ReactOS  0.4.14-dev-384-g5b37caa
infback.c File Reference
#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"
#include "inffixed.h"
Include dependency graph for infback.c:

Go to the source code of this file.

Macros

#define LOAD()
 
#define RESTORE()
 
#define INITBITS()
 
#define PULL()
 
#define PULLBYTE()
 
#define NEEDBITS(n)
 
#define BITS(n)   ((unsigned)hold & ((1U << (n)) - 1))
 
#define DROPBITS(n)
 
#define BYTEBITS()
 
#define ROOM()
 

Functions

void fixedtables OF ((struct inflate_state FAR *state))
 
int ZEXPORT inflateBackInit_ (z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)
 
void fixedtables (struct inflate_state FAR *state)
 
int ZEXPORT inflateBack (z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
 
int ZEXPORT inflateBackEnd (z_streamp strm)
 

Macro Definition Documentation

◆ BITS

#define BITS (   n)    ((unsigned)hold & ((1U << (n)) - 1))

Definition at line 190 of file infback.c.

◆ BYTEBITS

#define BYTEBITS ( )
Value:
do { \
hold >>= bits & 7; \
bits -= bits & 7; \
} while (0)
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929

Definition at line 201 of file infback.c.

◆ DROPBITS

#define DROPBITS (   n)
Value:
do { \
hold >>= (n); \
bits -= (unsigned)(n); \
} while (0)
GLdouble n
Definition: glext.h:7729

Definition at line 194 of file infback.c.

◆ INITBITS

#define INITBITS ( )
Value:
do { \
hold = 0; \
bits = 0; \
} while (0)

Definition at line 150 of file infback.c.

◆ LOAD

#define LOAD ( )
Value:
do { \
put = strm->next_out; \
left = strm->avail_out; \
next = strm->next_in; \
have = strm->avail_in; \
hold = state->hold; \
bits = state->bits; \
} while (0)
z_streamp strm
Definition: deflate.h:101
static int state
Definition: maze.c:121

Definition at line 128 of file infback.c.

◆ NEEDBITS

#define NEEDBITS (   n)
Value:
do { \
while (bits < (unsigned)(n)) \
PULLBYTE(); \
} while (0)
GLdouble n
Definition: glext.h:7729
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929

Definition at line 183 of file infback.c.

◆ PULL

#define PULL ( )
Value:
do { \
if (have == 0) { \
have = in(in_desc, &next); \
if (have == 0) { \
next = Z_NULL; \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)
#define Z_BUF_ERROR
Definition: zlib.h:184
static unsigned __int64 next
Definition: rand_nt.c:6
GLuint in
Definition: glext.h:9616
#define Z_NULL
Definition: zlib.h:212

Definition at line 158 of file infback.c.

◆ PULLBYTE

#define PULLBYTE ( )
Value:
do { \
PULL(); \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
} while (0)
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
static unsigned __int64 next
Definition: rand_nt.c:6
#define long
Definition: qsort.c:33

Definition at line 172 of file infback.c.

◆ RESTORE

#define RESTORE ( )
Value:
do { \
strm->next_out = put; \
strm->avail_out = left; \
strm->next_in = next; \
strm->avail_in = have; \
state->hold = hold; \
state->bits = bits; \
} while (0)
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define put(ret, state, sp, n)
Definition: match.c:105
GLint left
Definition: glext.h:7726
static unsigned __int64 next
Definition: rand_nt.c:6

Definition at line 139 of file infback.c.

◆ ROOM

#define ROOM ( )
Value:
do { \
if (left == 0) { \
put = state->window; \
left = state->wsize; \
state->whave = left; \
if (out(out_desc, put, left)) { \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)
#define put(ret, state, sp, n)
Definition: match.c:105
#define Z_BUF_ERROR
Definition: zlib.h:184
static FILE * out
Definition: regtests2xml.c:44
GLint left
Definition: glext.h:7726
static int state
Definition: maze.c:121

Definition at line 210 of file infback.c.

Function Documentation

◆ fixedtables()

void fixedtables ( struct inflate_state FAR state)

Definition at line 82 of file infback.c.

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 }
Definition: infutil.h:16
static const code lenfix[512]
Definition: inffixed.h:10
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
ios_base &_STLP_CALL fixed(ios_base &__s)
Definition: _ios_base.h:332
static int state
Definition: maze.c:121
static const code distfix[32]
Definition: inffixed.h:87
static unsigned __int64 next
Definition: rand_nt.c:6
int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR *FAR *table, unsigned FAR *bits, unsigned short FAR *work)
Definition: inftrees.c:32
Definition: inftrees.h:57

Referenced by inflateBack().

◆ inflateBack()

int ZEXPORT inflateBack ( z_streamp  strm,
in_func  in,
void FAR in_desc,
out_func  out,
void FAR out_desc 
)

Definition at line 250 of file infback.c.

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 
481  case LEN:
482  /* use inflate_fast() if we have enough input and output */
483  if (have >= 6 && left >= 258) {
484  RESTORE();
485  if (state->whave < state->wsize)
486  state->whave = state->wsize - left;
487  inflate_fast(strm, state->wsize);
488  LOAD();
489  break;
490  }
491 
492  /* get a literal, length, or end-of-block code */
493  for (;;) {
494  here = state->lencode[BITS(state->lenbits)];
495  if ((unsigned)(here.bits) <= bits) break;
496  PULLBYTE();
497  }
498  if (here.op && (here.op & 0xf0) == 0) {
499  last = here;
500  for (;;) {
501  here = state->lencode[last.val +
502  (BITS(last.bits + last.op) >> last.bits)];
503  if ((unsigned)(last.bits + here.bits) <= bits) break;
504  PULLBYTE();
505  }
506  DROPBITS(last.bits);
507  }
508  DROPBITS(here.bits);
509  state->length = (unsigned)here.val;
510 
511  /* process literal */
512  if (here.op == 0) {
513  Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
514  "inflate: literal '%c'\n" :
515  "inflate: literal 0x%02x\n", here.val));
516  ROOM();
517  *put++ = (unsigned char)(state->length);
518  left--;
519  state->mode = LEN;
520  break;
521  }
522 
523  /* process end of block */
524  if (here.op & 32) {
525  Tracevv((stderr, "inflate: end of block\n"));
526  state->mode = TYPE;
527  break;
528  }
529 
530  /* invalid code */
531  if (here.op & 64) {
532  strm->msg = (char *)"invalid literal/length code";
533  state->mode = BAD;
534  break;
535  }
536 
537  /* length code -- get extra bits, if any */
538  state->extra = (unsigned)(here.op) & 15;
539  if (state->extra != 0) {
540  NEEDBITS(state->extra);
541  state->length += BITS(state->extra);
542  DROPBITS(state->extra);
543  }
544  Tracevv((stderr, "inflate: length %u\n", state->length));
545 
546  /* get distance code */
547  for (;;) {
548  here = state->distcode[BITS(state->distbits)];
549  if ((unsigned)(here.bits) <= bits) break;
550  PULLBYTE();
551  }
552  if ((here.op & 0xf0) == 0) {
553  last = here;
554  for (;;) {
555  here = state->distcode[last.val +
556  (BITS(last.bits + last.op) >> last.bits)];
557  if ((unsigned)(last.bits + here.bits) <= bits) break;
558  PULLBYTE();
559  }
560  DROPBITS(last.bits);
561  }
562  DROPBITS(here.bits);
563  if (here.op & 64) {
564  strm->msg = (char *)"invalid distance code";
565  state->mode = BAD;
566  break;
567  }
568  state->offset = (unsigned)here.val;
569 
570  /* get distance extra bits, if any */
571  state->extra = (unsigned)(here.op) & 15;
572  if (state->extra != 0) {
573  NEEDBITS(state->extra);
574  state->offset += BITS(state->extra);
575  DROPBITS(state->extra);
576  }
577  if (state->offset > state->wsize - (state->whave < state->wsize ?
578  left : 0)) {
579  strm->msg = (char *)"invalid distance too far back";
580  state->mode = BAD;
581  break;
582  }
583  Tracevv((stderr, "inflate: distance %u\n", state->offset));
584 
585  /* copy match from window to output */
586  do {
587  ROOM();
588  copy = state->wsize - state->offset;
589  if (copy < left) {
590  from = put + copy;
591  copy = left - copy;
592  }
593  else {
594  from = put - state->offset;
595  copy = left;
596  }
597  if (copy > state->length) copy = state->length;
598  state->length -= copy;
599  left -= copy;
600  do {
601  *put++ = *from++;
602  } while (--copy);
603  } while (state->length != 0);
604  break;
605 
606  case DONE:
607  /* inflate stream terminated properly -- write leftover output */
608  ret = Z_STREAM_END;
609  if (left < state->wsize) {
610  if (out(out_desc, state->window, state->wsize - left))
611  ret = Z_BUF_ERROR;
612  }
613  goto inf_leave;
614 
615  case BAD:
616  ret = Z_DATA_ERROR;
617  goto inf_leave;
618 
619  default: /* can't happen, but makes compilers happy */
621  goto inf_leave;
622  }
623 
624  /* Return unused input */
625  inf_leave:
626  strm->next_in = next;
627  strm->avail_in = have;
628  return ret;
629 }
Definition: infutil.h:17
Definition: infutil.h:16
unsigned short val
Definition: inftrees.h:27
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
POINT last
Definition: font.c:46
#define DROPBITS(n)
Definition: infback.c:194
z_streamp strm
Definition: inflate.h:83
unsigned wsize
Definition: inflate.h:96
unsigned have
Definition: inflate.h:117
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define Z_STREAM_ERROR
Definition: zlib.h:181
unsigned char op
Definition: inftrees.h:25
#define Z_STREAM_END
Definition: zlib.h:178
#define LOAD()
Definition: infback.c:128
#define put(ret, state, sp, n)
Definition: match.c:105
#define z_const
Definition: zconf.h:237
#define INITBITS()
Definition: infback.c:150
#define PULLBYTE()
Definition: infback.c:172
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:93
#define NEEDBITS(n)
Definition: infback.c:183
#define Z_BUF_ERROR
Definition: zlib.h:184
void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start)
Definition: inffast.c:50
#define FAR
Definition: guiddef.h:36
unsigned char
Definition: typeof.h:29
Definition: infutil.h:21
#define BAD
Definition: inflate.c:10
unsigned long hold
Definition: inflate.h:101
#define Tracevv(x)
Definition: zutil.h:199
#define ROOM()
Definition: infback.c:210
if(!(yy_init))
Definition: macro.lex.yy.c:714
void zmemcpy(Bytef *dest, const Bytef *source, uInt len)
Definition: zutil.c:17
static FILE * out
Definition: regtests2xml.c:44
#define for
Definition: utility.h:88
GLint left
Definition: glext.h:7726
#define Z_DATA_ERROR
Definition: zlib.h:182
int ret
unsigned char bits
Definition: inftrees.h:26
#define LEN
Definition: rtl.c:127
static int state
Definition: maze.c:121
#define RESTORE()
Definition: infback.c:139
GLenum GLsizei len
Definition: glext.h:6722
#define BITS(n)
Definition: infback.c:190
#define Tracev(x)
Definition: zutil.h:198
static unsigned __int64 next
Definition: rand_nt.c:6
Definition: infutil.h:18
TYPE
Definition: eventcreate.c:651
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
#define PULL()
Definition: infback.c:158
FILE * stderr
int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR *FAR *table, unsigned FAR *bits, unsigned short FAR *work)
Definition: inftrees.c:32
#define DONE
Definition: rnr20lib.h:14
CardRegion * from
Definition: spigame.cpp:19
#define Z_NULL
Definition: zlib.h:212
#define BYTEBITS()
Definition: infback.c:201
Definition: inftrees.h:57
void fixedtables(struct inflate_state FAR *state)
Definition: infback.c:82

◆ inflateBackEnd()

int ZEXPORT inflateBackEnd ( z_streamp  strm)

Definition at line 631 of file infback.c.

633 {
634  if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
635  return Z_STREAM_ERROR;
636  ZFREE(strm, strm->state);
637  strm->state = Z_NULL;
638  Tracev((stderr, "inflate: end\n"));
639  return Z_OK;
640 }
z_streamp strm
Definition: inflate.h:83
#define Z_STREAM_ERROR
Definition: zlib.h:181
#define Z_OK
Definition: zlib.h:177
#define ZFREE(strm, addr)
Definition: zutil.h:212
#define Tracev(x)
Definition: zutil.h:198
FILE * stderr
#define Z_NULL
Definition: zlib.h:212

◆ inflateBackInit_()

int ZEXPORT inflateBackInit_ ( z_streamp  strm,
int  windowBits,
unsigned char FAR window,
const char version,
int  stream_size 
)

Definition at line 28 of file infback.c.

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 }
int windowBits
Definition: zlib.h:813
#define ZALLOC(strm, items, size)
Definition: zutil.h:210
#define U(x)
Definition: wordpad.c:44
z_streamp strm
Definition: inflate.h:83
#define Z_SOLO
Definition: cabinet.c:13
#define Z_STREAM_ERROR
Definition: zlib.h:181
#define FAR
Definition: guiddef.h:36
#define Z_OK
Definition: zlib.h:177
#define ZLIB_VERSION
Definition: zlib.h:40
static const WCHAR version[]
Definition: asmname.c:66
int const char int stream_size
Definition: zlib.h:813
static int state
Definition: maze.c:121
static IHTMLWindow2 * window
Definition: events.c:77
Byte FAR * voidpf
Definition: zconf.h:413
#define Tracev(x)
Definition: zutil.h:198
#define Z_VERSION_ERROR
Definition: zlib.h:185
void zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:173
voidpf zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:164
FILE * stderr
#define Z_NULL
Definition: zlib.h:212
#define Z_MEM_ERROR
Definition: zlib.h:183
unsigned int uInt
Definition: zconf.h:393

◆ OF()