home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume26 / freeze / patch01 < prev    next >
Encoding:
Text File  |  1991-11-24  |  56.3 KB  |  2,369 lines
  1. Newsgroups: comp.sources.misc
  2. From: leo@s514.ipmce.su (Leonid A. Broukhis)
  3. Subject:  REPOST: v26i053:  freeze - Freeze/melt compression program, Patch01
  4. Message-ID: <1991Nov24.205630.23773@sparky.imd.sterling.com>
  5. X-Md4-Signature: 27fe93a79067bfa88e2d3c88febb5514
  6. Date: Sun, 24 Nov 1991 20:56:30 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: leo@s514.ipmce.su (Leonid A. Broukhis)
  10. Posting-number: Volume 26, Issue 53
  11. Archive-name: freeze/patch01
  12. Environment: ISC, Xenix, SunOS, MS-DOS
  13. Patch-To: freeze: Volume 25, Issue 12-13
  14.  
  15. [ This is being reposted to correct invalid headers.  This is a   
  16. [ patch and not a complete repost. It was posted as a "Part".
  17. [ -Kent+ 
  18.  
  19. Here is a quite big patch:
  20.  
  21.  - I decided to not deal with u_short, ushort, u_char and uchar
  22.    and I've defined us_t, uc_t and ul_t;
  23.  - A little bug with utime corrected (usecs are now handled -
  24.     by pa@verano.sba.ca.us);
  25.  - Statist's man page added;
  26.  - Hash table size reduced;
  27.  - A speedup a la ZIP ("chain threshold" by the kind permission
  28.     of J.-L. Gailly);
  29.  - Typos fixed ("<" au lieu of "<="), etc.
  30.  - Improved compression rate.
  31.  
  32. diff -cr ../orig/README ./README
  33. *** ../orig/README    Sun Nov 24 00:09:17 1991
  34. --- ./README    Sun Nov 24 00:22:15 1991
  35. ***************
  36. *** 25,34 ****
  37.                   to be inline. This gives additional
  38.                   percents of speedup.
  39.       o __TURBOC__            For compiling under TURBO C
  40. - 
  41.       o __i386__              When compiling under GNU C causes
  42.                   some fixed register allocations,
  43.                   which give better code.
  44.   
  45.   Please! If your computer supports the string operations, try to write
  46.   "asm" instructions (GNU style) which realize the right-to-left memory
  47. --- 25,36 ----
  48.                   to be inline. This gives additional
  49.                   percents of speedup.
  50.       o __TURBOC__            For compiling under TURBO C
  51.       o __i386__              When compiling under GNU C causes
  52.                   some fixed register allocations,
  53.                   which give better code.
  54. +     o BIN_DEFAULT           (For MS-DOS only!) Define, if you
  55. +                 forget to use -i option when freezing
  56. +                 binary files.
  57.   
  58.   Please! If your computer supports the string operations, try to write
  59.   "asm" instructions (GNU style) which realize the right-to-left memory
  60. ***************
  61. *** 109,118 ****
  62.   Note: If you use "gensample | statist", remember that INTR influence BOTH
  63.   processes !!
  64.   
  65. - Sometimes `statist' can output the string "not enough information".
  66. - This means it cannot build the appropriate static Huffman table
  67. - (the given file is too trivial or random).
  68. - 
  69.   You may create the /etc/default/freeze file (if you don't like
  70.   /etc/default/ directory, choose another - in MS-DOS it is FREEZE.CNF in
  71.   the directory of FREEZE.EXE), which has the following format:  name =
  72. --- 111,116 ----
  73. ***************
  74. *** 120,126 ****
  75.   
  76.   ---------- cut here -----------
  77.   # This is freeze's defaults file
  78. ! gif =   0 0 0 0 2 60 0 0        # This is NOT! an optimal data
  79.                   # for GIF files
  80.   doc=0 0 1 2 7 16 36 0           # The sample was gcc.lp
  81.   # End of file
  82. --- 118,124 ----
  83.   
  84.   ---------- cut here -----------
  85.   # This is freeze's defaults file
  86. ! gif =   0 0 0 0 2 60 0 0        # This is NOT! optimal data
  87.                   # for GIF files
  88.   doc=0 0 1 2 7 16 36 0           # The sample was gcc.lp
  89.   # End of file
  90. ***************
  91. *** 182,184 ****
  92. --- 180,208 ----
  93.   
  94.   (I tried to implement splay trees instead of Huffman ones and instead of
  95.   static table for position information, but this gives nothing, alas.)
  96. + 
  97. + --------- CALGARY COMPRESSION CORPUS RESULTS --------
  98. + 
  99. + total 2308
  100. +    41515 May  9  1990 bib.F
  101. +   344793 May  9  1990 book1.F
  102. +   230861 May  9  1990 book2.F
  103. +    68626 May  9  1990 geo.F
  104. +   155783 May  9  1990 news.F
  105. +    10453 May  9  1990 obj1.F
  106. +    85500 May  9  1990 obj2.F
  107. +    20021 May  9  1990 paper1.F
  108. +    32693 May  9  1990 paper2.F
  109. +    19430 May  9  1990 paper3.F
  110. +     5771 May  9  1990 paper4.F
  111. +     5170 May  9  1990 paper5.F
  112. +    14091 May  9  1990 paper6.F
  113. +    53291 May  9  1990 pic.F
  114. +    14143 May  9  1990 progc.F
  115. +    17064 May  9  1990 progl.F
  116. +    11686 May  9  1990 progp.F
  117. +    22861 May  9  1990 trans.F
  118. + 
  119. + Average bits/byte on the standard set (except paper3-6) =
  120. +     1109290 * 8 / 3141622 = 2.825
  121. +     (With the "-g" flag = 2.892)
  122. diff -cr ../orig/bitio.c ./bitio.c
  123. *** ../orig/bitio.c    Sun Nov 24 00:09:20 1991
  124. --- ./bitio.c    Sun Nov 24 00:22:15 1991
  125. ***************
  126. *** 1,19 ****
  127.   #include "freeze.h"
  128.   #include "bitio.h"
  129.   
  130. ! unsigned long getbuf = 0;       /* assume sizeof (unsigned long) >= 4 */
  131. ! u_short putbuf;
  132. ! uchar   bitlen = 0, __, crpt_flag = 0;
  133.   
  134.   /* get N bits (N <= 16), returning in Bit(N-1)...Bit 0 */
  135.   
  136.   short GetNBits (n)
  137. !     register u_short n;
  138.   {
  139. !     register unsigned long dx = getbuf;
  140. !     register uchar c;
  141.   
  142. !     static u_short mask[17] = {
  143.           0x0000,
  144.           0x0001, 0x0003, 0x0007, 0x000f,
  145.           0x001f, 0x003f, 0x007f, 0x00ff,
  146. --- 1,19 ----
  147.   #include "freeze.h"
  148.   #include "bitio.h"
  149.   
  150. ! ul_t     getbuf = 0;     /* assume sizeof (ul_t) >= 4 */
  151. ! us_t     putbuf;
  152. ! uc_t     bitlen = 0, __, crpt_flag = 0;
  153.   
  154.   /* get N bits (N <= 16), returning in Bit(N-1)...Bit 0 */
  155.   
  156.   short GetNBits (n)
  157. !     register us_t n;
  158.   {
  159. !     register ul_t dx = getbuf;
  160. !     register uc_t c;
  161.   
  162. !     static us_t mask[17] = {
  163.           0x0000,
  164.           0x0001, 0x0003, 0x0007, 0x000f,
  165.           0x001f, 0x003f, 0x007f, 0x00ff,
  166. ***************
  167. *** 23,29 ****
  168.       while (bitlen < n)
  169.           {
  170.               c = getchar ();
  171. !             dx |= (unsigned long) c << (BYSH - bitlen);
  172.               bitlen += 8;
  173.           }
  174.       crpt_flag = feof(stdin);
  175. --- 23,29 ----
  176.       while (bitlen < n)
  177.           {
  178.               c = getchar ();
  179. !             dx |= (ul_t) c << (BYSH - bitlen);
  180.               bitlen += 8;
  181.           }
  182.       crpt_flag = feof(stdin);
  183. ***************
  184. *** 35,45 ****
  185.   /* output `l' high bits of `c' */
  186.   
  187.   void Putcode (l, c)
  188. !     register u_short l;
  189. !     u_short c;
  190.   {
  191. !     register u_short len = bitlen;
  192. !     register u_short b = (u_short)putbuf;
  193.       b |= c >> len;
  194.       if ((len += l) >= 8) {
  195.           putchar ((int)(b >> 8));
  196. --- 35,45 ----
  197.   /* output `l' high bits of `c' */
  198.   
  199.   void Putcode (l, c)
  200. !     register us_t l;
  201. !     us_t c;
  202.   {
  203. !     register us_t len = bitlen;
  204. !     register us_t b = (us_t)putbuf;
  205.       b |= c >> len;
  206.       if ((len += l) >= 8) {
  207.           putchar ((int)(b >> 8));
  208. diff -cr ../orig/bitio.h ./bitio.h
  209. *** ../orig/bitio.h    Sun Nov 24 00:09:17 1991
  210. --- ./bitio.h    Sun Nov 24 00:22:15 1991
  211. ***************
  212. *** 1,11 ****
  213.   /* Some definitions for faster bit-level I/O */
  214.   
  215. ! extern unsigned long getbuf;    /* Bit I/O buffers */
  216. ! extern u_short putbuf;
  217. ! extern uchar bitlen;            /* Number of bits actually in `???buf' */
  218.   
  219. ! extern uchar crpt_flag; /* 1 == EOF was read when melting */
  220. ! extern  uchar   __;     /* temporary variable for GetBit/Byte */
  221.   
  222.   extern void EncodeEnd(), Putcode(), crpt_message();
  223.   
  224. --- 1,11 ----
  225.   /* Some definitions for faster bit-level I/O */
  226.   
  227. ! extern ul_t getbuf;    /* Bit I/O buffers */
  228. ! extern us_t putbuf;
  229. ! extern uc_t bitlen;            /* Number of bits actually in `???buf' */
  230.   
  231. ! extern uc_t crpt_flag;   /* 1 == EOF was read when melting */
  232. ! extern uc_t __;          /* temporary variable for GetBit/Byte */
  233.   
  234.   extern void EncodeEnd(), Putcode(), crpt_message();
  235.   
  236. ***************
  237. *** 14,20 ****
  238.   #define BISH  (bits(getbuf)-1)
  239.   
  240.   #define GetByte()       (bitlen >= 8 ? (__ = getbuf >> BYSH, bitlen -= 8,\
  241. !             getbuf <<= 8, __) : (getbuf |= (unsigned long) \
  242.               (getchar() & 0xFF) << (BYSH - bitlen), __ = getbuf\
  243.               >> BYSH, getbuf <<= 8, __))
  244.   
  245. --- 14,20 ----
  246.   #define BISH  (bits(getbuf)-1)
  247.   
  248.   #define GetByte()       (bitlen >= 8 ? (__ = getbuf >> BYSH, bitlen -= 8,\
  249. !             getbuf <<= 8, __) : (getbuf |= (ul_t) \
  250.               (getchar() & 0xFF) << (BYSH - bitlen), __ = getbuf\
  251.               >> BYSH, getbuf <<= 8, __))
  252.   
  253. diff -cr ../orig/compat.h ./compat.h
  254. *** ../orig/compat.h    Sun Nov 24 00:09:20 1991
  255. --- ./compat.h    Sun Nov 24 00:22:16 1991
  256. ***************
  257. *** 1,4 ****
  258. ! extern uchar    Table1[];
  259.   
  260.   #define F1              60
  261.   #define N1              4096
  262. --- 1,4 ----
  263. ! extern uc_t    Table1[];
  264.   
  265.   #define F1              60
  266.   #define N1              4096
  267. diff -cr ../orig/debug.c ./debug.c
  268. *** ../orig/debug.c    Sun Nov 24 00:09:21 1991
  269. --- ./debug.c    Sun Nov 24 00:22:16 1991
  270. ***************
  271. *** 55,61 ****
  272.   
  273.   char *
  274.   pr_char(c)
  275. !     register uchar c;
  276.   {
  277.       static char buf[5];
  278.       register i = 4;
  279. --- 55,61 ----
  280.   
  281.   char *
  282.   pr_char(c)
  283. !     register uc_t c;
  284.   {
  285.       static char buf[5];
  286.       register i = 4;
  287. diff -cr ../orig/decode.c ./decode.c
  288. *** ../orig/decode.c    Sun Nov 24 00:09:21 1991
  289. --- ./decode.c    Sun Nov 24 00:22:16 1991
  290. ***************
  291. *** 29,35 ****
  292.           if (c < 256) {
  293.   #ifdef DEBUG
  294.               if (debug)
  295. !                 fprintf(stderr, "'%s'\n", pr_char((uchar)c));
  296.               else
  297.   #endif /* DEBUG */
  298.                   putchar (c);
  299. --- 29,35 ----
  300.           if (c < 256) {
  301.   #ifdef DEBUG
  302.               if (debug)
  303. !                 fprintf(stderr, "'%s'\n", pr_char((uc_t)c));
  304.               else
  305.   #endif /* DEBUG */
  306.                   putchar (c);
  307. ***************
  308. *** 47,53 ****
  309.                   c = text_buf[(i + k) & (N2 - 1)];
  310.   #ifdef DEBUG
  311.                   if (debug)
  312. !                     fprintf(stderr, "%s", pr_char((uchar)c));
  313.                   else
  314.   #endif
  315.                       putchar (c);
  316. --- 47,53 ----
  317.                   c = text_buf[(i + k) & (N2 - 1)];
  318.   #ifdef DEBUG
  319.                   if (debug)
  320. !                     fprintf(stderr, "%s", pr_char((uc_t)c));
  321.                   else
  322.   #endif
  323.                       putchar (c);
  324. ***************
  325. *** 84,90 ****
  326.           if (c < 256) {
  327.   #ifdef DEBUG
  328.               if (debug)
  329. !                 fprintf(stderr, "'%s'\n", pr_char((uchar)c));
  330.               else
  331.   #endif /* DEBUG */
  332.                   putchar (c);
  333. --- 84,90 ----
  334.           if (c < 256) {
  335.   #ifdef DEBUG
  336.               if (debug)
  337. !                 fprintf(stderr, "'%s'\n", pr_char((uc_t)c));
  338.               else
  339.   #endif /* DEBUG */
  340.                   putchar (c);
  341. ***************
  342. *** 102,108 ****
  343.                   c = text_buf[(i + k) & (N1 - 1)];
  344.   #ifdef DEBUG
  345.                   if (debug)
  346. !                     fprintf(stderr, "%s", pr_char((uchar)c));
  347.                   else
  348.   #endif
  349.                       putchar (c);
  350. --- 102,108 ----
  351.                   c = text_buf[(i + k) & (N1 - 1)];
  352.   #ifdef DEBUG
  353.                   if (debug)
  354. !                     fprintf(stderr, "%s", pr_char((uc_t)c));
  355.                   else
  356.   #endif
  357.                       putchar (c);
  358. diff -cr ../orig/default.c ./default.c
  359. *** ../orig/default.c    Sun Nov 24 00:09:21 1991
  360. --- ./default.c    Sun Nov 24 00:22:16 1991
  361. ***************
  362. *** 20,26 ****
  363.   
  364.       if (!fname) {
  365.           if (defd)
  366. !             fclose(defd);
  367.           defd = NOFILE;
  368.           return OK;
  369.       }
  370. --- 20,26 ----
  371.   
  372.       if (!fname) {
  373.           if (defd)
  374. !             (void) fclose(defd);
  375.           defd = NOFILE;
  376.           return OK;
  377.       }
  378. diff -cr ../orig/encode.c ./encode.c
  379. *** ../orig/encode.c    Sun Nov 24 00:09:17 1991
  380. --- ./encode.c    Sun Nov 24 00:22:17 1991
  381. ***************
  382. *** 15,21 ****
  383.   
  384.   void freeze ()
  385.   {
  386. !     register u_short i, len, r, s;
  387.       register short c;
  388.       putchar(MAGIC1);
  389.       putchar(MAGIC2_2);
  390. --- 15,21 ----
  391.   
  392.   void freeze ()
  393.   {
  394. !     register us_t i, len, r, s;
  395.       register short c;
  396.       putchar(MAGIC1);
  397.       putchar(MAGIC2_2);
  398. ***************
  399. *** 50,55 ****
  400. --- 50,56 ----
  401.           InsertNode(r + i - F2);
  402.   
  403.       while (len != 0) {
  404. +         match_length = THRESHOLD;
  405.           Get_Next_Match(r,1);
  406.           if (match_length > len)
  407.               match_length = len;
  408. ***************
  409. *** 66,76 ****
  410.           } else if (greedy) {
  411.   /* GREEDY parsing (compression rate 1.5% worse, but 40% faster) */
  412.   
  413. !             EncodeLength((u_short) (match_length - THRESHOLD));
  414. !             EncodePosition((u_short)match_position);
  415.   
  416.           } else {
  417. !             register u_short orig_length, orig_position, oldchar;
  418.   
  419.   /* This fragment (delayed coding, non-greedy) is due to ideas of
  420.       Jan Mark Wams' <jms@cs.vu.nl> COMIC:
  421. --- 67,77 ----
  422.           } else if (greedy) {
  423.   /* GREEDY parsing (compression rate 1.5% worse, but 40% faster) */
  424.   
  425. !             EncodeLength((us_t) (match_length - THRESHOLD));
  426. !             EncodePosition((us_t)match_position);
  427.   
  428.           } else {
  429. !             register us_t orig_length, orig_position, oldchar;
  430.   
  431.   /* This fragment (delayed coding, non-greedy) is due to ideas of
  432.       Jan Mark Wams' <jms@cs.vu.nl> COMIC:
  433. ***************
  434. *** 85,94 ****
  435.   
  436.               if (match_length > len) match_length = len;
  437.   
  438. !             if (orig_length > match_length) {
  439. !                 EncodeLength((u_short)
  440.                       (orig_length - THRESHOLD));
  441. !                 EncodePosition((u_short)orig_position);
  442.   #ifdef DEBUG
  443.                   match_position = orig_position;
  444.   #endif  /* DEBUG */
  445. --- 86,95 ----
  446.   
  447.               if (match_length > len) match_length = len;
  448.   
  449. !             if (orig_length >= match_length) {
  450. !                 EncodeLength((us_t)
  451.                       (orig_length - THRESHOLD));
  452. !                 EncodePosition((us_t)orig_position);
  453.   #ifdef DEBUG
  454.                   match_position = orig_position;
  455.   #endif  /* DEBUG */
  456. diff -cr ../orig/freeze.1 ./freeze.1
  457. *** ../orig/freeze.1    Sun Nov 24 00:09:18 1991
  458. --- ./freeze.1    Sun Nov 24 00:22:17 1991
  459. ***************
  460. *** 53,59 ****
  461.   If the
  462.   .B \-g
  463.   flag is given, a slightly less powerful (compression
  464. ! rate is 1.5% less), but 40% faster heuristic is used.
  465.   .PP
  466.   If the
  467.   .B \-f
  468. --- 53,61 ----
  469.   If the
  470.   .B \-g
  471.   flag is given, a slightly less powerful (compression
  472. ! rate is 1.5% less), but 40% faster heuristic is used. The more times this
  473. ! flag is present, the faster program works and the less compression
  474. ! rate is. This flag is quite useful when freezing bitmaps.
  475.   .PP
  476.   If the
  477.   .B \-f
  478. ***************
  479. *** 262,264 ****
  480. --- 264,269 ----
  481.   Unknown values of flag bits were discovered in the header
  482.   of frozen file.
  483.   .in -8
  484. + .SH "BUGS"
  485. + Found bugs descriptions, incompatibilities, etc.  please send to
  486. + leo@s514.ipmce.su.
  487. diff -cr ../orig/freeze.c ./freeze.c
  488. *** ../orig/freeze.c    Sun Nov 24 00:09:19 1991
  489. --- ./freeze.c    Sun Nov 24 00:22:17 1991
  490. ***************
  491. *** 29,34 ****
  492. --- 29,38 ----
  493.    * Version 2.3: Minor bug fixes (DOS filenames handling, backward
  494.    * compatibility feature improved, "bits" compression ratio display,
  495.    * preventive check for special files), speedups, more comments added.
  496. +  * Version 2.3.1: Typedefs cleaned, utime bug on the m88k corrected
  497. +  * (pa@verano.sba.ca.us, clewis@ferret.ocunix.on.ca (Chris Lewis)),
  498. +  * "chain threshold" euristic used for speedup (in "greedy" mode) -
  499. +  * a la ZIP (Jean-Loup Gailly). Max. hash bits reduced to 16.
  500.    */
  501.   
  502.   static char ident[] = "@(#) freeze.c 2.3.%d %s leo@s514.ipmce.su\n";
  503. ***************
  504. *** 76,82 ****
  505.       short image = O_TEXT;
  506.   # endif
  507.   #else
  508. ! #  define last_sep(s) rindex((s), '/')    /* Unix always uses slashes */
  509.   char deffile[] = "/etc/default/freeze";
  510.   #endif
  511.   
  512. --- 80,86 ----
  513.       short image = O_TEXT;
  514.   # endif
  515.   #else
  516. ! #  define last_sep(s) strrchr((s), '/')  /* Unix always uses slashes */
  517.   char deffile[] = "/etc/default/freeze";
  518.   #endif
  519.   
  520. ***************
  521. *** 89,94 ****
  522. --- 93,99 ----
  523.   
  524.   /* Do not sleep when freeze works :-) */
  525.   long indc_count, indc_threshold;
  526. + long file_length = 0;   /* initial length of file */
  527.   
  528.   #ifdef INT_SIG
  529.   int
  530. ***************
  531. *** 109,115 ****
  532.    *      -d:         If given, melting is done instead.
  533.    *
  534.    *      -g:         Use "greedy" parsing (1.5% worse, 40% faster).
  535. !  *                  (Means nothing when melting)
  536.    *
  537.    *      -f:         Forces output file to be generated, even if one already
  538.    *                  exists, and even if no space is saved by freezeing.
  539. --- 114,120 ----
  540.    *      -d:         If given, melting is done instead.
  541.    *
  542.    *      -g:         Use "greedy" parsing (1.5% worse, 40% faster).
  543. !  *                  (Means nothing when melting). May be repeated.
  544.    *
  545.    *      -f:         Forces output file to be generated, even if one already
  546.    *                  exists, and even if no space is saved by freezeing.
  547. ***************
  548. *** 129,135 ****
  549.    *                  as text (CR-LF and ^Z special) in melted form.  Default
  550.    *                  unless BIN_DEFAULT specified.
  551.    *
  552. !  *      -v:         Write freezing statistics
  553.    *
  554.    *      -V:         Write version and compilation options.
  555.    *
  556. --- 134,141 ----
  557.    *                  as text (CR-LF and ^Z special) in melted form.  Default
  558.    *                  unless BIN_DEFAULT specified.
  559.    *
  560. !  *      -v:         Write freezing statistics. -vv means "draw progress
  561. !  *                  indicator".
  562.    *
  563.    *      -V:         Write version and compilation options.
  564.    *
  565. ***************
  566. *** 158,164 ****
  567.       short overwrite = 0;  /* Do not overwrite unless given -f flag */
  568.       char tempname[100];
  569.       char **filelist, **fileptr;
  570. !     char *cp, *rindex();
  571.   
  572.   #ifndef MSDOS
  573.       char *malloc();
  574. --- 164,170 ----
  575.       short overwrite = 0;  /* Do not overwrite unless given -f flag */
  576.       char tempname[100];
  577.       char **filelist, **fileptr;
  578. !     char *cp;
  579.   
  580.   #ifndef MSDOS
  581.       char *malloc();
  582. ***************
  583. *** 184,195 ****
  584.       if ( (bgnd_flag = signal ( SIGINT, SIG_IGN )) != SIG_IGN )
  585.   #endif
  586.       {
  587. !     signal ( SIGINT, onintr );
  588.   #ifdef __TURBOC__
  589.       setcbrk(1);
  590.   #endif
  591.   #ifndef MSDOS
  592. !     signal ( SIGSEGV, oops );
  593.   #endif
  594.       }
  595.   
  596. --- 190,201 ----
  597.       if ( (bgnd_flag = signal ( SIGINT, SIG_IGN )) != SIG_IGN )
  598.   #endif
  599.       {
  600. !     (void) signal ( SIGINT, onintr );
  601.   #ifdef __TURBOC__
  602.       setcbrk(1);
  603.   #endif
  604.   #ifndef MSDOS
  605. !     (void) signal ( SIGSEGV, oops );
  606.   #endif
  607.       }
  608.   
  609. ***************
  610. *** 224,237 ****
  611.       } else {
  612.       /* Freezing */
  613.   #ifndef MSDOS
  614. !     defopen(deffile);
  615.   #else
  616. !     cp = rindex(cp, '.');
  617.       *++cp = 'C';
  618.       *++cp = 'N';
  619.       *++cp = 'F';
  620.       *++cp = '\0';
  621. !     defopen(argv[0]);
  622.   #endif
  623.       }
  624.   #ifdef BSD4_2
  625. --- 230,243 ----
  626.       } else {
  627.       /* Freezing */
  628.   #ifndef MSDOS
  629. !     (void) defopen(deffile);
  630.   #else
  631. !     cp = strrchr(cp, '.');
  632.       *++cp = 'C';
  633.       *++cp = 'N';
  634.       *++cp = 'F';
  635.       *++cp = '\0';
  636. !     (void) defopen(argv[0]);
  637.   #endif
  638.       }
  639.   #ifdef BSD4_2
  640. ***************
  641. *** 279,285 ****
  642.               quiet--;
  643.               break;
  644.               case 'g':
  645. !             greedy = 1;
  646.               break;
  647.               case 'd':
  648.               do_melt = 1;
  649. --- 285,291 ----
  650.               quiet--;
  651.               break;
  652.               case 'g':
  653. !             greedy++;
  654.               break;
  655.               case 'd':
  656.               do_melt = 1;
  657. ***************
  658. *** 330,348 ****
  659.           cp = *fileptr + strlen(*fileptr) - 2;
  660.           if ((*cp != '.' && *cp != 'X' && *cp != 'x') ||
  661.               (*(++cp) != 'F' && *cp != 'f')) {
  662. !             strcpy(tempname, *fileptr);
  663.               *tail = '\0';
  664. !             if ((cp=rindex(tempname,'.')) == NULL)
  665. !             strcat(tempname, ".F");
  666.               else if(*(++cp) == '\0')
  667.               /* pseudo-extension: FOOBAR. */
  668. !             strcat(tempname, "F");
  669.               else {
  670.               /* cp now points to file extension */
  671.               tail[0] = cp[1];        /* save two chars */
  672.               tail[1] = cp[2];
  673.               *(++cp) = '\0';
  674. !             strcat(tempname, "XF");
  675.               }
  676.               *fileptr = tempname;
  677.           }
  678. --- 336,354 ----
  679.           cp = *fileptr + strlen(*fileptr) - 2;
  680.           if ((*cp != '.' && *cp != 'X' && *cp != 'x') ||
  681.               (*(++cp) != 'F' && *cp != 'f')) {
  682. !             (void) strcpy(tempname, *fileptr);
  683.               *tail = '\0';
  684. !             if ((cp=strrchr(tempname,'.')) == NULL)
  685. !             (void) strcat(tempname, ".F");
  686.               else if(*(++cp) == '\0')
  687.               /* pseudo-extension: FOOBAR. */
  688. !             (void) strcat(tempname, "F");
  689.               else {
  690.               /* cp now points to file extension */
  691.               tail[0] = cp[1];        /* save two chars */
  692.               tail[1] = cp[2];
  693.               *(++cp) = '\0';
  694. !             (void) strcat(tempname, "XF");
  695.               }
  696.               *fileptr = tempname;
  697.           }
  698. ***************
  699. *** 350,357 ****
  700.           /* Check for .F suffix */
  701.           if (strcmp(*fileptr + strlen(*fileptr) - 2, ".F") != 0) {
  702.               /* No .F: tack one on */
  703. !             strcpy(tempname, *fileptr);
  704. !             strcat(tempname, ".F");
  705.               *fileptr = tempname;
  706.           }
  707.   #endif /*MSDOS */
  708. --- 356,363 ----
  709.           /* Check for .F suffix */
  710.           if (strcmp(*fileptr + strlen(*fileptr) - 2, ".F") != 0) {
  711.               /* No .F: tack one on */
  712. !             (void) strcpy(tempname, *fileptr);
  713. !             (void) strcat(tempname, ".F");
  714.               *fileptr = tempname;
  715.           }
  716.   #endif /*MSDOS */
  717. ***************
  718. *** 389,398 ****
  719.           }
  720.   
  721.           /* Generate output filename */
  722. !         strcpy(ofname, *fileptr);
  723.           ofname[strlen(*fileptr) - 2] = '\0';  /* Strip off .F */
  724.   #ifdef MSDOS
  725. !         strcat(ofname, tail);
  726.   #endif
  727.           } else {
  728.   
  729. --- 395,405 ----
  730.           }
  731.   
  732.           /* Generate output filename */
  733. !         precious = 1;
  734. !         (void) strcpy(ofname, *fileptr);
  735.           ofname[strlen(*fileptr) - 2] = '\0';  /* Strip off .F */
  736.   #ifdef MSDOS
  737. !         (void) strcat(ofname, tail);
  738.   #endif
  739.           } else {
  740.   
  741. ***************
  742. *** 427,438 ****
  743.           }
  744.   
  745.           /* Generate output filename */
  746. !         strcpy(ofname, *fileptr);
  747.   #ifndef BSD4_2        /* Short filenames */
  748.           if ((cp = last_sep(ofname)) != NULL) cp++;
  749.           else cp = ofname;
  750.   # ifdef MSDOS
  751. !         if (topipe == 0 && (sufp = rindex(cp, '.')) != NULL &&
  752.               strlen(sufp) > 2) fprintf(stderr,
  753.               "%s: part of filename extension will be replaced by XF\n",
  754.               cp);
  755. --- 434,445 ----
  756.           }
  757.   
  758.           /* Generate output filename */
  759. !         (void) strcpy(ofname, *fileptr);
  760.   #ifndef BSD4_2        /* Short filenames */
  761.           if ((cp = last_sep(ofname)) != NULL) cp++;
  762.           else cp = ofname;
  763.   # ifdef MSDOS
  764. !         if (topipe == 0 && (sufp = strrchr(cp, '.')) != NULL &&
  765.               strlen(sufp) > 2) fprintf(stderr,
  766.               "%s: part of filename extension will be replaced by XF\n",
  767.               cp);
  768. ***************
  769. *** 446,466 ****
  770.                                
  771.   #ifdef MSDOS
  772.           /* There is no difference between FOOBAR and FOOBAR. names */
  773. !         if ((cp = rindex(ofname, '.')) == NULL)
  774. !             strcat(ofname, ".F");
  775.           else if (cp[1] == '\0')
  776.               /* FOOBAR. case */
  777. !             strcat(ofname, "F");
  778.           else {
  779.               cp[2] = '\0';
  780. !             strcat(ofname, "XF");
  781.           }
  782.   #else
  783. !         strcat(ofname, ".F");
  784.   #endif /* MSDOS */
  785.   
  786.           }
  787. -         precious = 0;
  788.           /* Check for overwrite of existing file */
  789.           if (overwrite == 0 && topipe == 0) {
  790.           if (stat(ofname, &statbuf) == 0) {
  791. --- 453,472 ----
  792.                                
  793.   #ifdef MSDOS
  794.           /* There is no difference between FOOBAR and FOOBAR. names */
  795. !         if ((cp = strrchr(ofname, '.')) == NULL)
  796. !             (void) strcat(ofname, ".F");
  797.           else if (cp[1] == '\0')
  798.               /* FOOBAR. case */
  799. !             (void) strcat(ofname, "F");
  800.           else {
  801.               cp[2] = '\0';
  802. !             (void) strcat(ofname, "XF");
  803.           }
  804.   #else
  805. !         (void) strcat(ofname, ".F");
  806.   #endif /* MSDOS */
  807.   
  808.           }
  809.           /* Check for overwrite of existing file */
  810.           if (overwrite == 0 && topipe == 0) {
  811.           if (stat(ofname, &statbuf) == 0) {
  812. ***************
  813. *** 472,479 ****
  814.   #endif
  815.               fprintf(stderr,
  816.                   " do you wish to overwrite %s (y or n)? ", ofname);
  817. !             fflush(stderr);
  818. !             read(2, response, 2);
  819.               while (response[1] != '\n') {
  820.                   if (read(2, response+1, 1) < 0) {    /* Ack! */
  821.                   perror("stderr"); break;
  822. --- 478,485 ----
  823.   #endif
  824.               fprintf(stderr,
  825.                   " do you wish to overwrite %s (y or n)? ", ofname);
  826. !             (void) fflush(stderr);
  827. !             (void) read(2, response, 2);
  828.               while (response[1] != '\n') {
  829.                   if (read(2, response+1, 1) < 0) {    /* Ack! */
  830.                   perror("stderr"); break;
  831. ***************
  832. *** 505,513 ****
  833.   #ifdef DEBUG
  834.           }
  835.   #endif
  836.           if(quiet != 1)  {
  837.               fprintf(stderr, "%s:", *fileptr);
  838. -             indc_threshold = 2048;
  839.               indc_count = 1024;
  840.           }
  841.           }
  842. --- 511,519 ----
  843.   #ifdef DEBUG
  844.           }
  845.   #endif
  846. +         precious = 0;
  847.           if(quiet != 1)  {
  848.               fprintf(stderr, "%s:", *fileptr);
  849.               indc_count = 1024;
  850.           }
  851.           }
  852. ***************
  853. *** 539,544 ****
  854. --- 545,551 ----
  855.   
  856.           if(topipe == 0)
  857.           copystat(*fileptr);     /* Copy stats */
  858. +         precious = 1;
  859.        }
  860.       } else {        /* Standard input */
  861.   Pipe:
  862. ***************
  863. *** 546,559 ****
  864.           perror("stdin");
  865.           exit(1);
  866.       }
  867. !     file_length = statbuf.st_size;
  868.   
  869.       indc_threshold = file_length / 100;
  870.       if (indc_threshold < 4096)
  871.           indc_threshold = 4096;
  872. - #ifdef DEBUG
  873. -     fprintf(stderr, "File length: %ld\n", file_length);
  874. - #endif
  875.   
  876.       topipe = 1;
  877.       if (do_melt == 0) {
  878. --- 553,563 ----
  879.           perror("stdin");
  880.           exit(1);
  881.       }
  882. !     file_length = statbuf.st_mode & S_IFREG ? statbuf.st_size : 0;
  883.   
  884.       indc_threshold = file_length / 100;
  885.       if (indc_threshold < 4096)
  886.           indc_threshold = 4096;
  887.   
  888.       topipe = 1;
  889.       if (do_melt == 0) {
  890. ***************
  891. *** 606,612 ****
  892.   
  893.   long in_count = 1;      /* length of input */
  894.   long bytes_out;         /* length of frozen output */
  895. - long file_length = 0;   /* initial length of file */
  896.   
  897.   /* Calculates and prints the compression ratio w/o floating point OPs */
  898.   
  899. --- 610,615 ----
  900. ***************
  901. *** 651,669 ****
  902.       fprintf(stream, " (%d.%02d bits)", (int)(q / 100), (int)(q % 100));
  903.   }
  904.   
  905. - /* From compress.c */
  906. - 
  907. - char *
  908. - rindex(s, c)        /* For those who don't have it in libc.a */
  909. - register char *s, c;
  910. - {
  911. -     char *p;
  912. -     for (p = NULL; *s; s++)
  913. -         if (*s == c)
  914. -         p = s;
  915. -     return(p);
  916. - }
  917. - 
  918.   /* There was an error when reading or writing files */
  919.   
  920.   void writeerr()
  921. --- 654,659 ----
  922. ***************
  923. *** 670,676 ****
  924.   {
  925.       if (!topipe) {
  926.       perror ( ofname );
  927. !     unlink ( ofname );
  928.       }
  929.       exit ( 1 );
  930.   }
  931. --- 660,666 ----
  932.   {
  933.       if (!topipe) {
  934.       perror ( ofname );
  935. !     (void) unlink ( ofname );
  936.       }
  937.       exit ( 1 );
  938.   }
  939. ***************
  940. *** 680,696 ****
  941.   {
  942.   #ifdef __TURBOC__
  943.   struct ftime utimbuf;
  944.   #endif
  945.       int mode;
  946. - #ifndef __TURBOC__
  947. -     time_t timep[2];
  948. - #endif
  949.   
  950.   #ifdef MSDOS
  951.       if (_osmajor < 3) freopen("CON","at",stdout); else      /* MS-DOS 2.xx bug */
  952.   #endif
  953.   
  954. !     fclose(stdout);
  955.   
  956.       if (exit_stat == 2 && (!force)) { /* No freezing: remove file.F */
  957.   
  958. --- 670,686 ----
  959.   {
  960.   #ifdef __TURBOC__
  961.   struct ftime utimbuf;
  962. + #else
  963. + struct utimbuf timep;
  964.   #endif
  965. + 
  966.       int mode;
  967.   
  968.   #ifdef MSDOS
  969.       if (_osmajor < 3) freopen("CON","at",stdout); else      /* MS-DOS 2.xx bug */
  970.   #endif
  971.   
  972. !     (void) fclose(stdout);
  973.   
  974.       if (exit_stat == 2 && (!force)) { /* No freezing: remove file.F */
  975.   
  976. ***************
  977. *** 712,718 ****
  978.   
  979.   #ifndef MSDOS
  980.       /* Copy ownership */
  981. !     chown(ofname, (int) statbuf.st_uid, (int) statbuf.st_gid);
  982.   #endif
  983.   
  984.   #ifdef __TURBOC__
  985. --- 702,708 ----
  986.   
  987.   #ifndef MSDOS
  988.       /* Copy ownership */
  989. !     (void) chown(ofname, (int) statbuf.st_uid, (int) statbuf.st_gid);
  990.   #endif
  991.   
  992.   #ifdef __TURBOC__
  993. ***************
  994. *** 719,731 ****
  995.           getftime(fileno(stdin),&utimbuf);
  996.           freopen(ofname,"rb",stdout);
  997.           setftime(fileno(stdout),&utimbuf);
  998. !         fclose(stdout);
  999.   #else
  1000. !     timep[0] = statbuf.st_atime;
  1001. !     timep[1] = statbuf.st_mtime;
  1002. !     utime(ofname, timep);    /* Update last accessed and modified times */
  1003.   #endif
  1004. -     precious = 1;
  1005.       if (unlink(ifname))    /* Remove input file */
  1006.           perror(ifname);
  1007.       if(quiet != 1)
  1008. --- 709,727 ----
  1009.           getftime(fileno(stdin),&utimbuf);
  1010.           freopen(ofname,"rb",stdout);
  1011.           setftime(fileno(stdout),&utimbuf);
  1012. !     (void) fclose(stdout);
  1013.   #else
  1014. !     timep.actime = statbuf.st_atime;
  1015. !     timep.modtime = statbuf.st_mtime;
  1016. ! 
  1017. ! #if defined(__m88k__)
  1018. !       timep.acusec=  statbuf.st_ausec;        /* pa@verano */
  1019. !       timep.modusec= statbuf.st_musec;
  1020. ! #endif /* !m88k */
  1021. ! 
  1022. !     /* Update last accessed and modified times */
  1023. !     (void) utime(ofname, &timep);
  1024.   #endif
  1025.       if (unlink(ifname))    /* Remove input file */
  1026.           perror(ifname);
  1027.       if(quiet != 1)
  1028. ***************
  1029. *** 800,810 ****
  1030.   /* Exception handler (SIGINT) */
  1031.   
  1032.   onintr ( ) {
  1033. !     if (!precious) {
  1034. !     fclose(stdout);
  1035. !     unlink ( ofname );
  1036.       }
  1037. !     exit ( 1 );
  1038.   }
  1039.   
  1040.   #if defined(__TURBOC__) || !defined(INT_SIG)
  1041. --- 796,806 ----
  1042.   /* Exception handler (SIGINT) */
  1043.   
  1044.   onintr ( ) {
  1045. !     if (!precious) {            /* topipe == 1 implies precious == 1 */
  1046. !     (void) fclose(stdout);
  1047. !     (void) unlink(ofname);
  1048.       }
  1049. !     exit(1);
  1050.   }
  1051.   
  1052.   #if defined(__TURBOC__) || !defined(INT_SIG)
  1053. ***************
  1054. *** 815,821 ****
  1055.   
  1056.   oops ( )        /* file is corrupt or internal error */
  1057.   {
  1058. !     fflush(stdout);
  1059.       fprintf(stderr, "Segmentation violation occured...\n");
  1060.       exit ( 1 );
  1061.   }
  1062. --- 811,817 ----
  1063.   
  1064.   oops ( )        /* file is corrupt or internal error */
  1065.   {
  1066. !     (void) fflush(stdout);
  1067.       fprintf(stderr, "Segmentation violation occured...\n");
  1068.       exit ( 1 );
  1069.   }
  1070. ***************
  1071. *** 868,874 ****
  1072.       int i, is_list = 0;
  1073.       if(!s) {
  1074.       /* try to consider 'type' as a list of values: n1,n2, ... */
  1075. !         if(rindex(type, ','))
  1076.               is_list = 1;
  1077.           else {
  1078.               fprintf(stderr, "\"%s\" - no such file type\n", type);
  1079. --- 864,870 ----
  1080.       int i, is_list = 0;
  1081.       if(!s) {
  1082.       /* try to consider 'type' as a list of values: n1,n2, ... */
  1083. !         if(strrchr(type, ','))
  1084.               is_list = 1;
  1085.           else {
  1086.               fprintf(stderr, "\"%s\" - no such file type\n", type);
  1087. ***************
  1088. *** 881,887 ****
  1089.               exit(1);
  1090.           }
  1091.       }
  1092. !     if(!is_list && (!(t = rindex(s, '=')) ||
  1093.           sscanf(++t, "%d %d %d %d %d %d %d %d",
  1094.           v, v+1, v+2, v+3, v+4, v+5, v+6, v+7) != 8)) {
  1095.           fprintf(stderr,
  1096. --- 877,883 ----
  1097.               exit(1);
  1098.           }
  1099.       }
  1100. !     if(!is_list && (!(t = strrchr(s, '=')) ||
  1101.           sscanf(++t, "%d %d %d %d %d %d %d %d",
  1102.           v, v+1, v+2, v+3, v+4, v+5, v+6, v+7) != 8)) {
  1103.           fprintf(stderr,
  1104. diff -cr ../orig/freeze.h ./freeze.h
  1105. *** ../orig/freeze.h    Sun Nov 24 00:09:22 1991
  1106. --- ./freeze.h    Sun Nov 24 00:22:18 1991
  1107. ***************
  1108. *** 1,4 ****
  1109. - 
  1110.   #include <stdio.h>
  1111.   
  1112.   #ifdef SUN4
  1113. --- 1,3 ----
  1114. ***************
  1115. *** 10,18 ****
  1116.   # ifndef putc
  1117.   #   define putc(x, p)      (--(p)->_cnt < 0 ? _flsbuf((unsigned char) (x), (p)) : (int) (*(p)->_ptr++ = (unsigned char) (x)))
  1118.   # endif
  1119. - #ifndef BSD4_2
  1120. - typedef unsigned short u_short;
  1121. - #endif  /* BSD4_2 */
  1122.   #endif  /* SUN4 */
  1123.   
  1124.   #include <ctype.h>
  1125. --- 9,14 ----
  1126. ***************
  1127. *** 20,25 ****
  1128. --- 16,29 ----
  1129.   #include <sys/types.h>
  1130.   #include <sys/stat.h>
  1131.   
  1132. + #ifndef __TURBOC__
  1133. + #include <utime.h>      /* Some systems have sys/utime.h instead of this */
  1134. + #endif
  1135. + 
  1136. + #if defined(BSD42) && !defined(BSD4_2)
  1137. + #define BSD4_2
  1138. + #endif
  1139. + 
  1140.   /* for MAXNAMLEN only !!! */
  1141.   #ifdef unix
  1142.   #ifndef BSD4_2
  1143. ***************
  1144. *** 53,64 ****
  1145.   #include <fcntl.h>
  1146.   #endif  /* MSDOS */
  1147.   
  1148. ! typedef unsigned char uchar;
  1149.   
  1150.   #if defined(BITS) && BITS > 14
  1151. ! typedef unsigned long hash_t;
  1152.   #else
  1153. ! typedef u_short hash_t;
  1154.   #endif  /* BITS */
  1155.   
  1156.   #ifdef  lint
  1157. --- 57,70 ----
  1158.   #include <fcntl.h>
  1159.   #endif  /* MSDOS */
  1160.   
  1161. ! typedef unsigned short us_t;
  1162. ! typedef unsigned char uc_t;
  1163. ! typedef unsigned long ul_t;
  1164.   
  1165.   #if defined(BITS) && BITS > 14
  1166. ! typedef ul_t hash_t;
  1167.   #else
  1168. ! typedef us_t hash_t;
  1169.   #endif  /* BITS */
  1170.   
  1171.   #ifdef  lint
  1172. ***************
  1173. *** 75,99 ****
  1174.   
  1175.   #define ENDOF           256                     /* pseudo-literal */
  1176.   
  1177. ! extern uchar    Table2[];
  1178.   
  1179.   extern long     in_count, bytes_out, file_length;
  1180.   
  1181. ! extern uchar    text_buf[];
  1182. ! extern u_short  match_position, match_length;
  1183.   
  1184. ! extern short    quiet, force;      /* useful flags */
  1185.   
  1186. ! /* Note ind_threshold is triangle number of Kbytes */
  1187.   
  1188. ! extern long indc_threshold, indc_count;
  1189.   
  1190. - extern short    do_melt, topipe, greedy;
  1191. - 
  1192. - #define MAGIC1          ((uchar)'\037')
  1193. - #define MAGIC2_1        ((uchar)'\236')          /* freeze vers. 1.X */
  1194. - #define MAGIC2_2        ((uchar)'\237')
  1195. - 
  1196.   extern int exit_stat;
  1197.   
  1198.   #ifdef DEBUG
  1199. --- 81,100 ----
  1200.   
  1201.   #define ENDOF           256                     /* pseudo-literal */
  1202.   
  1203. ! extern uc_t    Table2[];
  1204.   
  1205.   extern long     in_count, bytes_out, file_length;
  1206.   
  1207. ! extern uc_t      text_buf[];
  1208.   
  1209. ! extern long     indc_threshold, indc_count;
  1210.   
  1211. ! extern short    do_melt, topipe, greedy, quiet, force;  /* useful flags */
  1212.   
  1213. ! #define MAGIC1          ((uc_t)'\037')
  1214. ! #define MAGIC2_1        ((uc_t)'\236')          /* freeze vers. 1.X */
  1215. ! #define MAGIC2_2        ((uc_t)'\237')
  1216.   
  1217.   extern int exit_stat;
  1218.   
  1219.   #ifdef DEBUG
  1220. ***************
  1221. *** 110,119 ****
  1222.   extern short DecodeChar(), DecodePosition(), GetNBits();
  1223.   extern void melt2(), (*meltfunc)(), writeerr(), prratio(), prbits(), freeze();
  1224.   
  1225. - #if defined(BSD42) && !defined(BSD4_2)
  1226. - #define BSD4_2
  1227. - #endif
  1228. - 
  1229.   #ifdef COMPAT
  1230.   #include "compat.h"
  1231.   #endif
  1232. --- 111,116 ----
  1233. ***************
  1234. *** 123,130 ****
  1235.       if (ferror(stdout))\
  1236.           writeerr();\
  1237.       if (file_length) {\
  1238. !         fprintf(stderr, " %2d%%\b\b\b\b",\
  1239. !             ftell(stdin) * 100 / file_length);\
  1240.           indc_count += indc_threshold;\
  1241.       } else {\
  1242.           fprintf(stderr, " %5ldK\b\b\b\b\b\b\b", in_count / 1024);\
  1243. --- 120,131 ----
  1244.       if (ferror(stdout))\
  1245.           writeerr();\
  1246.       if (file_length) {\
  1247. !         static int percents, old_percents = -1;\
  1248. !         if ((percents = ftell(stdin) * 100 / file_length) !=\
  1249. !             old_percents) {\
  1250. !             fprintf(stderr, " %2d%%\b\b\b\b", percents);\
  1251. !             old_percents = percents;\
  1252. !         }\
  1253.           indc_count += indc_threshold;\
  1254.       } else {\
  1255.           fprintf(stderr, " %5ldK\b\b\b\b\b\b\b", in_count / 1024);\
  1256. ***************
  1257. *** 136,139 ****
  1258. --- 137,143 ----
  1259.   
  1260.   #ifdef BSD4_2
  1261.   #define strchr index
  1262. + #define strrchr rindex
  1263.   #endif
  1264. + 
  1265. + extern char *strchr(), *strrchr();
  1266. diff -cr ../orig/huf.c ./huf.c
  1267. *** ../orig/huf.c    Sun Nov 24 00:09:19 1991
  1268. --- ./huf.c    Sun Nov 24 00:22:18 1991
  1269. ***************
  1270. *** 14,28 ****
  1271.    * it freely when melting.
  1272.    */
  1273.   
  1274. ! uchar Table2[9] = { 0, 0, 1, 1, 1, 4, 10, 27, 18 };
  1275.   
  1276. ! uchar p_len[64];        /* These arrays are built accordingly to values */
  1277. ! uchar d_len[256];       /* of `Table' above which are default, from the */
  1278. !             /* command line or from the header of frozen file */
  1279.   
  1280. ! uchar code[256];
  1281.   
  1282. ! u_short freq[T2 + 1];           /* frequency table */
  1283.   short   son[T2];                /* points to son node (son[i],son[i+1]) */
  1284.   short   prnt[T2 + N_CHAR2];     /* points to parent node */
  1285.   
  1286. --- 14,28 ----
  1287.    * it freely when melting.
  1288.    */
  1289.   
  1290. ! uc_t Table2[9] = { 0, 0, 1, 1, 1, 4, 10, 27, 18 };
  1291.   
  1292. ! uc_t p_len[64];        /* These arrays are built accordingly to values */
  1293. ! uc_t d_len[256];       /* of `Table' above which are default, from the */
  1294. !               /* command line or from the header of frozen file */
  1295.   
  1296. ! uc_t code[256];
  1297.   
  1298. ! us_t freq[T2 + 1];           /* frequency table */
  1299.   short   son[T2];                /* points to son node (son[i],son[i+1]) */
  1300.   short   prnt[T2 + N_CHAR2];     /* points to parent node */
  1301.   
  1302. ***************
  1303. *** 76,83 ****
  1304.   
  1305.   void reconst ()
  1306.   {
  1307. !     register u_short i, j, k;
  1308. !     register u_short f;
  1309.   
  1310.   #ifdef DEBUG
  1311.       if (quiet < 0)
  1312. --- 76,83 ----
  1313.   
  1314.   void reconst ()
  1315.   {
  1316. !     register us_t i, j, k;
  1317. !     register us_t f;
  1318.   
  1319.   #ifdef DEBUG
  1320.       if (quiet < 0)
  1321. ***************
  1322. *** 104,110 ****
  1323.           f = freq[j] = freq[i] + freq[k];
  1324.           for (k = j - 1; f < freq[k]; k--);
  1325.           k++;
  1326. !         {       register u_short *p, *e;
  1327.               for (p = &freq[j], e = &freq[k]; p > e; p--)
  1328.                   p[0] = p[-1];
  1329.               freq[k] = f;
  1330. --- 104,110 ----
  1331.           f = freq[j] = freq[i] + freq[k];
  1332.           for (k = j - 1; f < freq[k]; k--);
  1333.           k++;
  1334. !         {       register us_t *p, *e;
  1335.               for (p = &freq[j], e = &freq[k]; p > e; p--)
  1336.                   p[0] = p[-1];
  1337.               freq[k] = f;
  1338. ***************
  1339. *** 130,139 ****
  1340.   /* Updates given code's frequency, and updates tree */
  1341.   
  1342.   void update (c)
  1343. !     u_short c;
  1344.   {
  1345. !     register u_short *p;
  1346. !     register u_short i, j, k, l;
  1347.   
  1348.       if (freq[r] == MAX_FREQ) {
  1349.           reconst();
  1350. --- 130,139 ----
  1351.   /* Updates given code's frequency, and updates tree */
  1352.   
  1353.   void update (c)
  1354. !     us_t c;
  1355.   {
  1356. !     register us_t *p;
  1357. !     register us_t i, j, k, l;
  1358.   
  1359.       if (freq[r] == MAX_FREQ) {
  1360.           reconst();
  1361. ***************
  1362. *** 168,177 ****
  1363.   /* Encodes the literal or the length information */
  1364.   
  1365.   void EncodeChar (c)
  1366. !     u_short c;
  1367.   {
  1368. !     unsigned long i;
  1369. !     register u_short j, k;
  1370.   
  1371.       i = 0;
  1372.       j = 0;
  1373. --- 168,177 ----
  1374.   /* Encodes the literal or the length information */
  1375.   
  1376.   void EncodeChar (c)
  1377. !     us_t c;
  1378.   {
  1379. !     ul_t i;
  1380. !     register us_t j, k;
  1381.   
  1382.       i = 0;
  1383.       j = 0;
  1384. ***************
  1385. *** 191,200 ****
  1386.   /* `j' never reaches the value of 32 ! */
  1387.   
  1388.       if (j > 16) {
  1389. !         Putcode(16, (u_short)(i >> 16));
  1390. !         Putcode(j - 16, (u_short)i);
  1391.       } else {
  1392. !         Putcode(j, (u_short)(i >> 16));
  1393.       }
  1394.       update(c);
  1395.   }
  1396. --- 191,200 ----
  1397.   /* `j' never reaches the value of 32 ! */
  1398.   
  1399.       if (j > 16) {
  1400. !         Putcode(16, (us_t)(i >> 16));
  1401. !         Putcode(j - 16, (us_t)i);
  1402.       } else {
  1403. !         Putcode(j, (us_t)(i >> 16));
  1404.       }
  1405.       update(c);
  1406.   }
  1407. ***************
  1408. *** 202,217 ****
  1409.   /* Encodes the position information */
  1410.   
  1411.   void EncodePosition (c)
  1412. !     register u_short c;
  1413.   {
  1414. !     register u_short i;
  1415.   
  1416.       /* output upper 6 bit from table */
  1417.       i = c >> 7;
  1418. !     Putcode((u_short)(p_len[i]), (u_short)(code[i]) << 8);
  1419.   
  1420.       /* output lower 7 bit */
  1421. !     Putcode(7, (u_short)(c & 0x7f) << 9);
  1422.   }
  1423.   
  1424.   
  1425. --- 202,217 ----
  1426.   /* Encodes the position information */
  1427.   
  1428.   void EncodePosition (c)
  1429. !     register us_t c;
  1430.   {
  1431. !     register us_t i;
  1432.   
  1433.       /* output upper 6 bit from table */
  1434.       i = c >> 7;
  1435. !     Putcode((us_t)(p_len[i]), (us_t)(code[i]) << 8);
  1436.   
  1437.       /* output lower 7 bit */
  1438. !     Putcode(7, (us_t)(c & 0x7f) << 9);
  1439.   }
  1440.   
  1441.   
  1442. ***************
  1443. *** 221,227 ****
  1444.   
  1445.   short DecodeChar ()
  1446.   {
  1447. !     register u_short c;
  1448.       c = son[r];
  1449.   
  1450.       /* trace from root to leaf,
  1451. --- 221,227 ----
  1452.   
  1453.   short DecodeChar ()
  1454.   {
  1455. !     register us_t c;
  1456.       c = son[r];
  1457.   
  1458.       /* trace from root to leaf,
  1459. ***************
  1460. *** 245,251 ****
  1461.   
  1462.   short DecodePosition ()
  1463.   {
  1464. !     register u_short i, j, c;
  1465.   
  1466.       /* decode upper 6 bits from the table */
  1467.   
  1468. --- 245,251 ----
  1469.   
  1470.   short DecodePosition ()
  1471.   {
  1472. !     register us_t i, j, c;
  1473.   
  1474.       /* decode upper 6 bits from the table */
  1475.   
  1476. ***************
  1477. *** 252,258 ****
  1478.       i = GetByte();
  1479.       crpt_flag = feof(stdin);
  1480.   
  1481. !     c = (u_short)code[i] << 7;
  1482.       j = d_len[i] - 1;
  1483.   
  1484.       /* get lower 7 bits literally */
  1485. --- 252,258 ----
  1486.       i = GetByte();
  1487.       crpt_flag = feof(stdin);
  1488.   
  1489. !     c = (us_t)code[i] << 7;
  1490.       j = d_len[i] - 1;
  1491.   
  1492.       /* get lower 7 bits literally */
  1493. ***************
  1494. *** 263,269 ****
  1495.   
  1496.   /* Initializes static Huffman arrays */
  1497.   
  1498. ! void init(table) uchar * table; {
  1499.       short i, j, k, num;
  1500.       num = 0;
  1501.   
  1502. --- 263,269 ----
  1503.   
  1504.   /* Initializes static Huffman arrays */
  1505.   
  1506. ! void init(table) uc_t * table; {
  1507.       short i, j, k, num;
  1508.       num = 0;
  1509.   
  1510. ***************
  1511. *** 309,315 ****
  1512.   */
  1513.   
  1514.   void write_header() {
  1515. !     u_short i;
  1516.   
  1517.       i = Table2[5] & 0x1F; i <<= 4;
  1518.       i |= Table2[4] & 0xF; i <<= 3;
  1519. --- 309,315 ----
  1520.   */
  1521.   
  1522.   void write_header() {
  1523. !     us_t i;
  1524.   
  1525.       i = Table2[5] & 0x1F; i <<= 4;
  1526.       i |= Table2[4] & 0xF; i <<= 3;
  1527. ***************
  1528. *** 378,384 ****
  1529.   
  1530.   #ifdef COMPAT
  1531.   
  1532. ! uchar Table1[9] = { 0, 0, 0, 1, 3, 8, 12, 24, 16 };
  1533.   
  1534.   /* Old version of a routine above for handling files made by
  1535.       the 1st version of Freeze.
  1536. --- 378,384 ----
  1537.   
  1538.   #ifdef COMPAT
  1539.   
  1540. ! uc_t Table1[9] = { 0, 0, 0, 1, 3, 8, 12, 24, 16 };
  1541.   
  1542.   /* Old version of a routine above for handling files made by
  1543.       the 1st version of Freeze.
  1544. ***************
  1545. *** 386,397 ****
  1546.   
  1547.   short DecodePOld ()
  1548.   {
  1549. !     register u_short i, j, c;
  1550.   
  1551.       i = GetByte();
  1552.       crpt_flag = feof(stdin);
  1553.   
  1554. !     c = (u_short)code[i] << 6;
  1555.       j = d_len[i] - 2;
  1556.   
  1557.       return c | (((i << j) | GetNBits (j)) & 0x3f);
  1558. --- 386,397 ----
  1559.   
  1560.   short DecodePOld ()
  1561.   {
  1562. !     register us_t i, j, c;
  1563.   
  1564.       i = GetByte();
  1565.       crpt_flag = feof(stdin);
  1566.   
  1567. !     c = (us_t)code[i] << 6;
  1568.       j = d_len[i] - 2;
  1569.   
  1570.       return c | (((i << j) | GetNBits (j)) & 0x3f);
  1571. diff -cr ../orig/huf.h ./huf.h
  1572. *** ../orig/huf.h    Sun Nov 24 00:09:22 1991
  1573. --- ./huf.h    Sun Nov 24 00:22:18 1991
  1574. ***************
  1575. *** 1,6 ****
  1576.   
  1577. ! extern u_short freq[];
  1578.   extern short son[], prnt[];
  1579.   extern void StartHuff(), init(), write_header(), EncodeChar();
  1580.   extern void EncodePosition();
  1581. ! #define MAX_FREQ        (u_short)0x8000 /* Tree update timing */
  1582. --- 1,6 ----
  1583.   
  1584. ! extern us_t freq[];
  1585.   extern short son[], prnt[];
  1586.   extern void StartHuff(), init(), write_header(), EncodeChar();
  1587.   extern void EncodePosition();
  1588. ! #define MAX_FREQ        (us_t)0x8000 /* Tree update timing */
  1589. diff -cr ../orig/lz.c ./lz.c
  1590. *** ../orig/lz.c    Sun Nov 24 00:09:23 1991
  1591. --- ./lz.c    Sun Nov 24 00:22:19 1991
  1592. ***************
  1593. *** 7,16 ****
  1594.   /*                                                                      */
  1595.   /*----------------------------------------------------------------------*/
  1596.   
  1597. ! uchar    text_buf[N2 + F2 - 1];          /* cyclic buffer with an overlay */
  1598. ! u_short   match_position, match_length; /* current characteristics of a
  1599. !                        matched pattern */
  1600.   
  1601.   /*      next[N+1..] is used as hash table,
  1602.       the rest of next is a link down,
  1603.       prev is a link up.
  1604. --- 7,19 ----
  1605.   /*                                                                      */
  1606.   /*----------------------------------------------------------------------*/
  1607.   
  1608. ! uc_t    text_buf[N2 + F2 - 1];          /* cyclic buffer with an overlay */
  1609. ! us_t    match_position, match_length;   /* current characteristics of a
  1610. !                         matched pattern */
  1611. ! us_t    chain_length;                   /* max_chain_length ==
  1612. !                         CHAIN_THRESHOLD / greedy */
  1613.   
  1614. + 
  1615.   /*      next[N+1..] is used as hash table,
  1616.       the rest of next is a link down,
  1617.       prev is a link up.
  1618. ***************
  1619. *** 20,59 ****
  1620.   
  1621.   #ifndef __XENIX__
  1622.   #ifdef __TURBOC__
  1623. ! u_short huge * next = (u_short huge *) NULL;
  1624.   #else  /* __TURBOC__ */
  1625. ! u_short next[array_size];       /* a VERY large array :-) */
  1626.   #endif /* __TURBOC__ */
  1627.   #else  /* __XENIX__ */
  1628.   #if parts == 2
  1629. ! u_short next0[32768L], next1[8193];
  1630.   #else
  1631. ! #       if parts == 3
  1632. ! u_short next0[32768L], next1[32768L], next2[8193];
  1633. ! #       else
  1634. ! #               if parts == 5
  1635. ! u_short next0[32768L], next1[32768L], next2[32768L], next3[32768L], next4[8193];
  1636. ! #               else
  1637. ! u_short next0[32768L], next1[32768L], next2[32768L], next3[32768L], next4[32768L],
  1638. !     next5[32768L], next6[32768L], next7[32768L], next8[8193];
  1639. ! #               endif
  1640. ! #       endif
  1641.   #endif  /* parts */
  1642.   
  1643.   /* A list of `next's parts */
  1644.   
  1645. ! u_short *next[parts] = {
  1646.   next0, next1
  1647.   #if parts > 2
  1648.   ,next2
  1649. - #if parts > 3
  1650. - ,next3, next4
  1651. - #if parts > 5
  1652. - ,next5, next6,
  1653. - next7, next8
  1654.   #endif
  1655. - #endif
  1656. - #endif
  1657.   };
  1658.   #endif  /* __XENIX__ */
  1659.   
  1660. --- 23,46 ----
  1661.   
  1662.   #ifndef __XENIX__
  1663.   #ifdef __TURBOC__
  1664. ! us_t huge * next = (us_t huge *) NULL;
  1665.   #else  /* __TURBOC__ */
  1666. ! us_t next[array_size];       /* a VERY large array :-) */
  1667.   #endif /* __TURBOC__ */
  1668.   #else  /* __XENIX__ */
  1669.   #if parts == 2
  1670. ! us_t next0[32768L], next1[8193];
  1671.   #else
  1672. ! us_t next0[32768L], next1[32768L], next2[8193];
  1673.   #endif  /* parts */
  1674.   
  1675.   /* A list of `next's parts */
  1676.   
  1677. ! us_t *next[parts] = {
  1678.   next0, next1
  1679.   #if parts > 2
  1680.   ,next2
  1681.   #endif
  1682.   };
  1683.   #endif  /* __XENIX__ */
  1684.   
  1685. ***************
  1686. *** 74,84 ****
  1687.   #endif  /* GATHER_STAT */
  1688.   
  1689.   #ifdef __TURBOC__
  1690. !     if (!next && (next = (u_short huge *) farmalloc(
  1691. !         (unsigned long)array_size * sizeof(u_short))) == NULL) {
  1692.   
  1693.           fprintf(stderr, "Not enough memory (%luK wanted)\n",
  1694. !             (unsigned long)array_size * sizeof(u_short) / 1024);
  1695.           exit(3);
  1696.       }
  1697.   #endif  /* __TURBOC__ */
  1698. --- 61,71 ----
  1699.   #endif  /* GATHER_STAT */
  1700.   
  1701.   #ifdef __TURBOC__
  1702. !     if (!next && (next = (us_t huge *) farmalloc(
  1703. !         (ul_t)array_size * sizeof(us_t))) == NULL) {
  1704.   
  1705.           fprintf(stderr, "Not enough memory (%luK wanted)\n",
  1706. !             (ul_t)array_size * sizeof(us_t) / 1024);
  1707.           exit(3);
  1708.       }
  1709.   #endif  /* __TURBOC__ */
  1710. ***************
  1711. *** 87,116 ****
  1712.           nextof(i) = NIL;
  1713.       for (i = 0; i < sizeof(prev)/sizeof(*prev); i++ )
  1714.           prev[i] = NIL;
  1715.   }
  1716.   
  1717. ! /* Get the longest nearest match of the string beginning in text_buf[r]
  1718.       to the cyclic buffer. Result (length & position) is returned
  1719.       in correspondent global variables (`match_length' &
  1720. !     `match_position'). `match_length' == 0 denotes failure.
  1721.   */
  1722.   
  1723.   #ifndef FAST
  1724.   void get_next_match (r)
  1725. !     u_short r;
  1726.   {
  1727. !     register u_short p = r;
  1728.       register int m;
  1729. !     register uchar  *key FIX_SI, *pattern FIX_DI;
  1730.   #ifdef GATHER_STAT
  1731.       node_matches++;
  1732.   #endif
  1733.       key = text_buf + r;
  1734. -     match_length = 0;
  1735.       do {
  1736.           do {
  1737. !             if ((p = nextof(p)) == NIL)
  1738.                   return;
  1739.               pattern = text_buf + p;
  1740.   
  1741.               MATCHING;
  1742. --- 74,109 ----
  1743.           nextof(i) = NIL;
  1744.       for (i = 0; i < sizeof(prev)/sizeof(*prev); i++ )
  1745.           prev[i] = NIL;
  1746. +     chain_length = greedy ? CHAIN_THRESHOLD / greedy : 0;
  1747.   }
  1748.   
  1749. ! /* Get the longest (longer than `match_length' when entering in subroutine)
  1750. !     nearest match of the string beginning in text_buf[r]
  1751.       to the cyclic buffer. Result (length & position) is returned
  1752.       in correspondent global variables (`match_length' &
  1753. !     `match_position'). Unchanged `match_length' denotes failure.
  1754.   */
  1755.   
  1756.   #ifndef FAST
  1757.   void get_next_match (r)
  1758. !     us_t r;
  1759.   {
  1760. !     register us_t p = r;
  1761.       register int m;
  1762. !     register uc_t  *key FIX_SI, *pattern FIX_DI;
  1763. !     int     chain_count = chain_length;
  1764.   #ifdef GATHER_STAT
  1765.       node_matches++;
  1766.   #endif
  1767.       key = text_buf + r;
  1768.       do {
  1769.           do {
  1770. !             /* From ZIP 1.0 by J.-L. Gailly et al. */
  1771. ! 
  1772. !             if ((p = nextof(p)) == NIL ||
  1773. !                 (greedy && !chain_count--))
  1774.                   return;
  1775. + 
  1776.               pattern = text_buf + p;
  1777.   
  1778.               MATCHING;
  1779. diff -cr ../orig/lz.h ./lz.h
  1780. *** ../orig/lz.h    Sun Nov 24 00:09:23 1991
  1781. --- ./lz.h    Sun Nov 24 00:22:19 1991
  1782. ***************
  1783. *** 9,17 ****
  1784.   #define BITS    13      /* 1:1 hash */
  1785.   #endif
  1786.   
  1787. ! #if BITS > 21
  1788.   #undef BITS
  1789. ! #define BITS    21      /* 4 MB hash table, if sizeof(u_short) == 2 */
  1790.   #endif
  1791.   
  1792.   /* The following hash-function isn't optimal but it is very fast:
  1793. --- 9,17 ----
  1794.   #define BITS    13      /* 1:1 hash */
  1795.   #endif
  1796.   
  1797. ! #if BITS > 16
  1798.   #undef BITS
  1799. ! #define BITS    16      /* 128K hash table, if sizeof(us_t) == 2 */
  1800.   #endif
  1801.   
  1802.   /* The following hash-function isn't optimal but it is very fast:
  1803. ***************
  1804. *** 29,39 ****
  1805.   
  1806.   #if defined(M_XENIX) && defined(I_286) && (BITS > 14)
  1807.   #define __XENIX__
  1808. - #if BITS > 18
  1809. - #undef BITS
  1810. - #define BITS 18
  1811.   #endif
  1812. - #endif
  1813.   
  1814.   /* `array_size' is the size of array `next', which contains
  1815.       the heads of linked lists and the references to
  1816. --- 29,35 ----
  1817. ***************
  1818. *** 43,80 ****
  1819.   #define array_size      (N2 + 1 + (1L << BITS))
  1820.   
  1821.   extern hash_t prev[];
  1822.   
  1823.   #ifndef __XENIX__
  1824.   #define nextof(i)       next[i]
  1825.   
  1826.   #ifdef __TURBOC__
  1827. ! extern u_short huge * next;
  1828.   #else   /* __TURBOC__ */
  1829. ! extern u_short next[];
  1830.   #endif  /* __TURBOC__ */
  1831.   
  1832.   #else   /* __XENIX__ */
  1833.   
  1834.   /* We divide the array `next' in `parts' which fit into 286's segment */
  1835.   
  1836.   #define parts (array_size/32768 + 1)
  1837.   #define nextof(i)       next[(i) >> 15][(i) & 0x7fff]
  1838.   #if parts == 2
  1839. ! extern u_short next0[], next1[];
  1840.   #else
  1841. ! #    if parts == 3
  1842. ! extern u_short next0[], next1[], next2[];
  1843. ! #       else
  1844. ! #        if parts == 5
  1845. ! extern u_short next0[], next1[], next2[], next3[], next4[];
  1846. ! #        else
  1847. ! extern u_short next0[], next1[], next2[], next3[], next4[],
  1848. !     next5[], next6[], next7[], next8[];
  1849. ! #        endif
  1850. ! #    endif
  1851.   #endif  /* parts */
  1852.   
  1853. ! extern u_short *next[];
  1854.   #endif  /* __XENIX__ */
  1855.   
  1856.   /* Some defines to eliminate function-call overhead */
  1857. --- 39,69 ----
  1858.   #define array_size      (N2 + 1 + (1L << BITS))
  1859.   
  1860.   extern hash_t prev[];
  1861. + extern us_t      match_position, match_length, chain_length;
  1862.   
  1863.   #ifndef __XENIX__
  1864.   #define nextof(i)       next[i]
  1865.   
  1866.   #ifdef __TURBOC__
  1867. ! extern us_t huge * next;
  1868.   #else   /* __TURBOC__ */
  1869. ! extern us_t next[];
  1870.   #endif  /* __TURBOC__ */
  1871.   
  1872.   #else   /* __XENIX__ */
  1873.   
  1874.   /* We divide the array `next' in `parts' which fit into 286's segment */
  1875. + /* There may be 2 or 3 parts, because BITS <= 16 now */
  1876.   
  1877.   #define parts (array_size/32768 + 1)
  1878.   #define nextof(i)       next[(i) >> 15][(i) & 0x7fff]
  1879.   #if parts == 2
  1880. ! extern us_t next0[], next1[];
  1881.   #else
  1882. ! extern us_t next0[], next1[], next2[];
  1883.   #endif  /* parts */
  1884.   
  1885. ! extern us_t *next[];
  1886.   #endif  /* __XENIX__ */
  1887.   
  1888.   /* Some defines to eliminate function-call overhead */
  1889. ***************
  1890. *** 93,100 ****
  1891.   
  1892.   #define InsertNode(r)\
  1893.   {\
  1894. !     register hash_t p; register u_short first_son;\
  1895. !     register uchar  *key;\
  1896.       key = &text_buf[r];\
  1897.       p = N2 + 1 + (((hash_t)key[0] + ((hash_t)key[1] << LEN0) +\
  1898.               ((hash_t)key[2] << LEN1)) & ((1L << BITS) - 1));\
  1899. --- 82,89 ----
  1900.   
  1901.   #define InsertNode(r)\
  1902.   {\
  1903. !     register hash_t p; register us_t first_son;\
  1904. !     register uc_t  *key;\
  1905.       key = &text_buf[r];\
  1906.       p = N2 + 1 + (((hash_t)key[0] + ((hash_t)key[1] << LEN0) +\
  1907.               ((hash_t)key[2] << LEN1)) & ((1L << BITS) - 1));\
  1908. ***************
  1909. *** 163,168 ****
  1910. --- 152,159 ----
  1911.   
  1912.   #endif
  1913.   
  1914. + #define CHAIN_THRESHOLD (F2 * 3)
  1915. + 
  1916.   #ifdef  FAST
  1917.   /* Simple inline replacement for get_next_match; they match
  1918.   literally except return --> goto quote(leave)l. No obfuscations !! */
  1919. ***************
  1920. *** 173,186 ****
  1921.   #define LEAVE(num) leave/**/num
  1922.   #endif
  1923.   
  1924. ! #define Get_Next_Match(r,l) {register u_short p=r;register int m;\
  1925. ! register uchar *key FIX_SI, *pattern FIX_DI;key=text_buf+r;\
  1926. ! match_length=0;do{ do{ if((p=nextof(p))==NIL)goto LEAVE(l);\
  1927. ! pattern=text_buf+p;MATCHING;}while NOT_YET;\
  1928. ! for(m=match_length;++m<F2&&key[m]==pattern[m];);   \
  1929.   match_length=m;match_position=((r-p)&(N2-1))-1;}while(m<F2);\
  1930. ! nextof(prev[p])=nextof(p);prev[nextof(p)]=prev[p];prev[p]=NIL;   \
  1931. ! LEAVE(l):;}
  1932.   
  1933.   #else
  1934.   
  1935. --- 164,176 ----
  1936.   #define LEAVE(num) leave/**/num
  1937.   #endif
  1938.   
  1939. ! #define Get_Next_Match(r,l) {register us_t p=r;register int m;\
  1940. ! register uc_t *key FIX_SI, *pattern FIX_DI;int chain_count=chain_length;\
  1941. ! key=text_buf+r;do{ do{ if((p=nextof(p))==NIL||(greedy &&\
  1942. ! !chain_count--))goto LEAVE(l);pattern=text_buf+p;MATCHING;}while NOT_YET;\
  1943. ! for(m=match_length;++m<F2&&key[m]==pattern[m];);\
  1944.   match_length=m;match_position=((r-p)&(N2-1))-1;}while(m<F2);\
  1945. ! nextof(prev[p])=nextof(p);prev[nextof(p)]=prev[p];prev[p]=NIL;LEAVE(l):;}
  1946.   
  1947.   #else
  1948.   
  1949. diff -cr ../orig/makefile ./makefile
  1950. *** ../orig/makefile    Sun Nov 24 00:09:24 1991
  1951. --- ./makefile    Sun Nov 24 00:22:19 1991
  1952. ***************
  1953. *** 13,19 ****
  1954.   
  1955.   CC            = gcc
  1956.   
  1957. ! CFLAGS        = -DBITS=18 -O -DCOMPAT -DFAST -fstrength-reduce #-DBSD42 -DSUN4
  1958.   
  1959.   LINTFLAGS     = -DBITS=15 -DCOMPAT -DDEBUG -DGATHER_STAT -x -DFAST
  1960.   
  1961. --- 13,19 ----
  1962.   
  1963.   CC            = gcc
  1964.   
  1965. ! CFLAGS        = -DBITS=16 -O -DCOMPAT -DFAST -fstrength-reduce #-DBSD42 -DSUN4
  1966.   
  1967.   LINTFLAGS     = -DBITS=15 -DCOMPAT -DDEBUG -DGATHER_STAT -x -DFAST
  1968.   
  1969. ***************
  1970. *** 30,38 ****
  1971.   
  1972.   PROGRAM       = freeze
  1973.   
  1974. ! CATMAN        = freeze.man
  1975.   
  1976. ! MAN           = freeze.1
  1977.   
  1978.   SRCS          = bitio.c\
  1979.           debug.c\
  1980. --- 30,38 ----
  1981.   
  1982.   PROGRAM       = freeze
  1983.   
  1984. ! CATMAN        = freeze.man statist.man
  1985.   
  1986. ! MAN           = freeze.1 statist.1
  1987.   
  1988.   SRCS          = bitio.c\
  1989.           debug.c\
  1990. ***************
  1991. *** 43,50 ****
  1992.           huf.c\
  1993.           lz.c
  1994.   
  1995. ! all:            $(PROGRAM) statist $(CATMAN)
  1996.   
  1997.   lint:           $(SRCS)
  1998.           lint $(LINTFLAGS) $(SRCS) > lint.out
  1999.   
  2000. --- 43,57 ----
  2001.           huf.c\
  2002.           lz.c
  2003.   
  2004. ! .SUFFIXES:       .1 .man
  2005.   
  2006. + .1.man:
  2007. +         nroff -man < $< > $@
  2008. + 
  2009. + all:            $(PROGRAM) statist man
  2010. + 
  2011. + man:            $(CATMAN)
  2012. + 
  2013.   lint:           $(SRCS)
  2014.           lint $(LINTFLAGS) $(SRCS) > lint.out
  2015.   
  2016. ***************
  2017. *** 54,63 ****
  2018.   statist: statist.o lz.o
  2019.           $(CC) $(CFLAGS) $(LDFLAGS) -o statist statist.o lz.o $(LIBS)
  2020.   
  2021. ! clean:;         rm -f *.o *.b .,* core *.out $(PROGRAM) statist
  2022.   
  2023. ! install:        $(DEST)/$(PROGRAM) $(MANDEST)/$(MAN)
  2024.   
  2025.   patch:;         rm -f patch.out
  2026.           -for i in ../distribution/* ; do \
  2027.           (diff -c $$i `basename $$i` >> patch.out); \
  2028. --- 61,73 ----
  2029.   statist: statist.o lz.o
  2030.           $(CC) $(CFLAGS) $(LDFLAGS) -o statist statist.o lz.o $(LIBS)
  2031.   
  2032. ! clobber:        clean
  2033. !         rm -f $(PROGRAM) statist *.man
  2034.   
  2035. ! clean:;         rm -f *.o *.b .,* core *.out
  2036.   
  2037. + install:        $(DEST)/$(PROGRAM) $(MANDEST)/freeze.1 $(MANDEST)/statist.1
  2038. + 
  2039.   patch:;         rm -f patch.out
  2040.           -for i in ../distribution/* ; do \
  2041.           (diff -c $$i `basename $$i` >> patch.out); \
  2042. ***************
  2043. *** 64,81 ****
  2044.           done
  2045.   
  2046.   $(DEST)/$(PROGRAM): $(PROGRAM)
  2047. !         install -s -c $(PROGRAM) $(DEST)
  2048. !         ln -f $(DEST)/$(PROGRAM) $(DEST)/melt
  2049. !         ln -f $(DEST)/$(PROGRAM) $(DEST)/fcat
  2050.   
  2051. ! $(MANDEST)/$(MAN): $(CATMAN)
  2052. !         cp $(CATMAN) $(MANDEST)/$(MAN)
  2053. !         chmod +r $(MANDEST)/$(MAN)
  2054. !         ln -f $(MANDEST)/$(MAN) $(MANDEST)/melt.1
  2055. !         ln -f $(MANDEST)/$(MAN) $(MANDEST)/fcat.1
  2056.   
  2057. ! $(CATMAN):      $(MAN)
  2058. !         nroff -man < $(MAN) > $(CATMAN)
  2059.   
  2060.   ###
  2061.   bitio.o: freeze.h compat.h bitio.h
  2062. --- 74,94 ----
  2063.           done
  2064.   
  2065.   $(DEST)/$(PROGRAM): $(PROGRAM)
  2066. !         -strip $(PROGRAM)
  2067. !         -mcs -d $(PROGRAM)
  2068. !         install -m 755 $(PROGRAM) $(DEST)
  2069. !         -ln -f $@ $(DEST)/melt
  2070. !         -ln -f $@ $(DEST)/fcat
  2071.   
  2072. ! $(MANDEST)/freeze.1: freeze.man
  2073. !         cp freeze.man $@
  2074. !         chmod +r $@
  2075. !         -ln -f $@ $(MANDEST)/melt.1
  2076. !         -ln -f $@ $(MANDEST)/fcat.1
  2077.   
  2078. ! $(MANDEST)/statist.1: statist.man
  2079. !         cp statist.man $@
  2080. !         chmod +r $@
  2081.   
  2082.   ###
  2083.   bitio.o: freeze.h compat.h bitio.h
  2084. diff -cr ../orig/patchlevel.h ./patchlevel.h
  2085. *** ../orig/patchlevel.h    Sun Nov 24 00:09:24 1991
  2086. --- ./patchlevel.h    Sun Nov 24 00:29:56 1991
  2087. ***************
  2088. *** 1,2 ****
  2089. ! #define PATCHLEVEL 0
  2090. ! #define PATCHDATE "11/1/91"
  2091. --- 1,2 ----
  2092. ! #define PATCHLEVEL 1
  2093. ! #define PATCHDATE "11/20/91"
  2094. diff -cr ../orig/statist.c ./statist.c
  2095. *** ../orig/statist.c    Sun Nov 24 00:09:25 1991
  2096. --- ./statist.c    Sun Nov 24 00:22:20 1991
  2097. ***************
  2098. *** 11,17 ****
  2099.   
  2100.   #define update(c) (freq[c]++)
  2101.   
  2102. ! long in_count, bytes_out;
  2103.   
  2104.   long indc_count;
  2105.   short reduceflag = 0, greedy = 0;
  2106. --- 11,17 ----
  2107.   
  2108.   #define update(c) (freq[c]++)
  2109.   
  2110. ! long in_count, refers = 0;
  2111.   
  2112.   long indc_count;
  2113.   short reduceflag = 0, greedy = 0;
  2114. ***************
  2115. *** 18,27 ****
  2116.   
  2117.   int lens[F2+1];
  2118.   
  2119. ! u_short bits[9];
  2120.   
  2121.   short   prnt[T];
  2122. ! unsigned long freq[T];
  2123.   short used[T];
  2124.   
  2125.   void freeze(), StartHuff();
  2126. --- 18,27 ----
  2127.   
  2128.   int lens[F2+1];
  2129.   
  2130. ! us_t bits[9];
  2131.   
  2132.   short   prnt[T];
  2133. ! ul_t freq[T];
  2134.   short used[T];
  2135.   
  2136.   void freeze(), StartHuff();
  2137. ***************
  2138. *** 35,50 ****
  2139.       argv++;
  2140.       while (argc > 1) {
  2141.           if (**argv == '-') {
  2142. !             if ((*argv)[1] == 'g') {
  2143. !                 argc--; argv++;
  2144.                   greedy++;
  2145. !             } else
  2146. !                 break;
  2147.           } else
  2148.               break;
  2149.       }
  2150.       if(argc != 1) {
  2151. !         fprintf(stderr, "Usage: statist [-g] < sample_file\n");
  2152.           fprintf(stderr, "Press INTR to display current values\n");
  2153.           exit(0);
  2154.       }
  2155. --- 35,51 ----
  2156.       argv++;
  2157.       while (argc > 1) {
  2158.           if (**argv == '-') {
  2159. !             while (*++(*argv) == 'g')
  2160.                   greedy++;
  2161. !             if (**argv)
  2162. !                 goto usage;
  2163. !             argc--; argv++;
  2164.           } else
  2165.               break;
  2166.       }
  2167. +     usage:
  2168.       if(argc != 1) {
  2169. !         fprintf(stderr, "Usage: statist [-g...] < sample_file\n");
  2170.           fprintf(stderr, "Press INTR to display current values\n");
  2171.           exit(0);
  2172.       }
  2173. ***************
  2174. *** 59,75 ****
  2175.       return 0;
  2176.   }
  2177.   
  2178. ! unsigned long isqrt(val)
  2179. ! unsigned long val;
  2180.   {
  2181. !   unsigned long result = 0;
  2182. !   unsigned long side = 0;
  2183. !   unsigned long left = 0;
  2184.     int digit = 0;
  2185.     int i;
  2186. !   for (i=0; i<sizeof(unsigned long)*4; i++)
  2187.     {
  2188. !     left = (left << 2) + (val >> 30);
  2189.       val <<= 2;
  2190.       if (left >= side*2 + 1)
  2191.       {
  2192. --- 60,76 ----
  2193.       return 0;
  2194.   }
  2195.   
  2196. ! ul_t isqrt(val)
  2197. ! ul_t val;
  2198.   {
  2199. !   ul_t result = 0;
  2200. !   ul_t side = 0;
  2201. !   ul_t left = 0;
  2202.     int digit = 0;
  2203.     int i;
  2204. !   for (i=0; i<sizeof(ul_t)*4; i++)
  2205.     {
  2206. !     left = (left << 2) + (val >> (sizeof(ul_t) * 8 - 2));
  2207.       val <<= 2;
  2208.       if (left >= side*2 + 1)
  2209.       {
  2210. ***************
  2211. *** 99,107 ****
  2212.   void
  2213.   #endif
  2214.   giveres() {
  2215. !     u_short c;
  2216.       register int i, j, k, pr, f, average, sum;
  2217. !     unsigned long cumul, sigma2;
  2218.       short r, percent;
  2219.       signal(SIGINT, giveres);
  2220.       newtry:
  2221. --- 100,108 ----
  2222.   void
  2223.   #endif
  2224.   giveres() {
  2225. !     us_t c;
  2226.       register int i, j, k, pr, f, average, sum;
  2227. !     ul_t cumul, sigma2;
  2228.       short r, percent;
  2229.       signal(SIGINT, giveres);
  2230.       newtry:
  2231. ***************
  2232. *** 126,132 ****
  2233.               bits[j]++;
  2234.           if (j < pr)
  2235.               f += pr - j;
  2236. !         pr = j;
  2237.       }
  2238.   
  2239.       k = bits[1] + bits[2] + bits[3] + bits[4] +
  2240. --- 127,134 ----
  2241.               bits[j]++;
  2242.           if (j < pr)
  2243.               f += pr - j;
  2244. !         else
  2245. !             pr = j;
  2246.       }
  2247.   
  2248.       k = bits[1] + bits[2] + bits[3] + bits[4] +
  2249. ***************
  2250. *** 162,168 ****
  2251.       }
  2252.       sum = 0; cumul = 0;
  2253.       for(i = 3; i <= F2; i++) {
  2254. !         cumul += (unsigned long) i * lens[i];
  2255.           sum += lens[i];
  2256.       }
  2257.       sum || sum++;
  2258. --- 164,170 ----
  2259.       }
  2260.       sum = 0; cumul = 0;
  2261.       for(i = 3; i <= F2; i++) {
  2262. !         cumul += (ul_t) i * lens[i];
  2263.           sum += lens[i];
  2264.       }
  2265.       sum || sum++;
  2266. ***************
  2267. *** 187,196 ****
  2268.           }
  2269.       }
  2270.       for (sigma2 = 0, i = 3; i <= F2; i++)
  2271. !         sigma2 += (unsigned long)(i - average)*(i - average)*lens[i];
  2272.       sigma2 = sigma2 * 100 / sum;
  2273.       j = (int)isqrt(sigma2);
  2274.       printf("Sigma: %d.%1d\n", j / 10, j % 10);
  2275.       fflush(stdout);
  2276.   }
  2277.   
  2278. --- 189,199 ----
  2279.           }
  2280.       }
  2281.       for (sigma2 = 0, i = 3; i <= F2; i++)
  2282. !         sigma2 += (ul_t)(i - average)*(i - average)*lens[i];
  2283.       sigma2 = sigma2 * 100 / sum;
  2284.       j = (int)isqrt(sigma2);
  2285.       printf("Sigma: %d.%1d\n", j / 10, j % 10);
  2286. +     printf("References: %ld\n", refers);
  2287.       fflush(stdout);
  2288.   }
  2289.   
  2290. ***************
  2291. *** 197,203 ****
  2292.   
  2293.   void freeze ()
  2294.   {
  2295. !     register u_short i, len, r, s;
  2296.       register short c;
  2297.       StartHuff(0);
  2298.       InitTree();
  2299. --- 200,206 ----
  2300.   
  2301.   void freeze ()
  2302.   {
  2303. !     register us_t i, len, r, s;
  2304.       register short c;
  2305.       StartHuff(0);
  2306.       InitTree();
  2307. ***************
  2308. *** 211,216 ****
  2309. --- 214,220 ----
  2310.       for (i = 0; i <= F2; i++)
  2311.           InsertNode(r + i - F2);
  2312.       while (len != 0) {
  2313. +         match_length = THRESHOLD;
  2314.           Get_Next_Match(r,1);
  2315.           if (match_length > len)
  2316.               match_length = len;
  2317. ***************
  2318. *** 218,226 ****
  2319.               match_length = 1;
  2320.           } else if (greedy) {
  2321.               lens[match_length] ++;
  2322. !             update((u_short)match_position >> 7);
  2323.           } else {
  2324. !             register u_short orig_length, orig_position;
  2325.               orig_length = match_length;
  2326.               orig_position = match_position;
  2327.               DeleteNode(s);
  2328. --- 222,231 ----
  2329.               match_length = 1;
  2330.           } else if (greedy) {
  2331.               lens[match_length] ++;
  2332. !             update((us_t)match_position >> 7);
  2333. !             refers ++;
  2334.           } else {
  2335. !             register us_t orig_length, orig_position;
  2336.               orig_length = match_length;
  2337.               orig_position = match_position;
  2338.               DeleteNode(s);
  2339. ***************
  2340. *** 229,240 ****
  2341.               if (match_length > len) match_length = len;
  2342.               if (orig_length > match_length) {
  2343.                   lens[orig_length] ++;
  2344. !                 update((u_short)orig_position >> 7);
  2345.                   match_length = orig_length - 1;
  2346.               } else  {
  2347.                   lens[match_length] ++;
  2348.                   update(match_position >> 7);
  2349.               }
  2350.           }
  2351.           for (i = 0; i < match_length &&
  2352.                   (c = getchar()) != EOF; i++) {
  2353. --- 234,246 ----
  2354.               if (match_length > len) match_length = len;
  2355.               if (orig_length > match_length) {
  2356.                   lens[orig_length] ++;
  2357. !                 update((us_t)orig_position >> 7);
  2358.                   match_length = orig_length - 1;
  2359.               } else  {
  2360.                   lens[match_length] ++;
  2361.                   update(match_position >> 7);
  2362.               }
  2363. +             refers ++;
  2364.           }
  2365.           for (i = 0; i < match_length &&
  2366.                   (c = getchar()) != EOF; i++) {
  2367. exit 0 # Just in case...
  2368. exit 0 # Just in case...
  2369.