← Back to branch summary

~ubuntu-branches/ubuntu/trusty/jzlib/trusty-proposed

« back to all changes in this revision

Viewing changes to com/jcraft/jzlib/InfCodes.java

  • Committer: Bazaar Package Importer
  • Author(s): Adam Heath
  • Date: 2002-08-03 18:33:52 UTC
  • Revision ID: james.westby@ubuntu.com-20020803183352-78jh6jy5mio0f399
Tags: upstream-0.0.8
Import upstream version 0.0.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
com/jcraft/jzlib/InfCodes.java
 
1
/* -*-mode:java; c-basic-offset:2; -*- */
 
2
/* JZlib -- zlib in pure Java
 
3
 *  
 
4
 * Copyright (C) 2000 ymnk, JCraft, Inc.
 
5
 *   
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Library General Public License
 
8
 * as published by the Free Software Foundation; either version 2 of
 
9
 * the License, or (at your option) any later version.
 
10
 *   
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU Library General Public License for more details.
 
15
 * 
 
16
 * You should have received a copy of the GNU Library General Public
 
17
 * License along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 */
 
20
/*
 
21
 * This program is based on zlib-1.1.3, so all credit should go authors
 
22
 * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
 
23
 * and contributors of zlib.
 
24
 */
 
25
 
 
26
package com.jcraft.jzlib;
 
27
 
 
28
final class InfCodes{
 
29
 
 
30
  static final private int[] inflate_mask = {
 
31
    0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
 
32
    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
 
33
    0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
 
34
    0x00007fff, 0x0000ffff
 
35
  };
 
36
 
 
37
  static final private int Z_OK=0;
 
38
  static final private int Z_STREAM_END=1;
 
39
  static final private int Z_NEED_DICT=2;
 
40
  static final private int Z_ERRNO=-1;
 
41
  static final private int Z_STREAM_ERROR=-2;
 
42
  static final private int Z_DATA_ERROR=-3;
 
43
  static final private int Z_MEM_ERROR=-4;
 
44
  static final private int Z_BUF_ERROR=-5;
 
45
  static final private int Z_VERSION_ERROR=-6;
 
46
 
 
47
  // waiting for "i:"=input,
 
48
  //             "o:"=output,
 
49
  //             "x:"=nothing
 
50
  static final private int START=0;  // x: set up for LEN
 
51
  static final private int LEN=1;    // i: get length/literal/eob next
 
52
  static final private int LENEXT=2; // i: getting length extra (have base)
 
53
  static final private int DIST=3;   // i: get distance next
 
54
  static final private int DISTEXT=4;// i: getting distance extra
 
55
  static final private int COPY=5;   // o: copying bytes in window, waiting for space
 
56
  static final private int LIT=6;    // o: got literal, waiting for output space
 
57
  static final private int WASH=7;   // o: got eob, possibly still output waiting
 
58
  static final private int END=8;    // x: got eob and all data flushed
 
59
  static final private int BADCODE=9;// x: got error
 
60
 
 
61
  int mode;      // current inflate_codes mode
 
62
 
 
63
  // mode dependent information
 
64
  int len;
 
65
 
 
66
  int[] tree; // pointer into tree
 
67
  int tree_index=0;
 
68
  int need;   // bits needed
 
69
 
 
70
  int lit;
 
71
 
 
72
  // if EXT or COPY, where and how much
 
73
  int get;              // bits to get for extra
 
74
  int dist;             // distance back to copy from
 
75
 
 
76
  byte lbits;           // ltree bits decoded per branch
 
77
  byte dbits;           // dtree bits decoder per branch
 
78
  int[] ltree;          // literal/length/eob tree
 
79
  int ltree_index;      // literal/length/eob tree
 
80
  int[] dtree;          // distance tree
 
81
  int dtree_index;      // distance tree
 
82
 
 
83
  InfCodes(int bl, int bd,
 
84
           int[] tl, int tl_index,
 
85
           int[] td, int td_index, ZStream z){
 
86
    mode = START;
 
87
    lbits = (byte)bl;
 
88
    dbits = (byte)bd;
 
89
    ltree = tl;
 
90
    ltree_index=tl_index;
 
91
    dtree = td;
 
92
    dtree_index=td_index;
 
93
  }
 
94
 
 
95
  InfCodes(int bl, int bd, int[] tl, int[] td, ZStream z){
 
96
    mode = START;
 
97
    lbits = (byte)bl;
 
98
    dbits = (byte)bd;
 
99
    ltree = tl;
 
100
    ltree_index=0;
 
101
    dtree = td;
 
102
    dtree_index=0;
 
103
  }
 
104
 
 
105
  int proc(InfBlocks s, ZStream z, int r){ 
 
106
    int j;              // temporary storage
 
107
    int[] t;            // temporary pointer
 
108
    int tindex;         // temporary pointer
 
109
    int e;              // extra bits or operation
 
110
    int b=0;            // bit buffer
 
111
    int k=0;            // bits in bit buffer
 
112
    int p=0;            // input data pointer
 
113
    int n;              // bytes available there
 
114
    int q;              // output window write pointer
 
115
    int m;              // bytes to end of window or read pointer
 
116
    int f;              // pointer to copy strings from
 
117
 
 
118
    // copy input/output information to locals (UPDATE macro restores)
 
119
    p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
 
120
    q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
121
 
 
122
    // process input and output based on current state
 
123
    while (true){
 
124
      switch (mode){
 
125
        // waiting for "i:"=input, "o:"=output, "x:"=nothing
 
126
      case START:         // x: set up for LEN
 
127
        if (m >= 258 && n >= 10){
 
128
 
 
129
          s.bitb=b;s.bitk=k;
 
130
          z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
131
          s.write=q;
 
132
          r = inflate_fast(lbits, dbits, 
 
133
                           ltree, ltree_index, 
 
134
                           dtree, dtree_index,
 
135
                           s, z);
 
136
 
 
137
          p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
 
138
          q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
139
 
 
140
          if (r != Z_OK){
 
141
            mode = r == Z_STREAM_END ? WASH : BADCODE;
 
142
            break;
 
143
          }
 
144
        }
 
145
        need = lbits;
 
146
        tree = ltree;
 
147
        tree_index=ltree_index;
 
148
 
 
149
        mode = LEN;
 
150
      case LEN:           // i: get length/literal/eob next
 
151
        j = need;
 
152
 
 
153
        while(k<(j)){
 
154
          if(n!=0)r=Z_OK;
 
155
          else{
 
156
 
 
157
            s.bitb=b;s.bitk=k;
 
158
            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
159
            s.write=q;
 
160
            return s.inflate_flush(z,r);
 
161
          }
 
162
          n--;
 
163
          b|=(z.next_in[p++]&0xff)<<k;
 
164
          k+=8;
 
165
        }
 
166
 
 
167
        tindex=(tree_index+(b&inflate_mask[j]))*3;
 
168
 
 
169
        b>>>=(tree[tindex+1]);
 
170
        k-=(tree[tindex+1]);
 
171
 
 
172
        e=tree[tindex];
 
173
 
 
174
        if(e == 0){               // literal
 
175
          lit = tree[tindex+2];
 
176
          mode = LIT;
 
177
          break;
 
178
        }
 
179
        if((e & 16)!=0 ){          // length
 
180
          get = e & 15;
 
181
          len = tree[tindex+2];
 
182
          mode = LENEXT;
 
183
          break;
 
184
        }
 
185
        if ((e & 64) == 0){        // next table
 
186
          need = e;
 
187
          tree_index = tindex/3+tree[tindex+2];
 
188
          break;
 
189
        }
 
190
        if ((e & 32)!=0){               // end of block
 
191
          mode = WASH;
 
192
          break;
 
193
        }
 
194
        mode = BADCODE;        // invalid code
 
195
        z.msg = "invalid literal/length code";
 
196
        r = Z_DATA_ERROR;
 
197
 
 
198
        s.bitb=b;s.bitk=k;
 
199
        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
200
        s.write=q;
 
201
        return s.inflate_flush(z,r);
 
202
 
 
203
      case LENEXT:        // i: getting length extra (have base)
 
204
        j = get;
 
205
 
 
206
        while(k<(j)){
 
207
          if(n!=0)r=Z_OK;
 
208
          else{
 
209
 
 
210
            s.bitb=b;s.bitk=k;
 
211
            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
212
            s.write=q;
 
213
            return s.inflate_flush(z,r);
 
214
          }
 
215
          n--; b|=(z.next_in[p++]&0xff)<<k;
 
216
          k+=8;
 
217
        }
 
218
 
 
219
        len += (b & inflate_mask[j]);
 
220
 
 
221
        b>>=j;
 
222
        k-=j;
 
223
 
 
224
        need = dbits;
 
225
        tree = dtree;
 
226
        tree_index=dtree_index;
 
227
        mode = DIST;
 
228
      case DIST:          // i: get distance next
 
229
        j = need;
 
230
 
 
231
        while(k<(j)){
 
232
          if(n!=0)r=Z_OK;
 
233
          else{
 
234
 
 
235
            s.bitb=b;s.bitk=k;
 
236
            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
237
            s.write=q;
 
238
            return s.inflate_flush(z,r);
 
239
          }
 
240
          n--; b|=(z.next_in[p++]&0xff)<<k;
 
241
          k+=8;
 
242
        }
 
243
 
 
244
        tindex=(tree_index+(b & inflate_mask[j]))*3;
 
245
 
 
246
        b>>=tree[tindex+1];
 
247
        k-=tree[tindex+1];
 
248
 
 
249
        e = (tree[tindex]);
 
250
        if((e & 16)!=0){               // distance
 
251
          get = e & 15;
 
252
          dist = tree[tindex+2];
 
253
          mode = DISTEXT;
 
254
          break;
 
255
        }
 
256
        if ((e & 64) == 0){        // next table
 
257
          need = e;
 
258
          tree_index = tindex/3 + tree[tindex+2];
 
259
          break;
 
260
        }
 
261
        mode = BADCODE;        // invalid code
 
262
        z.msg = "invalid distance code";
 
263
        r = Z_DATA_ERROR;
 
264
 
 
265
        s.bitb=b;s.bitk=k;
 
266
        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
267
        s.write=q;
 
268
        return s.inflate_flush(z,r);
 
269
 
 
270
      case DISTEXT:       // i: getting distance extra
 
271
        j = get;
 
272
 
 
273
        while(k<(j)){
 
274
          if(n!=0)r=Z_OK;
 
275
          else{
 
276
 
 
277
            s.bitb=b;s.bitk=k;
 
278
            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
279
            s.write=q;
 
280
            return s.inflate_flush(z,r);
 
281
          }
 
282
          n--; b|=(z.next_in[p++]&0xff)<<k;
 
283
          k+=8;
 
284
        }
 
285
 
 
286
        dist += (b & inflate_mask[j]);
 
287
 
 
288
        b>>=j;
 
289
        k-=j;
 
290
 
 
291
        mode = COPY;
 
292
      case COPY:          // o: copying bytes in window, waiting for space
 
293
        f = q - dist;
 
294
        while(f < 0){     // modulo window size-"while" instead
 
295
          f += s.end;     // of "if" handles invalid distances
 
296
        }
 
297
        while (len!=0){
 
298
 
 
299
          if(m==0){
 
300
            if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
 
301
            if(m==0){
 
302
              s.write=q; r=s.inflate_flush(z,r);
 
303
              q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
304
 
 
305
              if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
 
306
 
 
307
              if(m==0){
 
308
                s.bitb=b;s.bitk=k;
 
309
                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
310
                s.write=q;
 
311
                return s.inflate_flush(z,r);
 
312
              }  
 
313
            }
 
314
          }
 
315
 
 
316
          s.window[q++]=s.window[f++]; m--;
 
317
 
 
318
          if (f == s.end)
 
319
            f = 0;
 
320
          len--;
 
321
        }
 
322
        mode = START;
 
323
        break;
 
324
      case LIT:           // o: got literal, waiting for output space
 
325
        if(m==0){
 
326
          if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
 
327
          if(m==0){
 
328
            s.write=q; r=s.inflate_flush(z,r);
 
329
            q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
330
 
 
331
            if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
 
332
            if(m==0){
 
333
              s.bitb=b;s.bitk=k;
 
334
              z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
335
              s.write=q;
 
336
              return s.inflate_flush(z,r);
 
337
            }
 
338
          }
 
339
        }
 
340
        r=Z_OK;
 
341
 
 
342
        s.window[q++]=(byte)lit; m--;
 
343
 
 
344
        mode = START;
 
345
        break;
 
346
      case WASH:           // o: got eob, possibly more output
 
347
        if (k > 7){        // return unused byte, if any
 
348
          k -= 8;
 
349
          n++;
 
350
          p--;             // can always return one
 
351
        }
 
352
 
 
353
        s.write=q; r=s.inflate_flush(z,r);
 
354
        q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
355
 
 
356
        if (s.read != s.write){
 
357
          s.bitb=b;s.bitk=k;
 
358
          z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
359
          s.write=q;
 
360
          return s.inflate_flush(z,r);
 
361
        }
 
362
        mode = END;
 
363
      case END:
 
364
        r = Z_STREAM_END;
 
365
        s.bitb=b;s.bitk=k;
 
366
        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
367
        s.write=q;
 
368
        return s.inflate_flush(z,r);
 
369
 
 
370
      case BADCODE:       // x: got error
 
371
 
 
372
        r = Z_DATA_ERROR;
 
373
 
 
374
        s.bitb=b;s.bitk=k;
 
375
        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
376
        s.write=q;
 
377
        return s.inflate_flush(z,r);
 
378
 
 
379
      default:
 
380
        r = Z_STREAM_ERROR;
 
381
 
 
382
        s.bitb=b;s.bitk=k;
 
383
        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
384
        s.write=q;
 
385
        return s.inflate_flush(z,r);
 
386
      }
 
387
    }
 
388
  }
 
389
 
 
390
  void free(ZStream z){
 
391
    //  ZFREE(z, c);
 
392
  }
 
393
 
 
394
  // Called with number of bytes left to write in window at least 258
 
395
  // (the maximum string length) and number of input bytes available
 
396
  // at least ten.  The ten bytes are six bytes for the longest length/
 
397
  // distance pair plus four bytes for overloading the bit buffer.
 
398
 
 
399
  int inflate_fast(int bl, int bd, 
 
400
                   int[] tl, int tl_index,
 
401
                   int[] td, int td_index,
 
402
                   InfBlocks s, ZStream z){
 
403
    int t;                // temporary pointer
 
404
    int[] tp;             // temporary pointer
 
405
    int tp_index;         // temporary pointer
 
406
    int e;                // extra bits or operation
 
407
    int b;                // bit buffer
 
408
    int k;                // bits in bit buffer
 
409
    int p;                // input data pointer
 
410
    int n;                // bytes available there
 
411
    int q;                // output window write pointer
 
412
    int m;                // bytes to end of window or read pointer
 
413
    int ml;               // mask for literal/length tree
 
414
    int md;               // mask for distance tree
 
415
    int c;                // bytes to copy
 
416
    int d;                // distance back to copy from
 
417
    int r;                // copy source pointer
 
418
 
 
419
    // load input, output, bit values
 
420
    p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
 
421
    q=s.write;m=q<s.read?s.read-q-1:s.end-q;
 
422
 
 
423
    // initialize masks
 
424
    ml = inflate_mask[bl];
 
425
    md = inflate_mask[bd];
 
426
 
 
427
    // do until not enough input or output space for fast loop
 
428
    do {                          // assume called with m >= 258 && n >= 10
 
429
      // get literal/length code
 
430
      while(k<(20)){              // max bits for literal/length code
 
431
        n--;
 
432
        b|=(z.next_in[p++]&0xff)<<k;k+=8;
 
433
      }
 
434
 
 
435
      t= b&ml;
 
436
      tp=tl; 
 
437
      tp_index=tl_index;
 
438
      if ((e = tp[(tp_index+t)*3]) == 0){
 
439
        b>>=(tp[(tp_index+t)*3+1]); k-=(tp[(tp_index+t)*3+1]);
 
440
 
 
441
        s.window[q++] = (byte)tp[(tp_index+t)*3+2];
 
442
        m--;
 
443
        continue;
 
444
      }
 
445
      do {
 
446
 
 
447
        b>>=(tp[(tp_index+t)*3+1]); k-=(tp[(tp_index+t)*3+1]);
 
448
 
 
449
        if((e&16)!=0){
 
450
          e &= 15;
 
451
          c = tp[(tp_index+t)*3+2] + ((int)b & inflate_mask[e]);
 
452
 
 
453
          b>>=e; k-=e;
 
454
 
 
455
          // decode distance base of block to copy
 
456
          while(k<(15)){           // max bits for distance code
 
457
            n--;
 
458
            b|=(z.next_in[p++]&0xff)<<k;k+=8;
 
459
          }
 
460
 
 
461
          t= b&md;
 
462
          tp=td;
 
463
          tp_index=td_index;
 
464
          e = tp[(tp_index+t)*3];
 
465
 
 
466
          do {
 
467
 
 
468
            b>>=(tp[(tp_index+t)*3+1]); k-=(tp[(tp_index+t)*3+1]);
 
469
 
 
470
            if((e&16)!=0){
 
471
              // get extra bits to add to distance base
 
472
              e &= 15;
 
473
              while(k<(e)){         // get extra bits (up to 13)
 
474
                n--;
 
475
                b|=(z.next_in[p++]&0xff)<<k;k+=8;
 
476
              }
 
477
 
 
478
              d = tp[(tp_index+t)*3+2] + (b&inflate_mask[e]);
 
479
 
 
480
              b>>=(e); k-=(e);
 
481
 
 
482
              // do the copy
 
483
              m -= c;
 
484
              if (q >= d){                // offset before dest
 
485
                //  just copy
 
486
                r=q-d;
 
487
                if(q-r>0 && 2>(q-r)){           
 
488
                  s.window[q++]=s.window[r++]; c--; // minimum count is three,
 
489
                  s.window[q++]=s.window[r++]; c--; // so unroll loop a little
 
490
                }
 
491
                else{
 
492
                  System.arraycopy(s.window, r, s.window, q, 2);
 
493
                  q+=2; r+=2; c-=2;
 
494
                }
 
495
              }
 
496
              else{                  // else offset after destination
 
497
                r=q-d;
 
498
                do{
 
499
                  r+=s.end;          // force pointer in window
 
500
                }while(r<0);         // covers invalid distances
 
501
                e=s.end-r;
 
502
                if(c>e){             // if source crosses,
 
503
                  c-=e;              // wrapped copy
 
504
                  if(q-r>0 && e>(q-r)){           
 
505
                    do{s.window[q++] = s.window[r++];}
 
506
                    while(--e!=0);
 
507
                  }
 
508
                  else{
 
509
                    System.arraycopy(s.window, r, s.window, q, e);
 
510
                    q+=e; r+=e; e=0;
 
511
                  }
 
512
                  r = 0;                  // copy rest from start of window
 
513
                }
 
514
 
 
515
              }
 
516
 
 
517
              // copy all or what's left
 
518
              if(q-r>0 && c>(q-r)){           
 
519
                do{s.window[q++] = s.window[r++];}
 
520
                while(--c!=0);
 
521
              }
 
522
              else{
 
523
                System.arraycopy(s.window, r, s.window, q, c);
 
524
                q+=c; r+=c; c=0;
 
525
              }
 
526
              break;
 
527
            }
 
528
            else if((e&64)==0){
 
529
              t+=tp[(tp_index+t)*3+2];
 
530
              t+=(b&inflate_mask[e]);
 
531
              e=tp[(tp_index+t)*3];
 
532
            }
 
533
            else{
 
534
              z.msg = "invalid distance code";
 
535
 
 
536
              c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
 
537
 
 
538
              s.bitb=b;s.bitk=k;
 
539
              z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
540
              s.write=q;
 
541
 
 
542
              return Z_DATA_ERROR;
 
543
            }
 
544
          }
 
545
          while(true);
 
546
          break;
 
547
        }
 
548
 
 
549
        if((e&64)==0){
 
550
          t+=tp[(tp_index+t)*3+2];
 
551
          t+=(b&inflate_mask[e]);
 
552
          if((e=tp[(tp_index+t)*3])==0){
 
553
 
 
554
            b>>=(tp[(tp_index+t)*3+1]); k-=(tp[(tp_index+t)*3+1]);
 
555
 
 
556
            s.window[q++]=(byte)tp[(tp_index+t)*3+2];
 
557
            m--;
 
558
            break;
 
559
          }
 
560
        }
 
561
        else if((e&32)!=0){
 
562
 
 
563
          c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
 
564
 
 
565
          s.bitb=b;s.bitk=k;
 
566
          z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
567
          s.write=q;
 
568
 
 
569
          return Z_STREAM_END;
 
570
        }
 
571
        else{
 
572
          z.msg="invalid literal/length code";
 
573
 
 
574
          c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
 
575
 
 
576
          s.bitb=b;s.bitk=k;
 
577
          z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
578
          s.write=q;
 
579
 
 
580
          return Z_DATA_ERROR;
 
581
        }
 
582
      } 
 
583
      while(true);
 
584
    } 
 
585
    while(m>=258 && n>= 10);
 
586
 
 
587
    // not enough input or output--restore pointers and return
 
588
    c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
 
589
 
 
590
    s.bitb=b;s.bitk=k;
 
591
    z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
 
592
    s.write=q;
 
593
 
 
594
    return Z_OK;
 
595
  }
 
596
}