Lines Matching defs:state

10 /* Initialize state for writing a gzip file.  Mark initialization by setting
11 state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
13 local int gz_init(gz_statep state)
16 z_streamp strm = &(state->strm);
19 state->in = (unsigned char *)malloc(state->want << 1);
20 if (state->in == NULL) {
21 gz_error(state, Z_MEM_ERROR, "out of memory");
25 /* only need output buffer and deflate state if compressing */
26 if (!state->direct) {
28 state->out = (unsigned char *)malloc(state->want);
29 if (state->out == NULL) {
30 free(state->in);
31 gz_error(state, Z_MEM_ERROR, "out of memory");
39 ret = deflateInit2(strm, state->level, Z_DEFLATED,
40 MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
42 free(state->out);
43 free(state->in);
44 gz_error(state, Z_MEM_ERROR, "out of memory");
50 /* mark state as initialized */
51 state->size = state->want;
54 if (!state->direct) {
55 strm->avail_out = state->size;
56 strm->next_out = state->out;
57 state->x.next = strm->next_out;
65 deflate() flush value. If flush is Z_FINISH, then the deflate() state is
68 local int gz_comp(gz_statep state, int flush)
72 z_streamp strm = &(state->strm);
75 if (state->size == 0 && gz_init(state) == -1)
79 if (state->direct) {
82 writ = write(state->fd, strm->next_in, put);
84 gz_error(state, Z_ERRNO, zstrerror());
94 if (state->reset) {
99 state->reset = 0;
109 while (strm->next_out > state->x.next) {
110 put = strm->next_out - state->x.next > (int)max ? max :
111 (unsigned)(strm->next_out - state->x.next);
112 writ = write(state->fd, state->x.next, put);
114 gz_error(state, Z_ERRNO, zstrerror());
117 state->x.next += writ;
120 strm->avail_out = state->size;
121 strm->next_out = state->out;
122 state->x.next = state->out;
130 gz_error(state, Z_STREAM_ERROR,
139 state->reset = 1;
147 local int gz_zero(gz_statep state, z_off64_t len)
151 z_streamp strm = &(state->strm);
154 if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
160 n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
161 (unsigned)len : state->size;
163 memset(state->in, 0, n);
167 strm->next_in = state->in;
168 state->x.pos += n;
169 if (gz_comp(state, Z_NO_FLUSH) == -1)
178 local z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
187 if (state->size == 0 && gz_init(state) == -1)
191 if (state->seek) {
192 state->seek = 0;
193 if (gz_zero(state, state->skip) == -1)
198 if (len < state->size) {
203 if (state->strm.avail_in == 0)
204 state->strm.next_in = state->in;
205 have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
206 state->in);
207 copy = state->size - have;
210 memcpy(state->in + have, buf, copy);
211 state->strm.avail_in += copy;
212 state->x.pos += copy;
215 if (len && gz_comp(state, Z_NO_FLUSH) == -1)
221 if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
225 state->strm.next_in = (z_const Bytef *)buf;
230 state->strm.avail_in = n;
231 state->x.pos += n;
232 if (gz_comp(state, Z_NO_FLUSH) == -1)
244 gz_statep state;
249 state = (gz_statep)file;
252 if (state->mode != GZ_WRITE || state->err != Z_OK)
258 gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
263 return (int)gz_write(state, buf, len);
271 gz_statep state;
276 state = (gz_statep)file;
279 if (state->mode != GZ_WRITE || state->err != Z_OK)
285 gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
290 return len ? gz_write(state, buf, len) / size : 0;
297 gz_statep state;
303 state = (gz_statep)file;
304 strm = &(state->strm);
307 if (state->mode != GZ_WRITE || state->err != Z_OK)
311 if (state->seek) {
312 state->seek = 0;
313 if (gz_zero(state, state->skip) == -1)
317 /* try writing to input buffer for speed (state->size == 0 if buffer not
319 if (state->size) {
321 strm->next_in = state->in;
322 have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
323 if (have < state->size) {
324 state->in[have] = (unsigned char)c;
326 state->x.pos++;
333 if (gz_write(state, buf, 1) != 1)
341 gz_statep state;
346 state = (gz_statep)file;
349 if (state->mode != GZ_WRITE || state->err != Z_OK)
355 gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
358 put = gz_write(state, s, len);
370 gz_statep state;
376 state = (gz_statep)file;
377 strm = &(state->strm);
380 if (state->mode != GZ_WRITE || state->err != Z_OK)
384 if (state->size == 0 && gz_init(state) == -1)
385 return state->err;
388 if (state->seek) {
389 state->seek = 0;
390 if (gz_zero(state, state->skip) == -1)
391 return state->err;
396 be state->size bytes available after the current contents */
398 strm->next_in = state->in;
399 next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
400 next[state->size - 1] = 0;
404 for (len = 0; len < state->size; len++)
411 (void)vsnprintf(next, state->size, format, va);
414 len = vsnprintf(next, state->size, format, va);
419 if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
424 state->x.pos += len;
425 if (strm->avail_in >= state->size) {
426 left = strm->avail_in - state->size;
427 strm->avail_in = state->size;
428 if (gz_comp(state, Z_NO_FLUSH) == -1)
429 return state->err;
430 memmove(state->in, state->in + state->size, left);
431 strm->next_in = state->in;
456 gz_statep state;
462 state = (gz_statep)file;
463 strm = &(state->strm);
470 if (state->mode != GZ_WRITE || state->err != Z_OK)
474 if (state->size == 0 && gz_init(state) == -1)
475 return state->error;
478 if (state->seek) {
479 state->seek = 0;
480 if (gz_zero(state, state->skip) == -1)
481 return state->error;
486 be state->size bytes available after the current contents */
488 strm->next_in = state->in;
490 next[state->size - 1] = 0;
504 snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
508 len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
514 if (len == 0 || len >= state->size || next[state->size - 1] != 0)
519 state->x.pos += len;
520 if (strm->avail_in >= state->size) {
521 left = strm->avail_in - state->size;
522 strm->avail_in = state->size;
523 if (gz_comp(state, Z_NO_FLUSH) == -1)
524 return state->err;
525 memmove(state->in, state->in + state->size, left);
526 strm->next_in = state->in;
536 gz_statep state;
541 state = (gz_statep)file;
544 if (state->mode != GZ_WRITE || state->err != Z_OK)
552 if (state->seek) {
553 state->seek = 0;
554 if (gz_zero(state, state->skip) == -1)
555 return state->err;
559 (void)gz_comp(state, flush);
560 return state->err;
565 gz_statep state;
571 state = (gz_statep)file;
572 strm = &(state->strm);
575 if (state->mode != GZ_WRITE || state->err != Z_OK || state->direct)
579 if (level == state->level && strategy == state->strategy)
583 if (state->seek) {
584 state->seek = 0;
585 if (gz_zero(state, state->skip) == -1)
586 return state->err;
590 if (state->size) {
592 if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
593 return state->err;
596 state->level = level;
597 state->strategy = strategy;
604 gz_statep state;
609 state = (gz_statep)file;
612 if (state->mode != GZ_WRITE)
616 if (state->seek) {
617 state->seek = 0;
618 if (gz_zero(state, state->skip) == -1)
619 ret = state->err;
623 if (gz_comp(state, Z_FINISH) == -1)
624 ret = state->err;
625 if (state->size) {
626 if (!state->direct) {
627 (void)deflateEnd(&(state->strm));
628 free(state->out);
630 free(state->in);
632 gz_error(state, Z_OK, NULL);
633 free(state->path);
634 if (close(state->fd) == -1)
636 free(state);