Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gzread.cc File Reference
#include "gzguts.h"
Include dependency graph for gzread.cc:

Go to the source code of this file.

Functions

local int gz_load OF ((gz_statep, unsigned char *, unsigned, unsigned *))
 
local int gz_avail OF ((gz_statep))
 
local int gz_skip OF ((gz_statep, z_off64_t))
 
local int gz_load (gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
 
local int gz_avail (gz_statep state)
 
local int gz_look (gz_statep state)
 
local int gz_decomp (gz_statep state)
 
local int gz_fetch (gz_statep state)
 
local int gz_skip (gz_statep state, z_off64_t len)
 
int ZEXPORT gzread (gzFile file, voidp buf, unsigned len)
 
int ZEXPORT gzgetc (gzFile file)
 
int ZEXPORT gzgetc_ (gzFile file)
 
int ZEXPORT gzungetc (int c, gzFile file)
 
char *ZEXPORT gzgets (gzFile file, char *buf, int len)
 
int ZEXPORT gzdirect (gzFile file)
 
int ZEXPORT gzclose_r (gzFile file)
 

Function Documentation

local int gz_avail ( gz_statep  state)

Definition at line 47 of file gzread.cc.

48 {
49  unsigned got;
50  z_streamp strm = &(state->strm);
51 
52  if (state->err != Z_OK && state->err != Z_BUF_ERROR)
53  return -1;
54  if (state->eof == 0) {
55  if (strm->avail_in) { /* copy what's there to the start */
56  unsigned char *p = state->in;
57  unsigned const char *q = strm->next_in;
58  unsigned n = strm->avail_in;
59  do {
60  *p++ = *q++;
61  } while (--n);
62  }
63  if (gz_load(state, state->in + strm->avail_in,
64  state->size - strm->avail_in, &got) == -1)
65  return -1;
66  strm->avail_in += got;
67  strm->next_in = state->in;
68  }
69  return 0;
70 }
const char * p
Definition: xmltok.h:285
local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
Definition: gzread.cc:20
z_streamp strm
Definition: deflate.h:98
const G4int n
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
z_stream FAR * z_streamp
Definition: zlib.h:106

Here is the call graph for this function:

Here is the caller graph for this function:

local int gz_decomp ( gz_statep  state)

Definition at line 166 of file gzread.cc.

167 {
168  int ret = Z_OK;
169  unsigned had;
170  z_streamp strm = &(state->strm);
171 
172  /* fill output buffer up to end of deflate stream */
173  had = strm->avail_out;
174  do {
175  /* get more input for inflate() */
176  if (strm->avail_in == 0 && gz_avail(state) == -1)
177  return -1;
178  if (strm->avail_in == 0) {
179  gz_error(state, Z_BUF_ERROR, "unexpected end of file");
180  break;
181  }
182 
183  /* decompress and handle errors */
184  ret = inflate(strm, Z_NO_FLUSH);
185  if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
186  gz_error(state, Z_STREAM_ERROR,
187  "internal error: inflate stream corrupt");
188  return -1;
189  }
190  if (ret == Z_MEM_ERROR) {
191  gz_error(state, Z_MEM_ERROR, "out of memory");
192  return -1;
193  }
194  if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
195  gz_error(state, Z_DATA_ERROR,
196  strm->msg == NULL ? "compressed data error" : strm->msg);
197  return -1;
198  }
199  } while (strm->avail_out && ret != Z_STREAM_END);
200 
201  /* update available output */
202  state->x.have = had - strm->avail_out;
203  state->x.next = strm->next_out - state->x.have;
204 
205  /* if the gzip stream completed successfully, look for another */
206  if (ret == Z_STREAM_END)
207  state->how = LOOK;
208 
209  /* good decompression */
210  return 0;
211 }
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
#define Z_NO_FLUSH
Definition: zlib.h:164
#define Z_NEED_DICT
Definition: zlib.h:175
#define Z_STREAM_ERROR
Definition: zlib.h:177
z_streamp strm
Definition: deflate.h:98
#define Z_DATA_ERROR
Definition: zlib.h:178
#define Z_STREAM_END
Definition: zlib.h:174
#define Z_MEM_ERROR
Definition: zlib.h:179
#define LOOK
Definition: gzguts.h:156
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
z_stream FAR * z_streamp
Definition: zlib.h:106
int ZEXPORT inflate(z_streamp strm, int flush)
Definition: inflate.cc:587
local int gz_avail(gz_statep state)
Definition: gzread.cc:47

Here is the call graph for this function:

Here is the caller graph for this function:

local int gz_fetch ( gz_statep  state)

Definition at line 219 of file gzread.cc.

220 {
221  z_streamp strm = &(state->strm);
222 
223  do {
224  switch(state->how) {
225  case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
226  if (gz_look(state) == -1)
227  return -1;
228  if (state->how == LOOK)
229  return 0;
230  break;
231  case COPY: /* -> COPY */
232  if (gz_load(state, state->out, state->size << 1, &(state->x.have))
233  == -1)
234  return -1;
235  state->x.next = state->out;
236  return 0;
237  case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */
238  strm->avail_out = state->size << 1;
239  strm->next_out = state->out;
240  if (gz_decomp(state) == -1)
241  return -1;
242  }
243  } while (state->x.have == 0 && (!state->eof || strm->avail_in));
244  return 0;
245 }
Definition: inflate.h:36
local int gz_decomp(gz_statep state)
Definition: gzread.cc:166
local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
Definition: gzread.cc:20
local int gz_look(gz_statep state)
Definition: gzread.cc:81
z_streamp strm
Definition: deflate.h:98
#define LOOK
Definition: gzguts.h:156
z_stream FAR * z_streamp
Definition: zlib.h:106
#define GZIP
Definition: deflate.h:23

Here is the call graph for this function:

Here is the caller graph for this function:

local int gz_load ( gz_statep  state,
unsigned char *  buf,
unsigned  len,
unsigned *  have 
)

Definition at line 20 of file gzread.cc.

21 {
22  int ret;
23 
24  *have = 0;
25  do {
26  ret = read(state->fd, buf + *have, len - *have);
27  if (ret <= 0)
28  break;
29  *have += ret;
30  } while (*have < len);
31  if (ret < 0) {
32  gz_error(state, Z_ERRNO, zstrerror());
33  return -1;
34  }
35  if (ret == 0)
36  state->eof = 1;
37  return 0;
38 }
const XML_Char int len
Definition: expat.h:262
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
#define Z_ERRNO
Definition: zlib.h:176
#define zstrerror()
Definition: gzguts.h:124

Here is the call graph for this function:

Here is the caller graph for this function:

local int gz_look ( gz_statep  state)

Definition at line 81 of file gzread.cc.

82 {
83  z_streamp strm = &(state->strm);
84 
85  /* allocate read buffers and inflate memory */
86  if (state->size == 0) {
87  /* allocate buffers */
88  state->in = (unsigned char *)malloc(state->want);
89  state->out = (unsigned char *)malloc(state->want << 1);
90  if (state->in == NULL || state->out == NULL) {
91  if (state->out != NULL)
92  free(state->out);
93  if (state->in != NULL)
94  free(state->in);
95  gz_error(state, Z_MEM_ERROR, "out of memory");
96  return -1;
97  }
98  state->size = state->want;
99 
100  /* allocate inflate memory */
101  state->strm.zalloc = Z_NULL;
102  state->strm.zfree = Z_NULL;
103  state->strm.opaque = Z_NULL;
104  state->strm.avail_in = 0;
105  state->strm.next_in = Z_NULL;
106  if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */
107  free(state->out);
108  free(state->in);
109  state->size = 0;
110  gz_error(state, Z_MEM_ERROR, "out of memory");
111  return -1;
112  }
113  }
114 
115  /* get at least the magic bytes in the input buffer */
116  if (strm->avail_in < 2) {
117  if (gz_avail(state) == -1)
118  return -1;
119  if (strm->avail_in == 0)
120  return 0;
121  }
122 
123  /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
124  a logical dilemma here when considering the case of a partially written
125  gzip file, to wit, if a single 31 byte is written, then we cannot tell
126  whether this is a single-byte file, or just a partially written gzip
127  file -- for here we assume that if a gzip file is being written, then
128  the header will be written in a single operation, so that reading a
129  single byte is sufficient indication that it is not a gzip file) */
130  if (strm->avail_in > 1 &&
131  strm->next_in[0] == 31 && strm->next_in[1] == 139) {
132  inflateReset(strm);
133  state->how = GZIP;
134  state->direct = 0;
135  return 0;
136  }
137 
138  /* no gzip header -- if we were decoding gzip before, then this is trailing
139  garbage. Ignore the trailing garbage and finish. */
140  if (state->direct == 0) {
141  strm->avail_in = 0;
142  state->eof = 1;
143  state->x.have = 0;
144  return 0;
145  }
146 
147  /* doing raw i/o, copy any leftover input to output -- this assumes that
148  the output buffer is larger than the input buffer, which also assures
149  space for gzungetc() */
150  state->x.next = state->out;
151  if (strm->avail_in) {
152  memcpy(state->x.next, strm->next_in, strm->avail_in);
153  state->x.have = strm->avail_in;
154  strm->avail_in = 0;
155  }
156  state->how = COPY;
157  state->direct = 1;
158  return 0;
159 }
Definition: inflate.h:36
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
#define inflateInit2(strm, windowBits)
Definition: zlib.h:1654
z_streamp strm
Definition: deflate.h:98
#define Z_MEM_ERROR
Definition: zlib.h:179
#define Z_OK
Definition: zlib.h:173
#define Z_NULL
Definition: zlib.h:208
z_stream FAR * z_streamp
Definition: zlib.h:106
local int gz_avail(gz_statep state)
Definition: gzread.cc:47
#define GZIP
Definition: deflate.h:23
int ZEXPORT inflateReset(z_streamp strm)
Definition: inflate.cc:128

Here is the call graph for this function:

Here is the caller graph for this function:

local int gz_skip ( gz_statep  state,
z_off64_t  len 
)

Definition at line 248 of file gzread.cc.

249 {
250  unsigned n;
251 
252  /* skip over len bytes or reach end-of-file, whichever comes first */
253  while (len)
254  /* skip over whatever is in output buffer */
255  if (state->x.have) {
256  n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
257  (unsigned)len : state->x.have;
258  state->x.have -= n;
259  state->x.next += n;
260  state->x.pos += n;
261  len -= n;
262  }
263 
264  /* output buffer empty -- return if we're at the end of the input */
265  else if (state->eof && state->strm.avail_in == 0)
266  break;
267 
268  /* need more data to skip -- load up output buffer */
269  else {
270  /* get more output, looking for header if required */
271  if (gz_fetch(state) == -1)
272  return -1;
273  }
274  return 0;
275 }
const XML_Char int len
Definition: expat.h:262
#define GT_OFF(x)
Definition: gzguts.h:208
local int gz_fetch(gz_statep state)
Definition: gzread.cc:219
const G4int n

Here is the call graph for this function:

Here is the caller graph for this function:

int ZEXPORT gzclose_r ( gzFile  file)

Definition at line 546 of file gzread.cc.

547 {
548  int ret, err;
549  gz_statep state;
550 
551  /* get internal structure */
552  if (file == NULL)
553  return Z_STREAM_ERROR;
554  state = (gz_statep)file;
555 
556  /* check that we're reading */
557  if (state->mode != GZ_READ)
558  return Z_STREAM_ERROR;
559 
560  /* free memory and close file */
561  if (state->size) {
562  inflateEnd(&(state->strm));
563  free(state->out);
564  free(state->in);
565  }
566  err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
567  gz_error(state, Z_OK, NULL);
568  free(state->path);
569  ret = close(state->fd);
570  free(state);
571  return ret ? Z_ERRNO : err;
572 }
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
#define Z_ERRNO
Definition: zlib.h:176
#define GZ_READ
Definition: gzguts.h:151
#define Z_STREAM_ERROR
Definition: zlib.h:177
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
gz_state FAR * gz_statep
Definition: gzguts.h:193
int ZEXPORT inflateEnd(z_streamp strm)
Definition: inflate.cc:1234

Here is the call graph for this function:

Here is the caller graph for this function:

int ZEXPORT gzdirect ( gzFile  file)

Definition at line 527 of file gzread.cc.

528 {
529  gz_statep state;
530 
531  /* get internal structure */
532  if (file == NULL)
533  return 0;
534  state = (gz_statep)file;
535 
536  /* if the state is not known, but we can find out, then do so (this is
537  mainly for right after a gzopen() or gzdopen()) */
538  if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
539  (void)gz_look(state);
540 
541  /* return 1 if transparent, 0 if processing a gzip stream */
542  return state->direct;
543 }
#define GZ_READ
Definition: gzguts.h:151
local int gz_look(gz_statep state)
Definition: gzread.cc:81
#define LOOK
Definition: gzguts.h:156
gz_state FAR * gz_statep
Definition: gzguts.h:193
typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData

Here is the call graph for this function:

int ZEXPORT gzgetc ( gzFile  file)

Definition at line 374 of file gzread.cc.

375 {
376  int ret;
377  unsigned char buf[1];
378  gz_statep state;
379 
380  /* get internal structure */
381  if (file == NULL)
382  return -1;
383  state = (gz_statep)file;
384 
385  /* check that we're reading and that there's no (serious) error */
386  if (state->mode != GZ_READ ||
387  (state->err != Z_OK && state->err != Z_BUF_ERROR))
388  return -1;
389 
390  /* try output buffer (no need to check for skip request) */
391  if (state->x.have) {
392  state->x.have--;
393  state->x.pos++;
394  return *(state->x.next)++;
395  }
396 
397  /* nothing there -- try gzread() */
398  ret = gzread(file, buf, 1);
399  return ret < 1 ? -1 : buf[0];
400 }
#define GZ_READ
Definition: gzguts.h:151
unsigned have
Definition: zlib.h:1671
int ZEXPORT gzread(gzFile file, voidp buf, unsigned len)
Definition: gzread.cc:278
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
gz_state FAR * gz_statep
Definition: gzguts.h:193

Here is the call graph for this function:

Here is the caller graph for this function:

int ZEXPORT gzgetc_ ( gzFile  file)

Definition at line 402 of file gzread.cc.

403 {
404  return gzgetc(file);
405 }
int ZEXPORT gzgetc(gzFile file)
Definition: gzread.cc:374

Here is the call graph for this function:

char* ZEXPORT gzgets ( gzFile  file,
char *  buf,
int  len 
)

Definition at line 466 of file gzread.cc.

467 {
468  unsigned left, n;
469  char *str;
470  unsigned char *eol;
471  gz_statep state;
472 
473  /* check parameters and get internal structure */
474  if (file == NULL || buf == NULL || len < 1)
475  return NULL;
476  state = (gz_statep)file;
477 
478  /* check that we're reading and that there's no (serious) error */
479  if (state->mode != GZ_READ ||
480  (state->err != Z_OK && state->err != Z_BUF_ERROR))
481  return NULL;
482 
483  /* process a skip request */
484  if (state->seek) {
485  state->seek = 0;
486  if (gz_skip(state, state->skip) == -1)
487  return NULL;
488  }
489 
490  /* copy output bytes up to new line or len - 1, whichever comes first --
491  append a terminating zero to the string (we don't check for a zero in
492  the contents, let the user worry about that) */
493  str = buf;
494  left = (unsigned)len - 1;
495  if (left) do {
496  /* assure that something is in the output buffer */
497  if (state->x.have == 0 && gz_fetch(state) == -1)
498  return NULL; /* error */
499  if (state->x.have == 0) { /* end of file */
500  state->past = 1; /* read past end */
501  break; /* return what we have */
502  }
503 
504  /* look for end-of-line in current output buffer */
505  n = state->x.have > left ? left : state->x.have;
506  eol = (unsigned char *)memchr(state->x.next, '\n', n);
507  if (eol != NULL)
508  n = (unsigned)(eol - state->x.next) + 1;
509 
510  /* copy through end-of-line, or remainder if not found */
511  memcpy(buf, state->x.next, n);
512  state->x.have -= n;
513  state->x.next += n;
514  state->x.pos += n;
515  left -= n;
516  buf += n;
517  } while (left && eol == NULL);
518 
519  /* return terminated string, or if nothing, end of file */
520  if (buf == str)
521  return NULL;
522  buf[0] = 0;
523  return str;
524 }
const XML_Char int len
Definition: expat.h:262
#define GZ_READ
Definition: gzguts.h:151
local int gz_fetch(gz_statep state)
Definition: gzread.cc:219
unsigned have
Definition: zlib.h:1671
const G4int n
local int gz_skip(gz_statep state, z_off64_t len)
Definition: gzread.cc:248
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
gz_state FAR * gz_statep
Definition: gzguts.h:193

Here is the call graph for this function:

int ZEXPORT gzread ( gzFile  file,
voidp  buf,
unsigned  len 
)

Definition at line 278 of file gzread.cc.

279 {
280  unsigned got, n;
281  gz_statep state;
282  z_streamp strm;
283 
284  /* get internal structure */
285  if (file == NULL)
286  return -1;
287  state = (gz_statep)file;
288  strm = &(state->strm);
289 
290  /* check that we're reading and that there's no (serious) error */
291  if (state->mode != GZ_READ ||
292  (state->err != Z_OK && state->err != Z_BUF_ERROR))
293  return -1;
294 
295  /* since an int is returned, make sure len fits in one, otherwise return
296  with an error (this avoids the flaw in the interface) */
297  if ((int)len < 0) {
298  gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
299  return -1;
300  }
301 
302  /* if len is zero, avoid unnecessary operations */
303  if (len == 0)
304  return 0;
305 
306  /* process a skip request */
307  if (state->seek) {
308  state->seek = 0;
309  if (gz_skip(state, state->skip) == -1)
310  return -1;
311  }
312 
313  /* get len bytes to buf, or less than len if at the end */
314  got = 0;
315  do {
316  /* first just try copying data from the output buffer */
317  if (state->x.have) {
318  n = state->x.have > len ? len : state->x.have;
319  memcpy(buf, state->x.next, n);
320  state->x.next += n;
321  state->x.have -= n;
322  }
323 
324  /* output buffer empty -- return if we're at the end of the input */
325  else if (state->eof && strm->avail_in == 0) {
326  state->past = 1; /* tried to read past end */
327  break;
328  }
329 
330  /* need output data -- for small len or new stream load up our output
331  buffer */
332  else if (state->how == LOOK || len < (state->size << 1)) {
333  /* get more output, looking for header if required */
334  if (gz_fetch(state) == -1)
335  return -1;
336  continue; /* no progress yet -- go back to copy above */
337  /* the copy above assures that we will leave with space in the
338  output buffer, allowing at least one gzungetc() to succeed */
339  }
340 
341  /* large len -- read directly into user buffer */
342  else if (state->how == COPY) { /* read directly */
343  if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
344  return -1;
345  }
346 
347  /* large len -- decompress directly into user buffer */
348  else { /* state->how == GZIP */
349  strm->avail_out = len;
350  strm->next_out = (unsigned char *)buf;
351  if (gz_decomp(state) == -1)
352  return -1;
353  n = state->x.have;
354  state->x.have = 0;
355  }
356 
357  /* update progress */
358  len -= n;
359  buf = (char *)buf + n;
360  got += n;
361  state->x.pos += n;
362  } while (len);
363 
364  /* return number of bytes read into user buffer (will fit in int) */
365  return (int)got;
366 }
const XML_Char int len
Definition: expat.h:262
Definition: inflate.h:36
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
local int gz_decomp(gz_statep state)
Definition: gzread.cc:166
#define GZ_READ
Definition: gzguts.h:151
local int gz_fetch(gz_statep state)
Definition: gzread.cc:219
local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
Definition: gzread.cc:20
z_streamp strm
Definition: deflate.h:98
#define Z_DATA_ERROR
Definition: zlib.h:178
const G4int n
#define LOOK
Definition: gzguts.h:156
local int gz_skip(gz_statep state, z_off64_t len)
Definition: gzread.cc:248
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
gz_state FAR * gz_statep
Definition: gzguts.h:193
z_stream FAR * z_streamp
Definition: zlib.h:106

Here is the call graph for this function:

Here is the caller graph for this function:

int ZEXPORT gzungetc ( int  c,
gzFile  file 
)

Definition at line 408 of file gzread.cc.

409 {
410  gz_statep state;
411 
412  /* get internal structure */
413  if (file == NULL)
414  return -1;
415  state = (gz_statep)file;
416 
417  /* check that we're reading and that there's no (serious) error */
418  if (state->mode != GZ_READ ||
419  (state->err != Z_OK && state->err != Z_BUF_ERROR))
420  return -1;
421 
422  /* process a skip request */
423  if (state->seek) {
424  state->seek = 0;
425  if (gz_skip(state, state->skip) == -1)
426  return -1;
427  }
428 
429  /* can't push EOF */
430  if (c < 0)
431  return -1;
432 
433  /* if output buffer empty, put byte at end (allows more pushing) */
434  if (state->x.have == 0) {
435  state->x.have = 1;
436  state->x.next = state->out + (state->size << 1) - 1;
437  state->x.next[0] = c;
438  state->x.pos--;
439  state->past = 0;
440  return c;
441  }
442 
443  /* if no room, give up (must have already done a gzungetc()) */
444  if (state->x.have == (state->size << 1)) {
445  gz_error(state, Z_DATA_ERROR, "out of room to push characters");
446  return -1;
447  }
448 
449  /* slide output data if needed and insert byte before existing data */
450  if (state->x.next == state->out) {
451  unsigned char *src = state->out + state->x.have;
452  unsigned char *dest = state->out + (state->size << 1);
453  while (src > state->out)
454  *--dest = *--src;
455  state->x.next = dest;
456  }
457  state->x.have++;
458  state->x.next--;
459  state->x.next[0] = c;
460  state->x.pos--;
461  state->past = 0;
462  return c;
463 }
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.cc:545
#define GZ_READ
Definition: gzguts.h:151
unsigned have
Definition: zlib.h:1671
#define Z_DATA_ERROR
Definition: zlib.h:178
local int gz_skip(gz_statep state, z_off64_t len)
Definition: gzread.cc:248
#define Z_BUF_ERROR
Definition: zlib.h:180
#define Z_OK
Definition: zlib.h:173
gz_state FAR * gz_statep
Definition: gzguts.h:193
tuple c
Definition: test.py:13

Here is the call graph for this function:

local int gz_load OF ( (gz_statep, unsigned char *, unsigned, unsigned *)  )
local int gz_skip OF ( (gz_statep, z_off64_t)  )