public static int gzread(gzFile_s *file, void *buf, uint len)
{
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return(-1);
}
if (((int)len) < 0)
{
gz_error(state, -2, "request does not fit in an int"); return(-1);
}
len = (uint)gz_read(state, buf, len);
if ((len == 0) && (state->err != 0) && (state->err != (-5)))
{
return(-1);
}
return((int)len);
}
public static int gzbuffer(gzFile_s *file, uint size)
{
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return(-1);
}
if (state->size != 0)
{
return(-1);
}
if ((size << 1) < size)
{
return(-1);
}
if (size < 2)
{
size = 2;
}
state->want = size;
return(0);
}
public static int gztell(gzFile_s *file)
{
long ret = 0;
ret = gztell64(file);
return(ret == ((int)ret) ? (int)ret : -1);
}
public static int gzseek(gzFile_s *file, int offset, int whence)
{
long ret = 0;
ret = gzseek64(file, offset, whence);
return(ret == ((int)ret) ? (int)ret : -1);
}
public static long gzoffset64(gzFile_s *file)
{
long offset = 0;
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return(-1);
}
offset = (long)_lseeki64(state->fd, 0, 1);
if (offset == (-1))
{
return(-1);
}
if (state->mode == 7247)
{
offset -= state->strm.avail_in;
}
return(offset);
}
public static int gzflush(gzFile_s *file, int flush)
{
gz_state *state;
if (file == ((void *)0))
{
return(-2);
}
state = (gz_state *)file;
if ((state->mode != 31153) || (state->err != 0))
{
return(-2);
}
if ((flush < 0) || (flush > 4))
{
return(-2);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_zero(state, state->skip) == (-1))
{
return(state->err);
}
}
(void)gz_comp(state, (int)flush);
return(state->err);
}
public static int gzoffset(gzFile_s *file)
{
long ret = 0;
ret = gzoffset64(file);
return(ret == ((int)ret) ? (int)ret : -1);
}
public static int gzclose_r(gzFile_s *file)
{
int ret = 0; int err = 0;
gz_state *state;
if (file == ((void *)0))
{
return((int)-2);
}
state = (gz_state *)file;
if (state->mode != 7247)
{
return((int)-2);
}
if (state->size != 0)
{
inflateEnd(&state->strm); free(state->_out_); free(state->_in_);
}
err = (int)(state->err == (-5)?(-5):0);
gz_error(state, (int)0, (void *)0);
free(state->path);
ret = (int)close((int)state->fd);
free(state);
return((int)(ret != 0?(-1):err));
}
public static int gzvprintf(gzFile_s *file, sbyte *format, sbyte *va)
{
int len = 0;
uint left = 0;
sbyte * next;
gz_state * state;
z_stream_s strm;
if (file == ((void *)0))
{
return(-2);
}
state = (gz_state *)file;
strm = &state->strm;
if ((state->mode != 31153) || (state->err != 0))
{
return(-2);
}
if ((state->size == 0) && (gz_init(state) == (-1)))
{
return(state->err);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_zero(state, state->skip) == (-1))
{
return(state->err);
}
}
if (strm.avail_in == 0)
{
strm.next_in = state->_in_;
}
next = (sbyte *)(state->_in_ + (strm.next_in - state->_in_) + strm.avail_in);
next[state->size - 1] = 0;
len = (int)vsnprintf(next, state->size, format, va);
if ((len == 0) || (((uint)len) >= state->size) || (next[state->size - 1] != 0))
{
return(0);
}
strm.avail_in += (uint)len;
state->x.pos += len;
if (strm.avail_in >= state->size)
{
left = strm.avail_in - state->size;
strm.avail_in = state->size;
if (gz_comp(state, 0) == (-1))
{
return(state->err);
}
memcpy(state->_in_, state->_in_ + state->size, (ulong)left); strm.next_in = state->_in_; strm.avail_in = left;
}
return(len);
}
public static int gzprintf(gzFile_s *file, sbyte *format)
{
sbyte *va;
int ret = 0;
__va_start(&va, format);
ret = gzvprintf(file, format, va);
(void)(va = (sbyte *)0);
return(ret);
}
public static sbyte *gzgets(gzFile_s *file, sbyte *buf, int len)
{
uint left = 0; uint n = 0;
sbyte * str;
byte * eol;
gz_state *state;
if ((file == ((void *)0)) || (buf == ((void *)0)) || (len < 1))
{
return((void *)0);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return((void *)0);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_skip(state, state->skip) == (-1))
{
return((void *)0);
}
}
str = buf;
left = (uint)len - 1;
if (left != 0)
{
do
{
if ((state->x.have == 0) && (gz_fetch(state) == (-1)))
{
return((void *)0);
}
if (state->x.have == 0)
{
state->past = (int)1; break;
}
n = (uint)(state->x.have > left?left:state->x.have); eol = (byte *)(memchr(state->x.next, (int)('
'), (ulong)(n))); if (eol != ((void *)(0)))
{
n = (uint)((uint)(eol - state->x.next) + 1);
}
memcpy(buf, state->x.next, (ulong)(n)); state->x.have -= (uint)(n); state->x.next += n; state->x.pos += (long)(n); left -= (uint)(n); buf += n;
}while ((left != 0) && (eol == ((void *)0)));
}
if (buf == str)
{
return((void *)0);
}
buf[0] = (sbyte)0;
return(str);
}
public static int gzclose(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return(-2);
}
state = (gz_state *)file;
return((int)(state->mode == 7247 ? gzclose_r(file) : gzclose_w(file)));
}
public static int gzungetc(int c, gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return(-1);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_skip(state, state->skip) == (-1))
{
return(-1);
}
}
if (c < 0)
{
return(-1);
}
if (state->x.have == 0)
{
state->x.have = 1;
state->x.next = state->_out_ + (state->size << 1) - 1; state->x.next[0] = (byte)c; state->x.pos--; state->past = 0;
return(c);
}
if (state->x.have == (state->size << 1))
{
gz_error(state, -3, "out of room to push characters"); return(-1);
}
if (state->x.next == state->_out_)
{
byte *src = state->_out_ + state->x.have; byte *dest = state->_out_ + (state->size << 1); while (src > state->_out_)
{
*--dest = *--src;
}
state->x.next = dest;
}
state->x.have++;
state->x.next--;
state->x.next[0] = (byte)c;
state->x.pos--;
state->past = 0;
return(c);
}
public static int gzeof(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return(0);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return(0);
}
return(state->mode == 7247 ? state->past : 0);
}
public static long gztell64(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return(-1);
}
return(state->x.pos + (state->seek != 0 ? state->skip : 0));
}
public static int gzdirect(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return((int)0);
}
state = (gz_state *)file;
if ((state->mode == 7247) && (state->how == 0) && (state->x.have == 0))
{
(void)gz_look(state);
}
return((int)state->direct);
}
public static int gzputc(gzFile_s *file, int c)
{
uint have = 0;
byte * buf = stackalloc byte[1];
gz_state * state;
z_stream_s strm;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
strm = &state->strm;
if ((state->mode != 31153) || (state->err != 0))
{
return(-1);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_zero(state, state->skip) == (-1))
{
return(-1);
}
}
if (state->size != 0)
{
if (strm.avail_in == 0)
{
strm.next_in = state->_in_;
}
have = (uint)(strm.next_in + strm.avail_in - state->_in_); if (have < state->size)
{
state->_in_[have] = (byte)c; strm.avail_in++; state->x.pos++; return(c & 0xff);
}
}
buf[0] = (byte)c;
if (gz_write(state, buf, 1) != 1)
{
return(-1);
}
return(c & 0xff);
}
public static int gzclose_w(gzFile_s *file)
{
int ret = 0;
gz_state *state;
if (file == ((void *)0))
{
return(-2);
}
state = (gz_state *)file;
if (state->mode != 31153)
{
return(-2);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_zero(state, state->skip) == (-1))
{
ret = state->err;
}
}
if (gz_comp(state, 4) == (-1))
{
ret = state->err;
}
if (state->size != 0)
{
if (state->direct == 0)
{
(void)deflateEnd(&state->strm); free(state->_out_);
}
free(state->_in_);
}
gz_error(state, 0, (void *)0);
free(state->path);
if (close(state->fd) == (-1))
{
ret = -1;
}
free(state);
return(ret);
}
public static sbyte *gzerror(gzFile_s *file, int *errnum)
{
gz_state *state;
if (file == ((void *)0))
{
return((void *)0);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return((void *)0);
}
if (errnum != ((void *)0))
{
*errnum = state->err;
}
return(state->err == (-4)?"out of memory":(state->msg == ((void *)0)?"":state->msg));
}
public static int gzputs(gzFile_s *file, sbyte *str)
{
int ret = 0;
ulong len = 0;
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 31153) || (state->err != 0))
{
return(-1);
}
len = strlen(str);
ret = (int)gz_write(state, str, len);
return((ret == 0) && (len != 0) ? -1 : ret);
}
public static int gzrewind(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return(-1);
}
if (_lseeki64(state->fd, state->start, 0) == (-1))
{
return(-1);
}
gz_reset(state);
return(0);
}
public static int gzwrite(gzFile_s *file, void *buf, uint len)
{
gz_state *state;
if (file == ((void *)0))
{
return(0);
}
state = (gz_state *)file;
if ((state->mode != 31153) || (state->err != 0))
{
return(0);
}
if (((int)len) < 0)
{
gz_error(state, -3, "requested length does not fit in int"); return(0);
}
return((int)gz_write(state, buf, len));
}
public static int gzsetparams(gzFile_s *file, int level, int strategy)
{
gz_state * state;
z_stream_s strm;
if (file == ((void *)0))
{
return(-2);
}
state = (gz_state *)file;
strm = &state->strm;
if ((state->mode != 31153) || (state->err != 0))
{
return(-2);
}
if ((level == state->level) && (strategy == state->strategy))
{
return(0);
}
if (state->seek != 0)
{
state->seek = 0;
if (gz_zero(state, state->skip) == (-1))
{
return(state->err);
}
}
if (state->size != 0)
{
if ((strm.avail_in != 0) && (gz_comp(state, 5) == (-1)))
{
return(state->err);
}
deflateParams(strm, level, strategy);
}
state->level = level;
state->strategy = strategy;
return(0);
}
public static void gzclearerr(gzFile_s *file)
{
gz_state *state;
if (file == ((void *)0))
{
return;
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return;
}
if (state->mode == 7247)
{
state->eof = 0;
state->past = 0;
}
gz_error(state, (int)0, (void *)0);
}
public static ulong gzfread(void *buf, ulong size, ulong nitems, gzFile_s *file)
{
ulong len = 0;
gz_state *state;
if (file == ((void *)0))
{
return(0);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return(0);
}
len = nitems * size;
if ((size != 0) && (len / size != nitems))
{
gz_error(state, -2, "request does not fit in a size_t"); return(0);
}
return(len != 0 ? gz_read(state, buf, len) / size : 0);
}
public static int gzgetc(gzFile_s *file)
{
int ret = 0;
byte * buf = stackalloc byte[1];
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) || ((state->err != 0) && (state->err != (-5))))
{
return(-1);
}
if (state->x.have != 0)
{
state->x.have--; state->x.pos++; return(*state->x.next++);
}
ret = (int)gz_read(state, buf, 1);
return(ret < 1 ? -1 : buf[0]);
}
public static long gzseek64(gzFile_s *file, long offset, int whence)
{
uint n = 0;
long ret = 0;
gz_state *state;
if (file == ((void *)0))
{
return(-1);
}
state = (gz_state *)file;
if ((state->mode != 7247) && (state->mode != 31153))
{
return(-1);
}
if ((state->err != 0) && (state->err != (-5)))
{
return(-1);
}
if ((whence != 0) && (whence != 1))
{
return(-1);
}
if (whence == 0)
{
offset -= state->x.pos;
}
else if (state->seek != 0)
{
offset += state->skip;
}
state->seek = 0;
if ((state->mode == 7247) && (state->how == 1) && ((state->x.pos + offset) >= 0))
{
ret = (long)_lseeki64(state->fd, offset - state->x.have, 1); if (ret == (-1))
{
return(-1);
}
state->x.have = 0;
state->eof = 0;
state->past = 0;
state->seek = 0;
gz_error(state, (int)0, (void *)0); state->strm.avail_in = 0;
state->x.pos += offset;
return(state->x.pos);
}
if (offset < 0)
{
if (state->mode != 7247)
{
return(-1);
}
offset += state->x.pos;
if (offset < 0)
{
return(-1);
}
if (gzrewind(file) == (-1))
{
return(-1);
}
}
if (state->mode == 7247)
{
n = (uint)(((==) && (state->x.have > 2147483647)) || (((long)state->x.have) > offset)?(uint)offset:state->x.have); state->x.have -= (uint)n; state->x.next += n; state->x.pos += (long)n; offset -= (long)n;
}
if (offset != 0)
{
state->seek = 1;
state->skip = offset;
}
return(state->x.pos + offset);
}
public static int gzgetc_(gzFile_s *file)
{
return(gzgetc(file));
}
