abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Macros | Functions
infback.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "misc/util/abc_global.h"
#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"
#include "inffixed.h"

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

ABC_NAMESPACE_IMPL_START local
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)
 
local 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

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

Definition at line 182 of file infback.c.

#define BYTEBITS ( )
Value:
do { \
hold >>= bits & 7; \
bits -= bits & 7; \
} while (0)
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 193 of file infback.c.

#define DROPBITS (   n)
Value:
do { \
hold >>= (n); \
bits -= (unsigned)(n); \
} while (0)
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 186 of file infback.c.

#define INITBITS ( )
Value:
do { \
hold = 0; \
bits = 0; \
} while (0)
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 142 of file infback.c.

#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)
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 120 of file infback.c.

#define NEEDBITS (   n)
Value:
do { \
while (bits < (unsigned)(n)) \
PULLBYTE(); \
} while (0)
PULLBYTE
#define PULLBYTE()
Definition: infback.c:164
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 175 of file infback.c.

#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)
if
if(last==0)
Definition: sparse_int.h:34
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:188
Z_NULL
#define Z_NULL
Definition: zlib.h:216

Definition at line 150 of file infback.c.

#define PULLBYTE ( )
Value:
do { \
PULL(); \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
} while (0)
PULL
#define PULL()
Definition: infback.c:150
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 164 of file infback.c.

#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)
bits
static char * bits(int n)
Definition: abcSaucy.c:201

Definition at line 131 of file infback.c.

#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)
if
if(last==0)
Definition: sparse_int.h:34
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:188

Definition at line 202 of file infback.c.

Function Documentation

local void fixedtables ( struct inflate_state FAR *  state)

Definition at line 75 of file infback.c.

76 {
77 #ifdef BUILDFIXED
78  static int virgin = 1;
79  static code *lenfix, *distfix;
80  static code fixed[544];
81 
82  /* build fixed huffman tables if first call (may not be thread safe) */
83  if (virgin) {
84  unsigned sym, bits;
85  static code *next;
86 
87  /* literal/length table */
88  sym = 0;
89  while (sym < 144) state->lens[sym++] = 8;
90  while (sym < 256) state->lens[sym++] = 9;
91  while (sym < 280) state->lens[sym++] = 7;
92  while (sym < 288) state->lens[sym++] = 8;
93  next = fixed;
94  lenfix = next;
95  bits = 9;
96  inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
97 
98  /* distance table */
99  sym = 0;
100  while (sym < 32) state->lens[sym++] = 5;
101  distfix = next;
102  bits = 5;
103  inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
104 
105  /* do this just once */
106  virgin = 0;
107  }
108 #else /* !BUILDFIXED */
109 # include "inffixed.h"
110 #endif /* BUILDFIXED */
111  state->lencode = lenfix;
112  state->lenbits = 9;
113  state->distcode = distfix;
114  state->distbits = 5;
115 }
DISTS
Definition: inftrees.h:59
lenfix
static const code lenfix[512]
Definition: inffixed.h:12
inflate_table
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:39
distfix
static const code distfix[32]
Definition: inffixed.h:89
code
Definition: inftrees.h:26
LENS
Definition: inftrees.h:58
bits
static char * bits(int n)
Definition: abcSaucy.c:201
int ZEXPORT inflateBack ( z_streamp  strm,
in_func  in,
void FAR *  in_desc,
out_func  out,
void FAR *  out_desc 
)

Definition at line 242 of file infback.c.

243 {
244  struct inflate_state FAR *state;
245  unsigned char FAR *next; /* next input */
246  unsigned char FAR *put; /* next output */
247  unsigned have, left; /* available input and output */
248  unsigned long hold; /* bit buffer */
249  unsigned bits; /* bits in bit buffer */
250  unsigned copy; /* number of stored or match bytes to copy */
251  unsigned char FAR *from; /* where to copy match bytes from */
252  code here; /* current decoding table entry */
253  code last; /* parent table entry */
254  unsigned len; /* length to copy for repeats, bits to drop */
255  int ret; /* return code */
256  static const unsigned short order[19] = /* permutation of code lengths */
257  {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
258 
259  /* Check that the strm exists and that the state was initialized */
260  if (strm == Z_NULL || strm->state == Z_NULL)
261  return Z_STREAM_ERROR;
262  state = (struct inflate_state FAR *)strm->state;
263 
264  /* Reset the state */
265  strm->msg = Z_NULL;
266  state->mode = TYPE;
267  state->last = 0;
268  state->whave = 0;
269  next = strm->next_in;
270  have = next != Z_NULL ? strm->avail_in : 0;
271  hold = 0;
272  bits = 0;
273  put = state->window;
274  left = state->wsize;
275 
276  /* Inflate until end of block marked as last */
277  for (;;)
278  switch (state->mode) {
279  case TYPE:
280  /* determine and dispatch block type */
281  if (state->last) {
282  BYTEBITS();
283  state->mode = DONE;
284  break;
285  }
286  NEEDBITS(3);
287  state->last = BITS(1);
288  DROPBITS(1);
289  switch (BITS(2)) {
290  case 0: /* stored block */
291  Tracev((stderr, "inflate: stored block%s\n",
292  state->last ? " (last)" : ""));
293  state->mode = STORED;
294  break;
295  case 1: /* fixed block */
296  fixedtables(state);
297  Tracev((stderr, "inflate: fixed codes block%s\n",
298  state->last ? " (last)" : ""));
299  state->mode = LEN; /* decode codes */
300  break;
301  case 2: /* dynamic block */
302  Tracev((stderr, "inflate: dynamic codes block%s\n",
303  state->last ? " (last)" : ""));
304  state->mode = TABLE;
305  break;
306  case 3:
307  strm->msg = (char *)"invalid block type";
308  state->mode = BAD;
309  }
310  DROPBITS(2);
311  break;
312 
313  case STORED:
314  /* get and verify stored block length */
315  BYTEBITS(); /* go to byte boundary */
316  NEEDBITS(32);
317  if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
318  strm->msg = (char *)"invalid stored block lengths";
319  state->mode = BAD;
320  break;
321  }
322  state->length = (unsigned)hold & 0xffff;
323  Tracev((stderr, "inflate: stored length %u\n",
324  state->length));
325  INITBITS();
326 
327  /* copy stored block from input to output */
328  while (state->length != 0) {
329  copy = state->length;
330  PULL();
331  ROOM();
332  if (copy > have) copy = have;
333  if (copy > left) copy = left;
334  zmemcpy(put, next, copy);
335  have -= copy;
336  next += copy;
337  left -= copy;
338  put += copy;
339  state->length -= copy;
340  }
341  Tracev((stderr, "inflate: stored end\n"));
342  state->mode = TYPE;
343  break;
344 
345  case TABLE:
346  /* get dynamic table entries descriptor */
347  NEEDBITS(14);
348  state->nlen = BITS(5) + 257;
349  DROPBITS(5);
350  state->ndist = BITS(5) + 1;
351  DROPBITS(5);
352  state->ncode = BITS(4) + 4;
353  DROPBITS(4);
354 #ifndef PKZIP_BUG_WORKAROUND
355  if (state->nlen > 286 || state->ndist > 30) {
356  strm->msg = (char *)"too many length or distance symbols";
357  state->mode = BAD;
358  break;
359  }
360 #endif
361  Tracev((stderr, "inflate: table sizes ok\n"));
362 
363  /* get code length code lengths (not a typo) */
364  state->have = 0;
365  while (state->have < state->ncode) {
366  NEEDBITS(3);
367  state->lens[order[state->have++]] = (unsigned short)BITS(3);
368  DROPBITS(3);
369  }
370  while (state->have < 19)
371  state->lens[order[state->have++]] = 0;
372  state->next = state->codes;
373  state->lencode = (code const FAR *)(state->next);
374  state->lenbits = 7;
375  ret = inflate_table(CODES, state->lens, 19, &(state->next),
376  &(state->lenbits), state->work);
377  if (ret) {
378  strm->msg = (char *)"invalid code lengths set";
379  state->mode = BAD;
380  break;
381  }
382  Tracev((stderr, "inflate: code lengths ok\n"));
383 
384  /* get length and distance code code lengths */
385  state->have = 0;
386  while (state->have < state->nlen + state->ndist) {
387  for (;;) {
388  here = state->lencode[BITS(state->lenbits)];
389  if ((unsigned)(here.bits) <= bits) break;
390  PULLBYTE();
391  }
392  if (here.val < 16) {
393  NEEDBITS(here.bits);
394  DROPBITS(here.bits);
395  state->lens[state->have++] = here.val;
396  }
397  else {
398  if (here.val == 16) {
399  NEEDBITS(here.bits + 2);
400  DROPBITS(here.bits);
401  if (state->have == 0) {
402  strm->msg = (char *)"invalid bit length repeat";
403  state->mode = BAD;
404  break;
405  }
406  len = (unsigned)(state->lens[state->have - 1]);
407  copy = 3 + BITS(2);
408  DROPBITS(2);
409  }
410  else if (here.val == 17) {
411  NEEDBITS(here.bits + 3);
412  DROPBITS(here.bits);
413  len = 0;
414  copy = 3 + BITS(3);
415  DROPBITS(3);
416  }
417  else {
418  NEEDBITS(here.bits + 7);
419  DROPBITS(here.bits);
420  len = 0;
421  copy = 11 + BITS(7);
422  DROPBITS(7);
423  }
424  if (state->have + copy > state->nlen + state->ndist) {
425  strm->msg = (char *)"invalid bit length repeat";
426  state->mode = BAD;
427  break;
428  }
429  while (copy--)
430  state->lens[state->have++] = (unsigned short)len;
431  }
432  }
433 
434  /* handle error breaks in while */
435  if (state->mode == BAD) break;
436 
437  /* check for end-of-block code (better have one) */
438  if (state->lens[256] == 0) {
439  strm->msg = (char *)"invalid code -- missing end-of-block";
440  state->mode = BAD;
441  break;
442  }
443 
444  /* build code tables -- note: do not change the lenbits or distbits
445  values here (9 and 6) without reading the comments in inftrees.h
446  concerning the ENOUGH constants, which depend on those values */
447  state->next = state->codes;
448  state->lencode = (code const FAR *)(state->next);
449  state->lenbits = 9;
450  ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
451  &(state->lenbits), state->work);
452  if (ret) {
453  strm->msg = (char *)"invalid literal/lengths set";
454  state->mode = BAD;
455  break;
456  }
457  state->distcode = (code const FAR *)(state->next);
458  state->distbits = 6;
459  ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
460  &(state->next), &(state->distbits), state->work);
461  if (ret) {
462  strm->msg = (char *)"invalid distances set";
463  state->mode = BAD;
464  break;
465  }
466  Tracev((stderr, "inflate: codes ok\n"));
467  state->mode = LEN;
468 
469  case LEN:
470  /* use inflate_fast() if we have enough input and output */
471  if (have >= 6 && left >= 258) {
472  RESTORE();
473  if (state->whave < state->wsize)
474  state->whave = state->wsize - left;
475  inflate_fast(strm, state->wsize);
476  LOAD();
477  break;
478  }
479 
480  /* get a literal, length, or end-of-block code */
481  for (;;) {
482  here = state->lencode[BITS(state->lenbits)];
483  if ((unsigned)(here.bits) <= bits) break;
484  PULLBYTE();
485  }
486  if (here.op && (here.op & 0xf0) == 0) {
487  last = here;
488  for (;;) {
489  here = state->lencode[last.val +
490  (BITS(last.bits + last.op) >> last.bits)];
491  if ((unsigned)(last.bits + here.bits) <= bits) break;
492  PULLBYTE();
493  }
494  DROPBITS(last.bits);
495  }
496  DROPBITS(here.bits);
497  state->length = (unsigned)here.val;
498 
499  /* process literal */
500  if (here.op == 0) {
501  Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
502  "inflate: literal '%c'\n" :
503  "inflate: literal 0x%02x\n", here.val));
504  ROOM();
505  *put++ = (unsigned char)(state->length);
506  left--;
507  state->mode = LEN;
508  break;
509  }
510 
511  /* process end of block */
512  if (here.op & 32) {
513  Tracevv((stderr, "inflate: end of block\n"));
514  state->mode = TYPE;
515  break;
516  }
517 
518  /* invalid code */
519  if (here.op & 64) {
520  strm->msg = (char *)"invalid literal/length code";
521  state->mode = BAD;
522  break;
523  }
524 
525  /* length code -- get extra bits, if any */
526  state->extra = (unsigned)(here.op) & 15;
527  if (state->extra != 0) {
528  NEEDBITS(state->extra);
529  state->length += BITS(state->extra);
530  DROPBITS(state->extra);
531  }
532  Tracevv((stderr, "inflate: length %u\n", state->length));
533 
534  /* get distance code */
535  for (;;) {
536  here = state->distcode[BITS(state->distbits)];
537  if ((unsigned)(here.bits) <= bits) break;
538  PULLBYTE();
539  }
540  if ((here.op & 0xf0) == 0) {
541  last = here;
542  for (;;) {
543  here = state->distcode[last.val +
544  (BITS(last.bits + last.op) >> last.bits)];
545  if ((unsigned)(last.bits + here.bits) <= bits) break;
546  PULLBYTE();
547  }
548  DROPBITS(last.bits);
549  }
550  DROPBITS(here.bits);
551  if (here.op & 64) {
552  strm->msg = (char *)"invalid distance code";
553  state->mode = BAD;
554  break;
555  }
556  state->offset = (unsigned)here.val;
557 
558  /* get distance extra bits, if any */
559  state->extra = (unsigned)(here.op) & 15;
560  if (state->extra != 0) {
561  NEEDBITS(state->extra);
562  state->offset += BITS(state->extra);
563  DROPBITS(state->extra);
564  }
565  if (state->offset > state->wsize - (state->whave < state->wsize ?
566  left : 0)) {
567  strm->msg = (char *)"invalid distance too far back";
568  state->mode = BAD;
569  break;
570  }
571  Tracevv((stderr, "inflate: distance %u\n", state->offset));
572 
573  /* copy match from window to output */
574  do {
575  ROOM();
576  copy = state->wsize - state->offset;
577  if (copy < left) {
578  from = put + copy;
579  copy = left - copy;
580  }
581  else {
582  from = put - state->offset;
583  copy = left;
584  }
585  if (copy > state->length) copy = state->length;
586  state->length -= copy;
587  left -= copy;
588  do {
589  *put++ = *from++;
590  } while (--copy);
591  } while (state->length != 0);
592  break;
593 
594  case DONE:
595  /* inflate stream terminated properly -- write leftover output */
596  ret = Z_STREAM_END;
597  if (left < state->wsize) {
598  if (out(out_desc, state->window, state->wsize - left))
599  ret = Z_BUF_ERROR;
600  }
601  goto inf_leave;
602 
603  case BAD:
604  ret = Z_DATA_ERROR;
605  goto inf_leave;
606 
607  default: /* can't happen, but makes compilers happy */
608  ret = Z_STREAM_ERROR;
609  goto inf_leave;
610  }
611 
612  /* Return unused input */
613  inf_leave:
614  strm->next_in = next;
615  strm->avail_in = have;
616  return ret;
617 }
inflate_state::nlen
unsigned nlen
Definition: inflate.h:114
code::val
unsigned short val
Definition: inftrees.h:29
inflate_state
Definition: inflate.h:83
Minisat::copy
static void copy(const T &from, T &to)
Definition: Alg.h:61
STORED
Definition: inflate.h:36
inflate_state::ndist
unsigned ndist
Definition: inflate.h:115
DROPBITS
#define DROPBITS(n)
Definition: infback.c:186
inflate_state::wsize
unsigned wsize
Definition: inflate.h:95
inflate_state::have
unsigned have
Definition: inflate.h:116
inflate_state::distbits
unsigned distbits
Definition: inflate.h:111
inflate_state::extra
unsigned extra
Definition: inflate.h:106
DISTS
Definition: inftrees.h:59
inflate_state::distcode
code const FAR * distcode
Definition: inflate.h:109
inflate_state::last
int last
Definition: inflate.h:85
Tracev
#define Tracev(x)
Definition: zutil.h:270
DONE
Definition: inflate.h:51
code::op
unsigned char op
Definition: inftrees.h:27
TYPE
Definition: inflate.h:34
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:185
LOAD
#define LOAD()
Definition: infback.c:120
inflate_state::lenbits
unsigned lenbits
Definition: inflate.h:110
inflate_state::lens
unsigned short lens[320]
Definition: inflate.h:118
INITBITS
#define INITBITS()
Definition: infback.c:142
PULLBYTE
#define PULLBYTE()
Definition: infback.c:164
LEN
Definition: inflate.h:43
NEEDBITS
#define NEEDBITS(n)
Definition: infback.c:175
inflate_state::ncode
unsigned ncode
Definition: inflate.h:113
for
for(p=first;p->value< newval;p=p->next)
TABLE
Definition: inflate.h:39
inflate_fast
void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start)
Definition: inffast.c:74
inflate_table
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:39
inflate_state::next
code FAR * next
Definition: inflate.h:117
inflate_state::codes
code codes[ENOUGH]
Definition: inflate.h:120
inflate_state::hold
unsigned long hold
Definition: inflate.h:100
CODES
Definition: inftrees.h:57
Z_DATA_ERROR
#define Z_DATA_ERROR
Definition: zlib.h:186
ROOM
#define ROOM()
Definition: infback.c:202
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:182
if
if(last==0)
Definition: sparse_int.h:34
inflate_state::work
unsigned short work[288]
Definition: inflate.h:119
zmemcpy
void ZLIB_INTERNAL zmemcpy(Bytef *dest, const Bytef *source, uInt len)
Definition: zutil.c:157
code::bits
unsigned char bits
Definition: inftrees.h:28
RESTORE
#define RESTORE()
Definition: infback.c:131
BITS
#define BITS(n)
Definition: infback.c:182
code
Definition: inftrees.h:26
fixedtables
local void fixedtables(struct inflate_state FAR *state)
Definition: infback.c:75
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:188
inflate_state::window
unsigned char FAR * window
Definition: inflate.h:98
inflate_state::mode
inflate_mode mode
Definition: inflate.h:84
LENS
Definition: inftrees.h:58
BAD
Definition: inflate.h:52
PULL
#define PULL()
Definition: infback.c:150
Z_NULL
#define Z_NULL
Definition: zlib.h:216
inflate_state::whave
unsigned whave
Definition: inflate.h:96
FAR
#define FAR
Definition: zconf.h:329
inflate_state::offset
unsigned offset
Definition: inflate.h:104
bits
static char * bits(int n)
Definition: abcSaucy.c:201
BYTEBITS
#define BYTEBITS()
Definition: infback.c:193
inflate_state::lencode
code const FAR * lencode
Definition: inflate.h:108
Tracevv
#define Tracevv(x)
Definition: zutil.h:271
inflate_state::length
unsigned length
Definition: inflate.h:103
int ZEXPORT inflateBackEnd ( z_streamp  strm)

Definition at line 619 of file infback.c.

620 {
621  if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
622  return Z_STREAM_ERROR;
623  ZFREE(strm, strm->state);
624  strm->state = Z_NULL;
625  Tracev((stderr, "inflate: end\n"));
626  return Z_OK;
627 }
Tracev
#define Tracev(x)
Definition: zutil.h:270
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:185
ZFREE
#define ZFREE(strm, addr)
Definition: zutil.h:283
Z_OK
#define Z_OK
Definition: zlib.h:181
Z_NULL
#define Z_NULL
Definition: zlib.h:216
int ZEXPORT inflateBackInit_ ( z_streamp  strm,
int  windowBits,
unsigned char FAR *  window,
const char *  version,
int  stream_size 
)

Definition at line 35 of file infback.c.

36 {
37  struct inflate_state FAR *state;
38 
39  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
40  stream_size != (int)(sizeof(z_stream)))
41  return Z_VERSION_ERROR;
42  if (strm == Z_NULL || window == Z_NULL ||
43  windowBits < 8 || windowBits > 15)
44  return Z_STREAM_ERROR;
45  strm->msg = Z_NULL; /* in case we return an error */
46  if (strm->zalloc == (alloc_func)0) {
47  strm->zalloc = zcalloc;
48  strm->opaque = (voidpf)0;
49  }
50  if (strm->zfree == (free_func)0) strm->zfree = zcfree;
51  state = (struct inflate_state FAR *)ZALLOC(strm, 1,
52  sizeof(struct inflate_state));
53  if (state == Z_NULL) return Z_MEM_ERROR;
54  Tracev((stderr, "inflate: allocated\n"));
55  strm->state = (struct internal_state FAR *)state;
56  state->dmax = 32768U;
57  state->wbits = windowBits;
58  state->wsize = 1U << windowBits;
59  state->window = window;
60  state->wnext = 0;
61  state->whave = 0;
62  return Z_OK;
63 }
voidpf
Byte FAR * voidpf
Definition: zconf.h:355
inflate_state
Definition: inflate.h:83
internal_state::window
Bytef * window
Definition: deflate.h:115
inflate_state::wnext
unsigned wnext
Definition: inflate.h:97
inflate_state::wsize
unsigned wsize
Definition: inflate.h:95
Tracev
#define Tracev(x)
Definition: zutil.h:270
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:185
ZALLOC
#define ZALLOC(strm, items, size)
Definition: zutil.h:281
setup.version
string version
Definition: setup.py:63
Z_MEM_ERROR
#define Z_MEM_ERROR
Definition: zlib.h:187
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:48
inflate_state::dmax
unsigned dmax
Definition: inflate.h:89
Z_VERSION_ERROR
#define Z_VERSION_ERROR
Definition: zlib.h:189
internal_state
Definition: deflate.h:96
inflate_state::window
unsigned char FAR * window
Definition: inflate.h:98
Z_OK
#define Z_OK
Definition: zlib.h:181
Z_NULL
#define Z_NULL
Definition: zlib.h:216
inflate_state::whave
unsigned whave
Definition: inflate.h:96
FAR
#define FAR
Definition: zconf.h:329
zcalloc
voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:300
inflate_state::wbits
unsigned wbits
Definition: inflate.h:94
z_stream_s
Definition: zlib.h:93
zcfree
void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:307
ABC_NAMESPACE_IMPL_START local void fixedtables OF ( (struct inflate_state FAR *state)  )