tanzip.c

给出了 zip 压缩算法的完整实现过程。

/*
  Copyright (c) 1990-2005 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2004-May-22 or later
  (the contents of which are also included in zip.h) for terms of use.
  If, for some reason, both of these files are missing, the Info-ZIP license
  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/*
 * routines only used by TANDEM ZIP
 */

#include "zip.h"
#include <tal.h>
#include "$system.zsysdefs.zsysc" nolist
#include <cextdecs> nolist
#include "tannsk.h"

/******************************/
/*  Function version_local()  */
/******************************/

void version_local()
{
    static ZCONST char CompiledWith[] = "Compiled with %s%s for %s%s%s%s.\n\n";
#if 0
    char buf[40];
#endif

    printf(CompiledWith,

#ifdef __GNUC__
      "gcc ", __VERSION__,
#else
#  if 0
      "cc ", (sprintf(buf, " version %d", _RELEASE), buf),
#  else
      "unknown compiler", "",
#  endif
#endif

      "Tandem/NSK", "",

#ifdef __DATE__
      " on ", __DATE__
#else
      "", ""
#endif
      );

} /* end function version_local() */

  int Bflag = 0;            /* Special formatting options for Tandem        */
                            /* Bit 0 = Add delimiter (0 = Yes, 1 = No)      */
                            /* Bit 1 = Delimiter Type (0 = CR/LF, 1 = LF)   */
                            /* Bit 2 = Space Fill records (0 = No, 1 = Yes) */
                            /* Bit 3 = Trim trailing space(0 = No, 1 = Yes) */
                            /* Thus, default is to add CR/LF, no padding    */
                            /* Bit 8 = Use 'safe' large read size (Expand)  */
  char nsk_delim[2] = {'\r', '\n'}; /* CR/LF */
  int nsk_delim_len = 2;
  int nsk_space_fill = 0;   /* 0 = No, 1 = Yes          */
  int nsk_trim_space = 0;   /* 0 = No, 1 = Yes          */
  unsigned short nsk_large_read = MAX_LARGE_READ;

  /* Following holds details of file currently used by zopen & zread */
  struct stat znsk_stat;
  nsk_stat_ov *znsk_ov = (nsk_stat_ov *)&znsk_stat.st_reserved[0];
  nsk_file_attrs *znsk_attr = (nsk_file_attrs *)
                                ((char *) (&znsk_stat.st_reserved[0]) + 4);

  /* Following items used by zread to avoid overwriting window */
  char zreadbuf[MAX_LARGE_READ];       /* Buffer as large as biggest read */
  char *zreadptr = (char *) zreadbuf;  /* pointer to start of buffer      */
  char *zread_ovptr = NULL;            /* pointer to left overs           */
  long zread_ovlen = 0;                /* size of remaining left overs    */

  int zopen (filename, opt)
    const char *filename;
    int opt;
  {
    /* Currently ignore opt.  Choose method of I/O based on NSK file type */
    short err, len, fnum, access, exclus, bufferlen, options;
    long recnum;
    char fname[FILENAME_MAX + 1];
    short extension;
    char ext[EXTENSION_MAX + 1];

    /* Remove any (pseudo) file extension */
    extension = parsename (filename,fname,ext);
    len = strlen(fname);

    fnum = 0;
    access = NSK_RDONLY;
    exclus = NSK_SHARED;

    err = stat(fname, &znsk_stat); /* Setup global struct, used by zread */

    if (znsk_attr->filetype == NSK_UNSTRUCTURED)
      if (znsk_attr->filecode == NSK_EDITFILECODE) {
        /* Edit File */
        fnum = -1; /* Ask OPENEDIT_ to open the file for us */
        err = OPENEDIT_ ((char *)fname, len, &fnum, access, exclus);
        if (!err) {
          recnum = -1; /* Position to first line */
          err = POSITIONEDIT (fnum, recnum);
        }
      }
      else {
        /* Unstructured File */
        options = NSK_UNSTRUCTUREDACCESS;
        err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,
                         ,,options,,,);
        if (!err)
          /* Ask for large transfer mode */
          err = (SETMODE (fnum, SET_LARGE_TRANSFERS, 1) != CCE);
      }
    else {
      /* Structured File */
      bufferlen = 4096;  /* request SBB */
      err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,
                       ,,,, bufferlen ,);
      if (err == 4)
        err = 0;  /* Allow saving of files that have missing altkeys */
    }

    return (err == 0 ? (int)fnum : -1);
  }

  unsigned zread (fnum, buf, len)
    int fnum;
    char *buf;
    unsigned len;
  {
    short err, trail;
    long total, movelen;
    unsigned short countread;
    unsigned readlen;  /* typed to match incoming arg */
    char *bufptr, *readptr;

    total = err = 0;
    bufptr = buf;

    /* We use a separate buffer to read in data as it can be larger than
       WSIZE, and hence would overwrite memory */

    /* We always attempt to give the user the exact requested size
       Hence we make use of an overfow buffer for previously truncated data */

    /* see if we have some left over characters from last time */
    if (zread_ovlen) {
       movelen = _min(len,zread_ovlen);
       memcpy(bufptr, zread_ovptr, movelen);
       bufptr += movelen;
       total += movelen;
       zread_ovptr += movelen;
       zread_ovlen -= movelen;
    }

    while (!err && (total < len)) {
      readptr = zreadptr;

      if (znsk_attr->filetype == NSK_UNSTRUCTURED)
        if (znsk_attr->filecode == NSK_EDITFILECODE){
          /* Edit File */
          trail = 1;
          readlen = MAX_EDIT_READ; /* guarantee it fits in buffer */

          /* get line and preserve any trailing space characters */
          err = READEDIT (fnum,, zreadptr, (short) readlen,
                            (short *) &countread,,, trail);
          /* if countread is ever negative then we will skip a line */

          if (!err) {
            readptr = zreadptr + countread;
            /* Note it is possible for Edit files to hold trailing space */
            if (nsk_trim_space)
              while (*(readptr-1) == ' ') {
                readptr--;
                countread--;
              }

            if (nsk_delim_len) {
              memcpy(readptr, nsk_delim, nsk_delim_len);
              readptr += nsk_delim_len;
              countread += nsk_delim_len;
            }
          }
        }
        else {
          /* Unstructured File */

          /* Using large transfer mode so we have to use 2K multiples
             Use largest size possible and put remains in overflow    */

          readlen = nsk_large_read; /* use largest read, overflow into buffer*/

          err = (READX(fnum, zreadptr, readlen, (short *)&countread) != CCE);
          if (err && (errno == EINVAL)) {
            /* Read too big so scale back to smaller value */
            readlen = nsk_large_read = MAX_LARGE_READ_EXPAND;
            err = (READX(fnum, zreadptr, readlen, (short *)&countread) != CCE);
          }
          if (!err)
            readptr = zreadptr + countread;
        }
      else {
        /* Structured File */
        readlen = znsk_attr->reclen;

        err = (READX(fnum, zreadptr, readlen, (short *)&countread)!= CCE);

        if (!err) {
          readptr = zreadptr + countread;
          if (nsk_space_fill)
            while (countread < readlen) {
              *readptr++ = ' ';
              countread++;
            }
          else
            if (nsk_trim_space)
              while (*(readptr-1) == ' ') {
                readptr--;
                countread--;
              }

          if (nsk_delim_len) {
            memcpy(readptr, nsk_delim, nsk_delim_len);
            readptr += nsk_delim_len;
            countread += nsk_delim_len;
          }
        }
      }
      if (!err) {
         movelen = _min((len-total), countread);
         memcpy(bufptr, zreadptr, movelen);
         bufptr += movelen;
         total += movelen;
         if (movelen < countread) { /* still stuff in Read buffer */
           zread_ovptr = zreadptr + movelen;   /* pointer to whats left */
           zread_ovlen = countread - movelen;  /* how much is left      */
         }
      }
    }

    return ((unsigned)total);
  }

  int zclose (fnum)
    int fnum;
  {
    short err;

    if ((znsk_attr->filetype == NSK_UNSTRUCTURED)
      && (znsk_attr->filecode == NSK_EDITFILECODE))
      err = CLOSEEDIT_(fnum);
    else
      err = FILE_CLOSE_(fnum);

    return (err != 0);
  }

void nskformatopt(p)
char **p;
{
char *q;

  /* set up formatting options for ZIP */

  q = *p; /* make a note of where we are */

  Bflag = 0; /* default option */

  Bflag = strtoul((*p + 1), p, 10);

  /* need to go back one character if we've got a result */
  if (q != *p)
    (*p)--;

  if (Bflag & NSK_SPACE_FILL)
    nsk_space_fill = 1;
  else
    nsk_space_fill = 0;

  if (Bflag & NSK_TRIM_TRAILING_SPACE)
    nsk_trim_space = 1;
  else
    nsk_trim_space = 0;

  if (Bflag & NSK_NO_DELIMITER)
    nsk_delim_len = 0;
  else {
    if (Bflag & NSK_USE_FF_DELIMITER) {
      nsk_delim[0] = '\n';
      nsk_delim_len = 1;
    }
    else {   /* CR/LF */
      nsk_delim[0] = '\r';
      nsk_delim[1] = '\n';
      nsk_delim_len = 2;
    }
  }

  if (Bflag & NSK_LARGE_READ_EXPAND)
    nsk_large_read = MAX_LARGE_READ_EXPAND;
  else
    nsk_large_read = MAX_LARGE_READ;

}


  int deletedir(d)
    char *d;                /* directory to delete */
  /* Delete the directory *d if it is empty, do nothing otherwise.
     Return the result of rmdir(), delete(), or system().
     For VMS, d must be in format [x.y]z.dir;1  (not [x.y.z]).
   */
  {
      return rmdir(d);