Add simple android client.
[odfkit:webodf.git] / android / assets / lib / core / RawInflate.js
1 /*global core*/
2 /*
3  * $Id: rawinflate.js,v 0.2 2009/03/01 18:32:24 dankogai Exp $
4  *
5  * original:
6  * http://www.onicos.com/staff/iz/amuse/javascript/expert/inflate.txt
7  */
8
9 /**
10  * @constructor
11  */
12 core.RawInflate = function RawInflate() {
13
14 /* Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
15  * Version: 1.0.0.1
16  * LastModified: Dec 25 1999
17  */
18
19 /* Interface:
20  * data = zip_inflate(src);
21  */
22
23 /* constant parameters */
24 var zip_WSIZE = 32768;          // Sliding Window size
25 var zip_STORED_BLOCK = 0;
26 var zip_STATIC_TREES = 1;
27 var zip_DYN_TREES    = 2;
28
29 /* for inflate */
30 var zip_lbits = 9;              // bits in base literal/length lookup table
31 var zip_dbits = 6;              // bits in base distance lookup table
32 var zip_INBUFSIZ = 32768;       // Input buffer size
33 var zip_INBUF_EXTRA = 64;       // Extra buffer
34
35 /* variables (inflate) */
36 var zip_slide;
37 var zip_wp;                     // current position in slide
38 var zip_fixed_tl = null;        // inflate static
39 var zip_fixed_td;               // inflate static
40 var zip_fixed_bl, fixed_bd;     // inflate static
41 var zip_bit_buf;                // bit buffer
42 var zip_bit_len;                // bits in bit buffer
43 var zip_method;
44 var zip_eof;
45 var zip_copy_leng;
46 var zip_copy_dist;
47 var zip_tl, zip_td;     // literal/length and distance decoder tables
48 var zip_bl, zip_bd;     // number of bits decoded by tl and td
49
50 var zip_inflate_data;
51 var zip_inflate_pos;
52
53
54 /* constant tables (inflate) */
55 var zip_MASK_BITS = new Array(
56     0x0000,
57     0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
58     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff);
59 // Tables for deflate from PKZIP's appnote.txt.
60 var zip_cplens = new Array( // Copy lengths for literal codes 257..285
61     3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
62     35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0);
63 /* note: see note #13 above about the 258 in this list. */
64 var zip_cplext = new Array( // Extra bits for literal codes 257..285
65     0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
66     3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99); // 99==invalid
67 var zip_cpdist = new Array( // Copy offsets for distance codes 0..29
68     1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
69     257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
70     8193, 12289, 16385, 24577);
71 var zip_cpdext = new Array( // Extra bits for distance codes
72     0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
73     7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
74     12, 12, 13, 13);
75 var zip_border = new Array(  // Order of the bit length code lengths
76     16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15);
77 /* objects (inflate) */
78
79 /**
80  * @constructor
81  */
82 var zip_HuftList = function() {
83     this.next = null;
84     this.list = null;
85 }
86
87 /**
88  * @constructor
89  */
90 var zip_HuftNode = function() {
91     this.e = 0; // number of extra bits or operation
92     this.b = 0; // number of bits in this code or subcode
93
94     // union
95     this.n = 0; // literal, length base, or distance base
96     this.t = null; // (zip_HuftNode) pointer to next level of table
97 }
98
99 /**
100  * @constructor
101  */
102 var zip_HuftBuild = function(b, // code lengths in bits (all assumed <= BMAX)
103                        n,       // number of codes (assumed <= N_MAX)
104                        s,       // number of simple-valued codes (0..s-1)
105                        d,       // list of base values for non-simple codes
106                        e,       // list of extra bits for non-simple codes
107                        mm       // maximum lookup bits
108                    ) {
109     this.BMAX = 16;   // maximum bit length of any code
110     this.N_MAX = 288; // maximum number of codes in any set
111     this.status = 0;    // 0: success, 1: incomplete table, 2: bad input
112     this.root = null;   // (zip_HuftList) starting table
113     this.m = 0;         // maximum lookup bits, returns actual
114
115 /* Given a list of code lengths and a maximum table size, make a set of
116    tables to decode that set of codes.  Return zero on success, one if
117    the given code set is incomplete (the tables are still built in this
118    case), two if the input is invalid (all zero length codes or an
119    oversubscribed set of lengths), and three if not enough memory.
120    The code with value 256 is special, and the tables are constructed
121    so that no bits beyond that code are fetched when that code is
122    decoded. */
123     {
124         var a;                  // counter for codes of length k
125         var c = new Array(this.BMAX+1); // bit length count table
126         var el;                 // length of EOB code (value 256)
127         var f;                  // i repeats in table every f entries
128         var g;                  // maximum code length
129         var h;                  // table level
130         var i;                  // counter, current code
131         var j;                  // counter
132         var k;                  // number of bits in current code
133         var lx = new Array(this.BMAX+1);        // stack of bits per table
134         var p;                  // pointer into c[], b[], or v[]
135         var pidx;               // index of p
136         var q;                  // (zip_HuftNode) points to current table
137         var r = new zip_HuftNode(); // table entry for structure assignment
138         var u = new Array(this.BMAX); // zip_HuftNode[BMAX][]  table stack
139         var v = new Array(this.N_MAX); // values in order of bit length
140         var w;
141         var x = new Array(this.BMAX+1);// bit offsets, then code stack
142         var xp;                 // pointer into x or c
143         var y;                  // number of dummy codes added
144         var z;                  // number of entries in current table
145         var o;
146         var tail;               // (zip_HuftList)
147
148         tail = this.root = null;
149         for(i = 0; i < c.length; i++)
150             c[i] = 0;
151         for(i = 0; i < lx.length; i++)
152             lx[i] = 0;
153         for(i = 0; i < u.length; i++)
154             u[i] = null;
155         for(i = 0; i < v.length; i++)
156             v[i] = 0;
157         for(i = 0; i < x.length; i++)
158             x[i] = 0;
159
160         // Generate counts for each bit length
161         el = n > 256 ? b[256] : this.BMAX; // set length of EOB code, if any
162         p = b; pidx = 0;
163         i = n;
164         do {
165             c[p[pidx]]++;       // assume all entries <= BMAX
166             pidx++;
167         } while(--i > 0);
168         if(c[0] == n) { // null input--all zero length codes
169             this.root = null;
170             this.m = 0;
171             this.status = 0;
172             return;
173         }
174
175         // Find minimum and maximum length, bound *m by those
176         for(j = 1; j <= this.BMAX; j++)
177             if(c[j] != 0)
178                 break;
179         k = j;                  // minimum code length
180         if(mm < j)
181             mm = j;
182         for(i = this.BMAX; i != 0; i--)
183             if(c[i] != 0)
184                 break;
185         g = i;                  // maximum code length
186         if(mm > i)
187             mm = i;
188
189         // Adjust last length count to fill out codes, if needed
190         for(y = 1 << j; j < i; j++, y <<= 1)
191             if((y -= c[j]) < 0) {
192                 this.status = 2;        // bad input: more codes than bits
193                 this.m = mm;
194                 return;
195             }
196         if((y -= c[i]) < 0) {
197             this.status = 2;
198             this.m = mm;
199             return;
200         }
201         c[i] += y;
202
203         // Generate starting offsets into the value table for each length
204         x[1] = j = 0;
205         p = c;
206         pidx = 1;
207         xp = 2;
208         while(--i > 0)          // note that i == g from above
209             x[xp++] = (j += p[pidx++]);
210
211         // Make a table of values in order of bit lengths
212         p = b; pidx = 0;
213         i = 0;
214         do {
215             if((j = p[pidx++]) != 0)
216                 v[x[j]++] = i;
217         } while(++i < n);
218         n = x[g];                       // set n to length of v
219
220         // Generate the Huffman codes and for each, make the table entries
221         x[0] = i = 0;           // first Huffman code is zero
222         p = v; pidx = 0;                // grab values in bit order
223         h = -1;                 // no tables yet--level -1
224         w = lx[0] = 0;          // no bits decoded yet
225         q = null;                       // ditto
226         z = 0;                  // ditto
227
228         // go through the bit lengths (k already is bits in shortest code)
229         for(; k <= g; k++) {
230             a = c[k];
231             while(a-- > 0) {
232                 // here i is the Huffman code of length k bits for value p[pidx]
233                 // make tables up to required level
234                 while(k > w + lx[1 + h]) {
235                     w += lx[1 + h]; // add bits already decoded
236                     h++;
237
238                     // compute minimum size table less than or equal to *m bits
239                     z = (z = g - w) > mm ? mm : z; // upper limit
240                     if((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table
241                         // too few codes for k-w bit table
242                         f -= a + 1;     // deduct codes from patterns left
243                         xp = k;
244                         while(++j < z) { // try smaller tables up to z bits
245                             if((f <<= 1) <= c[++xp])
246                                 break;  // enough codes to use up j bits
247                             f -= c[xp]; // else deduct codes from patterns
248                         }
249                     }
250                     if(w + j > el && w < el)
251                         j = el - w;     // make EOB code end at table
252                     z = 1 << j; // table entries for j-bit table
253                     lx[1 + h] = j; // set table size in stack
254
255                     // allocate and link in new table
256                     q = new Array(z);
257                     for(o = 0; o < z; o++) {
258                         q[o] = new zip_HuftNode();
259                     }
260
261                     if(tail == null)
262                         tail = this.root = new zip_HuftList();
263                     else
264                         tail = tail.next = new zip_HuftList();
265                     tail.next = null;
266                     tail.list = q;
267                     u[h] = q;   // table starts after link
268
269                     /* connect to last table, if there is one */
270                     if(h > 0) {
271                         x[h] = i;               // save pattern for backing up
272                         r.b = lx[h];    // bits to dump before this table
273                         r.e = 16 + j;   // bits in this table
274                         r.t = q;                // pointer to this table
275                         j = (i & ((1 << w) - 1)) >> (w - lx[h]);
276                         u[h-1][j].e = r.e;
277                         u[h-1][j].b = r.b;
278                         u[h-1][j].n = r.n;
279                         u[h-1][j].t = r.t;
280                     }
281                 }
282
283                 // set up table entry in r
284                 r.b = k - w;
285                 if(pidx >= n)
286                     r.e = 99;           // out of values--invalid code
287                 else if(p[pidx] < s) {
288                     r.e = (p[pidx] < 256 ? 16 : 15); // 256 is end-of-block code
289                     r.n = p[pidx++];    // simple code is just the value
290                 } else {
291                     r.e = e[p[pidx] - s];       // non-simple--look up in lists
292                     r.n = d[p[pidx++] - s];
293                 }
294
295                 // fill code-like entries with r //
296                 f = 1 << (k - w);
297                 for(j = i >> w; j < z; j += f) {
298                     q[j].e = r.e;
299                     q[j].b = r.b;
300                     q[j].n = r.n;
301                     q[j].t = r.t;
302                 }
303
304                 // backwards increment the k-bit code i
305                 for(j = 1 << (k - 1); (i & j) != 0; j >>= 1)
306                     i ^= j;
307                 i ^= j;
308
309                 // backup over finished tables
310                 while((i & ((1 << w) - 1)) != x[h]) {
311                     w -= lx[h];         // don't need to update q
312                     h--;
313                 }
314             }
315         }
316
317         /* return actual size of base table */
318         this.m = lx[1];
319
320         /* Return true (1) if we were given an incomplete table */
321         this.status = ((y != 0 && g != 1) ? 1 : 0);
322     } /* end of constructor */
323 }
324
325
326 /* routines (inflate) */
327
328 var zip_GET_BYTE = function() {
329     if(zip_inflate_data.length == zip_inflate_pos)
330         return -1;
331     return zip_inflate_data.charCodeAt(zip_inflate_pos++) & 0xff;
332 }
333
334 var zip_NEEDBITS = function(n) {
335     while(zip_bit_len < n) {
336         zip_bit_buf |= zip_GET_BYTE() << zip_bit_len;
337         zip_bit_len += 8;
338     }
339 }
340
341 var zip_GETBITS = function(n) {
342     return zip_bit_buf & zip_MASK_BITS[n];
343 }
344
345 var zip_DUMPBITS = function(n) {
346     zip_bit_buf >>= n;
347     zip_bit_len -= n;
348 }
349
350 var zip_inflate_codes = function(buff, off, size) {
351     /* inflate (decompress) the codes in a deflated (compressed) block.
352        Return an error code or zero if it all goes ok. */
353     var e;              // table entry flag/number of extra bits
354     var t;              // (zip_HuftNode) pointer to table entry
355     var n;
356
357     if(size == 0)
358       return 0;
359
360     // inflate the coded data
361     n = 0;
362     for(;;) {                   // do until end of block
363         zip_NEEDBITS(zip_bl);
364         t = zip_tl.list[zip_GETBITS(zip_bl)];
365         e = t.e;
366         while(e > 16) {
367             if(e == 99)
368                 return -1;
369             zip_DUMPBITS(t.b);
370             e -= 16;
371             zip_NEEDBITS(e);
372             t = t.t[zip_GETBITS(e)];
373             e = t.e;
374         }
375         zip_DUMPBITS(t.b);
376
377         if(e == 16) {           // then it's a literal
378             zip_wp &= zip_WSIZE - 1;
379             buff[off + n++] = zip_slide[zip_wp++] = t.n;
380             if(n == size)
381                 return size;
382             continue;
383         }
384
385         // exit if end of block
386         if(e == 15)
387             break;
388
389         // it's an EOB or a length
390
391         // get length of block to copy
392         zip_NEEDBITS(e);
393         zip_copy_leng = t.n + zip_GETBITS(e);
394         zip_DUMPBITS(e);
395
396         // decode distance of block to copy
397         zip_NEEDBITS(zip_bd);
398         t = zip_td.list[zip_GETBITS(zip_bd)];
399         e = t.e;
400
401         while(e > 16) {
402             if(e == 99)
403                 return -1;
404             zip_DUMPBITS(t.b);
405             e -= 16;
406             zip_NEEDBITS(e);
407             t = t.t[zip_GETBITS(e)];
408             e = t.e;
409         }
410         zip_DUMPBITS(t.b);
411         zip_NEEDBITS(e);
412         zip_copy_dist = zip_wp - t.n - zip_GETBITS(e);
413         zip_DUMPBITS(e);
414
415         // do the copy
416         while(zip_copy_leng > 0 && n < size) {
417             zip_copy_leng--;
418             zip_copy_dist &= zip_WSIZE - 1;
419             zip_wp &= zip_WSIZE - 1;
420             buff[off + n++] = zip_slide[zip_wp++]
421                 = zip_slide[zip_copy_dist++];
422         }
423
424         if(n == size)
425             return size;
426     }
427
428     zip_method = -1; // done
429     return n;
430 }
431
432 var zip_inflate_stored = function(buff, off, size) {
433     /* "decompress" an inflated type 0 (stored) block. */
434     var n;
435
436     // go to byte boundary
437     n = zip_bit_len & 7;
438     zip_DUMPBITS(n);
439
440     // get the length and its complement
441     zip_NEEDBITS(16);
442     n = zip_GETBITS(16);
443     zip_DUMPBITS(16);
444     zip_NEEDBITS(16);
445     if(n != ((~zip_bit_buf) & 0xffff))
446         return -1;                      // error in compressed data
447     zip_DUMPBITS(16);
448
449     // read and output the compressed data
450     zip_copy_leng = n;
451
452     n = 0;
453     while(zip_copy_leng > 0 && n < size) {
454         zip_copy_leng--;
455         zip_wp &= zip_WSIZE - 1;
456         zip_NEEDBITS(8);
457         buff[off + n++] = zip_slide[zip_wp++] =
458             zip_GETBITS(8);
459         zip_DUMPBITS(8);
460     }
461
462     if(zip_copy_leng == 0)
463       zip_method = -1; // done
464     return n;
465 }
466
467 var zip_fixed_bd;
468 var zip_inflate_fixed = function(buff, off, size) {
469     /* decompress an inflated type 1 (fixed Huffman codes) block.  We should
470        either replace this with a custom decoder, or at least precompute the
471        Huffman tables. */
472
473     // if first time, set up tables for fixed blocks
474     if(zip_fixed_tl == null) {
475         var i;                  // temporary variable
476         var l = new Array(288); // length list for huft_build
477         var h;  // zip_HuftBuild
478
479         // literal table
480         for(i = 0; i < 144; i++)
481             l[i] = 8;
482         for(; i < 256; i++)
483             l[i] = 9;
484         for(; i < 280; i++)
485             l[i] = 7;
486         for(; i < 288; i++)     // make a complete, but wrong code set
487             l[i] = 8;
488         zip_fixed_bl = 7;
489
490         h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext,
491                               zip_fixed_bl);
492         if(h.status != 0) {
493             alert("HufBuild error: "+h.status);
494             return -1;
495         }
496         zip_fixed_tl = h.root;
497         zip_fixed_bl = h.m;
498
499         // distance table
500         for(i = 0; i < 30; i++) // make an incomplete code set
501             l[i] = 5;
502         zip_fixed_bd = 5;
503
504         h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext, zip_fixed_bd);
505         if(h.status > 1) {
506             zip_fixed_tl = null;
507             alert("HufBuild error: "+h.status);
508             return -1;
509         }
510         zip_fixed_td = h.root;
511         zip_fixed_bd = h.m;
512     }
513
514     zip_tl = zip_fixed_tl;
515     zip_td = zip_fixed_td;
516     zip_bl = zip_fixed_bl;
517     zip_bd = zip_fixed_bd;
518     return zip_inflate_codes(buff, off, size);
519 }
520
521 var zip_inflate_dynamic = function(buff, off, size) {
522     // decompress an inflated type 2 (dynamic Huffman codes) block.
523     var i;              // temporary variables
524     var j;
525     var l;              // last length
526     var n;              // number of lengths to get
527     var t;              // (zip_HuftNode) literal/length code table
528     var nb;             // number of bit length codes
529     var nl;             // number of literal/length codes
530     var nd;             // number of distance codes
531     var ll = new Array(286+30); // literal/length and distance code lengths
532     var h;              // (zip_HuftBuild)
533
534     for(i = 0; i < ll.length; i++)
535         ll[i] = 0;
536
537     // read in table lengths
538     zip_NEEDBITS(5);
539     nl = 257 + zip_GETBITS(5);  // number of literal/length codes
540     zip_DUMPBITS(5);
541     zip_NEEDBITS(5);
542     nd = 1 + zip_GETBITS(5);    // number of distance codes
543     zip_DUMPBITS(5);
544     zip_NEEDBITS(4);
545     nb = 4 + zip_GETBITS(4);    // number of bit length codes
546     zip_DUMPBITS(4);
547     if(nl > 286 || nd > 30)
548       return -1;                // bad lengths
549
550     // read in bit-length-code lengths
551     for(j = 0; j < nb; j++)
552     {
553         zip_NEEDBITS(3);
554         ll[zip_border[j]] = zip_GETBITS(3);
555         zip_DUMPBITS(3);
556     }
557     for(; j < 19; j++)
558         ll[zip_border[j]] = 0;
559
560     // build decoding table for trees--single level, 7 bit lookup
561     zip_bl = 7;
562     h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl);
563     if(h.status != 0)
564         return -1;      // incomplete code set
565
566     zip_tl = h.root;
567     zip_bl = h.m;
568
569     // read in literal and distance code lengths
570     n = nl + nd;
571     i = l = 0;
572     while(i < n) {
573         zip_NEEDBITS(zip_bl);
574         t = zip_tl.list[zip_GETBITS(zip_bl)];
575         j = t.b;
576         zip_DUMPBITS(j);
577         j = t.n;
578         if(j < 16)              // length of code in bits (0..15)
579             ll[i++] = l = j;    // save last length in l
580         else if(j == 16) {      // repeat last length 3 to 6 times
581             zip_NEEDBITS(2);
582             j = 3 + zip_GETBITS(2);
583             zip_DUMPBITS(2);
584             if(i + j > n)
585                 return -1;
586             while(j-- > 0)
587                 ll[i++] = l;
588         } else if(j == 17) {    // 3 to 10 zero length codes
589             zip_NEEDBITS(3);
590             j = 3 + zip_GETBITS(3);
591             zip_DUMPBITS(3);
592             if(i + j > n)
593                 return -1;
594             while(j-- > 0)
595                 ll[i++] = 0;
596             l = 0;
597         } else {                // j == 18: 11 to 138 zero length codes
598             zip_NEEDBITS(7);
599             j = 11 + zip_GETBITS(7);
600             zip_DUMPBITS(7);
601             if(i + j > n)
602                 return -1;
603             while(j-- > 0)
604                 ll[i++] = 0;
605             l = 0;
606         }
607     }
608
609     // build the decoding tables for literal/length and distance codes
610     zip_bl = zip_lbits;
611     h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl);
612     if(zip_bl == 0)     // no literals or lengths
613         h.status = 1;
614     if(h.status != 0) {
615         //if(h.status == 1)
616         //    ;// **incomplete literal tree**
617         return -1;              // incomplete code set
618     }
619     zip_tl = h.root;
620     zip_bl = h.m;
621
622     for(i = 0; i < nd; i++)
623         ll[i] = ll[i + nl];
624     zip_bd = zip_dbits;
625     h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd);
626     zip_td = h.root;
627     zip_bd = h.m;
628
629     if(zip_bd == 0 && nl > 257) {   // lengths but no distances
630         // **incomplete distance tree**
631         return -1;
632     }
633
634     //if(h.status == 1) {
635 //      ;// **incomplete distance tree**
636     //}
637     if(h.status != 0)
638         return -1;
639
640     // decompress until an end-of-block code
641     return zip_inflate_codes(buff, off, size);
642 }
643
644 var zip_inflate_start = function() {
645     var i;
646
647     if(zip_slide == null)
648         zip_slide = new Array(2 * zip_WSIZE);
649     zip_wp = 0;
650     zip_bit_buf = 0;
651     zip_bit_len = 0;
652     zip_method = -1;
653     zip_eof = false;
654     zip_copy_leng = zip_copy_dist = 0;
655     zip_tl = null;
656 }
657
658 var zip_inflate_internal = function(buff, off, size) {
659     // decompress an inflated entry
660     var n, i;
661
662     n = 0;
663     while(n < size) {
664         if(zip_eof && zip_method == -1)
665             return n;
666
667         if(zip_copy_leng > 0) {
668             if(zip_method != zip_STORED_BLOCK) {
669                 // STATIC_TREES or DYN_TREES
670                 while(zip_copy_leng > 0 && n < size) {
671                     zip_copy_leng--;
672                     zip_copy_dist &= zip_WSIZE - 1;
673                     zip_wp &= zip_WSIZE - 1;
674                     buff[off + n++] = zip_slide[zip_wp++] =
675                         zip_slide[zip_copy_dist++];
676                 }
677             } else {
678                 while(zip_copy_leng > 0 && n < size) {
679                     zip_copy_leng--;
680                     zip_wp &= zip_WSIZE - 1;
681                     zip_NEEDBITS(8);
682                     buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
683                     zip_DUMPBITS(8);
684                 }
685                 if(zip_copy_leng == 0)
686                     zip_method = -1; // done
687             }
688             if(n == size)
689                 return n;
690         }
691
692         if(zip_method == -1) {
693             if(zip_eof)
694                 break;
695
696             // read in last block bit
697             zip_NEEDBITS(1);
698             if(zip_GETBITS(1) != 0)
699                 zip_eof = true;
700             zip_DUMPBITS(1);
701
702             // read in block type
703             zip_NEEDBITS(2);
704             zip_method = zip_GETBITS(2);
705             zip_DUMPBITS(2);
706             zip_tl = null;
707             zip_copy_leng = 0;
708         }
709
710         switch(zip_method) {
711           case 0: // zip_STORED_BLOCK
712             i = zip_inflate_stored(buff, off + n, size - n);
713             break;
714
715           case 1: // zip_STATIC_TREES
716             if(zip_tl != null)
717                 i = zip_inflate_codes(buff, off + n, size - n);
718             else
719                 i = zip_inflate_fixed(buff, off + n, size - n);
720             break;
721
722           case 2: // zip_DYN_TREES
723             if(zip_tl != null)
724                 i = zip_inflate_codes(buff, off + n, size - n);
725             else
726                 i = zip_inflate_dynamic(buff, off + n, size - n);
727             break;
728
729           default: // error
730             i = -1;
731             break;
732         }
733
734         if(i == -1) {
735             if(zip_eof)
736                 return 0;
737             return -1;
738         }
739         n += i;
740     }
741     return n;
742 }
743
744 var zip_inflate = function(str) {
745     var i, j;
746
747     zip_inflate_start();
748     zip_inflate_data = str;
749     zip_inflate_pos = 0;
750
751     var buff = new Array(1024);
752     var aout = [];
753     while((i = zip_inflate_internal(buff, 0, buff.length)) > 0) {
754         var cbuf = new Array(i);
755         for(j = 0; j < i; j++){
756             cbuf[j] = String.fromCharCode(buff[j]);
757         }
758         aout[aout.length] = cbuf.join("");
759     }
760     zip_inflate_data = null; // G.C.
761     return aout.join("");
762 }
763
764 this.inflate = zip_inflate;
765 };