#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1985, 1986 The Regents of the University of California.\n\
All rights reserved.\n";
#endif
#ifndef lint
static char sccsid[] = "@(#)compress.c 5.10 (Berkeley) 10/15/88";
#endif
#define min(a,b) ((a>b) ? b : a)
#ifndef SACREDMEM
#define SACREDMEM 0
#endif
#ifndef USERMEM
# define USERMEM 450000
#endif
#ifdef interdata
#define SIGNED_COMPARE_SLOW
#endif
#ifdef pdp11
# define BITS 12
# define NO_UCHAR
# undef USERMEM
#endif
#ifdef z8000
# define BITS 12
# undef vax
# undef USERMEM
#endif
#ifdef pcxt
# define BITS 12
# undef USERMEM
#endif
#ifdef USERMEM
# if USERMEM >= (433484+SACREDMEM)
# define PBITS 16
# else
# if USERMEM >= (229600+SACREDMEM)
# define PBITS 15
# else
# if USERMEM >= (127536+SACREDMEM)
# define PBITS 14
# else
# if USERMEM >= (73464+SACREDMEM)
# define PBITS 13
# else
# define PBITS 12
# endif
# endif
# endif
# endif
# undef USERMEM
#endif
#ifdef PBITS
# ifndef BITS
# define BITS PBITS
# endif
#endif
#if BITS == 16
# define HSIZE 69001
#endif
#if BITS == 15
# define HSIZE 35023
#endif
#if BITS == 14
# define HSIZE 18013
#endif
#if BITS == 13
# define HSIZE 9001
#endif
#if BITS <= 12
# define HSIZE 5003
#endif
#ifdef M_XENIX
# if BITS == 16
# define XENIX_16
# else
# if BITS > 13
# define BITS 13
# endif
# endif
#endif
#if BITS > 15
typedef long int code_int;
#else
typedef int code_int;
#endif
#ifdef SIGNED_COMPARE_SLOW
typedef unsigned long int count_int;
typedef unsigned short int count_short;
#else
typedef long int count_int;
#endif
#ifdef NO_UCHAR
typedef char char_type;
#else
typedef unsigned char char_type;
#endif
char_type magic_header[] = { "\037\235" };
#define BIT_MASK 0x1f
#define BLOCK_MASK 0x80
#define INIT_BITS 9
static char rcs_ident[] = "Header: compress.c,v 4.0 85/07/30 12:50:00 joe Release";
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef notdef
#include <sys/ioctl.h>
#endif
#define ARGVAL() (*++(*argv) || (--argc && *++argv))
int n_bits;
int maxbits = BITS;
code_int maxcode;
code_int maxmaxcode = 1 << BITS;
#ifdef COMPATIBLE
# define MAXCODE(n_bits) (1 << (n_bits) - 1)
#else
# define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
#endif
#ifdef XENIX_16
count_int htab0[8192];
count_int htab1[8192];
count_int htab2[8192];
count_int htab3[8192];
count_int htab4[8192];
count_int htab5[8192];
count_int htab6[8192];
count_int htab7[8192];
count_int htab8[HSIZE-65536];
count_int * htab[9] = {
htab0, htab1, htab2, htab3, htab4, htab5, htab6, htab7, htab8 };
#define htabof(i) (htab[(i) >> 13][(i) & 0x1fff])
unsigned short code0tab[16384];
unsigned short code1tab[16384];
unsigned short code2tab[16384];
unsigned short code3tab[16384];
unsigned short code4tab[16384];
unsigned short * codetab[5] = {
code0tab, code1tab, code2tab, code3tab, code4tab };
#define codetabof(i) (codetab[(i) >> 14][(i) & 0x3fff])
#else
#ifdef sel
count_int htab [HSIZE];
unsigned short codetab [HSIZE];
#else
count_int htab [HSIZE];
unsigned short codetab [HSIZE];
#endif
#define htabof(i) htab[i]
#define codetabof(i) codetab[i]
#endif
code_int hsize = HSIZE;
count_int fsize;
#define tab_prefixof(i) codetabof(i)
#ifdef XENIX_16
# define tab_suffixof(i) ((char_type *)htab[(i)>>15])[(i) & 0x7fff]
# define de_stack ((char_type *)(htab2))
#else
# define tab_suffixof(i) ((char_type *)(htab))[i]
# define de_stack ((char_type *)&tab_suffixof(1<<BITS))
#endif
code_int free_ent = 0;
int exit_stat = 0;
int perm_stat = 0;
code_int getcode();
Usage() {
#ifdef DEBUG
fprintf(stderr,"Usage: compress [-dDVfc] [-b maxbits] [file ...]\n");
}
int debug = 0;
#else
fprintf(stderr,"Usage: compress [-fvc] [-b maxbits] [file ...]\n");
}
#endif
int nomagic = 0;
int zcat_flg = 0;
int precious = 1;
int quiet = 1;
int block_compress = BLOCK_MASK;
int clear_flg = 0;
long int ratio = 0;
#define CHECK_GAP 10000
count_int checkpoint = CHECK_GAP;
#define FIRST 257
#define CLEAR 256
int force = 0;
char ofname [100];
#ifdef DEBUG
int verbose = 0;
#endif
int (*oldint)();
int bgnd_flag;
int do_decomp = 0;
main( argc, argv )
register int argc; char **argv;
{
int overwrite = 0;
char tempname[100];
char **filelist, **fileptr;
char *cp, *rindex(), *malloc();
struct stat statbuf;
extern onintr(), oops();
if ( (oldint = signal ( SIGINT, SIG_IGN )) != SIG_IGN ) {
signal ( SIGINT, onintr );
signal ( SIGSEGV, oops );
}
bgnd_flag = oldint != SIG_DFL;
#ifdef notdef
{ int tgrp;
if (bgnd_flag == 0 && ioctl(2, TIOCGPGRP, (char *)&tgrp) == 0 &&
getpgrp(0) != tgrp)
bgnd_flag = 1;
}
#endif
#ifdef COMPATIBLE
nomagic = 1;
#endif
filelist = fileptr = (char **)(malloc(argc * sizeof(*argv)));
*filelist = NULL;
if((cp = rindex(argv[0], '/')) != 0) {
cp++;
} else {
cp = argv[0];
}
if(strcmp(cp, "uncompress") == 0) {
do_decomp = 1;
} else if(strcmp(cp, "zcat") == 0) {
do_decomp = 1;
zcat_flg = 1;
}
#if defined(BSD4_2) && !defined(__UNIXOS2__)
setlinebuf( stderr );
#endif
for (argc--, argv++; argc > 0; argc--, argv++) {
if (**argv == '-') {
while (*++(*argv)) {
switch (**argv) {
#ifdef DEBUG
case 'D':
debug = 1;
break;
case 'V':
verbose = 1;
version();
break;
#else
case 'V':
version();
break;
#endif
case 'v':
quiet = 0;
break;
case 'd':
do_decomp = 1;
break;
case 'f':
case 'F':
overwrite = 1;
force = 1;
break;
case 'n':
nomagic = 1;
break;
case 'C':
block_compress = 0;
break;
case 'b':
if (!ARGVAL()) {
fprintf(stderr, "Missing maxbits\n");
Usage();
exit(1);
}
maxbits = atoi(*argv);
goto nextarg;
case 'c':
zcat_flg = 1;
break;
case 'q':
quiet = 1;
break;
default:
fprintf(stderr, "Unknown flag: '%c'; ", **argv);
Usage();
exit(1);
}
}
}
else {
*fileptr++ = *argv;
*fileptr = NULL;
}
nextarg: continue;
}
if(maxbits < INIT_BITS) maxbits = INIT_BITS;
if (maxbits > BITS) maxbits = BITS;
maxmaxcode = 1 << maxbits;
if (*filelist != NULL) {
for (fileptr = filelist; *fileptr; fileptr++) {
exit_stat = 0;
if (do_decomp) {
if (strcmp(*fileptr + strlen(*fileptr) - 2, ".Z") != 0) {
strcpy(tempname, *fileptr);
strcat(tempname, ".Z");
*fileptr = tempname;
}
if ((freopen(*fileptr, "r", stdin)) == NULL) {
perror(*fileptr);
perm_stat = 1;
continue;
}
if (nomagic == 0) {
if ((getchar() != (magic_header[0] & 0xFF))
|| (getchar() != (magic_header[1] & 0xFF))) {
fprintf(stderr, "%s: not in compressed format\n",
*fileptr);
continue;
}
maxbits = getchar();
block_compress = maxbits & BLOCK_MASK;
maxbits &= BIT_MASK;
maxmaxcode = 1 << maxbits;
if(maxbits > BITS) {
fprintf(stderr,
"%s: compressed with %d bits, can only handle %d bits\n",
*fileptr, maxbits, BITS);
continue;
}
}
strcpy(ofname, *fileptr);
ofname[strlen(*fileptr) - 2] = '\0';
} else {
if (strcmp(*fileptr + strlen(*fileptr) - 2, ".Z") == 0) {
fprintf(stderr, "%s: already has .Z suffix -- no change\n",
*fileptr);
continue;
}
if ((freopen(*fileptr, "r", stdin)) == NULL) {
perror(*fileptr);
perm_stat = 1;
continue;
}
stat ( *fileptr, &statbuf );
fsize = (long) statbuf.st_size;
hsize = HSIZE;
if ( fsize < (1 << 12) )
hsize = min ( 5003, HSIZE );
else if ( fsize < (1 << 13) )
hsize = min ( 9001, HSIZE );
else if ( fsize < (1 << 14) )
hsize = min ( 18013, HSIZE );
else if ( fsize < (1 << 15) )
hsize = min ( 35023, HSIZE );
else if ( fsize < 47000 )
hsize = min ( 50021, HSIZE );
strcpy(ofname, *fileptr);
#ifndef BSD4_2
if ((cp=rindex(ofname,'/')) != NULL) cp++;
else cp = ofname;
if (strlen(cp) > 12) {
fprintf(stderr,"%s: filename too long to tack on .Z\n",cp);
continue;
}
#endif
strcat(ofname, ".Z");
}
if (overwrite == 0 && zcat_flg == 0) {
if (stat(ofname, &statbuf) == 0) {
char response[2];
response[0] = 'n';
fprintf(stderr, "%s already exists;", ofname);
if (bgnd_flag == 0 && isatty(2)) {
fprintf(stderr, " do you wish to overwrite %s (y or n)? ",
ofname);
fflush(stderr);
read(2, response, 2);
while (response[1] != '\n') {
if (read(2, response+1, 1) < 0) {
perror("stderr"); break;
}
}
}
if (response[0] != 'y') {
fprintf(stderr, "\tnot overwritten\n");
continue;
}
}
}
if(zcat_flg == 0) {
if (freopen(ofname, "w", stdout) == NULL) {
perror(ofname);
perm_stat = 1;
continue;
}
precious = 0;
if(!quiet)
fprintf(stderr, "%s: ", *fileptr);
}
#ifdef __UNIXOS2__
_fsetmode(stdin,"b");
_fsetmode(stdout,"b");
#endif
if (do_decomp == 0) compress();
#ifndef DEBUG
else decompress();
#else
else if (debug == 0) decompress();
else printcodes();
if (verbose) dump_tab();
#endif
if(zcat_flg == 0) {
copystat(*fileptr, ofname);
precious = 1;
if((exit_stat == 1) || (!quiet))
putc('\n', stderr);
}
}
} else {
#ifdef __UNIXOS2__
_fsetmode(stdin,"b");
_fsetmode(stdout,"b");
#endif
if (do_decomp == 0) {
compress();
#ifdef DEBUG
if(verbose) dump_tab();
#endif
if(!quiet)
putc('\n', stderr);
} else {
if (nomagic == 0) {
if ((getchar()!=(magic_header[0] & 0xFF))
|| (getchar()!=(magic_header[1] & 0xFF))) {
fprintf(stderr, "stdin: not in compressed format\n");
exit(1);
}
maxbits = getchar();
block_compress = maxbits & BLOCK_MASK;
maxbits &= BIT_MASK;
maxmaxcode = 1 << maxbits;
fsize = 100000;
if(maxbits > BITS) {
fprintf(stderr,
"stdin: compressed with %d bits, can only handle %d bits\n",
maxbits, BITS);
exit(1);
}
}
#ifndef DEBUG
decompress();
#else
if (debug == 0) decompress();
else printcodes();
if (verbose) dump_tab();
#endif
}
}
exit(perm_stat ? perm_stat : exit_stat);
}
static int offset;
long int in_count = 1;
long int bytes_out;
long int out_count = 0;
compress() {
register long fcode;
register code_int i = 0;
register int c;
register code_int ent;
#ifdef XENIX_16
register code_int disp;
#else
register int disp;
#endif
register code_int hsize_reg;
register int hshift;
#ifndef COMPATIBLE
if (nomagic == 0) {
putchar(magic_header[0]); putchar(magic_header[1]);
putchar((char)(maxbits | block_compress));
if(ferror(stdout))
writeerr();
}
#endif
offset = 0;
bytes_out = 3;
out_count = 0;
clear_flg = 0;
ratio = 0;
in_count = 1;
checkpoint = CHECK_GAP;
maxcode = MAXCODE(n_bits = INIT_BITS);
free_ent = ((block_compress) ? FIRST : 256 );
ent = getchar ();
hshift = 0;
for ( fcode = (long) hsize; fcode < 65536L; fcode *= 2L )
hshift++;
hshift = 8 - hshift;
hsize_reg = hsize;
cl_hash( (count_int) hsize_reg);
#ifdef SIGNED_COMPARE_SLOW
while ( (c = getchar()) != (unsigned) EOF ) {
#else
while ( (c = getchar()) != EOF ) {
#endif
in_count++;
fcode = (long) (((long) c << maxbits) + ent);
i = ((c << hshift) ^ ent);
if ( htabof (i) == fcode ) {
ent = codetabof (i);
continue;
} else if ( (long)htabof (i) < 0 )
goto nomatch;
disp = hsize_reg - i;
if ( i == 0 )
disp = 1;
probe:
if ( (i -= disp) < 0 )
i += hsize_reg;
if ( htabof (i) == fcode ) {
ent = codetabof (i);
continue;
}
if ( (long)htabof (i) > 0 )
goto probe;
nomatch:
output ( (code_int) ent );
out_count++;
ent = c;
#ifdef SIGNED_COMPARE_SLOW
if ( (unsigned) free_ent < (unsigned) maxmaxcode) {
#else
if ( free_ent < maxmaxcode ) {
#endif
codetabof (i) = free_ent++;
htabof (i) = fcode;
}
else if ( (count_int)in_count >= checkpoint && block_compress )
cl_block ();
}
output( (code_int)ent );
out_count++;
output( (code_int)-1 );
if(zcat_flg == 0 && !quiet) {
#ifdef DEBUG
fprintf( stderr,
"%ld chars in, %ld codes (%ld bytes) out, compression factor: ",
in_count, out_count, bytes_out );
prratio( stderr, in_count, bytes_out );
fprintf( stderr, "\n");
fprintf( stderr, "\tCompression as in compact: " );
prratio( stderr, in_count-bytes_out, in_count );
fprintf( stderr, "\n");
fprintf( stderr, "\tLargest code (of last block) was %d (%d bits)\n",
free_ent - 1, n_bits );
#else
fprintf( stderr, "Compression: " );
prratio( stderr, in_count-bytes_out, in_count );
#endif
}
if(bytes_out > in_count)
exit_stat = 2;
return;
}
static char buf[BITS];
#ifndef vax
char_type lmask[9] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
char_type rmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
#endif
output( code )
code_int code;
{
#ifdef DEBUG
static int col = 0;
#endif
register int r_off = offset, bits= n_bits;
register char * bp = buf;
#ifdef DEBUG
if ( verbose )
fprintf( stderr, "%5d%c", code,
(col+=6) >= 74 ? (col = 0, '\n') : ' ' );
#endif
if ( code >= 0 ) {
#ifdef vax
0;
asm( "insv 4(ap),r11,r10,(r9)" );
#else
bp += (r_off >> 3);
r_off &= 7;
*bp = (*bp & rmask[r_off]) | (code << r_off) & lmask[r_off];
bp++;
bits -= (8 - r_off);
code >>= 8 - r_off;
if ( bits >= 8 ) {
*bp++ = code;
code >>= 8;
bits -= 8;
}
if(bits)
*bp = code;
#endif
offset += n_bits;
if ( offset == (n_bits << 3) ) {
bp = buf;
bits = n_bits;
bytes_out += bits;
do
putchar(*bp++);
while(--bits);
offset = 0;
}
if ( free_ent > maxcode || (clear_flg > 0))
{
if ( offset > 0 ) {
if( fwrite( buf, 1, n_bits, stdout ) != n_bits)
writeerr();
bytes_out += n_bits;
}
offset = 0;
if ( clear_flg ) {
maxcode = MAXCODE (n_bits = INIT_BITS);
clear_flg = 0;
}
else {
n_bits++;
if ( n_bits == maxbits )
maxcode = maxmaxcode;
else
maxcode = MAXCODE(n_bits);
}
#ifdef DEBUG
if ( debug ) {
fprintf( stderr, "\nChange to %d bits\n", n_bits );
col = 0;
}
#endif
}
} else {
if ( offset > 0 )
fwrite( buf, 1, (offset + 7) / 8, stdout );
bytes_out += (offset + 7) / 8;
offset = 0;
fflush( stdout );
#ifdef DEBUG
if ( verbose )
fprintf( stderr, "\n" );
#endif
if( ferror( stdout ) )
writeerr();
}
}
decompress() {
register char_type *stackp;
register int finchar;
register code_int code, oldcode, incode;
maxcode = MAXCODE(n_bits = INIT_BITS);
for ( code = 255; code >= 0; code-- ) {
tab_prefixof(code) = 0;
tab_suffixof(code) = (char_type)code;
}
free_ent = ((block_compress) ? FIRST : 256 );
finchar = oldcode = getcode();
if(oldcode == -1)
return;
putchar( (char)finchar );
if(ferror(stdout))
writeerr();
stackp = de_stack;
while ( (code = getcode()) > -1 ) {
if ( (code == CLEAR) && block_compress ) {
for ( code = 255; code >= 0; code-- )
tab_prefixof(code) = 0;
clear_flg = 1;
free_ent = FIRST - 1;
if ( (code = getcode ()) == -1 )
break;
}
incode = code;
if ( code >= free_ent ) {
*stackp++ = finchar;
code = oldcode;
}
#ifdef SIGNED_COMPARE_SLOW
while ( ((unsigned long)code) >= ((unsigned long)256) ) {
#else
while ( code >= 256 ) {
#endif
*stackp++ = tab_suffixof(code);
code = tab_prefixof(code);
}
*stackp++ = finchar = tab_suffixof(code);
do
putchar ( *--stackp );
while ( stackp > de_stack );
if ( (code=free_ent) < maxmaxcode ) {
tab_prefixof(code) = (unsigned short)oldcode;
tab_suffixof(code) = finchar;
free_ent = code+1;
}
oldcode = incode;
}
fflush( stdout );
if(ferror(stdout))
writeerr();
}
code_int
getcode() {
register code_int code;
static int offset = 0, size = 0;
static char_type buf[BITS];
register int r_off, bits;
register char_type *bp = buf;
if ( clear_flg > 0 || offset >= size || free_ent > maxcode ) {
if ( free_ent > maxcode ) {
n_bits++;
if ( n_bits == maxbits )
maxcode = maxmaxcode;
else
maxcode = MAXCODE(n_bits);
}
if ( clear_flg > 0) {
maxcode = MAXCODE (n_bits = INIT_BITS);
clear_flg = 0;
}
size = fread( buf, 1, n_bits, stdin );
if ( size <= 0 )
return -1;
offset = 0;
size = (size << 3) - (n_bits - 1);
}
r_off = offset;
bits = n_bits;
#ifdef vax
asm( "extzv r10,r9,(r8),r11" );
#else
bp += (r_off >> 3);
r_off &= 7;
#ifdef NO_UCHAR
code = ((*bp++ >> r_off) & rmask[8 - r_off]) & 0xff;
#else
code = (*bp++ >> r_off);
#endif
bits -= (8 - r_off);
r_off = 8 - r_off;
if ( bits >= 8 ) {
#ifdef NO_UCHAR
code |= (*bp++ & 0xff) << r_off;
#else
code |= *bp++ << r_off;
#endif
r_off += 8;
bits -= 8;
}
code |= (*bp & rmask[bits]) << r_off;
#endif
offset += n_bits;
return code;
}
char *
rindex(s, c)
register char *s, c;
{
char *p;
for (p = NULL; *s; s++)
if (*s == c)
p = s;
return(p);
}
#ifdef DEBUG
printcodes()
{
code_int code;
int col = 0, bits;
bits = n_bits = INIT_BITS;
maxcode = MAXCODE(n_bits);
free_ent = ((block_compress) ? FIRST : 256 );
while ( ( code = getcode() ) >= 0 ) {
if ( (code == CLEAR) && block_compress ) {
free_ent = FIRST - 1;
clear_flg = 1;
}
else if ( free_ent < maxmaxcode )
free_ent++;
if ( bits != n_bits ) {
fprintf(stderr, "\nChange to %d bits\n", n_bits );
bits = n_bits;
col = 0;
}
fprintf(stderr, "%5d%c", code, (col+=6) >= 74 ? (col = 0, '\n') : ' ' );
}
putc( '\n', stderr );
exit( 0 );
}
code_int sorttab[1<<BITS];
dump_tab()
{
register int i, first;
register ent;
#define STACK_SIZE 15000
int stack_top = STACK_SIZE;
register c;
if(do_decomp == 0) {
register int flag = 1;
for(i=0; i<hsize; i++) {
if((long)htabof(i) >= 0) {
sorttab[codetabof(i)] = i;
}
}
first = block_compress ? FIRST : 256;
for(i = first; i < free_ent; i++) {
fprintf(stderr, "%5d: \"", i);
de_stack[--stack_top] = '\n';
de_stack[--stack_top] = '"';
stack_top = in_stack((htabof(sorttab[i])>>maxbits)&0xff,
stack_top);
for(ent=htabof(sorttab[i]) & ((1<<maxbits)-1);
ent > 256;
ent=htabof(sorttab[ent]) & ((1<<maxbits)-1)) {
stack_top = in_stack(htabof(sorttab[ent]) >> maxbits,
stack_top);
}
stack_top = in_stack(ent, stack_top);
fwrite( &de_stack[stack_top], 1, STACK_SIZE-stack_top, stderr);
stack_top = STACK_SIZE;
}
} else if(!debug) {
for ( i = 0; i < free_ent; i++ ) {
ent = i;
c = tab_suffixof(ent);
if ( isascii(c) && isprint(c) )
fprintf( stderr, "%5d: %5d/'%c' \"",
ent, tab_prefixof(ent), c );
else
fprintf( stderr, "%5d: %5d/\\%03o \"",
ent, tab_prefixof(ent), c );
de_stack[--stack_top] = '\n';
de_stack[--stack_top] = '"';
for ( ; ent != NULL;
ent = (ent >= FIRST ? tab_prefixof(ent) : NULL) ) {
stack_top = in_stack(tab_suffixof(ent), stack_top);
}
fwrite( &de_stack[stack_top], 1, STACK_SIZE - stack_top, stderr );
stack_top = STACK_SIZE;
}
}
}
int
in_stack(c, stack_top)
register c, stack_top;
{
if ( (isascii(c) && isprint(c) && c != '\\') || c == ' ' ) {
de_stack[--stack_top] = c;
} else {
switch( c ) {
case '\n': de_stack[--stack_top] = 'n'; break;
case '\t': de_stack[--stack_top] = 't'; break;
case '\b': de_stack[--stack_top] = 'b'; break;
case '\f': de_stack[--stack_top] = 'f'; break;
case '\r': de_stack[--stack_top] = 'r'; break;
case '\\': de_stack[--stack_top] = '\\'; break;
default:
de_stack[--stack_top] = '0' + c % 8;
de_stack[--stack_top] = '0' + (c / 8) % 8;
de_stack[--stack_top] = '0' + c / 64;
break;
}
de_stack[--stack_top] = '\\';
}
return stack_top;
}
#endif
writeerr()
{
perror ( ofname );
unlink ( ofname );
exit ( 1 );
}
copystat(ifname, ofname)
char *ifname, *ofname;
{
struct stat statbuf;
int mode;
time_t timep[2];
fclose(stdout);
if (stat(ifname, &statbuf)) {
perror(ifname);
return;
}
if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
if(quiet)
fprintf(stderr, "%s: ", ifname);
fprintf(stderr, " -- not a regular file: unchanged");
exit_stat = 1;
perm_stat = 1;
} else if (statbuf.st_nlink > 1) {
if(quiet)
fprintf(stderr, "%s: ", ifname);
fprintf(stderr, " -- has %d other links: unchanged",
statbuf.st_nlink - 1);
exit_stat = 1;
perm_stat = 1;
} else if (exit_stat == 2 && (!force)) {
if(!quiet)
fprintf(stderr, " -- file unchanged");
} else {
exit_stat = 0;
mode = statbuf.st_mode & 07777;
if (chmod(ofname, mode))
perror(ofname);
#ifndef __UNIXOS2__
chown(ofname, statbuf.st_uid, statbuf.st_gid);
#endif
timep[0] = statbuf.st_atime;
timep[1] = statbuf.st_mtime;
utime(ofname, timep);
#ifdef __UNIXOS2__
fclose(stdin);
#endif
if (unlink(ifname))
perror(ifname);
if(!quiet)
fprintf(stderr, " -- replaced with %s", ofname);
return;
}
if (unlink(ofname))
perror(ofname);
}
onintr ( )
{
if (!precious)
unlink ( ofname );
exit ( 1 );
}
oops ( )
{
if ( do_decomp )
fprintf ( stderr, "uncompress: corrupt input\n" );
unlink ( ofname );
exit ( 1 );
}
cl_block ()
{
register long int rat;
checkpoint = in_count + CHECK_GAP;
#ifdef DEBUG
if ( debug ) {
fprintf ( stderr, "count: %ld, ratio: ", in_count );
prratio ( stderr, in_count, bytes_out );
fprintf ( stderr, "\n");
}
#endif
if(in_count > 0x007fffff) {
rat = bytes_out >> 8;
if(rat == 0) {
rat = 0x7fffffff;
} else {
rat = in_count / rat;
}
} else {
rat = (in_count << 8) / bytes_out;
}
if ( rat > ratio ) {
ratio = rat;
} else {
ratio = 0;
#ifdef DEBUG
if(verbose)
dump_tab();
#endif
cl_hash ( (count_int) hsize );
free_ent = FIRST;
clear_flg = 1;
output ( (code_int) CLEAR );
#ifdef DEBUG
if(debug)
fprintf ( stderr, "clear\n" );
#endif
}
}
cl_hash(hsize)
register count_int hsize;
{
#ifndef XENIX_16
register count_int *htab_p = htab+hsize;
#else
register j;
register long k = hsize;
register count_int *htab_p;
#endif
register long i;
register long m1 = -1;
#ifdef XENIX_16
for(j=0; j<=8 && k>=0; j++,k-=8192) {
i = 8192;
if(k < 8192) {
i = k;
}
htab_p = &(htab[j][i]);
i -= 16;
if(i > 0) {
#else
i = hsize - 16;
#endif
do {
*(htab_p-16) = m1;
*(htab_p-15) = m1;
*(htab_p-14) = m1;
*(htab_p-13) = m1;
*(htab_p-12) = m1;
*(htab_p-11) = m1;
*(htab_p-10) = m1;
*(htab_p-9) = m1;
*(htab_p-8) = m1;
*(htab_p-7) = m1;
*(htab_p-6) = m1;
*(htab_p-5) = m1;
*(htab_p-4) = m1;
*(htab_p-3) = m1;
*(htab_p-2) = m1;
*(htab_p-1) = m1;
htab_p -= 16;
} while ((i -= 16) >= 0);
#ifdef XENIX_16
}
}
#endif
for ( i += 16; i > 0; i-- )
*--htab_p = m1;
}
prratio(stream, num, den)
FILE *stream;
long int num, den;
{
register int q;
if(num > 214748L) {
q = num / (den / 10000L);
} else {
q = 10000L * num / den;
}
if (q < 0) {
putc('-', stream);
q = -q;
}
fprintf(stream, "%d.%02d%%", q / 100, q % 100);
}
version()
{
fprintf(stderr, "%s, Berkeley 5.10 10/15/88\n", rcs_ident);
fprintf(stderr, "Options: ");
#ifdef vax
fprintf(stderr, "vax, ");
#endif
#ifdef NO_UCHAR
fprintf(stderr, "NO_UCHAR, ");
#endif
#ifdef SIGNED_COMPARE_SLOW
fprintf(stderr, "SIGNED_COMPARE_SLOW, ");
#endif
#ifdef XENIX_16
fprintf(stderr, "XENIX_16, ");
#endif
#ifdef COMPATIBLE
fprintf(stderr, "COMPATIBLE, ");
#endif
#ifdef DEBUG
fprintf(stderr, "DEBUG, ");
#endif
#ifdef BSD4_2
fprintf(stderr, "BSD4_2, ");
#endif
fprintf(stderr, "BITS = %d\n", BITS);
}