Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2218

Internet Message Format | 1990-12-28 | 49.8 KB

From: [e-mail] (Wm E Davidsen Jr)
Newsgroups: alt.sources
Subject: lharc for unix (02/02)
Message-ID: <[e-mail]>
Date: 6 Dec 90 15:03:45 GMT

#!/bin/sh
# this is part 2 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file lharc.c continued
#
CurArch=2
if test ! -r s2_seq_.tmp
then echo "Please unpack part 1 first!"
     exit 1; fi
( read Scheck
  if test "$Scheck" != $CurArch
  then echo "Please unpack part $Scheck next!"
       exit 1;
  else exit 0; fi
) < s2_seq_.tmp || exit 1
echo "x - Continuing file lharc.c"
sed 's/^X//' << 'SHAR_EOF' >> lharc.c
X    } else {
X      fseek (fp, hdr.packed_size, SEEK_CUR);
X    }
X    }
X
X  fclose (fp);
X
X  return;
X}
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*----------------------------------------------------------------------*/
X
Xextern int encode_lzhuf ();
Xextern int encode_storerd_crc ();
X
Xappend_one (fp, nafp, hdr)
X     FILE *fp, *nafp;
X     LzHeader *hdr;
X{
X  long    header_pos, next_pos, org_pos, data_pos;
X  long    v_original_size, v_packed_size;
X
X  reading_filename = hdr->name;
X  writting_filename = temporary_name;
X
X  org_pos = ftell (fp);
X  header_pos = ftell (nafp);
X  write_header (nafp, hdr);    /* DUMMY */
X
X  if (hdr->original_size == 0)
X    {
X      printf("%s - not frozen\n",hdr->name);
X      return;        /* previous write_header is not DUMMY. (^_^) */
X    }
X
X  data_pos = ftell (nafp);
X  hdr->crc = encode_lzhuf (fp, nafp, hdr->original_size,
X               &v_original_size, &v_packed_size, hdr->name);
X  if (v_packed_size < v_original_size)
X    {
X      next_pos = ftell (nafp);
X    }
X  else
X    {                /* retry by stored method */
X      fseek (fp, org_pos, SEEK_SET);
X      fseek (nafp, data_pos, SEEK_SET);
X      hdr->crc = encode_stored_crc (fp, nafp, hdr->original_size,
X                    &v_original_size, &v_packed_size);
X      fflush (nafp);
X      next_pos = ftell (nafp);
X      ftruncate (fileno (nafp), next_pos);
X      bcopy (LZHUFF0_METHOD, hdr->method, METHOD_TYPE_STRAGE);
X    }
X  hdr->original_size = v_original_size;
X  hdr->packed_size = v_packed_size;
X  fseek (nafp, header_pos, SEEK_SET);
X  write_header (nafp, hdr);
X  fseek (nafp, next_pos, SEEK_SET);
X}
X
Xwrite_tail (nafp)
X     FILE *nafp;
X{
X  putc (0x00, nafp);
X}
X
Xcopy_old_one (oafp, nafp, hdr)
X     FILE *oafp, *nafp;
X     LzHeader *hdr;
X{
X  if (noexec)
X    {
X      fseek (oafp, (long)(hdr->header_size + 2) + hdr->packed_size, SEEK_CUR);
X    }
X  else
X    {
X      reading_filename = archive_name;
X      writting_filename = temporary_name;
X      copy_file (oafp, nafp, (long)(hdr->header_size + 2) + hdr->packed_size);
X    }
X}
X
X
XFILE *append_it (name, oafp, nafp)
X     char *name;
X     FILE *oafp, *nafp;
X{
X  LzHeader    ahdr, hdr;
X  FILE        *fp;
X  long        old_header;
X  int        cmp;
X  int        filec;
X  char        **filev;
X  int        i;
X
X  struct stat    v_stat;
X  boolean    directory;
X
X  /* check that any added name is not the same as the archive name */
X  if (strcmp(name, archive_name) == 0) return oafp;
X
X  if (!delete_from_archive)
X    if (stat (name, &v_stat) < 0)
X      {
X        message ("Error:", name);
X        return oafp;
X      }
X
X  directory = ((v_stat.st_mode & S_IFMT) == S_IFDIR);
X
X  init_header (name, &v_stat, &hdr);
X
X  if (!delete_from_archive && !directory && !noexec)
X    fp = xfopen (name, RMODE);
X
X  while (oafp)
X    {
X      old_header = ftell (oafp);
X      if (!get_header (oafp, &ahdr))
X    {
X      fclose (oafp);
X      oafp = NULL;
X      break;
X    }
X      else
X    {
X      cmp = STRING_COMPARE (ahdr.name, hdr.name);
X      if (cmp < 0)
X        {        /* SKIP */
X          fseek (oafp, old_header, SEEK_SET);
X          copy_old_one (oafp, nafp, &ahdr);
X        }
X      else if (cmp == 0)
X        {        /* REPLACE */
X          fseek (oafp, ahdr.packed_size, SEEK_CUR);
X          break;
X        }
X      else        /* cmp > 0, INSERT */
X        {
X          fseek (oafp, old_header, SEEK_SET);
X          break;
X        }
X    }
X    }
X
X  if (delete_from_archive)
X    {
X      if (noexec)
X        fprintf (stderr, "DELETE %s\n", name);
X      else
X        printf ("%s - Deleted\n", name);
X    }
X  else
X    {
X      if ( !oafp || (cmp > 0) || !update_if_newer
X           || (ahdr.unix_last_modified_stamp < hdr.unix_last_modified_stamp) )
X    {
X      if (noexec)
X        fprintf (stderr, "APPEND %s\n", name);
X          else
X#ifdef STRICT
X            if ( !directory )
X#endif
X              if ( !update_freshen || (cmp == 0) )
X                append_one (fp, nafp, &hdr);
X    }
X      else
X    {                    /* archive has old one */
X      fseek (oafp, old_header, SEEK_SET);
X      copy_old_one (oafp, nafp, &ahdr);
X    }
X
X      if (!directory)
X    {
X      if (!noexec)
X        fclose (fp);
X    }
X      else
X    {            /* recurcive call */
X      if (find_files (name, &filec, &filev))
X        {
X          for (i = 0; i < filec; i ++)
X        oafp = append_it (filev[i], oafp, nafp);
X          free_files (filec, filev);
X        }
X      return oafp;
X    }
X    }
X
X  return oafp;
X}
X
X
Xremove_it (name)
X     char *name;
X{
X  struct stat    v_stat;
X  int        i;
X  char        **filev;
X  int        filec;
X
X  if (stat (name, &v_stat) < 0)
X    {
X      fprintf (stderr, "Cannot access \"%s\".\n", name);
X      return;
X    }
X
X  if ((v_stat.st_mode & S_IFMT) == S_IFDIR)
X    {
X      if (!find_files (name, &filec, &filev))
X    {
X          fprintf (stderr, "Cannot open directory \"%s\".\n", name);
X      return;
X    }
X
X      for (i = 0; i < filec; i ++)
X    remove_it (filev[i]);
X
X      free_files (filec, filev);
X
X      if (noexec)
X        printf ("REMOVE DIR %s\n", name);
X      else if (rmdir (name) < 0)
X        fprintf (stderr, "Cannot remove directory \"%s\".\n", name);
X      else if (!quiet)
X        printf ("%s - Removed\n", name);
X    }
X  else
X    {
X      if (noexec)
X        printf ("REMOVE %s\n", name);
X      else if (unlink (name) < 0)
X        fprintf (stderr, "Cannot delete \"%s\".\n", name);
X      else if (!quiet)
X        printf ("%s - Removed\n", name);
X    }
X}
X
X#ifdef FASTCOPY
X#define BUFFER_SIZE 16384
X
X#ifndef O_BINARY
X#define O_BINARY 0
X#endif
X
Xcopy_archive(src, dst)
Xchar *src;
Xchar *dst;
X{
X  int ih, oh;
X  unsigned chunk;
X  char *buffer = (char *) rson;
X
X  printf ("Copying temp to archive ... ");
X
X  ih = open (src, O_RDONLY | O_BINARY);
X  if ( ih == -1 )
X    error(src);
X  oh = open (dst, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
X  if ( oh == -1 )
X    error(dst);
X
X  while ( (chunk = read(ih, buffer, BUFFER_SIZE)) > 0 )
X    if ( write(oh, buffer, chunk) != chunk )
X      error(dst);
X
X  close (ih);
X  close (oh);
X
X  printf("\b\b\b\b   \b\b\b\b.\n");
X}
X#endif
X
Xcmd_append ()
X{
X  LzHeader    ahdr;
X  FILE        *oafp, *nafp;
X  char        backup_archive_name [ FILENAME_LENGTH ];
X  char        new_archive_name_buffer [ FILENAME_LENGTH ];
X  char        *new_archive_name;
X  int        i;
X  long        old_header;
X  struct stat    v_stat;
X  boolean    old_archive_exist;
X
X  if (cmd_filec == 0)
X    return;
X
X  make_tmp_name (archive_name, temporary_name);
X
X  if ((oafp = fopen (archive_name, RMODE)) == NULL)
X    if (expand_archive_name (expanded_archive_name, archive_name))
X      {
X    errno = 0;
X        oafp = fopen (expanded_archive_name, RMODE);
X    archive_name = expanded_archive_name;
X      }
X
X  old_archive_exist = (oafp) ? TRUE : FALSE;
X  if (new_archive && oafp)
X    {
X      fclose (oafp);
X      oafp = NULL;
X    }
X
X  if (oafp && archive_is_msdos_sfx1 (archive_name))
X    {
X      skip_msdos_sfx1_code (oafp);
X      make_standard_archive_name (new_archive_name_buffer, archive_name);
X      new_archive_name = new_archive_name_buffer;
X    }
X  else
X    {
X      new_archive_name = archive_name;
X    }
X
X  errno = 0;
X  if (!noexec)
X    {
X      nafp = xfopen (temporary_name, WMODE);
X      remove_temporary_at_error = TRUE;
X    }
X
X  for (i = 0; i < cmd_filec; i ++)
X    oafp = append_it (cmd_filev[i], oafp, nafp);
X
X  if (oafp)
X    {
X      old_header = ftell (oafp);
X      while (get_header (oafp, &ahdr))
X    {
X      fseek (oafp, old_header, SEEK_SET);
X      copy_old_one (oafp, nafp, &ahdr);
X      old_header = ftell (oafp);
X    }
X      fclose (oafp);
X    }
X
X  if (!noexec)
X    {
X      write_tail (nafp);
X      fclose (nafp);
X    }
X
X  make_backup_name (backup_archive_name, archive_name);
X
X  if (!noexec && old_archive_exist)
X  {
X    unlink(backup_archive_name);
X
X    if (rename (archive_name, backup_archive_name) < 0)
X      error (archive_name);
X  }
X
X  if (!quiet && new_archive_name == new_archive_name_buffer)
X    {                /* warning at old archive is SFX */
X      printf ("New Archive File is \"%s\"\n", new_archive_name);
X    }
X
X  if (!noexec && rename (temporary_name, new_archive_name) < 0)
X    {
X      if (stat (temporary_name, &v_stat) < 0)
X    error (temporary_name);
X
X#ifdef FASTCOPY
X      copy_archive(temporary_name, archive_name);
X#else
X      oafp = xfopen (temporary_name, RMODE);
X      nafp = xfopen (archive_name, WMODE);
X      reading_filename = temporary_name;
X      writting_filename = archive_name;
X      copy_file (oafp, nafp, (long)v_stat.st_size);
X      fclose (nafp);
X      fclose (oafp);
X#endif
X
X      unlink (temporary_name);
X    }
X  remove_temporary_at_error = FALSE;
X
X  if (delete_after_append)
X    {
X      if (!quiet && !noexec)
X    printf ("Erasing...\n");
X      for (i = 0; i < cmd_filec; i ++)
X    remove_it (cmd_filev[i]);
X    }
X
X  return;
X}
X
X/* XENIX kludges */
X#ifdef M_XENIX
Xrename(old, new)
Xchar *old, *new;
X{
X    char cmd[256];
X
X    sprintf(cmd, "/bin/mv %s %s", old, new);
X    system(cmd);
X}
X#endif    /* XENIX */
SHAR_EOF
echo "File lharc.c is complete"
chmod 0666 lharc.c || echo "restore of lharc.c fails"
echo "x - extracting lharc.doc (Text)"
sed 's/^X//' << 'SHAR_EOF' > lharc.doc &&
X------------------------------------------------------------------------------
X            LHarc UNIX  Release #3  V0.03 beta version
X            Copyright (C) 1989  Yooichi.Tagawa
X
X                        cl mj
X                        zoMIX ID: y.tagawa
X------------------------------------------------------------------------------
X    1Lv
X
X    UNIX EL LHarc p
X
X
X    H    :AAIfgH"),hAUNIX E LHarc (LHarc UNIX) p LHarc F
X    *5\7B
X
X
Xyg"{z
X    lharc {axevludmcp}[qnft] archive_file [files or directories...]
X
X    R}hMAaxevludmcp L"Cj)PFBpwh5\7B(H*s    B)
X    IvVM qnft )gp"-BE`wh    B\E7B
X    (H*    B\B3
X
X
XyA[JCut@C<z
X    wh5=t@C<Lt@C*H/jNA.lzh pt@C<LckIt
X        A5D5\7B5=*AD;Lj
X    AIKhM h\9q*A    ^pcATtBbNXF5D .lzh Ij7
X    iL*G")F]\5")Fv"\7B
X    .com (fQ .exe LTbtBNXLj
X    3j= SFX ().W
X    5\7B5)5ALHarc UNIX EMASFX `.Lt@Cp
X    ME+\9qBSFX `.LA[JCut@CIN5DG    A/
X    =j
X
X
X
XyR}hjz
X    a        A[JCut@CIwh5=t@CpG    A
X        fBNg
X        WD
X    x \=M e    A[JCut@CL)gwh5=t@C)7WDLt@
X        Cp
X    v \=M l    A[JCut@C`I
X        WDLt@CLjp\&5\7Bl Lj
X        qpoM5\7B
X    u        wh5=t@C*A[JCut@C`I
X        CfhV5")AA[JCut@C`I
X        jN
X    d        A[JCut@CL)gwh5=t@Cp
X    m        A[JCut@CIwh5=t@Cp
X        5=t@Cp
X    c        A[JCut@CL`epj
X        p
X    p        A[JCut@CL)gwh5=t@C)7WDL`e
X        pW
X
XyIvVjz
X    q        bZ[WL}'p
X    n        @
X    f
X    t        eLXg[hBMS-DOS EELeLXgt@CL    |
X        O
X        dl*Omi)`5j\9qB)
X
X
Xy]
X    MS-DOS LHarc V1.13c ( i"MA;jHO) E
X    CF]
X    Z[W*oi)`5j\9qB
X    LHarc UNIX E
X    h*
X
X
XyzzKhz
X    H    :LpEA
X
X    1.
X    2.  zz`eIB"DMA
X        a.  zzL
X        v
X
X        gppS7i1FB
X        b.  LHarc IN7it    A    ?l*t/gjD
X        jg`E+i>/
X        t    A    ?l*t/gjD"i1Fp>&5=hLgppS
X        7i1FB
X        c.  oCi
X    3.
X    4.  1Lv
X        X5H"B
X    5.
X            mH"B
X    6.  1Lv
X        p5D`)\mH"B1Lj
X        H-ALHarc F<fADM"/H"B
X    7.  $pI
X        F_iB
X        a.    1Lv
X        b.    $pL
X        =j
X        c.    CXg[LhiF5Dgp7ij
X        $1Fp
X        \=A;LF+L9
X        d.    $ppt    A    ?lF5D
X        $pRMA;LT|[gp
X
X
Xy
X    LZHUF @L
X    ;jp Nifty IP    n5A\=ALArc L
X    1jgLvv)g LZHUF @yQAMS-DOS E LHarc p
X    A
X    N
X    qI
X
X
X
XGL V0.03:
X    *    1.  quiet F text_mode LIvVpt/D]\5=B
X        text_mode LIvVMAdl*Omi)`5j\9qLE
X        5DgAD->3"B
X    2.  G    [bZ[W*sKXH* i)`5j\9qB
X    +    3.
X        1qH`qE""LE5e$)B(^_^)
X    +    4.  TufBNg
X        A[JCut@CIG    ALbhpFhL<-1F*E+\5=B
X    *    5.  3k/W
X        E7B LArc type 4 yQAtype 5 I`N    5\5=B
X    *    6.  MS-DOS ELZtGNXg    NgLA[JCu`.`    p
X        $I5\5=B
X    7.  MS-DOS E V1.13c LA[JCut@C* [MS-DOS] EH-A
X        [generic] IHh\7*AMS-DOS ELLE =h(\*))gM
X        [MS-DOS] FF/E+itH[}bgIHAD"iFv"\7B(^_^)
X    8.  MS-DOS E V1.13c ELTufBNg
X        W
X    9.  {M VAX 11/785 UNIX 4.2BSD E
X        (`FbNRj* i)`5j\9q)
X    +    10. d66)Fv"\7*AMS-DOS <--> UNIX
X        L]MoCi
X    *    11. System-V VLZApeUI
X    *    12. v F l R}hL\&`TLO
X    *    13. lzhuf.c )g @mK6pMT+\5=B(Fv$)
X
XGL V0.02:
X    1.  verbose/quiet/text_mode option M\>"E7B
X    2.  G    [bZ[W*sKXH* i)`5j\9qB
X    *    3.
X        1qH`qE""LE5e$)B(^_^)
X    *    4.  TufBNg
X        A[JCut@CIG    ALbhpFhL<-1F*E+\5=B
X    5.  3k/W
X        >Fv"\7B
X    6.  ;
X        5D"\9qB
X    7.  MS-DOS E V1.13c LA[JCut@C* [MS-DOS] EH-A
X        [generic] IHh\7*AMS-DOS ELLE =h(\*))gM
X        [MS-DOS] FF/E+itH[}bgIHAD"iFv"\7B(^_^)
X    8.  MS-DOS E V1.13c ELTufBNg
X        W
X    9.  {M vax 11/785 UNIX 4.2BSD E
X        (`FbNRj* i)`5j\9q)
X    *    10. d66)Fv"\7*AMS-DOS <--> UNIX
X        L]MoCi
X
XGL V0.01:
X    1.  verbose/quiet/text_mode option M\>"E7B
X    2.  G    [bZ[W*sKXH* i)`5j\9qB
X    3.
X    4.  TufBNg
X    5.  3k/W
X        >Fv"\7B
X    6.  ;
X        5D"\9qB
X    7.  MS-DOS E V1.13c LA[JCut@C* [MS-DOS] EH-A
X        [generic] IHh\7*AMS-DOS ELLE =h(\*))gM
X        [MS-DOS] FF/E+itH[}bgIHAD"iFv"\7B(^_^)
X    8.  MS-DOS E V1.13c ELTufBNg
X        W
X    9.  {M vax 11/785 UNIX 4.2BSD E
X        (`FbNRj* i)`5j\9q)
X
X
X------------------------------------------------------------------------------
SHAR_EOF
chmod 0666 lharc.doc || echo "restore of lharc.doc fails"
echo "x - extracting lhdir.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lhdir.c &&
X/*----------------------------------------------------------------------*/
X/*        Directory access routine for LHarc UNIX            */
X/*                                    */
X/*        Copyright(C) MCMLXXXIX  Yooichi.Tagawa            */
X/*                                    */
X/*    Emulate opendir(),readdir(),closedir() function for LHarc    */
X/*                                    */
X/*  V0.00  Original                1988.05.31  Y.Tagawa    */
X/*  V0.03  Release #3 for LHarc UNIX        1988.07.02  Y.Tagawa    */
X/*----------------------------------------------------------------------*/
X
X
X#include <sys/types.h>
X
X/* Where is O_RDONLY ? (^_^) */
X#include <sys/file.h>
X#ifndef O_RDONLY
X#include <fcntl.h>
X#endif
X
X#define direct old_direct
X#include <sys/dir.h>
X#undef direct
X
X#include "lhdir.h"
X
XDIR *opendir (name)
X     char *name;
X{
X  register DIR *dirp;
X  register int fd;
X  if ((fd = open (name, O_RDONLY)) >= 0)
X    {
X      if ((dirp = (DIR*)malloc (sizeof (DIR))) != (DIR*)0)
X    {
X      dirp->dd_fd = fd;
X      dirp->dd_loc = 0;
X      dirp->dd_size = 0;
X      return dirp;
X    }
X
X      close (fd);
X    }
X
X  return (DIR*)0;
X}
X
Xstruct direct *readdir (dirp)
X     register DIR *dirp;
X{
X  static struct direct lhdir;
X  register struct old_direct *dp;
X
X  do {
X    if (dirp->dd_loc >= dirp->dd_size)
X      {
X    dirp->dd_loc = 0;
X    if ((dirp->dd_size = read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
X      return (struct direct *)0;
X      }
X
X    dp = (struct old_direct *)(dirp->dd_buf + dirp->dd_loc);
X
X    if (dirp->dd_loc + sizeof (struct old_direct) > dirp->dd_size)
X      return (struct direct *)0;
X
X    dirp->dd_loc += sizeof (struct old_direct);
X
X  } while (dp->d_ino == 0) ;
X
X  /* construct new format */
X  lhdir.d_ino = dp->d_ino;
X  strncpy (lhdir.d_name, dp->d_name, DIRSIZ);
X  lhdir.d_name[DIRSIZ] = '\0';
X  lhdir.d_namlen = strlen (lhdir.d_name);
X
X  return &lhdir;
X}
X
Xclosedir (dirp)
X     DIR *dirp;
X{
X  close (dirp->dd_fd);
X  free (dirp);
X}
X
SHAR_EOF
chmod 0600 lhdir.c || echo "restore of lhdir.c fails"
echo "x - extracting lhdir.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > lhdir.h &&
X/*----------------------------------------------------------------------*/
X/*        Directory access routine for LHarc UNIX            */
X/*                                    */
X/*        Copyright(C) MCMLXXXIX  Yooichi.Tagawa            */
X/*    Emulate opendir(),readdir(),closedir() function for LHarc    */
X/*                                    */
X/*  V0.00  Original                1988.05.31  Y.Tagawa    */
X/*  V0.03  Release #3 for LHarc UNIX        1988.07.02  Y.Tagawa    */
X/*----------------------------------------------------------------------*/
X
X
X/* DIRBLKSIZ must be sizeof (SYSTEM struct direct) * N   !!! */
X
X#ifndef DIRBLKSIZ
X#define DIRBLKSIZ    512
X#endif
X
Xstruct direct {
X  int    d_ino;
X  int    d_namlen;
X  char    d_name[256];
X};
X
Xtypedef struct {
X  int    dd_fd;
X  int    dd_loc;
X  int    dd_size;
X  char    dd_buf[DIRBLKSIZ];
X} DIR;
X
X
Xextern DIR *opendir ();
Xextern struct direct *readdir ();
Xextern closedir ();
X
SHAR_EOF
chmod 0600 lhdir.h || echo "restore of lhdir.h fails"
echo "x - extracting lhio.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lhio.c &&
X/*----------------------------------------------------------------------*/
X/*        File I/O module for LHarc UNIX                */
X/*                                    */
X/*        Copyright(C) MCMLXXXIX  Yooichi.Tagawa            */
X/*                                    */
X/*  V0.00  Original                1989.06.25  Y.Tagawa    */
X/*  V0.03  Release #3  Beta Version        1989.07.02  Y.Tagawa    */
X/*  V0.03a Fix few bugs                1989.07.04  Y.Tagawa    */
X/*----------------------------------------------------------------------*/
X
X#include <stdio.h>
X#include "lhio.h"
X
X#ifndef BUFFER_SIZE
X#define BUFFER_SIZE    16384
X#endif
X
X
Xextern int    text_mode;            /* in lharc.c */
XFILE            *crc_infile, *crc_outfile;      /* in lzhuf.c */
X
Xextern int rson[];
X
X/* These functions are NO-RETURN */
Xextern read_error ();
Xextern write_error ();
X
X
Xint        crc_getc_cashe;
Xunsigned int    crc_value;
Xunsigned int    crc_table[0x100];
Xlong        crc_size;
X
X
Xcrcsub (ptr, length)
X     char        *ptr;
X     register int    length;
X{
X  register unsigned char    *p;
X  register unsigned int        ctmp;
X
X  if (length != 0)
X    {
X      ctmp = crc_value;
X      p = (unsigned char*)ptr;
X      for (; length; length --)
X    {
X      ctmp ^= (unsigned int)*p++;
X      ctmp = (ctmp >> 8) ^ crc_table [ ctmp & 0xff ];
X    }
X      crc_value = ctmp;
X    }
X}
X
X#ifndef __GNUC__
Xvoid putc_crc (c)
X     int c;
X{
X  CRC_CHAR (c);
X  if (!text_mode || (c != 0x0d && c != 0x1a))
X    {
X      putc (c, crc_outfile);
X    }
X}
X
Xint getc_crc ()
X{
X  int    c;
X
X  if (crc_getc_cashe != EOF)
X    {
X      c = crc_getc_cashe;
X      crc_getc_cashe = EOF;
X      CRC_CHAR (c);
X      crc_size++;
X    }
X  else if ((c = getc (crc_infile)) != EOF)
X    {
X      if (text_mode && c == 0x0a)
X    {
X      crc_getc_cashe = c;
X      c = 0x0d;
X    }
X      CRC_CHAR (c);
X      crc_size++;
X    }
X  return c;
X}
X#endif
X
X
X
Xinit_crc ()
X{
X  static int        inited = 0;
X  register unsigned int    *p = crc_table;
X  register int        i, j;
X  register unsigned int    x;
X
X  if (!inited) {
X    for (j = 0; j < 256; j ++) {
X      x = j;
X      for (i = 0; i < 8; i ++) {
X    if ((x & 1) != 0) {
X      x = (x >> 1) ^ 0xa001;
X    } else {
X      x = (x >> 1);
X    }
X      }
X      *p ++ = x;
X    }
X    inited = 1;
X  }
X  crc_value = 0;
X  crc_getc_cashe = EOF;
X  crc_size = 0;
X}
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X/* if return value is -1, see errno */
Xcopy_binary_file (ifp, ofp, size, crc_flag)
X     FILE    *ifp, *ofp;
X     long    size;
X     int    crc_flag;    /* as boolean value */
X{
X  char *buffer = (char *) rson;
X  int read_size;
X  int n;
X
X  /* safty */
X  fflush (ofp);
X
X  while (size > 0)
X    {
X      read_size = ((size < (long)BUFFER_SIZE) ? (int)size : BUFFER_SIZE);
X
X      n = fread (buffer, sizeof (char), read_size, ifp);
X
X      if (n == 0)
X    read_error ();
X
X      if (fwrite (buffer, sizeof (char), n, ofp) < n)
X    write_error ();
X
X      if (crc_flag)
X    crcsub (buffer, n);
X
X      size -= (long)n;
X    }
X}
X
X/* read UNIX text file '0A' and write generic text file '0D0A' */
Xwrite_generic_text_file (ifp, ofp, size)
X     FILE    *ifp, *ofp;
X     long    size;
X{
X  char        buffer[BUFFER_SIZE];
X  int        read_size, write_count, n, m;
X  register char    *p, *p1, *e;
X
X  /* safty */
X  fflush (ofp);
X
X  write_count = 0;
X
X  while (size > 0)
X    {
X      read_size = ((size < BUFFER_SIZE) ? (int)size : BUFFER_SIZE);
X
X      n = fread (buffer, sizeof (char), read_size, ifp);
X
X      if (n == 0)
X    read_error ();
X
X      for (p1 = p = buffer, e = buffer + n; p < e; p++)
X    {
X      if (*p == '\n')
X        {
X          if ((m = p - p1) != 0)
X        {
X          if (fwrite (p1, sizeof (char), m, ofp) < m)
X            write_error ();
X          crcsub (p1, m);
X        }
X          putc (0x0d, ofp);
X          if (feof (ofp))
X        write_error ();
X          CRC_CHAR (0x0d);
X          p1 = p;
X          write_count ++;
X        }
X    }
X      if ((m = p - p1) != 0)
X    {
X      if (fwrite (p1, sizeof (char), m, ofp) < m)
X        write_error ();
X      crcsub (p1, m);
X    }
X
X      write_count += (long)n;
X      size -= (long)n;
X    }
X
X  crc_size = write_count;
X}
X
X/* read generic text file '0D0A' and write UNIX text file '0A' */
Xread_generic_text_file (ifp, ofp, size, crc_flag)
X     FILE    *ifp, *ofp;
X     long    size;
X     int    crc_flag;
X{
X  char        buffer[BUFFER_SIZE];
X  int        read_size, write_size, n, m;
X  register char *p, *p1, *e;
X
X  /* safty */
X  fflush (ofp);
X
X  while (size > 0)
X    {
X      read_size = ((size < BUFFER_SIZE) ? (int)size : BUFFER_SIZE);
X
X      n = fread (buffer, sizeof (char), read_size, ifp);
X
X      if (n == 0)
X    read_error ();
X
X      crcsub (buffer, n);
X
X      for (p1 = p = buffer, e = buffer + n; p < e; p ++)
X    {
X      if (*p == 0x0d)
X        {
X          if ((m = p - p1) != 0)
X        {
X          if (fwrite (p1, sizeof (char), m, ofp) < m)
X            write_error ();
X        }
X          p1 = p+1;
X        }
X    }
X      if ((m = p - p1) != 0)
X    {
X      if (fwrite (p1, sizeof (char), m, ofp) < m)
X        write_error ();
X    }
X
X      size -= (long)n;
X    }
X}
X
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X
Xcopy_file (ifp, ofp, size)
X     FILE    *ifp, *ofp;
X     long    size;
X{
X  copy_binary_file (ifp, ofp, size, 0);
X}
X
X/*ARGSUSED*/
Xint decode_stored_crc (ifp, ofp, original_size, name)
X     FILE    *ifp, *ofp;
X     long    original_size;
X     char    *name;
X{
X  init_crc ();
X
X  if (text_mode)
X    {
X      read_generic_text_file (ifp, ofp, original_size, 1);
X      return crc_value;
X    }
X  else
X    {
X      copy_binary_file (ifp, ofp, original_size, 1);
X      return crc_value;
X    }
X}
X
X/*ARGSUSED*/
Xint decode_stored_nocrc (ifp, ofp, original_size, name)
X     FILE    *ifp, *ofp;
X     long    original_size;
X     char    *name;
X{
X  if (text_mode)
X    {
X      read_generic_text_file (ifp, ofp, original_size, 0);
X      return 0;            /* DUMMY */
X    }
X  else
X    {
X      copy_binary_file (ifp, ofp, original_size, 0);
X    }
X  return 0;            /* DUMMY */
X}
X
Xint encode_stored_crc (ifp, ofp, size, original_size_var, write_size_var)
X     FILE       *ifp, *ofp;
X     long       size;
X     long    *original_size_var;
X     long    *write_size_var;
X{
X  init_crc ();
X
X  if (text_mode)
X    {
X      write_generic_text_file (ifp, ofp, size);
X      *original_size_var = *write_size_var = crc_size;
X      return crc_value;
X    }
X  else
X    {
X      copy_binary_file (ifp, ofp, size, 1);
X      *original_size_var = size;
X      *write_size_var = size;
X      return crc_value;
X    }
X}
SHAR_EOF
chmod 0666 lhio.c || echo "restore of lhio.c fails"
echo "x - extracting lhio.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > lhio.h &&
X/*----------------------------------------------------------------------*/
X/*        File I/O module for LHarc UNIX                */
X/*                                    */
X/*        Copyright(C) MCMLXXXIX  Yooichi.Tagawa            */
X/*                                    */
X/*  V0.00  Original                1989.06.25  Y.Tagawa    */
X/*  V0.03  Release #3  Beta Version        1989.07.02  Y.Tagawa    */
X/*----------------------------------------------------------------------*/
X
Xextern int        text_mode;
X
Xextern unsigned int    crc_table[0x100];
Xextern unsigned int    crc_value;
Xextern int        crc_getc_cashe;
Xextern FILE        *crc_infile, *crc_outfile;
Xextern long        crc_size;
X
X
X#define CRC_CHAR(c)                        \
X{ register unsigned int ctmp = crc_value ^ c;             \
X    crc_value = (ctmp >> 8) ^ crc_table [ ctmp & 0xff ]; }
X
X
X
X#if defined (__GNUC__)
X/*#define inlnie*/
X
X/* DECODING */
X/* '0D0A' -> '0A' conversion and strip '1A' when text_mode */
Xstatic inline putc_crc (int c)
X{
X  CRC_CHAR (c);
X  if (!text_mode || (c != 0x0d && c != 0x1a))
X    {
X      putc (c, crc_outfile);
X    }
X}
X
X/* ENCODING */
X/* '0A' -> '0D0A' conversion when text_mode */
Xstatic inline int getc_crc ()
X{
X  int    c;
X
X  if (crc_getc_cashe != EOF)
X    {
X      c = crc_getc_cashe;
X      crc_getc_cashe = EOF;
X      CRC_CHAR (c);
X      crc_size++;
X    }
X  else if ((c = getc (crc_infile)) != EOF)
X    {
X      if (text_mode && c == 0x0a)
X    {
X      crc_getc_cashe = c;
X      c = 0x0d;
X    }
X      CRC_CHAR (c);
X      crc_size++;
X    }
X  return c;
X}
X#endif
SHAR_EOF
chmod 0666 lhio.h || echo "restore of lhio.h fails"
echo "x - extracting lzhuf.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > lzhuf.c &&
X/*----------------------------------------------------------------------*/
X/*        lzhuf.c : Encoding/Decoding module for LHarc        */
X/*                                    */
X/*    LZSS Algorithm            Haruhiko.Okumura        */
X/*    Adaptic Huffman Encoding    1989.05.27  Haruyasu.Yoshizaki    */
X/*                                    */
X/*                                    */
X/*    Modified for UNIX LHarc V0.01    1989.05.28  Y.Tagawa        */
X/*    Modified for UNIX LHarc V0.02    1989.05.29  Y.Tagawa        */
X/*    Modified for UNIX LHarc V0.03    1989.07.02  Y.Tagawa        */
X/*----------------------------------------------------------------------*/
X
X/* Use ANSI sequences for using only one line per file but
X * indicator dots on next line */
X/* #define ANSI */
X
X#ifndef ANSI
X#define DOT       '.'
X#define BALL      'o'
X#else
X#define DOT       249
X#define BALL      3
X#define CURSORUP  "\033[A"
X#define ERASEEOL  "\033[K"
X#endif
X
X#include <stdio.h>
X
X#ifndef SELFMAIN
X#include "lhio.h"
X#else
X#define EXIT_SUCCESS    0
X#define EXIT_FAILURE    1
X#endif
X
X
X
XFILE *infile, *outfile;
Xlong textsize, codesize;
X
X
X#define INDICATOR_THRESHOLD    4096L
X#define MAX_INDICATOR_COUNT     78
Xlong indicator_count;
Xlong indicator_threshold;
X
X#ifdef SELFMAIN
Xint quiet = 0;
X#else
Xextern int quiet;
Xextern int output_to_test;
X#endif
X
X
X#ifdef SELFMAIN
X#define SETUP_PUTC_CRC(fp)    /* nothing */
X#define SETUP_GETC_CRC(fp)    /* nothing */
X#define PUTC_CRC(c)        putc((c),(outfile))
X#define GETC_CRC()        getc(infile)
X#define END_PUTC_CRC()
X#define END_GETC_CRC()
X#else
X#define SETUP_PUTC_CRC(fp)    crc_outfile = fp
X#define SETUP_GETC_CRC(fp)    crc_infile = fp
X#define PUTC_CRC(c)        putc_crc(c)
X#define GETC_CRC()        getc_crc()
X#define END_PUTC_CRC()
X#define END_GETC_CRC()
X#endif
X
X
X
X
X#ifdef SELFMAIN
Xvoid Error (message)
X    char *message;
X{
X    printf("\n%s\n", message);
X    exit(EXIT_FAILURE);
X}
X#endif
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*        LZSS ENCODING                        */
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X#define N        4096    /* buffer size */
X#define F        60    /* pre-sence buffer size */
X#define THRESHOLD    2
X#define NIL        N    /* term of tree */
X
Xunsigned char    text_buf[N + F - 1];
Xunsigned int     match_position, match_length;
Xint              lson[N + 1], rson[N + 1 + N], dad[N + 1];
Xunsigned char    same[N + 1];
X
X
X/* Initialize Tree */
XInitTree ()
X{
X    register int *p, *e;
X
X    for (p = rson + N + 1, e = rson + N + N; p <= e; )
X        *p++ = NIL;
X    for (p = dad, e = dad + N; p < e; )
X        *p++ = NIL;
X}
X
X
X/* Insert to node */
XInsertNode (r)
X    register int r;
X{
X    register int        p;
X    int            cmp;
X    register unsigned char    *key;
X    register unsigned int    c;
X    register unsigned int    i, j;
X
X    cmp = 1;
X    key = &text_buf[r];
X    i = key[1] ^ key[2];
X    i ^= i >> 4;
X    p = N + 1 + key[0] + ((i & 0x0f) << 8);
X    rson[r] = lson[r] = NIL;
X    match_length = 0;
X    i = j = 1;
X    for ( ; ; ) {
X        if (cmp >= 0) {
X            if (rson[p] != NIL) {
X                p = rson[p];
X                j = same[p];
X            } else {
X                rson[p] = r;
X                dad[r] = p;
X                same[r] = i;
X                return;
X            }
X        } else {
X            if (lson[p] != NIL) {
X                p = lson[p];
X                j = same[p];
X            } else {
X                lson[p] = r;
X                dad[r] = p;
X                same[r] = i;
X                return;
X            }
X        }
X
X        if (i > j) {
X            i = j;
X            cmp = key[i] - text_buf[p + i];
X        } else
X        if (i == j) {
X            for (; i < F; i++)
X                if ((cmp = key[i] - text_buf[p + i]) != 0)
X                    break;
X        }
X
X        if (i > THRESHOLD) {
X            if (i > match_length) {
X                match_position = ((r - p) & (N - 1)) - 1;
X                if ((match_length = i) >= F)
X                    break;
X            } else
X            if (i == match_length) {
X                if ((c = ((r - p) & (N - 1)) - 1) < match_position) {
X                    match_position = c;
X                }
X            }
X        }
X    }
X    same[r] = same[p];
X    dad[r] = dad[p];
X    lson[r] = lson[p];
X    rson[r] = rson[p];
X    dad[lson[p]] = r;
X    dad[rson[p]] = r;
X    if (rson[dad[p]] == p)
X        rson[dad[p]] = r;
X    else
X        lson[dad[p]] = r;
X    dad[p] = NIL;  /* remove p */
X}
X
X
Xlink (n, p, q)
X    int n, p, q;
X{
X    register unsigned char *s1, *s2, *s3;
X    if (p >= NIL) {
X        same[q] = 1;
X        return;
X    }
X    s1 = text_buf + p + n;
X    s2 = text_buf + q + n;
X    s3 = text_buf + p + F;
X    while (s1 < s3) {
X        if (*s1++ != *s2++) {
X            same[q] = s1 - 1 - text_buf - p;
X            return;
X        }
X    }
X    same[q] = F;
X}
X
X
Xlinknode (p, q, r)
X    int p, q, r;
X{
X    int cmp;
X
X    if ((cmp = same[q] - same[r]) == 0) {
X        link(same[q], p, r);
X    } else if (cmp < 0) {
X        same[r] = same[q];
X    }
X}
X
XDeleteNode (p)
X    register int p;
X{
X    register int  q;
X
X    if (dad[p] == NIL)
X        return;            /* has no linked */
X    if (rson[p] == NIL) {
X        if ((q = lson[p]) != NIL)
X            linknode(dad[p], p, q);
X    } else
X    if (lson[p] == NIL) {
X        q = rson[p];
X        linknode(dad[p], p, q);
X    } else {
X        q = lson[p];
X        if (rson[q] != NIL) {
X            do {
X                q = rson[q];
X            } while (rson[q] != NIL);
X            if (lson[q] != NIL)
X                linknode(dad[q], q, lson[q]);
X            link(1, q, lson[p]);
X            rson[dad[q]] = lson[q];
X            dad[lson[q]] = dad[q];
X            lson[q] = lson[p];
X            dad[lson[p]] = q;
X        }
X        link(1, dad[p], q);
X        link(1, q, rson[p]);
X        rson[q] = rson[p];
X        dad[rson[p]] = q;
X    }
X    dad[q] = dad[p];
X    if (rson[dad[p]] == p)
X        rson[dad[p]] = q;
X    else
X        lson[dad[p]] = q;
X    dad[p] = NIL;
X}
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*        HUFFMAN ENCODING                    */
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X#define N_CHAR      (256 - THRESHOLD + F) /* {code : 0 .. N_CHAR-1} */
X#define T         (N_CHAR * 2 - 1)    /* size of table */
X#define R         (T - 1)            /* root position */
X#define MAX_FREQ    0x8000    /* tree update timing from frequency */
X
Xtypedef unsigned char uchar;
X
X
X
X/* TABLE OF ENCODE/DECODE for upper 6bits position information */
X
X/* for encode */
Xuchar p_len[64] = {
X    0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
X    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
X};
X
Xuchar p_code[64] = {
X    0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x68,
X    0x70, 0x78, 0x80, 0x88, 0x90, 0x94, 0x98, 0x9C,
X    0xA0, 0xA4, 0xA8, 0xAC, 0xB0, 0xB4, 0xB8, 0xBC,
X    0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
X    0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
X    0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
X    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
X    0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
X};
X
X/* for decode */
Xuchar d_code[256] = {
X    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
X    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
X    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
X    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
X    0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
X    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
X    0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
X    0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
X    0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
X    0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
X    0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
X    0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
X    0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
X    0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B,
X    0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
X    0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
X    0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
X    0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
X    0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
X    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
X    0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
X};
X
Xuchar d_len[256] = {
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
X    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
X    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
X};
X
Xunsigned freq[T + 1];    /* frequency table */
X
Xint prnt[T + N_CHAR];    /* points to parent node */
X/* notes :
X   prnt[T .. T + N_CHAR - 1] used by
X   indicates leaf position that corresponding to code */
X
Xint son[T];              /* points to son node (son[i],son[i+]) */
X
Xunsigned getbuf = 0;
Xuchar getlen = 0;
X
X
X/* get one bit */
X/* returning in Bit 0 */
Xint GetBit ()
X{
X    register unsigned int dx = getbuf;
X    register unsigned int c;
X
X    if (getlen <= 8)
X        {
X            c = getc (infile);
X            if ((int)c < 0) c = 0;
X            dx |= c << (8 - getlen);
X            getlen += 8;
X        }
X    getbuf = dx << 1;
X    getlen--;
X    return (dx & 0x8000) ? 1 : 0;
X}
X
X/* get one byte */
X/* returning in Bit7...0 */
Xint GetByte ()
X{
X    register unsigned int dx = getbuf;
X    register unsigned c;
X
X    if (getlen <= 8) {
X        c = getc (infile);
X        if ((int)c < 0) c = 0;
X        dx |= c << (8 - getlen);
X        getlen += 8;
X    }
X    getbuf = dx << 8;
X    getlen -= 8;
X    return (dx >> 8) & 0xff;
X}
X
X/* get N bit */
X/* returning in Bit(N-1)...Bit 0 */
Xint GetNBits (n)
X    register unsigned int n;
X{
X    register unsigned int dx = getbuf;
X    register unsigned int c;
X    static int mask[17] = {
X        0x0000,
X        0x0001, 0x0003, 0x0007, 0x000f,
X        0x001f, 0x003f, 0x007f, 0x00ff,
X        0x01ff, 0x03ff, 0x07ff, 0x0fff,
X        0x1fff, 0x3fff, 0x0fff, 0xffff };
X    static int shift[17] = {
X        16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
X
X    if (getlen <= 8)
X        {
X            c = getc (infile);
X            if ((int)c < 0) c = 0;
X            dx |= c << (8 - getlen);
X            getlen += 8;
X        }
X    getbuf = dx << n;
X    getlen -= n;
X    return (dx >> shift[n]) & mask[n];
X}
X
Xunsigned putbuf = 0;
Xuchar putlen = 0;
X
X/* output C bits */
XPutcode (l, c)
X    register int l;
X    register unsigned int c;
X{
X    register len = putlen;
X    register unsigned int b = putbuf;
X    b |= c >> len;
X    if ((len += l) >= 8) {
X        putc (b >> 8, outfile);
X        if ((len -= 8) >= 8) {
X            putc (b, outfile);
X            codesize += 2;
X            len -= 8;
X            b = c << (l - len);
X        } else {
X            b <<= 8;
X            codesize++;
X        }
X    }
X    putbuf = b;
X    putlen = len;
X}
X
X
X/* Initialize tree */
X
XStartHuff ()
X{
X    register int i, j;
X
X    for (i = 0; i < N_CHAR; i++) {
X        freq[i] = 1;
X        son[i] = i + T;
X        prnt[i + T] = i;
X    }
X    i = 0; j = N_CHAR;
X    while (j <= R) {
X        freq[j] = freq[i] + freq[i + 1];
X        son[j] = i;
X        prnt[i] = prnt[i + 1] = j;
X        i += 2; j++;
X    }
X    freq[T] = 0xffff;
X    prnt[R] = 0;
X    putlen = getlen = 0;
X    putbuf = getbuf = 0;
X}
X
X
X/* reconstruct tree */
Xreconst ()
X{
X    register int i, j, k;
X    register unsigned f;
X
X    /* correct leaf node into of first half,
X       and set these freqency to (freq+1)/2       */
X    j = 0;
X    for (i = 0; i < T; i++) {
X        if (son[i] >= T) {
X            freq[j] = (freq[i] + 1) / 2;
X            son[j] = son[i];
X            j++;
X        }
X    }
X    /* build tree.  Link sons first */
X    for (i = 0, j = N_CHAR; j < T; i += 2, j++) {
X        k = i + 1;
X        f = freq[j] = freq[i] + freq[k];
X        for (k = j - 1; f < freq[k]; k--);
X        k++;
X        {    register unsigned *p, *e;
X            for (p = &freq[j], e = &freq[k]; p > e; p--)
X                p[0] = p[-1];
X            freq[k] = f;
X        }
X        {    register int *p, *e;
X            for (p = &son[j], e = &son[k]; p > e; p--)
X                p[0] = p[-1];
X            son[k] = i;
X        }
X    }
X    /* link parents */
X    for (i = 0; i < T; i++) {
X        if ((k = son[i]) >= T) {
X            prnt[k] = i;
X        } else {
X            prnt[k] = prnt[k + 1] = i;
X        }
X    }
X}
X
X
X/* update given code's frequency, and update tree */
X
Xupdate (c)
X    unsigned int    c;
X{
X    register unsigned *p;
X    register int i, j, k, l;
X
X    if (freq[R] == MAX_FREQ) {
X        reconst();
X    }
X    c = prnt[c + T];
X    do {
X        k = ++freq[c];
X
X        /* swap nodes when become wrong frequency order. */
X        if (k > freq[l = c + 1]) {
X            for (p = freq+l+1; k > *p++; ) ;
X            l = p - freq - 2;
X            freq[c] = p[-2];
X            p[-2] = k;
X
X            i = son[c];
X            prnt[i] = l;
X            if (i < T) prnt[i + 1] = l;
X
X            j = son[l];
X            son[l] = i;
X
X            prnt[j] = c;
X            if (j < T) prnt[j + 1] = c;
X            son[c] = j;
X
X            c = l;
X        }
X    } while ((c = prnt[c]) != 0);    /* loop until reach to root */
X}
X
X/* unsigned code, len; */
X
XEncodeChar (c)
X    unsigned c;
X{
X    register int *p;
X    register unsigned long i;
X    register int j, k;
X
X    i = 0;
X    j = 0;
X    p = prnt;
X    k = p[c + T];
X
X    /* trace links from leaf node to root */
X    do {
X        i >>= 1;
X
X        /* if node index is odd, trace larger of sons */
X        if (k & 1) i += 0x80000000;
X
X        j++;
X    } while ((k = p[k]) != R) ;
X    if (j > 16) {
X        Putcode(16, (unsigned int)(i >> 16));
X        Putcode(j - 16, (unsigned int)i);
X    } else {
X        Putcode(j, (unsigned int)(i >> 16));
X    }
X/*    code = i; */
X/*     len = j; */
X    update(c);
X}
X
XEncodePosition (c)
X    unsigned c;
X{
X    unsigned i;
X
X    /* output upper 6bit from table */
X    i = c >> 6;
X    Putcode((int)(p_len[i]), (unsigned int)(p_code[i]) << 8);
X
X    /* output lower 6 bit */
X    Putcode(6, (unsigned int)(c & 0x3f) << 10);
X}
X
XEncodeEnd ()
X{
X    if (putlen) {
X        putc(putbuf >> 8, outfile);
X        codesize++;
X    }
X}
X
Xint DecodeChar ()
X{
X    register unsigned c;
X
X    c = son[R];
X
X    /* trace from root to leaf,
X       got bit is 0 to small(son[]), 1 to large (son[]+1) son node */
X    while (c < T) {
X        c += GetBit();
X        c = son[c];
X    }
X    c -= T;
X    update(c);
X    return c;
X}
X
Xint DecodePosition ()
X{
X    unsigned i, j, c;
X
X    /* decode upper 6bit from table */
X    i = GetByte();
X    c = (unsigned)d_code[i] << 6;
X    j = d_len[i];
X
X    /* get lower 6bit */
X    j -= 2;
X    return c | (((i << j) | GetNBits (j)) & 0x3f);
X}
X
X
XEncode ()
X{
X    register int  i, c, len, r, s, last_match_length;
X
X    if (textsize == 0)
X        return;
X
X    textsize = 0;
X    StartHuff();
X    InitTree();
X    s = 0;
X    r = N - F;
X    for (i = s; i < r; i++)
X        text_buf[i] = ' ';
X    for (len = 0; len < F && (c = GETC_CRC()) != EOF; len++)
X        text_buf[r + len] = c;
X    textsize = len;
X    for (i = 1; i <= F; i++)
X        InsertNode(r - i);
X    InsertNode(r);
X    do {
X        if (match_length > len)
X            match_length = len;
X        if (match_length <= THRESHOLD) {
X            match_length = 1;
X            EncodeChar(text_buf[r]);
X        } else {
X            EncodeChar(255 - THRESHOLD + match_length);
X            EncodePosition(match_position);
X        }
X        last_match_length = match_length;
X        for (i = 0; i < last_match_length &&
X                (c = GETC_CRC()) != EOF; i++) {
X            DeleteNode(s);
X            text_buf[s] = c;
X            if (s < F - 1)
X                text_buf[s + N] = c;
X            s = (s + 1) & (N - 1);
X            r = (r + 1) & (N - 1);
X            InsertNode(r);
X        }
X
X        textsize += i;
X        if ((textsize > indicator_count) && !quiet) {
X            putchar (BALL);
X            fflush (stdout);
X            indicator_count += indicator_threshold;
X        }
X        while (i++ < last_match_length) {
X            DeleteNode(s);
X            s = (s + 1) & (N - 1);
X            r = (r + 1) & (N - 1);
X            if (--len) InsertNode(r);
X        }
X    } while (len > 0);
X    EncodeEnd();
X    END_GETC_CRC ();
X}
X
XDecode ()
X{
X    register int    i, j, k, r, c;
X    register long    count;
X
X#ifdef SELFMAIN
X    if (textsize == 0)
X        return;
X#endif
X    StartHuff();
X    for (i = 0; i < N - F; i++)
X        text_buf[i] = ' ';
X    r = N - F;
X    for (count = 0; count < textsize; ) {
X        c = DecodeChar();
X        if (c < 256) {
X            PUTC_CRC (c);
X            text_buf[r++] = c;
X            r &= (N - 1);
X            count++;
X        } else {
X            i = (r - DecodePosition() - 1) & (N - 1);
X            j = c - 255 + THRESHOLD;
X            for (k = 0; k < j; k++) {
X                c = text_buf[(i + k) & (N - 1)];
X                PUTC_CRC (c);
X                text_buf[r++] = c;
X                r &= (N - 1);
X                count++;
X            }
X        }
X
X        if (!quiet && (count > indicator_count)) {
X            putchar (BALL);
X            fflush (stdout);
X            indicator_count += indicator_threshold;
X        }
X    }
X    END_PUTC_CRC ();
X}
X
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*        LARC                            */
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X#define F_OLD    18    /* look ahead buffer size for LArc */
X
X/* intialize buffer for LArc type 5 */
XInitBuf ()
X{
X    register unsigned char *p = text_buf;
X    register int i, j;
X    for (i = 0; i < 256; i ++)
X        for (j = 0; j < 13; j ++)
X            *p ++ = i;
X    for (i = 0; i < 256; i ++)
X        *p ++ = i;
X    for (i = 0; i < 256; i ++)
X        *p ++ = 255 - i;
X    for (i = 0; i < 128; i ++)
X        *p ++ = 0;
X    for (i = 0; i < 128; i ++)
X        *p ++ = 0x20;
X}
X
X/* Decode LArc type 5 */
XDecodeOld ()
X{
X    register int si, di;
X    register long count;
X    int    dl, dh, al, cx;
X    if (textsize == 0)
X        return;
X
X    InitBuf ();
X    di = N - F_OLD;
X    dl = 0x80;
X
X    for (count = 0; count < textsize; ) {
X        dl = ((dl << 1) | (dl >> 7)) & 0xff;
X        if (dl & 0x01)
X            dh = getc (infile);
X        al = getc (infile);
X        if ((dh & dl) != 0) {
X            PUTC_CRC (al);
X            text_buf[di] = al;
X            di = (di + 1) & (N - 1);
X            count ++;
X        } else {
X            cx = getc (infile);
X            si = (al & 0x00ff) | ((cx << 4) & 0x0f00);
X            cx = (cx & 0x000f) + 3;
X            count += cx;
X            do {
X                text_buf[di] = al = text_buf[si];
X                PUTC_CRC (al);
X                si = (si + 1) & (N - 1);
X                di = (di + 1) & (N - 1);
X            } while (--cx != 0) ;
X        }
X
X        if (!quiet && (count > indicator_count)) {
X            putchar (BALL);
X            fflush (stdout);
X            indicator_count += indicator_threshold;
X        }
X    }
X    END_PUTC_CRC ();
X}
X
X
X
X/*----------------------------------------------------------------------*/
X/*                                    */
X/*        Global Entries for Archiver Driver            */
X/*                                    */
X/*----------------------------------------------------------------------*/
X
X
Xstart_indicator (name, size, msg)
X    char *name;
X    long size;
X    char *msg;
X{
X    long    i;
X    int    m;
X
X    if (quiet)
X        return;
X
X#ifdef ANSI
X    m = MAX_INDICATOR_COUNT;
X#else
X    m = MAX_INDICATOR_COUNT - strlen (name);
X#endif
X    if (m < 0)
X        m = 3;        /* (^_^) */
X
X#ifdef ANSI
X        printf ("\r%s - %s:\n", name, msg);
X#else
X        printf ("\r%s - %s :  ", name, msg);
X#endif
X
X    indicator_threshold =
X        ((size  + (m * INDICATOR_THRESHOLD - 1)) /
X         (m * INDICATOR_THRESHOLD) *
X         INDICATOR_THRESHOLD);
X
X    /* bug fix for files with size==0 28.03.1990 SB */
X    if (indicator_threshold == 0)
X        indicator_threshold = INDICATOR_THRESHOLD;
X    /************************************************/
X
X    i = ((size + (indicator_threshold - 1)) / indicator_threshold);
X    while (i--)
X        putchar (DOT);
X    indicator_count = 0;
X#ifdef ANSI
X        printf ("\r%s%s - %s:\n", CURSORUP, name, msg);
X#else
X        printf ("\r%s - %s :  ", name, msg);
X#endif
X    fflush (stdout);
X}
X
Xfinish_indicator2 (name, msg, pcnt)
X    char *name;
X    char *msg;
X    int pcnt;
X{
X    if (quiet)
X        return;
X
X    if (pcnt > 100) pcnt = 100;    /* (^_^) */
X#ifdef ANSI
X        printf ("\r%s%s - %s(%d%%)\n%s", CURSORUP, name, msg, pcnt, ERASEEOL);
X#else
X        printf ("\r%s - %s(%d%%)\n", name, msg, pcnt);
X#endif
X    fflush (stdout);
X}
X
Xfinish_indicator (name, msg)
X    char *name;
X    char *msg;
X{
X    if (quiet)
X        return;
X
X#ifdef ANSI
X        printf ("\r%s%s - %s\n%s", CURSORUP, name, msg, ERASEEOL);
X#else
X        printf ("\r%s - %s\n", name, msg);
X#endif
X    fflush (stdout);
X}
X
X
X#ifndef SELFMAIN
Xint encode_lzhuf (infp, outfp, size, original_size_var, packed_size_var, name)
X    FILE *infp;
X    FILE *outfp;
X    long size;
X    long *original_size_var;
X    long *packed_size_var;
X    char *name;
X{
X    infile = infp;
X    outfile = outfp;
X    SETUP_GETC_CRC(infp);
X    textsize = size;
X    codesize = 0;
X    init_crc ();
X    start_indicator (name, size, "Freezing");
X    Encode ();
X    finish_indicator2 (name, "Frozen",
X               (int)((codesize * 100L) / crc_size));
X    *packed_size_var = codesize;
X    *original_size_var = crc_size;
X    return crc_value;
X}
X
Xint decode_lzhuf (infp, outfp, original_size, name)
X    FILE *infp;
X    FILE *outfp;
X    long original_size;
X    char *name;
X{
X    infile = infp;
X    outfile = outfp;
X    SETUP_PUTC_CRC(outfp);
X    textsize = original_size;
X    init_crc ();
X        start_indicator (name, original_size,
X                         (output_to_test ? "Testing" : "Melting"));
X    Decode ();
X        finish_indicator (name, (output_to_test ? "Tested  " : "Melted  "));
X    return crc_value;
X}
X
X
Xint decode_larc (infp, outfp, original_size, name)
X    FILE *infp, *outfp;
X    long original_size;
X    char *name;
X{
X    infile = infp;
X    outfile = outfp;
X    SETUP_PUTC_CRC(outfp);
X    textsize = original_size;
X    init_crc ();
X        start_indicator (name, original_size,
X                         (output_to_test ? "Testing" : "Melting"));
X    DecodeOld ();
X        finish_indicator (name, (output_to_test ? "Tested  " : "Melted  "));
X    return crc_value;
X}
X#endif
X
X#ifdef SELFMAIN
Xint main (argc, argv)
X    int argc;
X    char *argv[];
X{
X    char  *s;
X    int i;
X
X    indicator_count = 0;
X    indicator_threshold = 1024;
X    textsize = codesize = 0;
X    if (argc != 4) {
X        printf ("\
Xusage: lzhuf e in_file out_file (packing)\n\
X       lzhuf d in_file out_file (unpacking)\n");
X        return EXIT_FAILURE;
X    }
X    if ((s = argv[1], ((*s != 'e') && (*s != 'd')) || s[1] != '\0') ||
X        (s = argv[2], (infile  = fopen(s, "rb")) == NULL) ||
X        (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
X        printf("??? %s\n", s);
X        return EXIT_FAILURE;
X    }
X    if (argv[1][0] == 'e') {
X        /* Get original text size and output it */
X        fseek(infile, 0L, 2);
X        textsize = ftell(infile);
X        rewind (infile);
X        if (fwrite(&textsize, sizeof textsize, 1, outfile) < 1)
X            Error("cannot write");
X
X        start_indicator (argv[2], textsize, "Freezing");
X        Encode();
X        finith_indicator2 (argv[2], "Frozen",
X                   (int)((codesize * 100L) / textsize));
X
X        printf("input : %ld bytes\n", textsize);
X        printf("output: %ld bytes\n", codesize);
X    } else {
X        /* Read original text size */
X        if (fread(&textsize, sizeof textsize, 1, infile) < 1)
X            Error("cannot read");
X
X        start_indicator (argv[2], textsize, "Melting");
X        Decode();
X        finish_indicator (argv[2], "Melted  ");
X    }
X    fclose(infile);
X    fclose(outfile);
X    return EXIT_SUCCESS;
X}
X#endif
X
X
X/* These lines are used in GNU-Emacs */
X/* Local Variables: */
X/* comment-column:40 */
X/* tab-width:8 */
X/* c-indent-level:8 */
X/* c-continued-statement-offset:8 */
X/* c-argdecl-indent:8 */
X/* End: */
SHAR_EOF
chmod 0666 lzhuf.c || echo "restore of lzhuf.c fails"
echo "x - extracting mktemp.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > mktemp.c &&
X/* MKTEMP.C using TMP environment variable */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X#include <io.h>
X
Xvoid Mktemp(char *file)
X{
X  char fname[32], *tmp;
X
X  tmp = getenv("TMP");
X
X  if ( tmp != NULL )
X  {
X    strcpy(fname, file);
X    strcpy(file, tmp);
X
X    if ( file[strlen(file) - 1] != '\\' )
X      strcat(file, "\\");
X
X    strcat(file, fname);
X  }
X
X  mktemp(file);
X}
X
X/* End of MKTEMP.C */
SHAR_EOF
chmod 0666 mktemp.c || echo "restore of mktemp.c fails"
echo "x - extracting pipes.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > pipes.c &&
X/* a simulation for the Unix popen() and pclose() calls on MS-DOS */
X/* only one pipe can be open at a time */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X
Xstatic char pipename[128], command[128];
Xstatic int wrpipe;
X
Xextern void Mktemp(char *);
X
XFILE *popen(char *cmd, char *flags)
X{
X  wrpipe = (strchr(flags, 'w') != NULL);
X
X  if ( wrpipe )
X  {
X    strcpy(command, cmd);
X    strcpy(pipename, "~WXXXXXX");
X    Mktemp(pipename);
X    return fopen(pipename, flags);  /* ordinary file */
X  }
X  else
X  {
X    strcpy(pipename, "~RXXXXXX");
X    Mktemp(pipename);
X    strcpy(command, cmd);
X    strcat(command, ">");
X    strcat(command, pipename);
X    system(command);
X    return fopen(pipename, flags);  /* ordinary file */
X  }
X}
X
Xint pclose(FILE *pipe)
X{
X  int rc;
X
X  if ( fclose(pipe) == EOF )
X    return EOF;
X
X  if ( wrpipe )
X  {
X    if ( command[strlen(command) - 1] == '!' )
X      command[strlen(command) - 1] = 0;
X    else
X      strcat(command, "<");
X
X    strcat(command, pipename);
X    rc = system(command);
X    unlink(pipename);
X    return rc;
X  }
X  else
X  {
X    unlink(pipename);
X    return 0;
X  }
X}
SHAR_EOF
chmod 0666 pipes.c || echo "restore of pipes.c fails"
rm -f s2_seq_.tmp
echo "You have unpacked the last part"
exit 0

--
bill davidsen    ([e-mail] -or- uunet!crdgw1!crdos1!davidsen)
    VMS is a text-only adventure game. If you win you can use unix.