1 /* cat -- concatenate files and print on the standard output.
2 Copyright (C) 1988-2021 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 3 of the License, or
7 (at your option) any later version.
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, see <https://www.gnu.org/licenses/>. */
17 /* Differences from the Unix cat:
18 * Always unbuffered, -u is ignored.
19 * Usually much faster than other versions of cat, the difference
20 is especially apparent when using the -v option.
22 By tege@sics.se, Torbjorn Granlund, advised by rms, Richard Stallman. */
28 #include <sys/types.h>
33 #include <sys/ioctl.h>
36 #include "ioblksize.h"
40 #include "full-write.h"
41 #include "safe-read.h"
42 #include "xbinary-io.h"
44 /* The official name of this program (e.g., no 'g' prefix). */
45 #define PROGRAM_NAME "cat"
48 proper_name ("Torbjorn Granlund"), \
49 proper_name ("Richard M. Stallman")
51 /* Name of input file. May be "-". */
52 static char const *infile
;
54 /* Descriptor on which input file is open. */
55 static int input_desc
;
57 /* Buffer for line numbers.
58 An 11 digit counter may overflow within an hour on a P2/466,
59 an 18 digit counter needs about 1000y */
60 #define LINE_COUNTER_BUF_LEN 20
61 static char line_buf
[LINE_COUNTER_BUF_LEN
] =
63 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
64 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '0',
68 /* Position in 'line_buf' where printing starts. This will not change
69 unless the number of lines is larger than 999999. */
70 static char *line_num_print
= line_buf
+ LINE_COUNTER_BUF_LEN
- 8;
72 /* Position of the first digit in 'line_buf'. */
73 static char *line_num_start
= line_buf
+ LINE_COUNTER_BUF_LEN
- 3;
75 /* Position of the last digit in 'line_buf'. */
76 static char *line_num_end
= line_buf
+ LINE_COUNTER_BUF_LEN
- 3;
78 /* Preserves the 'cat' function's local 'newlines' between invocations. */
79 static int newlines2
= 0;
81 /* Whether there is a pending CR to process. */
82 static bool pending_cr
= false;
87 if (status
!= EXIT_SUCCESS
)
92 Usage: %s [OPTION]... [FILE]...\n\
96 Concatenate FILE(s) to standard output.\n\
103 -A, --show-all equivalent to -vET\n\
104 -b, --number-nonblank number nonempty output lines, overrides -n\n\
105 -e equivalent to -vE\n\
106 -E, --show-ends display $ at end of each line\n\
107 -n, --number number all output lines\n\
108 -s, --squeeze-blank suppress repeated empty output lines\n\
111 -t equivalent to -vT\n\
112 -T, --show-tabs display TAB characters as ^I\n\
114 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB\n\
116 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
117 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
121 %s f - g Output f's contents, then standard input, then g's contents.\n\
122 %s Copy standard input to standard output.\n\
124 program_name
, program_name
);
125 emit_ancillary_info (PROGRAM_NAME
);
130 /* Compute the next line number. */
135 char *endp
= line_num_end
;
142 while (endp
>= line_num_start
);
143 if (line_num_start
> line_buf
)
144 *--line_num_start
= '1';
147 if (line_num_start
< line_num_print
)
151 /* Plain cat. Copies the file behind 'input_desc' to STDOUT_FILENO.
152 Return true if successful. */
156 /* Pointer to the buffer, used by reads and writes. */
159 /* Number of characters preferably read or written by each read and write
163 /* Actual number of characters read, and therefore written. */
166 /* Loop until the end of the file. */
170 /* Read a block of input. */
172 n_read
= safe_read (input_desc
, buf
, bufsize
);
173 if (n_read
== SAFE_READ_ERROR
)
175 error (0, errno
, "%s", quotef (infile
));
179 /* End of this file? */
184 /* Write this block out. */
187 /* The following is ok, since we know that 0 < n_read. */
189 if (full_write (STDOUT_FILENO
, buf
, n
) != n
)
190 die (EXIT_FAILURE
, errno
, _("write error"));
195 /* Write any pending output to STDOUT_FILENO.
196 Pending is defined to be the *BPOUT - OUTBUF bytes starting at OUTBUF.
197 Then set *BPOUT to OUTPUT if it's not already that value. */
200 write_pending (char *outbuf
, char **bpout
)
202 size_t n_write
= *bpout
- outbuf
;
205 if (full_write (STDOUT_FILENO
, outbuf
, n_write
) != n_write
)
206 die (EXIT_FAILURE
, errno
, _("write error"));
211 /* Cat the file behind INPUT_DESC to the file behind OUTPUT_DESC.
212 Return true if successful.
213 Called if any option more than -u was specified.
215 A newline character is always put at the end of the buffer, to make
216 an explicit test for buffer end unnecessary. */
220 /* Pointer to the beginning of the input buffer. */
223 /* Number of characters read in each read call. */
226 /* Pointer to the beginning of the output buffer. */
229 /* Number of characters written by each write call. */
232 /* Variables that have values according to the specified options. */
233 bool show_nonprinting
,
236 bool number_nonblank
,
240 /* Last character read from the input buffer. */
243 /* Pointer to the next character in the input buffer. */
246 /* Pointer to the first non-valid byte in the input buffer, i.e., the
247 current end of the buffer. */
250 /* Pointer to the position where the next character shall be written. */
253 /* Number of characters read by the last read call. */
256 /* Determines how many consecutive newlines there have been in the
257 input. 0 newlines makes NEWLINES -1, 1 newline makes NEWLINES 1,
258 etc. Initially 0 to indicate that we are at the beginning of a
259 new line. The "state" of the procedure is determined by
261 int newlines
= newlines2
;
264 /* If nonzero, use the FIONREAD ioctl, as an optimization.
265 (On Ultrix, it is not supported on NFS file systems.) */
266 bool use_fionread
= true;
269 /* The inbuf pointers are initialized so that BPIN > EOB, and thereby input
270 is read immediately. */
281 /* Write if there are at least OUTSIZE bytes in OUTBUF. */
283 if (outbuf
+ outsize
<= bpout
)
286 size_t remaining_bytes
;
289 if (full_write (STDOUT_FILENO
, wp
, outsize
) != outsize
)
290 die (EXIT_FAILURE
, errno
, _("write error"));
292 remaining_bytes
= bpout
- wp
;
294 while (outsize
<= remaining_bytes
);
296 /* Move the remaining bytes to the beginning of the
299 memmove (outbuf
, wp
, remaining_bytes
);
300 bpout
= outbuf
+ remaining_bytes
;
303 /* Is INBUF empty? */
307 bool input_pending
= false;
311 /* Is there any input to read immediately?
312 If not, we are about to wait,
313 so write all buffered output before waiting. */
316 && ioctl (input_desc
, FIONREAD
, &n_to_read
) < 0)
318 /* Ultrix returns EOPNOTSUPP on NFS;
319 HP-UX returns ENOTTY on pipes.
320 SunOS returns EINVAL and
321 More/BSD returns ENODEV on special files
323 Irix-5 returns ENOSYS on pipes. */
324 if (errno
== EOPNOTSUPP
|| errno
== ENOTTY
325 || errno
== EINVAL
|| errno
== ENODEV
327 use_fionread
= false;
330 error (0, errno
, _("cannot do ioctl on %s"),
332 newlines2
= newlines
;
337 input_pending
= true;
341 write_pending (outbuf
, &bpout
);
343 /* Read more input into INBUF. */
345 n_read
= safe_read (input_desc
, inbuf
, insize
);
346 if (n_read
== SAFE_READ_ERROR
)
348 error (0, errno
, "%s", quotef (infile
));
349 write_pending (outbuf
, &bpout
);
350 newlines2
= newlines
;
355 write_pending (outbuf
, &bpout
);
356 newlines2
= newlines
;
360 /* Update the pointers and insert a sentinel at the buffer
369 /* It was a real (not a sentinel) newline. */
371 /* Was the last line empty?
372 (i.e., have two or more consecutive newlines been read?) */
378 /* Limit this to 2 here. Otherwise, with lots of
379 consecutive newlines, the counter could wrap
380 around at INT_MAX. */
383 /* Are multiple adjacent empty lines to be substituted
384 by single ditto (-s), and this was the second empty
393 /* Are line numbers to be written at empty lines (-n)? */
395 if (number
&& !number_nonblank
)
398 bpout
= stpcpy (bpout
, line_num_print
);
402 /* Output a currency symbol if requested (-e). */
414 /* Output the newline. */
422 /* Here CH cannot contain a newline character. */
430 /* Are we at the beginning of a line, and line numbers are requested? */
432 if (newlines
>= 0 && number
)
435 bpout
= stpcpy (bpout
, line_num_print
);
438 /* The loops below continue until a newline character is found,
439 which means that the buffer is empty or that a proper newline
442 /* If quoting, i.e., at least one of -v, -e, or -t specified,
443 scan for chars that need conversion. */
444 if (show_nonprinting
)
474 *bpout
++ = ch
- 128 + 64;
478 else if (ch
== '\t' && !show_tabs
)
496 /* Not quoting, neither of -v, -e, or -t specified. */
499 if (ch
== '\t' && show_tabs
)
506 if (ch
== '\r' && *bpin
== '\n' && show_ends
)
532 main (int argc
, char **argv
)
534 /* Optimal size of i/o operations of output. */
537 /* Optimal size of i/o operations of input. */
540 size_t page_size
= getpagesize ();
542 /* Pointer to the input buffer. */
545 /* Pointer to the output buffer. */
551 /* Index in argv to processed argument. */
554 /* Device number of the output (file or whatever). */
557 /* I-node number of the output. */
560 /* True if the output is a regular file. */
563 /* Nonzero if we have ever read standard input. */
564 bool have_read_stdin
= false;
566 struct stat stat_buf
;
568 /* Variables that are set according to the specified options. */
570 bool number_nonblank
= false;
571 bool squeeze_blank
= false;
572 bool show_ends
= false;
573 bool show_nonprinting
= false;
574 bool show_tabs
= false;
575 int file_open_mode
= O_RDONLY
;
577 static struct option
const long_options
[] =
579 {"number-nonblank", no_argument
, NULL
, 'b'},
580 {"number", no_argument
, NULL
, 'n'},
581 {"squeeze-blank", no_argument
, NULL
, 's'},
582 {"show-nonprinting", no_argument
, NULL
, 'v'},
583 {"show-ends", no_argument
, NULL
, 'E'},
584 {"show-tabs", no_argument
, NULL
, 'T'},
585 {"show-all", no_argument
, NULL
, 'A'},
586 {GETOPT_HELP_OPTION_DECL
},
587 {GETOPT_VERSION_OPTION_DECL
},
591 initialize_main (&argc
, &argv
);
592 set_program_name (argv
[0]);
593 setlocale (LC_ALL
, "");
594 bindtextdomain (PACKAGE
, LOCALEDIR
);
595 textdomain (PACKAGE
);
597 /* Arrange to close stdout if we exit via the
598 case_GETOPT_HELP_CHAR or case_GETOPT_VERSION_CHAR code.
599 Normally STDOUT_FILENO is used rather than stdout, so
600 close_stdout does nothing. */
601 atexit (close_stdout
);
603 /* Parse command line options. */
605 while ((c
= getopt_long (argc
, argv
, "benstuvAET", long_options
, NULL
))
612 number_nonblank
= true;
617 show_nonprinting
= true;
625 squeeze_blank
= true;
630 show_nonprinting
= true;
634 /* We provide the -u feature unconditionally. */
638 show_nonprinting
= true;
642 show_nonprinting
= true;
655 case_GETOPT_HELP_CHAR
;
657 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
660 usage (EXIT_FAILURE
);
664 /* Get device, i-node number, and optimal blocksize of output. */
666 if (fstat (STDOUT_FILENO
, &stat_buf
) < 0)
667 die (EXIT_FAILURE
, errno
, _("standard output"));
669 outsize
= io_blksize (stat_buf
);
670 out_dev
= stat_buf
.st_dev
;
671 out_ino
= stat_buf
.st_ino
;
672 out_isreg
= S_ISREG (stat_buf
.st_mode
) != 0;
674 if (! (number
|| show_ends
|| squeeze_blank
))
676 file_open_mode
|= O_BINARY
;
677 xset_binary_mode (STDOUT_FILENO
, O_BINARY
);
680 /* Check if any of the input files are the same as the output file. */
690 infile
= argv
[argind
];
692 if (STREQ (infile
, "-"))
694 have_read_stdin
= true;
695 input_desc
= STDIN_FILENO
;
696 if (file_open_mode
& O_BINARY
)
697 xset_binary_mode (STDIN_FILENO
, O_BINARY
);
701 input_desc
= open (infile
, file_open_mode
);
704 error (0, errno
, "%s", quotef (infile
));
710 if (fstat (input_desc
, &stat_buf
) < 0)
712 error (0, errno
, "%s", quotef (infile
));
716 insize
= io_blksize (stat_buf
);
718 fdadvise (input_desc
, 0, 0, FADVISE_SEQUENTIAL
);
720 /* Don't copy a nonempty regular file to itself, as that would
721 merely exhaust the output device. It's better to catch this
722 error earlier rather than later. */
725 && stat_buf
.st_dev
== out_dev
&& stat_buf
.st_ino
== out_ino
726 && lseek (input_desc
, 0, SEEK_CUR
) < stat_buf
.st_size
)
728 error (0, 0, _("%s: input file is output file"), quotef (infile
));
733 /* Select which version of 'cat' to use. If any format-oriented
734 options were given use 'cat'; otherwise use 'simple_cat'. */
736 if (! (number
|| show_ends
|| show_nonprinting
737 || show_tabs
|| squeeze_blank
))
739 insize
= MAX (insize
, outsize
);
740 inbuf
= xmalloc (insize
+ page_size
- 1);
742 ok
&= simple_cat (ptr_align (inbuf
, page_size
), insize
);
746 inbuf
= xmalloc (insize
+ 1 + page_size
- 1);
749 (OUTSIZE - 1 + INSIZE * 4 + LINE_COUNTER_BUF_LEN + PAGE_SIZE - 1)
750 bytes allocated for the output buffer?
752 A test whether output needs to be written is done when the input
753 buffer empties or when a newline appears in the input. After
754 output is written, at most (OUTSIZE - 1) bytes will remain in the
755 buffer. Now INSIZE bytes of input is read. Each input character
756 may grow by a factor of 4 (by the prepending of M-^). If all
757 characters do, and no newlines appear in this block of input, we
758 will have at most (OUTSIZE - 1 + INSIZE * 4) bytes in the buffer.
759 If the last character in the preceding block of input was a
760 newline, a line number may be written (according to the given
761 options) as the first thing in the output buffer. (Done after the
762 new input is read, but before processing of the input begins.)
763 A line number requires seldom more than LINE_COUNTER_BUF_LEN
766 Align the output buffer to a page size boundary, for efficiency
767 on some paging implementations, so add PAGE_SIZE - 1 bytes to the
768 request to make room for the alignment. */
770 outbuf
= xmalloc (outsize
- 1 + insize
* 4 + LINE_COUNTER_BUF_LEN
773 ok
&= cat (ptr_align (inbuf
, page_size
), insize
,
774 ptr_align (outbuf
, page_size
), outsize
, show_nonprinting
,
775 show_tabs
, number
, number_nonblank
, show_ends
,
784 if (!STREQ (infile
, "-") && close (input_desc
) < 0)
786 error (0, errno
, "%s", quotef (infile
));
790 while (++argind
< argc
);
794 if (full_write (STDOUT_FILENO
, "\r", 1) != 1)
795 die (EXIT_FAILURE
, errno
, _("write error"));
798 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
799 die (EXIT_FAILURE
, errno
, _("closing standard input"));
801 return ok
? EXIT_SUCCESS
: EXIT_FAILURE
;