Changeset 8c05550 in rtems


Ignore:
Timestamp:
Mar 18, 2011, 10:11:07 AM (9 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.11, master
Children:
a96fad0, d159dd8
Parents:
9f5ede0
Message:

Import from zlib-1.2.4

Location:
cpukit/zlib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/zlib/infback.c

    r9f5ede0 r8c05550  
    11/* infback.c -- inflate using a call-back interface
    2  * Copyright (C) 1995-2005 Mark Adler
     2 * Copyright (C) 1995-2009 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    5656    state->wsize = 1U << windowBits;
    5757    state->window = window;
    58     state->write = 0;
     58    state->wnext = 0;
    5959    state->whave = 0;
    6060    return Z_OK;
     
    254254    unsigned copy;              /* number of stored or match bytes to copy */
    255255    unsigned char FAR *from;    /* where to copy match bytes from */
    256     code this;                  /* current decoding table entry */
     256    code here;                  /* current decoding table entry */
    257257    code last;                  /* parent table entry */
    258258    unsigned len;               /* length to copy for repeats, bits to drop */
     
    390390            while (state->have < state->nlen + state->ndist) {
    391391                for (;;) {
    392                     this = state->lencode[BITS(state->lenbits)];
    393                     if ((unsigned)(this.bits) <= bits) break;
     392                    here = state->lencode[BITS(state->lenbits)];
     393                    if ((unsigned)(here.bits) <= bits) break;
    394394                    PULLBYTE();
    395395                }
    396                 if (this.val < 16) {
    397                     NEEDBITS(this.bits);
    398                     DROPBITS(this.bits);
    399                     state->lens[state->have++] = this.val;
     396                if (here.val < 16) {
     397                    NEEDBITS(here.bits);
     398                    DROPBITS(here.bits);
     399                    state->lens[state->have++] = here.val;
    400400                }
    401401                else {
    402                     if (this.val == 16) {
    403                         NEEDBITS(this.bits + 2);
    404                         DROPBITS(this.bits);
     402                    if (here.val == 16) {
     403                        NEEDBITS(here.bits + 2);
     404                        DROPBITS(here.bits);
    405405                        if (state->have == 0) {
    406406                            strm->msg = (char *)"invalid bit length repeat";
     
    412412                        DROPBITS(2);
    413413                    }
    414                     else if (this.val == 17) {
    415                         NEEDBITS(this.bits + 3);
    416                         DROPBITS(this.bits);
     414                    else if (here.val == 17) {
     415                        NEEDBITS(here.bits + 3);
     416                        DROPBITS(here.bits);
    417417                        len = 0;
    418418                        copy = 3 + BITS(3);
     
    420420                    }
    421421                    else {
    422                         NEEDBITS(this.bits + 7);
    423                         DROPBITS(this.bits);
     422                        NEEDBITS(here.bits + 7);
     423                        DROPBITS(here.bits);
    424424                        len = 0;
    425425                        copy = 11 + BITS(7);
     
    439439            if (state->mode == BAD) break;
    440440
    441             /* build code tables */
     441            /* check for end-of-block code (better have one) */
     442            if (state->lens[256] == 0) {
     443                strm->msg = (char *)"invalid code -- missing end-of-block";
     444                state->mode = BAD;
     445                break;
     446            }
     447
     448            /* build code tables -- note: do not change the lenbits or distbits
     449               values here (9 and 6) without reading the comments in inftrees.h
     450               concerning the ENOUGH constants, which depend on those values */
    442451            state->next = state->codes;
    443452            state->lencode = (code const FAR *)(state->next);
     
    475484            /* get a literal, length, or end-of-block code */
    476485            for (;;) {
    477                 this = state->lencode[BITS(state->lenbits)];
    478                 if ((unsigned)(this.bits) <= bits) break;
     486                here = state->lencode[BITS(state->lenbits)];
     487                if ((unsigned)(here.bits) <= bits) break;
    479488                PULLBYTE();
    480489            }
    481             if (this.op && (this.op & 0xf0) == 0) {
    482                 last = this;
     490            if (here.op && (here.op & 0xf0) == 0) {
     491                last = here;
    483492                for (;;) {
    484                     this = state->lencode[last.val +
     493                    here = state->lencode[last.val +
    485494                            (BITS(last.bits + last.op) >> last.bits)];
    486                     if ((unsigned)(last.bits + this.bits) <= bits) break;
     495                    if ((unsigned)(last.bits + here.bits) <= bits) break;
    487496                    PULLBYTE();
    488497                }
    489498                DROPBITS(last.bits);
    490499            }
    491             DROPBITS(this.bits);
    492             state->length = (unsigned)this.val;
     500            DROPBITS(here.bits);
     501            state->length = (unsigned)here.val;
    493502
    494503            /* process literal */
    495             if (this.op == 0) {
    496                 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
     504            if (here.op == 0) {
     505                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
    497506                        "inflate:         literal '%c'\n" :
    498                         "inflate:         literal 0x%02x\n", this.val));
     507                        "inflate:         literal 0x%02x\n", here.val));
    499508                ROOM();
    500509                *put++ = (unsigned char)(state->length);
     
    505514
    506515            /* process end of block */
    507             if (this.op & 32) {
     516            if (here.op & 32) {
    508517                Tracevv((stderr, "inflate:         end of block\n"));
    509518                state->mode = TYPE;
     
    512521
    513522            /* invalid code */
    514             if (this.op & 64) {
     523            if (here.op & 64) {
    515524                strm->msg = (char *)"invalid literal/length code";
    516525                state->mode = BAD;
     
    519528
    520529            /* length code -- get extra bits, if any */
    521             state->extra = (unsigned)(this.op) & 15;
     530            state->extra = (unsigned)(here.op) & 15;
    522531            if (state->extra != 0) {
    523532                NEEDBITS(state->extra);
     
    529538            /* get distance code */
    530539            for (;;) {
    531                 this = state->distcode[BITS(state->distbits)];
    532                 if ((unsigned)(this.bits) <= bits) break;
     540                here = state->distcode[BITS(state->distbits)];
     541                if ((unsigned)(here.bits) <= bits) break;
    533542                PULLBYTE();
    534543            }
    535             if ((this.op & 0xf0) == 0) {
    536                 last = this;
     544            if ((here.op & 0xf0) == 0) {
     545                last = here;
    537546                for (;;) {
    538                     this = state->distcode[last.val +
     547                    here = state->distcode[last.val +
    539548                            (BITS(last.bits + last.op) >> last.bits)];
    540                     if ((unsigned)(last.bits + this.bits) <= bits) break;
     549                    if ((unsigned)(last.bits + here.bits) <= bits) break;
    541550                    PULLBYTE();
    542551                }
    543552                DROPBITS(last.bits);
    544553            }
    545             DROPBITS(this.bits);
    546             if (this.op & 64) {
     554            DROPBITS(here.bits);
     555            if (here.op & 64) {
    547556                strm->msg = (char *)"invalid distance code";
    548557                state->mode = BAD;
    549558                break;
    550559            }
    551             state->offset = (unsigned)this.val;
     560            state->offset = (unsigned)here.val;
    552561
    553562            /* get distance extra bits, if any */
    554             state->extra = (unsigned)(this.op) & 15;
     563            state->extra = (unsigned)(here.op) & 15;
    555564            if (state->extra != 0) {
    556565                NEEDBITS(state->extra);
  • cpukit/zlib/inffast.c

    r9f5ede0 r8c05550  
    11/* inffast.c -- fast decoding
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2008 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    8080    unsigned wsize;             /* window size or zero if not using window */
    8181    unsigned whave;             /* valid bytes in the window */
    82     unsigned write;             /* window write index */
     82    unsigned wnext;             /* window write index */
    8383    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
    8484    unsigned long hold;         /* local strm->hold */
     
    8888    unsigned lmask;             /* mask for first level of length codes */
    8989    unsigned dmask;             /* mask for first level of distance codes */
    90     code this;                  /* retrieved table entry */
     90    code here;                  /* retrieved table entry */
    9191    unsigned op;                /* code bits, operation, extra bits, or */
    9292                                /*  window position, window bytes to copy */
     
    107107    wsize = state->wsize;
    108108    whave = state->whave;
    109     write = state->write;
     109    wnext = state->wnext;
    110110    window = state->window;
    111111    hold = state->hold;
     
    125125            bits += 8;
    126126        }
    127         this = lcode[hold & lmask];
     127        here = lcode[hold & lmask];
    128128      dolen:
    129         op = (unsigned)(this.bits);
     129        op = (unsigned)(here.bits);
    130130        hold >>= op;
    131131        bits -= op;
    132         op = (unsigned)(this.op);
     132        op = (unsigned)(here.op);
    133133        if (op == 0) {                          /* literal */
    134             Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
     134            Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
    135135                    "inflate:         literal '%c'\n" :
    136                     "inflate:         literal 0x%02x\n", this.val));
    137             PUP(out) = (unsigned char)(this.val);
     136                    "inflate:         literal 0x%02x\n", here.val));
     137            PUP(out) = (unsigned char)(here.val);
    138138        }
    139139        else if (op & 16) {                     /* length base */
    140             len = (unsigned)(this.val);
     140            len = (unsigned)(here.val);
    141141            op &= 15;                           /* number of extra bits */
    142142            if (op) {
     
    156156                bits += 8;
    157157            }
    158             this = dcode[hold & dmask];
     158            here = dcode[hold & dmask];
    159159          dodist:
    160             op = (unsigned)(this.bits);
     160            op = (unsigned)(here.bits);
    161161            hold >>= op;
    162162            bits -= op;
    163             op = (unsigned)(this.op);
     163            op = (unsigned)(here.op);
    164164            if (op & 16) {                      /* distance base */
    165                 dist = (unsigned)(this.val);
     165                dist = (unsigned)(here.val);
    166166                op &= 15;                       /* number of extra bits */
    167167                if (bits < op) {
     
    188188                    op = dist - op;             /* distance back in window */
    189189                    if (op > whave) {
    190                         strm->msg = (char *)"invalid distance too far back";
    191                         state->mode = BAD;
    192                         break;
     190                        if (state->sane) {
     191                            strm->msg =
     192                                (char *)"invalid distance too far back";
     193                            state->mode = BAD;
     194                            break;
     195                        }
     196#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
     197                        if (len <= op - whave) {
     198                            do {
     199                                PUP(out) = 0;
     200                            } while (--len);
     201                            continue;
     202                        }
     203                        len -= op - whave;
     204                        do {
     205                            PUP(out) = 0;
     206                        } while (--op > whave);
     207                        if (op == 0) {
     208                            from = out - dist;
     209                            do {
     210                                PUP(out) = PUP(from);
     211                            } while (--len);
     212                            continue;
     213                        }
     214#endif
    193215                    }
    194216                    from = window - OFF;
    195                     if (write == 0) {           /* very common case */
     217                    if (wnext == 0) {           /* very common case */
    196218                        from += wsize - op;
    197219                        if (op < len) {         /* some from window */
     
    203225                        }
    204226                    }
    205                     else if (write < op) {      /* wrap around window */
    206                         from += wsize + write - op;
    207                         op -= write;
     227                    else if (wnext < op) {      /* wrap around window */
     228                        from += wsize + wnext - op;
     229                        op -= wnext;
    208230                        if (op < len) {         /* some from end of window */
    209231                            len -= op;
     
    212234                            } while (--op);
    213235                            from = window - OFF;
    214                             if (write < len) {  /* some from start of window */
    215                                 op = write;
     236                            if (wnext < len) {  /* some from start of window */
     237                                op = wnext;
    216238                                len -= op;
    217239                                do {
     
    223245                    }
    224246                    else {                      /* contiguous in window */
    225                         from += write - op;
     247                        from += wnext - op;
    226248                        if (op < len) {         /* some from window */
    227249                            len -= op;
     
    260282            }
    261283            else if ((op & 64) == 0) {          /* 2nd level distance code */
    262                 this = dcode[this.val + (hold & ((1U << op) - 1))];
     284                here = dcode[here.val + (hold & ((1U << op) - 1))];
    263285                goto dodist;
    264286            }
     
    270292        }
    271293        else if ((op & 64) == 0) {              /* 2nd level length code */
    272             this = lcode[this.val + (hold & ((1U << op) - 1))];
     294            here = lcode[here.val + (hold & ((1U << op) - 1))];
    273295            goto dolen;
    274296        }
     
    306328   - Using bit fields for code structure
    307329   - Different op definition to avoid & for extra bits (do & for table bits)
    308    - Three separate decoding do-loops for direct, window, and write == 0
     330   - Three separate decoding do-loops for direct, window, and wnext == 0
    309331   - Special case for distance > 1 copies to do overlapped load and store copy
    310332   - Explicit branch predictions (based on measured branch probabilities)
  • cpukit/zlib/inflate.h

    r9f5ede0 r8c05550  
    11/* inflate.h -- internal inflate state definition
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2009 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    3333        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
    3434        STORED,     /* i: waiting for stored size (length and complement) */
     35        COPY_,      /* i/o: same as COPY below, but only first time in */
    3536        COPY,       /* i/o: waiting for input or output to copy stored block */
    3637        TABLE,      /* i: waiting for dynamic block table lengths */
    3738        LENLENS,    /* i: waiting for code length code lengths */
    3839        CODELENS,   /* i: waiting for length/lit and distance code lengths */
    39             LEN,        /* i: waiting for length/lit code */
     40            LEN_,       /* i: same as LEN below, but only first time in */
     41            LEN,        /* i: waiting for length/lit/eob code */
    4042            LENEXT,     /* i: waiting for length extra bits */
    4143            DIST,       /* i: waiting for distance code */
     
    5456    State transitions between above modes -
    5557
    56     (most modes can go to the BAD or MEM mode -- not shown for clarity)
     58    (most modes can go to BAD or MEM on error -- not shown for clarity)
    5759
    5860    Process header:
    59         HEAD -> (gzip) or (zlib)
    60         (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
    61         NAME -> COMMENT -> HCRC -> TYPE
     61        HEAD -> (gzip) or (zlib) or (raw)
     62        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
     63                  HCRC -> TYPE
    6264        (zlib) -> DICTID or TYPE
    6365        DICTID -> DICT -> TYPE
     66        (raw) -> TYPEDO
    6467    Read deflate blocks:
    65             TYPE -> STORED or TABLE or LEN or CHECK
    66             STORED -> COPY -> TYPE
    67             TABLE -> LENLENS -> CODELENS -> LEN
    68     Read deflate codes:
     68            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
     69            STORED -> COPY_ -> COPY -> TYPE
     70            TABLE -> LENLENS -> CODELENS -> LEN_
     71            LEN_ -> LEN
     72    Read deflate codes in fixed or dynamic block:
    6973                LEN -> LENEXT or LIT or TYPE
    7074                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
     
    7478 */
    7579
    76 /* state maintained between inflate() calls.  Approximately 7K bytes. */
     80/* state maintained between inflate() calls.  Approximately 10K bytes. */
    7781struct inflate_state {
    7882    inflate_mode mode;          /* current inflate mode */
     
    8993    unsigned wsize;             /* window size or zero if not using window */
    9094    unsigned whave;             /* valid bytes in the window */
    91     unsigned write;             /* window write index */
     95    unsigned wnext;             /* window write index */
    9296    unsigned char FAR *window;  /* allocated sliding window, if needed */
    9397        /* bit accumulator */
     
    113117    unsigned short work[288];   /* work area for code table building */
    114118    code codes[ENOUGH];         /* space for code tables */
     119    int sane;                   /* if false, allow invalid distance too far */
     120    int back;                   /* bits back of last unprocessed length/lit */
     121    unsigned was;               /* initial length of match */
    115122};
Note: See TracChangeset for help on using the changeset viewer.