Mercurial > hg > LGMap

comparison geotemco/lib/jszip/jszip-inflate.js @ 0:57bde4830927

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