NCBI C++ ToolKit
infback.c
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* infback.c -- inflate using a call-back interface
2  * Copyright (C) 1995-2022 Mark Adler
3  * For conditions of distribution and use, see copyright notice in zlib.h
4  */
5 
6 /*
7  This code is largely copied from inflate.c. Normally either infback.o or
8  inflate.o would be linked into an application--not both. The interface
9  with inffast.c is retained so that optimized assembler-coded versions of
10  inflate_fast() can be used with either inflate.c or infback.c.
11  */
12 
13 #include "zutil.h"
14 #include "inftrees.h"
15 #include "inflate.h"
16 #include "inffast.h"
17 
18 /* function prototypes */
20 
21 /*
22  strm provides memory allocation functions in zalloc and zfree, or
23  Z_NULL to use the library memory allocation functions.
24 
25  windowBits is in the range 8..15, and window is a user-supplied
26  window and output buffer that is 2**windowBits bytes.
27  */
28 int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
30 int windowBits;
31 unsigned char FAR *window;
32 const char *version;
33 int stream_size;
34 {
35  struct inflate_state FAR *state;
36 
37  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
38  stream_size != (int)(sizeof(z_stream)))
39  return Z_VERSION_ERROR;
40  if (strm == Z_NULL || window == Z_NULL ||
41  windowBits < 8 || windowBits > 15)
42  return Z_STREAM_ERROR;
43  strm->msg = Z_NULL; /* in case we return an error */
44  if (strm->zalloc == (alloc_func)0) {
45 #ifdef Z_SOLO
46  return Z_STREAM_ERROR;
47 #else
48  strm->zalloc = zcalloc;
49  strm->opaque = (voidpf)0;
50 #endif
51  }
52  if (strm->zfree == (free_func)0)
53 #ifdef Z_SOLO
54  return Z_STREAM_ERROR;
55 #else
56  strm->zfree = zcfree;
57 #endif
58  state = (struct inflate_state FAR *)ZALLOC(strm, 1,
59  sizeof(struct inflate_state));
60  if (state == Z_NULL) return Z_MEM_ERROR;
61  Tracev((stderr, "inflate: allocated\n"));
62  strm->state = (struct internal_state FAR *)state;
63  state->dmax = 32768U;
64  state->wbits = (uInt)windowBits;
65  state->wsize = 1U << windowBits;
66  state->window = window;
67  state->wnext = 0;
68  state->whave = 0;
69  return Z_OK;
70 }
71 
72 /*
73  Return state with length and distance decoding tables and index sizes set to
74  fixed code decoding. Normally this returns fixed tables from inffixed.h.
75  If BUILDFIXED is defined, then instead this routine builds the tables the
76  first time it's called, and returns those tables the first time and
77  thereafter. This reduces the size of the code by about 2K bytes, in
78  exchange for a little execution time. However, BUILDFIXED should not be
79  used for threaded applications, since the rewriting of the tables and virgin
80  may not be thread-safe.
81  */
83 struct inflate_state FAR *state;
84 {
85 #ifdef BUILDFIXED
86  static int virgin = 1;
87  static code *lenfix, *distfix;
88  static code fixed[544];
89 
90  /* build fixed huffman tables if first call (may not be thread safe) */
91  if (virgin) {
92  unsigned sym, bits;
93  static code *next;
94 
95  /* literal/length table */
96  sym = 0;
97  while (sym < 144) state->lens[sym++] = 8;
98  while (sym < 256) state->lens[sym++] = 9;
99  while (sym < 280) state->lens[sym++] = 7;
100  while (sym < 288) state->lens[sym++] = 8;
101  next = fixed;
102  lenfix = next;
103  bits = 9;
104  inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
105 
106  /* distance table */
107  sym = 0;
108  while (sym < 32) state->lens[sym++] = 5;
109  distfix = next;
110  bits = 5;
111  inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
112 
113  /* do this just once */
114  virgin = 0;
115  }
116 #else /* !BUILDFIXED */
117 # include "inffixed.h"
118 #endif /* BUILDFIXED */
119  state->lencode = lenfix;
120  state->lenbits = 9;
121  state->distcode = distfix;
122  state->distbits = 5;
123 }
124 
125 /* Macros for inflateBack(): */
126 
127 /* Load returned state from inflate_fast() */
128 #define LOAD() \
129  do { \
130  put = strm->next_out; \
131  left = strm->avail_out; \
132  next = strm->next_in; \
133  have = strm->avail_in; \
134  hold = state->hold; \
135  bits = state->bits; \
136  } while (0)
137 
138 /* Set state from registers for inflate_fast() */
139 #define RESTORE() \
140  do { \
141  strm->next_out = put; \
142  strm->avail_out = left; \
143  strm->next_in = next; \
144  strm->avail_in = have; \
145  state->hold = hold; \
146  state->bits = bits; \
147  } while (0)
148 
149 /* Clear the input bit accumulator */
150 #define INITBITS() \
151  do { \
152  hold = 0; \
153  bits = 0; \
154  } while (0)
155 
156 /* Assure that some input is available. If input is requested, but denied,
157  then return a Z_BUF_ERROR from inflateBack(). */
158 #define PULL() \
159  do { \
160  if (have == 0) { \
161  have = in(in_desc, &next); \
162  if (have == 0) { \
163  next = Z_NULL; \
164  ret = Z_BUF_ERROR; \
165  goto inf_leave; \
166  } \
167  } \
168  } while (0)
169 
170 /* Get a byte of input into the bit accumulator, or return from inflateBack()
171  with an error if there is no input available. */
172 #define PULLBYTE() \
173  do { \
174  PULL(); \
175  have--; \
176  hold += (unsigned long)(*next++) << bits; \
177  bits += 8; \
178  } while (0)
179 
180 /* Assure that there are at least n bits in the bit accumulator. If there is
181  not enough available input to do that, then return from inflateBack() with
182  an error. */
183 #define NEEDBITS(n) \
184  do { \
185  while (bits < (unsigned)(n)) \
186  PULLBYTE(); \
187  } while (0)
188 
189 /* Return the low n bits of the bit accumulator (n < 16) */
190 #define BITS(n) \
191  ((unsigned)hold & ((1U << (n)) - 1))
192 
193 /* Remove n bits from the bit accumulator */
194 #define DROPBITS(n) \
195  do { \
196  hold >>= (n); \
197  bits -= (unsigned)(n); \
198  } while (0)
199 
200 /* Remove zero to seven bits as needed to go to a byte boundary */
201 #define BYTEBITS() \
202  do { \
203  hold >>= bits & 7; \
204  bits -= bits & 7; \
205  } while (0)
206 
207 /* Assure that some output space is available, by writing out the window
208  if it's full. If the write fails, return from inflateBack() with a
209  Z_BUF_ERROR. */
210 #define ROOM() \
211  do { \
212  if (left == 0) { \
213  put = state->window; \
214  left = state->wsize; \
215  state->whave = left; \
216  if (out(out_desc, put, left)) { \
217  ret = Z_BUF_ERROR; \
218  goto inf_leave; \
219  } \
220  } \
221  } while (0)
222 
223 /*
224  strm provides the memory allocation functions and window buffer on input,
225  and provides information on the unused input on return. For Z_DATA_ERROR
226  returns, strm will also provide an error message.
227 
228  in() and out() are the call-back input and output functions. When
229  inflateBack() needs more input, it calls in(). When inflateBack() has
230  filled the window with output, or when it completes with data in the
231  window, it calls out() to write out the data. The application must not
232  change the provided input until in() is called again or inflateBack()
233  returns. The application must not change the window/output buffer until
234  inflateBack() returns.
235 
236  in() and out() are called with a descriptor parameter provided in the
237  inflateBack() call. This parameter can be a structure that provides the
238  information required to do the read or write, as well as accumulated
239  information on the input and output such as totals and check values.
240 
241  in() should return zero on failure. out() should return non-zero on
242  failure. If either in() or out() fails, than inflateBack() returns a
243  Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
244  was in() or out() that caused in the error. Otherwise, inflateBack()
245  returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
246  error, or Z_MEM_ERROR if it could not allocate memory for the state.
247  inflateBack() can also return Z_STREAM_ERROR if the input parameters
248  are not correct, i.e. strm is Z_NULL or the state was not initialized.
249  */
250 int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
252 in_func in;
253 void FAR *in_desc;
254 out_func out;
255 void FAR *out_desc;
256 {
257  struct inflate_state FAR *state;
258  z_const unsigned char FAR *next; /* next input */
259  unsigned char FAR *put; /* next output */
260  unsigned have, left; /* available input and output */
261  unsigned long hold; /* bit buffer */
262  unsigned bits; /* bits in bit buffer */
263  unsigned copy; /* number of stored or match bytes to copy */
264  unsigned char FAR *from; /* where to copy match bytes from */
265  code here; /* current decoding table entry */
266  code last; /* parent table entry */
267  unsigned len; /* length to copy for repeats, bits to drop */
268  int ret; /* return code */
269  static const unsigned short order[19] = /* permutation of code lengths */
270  {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
271 
272  /* Check that the strm exists and that the state was initialized */
273  if (strm == Z_NULL || strm->state == Z_NULL)
274  return Z_STREAM_ERROR;
275  state = (struct inflate_state FAR *)strm->state;
276 
277  /* Reset the state */
278  strm->msg = Z_NULL;
279  state->mode = TYPE;
280  state->last = 0;
281  state->whave = 0;
282  next = strm->next_in;
283  have = next != Z_NULL ? strm->avail_in : 0;
284  hold = 0;
285  bits = 0;
286  put = state->window;
287  left = state->wsize;
288 
289  /* Inflate until end of block marked as last */
290  for (;;)
291  switch (state->mode) {
292  case TYPE:
293  /* determine and dispatch block type */
294  if (state->last) {
295  BYTEBITS();
296  state->mode = DONE;
297  break;
298  }
299  NEEDBITS(3);
300  state->last = BITS(1);
301  DROPBITS(1);
302  switch (BITS(2)) {
303  case 0: /* stored block */
304  Tracev((stderr, "inflate: stored block%s\n",
305  state->last ? " (last)" : ""));
306  state->mode = STORED;
307  break;
308  case 1: /* fixed block */
310  Tracev((stderr, "inflate: fixed codes block%s\n",
311  state->last ? " (last)" : ""));
312  state->mode = LEN; /* decode codes */
313  break;
314  case 2: /* dynamic block */
315  Tracev((stderr, "inflate: dynamic codes block%s\n",
316  state->last ? " (last)" : ""));
317  state->mode = TABLE;
318  break;
319  case 3:
320  strm->msg = (char *)"invalid block type";
321  state->mode = BAD;
322  }
323  DROPBITS(2);
324  break;
325 
326  case STORED:
327  /* get and verify stored block length */
328  BYTEBITS(); /* go to byte boundary */
329  NEEDBITS(32);
330  if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
331  strm->msg = (char *)"invalid stored block lengths";
332  state->mode = BAD;
333  break;
334  }
335  state->length = (unsigned)hold & 0xffff;
336  Tracev((stderr, "inflate: stored length %u\n",
337  state->length));
338  INITBITS();
339 
340  /* copy stored block from input to output */
341  while (state->length != 0) {
342  copy = state->length;
343  PULL();
344  ROOM();
345  if (copy > have) copy = have;
346  if (copy > left) copy = left;
347  zmemcpy(put, next, copy);
348  have -= copy;
349  next += copy;
350  left -= copy;
351  put += copy;
352  state->length -= copy;
353  }
354  Tracev((stderr, "inflate: stored end\n"));
355  state->mode = TYPE;
356  break;
357 
358  case TABLE:
359  /* get dynamic table entries descriptor */
360  NEEDBITS(14);
361  state->nlen = BITS(5) + 257;
362  DROPBITS(5);
363  state->ndist = BITS(5) + 1;
364  DROPBITS(5);
365  state->ncode = BITS(4) + 4;
366  DROPBITS(4);
367 #ifndef PKZIP_BUG_WORKAROUND
368  if (state->nlen > 286 || state->ndist > 30) {
369  strm->msg = (char *)"too many length or distance symbols";
370  state->mode = BAD;
371  break;
372  }
373 #endif
374  Tracev((stderr, "inflate: table sizes ok\n"));
375 
376  /* get code length code lengths (not a typo) */
377  state->have = 0;
378  while (state->have < state->ncode) {
379  NEEDBITS(3);
380  state->lens[order[state->have++]] = (unsigned short)BITS(3);
381  DROPBITS(3);
382  }
383  while (state->have < 19)
384  state->lens[order[state->have++]] = 0;
385  state->next = state->codes;
386  state->lencode = (code const FAR *)(state->next);
387  state->lenbits = 7;
388  ret = inflate_table(CODES, state->lens, 19, &(state->next),
389  &(state->lenbits), state->work);
390  if (ret) {
391  strm->msg = (char *)"invalid code lengths set";
392  state->mode = BAD;
393  break;
394  }
395  Tracev((stderr, "inflate: code lengths ok\n"));
396 
397  /* get length and distance code code lengths */
398  state->have = 0;
399  while (state->have < state->nlen + state->ndist) {
400  for (;;) {
401  here = state->lencode[BITS(state->lenbits)];
402  if ((unsigned)(here.bits) <= bits) break;
403  PULLBYTE();
404  }
405  if (here.val < 16) {
406  DROPBITS(here.bits);
407  state->lens[state->have++] = here.val;
408  }
409  else {
410  if (here.val == 16) {
411  NEEDBITS(here.bits + 2);
412  DROPBITS(here.bits);
413  if (state->have == 0) {
414  strm->msg = (char *)"invalid bit length repeat";
415  state->mode = BAD;
416  break;
417  }
418  len = (unsigned)(state->lens[state->have - 1]);
419  copy = 3 + BITS(2);
420  DROPBITS(2);
421  }
422  else if (here.val == 17) {
423  NEEDBITS(here.bits + 3);
424  DROPBITS(here.bits);
425  len = 0;
426  copy = 3 + BITS(3);
427  DROPBITS(3);
428  }
429  else {
430  NEEDBITS(here.bits + 7);
431  DROPBITS(here.bits);
432  len = 0;
433  copy = 11 + BITS(7);
434  DROPBITS(7);
435  }
436  if (state->have + copy > state->nlen + state->ndist) {
437  strm->msg = (char *)"invalid bit length repeat";
438  state->mode = BAD;
439  break;
440  }
441  while (copy--)
442  state->lens[state->have++] = (unsigned short)len;
443  }
444  }
445 
446  /* handle error breaks in while */
447  if (state->mode == BAD) break;
448 
449  /* check for end-of-block code (better have one) */
450  if (state->lens[256] == 0) {
451  strm->msg = (char *)"invalid code -- missing end-of-block";
452  state->mode = BAD;
453  break;
454  }
455 
456  /* build code tables -- note: do not change the lenbits or distbits
457  values here (9 and 6) without reading the comments in inftrees.h
458  concerning the ENOUGH constants, which depend on those values */
459  state->next = state->codes;
460  state->lencode = (code const FAR *)(state->next);
461  state->lenbits = 9;
462  ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
463  &(state->lenbits), state->work);
464  if (ret) {
465  strm->msg = (char *)"invalid literal/lengths set";
466  state->mode = BAD;
467  break;
468  }
469  state->distcode = (code const FAR *)(state->next);
470  state->distbits = 6;
471  ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
472  &(state->next), &(state->distbits), state->work);
473  if (ret) {
474  strm->msg = (char *)"invalid distances set";
475  state->mode = BAD;
476  break;
477  }
478  Tracev((stderr, "inflate: codes ok\n"));
479  state->mode = LEN;
480  /* fallthrough */
481 
482  case LEN:
483  /* use inflate_fast() if we have enough input and output */
484  if (have >= 6 && left >= 258) {
485  RESTORE();
486  if (state->whave < state->wsize)
487  state->whave = state->wsize - left;
488  inflate_fast(strm, state->wsize);
489  LOAD();
490  break;
491  }
492 
493  /* get a literal, length, or end-of-block code */
494  for (;;) {
495  here = state->lencode[BITS(state->lenbits)];
496  if ((unsigned)(here.bits) <= bits) break;
497  PULLBYTE();
498  }
499  if (here.op && (here.op & 0xf0) == 0) {
500  last = here;
501  for (;;) {
502  here = state->lencode[last.val +
503  (BITS(last.bits + last.op) >> last.bits)];
504  if ((unsigned)(last.bits + here.bits) <= bits) break;
505  PULLBYTE();
506  }
507  DROPBITS(last.bits);
508  }
509  DROPBITS(here.bits);
510  state->length = (unsigned)here.val;
511 
512  /* process literal */
513  if (here.op == 0) {
514  Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
515  "inflate: literal '%c'\n" :
516  "inflate: literal 0x%02x\n", here.val));
517  ROOM();
518  *put++ = (unsigned char)(state->length);
519  left--;
520  state->mode = LEN;
521  break;
522  }
523 
524  /* process end of block */
525  if (here.op & 32) {
526  Tracevv((stderr, "inflate: end of block\n"));
527  state->mode = TYPE;
528  break;
529  }
530 
531  /* invalid code */
532  if (here.op & 64) {
533  strm->msg = (char *)"invalid literal/length code";
534  state->mode = BAD;
535  break;
536  }
537 
538  /* length code -- get extra bits, if any */
539  state->extra = (unsigned)(here.op) & 15;
540  if (state->extra != 0) {
541  NEEDBITS(state->extra);
542  state->length += BITS(state->extra);
543  DROPBITS(state->extra);
544  }
545  Tracevv((stderr, "inflate: length %u\n", state->length));
546 
547  /* get distance code */
548  for (;;) {
549  here = state->distcode[BITS(state->distbits)];
550  if ((unsigned)(here.bits) <= bits) break;
551  PULLBYTE();
552  }
553  if ((here.op & 0xf0) == 0) {
554  last = here;
555  for (;;) {
556  here = state->distcode[last.val +
557  (BITS(last.bits + last.op) >> last.bits)];
558  if ((unsigned)(last.bits + here.bits) <= bits) break;
559  PULLBYTE();
560  }
561  DROPBITS(last.bits);
562  }
563  DROPBITS(here.bits);
564  if (here.op & 64) {
565  strm->msg = (char *)"invalid distance code";
566  state->mode = BAD;
567  break;
568  }
569  state->offset = (unsigned)here.val;
570 
571  /* get distance extra bits, if any */
572  state->extra = (unsigned)(here.op) & 15;
573  if (state->extra != 0) {
574  NEEDBITS(state->extra);
575  state->offset += BITS(state->extra);
576  DROPBITS(state->extra);
577  }
578  if (state->offset > state->wsize - (state->whave < state->wsize ?
579  left : 0)) {
580  strm->msg = (char *)"invalid distance too far back";
581  state->mode = BAD;
582  break;
583  }
584  Tracevv((stderr, "inflate: distance %u\n", state->offset));
585 
586  /* copy match from window to output */
587  do {
588  ROOM();
589  copy = state->wsize - state->offset;
590  if (copy < left) {
591  from = put + copy;
592  copy = left - copy;
593  }
594  else {
595  from = put - state->offset;
596  copy = left;
597  }
598  if (copy > state->length) copy = state->length;
599  state->length -= copy;
600  left -= copy;
601  do {
602  *put++ = *from++;
603  } while (--copy);
604  } while (state->length != 0);
605  break;
606 
607  case DONE:
608  /* inflate stream terminated properly -- write leftover output */
609  ret = Z_STREAM_END;
610  if (left < state->wsize) {
611  if (out(out_desc, state->window, state->wsize - left))
612  ret = Z_BUF_ERROR;
613  }
614  goto inf_leave;
615 
616  case BAD:
617  ret = Z_DATA_ERROR;
618  goto inf_leave;
619 
620  default: /* can't happen, but makes compilers happy */
621  ret = Z_STREAM_ERROR;
622  goto inf_leave;
623  }
624 
625  /* Return unused input */
626  inf_leave:
627  strm->next_in = next;
628  strm->avail_in = have;
629  return ret;
630 }
631 
634 {
635  if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
636  return Z_STREAM_ERROR;
637  ZFREE(strm, strm->state);
638  strm->state = Z_NULL;
639  Tracev((stderr, "inflate: end\n"));
640  return Z_OK;
641 }
std::ofstream out("events_result.xml")
main entry point for tests
static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)
Definition: dlist.tmpl.h:51
static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)
Definition: dlist.tmpl.h:56
#define LEN(ptr)
#define TYPE(s)
#define FAR
Definition: ncbistd.hpp:278
for(len=0;yy_str[len];++len)
if(yy_accept[yy_current_state])
int len
static int version
Definition: mdb_load.c:29
std::istream & in(std::istream &in_, double &x_)
void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)
Definition: njn_matrix.hpp:613
Definition: inftrees.h:24
unsigned char op
Definition: inftrees.h:25
unsigned char bits
Definition: inftrees.h:26
unsigned short val
Definition: inftrees.h:27
unsigned char FAR * window
Definition: inflate.h:100
unsigned have
Definition: inflate.h:118
unsigned long hold
Definition: inflate.h:102
z_streamp strm
Definition: inflate.h:83
unsigned bits
Definition: inflate.h:103
unsigned wsize
Definition: inflate.h:97
Bytef * window
Definition: deflate.h:119
uInt avail_in
Definition: zlib.h:88
Bytef * next_in
Definition: zlib.h:87
alloc_func zalloc
Definition: zlib.h:98
char * msg
Definition: zlib.h:95
free_func zfree
Definition: zlib.h:99
voidpf opaque
Definition: zlib.h:100
struct internal_state * state
Definition: zlib.h:96
#define ZEXPORT
Definition: zconf.h:382
#define z_const
Definition: zconf.h:239
#define inflate_fast
Definition: zconf_cf.h:121
#define voidpf
Definition: zconf_cf.h:154
#define zcalloc
Definition: zconf_cf.h:128
#define inflate_table
Definition: zconf_cf.h:122
#define uInt
Definition: zconf_cf.h:148
#define zcfree
Definition: zconf_cf.h:129
int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)
Definition: infback.c:28
#define LOAD()
Definition: infback.c:128
#define PULL()
Definition: infback.c:158
#define INITBITS()
Definition: infback.c:150
#define BITS(n)
Definition: infback.c:190
#define DROPBITS(n)
Definition: infback.c:194
int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
Definition: infback.c:250
int ZEXPORT inflateBackEnd(z_streamp strm)
Definition: infback.c:632
void fixedtables(struct inflate_state FAR *state)
Definition: infback.c:82
void fixedtables OF((struct inflate_state FAR *state))
#define BYTEBITS()
Definition: infback.c:201
#define ROOM()
Definition: infback.c:210
#define NEEDBITS(n)
Definition: infback.c:183
#define PULLBYTE()
Definition: infback.c:172
#define RESTORE()
Definition: infback.c:139
static const code distfix[32]
Definition: inffixed.h:87
static const code lenfix[512]
Definition: inffixed.h:10
@ TABLE
Definition: inflate.h:37
@ STORED
Definition: inflate.h:34
@ DONE
Definition: inflate.h:49
@ BAD
Definition: inflate.h:50
@ CODES
Definition: inftrees.h:55
@ LENS
Definition: inftrees.h:56
@ DISTS
Definition: inftrees.h:57
void(* free_func)()
Definition: zlib.h:82
#define Z_BUF_ERROR
Definition: zlib.h:184
#define ZLIB_VERSION
Definition: zlib.h:40
voidpf(* alloc_func)()
Definition: zlib.h:81
#define Z_VERSION_ERROR
Definition: zlib.h:185
#define Z_STREAM_END
Definition: zlib.h:178
#define Z_OK
Definition: zlib.h:177
#define Z_DATA_ERROR
Definition: zlib.h:182
unsigned(* in_func)()
Definition: zlib.h:1095
int(* out_func)()
Definition: zlib.h:1096
#define Z_STREAM_ERROR
Definition: zlib.h:181
#define Z_NULL
Definition: zlib.h:212
#define Z_MEM_ERROR
Definition: zlib.h:183
#define local
Definition: zutil.h:33
#define ZALLOC(strm, items, size)
Definition: zutil.h:265
#define Tracev(x)
Definition: zutil.h:253
#define ZFREE(strm, addr)
Definition: zutil.h:267
void zmemcpy()
#define Tracevv(x)
Definition: zutil.h:254
Modified on Wed May 22 11:32:26 2024 by modify_doxy.py rev. 669887