ReactOS  0.4.15-dev-5606-gf34e425
gzwrite.c File Reference
#include "gzguts.h"
Include dependency graph for gzwrite.c:

Go to the source code of this file.

Functions

int gz_init OF ((gz_statep))
 
int gz_comp OF ((gz_statep, int))
 
int gz_zero OF ((gz_statep, z_off64_t))
 
z_size_t gz_write OF ((gz_statep, voidpc, z_size_t))
 
int gz_init (gz_statep state)
 
int gz_comp (gz_statep state, int flush)
 
int gz_zero (gz_statep state, z_off64_t len)
 
z_size_t gz_write (gz_statep state, voidpc buf, z_size_t len)
 
int ZEXPORT gzwrite (gzFile file, voidpc buf, unsigned len)
 
z_size_t ZEXPORT gzfwrite (voidpc buf, z_size_t size, z_size_t nitems, gzFile file)
 
int ZEXPORT gzputc (gzFile file, int c)
 
int ZEXPORT gzputs (gzFile file, const char *s)
 
int ZEXPORTVA gzprintf (gzFile file, const char *format, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11, int a12, int a13, int a14, int a15, int a16, int a17, int a18, int a19, int a20)
 
int ZEXPORT gzflush (gzFile file, int flush)
 
int ZEXPORT gzsetparams (gzFile file, int level, int strategy)
 
int ZEXPORT gzclose_w (gzFile file)
 

Function Documentation

◆ gz_comp()

int gz_comp ( gz_statep  state,
int  flush 
)

Definition at line 73 of file gzwrite.c.

76 {
77  int ret, writ;
78  unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
79  z_streamp strm = &(state->strm);
80 
81  /* allocate memory if this is the first time through */
82  if (state->size == 0 && gz_init(state) == -1)
83  return -1;
84 
85  /* write directly if requested */
86  if (state->direct) {
87  while (strm->avail_in) {
88  put = strm->avail_in > max ? max : strm->avail_in;
89  writ = write(state->fd, strm->next_in, put);
90  if (writ < 0) {
92  return -1;
93  }
94  strm->avail_in -= (unsigned)writ;
95  strm->next_in += writ;
96  }
97  return 0;
98  }
99 
100  /* check for a pending reset */
101  if (state->reset) {
102  /* don't start a new gzip member unless there is data to write */
103  if (strm->avail_in == 0)
104  return 0;
106  state->reset = 0;
107  }
108 
109  /* run deflate() on provided input until it produces no more output */
110  ret = Z_OK;
111  do {
112  /* write out current buffer contents if full, or if flushing, but if
113  doing Z_FINISH then don't write until we get to Z_STREAM_END */
114  if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
115  (flush != Z_FINISH || ret == Z_STREAM_END))) {
116  while (strm->next_out > state->x.next) {
117  put = strm->next_out - state->x.next > (int)max ? max :
118  (unsigned)(strm->next_out - state->x.next);
119  writ = write(state->fd, state->x.next, put);
120  if (writ < 0) {
122  return -1;
123  }
124  state->x.next += writ;
125  }
126  if (strm->avail_out == 0) {
127  strm->avail_out = state->size;
128  strm->next_out = state->out;
129  state->x.next = state->out;
130  }
131  }
132 
133  /* compress */
134  have = strm->avail_out;
135  ret = deflate(strm, flush);
136  if (ret == Z_STREAM_ERROR) {
138  "internal error: deflate stream corrupt");
139  return -1;
140  }
141  have -= strm->avail_out;
142  } while (have);
143 
144  /* if that completed a deflate stream, allow another to start */
145  if (flush == Z_FINISH)
146  state->reset = 1;
147 
148  /* all done, no errors */
149  return 0;
150 }
#define max(a, b)
Definition: svc.c:63
z_stream FAR * z_streamp
Definition: zlib.h:80
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
#define put(ret, state, sp, n)
Definition: match.c:105
#define write
Definition: acwin.h:97
int gz_init(gz_statep state)
Definition: gzwrite.c:17
#define Z_STREAM_END
Definition: zlib.h:115
z_streamp strm
Definition: deflate.h:101
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
int flush
Definition: zlib.h:309
int deflate(z_streamp strm, int flush) DECLSPEC_HIDDEN
Definition: deflate.c:804
int ret
static int state
Definition: maze.c:121
#define Z_FINISH
Definition: zlib.h:109
#define Z_NO_FLUSH
Definition: zlib.h:105
int ZEXPORT deflateReset(z_streamp strm)
Definition: deflate.c:545
#define Z_ERRNO
Definition: zlib.h:117
static unsigned(__cdecl *hash_bstr)(bstr_t s)
#define zstrerror(errnum)
Definition: zutil.h:152
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by gz_write(), gz_zero(), gzclose_w(), gzflush(), gzprintf(), and gzsetparams().

◆ gz_init()

int gz_init ( gz_statep  state)

Definition at line 17 of file gzwrite.c.

19 {
20  int ret;
21  z_streamp strm = &(state->strm);
22 
23  /* allocate input buffer (double size for gzprintf) */
24  state->in = (unsigned char *)malloc(state->want << 1);
25  if (state->in == NULL) {
26  gz_error(state, Z_MEM_ERROR, "out of memory");
27  return -1;
28  }
29 
30  /* only need output buffer and deflate state if compressing */
31  if (!state->direct) {
32  /* allocate output buffer */
33  state->out = (unsigned char *)malloc(state->want);
34  if (state->out == NULL) {
35  free(state->in);
36  gz_error(state, Z_MEM_ERROR, "out of memory");
37  return -1;
38  }
39 
40  /* allocate deflate memory, set up for gzip compression */
41  strm->zalloc = Z_NULL;
42  strm->zfree = Z_NULL;
43  strm->opaque = Z_NULL;
45  MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
46  if (ret != Z_OK) {
47  free(state->out);
48  free(state->in);
49  gz_error(state, Z_MEM_ERROR, "out of memory");
50  return -1;
51  }
52  strm->next_in = NULL;
53  }
54 
55  /* mark state as initialized */
56  state->size = state->want;
57 
58  /* initialize write buffer if compressing */
59  if (!state->direct) {
60  strm->avail_out = state->size;
61  strm->next_out = state->out;
62  state->x.next = strm->next_out;
63  }
64  return 0;
65 }
z_stream FAR * z_streamp
Definition: zlib.h:80
#define Z_OK
Definition: zlib.h:114
#define free
Definition: debug_ros.c:5
#define MAX_WBITS
Definition: zlib.h:151
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy)
Definition: zlib.h:1814
z_streamp strm
Definition: deflate.h:101
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
int ret
static int state
Definition: maze.c:121
#define Z_DEFLATED
Definition: zlib.h:146
#define Z_NULL
Definition: zlib.h:149
#define NULL
Definition: types.h:112
#define Z_MEM_ERROR
Definition: zlib.h:120
#define malloc
Definition: debug_ros.c:4
#define DEF_MEM_LEVEL
Definition: zutil.h:53

Referenced by gz_comp(), gz_write(), and gzprintf().

◆ gz_write()

z_size_t gz_write ( gz_statep  state,
voidpc  buf,
z_size_t  len 
)

Definition at line 187 of file gzwrite.c.

191 {
192  z_size_t put = len;
193 
194  /* if len is zero, avoid unnecessary operations */
195  if (len == 0)
196  return 0;
197 
198  /* allocate memory if this is the first time through */
199  if (state->size == 0 && gz_init(state) == -1)
200  return 0;
201 
202  /* check for seek request */
203  if (state->seek) {
204  state->seek = 0;
205  if (gz_zero(state, state->skip) == -1)
206  return 0;
207  }
208 
209  /* for small len, copy to input buffer, otherwise compress directly */
210  if (len < state->size) {
211  /* copy to input buffer, compress when full */
212  do {
213  unsigned have, copy;
214 
215  if (state->strm.avail_in == 0)
216  state->strm.next_in = state->in;
217  have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
218  state->in);
219  copy = state->size - have;
220  if (copy > len)
221  copy = (unsigned)len;
222  memcpy(state->in + have, buf, copy);
223  state->strm.avail_in += copy;
224  state->x.pos += copy;
225  buf = (const char *)buf + copy;
226  len -= copy;
227  if (len && gz_comp(state, Z_NO_FLUSH) == -1)
228  return 0;
229  } while (len);
230  }
231  else {
232  /* consume whatever's left in the input buffer */
233  if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
234  return 0;
235 
236  /* directly compress user buffer to file */
237  state->strm.next_in = (z_const Bytef *)buf;
238  do {
239  unsigned n = (unsigned)-1;
240  if (n > len)
241  n = (unsigned)len;
242  state->strm.avail_in = n;
243  state->x.pos += n;
244  if (gz_comp(state, Z_NO_FLUSH) == -1)
245  return 0;
246  len -= n;
247  } while (len);
248  }
249 
250  /* input was all buffered or compressed */
251  return put;
252 }
unsigned long z_size_t
Definition: zconf.h:250
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
GLdouble n
Definition: glext.h:7729
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
#define put(ret, state, sp, n)
Definition: match.c:105
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
int gz_init(gz_statep state)
Definition: gzwrite.c:17
GLsizeiptr size
Definition: glext.h:5919
static int state
Definition: maze.c:121
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
Byte FAR Bytef
Definition: zlib.h:41
#define z_const
Definition: zlib.h:35
#define Z_NO_FLUSH
Definition: zlib.h:105
static unsigned(__cdecl *hash_bstr)(bstr_t s)

Referenced by gzfwrite(), gzputc(), gzputs(), and gzwrite().

◆ gz_zero()

int gz_zero ( gz_statep  state,
z_off64_t  len 
)

Definition at line 154 of file gzwrite.c.

157 {
158  int first;
159  unsigned n;
160  z_streamp strm = &(state->strm);
161 
162  /* consume whatever's left in the input buffer */
163  if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
164  return -1;
165 
166  /* compress len zeros (len guaranteed > 0) */
167  first = 1;
168  while (len) {
169  n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
170  (unsigned)len : state->size;
171  if (first) {
172  memset(state->in, 0, n);
173  first = 0;
174  }
175  strm->avail_in = n;
176  strm->next_in = state->in;
177  state->x.pos += n;
178  if (gz_comp(state, Z_NO_FLUSH) == -1)
179  return -1;
180  len -= n;
181  }
182  return 0;
183 }
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
z_stream FAR * z_streamp
Definition: zlib.h:80
const GLint * first
Definition: glext.h:5794
#define GT_OFF(x)
Definition: gzguts.h:218
GLdouble n
Definition: glext.h:7729
#define z_off64_t
Definition: zconf.h:513
z_streamp strm
Definition: deflate.h:101
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
#define Z_NO_FLUSH
Definition: zlib.h:105
#define memset(x, y, z)
Definition: compat.h:39

Referenced by gz_write(), gzclose_w(), gzflush(), gzprintf(), gzputc(), and gzsetparams().

◆ gzclose_w()

int ZEXPORT gzclose_w ( gzFile  file)

Definition at line 639 of file gzwrite.c.

641 {
642  int ret = Z_OK;
644 
645  /* get internal structure */
646  if (file == NULL)
647  return Z_STREAM_ERROR;
648  state = (gz_statep)file;
649 
650  /* check that we're writing */
651  if (state->mode != GZ_WRITE)
652  return Z_STREAM_ERROR;
653 
654  /* check for seek request */
655  if (state->seek) {
656  state->seek = 0;
657  if (gz_zero(state, state->skip) == -1)
658  ret = state->err;
659  }
660 
661  /* flush, free memory, and close file */
662  if (gz_comp(state, Z_FINISH) == -1)
663  ret = state->err;
664  if (state->size) {
665  if (!state->direct) {
666  (void)deflateEnd(&(state->strm));
667  free(state->out);
668  }
669  free(state->in);
670  }
671  gz_error(state, Z_OK, NULL);
672  free(state->path);
673  if (close(state->fd) == -1)
674  ret = Z_ERRNO;
675  free(state);
676  return ret;
677 }
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
#define free
Definition: debug_ros.c:5
if(dx==0 &&dy==0)
Definition: linetemp.h:174
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
int deflateEnd(z_streamp strm) DECLSPEC_HIDDEN
Definition: deflate.c:1119
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
#define GZ_WRITE
Definition: gzguts.h:161
int ret
static int state
Definition: maze.c:121
#define close
Definition: acwin.h:98
#define Z_FINISH
Definition: zlib.h:109
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
#define Z_ERRNO
Definition: zlib.h:117
Definition: fci.c:126

Referenced by gzclose().

◆ gzflush()

int ZEXPORT gzflush ( gzFile  file,
int  flush 
)

Definition at line 565 of file gzwrite.c.

568 {
570 
571  /* get internal structure */
572  if (file == NULL)
573  return Z_STREAM_ERROR;
574  state = (gz_statep)file;
575 
576  /* check that we're writing and that there's no error */
577  if (state->mode != GZ_WRITE || state->err != Z_OK)
578  return Z_STREAM_ERROR;
579 
580  /* check flush parameter */
581  if (flush < 0 || flush > Z_FINISH)
582  return Z_STREAM_ERROR;
583 
584  /* check for seek request */
585  if (state->seek) {
586  state->seek = 0;
587  if (gz_zero(state, state->skip) == -1)
588  return state->err;
589  }
590 
591  /* compress remaining data with requested flush */
592  (void)gz_comp(state, flush);
593  return state->err;
594 }
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
int flush
Definition: zlib.h:309
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
#define Z_FINISH
Definition: zlib.h:109
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
Definition: fci.c:126

◆ gzfwrite()

z_size_t ZEXPORT gzfwrite ( voidpc  buf,
z_size_t  size,
z_size_t  nitems,
gzFile  file 
)

Definition at line 283 of file gzwrite.c.

288 {
289  z_size_t len;
291 
292  /* get internal structure */
293  if (file == NULL)
294  return 0;
295  state = (gz_statep)file;
296 
297  /* check that we're writing and that there's no error */
298  if (state->mode != GZ_WRITE || state->err != Z_OK)
299  return 0;
300 
301  /* compute bytes to read -- error on overflow */
302  len = nitems * size;
303  if (size && len / size != nitems) {
304  gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
305  return 0;
306  }
307 
308  /* write len bytes to buf, return the number of full items written */
309  return len ? gz_write(state, buf, len) / size : 0;
310 }
unsigned long z_size_t
Definition: zconf.h:250
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
Definition: gzwrite.c:187
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
#define GZ_WRITE
Definition: gzguts.h:161
GLsizeiptr size
Definition: glext.h:5919
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
Definition: fci.c:126

◆ gzprintf()

int ZEXPORTVA gzprintf ( gzFile  file,
const char format,
int  a1,
int  a2,
int  a3,
int  a4,
int  a5,
int  a6,
int  a7,
int  a8,
int  a9,
int  a10,
int  a11,
int  a12,
int  a13,
int  a14,
int  a15,
int  a16,
int  a17,
int  a18,
int  a19,
int  a20 
)

Definition at line 477 of file gzwrite.c.

483 {
484  unsigned len, left;
485  char *next;
487  z_streamp strm;
488 
489  /* get internal structure */
490  if (file == NULL)
491  return Z_STREAM_ERROR;
492  state = (gz_statep)file;
493  strm = &(state->strm);
494 
495  /* check that can really pass pointer in ints */
496  if (sizeof(int) != sizeof(void *))
497  return Z_STREAM_ERROR;
498 
499  /* check that we're writing and that there's no error */
500  if (state->mode != GZ_WRITE || state->err != Z_OK)
501  return Z_STREAM_ERROR;
502 
503  /* make sure we have some buffer space */
504  if (state->size == 0 && gz_init(state) == -1)
505  return state->error;
506 
507  /* check for seek request */
508  if (state->seek) {
509  state->seek = 0;
510  if (gz_zero(state, state->skip) == -1)
511  return state->error;
512  }
513 
514  /* do the printf() into the input buffer, put length in len -- the input
515  buffer is double-sized just for this function, so there is guaranteed to
516  be state->size bytes available after the current contents */
517  if (strm->avail_in == 0)
518  strm->next_in = state->in;
519  next = (char *)(strm->next_in + strm->avail_in);
520  next[state->size - 1] = 0;
521 #ifdef NO_snprintf
522 # ifdef HAS_sprintf_void
523  sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
524  a13, a14, a15, a16, a17, a18, a19, a20);
525  for (len = 0; len < size; len++)
526  if (next[len] == 0)
527  break;
528 # else
529  len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
530  a12, a13, a14, a15, a16, a17, a18, a19, a20);
531 # endif
532 #else
533 # ifdef HAS_snprintf_void
534  snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
535  a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
536  len = strlen(next);
537 # else
538  len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
539  a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
540 # endif
541 #endif
542 
543  /* check that printf() results fit in buffer */
544  if (len == 0 || len >= state->size || next[state->size - 1] != 0)
545  return 0;
546 
547  /* update buffer and position, compress first half if past that */
548  strm->avail_in += len;
549  state->x.pos += len;
550  if (strm->avail_in >= state->size) {
551  left = strm->avail_in - state->size;
552  strm->avail_in = state->size;
553  if (gz_comp(state, Z_NO_FLUSH) == -1)
554  return state->err;
555  memmove(state->in, state->in + state->size, left);
556  strm->next_in = state->in;
557  strm->avail_in = left;
558  }
559  return (int)len;
560 }
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static const struct update_accum a3
Definition: msg.c:600
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
z_stream FAR * z_streamp
Definition: zlib.h:80
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
#define snprintf
Definition: wintirpc.h:48
static const struct update_accum a4
Definition: msg.c:2285
if(dx==0 &&dy==0)
Definition: linetemp.h:174
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define sprintf(buf, format,...)
Definition: sprintf.c:55
int gz_init(gz_statep state)
Definition: gzwrite.c:17
z_streamp strm
Definition: deflate.h:101
#define GZ_WRITE
Definition: gzguts.h:161
GLsizeiptr size
Definition: glext.h:5919
static const struct update_accum a2
Definition: msg.c:586
GLint left
Definition: glext.h:7726
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
static unsigned __int64 next
Definition: rand_nt.c:6
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
#define Z_NO_FLUSH
Definition: zlib.h:105
static const struct update_accum a1
Definition: msg.c:578
Definition: fci.c:126

◆ gzputc()

int ZEXPORT gzputc ( gzFile  file,
int  c 
)

Definition at line 313 of file gzwrite.c.

316 {
317  unsigned have;
318  unsigned char buf[1];
320  z_streamp strm;
321 
322  /* get internal structure */
323  if (file == NULL)
324  return -1;
325  state = (gz_statep)file;
326  strm = &(state->strm);
327 
328  /* check that we're writing and that there's no error */
329  if (state->mode != GZ_WRITE || state->err != Z_OK)
330  return -1;
331 
332  /* check for seek request */
333  if (state->seek) {
334  state->seek = 0;
335  if (gz_zero(state, state->skip) == -1)
336  return -1;
337  }
338 
339  /* try writing to input buffer for speed (state->size == 0 if buffer not
340  initialized) */
341  if (state->size) {
342  if (strm->avail_in == 0)
343  strm->next_in = state->in;
344  have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
345  if (have < state->size) {
346  state->in[have] = (unsigned char)c;
347  strm->avail_in++;
348  state->x.pos++;
349  return c & 0xff;
350  }
351  }
352 
353  /* no room in buffer or not initialized, use gz_write() */
354  buf[0] = (unsigned char)c;
355  if (gz_write(state, buf, 1) != 1)
356  return -1;
357  return c & 0xff;
358 }
z_stream FAR * z_streamp
Definition: zlib.h:80
#define Z_OK
Definition: zlib.h:114
z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
Definition: gzwrite.c:187
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
unsigned char
Definition: typeof.h:29
z_streamp strm
Definition: deflate.h:101
#define GZ_WRITE
Definition: gzguts.h:161
GLsizeiptr size
Definition: glext.h:5919
const GLubyte * c
Definition: glext.h:8905
static int state
Definition: maze.c:121
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
static unsigned(__cdecl *hash_bstr)(bstr_t s)
Definition: fci.c:126

◆ gzputs()

int ZEXPORT gzputs ( gzFile  file,
const char s 
)

Definition at line 361 of file gzwrite.c.

364 {
365  z_size_t len, put;
367 
368  /* get internal structure */
369  if (file == NULL)
370  return -1;
371  state = (gz_statep)file;
372 
373  /* check that we're writing and that there's no error */
374  if (state->mode != GZ_WRITE || state->err != Z_OK)
375  return -1;
376 
377  /* write string */
378  len = strlen(s);
379  if ((int)len < 0 || (unsigned)len != len) {
380  gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
381  return -1;
382  }
383  put = gz_write(state, s, len);
384  return put < len ? -1 : (int)len;
385 }
unsigned long z_size_t
Definition: zconf.h:250
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
Definition: gzwrite.c:187
#define put(ret, state, sp, n)
Definition: match.c:105
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
Definition: fci.c:126

◆ gzsetparams()

int ZEXPORT gzsetparams ( gzFile  file,
int  level,
int  strategy 
)

Definition at line 597 of file gzwrite.c.

601 {
603  z_streamp strm;
604 
605  /* get internal structure */
606  if (file == NULL)
607  return Z_STREAM_ERROR;
608  state = (gz_statep)file;
609  strm = &(state->strm);
610 
611  /* check that we're writing and that there's no error */
612  if (state->mode != GZ_WRITE || state->err != Z_OK)
613  return Z_STREAM_ERROR;
614 
615  /* if no change is requested, then do nothing */
616  if (level == state->level && strategy == state->strategy)
617  return Z_OK;
618 
619  /* check for seek request */
620  if (state->seek) {
621  state->seek = 0;
622  if (gz_zero(state, state->skip) == -1)
623  return state->err;
624  }
625 
626  /* change compression parameters for subsequent input */
627  if (state->size) {
628  /* flush previous input with previous parameters before changing */
629  if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
630  return state->err;
632  }
633  state->level = level;
634  state->strategy = strategy;
635  return Z_OK;
636 }
#define Z_BLOCK
Definition: zlib.h:110
int gz_comp(gz_statep state, int flush)
Definition: gzwrite.c:73
GLint level
Definition: gl.h:1546
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy)
Definition: deflate.c:609
z_stream FAR * z_streamp
Definition: zlib.h:80
#define Z_STREAM_ERROR
Definition: zlib.h:118
#define Z_OK
Definition: zlib.h:114
int gz_zero(gz_statep state, z_off64_t len)
Definition: gzwrite.c:154
z_streamp strm
Definition: deflate.h:101
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
Definition: fci.c:126

◆ gzwrite()

int ZEXPORT gzwrite ( gzFile  file,
voidpc  buf,
unsigned  len 
)

Definition at line 255 of file gzwrite.c.

259 {
261 
262  /* get internal structure */
263  if (file == NULL)
264  return 0;
265  state = (gz_statep)file;
266 
267  /* check that we're writing and that there's no error */
268  if (state->mode != GZ_WRITE || state->err != Z_OK)
269  return 0;
270 
271  /* since an int is returned, make sure len fits in one, otherwise return
272  with an error (this avoids a flaw in the interface) */
273  if ((int)len < 0) {
274  gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
275  return 0;
276  }
277 
278  /* write len bytes from buf (the return value will fit in an int) */
279  return (int)gz_write(state, buf, len);
280 }
#define Z_OK
Definition: zlib.h:114
z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
Definition: gzwrite.c:187
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
Definition: gzlib.c:581
#define GZ_WRITE
Definition: gzguts.h:161
static int state
Definition: maze.c:121
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
gz_state FAR * gz_statep
Definition: gzguts.h:203
#define Z_DATA_ERROR
Definition: zlib.h:119
Definition: fci.c:126

◆ OF() [1/4]

int gz_init OF ( (gz_statep )

◆ OF() [2/4]

int gz_comp OF ( (gz_statep, int )

◆ OF() [3/4]

◆ OF() [4/4]