ReactOS  0.4.14-dev-317-g96040ec
gzlib.c File Reference
#include "gzguts.h"
Include dependency graph for gzlib.c:

Go to the source code of this file.

Macros

#define LSEEK   lseek
 

Functions

void gz_reset OF ((gz_statep))
 
gzFile gz_open OF ((const void *, int, const char *))
 
void gz_reset (gz_statep state)
 
gzFile gz_open (void *path, int fd, const char *mode) const
 
gzFile ZEXPORT gzopen (char *path, const char *mode) const
 
gzFile ZEXPORT gzopen64 (char *path, const char *mode) const
 
gzFile ZEXPORT gzdopen (int fd, const char *mode)
 
int ZEXPORT gzbuffer (gzFile file, unsigned size)
 
int ZEXPORT gzrewind (gzFile file)
 
z_off64_t ZEXPORT gzseek64 (gzFile file, z_off64_t offset, int whence)
 
z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence)
 
z_off64_t ZEXPORT gztell64 (gzFile file)
 
z_off_t ZEXPORT gztell (gzFile file)
 
z_off64_t ZEXPORT gzoffset64 (gzFile file)
 
z_off_t ZEXPORT gzoffset (gzFile file)
 
int ZEXPORT gzeof (gzFile file)
 
const char *ZEXPORT gzerror (gzFile file, int *errnum)
 
void ZEXPORT gzclearerr (gzFile file)
 
void ZLIB_INTERNAL gz_error (gz_statep state, int err, const char *msg)
 
unsigned ZLIB_INTERNAL gz_intmax ()
 

Macro Definition Documentation

◆ LSEEK

#define LSEEK   lseek

Definition at line 14 of file gzlib.c.

Function Documentation

◆ gz_error()

void ZLIB_INTERNAL gz_error ( gz_statep  state,
int  err,
const char msg 
)

Definition at line 579 of file gzlib.c.

583 {
584  /* free previously allocated message and clear */
585  if (state->msg != NULL) {
586  if (state->err != Z_MEM_ERROR)
587  free(state->msg);
588  state->msg = NULL;
589  }
590 
591  /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
592  if (err != Z_OK && err != Z_BUF_ERROR)
593  state->x.have = 0;
594 
595  /* set error code, and if no message, then done */
596  state->err = err;
597  if (msg == NULL)
598  return;
599 
600  /* for an out of memory error, return literal string when requested */
601  if (err == Z_MEM_ERROR)
602  return;
603 
604  /* construct error message with path */
605  if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
606  NULL) {
607  state->err = Z_MEM_ERROR;
608  return;
609  }
610 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
611  (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
612  "%s%s%s", state->path, ": ", msg);
613 #else
614  strcpy(state->msg, state->path);
615  strcat(state->msg, ": ");
616  strcat(state->msg, msg);
617 #endif
618 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define free
Definition: debug_ros.c:5
#define snprintf
Definition: wintirpc.h:48
#define Z_BUF_ERROR
Definition: zlib.h:184
#define Z_OK
Definition: zlib.h:177
smooth NULL
Definition: ftsmooth.c:416
static int state
Definition: maze.c:121
#define err(...)
#define msg(x)
Definition: auth_time.c:54
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define malloc
Definition: debug_ros.c:4
#define Z_MEM_ERROR
Definition: zlib.h:183

Referenced by gz_comp(), gz_decomp(), gz_init(), gz_load(), gz_look(), gz_reset(), gzclearerr(), gzclose_r(), gzclose_w(), gzfread(), gzfwrite(), gzread(), gzseek64(), gzungetc(), and gzwrite().

◆ gz_intmax()

unsigned ZLIB_INTERNAL gz_intmax ( )

Definition at line 625 of file gzlib.c.

626 {
627  unsigned p, q;
628 
629  p = 1;
630  do {
631  q = p;
632  p <<= 1;
633  p++;
634  } while (p > q);
635  return q >> 1;
636 }
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLfloat GLfloat p
Definition: glext.h:8902

◆ gz_open()

gzFile gz_open ( void path,
int  fd,
const char mode 
) const

Definition at line 91 of file gzlib.c.

95 {
97  z_size_t len;
98  int oflag;
99 #ifdef O_CLOEXEC
100  int cloexec = 0;
101 #endif
102 #ifdef O_EXCL
103  int exclusive = 0;
104 #endif
105 
106  /* check input */
107  if (path == NULL)
108  return NULL;
109 
110  /* allocate gzFile structure to return */
111  state = (gz_statep)malloc(sizeof(gz_state));
112  if (state == NULL)
113  return NULL;
114  state->size = 0; /* no buffers allocated yet */
115  state->want = GZBUFSIZE; /* requested buffer size */
116  state->msg = NULL; /* no error message yet */
117 
118  /* interpret mode */
119  state->mode = GZ_NONE;
120  state->level = Z_DEFAULT_COMPRESSION;
121  state->strategy = Z_DEFAULT_STRATEGY;
122  state->direct = 0;
123  while (*mode) {
124  if (*mode >= '0' && *mode <= '9')
125  state->level = *mode - '0';
126  else
127  switch (*mode) {
128  case 'r':
129  state->mode = GZ_READ;
130  break;
131 #ifndef NO_GZCOMPRESS
132  case 'w':
133  state->mode = GZ_WRITE;
134  break;
135  case 'a':
136  state->mode = GZ_APPEND;
137  break;
138 #endif
139  case '+': /* can't read and write at the same time */
140  free(state);
141  return NULL;
142  case 'b': /* ignore -- will request binary anyway */
143  break;
144 #ifdef O_CLOEXEC
145  case 'e':
146  cloexec = 1;
147  break;
148 #endif
149 #ifdef O_EXCL
150  case 'x':
151  exclusive = 1;
152  break;
153 #endif
154  case 'f':
155  state->strategy = Z_FILTERED;
156  break;
157  case 'h':
158  state->strategy = Z_HUFFMAN_ONLY;
159  break;
160  case 'R':
161  state->strategy = Z_RLE;
162  break;
163  case 'F':
164  state->strategy = Z_FIXED;
165  break;
166  case 'T':
167  state->direct = 1;
168  break;
169  default: /* could consider as an error, but just ignore */
170  ;
171  }
172  mode++;
173  }
174 
175  /* must provide an "r", "w", or "a" */
176  if (state->mode == GZ_NONE) {
177  free(state);
178  return NULL;
179  }
180 
181  /* can't force transparent read */
182  if (state->mode == GZ_READ) {
183  if (state->direct) {
184  free(state);
185  return NULL;
186  }
187  state->direct = 1; /* for empty file */
188  }
189 
190  /* save the path name for error messages */
191 #ifdef WIDECHAR
192  if (fd == -2) {
193  len = wcstombs(NULL, path, 0);
194  if (len == (z_size_t)-1)
195  len = 0;
196  }
197  else
198 #endif
199  len = strlen((const char *)path);
200  state->path = (char *)malloc(len + 1);
201  if (state->path == NULL) {
202  free(state);
203  return NULL;
204  }
205 #ifdef WIDECHAR
206  if (fd == -2)
207  if (len)
208  wcstombs(state->path, path, len + 1);
209  else
210  *(state->path) = 0;
211  else
212 #endif
213 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
214  (void)snprintf(state->path, len + 1, "%s", (const char *)path);
215 #else
216  strcpy(state->path, path);
217 #endif
218 
219  /* compute the flags for open() */
220  oflag =
221 #ifdef O_LARGEFILE
222  O_LARGEFILE |
223 #endif
224 #ifdef O_BINARY
225  O_BINARY |
226 #endif
227 #ifdef O_CLOEXEC
228  (cloexec ? O_CLOEXEC : 0) |
229 #endif
230  (state->mode == GZ_READ ?
231  O_RDONLY :
232  (O_WRONLY | O_CREAT |
233 #ifdef O_EXCL
234  (exclusive ? O_EXCL : 0) |
235 #endif
236  (state->mode == GZ_WRITE ?
237  O_TRUNC :
238  O_APPEND)));
239 
240  /* open the file with the appropriate flags (or just use fd) */
241  state->fd = fd > -1 ? fd : (
242 #ifdef WIDECHAR
243  fd == -2 ? _wopen(path, oflag, 0666) :
244 #endif
245  open((const char *)path, oflag, 0666));
246  if (state->fd == -1) {
247  free(state->path);
248  free(state);
249  return NULL;
250  }
251  if (state->mode == GZ_APPEND) {
252  LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
253  state->mode = GZ_WRITE; /* simplify later checks */
254  }
255 
256  /* save the current position for rewinding (only if reading) */
257  if (state->mode == GZ_READ) {
258  state->start = LSEEK(state->fd, 0, SEEK_CUR);
259  if (state->start == -1) state->start = 0;
260  }
261 
262  /* initialize stream */
263  gz_reset(state);
264 
265  /* return stream */
266  return (gzFile)state;
267 }
unsigned long z_size_t
Definition: zconf.h:250
#define SEEK_CUR
Definition: util.h:63
#define Z_HUFFMAN_ONLY
Definition: zlib.h:197
_CRTIMP int __cdecl _wopen(const wchar_t *_Filename, int _OpenFlag,...)
Definition: file.c:2020
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define open
Definition: acwin.h:95
#define GZ_NONE
Definition: gzguts.h:159
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLsizei const GLchar ** path
Definition: glext.h:7234
#define free
Definition: debug_ros.c:5
#define GZ_APPEND
Definition: gzguts.h:162
#define GZ_READ
Definition: gzguts.h:160
#define snprintf
Definition: wintirpc.h:48
static int fd
Definition: io.c:51
#define Z_DEFAULT_STRATEGY
Definition: zlib.h:200
#define O_WRONLY
Definition: acwin.h:111
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
#define Z_DEFAULT_COMPRESSION
Definition: zlib.h:193
#define O_EXCL
Definition: fcntl.h:40
#define GZ_WRITE
Definition: gzguts.h:161
#define LSEEK
Definition: gzlib.c:14
#define Z_FILTERED
Definition: zlib.h:196
#define O_LARGEFILE
Definition: port.h:154
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
#define O_TRUNC
Definition: acwin.h:112
GLenum mode
Definition: glext.h:6217
#define GZBUFSIZE
Definition: gzguts.h:156
#define O_BINARY
Definition: acwin.h:109
Definition: services.c:325
gz_state FAR * gz_statep
Definition: gzguts.h:202
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define const
Definition: zconf.h:230
#define SEEK_END
Definition: cabinet.c:27
#define Z_FIXED
Definition: zlib.h:199
#define malloc
Definition: debug_ros.c:4
#define Z_RLE
Definition: zlib.h:198
size_t __cdecl wcstombs(_Out_writes_opt_z_(_MaxCount) char *_Dest, _In_z_ const wchar_t *_Source, _In_ size_t _MaxCount)
#define O_CREAT
Definition: acwin.h:110
void gz_reset(gz_statep state)
Definition: gzlib.c:75
#define O_APPEND
Definition: fcntl.h:37
#define O_RDONLY
Definition: acwin.h:108

Referenced by gzdopen(), gzopen(), and gzopen64().

◆ gz_reset()

void gz_reset ( gz_statep  state)

Definition at line 75 of file gzlib.c.

77 {
78  state->x.have = 0; /* no output data available */
79  if (state->mode == GZ_READ) { /* for reading ... */
80  state->eof = 0; /* not at end of file */
81  state->past = 0; /* have not read past end yet */
82  state->how = LOOK; /* look for gzip header */
83  }
84  state->seek = 0; /* no seek request pending */
85  gz_error(state, Z_OK, NULL); /* clear error */
86  state->x.pos = 0; /* no uncompressed data yet */
87  state->strm.avail_in = 0; /* no input data yet */
88 }
#define GZ_READ
Definition: gzguts.h:160
#define Z_OK
Definition: zlib.h:177
smooth NULL
Definition: ftsmooth.c:416
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:579
static int state
Definition: maze.c:121
#define LOOK
Definition: gzguts.h:165

Referenced by gz_open(), and gzrewind().

◆ gzbuffer()

int ZEXPORT gzbuffer ( gzFile  file,
unsigned  size 
)

Definition at line 316 of file gzlib.c.

319 {
321 
322  /* get internal structure and check integrity */
323  if (file == NULL)
324  return -1;
325  state = (gz_statep)file;
326  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
327  return -1;
328 
329  /* make sure we haven't already allocated memory */
330  if (state->size != 0)
331  return -1;
332 
333  /* check and set requested size */
334  if ((size << 1) < size)
335  return -1; /* need to be able to double it */
336  if (size < 2)
337  size = 2; /* need two bytes to check magic header */
338  state->want = size;
339  return 0;
340 }
#define GZ_READ
Definition: gzguts.h:160
smooth NULL
Definition: ftsmooth.c:416
#define GZ_WRITE
Definition: gzguts.h:161
GLsizeiptr size
Definition: glext.h:5919
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

◆ gzclearerr()

void ZEXPORT gzclearerr ( gzFile  file)

Definition at line 553 of file gzlib.c.

555 {
557 
558  /* get internal structure and check integrity */
559  if (file == NULL)
560  return;
561  state = (gz_statep)file;
562  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
563  return;
564 
565  /* clear error and end-of-file */
566  if (state->mode == GZ_READ) {
567  state->eof = 0;
568  state->past = 0;
569  }
570  gz_error(state, Z_OK, NULL);
571 }
#define GZ_READ
Definition: gzguts.h:160
#define Z_OK
Definition: zlib.h:177
smooth NULL
Definition: ftsmooth.c:416
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:579
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

◆ gzdopen()

gzFile ZEXPORT gzdopen ( int  fd,
const char mode 
)

Definition at line 286 of file gzlib.c.

289 {
290  char *path; /* identifier for error messages */
291  gzFile gz;
292 
293  if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
294  return NULL;
295 #if !defined(NO_snprintf) && !defined(NO_vsnprintf)
296  (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
297 #else
298  sprintf(path, "<fd:%d>", fd); /* for debugging */
299 #endif
300  gz = gz_open(path, fd, mode);
301  free(path);
302  return gz;
303 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
GLsizei const GLchar ** path
Definition: glext.h:7234
#define free
Definition: debug_ros.c:5
#define snprintf
Definition: wintirpc.h:48
static int fd
Definition: io.c:51
#define sprintf(buf, format,...)
Definition: sprintf.c:55
gzFile gz_open(void *path, int fd, const char *mode) const
Definition: gzlib.c:91
smooth NULL
Definition: ftsmooth.c:416
GLenum mode
Definition: glext.h:6217
Definition: services.c:325
#define malloc
Definition: debug_ros.c:4

◆ gzeof()

int ZEXPORT gzeof ( gzFile  file)

Definition at line 515 of file gzlib.c.

517 {
519 
520  /* get internal structure and check integrity */
521  if (file == NULL)
522  return 0;
523  state = (gz_statep)file;
524  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
525  return 0;
526 
527  /* return end-of-file state */
528  return state->mode == GZ_READ ? state->past : 0;
529 }
#define GZ_READ
Definition: gzguts.h:160
smooth NULL
Definition: ftsmooth.c:416
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

◆ gzerror()

const char* ZEXPORT gzerror ( gzFile  file,
int errnum 
)

Definition at line 532 of file gzlib.c.

535 {
537 
538  /* get internal structure and check integrity */
539  if (file == NULL)
540  return NULL;
541  state = (gz_statep)file;
542  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
543  return NULL;
544 
545  /* return error information */
546  if (errnum != NULL)
547  *errnum = state->err;
548  return state->err == Z_MEM_ERROR ? "out of memory" :
549  (state->msg == NULL ? "" : state->msg);
550 }
#define GZ_READ
Definition: gzguts.h:160
smooth NULL
Definition: ftsmooth.c:416
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
#define Z_MEM_ERROR
Definition: zlib.h:183
Definition: fci.c:126

◆ gzoffset()

z_off_t ZEXPORT gzoffset ( gzFile  file)

Definition at line 505 of file gzlib.c.

507 {
508  z_off64_t ret;
509 
510  ret = gzoffset64(file);
511  return ret == (z_off_t)ret ? (z_off_t)ret : -1;
512 }
#define z_off_t
Definition: zconf.h:504
z_off64_t ZEXPORT gzoffset64(gzFile file)
Definition: gzlib.c:482
#define z_off64_t
Definition: zconf.h:513
int ret
Definition: fci.c:126

◆ gzoffset64()

z_off64_t ZEXPORT gzoffset64 ( gzFile  file)

Definition at line 482 of file gzlib.c.

484 {
487 
488  /* get internal structure and check integrity */
489  if (file == NULL)
490  return -1;
491  state = (gz_statep)file;
492  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
493  return -1;
494 
495  /* compute and return effective offset in file */
496  offset = LSEEK(state->fd, 0, SEEK_CUR);
497  if (offset == -1)
498  return -1;
499  if (state->mode == GZ_READ) /* reading */
500  offset -= state->strm.avail_in; /* don't count buffered input */
501  return offset;
502 }
#define SEEK_CUR
Definition: util.h:63
GLintptr offset
Definition: glext.h:5920
#define GZ_READ
Definition: gzguts.h:160
#define z_off64_t
Definition: zconf.h:513
smooth NULL
Definition: ftsmooth.c:416
#define GZ_WRITE
Definition: gzguts.h:161
#define LSEEK
Definition: gzlib.c:14
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

Referenced by gzoffset().

◆ gzopen()

gzFile ZEXPORT gzopen ( char path,
const char mode 
) const

Definition at line 270 of file gzlib.c.

273 {
274  return gz_open(path, -1, mode);
275 }
gzFile gz_open(void *path, int fd, const char *mode) const
Definition: gzlib.c:91
GLenum mode
Definition: glext.h:6217
Definition: services.c:325

◆ gzopen64()

gzFile ZEXPORT gzopen64 ( char path,
const char mode 
) const

Definition at line 278 of file gzlib.c.

281 {
282  return gz_open(path, -1, mode);
283 }
gzFile gz_open(void *path, int fd, const char *mode) const
Definition: gzlib.c:91
GLenum mode
Definition: glext.h:6217
Definition: services.c:325

◆ gzrewind()

int ZEXPORT gzrewind ( gzFile  file)

Definition at line 343 of file gzlib.c.

345 {
347 
348  /* get internal structure */
349  if (file == NULL)
350  return -1;
351  state = (gz_statep)file;
352 
353  /* check that we're reading and that there's no error */
354  if (state->mode != GZ_READ ||
355  (state->err != Z_OK && state->err != Z_BUF_ERROR))
356  return -1;
357 
358  /* back up and start over */
359  if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
360  return -1;
361  gz_reset(state);
362  return 0;
363 }
#define GZ_READ
Definition: gzguts.h:160
#define Z_BUF_ERROR
Definition: zlib.h:184
#define Z_OK
Definition: zlib.h:177
smooth NULL
Definition: ftsmooth.c:416
#define SEEK_SET
Definition: jmemansi.c:26
#define LSEEK
Definition: gzlib.c:14
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
void gz_reset(gz_statep state)
Definition: gzlib.c:75
Definition: fci.c:126

Referenced by gzseek64().

◆ gzseek()

z_off_t ZEXPORT gzseek ( gzFile  file,
z_off_t  offset,
int  whence 
)

Definition at line 443 of file gzlib.c.

447 {
448  z_off64_t ret;
449 
450  ret = gzseek64(file, (z_off64_t)offset, whence);
451  return ret == (z_off_t)ret ? (z_off_t)ret : -1;
452 }
#define z_off_t
Definition: zconf.h:504
GLintptr offset
Definition: glext.h:5920
#define z_off64_t
Definition: zconf.h:513
int ret
z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence)
Definition: gzlib.c:366
Definition: fci.c:126

◆ gzseek64()

z_off64_t ZEXPORT gzseek64 ( gzFile  file,
z_off64_t  offset,
int  whence 
)

Definition at line 366 of file gzlib.c.

370 {
371  unsigned n;
372  z_off64_t ret;
374 
375  /* get internal structure and check integrity */
376  if (file == NULL)
377  return -1;
378  state = (gz_statep)file;
379  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
380  return -1;
381 
382  /* check that there's no error */
383  if (state->err != Z_OK && state->err != Z_BUF_ERROR)
384  return -1;
385 
386  /* can only seek from start or relative to current position */
387  if (whence != SEEK_SET && whence != SEEK_CUR)
388  return -1;
389 
390  /* normalize offset to a SEEK_CUR specification */
391  if (whence == SEEK_SET)
392  offset -= state->x.pos;
393  else if (state->seek)
394  offset += state->skip;
395  state->seek = 0;
396 
397  /* if within raw area while reading, just go there */
398  if (state->mode == GZ_READ && state->how == COPY &&
399  state->x.pos + offset >= 0) {
400  ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
401  if (ret == -1)
402  return -1;
403  state->x.have = 0;
404  state->eof = 0;
405  state->past = 0;
406  state->seek = 0;
407  gz_error(state, Z_OK, NULL);
408  state->strm.avail_in = 0;
409  state->x.pos += offset;
410  return state->x.pos;
411  }
412 
413  /* calculate skip amount, rewinding if needed for back seek when reading */
414  if (offset < 0) {
415  if (state->mode != GZ_READ) /* writing -- can't go backwards */
416  return -1;
417  offset += state->x.pos;
418  if (offset < 0) /* before start of file! */
419  return -1;
420  if (gzrewind(file) == -1) /* rewind, then skip to offset */
421  return -1;
422  }
423 
424  /* if reading, skip what's in output buffer (one less gzgetc() check) */
425  if (state->mode == GZ_READ) {
426  n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
427  (unsigned)offset : state->x.have;
428  state->x.have -= n;
429  state->x.next += n;
430  state->x.pos += n;
431  offset -= n;
432  }
433 
434  /* request skip (if not zero) */
435  if (offset) {
436  state->seek = 1;
437  state->skip = offset;
438  }
439  return state->x.pos + offset;
440 }
#define SEEK_CUR
Definition: util.h:63
#define COPY(len)
Definition: rtl.c:274
GLintptr offset
Definition: glext.h:5920
#define GT_OFF(x)
Definition: gzguts.h:217
GLdouble n
Definition: glext.h:7729
#define GZ_READ
Definition: gzguts.h:160
#define z_off64_t
Definition: zconf.h:513
#define Z_BUF_ERROR
Definition: zlib.h:184
int ZEXPORT gzrewind(gzFile file)
Definition: gzlib.c:343
#define Z_OK
Definition: zlib.h:177
smooth NULL
Definition: ftsmooth.c:416
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:579
#define SEEK_SET
Definition: jmemansi.c:26
#define GZ_WRITE
Definition: gzguts.h:161
#define LSEEK
Definition: gzlib.c:14
int ret
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

Referenced by gzseek().

◆ gztell()

z_off_t ZEXPORT gztell ( gzFile  file)

Definition at line 472 of file gzlib.c.

474 {
475  z_off64_t ret;
476 
477  ret = gztell64(file);
478  return ret == (z_off_t)ret ? (z_off_t)ret : -1;
479 }
#define z_off_t
Definition: zconf.h:504
#define z_off64_t
Definition: zconf.h:513
z_off64_t ZEXPORT gztell64(gzFile file)
Definition: gzlib.c:455
int ret
Definition: fci.c:126

◆ gztell64()

z_off64_t ZEXPORT gztell64 ( gzFile  file)

Definition at line 455 of file gzlib.c.

457 {
459 
460  /* get internal structure and check integrity */
461  if (file == NULL)
462  return -1;
463  state = (gz_statep)file;
464  if (state->mode != GZ_READ && state->mode != GZ_WRITE)
465  return -1;
466 
467  /* return position */
468  return state->x.pos + (state->seek ? state->skip : 0);
469 }
#define GZ_READ
Definition: gzguts.h:160
smooth NULL
Definition: ftsmooth.c:416
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
gz_state FAR * gz_statep
Definition: gzguts.h:202
Definition: fci.c:126

Referenced by gztell().

◆ OF() [1/2]

void gz_reset OF ( (gz_statep )

◆ OF() [2/2]

gzFile gz_open OF ( (const void *, int, const char *)  )