home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / COMPRESS / VUNZIP.ZIP / UNZIP.C < prev   
Encoding:
C/C++ Source or Header  |  1990-02-01  |  32.0 KB  |  1,390 lines
  1. /*
  2.  * Copyright 1989 Samuel H. Smith;  All rights reserved
  3.  *
  4.  * Do not distribute modified versions without my permission.
  5.  * Do not remove or alter this notice or any other copyright notice.
  6.  * If you use this in your own program you must distribute source code.
  7.  * Do not use any of this in a commercial product.
  8.  *
  9.  */
  10.  
  11. /*
  12.  * UnZip - A simple zipfile extract utility
  13.  *
  14.  *  ported to VAX by Kw Chiu and Francis Leung
  15.  *
  16.  * To compile using Turbo C:
  17.  *      tcc -B -O -Z -G -mc unzip.c crc32.c    ;turbo C 2.0, compact model
  18.  *
  19.  * To compile in VAX:
  20.  *      cc unzip,crc32
  21.  *      link unzip,crc32
  22.  *
  23.  */
  24.  
  25. #define VERSION  "UnZip:  Zipfile Extract v2.0 (C) of 09-09-89;  (C) 1989 Samuel H. Smith"
  26.  
  27. typedef unsigned char byte;    /* code assumes UNSIGNED bytes */
  28. typedef long longint;
  29. typedef unsigned short word;  /* short in VAX */
  30. typedef char boolean;
  31.  
  32. #define STRSIZ 256
  33.  
  34. #include <stdio.h>
  35.  /* this is your standard header for all C compiles */
  36.  
  37. /* #include <stdlib.h> */
  38.  /* this include defines various standard library prototypes */
  39.  
  40.  
  41. /*
  42.  * SEE HOST OPERATING SYSTEM SPECIFICS SECTION STARTING NEAR LINE 180
  43.  *
  44.  */
  45.  
  46.  
  47. /* ----------------------------------------------------------- */
  48. /*
  49.  * Zipfile layout declarations
  50.  *
  51.  */
  52.  
  53. typedef longint signature_type;
  54.  
  55.  
  56. #define LOCAL_FILE_HEADER_SIGNATURE  0x04034b50L
  57.  
  58.  
  59. typedef struct local_file_header {
  60.     word version_needed_to_extract;
  61.     word general_purpose_bit_flag;
  62.     word compression_method;
  63.     word last_mod_file_time;
  64.     word last_mod_file_date;
  65.     longint crc32;
  66.     longint compressed_size;
  67.     longint uncompressed_size;
  68.     word filename_length;
  69.     word extra_field_length;
  70. } local_file_header;
  71.  
  72.  
  73. #define CENTRAL_FILE_HEADER_SIGNATURE  0x02014b50L
  74.  
  75.  
  76. typedef struct central_directory_file_header {
  77.     word version_made_by;
  78.     word version_needed_to_extract;
  79.     word general_purpose_bit_flag;
  80.     word compression_method;
  81.     word last_mod_file_time;
  82.     word last_mod_file_date;
  83.     longint crc32;
  84.     longint compressed_size;
  85.     longint uncompressed_size;
  86.     word filename_length;
  87.     word extra_field_length;
  88.     word file_comment_length;
  89.     word disk_number_start;
  90.     word internal_file_attributes;
  91.     longint external_file_attributes;
  92.     longint relative_offset_local_header;
  93. } central_directory_file_header;
  94.  
  95.  
  96. #define END_CENTRAL_DIR_SIGNATURE  0x06054b50L
  97.  
  98.  
  99. typedef struct end_central_dir_record {
  100.     word number_this_disk;
  101.     word number_disk_with_start_central;
  102.     word total_entries_central_dir_on_th;
  103.     word total_entries_central_dir;
  104.     longint size_central_directory;
  105.     longint offset_start_central_directory;
  106.     word zipfile_comment_length;
  107. } end_central_dir_record;
  108.  
  109.  
  110.  
  111. /* ----------------------------------------------------------- */
  112. /*
  113.  * input file variables
  114.  *
  115.  */
  116.  
  117. #define INBUFSIZ 0x2000
  118. byte *inbuf;            /* input file buffer - any size is legal */
  119. byte *inptr;
  120.  
  121. int incnt;
  122. unsigned bitbuf;
  123. int bits_left;
  124. boolean zipeof;
  125.  
  126. int zipfd;
  127. char zipfn[STRSIZ];
  128. local_file_header lrec;
  129.  
  130.  
  131. /* ----------------------------------------------------------- */
  132. /*
  133.  * output stream variables
  134.  *
  135.  */
  136.  
  137. #define OUTBUFSIZ 0x2000        /* must be 0x2000 or larger for unImplode */
  138. byte *outbuf;                   /* buffer for rle look-back */
  139. byte *outptr;
  140.  
  141. longint outpos;            /* absolute position in outfile */
  142. int outcnt;            /* current position in outbuf */
  143.  
  144. int outfd;
  145. char filename[STRSIZ];
  146. char extra[STRSIZ];
  147.  
  148. #define DLE 144
  149.  
  150.  
  151. /* ----------------------------------------------------------- */
  152. /*
  153.  * shrink/reduce working storage
  154.  *
  155.  */
  156.  
  157. int factor;
  158. byte followers[256][64];
  159. byte Slen[256];
  160.  
  161. #define max_bits 13
  162. #define init_bits 9
  163. #define hsize 8192
  164. #define first_ent 257
  165. #define clear 256
  166.  
  167. typedef int hsize_array_integer[hsize+1];
  168. typedef byte hsize_array_byte[hsize+1];
  169.  
  170. hsize_array_integer prefix_of;
  171. hsize_array_byte suffix_of;
  172. hsize_array_byte stack;
  173.  
  174. int codesize;
  175. int maxcode;
  176. int free_ent;
  177. int maxcodemax;
  178. int offset;
  179. int sizex;
  180.  
  181.  
  182.  
  183. /* ============================================================= */
  184. /*
  185.  * Host operating system details
  186.  *
  187.  */
  188.  
  189. /* #include <string.h> */
  190.  /* this include defines strcpy, strcmp, etc. */
  191.  
  192. /* ifdef...  added by K.W.Chiu */
  193.  
  194. #ifdef VAX
  195. /* #include <unixio.h> */
  196. #include <file.h>
  197. #define O_BINARY 0
  198. #include <stat.h>
  199. #else
  200.  
  201. #include <io.h>
  202.  /*
  203.   * this include file defines
  204.   *             struct ftime ...        (* file time/date stamp info *)
  205.   *             int setftime (int handle, struct ftime *ftimep);
  206.   *             #define SEEK_CUR  1     (* lseek() modes *)
  207.   *             #define SEEK_END  2
  208.   *             #define SEEK_SET  0
  209.   */
  210.  
  211. #include <fcntl.h>
  212.  /*
  213.   * this include file defines
  214.   *             #define O_BINARY 0x8000  (* no cr-lf translation *)
  215.   * as used in the open() standard function
  216.   */
  217.  
  218. #include <sys/stat.h>
  219.  /*
  220.   * this include file defines
  221.   *             #define S_IREAD 0x0100  (* owner may read *)
  222.   *             #define S_IWRITE 0x0080 (* owner may write *)
  223.   * as used in the creat() standard function
  224.   */
  225. #endif
  226.  
  227. #define SEEK_SET  0        /* wsm */
  228. /* #undef HIGH_LOW */        /* wsm */
  229.  /*
  230.   * change 'undef' to 'define' if your machine stores high order bytes in
  231.   * lower addresses.
  232.   */
  233.  
  234. void set_file_time()
  235.  /*
  236.   * set the output file date/time stamp according to information from the
  237.   * zipfile directory record for this file 
  238.   */
  239. {
  240. #ifdef VAX
  241.     /* don't know how to set file time */
  242. #else
  243.  
  244.     union {
  245.                 struct ftime ft;        /* system file time record */
  246.         struct {
  247.                         word ztime;     /* date and time words */
  248.                         word zdate;     /* .. same format as in .ZIP file */
  249.         } zt;
  250.     } td;
  251.  
  252.     /*
  253.      * set output file date and time - this is optional and can be
  254.      * deleted if your compiler does not easily support setftime() 
  255.      */
  256.  
  257.     td.zt.ztime = lrec.last_mod_file_time;
  258.     td.zt.zdate = lrec.last_mod_file_date;
  259.  
  260.     setftime(outfd, &td.ft);
  261. #endif
  262. }
  263.  
  264.  
  265. int create_output_file()
  266.  /* return non-0 if creat failed */
  267. {
  268.     /* create the output file with READ and WRITE permissions */
  269.     outfd = creat(filename, S_IWRITE | S_IREAD);
  270.     if (outfd < 1) {
  271.         printf("Can't create output: %s\n", filename);
  272.         return 1;
  273.     }
  274.  
  275.     /*
  276.      * close the newly created file and reopen it in BINARY mode to
  277.      * disable all CR/LF translations 
  278.      */
  279.     close(outfd);
  280.     outfd = open(filename, O_RDWR | O_BINARY);
  281.  
  282.     /* write a single byte at EOF to pre-allocate the file */
  283.         lseek(outfd, lrec.uncompressed_size - 1L, SEEK_SET);
  284.     write(outfd, "?", 1);
  285.     lseek(outfd, 0L, SEEK_SET);
  286.     return 0;
  287. }
  288.  
  289.  
  290. int open_input_file()
  291.  /* return non-0 if creat failed */
  292. {
  293.     /*
  294.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  295.      * translation, which would corrupt the bitstreams 
  296.      */
  297.  
  298.     zipfd = open(zipfn, O_RDONLY | O_BINARY);
  299.     if (zipfd < 1) {
  300.         printf("Can't open input file: %s\n", zipfn);
  301.         return (1);
  302.     }
  303.     return 0;
  304. }
  305.  
  306.  
  307. #ifdef HIGH_LOW
  308.  
  309. void swap_bytes(wordp)
  310. word *wordp;
  311.  /* convert intel style 'short int' variable to host format */
  312. {
  313.     char *charp = (char *) wordp;
  314.     char temp;
  315.  
  316.     temp = charp[0];
  317.     charp[0] = charp[1];
  318.     charp[1] = temp;
  319. }
  320.  
  321. void swap_lbytes(longp)
  322. longint *longp;
  323.  /* convert intel style 'long' variable to host format */
  324. {
  325.     char *charp = (char *) longp;
  326.     char temp[4];
  327.  
  328.     temp[3] = charp[0];
  329.     temp[2] = charp[1];
  330.     temp[1] = charp[2];
  331.     temp[0] = charp[3];
  332.  
  333.     charp[0] = temp[0];
  334.     charp[1] = temp[1];
  335.     charp[2] = temp[2];
  336.     charp[3] = temp[3];
  337. }
  338.  
  339. #endif
  340.  
  341.  
  342.  
  343. /* ============================================================= */
  344.  
  345. int FillBuffer()
  346.  /* fill input buffer if possible */
  347. {
  348.     int readsize;
  349.  
  350.         if (lrec.compressed_size <= 0)
  351.         return incnt = 0;
  352.  
  353.         if (lrec.compressed_size > INBUFSIZ)
  354.         readsize = INBUFSIZ;
  355.     else
  356.                 readsize = (int) lrec.compressed_size;
  357.     incnt = read(zipfd, inbuf, readsize);
  358.  
  359.         lrec.compressed_size -= incnt;
  360.     inptr = inbuf;
  361.     return incnt--;
  362. }
  363.  
  364. int ReadByte(x)
  365. unsigned *x;
  366.  /* read a byte; return 8 if byte available, 0 if not */
  367. {
  368.     if (incnt-- == 0)
  369.         if (FillBuffer() == 0)
  370.             return 0;
  371.  
  372.     *x = *inptr++;
  373.     return 8;
  374. }
  375.  
  376.  
  377. /* ------------------------------------------------------------- */
  378. static unsigned mask_bits[] =
  379.         {0,     0x0001, 0x0003, 0x0007, 0x000f,
  380.                 0x001f, 0x003f, 0x007f, 0x00ff,
  381.                 0x01ff, 0x03ff, 0x07ff, 0x0fff,
  382.                 0x1fff, 0x3fff, 0x7fff, 0xffff
  383.         };
  384.  
  385.  
  386. int FillBitBuffer(bits)
  387. register int bits;
  388. {
  389.     /* get the bits that are left and read the next word */
  390.     unsigned temp;
  391.         register int result = bitbuf;
  392.     int sbits = bits_left;
  393.     bits -= bits_left;
  394.  
  395.     /* read next word of input */
  396.     bits_left = ReadByte(&bitbuf);
  397.     bits_left += ReadByte(&temp);
  398.     bitbuf |= (temp << 8);
  399.     if (bits_left == 0)
  400.         zipeof = 1;
  401.  
  402.     /* get the remaining bits */
  403.         result = result | (int) ((bitbuf & mask_bits[bits]) << sbits);
  404.         bitbuf >>= bits;
  405.         bits_left -= bits;
  406.         return result;
  407. }
  408.  
  409. #define READBIT(nbits,zdest) { if (nbits <= bits_left) { zdest = (int)(bitbuf & mask_bits[nbits]); bitbuf >>= nbits; bits_left -= nbits; } else zdest = FillBitBuffer(nbits);}
  410.  
  411. /*
  412.  * macro READBIT(nbits,zdest)
  413.  *  {
  414.  *      if (nbits <= bits_left) {
  415.  *          zdest = (int)(bitbuf & mask_bits[nbits]);
  416.  *          bitbuf >>= nbits;
  417.  *          bits_left -= nbits;
  418.  *      } else
  419.  *          zdest = FillBitBuffer(nbits);
  420.  *  }
  421.  *
  422.  */
  423.  
  424.  
  425. /* ------------------------------------------------------------- */
  426.  
  427. #include "crc32.h"
  428.  
  429.  
  430. /* ------------------------------------------------------------- */
  431.  
  432. void FlushOutput()
  433.  /* flush contents of output buffer */
  434. {
  435.     UpdateCRC(outbuf, outcnt);
  436.     write(outfd, outbuf, outcnt);
  437.     outpos += outcnt;
  438.     outcnt = 0;
  439.     outptr = outbuf;
  440.     printf (".");       /* inform user of progress. - Francis Leung */
  441. }
  442.  
  443. #define OUTB(intc) { *outptr++=intc; if (++outcnt==OUTBUFSIZ) FlushOutput(); }
  444.  
  445. /*
  446.  *  macro OUTB(intc)
  447.  *  {
  448.  *      *outptr++=intc;
  449.  *      if (++outcnt==OUTBUFSIZ)
  450.  *          FlushOutput();
  451.  *  }
  452.  *
  453.  */
  454.  
  455.  
  456. /* ----------------------------------------------------------- */
  457.  
  458. void LoadFollowers()
  459. {
  460.         register int x;
  461.         register int i;
  462.  
  463.     for (x = 255; x >= 0; x--) {
  464.                 READBIT(6,Slen[x]);
  465.         for (i = 0; i < Slen[x]; i++) {
  466.                         READBIT(8,followers[x][i]);
  467.         }
  468.     }
  469. }
  470.  
  471.  
  472. /* ----------------------------------------------------------- */
  473. /*
  474.  * The Reducing algorithm is actually a combination of two
  475.  * distinct algorithms.  The first algorithm compresses repeated
  476.  * byte sequences, and the second algorithm takes the compressed
  477.  * stream from the first algorithm and applies a probabilistic
  478.  * compression method.
  479.  */
  480.  
  481. int L_table[] = {0, 0x7f, 0x3f, 0x1f, 0x0f};
  482.  
  483. int D_shift[] = {0, 0x07, 0x06, 0x05, 0x04};
  484. int D_mask[]  = {0, 0x01, 0x03, 0x07, 0x0f};
  485.  
  486. int B_table[] = {8, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5,
  487.          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6,
  488.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  489.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
  490.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  491.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  492.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  493.          7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  494.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  495.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  496.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  497.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  498.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  499.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  500.          8, 8, 8, 8};
  501.  
  502. /* ----------------------------------------------------------- */
  503.  
  504. void unReduce()
  505.  /* expand probablisticly reduced data */
  506. {
  507.         register int lchar;
  508.         int nchar;
  509.         int ExState;
  510.         int V;
  511.         int Len;
  512.  
  513.         factor = lrec.compression_method - 1;
  514.     ExState = 0;
  515.     lchar = 0;
  516.     LoadFollowers();
  517.  
  518.         while (((outpos+outcnt) < lrec.uncompressed_size) && (!zipeof)) {
  519.         if (Slen[lchar] == 0)
  520.                         READBIT(8,nchar)      /* ; */
  521.                 else
  522.         {
  523.                         READBIT(1,nchar);
  524.                         if (nchar != 0)
  525.                                 READBIT(8,nchar)      /* ; */
  526.                         else
  527.             {
  528.                                 int follower;
  529.                                 int bitsneeded = B_table[Slen[lchar]];
  530.                                 READBIT(bitsneeded,follower);
  531.                                 nchar = followers[lchar][follower];
  532.             }
  533.         }
  534.  
  535.         /* expand the resulting byte */
  536.         switch (ExState) {
  537.  
  538.         case 0:
  539.                         if (nchar != DLE)
  540.                                 OUTB(nchar) /*;*/
  541.             else
  542.                 ExState = 1;
  543.             break;
  544.  
  545.         case 1:
  546.                         if (nchar != 0) {
  547.                                 V = nchar;
  548.                 Len = V & L_table[factor];
  549.                 if (Len == L_table[factor])
  550.                     ExState = 2;
  551.                 else
  552.                     ExState = 3;
  553.             }
  554.             else {
  555.                                 OUTB(DLE);
  556.                 ExState = 0;
  557.             }
  558.             break;
  559.  
  560.                 case 2: {
  561.                                 Len += nchar;
  562.                 ExState = 3;
  563.             }
  564.             break;
  565.  
  566.                 case 3: {
  567.                 register int i = Len + 3;
  568.                 int offset = (((V >> D_shift[factor]) &
  569.                                           D_mask[factor]) << 8) + nchar + 1;
  570.                                 longint op = (outpos+outcnt) - offset;
  571.  
  572.                 /* special case- before start of file */
  573.                 while ((op < 0L) && (i > 0)) {
  574.                     OUTB(0);
  575.                     op++;
  576.                     i--;
  577.                 }
  578.  
  579.                 /* normal copy of data from output buffer */
  580.                 {
  581.                     register int ix = (int) (op % OUTBUFSIZ);
  582. #ifndef VAX
  583.                   /* it appeared that the VAX memcpy function is not
  584.                    * working the same way as Turbo C, therefore use
  585.                    * OUTB instead.  - Francis Leung
  586.                    */
  587.  
  588.  
  589.                                         /* do a block memory copy if possible */
  590.                                         if ( ((ix    +i) < OUTBUFSIZ) &&
  591.                                              ((outcnt+i) < OUTBUFSIZ) ) {
  592.                                                 memcpy(outptr,&outbuf[ix],i);
  593.                                                 outptr += i;
  594.                                                 outcnt += i;
  595.                                         }
  596.                                         else
  597.                                         /* otherwise copy byte by byte */
  598. #endif
  599.                                         while (i--) {
  600.                                                 OUTB(outbuf[ix]);
  601.                                                 if (++ix >= OUTBUFSIZ)
  602.                                                         ix = 0;
  603.                                         }
  604.                                 }
  605.  
  606.                 ExState = 0;
  607.             }
  608.             break;
  609.         }
  610.  
  611.                 /* store character for next iteration */
  612.                 lchar = nchar;
  613.         }
  614. }
  615.  
  616.  
  617. /* ------------------------------------------------------------- */
  618. /*
  619.  * Shrinking is a Dynamic Ziv-Lempel-Welch compression algorithm
  620.  * with partial clearing.
  621.  *
  622.  */
  623.  
  624. void partial_clear()
  625. {
  626.         register int pr;
  627.         register int cd;
  628.  
  629.     /* mark all nodes as potentially unused */
  630.     for (cd = first_ent; cd < free_ent; cd++)
  631.         prefix_of[cd] |= 0x8000;
  632.  
  633.     /* unmark those that are used by other nodes */
  634.     for (cd = first_ent; cd < free_ent; cd++) {
  635.         pr = prefix_of[cd] & 0x7fff;    /* reference to another node? */
  636.                 if (pr >= first_ent)            /* flag node as referenced */
  637.             prefix_of[pr] &= 0x7fff;
  638.     }
  639.  
  640.     /* clear the ones that are still marked */
  641.     for (cd = first_ent; cd < free_ent; cd++)
  642.         if ((prefix_of[cd] & 0x8000) != 0)
  643.             prefix_of[cd] = -1;
  644.  
  645.     /* find first cleared node as next free_ent */
  646.         cd = first_ent;
  647.         while ((cd < maxcodemax) && (prefix_of[cd] != -1))
  648.                 cd++;
  649.         free_ent = cd;
  650. }
  651.  
  652.  
  653. /* ------------------------------------------------------------- */
  654.  
  655. void unShrink()
  656. {
  657. #define  GetCode(dest) READBIT(codesize,dest)
  658.  
  659.     register int code;
  660.     register int stackp;
  661.     int finchar;
  662.     int oldcode;
  663.     int incode;
  664.  
  665.  
  666.     /* decompress the file */
  667.     maxcodemax = 1 << max_bits;
  668.     codesize = init_bits;
  669.     maxcode = (1 << codesize) - 1;
  670.     free_ent = first_ent;
  671.     offset = 0;
  672.     sizex = 0;
  673.  
  674.     for (code = maxcodemax; code > 255; code--)
  675.         prefix_of[code] = -1;
  676.  
  677.     for (code = 255; code >= 0; code--) {
  678.         prefix_of[code] = 0;
  679.         suffix_of[code] = code;
  680.     }
  681.  
  682.     GetCode(oldcode);
  683.     if (zipeof)
  684.         return;
  685.     finchar = oldcode;
  686.  
  687.         OUTB(finchar);
  688.  
  689.         stackp = hsize;
  690.  
  691.     while (!zipeof) {
  692.         GetCode(code);
  693.         if (zipeof)
  694.             return;
  695.  
  696.         while (code == clear) {
  697.             GetCode(code);
  698.             switch (code) {
  699.  
  700.             case 1:{
  701.                     codesize++;
  702.                     if (codesize == max_bits)
  703.                         maxcode = maxcodemax;
  704.                     else
  705.                         maxcode = (1 << codesize) - 1;
  706.                 }
  707.                 break;
  708.  
  709.             case 2:
  710.                 partial_clear();
  711.                 break;
  712.             }
  713.  
  714.             GetCode(code);
  715.             if (zipeof)
  716.                 return;
  717.         }
  718.  
  719.  
  720.         /* special case for KwKwK string */
  721.         incode = code;
  722.         if (prefix_of[code] == -1) {
  723.                         stack[--stackp] = finchar;
  724.             code = oldcode;
  725.         }
  726.  
  727.  
  728.         /* generate output characters in reverse order */
  729.         while (code >= first_ent) {
  730.                         stack[--stackp] = suffix_of[code];
  731.             code = prefix_of[code];
  732.         }
  733.  
  734.         finchar = suffix_of[code];
  735.                 stack[--stackp] = finchar;
  736.  
  737. #ifndef VAX     /* added by Francis Leung */
  738.  
  739.                 /* and put them out in forward order, block copy */
  740.                 if ((hsize-stackp+outcnt) < OUTBUFSIZ) {
  741.                         memcpy(outptr,&stack[stackp],hsize-stackp);
  742.                         outptr += hsize-stackp;
  743.                         outcnt += hsize-stackp;
  744.                         stackp = hsize;
  745.                 }
  746.                 else
  747.                 /* output byte by byte if we can't go by blocks */
  748. #endif
  749.                 while (stackp < hsize)
  750.                         OUTB(stack[stackp++]);
  751.  
  752.  
  753.         /* generate new entry */
  754.         code = free_ent;
  755.         if (code < maxcodemax) {
  756.             prefix_of[code] = oldcode;
  757.             suffix_of[code] = finchar;
  758.  
  759.             do
  760.                 code++;
  761.             while ((code < maxcodemax) && (prefix_of[code] != -1));
  762.  
  763.             free_ent = code;
  764.         }
  765.  
  766.         /* remember previous code */
  767.         oldcode = incode;
  768.     }
  769.  
  770. }
  771.  
  772.  
  773. /* ------------------------------------------------------------- */ 
  774. /*
  775.  * Imploding
  776.  * ---------
  777.  *
  778.  * The Imploding algorithm is actually a combination of two distinct
  779.  * algorithms.  The first algorithm compresses repeated byte sequences
  780.  * using a sliding dictionary.  The second algorithm is used to compress
  781.  * the encoding of the sliding dictionary ouput, using multiple
  782.  * Shannon-Fano trees.
  783.  *
  784.  */ 
  785.  
  786.    enum { maxSF        = 256 };
  787.  
  788.    typedef struct sf_entry { 
  789.                  word         Code; 
  790.                  byte         Value; 
  791.                  byte         BitLength; 
  792.               } sf_entry; 
  793.  
  794.    typedef struct sf_tree {   /* a shannon-fano tree */ 
  795.       sf_entry     entri[maxSF];
  796.       int          entries;
  797.       int          MaxLength;
  798.    } sf_tree; 
  799.  
  800.    typedef sf_tree      *sf_treep; 
  801.  
  802.    sf_tree      lit_tree; 
  803.    sf_tree      length_tree; 
  804.    sf_tree      distance_tree; 
  805.    boolean      lit_tree_present; 
  806.    boolean      eightK_dictionary; 
  807.    int          minimum_match_length;
  808.    int          dict_bits;
  809.  
  810.  
  811. void SortLengths(tree)
  812. sf_tree *tree;
  813.   /* Sort the Bit Lengths in ascending order, while retaining the order
  814.     of the original lengths stored in the file */ 
  815. { 
  816.    int          x;
  817.    int          gap;
  818.    sf_entry     t; 
  819.    boolean      noswaps;
  820.    int          a, b;
  821.  
  822.    gap = tree->entries / 2; 
  823.  
  824.    do { 
  825.       do { 
  826.          noswaps = 1;
  827.          for (x = 0; x <= (tree->entries - 1) - gap; x++) 
  828.          { 
  829.             a = tree->entri[x].BitLength; 
  830.             b = tree->entri[x + gap].BitLength; 
  831.             if ((a > b) || ((a == b) && (tree->entri[x].Value > tree->entri[x + gap].Value))) 
  832.             { 
  833.                t = tree->entri[x]; 
  834.                tree->entri[x] = tree->entri[x + gap]; 
  835.                tree->entri[x + gap] = t; 
  836.                noswaps = 0;
  837.             } 
  838.          } 
  839.       }  while (!noswaps);
  840.  
  841.       gap = gap / 2; 
  842.    }  while (gap > 0);
  843. } 
  844.  
  845.  
  846. /* ----------------------------------------------------------- */ 
  847.  
  848. void ReadLengths(tree)
  849. sf_tree *tree;
  850. { 
  851.    int          treeBytes;
  852.    int          i;
  853.    int          num, len;
  854.  
  855.   /* get number of bytes in compressed tree */
  856.    READBIT(8,treeBytes);
  857.    treeBytes++; 
  858.    i = 0; 
  859.  
  860.    tree->MaxLength = 0;
  861.  
  862.  /* High 4 bits: Number of values at this bit length + 1. (1 - 16)
  863.     Low  4 bits: Bit Length needed to represent value + 1. (1 - 16) */
  864.    while (treeBytes > 0)
  865.    {
  866.       READBIT(4,len); len++;
  867.       READBIT(4,num); num++;
  868.  
  869.       while (num > 0)
  870.       {
  871.          if (len > tree->MaxLength)
  872.             tree->MaxLength = len;
  873.          tree->entri[i].BitLength = len;
  874.          tree->entri[i].Value = i;
  875.          i++;
  876.          num--;
  877.       }
  878.  
  879.       treeBytes--;
  880.    } 
  881. } 
  882.  
  883.  
  884. /* ----------------------------------------------------------- */ 
  885.  
  886. void GenerateTrees(tree)
  887. sf_tree *tree;
  888.      /* Generate the Shannon-Fano trees */ 
  889. { 
  890.    word         Code;
  891.    int          CodeIncrement;
  892.    int          LastBitLength;
  893.    int          i;
  894.  
  895.  
  896.    Code = 0;
  897.    CodeIncrement = 0; 
  898.    LastBitLength = 0; 
  899.  
  900.    i = tree->entries - 1;   /* either 255 or 63 */ 
  901.    while (i >= 0) 
  902.    { 
  903.       Code += CodeIncrement; 
  904.       if (tree->entri[i].BitLength != LastBitLength) 
  905.       { 
  906.          LastBitLength = tree->entri[i].BitLength; 
  907.          CodeIncrement = 1 << (16 - LastBitLength); 
  908.       } 
  909.  
  910.       tree->entri[i].Code = Code; 
  911.       i--; 
  912.    } 
  913. } 
  914.  
  915.  
  916. /* ----------------------------------------------------------- */ 
  917.  
  918. void ReverseBits(tree)
  919. sf_tree *tree;
  920.  /* Reverse the order of all the bits in the above ShannonCode[]
  921.     vector, so that the most significant bit becomes the least
  922.     significant bit. For example, the value 0x1234 (hex) would become
  923.     0x2C48 (hex). */ 
  924. { 
  925.    int          i;
  926.    word         mask;
  927.    word         revb;
  928.    word         v;
  929.    word         o;
  930.    int          b;
  931.  
  932.  
  933.    for (i = 0; i <= tree->entries - 1; i++) 
  934.    { 
  935.         /* get original code */ 
  936.       o = tree->entri[i].Code; 
  937.  
  938.         /* reverse each bit */ 
  939.       mask = 0x0001;
  940.       revb = 0x8000;
  941.       v = 0;
  942.       for (b = 0; b <= 15; b++) 
  943.       { 
  944.            /* if bit set in mask, then substitute reversed bit */ 
  945.          if ((o & mask) != 0) 
  946.             v = v | revb; 
  947.  
  948.            /* advance to next bit */ 
  949.          revb = (revb >> 1);
  950.          mask = (mask << 1);
  951.       } 
  952.  
  953.         /* store reversed bits */ 
  954.       tree->entri[i].Code = v; 
  955.    } 
  956. } 
  957.  
  958.  
  959. /* ----------------------------------------------------------- */ 
  960.  
  961. void LoadTree(tree, treesize)
  962. sf_tree *tree;
  963. int treesize;
  964.      /* allocate and load a shannon-fano tree from the compressed file */ 
  965. { 
  966.    tree->entries = treesize; 
  967.    ReadLengths(tree); 
  968.    SortLengths(tree); 
  969.    GenerateTrees(tree); 
  970.    ReverseBits(tree); 
  971. } 
  972.  
  973.  
  974. /* ----------------------------------------------------------- */ 
  975.  
  976. void LoadTrees()
  977. { 
  978.    eightK_dictionary = (lrec.general_purpose_bit_flag & 0x02) != 0;   /* bit 1 */
  979.    lit_tree_present = (lrec.general_purpose_bit_flag & 0x04) != 0;   /* bit 2 */
  980.  
  981.    if (eightK_dictionary) 
  982.       dict_bits = 7;
  983.    else 
  984.       dict_bits = 6; 
  985.  
  986.    if (lit_tree_present) 
  987.    { 
  988.       minimum_match_length = 3; 
  989.       LoadTree(&lit_tree,256); 
  990.    } 
  991.    else 
  992.       minimum_match_length = 2; 
  993.  
  994.    LoadTree(&length_tree,64); 
  995.    LoadTree(&distance_tree,64); 
  996. } 
  997.  
  998.  
  999. /* ----------------------------------------------------------- */ 
  1000.  
  1001. void ReadTree(tree, dest)
  1002. sf_tree *tree;
  1003. int *dest;
  1004.      /* read next byte using a shannon-fano tree */ 
  1005. { 
  1006.    int          bits = 0;
  1007.    word         cv = 0;
  1008.    int          cur = 0;
  1009.    int          b;
  1010.  
  1011.    *dest = -1;   /* in case of error */ 
  1012.  
  1013.    for (;;)
  1014.    { 
  1015.       READBIT(1,b);
  1016.       cv = cv | (b << bits);
  1017.       bits++; 
  1018.  
  1019.       /* this is a very poor way of decoding shannon-fano.  two quicker
  1020.          methods come to mind:
  1021.             a) arrange the tree as a huffman-style binary tree with
  1022.                a "leaf" indicator at each node,
  1023.          and
  1024.             b) take advantage of the fact that s-f codes are at most 8
  1025.                bits long and alias unused codes for all bits following
  1026.                the "leaf" bit.
  1027.       */
  1028.  
  1029.       while (tree->entri[cur].BitLength < bits) 
  1030.       { 
  1031.          cur++; 
  1032.          if (cur >= tree->entries) 
  1033.             return; /* data error */
  1034.       } 
  1035.  
  1036.       while (tree->entri[cur].BitLength == bits) 
  1037.       { 
  1038.          if (tree->entri[cur].Code == cv) 
  1039.          { 
  1040.             *dest = tree->entri[cur].Value; 
  1041.             return; 
  1042.          } 
  1043.  
  1044.          cur++; 
  1045.          if (cur >= tree->entries) 
  1046.             return; /* data error */
  1047.       } 
  1048.    } 
  1049. } 
  1050.  
  1051.  
  1052. /* ----------------------------------------------------------- */ 
  1053.  
  1054. void  unImplode()
  1055.      /* expand imploded data */ 
  1056.  
  1057. { 
  1058.    int          lout;
  1059.    longint      op;
  1060.    int          Length;
  1061.    int          Distance;
  1062.    int          i;
  1063.  
  1064.    LoadTrees(); 
  1065.  
  1066.    while ((!zipeof) && ((outpos+outcnt) < lrec.uncompressed_size))
  1067.    { 
  1068.       READBIT(1,lout);
  1069.  
  1070.       if (lout != 0)   /* encoded data is literal data */ 
  1071.       { 
  1072.          if (lit_tree_present)  /* use Literal Shannon-Fano tree */
  1073.             ReadTree(&lit_tree,&lout);
  1074.          else 
  1075.             READBIT(8,lout);
  1076.  
  1077.          OUTB(lout);
  1078.       } 
  1079.       else             /* encoded data is sliding dictionary match */
  1080.       {                
  1081.          READBIT(dict_bits,lout);
  1082.          Distance = lout; 
  1083.  
  1084.          ReadTree(&distance_tree,&lout); 
  1085.          Distance |= (lout << dict_bits);
  1086.          /* using the Distance Shannon-Fano tree, read and decode the
  1087.             upper 6 bits of the Distance value */ 
  1088.  
  1089.          ReadTree(&length_tree,&Length); 
  1090.          /* using the Length Shannon-Fano tree, read and decode the
  1091.             Length value */
  1092.  
  1093.          Length += minimum_match_length; 
  1094.          if (Length == (63 + minimum_match_length)) 
  1095.          { 
  1096.             READBIT(8,lout);
  1097.             Length += lout; 
  1098.          } 
  1099.  
  1100.         /* move backwards Distance+1 bytes in the output stream, and copy
  1101.           Length characters from this position to the output stream.
  1102.           (if this position is before the start of the output stream,
  1103.           then assume that all the data before the start of the output
  1104.           stream is filled with zeros) */ 
  1105.  
  1106.          op = (outpos+outcnt) - Distance - 1L;
  1107.  
  1108.           /* special case- before start of file */
  1109.           while ((op < 0L) && (Length > 0)) {
  1110.                   OUTB(0);
  1111.                   op++;
  1112.                   Length--;
  1113.           }
  1114.  
  1115.           /* normal copy of data from output buffer */
  1116.           {
  1117.                   register int ix = (int) (op % OUTBUFSIZ);
  1118.  
  1119. #ifndef VAX       /* added by Francis Leung */
  1120.  
  1121.                   /* do a block memory copy if possible */
  1122.                   if ( ((ix    +Length) < OUTBUFSIZ) &&
  1123.                        ((outcnt+Length) < OUTBUFSIZ) ) {
  1124.                           memcpy(outptr,&outbuf[ix],Length);
  1125.                           outptr += Length;
  1126.                           outcnt += Length;
  1127.                   }
  1128.                   else
  1129.                   /* otherwise copy byte by byte */
  1130. #endif
  1131.                   while (Length--) {
  1132.                           OUTB(outbuf[ix]);
  1133.                           if (++ix >= OUTBUFSIZ)
  1134.                                   ix = 0;
  1135.                   }
  1136.          }
  1137.       } 
  1138.    } 
  1139. } 
  1140.  
  1141.  
  1142.  
  1143. /* ---------------------------------------------------------- */
  1144.  
  1145. void extract_member()
  1146. {
  1147.         word     b;
  1148.  
  1149.     bits_left = 0;
  1150.     bitbuf = 0;
  1151.     incnt = 0;
  1152.     outpos = 0L;
  1153.     outcnt = 0;
  1154.     outptr = outbuf;
  1155.     zipeof = 0;
  1156.     crc32val = 0xFFFFFFFFL;
  1157.  
  1158.  
  1159.     /* create the output file with READ and WRITE permissions */
  1160.     if (create_output_file())
  1161.         exit(1);
  1162.  
  1163.         switch (lrec.compression_method) {
  1164.  
  1165.     case 0:        /* stored */
  1166.         {
  1167.             printf(" Extracting: %-12s ", filename);
  1168.             while (ReadByte(&b))
  1169.                 OUTB(b);
  1170.         }
  1171.         break;
  1172.  
  1173.         case 1: {
  1174.             printf("UnShrinking: %-12s ", filename);
  1175.             unShrink();
  1176.         }
  1177.         break;
  1178.  
  1179.     case 2:
  1180.     case 3:
  1181.     case 4:
  1182.         case 5: {
  1183.             printf("  Expanding: %-12s ", filename);
  1184.             unReduce();
  1185.         }
  1186.         break;
  1187.  
  1188.         case 6: {
  1189.                         printf("  Exploding: %-12s ", filename);
  1190.                         unImplode();
  1191.         }
  1192.         break;
  1193.  
  1194.         default:
  1195.         printf("Unknown compression method.");
  1196.     }
  1197.  
  1198.  
  1199.     /* write the last partial buffer, if any */
  1200.     if (outcnt > 0) {
  1201.         UpdateCRC(outbuf, outcnt);
  1202.         write(outfd, outbuf, outcnt);
  1203.     }
  1204.  
  1205.     /* set output file date and time */
  1206.     set_file_time();
  1207.  
  1208.     close(outfd);
  1209.  
  1210.     crc32val = -1 - crc32val;
  1211.         if (crc32val != lrec.crc32)
  1212.                 printf(" Bad CRC %08lx  (should be %08lx)", lrec.crc32, crc32val);
  1213.  
  1214.     printf("\n");
  1215. }
  1216.  
  1217.  
  1218. /* ---------------------------------------------------------- */
  1219.  
  1220. void get_string(len, s)
  1221. int len;
  1222. char *s;
  1223. {
  1224.     read(zipfd, s, len);
  1225.     s[len] = 0;
  1226. }
  1227.  
  1228.  
  1229. /* ---------------------------------------------------------- */
  1230.  
  1231. void process_local_file_header()
  1232. {
  1233.     read(zipfd, &lrec, sizeof(lrec));
  1234.  
  1235. #ifdef HIGH_LOW
  1236.     swap_bytes(&lrec.filename_length);
  1237.     swap_bytes(&lrec.extra_field_length);
  1238.     swap_lbytes(&lrec.compressed_size);
  1239.     swap_lbytes(&lrec.uncompressed_size);
  1240.     swap_bytes(&lrec.compression_method);
  1241. #endif
  1242.  
  1243.     get_string(lrec.filename_length, filename);
  1244.     get_string(lrec.extra_field_length, extra);
  1245.     extract_member();
  1246. }
  1247.  
  1248.  
  1249. /* ---------------------------------------------------------- */
  1250.  
  1251. void process_central_file_header()
  1252. {
  1253.     central_directory_file_header rec;
  1254.     char filename[STRSIZ];
  1255.     char extra[STRSIZ];
  1256.     char comment[STRSIZ];
  1257.  
  1258.     read(zipfd, &rec, sizeof(rec));
  1259.  
  1260. #ifdef HIGH_LOW
  1261.     swap_bytes(&rec.filename_length);
  1262.     swap_bytes(&rec.extra_field_length);
  1263.     swap_bytes(&rec.file_comment_length);
  1264. #endif
  1265.  
  1266.         get_string(rec.filename_length, filename);
  1267.     get_string(rec.extra_field_length, extra);
  1268.     get_string(rec.file_comment_length, comment);
  1269. }
  1270.  
  1271.  
  1272. /* ---------------------------------------------------------- */
  1273.  
  1274. void process_end_central_dir()
  1275. {
  1276.     end_central_dir_record rec;
  1277.     char comment[STRSIZ];
  1278.  
  1279.     read(zipfd, &rec, sizeof(rec));
  1280.  
  1281. #ifdef HIGH_LOW
  1282.     swap_bytes(&rec.zipfile_comment_length);
  1283. #endif
  1284.  
  1285.     get_string(rec.zipfile_comment_length, comment);
  1286. }
  1287.  
  1288.  
  1289. /* ---------------------------------------------------------- */
  1290.  
  1291. void process_headers()
  1292. {
  1293.     longint sig;
  1294.  
  1295.     while (1) {
  1296.         if (read(zipfd, &sig, sizeof(sig)) != sizeof(sig))
  1297.             return;
  1298.  
  1299. #ifdef HIGH_LOW
  1300.         swap_lbytes(&sig);
  1301. #endif
  1302.  
  1303.                 if (sig == LOCAL_FILE_HEADER_SIGNATURE)
  1304.             process_local_file_header();
  1305.                 else if (sig == CENTRAL_FILE_HEADER_SIGNATURE)
  1306.             process_central_file_header();
  1307.                 else if (sig == END_CENTRAL_DIR_SIGNATURE) {
  1308.             process_end_central_dir();
  1309.             return;
  1310.         }
  1311.                 else {
  1312.             printf("Invalid Zipfile Header\n");
  1313.             return;
  1314.         }
  1315.     }
  1316.  
  1317. }
  1318.  
  1319.  
  1320. /* ---------------------------------------------------------- */
  1321.  
  1322. void extract_zipfile()
  1323. {
  1324.     /*
  1325.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  1326.      * translation, which would corrupt the bitstreams 
  1327.      */
  1328.  
  1329.     if (open_input_file())
  1330.         exit(1);
  1331.  
  1332.     process_headers();
  1333.  
  1334.     close(zipfd);
  1335. }
  1336.  
  1337.  
  1338. /* ---------------------------------------------------------- */
  1339. /*
  1340.  * main program
  1341.  *
  1342.  */
  1343.  
  1344. void main(argc, argv)
  1345. int argc;
  1346. char **argv;
  1347. {
  1348.     if (argc != 2) {
  1349.                 printf("\n%s\nCourtesy of:  S.H.Smith  and  The Tool Shop BBS,  (602) 279-2673.\n\n",VERSION);
  1350.  
  1351. #ifdef VAX
  1352.    printf("Modified by K.W.Chiu and Francis Leung to work on VAX.\n");
  1353.    printf("   Kw Chiu, Sysop of Chiu's Board (IFNA 700/138), Hong Kong.\n");
  1354.    printf("   ..!uunet!hkucs!hkucc!hcxcckw\n");
  1355.    printf("File date and time not restored. Please teach me how to do so.\n");
  1356. #endif
  1357.         printf("You may copy and distribute this program freely, provided that:\n");
  1358.         printf("    1)   No fee is charged for such copying and distribution, and\n");
  1359.         printf("    2)   It is distributed ONLY in its original, unmodified state.\n\n");
  1360.         printf("If you wish to distribute a modified version of this program, you MUST\n");
  1361.         printf("include the source code.\n\n");
  1362.         printf("If you modify this program, I would appreciate a copy of the  new source\n");
  1363.         printf("code.   I am holding the copyright on the source code, so please don't\n");
  1364.         printf("delete my name from the program files or from the documentation.\n\n");
  1365.                 printf("IN NO EVENT WILL I BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING ANY LOST\n");
  1366.                 printf("PROFITS, LOST SAVINGS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES\n");
  1367.                 printf("ARISING OUT OF YOUR USE OR INABILITY TO USE THE PROGRAM, OR FOR ANY\n");
  1368.                 printf("CLAIM BY ANY OTHER PARTY.\n\n");
  1369.                 printf("Usage:  UnZip FILE[.zip]\n");
  1370.                 exit(1);
  1371.     }
  1372.  
  1373.     /* .ZIP default if none provided by user */
  1374.     strcpy(zipfn, argv[1]);
  1375.     if (strchr(zipfn, '.') == NULL)
  1376.         strcat(zipfn, ".ZIP");
  1377.  
  1378.         /* allocate i/o buffers */
  1379.     inbuf = (byte *) (malloc(INBUFSIZ));
  1380.     outbuf = (byte *) (malloc(OUTBUFSIZ));
  1381.     if ((inbuf == NULL) || (outbuf == NULL)) {
  1382.         printf("Can't allocate buffers!\n");
  1383.         exit(1);
  1384.     }
  1385.  
  1386.         /* do the job... */
  1387.         extract_zipfile();
  1388.     exit();
  1389. }
  1390.