1 /* cat -- concatenate files and print on the standard output.
2 Copyright (C) 88, 90, 91, 1995-2006 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18 /* Differences from the Unix cat:
19 * Always unbuffered, -u is ignored.
20 * Usually much faster than other versions of cat, the difference
21 is especially apparent when using the -v option.
23 By tege@sics.se, Torbjorn Granlund, advised by rms, Richard Stallman. */
29 #include <sys/types.h>
35 # include <sys/ioctl.h>
40 #include "full-write.h"
41 #include "getpagesize.h"
43 #include "safe-read.h"
45 /* The official name of this program (e.g., no `g' prefix). */
46 #define PROGRAM_NAME "cat"
48 #define AUTHORS "Torbjorn Granlund", "Richard M. Stallman"
50 /* Undefine, to avoid warning about redefinition on some systems. */
52 #define max(h,i) ((h) > (i) ? (h) : (i))
54 /* Name under which this program was invoked. */
57 /* Name of input file. May be "-". */
60 /* Descriptor on which input file is open. */
61 static int input_desc;
63 /* Buffer for line numbers.
64 An 11 digit counter may overflow within an hour on a P2/466,
65 an 18 digit counter needs about 1000y */
66 #define LINE_COUNTER_BUF_LEN 20
67 static char line_buf[LINE_COUNTER_BUF_LEN] =
69 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
70 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '0',
74 /* Position in `line_buf' where printing starts. This will not change
75 unless the number of lines is larger than 999999. */
76 static char *line_num_print = line_buf + LINE_COUNTER_BUF_LEN - 8;
78 /* Position of the first digit in `line_buf'. */
79 static char *line_num_start = line_buf + LINE_COUNTER_BUF_LEN - 3;
81 /* Position of the last digit in `line_buf'. */
82 static char *line_num_end = line_buf + LINE_COUNTER_BUF_LEN - 3;
84 /* Preserves the `cat' function's local `newlines' between invocations. */
85 static int newlines2 = 0;
90 if (status != EXIT_SUCCESS)
91 fprintf (stderr, _("Try `%s --help' for more information.\n"),
96 Usage: %s [OPTION] [FILE]...\n\
100 Concatenate FILE(s), or standard input, to standard output.\n\
102 -A, --show-all equivalent to -vET\n\
103 -b, --number-nonblank number nonblank output lines\n\
104 -e equivalent to -vE\n\
105 -E, --show-ends display $ at end of each line\n\
106 -n, --number number all output lines\n\
107 -s, --squeeze-blank never more than one single blank line\n\
110 -t equivalent to -vT\n\
111 -T, --show-tabs display TAB characters as ^I\n\
113 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB\n\
115 fputs (HELP_OPTION_DESCRIPTION, stdout);
116 fputs (VERSION_OPTION_DESCRIPTION, stdout);
119 With no FILE, or when FILE is -, read standard input.\n\
124 %s f - g Output f's contents, then standard input, then g's contents.\n\
125 %s Copy standard input to standard output.\n\
127 program_name, program_name);
128 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
133 /* Compute the next line number. */
138 char *endp = line_num_end;
145 while (endp >= line_num_start);
146 if (line_num_start > line_buf)
147 *--line_num_start = '1';
150 if (line_num_start < line_num_print)
154 /* Plain cat. Copies the file behind `input_desc' to STDOUT_FILENO.
155 Return true if successful. */
159 /* Pointer to the buffer, used by reads and writes. */
162 /* Number of characters preferably read or written by each read and write
166 /* Actual number of characters read, and therefore written. */
169 /* Loop until the end of the file. */
173 /* Read a block of input. */
175 n_read = safe_read (input_desc, buf, bufsize);
176 if (n_read == SAFE_READ_ERROR)
178 error (0, errno, "%s", infile);
182 /* End of this file? */
187 /* Write this block out. */
190 /* The following is ok, since we know that 0 < n_read. */
192 if (full_write (STDOUT_FILENO, buf, n) != n)
193 error (EXIT_FAILURE, errno, _("write error"));
198 /* Write any pending output to STDOUT_FILENO.
199 Pending is defined to be the *BPOUT - OUTBUF bytes starting at OUTBUF.
200 Then set *BPOUT to OUTPUT if it's not already that value. */
203 write_pending (char *outbuf, char **bpout)
205 size_t n_write = *bpout - outbuf;
208 if (full_write (STDOUT_FILENO, outbuf, n_write) != n_write)
209 error (EXIT_FAILURE, errno, _("write error"));
214 /* Cat the file behind INPUT_DESC to the file behind OUTPUT_DESC.
215 Return true if successful.
216 Called if any option more than -u was specified.
218 A newline character is always put at the end of the buffer, to make
219 an explicit test for buffer end unnecessary. */
223 /* Pointer to the beginning of the input buffer. */
226 /* Number of characters read in each read call. */
229 /* Pointer to the beginning of the output buffer. */
232 /* Number of characters written by each write call. */
235 /* Variables that have values according to the specified options. */
236 bool show_nonprinting,
239 bool number_nonblank,
243 /* Last character read from the input buffer. */
246 /* Pointer to the next character in the input buffer. */
249 /* Pointer to the first non-valid byte in the input buffer, i.e. the
250 current end of the buffer. */
253 /* Pointer to the position where the next character shall be written. */
256 /* Number of characters read by the last read call. */
259 /* Determines how many consecutive newlines there have been in the
260 input. 0 newlines makes NEWLINES -1, 1 newline makes NEWLINES 1,
261 etc. Initially 0 to indicate that we are at the beginning of a
262 new line. The "state" of the procedure is determined by
264 int newlines = newlines2;
267 /* If nonzero, use the FIONREAD ioctl, as an optimization.
268 (On Ultrix, it is not supported on NFS file systems.) */
269 bool use_fionread = true;
272 /* The inbuf pointers are initialized so that BPIN > EOB, and thereby input
273 is read immediately. */
284 /* Write if there are at least OUTSIZE bytes in OUTBUF. */
286 if (outbuf + outsize <= bpout)
289 size_t remaining_bytes;
292 if (full_write (STDOUT_FILENO, wp, outsize) != outsize)
293 error (EXIT_FAILURE, errno, _("write error"));
295 remaining_bytes = bpout - wp;
297 while (outsize <= remaining_bytes);
299 /* Move the remaining bytes to the beginning of the
302 memmove (outbuf, wp, remaining_bytes);
303 bpout = outbuf + remaining_bytes;
306 /* Is INBUF empty? */
310 bool input_pending = false;
314 /* Is there any input to read immediately?
315 If not, we are about to wait,
316 so write all buffered output before waiting. */
319 && ioctl (input_desc, FIONREAD, &n_to_read) < 0)
321 /* Ultrix returns EOPNOTSUPP on NFS;
322 HP-UX returns ENOTTY on pipes.
323 SunOS returns EINVAL and
324 More/BSD returns ENODEV on special files
326 Irix-5 returns ENOSYS on pipes. */
327 if (errno == EOPNOTSUPP || errno == ENOTTY
328 || errno == EINVAL || errno == ENODEV
330 use_fionread = false;
333 error (0, errno, _("cannot do ioctl on %s"), quote (infile));
334 newlines2 = newlines;
339 input_pending = true;
343 write_pending (outbuf, &bpout);
345 /* Read more input into INBUF. */
347 n_read = safe_read (input_desc, inbuf, insize);
348 if (n_read == SAFE_READ_ERROR)
350 error (0, errno, "%s", infile);
351 write_pending (outbuf, &bpout);
352 newlines2 = newlines;
357 write_pending (outbuf, &bpout);
358 newlines2 = newlines;
362 /* Update the pointers and insert a sentinel at the buffer
371 /* It was a real (not a sentinel) newline. */
373 /* Was the last line empty?
374 (i.e. have two or more consecutive newlines been read?) */
380 /* Limit this to 2 here. Otherwise, with lots of
381 consecutive newlines, the counter could wrap
382 around at INT_MAX. */
385 /* Are multiple adjacent empty lines to be substituted
386 by single ditto (-s), and this was the second empty
395 /* Are line numbers to be written at empty lines (-n)? */
397 if (number & !number_nonblank)
400 bpout = stpcpy (bpout, line_num_print);
404 /* Output a currency symbol if requested (-e). */
409 /* Output the newline. */
417 /* Are we at the beginning of a line, and line numbers are requested? */
419 if (newlines >= 0 && number)
422 bpout = stpcpy (bpout, line_num_print);
425 /* Here CH cannot contain a newline character. */
427 /* The loops below continue until a newline character is found,
428 which means that the buffer is empty or that a proper newline
431 /* If quoting, i.e. at least one of -v, -e, or -t specified,
432 scan for chars that need conversion. */
433 if (show_nonprinting)
463 *bpout++ = ch - 128 + 64;
467 else if (ch == '\t' && !show_tabs)
485 /* Not quoting, neither of -v, -e, or -t specified. */
488 if (ch == '\t' && show_tabs)
508 main (int argc, char **argv)
510 /* Optimal size of i/o operations of output. */
513 /* Optimal size of i/o operations of input. */
516 size_t page_size = getpagesize ();
518 /* Pointer to the input buffer. */
521 /* Pointer to the output buffer. */
527 /* Index in argv to processed argument. */
530 /* Device number of the output (file or whatever). */
533 /* I-node number of the output. */
536 /* True if the output file should not be the same as any input file. */
537 bool check_redirection = true;
539 /* Nonzero if we have ever read standard input. */
540 bool have_read_stdin = false;
542 struct stat stat_buf;
544 /* Variables that are set according to the specified options. */
546 bool number_nonblank = false;
547 bool squeeze_blank = false;
548 bool show_ends = false;
549 bool show_nonprinting = false;
550 bool show_tabs = false;
551 int file_open_mode = O_RDONLY;
553 static struct option const long_options[] =
555 {"number-nonblank", no_argument, NULL, 'b'},
556 {"number", no_argument, NULL, 'n'},
557 {"squeeze-blank", no_argument, NULL, 's'},
558 {"show-nonprinting", no_argument, NULL, 'v'},
559 {"show-ends", no_argument, NULL, 'E'},
560 {"show-tabs", no_argument, NULL, 'T'},
561 {"show-all", no_argument, NULL, 'A'},
562 {GETOPT_HELP_OPTION_DECL},
563 {GETOPT_VERSION_OPTION_DECL},
567 initialize_main (&argc, &argv);
568 program_name = argv[0];
569 setlocale (LC_ALL, "");
570 bindtextdomain (PACKAGE, LOCALEDIR);
571 textdomain (PACKAGE);
573 /* Arrange to close stdout if we exit via the
574 case_GETOPT_HELP_CHAR or case_GETOPT_VERSION_CHAR code.
575 Normally STDOUT_FILENO is used rather than stdout, so
576 close_stdout does nothing. */
577 atexit (close_stdout);
579 /* Parse command line options. */
581 while ((c = getopt_long (argc, argv, "benstuvAET", long_options, NULL))
588 number_nonblank = true;
593 show_nonprinting = true;
601 squeeze_blank = true;
606 show_nonprinting = true;
610 /* We provide the -u feature unconditionally. */
614 show_nonprinting = true;
618 show_nonprinting = true;
631 case_GETOPT_HELP_CHAR;
633 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
636 usage (EXIT_FAILURE);
640 /* Get device, i-node number, and optimal blocksize of output. */
642 if (fstat (STDOUT_FILENO, &stat_buf) < 0)
643 error (EXIT_FAILURE, errno, _("standard output"));
645 outsize = ST_BLKSIZE (stat_buf);
646 /* Input file can be output file for non-regular files.
647 fstat on pipes returns S_IFSOCK on some systems, S_IFIFO
648 on others, so the checking should not be done for those types,
649 and to allow things like cat < /dev/tty > /dev/tty, checking
650 is not done for device files either. */
652 if (S_ISREG (stat_buf.st_mode))
654 out_dev = stat_buf.st_dev;
655 out_ino = stat_buf.st_ino;
659 check_redirection = false;
660 #ifdef lint /* Suppress `used before initialized' warning. */
666 if (! (number | show_ends | squeeze_blank))
668 file_open_mode |= O_BINARY;
669 if (O_BINARY && ! isatty (STDOUT_FILENO))
670 freopen (NULL, "wb", stdout);
673 /* Check if any of the input files are the same as the output file. */
683 infile = argv[argind];
685 if (STREQ (infile, "-"))
687 have_read_stdin = true;
688 input_desc = STDIN_FILENO;
689 if ((file_open_mode & O_BINARY) && ! isatty (STDIN_FILENO))
690 freopen (NULL, "rb", stdin);
694 input_desc = open (infile, file_open_mode);
697 error (0, errno, "%s", infile);
703 if (fstat (input_desc, &stat_buf) < 0)
705 error (0, errno, "%s", infile);
709 insize = ST_BLKSIZE (stat_buf);
711 /* Compare the device and i-node numbers of this input file with
712 the corresponding values of the (output file associated with)
713 stdout, and skip this input file if they coincide. Input
714 files cannot be redirected to themselves. */
716 if (check_redirection
717 && stat_buf.st_dev == out_dev && stat_buf.st_ino == out_ino
718 && (input_desc != STDIN_FILENO))
720 error (0, 0, _("%s: input file is output file"), infile);
725 /* Select which version of `cat' to use. If any format-oriented
726 options were given use `cat'; otherwise use `simple_cat'. */
728 if (! (number | show_ends | show_nonprinting
729 | show_tabs | squeeze_blank))
731 insize = max (insize, outsize);
732 inbuf = xmalloc (insize + page_size - 1);
734 ok &= simple_cat (ptr_align (inbuf, page_size), insize);
738 inbuf = xmalloc (insize + 1 + page_size - 1);
741 (OUTSIZE - 1 + INSIZE * 4 + LINE_COUNTER_BUF_LEN + PAGE_SIZE - 1)
742 bytes allocated for the output buffer?
744 A test whether output needs to be written is done when the input
745 buffer empties or when a newline appears in the input. After
746 output is written, at most (OUTSIZE - 1) bytes will remain in the
747 buffer. Now INSIZE bytes of input is read. Each input character
748 may grow by a factor of 4 (by the prepending of M-^). If all
749 characters do, and no newlines appear in this block of input, we
750 will have at most (OUTSIZE - 1 + INSIZE * 4) bytes in the buffer.
751 If the last character in the preceding block of input was a
752 newline, a line number may be written (according to the given
753 options) as the first thing in the output buffer. (Done after the
754 new input is read, but before processing of the input begins.)
755 A line number requires seldom more than LINE_COUNTER_BUF_LEN
758 Align the output buffer to a page size boundary, for efficency on
759 some paging implementations, so add PAGE_SIZE - 1 bytes to the
760 request to make room for the alignment. */
762 outbuf = xmalloc (outsize - 1 + insize * 4 + LINE_COUNTER_BUF_LEN
765 ok &= cat (ptr_align (inbuf, page_size), insize,
766 ptr_align (outbuf, page_size), outsize, show_nonprinting,
767 show_tabs, number, number_nonblank, show_ends,
776 if (!STREQ (infile, "-") && close (input_desc) < 0)
778 error (0, errno, "%s", infile);
782 while (++argind < argc);
784 if (have_read_stdin && close (STDIN_FILENO) < 0)
785 error (EXIT_FAILURE, errno, _("closing standard input"));
787 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);