← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gzip/vivid

« back to all changes in this revision

Viewing changes to unlzh.c

  • Committer: Steve Langasek
  • Date: 2012-06-29 02:07:40 UTC
  • mfrom: (4.1.9 sid)
  • Revision ID: steve.langasek@canonical.com-20120629020740-qqikrblzana08v2y
Merge version 1.5-1.1 from Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
unlzh.c
12
12
 
13
13
/* decode.c */
14
14
 
15
 
local unsigned  decode  OF((unsigned count, uch buffer[]));
16
 
local void decode_start OF((void));
 
15
local unsigned  decode  (unsigned count, uch buffer[]);
 
16
local void decode_start (void);
17
17
 
18
18
/* huf.c */
19
 
local void huf_decode_start OF((void));
20
 
local unsigned decode_c     OF((void));
21
 
local unsigned decode_p     OF((void));
22
 
local void read_pt_len      OF((int nn, int nbit, int i_special));
23
 
local void read_c_len       OF((void));
 
19
local void huf_decode_start (void);
 
20
local unsigned decode_c     (void);
 
21
local unsigned decode_p     (void);
 
22
local void read_pt_len      (int nn, int nbit, int i_special);
 
23
local void read_c_len       (void);
24
24
 
25
25
/* io.c */
26
 
local void fillbuf      OF((int n));
27
 
local unsigned getbits  OF((int n));
28
 
local void init_getbits OF((void));
 
26
local void fillbuf      (int n);
 
27
local unsigned getbits  (int n);
 
28
local void init_getbits (void);
29
29
 
30
30
/* maketbl.c */
31
31
 
32
 
local void make_table OF((int nchar, uch bitlen[],
33
 
                          int tablebits, ush table[]));
 
32
local void make_table (int nchar, uch bitlen[],
 
33
                       int tablebits, ush table[]);
34
34
 
35
35
 
36
36
#define DICBIT    13    /* 12(-lh4-) or 13(-lh5-) */
57
57
/* huf.c */
58
58
 
59
59
#define NC (UCHAR_MAX + MAXMATCH + 2 - THRESHOLD)
60
 
        /* alphabet = {0, 1, 2, ..., NC - 1} */
 
60
        /* alphabet = {0, 1, 2, ..., NC - 1} */
61
61
#define CBIT 9  /* $\lfloor \log_2 NC \rfloor + 1$ */
62
62
#define CODE_BIT  16  /* codeword length */
63
63
 
104
104
{
105
105
    bitbuf <<= n;
106
106
    while (n > bitcount) {
107
 
        bitbuf |= subbitbuf << (n -= bitcount);
108
 
        subbitbuf = (unsigned)try_byte();
109
 
        if ((int)subbitbuf == EOF) subbitbuf = 0;
110
 
        bitcount = CHAR_BIT;
 
107
        bitbuf |= subbitbuf << (n -= bitcount);
 
108
        subbitbuf = (unsigned)try_byte();
 
109
        if ((int)subbitbuf == EOF) subbitbuf = 0;
 
110
        bitcount = CHAR_BIT;
111
111
    }
112
112
    bitbuf |= subbitbuf >> (bitcount -= n);
113
113
}
128
128
}
129
129
 
130
130
/***********************************************************
131
 
        maketbl.c -- make table for decoding
 
131
        maketbl.c -- make table for decoding
132
132
***********************************************************/
133
133
 
134
134
local void make_table(nchar, bitlen, tablebits, table)
145
145
 
146
146
    start[1] = 0;
147
147
    for (i = 1; i <= 16; i++)
148
 
        start[i + 1] = start[i] + (count[i] << (16 - i));
 
148
        start[i + 1] = start[i] + (count[i] << (16 - i));
149
149
    if ((start[17] & 0xffff) != 0)
150
150
      gzip_error ("Bad table\n");
151
151
 
152
152
    jutbits = 16 - tablebits;
153
153
    for (i = 1; i <= (unsigned)tablebits; i++) {
154
 
        start[i] >>= jutbits;
155
 
        weight[i] = (unsigned) 1 << (tablebits - i);
 
154
        start[i] >>= jutbits;
 
155
        weight[i] = (unsigned) 1 << (tablebits - i);
156
156
    }
157
157
    while (i <= 16) {
158
 
        weight[i] = (unsigned) 1 << (16 - i);
159
 
        i++;
 
158
        weight[i] = (unsigned) 1 << (16 - i);
 
159
        i++;
160
160
    }
161
161
 
162
162
    i = start[tablebits + 1] >> jutbits;
163
163
    if (i != 0) {
164
 
        k = 1 << tablebits;
165
 
        while (i != k) table[i++] = 0;
 
164
        k = 1 << tablebits;
 
165
        while (i != k) table[i++] = 0;
166
166
    }
167
167
 
168
168
    avail = nchar;
169
169
    mask = (unsigned) 1 << (15 - tablebits);
170
170
    for (ch = 0; ch < (unsigned)nchar; ch++) {
171
 
        if ((len = bitlen[ch]) == 0) continue;
172
 
        nextcode = start[len] + weight[len];
173
 
        if (len <= (unsigned)tablebits) {
174
 
            if ((unsigned) 1 << tablebits < nextcode)
175
 
              gzip_error ("Bad table\n");
176
 
            for (i = start[len]; i < nextcode; i++) table[i] = ch;
177
 
        } else {
178
 
            k = start[len];
179
 
            p = &table[k >> jutbits];
180
 
            i = len - tablebits;
181
 
            while (i != 0) {
182
 
                if (*p == 0) {
183
 
                    right[avail] = left[avail] = 0;
184
 
                    *p = avail++;
185
 
                }
186
 
                if (k & mask) p = &right[*p];
187
 
                else          p = &left[*p];
188
 
                k <<= 1;  i--;
189
 
            }
190
 
            *p = ch;
191
 
        }
192
 
        start[len] = nextcode;
 
171
        if ((len = bitlen[ch]) == 0) continue;
 
172
        nextcode = start[len] + weight[len];
 
173
        if (len <= (unsigned)tablebits) {
 
174
            if ((unsigned) 1 << tablebits < nextcode)
 
175
              gzip_error ("Bad table\n");
 
176
            for (i = start[len]; i < nextcode; i++) table[i] = ch;
 
177
        } else {
 
178
            k = start[len];
 
179
            p = &table[k >> jutbits];
 
180
            i = len - tablebits;
 
181
            while (i != 0) {
 
182
                if (*p == 0) {
 
183
                    right[avail] = left[avail] = 0;
 
184
                    *p = avail++;
 
185
                }
 
186
                if (k & mask) p = &right[*p];
 
187
                else          p = &left[*p];
 
188
                k <<= 1;  i--;
 
189
            }
 
190
            *p = ch;
 
191
        }
 
192
        start[len] = nextcode;
193
193
    }
194
194
}
195
195
 
207
207
 
208
208
    n = getbits(nbit);
209
209
    if (n == 0) {
210
 
        c = getbits(nbit);
211
 
        for (i = 0; i < nn; i++) pt_len[i] = 0;
212
 
        for (i = 0; i < 256; i++) pt_table[i] = c;
 
210
        c = getbits(nbit);
 
211
        for (i = 0; i < nn; i++) pt_len[i] = 0;
 
212
        for (i = 0; i < 256; i++) pt_table[i] = c;
213
213
    } else {
214
 
        i = 0;
215
 
        while (i < n) {
216
 
            c = bitbuf >> (BITBUFSIZ - 3);
217
 
            if (c == 7) {
218
 
                mask = (unsigned) 1 << (BITBUFSIZ - 1 - 3);
219
 
                while (mask & bitbuf) {  mask >>= 1;  c++;  }
220
 
                if (16 < c)
221
 
                  gzip_error ("Bad table\n");
222
 
            }
223
 
            fillbuf((c < 7) ? 3 : c - 3);
224
 
            pt_len[i++] = c;
225
 
            if (i == i_special) {
226
 
                c = getbits(2);
227
 
                while (--c >= 0) pt_len[i++] = 0;
228
 
            }
229
 
        }
230
 
        while (i < nn) pt_len[i++] = 0;
231
 
        make_table(nn, pt_len, 8, pt_table);
 
214
        i = 0;
 
215
        while (i < n) {
 
216
            c = bitbuf >> (BITBUFSIZ - 3);
 
217
            if (c == 7) {
 
218
                mask = (unsigned) 1 << (BITBUFSIZ - 1 - 3);
 
219
                while (mask & bitbuf) {  mask >>= 1;  c++;  }
 
220
                if (16 < c)
 
221
                  gzip_error ("Bad table\n");
 
222
            }
 
223
            fillbuf((c < 7) ? 3 : c - 3);
 
224
            pt_len[i++] = c;
 
225
            if (i == i_special) {
 
226
                c = getbits(2);
 
227
                while (--c >= 0) pt_len[i++] = 0;
 
228
            }
 
229
        }
 
230
        while (i < nn) pt_len[i++] = 0;
 
231
        make_table(nn, pt_len, 8, pt_table);
232
232
    }
233
233
}
234
234
 
239
239
 
240
240
    n = getbits(CBIT);
241
241
    if (n == 0) {
242
 
        c = getbits(CBIT);
243
 
        for (i = 0; i < NC; i++) c_len[i] = 0;
244
 
        for (i = 0; i < 4096; i++) c_table[i] = c;
 
242
        c = getbits(CBIT);
 
243
        for (i = 0; i < NC; i++) c_len[i] = 0;
 
244
        for (i = 0; i < 4096; i++) c_table[i] = c;
245
245
    } else {
246
 
        i = 0;
247
 
        while (i < n) {
248
 
            c = pt_table[bitbuf >> (BITBUFSIZ - 8)];
249
 
            if (c >= NT) {
250
 
                mask = (unsigned) 1 << (BITBUFSIZ - 1 - 8);
251
 
                do {
252
 
                    if (bitbuf & mask) c = right[c];
253
 
                    else               c = left [c];
254
 
                    mask >>= 1;
255
 
                } while (c >= NT);
256
 
            }
257
 
            fillbuf((int) pt_len[c]);
258
 
            if (c <= 2) {
259
 
                if      (c == 0) c = 1;
260
 
                else if (c == 1) c = getbits(4) + 3;
261
 
                else             c = getbits(CBIT) + 20;
262
 
                while (--c >= 0) c_len[i++] = 0;
263
 
            } else c_len[i++] = c - 2;
264
 
        }
265
 
        while (i < NC) c_len[i++] = 0;
266
 
        make_table(NC, c_len, 12, c_table);
 
246
        i = 0;
 
247
        while (i < n) {
 
248
            c = pt_table[bitbuf >> (BITBUFSIZ - 8)];
 
249
            if (c >= NT) {
 
250
                mask = (unsigned) 1 << (BITBUFSIZ - 1 - 8);
 
251
                do {
 
252
                    if (bitbuf & mask) c = right[c];
 
253
                    else               c = left [c];
 
254
                    mask >>= 1;
 
255
                } while (c >= NT);
 
256
            }
 
257
            fillbuf((int) pt_len[c]);
 
258
            if (c <= 2) {
 
259
                if      (c == 0) c = 1;
 
260
                else if (c == 1) c = getbits(4) + 3;
 
261
                else             c = getbits(CBIT) + 20;
 
262
                while (--c >= 0) c_len[i++] = 0;
 
263
            } else c_len[i++] = c - 2;
 
264
        }
 
265
        while (i < NC) c_len[i++] = 0;
 
266
        make_table(NC, c_len, 12, c_table);
267
267
    }
268
268
}
269
269
 
272
272
    unsigned j, mask;
273
273
 
274
274
    if (blocksize == 0) {
275
 
        blocksize = getbits(16);
276
 
        if (blocksize == 0) {
277
 
            return NC; /* end of file */
278
 
        }
279
 
        read_pt_len(NT, TBIT, 3);
280
 
        read_c_len();
281
 
        read_pt_len(NP, PBIT, -1);
 
275
        blocksize = getbits(16);
 
276
        if (blocksize == 0) {
 
277
            return NC; /* end of file */
 
278
        }
 
279
        read_pt_len(NT, TBIT, 3);
 
280
        read_c_len();
 
281
        read_pt_len(NP, PBIT, -1);
282
282
    }
283
283
    blocksize--;
284
284
    j = c_table[bitbuf >> (BITBUFSIZ - 12)];
285
285
    if (j >= NC) {
286
 
        mask = (unsigned) 1 << (BITBUFSIZ - 1 - 12);
287
 
        do {
288
 
            if (bitbuf & mask) j = right[j];
289
 
            else               j = left [j];
290
 
            mask >>= 1;
291
 
        } while (j >= NC);
 
286
        mask = (unsigned) 1 << (BITBUFSIZ - 1 - 12);
 
287
        do {
 
288
            if (bitbuf & mask) j = right[j];
 
289
            else               j = left [j];
 
290
            mask >>= 1;
 
291
        } while (j >= NC);
292
292
    }
293
293
    fillbuf((int) c_len[j]);
294
294
    return j;
300
300
 
301
301
    j = pt_table[bitbuf >> (BITBUFSIZ - 8)];
302
302
    if (j >= NP) {
303
 
        mask = (unsigned) 1 << (BITBUFSIZ - 1 - 8);
304
 
        do {
305
 
            if (bitbuf & mask) j = right[j];
306
 
            else               j = left [j];
307
 
            mask >>= 1;
308
 
        } while (j >= NP);
 
303
        mask = (unsigned) 1 << (BITBUFSIZ - 1 - 8);
 
304
        do {
 
305
            if (bitbuf & mask) j = right[j];
 
306
            else               j = left [j];
 
307
            mask >>= 1;
 
308
        } while (j >= NP);
309
309
    }
310
310
    fillbuf((int) pt_len[j]);
311
311
    if (j != 0) j = ((unsigned) 1 << (j - 1)) + getbits((int) (j - 1));
350
350
 
351
351
    r = 0;
352
352
    while (--j >= 0) {
353
 
        buffer[r] = buffer[i];
354
 
        i = (i + 1) & (DICSIZ - 1);
355
 
        if (++r == count) return r;
 
353
        buffer[r] = buffer[i];
 
354
        i = (i + 1) & (DICSIZ - 1);
 
355
        if (++r == count) return r;
356
356
    }
357
357
    for ( ; ; ) {
358
 
        c = decode_c();
359
 
        if (c == NC) {
360
 
            done = 1;
361
 
            return r;
362
 
        }
363
 
        if (c <= UCHAR_MAX) {
364
 
            buffer[r] = c;
365
 
            if (++r == count) return r;
366
 
        } else {
367
 
            j = c - (UCHAR_MAX + 1 - THRESHOLD);
368
 
            i = (r - decode_p() - 1) & (DICSIZ - 1);
369
 
            while (--j >= 0) {
370
 
                buffer[r] = buffer[i];
371
 
                i = (i + 1) & (DICSIZ - 1);
372
 
                if (++r == count) return r;
373
 
            }
374
 
        }
 
358
        c = decode_c();
 
359
        if (c == NC) {
 
360
            done = 1;
 
361
            return r;
 
362
        }
 
363
        if (c <= UCHAR_MAX) {
 
364
            buffer[r] = c;
 
365
            if (++r == count) return r;
 
366
        } else {
 
367
            j = c - (UCHAR_MAX + 1 - THRESHOLD);
 
368
            i = (r - decode_p() - 1) & (DICSIZ - 1);
 
369
            while (--j >= 0) {
 
370
                buffer[r] = buffer[i];
 
371
                i = (i + 1) & (DICSIZ - 1);
 
372
                if (++r == count) return r;
 
373
            }
 
374
        }
375
375
    }
376
376
}
377
377
 
389
389
 
390
390
    decode_start();
391
391
    while (!done) {
392
 
        n = decode((unsigned) DICSIZ, window);
393
 
        if (!test && n > 0) {
394
 
            write_buf(out, (char*)window, n);
395
 
        }
 
392
        n = decode((unsigned) DICSIZ, window);
 
393
        if (!test && n > 0) {
 
394
            write_buf(out, (char*)window, n);
 
395
        }
396
396
    }
397
397
    return OK;
398
398
}