aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
authorMark Adler <madler@alumni.caltech.edu>2023-04-14 01:42:03 -0700
committerMark Adler <madler@alumni.caltech.edu>2023-04-15 21:17:31 -0700
commite9d5486e6635141f589e110fd789648aa08e9544 (patch)
treea78b9ccd92b05af7cd5776b688d9c3eb3a81a40a /test
parent5799c14c8526bf1aaa130c021982f831d155b46d (diff)
downloadzlib-e9d5486e6635141f589e110fd789648aa08e9544.tar.gz
zlib-e9d5486e6635141f589e110fd789648aa08e9544.tar.bz2
zlib-e9d5486e6635141f589e110fd789648aa08e9544.zip
Remove K&R function definitions from zlib.
C2X has removed K&R definitions from the C function syntax. Though the standard has not yet been approved, some high-profile compilers are now issuing warnings when such definitions are encountered.
Diffstat (limited to 'test')
-rw-r--r--test/example.c93
-rw-r--r--test/minigzip.c172
2 files changed, 68 insertions, 197 deletions
diff --git a/test/example.c b/test/example.c
index 1470bc8..1c755bc 100644
--- a/test/example.c
+++ b/test/example.c
@@ -34,37 +34,14 @@ static z_const char hello[] = "hello, hello!";
34static const char dictionary[] = "hello"; 34static const char dictionary[] = "hello";
35static uLong dictId; /* Adler32 value of the dictionary */ 35static uLong dictId; /* Adler32 value of the dictionary */
36 36
37void test_deflate OF((Byte *compr, uLong comprLen));
38void test_inflate OF((Byte *compr, uLong comprLen,
39 Byte *uncompr, uLong uncomprLen));
40void test_large_deflate OF((Byte *compr, uLong comprLen,
41 Byte *uncompr, uLong uncomprLen));
42void test_large_inflate OF((Byte *compr, uLong comprLen,
43 Byte *uncompr, uLong uncomprLen));
44void test_flush OF((Byte *compr, uLong *comprLen));
45void test_sync OF((Byte *compr, uLong comprLen,
46 Byte *uncompr, uLong uncomprLen));
47void test_dict_deflate OF((Byte *compr, uLong comprLen));
48void test_dict_inflate OF((Byte *compr, uLong comprLen,
49 Byte *uncompr, uLong uncomprLen));
50int main OF((int argc, char *argv[]));
51
52
53#ifdef Z_SOLO 37#ifdef Z_SOLO
54 38
55void *myalloc OF((void *, unsigned, unsigned)); 39void *myalloc(void *q, unsigned n, unsigned m) {
56void myfree OF((void *, void *));
57
58void *myalloc(q, n, m)
59 void *q;
60 unsigned n, m;
61{
62 (void)q; 40 (void)q;
63 return calloc(n, m); 41 return calloc(n, m);
64} 42}
65 43
66void myfree(void *q, void *p) 44void myfree(void *q, void *p) {
67{
68 (void)q; 45 (void)q;
69 free(p); 46 free(p);
70} 47}
@@ -77,18 +54,11 @@ static free_func zfree = myfree;
77static alloc_func zalloc = (alloc_func)0; 54static alloc_func zalloc = (alloc_func)0;
78static free_func zfree = (free_func)0; 55static free_func zfree = (free_func)0;
79 56
80void test_compress OF((Byte *compr, uLong comprLen,
81 Byte *uncompr, uLong uncomprLen));
82void test_gzio OF((const char *fname,
83 Byte *uncompr, uLong uncomprLen));
84
85/* =========================================================================== 57/* ===========================================================================
86 * Test compress() and uncompress() 58 * Test compress() and uncompress()
87 */ 59 */
88void test_compress(compr, comprLen, uncompr, uncomprLen) 60void test_compress(Byte *compr, uLong comprLen, Byte *uncompr,
89 Byte *compr, *uncompr; 61 uLong uncomprLen) {
90 uLong comprLen, uncomprLen;
91{
92 int err; 62 int err;
93 uLong len = (uLong)strlen(hello)+1; 63 uLong len = (uLong)strlen(hello)+1;
94 64
@@ -111,11 +81,7 @@ void test_compress(compr, comprLen, uncompr, uncomprLen)
111/* =========================================================================== 81/* ===========================================================================
112 * Test read/write of .gz files 82 * Test read/write of .gz files
113 */ 83 */
114void test_gzio(fname, uncompr, uncomprLen) 84void test_gzio(const char *fname, Byte *uncompr, uLong uncomprLen) {
115 const char *fname; /* compressed file name */
116 Byte *uncompr;
117 uLong uncomprLen;
118{
119#ifdef NO_GZCOMPRESS 85#ifdef NO_GZCOMPRESS
120 fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n"); 86 fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
121#else 87#else
@@ -197,10 +163,7 @@ void test_gzio(fname, uncompr, uncomprLen)
197/* =========================================================================== 163/* ===========================================================================
198 * Test deflate() with small buffers 164 * Test deflate() with small buffers
199 */ 165 */
200void test_deflate(compr, comprLen) 166void test_deflate(Byte *compr, uLong comprLen) {
201 Byte *compr;
202 uLong comprLen;
203{
204 z_stream c_stream; /* compression stream */ 167 z_stream c_stream; /* compression stream */
205 int err; 168 int err;
206 uLong len = (uLong)strlen(hello)+1; 169 uLong len = (uLong)strlen(hello)+1;
@@ -235,10 +198,8 @@ void test_deflate(compr, comprLen)
235/* =========================================================================== 198/* ===========================================================================
236 * Test inflate() with small buffers 199 * Test inflate() with small buffers
237 */ 200 */
238void test_inflate(compr, comprLen, uncompr, uncomprLen) 201void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
239 Byte *compr, *uncompr; 202 uLong uncomprLen) {
240 uLong comprLen, uncomprLen;
241{
242 int err; 203 int err;
243 z_stream d_stream; /* decompression stream */ 204 z_stream d_stream; /* decompression stream */
244 205
@@ -276,10 +237,8 @@ void test_inflate(compr, comprLen, uncompr, uncomprLen)
276/* =========================================================================== 237/* ===========================================================================
277 * Test deflate() with large buffers and dynamic change of compression level 238 * Test deflate() with large buffers and dynamic change of compression level
278 */ 239 */
279void test_large_deflate(compr, comprLen, uncompr, uncomprLen) 240void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr,
280 Byte *compr, *uncompr; 241 uLong uncomprLen) {
281 uLong comprLen, uncomprLen;
282{
283 z_stream c_stream; /* compression stream */ 242 z_stream c_stream; /* compression stream */
284 int err; 243 int err;
285 244
@@ -331,10 +290,8 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
331/* =========================================================================== 290/* ===========================================================================
332 * Test inflate() with large buffers 291 * Test inflate() with large buffers
333 */ 292 */
334void test_large_inflate(compr, comprLen, uncompr, uncomprLen) 293void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
335 Byte *compr, *uncompr; 294 uLong uncomprLen) {
336 uLong comprLen, uncomprLen;
337{
338 int err; 295 int err;
339 z_stream d_stream; /* decompression stream */ 296 z_stream d_stream; /* decompression stream */
340 297
@@ -372,10 +329,7 @@ void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
372/* =========================================================================== 329/* ===========================================================================
373 * Test deflate() with full flush 330 * Test deflate() with full flush
374 */ 331 */
375void test_flush(compr, comprLen) 332void test_flush(Byte *compr, uLong *comprLen) {
376 Byte *compr;
377 uLong *comprLen;
378{
379 z_stream c_stream; /* compression stream */ 333 z_stream c_stream; /* compression stream */
380 int err; 334 int err;
381 uInt len = (uInt)strlen(hello)+1; 335 uInt len = (uInt)strlen(hello)+1;
@@ -410,10 +364,7 @@ void test_flush(compr, comprLen)
410/* =========================================================================== 364/* ===========================================================================
411 * Test inflateSync() 365 * Test inflateSync()
412 */ 366 */
413void test_sync(compr, comprLen, uncompr, uncomprLen) 367void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen) {
414 Byte *compr, *uncompr;
415 uLong comprLen, uncomprLen;
416{
417 int err; 368 int err;
418 z_stream d_stream; /* decompression stream */ 369 z_stream d_stream; /* decompression stream */
419 370
@@ -453,10 +404,7 @@ void test_sync(compr, comprLen, uncompr, uncomprLen)
453/* =========================================================================== 404/* ===========================================================================
454 * Test deflate() with preset dictionary 405 * Test deflate() with preset dictionary
455 */ 406 */
456void test_dict_deflate(compr, comprLen) 407void test_dict_deflate(Byte *compr, uLong comprLen) {
457 Byte *compr;
458 uLong comprLen;
459{
460 z_stream c_stream; /* compression stream */ 408 z_stream c_stream; /* compression stream */
461 int err; 409 int err;
462 410
@@ -490,10 +438,8 @@ void test_dict_deflate(compr, comprLen)
490/* =========================================================================== 438/* ===========================================================================
491 * Test inflate() with a preset dictionary 439 * Test inflate() with a preset dictionary
492 */ 440 */
493void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) 441void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
494 Byte *compr, *uncompr; 442 uLong uncomprLen) {
495 uLong comprLen, uncomprLen;
496{
497 int err; 443 int err;
498 z_stream d_stream; /* decompression stream */ 444 z_stream d_stream; /* decompression stream */
499 445
@@ -541,10 +487,7 @@ void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
541 * Usage: example [output.gz [input.gz]] 487 * Usage: example [output.gz [input.gz]]
542 */ 488 */
543 489
544int main(argc, argv) 490int main(int argc, char *argv[]) {
545 int argc;
546 char *argv[];
547{
548 Byte *compr, *uncompr; 491 Byte *compr, *uncompr;
549 uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */ 492 uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
550 uLong uncomprLen = comprLen; 493 uLong uncomprLen = comprLen;
diff --git a/test/minigzip.c b/test/minigzip.c
index a649d2b..8a21ddf 100644
--- a/test/minigzip.c
+++ b/test/minigzip.c
@@ -59,7 +59,7 @@
59 59
60#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) 60#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE)
61#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ 61#ifndef WIN32 /* unlink already in stdio.h for WIN32 */
62 extern int unlink OF((const char *)); 62 extern int unlink(const char *);
63#endif 63#endif
64#endif 64#endif
65 65
@@ -149,20 +149,12 @@ static void pwinerror (s)
149# include <unistd.h> /* for unlink() */ 149# include <unistd.h> /* for unlink() */
150#endif 150#endif
151 151
152void *myalloc OF((void *, unsigned, unsigned)); 152void *myalloc(void *q, unsigned n, unsigned m) {
153void myfree OF((void *, void *));
154
155void *myalloc(q, n, m)
156 void *q;
157 unsigned n, m;
158{
159 (void)q; 153 (void)q;
160 return calloc(n, m); 154 return calloc(n, m);
161} 155}
162 156
163void myfree(q, p) 157void myfree(void *q, void *p) {
164 void *q, *p;
165{
166 (void)q; 158 (void)q;
167 free(p); 159 free(p);
168} 160}
@@ -175,29 +167,7 @@ typedef struct gzFile_s {
175 z_stream strm; 167 z_stream strm;
176} *gzFile; 168} *gzFile;
177 169
178gzFile gzopen OF((const char *, const char *)); 170gzFile gz_open(const char *path, int fd, const char *mode) {
179gzFile gzdopen OF((int, const char *));
180gzFile gz_open OF((const char *, int, const char *));
181
182gzFile gzopen(path, mode)
183const char *path;
184const char *mode;
185{
186 return gz_open(path, -1, mode);
187}
188
189gzFile gzdopen(fd, mode)
190int fd;
191const char *mode;
192{
193 return gz_open(NULL, fd, mode);
194}
195
196gzFile gz_open(path, fd, mode)
197 const char *path;
198 int fd;
199 const char *mode;
200{
201 gzFile gz; 171 gzFile gz;
202 int ret; 172 int ret;
203 173
@@ -231,13 +201,15 @@ gzFile gz_open(path, fd, mode)
231 return gz; 201 return gz;
232} 202}
233 203
234int gzwrite OF((gzFile, const void *, unsigned)); 204gzFile gzopen(const char *path, const char *mode) {
205 return gz_open(path, -1, mode);
206}
235 207
236int gzwrite(gz, buf, len) 208gzFile gzdopen(int fd, const char *mode) {
237 gzFile gz; 209 return gz_open(NULL, fd, mode);
238 const void *buf; 210}
239 unsigned len; 211
240{ 212int gzwrite(gzFile gz, const void *buf, unsigned len) {
241 z_stream *strm; 213 z_stream *strm;
242 unsigned char out[BUFLEN]; 214 unsigned char out[BUFLEN];
243 215
@@ -255,13 +227,7 @@ int gzwrite(gz, buf, len)
255 return len; 227 return len;
256} 228}
257 229
258int gzread OF((gzFile, void *, unsigned)); 230int gzread(gzFile gz, void *buf, unsigned len) {
259
260int gzread(gz, buf, len)
261 gzFile gz;
262 void *buf;
263 unsigned len;
264{
265 int ret; 231 int ret;
266 unsigned got; 232 unsigned got;
267 unsigned char in[1]; 233 unsigned char in[1];
@@ -292,11 +258,7 @@ int gzread(gz, buf, len)
292 return len - strm->avail_out; 258 return len - strm->avail_out;
293} 259}
294 260
295int gzclose OF((gzFile)); 261int gzclose(gzFile gz) {
296
297int gzclose(gz)
298 gzFile gz;
299{
300 z_stream *strm; 262 z_stream *strm;
301 unsigned char out[BUFLEN]; 263 unsigned char out[BUFLEN];
302 264
@@ -321,12 +283,7 @@ int gzclose(gz)
321 return Z_OK; 283 return Z_OK;
322} 284}
323 285
324const char *gzerror OF((gzFile, int *)); 286const char *gzerror(gzFile gz, int *err) {
325
326const char *gzerror(gz, err)
327 gzFile gz;
328 int *err;
329{
330 *err = gz->err; 287 *err = gz->err;
331 return gz->msg; 288 return gz->msg;
332} 289}
@@ -335,67 +292,20 @@ const char *gzerror(gz, err)
335 292
336static char *prog; 293static char *prog;
337 294
338void error OF((const char *msg));
339void gz_compress OF((FILE *in, gzFile out));
340#ifdef USE_MMAP
341int gz_compress_mmap OF((FILE *in, gzFile out));
342#endif
343void gz_uncompress OF((gzFile in, FILE *out));
344void file_compress OF((char *file, char *mode));
345void file_uncompress OF((char *file));
346int main OF((int argc, char *argv[]));
347
348/* =========================================================================== 295/* ===========================================================================
349 * Display error message and exit 296 * Display error message and exit
350 */ 297 */
351void error(msg) 298void error(const char *msg) {
352 const char *msg;
353{
354 fprintf(stderr, "%s: %s\n", prog, msg); 299 fprintf(stderr, "%s: %s\n", prog, msg);
355 exit(1); 300 exit(1);
356} 301}
357 302
358/* ===========================================================================
359 * Compress input to output then close both files.
360 */
361
362void gz_compress(in, out)
363 FILE *in;
364 gzFile out;
365{
366 local char buf[BUFLEN];
367 int len;
368 int err;
369
370#ifdef USE_MMAP
371 /* Try first compressing with mmap. If mmap fails (minigzip used in a
372 * pipe), use the normal fread loop.
373 */
374 if (gz_compress_mmap(in, out) == Z_OK) return;
375#endif
376 for (;;) {
377 len = (int)fread(buf, 1, sizeof(buf), in);
378 if (ferror(in)) {
379 perror("fread");
380 exit(1);
381 }
382 if (len == 0) break;
383
384 if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
385 }
386 fclose(in);
387 if (gzclose(out) != Z_OK) error("failed gzclose");
388}
389
390#ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */ 303#ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
391 304
392/* Try compressing the input file at once using mmap. Return Z_OK if 305/* Try compressing the input file at once using mmap. Return Z_OK if
393 * if success, Z_ERRNO otherwise. 306 * if success, Z_ERRNO otherwise.
394 */ 307 */
395int gz_compress_mmap(in, out) 308int gz_compress_mmap(FILE *in, gzFile out) {
396 FILE *in;
397 gzFile out;
398{
399 int len; 309 int len;
400 int err; 310 int err;
401 int ifd = fileno(in); 311 int ifd = fileno(in);
@@ -425,12 +335,38 @@ int gz_compress_mmap(in, out)
425#endif /* USE_MMAP */ 335#endif /* USE_MMAP */
426 336
427/* =========================================================================== 337/* ===========================================================================
338 * Compress input to output then close both files.
339 */
340
341void gz_compress(FILE *in, gzFile out) {
342 local char buf[BUFLEN];
343 int len;
344 int err;
345
346#ifdef USE_MMAP
347 /* Try first compressing with mmap. If mmap fails (minigzip used in a
348 * pipe), use the normal fread loop.
349 */
350 if (gz_compress_mmap(in, out) == Z_OK) return;
351#endif
352 for (;;) {
353 len = (int)fread(buf, 1, sizeof(buf), in);
354 if (ferror(in)) {
355 perror("fread");
356 exit(1);
357 }
358 if (len == 0) break;
359
360 if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
361 }
362 fclose(in);
363 if (gzclose(out) != Z_OK) error("failed gzclose");
364}
365
366/* ===========================================================================
428 * Uncompress input to output then close both files. 367 * Uncompress input to output then close both files.
429 */ 368 */
430void gz_uncompress(in, out) 369void gz_uncompress(gzFile in, FILE *out) {
431 gzFile in;
432 FILE *out;
433{
434 local char buf[BUFLEN]; 370 local char buf[BUFLEN];
435 int len; 371 int len;
436 int err; 372 int err;
@@ -454,10 +390,7 @@ void gz_uncompress(in, out)
454 * Compress the given file: create a corresponding .gz file and remove the 390 * Compress the given file: create a corresponding .gz file and remove the
455 * original. 391 * original.
456 */ 392 */
457void file_compress(file, mode) 393void file_compress(char *file, char *mode) {
458 char *file;
459 char *mode;
460{
461 local char outfile[MAX_NAME_LEN]; 394 local char outfile[MAX_NAME_LEN];
462 FILE *in; 395 FILE *in;
463 gzFile out; 396 gzFile out;
@@ -493,9 +426,7 @@ void file_compress(file, mode)
493/* =========================================================================== 426/* ===========================================================================
494 * Uncompress the given file and remove the original. 427 * Uncompress the given file and remove the original.
495 */ 428 */
496void file_uncompress(file) 429void file_uncompress(char *file) {
497 char *file;
498{
499 local char buf[MAX_NAME_LEN]; 430 local char buf[MAX_NAME_LEN];
500 char *infile, *outfile; 431 char *infile, *outfile;
501 FILE *out; 432 FILE *out;
@@ -553,10 +484,7 @@ void file_uncompress(file)
553 * -1 to -9 : compression level 484 * -1 to -9 : compression level
554 */ 485 */
555 486
556int main(argc, argv) 487int main(int argc, char *argv[]) {
557 int argc;
558 char *argv[];
559{
560 int copyout = 0; 488 int copyout = 0;
561 int uncompr = 0; 489 int uncompr = 0;
562 gzFile file; 490 gzFile file;
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-16 12:25:27 +0000