/* Supporting routines which may sometimes be missing.
- Copyright (C) 1988, 1992 Free Software Foundation
+ Copyright (C) 1988 Free Software Foundation
This file is part of GNU Tar.
#ifdef __MSDOS__
char TTY_NAME[] = "con";
+#define MKNOD_MISSING
+#define UTILS_MISSING
+#define VALLOC_MISSING
+
#else /* not __MSDOS__ */
-char TTY_NAME[] = "/dev/tty";
+char TTY_NAME[] ="/dev/tty";
+
+#define UTILS_MISSING
+#define CK_PIPE_MISSING
#endif /* not __MSDOS__ */
/* End of system-dependent #ifdefs */
-#ifndef HAVE_VALLOC
+#ifdef VALLOC_MISSING
/*
* valloc() does a malloc() on a page boundary. On some systems,
* this can make large block I/O more efficient.
*/
char *
valloc (size)
- unsigned size;
+ unsigned size;
{
- return (malloc (size));
+ return (malloc (size));
}
+#endif
-#endif /* !HAVE_VALLOC */
-
-#ifndef HAVE_MKDIR
+#ifdef MKDIR_MISSING
/*
- * Written by Robert Rother, Mariah Corporation, August 1985.
+ * Written by Robert Rother, Mariah Corporation, August 1985.
*
* If you want it, it's yours. All I ask in return is that if you
* figure out how to do this in a Bourne Shell script you send me
* Make a directory.
*/
int
-mkdir (dpath, dmode)
- char *dpath;
- int dmode;
+mkdir(dpath, dmode)
+ char *dpath;
+ int dmode;
{
- int cpid, status;
- struct stat statbuf;
+ int cpid, status;
+ struct stat statbuf;
- if (stat (dpath, &statbuf) == 0)
- {
- errno = EEXIST; /* Stat worked, so it already exists */
- return -1;
- }
+ if (stat(dpath,&statbuf) == 0) {
+ errno = EEXIST; /* Stat worked, so it already exists */
+ return -1;
+ }
- /* If stat fails for a reason other than non-existence, return error */
- if (errno != ENOENT)
- return -1;
+ /* If stat fails for a reason other than non-existence, return error */
+ if (errno != ENOENT) return -1;
- switch (cpid = fork ())
- {
+ switch (cpid = fork()) {
- case -1: /* Error in fork() */
- return (-1); /* Errno is set already */
+ case -1: /* Error in fork() */
+ return(-1); /* Errno is set already */
- case 0: /* Child process */
- /*
+ case 0: /* Child process */
+ /*
* Cheap hack to set mode of new directory. Since this
* child process is going away anyway, we zap its umask.
* FIXME, this won't suffice to set SUID, SGID, etc. on this
* directory. Does anybody care?
*/
- status = umask (0); /* Get current umask */
- status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
- execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
- _exit (-1); /* Can't exec /bin/mkdir */
-
- default: /* Parent process */
- while (cpid != wait (&status)); /* Wait for kid to finish */
- }
+ status = umask(0); /* Get current umask */
+ status = umask(status | (0777 & ~dmode)); /* Set for mkdir */
+ execl("/bin/mkdir", "mkdir", dpath, (char *)0);
+ _exit(-1); /* Can't exec /bin/mkdir */
+
+ default: /* Parent process */
+ while (cpid != wait(&status)) ; /* Wait for kid to finish */
+ }
- if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
- {
- errno = EIO; /* We don't know why, but */
- return -1; /* /bin/mkdir failed */
- }
+ if (WTERMSIG(status) != 0 || WEXITSTATUS(status) != 0) {
+ errno = EIO; /* We don't know why, but */
+ return -1; /* /bin/mkdir failed */
+ }
- return 0;
+ return 0;
}
int
-rmdir (dpath)
- char *dpath;
+rmdir(dpath)
+ char *dpath;
{
- int cpid, status;
- struct stat statbuf;
-
- if (stat (dpath, &statbuf) != 0)
- {
- /* Stat just set errno. We don't have to */
- return -1;
- }
+ int cpid, status;
+ struct stat statbuf;
- switch (cpid = fork ())
- {
+ if (stat(dpath,&statbuf) != 0) {
+ /* Stat just set errno. We don't have to */
+ return -1;
+ }
- case -1: /* Error in fork() */
- return (-1); /* Errno is set already */
+ switch (cpid = fork()) {
- case 0: /* Child process */
- execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
- _exit (-1); /* Can't exec /bin/mkdir */
+ case -1: /* Error in fork() */
+ return(-1); /* Errno is set already */
- default: /* Parent process */
- while (cpid != wait (&status)); /* Wait for kid to finish */
- }
+ case 0: /* Child process */
+ execl("/bin/rmdir", "rmdir", dpath, (char *)0);
+ _exit(-1); /* Can't exec /bin/mkdir */
+
+ default: /* Parent process */
+ while (cpid != wait(&status)) ; /* Wait for kid to finish */
+ }
- if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
- {
- errno = EIO; /* We don't know why, but */
- return -1; /* /bin/mkdir failed */
- }
+ if (WTERMSIG(status) != 0 || WEXITSTATUS(status) != 0) {
+ errno = EIO; /* We don't know why, but */
+ return -1; /* /bin/mkdir failed */
+ }
- return 0;
+ return 0;
}
+#endif
-#endif /* !HAVE_MKDIR */
-
-#ifndef HAVE_RENAME
+#ifdef RENAME_MISSING
/* Rename file FROM to file TO.
Return 0 if successful, -1 if not. */
{
struct stat from_stats;
- if (stat (from, &from_stats))
- return -1;
-
- if (unlink (to) && errno != ENOENT)
- return -1;
-
- if (link (from, to))
- return -1;
-
- if (unlink (from) && errno != ENOENT)
+ if (stat (from, &from_stats) == 0)
{
- unlink (to);
- return -1;
+ if (unlink (to) && errno != ENOENT)
+ return -1;
+ if (link (from, to) == 0 && (unlink (from) == 0 || errno == ENOENT))
+ return 0;
}
-
- return 0;
+ return -1;
}
+#endif
-#endif /* !HAVE_RENAME */
-
-#ifdef minix
+#ifdef BZERO_MISSING
/* Minix has bcopy but not bzero, and no memset. Thanks, Andy. */
void
bzero (s1, n)
- register char *s1;
- register int n;
+ register char *s1;
+ register int n;
{
- while (n--)
- *s1++ = '\0';
+ while (n--) *s1++ = '\0';
}
/* It also has no bcmp() */
int
-bcmp (s1, s2, n)
- register char *s1, *s2;
- register int n;
+bcmp (s1, s2, n)
+ register char *s1,*s2;
+ register int n;
{
- for (; n--; ++s1, ++s2)
- {
- if (*s1 != *s2)
- return *s1 - *s2;
- }
- return 0;
+ for ( ; n-- ; ++s1, ++s2) {
+ if (*s1 != *s2) return *s1 - *s2;
+ }
+ return 0;
}
/*
* *and* doesn't have execlp, YOU get to fix it.
*/
int
-execlp (filename, arg0)
- char *filename, *arg0;
+execlp(filename, arg0)
+ char *filename, *arg0;
{
- register char *p, *path;
- register char *fnbuffer;
- char **argstart = &arg0;
- struct stat statbuf;
- extern char **environ;
-
- if ((p = getenv ("PATH")) == NULL)
- {
- /* couldn't find path variable -- try to exec given filename */
- return execve (filename, argstart, environ);
- }
+ register char *p, *path;
+ register char *fnbuffer;
+ char **argstart = &arg0;
+ struct stat statbuf;
+ extern char **environ;
+
+ if ((p = getenv("PATH")) == NULL) {
+ /* couldn't find path variable -- try to exec given filename */
+ return execve(filename, argstart, environ);
+ }
- /*
+ /*
* make a place to build the filename. We malloc larger than we
* need, but we know it will fit in this.
*/
- fnbuffer = malloc (strlen (p) + 1 + strlen (filename));
- if (fnbuffer == NULL)
- {
- errno = ENOMEM;
- return -1;
- }
+ fnbuffer = malloc( strlen(p) + 1 + strlen(filename) );
+ if (fnbuffer == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
- /*
+ /*
* try each component of the path to see if the file's there
* and executable.
*/
- for (path = p; path; path = p)
- {
- /* construct full path name to try */
- if ((p = index (path, ':')) == NULL)
- {
- strcpy (fnbuffer, path);
- }
- else
- {
- strncpy (fnbuffer, path, p - path);
- fnbuffer[p - path] = '\0';
- p++; /* Skip : for next time */
- }
- if (strlen (fnbuffer) != 0)
- strcat (fnbuffer, "/");
- strcat (fnbuffer, filename);
-
- /* check to see if file is there and is a normal file */
- if (stat (fnbuffer, &statbuf) < 0)
- {
- if (errno == ENOENT)
- continue; /* file not there,keep on looking */
- else
- goto fail; /* failed for some reason, return */
- }
- if (!S_ISREG (statbuf.st_mode))
- continue;
-
- if (execve (fnbuffer, argstart, environ) < 0
- && errno != ENOENT
- && errno != ENOEXEC)
- {
- /* failed, for some other reason besides "file
+ for (path = p ; path ; path = p) {
+ /* construct full path name to try */
+ if ((p = index(path,':')) == NULL) {
+ strcpy(fnbuffer, path);
+ } else {
+ strncpy(fnbuffer, path, p-path);
+ fnbuffer[p-path] = '\0';
+ p++; /* Skip : for next time */
+ }
+ if (strlen(fnbuffer) != 0)
+ strcat(fnbuffer,"/");
+ strcat(fnbuffer,filename);
+
+ /* check to see if file is there and is a normal file */
+ if (stat(fnbuffer, &statbuf) < 0) {
+ if (errno == ENOENT)
+ continue; /* file not there,keep on looking */
+ else
+ goto fail; /* failed for some reason, return */
+ }
+ if (!S_ISREG(statbuf.st_mode)) continue;
+
+ if (execve(fnbuffer, argstart, environ) < 0
+ && errno != ENOENT
+ && errno != ENOEXEC) {
+ /* failed, for some other reason besides "file
* not found" or "not a.out format"
*/
- goto fail;
- }
+ goto fail;
+ }
- /*
+ /*
* If we got error ENOEXEC, the file is executable but is
* not an object file. Try to execute it as a shell script,
* returning error if we can't execute /bin/sh.
* code clobbers argstart[-1] if the exec of the shell
* fails.
*/
- if (errno == ENOEXEC)
- {
- char *shell;
-
- /* Try to execute command "sh arg0 arg1 ..." */
- if ((shell = getenv ("SHELL")) == NULL)
- shell = "/bin/sh";
- argstart[-1] = shell;
- argstart[0] = fnbuffer;
- execve (shell, &argstart[-1], environ);
- goto fail; /* Exec didn't work */
- }
-
- /*
+ if (errno == ENOEXEC) {
+ char *shell;
+
+ /* Try to execute command "sh arg0 arg1 ..." */
+ if ((shell = getenv("SHELL")) == NULL)
+ shell = "/bin/sh";
+ argstart[-1] = shell;
+ argstart[0] = fnbuffer;
+ execve(shell, &argstart[-1], environ);
+ goto fail; /* Exec didn't work */
+ }
+
+ /*
* If we succeeded, the execve() doesn't return, so we
* can only be here is if the file hasn't been found yet.
* Try the next place on the path.
*/
- }
+ }
- /* all attempts failed to locate the file. Give up. */
- errno = ENOENT;
+ /* all attempts failed to locate the file. Give up. */
+ errno = ENOENT;
fail:
- free (fnbuffer);
- return -1;
+ free(fnbuffer);
+ return -1;
}
-
-#endif /* minix */
+#endif
#ifdef EMUL_OPEN3
* and also contains integers (args to 'access') that should be #define's.
*/
static int modes[] =
-{
- 04, /* O_RDONLY */
- 02, /* O_WRONLY */
- 06, /* O_RDWR */
- 06, /* invalid but we'd better cope -- O_WRONLY+O_RDWR */
-};
+ {
+ 04, /* O_RDONLY */
+ 02, /* O_WRONLY */
+ 06, /* O_RDWR */
+ 06, /* invalid but we'd better cope -- O_WRONLY+O_RDWR */
+ };
/* Shut off the automatic emulation of open(), we'll need it. */
#undef open
int
-open3 (path, flags, mode)
- char *path;
- int flags, mode;
+open3(path, flags, mode)
+char *path;
+int flags, mode;
{
- int exists = 1;
- int call_creat = 0;
- int fd;
- /*
+ int exists = 1;
+ int call_creat = 0;
+ int fd;
+ /*
* We actually do the work by calling the open() or creat() system
- * call, depending on the flags. Call_creat is true if we will use
+ * call, depending on the flags. Call_creat is true if we will use
* creat(), false if we will use open().
*/
- /*
- * See if the file exists and is accessible in the requested mode.
+ /*
+ * See if the file exists and is accessible in the requested mode.
*
* Strictly speaking we shouldn't be using access, since access checks
* against real uid, and the open call should check against euid.
* FIXME, the construction "flags & 3" and the modes table depends
* on the specific integer values of the O_XXX #define's. Foo!
*/
- if (access (path, modes[flags & 3]) < 0)
- {
- if (errno == ENOENT)
- {
- /* the file does not exist */
- exists = 0;
- }
- else
- {
- /* probably permission violation */
- if (flags & O_EXCL)
- {
- /* Oops, the file exists, we didn't want it. */
- /* No matter what the error, claim EEXIST. */
- errno = EEXIST;
- }
- return -1;
+ if (access(path,modes[flags & 3]) < 0) {
+ if (errno == ENOENT) {
+ /* the file does not exist */
+ exists = 0;
+ } else {
+ /* probably permission violation */
+ if (flags & O_EXCL) {
+ /* Oops, the file exists, we didn't want it. */
+ /* No matter what the error, claim EEXIST. */
+ errno = EEXIST;
+ }
+ return -1;
+ }
}
- }
- /* if we have the O_CREAT bit set, check for O_EXCL */
- if (flags & O_CREAT)
- {
- if ((flags & O_EXCL) && exists)
- {
- /* Oops, the file exists and we didn't want it to. */
- errno = EEXIST;
- return -1;
- }
- /*
+ /* if we have the O_CREAT bit set, check for O_EXCL */
+ if (flags & O_CREAT) {
+ if ((flags & O_EXCL) && exists) {
+ /* Oops, the file exists and we didn't want it to. */
+ errno = EEXIST;
+ return -1;
+ }
+ /*
* If the file doesn't exist, be sure to call creat() so that
* it will be created with the proper mode.
*/
- if (!exists)
- call_creat = 1;
- }
- else
- {
- /* If O_CREAT isn't set and the file doesn't exist, error. */
- if (!exists)
- {
- errno = ENOENT;
- return -1;
+ if (!exists) call_creat = 1;
+ } else {
+ /* If O_CREAT isn't set and the file doesn't exist, error. */
+ if (!exists) {
+ errno = ENOENT;
+ return -1;
+ }
}
- }
- /*
+ /*
* If the O_TRUNC flag is set and the file exists, we want to call
* creat() anyway, since creat() guarantees that the file will be
* truncated and open()-for-writing doesn't.
* (If the file doesn't exist, we're calling creat() anyway and the
* file will be created with zero length.)
*/
- if ((flags & O_TRUNC) && exists)
- call_creat = 1;
- /* actually do the call */
- if (call_creat)
- {
- /*
+ if ((flags & O_TRUNC) && exists) call_creat = 1;
+ /* actually do the call */
+ if (call_creat) {
+ /*
* call creat. May have to close and reopen the file if we
* want O_RDONLY or O_RDWR access -- creat() only gives
* O_WRONLY.
*/
- fd = creat (path, mode);
- if (fd < 0 || (flags & O_WRONLY))
- return fd;
- if (close (fd) < 0)
- return -1;
- /* Fall out to reopen the file we've created */
- }
+ fd = creat(path,mode);
+ if (fd < 0 || (flags & O_WRONLY)) return fd;
+ if (close(fd) < 0) return -1;
+ /* Fall out to reopen the file we've created */
+ }
- /*
+ /*
* calling old open, we strip most of the new flags just in case.
*/
- return open (path, flags & (O_RDONLY | O_WRONLY | O_RDWR | O_BINARY));
+ return open(path, flags & (O_RDONLY|O_WRONLY|O_RDWR|O_BINARY));
}
+#endif
-#endif /* EMUL_OPEN3 */
-
-#ifndef HAVE_MKNOD
+#ifdef MKNOD_MISSING
#ifdef __MSDOS__
typedef int dev_t;
#endif
/* Fake mknod by complaining */
int
-mknod (path, mode, dev)
- char *path;
- unsigned short mode;
- dev_t dev;
+mknod(path, mode, dev)
+ char *path;
+ unsigned short mode;
+ dev_t dev;
{
- int fd;
-
- errno = ENXIO; /* No such device or address */
- return -1; /* Just give an error */
+ int fd;
+
+ errno = ENXIO; /* No such device or address */
+ return -1; /* Just give an error */
}
/* Fake links by copying */
int
-link (path1, path2)
- char *path1;
- char *path2;
+link(path1, path2)
+ char *path1;
+ char *path2;
{
- char buf[256];
- int ifd, ofd;
- int nrbytes;
- int nwbytes;
-
- fprintf (stderr, "%s: %s: cannot link to %s, copying instead\n",
- tar, path1, path2);
- if ((ifd = open (path1, O_RDONLY | O_BINARY)) < 0)
- return -1;
- if ((ofd = creat (path2, 0666)) < 0)
- return -1;
- setmode (ofd, O_BINARY);
- while ((nrbytes = read (ifd, buf, sizeof (buf))) > 0)
- {
- if ((nwbytes = write (ofd, buf, nrbytes)) != nrbytes)
- {
- nrbytes = -1;
- break;
+ char buf[256];
+ int ifd, ofd;
+ int nrbytes;
+ int nwbytes;
+
+ fprintf(stderr, "%s: %s: cannot link to %s, copying instead\n",
+ tar, path1, path2);
+ if ((ifd = open(path1, O_RDONLY|O_BINARY)) < 0)
+ return -1;
+ if ((ofd = creat(path2, 0666)) < 0)
+ return -1;
+ setmode(ofd, O_BINARY);
+ while ((nrbytes = read(ifd, buf, sizeof(buf))) > 0) {
+ if ((nwbytes = write(ofd, buf, nrbytes)) != nrbytes) {
+ nrbytes = -1;
+ break;
+ }
}
- }
- /* Note use of "|" rather than "||" below: we want to close
+ /* Note use of "|" rather than "||" below: we want to close
* the files even if an error occurs.
*/
- if ((nrbytes < 0) | (0 != close (ifd)) | (0 != close (ofd)))
- {
- unlink (path2);
- return -1;
- }
- return 0;
+ if ((nrbytes < 0) | (0 != close(ifd)) | (0 != close(ofd))) {
+ unlink(path2);
+ return -1;
+ }
+ return 0;
}
/* everyone owns everything on MS-DOS (or is it no one owns anything?) */
int
-chown (path, uid, gid)
- char *path;
- int uid;
- int gid;
+chown(path, uid, gid)
+ char *path;
+ int uid;
+ int gid;
{
- return 0;
+ return 0;
}
int
-geteuid ()
+geteuid()
{
- return 0;
+ return 0;
}
-
-#endif /* !HAVE_MKNOD */
+#endif /* MKNOD_MISSING */
#ifdef __TURBOC__
#include <time.h>
struct utimbuf
{
- time_t actime; /* Access time. */
- time_t modtime; /* Modification time. */
+ time_t actime; /* Access time. */
+ time_t modtime; /* Modification time. */
};
int
_close (fd);
return status;
}
+#endif
-#endif /* __TURBOC__ */
-
+#ifdef UTILS_MISSING
/* Stash argv[0] here so panic will know what the program is called */
char *myname = 0;
void
-panic (s)
- char *s;
+panic(s)
+char *s;
{
- if (myname)
- fprintf (stderr, "%s:", myname);
- fprintf (stderr, s);
- putc ('\n', stderr);
- exit (12);
+ if(myname)
+ fprintf(stderr,"%s:",myname);
+ fprintf(stderr,s);
+ putc('\n',stderr);
+ exit(12);
}
PTR
-ck_malloc (size)
- size_t size;
+ck_malloc(size)
+size_t size;
{
- PTR ret;
-
- if (!size)
- size++;
- ret = malloc (size);
- if (ret == 0)
- panic ("Couldn't allocate memory");
- return ret;
+ PTR ret;
+
+ if(!size)
+ size++;
+ ret=malloc(size);
+ if(ret==0)
+ panic("Couldn't allocate memory");
+ return ret;
}
/* Used by alloca.c and bison.simple. */
char *
-xmalloc (size)
- size_t size;
+xmalloc(size)
+size_t size;
{
- return (char *) ck_malloc (size);
+ return (char *) ck_malloc(size);
}
PTR
-ck_realloc (ptr, size)
- PTR ptr;
- size_t size;
+ck_realloc(ptr,size)
+PTR ptr;
+size_t size;
{
- PTR ret;
-
- if (!ptr)
- ret = ck_malloc (size);
- else
- ret = realloc (ptr, size);
- if (ret == 0)
- panic ("Couldn't re-allocate memory");
- return ret;
+ PTR ret;
+
+ if(!ptr)
+ ret=ck_malloc(size);
+ else
+ ret=realloc(ptr,size);
+ if(ret==0)
+ panic("Couldn't re-allocate memory");
+ return ret;
}
/* Implement a variable sized buffer of 'stuff'. We don't know what it is,
nor do we care, as long as it doesn't mind being aligned on a char boundry.
*/
-struct buffer
- {
- int allocated;
- int length;
- char *b;
- };
+struct buffer {
+ int allocated;
+ int length;
+ char *b;
+};
#define MIN_ALLOCATE 50
char *
-init_buffer ()
+init_buffer()
{
- struct buffer *b;
+ struct buffer *b;
- b = (struct buffer *) ck_malloc (sizeof (struct buffer));
- b->allocated = MIN_ALLOCATE;
- b->b = (char *) ck_malloc (MIN_ALLOCATE);
- b->length = 0;
- return (char *) b;
+ b=(struct buffer *)ck_malloc(sizeof(struct buffer));
+ b->allocated=MIN_ALLOCATE;
+ b->b=(char *)ck_malloc(MIN_ALLOCATE);
+ b->length=0;
+ return (char *)b;
}
void
-flush_buffer (bb)
- char *bb;
+flush_buffer(bb)
+char *bb;
{
- struct buffer *b;
-
- b = (struct buffer *) bb;
- free (b->b);
- b->b = 0;
- b->allocated = 0;
- b->length = 0;
- free ((void *) b);
+ struct buffer *b;
+
+ b=(struct buffer *)bb;
+ free(b->b);
+ b->b=0;
+ b->allocated=0;
+ b->length=0;
+ free((void *)b);
}
void
-add_buffer (bb, p, n)
- char *bb;
- char *p;
- int n;
+add_buffer(bb,p,n)
+char *bb;
+char *p;
+int n;
{
- struct buffer *b;
+ struct buffer *b;
- b = (struct buffer *) bb;
- if (b->length + n > b->allocated)
- {
- b->allocated = b->length + n + MIN_ALLOCATE;
- b->b = (char *) ck_realloc (b->b, b->allocated);
- }
- bcopy (p, b->b + b->length, n);
- b->length += n;
+ b=(struct buffer *)bb;
+ if(b->length+n>b->allocated) {
+ b->allocated=b->length+n+MIN_ALLOCATE;
+ b->b=(char *)ck_realloc(b->b,b->allocated);
+ }
+ bcopy(p,b->b+b->length,n);
+ b->length+=n;
}
char *
-get_buffer (bb)
- char *bb;
+get_buffer(bb)
+char *bb;
{
- struct buffer *b;
+ struct buffer *b;
- b = (struct buffer *) bb;
- return b->b;
+ b=(struct buffer *)bb;
+ return b->b;
}
char *
-merge_sort (list, n, off, cmp)
- char *list;
- int (*cmp) ();
- unsigned n;
- int off;
+merge_sort(list,n,off,cmp)
+char *list;
+int (*cmp)();
+unsigned n;
+int off;
{
- char *ret;
+ char *ret;
- char *alist, *blist;
- unsigned alength, blength;
+ char *alist,*blist;
+ unsigned alength,blength;
- char *tptr;
- int tmp;
- char **prev;
+ char *tptr;
+ int tmp;
+ char **prev;
#define NEXTOF(ptr) (* ((char **)(((char *)(ptr))+off) ) )
- if (n == 1)
- return list;
- if (n == 2)
- {
- if ((*cmp) (list, NEXTOF (list)) > 0)
- {
- ret = NEXTOF (list);
- NEXTOF (ret) = list;
- NEXTOF (list) = 0;
- return ret;
+ if(n==1)
+ return list;
+ if(n==2) {
+ if((*cmp)(list,NEXTOF(list))>0) {
+ ret=NEXTOF(list);
+ NEXTOF(ret)=list;
+ NEXTOF(list)=0;
+ return ret;
+ }
+ return list;
}
- return list;
- }
- alist = list;
- alength = (n + 1) / 2;
- blength = n / 2;
- for (tptr = list, tmp = (n - 1) / 2; tmp; tptr = NEXTOF (tptr), tmp--)
- ;
- blist = NEXTOF (tptr);
- NEXTOF (tptr) = 0;
-
- alist = merge_sort (alist, alength, off, cmp);
- blist = merge_sort (blist, blength, off, cmp);
- prev = &ret;
- for (; alist && blist;)
- {
- if ((*cmp) (alist, blist) < 0)
- {
- tptr = NEXTOF (alist);
- *prev = alist;
- prev = &(NEXTOF (alist));
- alist = tptr;
- }
- else
- {
- tptr = NEXTOF (blist);
- *prev = blist;
- prev = &(NEXTOF (blist));
- blist = tptr;
+ alist=list;
+ alength=(n+1)/2;
+ blength=n/2;
+ for(tptr=list,tmp=(n-1)/2;tmp;tptr=NEXTOF(tptr),tmp--)
+ ;
+ blist=NEXTOF(tptr);
+ NEXTOF(tptr)=0;
+
+ alist=merge_sort(alist,alength,off,cmp);
+ blist=merge_sort(blist,blength,off,cmp);
+ prev = &ret;
+ for(;alist && blist;) {
+ if((*cmp)(alist,blist)<0) {
+ tptr=NEXTOF(alist);
+ *prev = alist;
+ prev = &(NEXTOF(alist));
+ alist=tptr;
+ } else {
+ tptr=NEXTOF(blist);
+ *prev = blist;
+ prev = &(NEXTOF(blist));
+ blist=tptr;
+ }
}
- }
- if (alist)
- *prev = alist;
- else
- *prev = blist;
+ if(alist)
+ *prev = alist;
+ else
+ *prev = blist;
- return ret;
+ return ret;
}
void
-ck_close (fd)
- int fd;
+ck_close(fd)
+int fd;
{
- if (close (fd) < 0)
- {
- msg_perror ("can't close a file #%d", fd);
- exit (EX_SYSTEM);
- }
+ if(close(fd)<0) {
+ msg_perror("can't close a file #%d",fd);
+ exit(EX_SYSTEM);
+ }
}
#include <ctype.h>
caller is done with it.
*/
char *
-quote_copy_string (string)
- char *string;
+quote_copy_string(string)
+char *string;
{
- char *from_here;
- char *to_there = 0;
- char *copy_buf = 0;
- int c;
- int copying = 0;
-
- from_here = string;
- while (*from_here)
- {
- c = *from_here++;
- if (c == '\\')
- {
- if (!copying)
- {
- int n;
-
- n = (from_here - string) - 1;
- copying++;
- copy_buf = (char *) malloc (n + 5 + strlen (from_here) * 4);
- if (!copy_buf)
- return 0;
- bcopy (string, copy_buf, n);
- to_there = copy_buf + n;
- }
- *to_there++ = '\\';
- *to_there++ = '\\';
- }
- else if (isprint (c))
- {
- if (copying)
- *to_there++ = c;
+ char *from_here;
+ char *to_there = 0;
+ char *copy_buf = 0;
+ int c;
+ int copying = 0;
+
+ from_here=string;
+ while(*from_here) {
+ c= *from_here++;
+ if(c=='\\') {
+ if(!copying) {
+ int n;
+
+ n=(from_here-string)-1;
+ copying++;
+ copy_buf=(char *)malloc(n+5+strlen(from_here)*4);
+ if(!copy_buf)
+ return 0;
+ bcopy(string,copy_buf,n);
+ to_there=copy_buf+n;
+ }
+ *to_there++='\\';
+ *to_there++='\\';
+ } else if(isprint(c)) {
+ if(copying)
+ *to_there++= c;
+ } else {
+ if(!copying) {
+ int n;
+
+ n=(from_here-string)-1;
+ copying++;
+ copy_buf=(char *)malloc(n+5+strlen(from_here)*4);
+ if(!copy_buf)
+ return 0;
+ bcopy(string,copy_buf,n);
+ to_there=copy_buf+n;
+ }
+ *to_there++='\\';
+ if(c=='\n') *to_there++='n';
+ else if(c=='\t') *to_there++='t';
+ else if(c=='\f') *to_there++='f';
+ else if(c=='\b') *to_there++='b';
+ else if(c=='\r') *to_there++='r';
+ else if(c=='\177') *to_there++='?';
+ else {
+ to_there[0]=(c>>6)+'0';
+ to_there[1]=((c>>3)&07)+'0';
+ to_there[2]=(c&07)+'0';
+ to_there+=3;
+ }
+ }
}
- else
- {
- if (!copying)
- {
- int n;
-
- n = (from_here - string) - 1;
- copying++;
- copy_buf = (char *) malloc (n + 5 + strlen (from_here) * 4);
- if (!copy_buf)
- return 0;
- bcopy (string, copy_buf, n);
- to_there = copy_buf + n;
- }
- *to_there++ = '\\';
- if (c == '\n')
- *to_there++ = 'n';
- else if (c == '\t')
- *to_there++ = 't';
- else if (c == '\f')
- *to_there++ = 'f';
- else if (c == '\b')
- *to_there++ = 'b';
- else if (c == '\r')
- *to_there++ = 'r';
- else if (c == '\177')
- *to_there++ = '?';
- else
- {
- to_there[0] = (c >> 6) + '0';
- to_there[1] = ((c >> 3) & 07) + '0';
- to_there[2] = (c & 07) + '0';
- to_there += 3;
- }
+ if(copying) {
+ *to_there='\0';
+ return copy_buf;
}
- }
- if (copying)
- {
- *to_there = '\0';
- return copy_buf;
- }
- return (char *) 0;
+ return (char *)0;
}
/* There is no un-quote-copy-string. Write it yourself */
char *
-un_quote_string (string)
- char *string;
+un_quote_string(string)
+char *string;
{
- char *ret;
- char *from_here;
- char *to_there;
- int tmp;
-
- ret = string;
- to_there = string;
- from_here = string;
- while (*from_here)
- {
- if (*from_here != '\\')
- {
- if (from_here != to_there)
- *to_there++ = *from_here++;
- else
- from_here++, to_there++;
- continue;
- }
- switch (*++from_here)
- {
- case '\\':
- *to_there++ = *from_here++;
- break;
- case 'n':
- *to_there++ = '\n';
- from_here++;
- break;
- case 't':
- *to_there++ = '\t';
- from_here++;
- break;
- case 'f':
- *to_there++ = '\f';
- from_here++;
- break;
- case 'b':
- *to_there++ = '\b';
- from_here++;
- break;
- case 'r':
- *to_there++ = '\r';
- from_here++;
- break;
- case '?':
- *to_there++ = 0177;
- from_here++;
- break;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- tmp = *from_here - '0';
- from_here++;
- if (*from_here < '0' || *from_here > '7')
- {
- *to_there++ = tmp;
- break;
- }
- tmp = tmp * 8 + *from_here - '0';
- from_here++;
- if (*from_here < '0' || *from_here > '7')
- {
- *to_there++ = tmp;
- break;
- }
- tmp = tmp * 8 + *from_here - '0';
- from_here++;
- *to_there = tmp;
- break;
- default:
- ret = 0;
- *to_there++ = '\\';
- *to_there++ = *from_here++;
- break;
+ char *ret;
+ char *from_here;
+ char *to_there;
+ int tmp;
+
+ ret=string;
+ to_there=string;
+ from_here=string;
+ while(*from_here) {
+ if(*from_here!='\\') {
+ if(from_here!=to_there)
+ *to_there++= *from_here++;
+ else
+ from_here++,to_there++;
+ continue;
+ }
+ switch(*++from_here) {
+ case '\\':
+ *to_there++= *from_here++;
+ break;
+ case 'n':
+ *to_there++= '\n';
+ from_here++;
+ break;
+ case 't':
+ *to_there++= '\t';
+ from_here++;
+ break;
+ case 'f':
+ *to_there++= '\f';
+ from_here++;
+ break;
+ case 'b':
+ *to_there++= '\b';
+ from_here++;
+ break;
+ case 'r':
+ *to_there++= '\r';
+ from_here++;
+ break;
+ case '?':
+ *to_there++= 0177;
+ from_here++;
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ tmp= *from_here - '0';
+ from_here++;
+ if(*from_here<'0' || *from_here>'7') {
+ *to_there++= tmp;
+ break;
+ }
+ tmp= tmp*8 + *from_here-'0';
+ from_here++;
+ if(*from_here<'0' || *from_here>'7') {
+ *to_there++= tmp;
+ break;
+ }
+ tmp=tmp*8 + *from_here-'0';
+ from_here++;
+ *to_there=tmp;
+ break;
+ default:
+ ret=0;
+ *to_there++='\\';
+ *to_there++= *from_here++;
+ break;
+ }
}
- }
- if (*to_there)
- *to_there++ = '\0';
- return ret;
+ if(*to_there)
+ *to_there++='\0';
+ return ret;
}
+#endif
-void
-ck_pipe (pipes)
- int *pipes;
+#ifdef CK_PIPE_MISSING
+void ck_pipe(pipes)
+int *pipes;
{
- if (pipe (pipes) < 0)
- {
- msg_perror ("can't open a pipe");
- exit (EX_SYSTEM);
- }
+ if(pipe(pipes)<0) {
+ msg_perror("can't open a pipe");
+ exit(EX_SYSTEM);
+ }
}
+#endif
+
+#ifdef STRSTR_MISSING
-#ifndef HAVE_STRSTR
/*
* strstr - find first occurrence of wanted in s
*/
char * /* found string, or NULL if none */
-strstr (s, wanted)
- char *s;
- char *wanted;
+strstr(s, wanted)
+char *s;
+char *wanted;
{
- register char *scan;
- register size_t len;
- register char firstc;
+ register char *scan;
+ register size_t len;
+ register char firstc;
- if (*wanted == '\0')
- return (char *) 0;
- /*
+ if (*wanted == '\0')
+ return (char *)0;
+ /*
* The odd placement of the two tests is so "" is findable.
* Also, we inline the first char for speed.
* The ++ on scan has been moved down for optimization.
*/
- firstc = *wanted;
- len = strlen (wanted);
- for (scan = s; *scan != firstc || strncmp (scan, wanted, len) != 0;)
- if (*scan++ == '\0')
- return (char *) 0;
- return scan;
+ firstc = *wanted;
+ len = strlen(wanted);
+ for (scan = s; *scan != firstc || strncmp(scan, wanted, len) != 0; )
+ if (*scan++ == '\0')
+ return (char *)0;
+ return scan;
}
+#endif
-#endif /* !HAVE_STRSTR */
-
-#ifndef HAVE_FTRUNCATE
+#ifdef FTRUNCATE_MISSING
#ifdef F_CHSIZE
int
{
return fcntl (fd, F_CHSIZE, length);
}
-
-#else /* !F_CHSIZE */
+#else
#ifdef F_FREESP
/* code courtesy of William Kucharski, kucharsk@Solbourne.com */
int
-ftruncate (fd, length)
- int fd; /* file descriptor */
- off_t length; /* length to set file to */
+ftruncate(fd, length)
+int fd; /* file descriptor */
+off_t length; /* length to set file to */
{
- struct flock fl;
+ struct flock fl;
- fl.l_whence = 0;
- fl.l_len = 0;
- fl.l_start = length;
- fl.l_type = F_WRLCK; /* write lock on file space */
+ fl.l_whence = 0;
+ fl.l_len = 0;
+ fl.l_start = length;
+ fl.l_type = F_WRLCK; /* write lock on file space */
- /*
+ /*
* This relies on the UNDOCUMENTED F_FREESP argument to
* fcntl(2), which truncates the file so that it ends at the
* position indicated by fl.l_start.
* Will minor miracles never cease?
*/
- if (fcntl (fd, F_FREESP, &fl) < 0)
- return -1;
+ if (fcntl(fd, F_FREESP, &fl) < 0)
+ return -1;
- return 0;
+ return 0;
}
-#else /* !F_FREESP */
+#else
int
-ftruncate (fd, length)
- int fd;
- off_t length;
+ftruncate(fd, length)
+int fd;
+off_t length;
{
- errno = EIO;
- return -1;
+ errno = EIO;
+ return -1;
}
-
-#endif /* !F_FREESP */
-#endif /* !F_CHSIZE */
-#endif /* !HAVE_FTRUNCATE */
+#endif
+#endif
+#endif
extern FILE *msg_file;
-#if defined (HAVE_VPRINTF) && __STDC__
+#if !defined (VPRINTF_MISSING) && defined (__STDC__)
#include <stdarg.h>
void
-msg (char *str,...)
+msg(char *str,...)
{
- va_list args;
-
- va_start (args, str);
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- vfprintf (stderr, str, args);
- va_end (args);
- putc ('\n', stderr);
- fflush (stderr);
+ va_list args;
+
+ va_start(args,str);
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ vfprintf(stderr,str,args);
+ va_end(args);
+ putc('\n',stderr);
+ fflush(stderr);
}
void
-msg_perror (char *str,...)
+msg_perror(char *str,...)
{
- va_list args;
- int save_e;
-
- save_e = errno;
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- va_start (args, str);
- vfprintf (stderr, str, args);
- va_end (args);
- errno = save_e;
- perror (" ");
- fflush (stderr);
+ va_list args;
+ int save_e;
+
+ save_e=errno;
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ va_start(args,str);
+ vfprintf(stderr,str,args);
+ va_end(args);
+ errno=save_e;
+ perror(" ");
+ fflush(stderr);
}
+#endif /* not VPRINTF_MISSING or __STDC__ */
-#endif /* HAVE_VPRINTF and __STDC__ */
-
-#if defined(HAVE_VPRINTF) && !__STDC__
+#if !defined(VPRINTF_MISSING) && !defined(__STDC__)
#include <varargs.h>
void
-msg (str, va_alist)
- char *str;
- va_dcl
+msg(str,va_alist)
+char *str;
+va_dcl
{
- va_list args;
-
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- va_start (args);
- vfprintf (stderr, str, args);
- va_end (args);
- putc ('\n', stderr);
- fflush (stderr);
+ va_list args;
+
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ va_start(args);
+ vfprintf(stderr,str,args);
+ va_end(args);
+ putc('\n',stderr);
+ fflush(stderr);
}
void
-msg_perror (str, va_alist)
- char *str;
- va_dcl
+msg_perror(str,va_alist)
+char *str;
+va_dcl
{
- va_list args;
- int save_e;
-
- save_e = errno;
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- va_start (args);
- vfprintf (stderr, str, args);
- va_end (args);
- errno = save_e;
- perror (" ");
- fflush (stderr);
+ va_list args;
+ int save_e;
+
+ save_e=errno;
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ va_start(args);
+ vfprintf(stderr,str,args);
+ va_end(args);
+ errno=save_e;
+ perror(" ");
+ fflush(stderr);
}
+#endif /* not VPRINTF_MISSING and not __STDC__ */
-#endif /* HAVE_VPRINTF and not __STDC__ */
-
-#if !defined(HAVE_VPRINTF) && defined(HAVE_DOPRNT)
+#if defined(VPRINTF_MISSING) && !defined(DOPRNT_MISSING)
void
-msg (str, args)
- char *str;
- int args;
+msg(str,args)
+char *str;
+int args;
{
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- _doprnt (str, &args, stderr);
- putc ('\n', stderr);
- fflush (stderr);
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ _doprnt(str, &args, stderr);
+ putc('\n',stderr);
+ fflush(stderr);
}
void
-msg_perror (str, args)
- char *str;
+msg_perror(str,args)
+char *str;
{
- int save_e;
-
- save_e = errno;
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- _doprnt (str, &args, stderr);
- errno = save_e;
- perror (" ");
- fflush (stderr);
+ int save_e;
+
+ save_e=errno;
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ _doprnt(str, &args, stderr);
+ errno=save_e;
+ perror(" ");
+ fflush(stderr);
}
+#endif /* VPRINTF_MISSING and not DOPRNT_MISSING */
-#endif /* !HAVE_VPRINTF and HAVE_DOPRNT */
-
-#if !defined(HAVE_VPRINTF) && !defined(HAVE_DOPRNT)
-void
-msg (str, a1, a2, a3, a4, a5, a6)
- char *str;
+#if defined(VPRINTF_MISSING) && defined(DOPRNT_MISSING)
+void msg(str,a1,a2,a3,a4,a5,a6)
+char *str;
{
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- fprintf (stderr, str, a1, a2, a3, a4, a5, a6);
- putc ('\n', stderr);
- fflush (stderr);
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ fprintf(stderr,str,a1,a2,a3,a4,a5,a6);
+ putc('\n',stderr);
+ fflush(stderr);
}
void
-msg_perror (str, a1, a2, a3, a4, a5, a6)
- char *str;
+msg_perror(str,a1,a2,a3,a4,a5,a6)
+char *str;
{
- int save_e;
-
- save_e = errno;
- fflush (msg_file);
- fprintf (stderr, "%s: ", tar);
- if (f_sayblock)
- fprintf (stderr, "rec %d: ", baserec + (ar_record - ar_block));
- fprintf (stderr, str, a1, a2, a3, a4, a5, a6);
- fprintf (stderr, ": ");
- errno = save_e;
- perror (" ");
+ int save_e;
+
+ save_e=errno;
+ fflush(msg_file);
+ fprintf(stderr,"%s: ",tar);
+ if(f_sayblock)
+ fprintf(stderr,"rec %d: ",baserec + (ar_record - ar_block));
+ fprintf(stderr,str,a1,a2,a3,a4,a5,a6);
+ fprintf(stderr,": ");
+ errno=save_e;
+ perror(" ");
}
-
-#endif /* !HAVE_VPRINTF and !HAVE_DOPRNT */
+#endif /* VPRINTF_MISSING and DOPRNT_MISSING */
projects / chaz / tar / commitdiff
