759 lines
16 KiB
C
Executable file
759 lines
16 KiB
C
Executable file
/* tmp.c */
|
|
|
|
/* Author:
|
|
* Steve Kirkendall
|
|
* 14407 SW Teal Blvd. #C
|
|
* Beaverton, OR 97005
|
|
* kirkenda@cs.pdx.edu
|
|
*/
|
|
|
|
|
|
/* This file contains functions which create & readback a TMPFILE */
|
|
|
|
|
|
#include "config.h"
|
|
#include "vi.h"
|
|
#if TOS
|
|
# include <stat.h>
|
|
#else
|
|
# if OSK
|
|
# include "osk.h"
|
|
# else
|
|
# if AMIGA
|
|
# include "amistat.h"
|
|
# else
|
|
# include <sys/stat.h>
|
|
# endif
|
|
# endif
|
|
#endif
|
|
#if TURBOC
|
|
# include <process.h>
|
|
#endif
|
|
|
|
#ifndef NO_MODELINES
|
|
static void do_modelines(l, stop)
|
|
long l; /* line number to start at */
|
|
long stop; /* line number to stop at */
|
|
{
|
|
char *str; /* used to scan through the line */
|
|
char *start; /* points to the start of the line */
|
|
char buf[80];
|
|
|
|
/* if modelines are disabled, then do nothing */
|
|
if (!*o_modelines)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* for each line... */
|
|
for (; l <= stop; l++)
|
|
{
|
|
/* for each position in the line.. */
|
|
for (str = fetchline(l); *str; str++)
|
|
{
|
|
/* if it is the start of a modeline command... */
|
|
if ((str[0] == 'e' && str[1] == 'x'
|
|
|| str[0] == 'v' && str[1] == 'i')
|
|
&& str[2] == ':')
|
|
{
|
|
start = str += 3;
|
|
|
|
/* find the end */
|
|
for (str = start + strlen(start); *--str != ':'; )
|
|
{
|
|
}
|
|
|
|
/* if it is a well-formed modeline, execute it */
|
|
if (str > start && str - start < sizeof buf)
|
|
{
|
|
strncpy(buf, start, (int)(str - start));
|
|
exstring(buf, str - start, '\\');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/* The FAIL() macro prints an error message and then exits. */
|
|
#define FAIL(why,arg) mode = MODE_EX; msg(why, arg); endwin(); exit(9)
|
|
|
|
/* This is the name of the temp file */
|
|
static char tmpname[80];
|
|
|
|
/* This function creates the temp file and copies the original file into it.
|
|
* Returns if successful, or stops execution if it fails.
|
|
*/
|
|
int tmpstart(filename)
|
|
char *filename; /* name of the original file */
|
|
{
|
|
int origfd; /* fd used for reading the original file */
|
|
struct stat statb; /* stat buffer, used to examine inode */
|
|
REG BLK *this; /* pointer to the current block buffer */
|
|
REG BLK *next; /* pointer to the next block buffer */
|
|
int inbuf; /* number of characters in a buffer */
|
|
int nread; /* number of bytes read */
|
|
REG int j, k;
|
|
int i;
|
|
long nbytes;
|
|
|
|
/* switching to a different file certainly counts as a change */
|
|
changes++;
|
|
redraw(MARK_UNSET, FALSE);
|
|
|
|
/* open the original file for reading */
|
|
*origname = '\0';
|
|
if (filename && *filename)
|
|
{
|
|
strcpy(origname, filename);
|
|
origfd = open(origname, O_RDONLY);
|
|
if (origfd < 0 && errno != ENOENT)
|
|
{
|
|
msg("Can't open \"%s\"", origname);
|
|
return tmpstart("");
|
|
}
|
|
if (origfd >= 0)
|
|
{
|
|
if (stat(origname, &statb) < 0)
|
|
{
|
|
FAIL("Can't stat \"%s\"", origname);
|
|
}
|
|
#if TOS
|
|
if (origfd >= 0 && (statb.st_mode & S_IJDIR))
|
|
#else
|
|
# if OSK
|
|
if (origfd >= 0 && (statb.st_mode & S_IFDIR))
|
|
# else
|
|
if (origfd >= 0 && (statb.st_mode & S_IFMT) != S_IFREG)
|
|
# endif
|
|
#endif
|
|
{
|
|
msg("\"%s\" is not a regular file", origname);
|
|
return tmpstart("");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stat(".", &statb);
|
|
}
|
|
if (origfd >= 0)
|
|
{
|
|
origtime = statb.st_mtime;
|
|
#if OSK
|
|
if (*o_readonly || !(statb.st_mode &
|
|
((getuid() >> 16) == 0 ? S_IOWRITE | S_IWRITE :
|
|
((statb.st_gid != (getuid() >> 16) ? S_IOWRITE : S_IWRITE)))))
|
|
#endif
|
|
#if AMIGA || MSDOS || (TOS && defined(__GNUC__))
|
|
if (*o_readonly || !(statb.st_mode & S_IWRITE))
|
|
#endif
|
|
#if TOS && !defined(__GNUC__)
|
|
if (*o_readonly || (statb.st_mode & S_IJRON))
|
|
#endif
|
|
#if ANY_UNIX
|
|
if (*o_readonly || !(statb.st_mode &
|
|
((geteuid() == 0) ? 0222 :
|
|
((statb.st_uid != geteuid() ? 0022 : 0200)))))
|
|
#endif
|
|
#if VMS
|
|
if (*o_readonly)
|
|
#endif
|
|
{
|
|
setflag(file, READONLY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
origtime = 0L;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setflag(file, NOFILE);
|
|
origfd = -1;
|
|
origtime = 0L;
|
|
stat(".", &statb);
|
|
}
|
|
|
|
/* make a name for the tmp file */
|
|
tmpnum++;
|
|
#if MSDOS || TOS
|
|
/* MS-Dos doesn't allow multiple slashes, but supports drives
|
|
* with current directories.
|
|
* This relies on TMPNAME beginning with "%s\\"!!!!
|
|
*/
|
|
strcpy(tmpname, o_directory);
|
|
if ((i = strlen(tmpname)) && !strchr(":/\\", tmpname[i-1]))
|
|
tmpname[i++]=SLASH;
|
|
sprintf(tmpname+i, TMPNAME+3, getpid(), tmpnum);
|
|
#else
|
|
sprintf(tmpname, TMPNAME, o_directory, getpid(), tmpnum);
|
|
#endif
|
|
|
|
/* make sure nobody else is editing the same file */
|
|
if (access(tmpname, 0) == 0)
|
|
{
|
|
FAIL("Temp file \"%s\" already exists?", tmpname);
|
|
}
|
|
|
|
/* create the temp file */
|
|
#if ANY_UNIX
|
|
close(creat(tmpname, 0600)); /* only we can read it */
|
|
#else
|
|
close(creat(tmpname, FILEPERMS)); /* anybody body can read it, alas */
|
|
#endif
|
|
tmpfd = open(tmpname, O_RDWR | O_BINARY);
|
|
if (tmpfd < 0)
|
|
{
|
|
FAIL("Can't create temp file... Does directory \"%s\" exist?", o_directory);
|
|
return 1;
|
|
}
|
|
|
|
/* allocate space for the header in the file */
|
|
write(tmpfd, hdr.c, (unsigned)BLKSIZE);
|
|
write(tmpfd, tmpblk.c, (unsigned)BLKSIZE);
|
|
|
|
#ifndef NO_RECYCLE
|
|
/* initialize the block allocator */
|
|
/* This must already be done here, before the first attempt
|
|
* to write to the new file! GB */
|
|
garbage();
|
|
#endif
|
|
|
|
/* initialize lnum[] */
|
|
for (i = 1; i < MAXBLKS; i++)
|
|
{
|
|
lnum[i] = INFINITY;
|
|
}
|
|
lnum[0] = 0;
|
|
|
|
/* if there is no original file, then create a 1-line file */
|
|
if (origfd < 0)
|
|
{
|
|
hdr.n[0] = 0; /* invalid inode# denotes new file */
|
|
|
|
this = blkget(1); /* get the new text block */
|
|
strcpy(this->c, "\n"); /* put a line in it */
|
|
|
|
lnum[1] = 1L; /* block 1 ends with line 1 */
|
|
nlines = 1L; /* there is 1 line in the file */
|
|
nbytes = 1L;
|
|
|
|
if (*origname)
|
|
{
|
|
msg("\"%s\" [NEW FILE] 1 line, 1 char", origname);
|
|
}
|
|
else
|
|
{
|
|
msg("\"[NO FILE]\" 1 line, 1 char");
|
|
}
|
|
}
|
|
else /* there is an original file -- read it in */
|
|
{
|
|
nbytes = nlines = 0;
|
|
|
|
/* preallocate 1 "next" buffer */
|
|
i = 1;
|
|
next = blkget(i);
|
|
inbuf = 0;
|
|
|
|
/* loop, moving blocks from orig to tmp */
|
|
for (;;)
|
|
{
|
|
/* "next" buffer becomes "this" buffer */
|
|
this = next;
|
|
|
|
/* read [more] text into this block */
|
|
nread = tread(origfd, &this->c[inbuf], BLKSIZE - 1 - inbuf);
|
|
if (nread < 0)
|
|
{
|
|
close(origfd);
|
|
close(tmpfd);
|
|
tmpfd = -1;
|
|
unlink(tmpname);
|
|
FAIL("Error reading \"%s\"", origname);
|
|
}
|
|
|
|
/* convert NUL characters to something else */
|
|
for (j = k = inbuf; k < inbuf + nread; k++)
|
|
{
|
|
if (!this->c[k])
|
|
{
|
|
setflag(file, HADNUL);
|
|
this->c[j++] = 0x80;
|
|
}
|
|
#ifndef CRUNCH
|
|
else if (*o_beautify && this->c[k] < ' ' && this->c[k] > 0)
|
|
{
|
|
if (this->c[k] == '\t'
|
|
|| this->c[k] == '\n'
|
|
|| this->c[k] == '\f')
|
|
{
|
|
this->c[j++] = this->c[k];
|
|
}
|
|
else if (this->c[k] == '\b')
|
|
{
|
|
/* delete '\b', but complain */
|
|
setflag(file, HADBS);
|
|
}
|
|
/* else silently delete control char */
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
this->c[j++] = this->c[k];
|
|
}
|
|
}
|
|
inbuf = j;
|
|
|
|
/* if the buffer is empty, quit */
|
|
if (inbuf == 0)
|
|
{
|
|
goto FoundEOF;
|
|
}
|
|
|
|
#if MSDOS || TOS
|
|
/* BAH! MS text mode read fills inbuf, then compresses eliminating \r
|
|
but leaving garbage at end of buf. The same is true for TURBOC. GB. */
|
|
|
|
memset(this->c + inbuf, '\0', BLKSIZE - inbuf);
|
|
#endif
|
|
|
|
/* search backward for last newline */
|
|
for (k = inbuf; --k >= 0 && this->c[k] != '\n';)
|
|
{
|
|
}
|
|
if (k++ < 0)
|
|
{
|
|
if (inbuf >= BLKSIZE - 1)
|
|
{
|
|
k = 80;
|
|
}
|
|
else
|
|
{
|
|
k = inbuf;
|
|
}
|
|
}
|
|
|
|
/* allocate next buffer */
|
|
next = blkget(++i);
|
|
|
|
/* move fragmentary last line to next buffer */
|
|
inbuf -= k;
|
|
for (j = 0; k < BLKSIZE; j++, k++)
|
|
{
|
|
next->c[j] = this->c[k];
|
|
this->c[k] = 0;
|
|
}
|
|
|
|
/* if necessary, add a newline to this buf */
|
|
for (k = BLKSIZE - inbuf; --k >= 0 && !this->c[k]; )
|
|
{
|
|
}
|
|
if (this->c[k] != '\n')
|
|
{
|
|
setflag(file, ADDEDNL);
|
|
this->c[k + 1] = '\n';
|
|
}
|
|
|
|
/* count the lines in this block */
|
|
for (k = 0; k < BLKSIZE && this->c[k]; k++)
|
|
{
|
|
if (this->c[k] == '\n')
|
|
{
|
|
nlines++;
|
|
}
|
|
nbytes++;
|
|
}
|
|
lnum[i - 1] = nlines;
|
|
}
|
|
FoundEOF:
|
|
|
|
/* if this is a zero-length file, add 1 line */
|
|
if (nlines == 0)
|
|
{
|
|
this = blkget(1); /* get the new text block */
|
|
strcpy(this->c, "\n"); /* put a line in it */
|
|
|
|
lnum[1] = 1; /* block 1 ends with line 1 */
|
|
nlines = 1; /* there is 1 line in the file */
|
|
nbytes = 1;
|
|
}
|
|
|
|
#if MSDOS || TOS
|
|
/* each line has an extra CR that we didn't count yet */
|
|
nbytes += nlines;
|
|
#endif
|
|
|
|
/* report the number of lines in the file */
|
|
msg("\"%s\" %s %ld line%s, %ld char%s",
|
|
origname,
|
|
(tstflag(file, READONLY) ? "[READONLY]" : ""),
|
|
nlines,
|
|
nlines == 1 ? "" : "s",
|
|
nbytes,
|
|
nbytes == 1 ? "" : "s");
|
|
}
|
|
|
|
/* initialize the cursor to start of line 1 */
|
|
cursor = MARK_FIRST;
|
|
|
|
/* close the original file */
|
|
close(origfd);
|
|
|
|
/* any other messages? */
|
|
if (tstflag(file, HADNUL))
|
|
{
|
|
msg("This file contained NULs. They've been changed to \\x80 chars");
|
|
}
|
|
if (tstflag(file, ADDEDNL))
|
|
{
|
|
msg("Newline characters have been inserted to break up long lines");
|
|
}
|
|
#ifndef CRUNCH
|
|
if (tstflag(file, HADBS))
|
|
{
|
|
msg("Backspace characters deleted due to ':set beautify'");
|
|
}
|
|
#endif
|
|
|
|
storename(origname);
|
|
|
|
#ifndef NO_MODELINES
|
|
if (nlines > 10)
|
|
{
|
|
do_modelines(1L, 5L);
|
|
do_modelines(nlines - 4L, nlines);
|
|
}
|
|
else
|
|
{
|
|
do_modelines(1L, nlines);
|
|
}
|
|
#endif
|
|
|
|
/* force all blocks out onto the disk, to support file recovery */
|
|
blksync();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/* This function copies the temp file back onto an original file.
|
|
* Returns TRUE if successful, or FALSE if the file could NOT be saved.
|
|
*/
|
|
int tmpsave(filename, bang)
|
|
char *filename; /* the name to save it to */
|
|
int bang; /* forced write? */
|
|
{
|
|
int fd; /* fd of the file we're writing to */
|
|
REG int len; /* length of a text block */
|
|
REG BLK *this; /* a text block */
|
|
long bytes; /* byte counter */
|
|
REG int i;
|
|
|
|
/* if no filename is given, assume the original file name */
|
|
if (!filename || !*filename)
|
|
{
|
|
filename = origname;
|
|
}
|
|
|
|
/* if still no file name, then fail */
|
|
if (!*filename)
|
|
{
|
|
msg("Don't know a name for this file -- NOT WRITTEN");
|
|
return FALSE;
|
|
}
|
|
|
|
/* can't rewrite a READONLY file */
|
|
#if AMIGA
|
|
if (!strcmp(filename, origname) && tstflag(file, READONLY) && !bang)
|
|
#else
|
|
if (!strcmp(filename, origname) && *o_readonly && !bang)
|
|
#endif
|
|
{
|
|
msg("\"%s\" [READONLY] -- NOT WRITTEN", filename);
|
|
return FALSE;
|
|
}
|
|
|
|
/* open the file */
|
|
if (*filename == '>' && filename[1] == '>')
|
|
{
|
|
filename += 2;
|
|
while (*filename == ' ' || *filename == '\t')
|
|
{
|
|
filename++;
|
|
}
|
|
#ifdef O_APPEND
|
|
fd = open(filename, O_WRONLY|O_APPEND);
|
|
#else
|
|
fd = open(filename, O_WRONLY);
|
|
lseek(fd, 0L, 2);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
/* either the file must not exist, or it must be the original
|
|
* file, or we must have a bang, or "writeany" must be set.
|
|
*/
|
|
if (strcmp(filename, origname) && access(filename, 0) == 0 && !bang
|
|
#ifndef CRUNCH
|
|
&& !*o_writeany
|
|
#endif
|
|
)
|
|
{
|
|
msg("File already exists - Use :w! to overwrite");
|
|
return FALSE;
|
|
}
|
|
#if VMS
|
|
/* Create a new VMS version of this file. */
|
|
{
|
|
char *strrchr(), *ptr = strrchr(filename,';');
|
|
if (ptr) *ptr = '\0'; /* Snip off any ;number in the name */
|
|
}
|
|
#endif
|
|
fd = creat(filename, FILEPERMS);
|
|
}
|
|
if (fd < 0)
|
|
{
|
|
msg("Can't write to \"%s\" -- NOT WRITTEN", filename);
|
|
return FALSE;
|
|
}
|
|
|
|
/* write each text block to the file */
|
|
bytes = 0L;
|
|
for (i = 1; i < MAXBLKS && (this = blkget(i)) && this->c[0]; i++)
|
|
{
|
|
for (len = 0; len < BLKSIZE && this->c[len]; len++)
|
|
{
|
|
}
|
|
if (twrite(fd, this->c, len) < len)
|
|
{
|
|
msg("Trouble writing to \"%s\"", filename);
|
|
if (!strcmp(filename, origname))
|
|
{
|
|
setflag(file, MODIFIED);
|
|
}
|
|
close(fd);
|
|
return FALSE;
|
|
}
|
|
bytes += len;
|
|
}
|
|
|
|
/* reset the "modified" flag, but not the "undoable" flag */
|
|
clrflag(file, MODIFIED);
|
|
significant = FALSE;
|
|
|
|
/* report lines & characters */
|
|
#if MSDOS || TOS
|
|
bytes += nlines; /* for the inserted carriage returns */
|
|
#endif
|
|
msg("Wrote \"%s\" %ld lines, %ld characters", filename, nlines, bytes);
|
|
|
|
/* close the file */
|
|
close(fd);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* This function deletes the temporary file. If the file has been modified
|
|
* and "bang" is FALSE, then it returns FALSE without doing anything; else
|
|
* it returns TRUE.
|
|
*
|
|
* If the "autowrite" option is set, then instead of returning FALSE when
|
|
* the file has been modified and "bang" is false, it will call tmpend().
|
|
*/
|
|
int tmpabort(bang)
|
|
int bang;
|
|
{
|
|
/* if there is no file, return successfully */
|
|
if (tmpfd < 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
/* see if we must return FALSE -- can't quit */
|
|
if (!bang && tstflag(file, MODIFIED))
|
|
{
|
|
/* if "autowrite" is set, then act like tmpend() */
|
|
if (*o_autowrite)
|
|
return tmpend(bang);
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
/* delete the tmp file */
|
|
cutswitch();
|
|
strcpy(prevorig, origname);
|
|
prevline = markline(cursor);
|
|
*origname = '\0';
|
|
origtime = 0L;
|
|
blkinit();
|
|
nlines = 0;
|
|
initflags();
|
|
return TRUE;
|
|
}
|
|
|
|
/* This function saves the file if it has been modified, and then deletes
|
|
* the temporary file. Returns TRUE if successful, or FALSE if the file
|
|
* needs to be saved but can't be. When it returns FALSE, it will not have
|
|
* deleted the tmp file, either.
|
|
*/
|
|
int tmpend(bang)
|
|
int bang;
|
|
{
|
|
/* save the file if it has been modified */
|
|
if (tstflag(file, MODIFIED) && !tmpsave((char *)0, FALSE) && !bang)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
/* delete the tmp file */
|
|
tmpabort(TRUE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* If the tmp file has been changed, then this function will force those
|
|
* changes to be written to the disk, so that the tmp file will survive a
|
|
* system crash or power failure.
|
|
*/
|
|
#if AMIGA || MSDOS || TOS
|
|
sync()
|
|
{
|
|
/* MS-DOS and TOS don't flush their buffers until the file is closed,
|
|
* so here we close the tmp file and then immediately reopen it.
|
|
*/
|
|
close(tmpfd);
|
|
tmpfd = open(tmpname, O_RDWR | O_BINARY);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* This function stores the file's name in the second block of the temp file.
|
|
* SLEAZE ALERT! SLEAZE ALERT! The "tmpblk" buffer is probably being used
|
|
* to store the arguments to a command, so we can't use it here. Instead,
|
|
* we'll borrow the buffer that is used for "shift-U".
|
|
*/
|
|
storename(name)
|
|
char *name; /* the name of the file - normally origname */
|
|
{
|
|
#ifndef CRUNCH
|
|
int len;
|
|
char *ptr;
|
|
#endif
|
|
|
|
/* we're going to clobber the U_text buffer, so reset U_line */
|
|
U_line = 0L;
|
|
|
|
if (!name)
|
|
{
|
|
strncpy(U_text, "", BLKSIZE);
|
|
U_text[1] = 127;
|
|
}
|
|
#ifndef CRUNCH
|
|
else if (*name != SLASH)
|
|
{
|
|
/* get the directory name */
|
|
ptr = getcwd(U_text, BLKSIZE);
|
|
if (ptr != U_text)
|
|
{
|
|
strcpy(U_text, ptr);
|
|
}
|
|
|
|
/* append a slash to the directory name */
|
|
len = strlen(U_text);
|
|
U_text[len++] = SLASH;
|
|
|
|
/* append the filename, padded with heaps o' NULs */
|
|
strncpy(U_text + len, *name ? name : "foo", BLKSIZE - len);
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
/* copy the filename into U_text */
|
|
strncpy(U_text, *name ? name : "foo", BLKSIZE);
|
|
}
|
|
|
|
if (tmpfd >= 0)
|
|
{
|
|
/* write the name out to second block of the temp file */
|
|
lseek(tmpfd, (long)BLKSIZE, 0);
|
|
write(tmpfd, U_text, (unsigned)BLKSIZE);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/* This function handles deadly signals. It restores sanity to the terminal
|
|
* preserves the current temp file, and deletes any old temp files.
|
|
*/
|
|
int deathtrap(sig)
|
|
int sig; /* the deadly signal that we caught */
|
|
{
|
|
char *why;
|
|
|
|
/* restore the terminal's sanity */
|
|
endwin();
|
|
|
|
#ifdef CRUNCH
|
|
why = "-Elvis died";
|
|
#else
|
|
/* give a more specific description of how Elvis died */
|
|
switch (sig)
|
|
{
|
|
# ifdef SIGHUP
|
|
case SIGHUP: why = "-the modem lost its carrier"; break;
|
|
# endif
|
|
# ifndef DEBUG
|
|
# ifdef SIGILL
|
|
case SIGILL: why = "-Elvis hit an illegal instruction"; break;
|
|
# endif
|
|
# ifdef SIGBUS
|
|
case SIGBUS: why = "-Elvis had a bus error"; break;
|
|
# endif
|
|
# if defined(SIGSEGV) && !defined(TOS)
|
|
case SIGSEGV: why = "-Elvis had a segmentation violation"; break;
|
|
# endif
|
|
# ifdef SIGSYS
|
|
case SIGSYS: why = "-Elvis munged a system call"; break;
|
|
# endif
|
|
# endif /* !DEBUG */
|
|
# ifdef SIGPIPE
|
|
case SIGPIPE: why = "-the pipe reader died"; break;
|
|
# endif
|
|
# ifdef SIGTERM
|
|
case SIGTERM: why = "-Elvis was terminated"; break;
|
|
# endif
|
|
# if !MINIX
|
|
# ifdef SIGUSR1
|
|
case SIGUSR1: why = "-Elvis was killed via SIGUSR1"; break;
|
|
# endif
|
|
# ifdef SIGUSR2
|
|
case SIGUSR2: why = "-Elvis was killed via SIGUSR2"; break;
|
|
# endif
|
|
# endif
|
|
default: why = "-Elvis died"; break;
|
|
}
|
|
#endif
|
|
|
|
/* if we had a temp file going, then preserve it */
|
|
if (tmpnum > 0 && tmpfd >= 0)
|
|
{
|
|
close(tmpfd);
|
|
sprintf(tmpblk.c, "%s \"%s\" %s", PRESERVE, why, tmpname);
|
|
system(tmpblk.c);
|
|
}
|
|
|
|
/* delete any old temp files */
|
|
cutend();
|
|
|
|
/* exit with the proper exit status */
|
|
exit(sig);
|
|
}
|