zenilib: zenilib/jni/external/zlib/example.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
example.c
Go to the documentation of this file.
1 /* example.c -- usage example of the zlib compression library
2 * Copyright (C) 1995-2006 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6 /* @(#) $Id$ */
7
8 #include "zlib.h"
9 #include <stdio.h>
10
11 #ifdef STDC
12 # include <string.h>
13 # include <stdlib.h>
14 #endif
15
16 #if defined(VMS) || defined(RISCOS)
17 # define TESTFILE "foo-gz"
18 #else
19 # define TESTFILE "foo.gz"
20 #endif
21
22 #define CHECK_ERR(err, msg) { \
23 if (err != Z_OK) { \
24 fprintf(stderr, "%s error: %d\n", msg, err); \
25 exit(1); \
26 } \
27 }
28
29 const char hello[] = "hello, hello!";
30 /* "hello world" would be more standard, but the repeated "hello"
31 * stresses the compression code better, sorry...
32 */
33
34 const char dictionary[] = "hello";
35 uLong dictId; /* Adler32 value of the dictionary */
36
37 void test_compress OF((Byte *compr, uLong comprLen,
38 Byte *uncompr, uLong uncomprLen));
39 void test_gzio OF((const char *fname,
40 Byte *uncompr, uLong uncomprLen));
41 void test_deflate OF((Byte *compr, uLong comprLen));
42 void test_inflate OF((Byte *compr, uLong comprLen,
43 Byte *uncompr, uLong uncomprLen));
44 void test_large_deflate OF((Byte *compr, uLong comprLen,
45 Byte *uncompr, uLong uncomprLen));
46 void test_large_inflate OF((Byte *compr, uLong comprLen,
47 Byte *uncompr, uLong uncomprLen));
48 void test_flush OF((Byte *compr, uLong *comprLen));
49 void test_sync OF((Byte *compr, uLong comprLen,
50 Byte *uncompr, uLong uncomprLen));
51 void test_dict_deflate OF((Byte *compr, uLong comprLen));
52 void test_dict_inflate OF((Byte *compr, uLong comprLen,
53 Byte *uncompr, uLong uncomprLen));
54 int main OF((int argc, char *argv[]));
55
56 /* ===========================================================================
57 * Test compress() and uncompress()
58 */
59 void test_compress(compr, comprLen, uncompr, uncomprLen)
60 Byte *compr, *uncompr;
61 uLong comprLen, uncomprLen;
62 {
63 int err;
64 uLong len = (uLong)strlen(hello)+1;
65
66 err = compress(compr, &comprLen, (const Bytef*)hello, len);
67 CHECK_ERR(err, "compress");
68
69 strcpy((char*)uncompr, "garbage");
70
71 err = uncompress(uncompr, &uncomprLen, compr, comprLen);
72 CHECK_ERR(err, "uncompress");
73
74 if (strcmp((char*)uncompr, hello)) {
75 fprintf(stderr, "bad uncompress\n");
76 exit(1);
77 } else {
78 printf("uncompress(): %s\n", (char *)uncompr);
79 }
80 }
81
82 /* ===========================================================================
83 * Test read/write of .gz files
84 */
85 void test_gzio(fname, uncompr, uncomprLen)
86 const char *fname; /* compressed file name */
87 Byte *uncompr;
88 uLong uncomprLen;
89 {
90 #ifdef NO_GZCOMPRESS
91 fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
92 #else
93 int err;
94 int len = (int)strlen(hello)+1;
95 gzFile file;
96 z_off_t pos;
97
98 file = gzopen(fname, "wb");
99 if (file == NULL) {
100 fprintf(stderr, "gzopen error\n");
101 exit(1);
102 }
103 gzputc(file, 'h');
104 if (gzputs(file, "ello") != 4) {
105 fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
106 exit(1);
107 }
108 if (gzprintf(file, ", %s!", "hello") != 8) {
109 fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
110 exit(1);
111 }
112 gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
113 gzclose(file);
114
115 file = gzopen(fname, "rb");
116 if (file == NULL) {
117 fprintf(stderr, "gzopen error\n");
118 exit(1);
119 }
120 strcpy((char*)uncompr, "garbage");
121
122 if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
123 fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
124 exit(1);
125 }
126 if (strcmp((char*)uncompr, hello)) {
127 fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
128 exit(1);
129 } else {
130 printf("gzread(): %s\n", (char*)uncompr);
131 }
132
133 pos = gzseek(file, -8L, SEEK_CUR);
134 if (pos != 6 || gztell(file) != pos) {
135 fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
136 (long)pos, (long)gztell(file));
137 exit(1);
138 }
139
140 if (gzgetc(file) != ' ') {
141 fprintf(stderr, "gzgetc error\n");
142 exit(1);
143 }
144
145 if (gzungetc(' ', file) != ' ') {
146 fprintf(stderr, "gzungetc error\n");
147 exit(1);
148 }
149
150 gzgets(file, (char*)uncompr, (int)uncomprLen);
151 if (strlen((char*)uncompr) != 7) { /* " hello!" */
152 fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
153 exit(1);
154 }
155 if (strcmp((char*)uncompr, hello + 6)) {
156 fprintf(stderr, "bad gzgets after gzseek\n");
157 exit(1);
158 } else {
159 printf("gzgets() after gzseek: %s\n", (char*)uncompr);
160 }
161
162 gzclose(file);
163 #endif
164 }
165
166 /* ===========================================================================
167 * Test deflate() with small buffers
168 */
169 void test_deflate(compr, comprLen)
170 Byte *compr;
171 uLong comprLen;
172 {
173 z_stream c_stream; /* compression stream */
174 int err;
175 uLong len = (uLong)strlen(hello)+1;
176
177 c_stream.zalloc = (alloc_func)0;
178 c_stream.zfree = (free_func)0;
179 c_stream.opaque = (voidpf)0;
180
181 err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
182 CHECK_ERR(err, "deflateInit");
183
184 c_stream.next_in = (Bytef*)hello;
185 c_stream.next_out = compr;
186
187 while (c_stream.total_in != len && c_stream.total_out < comprLen) {
188 c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
189 err = deflate(&c_stream, Z_NO_FLUSH);
190 CHECK_ERR(err, "deflate");
191 }
192 /* Finish the stream, still forcing small buffers: */
193 for (;;) {
194 c_stream.avail_out = 1;
195 err = deflate(&c_stream, Z_FINISH);
196 if (err == Z_STREAM_END) break;
197 CHECK_ERR(err, "deflate");
198 }
199
200 err = deflateEnd(&c_stream);
201 CHECK_ERR(err, "deflateEnd");
202 }
203
204 /* ===========================================================================
205 * Test inflate() with small buffers
206 */
207 void test_inflate(compr, comprLen, uncompr, uncomprLen)
208 Byte *compr, *uncompr;
209 uLong comprLen, uncomprLen;
210 {
211 int err;
212 z_stream d_stream; /* decompression stream */
213
214 strcpy((char*)uncompr, "garbage");
215
216 d_stream.zalloc = (alloc_func)0;
217 d_stream.zfree = (free_func)0;
218 d_stream.opaque = (voidpf)0;
219
220 d_stream.next_in = compr;
221 d_stream.avail_in = 0;
222 d_stream.next_out = uncompr;
223
224 err = inflateInit(&d_stream);
225 CHECK_ERR(err, "inflateInit");
226
227 while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
228 d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
229 err = inflate(&d_stream, Z_NO_FLUSH);
230 if (err == Z_STREAM_END) break;
231 CHECK_ERR(err, "inflate");
232 }
233
234 err = inflateEnd(&d_stream);
235 CHECK_ERR(err, "inflateEnd");
236
237 if (strcmp((char*)uncompr, hello)) {
238 fprintf(stderr, "bad inflate\n");
239 exit(1);
240 } else {
241 printf("inflate(): %s\n", (char *)uncompr);
242 }
243 }
244
245 /* ===========================================================================
246 * Test deflate() with large buffers and dynamic change of compression level
247 */
248 void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
249 Byte *compr, *uncompr;
250 uLong comprLen, uncomprLen;
251 {
252 z_stream c_stream; /* compression stream */
253 int err;
254
255 c_stream.zalloc = (alloc_func)0;
256 c_stream.zfree = (free_func)0;
257 c_stream.opaque = (voidpf)0;
258
259 err = deflateInit(&c_stream, Z_BEST_SPEED);
260 CHECK_ERR(err, "deflateInit");
261
262 c_stream.next_out = compr;
263 c_stream.avail_out = (uInt)comprLen;
264
265 /* At this point, uncompr is still mostly zeroes, so it should compress
266 * very well:
267 */
268 c_stream.next_in = uncompr;
269 c_stream.avail_in = (uInt)uncomprLen;
270 err = deflate(&c_stream, Z_NO_FLUSH);
271 CHECK_ERR(err, "deflate");
272 if (c_stream.avail_in != 0) {
273 fprintf(stderr, "deflate not greedy\n");
274 exit(1);
275 }
276
277 /* Feed in already compressed data and switch to no compression: */
278 deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
279 c_stream.next_in = compr;
280 c_stream.avail_in = (uInt)comprLen/2;
281 err = deflate(&c_stream, Z_NO_FLUSH);
282 CHECK_ERR(err, "deflate");
283
284 /* Switch back to compressing mode: */
285 deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
286 c_stream.next_in = uncompr;
287 c_stream.avail_in = (uInt)uncomprLen;
288 err = deflate(&c_stream, Z_NO_FLUSH);
289 CHECK_ERR(err, "deflate");
290
291 err = deflate(&c_stream, Z_FINISH);
292 if (err != Z_STREAM_END) {
293 fprintf(stderr, "deflate should report Z_STREAM_END\n");
294 exit(1);
295 }
296 err = deflateEnd(&c_stream);
297 CHECK_ERR(err, "deflateEnd");
298 }
299
300 /* ===========================================================================
301 * Test inflate() with large buffers
302 */
303 void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
304 Byte *compr, *uncompr;
305 uLong comprLen, uncomprLen;
306 {
307 int err;
308 z_stream d_stream; /* decompression stream */
309
310 strcpy((char*)uncompr, "garbage");
311
312 d_stream.zalloc = (alloc_func)0;
313 d_stream.zfree = (free_func)0;
314 d_stream.opaque = (voidpf)0;
315
316 d_stream.next_in = compr;
317 d_stream.avail_in = (uInt)comprLen;
318
319 err = inflateInit(&d_stream);
320 CHECK_ERR(err, "inflateInit");
321
322 for (;;) {
323 d_stream.next_out = uncompr; /* discard the output */
324 d_stream.avail_out = (uInt)uncomprLen;
325 err = inflate(&d_stream, Z_NO_FLUSH);
326 if (err == Z_STREAM_END) break;
327 CHECK_ERR(err, "large inflate");
328 }
329
330 err = inflateEnd(&d_stream);
331 CHECK_ERR(err, "inflateEnd");
332
333 if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
334 fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
335 exit(1);
336 } else {
337 printf("large_inflate(): OK\n");
338 }
339 }
340
341 /* ===========================================================================
342 * Test deflate() with full flush
343 */
344 void test_flush(compr, comprLen)
345 Byte *compr;
346 uLong *comprLen;
347 {
348 z_stream c_stream; /* compression stream */
349 int err;
350 uInt len = (uInt)strlen(hello)+1;
351
352 c_stream.zalloc = (alloc_func)0;
353 c_stream.zfree = (free_func)0;
354 c_stream.opaque = (voidpf)0;
355
356 err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
357 CHECK_ERR(err, "deflateInit");
358
359 c_stream.next_in = (Bytef*)hello;
360 c_stream.next_out = compr;
361 c_stream.avail_in = 3;
362 c_stream.avail_out = (uInt)*comprLen;
363 err = deflate(&c_stream, Z_FULL_FLUSH);
364 CHECK_ERR(err, "deflate");
365
366 compr[3]++; /* force an error in first compressed block */
367 c_stream.avail_in = len - 3;
368
369 err = deflate(&c_stream, Z_FINISH);
370 if (err != Z_STREAM_END) {
371 CHECK_ERR(err, "deflate");
372 }
373 err = deflateEnd(&c_stream);
374 CHECK_ERR(err, "deflateEnd");
375
376 *comprLen = c_stream.total_out;
377 }
378
379 /* ===========================================================================
380 * Test inflateSync()
381 */
382 void test_sync(compr, comprLen, uncompr, uncomprLen)
383 Byte *compr, *uncompr;
384 uLong comprLen, uncomprLen;
385 {
386 int err;
387 z_stream d_stream; /* decompression stream */
388
389 strcpy((char*)uncompr, "garbage");
390
391 d_stream.zalloc = (alloc_func)0;
392 d_stream.zfree = (free_func)0;
393 d_stream.opaque = (voidpf)0;
394
395 d_stream.next_in = compr;
396 d_stream.avail_in = 2; /* just read the zlib header */
397
398 err = inflateInit(&d_stream);
399 CHECK_ERR(err, "inflateInit");
400
401 d_stream.next_out = uncompr;
402 d_stream.avail_out = (uInt)uncomprLen;
403
404 inflate(&d_stream, Z_NO_FLUSH);
405 CHECK_ERR(err, "inflate");
406
407 d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
408 err = inflateSync(&d_stream); /* but skip the damaged part */
409 CHECK_ERR(err, "inflateSync");
410
411 err = inflate(&d_stream, Z_FINISH);
412 if (err != Z_DATA_ERROR) {
413 fprintf(stderr, "inflate should report DATA_ERROR\n");
414 /* Because of incorrect adler32 */
415 exit(1);
416 }
417 err = inflateEnd(&d_stream);
418 CHECK_ERR(err, "inflateEnd");
419
420 printf("after inflateSync(): hel%s\n", (char *)uncompr);
421 }
422
423 /* ===========================================================================
424 * Test deflate() with preset dictionary
425 */
426 void test_dict_deflate(compr, comprLen)
427 Byte *compr;
428 uLong comprLen;
429 {
430 z_stream c_stream; /* compression stream */
431 int err;
432
433 c_stream.zalloc = (alloc_func)0;
434 c_stream.zfree = (free_func)0;
435 c_stream.opaque = (voidpf)0;
436
437 err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
438 CHECK_ERR(err, "deflateInit");
439
440 err = deflateSetDictionary(&c_stream,
441 (const Bytef*)dictionary, sizeof(dictionary));
442 CHECK_ERR(err, "deflateSetDictionary");
443
444 dictId = c_stream.adler;
445 c_stream.next_out = compr;
446 c_stream.avail_out = (uInt)comprLen;
447
448 c_stream.next_in = (Bytef*)hello;
449 c_stream.avail_in = (uInt)strlen(hello)+1;
450
451 err = deflate(&c_stream, Z_FINISH);
452 if (err != Z_STREAM_END) {
453 fprintf(stderr, "deflate should report Z_STREAM_END\n");
454 exit(1);
455 }
456 err = deflateEnd(&c_stream);
457 CHECK_ERR(err, "deflateEnd");
458 }
459
460 /* ===========================================================================
461 * Test inflate() with a preset dictionary
462 */
463 void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
464 Byte *compr, *uncompr;
465 uLong comprLen, uncomprLen;
466 {
467 int err;
468 z_stream d_stream; /* decompression stream */
469
470 strcpy((char*)uncompr, "garbage");
471
472 d_stream.zalloc = (alloc_func)0;
473 d_stream.zfree = (free_func)0;
474 d_stream.opaque = (voidpf)0;
475
476 d_stream.next_in = compr;
477 d_stream.avail_in = (uInt)comprLen;
478
479 err = inflateInit(&d_stream);
480 CHECK_ERR(err, "inflateInit");
481
482 d_stream.next_out = uncompr;
483 d_stream.avail_out = (uInt)uncomprLen;
484
485 for (;;) {
486 err = inflate(&d_stream, Z_NO_FLUSH);
487 if (err == Z_STREAM_END) break;
488 if (err == Z_NEED_DICT) {
489 if (d_stream.adler != dictId) {
490 fprintf(stderr, "unexpected dictionary");
491 exit(1);
492 }
493 err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
494 sizeof(dictionary));
495 }
496 CHECK_ERR(err, "inflate with dict");
497 }
498
499 err = inflateEnd(&d_stream);
500 CHECK_ERR(err, "inflateEnd");
501
502 if (strcmp((char*)uncompr, hello)) {
503 fprintf(stderr, "bad inflate with dict\n");
504 exit(1);
505 } else {
506 printf("inflate with dictionary: %s\n", (char *)uncompr);
507 }
508 }
509
510 /* ===========================================================================
511 * Usage: example [output.gz [input.gz]]
512 */
513
514 int main(argc, argv)
515 int argc;
516 char *argv[];
517 {
518 Byte *compr, *uncompr;
519 uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
520 uLong uncomprLen = comprLen;
521 static const char* myVersion = ZLIB_VERSION;
522
523 if (zlibVersion()[0] != myVersion[0]) {
524 fprintf(stderr, "incompatible zlib version\n");
525 exit(1);
526
527 } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
528 fprintf(stderr, "warning: different zlib version\n");
529 }
530
531 printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
532 ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
533
534 compr = (Byte*)calloc((uInt)comprLen, 1);
535 uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
536 /* compr and uncompr are cleared to avoid reading uninitialized
537 * data and to ensure that uncompr compresses well.
538 */
539 if (compr == Z_NULL || uncompr == Z_NULL) {
540 printf("out of memory\n");
541 exit(1);
542 }
543 test_compress(compr, comprLen, uncompr, uncomprLen);
544
545 test_gzio((argc > 1 ? argv[1] : TESTFILE),
546 uncompr, uncomprLen);
547
548 test_deflate(compr, comprLen);
549 test_inflate(compr, comprLen, uncompr, uncomprLen);
550
551 test_large_deflate(compr, comprLen, uncompr, uncomprLen);
552 test_large_inflate(compr, comprLen, uncompr, uncomprLen);
553
554 test_flush(compr, &comprLen);
555 test_sync(compr, comprLen, uncompr, uncomprLen);
556 comprLen = uncomprLen;
557
558 test_dict_deflate(compr, comprLen);
559 test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
560
561 free(compr);
562 free(uncompr);
563
564 return 0;
565 }
gzgetc
int ZEXPORT gzgetc(gzFile file)
Definition: gzio.c:503
Z_BEST_COMPRESSION
#define Z_BEST_COMPRESSION
Definition: zlib.h:147
gzFile
voidp gzFile
Definition: zlib.h:1165
deflateParams
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
Definition: deflate.c:412
uLong
unsigned long uLong
Definition: zconf.h:222
Z_FULL_FLUSH
#define Z_FULL_FLUSH
Definition: zlib.h:128
gzgets
char *ZEXPORT gzgets(gzFile file, char *buf, int len)
Definition: gzio.c:540
main
int main(int argc, char **argv)
Definition: bootstrap.cpp:102
test_flush
void test_flush(Byte *compr, uLong *comprLen)
Definition: example.c:344
uncompress
int ZEXPORT uncompress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: uncompr.c:24
NULL
#define NULL
Definition: ftobjs.h:61
TESTFILE
#define TESTFILE
Definition: example.c:19
test_deflate
void test_deflate(Byte *compr, uLong comprLen)
Definition: example.c:169
Bytef
Byte FAR Bytef
Definition: zconf.h:228
ZLIB_VERNUM
#define ZLIB_VERNUM
Definition: zlib.h:41
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:40
inflateEnd
int ZEXPORT inflateEnd(z_streamp strm)
Definition: inflate.c:1238
z_stream_s::avail_in
uInt avail_in
Definition: zlib.h:70
free
SDL_EventEntry * free
Definition: SDL_events.c:80
hello
const char hello[]
Definition: example.c:29
Z_DATA_ERROR
#define Z_DATA_ERROR
Definition: zlib.h:137
gzclose
int ZEXPORT gzclose(gzFile file)
Definition: gzclose.c:11
test_inflate
void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:207
file
FILE * file
Definition: visualinfo.c:88
test_dict_inflate
void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:463
Z_FILTERED
#define Z_FILTERED
Definition: zlib.h:151
gzread
int ZEXPORT gzread(gzFile file, voidp buf, unsigned len)
Definition: gzio.c:394
deflateEnd
int ZEXPORT deflateEnd(z_streamp strm)
Definition: deflate.c:895
gzungetc
int ZEXPORT gzungetc(int c, gzFile file)
Definition: gzio.c:515
voidpf
Byte FAR * voidpf
Definition: zconf.h:239
len
GLenum GLsizei len
Definition: glew.h:7035
Z_DEFAULT_COMPRESSION
#define Z_DEFAULT_COMPRESSION
Definition: zlib.h:148
calloc
#define calloc
Definition: SDL_malloc.c:636
uInt
unsigned int uInt
Definition: zconf.h:221
z_stream_s::opaque
voidpf opaque
Definition: zlib.h:82
Z_NULL
#define Z_NULL
Definition: zlib.h:164
z_stream_s::zfree
free_func zfree
Definition: zlib.h:81
Z_NO_COMPRESSION
#define Z_NO_COMPRESSION
Definition: zlib.h:145
test_gzio
void test_gzio(char *fname, Byte *uncompr, uLong uncomprLen) const
Definition: example.c:85
SEEK_CUR
#define SEEK_CUR
Definition: zconf.h:250
gzopen
gzFile ZEXPORT gzopen(char *path, const char *mode) const
Definition: gzio.c:208
test_large_inflate
void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:303
test_large_deflate
void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:248
test_dict_deflate
void test_dict_deflate(Byte *compr, uLong comprLen)
Definition: example.c:426
dictId
uLong dictId
Definition: example.c:35
int
int
Definition: SDL_systhread.c:37
test_sync
void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:382
deflateInit
#define deflateInit(strm, level)
Definition: zlib.h:815
Z_FINISH
#define Z_FINISH
Definition: zlib.h:129
gzerror
const char *ZEXPORT gzerror(gzFile file, int *errnum)
Definition: gzio.c:987
Z_NEED_DICT
#define Z_NEED_DICT
Definition: zlib.h:134
z_stream_s::total_in
uLong total_in
Definition: zlib.h:71
inflateSync
int ZEXPORT inflateSync(z_streamp strm)
Definition: inflate.c:1345
z_off_t
#define z_off_t
Definition: zconf.h:254
gzprintf
int ZEXPORTVA gzprintf(gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
Definition: gzio.c:637
z_stream_s::zalloc
alloc_func zalloc
Definition: zlib.h:80
Z_DEFAULT_STRATEGY
#define Z_DEFAULT_STRATEGY
Definition: zlib.h:153
inflate
int ZEXPORT inflate(z_streamp strm, int flush)
Definition: inflate.c:589
gzputs
int ZEXPORT gzputs(gzFile file, const char *s)
Definition: gzio.c:693
zlibVersion
const char *ZEXPORT zlibVersion()
Definition: zutil.c:27
deflate
int ZEXPORT deflate(z_streamp strm, int flush)
Definition: deflate.c:582
z_stream_s::next_in
Bytef * next_in
Definition: zlib.h:69
OF
#define OF(args)
Definition: zconf.h:146
z_stream_s::adler
uLong adler
Definition: zlib.h:85
dictionary
const char dictionary[]
Definition: example.c:34
z_stream_s::total_out
uLong total_out
Definition: zlib.h:75
Z_NO_FLUSH
#define Z_NO_FLUSH
Definition: zlib.h:125
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:133
gztell
z_off_t ZEXPORT gztell(gzFile file)
Definition: gzio.c:881
zlibCompileFlags
uLong ZEXPORT zlibCompileFlags()
Definition: zutil.c:32
const
#define const
Definition: zconf.h:91
inflateInit
#define inflateInit(strm)
Definition: zlib.h:817
test_compress
void test_compress(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
Definition: example.c:59
inflateSetDictionary
int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
Definition: inflate.c:1252
compress
int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: compress.c:62
Byte
unsigned char Byte
Definition: zconf.h:219
deflateSetDictionary
int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength)
Definition: deflate.c:311
String.h
z_stream_s::avail_out
uInt avail_out
Definition: zlib.h:74
CHECK_ERR
#define CHECK_ERR(err, msg)
Definition: example.c:22
zlib.h
gzseek
z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
Definition: gzio.c:767
z_stream_s::next_out
Bytef * next_out
Definition: zlib.h:73
Z_BEST_SPEED
#define Z_BEST_SPEED
Definition: zlib.h:146
gzputc
int ZEXPORT gzputc(gzFile file, int c)
Definition: gzio.c:678
z_stream_s
Definition: zlib.h:68