OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [gzio.c] - Blame information for rev 758

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 745 jeremybenn
/* gzio.c -- IO on .gz files
2
 * Copyright (C) 1995-2005 Jean-loup Gailly.
3
 * For conditions of distribution and use, see copyright notice in zlib.h
4
 *
5
 * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
6
 */
7
 
8
/* @(#) $Id: gzio.c,v 1.1.1.2 2002/03/11 21:53:24 tromey Exp $ */
9
 
10
#include <stdio.h>
11
 
12
#include "zutil.h"
13
 
14
#ifdef NO_DEFLATE       /* for compatibility with old definition */
15
#  define NO_GZCOMPRESS
16
#endif
17
 
18
#ifndef NO_DUMMY_DECL
19
struct internal_state {int dummy;}; /* for buggy compilers */
20
#endif
21
 
22
#ifndef Z_BUFSIZE
23
#  ifdef MAXSEG_64K
24
#    define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
25
#  else
26
#    define Z_BUFSIZE 16384
27
#  endif
28
#endif
29
#ifndef Z_PRINTF_BUFSIZE
30
#  define Z_PRINTF_BUFSIZE 4096
31
#endif
32
 
33
#ifdef __MVS__
34
#  pragma map (fdopen , "\174\174FDOPEN")
35
   FILE *fdopen(int, const char *);
36
#endif
37
 
38
#ifndef STDC
39
extern voidp  malloc OF((uInt size));
40
extern void   free   OF((voidpf ptr));
41
#endif
42
 
43
#define ALLOC(size) malloc(size)
44
#define TRYFREE(p) {if (p) free(p);}
45
 
46
static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
47
 
48
/* gzip flag byte */
49
#define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
50
#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
51
#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
52
#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
53
#define COMMENT      0x10 /* bit 4 set: file comment present */
54
#define RESERVED     0xE0 /* bits 5..7: reserved */
55
 
56
typedef struct gz_stream {
57
    z_stream stream;
58
    int      z_err;   /* error code for last stream operation */
59
    int      z_eof;   /* set if end of input file */
60
    FILE     *file;   /* .gz file */
61
    Byte     *inbuf;  /* input buffer */
62
    Byte     *outbuf; /* output buffer */
63
    uLong    crc;     /* crc32 of uncompressed data */
64
    char     *msg;    /* error message */
65
    char     *path;   /* path name for debugging only */
66
    int      transparent; /* 1 if input file is not a .gz file */
67
    char     mode;    /* 'w' or 'r' */
68
    z_off_t  start;   /* start of compressed data in file (header skipped) */
69
    z_off_t  in;      /* bytes into deflate or inflate */
70
    z_off_t  out;     /* bytes out of deflate or inflate */
71
    int      back;    /* one character push-back */
72
    int      last;    /* true if push-back is last character */
73
} gz_stream;
74
 
75
 
76
local gzFile gz_open      OF((const char *path, const char *mode, int  fd));
77
local int do_flush        OF((gzFile file, int flush));
78
local int    get_byte     OF((gz_stream *s));
79
local void   check_header OF((gz_stream *s));
80
local int    destroy      OF((gz_stream *s));
81
local void   putLong      OF((FILE *file, uLong x));
82
local uLong  getLong      OF((gz_stream *s));
83
 
84
/* ===========================================================================
85
     Opens a gzip (.gz) file for reading or writing. The mode parameter
86
   is as in fopen ("rb" or "wb"). The file is given either by file descriptor
87
   or path name (if fd == -1).
88
     gz_open returns NULL if the file could not be opened or if there was
89
   insufficient memory to allocate the (de)compression state; errno
90
   can be checked to distinguish the two cases (if errno is zero, the
91
   zlib error is Z_MEM_ERROR).
92
*/
93
local gzFile gz_open (path, mode, fd)
94
    const char *path;
95
    const char *mode;
96
    int  fd;
97
{
98
    int err;
99
    int level = Z_DEFAULT_COMPRESSION; /* compression level */
100
    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
101
    char *p = (char*)mode;
102
    gz_stream *s;
103
    char fmode[80]; /* copy of mode, without the compression level */
104
    char *m = fmode;
105
 
106
    if (!path || !mode) return Z_NULL;
107
 
108
    s = (gz_stream *)ALLOC(sizeof(gz_stream));
109
    if (!s) return Z_NULL;
110
 
111
    s->stream.zalloc = (alloc_func)0;
112
    s->stream.zfree = (free_func)0;
113
    s->stream.opaque = (voidpf)0;
114
    s->stream.next_in = s->inbuf = Z_NULL;
115
    s->stream.next_out = s->outbuf = Z_NULL;
116
    s->stream.avail_in = s->stream.avail_out = 0;
117
    s->file = NULL;
118
    s->z_err = Z_OK;
119
    s->z_eof = 0;
120
    s->in = 0;
121
    s->out = 0;
122
    s->back = EOF;
123
    s->crc = crc32(0L, Z_NULL, 0);
124
    s->msg = NULL;
125
    s->transparent = 0;
126
 
127
    s->path = (char*)ALLOC(strlen(path)+1);
128
    if (s->path == NULL) {
129
        return destroy(s), (gzFile)Z_NULL;
130
    }
131
    strcpy(s->path, path); /* do this early for debugging */
132
 
133
    s->mode = '\0';
134
    do {
135
        if (*p == 'r') s->mode = 'r';
136
        if (*p == 'w' || *p == 'a') s->mode = 'w';
137
        if (*p >= '0' && *p <= '9') {
138
            level = *p - '0';
139
        } else if (*p == 'f') {
140
          strategy = Z_FILTERED;
141
        } else if (*p == 'h') {
142
          strategy = Z_HUFFMAN_ONLY;
143
        } else if (*p == 'R') {
144
          strategy = Z_RLE;
145
        } else {
146
            *m++ = *p; /* copy the mode */
147
        }
148
    } while (*p++ && m != fmode + sizeof(fmode));
149
    if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
150
 
151
    if (s->mode == 'w') {
152
#ifdef NO_GZCOMPRESS
153
        err = Z_STREAM_ERROR;
154
#else
155
        err = deflateInit2(&(s->stream), level,
156
                           Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
157
        /* windowBits is passed < 0 to suppress zlib header */
158
 
159
        s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
160
#endif
161
        if (err != Z_OK || s->outbuf == Z_NULL) {
162
            return destroy(s), (gzFile)Z_NULL;
163
        }
164
    } else {
165
        s->stream.next_in  = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
166
 
167
        err = inflateInit2(&(s->stream), -MAX_WBITS);
168
        /* windowBits is passed < 0 to tell that there is no zlib header.
169
         * Note that in this case inflate *requires* an extra "dummy" byte
170
         * after the compressed stream in order to complete decompression and
171
         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
172
         * present after the compressed stream.
173
         */
174
        if (err != Z_OK || s->inbuf == Z_NULL) {
175
            return destroy(s), (gzFile)Z_NULL;
176
        }
177
    }
178
    s->stream.avail_out = Z_BUFSIZE;
179
 
180
    errno = 0;
181
    s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
182
 
183
    if (s->file == NULL) {
184
        return destroy(s), (gzFile)Z_NULL;
185
    }
186
    if (s->mode == 'w') {
187
        /* Write a very simple .gz header:
188
         */
189
        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
190
             Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
191
        s->start = 10L;
192
        /* We use 10L instead of ftell(s->file) to because ftell causes an
193
         * fflush on some systems. This version of the library doesn't use
194
         * start anyway in write mode, so this initialization is not
195
         * necessary.
196
         */
197
    } else {
198
        check_header(s); /* skip the .gz header */
199
        s->start = ftell(s->file) - s->stream.avail_in;
200
    }
201
 
202
    return (gzFile)s;
203
}
204
 
205
/* ===========================================================================
206
     Opens a gzip (.gz) file for reading or writing.
207
*/
208
gzFile ZEXPORT gzopen (path, mode)
209
    const char *path;
210
    const char *mode;
211
{
212
    return gz_open (path, mode, -1);
213
}
214
 
215
/* ===========================================================================
216
     Associate a gzFile with the file descriptor fd. fd is not dup'ed here
217
   to mimic the behavio(u)r of fdopen.
218
*/
219
gzFile ZEXPORT gzdopen (fd, mode)
220
    int fd;
221
    const char *mode;
222
{
223
    char name[46];      /* allow for up to 128-bit integers */
224
 
225
    if (fd < 0) return (gzFile)Z_NULL;
226
    sprintf(name, "<fd:%d>", fd); /* for debugging */
227
 
228
    return gz_open (name, mode, fd);
229
}
230
 
231
/* ===========================================================================
232
 * Update the compression level and strategy
233
 */
234
int ZEXPORT gzsetparams (file, level, strategy)
235
    gzFile file;
236
    int level;
237
    int strategy;
238
{
239
    gz_stream *s = (gz_stream*)file;
240
 
241
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
242
 
243
    /* Make room to allow flushing */
244
    if (s->stream.avail_out == 0) {
245
 
246
        s->stream.next_out = s->outbuf;
247
        if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
248
            s->z_err = Z_ERRNO;
249
        }
250
        s->stream.avail_out = Z_BUFSIZE;
251
    }
252
 
253
    return deflateParams (&(s->stream), level, strategy);
254
}
255
 
256
/* ===========================================================================
257
     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
258
   for end of file.
259
   IN assertion: the stream s has been sucessfully opened for reading.
260
*/
261
local int get_byte(s)
262
    gz_stream *s;
263
{
264
    if (s->z_eof) return EOF;
265
    if (s->stream.avail_in == 0) {
266
        errno = 0;
267
        s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
268
        if (s->stream.avail_in == 0) {
269
            s->z_eof = 1;
270
            if (ferror(s->file)) s->z_err = Z_ERRNO;
271
            return EOF;
272
        }
273
        s->stream.next_in = s->inbuf;
274
    }
275
    s->stream.avail_in--;
276
    return *(s->stream.next_in)++;
277
}
278
 
279
/* ===========================================================================
280
      Check the gzip header of a gz_stream opened for reading. Set the stream
281
    mode to transparent if the gzip magic header is not present; set s->err
282
    to Z_DATA_ERROR if the magic header is present but the rest of the header
283
    is incorrect.
284
    IN assertion: the stream s has already been created sucessfully;
285
       s->stream.avail_in is zero for the first time, but may be non-zero
286
       for concatenated .gz files.
287
*/
288
local void check_header(s)
289
    gz_stream *s;
290
{
291
    int method; /* method byte */
292
    int flags;  /* flags byte */
293
    uInt len;
294
    int c;
295
 
296
    /* Assure two bytes in the buffer so we can peek ahead -- handle case
297
       where first byte of header is at the end of the buffer after the last
298
       gzip segment */
299
    len = s->stream.avail_in;
300
    if (len < 2) {
301
        if (len) s->inbuf[0] = s->stream.next_in[0];
302
        errno = 0;
303
        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
304
        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
305
        s->stream.avail_in += len;
306
        s->stream.next_in = s->inbuf;
307
        if (s->stream.avail_in < 2) {
308
            s->transparent = s->stream.avail_in;
309
            return;
310
        }
311
    }
312
 
313
    /* Peek ahead to check the gzip magic header */
314
    if (s->stream.next_in[0] != gz_magic[0] ||
315
        s->stream.next_in[1] != gz_magic[1]) {
316
        s->transparent = 1;
317
        return;
318
    }
319
    s->stream.avail_in -= 2;
320
    s->stream.next_in += 2;
321
 
322
    /* Check the rest of the gzip header */
323
    method = get_byte(s);
324
    flags = get_byte(s);
325
    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
326
        s->z_err = Z_DATA_ERROR;
327
        return;
328
    }
329
 
330
    /* Discard time, xflags and OS code: */
331
    for (len = 0; len < 6; len++) (void)get_byte(s);
332
 
333
    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
334
        len  =  (uInt)get_byte(s);
335
        len += ((uInt)get_byte(s))<<8;
336
        /* len is garbage if EOF but the loop below will quit anyway */
337
        while (len-- != 0 && get_byte(s) != EOF) ;
338
    }
339
    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
340
        while ((c = get_byte(s)) != 0 && c != EOF) ;
341
    }
342
    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
343
        while ((c = get_byte(s)) != 0 && c != EOF) ;
344
    }
345
    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
346
        for (len = 0; len < 2; len++) (void)get_byte(s);
347
    }
348
    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
349
}
350
 
351
 /* ===========================================================================
352
 * Cleanup then free the given gz_stream. Return a zlib error code.
353
   Try freeing in the reverse order of allocations.
354
 */
355
local int destroy (s)
356
    gz_stream *s;
357
{
358
    int err = Z_OK;
359
 
360
    if (!s) return Z_STREAM_ERROR;
361
 
362
    TRYFREE(s->msg);
363
 
364
    if (s->stream.state != NULL) {
365
        if (s->mode == 'w') {
366
#ifdef NO_GZCOMPRESS
367
            err = Z_STREAM_ERROR;
368
#else
369
            err = deflateEnd(&(s->stream));
370
#endif
371
        } else if (s->mode == 'r') {
372
            err = inflateEnd(&(s->stream));
373
        }
374
    }
375
    if (s->file != NULL && fclose(s->file)) {
376
#ifdef ESPIPE
377
        if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
378
#endif
379
            err = Z_ERRNO;
380
    }
381
    if (s->z_err < 0) err = s->z_err;
382
 
383
    TRYFREE(s->inbuf);
384
    TRYFREE(s->outbuf);
385
    TRYFREE(s->path);
386
    TRYFREE(s);
387
    return err;
388
}
389
 
390
/* ===========================================================================
391
     Reads the given number of uncompressed bytes from the compressed file.
392
   gzread returns the number of bytes actually read (0 for end of file).
393
*/
394
int ZEXPORT gzread (file, buf, len)
395
    gzFile file;
396
    voidp buf;
397
    unsigned len;
398
{
399
    gz_stream *s = (gz_stream*)file;
400
    Bytef *start = (Bytef*)buf; /* starting point for crc computation */
401
    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
402
 
403
    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
404
 
405
    if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
406
    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
407
 
408
    next_out = (Byte*)buf;
409
    s->stream.next_out = (Bytef*)buf;
410
    s->stream.avail_out = len;
411
 
412
    if (s->stream.avail_out && s->back != EOF) {
413
        *next_out++ = s->back;
414
        s->stream.next_out++;
415
        s->stream.avail_out--;
416
        s->back = EOF;
417
        s->out++;
418
        start++;
419
        if (s->last) {
420
            s->z_err = Z_STREAM_END;
421
            return 1;
422
        }
423
    }
424
 
425
    while (s->stream.avail_out != 0) {
426
 
427
        if (s->transparent) {
428
            /* Copy first the lookahead bytes: */
429
            uInt n = s->stream.avail_in;
430
            if (n > s->stream.avail_out) n = s->stream.avail_out;
431
            if (n > 0) {
432
                zmemcpy(s->stream.next_out, s->stream.next_in, n);
433
                next_out += n;
434
                s->stream.next_out = next_out;
435
                s->stream.next_in   += n;
436
                s->stream.avail_out -= n;
437
                s->stream.avail_in  -= n;
438
            }
439
            if (s->stream.avail_out > 0) {
440
                s->stream.avail_out -=
441
                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
442
            }
443
            len -= s->stream.avail_out;
444
            s->in  += len;
445
            s->out += len;
446
            if (len == 0) s->z_eof = 1;
447
            return (int)len;
448
        }
449
        if (s->stream.avail_in == 0 && !s->z_eof) {
450
 
451
            errno = 0;
452
            s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
453
            if (s->stream.avail_in == 0) {
454
                s->z_eof = 1;
455
                if (ferror(s->file)) {
456
                    s->z_err = Z_ERRNO;
457
                    break;
458
                }
459
            }
460
            s->stream.next_in = s->inbuf;
461
        }
462
        s->in += s->stream.avail_in;
463
        s->out += s->stream.avail_out;
464
        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
465
        s->in -= s->stream.avail_in;
466
        s->out -= s->stream.avail_out;
467
 
468
        if (s->z_err == Z_STREAM_END) {
469
            /* Check CRC and original size */
470
            s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
471
            start = s->stream.next_out;
472
 
473
            if (getLong(s) != s->crc) {
474
                s->z_err = Z_DATA_ERROR;
475
            } else {
476
                (void)getLong(s);
477
                /* The uncompressed length returned by above getlong() may be
478
                 * different from s->out in case of concatenated .gz files.
479
                 * Check for such files:
480
                 */
481
                check_header(s);
482
                if (s->z_err == Z_OK) {
483
                    inflateReset(&(s->stream));
484
                    s->crc = crc32(0L, Z_NULL, 0);
485
                }
486
            }
487
        }
488
        if (s->z_err != Z_OK || s->z_eof) break;
489
    }
490
    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
491
 
492
    if (len == s->stream.avail_out &&
493
        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
494
        return -1;
495
    return (int)(len - s->stream.avail_out);
496
}
497
 
498
 
499
/* ===========================================================================
500
      Reads one byte from the compressed file. gzgetc returns this byte
501
   or -1 in case of end of file or error.
502
*/
503
int ZEXPORT gzgetc(file)
504
    gzFile file;
505
{
506
    unsigned char c;
507
 
508
    return gzread(file, &c, 1) == 1 ? c : -1;
509
}
510
 
511
 
512
/* ===========================================================================
513
      Push one byte back onto the stream.
514
*/
515
int ZEXPORT gzungetc(c, file)
516
    int c;
517
    gzFile file;
518
{
519
    gz_stream *s = (gz_stream*)file;
520
 
521
    if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
522
    s->back = c;
523
    s->out--;
524
    s->last = (s->z_err == Z_STREAM_END);
525
    if (s->last) s->z_err = Z_OK;
526
    s->z_eof = 0;
527
    return c;
528
}
529
 
530
 
531
/* ===========================================================================
532
      Reads bytes from the compressed file until len-1 characters are
533
   read, or a newline character is read and transferred to buf, or an
534
   end-of-file condition is encountered.  The string is then terminated
535
   with a null character.
536
      gzgets returns buf, or Z_NULL in case of error.
537
 
538
      The current implementation is not optimized at all.
539
*/
540
char * ZEXPORT gzgets(file, buf, len)
541
    gzFile file;
542
    char *buf;
543
    int len;
544
{
545
    char *b = buf;
546
    if (buf == Z_NULL || len <= 0) return Z_NULL;
547
 
548
    while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
549
    *buf = '\0';
550
    return b == buf && len > 0 ? Z_NULL : b;
551
}
552
 
553
 
554
#ifndef NO_GZCOMPRESS
555
/* ===========================================================================
556
     Writes the given number of uncompressed bytes into the compressed file.
557
   gzwrite returns the number of bytes actually written (0 in case of error).
558
*/
559
int ZEXPORT gzwrite (file, buf, len)
560
    gzFile file;
561
    voidpc buf;
562
    unsigned len;
563
{
564
    gz_stream *s = (gz_stream*)file;
565
 
566
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
567
 
568
    s->stream.next_in = (Bytef*)buf;
569
    s->stream.avail_in = len;
570
 
571
    while (s->stream.avail_in != 0) {
572
 
573
        if (s->stream.avail_out == 0) {
574
 
575
            s->stream.next_out = s->outbuf;
576
            if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
577
                s->z_err = Z_ERRNO;
578
                break;
579
            }
580
            s->stream.avail_out = Z_BUFSIZE;
581
        }
582
        s->in += s->stream.avail_in;
583
        s->out += s->stream.avail_out;
584
        s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
585
        s->in -= s->stream.avail_in;
586
        s->out -= s->stream.avail_out;
587
        if (s->z_err != Z_OK) break;
588
    }
589
    s->crc = crc32(s->crc, (const Bytef *)buf, len);
590
 
591
    return (int)(len - s->stream.avail_in);
592
}
593
 
594
 
595
/* ===========================================================================
596
     Converts, formats, and writes the args to the compressed file under
597
   control of the format string, as in fprintf. gzprintf returns the number of
598
   uncompressed bytes actually written (0 in case of error).
599
*/
600
#ifdef STDC
601
#include <stdarg.h>
602
 
603
int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
604
{
605
    char buf[Z_PRINTF_BUFSIZE];
606
    va_list va;
607
    int len;
608
 
609
    buf[sizeof(buf) - 1] = 0;
610
    va_start(va, format);
611
#ifdef NO_vsnprintf
612
#  ifdef HAS_vsprintf_void
613
    (void)vsprintf(buf, format, va);
614
    va_end(va);
615
    for (len = 0; len < sizeof(buf); len++)
616
        if (buf[len] == 0) break;
617
#  else
618
    len = vsprintf(buf, format, va);
619
    va_end(va);
620
#  endif
621
#else
622
#  ifdef HAS_vsnprintf_void
623
    (void)vsnprintf(buf, sizeof(buf), format, va);
624
    va_end(va);
625
    len = strlen(buf);
626
#  else
627
    len = vsnprintf(buf, sizeof(buf), format, va);
628
    va_end(va);
629
#  endif
630
#endif
631
    if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
632
        return 0;
633
    return gzwrite(file, buf, (unsigned)len);
634
}
635
#else /* not ANSI C */
636
 
637
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
638
                       a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
639
    gzFile file;
640
    const char *format;
641
    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
642
        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
643
{
644
    char buf[Z_PRINTF_BUFSIZE];
645
    int len;
646
 
647
    buf[sizeof(buf) - 1] = 0;
648
#ifdef NO_snprintf
649
#  ifdef HAS_sprintf_void
650
    sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
651
            a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
652
    for (len = 0; len < sizeof(buf); len++)
653
        if (buf[len] == 0) break;
654
#  else
655
    len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
656
                a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
657
#  endif
658
#else
659
#  ifdef HAS_snprintf_void
660
    snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
661
             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
662
    len = strlen(buf);
663
#  else
664
    len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
665
                 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
666
#  endif
667
#endif
668
    if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
669
        return 0;
670
    return gzwrite(file, buf, len);
671
}
672
#endif
673
 
674
/* ===========================================================================
675
      Writes c, converted to an unsigned char, into the compressed file.
676
   gzputc returns the value that was written, or -1 in case of error.
677
*/
678
int ZEXPORT gzputc(file, c)
679
    gzFile file;
680
    int c;
681
{
682
    unsigned char cc = (unsigned char) c; /* required for big endian systems */
683
 
684
    return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
685
}
686
 
687
 
688
/* ===========================================================================
689
      Writes the given null-terminated string to the compressed file, excluding
690
   the terminating null character.
691
      gzputs returns the number of characters written, or -1 in case of error.
692
*/
693
int ZEXPORT gzputs(file, s)
694
    gzFile file;
695
    const char *s;
696
{
697
    return gzwrite(file, (char*)s, (unsigned)strlen(s));
698
}
699
 
700
 
701
/* ===========================================================================
702
     Flushes all pending output into the compressed file. The parameter
703
   flush is as in the deflate() function.
704
*/
705
local int do_flush (file, flush)
706
    gzFile file;
707
    int flush;
708
{
709
    uInt len;
710
    int done = 0;
711
    gz_stream *s = (gz_stream*)file;
712
 
713
    if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
714
 
715
    s->stream.avail_in = 0; /* should be zero already anyway */
716
 
717
    for (;;) {
718
        len = Z_BUFSIZE - s->stream.avail_out;
719
 
720
        if (len != 0) {
721
            if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
722
                s->z_err = Z_ERRNO;
723
                return Z_ERRNO;
724
            }
725
            s->stream.next_out = s->outbuf;
726
            s->stream.avail_out = Z_BUFSIZE;
727
        }
728
        if (done) break;
729
        s->out += s->stream.avail_out;
730
        s->z_err = deflate(&(s->stream), flush);
731
        s->out -= s->stream.avail_out;
732
 
733
        /* Ignore the second of two consecutive flushes: */
734
        if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
735
 
736
        /* deflate has finished flushing only when it hasn't used up
737
         * all the available space in the output buffer:
738
         */
739
        done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
740
 
741
        if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
742
    }
743
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
744
}
745
 
746
int ZEXPORT gzflush (file, flush)
747
     gzFile file;
748
     int flush;
749
{
750
    gz_stream *s = (gz_stream*)file;
751
    int err = do_flush (file, flush);
752
 
753
    if (err) return err;
754
    fflush(s->file);
755
    return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
756
}
757
#endif /* NO_GZCOMPRESS */
758
 
759
/* ===========================================================================
760
      Sets the starting position for the next gzread or gzwrite on the given
761
   compressed file. The offset represents a number of bytes in the
762
      gzseek returns the resulting offset location as measured in bytes from
763
   the beginning of the uncompressed stream, or -1 in case of error.
764
      SEEK_END is not implemented, returns error.
765
      In this version of the library, gzseek can be extremely slow.
766
*/
767
z_off_t ZEXPORT gzseek (file, offset, whence)
768
    gzFile file;
769
    z_off_t offset;
770
    int whence;
771
{
772
    gz_stream *s = (gz_stream*)file;
773
 
774
    if (s == NULL || whence == SEEK_END ||
775
        s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
776
        return -1L;
777
    }
778
 
779
    if (s->mode == 'w') {
780
#ifdef NO_GZCOMPRESS
781
        return -1L;
782
#else
783
        if (whence == SEEK_SET) {
784
            offset -= s->in;
785
        }
786
        if (offset < 0) return -1L;
787
 
788
        /* At this point, offset is the number of zero bytes to write. */
789
        if (s->inbuf == Z_NULL) {
790
            s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
791
            if (s->inbuf == Z_NULL) return -1L;
792
            zmemzero(s->inbuf, Z_BUFSIZE);
793
        }
794
        while (offset > 0)  {
795
            uInt size = Z_BUFSIZE;
796
            if (offset < Z_BUFSIZE) size = (uInt)offset;
797
 
798
            size = gzwrite(file, s->inbuf, size);
799
            if (size == 0) return -1L;
800
 
801
            offset -= size;
802
        }
803
        return s->in;
804
#endif
805
    }
806
    /* Rest of function is for reading only */
807
 
808
    /* compute absolute position */
809
    if (whence == SEEK_CUR) {
810
        offset += s->out;
811
    }
812
    if (offset < 0) return -1L;
813
 
814
    if (s->transparent) {
815
        /* map to fseek */
816
        s->back = EOF;
817
        s->stream.avail_in = 0;
818
        s->stream.next_in = s->inbuf;
819
        if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
820
 
821
        s->in = s->out = offset;
822
        return offset;
823
    }
824
 
825
    /* For a negative seek, rewind and use positive seek */
826
    if (offset >= s->out) {
827
        offset -= s->out;
828
    } else if (gzrewind(file) < 0) {
829
        return -1L;
830
    }
831
    /* offset is now the number of bytes to skip. */
832
 
833
    if (offset != 0 && s->outbuf == Z_NULL) {
834
        s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
835
        if (s->outbuf == Z_NULL) return -1L;
836
    }
837
    if (offset && s->back != EOF) {
838
        s->back = EOF;
839
        s->out++;
840
        offset--;
841
        if (s->last) s->z_err = Z_STREAM_END;
842
    }
843
    while (offset > 0)  {
844
        int size = Z_BUFSIZE;
845
        if (offset < Z_BUFSIZE) size = (int)offset;
846
 
847
        size = gzread(file, s->outbuf, (uInt)size);
848
        if (size <= 0) return -1L;
849
        offset -= size;
850
    }
851
    return s->out;
852
}
853
 
854
/* ===========================================================================
855
     Rewinds input file.
856
*/
857
int ZEXPORT gzrewind (file)
858
    gzFile file;
859
{
860
    gz_stream *s = (gz_stream*)file;
861
 
862
    if (s == NULL || s->mode != 'r') return -1;
863
 
864
    s->z_err = Z_OK;
865
    s->z_eof = 0;
866
    s->back = EOF;
867
    s->stream.avail_in = 0;
868
    s->stream.next_in = s->inbuf;
869
    s->crc = crc32(0L, Z_NULL, 0);
870
    if (!s->transparent) (void)inflateReset(&s->stream);
871
    s->in = 0;
872
    s->out = 0;
873
    return fseek(s->file, s->start, SEEK_SET);
874
}
875
 
876
/* ===========================================================================
877
     Returns the starting position for the next gzread or gzwrite on the
878
   given compressed file. This position represents a number of bytes in the
879
   uncompressed data stream.
880
*/
881
z_off_t ZEXPORT gztell (file)
882
    gzFile file;
883
{
884
    return gzseek(file, 0L, SEEK_CUR);
885
}
886
 
887
/* ===========================================================================
888
     Returns 1 when EOF has previously been detected reading the given
889
   input stream, otherwise zero.
890
*/
891
int ZEXPORT gzeof (file)
892
    gzFile file;
893
{
894
    gz_stream *s = (gz_stream*)file;
895
 
896
    /* With concatenated compressed files that can have embedded
897
     * crc trailers, z_eof is no longer the only/best indicator of EOF
898
     * on a gz_stream. Handle end-of-stream error explicitly here.
899
     */
900
    if (s == NULL || s->mode != 'r') return 0;
901
    if (s->z_eof) return 1;
902
    return s->z_err == Z_STREAM_END;
903
}
904
 
905
/* ===========================================================================
906
     Returns 1 if reading and doing so transparently, otherwise zero.
907
*/
908
int ZEXPORT gzdirect (file)
909
    gzFile file;
910
{
911
    gz_stream *s = (gz_stream*)file;
912
 
913
    if (s == NULL || s->mode != 'r') return 0;
914
    return s->transparent;
915
}
916
 
917
/* ===========================================================================
918
   Outputs a long in LSB order to the given file
919
*/
920
local void putLong (file, x)
921
    FILE *file;
922
    uLong x;
923
{
924
    int n;
925
    for (n = 0; n < 4; n++) {
926
        fputc((int)(x & 0xff), file);
927
        x >>= 8;
928
    }
929
}
930
 
931
/* ===========================================================================
932
   Reads a long in LSB order from the given gz_stream. Sets z_err in case
933
   of error.
934
*/
935
local uLong getLong (s)
936
    gz_stream *s;
937
{
938
    uLong x = (uLong)get_byte(s);
939
    int c;
940
 
941
    x += ((uLong)get_byte(s))<<8;
942
    x += ((uLong)get_byte(s))<<16;
943
    c = get_byte(s);
944
    if (c == EOF) s->z_err = Z_DATA_ERROR;
945
    x += ((uLong)c)<<24;
946
    return x;
947
}
948
 
949
/* ===========================================================================
950
     Flushes all pending output if necessary, closes the compressed file
951
   and deallocates all the (de)compression state.
952
*/
953
int ZEXPORT gzclose (file)
954
    gzFile file;
955
{
956
    gz_stream *s = (gz_stream*)file;
957
 
958
    if (s == NULL) return Z_STREAM_ERROR;
959
 
960
    if (s->mode == 'w') {
961
#ifdef NO_GZCOMPRESS
962
        return Z_STREAM_ERROR;
963
#else
964
        if (do_flush (file, Z_FINISH) != Z_OK)
965
            return destroy((gz_stream*)file);
966
 
967
        putLong (s->file, s->crc);
968
        putLong (s->file, (uLong)(s->in & 0xffffffff));
969
#endif
970
    }
971
    return destroy((gz_stream*)file);
972
}
973
 
974
#ifdef STDC
975
#  define zstrerror(errnum) strerror(errnum)
976
#else
977
#  define zstrerror(errnum) ""
978
#endif
979
 
980
/* ===========================================================================
981
     Returns the error message for the last error which occurred on the
982
   given compressed file. errnum is set to zlib error number. If an
983
   error occurred in the file system and not in the compression library,
984
   errnum is set to Z_ERRNO and the application may consult errno
985
   to get the exact error code.
986
*/
987
const char * ZEXPORT gzerror (file, errnum)
988
    gzFile file;
989
    int *errnum;
990
{
991
    char *m;
992
    gz_stream *s = (gz_stream*)file;
993
 
994
    if (s == NULL) {
995
        *errnum = Z_STREAM_ERROR;
996
        return (const char*)ERR_MSG(Z_STREAM_ERROR);
997
    }
998
    *errnum = s->z_err;
999
    if (*errnum == Z_OK) return (const char*)"";
1000
 
1001
    m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
1002
 
1003
    if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
1004
 
1005
    TRYFREE(s->msg);
1006
    s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1007
    if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
1008
    strcpy(s->msg, s->path);
1009
    strcat(s->msg, ": ");
1010
    strcat(s->msg, m);
1011
    return (const char*)s->msg;
1012
}
1013
 
1014
/* ===========================================================================
1015
     Clear the error and end-of-file flags, and do the same for the real file.
1016
*/
1017
void ZEXPORT gzclearerr (file)
1018
    gzFile file;
1019
{
1020
    gz_stream *s = (gz_stream*)file;
1021
 
1022
    if (s == NULL) return;
1023
    if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1024
    s->z_eof = 0;
1025
    clearerr(s->file);
1026
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.