v25i145: zip - file compression/archive tool, Part04/07
Mark Adler
Posting-Number: Volume 25, Issue 145
Archive-Name: zip/part04
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 4 (of 7)."
# Contents: im_lmat.c zip.c zip.doc
# Wrapped by vi...@cognition.pa.dec.com on Sun Mar 1 18:57:38 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'im_lmat.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'im_lmat.c'\"
else
echo shar: Extracting \"'im_lmat.c'\" \(27597 characters\)
sed "s/^X//" >'im_lmat.c' <<'END_OF_FILE'
X/*
X
X Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, and Jean-loup Gailly.
X Permission is granted to any individual or institution to use, copy, or
X redistribute this software so long as all of the original files are included
X unmodified, that it is not sold for profit, and that this copyright notice
X is retained.
X
X*/
X
X/*
X * im_lmat.c by Jean-loup Gailly.
X *
X * PURPOSE
X *
X * Identify new text as repetitions of old text within a fixed-
X * length sliding window trailing behind the new text.
X *
X * DISCUSSION
X *
X * The "implosion" process depends on being able to identify portions
X * of the input text which are identical to earlier input (within a
X * sliding window trailing behind the input currently being processed).
X *
X * The most straightforward technique turns out to be the fastest for
X * most input files: try all possible matches and select the longest.
X * The key feature is of this algorithm is that insertion and deletions
X * from the string dictionary are very simple and thus fast. Insertions
X * and deletions are performed at each input character, whereas string
X * matches are performed only when the previous match ends. So it is
X * preferable to spend more time in matches to allow very fast string
X * insertions and deletions. The matching algorithm for small strings
X * is inspired from that of Rabin & Karp. A brute force approach is
X * used to find longer strings when a small match has been found.
X * A similar algorithm is used in freeze (by Leonid Broukhis) but the
X * algorithm used here is faster.
X * A previous version of this file used a more sophisticated algorithm
X * (by Fiala and Greene) which is guaranteed to run in linear amortized
X * time, but has a larger average cost and uses more memory. However
X * the F&G algorithm may be faster for some highly redundant files if
X * the parameter max_chain_length (described below) is too large.
X *
X * ACKNOWLEDGEMENTS
X *
X * Rich Wales defined the interface, provided the necessary information
X * to ensure compatibility with pkunzip 1.0 (not an easy job) and
X * suggested the solution (n == 1 + n-1) adopted here.
X * The idea of lazy evaluation of matches is due to Jan Mark Wams, and
X * I found it in 'freeze' written by Leonid Broukhis.
X * Special thanks to Kai-Uwe Rommel for the OS/2 port, to Glenn J.
X * Andrews for the VMS port, and to many other info-zippers for testing.
X *
X * REFERENCES
X *
X * A description of the Rabin and Karp algorithm is given in the book
X * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
X *
X * Fiala,E.R., and Greene,D.H.
X * Data Compression with Finite Windows, CACM, 32,4 (1989) 490-595.
X *
X * INTERFACE
X *
X * ImpErr lm_init (int pack_level)
X * Initialize the "longest match" routines for a new file.
X * The global variable fd is an implicit parameter.
X *
X * ImpErr lm_input (U_CHAR *block, U_INT count)
X * Process a block of input characters.
X *
X * ImpErr lm_windup (void)
X * Flush out the remaining unprocessed input.
X */
X
X#include "implode.h"
X
X/***********************************************************************
X *
X * Configuration parameters
X */
X
X#define MAX_MATCH_LENGTH 320
X/* The maximum match length. 320 = 64 + 256. (If the length is greater than
X * 63, pkzip uses an extra byte.)
X */
X
X#define MAX_WBITS 13
X#define WSIZE (1 << MAX_WBITS)
X/* Maximum window size = 8K */
X
X/* Constants used to dimension the hash table: */
X#define HASH_BITS 14
X/* HASH_BITS must be >= 13, see longest_match() */
X
X#define HASH_SIZE (1<<HASH_BITS)
X#define HASH_MASK (HASH_SIZE-1)
X
X#if defined(MSDOS) || defined(i386) || defined(mc68020) || defined(vax)
X# define UNALIGNED_OK
X /* Define this symbol if your target allows access to unaligned data.
X * This is not mandatory, just a speed optimization. The compressed
X * output is strictly identical.
X */
X#endif
X#ifdef __TURBOC__
X# define DYN_ALLOC
X /* Turbo C 2.0 does not accept far static allocations in small model */
X#endif
X
X/***********************************************************************
X *
X * Local data used by the "longest match" routines.
X */
X
X#if HASH_BITS <= 14
X typedef unsigned short Hash;
X#else
X /* Defined just for safety, since values > 14 do not speed up implosion */
X typedef unsigned long Hash;
X#endif
X
typedef unsigned short Pos;
typedef unsigned int IPos;
X/* A Pos is an index in the character window. We use short instead of int to
X * save space in the various tables. IPos is used only for parameter passing.
X */
X
int near min_match_length;
X/* Minimum match length, 2 for binary files, 3 for ascii files.
X * (bad luck for ebcdic users; not because they may not get optimal
X * compression, but because they have to use ebcdic machines :-)
X * A zero value means that the min_match_length is not yet determined.
X */
X
U_CHAR near window[MAX_MATCH_LENGTH + WSIZE + BSZ];
X/* MAX_MATCH_LENGTH bytes are duplicated at both ends of the window,
X * to speed up string comparisons. The BSZ extra bytes allow a block copy
X * of the input buffer into the window instead of a copy one byte at a time.
X */
X
X#define MAX_DIST (WSIZE + BSZ)
X/* Maximum theoretical distance between two distinct bytes in the window.
X * Actual distances are limited to bufsize.
X */
X
X#define NIL MAX_DIST
X/* Tail of hash chains */
X
X#ifdef DYN_ALLOC
X Hash far *next = NULL;
X Pos far *prev = NULL;
X#else
X Hash far next[MAX_DIST+1];
X Pos far prev[MAX_DIST+HASH_SIZE+1];
X#endif
X/* next is a link to a more recent string with same hash index, or to the head
X * of a hash table chain if there is no such string. next[NIL] is used to
X * avoid extra checks. next[s] is NIL if string s is not yet in the dictionary
X *
X * prev is a link to an older string with same hash index (first MAX_DIST
X * values) or head of hash chain (last HASH_SIZE values). prev[NIL] is used
X * to avoid extra checks.
X */
X#define match_head (prev+(MAX_DIST+1))
X
Hash near ins_h; /* hash index of string to be inserted. */
X
int near h_shift;
X/* Number of bits by which ins_h must be shifted at each
X * input step. It must be such that after min_match_length steps, the oldest
X * byte no longer takes part in the hash key, that is:
X * h_shift * min_match_length >= HASH_BITS
X */
X
MATCH *ma_buf = NULL;
X/* Buffer used to speed up reading/writing to/from temp file */
X#define MA_BUFEND (ma_buf+MA_BUFSIZE)
X
MATCH *ma;
X/* Pointer to the most recent match. */
X
int near start_length;
X/* Matches not greater than this are discarded. This is used in the lazy match
X * evaluation. If start_length > 1, ma is a valid guess of length start_length
X * and ct_tally has not yet been called.
X */
X
X int near strstart; /* start of string to insert */
X int near strsize; /* length of string to insert */
X int near match_length; /* length of current best match */
X int near bufsize; /* # of slots in window */
X int near checkpoint; /* look for new match at this point */
static int insert_point; /* position of next input buffer */
X
static int max_lazy_match;
X/* We try lazy evaluation only for matches of length 2..max_lazy_match, to
X * speed up the implosion. We use 0 for maximum speed, 0.9*MAX_MATCH_LENGTH
X * for maximum compression.
X */
X
X int near max_chain_length;
X/* To speed up implosion, hash chains are truncated to this length.
X * A higher limit improves compression ratio but degrades the speed.
X * We use 40 for maximum speed, 960 for maximum compression. Values
X * below 20 are not recommended.
X */
X
X/* Values for max_lazy_match and max_chain_length, depending on the desired
X * pack level (0..9). The values given below have been tuned to exclude
X * worst case performance for pathological files. Better values may be
X * found for specific files. Note that the current algorithm requires
X * max_lazy >= 2.
X */
typedef struct config {
X int max_lazy;
X int max_chain;
X} config;
X
static config configuration_table[10] = {
X/* 0 */ {2, MAX_MATCH_LENGTH/8}, /* maximum speed */
X/* 1 */ {4, MAX_MATCH_LENGTH/4},
X/* 2 */ {5, MAX_MATCH_LENGTH/2},
X/* 3 */ {MAX_MATCH_LENGTH/16, MAX_MATCH_LENGTH/2},
X/* 4 */ {MAX_MATCH_LENGTH/16, 3*MAX_MATCH_LENGTH/4},
X/* 5 */ {MAX_MATCH_LENGTH/16, MAX_MATCH_LENGTH},
X/* 6 */ {MAX_MATCH_LENGTH/16, 3*MAX_MATCH_LENGTH/2},
X/* 7 */ {MAX_MATCH_LENGTH/16, 2*MAX_MATCH_LENGTH},
X/* 8 */ {9*MAX_MATCH_LENGTH/10, 2*MAX_MATCH_LENGTH},
X/* 9 */ {9*MAX_MATCH_LENGTH/10, 3*MAX_MATCH_LENGTH}}; /* maximum compression */
X
X
X#define MIN(a,b) ((a) <= (b) ? (a) : (b))
X/* The arguments must not have side effects. */
X
X#define EQUAL 0
X/* result of strncmp for equal strings */
X
X/* Prototypes for local functions */
X
static void set_min_match_length OF ((U_CHAR *block, U_INT count));
X ImpErr write_match OF ((IPos ma_start, int ma_length));
X IPos longest_match OF ((IPos cur_match));
X ImpErr lm_process OF ((U_INT count));
X
X/***********************************************************************
X *
X * Initialize the "longest match" routines for a new file.
X * The global variable fd is an implicit parameter.
X */
ImpErr lm_init (pack_level)
X int pack_level; /* 0: best speed, 9: best compression, other: default */
X{
X register int i;
X
X /* Validate the arguments */
X bufsize = fd.fd_bufsize;
X strsize = MIN (fd.fd_strsize, MAX_MATCH_LENGTH);
X if (bufsize > WSIZE) return IM_BADARG;
X if (bufsize < 2 * strsize) return IM_BADARG;
X if (pack_level < 0 || pack_level > 9) return IM_BADARG;
X
X /* Make sure "bufsize" is a power of 2 */
X if ((bufsize & (bufsize - 1)) != 0) return IM_BADARG;
X
X /* Use dynamic allocation if compiler does not like big static arrays: */
X#ifdef DYN_ALLOC
X if (prev == NULL) {
X next = (Hash far*)farmalloc((U_INT)(MAX_DIST+9)*sizeof(Hash));
X prev = (Pos far*) farmalloc((U_INT)(MAX_DIST+HASH_SIZE+9)*sizeof(Pos));
X /* We allocate 16 extra bytes for the normalization under MSDOS */
X if (prev == NULL || next == NULL) return IM_NOMEM;
X
X# if defined(MSDOS) && !defined(OS2)
X /* Normalize to pointers with offset 0 (required by asm version).
X * For OS/2, we can't of course play such nasty games.
X */
X#define NORMALIZE(ptr) { \
X *((int*)&ptr+1) += ((unsigned)(ptr-0) + 15) >> 4; \
X *(int*)&ptr = 0; \
X}
X NORMALIZE(prev); NORMALIZE(next);
X# endif
X }
X#endif /* DYN_ALLOC */
X
X /* Initialize the hash tables. */
X for (i = 0; i < HASH_SIZE; i++) match_head[i] = NIL;
X for (i = 0; i <= MAX_DIST; i++) next[i] = NIL;
X /* prev[0..MAX_DIST] will be initialized on the fly */
X ins_h = 0;
X
X /* Assume strsize zeros before the input (bytes beyond strsize
X * can be garbage):
X */
X memset((char*)window, 0, MAX_MATCH_LENGTH);
X /* It is not necessary to duplicate this at the end of the window.
X * Duplication will start only after the first wrap around.
X */
X insert_point = MAX_MATCH_LENGTH;
X
X /* Force a check for the file type (ascii/binary) and set the default
X * configuration parameters:
X */
X min_match_length = 0;
X max_lazy_match = configuration_table[pack_level].max_lazy;
X max_chain_length = configuration_table[pack_level].max_chain;
X
X /* Do not report matches before the first strsize strings have been
X * inserted in the suffix tree:
X */
X strstart = 0;
X checkpoint = strsize;
X if (ma_buf == NULL) {
X ma_buf = (MATCH *) malloc ((unsigned) (MA_BUFSIZE * sizeof (MATCH)));
X if (ma_buf == NULL) return IM_NOMEM;
X }
X ma = ma_buf - 1;
X start_length = 1;
X
X /* All done. */
X return IM_OK;
X}
X
X/***********************************************************************
X *
X * Output the match info.
X * IN assertions: The matching strings start at strstart and ma_start
X * and have a length of ma_length bytes.
X * If ma_length is not greater than start_length, ma_start is garbage.
X * strstat == checkpoint. If start_length > 1, ma is the
X * previous match which has not yet been output.
X * OUT assertion: checkpoint is reset according to the match length
X * actually chosen.
X * ma is set to the current match, with start_length set appropriately.
X */
ImpErr write_match(ma_start, ma_length)
X IPos ma_start; /* start of matched string */
X int ma_length; /* length of complete match */
X{
X int ma_dist = 0; /* distance of current match */
X
X /* ma_length can be too large towards the end of the input: */
X if (ma_length > strsize) ma_length = strsize;
X
X#ifdef DEBUG
X /* check that the match is indeed a match */
X if (ma_length > start_length &&
X strncmp(window + ma_start, window + strstart, ma_length) != EQUAL) {
X fprintf(stderr,
X "write_match: ma_start %d, strstart %d, ma_length %d\n",
X ma_start, strstart, ma_length);
X exit(1);
X }
X#endif
X /* PKUNZIP accepts most overlapping matches. However, when the
X * distance has the value 1, versions of PKUNZIP prior to 1.10 don't
X * handle the overlap properly -- and version 1.10 handles the
X * overlap correctly only if the length is limited to 62 plus the
X * minimum match length; i.e., only if there is no supplementary
X * length byte. (From phone conversation with Phil Katz, 23 January
X * 1991.) The compression ratio is generally better when we do not
X * limit the match length to 64, so we remove distance-one matches
X * completely. (But PKUNZIP 1.01 also rejects some distance-two matches.
X * This could be fixed but would degrade compression.)
X */
X if (ma_length > 1) {
X ma_dist = strstart - ma_start;
X if (ma_dist < 0) ma_dist += MAX_DIST;
X if (ma_dist == 1) {
X /* keep the previous match if it was delayed */
X if (start_length > 1) {
X ma_length = 1;
X } else {
X /* Truncate the match to 1 */
X ImpErr retcode = write_match(ma_start, 1);
X if (retcode != IM_OK) return retcode;
X
X /* Emit a match with a distance of two and a length reduced by
X * one. This reduced match may be delayed.
X */
X checkpoint = ++strstart;
X retcode = write_match(ma_start, ma_length-1);
X strstart--;
X return retcode; /* Leave checkpoint unchanged */
X } /* start_length > 1 */
X } /* ma_dist == 1 */
X } /* ma_length > 1 */
X
X /* If the previous match has been delayed, keep it or prefer the
X * current match:
X */
X if (start_length > 1) {
X /* Keep the previous match if it is not shorter than the current one.
X * Otherwise, emit only the first byte of the previous match,
X * followed by the current match. If we have a delayed match for
X * the last bytes of the input file, the next match will necessarily
X * be smaller, so ct_tally will correctly be called for the delayed
X * match.
X */
X if (start_length >= ma_length) {
X /* Keep the previous match */
X if (start_length == 2) {
X ma->ma_dist = - ma->ma_dist;
X ma->l.ma_litc[1] = window[strstart]; /* litc[0] already set */
X } else {
X ma->l.ma_length = start_length; /* overwrite ma->l.ma_litc */
X }
X checkpoint = strstart + start_length - 1;
X start_length = 1;
X return ct_tally (ma);
X }
X /* Shorten the previous match to zero */
X ma->ma_dist = 0; /* keep ma->l.ma_litc */
X start_length = 1;
X (void) ct_tally (ma); /* ignore result, ct_tally cannot fail */
X }
X
X if (++ma == MA_BUFEND) {
X ma = ma_buf;
X if (twrite ((char *) ma, sizeof(MATCH), MA_BUFSIZE, fd.fd_temp)
X != MA_BUFSIZE) return IM_IOERR;
X }
X
X /* Keep the current match as guess only if its length is small,
X * trying to find a better match at the next step. If speed is not
X * critical, we use this lazy mechanism for all lengths.
X */
X if (ma_length > 1) {
X ma->ma_dist = ma_dist;
X if (ma_length <= max_lazy_match) {
X /* Set ma_litc[0]: this is the only way to identify the unmatched
X * data if the delayed match will be truncated to 1. It is also
X * useful if ma_length == 2: it may be more efficient in this case
X * to encode the individual characters rather than the match info.
X */
X ma->l.ma_litc[0] = window[strstart];
X start_length = ma_length;
X checkpoint = strstart + 1;
X return IM_OK;
X }
X /* At this point, ma_length >= 3, no need for ma_litc */
X ma->l.ma_length = ma_length;
X checkpoint = strstart + ma_length;
X } else {
X ma->ma_dist = 0;
X ma->l.ma_litc[0] = window[strstart]; /* ma_litc[1] is not required */
X checkpoint = strstart + 1;
X }
X return ct_tally (ma);
X /* Keep start_length == 1 */
X}
X
X/***********************************************************************
X *
X * Determine the minimum match length, based on the type of data
X * in the given input buffer: 2 for binary data, 3 otherwise. Set also
X * h_shift according to the chosen min_match_length, and reduce
X * max_chain_length for binary files.
X * If the guess about data type is wrong, this only affects the
X * compression ratio and speed but not the correctness of the algorithms.
X * If there are more than 20% bytes which seem non ascii in the first
X * 500 bytes, we assume that the data is binary. (We accept data
X * with a few high bits set as ascii to take into account special
X * word processor formats.)
X */
static void set_min_match_length (block, count)
X U_CHAR *block; /* input data */
X U_INT count; /* # of input char's */
X{
X int non_ascii = 0;
X min_match_length = 3; /* Default ascii */
X if (count >= 500) {
X count = 500;
X while (--count != 0) {
X if (*block <= 6 || *block >= 0x80) non_ascii++;
X block++;
X }
X if (non_ascii > 100) {
X min_match_length = 2;
X max_chain_length >>= 2;
X }
X }
X h_shift = (HASH_BITS+min_match_length-1)/min_match_length;
X#ifdef DEBUG
X fprintf(stderr," (min_match_length %d) ", min_match_length);
X#endif
X}
X
X/***********************************************************************
X *
X * Insert string s in the dictionary and set last_match to the previous head
X * of the hash chain (the most recent string with same hash key).
X * IN assertion: all calls to to INSERT_STRING are made with consecutive
X * input characters, so that a running hash key can be computed from the
X * previous key instead of complete recalculation each time.
X */
X#define INSERT_STRING(s, last_match) \
X{ \
X ins_h = ((ins_h<<h_shift) ^ window[s + min_match_length-1]) & HASH_MASK; \
X prev[s] = last_match = match_head[ins_h]; \
X next[last_match] = prev[next[s] = ins_h + MAX_DIST+1] = s; \
X}
X /* next[NIL] is garbage, we can overwrite it if s is a tail */
X
X/***********************************************************************
X *
X * Remove string s from the dictionary, or do nothing if s is not yet
X * in the dictionary.
X * IN assertion: s is the tail of its hash chain (the oldest string).
X */
X#define DELETE_STRING(s) {prev[next[s]] = NIL;}
X/* No effect if next[s] == NIL (s not in dictionary) */
X
X/***********************************************************************
X *
X * Find the longest match starting at the given string. Return its position
X * and set its length in match_length. Matches shorter or equal to
X * start_length are discarded, in which case match_length is unchanged
X * and the result position is NIL.
X * IN assertions: cur_match is the head of the hash chain for the current
X * string (strstart) and is not NIL, and start_length >= 1
X */
X#if !defined(MSDOS) || defined(NO_ASM)
X/* For MSDOS, a version of this routine written in assembler is in im_lm.asm.
X * The algorithms are strictly equivalent, so the C version can be used
X * instead if you do not have masm or tasm. (Update the makefile in this case.)
X */
IPos longest_match(cur_match)
X IPos cur_match;
X{
X register U_CHAR *match; /* pointer in matched string */
X register U_CHAR *scan = window + strstart;/* pointer in current string */
X register int len; /* length of current match */
X IPos cur_best = NIL; /* best match so far */
X register int ma_length = start_length; /* best match length so far */
X int chain_count = max_chain_length; /* used to limit hash chains */
X typedef unsigned short US;
X typedef unsigned long UL;
X#ifdef UNALIGNED_OK
X register US scan_start = *(US*)scan;
X register US scan_end = *(US*)(scan+ma_length-1);
X#else
X register U_CHAR scan_start = *scan;
X register U_CHAR scan_end1 = scan[ma_length-1];
X register U_CHAR scan_end = scan[ma_length];
X#endif
X do {
X match = window + cur_match;
X /* Skip to next match if the match length cannot increase
X * or if the match length is less than 2:
X */
X#ifdef UNALIGNED_OK
X /* This code assumes sizeof(unsigned short) == 2 and
X * sizeof(unsigned long) == 4. Do not use UNALIGNED_OK if your
X * compiler uses different sizes.
X */
X if (*(US*)(match+ma_length-1) != scan_end ||
X *(US*)match != scan_start) continue;
X
X len = min_match_length - 4;
X /* If min_match_length == 3, it is not necessary to compare
X * scan[2] and match[2] since they are always equal when the other
X * bytes match, given that the hash keys are equal and that
X * HASH_BITS >= 8.
X */
X# define ML MAX_MATCH_LENGTH
X do {} while ((len+=4) < ML && *(UL*)(scan+len) == *(UL*)(match+len));
X
X if (*(US*)(scan+len) == *(US*)(match+len)) len += 2;
X if (scan[len] == match[len]) len++;
X
X#else /* UNALIGNED_OK */
X if (match[ma_length] != scan_end ||
X match[ma_length-1] != scan_end1 || *match != scan_start)
X continue;
X /* It is not necessary to compare scan[1] and match[1] since they
X * are always equal when the other bytes match, given that
X * the hash keys are equal and that h_shift+8 <= HASH_BITS,
X * that is, when the last byte is entirely included in the hash key.
X * The condition is equivalent to
X * (HASH_BITS+2)/3 + 8 <= HASH_BITS
X * or: HASH_BITS >= 13 (see set_min_match_length()).
X * Also, we check for a match at ma_length-1 to get rid quickly of
X * the match with the suffix of the match made at the previous step,
X * which is known to fail.
X */
X len = 1;
X do {} while (++len < MAX_MATCH_LENGTH && scan[len] == match[len]);
X
X#endif /* UNALIGNED_OK */
X
X if (len > ma_length) {
X cur_best = cur_match, ma_length = len;
X if (len >= strsize) break;
X#ifdef UNALIGNED_OK
X scan_end = *(US*)(scan+ma_length-1);
X#else
X scan_end1 = scan[ma_length-1];
X scan_end = scan[ma_length];
X#endif
X }
X } while (--chain_count != 0 && (cur_match = prev[cur_match]) != NIL);
X
X if (ma_length > start_length) match_length = ma_length;
X return cur_best;
X}
X#endif /* MSDOS */
X
X/***********************************************************************
X *
X * Process a block of input characters, generating zero or more match
X * info records as appropriate.
X * IN assertion: count <= BSZ
X */
ImpErr lm_input (block, count)
X U_CHAR *block; /* input data */
X U_INT count; /* # of input char's */
X{
X if (count == 0) return IM_OK;
X
X /* Determine the input file type if this is the first call */
X if (min_match_length == 0) set_min_match_length (block, count);
X
X if (insert_point + count <= sizeof(window)) {
X memcpy((char*)window + insert_point, (char*)block, count);
X
X } else {
X int remain = sizeof(window)-insert_point;
X memcpy((char*)window + insert_point, (char*)block, remain);
X
X memcpy((char*)window + MAX_MATCH_LENGTH,
X (char*)block + remain, count - remain);
X }
X insert_point += count;
X if (insert_point > MAX_DIST) {
X /* Duplicate the end of the window */
X memcpy((char*)window,
X (char*)window + MAX_DIST,
X MIN (insert_point - MAX_DIST, MAX_MATCH_LENGTH));
X }
X if (insert_point >= sizeof(window)) insert_point -= MAX_DIST;
X
X return lm_process(count);
X}
X
X/***********************************************************************
X *
X * Process a block of characters already inserted in the window
X * IN assertion: count > 0
X */
X#if !defined(MSDOS) || defined(NO_ASM)
ImpErr lm_process (count)
X U_INT count; /* number of bytes to process */
X{
X ImpErr retcode; /* as usual */
X IPos cur_match; /* starting point for longest match search */
X IPos best_match = NIL; /* longest match found */
X int delete_point; /* position of next string to remove */
X
X delete_point = strstart - bufsize + MAX_MATCH_LENGTH - 1;
X if (delete_point < 0) delete_point += MAX_DIST;
X
X /* Process the input block. */
X do {
X /* Insert the string window[strstart .. strstart+strsize-1] in the
X * dictionary, and set cur_match to the head of the hash chain:
X */
X INSERT_STRING(strstart, cur_match);
X
X if (strstart == checkpoint) {
X /* Find the longest match, discarding those <= start_length */
X match_length = 0;
X if (cur_match != NIL) {
X best_match = longest_match (cur_match);
X /* longest_match updates match_length if longer match found */
X }
X retcode = write_match (best_match, match_length);
X if (retcode != IM_OK) return retcode;
X }
X
X /* Remove the oldest string from the dictionary, except if we have not
X * yet created bufsize dictionary entries. We could avoid this
X * deletion and check instead for obsolete pointers in
X * longest_match(), but this would be slower.
X */
X#if (MAX_DIST & (MAX_DIST-1)) != 0
X if (++delete_point == MAX_DIST) delete_point = 0;
X#else
X delete_point = (delete_point + 1) & (MAX_DIST-1);
X#endif
X DELETE_STRING (delete_point);
X
X if (++strstart == MAX_DIST) {
X strstart = 0, checkpoint -= MAX_DIST;
X }
X } while (--count != 0);
X return IM_OK;
X}
X#endif /* MSDOS */
X
X/***********************************************************************
X *
X * Wind up processing by flushing unprocessed input. For normal processing,
X * this routine is called twice (by imp_size then imp_clear) and the
X * second call does nothing. In case of error, this routine is called only
X * by imp_clear().
X */
ImpErr lm_windup()
X{
X ImpErr retcode;
X int matches;
X
X /* Process the remaining input. */
X while (strsize > 0) {
X retcode = lm_process (1);
X if (retcode != IM_OK) return retcode;
X --strsize;
X }
X /* Flush the match buffer. */
X if ((matches = ma-ma_buf+1) != 0 && matches !=
X twrite ((char *) ma_buf, sizeof(MATCH), matches, fd.fd_temp)) {
X return IM_IOERR;
X }
X ma = ma_buf - 1;
X return IM_OK;
X}
END_OF_FILE
if test 27597 -ne `wc -c <'im_lmat.c'`; then
echo shar: \"'im_lmat.c'\" unpacked with wrong size!
fi
# end of 'im_lmat.c'
fi
if test -f 'zip.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'zip.c'\"
else
echo shar: Extracting \"'zip.c'\" \(25825 characters\)
sed "s/^X//" >'zip.c' <<'END_OF_FILE'
X/*
X
X Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, and Jean-loup Gailly.
X Permission is granted to any individual or institution to use, copy, or
X redistribute this software so long as all of the original files are included
X unmodified, that it is not sold for profit, and that this copyright notice
X is retained.
X
X*/
X
X/*
X * zip.c by Mark Adler.
X */
X
X#include "revision.h"
X#include "zip.h"
X#include <signal.h>
X
X#define PWLEN 80 /* Input buffer size for reading encryption key */
X#define MAXCOM 256 /* Maximum one-line comment size */
X
X
X/* Local option flags */
X#define DELETE 0
X#define ADD 1
X#define UPDATE 2
X#define FRESHEN 3
local int action = ADD; /* one of ADD, UPDATE, FRESHEN, or DELETE */
local int comadd = 0; /* 1=add comments for new files */
local int zipedit = 0; /* 1=edit zip comment and all file comments */
local int dispose = 0; /* 1=remove files after put in zip file */
local int latest = 0; /* 1=set zip file time to time of latest file */
local ulg before = 0; /* 0=ignore, else exclude files before this time */
X
X
X/* Temporary zip file name and file pointer */
local char *tempzip;
local FILE *tempzf;
X
X
X/* Local functions */
X#ifdef PROTO
X local void freeup(void);
X local void leave(int);
X local void err(int, char *);
X local void handler(int);
X local void license(void);
X local void help(void);
X void main(int, char **);
X#endif /* PROTO */
X
X
X
local void freeup()
X/* Free all allocations in the found list and the zfiles list */
X{
X struct flist far *f; /* steps through found list */
X struct zlist far *z; /* pointer to next entry in zfiles list */
X
X for (f = found; f != NULL; f = fexpel(f))
X ;
X while (zfiles != NULL)
X {
X z = zfiles->nxt;
X free((voidp *)(zfiles->name));
X free((voidp *)(zfiles->zname));
X if (zfiles->ext)
X free((voidp *)(zfiles->extra));
X if (zfiles->cext && zfiles->cextra != zfiles->extra)
X free((voidp *)(zfiles->cextra));
X if (zfiles->com)
X free((voidp *)(zfiles->comment));
X farfree((voidp far *)zfiles);
X zfiles = z;
X zcount--;
X }
X}
X
X
local void leave(e)
int e; /* exit code */
X/* Process -o and -m options (if specified), free up malloc'ed stuff, and
X exit with the code e. */
X{
X int r; /* return value from trash() */
X ulg t; /* latest time in zip file */
X struct zlist far *z; /* pointer into zfile list */
X
X /* If latest, set time to zip file to latest file in zip file */
X if (latest)
X {
X diag("changing time of zip file to time of latest file in it");
X /* find latest time in zip file */
X t = zfiles->tim;
X for (z = zfiles->nxt; z != NULL; z = z->nxt)
X if (t < z->tim)
X t = z->tim;
X /* set modified time of zip file to that time */
X stamp(zipfile, t);
X }
X if (tempath != NULL)
X {
X free((voidp *)tempath);
X tempath = NULL;
X }
X if (zipfile != NULL)
X {
X free((voidp *)zipfile);
X zipfile = NULL;
X }
X
X
X /* If dispose, delete all files in the zfiles list that are marked */
X if (dispose)
X {
X diag("deleting files that were added to zip file");
X if ((r = trash()) != ZE_OK)
X err(r, "was deleting moved files and directories");
X }
X
X
X /* Done! */
X freeup();
X#ifdef VMS
X exit(0);
X#else /* !VMS */
X exit(e);
X#endif /* ?VMS */
X}
X
X
local void err(c, h)
int c; /* error code from the ZE_ class */
char *h; /* message about how it happened */
X/* Issue a message for the error, clean up files and memory, and exit. */
X{
X if (PERR(c))
X perror("zip error");
X fprintf(stderr, "zip error: %s (%s)\n", errors[c-1], h);
X if (shract)
X {
X shr_clear();
X shract = 0;
X }
X#ifndef NOIMPLODE
X if (impact)
X {
X imp_clear();
X impact = 0;
X }
X#endif /* !NOIMPLODE */
X if (tempzf != NULL)
X fclose(tempzf);
X if (tempzip != NULL)
X {
X destroy(tempzip);
X if (tempzip != zipfile)
X free((voidp *)tempzip);
X }
X if (key != NULL)
X free((voidp *)key);
X if (tempath != NULL)
X free((voidp *)tempath);
X if (zipfile != NULL)
X free((voidp *)zipfile);
X freeup();
X#ifdef VMS
X exit(0);
X#else /* !VMS */
X exit(c);
X#endif /* ?VMS */
X}
X
X
local void handler(s)
int s; /* signal number (ignored) */
X/* Upon getting a user interrupt, turn echo back on for tty and abort
X cleanly using err(). */
X{
X#ifndef MSVMS
X#ifndef EXPORT
X echon();
X#endif /* !EXPORT */
X putc('\n', stderr);
X#endif /* !MSVMS */
X err(ZE_ABORT, "aborting");
X s++; /* keep some compilers happy */
X}
X
X
void warn(a, b)
char *a, *b; /* message strings juxtaposed in output */
X/* Print a warning message to stderr and return. */
X{
X fprintf(stderr, "zip warning: %s%s\n", a, b);
X}
X
X
local void license()
X/* Print license information to stdout. */
X{
X extent i; /* counter for copyright array */
X
X for (i = 0; i < sizeof(copyright)/sizeof(char *); i++)
X puts(copyright[i]);
X for (i = 0; i < sizeof(disclaimer)/sizeof(char *); i++)
X puts(disclaimer[i]);
X}
X
X
local void help()
X/* Print help (along with license info) to stdout. */
X{
X extent i; /* counter for help array */
X
X /* help array */
X static char *text[] = {
X"",
X"Zip %d.%d (%s)",
X"Usage: zip [-options] [-b path] [-t mmddyy] zipfile list [-x list]",
X" the default action is to add or replace zipfile entries from list, which",
X" can include the special name - to read names from stdin.",
X" -f freshen: only changed files -u update: only changed or new files",
X" -d delete entries in zipfile -m move into zipfile (delete files)",
X" -k simulate PKZIP made zipfile -g allow growing existing zipfile",
X" -h show this help -l show software license",
X" -r recurse into directories -j junk (don't record) directory names",
X" -i implode only -s shrink only",
X" -0 compress faster -9 compress better",
X" -q quiet operation -n don't compress special suffixes",
X" -c add one-line comments -z add zipfile comment",
X" -b use \"path\" for temp files -t only do files after \"mmddyy\"",
X#ifdef EXPORT
X" -o make zipfile as old as latest entry",
X#else /* !EXPORT */
X" -e encrypt (-ee verify key) -o make zipfile as old as latest entry",
X#endif /* ?EXPORT */
X#ifdef VMS
X" -w append the VMS version number to the name stored in the zip file",
X#endif /* VMS */
X#ifdef S_IFLNK
X" -y store symbolic links as the link instead of the referenced file",
X#endif /* !S_IFLNK */
X" -x exclude the names that follow from those operated on"
X };
X
X for (i = 0; i < sizeof(copyright)/sizeof(char *); i++)
X puts(copyright[i]);
X for (i = 0; i < sizeof(text)/sizeof(char *); i++)
X {
X printf(text[i], REVISION / 10, REVISION % 10, REVDATE);
X putchar('\n');
X }
X}
X
X
X/* Do command line expansion for MSDOS and VMS */
X#ifdef MSVMS
X# define PROCNAME(n) (action==ADD||action==UPDATE?wild(n):procname(n))
X#else /* !MSVMS */
X# define PROCNAME(n) procname(n)
X#endif /* ?MSVMS */
X
X
void main(argc, argv)
int argc; /* number of tokens in command line */
char **argv; /* command line tokens */
X/* Add, update, freshen, or delete zip entries in a zip file. See the
X command help in help() above. */
X{
X int a; /* attributes of zip file */
X ulg c; /* start of central directory */
X int d; /* true if just adding to a zip file */
X char *e; /* malloc'd comment buffer */
X struct flist far *f; /* steps through found linked list */
X int i; /* arg counter, root directory flag */
X int k; /* next argument type, marked counter,
X comment size, entry count */
X ulg n; /* total of entry len's */
X int o; /* true if there were any ZE_OPEN errors */
X char *p; /* steps through option arguments */
X int r; /* temporary variable */
X ulg t; /* file time, length of central directory */
X struct zlist far *v; /* temporary variable */
X struct zlist far * far *w; /* pointer to last link in zfiles list */
X FILE *x, *y; /* input and output zip files */
X struct zlist far *z; /* steps through zfiles linked list */
X
X
X /* Process arguments */
X diag("processing arguments");
X if (argc == 1)
X {
X help();
X exit(0);
X }
X zipfile = tempzip = NULL;
X tempzf = NULL;
X d = 0; /* disallow adding to a zip file */
X signal(SIGINT, handler);
X signal(SIGTERM, handler);
X k = 0; /* Next non-option argument type */
X for (i = 1; i < argc; i++)
X {
X if (argv[i][0] == '-')
X if (argv[i][1])
X for (p = argv[i]+1; *p; p++)
X switch(*p)
X {
X case '0': case '1': case '2': case '3': case '4':
X case '5': case '6': case '7': case '8': case '9':
X /* Set the compression efficacy */
X level = *p - '0'; break;
X case 'b': /* Specify path for temporary file */
X if (k != 0)
X err(ZE_PARMS, "use -b before zip file name");
X else
X k = 1; /* Next non-option is path */
X break;
X case 'c': /* Add comments for new files in zip file */
X comadd = 1; break;
X case 'd': /* Delete files from zip file */
X if (action != ADD)
X err(ZE_PARMS, "specify just one action");
X action = DELETE;
X break;
X#ifndef EXPORT
X case 'e': /* Encrypt */
X e = key == NULL ? (char *)NULL : key;
X if ((key = malloc(PWLEN+1)) == NULL)
X err(ZE_MEM, "was getting encryption password");
X if (getp(e == NULL ? "Enter password: " : "Verify password: ",
X key, PWLEN+1) == NULL)
X err(ZE_PARMS, "stderr is not a tty");
X if (e != NULL)
X {
X r = strcmp(key, e);
X free((voidp *)e);
X if (r)
X err(ZE_PARMS, "password not verified");
X }
X break;
X#endif /* !EXPORT */
X case 'f': /* Freshen zip file--overwrite only */
X if (action != ADD)
X err(ZE_PARMS, "specify just one action");
X action = FRESHEN;
X break;
X case 'g': /* Allow appending to a zip file */
X d = 1; break;
X case 'h': /* Help */
X help(); break;
X case 'i': /* Implode only */
X method = IMPLODE; break;
X case 'j': /* Junk directory names */
X pathput = 0; break;
X case 'k': /* Make entries using DOS names (k for Katz) */
X dosify = 2; break;
X case 'l': /* Show license, version */
X license(); break;
X case 'm': /* Delete files added or updated in zip file */
X dispose = 1; break;
X case 'n': /* Don't compress files with a special suffix */
X if ((special = getenv("NOZIP")) == NULL)
X special = ".Z:.zip:.zoo:.arc";
X#ifndef OS2
X#ifdef MSDOS
X strupr(special);
X#endif /* MSDOS */
X#endif /* !OS2 */
X break;
X case 'o': /* Set zip file time to time of latest file in it */
X latest = 1; break;
X case 'p': /* Store path with name */
X break; /* (do nothing as annoyance avoidance) */
X case 'q': /* Quiet operation */
X noisy = 0; break;
X case 'r': /* Recurse into subdirectories */
X recurse = 1; break;
X case 's': /* Shrink only */
X method = SHRINK; break;
X case 't': /* Exclude files earlier than specified date */
X if (before)
X err(ZE_PARMS, "can only have one -t");
X k = 2; break;
X case 'u': /* Update zip file--overwrite only if newer */
X if (action != ADD)
X err(ZE_PARMS, "specify just one action");
X action = UPDATE;
X break;
X case 'v': /* Mention oddities in zip file structure */
X verbose = 1;
X break;
X#ifdef VMS
X case 'w': /* Append the VMS version number */
X vmsver = 1; break;
X#endif /* VMS */
X case 'x': /* Exclude following files */
X if (k != 4 &&
X (k != 3 || (action != UPDATE && action != FRESHEN)))
X err(ZE_PARMS, "nothing to exclude (-x) from");
X if (k == 3) /* must be -u or -f */
X for (z = zfiles; z != NULL; z = z->nxt)
X z->mark = 1; /* mark all of them */
X k = 5;
X if ((r = exclude()) != ZE_OK)
X if (r == ZE_PARMS)
X err(r, "cannot repeat names in zip file");
X else
X err(r, "was processing list of files");
X break;
X#ifdef S_IFLNK
X case 'y': /* Store symbolic links as such */
X linkput = 1; break;
X#endif /* !S_IFLNK */
X case 'z': /* Edit zip file comment */
X zipedit = 1; break;
X default:
X {
X sprintf(errbuf, "no such option: %c", *p);
X err(ZE_PARMS, errbuf);
X }
X }
X else /* just a dash */
X if (k < 3)
X err(ZE_PARMS, "zip file cannot be stdin");
X else /* read names from stdin */
X while ((p = getnam(errbuf)) != NULL)
X {
X if ((r = PROCNAME(p)) != ZE_OK)
X if (r == ZE_MISS)
X warn("name not matched: ", p);
X else
X err(r, p);
X }
X else /* not an option */
X {
X switch (k)
X {
X case 0:
X if ((zipfile = ziptyp(argv[i])) == NULL)
X err(ZE_MEM, "was processing arguments");
X if ((r = readzipfile()) != ZE_OK)
X err(r, zipfile);
X found = NULL;
X fnxt = &found;
X k = 3;
X break;
X case 1:
X if ((tempath = malloc(strlen(argv[i]) + 1)) == NULL)
X err(ZE_MEM, "was processing arguments");
X strcpy(tempath, argv[i]);
X k = 0;
X break;
X case 2:
X {
X int yy, mm, dd; /* results of sscanf() */
X
X if (sscanf(argv[i], "%2d%2d%2d", &mm, &dd, &yy) != 3 ||
X mm < 1 || mm > 12 || dd < 1 || dd > 31)
X err(ZE_PARMS, "invalid date entered for -t option");
X before = dostime(yy + (yy < 80 ? 2000 : 1900), mm, dd, 0, 0, 0);
X k = 0;
X break;
X }
X case 3: case 4: case 5:
X if ((r = PROCNAME(argv[i])) != ZE_OK)
X if (r == ZE_MISS)
X warn("name not matched: ", argv[i]);
X else
X err(r, argv[i]);
X if (k == 3)
X k = 4;
X }
X }
X }
X if (k < 3)
X exit(0); /* No zip file, don't complain */
X if (k != 5) /* Clean up selections */
X {
X if (k == 3 && (action == UPDATE || action == FRESHEN))
X for (z = zfiles; z != NULL; z = z->nxt)
X z->mark = 1; /* if -u or -f with no args, do all */
X if ((r = exclude()) != ZE_OK) /* remove duplicates in found list */
X if (r == ZE_PARMS)
X err(r, "cannot repeat names in zip file");
X else
X err(r, "was processing list of files");
X }
X if (zcount)
X free((voidp *)zsort);
X
X
X /* Check option combinations */
X if (action == DELETE && (method != BEST || dispose || recurse ||
X dosify || key != NULL || comadd || zipedit))
X err(ZE_PARMS, "invalid option(s) used with -d");
X if (linkput && dosify)
X err(ZE_PARMS, "can't use -y with -k");
X
X /* If -b not specified, make temporary path the same as the zip file */
X#ifdef MSDOS
X if (tempath == NULL && ((p = strrchr(zipfile, '/')) != NULL ||
X (p = strrchr(zipfile, '\\')) != NULL ||
X (p = strrchr(zipfile, ':')) != NULL))
X {
X if (*p == ':')
X p++;
X#else /* !MSDOS */
X if (tempath == NULL && (p = strrchr(zipfile, '/')) != NULL)
X {
X#endif /* ?MSDOS */
X if ((tempath = malloc((int)(p - zipfile) + 1)) == NULL)
X err(ZE_MEM, "was processing arguments");
X r = *p; *p = 0;
X strcpy(tempath, zipfile);
X *p = (char)r;
X }
X
X /* If under MSDOS, force entries to look like made by PKZIP */
X#ifndef OS2
X#ifdef MSDOS
X dosify = 1;
X#endif /* MSDOS */
X#endif /* !OS2 */
X
X
X /* For each marked entry, if not deleting, check if it exists, and if
X updating or freshening, compare date with entry in old zip file.
X Unmark if it doesn't exist or is too old, else update marked count. */
X diag("stating marked entries");
X k = 0; /* Initialize marked count */
X for (z = zfiles; z != NULL; z = z->nxt)
X if (z->mark)
X if (action != DELETE &&
X ((t = filetime(z->name, (ulg *)NULL, (long *)NULL)) == 0 ||
X t < before ||
X ((action == UPDATE || action == FRESHEN) && t <= z->tim)))
X {
X z->mark = 0;
X z->trash = t && t >= before; /* delete if -um or -fm */
X if (verbose)
X printf("zip diagnostic: %s %s\n", z->name,
X z->trash ? "up to date" : "missing or early");
X }
X else
X k++;
X
X
X /* Remove entries from found list that do not exist or are too old */
X diag("stating new entries");
X for (f = found; f != NULL;)
X if (action == DELETE || action == FRESHEN ||
X (t = filetime(f->name, (ulg *)NULL, (long *)NULL)) == 0 ||
X t < before || strcmp(f->name, zipfile) == 0)
X f = fexpel(f);
X else
X f = f->nxt;
X
X
X /* Make sure there's something left to do */
X if (k == 0 && found == NULL && !(zfiles != NULL && (latest || zipedit)))
X if (action == UPDATE || action == FRESHEN)
X leave(ZE_OK);
X else
X err(ZE_NONE, zipfile);
X d = (d && k == 0 && zfiles != NULL); /* d true if just appending */
X
X
X /* Before we get carried away, make sure zip file is writeable */
X if ((x = fopen(zipfile, zfiles == NULL ? FOPW : FOPM)) == NULL)
X err(ZE_CREAT, zipfile);
X fclose(x);
X a = getfileattr(zipfile);
X if (zfiles == NULL)
X destroy(zipfile);
X
X
X /* Open zip file and temporary output file */
X diag("opening zip file and creating temporary zip file");
X x = NULL;
X if (d)
X {
X if ((y = fopen(zipfile, FOPM)) == NULL)
X err(ZE_NAME, zipfile);
X tempzip = zipfile;
X tempzf = y;
X#ifdef MSDOS
X {
X char *zipbuf;
X
X zipbuf = (char *)malloc(BSZ);
X if (zipbuf == NULL)
X err(ZE_MEM, tempzip);
X setbuf(y, zipbuf);
X }
X#endif /* MSDOS */
X if (fseek(y, cenbeg, SEEK_SET))
X err(ferror(y) ? ZE_READ : ZE_EOF, zipfile);
X }
X else
X {
X if (zfiles != NULL && (x = fopen(zipfile, FOPR)) == NULL)
X err(ZE_NAME, zipfile);
X if ((tempzip = tempname('Z')) == NULL)
X err(ZE_MEM, tempzip);
X if ((tempzf = y = fopen(tempzip, FOPW)) == NULL)
X err(ZE_TEMP, tempzip);
X if (zipbeg && (r = fcopy(x, y, zipbeg)) != ZE_OK)
X err(r, r == ZE_TEMP ? tempzip : zipfile);
X }
X o = 0; /* no ZE_OPEN errors yet */
X
X
X /* Process zip file, updating marked files */
X if (zfiles != NULL)
X diag("going through old zip file");
X w = &zfiles;
X while ((z = *w) != NULL)
X if (z->mark)
X {
X /* if not deleting, zip it up */
X if (action != DELETE)
X {
X if (noisy)
X {
X printf("updating %s", z->zname);
X fflush(stdout);
X }
X if ((r = zipup(z, y)) != ZE_OK && r != ZE_OPEN)
X {
X if (noisy)
X {
X putchar('\n');
X fflush(stdout);
X }
X sprintf(errbuf, "was zipping %s", z->name);
X err(r, errbuf);
X }
X if (r == ZE_OPEN)
X {
X o = 1;
X if (noisy)
X {
X putchar('\n');
X fflush(stdout);
X }
X perror("zip warning");
X warn("could not open for reading: ", z->name);
X warn("will just copy entry over: ", z->zname);
X if ((r = zipcopy(z, x, y)) != ZE_OK)
X {
X sprintf(errbuf, "was copying %s", z->zname);
X err(r, errbuf);
X }
X z->mark = 0;
X }
X w = &z->nxt;
X }
X else
X {
X if (noisy)
X {
X printf("deleting %s\n", z->zname);
X fflush(stdout);
X }
X v = z->nxt; /* delete entry from list */
X free((voidp *)(z->name));
X free((voidp *)(z->zname));
X if (z->ext)
X free((voidp *)(z->extra));
X if (z->cext && z->cextra != z->extra)
X free((voidp *)(z->cextra));
X if (z->com)
X free((voidp *)(z->comment));
X farfree((voidp far *)z);
X *w = v;
X zcount--;
X }
X }
X else
X {
X /* copy the original entry verbatim */
X if (!d && (r = zipcopy(z, x, y)) != ZE_OK)
X {
X sprintf(errbuf, "was copying %s", z->zname);
X err(r, errbuf);
X }
X w = &z->nxt;
X }
X if (x != NULL)
X fclose(x);
X
X
X /* Process the edited found list, adding them to the zip file */
X diag("zipping up new entries, if any");
X for (f = found; f != NULL; f = fexpel(f))
X {
X /* add a new zfiles entry and set the name */
X if ((z = (struct zlist far *)farmalloc(sizeof(struct zlist))) == NULL)
X err(ZE_MEM, "was adding files to zip file");
X z->nxt = NULL;
X z->name = f->name;
X f->name = NULL;
X z->zname = f->zname;
X f->zname = NULL;
X z->ext = z->cext = z->com = 0;
X z->mark = 1;
X /* zip it up */
X if (noisy)
X {
X printf("adding %s", z->zname);
X fflush(stdout);
X }
X if ((r = zipup(z, y)) != ZE_OK && r != ZE_OPEN)
X {
X if (noisy)
X {
X putchar('\n');
X fflush(stdout);
X }
X sprintf(errbuf, "was zipping %s", z->name);
X err(r, errbuf);
X }
X if (r == ZE_OPEN)
X {
X o = 1;
X if (noisy)
X {
X putchar('\n');
X fflush(stdout);
X }
X perror("zip warning");
X warn("could not open for reading: ", z->name);
X free((voidp *)(z->name));
X free((voidp *)(z->zname));
X farfree((voidp far *)z);
X }
X else
X {
X *w = z;
X w = &z->nxt;
X zcount++;
X }
X }
X if (key != NULL)
X {
X free((voidp *)key);
X key = NULL;
X }
X
X
X /* Get one line comment for each new entry */
X if (comadd)
X {
X if ((e = malloc(MAXCOM + 1)) == NULL)
X err(ZE_MEM, "was reading comment lines");
X for (z = zfiles; z != NULL; z = z->nxt)
X if (z->mark)
X {
X if (noisy)
X printf("Enter comment for %s:\n", z->name);
X if (fgets(e, MAXCOM+1, stdin) != NULL)
X {
X if ((p = malloc((k = strlen(e))+1)) == NULL)
X {
X free((voidp *)e);
X err(ZE_MEM, "was reading comment lines");
X }
X strcpy(p, e);
X if (p[k-1] == '\n')
X p[--k] = 0;
X z->comment = p;
X z->com = k;
X }
X }
X free((voidp *)e);
X }
X
X /* Get multi-line comment for the zip file */
X if (zipedit)
X {
X if ((e = malloc(MAXCOM + 1)) == NULL)
X err(ZE_MEM, "was reading comment lines");
X if (noisy && zcomlen)
X {
X puts("current zip file comment is:");
X fwrite(zcomment, 1, zcomlen, stdout);
X if (zcomment[zcomlen-1] != '\n')
X putchar('\n');
X free((voidp *)zcomment);
X }
X zcomment = malloc(1);
X *zcomment = 0;
X if (noisy)
X puts("enter new zip file comment (end with .):");
X while (fgets(e, MAXCOM+1, stdin) != NULL && strcmp(e, ".\n"))
X {
X if (e[(r = strlen(e)) - 1] == '\n')
X e[--r] = 0;
X if ((p = malloc((*zcomment ? strlen(zcomment) + 3 : 1) + r)) == NULL)
X {
X free((voidp *)e);
X err(ZE_MEM, "was reading comment lines");
X }
X if (*zcomment)
X strcat(strcat(strcpy(p, zcomment), "\r\n"), e);
X else
X strcpy(p, *e ? e : "\r\n");
X free((voidp *)zcomment);
X zcomment = p;
X }
X zcomlen = strlen(zcomment);
X free((voidp *)e);
X }
X
X
X /* Write central directory and end header to temporary zip */
X diag("writing central directory");
X k = 0; /* keep count for end header */
X if ((c = ftell(y)) == -1L) /* get start of central */
X err(d ? ZE_WRITE : ZE_TEMP, tempzip);
X n = t = 0;
X for (z = zfiles; z != NULL; z = z->nxt)
X {
X if ((r = putcentral(z, y)) != ZE_OK)
X err(r, tempzip);
X n += z->len;
X t += z->siz;
X k++;
X }
X if (k == 0)
X warn("zip file empty", "");
X if (verbose)
X printf("total bytes=%lu, compressed=%lu -> %d%% savings\n",
X n, t, percent(n, t));
X if ((t = ftell(y)) == -1L) /* get end of central */
X err(d ? ZE_WRITE : ZE_TEMP, tempzip);
X t -= c; /* compute length of central */
X diag("writing end of central directory");
X if ((r = putend(k, t, c, zcomlen, zcomment, y)) != ZE_OK)
X err(r, tempzip);
X tempzf = NULL;
X if (fclose(y))
X err(d ? ZE_WRITE : ZE_TEMP, tempzip);
X
X
X /* Replace old zip file with new zip file, leaving only the new one */
X if (!d)
X {
X diag("replacing old zip file with new zip file");
X if ((r = replace(zipfile, tempzip)) != ZE_OK)
X {
X warn("new zip file left as: ", tempzip);
X free((voidp *)tempzip);
X tempzip = NULL;
X err(r, "was replacing the original zip file");
X }
X free((voidp *)tempzip);
X }
X tempzip = NULL;
X setfileattr(zipfile, a);
X
X /* Finish up (process -o, -m, clean up). Exit code depends on o. */
X leave(o ? ZE_OPEN : ZE_OK);
X}
END_OF_FILE
if test 25825 -ne `wc -c <'zip.c'`; then
echo shar: \"'zip.c'\" unpacked with wrong size!
fi
# end of 'zip.c'
fi
if test -f 'zip.doc' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'zip.doc'\"
else
echo shar: Extracting \"'zip.doc'\" \(22854 characters\)
sed "s/^X//" >'zip.doc' <<'END_OF_FILE'
X
X
X
ZIP(1) UNIX Programmer's Manual ZIP(1)
X
X
X
NAME
X zip - package and compress (archive) files
X
SYNOPSIS
X zip [ -cdefghijklmnoqrsuwyz ] [ -b path ] [ -t mmddyy ] zip-
X file list [ -x list ]
X
DESCRIPTION
X Zip is a compression and file packaging utility for Unix,
X MSDOS, OS/2, and VMS. It is analogous to a combination of
X tar and compress and is compatible with PKZIP (Phil Katz
X ZIP) for MSDOS systems.
X
X There is a companion to Zip called UnZip (of course) which
X you should be able to find the same place you got Zip. Zip
X and UnZip can work with files produced by PKZIP under MSDOS,
X and PKZIP and PKUNZIP can work with files produced by Zip.
X
X Zip puts one or more compressed files into a single "zip
X file" along with information about the files, including the
X name, path if requested, date and time last modified, pro-
X tection, and check information to verify the fidelity of
X each entry. Zip can pack an entire directory structure in a
X zip file with a single command. Compression ratios of 2:1
X to 3:1 are common for text files. Zip has two compression
X methods, implosion and shrinking, and automatically chooses
X the better of the two for each file to be compressed.
X
X Zip is useful for packaging a set of files to send to some-
X one or for distribution; for archiving or backing up files;
X and for saving disk space by temporarily compressing unused
X files or directories.
X
HOW TO INSTALL ZIP
X Zip is distributed as C source code that can be compiled on
X a wide range of Unix machines, VAXes running VMS, and MSDOS
X machines using Microsoft or Borland C++, and OS/2 machines
X using Microsoft C. You will need Unzip (under Unix, MSDOS,
X or VMS) or PKUNZIP (under MSDOS) to unpack the distribution
X file, zip10.zip.
X
X First, unpack the source as follows, assuming that you have
X zip10.zip in the current directory:
X
X mkdir zipsrc
X cd zipsrc
X unzip ../zip10
X
X This extracts all source files and documentation in the
X directory called "zipsrc". You then do:
X
X
X make system
X
X where "system" is one of: bsd, bsdold, sysv, next, next10,
X sun, hpux, dnix, cray, 3b1, zilog, aux, convex, aix, or
X minix. If you are using a NeXT running version 2.0 or
X greater, then make next. If you are using 1.0, then make
X next10. If you are using Sun OS 4.x, then make sun. If you
X are using HPUX, then make hpux. The other special systems
X are DNIX 5.2 or 5.3, Cray Unicos, AT&T 3B1 (also known as
X Unix PC or PC 7300), Zilog Zeus, A/UX, Convex, AIX, and
X MINIX. Otherwise, if you are using BSD Unix, try bsd. If
X the linker cannot find _memset or _memcpy, try bsdold. If
X you are using System V Unix or SCO Unix, try sysv. Also use
X sysv on a Silicon Graphics (SGI) machine. You can also
X cross-compile Zip for MSDOS under SCO 386 Unix using "make
X scodos".
X
X If none of these compiles, links, and functions properly on
X your Unix system, see the section BUGS below for how to get
X help.
X
X If the appropriate system was selected, then the executable
X "zip" will be created. You can move the executable "zip" to
X an appropriate directory in the search path using a command
X like:
X
X mv zip ~/bin
X
X or
X
X mv zip /usr/local/bin
X
X You can use the command "set" to see the current search
X path. If you are using the C-Shell (csh), enter the com-
X mand:
X
X rehash
X
X so csh can find the new command in the path. You are now
X ready to use Zip.
X
X You can also move the manual page (the raw form of what
X you're reading) to where the Unix man command can find it
X (assuming you have the necessary privileges):
X
X mv zip.1 /usr/man/man1
X
X You can get rid of the now unnecessary source and object
X files with:
X
X cd ..
X rm -r zipsrc
X
X This will remove the directory zip and its contents created
X by unzip. You should keep the zip10.zip file around though,
X in case you need to build it again or want to give it to a
X colleague.
X
X The steps for installation under MSDOS, OS/2, and VMS are
X similar to the above: first unzip the distribution files
X into their own directory. Then under MSDOS do one of:
X
X make makefile.msc
X make -fmakefile.bor
X
X
X for Microsoft or Borland C++, respectively. Under OS/2:
X
X nmake -f makefile.os2
X
X for Microsoft C 6.00. Under VAX VMS:
X
X
X @makevms
X
X The installation process will also compile and link several
X other utilities. They are zipcloak for encrypting and
X decrypting zip files, zipnote for editing zip file comments,
X zipsplit for splitting a zip file into several zip files,
X and ship for sending zip files or any other binary file via
X electronic mail. For command help on any of the zip* utili-
X ties, simply enter the name with no arguments. For help
X with ship, enter "ship -h".
X
HOW TO USE ZIP
X The simplest use of Zip is as follows:
X
X zip stuff *
X
X This will create the file "stuff.zip" (assuming it does not
X exist) and put all the files in the current directory in
X stuff.zip in a compressed form. The .zip suffix is added
X automatically, unless that file name given contains a dot
X already. This allows specifying suffixes other than ".zip".
X
X Because of the way the shell does filename substitution,
X files that start with a "." are not included. To include
X those as well, you can:
X
X zip stuff .* *
X
X Even this will not include any subdirectories that are in
X the current directory. To zip up an entire directory, the
X command:
X
X zip -r foo foo
X
X will create the file "foo.zip" containing all the files and
X directories in the directory "foo" that is in the current
X directory. The "r" option means recurse through the direc-
X tory structure. In this case, all the files and directories
X in foo are zipped, including the ones that start with a ".",
X since the recursion does not use the shell's file-name sub-
X stitution. You should not use -r with the name ".*", since
X that matches ".." which will attempt to zip up the parent
X directory--probably not what was intended.
X
X You may want to make a zip file that contains the files in
X foo, but not record the directory name, foo. You can use
X the -j (junk path) option to leave off the path:
X
X zip -j foo foo/*
X
X The -y option (only under Unix) will store symbolic links as
X such in the zip file, instead of compressing and storing the
X file referred to in the link.
X
X You might be zipping to save disk space, in which case you
X could:
X
X zip -rm foo foo
X
X where the "m" option means "move". This will delete foo and
X its contents after making foo.zip. No deletions will be
X done until the zip has completed with no errors. This
X option is obviously more dangerous and should be used with
X care.
X
X
X If the zip file already exists, these commands will replace
X existing or add new entries to the zip file. For example,
X if you were really short on disk space, you might not have
X enough room simultaneously to hold the directory foo and the
X compressed foo.zip. In this case, you could do it in steps.
X If foo contained the subdirectories tom, dick, and harry,
X then you could:
X
X zip -rm foo foo/tom
X zip -rm foo foo/dick
X zip -rm foo foo/harry
X
X where the first command would create foo.zip, and the next
X two would add to it. At the completion of each zip command,
X the directory just zipped would be deleted, making room in
X which the next Zip command could work.
X
MODIFYING EXISTING ZIP FILES
X When given the name of an existing zip file with the above
X commands, Zip will replace identically named entries in the
X Zip file or add entries for new names. For example, if
X foo.zip exists and contains foo/file1 and foo/file2, and the
X directory foo contains the files foo/file1 and foo/file3,
X then:
X
X zip -r foo foo
X
X will replace foo/file1 in foo.zip and add foo/file3 to
X foo.zip. After this, foo.zip contains foo/file1, foo/file2,
X and foo/file3, with foo/file2 unchanged from before.
X
X When changing an existing zip file, Zip will write a tem-
X porary file with the new contents, and only replace the old
X one when the zip has completed with no errors. Also, the
X two methods, shrink and implode, create temporary files that
X are deleted after each file is zipped. You can use the -b
X option to specify a different path (usually a different dev-
X ice) to put the temporary files in. For example:
X
X zip -b /tmp stuff *
X
X will put the temporary zip file and the temporary compres-
X sion files in the directory "/tmp", copying over stuff.zip
X in the current directory when done.
X
X If you are only adding entries to a zip file, not replacing,
X and the -g option is given, then Zip grows (appends to) the
X file instead of copying it. The danger of this is that if
X the operation fails, the original zip file is corrupted and
X lost.
X
X There are two other ways to change or add entries in a zip
X file that are restrictions of simple addition or replace-
X ment. The first is -u (update) which will add new entries
X to the zip file as before but will replace existing entries
X only if the modified date of the file is more recent than
X the date recorded for that name in the zip file. For exam-
X ple:
X
X zip -u stuff *
X
X will add any new files in the current directory, and update
X any changed files in the zip file stuff.zip. Note that Zip
X will not try to pack stuff.zip into itself when you do this.
X Zip will always exclude the zip file from the files on which
X to be operated.
X
X The second restriction is -f (freshen) which, like update,
X will only replace entries with newer files; unlike update,
X will not add files that are not already in the zip file.
X For this option, you may want to simply freshen all of the
X files that are in the specified zip file. To do this you
X would simply:
X
X zip -f foo
X
X Note that the -f option with no arguments freshens all the
X entries in the zip file. The same is true of -u, and hence
X "zip -u foo" and "zip -f foo" both do the same thing.
X
X This command should be run from the same directory from
X which the original zip command was run, since paths stored
X in zip files are always relative.
X
X Another restriction that can be used with adding, updating,
X or freshening is -t (time), which will not operate on files
X modified earlier than the specified date. For example:
X
X zip -rt 120791 infamy foo
X
X will add all the files in foo and its subdirectories that
X were last modified on December 7, 1991, or later to the zip
X file infamy.zip.
X
X Also, files can be explicitly excluded using the -x option:
X
X zip -r foo foo -x \*.o
X
X which will zip up the contents of foo into foo.zip but
X exclude all the files that end in ".o". Here the backslash
X causes Zip to match file names that were found when foo was
X searched.
X
X The last operation is -d (delete) which will remove entries
X from a zip file. An example might be:
X
X zip -d foo foo/tom/junk foo/harry/\* \*.o
X
X which will remove the entry foo/tom/junk, all of the files
X that start with "foo/harry/", and all of the files that end
X with ".o" (in any path). Note that once again, the shell
X expansion has been inhibited with backslashes, so that Zip
X can see the asterisks. Zip can then match on the contents of
X the zip file instead of the contents of the current direc-
X tory.
X
X Under MSDOS, -d is case sensitive when it matches names in
X the zip file. This allows deleting names that were zipped
X on other systems, but requires that the names be entered in
X upper case if they were zipped on an MSDOS system, so that
X the names can be found in the zip file and deleted.
X
MORE OPTIONS
X As mentioned before, Zip will use the best of two methods:
X shrink or implode. Usually implode is better, but sometimes
X shrink is better, especially for smaller files. Sometimes
X neither method produces a packed version smaller than the
X original file, in which case it is stored in the zip file
X with no compression (called the "store" method).
X
X The option -s (shrink) will force Zip always to use shrink
X or store, and the -i (implode) option forces Zip to use
X implode or store. Shrinking is faster than imploding, and
X so -s might be used when speed is more important than
X optimal compression. Implode only (-i) might be used when
X the unzipper for which the zip file is destined can only
X handle implosion. An example of this is the PKSFXjr program
X that comes with PKZIP. Also, -i is slightly faster than
X imploding and shrinking at the same time. For example:
X
X zip -rs foo foo
X
X will zip up the directory foo into foo.zip using only shrink
X or store. The speed of implosion can also be controlled
X with options -0 (fastest method but less compression) to -9
X (best compression but slower). The default value is -5. For
X example:
X
X zip -r0 foo foo
X
X In nearly all cases, a file that is already compressed can-
X not be compressed further by Zip, or if it can, the effect
X is minimal. The -n option prevents Zip from trying to
X compress files that have the suffixes: .Z, .zip, .zoo, or
X .arc. Such files are simply stored (0% compression) in the
X output zip file, so that Zip doesn't waste its time trying
X to compress them. If the environment variable NOZIP is set,
X then the suffixes listed there are used instead of the
X default list. The suffixes are separated by either colons
X or semicolons. For example, in Unix csh:
X
X setenv NOZIP .Z:.zip:.tiff:.gif:.snd
X zip -rn foo foo
X
X will put everything in foo into foo.zip, but will store any
X files that end in .Z, .zip, .tiff, .gif, or .snd without
X trying to compress them. (Image and sound files often have
X their own specialized compression methods.) If the environ-
X ment variable NOZIP exists but is empty or contains just a
X colon or semicolon, then zip -n will store all the entries
X and do no compression.
X
X Under Unix and under OS/2 (if files from a HPFS are stored),
X Zip will store the full path (relative to the current path)
X and name of the file (or just the name if -j is specified)
X in the zip file along with the Unix attributes, and it will
X mark the entry as made under Unix. If the zip file is
X intended for PKUNZIP under MSDOS, then the -k (Katz) option
X should be used to attempt to convert the names and paths to
X conform to MSDOS, store only the MSDOS attribute (just the
X user write attribute from Unix), and mark the entry as made
X under MSDOS (even though it wasn't).
X
X The -o (older) option will set the "last modified" time of
X the zip file to the latest "last modified" time of the
X entries in the zip file. This can be used without any other
X operations, if desired. For example:
X
X zip -o foo
X
X
X will change the last modified time of foo.zip to the latest
X time of the entries in foo.zip.
X
X The -e and -c options operate on all files updated or added
X to the zip file. Encryption (-e) will prompt for a password
X on the terminal and will not echo the password as it is
X typed (if stderr is not a TTY, Zip will exit with an error).
X New zip entries will be encrypted using that password. For
X added peace of mind, you can use -ee, which will prompt for
X the password twice, checking that the two are the same
X before using it.
X
X One-line comments can be added for each file with the -c
X option. The zip file operations (adding or updating) will
X be done first, and you will then be prompted for a one-line
X comment for each file. You can then enter the comment fol-
X lowed by return, or just return for no comment.
X
X The -z option will prompt you for a multi-line comment for
X the entire zip file. This option can be used by itself, or
X in combination with other options. The comment is ended by
X a line containing just a period, or an end of file condition
X (^D on Unix, ^Z on MSDOS, OS/2, and VAX/VMS). Since -z
X reads the lines from stdin, you can simply take the comment
X from a file:
X
X zip -z foo < foowhat
X
X The -q (quiet) option eliminates the informational messages
X and comment prompts while Zip is operating. This might be
X used in shell scripts, for example, or if the zip operation
X is being performed as a background task ("zip -q foo *.c
X &").
X
X Zip can take a list of file names to operate on from stdin
X using the - option. In Unix, this option can be used with
X the find command to extend greatly the functionality of Zip.
X For example, to zip up all the C source files in the current
X directory and its subdirectories, you can:
X
X find . -type f -name "*.[ch]" -print | zip source -
X
X Note that the pattern must be quoted to keep the shell from
X expanding it.
X
X Under VMS only, the -w option will append the version number
X of the files to the name and zip up multiple versions of
X files. Without -w, Zip will only use the most recent ver-
X sion of the specified file(s).
X
X If Zip is run with no arguments or with the -h option, the
X license and the command-argument and option help is shown.
X The -l option just shows the license.
X
ABOUT PATTERN MATCHING
X (Note: this section applies to Unix. Watch this space for
X details on MSDOS and VMS operation.)
X
X The Unix shell (sh or csh) does filename substitution on
X command arguments. The special characters are ?, which
X matches any single character; * which matches any number of
X characters (including none); and [] which matches any char-
X acter in the range inside the brackets (like [a-f] or
X [0-9]). When these characters are encountered (and not
X escaped with a backslash or quotes), the shell will look for
X files relative to the current path that match the pattern,
X and replace the argument with a list of the names that
X matched.
X
X Zip can do the same matching on names that are in the zip
X file being modified or, in the case of the -x (exclude)
X option, on the list of files to be operated on, by using
X backslashes or quotes to tell the shell not to do the name
X expansion. In general, when Zip encounters a name in the
X list of files to do, it first looks for the name in the file
X system. If it finds it, it then adds it to the list of
X files to do. If it does not find it, it will look for the
X name in the zip file being modified (if it exists), using
X the pattern matching characters above, if any. For each
X match, it will add that name to the list of files to do.
X After -x (exclude), the names are removed from the to-do
X list instead of added.
X
X The pattern matching includes the path, and so patterns like
X \*.o match names that end in ".o", no matter what the path
X prefix is. Note that the backslash must precede every spe-
X cial character (i.e. ?*[]), or the entire argument must be
X enclosed in double quotes ("").
X
X In general, using backslash to make Zip do the pattern
X matching is used with the -f (freshen) and -d (delete)
X options, and sometimes after the -x (exclude) option when
X used with any operation (add, -u, -f, or -d). Zip will
X never use pattern matching to search the file system. If
X Zip has recursed into a directory, all files (and all direc-
X tories) in there are fair game.
X
COPYRIGHT
X Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, and
X Jean-loup Gailly. Permission is granted to any individual
X or institution to use, copy, or redistribute this software
X so long as all of the original files are included unmodi-
X fied, that it is not sold for profit, and that this copy-
X right notice is retained.
X
ACKNOWLEDGEMENTS
X Thanks to R. P. Byrne for his Shrink.Pas program which
X inspired this project, and from which the shrink algorithm
X was stolen; to Phil Katz for making the zip file format,
X compression format, and .ZIP filename extension all public
X domain; to Keith Petersen for providing a mailing list and
X ftp site for the INFO-ZIP group to use; and most impor-
X tantly, to the INFO-ZIP group itself (listed in the file
X infozip.who) without whose tireless testing and bug-fixing
X efforts a portable Zip would not have been possible.
X Finally we should thank (blame) the INFO-ZIP moderator,
X David Kirschbaum for getting us into this mess in the first
X place.
X
SEE ALSO
X unzip(1), tar(1), compress(1)
X
BUGS
X Versions of PKUNZIP before 1.1 have a bug that on rare occa-
X sions will prevent it from unzipping files produced by Zip
X or PKZIP 1.1. If you experience such problems, we recommend
X that you get PKUNZIP 1.1 or the portable Unzip, neither of
X which have this problem.
X
X Under MSDOS, Zip will find hidden and system files, but not
X set the attributes appropriately in the zip file so that
X Unzip can restore them. This will be fixed in the next
X version.
X
X Under VMS, not all of the odd file formats are treated prop-
X erly. Only stream-LF format zip files are expected to work
X with Zip. Others can be converted using Rahul Dhesi's BILF
X program. The next version of Zip will handle some of the
X conversion internally.
X
X LIKE ANYTHING ELSE THAT'S FREE, ZIP AND ITS ASSOCIATED UTIL-
X ITIES ARE PROVIDED AS IS AND COME WITH NO WARRANTY OF ANY
X KIND, EITHER EXPRESSED OR IMPLIED. IN NO EVENT WILL THE
X COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES RESULTING FROM
X THE USE OF THIS SOFTWARE.
X
X That having been said, please send any problems or comments
X via email to the Internet address zip-...@cs.ucla.edu. For
X bug reports, please include the version of Zip, the make
X options you used to compile it, the machine and operating
X system you are using, and as much additional information as
X possible. Thank you for your support.
X
END_OF_FILE
if test 22854 -ne `wc -c <'zip.doc'`; then
echo shar: \"'zip.doc'\" unpacked with wrong size!
fi
# end of 'zip.doc'
fi
echo shar: End of archive 4 \(of 7\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 5 6 7 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 7 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0