.
[coreutils.git] / src / cat.c
blobd8594cba6d8a2ca5909b9f013b8e0924fd6d738b
1 /* cat -- concatenate files and print on the standard output.
2 Copyright (C) 88, 90, 91, 95, 1996 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)
7 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, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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. */
25 #include <config.h>
27 #include <stdio.h>
28 #include <getopt.h>
29 #include <sys/types.h>
30 #ifndef _POSIX_SOURCE
31 #include <sys/ioctl.h>
32 #endif
33 #include "system.h"
34 #include "error.h"
36 /* Undefine, to avoid warning about redefinition on some systems. */
37 #undef max
38 #define max(h,i) ((h) > (i) ? (h) : (i))
40 char *stpcpy ();
41 char *xmalloc ();
42 int full_write ();
43 int safe_read ();
45 /* Name under which this program was invoked. */
46 char *program_name;
48 /* Name of input file. May be "-". */
49 static char *infile;
51 /* Descriptor on which input file is open. */
52 static int input_desc;
54 /* Descriptor on which output file is open. Always is 1. */
55 static int output_desc;
57 /* Buffer for line numbers. */
58 static char line_buf[13] =
59 {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '0', '\t', '\0'};
61 /* Position in `line_buf' where printing starts. This will not change
62 unless the number of lines is larger than 999999. */
63 static char *line_num_print = line_buf + 5;
65 /* Position of the first digit in `line_buf'. */
66 static char *line_num_start = line_buf + 10;
68 /* Position of the last digit in `line_buf'. */
69 static char *line_num_end = line_buf + 10;
71 /* Preserves the `cat' function's local `newlines' between invocations. */
72 static int newlines2 = 0;
74 /* Count of non-fatal error conditions. */
75 static int exit_status = 0;
77 static void
78 usage (int status)
80 if (status != 0)
81 fprintf (stderr, _("Try `%s --help' for more information.\n"),
82 program_name);
83 else
85 printf (_("\
86 Usage: %s [OPTION] [FILE]...\n\
87 "),
88 program_name);
89 printf (_("\
90 Concatenate FILE(s), or standard input, to standard output.\n\
91 \n\
92 -A, --show-all equivalent to -vET\n\
93 -b, --number-nonblank number nonblank output lines\n\
94 -e equivalent to -vE\n\
95 -E, --show-ends display $ at end of each line\n\
96 -n, --number number all output lines\n\
97 -s, --squeeze-blank never more than one single blank line\n\
98 -t equivalent to -vT\n\
99 -T, --show-tabs display TAB characters as ^I\n\
100 -u (ignored)\n\
101 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB\n\
102 --help display this help and exit\n\
103 --version output version information and exit\n\
105 With no FILE, or when FILE is -, read standard input.\n\
106 "));
107 puts (_("\nReport bugs to textutils-bugs@gnu.ai.mit.edu"));
109 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
112 /* Compute the next line number. */
114 static void
115 next_line_num (void)
117 char *endp = line_num_end;
120 if ((*endp)++ < '9')
121 return;
122 *endp-- = '0';
124 while (endp >= line_num_start);
125 *--line_num_start = '1';
126 if (line_num_start < line_num_print)
127 line_num_print--;
130 /* Plain cat. Copies the file behind `input_desc' to the file behind
131 `output_desc'. */
133 static void
134 simple_cat (
135 /* Pointer to the buffer, used by reads and writes. */
136 unsigned char *buf,
138 /* Number of characters preferably read or written by each read and write
139 call. */
140 int bufsize)
142 /* Actual number of characters read, and therefore written. */
143 int n_read;
145 /* Loop until the end of the file. */
147 for (;;)
149 /* Read a block of input. */
151 n_read = safe_read (input_desc, buf, bufsize);
152 if (n_read < 0)
154 error (0, errno, "%s", infile);
155 exit_status = 1;
156 return;
159 /* End of this file? */
161 if (n_read == 0)
162 break;
164 /* Write this block out. */
166 if (full_write (output_desc, buf, n_read) < 0)
167 error (EXIT_FAILURE, errno, _("write error"));
171 /* Cat the file behind INPUT_DESC to the file behind OUTPUT_DESC.
172 Called if any option more than -u was specified.
174 A newline character is always put at the end of the buffer, to make
175 an explicit test for buffer end unnecessary. */
177 static void
178 cat (
179 /* Pointer to the beginning of the input buffer. */
180 unsigned char *inbuf,
182 /* Number of characters read in each read call. */
183 int insize,
185 /* Pointer to the beginning of the output buffer. */
186 unsigned char *outbuf,
188 /* Number of characters written by each write call. */
189 int outsize,
191 /* Variables that have values according to the specified options. */
192 int quote,
193 int output_tabs,
194 int numbers,
195 int numbers_at_empty_lines,
196 int mark_line_ends,
197 int squeeze_empty_lines)
199 /* Last character read from the input buffer. */
200 unsigned char ch;
202 /* Pointer to the next character in the input buffer. */
203 unsigned char *bpin;
205 /* Pointer to the first non-valid byte in the input buffer, i.e. the
206 current end of the buffer. */
207 unsigned char *eob;
209 /* Pointer to the position where the next character shall be written. */
210 unsigned char *bpout;
212 /* Number of characters read by the last read call. */
213 int n_read;
215 /* Determines how many consecutive newlines there have been in the
216 input. 0 newlines makes NEWLINES -1, 1 newline makes NEWLINES 1,
217 etc. Initially 0 to indicate that we are at the beginning of a
218 new line. The "state" of the procedure is determined by
219 NEWLINES. */
220 int newlines = newlines2;
222 #ifdef FIONREAD
223 /* If nonzero, use the FIONREAD ioctl, as an optimization.
224 (On Ultrix, it is not supported on NFS filesystems.) */
225 int use_fionread = 1;
226 #endif
228 /* The inbuf pointers are initialized so that BPIN > EOB, and thereby input
229 is read immediately. */
231 eob = inbuf;
232 bpin = eob + 1;
234 bpout = outbuf;
236 for (;;)
240 /* Write if there are at least OUTSIZE bytes in OUTBUF. */
242 if (bpout - outbuf >= outsize)
244 unsigned char *wp = outbuf;
247 if (full_write (output_desc, wp, outsize) < 0)
248 error (EXIT_FAILURE, errno, _("write error"));
249 wp += outsize;
251 while (bpout - wp >= outsize);
253 /* Move the remaining bytes to the beginning of the
254 buffer. */
256 memmove (outbuf, wp, bpout - wp);
257 bpout = outbuf + (bpout - wp);
260 /* Is INBUF empty? */
262 if (bpin > eob)
264 #ifdef FIONREAD
265 int n_to_read = 0;
267 /* Is there any input to read immediately?
268 If not, we are about to wait,
269 so write all buffered output before waiting. */
271 if (use_fionread
272 && ioctl (input_desc, FIONREAD, &n_to_read) < 0)
274 /* Ultrix returns EOPNOTSUPP on NFS;
275 HP-UX returns ENOTTY on pipes.
276 SunOS returns EINVAL and
277 More/BSD returns ENODEV on special files
278 like /dev/null.
279 Irix-5 returns ENOSYS on pipes. */
280 if (errno == EOPNOTSUPP || errno == ENOTTY
281 || errno == EINVAL || errno == ENODEV
282 #ifdef ENOSYS
283 || errno == ENOSYS
284 #endif
286 use_fionread = 0;
287 else
289 error (0, errno, _("cannot do ioctl on `%s'"), infile);
290 exit_status = 1;
291 newlines2 = newlines;
292 return;
295 if (n_to_read == 0)
296 #endif
298 int n_write = bpout - outbuf;
300 if (full_write (output_desc, outbuf, n_write) < 0)
301 error (EXIT_FAILURE, errno, _("write error"));
302 bpout = outbuf;
305 /* Read more input into INBUF. */
307 n_read = safe_read (input_desc, inbuf, insize);
308 if (n_read < 0)
310 error (0, errno, "%s", infile);
311 exit_status = 1;
312 newlines2 = newlines;
313 return;
315 if (n_read == 0)
317 newlines2 = newlines;
318 return;
321 /* Update the pointers and insert a sentinel at the buffer
322 end. */
324 bpin = inbuf;
325 eob = bpin + n_read;
326 *eob = '\n';
328 else
330 /* It was a real (not a sentinel) newline. */
332 /* Was the last line empty?
333 (i.e. have two or more consecutive newlines been read?) */
335 if (++newlines > 0)
337 /* Are multiple adjacent empty lines to be substituted by
338 single ditto (-s), and this was the second empty line? */
340 if (squeeze_empty_lines && newlines >= 2)
342 ch = *bpin++;
343 continue;
346 /* Are line numbers to be written at empty lines (-n)? */
348 if (numbers && numbers_at_empty_lines)
350 next_line_num ();
351 bpout = (unsigned char *) stpcpy ((char *) bpout,
352 line_num_print);
356 /* Output a currency symbol if requested (-e). */
358 if (mark_line_ends)
359 *bpout++ = '$';
361 /* Output the newline. */
363 *bpout++ = '\n';
365 ch = *bpin++;
367 while (ch == '\n');
369 /* Are we at the beginning of a line, and line numbers are requested? */
371 if (newlines >= 0 && numbers)
373 next_line_num ();
374 bpout = (unsigned char *) stpcpy ((char *) bpout, line_num_print);
377 /* Here CH cannot contain a newline character. */
379 /* The loops below continue until a newline character is found,
380 which means that the buffer is empty or that a proper newline
381 has been found. */
383 /* If quoting, i.e. at least one of -v, -e, or -t specified,
384 scan for chars that need conversion. */
385 if (quote)
386 for (;;)
388 if (ch >= 32)
390 if (ch < 127)
391 *bpout++ = ch;
392 else if (ch == 127)
393 *bpout++ = '^',
394 *bpout++ = '?';
395 else
397 *bpout++ = 'M',
398 *bpout++ = '-';
399 if (ch >= 128 + 32)
400 if (ch < 128 + 127)
401 *bpout++ = ch - 128;
402 else
403 *bpout++ = '^',
404 *bpout++ = '?';
405 else
406 *bpout++ = '^',
407 *bpout++ = ch - 128 + 64;
410 else if (ch == '\t' && output_tabs)
411 *bpout++ = '\t';
412 else if (ch == '\n')
414 newlines = -1;
415 break;
417 else
418 *bpout++ = '^',
419 *bpout++ = ch + 64;
421 ch = *bpin++;
423 else
424 /* Not quoting, neither of -v, -e, or -t specified. */
425 for (;;)
427 if (ch == '\t' && !output_tabs)
428 *bpout++ = '^',
429 *bpout++ = ch + 64;
430 else if (ch != '\n')
431 *bpout++ = ch;
432 else
434 newlines = -1;
435 break;
438 ch = *bpin++;
444 main (int argc, char **argv)
446 /* Optimal size of i/o operations of output. */
447 int outsize;
449 /* Optimal size of i/o operations of input. */
450 int insize;
452 /* Pointer to the input buffer. */
453 unsigned char *inbuf;
455 /* Pointer to the output buffer. */
456 unsigned char *outbuf;
458 int c;
460 /* Index in argv to processed argument. */
461 int argind;
463 /* Device number of the output (file or whatever). */
464 int out_dev;
466 /* I-node number of the output. */
467 int out_ino;
469 /* Nonzero if the output file should not be the same as any input file. */
470 int check_redirection = 1;
472 /* Nonzero if we have ever read standard input. */
473 int have_read_stdin = 0;
475 struct stat stat_buf;
477 /* Variables that are set according to the specified options. */
478 int numbers = 0;
479 int numbers_at_empty_lines = 1;
480 int squeeze_empty_lines = 0;
481 int mark_line_ends = 0;
482 int quote = 0;
483 int output_tabs = 1;
485 /* If nonzero, call cat, otherwise call simple_cat to do the actual work. */
486 int options = 0;
488 /* If nonzero, display usage information and exit. */
489 static int show_help;
491 /* If nonzero, print the version on standard output then exit. */
492 static int show_version;
494 static struct option const long_options[] =
496 {"number-nonblank", no_argument, NULL, 'b'},
497 {"number", no_argument, NULL, 'n'},
498 {"squeeze-blank", no_argument, NULL, 's'},
499 {"show-nonprinting", no_argument, NULL, 'v'},
500 {"show-ends", no_argument, NULL, 'E'},
501 {"show-tabs", no_argument, NULL, 'T'},
502 {"show-all", no_argument, NULL, 'A'},
503 {"help", no_argument, &show_help, 1},
504 {"version", no_argument, &show_version, 1},
505 {NULL, 0, NULL, 0}
508 program_name = argv[0];
509 setlocale (LC_ALL, "");
510 bindtextdomain (PACKAGE, LOCALEDIR);
511 textdomain (PACKAGE);
513 /* Parse command line options. */
515 while ((c = getopt_long (argc, argv, "benstuvAET", long_options, (int *) 0))
516 != EOF)
518 switch (c)
520 case 0:
521 break;
523 case 'b':
524 ++options;
525 numbers = 1;
526 numbers_at_empty_lines = 0;
527 break;
529 case 'e':
530 ++options;
531 mark_line_ends = 1;
532 quote = 1;
533 break;
535 case 'n':
536 ++options;
537 numbers = 1;
538 break;
540 case 's':
541 ++options;
542 squeeze_empty_lines = 1;
543 break;
545 case 't':
546 ++options;
547 output_tabs = 0;
548 quote = 1;
549 break;
551 case 'u':
552 /* We provide the -u feature unconditionally. */
553 break;
555 case 'v':
556 ++options;
557 quote = 1;
558 break;
560 case 'A':
561 ++options;
562 quote = 1;
563 mark_line_ends = 1;
564 output_tabs = 0;
565 break;
567 case 'E':
568 ++options;
569 mark_line_ends = 1;
570 break;
572 case 'T':
573 ++options;
574 output_tabs = 0;
575 break;
577 default:
578 usage (EXIT_FAILURE);
582 if (show_version)
584 printf ("cat (%s) %s\n", GNU_PACKAGE, VERSION);
585 exit (EXIT_SUCCESS);
588 if (show_help)
589 usage (0);
591 output_desc = 1;
593 /* Get device, i-node number, and optimal blocksize of output. */
595 if (fstat (output_desc, &stat_buf) < 0)
596 error (EXIT_FAILURE, errno, _("standard output"));
598 outsize = ST_BLKSIZE (stat_buf);
599 /* Input file can be output file for non-regular files.
600 fstat on pipes returns S_IFSOCK on some systems, S_IFIFO
601 on others, so the checking should not be done for those types,
602 and to allow things like cat < /dev/tty > /dev/tty, checking
603 is not done for device files either. */
605 if (S_ISREG (stat_buf.st_mode))
607 out_dev = stat_buf.st_dev;
608 out_ino = stat_buf.st_ino;
610 else
612 check_redirection = 0;
613 #ifdef lint /* Suppress `used before initialized' warning. */
614 out_dev = 0;
615 out_ino = 0;
616 #endif
619 /* Check if any of the input files are the same as the output file. */
621 /* Main loop. */
623 infile = "-";
624 argind = optind;
628 if (argind < argc)
629 infile = argv[argind];
631 if (infile[0] == '-' && infile[1] == 0)
633 have_read_stdin = 1;
634 input_desc = 0;
636 else
638 input_desc = open (infile, O_RDONLY);
639 if (input_desc < 0)
641 error (0, errno, "%s", infile);
642 exit_status = 1;
643 continue;
647 if (fstat (input_desc, &stat_buf) < 0)
649 error (0, errno, "%s", infile);
650 exit_status = 1;
651 goto contin;
653 insize = ST_BLKSIZE (stat_buf);
655 /* Compare the device and i-node numbers of this input file with
656 the corresponding values of the (output file associated with)
657 stdout, and skip this input file if they coincide. Input
658 files cannot be redirected to themselves. */
660 if (check_redirection
661 && stat_buf.st_dev == out_dev && stat_buf.st_ino == out_ino
662 && (input_desc != STDIN_FILENO || output_desc != STDOUT_FILENO))
664 error (0, 0, _("%s: input file is output file"), infile);
665 exit_status = 1;
666 goto contin;
669 /* Select which version of `cat' to use. If any options (more than -u,
670 --version, or --help) were specified, use `cat', otherwise use
671 `simple_cat'. */
673 if (options == 0)
675 insize = max (insize, outsize);
676 inbuf = (unsigned char *) xmalloc (insize);
678 simple_cat (inbuf, insize);
680 else
682 inbuf = (unsigned char *) xmalloc (insize + 1);
684 /* Why are (OUTSIZE - 1 + INSIZE * 4 + 13) bytes allocated for
685 the output buffer?
687 A test whether output needs to be written is done when the input
688 buffer empties or when a newline appears in the input. After
689 output is written, at most (OUTSIZE - 1) bytes will remain in the
690 buffer. Now INSIZE bytes of input is read. Each input character
691 may grow by a factor of 4 (by the prepending of M-^). If all
692 characters do, and no newlines appear in this block of input, we
693 will have at most (OUTSIZE - 1 + INSIZE) bytes in the buffer. If
694 the last character in the preceding block of input was a
695 newline, a line number may be written (according to the given
696 options) as the first thing in the output buffer. (Done after the
697 new input is read, but before processing of the input begins.) A
698 line number requires seldom more than 13 positions. */
700 outbuf = (unsigned char *) xmalloc (outsize - 1 + insize * 4 + 13);
702 cat (inbuf, insize, outbuf, outsize, quote,
703 output_tabs, numbers, numbers_at_empty_lines, mark_line_ends,
704 squeeze_empty_lines);
706 free (outbuf);
709 free (inbuf);
711 contin:
712 if (strcmp (infile, "-") && close (input_desc) < 0)
714 error (0, errno, "%s", infile);
715 exit_status = 1;
718 while (++argind < argc);
720 if (have_read_stdin && close (0) < 0)
721 error (EXIT_FAILURE, errno, "-");
722 if (close (1) < 0)
723 error (EXIT_FAILURE, errno, _("write error"));
725 exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);