home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / COMPRESS / ARC520S.ZIP / ARCLZW.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-10-24  |  27.0 KB  |  788 lines
  1. /*  ARC - Archive utility - ARCLZW
  2.  
  3.     Version 2.03, created on 10/24/86 at 11:46:22
  4.  
  5. (C) COPYRIGHT 1985,86 by System Enhancement Associates; ALL RIGHTS RESERVED
  6.  
  7.     By:  Thom Henderson
  8.  
  9.     Description:
  10.          This file contains the routines used to implement Lempel-Zev
  11.          data compression, which calls for building a coding table on
  12.          the fly.  This form of compression is especially good for encoding
  13.          files which contain repeated strings, and can often give dramatic
  14.          improvements over traditional Huffman SQueezing.
  15.  
  16.     Language:
  17.          Computer Innovations Optimizing C86
  18.  
  19.     Programming notes:
  20.          In this section I am drawing heavily on the COMPRESS program
  21.          from UNIX.  The basic method is taken from "A Technique for High
  22.          Performance Data Compression", Terry A. Welch, IEEE Computer
  23.          Vol 17, No 6 (June 1984), pp 8-19.  Also see "Knuth's Fundamental
  24.          Algorithms", Donald Knuth, Vol 3, Section 6.4.
  25.  
  26.          As best as I can tell, this method works by tracing down a hash
  27.          table of code strings where each entry has the property:
  28.  
  29.               if <string> <char> is in the table
  30.               then <string> is in the table.
  31. */
  32. #include <stdio.h>
  33. #include "arc.h"
  34.  
  35. /* definitions for older style crunching */
  36.  
  37. #define FALSE    0
  38. #define TRUE     !FALSE
  39. #define TABSIZE  4096
  40. #define NO_PRED  0xFFFF
  41. #define EMPTY    0xFFFF
  42. #define NOT_FND  0xFFFF
  43.  
  44. static unsigned int inbuf;             /* partial input code storage */
  45. static int sp;                         /* current stack pointer */
  46.  
  47. static struct entry                    /* string table entry format */
  48. {   char used;                         /* true when this entry is in use */
  49.     unsigned int next;                 /* ptr to next in collision list */
  50.     unsigned int predecessor;          /* code for preceeding string */
  51.     unsigned char follower;            /* char following string */
  52. }   string_tab[TABSIZE];               /* the code string table */
  53.  
  54.  
  55. /* definitions for the new dynamic Lempel-Zev crunching */
  56.  
  57. #define BITS   12                      /* maximum bits per code */
  58. #define HSIZE  5003                    /* 80% occupancy */
  59. #define INIT_BITS 9                    /* initial number of bits/code */
  60.  
  61. static int n_bits;                     /* number of bits/code */
  62. static int maxcode;                    /* maximum code, given n_bits */
  63. #define MAXCODE(n)      ((1<<(n)) - 1) /* maximum code calculation */
  64. static int maxcodemax =  1 << BITS;    /* largest possible code (+1) */
  65.  
  66. static char buf[BITS];                 /* input/output buffer */
  67.  
  68. static unsigned char lmask[9] =        /* left side masks */
  69. {   0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };
  70. static unsigned char rmask[9] =        /* right side masks */
  71. {   0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
  72.  
  73. static int offset;                     /* byte offset for code output */
  74. static long in_count;                  /* length of input */
  75. static long bytes_out;                 /* length of compressed output */
  76. static long bytes_ref;                 /* output quality reference */
  77. static long bytes_last;                /* output size at last checkpoint */
  78. static unsigned int ent;
  79.  
  80. /* To save much memory (which we badly need at this point), we overlay
  81.  * the table used by the previous version of Lempel-Zev with those used
  82.  * by the new version.  Since no two of these routines will be used
  83.  * together, we can safely do this.
  84.  */
  85.  
  86. static long *htab = string_tab;        /* hash code table   (crunch) */
  87. static unsigned int codetab[HSIZE];    /* string code table (crunch) */
  88.  
  89. static unsigned int *prefix = codetab; /* prefix code table (uncrunch) */
  90. static unsigned char *suffix = string_tab;  /* suffix table (uncrunch) */
  91.  
  92. static int free_ent;                   /* first unused entry */
  93. static int firstcmp;                   /* true at start of compression */
  94. static unsigned char stack[HSIZE];     /* local push/pop stack */
  95.  
  96. /*
  97.  * block compression parameters -- after all codes are used up,
  98.  * and compression rate changes, start over.
  99.  */
  100.  
  101. static int clear_flg;
  102. #define CHECK_GAP 2048                 /* ratio check interval */
  103. static long checkpoint;
  104.  
  105. /*
  106.  * the next two codes should not be changed lightly, as they must not
  107.  * lie within the contiguous general code space.
  108.  */
  109. #define FIRST   257                    /* first free entry */
  110. #define CLEAR   256                    /* table clear output code */
  111.  
  112. /* The cl_block() routine is called at each checkpoint to determine if
  113.  * compression would likely improve by resetting the code table.  The
  114.  * method chosen to determine this is based on empirical observation that,
  115.  * in general, every 2k of input data should compress at least as well
  116.  * as the first 2k of input.
  117.  */
  118.  
  119. static cl_block(t)                     /* table clear for block compress */
  120. FILE *t;                               /* our output file */
  121. {
  122.     checkpoint = in_count + CHECK_GAP;
  123.  
  124.     if(bytes_ref)
  125.     {    if(bytes_out-bytes_last > bytes_ref)
  126.          {    setmem(htab,HSIZE*sizeof(long),0xff);
  127.               free_ent = FIRST;
  128.               clear_flg = 1;
  129.               putcode(CLEAR,t);
  130.               bytes_ref = 0;
  131.          }
  132.     }
  133.     else bytes_ref = bytes_out - bytes_last;
  134.  
  135.     bytes_last = bytes_out;            /* remember where we were */
  136. }
  137.  
  138. /*****************************************************************
  139.  *
  140.  * Output a given code.
  141.  * Inputs:
  142.  *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
  143.  *              that n_bits =< (long)wordsize - 1.
  144.  * Outputs:
  145.  *      Outputs code to the file.
  146.  * Assumptions:
  147.  *      Chars are 8 bits long.
  148.  * Algorithm:
  149.  *      Maintain a BITS character long buffer (so that 8 codes will
  150.  * fit in it exactly).  When the buffer fills up empty it and start over.
  151.  */
  152.  
  153. static putcode(code,t)                 /* output a code */
  154. int code;                              /* code to output */
  155. FILE *t;                               /* where to put it */
  156. {
  157.     int r_off = offset;                /* right offset */
  158.     int bits = n_bits;                 /* bits to go */
  159.     char *bp = buf;                    /* buffer pointer */
  160.     int n;                             /* index */
  161.  
  162.     if(code >= 0)                      /* if a real code */
  163.     {    /*
  164.           * Get to the first byte.
  165.           */
  166.          bp += (r_off >> 3);
  167.          r_off &= 7;
  168.  
  169.          /*
  170.           * Since code is always >= 8 bits, only need to mask the first
  171.           * hunk on the left.
  172.           */
  173.          *bp = (*bp&rmask[r_off]) | (code<<r_off) & lmask[r_off];
  174.          bp++;
  175.          bits -= (8 - r_off);
  176.          code >>= (8 - r_off);
  177.  
  178.          /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
  179.          if(bits >= 8)
  180.          {    *bp++ = code;
  181.               code >>= 8;
  182.               bits -= 8;
  183.          }
  184.  
  185.          /* Last bits. */
  186.          if(bits)
  187.               *bp = code;
  188.  
  189.          offset += n_bits;
  190.  
  191.          if(offset == (n_bits << 3))
  192.          {    bp = buf;
  193.               bits = n_bits;
  194.               bytes_out += bits;
  195.               do
  196.                    putc_pak(*bp++,t);
  197.               while(--bits);
  198.               offset = 0;
  199.          }
  200.  
  201.          /*
  202.           * If the next entry is going to be too big for the code size,
  203.           * then increase it, if possible.
  204.           */
  205.          if(free_ent>maxcode || clear_flg>0)
  206.          {    /*
  207.                * Write the whole buffer, because the input side won't
  208.                * discover the size increase until after it has read it.
  209.                */
  210.               if(offset > 0)
  211.               {    bp = buf;           /* reset pointer for writing */
  212.                    bytes_out += n = n_bits;
  213.                    while(n--)
  214.                         putc_pak(*bp++,t);
  215.               }
  216.               offset = 0;
  217.  
  218.               if(clear_flg)            /* reset if clearing */
  219.               {    maxcode = MAXCODE(n_bits = INIT_BITS);
  220.                    clear_flg = 0;
  221.               }
  222.               else                     /* else use more bits */
  223.               {    n_bits++;
  224.                    if(n_bits == BITS)
  225.                         maxcode = maxcodemax;
  226.                    else
  227.                         maxcode = MAXCODE(n_bits);
  228.               }
  229.          }
  230.     }
  231.  
  232.     else                               /* dump the buffer on EOF */
  233.     {    bytes_out += n = (offset+7) / 8;
  234.  
  235.          if(offset > 0)
  236.               while(n--)
  237.                    putc_pak(*bp++,t);
  238.          offset = 0;
  239.     }
  240. }
  241.  
  242. /*****************************************************************
  243.  *
  244.  * Read one code from the standard input.  If EOF, return -1.
  245.  * Inputs:
  246.  *      cmpin
  247.  * Outputs:
  248.  *      code or -1 is returned.
  249.  */
  250.  
  251. static int getcode(f)                  /* get a code */
  252. FILE *f;                               /* file to get from */
  253. {
  254.     int code;
  255.     static int offset = 0, size = 0;
  256.     int r_off, bits;
  257.     unsigned char *bp = buf;
  258.  
  259.     if(clear_flg > 0 || offset >= size || free_ent > maxcode)
  260.     {    /*
  261.           * If the next entry will be too big for the current code
  262.           * size, then we must increase the size.  This implies reading
  263.           * a new buffer full, too.
  264.           */
  265.          if(free_ent > maxcode)
  266.          {    n_bits++;
  267.               if(n_bits == BITS)
  268.                    maxcode = maxcodemax;    /* won't get any bigger now */
  269.               else maxcode = MAXCODE(n_bits);
  270.          }
  271.          if(clear_flg > 0)
  272.          {    maxcode = MAXCODE(n_bits = INIT_BITS);
  273.               clear_flg = 0;
  274.          }
  275.  
  276.          for(size=0; size<n_bits; size++)
  277.          {    if((code=getc_unp(f))==EOF)
  278.                    break;
  279.               else buf[size] = code;
  280.          }
  281.          if(size <= 0)
  282.               return -1;               /* end of file */
  283.  
  284.          offset = 0;
  285.          /* Round size down to integral number of codes */
  286.          size = (size << 3)-(n_bits - 1);
  287.     }
  288.     r_off = offset;
  289.     bits = n_bits;
  290.  
  291.     /*
  292.      * Get to the first byte.
  293.      */
  294.     bp +=(r_off >> 3);
  295.     r_off &= 7;
  296.  
  297.     /* Get first part (low order bits) */
  298.     code = (*bp++ >> r_off);
  299.     bits -= 8 - r_off;
  300.     r_off = 8 - r_off;                 /* now, offset into code word */
  301.  
  302.     /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
  303.     if(bits >= 8)
  304.     {    code |= *bp++ << r_off;
  305.          r_off += 8;
  306.          bits -= 8;
  307.     }
  308.     /* high order bits. */
  309.     code |= (*bp & rmask[bits]) << r_off;
  310.     offset += n_bits;
  311.  
  312.     return code & MAXCODE(BITS);
  313. }
  314.  
  315. /*
  316.  * compress a file
  317.  *
  318.  * Algorithm:  use open addressing double hashing (no chaining) on the
  319.  * prefix code / next character combination.  We do a variant of Knuth's
  320.  * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  321.  * secondary probe.  Here, the modular division first probe is gives way
  322.  * to a faster exclusive-or manipulation.  Also do block compression with
  323.  * an adaptive reset, where the code table is cleared when the compression
  324.  * ratio decreases, but after the table fills.  The variable-length output
  325.  * codes are re-sized at this point, and a special CLEAR code is generated
  326.  * for the decompressor.
  327.  */
  328.  
  329. init_cm(f,t)                           /* initialize for compression */
  330. FILE *f;                               /* file we will be compressing */
  331. FILE *t;                               /* where we will put it */
  332. {
  333.     offset = 0;
  334.     bytes_out = bytes_last = 1;
  335.     bytes_ref = 0;
  336.     clear_flg = 0;
  337.     in_count = 1;
  338.     checkpoint = CHECK_GAP;
  339.     maxcode = MAXCODE(n_bits = INIT_BITS);
  340.     free_ent = FIRST;
  341.     setmem(htab,HSIZE*sizeof(long),0xff);
  342.     n_bits = INIT_BITS;                /* set starting code size */
  343.  
  344.     putc_pak(BITS,t);                  /* note our max code length */
  345.  
  346.     firstcmp = 1;                      /* next byte will be first */
  347. }
  348.  
  349. putc_cm(c,t)                           /* compress a character */
  350. unsigned char c;                       /* character to compress */
  351. FILE *t;                               /* where to put it */
  352. {
  353.     static long fcode;
  354.     static int hshift;
  355.     int i;
  356.     int disp;
  357.  
  358.     if(firstcmp)                       /* special case for first byte */
  359.     {    ent = c;                      /* remember first byte */
  360.  
  361.          hshift = 0;
  362.          for(fcode=(long)HSIZE;  fcode<65536L; fcode*=2L)
  363.               hshift++;
  364.          hshift = 8 - hshift;          /* set hash code range bound */
  365.  
  366.          firstcmp = 0;                 /* no longer first */
  367.          return;
  368.     }
  369.  
  370.     in_count++;
  371.  
  372.     fcode =(long)(((long)c << BITS)+ent);
  373.     i = (c<<hshift)^ent;               /* xor hashing */
  374.  
  375.     if(htab[i]==fcode)
  376.     {    ent = codetab[i];
  377.          return;
  378.     }
  379.     else if(htab[i]<0)                 /* empty slot */
  380.          goto nomatch;
  381.     disp = HSIZE - i;                  /* secondary hash (after G.Knott) */
  382.     if(i == 0)
  383.          disp = 1;
  384.  
  385. probe:
  386.     if((i -= disp) < 0)
  387.          i += HSIZE;
  388.  
  389.     if(htab[i] == fcode)
  390.     {    ent = codetab[i];
  391.          return;
  392.     }
  393.     if(htab[i] > 0)
  394.          goto probe;
  395.  
  396. nomatch:
  397.     putcode(ent,t);
  398.     ent = c;
  399.     if(free_ent < maxcodemax)
  400.     {    codetab[i] = free_ent++;      /* code -> hashtable */
  401.          htab[i] = fcode;
  402.     }
  403.  
  404.     if(in_count >= checkpoint)
  405.          cl_block(t);                  /* check for adaptive reset */
  406. }
  407.  
  408. long pred_cm(t)                        /* finish compressing a file */
  409. FILE *t;                               /* where to put it */
  410. {
  411.     putcode(ent,t);                    /* put out the final code */
  412.     putcode(-1,t);                     /* tell output we are done */
  413.  
  414.     return bytes_out;                  /* say how big it got */
  415. }
  416.  
  417. /*
  418.  * Decompress a file.  This routine adapts to the codes in the file
  419.  * building the string table on-the-fly; requiring no table to be stored
  420.  * in the compressed file.  The tables used herein are shared with those of
  421.  * the compress() routine.  See the definitions above.
  422.  */
  423.  
  424. decomp(f,t)                            /* decompress a file */
  425. FILE *f;                               /* file to read codes from */
  426. FILE *t;                               /* file to write text to */
  427. {
  428.     unsigned char *stackp;
  429.     int finchar;
  430.     int code, oldcode, incode;
  431.  
  432.     if((code=getc_unp(f))!=BITS)
  433.          abort("File packed with %d bits, I can only handle %d",code,BITS);
  434.  
  435.     n_bits = INIT_BITS;                /* set starting code size */
  436.     clear_flg = 0;
  437.  
  438.     /*
  439.      * As above, initialize the first 256 entries in the table.
  440.      */
  441.     maxcode = MAXCODE(n_bits=INIT_BITS);
  442.     setmem(prefix,256*sizeof(int),0);  /* reset decode string table */
  443.     for(code = 255; code >= 0; code--)
  444.          suffix[code] = (unsigned char)code;
  445.  
  446.     free_ent = FIRST;
  447.  
  448.     finchar = oldcode = getcode(f);
  449.     if(oldcode == -1)                  /* EOF already? */
  450.          return;                       /* Get out of here */
  451.     putc_ncr((char)finchar,t);         /* first code must be 8 bits=char */
  452.     stackp = stack;
  453.  
  454.     while((code = getcode(f))> -1)
  455.     {    if(code==CLEAR)               /* reset string table */
  456.          {    setmem(prefix,256*sizeof(int),0);
  457.               clear_flg = 1;
  458.               free_ent = FIRST - 1;
  459.               if((code=getcode(f))==-1)/* O, untimely death! */
  460.                    break;
  461.          }
  462.          incode = code;
  463.          /*
  464.           * Special case for KwKwK string.
  465.           */
  466.          if(code >= free_ent)
  467.          {    *stackp++ = finchar;
  468.               code = oldcode;
  469.          }
  470.  
  471.          /*
  472.           * Generate output characters in reverse order
  473.           */
  474.          while(code >= 256)
  475.          {    *stackp++ = suffix[code];
  476.               code = prefix[code];
  477.          }
  478.          *stackp++ = finchar = suffix[code];
  479.  
  480.          /*
  481.           * And put them out in forward order
  482.           */
  483.          do
  484.               putc_ncr(*--stackp,t);
  485.          while(stackp > stack);
  486.  
  487.          /*
  488.           * Generate the new entry.
  489.           */
  490.          if((code=free_ent) < maxcodemax)
  491.          {    prefix[code] = (unsigned short)oldcode;
  492.               suffix[code] = finchar;
  493.               free_ent = code+1;
  494.          }
  495.          /*
  496.           * Remember previous code.
  497.           */
  498.          oldcode = incode;
  499.     }
  500. }
  501.  
  502.  
  503. /*************************************************************************
  504.  * Please note how much trouble it can be to maintain upwards            *
  505.  * compatibility.  All that follows is for the sole purpose of unpacking *
  506.  * files which were packed using an older method.                        *
  507.  *************************************************************************/
  508.  
  509.  
  510. /*  The h() pointer points to the routine to use for calculating a hash
  511.     value.  It is set in the init routines to point to either of oldh()
  512.     or newh().
  513.  
  514.     oldh() calculates a hash value by taking the middle twelve bits
  515.     of the square of the key.
  516.  
  517.     newh() works somewhat differently, and was tried because it makes
  518.     ARC about 23% faster.  This approach was abandoned because dynamic
  519.     Lempel-Zev (above) works as well, and packs smaller also.  However,
  520.     inadvertent release of a developmental copy forces us to leave this in.
  521. */
  522.  
  523. static unsigned (*h)();                /* pointer to hash function */
  524.  
  525. static unsigned oldh(pred,foll)        /* old hash function */
  526. unsigned int pred;                     /* code for preceeding string */
  527. unsigned char foll;                    /* value of following char */
  528. {
  529.     long local;                        /* local hash value */
  530.  
  531.     local = (pred + foll) | 0x0800;    /* create the hash key */
  532.     local *= local;                    /* square it */
  533.     return (local >> 6) & 0x0FFF;      /* return the middle 12 bits */
  534. }
  535.  
  536. static unsigned newh(pred,foll)        /* new hash function */
  537. unsigned int pred;                     /* code for preceeding string */
  538. unsigned char foll;                    /* value of following char */
  539. {
  540.     return ((pred+foll)*15073)&0xFFF;  /* faster hash */
  541. }
  542.  
  543. /*  The eolist() function is used to trace down a list of entries with
  544.     duplicate keys until the last duplicate is found.
  545. */
  546.  
  547. static unsigned eolist(index)          /* find last duplicate */
  548. unsigned int index;
  549. {
  550.     int temp;
  551.  
  552.     while(temp=string_tab[index].next) /* while more duplicates */
  553.          index = temp;
  554.  
  555.     return index;
  556. }
  557.  
  558. /*  The hash() routine is used to find a spot in the hash table for a new
  559.     entry.  It performs a "hash and linear probe" lookup, using h() to
  560.     calculate the starting hash value and eolist() to perform the linear
  561.     probe.  This routine DOES NOT detect a table full condition.  That
  562.     MUST be checked for elsewhere.
  563. */
  564.  
  565. static unsigned hash(pred,foll)        /* find spot in the string table */
  566. unsigned int pred;                     /* code for preceeding string */
  567. unsigned char foll;                    /* char following string */
  568. {
  569.     unsigned int local, tempnext;      /* scratch storage */
  570.     struct entry *ep;                  /* allows faster table handling */
  571.  
  572.     local = (*h)(pred,foll);           /* get initial hash value */
  573.  
  574.     if(!string_tab[local].used)        /* if that spot is free */
  575.          return local;                 /* then that's all we need */
  576.  
  577.     else                               /* else a collision has occured */
  578.     {    local = eolist(local);        /* move to last duplicate */
  579.  
  580.          /*   We must find an empty spot. We start looking 101 places
  581.               down the table from the last duplicate.
  582.          */
  583.  
  584.          tempnext = (local+101) & 0x0FFF;
  585.          ep = &string_tab[tempnext];   /* initialize pointer */
  586.  
  587.          while(ep->used)               /* while empty spot not found */
  588.          {    if(++tempnext==TABSIZE)  /* if we are at the end */
  589.               {    tempnext = 0;       /* wrap to beginning of table*/
  590.                    ep = string_tab;
  591.               }
  592.               else ++ep;               /* point to next element in table */
  593.          }
  594.  
  595.          /*   local still has the pointer to the last duplicate, while
  596.               tempnext has the pointer to the spot we found.  We use
  597.               this to maintain the chain of pointers to duplicates.
  598.          */
  599.  
  600.          string_tab[local].next = tempnext;
  601.  
  602.          return tempnext;
  603.     }
  604. }
  605.  
  606. /*  The unhash() function is used to search the hash table for a given key.
  607.     Like hash(), it performs a hash and linear probe search.  It returns
  608.     either the number of the entry (if found) or NOT_FND (if not found).
  609. */
  610.  
  611. static unsigned unhash(pred,foll)      /* search string table for a key */
  612. unsigned int pred;                     /* code of preceeding string */
  613. unsigned char foll;                    /* character following string */
  614. {
  615.     unsigned int local, offset;        /* scratch storage */
  616.     struct entry *ep;                  /* this speeds up access */
  617.  
  618.     local = (*h)(pred,foll);           /* initial hash */
  619.  
  620.     while(1)
  621.     {    ep = &string_tab[local];      /* speed up table access */
  622.  
  623.          if((ep->predecessor==pred) && (ep->follower==foll))
  624.               return local;            /* we have a match */
  625.  
  626.          if(!ep->next)                 /* if no more duplicates */
  627.               return NOT_FND;          /* then key is not listed */
  628.  
  629.          local = ep->next;             /* move on to next duplicate */
  630.     }
  631. }
  632.  
  633. /*  The init_tab() routine is used to initialize our hash table.
  634.     You realize, of course, that "initialize" is a complete misnomer.
  635. */
  636.  
  637. static init_tab()                      /* set ground state in hash table */
  638. {
  639.     unsigned int i;                    /* table index */
  640.  
  641.     setmem((char *)string_tab,sizeof(string_tab),0);
  642.  
  643.     for(i=0; i<256; i++)               /* list all single byte strings */
  644.          upd_tab(NO_PRED,i);
  645.  
  646.     inbuf = EMPTY;                     /* nothing is in our buffer */
  647. }
  648.  
  649. /*  The upd_tab routine is used to add a new entry to the string table.
  650.     As previously stated, no checks are made to ensure that the table
  651.     has any room.  This must be done elsewhere.
  652. */
  653.  
  654. upd_tab(pred,foll)                     /* add an entry to the table */
  655. unsigned int pred;                     /* code for preceeding string */
  656. unsigned int foll;                     /* character which follows string */
  657. {
  658.     struct entry *ep;                  /* pointer to current entry */
  659.  
  660.     /* calculate offset just once */
  661.  
  662.     ep = &string_tab[hash(pred,foll)];
  663.  
  664.     ep->used = TRUE;                   /* this spot is now in use */
  665.     ep->next = 0;                      /* no duplicates after this yet */
  666.     ep->predecessor = pred;            /* note code of preceeding string */
  667.     ep->follower = foll;               /* note char after string */
  668. }
  669.  
  670. /*  This algorithm encoded a file into twelve bit strings (three nybbles).
  671.     The gocode() routine is used to read these strings a byte (or two)
  672.     at a time.
  673. */
  674.  
  675. static gocode(fd)                      /* read in a twelve bit code */
  676. FILE *fd;                              /* file to get code from */
  677. {
  678.     unsigned int localbuf, returnval;
  679.  
  680.     if(inbuf==EMPTY)                   /* if on a code boundary */
  681.     {    if((localbuf=getc_unp(fd))==EOF)   /* get start of next code */
  682.               return EOF;              /* pass back end of file status */
  683.          localbuf &= 0xFF;             /* mask down to true byte value */
  684.          if((inbuf=getc_unp(fd))==EOF) /* get end of code, start of next */
  685.               return EOF;              /* this should never happen */
  686.          inbuf &= 0xFF;                /* mask down to true byte value */
  687.  
  688.          returnval = ((localbuf<<4)&0xFF0) + ((inbuf>>4)&0x00F);
  689.          inbuf &= 0x000F;              /* leave partial code pending */
  690.     }
  691.  
  692.     else                               /* buffer contains first nybble */
  693.     {    if((localbuf=getc_unp(fd))==EOF)
  694.               return EOF;
  695.          localbuf &= 0xFF;
  696.  
  697.          returnval = localbuf + ((inbuf<<8)&0xF00);
  698.          inbuf = EMPTY;                /* note no hanging nybbles */
  699.     }
  700.     return returnval;                  /* pass back assembled code */
  701. }
  702.  
  703. static push(c)                         /* push char onto stack */
  704. int c;                                 /* character to push */
  705. {
  706.     stack[sp] = ((char) c);            /* coerce integer into a char */
  707.  
  708.     if(++sp >= TABSIZE)
  709.          abort("Stack overflow\n");
  710. }
  711.  
  712. static int pop()                       /* pop character from stack */
  713. {
  714.     if(sp>0)
  715.          return ((int) stack[--sp]);   /* leave ptr at next empty slot */
  716.  
  717.     else return EMPTY;
  718. }
  719.  
  720. /***** LEMPEL-ZEV DECOMPRESSION *****/
  721.  
  722. static int code_count;                 /* needed to detect table full */
  723. static unsigned code;                  /* where we are so far */
  724. static int firstc;                     /* true only on first character */
  725.  
  726. init_ucr(new)                          /* get set for uncrunching */
  727. int new;                               /* true to use new hash function */
  728. {
  729.     if(new)                            /* set proper hash function */
  730.          h = newh;
  731.     else h = oldh;
  732.  
  733.     sp = 0;                            /* clear out the stack */
  734.     init_tab();                        /* set up atomic code definitions */
  735.     code_count = TABSIZE - 256;        /* note space left in table */
  736.     firstc = 1;                        /* true only on first code */
  737. }
  738.  
  739. int getc_ucr(f)                        /* get next uncrunched byte */
  740. FILE *f;                               /* file containing crunched data */
  741. {
  742.     unsigned int c;                    /* a character of input */
  743.     int code, newcode;
  744.     static int oldcode, finchar;
  745.     struct entry *ep;                  /* allows faster table handling */
  746.  
  747.     if(firstc)                         /* first code is always known */
  748.     {    firstc = FALSE;               /* but next will not be first */
  749.          oldcode = gocode(f);
  750.          return finchar = string_tab[oldcode].follower;
  751.     }
  752.  
  753.     if(!sp)                            /* if stack is empty */
  754.     {    if((code=newcode=gocode(f))==EOF)
  755.               return EOF;
  756.  
  757.          ep = &string_tab[code];       /* initialize pointer */
  758.  
  759.          if(!ep->used)                 /* if code isn't known */
  760.          {    code = oldcode;
  761.               ep = &string_tab[code];  /* re-initialize pointer */
  762.               push(finchar);
  763.          }
  764.  
  765.          while(ep->predecessor!=NO_PRED)
  766.          {    push(ep->follower);      /* decode string backwards */
  767.               code = ep->predecessor;
  768.               ep = &string_tab[code];
  769.          }
  770.  
  771.          push(finchar=ep->follower);   /* save first character also */
  772.  
  773.          /*   The above loop will terminate, one way or another,
  774.               with string_tab[code].follower equal to the first
  775.               character in the string.
  776.          */
  777.  
  778.          if(code_count)                /* if room left in string table */
  779.          {    upd_tab(oldcode,finchar);
  780.               --code_count;
  781.          }
  782.  
  783.          oldcode = newcode;
  784.     }
  785.  
  786.     return pop();                      /* return saved character */
  787. }
  788.