Some formatting updates (ran the code through indent)

 -Erik

1 files changed, 848 insertions, 941 deletions

diff --git a/coreutils/tail.c b/coreutils/tail.c
index 0ab8f11..31705af 100644
--- a/coreutils/tail.c
+++ b/coreutils/tail.c
@@ -1,3 +1,4 @@
+/* vi: set sw=4 ts=4: */
 #include "internal.h"
 /* This file contains _two_ implementations of tail.  One is
  * a bit more full featured, but costs 6k.  The other (i.e. the
@@ -68,22 +69,23 @@ static int forever;
 static int print_headers;
 
 const char tail_usage[] =
-    "tail [OPTION] [FILE]...\n\n"
-    "Print last 10 lines of each FILE to standard output.\n"
-    "With more than one FILE, precede each with a header giving the\n"
-    "file name. With no FILE, or when FILE is -, read standard input.\n\n"
-    "Options:\n"
-    "\t-n NUM\t\tPrint last NUM lines instead of first 10\n"
-    "\t-f\t\tOutput data as the file grows.  This version\n"
-    "\t\t\tof 'tail -f' supports only one file at a time.\n";
+	"tail [OPTION] [FILE]...\n\n"
+	"Print last 10 lines of each FILE to standard output.\n"
+	"With more than one FILE, precede each with a header giving the\n"
+	"file name. With no FILE, or when FILE is -, read standard input.\n\n"
+	"Options:\n"
+	"\t-n NUM\t\tPrint last NUM lines instead of first 10\n"
+
+	"\t-f\t\tOutput data as the file grows.  This version\n"
+	"\t\t\tof 'tail -f' supports only one file at a time.\n";
 
 
 static void write_header(const char *filename)
 {
-    static int first_file = 1;
+	static int first_file = 1;
 
-    printf("%s==> %s <==\n", (first_file ? "" : "\n"), filename);
-    first_file = 0;
+	printf("%s==> %s <==\n", (first_file ? "" : "\n"), filename);
+	first_file = 0;
 }
 
 /* Print the last N_LINES lines from the end of file FD.
@@ -97,57 +99,57 @@ static void write_header(const char *filename)
 static int
 file_lines(const char *filename, int fd, long int n_lines, off_t pos)
 {
-    char buffer[BUFSIZ];
-    int bytes_read;
-    int i;			/* Index into `buffer' for scanning.  */
-
-    if (n_lines == 0)
-	return 0;
+	char buffer[BUFSIZ];
+	int bytes_read;
+	int i;						/* Index into `buffer' for scanning.  */
 
-    /* Set `bytes_read' to the size of the last, probably partial, buffer;
-       0 < `bytes_read' <= `BUFSIZ'.  */
-    bytes_read = pos % BUFSIZ;
-    if (bytes_read == 0)
-	bytes_read = BUFSIZ;
-    /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
-       reads will be on block boundaries, which might increase efficiency.  */
-    pos -= bytes_read;
-    lseek(fd, pos, SEEK_SET);
-    bytes_read = fullRead(fd, buffer, bytes_read);
-    if (bytes_read == -1)
-	error("read error");
-
-    /* Count the incomplete line on files that don't end with a newline.  */
-    if (bytes_read && buffer[bytes_read - 1] != '\n')
-	--n_lines;
-
-    do {
-	/* Scan backward, counting the newlines in this bufferfull.  */
-	for (i = bytes_read - 1; i >= 0; i--) {
-	    /* Have we counted the requested number of newlines yet?  */
-	    if (buffer[i] == '\n' && n_lines-- == 0) {
-		/* If this newline wasn't the last character in the buffer,
-		   print the text after it.  */
-		if (i != bytes_read - 1)
-		    XWRITE(STDOUT_FILENO, &buffer[i + 1],
-			   bytes_read - (i + 1));
+	if (n_lines == 0)
 		return 0;
-	    }
-	}
-	/* Not enough newlines in that bufferfull.  */
-	if (pos == 0) {
-	    /* Not enough lines in the file; print the entire file.  */
-	    lseek(fd, (off_t) 0, SEEK_SET);
-	    return 0;
-	}
-	pos -= BUFSIZ;
+
+	/* Set `bytes_read' to the size of the last, probably partial, buffer;
+	   0 < `bytes_read' <= `BUFSIZ'.  */
+	bytes_read = pos % BUFSIZ;
+	if (bytes_read == 0)
+		bytes_read = BUFSIZ;
+	/* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
+	   reads will be on block boundaries, which might increase efficiency.  */
+	pos -= bytes_read;
 	lseek(fd, pos, SEEK_SET);
-    }
-    while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0);
-    if (bytes_read == -1)
-	error("read error");
+	bytes_read = fullRead(fd, buffer, bytes_read);
+	if (bytes_read == -1)
+		error("read error");
+
+	/* Count the incomplete line on files that don't end with a newline.  */
+	if (bytes_read && buffer[bytes_read - 1] != '\n')
+		--n_lines;
+
+	do {
+		/* Scan backward, counting the newlines in this bufferfull.  */
+		for (i = bytes_read - 1; i >= 0; i--) {
+			/* Have we counted the requested number of newlines yet?  */
+			if (buffer[i] == '\n' && n_lines-- == 0) {
+				/* If this newline wasn't the last character in the buffer,
+				   print the text after it.  */
+				if (i != bytes_read - 1)
+					XWRITE(STDOUT_FILENO, &buffer[i + 1],
+						   bytes_read - (i + 1));
+				return 0;
+			}
+		}
+		/* Not enough newlines in that bufferfull.  */
+		if (pos == 0) {
+			/* Not enough lines in the file; print the entire file.  */
+			lseek(fd, (off_t) 0, SEEK_SET);
+			return 0;
+		}
+		pos -= BUFSIZ;
+		lseek(fd, pos, SEEK_SET);
+	}
+	while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0);
+	if (bytes_read == -1)
+		error("read error");
 
-    return 0;
+	return 0;
 }
 
 /* Print the last N_LINES lines from the end of the standard input,
@@ -157,100 +159,100 @@ file_lines(const char *filename, int fd, long int n_lines, off_t pos)
 
 static int pipe_lines(const char *filename, int fd, long int n_lines)
 {
-    struct linebuffer {
-	int nbytes, nlines;
-	char buffer[BUFSIZ];
-	struct linebuffer *next;
-    };
-    typedef struct linebuffer LBUFFER;
-    LBUFFER *first, *last, *tmp;
-    int i;			/* Index into buffers.  */
-    int total_lines = 0;	/* Total number of newlines in all buffers.  */
-    int errors = 0;
-
-    first = last = (LBUFFER *) xmalloc(sizeof(LBUFFER));
-    first->nbytes = first->nlines = 0;
-    first->next = NULL;
-    tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
-
-    /* Input is always read into a fresh buffer.  */
-    while ((tmp->nbytes = fullRead(fd, tmp->buffer, BUFSIZ)) > 0) {
-	tmp->nlines = 0;
-	tmp->next = NULL;
-
-	/* Count the number of newlines just read.  */
-	for (i = 0; i < tmp->nbytes; i++)
-	    if (tmp->buffer[i] == '\n')
-		++tmp->nlines;
-	total_lines += tmp->nlines;
-
-	/* If there is enough room in the last buffer read, just append the new
-	   one to it.  This is because when reading from a pipe, `nbytes' can
-	   often be very small.  */
-	if (tmp->nbytes + last->nbytes < BUFSIZ) {
-	    memcpy(&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
-	    last->nbytes += tmp->nbytes;
-	    last->nlines += tmp->nlines;
-	} else {
-	    /* If there's not enough room, link the new buffer onto the end of
-	       the list, then either free up the oldest buffer for the next
-	       read if that would leave enough lines, or else malloc a new one.
-	       Some compaction mechanism is possible but probably not
-	       worthwhile.  */
-	    last = last->next = tmp;
-	    if (total_lines - first->nlines > n_lines) {
-		tmp = first;
-		total_lines -= first->nlines;
-		first = first->next;
-	    } else
-		tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+	struct linebuffer {
+		int nbytes, nlines;
+		char buffer[BUFSIZ];
+		struct linebuffer *next;
+	};
+	typedef struct linebuffer LBUFFER;
+	LBUFFER *first, *last, *tmp;
+	int i;						/* Index into buffers.  */
+	int total_lines = 0;		/* Total number of newlines in all buffers.  */
+	int errors = 0;
+
+	first = last = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+	first->nbytes = first->nlines = 0;
+	first->next = NULL;
+	tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+
+	/* Input is always read into a fresh buffer.  */
+	while ((tmp->nbytes = fullRead(fd, tmp->buffer, BUFSIZ)) > 0) {
+		tmp->nlines = 0;
+		tmp->next = NULL;
+
+		/* Count the number of newlines just read.  */
+		for (i = 0; i < tmp->nbytes; i++)
+			if (tmp->buffer[i] == '\n')
+				++tmp->nlines;
+		total_lines += tmp->nlines;
+
+		/* If there is enough room in the last buffer read, just append the new
+		   one to it.  This is because when reading from a pipe, `nbytes' can
+		   often be very small.  */
+		if (tmp->nbytes + last->nbytes < BUFSIZ) {
+			memcpy(&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
+			last->nbytes += tmp->nbytes;
+			last->nlines += tmp->nlines;
+		} else {
+			/* If there's not enough room, link the new buffer onto the end of
+			   the list, then either free up the oldest buffer for the next
+			   read if that would leave enough lines, or else malloc a new one.
+			   Some compaction mechanism is possible but probably not
+			   worthwhile.  */
+			last = last->next = tmp;
+			if (total_lines - first->nlines > n_lines) {
+				tmp = first;
+				total_lines -= first->nlines;
+				first = first->next;
+			} else
+				tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+		}
 	}
-    }
-    if (tmp->nbytes == -1)
-	error("read error");
-
-    free((char *) tmp);
-
-    /* This prevents a core dump when the pipe contains no newlines.  */
-    if (n_lines == 0)
-	goto free_lbuffers;
-
-    /* Count the incomplete line on files that don't end with a newline.  */
-    if (last->buffer[last->nbytes - 1] != '\n') {
-	++last->nlines;
-	++total_lines;
-    }
-
-    /* Run through the list, printing lines.  First, skip over unneeded
-       buffers.  */
-    for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
-	total_lines -= tmp->nlines;
-
-    /* Find the correct beginning, then print the rest of the file.  */
-    if (total_lines > n_lines) {
-	char *cp;
-
-	/* Skip `total_lines' - `n_lines' newlines.  We made sure that
-	   `total_lines' - `n_lines' <= `tmp->nlines'.  */
-	cp = tmp->buffer;
-	for (i = total_lines - n_lines; i; --i)
-	    while (*cp++ != '\n')
-		/* Do nothing.  */ ;
-	i = cp - tmp->buffer;
-    } else
-	i = 0;
-    XWRITE(STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
-
-    for (tmp = tmp->next; tmp; tmp = tmp->next)
-	XWRITE(STDOUT_FILENO, tmp->buffer, tmp->nbytes);
+	if (tmp->nbytes == -1)
+		error("read error");
+
+	free((char *) tmp);
+
+	/* This prevents a core dump when the pipe contains no newlines.  */
+	if (n_lines == 0)
+		goto free_lbuffers;
+
+	/* Count the incomplete line on files that don't end with a newline.  */
+	if (last->buffer[last->nbytes - 1] != '\n') {
+		++last->nlines;
+		++total_lines;
+	}
+
+	/* Run through the list, printing lines.  First, skip over unneeded
+	   buffers.  */
+	for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
+		total_lines -= tmp->nlines;
+
+	/* Find the correct beginning, then print the rest of the file.  */
+	if (total_lines > n_lines) {
+		char *cp;
+
+		/* Skip `total_lines' - `n_lines' newlines.  We made sure that
+		   `total_lines' - `n_lines' <= `tmp->nlines'.  */
+		cp = tmp->buffer;
+		for (i = total_lines - n_lines; i; --i)
+			while (*cp++ != '\n')
+				/* Do nothing.  */ ;
+		i = cp - tmp->buffer;
+	} else
+		i = 0;
+	XWRITE(STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
+
+	for (tmp = tmp->next; tmp; tmp = tmp->next)
+		XWRITE(STDOUT_FILENO, tmp->buffer, tmp->nbytes);
 
   free_lbuffers:
-    while (first) {
-	tmp = first->next;
-	free((char *) first);
-	first = tmp;
-    }
-    return errors;
+	while (first) {
+		tmp = first->next;
+		free((char *) first);
+		first = tmp;
+	}
+	return errors;
 }
 
 /* Display file FILENAME from the current position in FD to the end.
@@ -259,25 +261,25 @@ static int pipe_lines(const char *filename, int fd, long int n_lines)
 
 static long dump_remainder(const char *filename, int fd)
 {
-    char buffer[BUFSIZ];
-    int bytes_read;
-    long total;
+	char buffer[BUFSIZ];
+	int bytes_read;
+	long total;
 
-    total = 0;
+	total = 0;
   output:
-    while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0) {
-	XWRITE(STDOUT_FILENO, buffer, bytes_read);
-	total += bytes_read;
-    }
-    if (bytes_read == -1)
-	error("read error");
-    if (forever) {
-	fflush(stdout);
-	sleep(1);
-	goto output;
-    }
-
-    return total;
+	while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0) {
+		XWRITE(STDOUT_FILENO, buffer, bytes_read);
+		total += bytes_read;
+	}
+	if (bytes_read == -1)
+		error("read error");
+	if (forever) {
+		fflush(stdout);
+		sleep(1);
+		goto output;
+	}
+
+	return total;
 }
 
 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
@@ -285,31 +287,31 @@ static long dump_remainder(const char *filename, int fd)
 
 static int tail_lines(const char *filename, int fd, long int n_lines)
 {
-    struct stat stats;
-    off_t length;
-
-    if (print_headers)
-	write_header(filename);
-
-    if (fstat(fd, &stats))
-	error("fstat error");
-
-    /* Use file_lines only if FD refers to a regular file with
-       its file pointer positioned at beginning of file.  */
-    /* FIXME: adding the lseek conjunct is a kludge.
-       Once there's a reasonable test suite, fix the true culprit:
-       file_lines.  file_lines shouldn't presume that the input
-       file pointer is initially positioned to beginning of file.  */
-    if (S_ISREG(stats.st_mode)
-	&& lseek(fd, (off_t) 0, SEEK_CUR) == (off_t) 0) {
-	length = lseek(fd, (off_t) 0, SEEK_END);
-	if (length != 0 && file_lines(filename, fd, n_lines, length))
-	    return 1;
-	dump_remainder(filename, fd);
-    } else
-	return pipe_lines(filename, fd, n_lines);
-
-    return 0;
+	struct stat stats;
+	off_t length;
+
+	if (print_headers)
+		write_header(filename);
+
+	if (fstat(fd, &stats))
+		error("fstat error");
+
+	/* Use file_lines only if FD refers to a regular file with
+	   its file pointer positioned at beginning of file.  */
+	/* FIXME: adding the lseek conjunct is a kludge.
+	   Once there's a reasonable test suite, fix the true culprit:
+	   file_lines.  file_lines shouldn't presume that the input
+	   file pointer is initially positioned to beginning of file.  */
+	if (S_ISREG(stats.st_mode)
+		&& lseek(fd, (off_t) 0, SEEK_CUR) == (off_t) 0) {
+		length = lseek(fd, (off_t) 0, SEEK_END);
+		if (length != 0 && file_lines(filename, fd, n_lines, length))
+			return 1;
+		dump_remainder(filename, fd);
+	} else
+		return pipe_lines(filename, fd, n_lines);
+
+	return 0;
 }
 
 /* Display the last N_UNITS lines of file FILENAME.
@@ -318,78 +320,78 @@ static int tail_lines(const char *filename, int fd, long int n_lines)
 
 static int tail_file(const char *filename, off_t n_units)
 {
-    int fd, errors;
-
-    if (!strcmp(filename, "-")) {
-	filename = "standard input";
-	errors = tail_lines(filename, 0, (long) n_units);
-    } else {
-	/* Not standard input.  */
-	fd = open(filename, O_RDONLY);
-	if (fd == -1)
-	    error("open error");
-
-	errors = tail_lines(filename, fd, (long) n_units);
-	close(fd);
-    }
-
-    return errors;
+	int fd, errors;
+
+	if (!strcmp(filename, "-")) {
+		filename = "standard input";
+		errors = tail_lines(filename, 0, (long) n_units);
+	} else {
+		/* Not standard input.  */
+		fd = open(filename, O_RDONLY);
+		if (fd == -1)
+			error("open error");
+
+		errors = tail_lines(filename, fd, (long) n_units);
+		close(fd);
+	}
+
+	return errors;
 }
 
 extern int tail_main(int argc, char **argv)
 {
-    int exit_status = 0;
-    int n_units = DEFAULT_N_LINES;
-    int n_tmp, i;
-    char opt;
-
-    forever = print_headers = 0;
-
-    /* parse argv[] */
-    for (i = 1; i < argc; i++) {
-	if (argv[i][0] == '-') {
-	    opt = argv[i][1];
-	    switch (opt) {
-	    case 'f':
-		forever = 1;
-		break;
-	    case 'n':
-		n_tmp = 0;
-		if (++i < argc)
-		    n_tmp = atoi(argv[i]);
-		if (n_tmp < 1)
-		    usage(tail_usage);
-		n_units = n_tmp;
-		break;
-	    case '-':
-	    case 'h':
-		usage(tail_usage);
-	    default:
-		fprintf(stderr, "tail: invalid option -- %c\n", opt);
-		usage(tail_usage);
-	    }
-	} else {
-	    break;
+	int exit_status = 0;
+	int n_units = DEFAULT_N_LINES;
+	int n_tmp, i;
+	char opt;
+
+	forever = print_headers = 0;
+
+	/* parse argv[] */
+	for (i = 1; i < argc; i++) {
+		if (argv[i][0] == '-') {
+			opt = argv[i][1];
+			switch (opt) {
+			case 'f':
+				forever = 1;
+				break;
+			case 'n':
+				n_tmp = 0;
+				if (++i < argc)
+					n_tmp = atoi(argv[i]);
+				if (n_tmp < 1)
+					usage(tail_usage);
+				n_units = n_tmp;
+				break;
+			case '-':
+			case 'h':
+				usage(tail_usage);
+			default:
+				fprintf(stderr, "tail: invalid option -- %c\n", opt);
+				usage(tail_usage);
+			}
+		} else {
+			break;
+		}
 	}
-    }
 
-    if (i + 1 < argc) {
-	if (forever) {
-	    fprintf(stderr,
-		    "tail: option -f is invalid with multiple files\n");
-	    usage(tail_usage);
+	if (i + 1 < argc) {
+		if (forever) {
+			fprintf(stderr,
+					"tail: option -f is invalid with multiple files\n");
+			usage(tail_usage);
+		}
+		print_headers = 1;
 	}
-	print_headers = 1;
-    }
 
-    if (i >= argc) {
-	exit_status |= tail_file("-", n_units);
-    } else {
-	for (; i < argc; i++)
-	    exit_status |= tail_file(argv[i], n_units);
-    }
+	if (i >= argc) {
+		exit_status |= tail_file("-", n_units);
+	} else {
+		for (; i < argc; i++)
+			exit_status |= tail_file(argv[i], n_units);
+	}
 
-    exit(exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+	exit(exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 }
 
 
@@ -441,15 +443,15 @@ extern int tail_main(int argc, char **argv)
 #define NDEBUG 1
 
 
-static void detailed_error(int i, int errnum, char* fmt, ...)
+static void detailed_error(int i, int errnum, char *fmt, ...)
 {
-    va_list arguments;
+	va_list arguments;
 
-    va_start(arguments, fmt);
-    vfprintf(stderr, fmt, arguments);
-    fprintf(stderr, "\n%s\n", strerror( errnum));
-    va_end(arguments);
-    exit(i);
+	va_start(arguments, fmt);
+	vfprintf(stderr, fmt, arguments);
+	fprintf(stderr, "\n%s\n", strerror(errnum));
+	va_end(arguments);
+	exit(i);
 }
 
 
@@ -494,9 +496,8 @@ static int from_start;
 static int print_headers;
 
 /* When to print the filename banners.  */
-enum header_mode
-{
-  multiple_files, always, never
+enum header_mode {
+	multiple_files, always, never
 };
 
 /* The name this program was run with.  */
@@ -506,8 +507,7 @@ char *program_name;
 static int have_read_stdin;
 
 
-static const char tail_usage[] = 
-"tail [OPTION]... [FILE]...\n\
+static const char tail_usage[] = "tail [OPTION]... [FILE]...\n\
 \n\
 Print last 10 lines of each FILE to standard output.\n\
 With more than one FILE, precede each with a header giving the file name.\n\
@@ -524,15 +524,13 @@ If the first character of N (bytes or lines) is a `+', output begins with \n\
 the Nth item from the start of each file, otherwise, print the last N items\n\
 in the file.  N bytes may be suffixed by k (x1024), b (x512), or m (1024^2).\n\n";
 
-static void
-write_header (const char *filename, const char *comment)
+static void write_header(const char *filename, const char *comment)
 {
-  static int first_file = 1;
+	static int first_file = 1;
 
-  printf ("%s==> %s%s%s <==\n", (first_file ? "" : "\n"), filename,
-	  (comment ? ": " : ""),
-	  (comment ? comment : ""));
-  first_file = 0;
+	printf("%s==> %s%s%s <==\n", (first_file ? "" : "\n"), filename,
+		   (comment ? ": " : ""), (comment ? comment : ""));
+	first_file = 0;
 }
 
 /* Print the last N_LINES lines from the end of file FD.
@@ -544,67 +542,62 @@ write_header (const char *filename, const char *comment)
    Return 0 if successful, 1 if an error occurred.  */
 
 static int
-file_lines (const char *filename, int fd, long int n_lines, off_t pos)
+file_lines(const char *filename, int fd, long int n_lines, off_t pos)
 {
-  char buffer[BUFSIZ];
-  int bytes_read;
-  int i;			/* Index into `buffer' for scanning.  */
-
-  if (n_lines == 0)
-    return 0;
-
-  /* Set `bytes_read' to the size of the last, probably partial, buffer;
-     0 < `bytes_read' <= `BUFSIZ'.  */
-  bytes_read = pos % BUFSIZ;
-  if (bytes_read == 0)
-    bytes_read = BUFSIZ;
-  /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
-     reads will be on block boundaries, which might increase efficiency.  */
-  pos -= bytes_read;
-  lseek (fd, pos, SEEK_SET);
-  bytes_read = fullRead (fd, buffer, bytes_read);
-  if (bytes_read == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-
-  /* Count the incomplete line on files that don't end with a newline.  */
-  if (bytes_read && buffer[bytes_read - 1] != '\n')
-    --n_lines;
-
-  do
-    {
-      /* Scan backward, counting the newlines in this bufferfull.  */
-      for (i = bytes_read - 1; i >= 0; i--)
-	{
-	  /* Have we counted the requested number of newlines yet?  */
-	  if (buffer[i] == '\n' && n_lines-- == 0)
-	    {
-	      /* If this newline wasn't the last character in the buffer,
-	         print the text after it.  */
-	      if (i != bytes_read - 1)
-		XWRITE (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
-	      return 0;
-	    }
+	char buffer[BUFSIZ];
+	int bytes_read;
+	int i;						/* Index into `buffer' for scanning.  */
+
+	if (n_lines == 0)
+		return 0;
+
+	/* Set `bytes_read' to the size of the last, probably partial, buffer;
+	   0 < `bytes_read' <= `BUFSIZ'.  */
+	bytes_read = pos % BUFSIZ;
+	if (bytes_read == 0)
+		bytes_read = BUFSIZ;
+	/* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
+	   reads will be on block boundaries, which might increase efficiency.  */
+	pos -= bytes_read;
+	lseek(fd, pos, SEEK_SET);
+	bytes_read = fullRead(fd, buffer, bytes_read);
+	if (bytes_read == -1) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
+	}
+
+	/* Count the incomplete line on files that don't end with a newline.  */
+	if (bytes_read && buffer[bytes_read - 1] != '\n')
+		--n_lines;
+
+	do {
+		/* Scan backward, counting the newlines in this bufferfull.  */
+		for (i = bytes_read - 1; i >= 0; i--) {
+			/* Have we counted the requested number of newlines yet?  */
+			if (buffer[i] == '\n' && n_lines-- == 0) {
+				/* If this newline wasn't the last character in the buffer,
+				   print the text after it.  */
+				if (i != bytes_read - 1)
+					XWRITE(STDOUT_FILENO, &buffer[i + 1],
+						   bytes_read - (i + 1));
+				return 0;
+			}
+		}
+		/* Not enough newlines in that bufferfull.  */
+		if (pos == 0) {
+			/* Not enough lines in the file; print the entire file.  */
+			lseek(fd, (off_t) 0, SEEK_SET);
+			return 0;
+		}
+		pos -= BUFSIZ;
+		lseek(fd, pos, SEEK_SET);
 	}
-      /* Not enough newlines in that bufferfull.  */
-      if (pos == 0)
-	{
-	  /* Not enough lines in the file; print the entire file.  */
-	  lseek (fd, (off_t) 0, SEEK_SET);
-	  return 0;
+	while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0);
+	if (bytes_read == -1) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
 	}
-      pos -= BUFSIZ;
-      lseek (fd, pos, SEEK_SET);
-    }
-  while ((bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0);
-  if (bytes_read == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-  return 0;
+	return 0;
 }
 
 /* Print the last N_LINES lines from the end of the standard input,
@@ -612,301 +605,264 @@ file_lines (const char *filename, int fd, long int n_lines, off_t pos)
    Buffer the text as a linked list of LBUFFERs, adding them as needed.
    Return 0 if successful, 1 if an error occured.  */
 
-static int
-pipe_lines (const char *filename, int fd, long int n_lines)
+static int pipe_lines(const char *filename, int fd, long int n_lines)
 {
-  struct linebuffer
-  {
-    int nbytes, nlines;
-    char buffer[BUFSIZ];
-    struct linebuffer *next;
-  };
-  typedef struct linebuffer LBUFFER;
-  LBUFFER *first, *last, *tmp;
-  int i;			/* Index into buffers.  */
-  int total_lines = 0;		/* Total number of newlines in all buffers.  */
-  int errors = 0;
-
-  first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
-  first->nbytes = first->nlines = 0;
-  first->next = NULL;
-  tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
-
-  /* Input is always read into a fresh buffer.  */
-  while ((tmp->nbytes = fullRead (fd, tmp->buffer, BUFSIZ)) > 0)
-    {
-      tmp->nlines = 0;
-      tmp->next = NULL;
-
-      /* Count the number of newlines just read.  */
-      for (i = 0; i < tmp->nbytes; i++)
-	if (tmp->buffer[i] == '\n')
-	  ++tmp->nlines;
-      total_lines += tmp->nlines;
-
-      /* If there is enough room in the last buffer read, just append the new
-         one to it.  This is because when reading from a pipe, `nbytes' can
-         often be very small.  */
-      if (tmp->nbytes + last->nbytes < BUFSIZ)
-	{
-	  memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
-	  last->nbytes += tmp->nbytes;
-	  last->nlines += tmp->nlines;
+	struct linebuffer {
+		int nbytes, nlines;
+		char buffer[BUFSIZ];
+		struct linebuffer *next;
+	};
+	typedef struct linebuffer LBUFFER;
+	LBUFFER *first, *last, *tmp;
+	int i;						/* Index into buffers.  */
+	int total_lines = 0;		/* Total number of newlines in all buffers.  */
+	int errors = 0;
+
+	first = last = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+	first->nbytes = first->nlines = 0;
+	first->next = NULL;
+	tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+
+	/* Input is always read into a fresh buffer.  */
+	while ((tmp->nbytes = fullRead(fd, tmp->buffer, BUFSIZ)) > 0) {
+		tmp->nlines = 0;
+		tmp->next = NULL;
+
+		/* Count the number of newlines just read.  */
+		for (i = 0; i < tmp->nbytes; i++)
+			if (tmp->buffer[i] == '\n')
+				++tmp->nlines;
+		total_lines += tmp->nlines;
+
+		/* If there is enough room in the last buffer read, just append the new
+		   one to it.  This is because when reading from a pipe, `nbytes' can
+		   often be very small.  */
+		if (tmp->nbytes + last->nbytes < BUFSIZ) {
+			memcpy(&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
+			last->nbytes += tmp->nbytes;
+			last->nlines += tmp->nlines;
+		} else {
+			/* If there's not enough room, link the new buffer onto the end of
+			   the list, then either free up the oldest buffer for the next
+			   read if that would leave enough lines, or else malloc a new one.
+			   Some compaction mechanism is possible but probably not
+			   worthwhile.  */
+			last = last->next = tmp;
+			if (total_lines - first->nlines > n_lines) {
+				tmp = first;
+				total_lines -= first->nlines;
+				first = first->next;
+			} else
+				tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
+		}
+	}
+	if (tmp->nbytes == -1) {
+		detailed_error(0, errno, "%s", filename);
+		errors = 1;
+		free((char *) tmp);
+		goto free_lbuffers;
 	}
-      else
-	{
-	  /* If there's not enough room, link the new buffer onto the end of
-	     the list, then either free up the oldest buffer for the next
-	     read if that would leave enough lines, or else malloc a new one.
-	     Some compaction mechanism is possible but probably not
-	     worthwhile.  */
-	  last = last->next = tmp;
-	  if (total_lines - first->nlines > n_lines)
-	    {
-	      tmp = first;
-	      total_lines -= first->nlines;
-	      first = first->next;
-	    }
-	  else
-	    tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
+
+	free((char *) tmp);
+
+	/* This prevents a core dump when the pipe contains no newlines.  */
+	if (n_lines == 0)
+		goto free_lbuffers;
+
+	/* Count the incomplete line on files that don't end with a newline.  */
+	if (last->buffer[last->nbytes - 1] != '\n') {
+		++last->nlines;
+		++total_lines;
+	}
+
+	/* Run through the list, printing lines.  First, skip over unneeded
+	   buffers.  */
+	for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
+		total_lines -= tmp->nlines;
+
+	/* Find the correct beginning, then print the rest of the file.  */
+	if (total_lines > n_lines) {
+		char *cp;
+
+		/* Skip `total_lines' - `n_lines' newlines.  We made sure that
+		   `total_lines' - `n_lines' <= `tmp->nlines'.  */
+		cp = tmp->buffer;
+		for (i = total_lines - n_lines; i; --i)
+			while (*cp++ != '\n')
+				/* Do nothing.  */ ;
+		i = cp - tmp->buffer;
+	} else
+		i = 0;
+	XWRITE(STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
+
+	for (tmp = tmp->next; tmp; tmp = tmp->next)
+		XWRITE(STDOUT_FILENO, tmp->buffer, tmp->nbytes);
+
+  free_lbuffers:
+	while (first) {
+		tmp = first->next;
+		free((char *) first);
+		first = tmp;
 	}
-    }
-  if (tmp->nbytes == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      errors = 1;
-      free ((char *) tmp);
-      goto free_lbuffers;
-    }
-
-  free ((char *) tmp);
-
-  /* This prevents a core dump when the pipe contains no newlines.  */
-  if (n_lines == 0)
-    goto free_lbuffers;
-
-  /* Count the incomplete line on files that don't end with a newline.  */
-  if (last->buffer[last->nbytes - 1] != '\n')
-    {
-      ++last->nlines;
-      ++total_lines;
-    }
-
-  /* Run through the list, printing lines.  First, skip over unneeded
-     buffers.  */
-  for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
-    total_lines -= tmp->nlines;
-
-  /* Find the correct beginning, then print the rest of the file.  */
-  if (total_lines > n_lines)
-    {
-      char *cp;
-
-      /* Skip `total_lines' - `n_lines' newlines.  We made sure that
-         `total_lines' - `n_lines' <= `tmp->nlines'.  */
-      cp = tmp->buffer;
-      for (i = total_lines - n_lines; i; --i)
-	while (*cp++ != '\n')
-	  /* Do nothing.  */ ;
-      i = cp - tmp->buffer;
-    }
-  else
-    i = 0;
-  XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
-
-  for (tmp = tmp->next; tmp; tmp = tmp->next)
-    XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
-
-free_lbuffers:
-  while (first)
-    {
-      tmp = first->next;
-      free ((char *) first);
-      first = tmp;
-    }
-  return errors;
+	return errors;
 }
 
 /* Print the last N_BYTES characters from the end of pipe FD.
    This is a stripped down version of pipe_lines.
    Return 0 if successful, 1 if an error occurred.  */
 
-static int
-pipe_bytes (const char *filename, int fd, off_t n_bytes)
+static int pipe_bytes(const char *filename, int fd, off_t n_bytes)
 {
-  struct charbuffer
-  {
-    int nbytes;
-    char buffer[BUFSIZ];
-    struct charbuffer *next;
-  };
-  typedef struct charbuffer CBUFFER;
-  CBUFFER *first, *last, *tmp;
-  int i;			/* Index into buffers.  */
-  int total_bytes = 0;		/* Total characters in all buffers.  */
-  int errors = 0;
-
-  first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
-  first->nbytes = 0;
-  first->next = NULL;
-  tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
-
-  /* Input is always read into a fresh buffer.  */
-  while ((tmp->nbytes = fullRead (fd, tmp->buffer, BUFSIZ)) > 0)
-    {
-      tmp->next = NULL;
-
-      total_bytes += tmp->nbytes;
-      /* If there is enough room in the last buffer read, just append the new
-         one to it.  This is because when reading from a pipe, `nbytes' can
-         often be very small.  */
-      if (tmp->nbytes + last->nbytes < BUFSIZ)
-	{
-	  memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
-	  last->nbytes += tmp->nbytes;
+	struct charbuffer {
+		int nbytes;
+		char buffer[BUFSIZ];
+		struct charbuffer *next;
+	};
+	typedef struct charbuffer CBUFFER;
+	CBUFFER *first, *last, *tmp;
+	int i;						/* Index into buffers.  */
+	int total_bytes = 0;		/* Total characters in all buffers.  */
+	int errors = 0;
+
+	first = last = (CBUFFER *) xmalloc(sizeof(CBUFFER));
+	first->nbytes = 0;
+	first->next = NULL;
+	tmp = (CBUFFER *) xmalloc(sizeof(CBUFFER));
+
+	/* Input is always read into a fresh buffer.  */
+	while ((tmp->nbytes = fullRead(fd, tmp->buffer, BUFSIZ)) > 0) {
+		tmp->next = NULL;
+
+		total_bytes += tmp->nbytes;
+		/* If there is enough room in the last buffer read, just append the new
+		   one to it.  This is because when reading from a pipe, `nbytes' can
+		   often be very small.  */
+		if (tmp->nbytes + last->nbytes < BUFSIZ) {
+			memcpy(&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
+			last->nbytes += tmp->nbytes;
+		} else {
+			/* If there's not enough room, link the new buffer onto the end of
+			   the list, then either free up the oldest buffer for the next
+			   read if that would leave enough characters, or else malloc a new
+			   one.  Some compaction mechanism is possible but probably not
+			   worthwhile.  */
+			last = last->next = tmp;
+			if (total_bytes - first->nbytes > n_bytes) {
+				tmp = first;
+				total_bytes -= first->nbytes;
+				first = first->next;
+			} else {
+				tmp = (CBUFFER *) xmalloc(sizeof(CBUFFER));
+			}
+		}
 	}
-      else
-	{
-	  /* If there's not enough room, link the new buffer onto the end of
-	     the list, then either free up the oldest buffer for the next
-	     read if that would leave enough characters, or else malloc a new
-	     one.  Some compaction mechanism is possible but probably not
-	     worthwhile.  */
-	  last = last->next = tmp;
-	  if (total_bytes - first->nbytes > n_bytes)
-	    {
-	      tmp = first;
-	      total_bytes -= first->nbytes;
-	      first = first->next;
-	    }
-	  else
-	    {
-	      tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
-	    }
+	if (tmp->nbytes == -1) {
+		detailed_error(0, errno, "%s", filename);
+		errors = 1;
+		free((char *) tmp);
+		goto free_cbuffers;
+	}
+
+	free((char *) tmp);
+
+	/* Run through the list, printing characters.  First, skip over unneeded
+	   buffers.  */
+	for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
+		total_bytes -= tmp->nbytes;
+
+	/* Find the correct beginning, then print the rest of the file.
+	   We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'.  */
+	if (total_bytes > n_bytes)
+		i = total_bytes - n_bytes;
+	else
+		i = 0;
+	XWRITE(STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
+
+	for (tmp = tmp->next; tmp; tmp = tmp->next)
+		XWRITE(STDOUT_FILENO, tmp->buffer, tmp->nbytes);
+
+  free_cbuffers:
+	while (first) {
+		tmp = first->next;
+		free((char *) first);
+		first = tmp;
 	}
-    }
-  if (tmp->nbytes == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      errors = 1;
-      free ((char *) tmp);
-      goto free_cbuffers;
-    }
-
-  free ((char *) tmp);
-
-  /* Run through the list, printing characters.  First, skip over unneeded
-     buffers.  */
-  for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
-    total_bytes -= tmp->nbytes;
-
-  /* Find the correct beginning, then print the rest of the file.
-     We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'.  */
-  if (total_bytes > n_bytes)
-    i = total_bytes - n_bytes;
-  else
-    i = 0;
-  XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
-
-  for (tmp = tmp->next; tmp; tmp = tmp->next)
-    XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
-
-free_cbuffers:
-  while (first)
-    {
-      tmp = first->next;
-      free ((char *) first);
-      first = tmp;
-    }
-  return errors;
+	return errors;
 }
 
 /* Skip N_BYTES characters from the start of pipe FD, and print
    any extra characters that were read beyond that.
    Return 1 on error, 0 if ok.  */
 
-static int
-start_bytes (const char *filename, int fd, off_t n_bytes)
+static int start_bytes(const char *filename, int fd, off_t n_bytes)
 {
-  char buffer[BUFSIZ];
-  int bytes_read = 0;
-
-  while (n_bytes > 0 && (bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
-    n_bytes -= bytes_read;
-  if (bytes_read == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-  else if (n_bytes < 0)
-    XWRITE (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
-  return 0;
+	char buffer[BUFSIZ];
+	int bytes_read = 0;
+
+	while (n_bytes > 0 && (bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0)
+		n_bytes -= bytes_read;
+	if (bytes_read == -1) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
+	} else if (n_bytes < 0)
+		XWRITE(STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
+	return 0;
 }
 
 /* Skip N_LINES lines at the start of file or pipe FD, and print
    any extra characters that were read beyond that.
    Return 1 on error, 0 if ok.  */
 
-static int
-start_lines (const char *filename, int fd, long int n_lines)
+static int start_lines(const char *filename, int fd, long int n_lines)
 {
-  char buffer[BUFSIZ];
-  int bytes_read = 0;
-  int bytes_to_skip = 0;
-
-  while (n_lines && (bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
-    {
-      bytes_to_skip = 0;
-      while (bytes_to_skip < bytes_read)
-	if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
-	  break;
-    }
-  if (bytes_read == -1)
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-  else if (bytes_to_skip < bytes_read)
-    {
-      XWRITE (STDOUT_FILENO, &buffer[bytes_to_skip],
-	      bytes_read - bytes_to_skip);
-    }
-  return 0;
+	char buffer[BUFSIZ];
+	int bytes_read = 0;
+	int bytes_to_skip = 0;
+
+	while (n_lines && (bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0) {
+		bytes_to_skip = 0;
+		while (bytes_to_skip < bytes_read)
+			if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
+				break;
+	}
+	if (bytes_read == -1) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
+	} else if (bytes_to_skip < bytes_read) {
+		XWRITE(STDOUT_FILENO, &buffer[bytes_to_skip],
+			   bytes_read - bytes_to_skip);
+	}
+	return 0;
 }
 
 /* Display file FILENAME from the current position in FD to the end.
    If `forever' is nonzero, keep reading from the end of the file
    until killed.  Return the number of bytes read from the file.  */
 
-static long
-dump_remainder (const char *filename, int fd)
+static long dump_remainder(const char *filename, int fd)
 {
-  char buffer[BUFSIZ];
-  int bytes_read;
-  long total;
-
-  total = 0;
-output:
-  while ((bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
-    {
-      XWRITE (STDOUT_FILENO, buffer, bytes_read);
-      total += bytes_read;
-    }
-  if (bytes_read == -1)
-    detailed_error (EXIT_FAILURE, errno, "%s", filename);
-  if (forever)
-    {
-      fflush (stdout);
-      sleep (1);
-      goto output;
-    }
-  else
-    {
-      if (forever_multiple)
-	fflush (stdout);
-    }
-
-  return total;
+	char buffer[BUFSIZ];
+	int bytes_read;
+	long total;
+
+	total = 0;
+  output:
+	while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0) {
+		XWRITE(STDOUT_FILENO, buffer, bytes_read);
+		total += bytes_read;
+	}
+	if (bytes_read == -1)
+		detailed_error(EXIT_FAILURE, errno, "%s", filename);
+	if (forever) {
+		fflush(stdout);
+		sleep(1);
+		goto output;
+	} else {
+		if (forever_multiple)
+			fflush(stdout);
+	}
+
+	return total;
 }
 
 /* Tail NFILES (>1) files forever until killed.  The file names are in
@@ -916,186 +872,161 @@ output:
    none of them have changed size in one iteration, we sleep for a
    second and try again.  We do this until the user interrupts us.  */
 
-static void
-tail_forever (char **names, int nfiles)
+static void tail_forever(char **names, int nfiles)
 {
-  int last;
-
-  last = -1;
-
-  while (1)
-    {
-      int i;
-      int changed;
-
-      changed = 0;
-      for (i = 0; i < nfiles; i++)
-	{
-	  struct stat stats;
-
-	  if (file_descs[i] < 0)
-	    continue;
-	  if (fstat (file_descs[i], &stats) < 0)
-	    {
-	      detailed_error (0, errno, "%s", names[i]);
-	      file_descs[i] = -1;
-	      continue;
-	    }
-	  if (stats.st_size == file_sizes[i])
-	    continue;
-
-	  /* This file has changed size.  Print out what we can, and
-	     then keep looping.  */
-
-	  changed = 1;
-
-	  if (stats.st_size < file_sizes[i])
-	    {
-	      write_header (names[i], "file truncated");
-	      last = i;
-	      lseek (file_descs[i], stats.st_size, SEEK_SET);
-	      file_sizes[i] = stats.st_size;
-	      continue;
-	    }
-
-	  if (i != last)
-	    {
-	      if (print_headers)
-		write_header (names[i], NULL);
-	      last = i;
-	    }
-	  file_sizes[i] += dump_remainder (names[i], file_descs[i]);
-	}
+	int last;
+
+	last = -1;
+
+	while (1) {
+		int i;
+		int changed;
+
+		changed = 0;
+		for (i = 0; i < nfiles; i++) {
+			struct stat stats;
+
+			if (file_descs[i] < 0)
+				continue;
+			if (fstat(file_descs[i], &stats) < 0) {
+				detailed_error(0, errno, "%s", names[i]);
+				file_descs[i] = -1;
+				continue;
+			}
+			if (stats.st_size == file_sizes[i])
+				continue;
+
+			/* This file has changed size.  Print out what we can, and
+			   then keep looping.  */
+
+			changed = 1;
+
+			if (stats.st_size < file_sizes[i]) {
+				write_header(names[i], "file truncated");
+				last = i;
+				lseek(file_descs[i], stats.st_size, SEEK_SET);
+				file_sizes[i] = stats.st_size;
+				continue;
+			}
+
+			if (i != last) {
+				if (print_headers)
+					write_header(names[i], NULL);
+				last = i;
+			}
+			file_sizes[i] += dump_remainder(names[i], file_descs[i]);
+		}
 
-      /* If none of the files changed size, sleep.  */
-      if (! changed)
-	sleep (1);
-    }
+		/* If none of the files changed size, sleep.  */
+		if (!changed)
+			sleep(1);
+	}
 }
 
 /* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
    Return 0 if successful, 1 if an error occurred.  */
 
-static int
-tail_bytes (const char *filename, int fd, off_t n_bytes)
+static int tail_bytes(const char *filename, int fd, off_t n_bytes)
 {
-  struct stat stats;
-
-  /* FIXME: resolve this like in dd.c.  */
-  /* Use fstat instead of checking for errno == ESPIPE because
-     lseek doesn't work on some special files but doesn't return an
-     error, either.  */
-  if (fstat (fd, &stats))
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-
-  if (from_start)
-    {
-      if (S_ISREG (stats.st_mode))
-	lseek (fd, n_bytes, SEEK_CUR);
-      else if (start_bytes (filename, fd, n_bytes))
-	return 1;
-      dump_remainder (filename, fd);
-    }
-  else
-    {
-      if (S_ISREG (stats.st_mode))
-	{
-	  off_t current_pos, end_pos;
-	  size_t bytes_remaining;
-
-	  if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
-	      && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
-	    {
-	      off_t diff;
-	      /* Be careful here.  The current position may actually be
-		 beyond the end of the file.  */
-	      bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
-	    }
-	  else
-	    {
-	      detailed_error (0, errno, "%s", filename);
-	      return 1;
-	    }
-
-	  if (bytes_remaining <= n_bytes)
-	    {
-	      /* From the current position to end of file, there are no
-		 more bytes than have been requested.  So reposition the
-		 file pointer to the incoming current position and print
-		 everything after that.  */
-	      lseek (fd, current_pos, SEEK_SET);
-	    }
-	  else
-	    {
-	      /* There are more bytes remaining than were requested.
-		 Back up.  */
-	      lseek (fd, -n_bytes, SEEK_END);
-	    }
-	  dump_remainder (filename, fd);
+	struct stat stats;
+
+	/* FIXME: resolve this like in dd.c.  */
+	/* Use fstat instead of checking for errno == ESPIPE because
+	   lseek doesn't work on some special files but doesn't return an
+	   error, either.  */
+	if (fstat(fd, &stats)) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
+	}
+
+	if (from_start) {
+		if (S_ISREG(stats.st_mode))
+			lseek(fd, n_bytes, SEEK_CUR);
+		else if (start_bytes(filename, fd, n_bytes))
+			return 1;
+		dump_remainder(filename, fd);
+	} else {
+		if (S_ISREG(stats.st_mode)) {
+			off_t current_pos, end_pos;
+			size_t bytes_remaining;
+
+			if ((current_pos = lseek(fd, (off_t) 0, SEEK_CUR)) != -1
+				&& (end_pos = lseek(fd, (off_t) 0, SEEK_END)) != -1) {
+				off_t diff;
+
+				/* Be careful here.  The current position may actually be
+				   beyond the end of the file.  */
+				bytes_remaining = (diff =
+								   end_pos - current_pos) < 0 ? 0 : diff;
+			} else {
+				detailed_error(0, errno, "%s", filename);
+				return 1;
+			}
+
+			if (bytes_remaining <= n_bytes) {
+				/* From the current position to end of file, there are no
+				   more bytes than have been requested.  So reposition the
+				   file pointer to the incoming current position and print
+				   everything after that.  */
+				lseek(fd, current_pos, SEEK_SET);
+			} else {
+				/* There are more bytes remaining than were requested.
+				   Back up.  */
+				lseek(fd, -n_bytes, SEEK_END);
+			}
+			dump_remainder(filename, fd);
+		} else
+			return pipe_bytes(filename, fd, n_bytes);
 	}
-      else
-	return pipe_bytes (filename, fd, n_bytes);
-    }
-  return 0;
+	return 0;
 }
 
 /* Output the last N_LINES lines of file FILENAME open for reading in FD.
    Return 0 if successful, 1 if an error occurred.  */
 
-static int
-tail_lines (const char *filename, int fd, long int n_lines)
+static int tail_lines(const char *filename, int fd, long int n_lines)
 {
-  struct stat stats;
-  off_t length;
-
-  if (fstat (fd, &stats))
-    {
-      detailed_error (0, errno, "%s", filename);
-      return 1;
-    }
-
-  if (from_start)
-    {
-      if (start_lines (filename, fd, n_lines))
-	return 1;
-      dump_remainder (filename, fd);
-    }
-  else
-    {
-      /* Use file_lines only if FD refers to a regular file with
-         its file pointer positioned at beginning of file.  */
-      /* FIXME: adding the lseek conjunct is a kludge.
-	 Once there's a reasonable test suite, fix the true culprit:
-	 file_lines.  file_lines shouldn't presume that the input
-	 file pointer is initially positioned to beginning of file.  */
-      if (S_ISREG (stats.st_mode)
-	  && lseek (fd, (off_t) 0, SEEK_CUR) == (off_t) 0)
-	{
-	  length = lseek (fd, (off_t) 0, SEEK_END);
-	  if (length != 0 && file_lines (filename, fd, n_lines, length))
-	    return 1;
-	  dump_remainder (filename, fd);
+	struct stat stats;
+	off_t length;
+
+	if (fstat(fd, &stats)) {
+		detailed_error(0, errno, "%s", filename);
+		return 1;
+	}
+
+	if (from_start) {
+		if (start_lines(filename, fd, n_lines))
+			return 1;
+		dump_remainder(filename, fd);
+	} else {
+		/* Use file_lines only if FD refers to a regular file with
+		   its file pointer positioned at beginning of file.  */
+		/* FIXME: adding the lseek conjunct is a kludge.
+		   Once there's a reasonable test suite, fix the true culprit:
+		   file_lines.  file_lines shouldn't presume that the input
+		   file pointer is initially positioned to beginning of file.  */
+		if (S_ISREG(stats.st_mode)
+			&& lseek(fd, (off_t) 0, SEEK_CUR) == (off_t) 0) {
+			length = lseek(fd, (off_t) 0, SEEK_END);
+			if (length != 0 && file_lines(filename, fd, n_lines, length))
+				return 1;
+			dump_remainder(filename, fd);
+		} else
+			return pipe_lines(filename, fd, n_lines);
 	}
-      else
-	return pipe_lines (filename, fd, n_lines);
-    }
-  return 0;
+	return 0;
 }
 
 /* Display the last N_UNITS units of file FILENAME, open for reading
    in FD.
    Return 0 if successful, 1 if an error occurred.  */
 
-static int
-tail (const char *filename, int fd, off_t n_units)
+static int tail(const char *filename, int fd, off_t n_units)
 {
-  if (count_lines)
-    return tail_lines (filename, fd, (long) n_units);
-  else
-    return tail_bytes (filename, fd, n_units);
+	if (count_lines)
+		return tail_lines(filename, fd, (long) n_units);
+	else
+		return tail_bytes(filename, fd, n_units);
 }
 
 /* Display the last N_UNITS units of file FILENAME.
@@ -1103,207 +1034,183 @@ tail (const char *filename, int fd, off_t n_units)
    FILENUM is this file's index in the list of files the user gave.
    Return 0 if successful, 1 if an error occurred.  */
 
-static int
-tail_file (const char *filename, off_t n_units, int filenum)
+static int tail_file(const char *filename, off_t n_units, int filenum)
 {
-  int fd, errors;
-  struct stat stats;
-
-  if (!strcmp (filename, "-"))
-    {
-      have_read_stdin = 1;
-      filename = "standard input";
-      if (print_headers)
-	write_header (filename, NULL);
-      errors = tail (filename, 0, n_units);
-      if (forever_multiple)
-	{
-	  if (fstat (0, &stats) < 0)
-	    {
-	      detailed_error (0, errno, "standard input");
-	      errors = 1;
-	    }
-	  else if (!S_ISREG (stats.st_mode))
-	    {
-	      detailed_error (0, 0,
-		     "standard input: cannot follow end of non-regular file");
-	      errors = 1;
-	    }
-	  if (errors)
-	    file_descs[filenum] = -1;
-	  else
-	    {
-	      file_descs[filenum] = 0;
-	      file_sizes[filenum] = stats.st_size;
-	    }
-	}
-    }
-  else
-    {
-      /* Not standard input.  */
-      fd = open (filename, O_RDONLY);
-      if (fd == -1)
-	{
-	  if (forever_multiple)
-	    file_descs[filenum] = -1;
-	  detailed_error (0, errno, "%s", filename);
-	  errors = 1;
-	}
-      else
-	{
-	  if (print_headers)
-	    write_header (filename, NULL);
-	  errors = tail (filename, fd, n_units);
-	  if (forever_multiple)
-	    {
-	      if (fstat (fd, &stats) < 0)
-		{
-		  detailed_error (0, errno, "%s", filename);
-		  errors = 1;
-		}
-	      else if (!S_ISREG (stats.st_mode))
-		{
-		  detailed_error (0, 0, "%s: cannot follow end of non-regular file",
-			 filename);
-		  errors = 1;
-		}
-	      if (errors)
-		{
-		  close (fd);
-		  file_descs[filenum] = -1;
-		}
-	      else
-		{
-		  file_descs[filenum] = fd;
-		  file_sizes[filenum] = stats.st_size;
+	int fd, errors;
+	struct stat stats;
+
+	if (!strcmp(filename, "-")) {
+		have_read_stdin = 1;
+		filename = "standard input";
+		if (print_headers)
+			write_header(filename, NULL);
+		errors = tail(filename, 0, n_units);
+		if (forever_multiple) {
+			if (fstat(0, &stats) < 0) {
+				detailed_error(0, errno, "standard input");
+				errors = 1;
+			} else if (!S_ISREG(stats.st_mode)) {
+				detailed_error(0, 0,
+							   "standard input: cannot follow end of non-regular file");
+				errors = 1;
+			}
+			if (errors)
+				file_descs[filenum] = -1;
+			else {
+				file_descs[filenum] = 0;
+				file_sizes[filenum] = stats.st_size;
+			}
 		}
-	    }
-	  else
-	    {
-	      if (close (fd))
-		{
-		  detailed_error (0, errno, "%s", filename);
-		  errors = 1;
+	} else {
+		/* Not standard input.  */
+		fd = open(filename, O_RDONLY);
+		if (fd == -1) {
+			if (forever_multiple)
+				file_descs[filenum] = -1;
+			detailed_error(0, errno, "%s", filename);
+			errors = 1;
+		} else {
+			if (print_headers)
+				write_header(filename, NULL);
+			errors = tail(filename, fd, n_units);
+			if (forever_multiple) {
+				if (fstat(fd, &stats) < 0) {
+					detailed_error(0, errno, "%s", filename);
+					errors = 1;
+				} else if (!S_ISREG(stats.st_mode)) {
+					detailed_error(0, 0,
+								   "%s: cannot follow end of non-regular file",
+								   filename);
+					errors = 1;
+				}
+				if (errors) {
+					close(fd);
+					file_descs[filenum] = -1;
+				} else {
+					file_descs[filenum] = fd;
+					file_sizes[filenum] = stats.st_size;
+				}
+			} else {
+				if (close(fd)) {
+					detailed_error(0, errno, "%s", filename);
+					errors = 1;
+				}
+			}
 		}
-	    }
 	}
-    }
 
-  return errors;
+	return errors;
 }
 
-extern int
-tail_main (int argc, char **argv)
+extern int tail_main(int argc, char **argv)
 {
-  int stopit = 0;
-  enum header_mode header_mode = multiple_files;
-  int exit_status = 0;
-  /* If from_start, the number of items to skip before printing; otherwise,
-     the number of items at the end of the file to print.  Initially, -1
-     means the value has not been set.  */
-  off_t n_units = -1;
-  int n_files;
-  char **file;
-
-  program_name = argv[0];
-  have_read_stdin = 0;
-  count_lines = 1;
-  forever = forever_multiple = from_start = print_headers = 0;
-      
-  /* Parse any options */
-  //fprintf(stderr, "argc=%d, argv=%s\n", argc, *argv);
-    while (--argc > 0 && ( **(++argv) == '-' || **argv == '+' )) {
-	if (**argv == '+') {
-	    from_start = 1;
+	int stopit = 0;
+	enum header_mode header_mode = multiple_files;
+	int exit_status = 0;
+
+	/* If from_start, the number of items to skip before printing; otherwise,
+	   the number of items at the end of the file to print.  Initially, -1
+	   means the value has not been set.  */
+	off_t n_units = -1;
+	int n_files;
+	char **file;
+
+	program_name = argv[0];
+	have_read_stdin = 0;
+	count_lines = 1;
+	forever = forever_multiple = from_start = print_headers = 0;
+
+	/* Parse any options */
+	//fprintf(stderr, "argc=%d, argv=%s\n", argc, *argv);
+	while (--argc > 0 && (**(++argv) == '-' || **argv == '+')) {
+		if (**argv == '+') {
+			from_start = 1;
+		}
+		stopit = 0;
+		while (stopit == 0 && *(++(*argv))) {
+			switch (**argv) {
+			case 'c':
+				count_lines = 0;
+
+				if (--argc < 1) {
+					usage(tail_usage);
+				}
+				n_units = getNum(*(++argv));
+				stopit = 1;
+				break;
+
+			case 'f':
+				forever = 1;
+				break;
+
+			case 'n':
+				count_lines = 1;
+
+				if (--argc < 1) {
+					usage(tail_usage);
+				}
+				n_units = atol(*(++argv));
+				stopit = 1;
+				break;
+
+			case 'q':
+				header_mode = never;
+				break;
+
+			case 'v':
+				header_mode = always;
+				break;
+
+			default:
+				usage(tail_usage);
+			}
+		}
+	}
+
+
+	if (n_units == -1)
+		n_units = DEFAULT_N_LINES;
+
+	/* To start printing with item N_UNITS from the start of the file, skip
+	   N_UNITS - 1 items.  `tail +0' is actually meaningless, but for Unix
+	   compatibility it's treated the same as `tail +1'.  */
+	if (from_start) {
+		if (n_units)
+			--n_units;
 	}
-	stopit = 0;
-	while (stopit == 0 && *(++(*argv))) {
-	    switch (**argv) {
-		case 'c':
-		  count_lines = 0;
-
-		  if (--argc < 1) {
-		      usage(tail_usage);
-		  }
-		  n_units = getNum(*(++argv));
-		  stopit = 1;
-		  break;
-
-		case 'f':
-		  forever = 1;
-		  break;
-
-		case 'n':
-		  count_lines = 1;
-
-		  if (--argc < 1) {
-		      usage(tail_usage);
-		  }
-		  n_units = atol(*(++argv));
-		  stopit = 1;
-		  break;
-
-		case 'q':
-		  header_mode = never;
-		  break;
-
-		case 'v':
-		  header_mode = always;
-		  break;
-
-		default:
-		  usage (tail_usage);
-	    }
+
+	n_files = argc;
+	file = argv;
+
+	if (n_files > 1 && forever) {
+		forever_multiple = 1;
+		forever = 0;
+		file_descs = (int *) xmalloc(n_files * sizeof(int));
+
+		file_sizes = (off_t *) xmalloc(n_files * sizeof(off_t));
 	}
-    }
-
-
-  if (n_units == -1)
-    n_units = DEFAULT_N_LINES;
-
-  /* To start printing with item N_UNITS from the start of the file, skip
-     N_UNITS - 1 items.  `tail +0' is actually meaningless, but for Unix
-     compatibility it's treated the same as `tail +1'.  */
-  if (from_start)
-    {
-      if (n_units)
-	--n_units;
-    }
-
-  n_files = argc;
-  file = argv;
-
-  if (n_files > 1 && forever)
-    {
-      forever_multiple = 1;
-      forever = 0;
-      file_descs = (int *) xmalloc (n_files * sizeof (int));
-      file_sizes = (off_t *) xmalloc (n_files * sizeof (off_t));
-    }
-
-  if (header_mode == always
-      || (header_mode == multiple_files && n_files > 1))
-    print_headers = 1;
-
-  if (n_files == 0)
-    {
-      exit_status |= tail_file ("-", n_units, 0);
-    }
-  else
-    {
-      int i;
-      for (i = 0; i < n_files; i++)
-	exit_status |= tail_file (file[i], n_units, i);
-
-      if (forever_multiple)
-	tail_forever (file, n_files);
-    }
-
-  if (have_read_stdin && close (0) < 0)
-    detailed_error (EXIT_FAILURE, errno, "-");
-  if (fclose (stdout) == EOF)
-    detailed_error (EXIT_FAILURE, errno, "write error");
-  exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+
+	if (header_mode == always
+		|| (header_mode == multiple_files && n_files > 1))
+		print_headers = 1;
+
+	if (n_files == 0) {
+		exit_status |= tail_file("-", n_units, 0);
+	} else {
+		int i;
+
+		for (i = 0; i < n_files; i++)
+			exit_status |= tail_file(file[i], n_units, i);
+
+		if (forever_multiple)
+			tail_forever(file, n_files);
+	}
+
+	if (have_read_stdin && close(0) < 0)
+		detailed_error(EXIT_FAILURE, errno, "-");
+	if (fclose(stdout) == EOF)
+		detailed_error(EXIT_FAILURE, errno, "write error");
+	exit(exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 }