Lines Matching defs:state
17 /* Initialize state for writing a gzip file. Mark initialization by setting
18 state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
20 local int gz_init(state)
21 gz_statep state;
24 z_streamp strm = &(state->strm);
27 state->in = (unsigned char *)malloc(state->want << 1);
28 if (state->in == NULL) {
29 gz_error(state, Z_MEM_ERROR, "out of memory");
33 /* only need output buffer and deflate state if compressing */
34 if (!state->direct) {
36 state->out = (unsigned char *)malloc(state->want);
37 if (state->out == NULL) {
38 free(state->in);
39 gz_error(state, Z_MEM_ERROR, "out of memory");
47 ret = deflateInit2(strm, state->level, Z_DEFLATED,
48 MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
50 free(state->out);
51 free(state->in);
52 gz_error(state, Z_MEM_ERROR, "out of memory");
58 /* mark state as initialized */
59 state->size = state->want;
62 if (!state->direct) {
63 strm->avail_out = state->size;
64 strm->next_out = state->out;
65 state->x.next = strm->next_out;
73 deflate() flush value. If flush is Z_FINISH, then the deflate() state is
76 local int gz_comp(state, flush)
77 gz_statep state;
82 z_streamp strm = &(state->strm);
85 if (state->size == 0 && gz_init(state) == -1)
89 if (state->direct) {
92 writ = write(state->fd, strm->next_in, put);
94 gz_error(state, Z_ERRNO, zstrerror());
110 while (strm->next_out > state->x.next) {
111 put = strm->next_out - state->x.next > (int)max ? max :
112 (unsigned)(strm->next_out - state->x.next);
113 writ = write(state->fd, state->x.next, put);
115 gz_error(state, Z_ERRNO, zstrerror());
118 state->x.next += writ;
121 strm->avail_out = state->size;
122 strm->next_out = state->out;
123 state->x.next = state->out;
131 gz_error(state, Z_STREAM_ERROR,
148 local int gz_zero(state, len)
149 gz_statep state;
154 z_streamp strm = &(state->strm);
157 if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
163 n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
164 (unsigned)len : state->size;
166 memset(state->in, 0, n);
170 strm->next_in = state->in;
171 state->x.pos += n;
172 if (gz_comp(state, Z_NO_FLUSH) == -1)
181 local z_size_t gz_write(state, buf, len)
182 gz_statep state;
193 if (state->size == 0 && gz_init(state) == -1)
197 if (state->seek) {
198 state->seek = 0;
199 if (gz_zero(state, state->skip) == -1)
204 if (len < state->size) {
209 if (state->strm.avail_in == 0)
210 state->strm.next_in = state->in;
211 have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
212 state->in);
213 copy = state->size - have;
216 memcpy(state->in + have, buf, copy);
217 state->strm.avail_in += copy;
218 state->x.pos += copy;
221 if (len && gz_comp(state, Z_NO_FLUSH) == -1)
227 if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
231 state->strm.next_in = (z_const Bytef *)buf;
236 state->strm.avail_in = n;
237 state->x.pos += n;
238 if (gz_comp(state, Z_NO_FLUSH) == -1)
254 gz_statep state;
259 state = (gz_statep)file;
262 if (state->mode != GZ_WRITE || state->err != Z_OK)
268 gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
273 return (int)gz_write(state, buf, len);
284 gz_statep state;
289 state = (gz_statep)file;
292 if (state->mode != GZ_WRITE || state->err != Z_OK)
298 gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
303 return len ? gz_write(state, buf, len) / size : 0;
313 gz_statep state;
319 state = (gz_statep)file;
320 strm = &(state->strm);
323 if (state->mode != GZ_WRITE || state->err != Z_OK)
327 if (state->seek) {
328 state->seek = 0;
329 if (gz_zero(state, state->skip) == -1)
333 /* try writing to input buffer for speed (state->size == 0 if buffer not
335 if (state->size) {
337 strm->next_in = state->in;
338 have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
339 if (have < state->size) {
340 state->in[have] = (unsigned char)c;
342 state->x.pos++;
349 if (gz_write(state, buf, 1) != 1)
361 gz_statep state;
366 state = (gz_statep)file;
369 if (state->mode != GZ_WRITE || state->err != Z_OK)
374 ret = gz_write(state, str, len);
387 gz_statep state;
393 state = (gz_statep)file;
394 strm = &(state->strm);
397 if (state->mode != GZ_WRITE || state->err != Z_OK)
401 if (state->size == 0 && gz_init(state) == -1)
402 return state->err;
405 if (state->seek) {
406 state->seek = 0;
407 if (gz_zero(state, state->skip) == -1)
408 return state->err;
413 be state->size bytes available after the current contents */
415 strm->next_in = state->in;
416 next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
417 next[state->size - 1] = 0;
421 for (len = 0; len < state->size; len++)
428 (void)vsnprintf(next, state->size, format, va);
431 len = vsnprintf(next, state->size, format, va);
436 if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
441 state->x.pos += len;
442 if (strm->avail_in >= state->size) {
443 left = strm->avail_in - state->size;
444 strm->avail_in = state->size;
445 if (gz_comp(state, Z_NO_FLUSH) == -1)
446 return state->err;
447 memcpy(state->in, state->in + state->size, left);
448 strm->next_in = state->in;
477 gz_statep state;
483 state = (gz_statep)file;
484 strm = &(state->strm);
491 if (state->mode != GZ_WRITE || state->err != Z_OK)
495 if (state->size == 0 && gz_init(state) == -1)
496 return state->error;
499 if (state->seek) {
500 state->seek = 0;
501 if (gz_zero(state, state->skip) == -1)
502 return state->error;
507 be state->size bytes available after the current contents */
509 strm->next_in = state->in;
511 next[state->size - 1] = 0;
525 snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
529 len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
535 if (len == 0 || len >= state->size || next[state->size - 1] != 0)
540 state->x.pos += len;
541 if (strm->avail_in >= state->size) {
542 left = strm->avail_in - state->size;
543 strm->avail_in = state->size;
544 if (gz_comp(state, Z_NO_FLUSH) == -1)
545 return state->err;
546 memcpy(state->in, state->in + state->size, left);
547 strm->next_in = state->in;
560 gz_statep state;
565 state = (gz_statep)file;
568 if (state->mode != GZ_WRITE || state->err != Z_OK)
576 if (state->seek) {
577 state->seek = 0;
578 if (gz_zero(state, state->skip) == -1)
579 return state->err;
583 (void)gz_comp(state, flush);
584 return state->err;
593 gz_statep state;
599 state = (gz_statep)file;
600 strm = &(state->strm);
603 if (state->mode != GZ_WRITE || state->err != Z_OK)
607 if (level == state->level && strategy == state->strategy)
611 if (state->seek) {
612 state->seek = 0;
613 if (gz_zero(state, state->skip) == -1)
614 return state->err;
618 if (state->size) {
620 if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
621 return state->err;
624 state->level = level;
625 state->strategy = strategy;
634 gz_statep state;
639 state = (gz_statep)file;
642 if (state->mode != GZ_WRITE)
646 if (state->seek) {
647 state->seek = 0;
648 if (gz_zero(state, state->skip) == -1)
649 ret = state->err;
653 if (gz_comp(state, Z_FINISH) == -1)
654 ret = state->err;
655 if (state->size) {
656 if (!state->direct) {
657 (void)deflateEnd(&(state->strm));
658 free(state->out);
660 free(state->in);
662 gz_error(state, Z_OK, NULL);
663 free(state->path);
664 if (close(state->fd) == -1)
666 free(state);