1,295c1,56
< #include "EXTERN.h"
< #include "common.h"
< #include "INTERN.h"
< #include "util.h"
< #include "backupfile.h"
< 
< /* Rename a file, copying it if necessary. */
< 
< int
< move_file(from,to)
< char *from, *to;
< {
<     char bakname[512];
<     Reg1 char *s;
<     Reg2 int i;
<     Reg3 int fromfd;
< 
<     /* to stdout? */
< 
<     if (strEQ(to, "-")) {
< #ifdef DEBUGGING
< 	if (debug & 4)
< 	    say2("Moving %s to stdout.\n", from);
< #endif
< 	fromfd = open(from, 0);
< 	if (fromfd < 0)
< 	    fatal2("patch: internal error, can't reopen %s\n", from);
< 	while ((i=read(fromfd, buf, sizeof buf)) > 0)
< 	    if (write(1, buf, i) != 1)
< 		fatal1("patch: write failed\n");
< 	Close(fromfd);
< 	return 0;
<     }
< 
<     if (origprae) {
< 	Strcpy(bakname, origprae);
< 	Strcat(bakname, to);
<     } else {
< #ifndef NODIR
< 	char *backupname = find_backup_file_name(to);
< 	if (backupname == (char *) 0)
< 	    fatal1("Can't seem to get enough memory.\n");
< 	Strcpy(bakname, backupname);
< 	free(backupname);
< #else /* NODIR */
< 	Strcpy(bakname, to);
<     	Strcat(bakname, simple_backup_suffix);
< #endif /* NODIR */
<     }
< 
<     if (stat(to, &filestat) >= 0) {	/* output file exists */
< 	dev_t to_device = filestat.st_dev;
< 	ino_t to_inode  = filestat.st_ino;
< 	char *simplename = bakname;
< 	
< 	for (s=bakname; *s; s++) {
< 	    if (*s == '/')
< 		simplename = s+1;
< 	}
< 	/* Find a backup name that is not the same file.
< 	   Change the first lowercase char into uppercase;
< 	   if that isn't sufficient, chop off the first char and try again.  */
< 	while (stat(bakname, &filestat) >= 0 &&
< 		to_device == filestat.st_dev && to_inode == filestat.st_ino) {
< 	    /* Skip initial non-lowercase chars.  */
< 	    for (s=simplename; *s && !islower(*s); s++) ;
< 	    if (*s)
< 		*s = toupper(*s);
< 	    else
< 		Strcpy(simplename, simplename+1);
< 	}
< 	while (unlink(bakname) >= 0) ;	/* while() is for benefit of Eunice */
< #ifdef DEBUGGING
< 	if (debug & 4)
< 	    say3("Moving %s to %s.\n", to, bakname);
< #endif
< 	if (link(to, bakname) < 0)
< 	{
< 	    /* Maybe `to' is a symlink into a different file system.
< 	       Copying replaces the symlink with a file; using rename
< 	       would be better.  */
< 	    Reg4 int tofd;
< 	    Reg5 int bakfd;
< 
< 	    bakfd = creat(bakname, 0666);
< 	    if (bakfd < 0) {
< 		say3("patch: can't backup %s, output is in %s.\n", to, from);
< 		return -1;
< 	    }
< 	    tofd = open(to, 0);
< 	    if (tofd < 0)
< 		fatal2("patch: internal error, can't open %s\n", to);
< 	    while ((i=read(tofd, buf, sizeof buf)) > 0)
< 		if (write(bakfd, buf, i) != i)
< 		    fatal1("patch: write failed\n");
< 	    Close(tofd);
< 	    Close(bakfd);
< 	}
< 	while (unlink(to) >= 0) ;
<     }
< #ifdef DEBUGGING
<     if (debug & 4)
< 	say3("Moving %s to %s.\n", from, to);
< #endif
<     if (link(from, to) < 0) {		/* different file system? */
< 	Reg4 int tofd;
< 	
< 	tofd = creat(to, 0666);
< 	if (tofd < 0) {
< 	    say3("patch: can't create %s, output is in %s.\n",
< 	      to, from);
< 	    return -1;
< 	}
< 	fromfd = open(from, 0);
< 	if (fromfd < 0)
< 	    fatal2("patch: internal error, can't reopen %s\n", from);
< 	while ((i=read(fromfd, buf, sizeof buf)) > 0)
< 	    if (write(tofd, buf, i) != i)
< 		fatal1("patch: write failed\n");
< 	Close(fromfd);
< 	Close(tofd);
<     }
<     Unlink(from);
<     return 0;
< }
< 
< /* Copy a file. */
< 
< void
< copy_file(from,to)
< char *from, *to;
< {
<     Reg3 int tofd;
<     Reg2 int fromfd;
<     Reg1 int i;
<     
<     tofd = creat(to, 0666);
<     if (tofd < 0)
< 	fatal2("patch: can't create %s.\n", to);
<     fromfd = open(from, 0);
<     if (fromfd < 0)
< 	fatal2("patch: internal error, can't reopen %s\n", from);
<     while ((i=read(fromfd, buf, sizeof buf)) > 0)
< 	if (write(tofd, buf, i) != i)
< 	    fatal2("patch: write (%s) failed\n", to);
<     Close(fromfd);
<     Close(tofd);
< }
< 
< /* Allocate a unique area for a string. */
< 
< char *
< savestr(s)
< Reg1 char *s;
< {
<     Reg3 char *rv;
<     Reg2 char *t;
< 
<     if (!s)
< 	s = "Oops";
<     t = s;
<     while (*t++);
<     rv = malloc((MEM) (t - s));
<     if (rv == Nullch) {
< 	if (using_plan_a)
< 	    out_of_mem = TRUE;
< 	else
< 	    fatal1("patch: out of memory (savestr)\n");
<     }
<     else {
< 	t = rv;
< 	while (*t++ = *s++);
<     }
<     return rv;
< }
< 
< #if defined(lint) && defined(CANVARARG)
< 
< /*VARARGS ARGSUSED*/
< say(pat) char *pat; { ; }
< /*VARARGS ARGSUSED*/
< fatal(pat) char *pat; { ; }
< /*VARARGS ARGSUSED*/
< ask(pat) char *pat; { ; }
< 
< #else
< 
< /* Vanilla terminal output (buffered). */
< 
< void
< say(pat,arg1,arg2,arg3)
< char *pat;
< long arg1,arg2,arg3;
< {
<     fprintf(stderr, pat, arg1, arg2, arg3);
<     Fflush(stderr);
< }
< 
< /* Terminal output, pun intended. */
< 
< void				/* very void */
< fatal(pat,arg1,arg2,arg3)
< char *pat;
< long arg1,arg2,arg3;
< {
<     void my_exit();
< 
<     say(pat, arg1, arg2, arg3);
<     my_exit(1);
< }
< 
< /* Get a response from the user, somehow or other. */
< 
< void
< ask(pat,arg1,arg2,arg3)
< char *pat;
< long arg1,arg2,arg3;
< {
<     int ttyfd;
<     int r;
<     bool tty2 = isatty(2);
< 
<     Sprintf(buf, pat, arg1, arg2, arg3);
<     Fflush(stderr);
<     write(2, buf, strlen(buf));
<     if (tty2) {				/* might be redirected to a file */
< 	r = read(2, buf, sizeof buf);
<     }
<     else if (isatty(1)) {		/* this may be new file output */
< 	Fflush(stdout);
< 	write(1, buf, strlen(buf));
< 	r = read(1, buf, sizeof buf);
<     }
< #ifdef WIN32
<     else if ((ttyfd = open("CON", 2)) >= 0) {
< #else
<     else if ((ttyfd = open("/dev/tty", 2)) >= 0 && isatty(ttyfd)) {
< #endif
< 					/* might be deleted or unwriteable */
< 	write(ttyfd, buf, strlen(buf));
< 	r = read(ttyfd, buf, sizeof buf);
< 	Close(ttyfd);
<     }
<     else if (isatty(0)) {		/* this is probably patch input */
< 	Fflush(stdin);
< 	write(0, buf, strlen(buf));
< 	r = read(0, buf, sizeof buf);
<     }
<     else {				/* no terminal at all--default it */
< 	buf[0] = '\n';
< 	r = 1;
<     }
<     if (r <= 0)
< 	buf[0] = 0;
<     else
< 	buf[r] = '\0';
<     if (!tty2)
< 	say1(buf);
< }
< #endif /* lint */
< 
< /* How to handle certain events when not in a critical region. */
< 
< void
< set_signals(reset)
< int reset;
< {
<     void my_exit();
< #ifndef lint
< #ifdef VOIDSIG
<     static void (*hupval)(),(*intval)();
< #else
<     static int (*hupval)(),(*intval)();
< #endif
< 
<     if (!reset) {
< 	hupval = signal(SIGHUP, SIG_IGN);
< 	if (hupval != SIG_IGN)
< #ifdef VOIDSIG
< 	    hupval = my_exit;
< #else
< 	    hupval = (int(*)())my_exit;
< #endif
< 	intval = signal(SIGINT, SIG_IGN);
< 	if (intval != SIG_IGN)
< #ifdef VOIDSIG
< 	    intval = my_exit;
< #else
< 	    intval = (int(*)())my_exit;
< #endif
<     }
<     Signal(SIGHUP, hupval);
<     Signal(SIGINT, intval);
< #endif
< }
---
> /* $Header: util.h,v 2.0 86/09/17 15:40:06 lwall Exp $
>  *
>  * $Log:	util.h,v $
>  * Revision 2.0  86/09/17  15:40:06  lwall
>  * Baseline for netwide release.
>  * 
>  */
> 
> /* and for those machine that can't handle a variable argument list */
> 
> #ifdef CANVARARG
> 
> #define say1 say
> #define say2 say
> #define say3 say
> #define say4 say
> #define ask1 ask
> #define ask2 ask
> #define ask3 ask
> #define ask4 ask
> #define fatal1 fatal
> #define fatal2 fatal
> #define fatal3 fatal
> #define fatal4 fatal
> 
> #else /* hope they allow multi-line macro actual arguments */
> 
> #ifdef lint
> 
> #define say1(a) say(a, 0, 0, 0)
> #define say2(a,b) say(a, (b)==(b), 0, 0)
> #define say3(a,b,c) say(a, (b)==(b), (c)==(c), 0)
> #define say4(a,b,c,d) say(a, (b)==(b), (c)==(c), (d)==(d))
> #define ask1(a) ask(a, 0, 0, 0)
> #define ask2(a,b) ask(a, (b)==(b), 0, 0)
> #define ask3(a,b,c) ask(a, (b)==(b), (c)==(c), 0)
> #define ask4(a,b,c,d) ask(a, (b)==(b), (c)==(c), (d)==(d))
> #define fatal1(a) fatal(a, 0, 0, 0)
> #define fatal2(a,b) fatal(a, (b)==(b), 0, 0)
> #define fatal3(a,b,c) fatal(a, (b)==(b), (c)==(c), 0)
> #define fatal4(a,b,c,d) fatal(a, (b)==(b), (c)==(c), (d)==(d))
> 
> #else /* lint */
>     /* if this doesn't work, try defining CANVARARG above */
> #define say1(a) say(a, Nullch, Nullch, Nullch)
> #define say2(a,b) say(a, b, Nullch, Nullch)
> #define say3(a,b,c) say(a, b, c, Nullch)
> #define say4 say
> #define ask1(a) ask(a, Nullch, Nullch, Nullch)
> #define ask2(a,b) ask(a, b, Nullch, Nullch)
> #define ask3(a,b,c) ask(a, b, c, Nullch)
> #define ask4 ask
> #define fatal1(a) fatal(a, Nullch, Nullch, Nullch)
> #define fatal2(a,b) fatal(a, b, Nullch, Nullch)
> #define fatal3(a,b,c) fatal(a, b, c, Nullch)
> #define fatal4 fatal
297c58
< /* How to handle certain events when in a critical region. */
---
> #endif /* lint */
299,304c60
< void
< ignore_signals()
< {
< #ifndef lint
<     Signal(SIGHUP, SIG_IGN);
<     Signal(SIGINT, SIG_IGN);
---
> /* if neither of the above work, join all multi-line macro calls. */
306d61
< }
308c63
< /* Make sure we'll have the directories to create a file. */
---
> EXT char serrbuf[BUFSIZ];		/* buffer for stderr */
310,407c65,74
< void
< makedirs(filename,striplast)
< Reg1 char *filename;
< bool striplast;
< {
<     char tmpbuf[256];
<     Reg2 char *s = tmpbuf;
<     char *dirv[20];
<     Reg3 int i;
<     Reg4 int dirvp = 0;
< 
<     while (*filename) {
< 	if (*filename == '/') {
< 	    filename++;
< 	    dirv[dirvp++] = s;
< 	    *s++ = '\0';
< 	}
< 	else {
< 	    *s++ = *filename++;
< 	}
<     }
<     *s = '\0';
<     dirv[dirvp] = s;
<     if (striplast)
< 	dirvp--;
<     if (dirvp < 0)
< 	return;
<     strcpy(buf, "mkdir");
<     s = buf;
<     for (i=0; i<=dirvp; i++) {
< 	while (*s) s++;
< 	*s++ = ' ';
< 	strcpy(s, tmpbuf);
< 	*dirv[i] = '/';
<     }
<     system(buf);
< }
< 
< /* Make filenames more reasonable. */
< 
< char *
< fetchname(at,strip_leading,assume_exists)
< char *at;
< int strip_leading;
< int assume_exists;
< {
<     char *fullname;
<     char *name;
<     Reg1 char *t;
<     char tmpbuf[200];
<     int sleading = strip_leading;
< 
<     if (!at)
< 	return Nullch;
<     while (isspace(*at))
< 	at++;
< #ifdef DEBUGGING
<     if (debug & 128)
< 	say4("fetchname %s %d %d\n",at,strip_leading,assume_exists);
< #endif
<     if (strnEQ(at, "/dev/null", 9))	/* so files can be created by diffing */
< 	return Nullch;			/*   against /dev/null. */
<     name = fullname = t = savestr(at);
< 
<     /* Strip off up to `sleading' leading slashes and null terminate.  */
<     for (; *t && !isspace(*t); t++)
< 	if (*t == '/')
< 	    if (--sleading >= 0)
< 		name = t+1;
<     *t = '\0';
< 
<     /* If no -p option was given (957 is the default value!),
<        we were given a relative pathname,
<        and the leading directories that we just stripped off all exist,
<        put them back on.  */
<     if (strip_leading == 957 && name != fullname && *fullname != '/') {
< 	name[-1] = '\0';
< 	if (stat(fullname, &filestat) >= 0 && S_ISDIR (filestat.st_mode)) {
< 	    name[-1] = '/';
< 	    name=fullname;
< 	}
<     }
< 
<     name = savestr(name);
<     free(fullname);
< 
<     if (stat(name, &filestat) < 0 && !assume_exists) {
<         Sprintf(tmpbuf, "RCS/%s%s", name, RCSSUFFIX);
< 	if (stat(tmpbuf, &filestat) < 0 && stat(tmpbuf+4, &filestat) < 0) {
< 	    Sprintf(tmpbuf, "SCCS/%s%s", SCCSPREFIX, name);
< 	    if (stat(tmpbuf, &filestat) < 0 && stat(tmpbuf+5, &filestat) < 0) {
< 		free(name);
< 		name = Nullch;
< 	    }
< 	}
<     }
<     return name;
< }
---
> char *fetchname();
> int move_file();
> void copy_file();
> void say();
> void fatal();
> void ask();
> char *savestr();
> void set_signals();
> void ignore_signals();
> void makedirs();
