1 /* head -- output first part of file(s)
2 Copyright (C) 1989-2013 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 <http://www.gnu.org/licenses/>. */
17 /* Options: (see usage)
18 Reads from standard input if no files are given or when a filename of
20 By default, filename headers are printed only if more than one file
22 By default, prints the first 10 lines (head -n 10).
24 David MacKenzie <djm@gnu.ai.mit.edu> */
30 #include <sys/types.h>
35 #include "full-read.h"
37 #include "safe-read.h"
41 /* The official name of this program (e.g., no 'g' prefix). */
42 #define PROGRAM_NAME "head"
45 proper_name ("David MacKenzie"), \
46 proper_name ("Jim Meyering")
48 /* Number of lines/chars/blocks to head. */
49 #define DEFAULT_NUMBER 10
51 /* Useful only when eliding tail bytes or lines.
52 If true, skip the is-regular-file test used to determine whether
53 to use the lseek optimization. Instead, use the more general (and
54 more expensive) code unconditionally. Intended solely for testing. */
55 static bool presume_input_pipe
;
57 /* If true, print filename headers. */
58 static bool print_headers
;
60 /* When to print the filename banners. */
63 multiple_files
, always
, never
66 /* Have we ever read standard input? */
67 static bool have_read_stdin
;
74 COPY_FD_UNEXPECTED_EOF
77 /* For long options that have no equivalent short option, use a
78 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
81 PRESUME_INPUT_PIPE_OPTION
= CHAR_MAX
+ 1
84 static struct option
const long_options
[] =
86 {"bytes", required_argument
, NULL
, 'c'},
87 {"lines", required_argument
, NULL
, 'n'},
88 {"-presume-input-pipe", no_argument
, NULL
,
89 PRESUME_INPUT_PIPE_OPTION
}, /* do not document */
90 {"quiet", no_argument
, NULL
, 'q'},
91 {"silent", no_argument
, NULL
, 'q'},
92 {"verbose", no_argument
, NULL
, 'v'},
93 {GETOPT_HELP_OPTION_DECL
},
94 {GETOPT_VERSION_OPTION_DECL
},
101 if (status
!= EXIT_SUCCESS
)
106 Usage: %s [OPTION]... [FILE]...\n\
110 Print the first 10 lines of each FILE to standard output.\n\
111 With more than one FILE, precede each with a header giving the file name.\n\
112 With no FILE, or when FILE is -, read standard input.\n\
115 emit_mandatory_arg_note ();
118 -c, --bytes=[-]K print the first K bytes of each file;\n\
119 with the leading '-', print all but the last\n\
120 K bytes of each file\n\
121 -n, --lines=[-]K print the first K lines instead of the first 10;\n\
122 with the leading '-', print all but the last\n\
123 K lines of each file\n\
126 -q, --quiet, --silent never print headers giving file names\n\
127 -v, --verbose always print headers giving file names\n\
129 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
130 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
133 K may have a multiplier suffix:\n\
134 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
135 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
137 emit_ancillary_info ();
143 diagnose_copy_fd_failure (enum Copy_fd_status err
, char const *filename
)
147 case COPY_FD_READ_ERROR
:
148 error (0, errno
, _("error reading %s"), quote (filename
));
150 case COPY_FD_WRITE_ERROR
:
151 error (0, errno
, _("error writing %s"), quote (filename
));
153 case COPY_FD_UNEXPECTED_EOF
:
154 error (0, errno
, _("%s: file has shrunk too much"), quote (filename
));
162 write_header (const char *filename
)
164 static bool first_file
= true;
166 printf ("%s==> %s <==\n", (first_file
? "" : "\n"), filename
);
170 /* Copy no more than N_BYTES from file descriptor SRC_FD to O_STREAM.
171 Return an appropriate indication of success or failure. */
173 static enum Copy_fd_status
174 copy_fd (int src_fd
, FILE *o_stream
, uintmax_t n_bytes
)
177 const size_t buf_size
= sizeof (buf
);
179 /* Copy the file contents. */
182 size_t n_to_read
= MIN (buf_size
, n_bytes
);
183 size_t n_read
= safe_read (src_fd
, buf
, n_to_read
);
184 if (n_read
== SAFE_READ_ERROR
)
185 return COPY_FD_READ_ERROR
;
189 if (n_read
== 0 && n_bytes
!= 0)
190 return COPY_FD_UNEXPECTED_EOF
;
192 if (fwrite (buf
, 1, n_read
, o_stream
) < n_read
)
193 return COPY_FD_WRITE_ERROR
;
199 /* Print all but the last N_ELIDE lines from the input available via
200 the non-seekable file descriptor FD. Return true upon success.
201 Give a diagnostic and return false upon error. */
203 elide_tail_bytes_pipe (const char *filename
, int fd
, uintmax_t n_elide_0
)
205 size_t n_elide
= n_elide_0
;
207 #ifndef HEAD_TAIL_PIPE_READ_BUFSIZE
208 # define HEAD_TAIL_PIPE_READ_BUFSIZE BUFSIZ
210 #define READ_BUFSIZE HEAD_TAIL_PIPE_READ_BUFSIZE
212 /* If we're eliding no more than this many bytes, then it's ok to allocate
213 more memory in order to use a more time-efficient algorithm.
214 FIXME: use a fraction of available memory instead, as in sort.
215 FIXME: is this even worthwhile? */
216 #ifndef HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
217 # define HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD 1024 * 1024
220 #if HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD < 2 * READ_BUFSIZE
221 "HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD must be at least 2 * READ_BUFSIZE"
224 if (SIZE_MAX
< n_elide_0
+ READ_BUFSIZE
)
226 char umax_buf
[INT_BUFSIZE_BOUND (n_elide_0
)];
227 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
228 umaxtostr (n_elide_0
, umax_buf
));
231 /* Two cases to consider...
232 1) n_elide is small enough that we can afford to double-buffer:
233 allocate 2 * (READ_BUFSIZE + n_elide) bytes
234 2) n_elide is too big for that, so we allocate only
235 (READ_BUFSIZE + n_elide) bytes
237 FIXME: profile, to see if double-buffering is worthwhile
239 CAUTION: do not fail (out of memory) when asked to elide
240 a ridiculous amount, but when given only a small input. */
242 if (n_elide
<= HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
)
247 size_t n_to_read
= READ_BUFSIZE
+ n_elide
;
250 b
[0] = xnmalloc (2, n_to_read
);
251 b
[1] = b
[0] + n_to_read
;
253 for (i
= false; ! eof
; i
= !i
)
255 size_t n_read
= full_read (fd
, b
[i
], n_to_read
);
257 if (n_read
< n_to_read
)
261 error (0, errno
, _("error reading %s"), quote (filename
));
267 if (n_read
<= n_elide
)
271 /* The input is no larger than the number of bytes
272 to elide. So there's nothing to output, and
277 delta
= n_elide
- n_read
;
283 /* Output any (but maybe just part of the) elided data from
284 the previous round. */
287 /* Don't bother checking for errors here.
288 If there's a failure, the test of the following
289 fwrite or in close_stdout will catch it. */
290 fwrite (b
[!i
] + READ_BUFSIZE
, 1, n_elide
- delta
, stdout
);
295 && fwrite (b
[i
], 1, n_read
- n_elide
, stdout
) < n_read
- n_elide
)
297 error (0, errno
, _("write error"));
308 /* Read blocks of size READ_BUFSIZE, until we've read at least n_elide
309 bytes. Then, for each new buffer we read, also write an old one. */
314 bool buffered_enough
;
317 /* Round n_elide up to a multiple of READ_BUFSIZE. */
318 size_t rem
= READ_BUFSIZE
- (n_elide
% READ_BUFSIZE
);
319 size_t n_elide_round
= n_elide
+ rem
;
320 size_t n_bufs
= n_elide_round
/ READ_BUFSIZE
+ 1;
321 b
= xcalloc (n_bufs
, sizeof *b
);
323 buffered_enough
= false;
324 for (i
= 0, i_next
= 1; !eof
; i
= i_next
, i_next
= (i_next
+ 1) % n_bufs
)
327 b
[i
] = xmalloc (READ_BUFSIZE
);
328 n_read
= full_read (fd
, b
[i
], READ_BUFSIZE
);
329 if (n_read
< READ_BUFSIZE
)
333 error (0, errno
, _("error reading %s"), quote (filename
));
341 buffered_enough
= true;
345 if (fwrite (b
[i_next
], 1, n_read
, stdout
) < n_read
)
347 error (0, errno
, _("write error"));
354 /* Output any remainder: rem bytes from b[i] + n_read. */
359 size_t n_bytes_left_in_b_i
= READ_BUFSIZE
- n_read
;
360 if (rem
< n_bytes_left_in_b_i
)
362 fwrite (b
[i
] + n_read
, 1, rem
, stdout
);
366 fwrite (b
[i
] + n_read
, 1, n_bytes_left_in_b_i
, stdout
);
367 fwrite (b
[i_next
], 1, rem
- n_bytes_left_in_b_i
, stdout
);
370 else if (i
+ 1 == n_bufs
)
372 /* This happens when n_elide < file_size < n_elide_round.
376 |---------!---------!---------!---------|
377 |---- n_elide ---------|
380 |---- file size -----------|
382 |---- n_elide_round ----------|
384 size_t y
= READ_BUFSIZE
- rem
;
385 size_t x
= n_read
- y
;
386 fwrite (b
[i_next
], 1, x
, stdout
);
391 for (i
= 0; i
< n_bufs
; i
++)
399 /* Print all but the last N_ELIDE lines from the input available
400 via file descriptor FD. Return true upon success.
401 Give a diagnostic and return false upon error. */
403 /* NOTE: if the input file shrinks by more than N_ELIDE bytes between
404 the length determination and the actual reading, then head fails. */
407 elide_tail_bytes_file (const char *filename
, int fd
, uintmax_t n_elide
)
411 if (presume_input_pipe
|| fstat (fd
, &stats
) || ! S_ISREG (stats
.st_mode
))
413 return elide_tail_bytes_pipe (filename
, fd
, n_elide
);
417 off_t current_pos
, end_pos
;
418 uintmax_t bytes_remaining
;
420 enum Copy_fd_status err
;
422 if ((current_pos
= lseek (fd
, 0, SEEK_CUR
)) == -1
423 || (end_pos
= lseek (fd
, 0, SEEK_END
)) == -1)
425 error (0, errno
, _("cannot lseek %s"), quote (filename
));
429 /* Be careful here. The current position may actually be
430 beyond the end of the file. */
431 bytes_remaining
= (diff
= end_pos
- current_pos
) < 0 ? 0 : diff
;
433 if (bytes_remaining
<= n_elide
)
436 /* Seek back to 'current' position, then copy the required
437 number of bytes from fd. */
438 if (lseek (fd
, 0, current_pos
) == -1)
440 error (0, errno
, _("%s: cannot lseek back to original position"),
445 err
= copy_fd (fd
, stdout
, bytes_remaining
- n_elide
);
446 if (err
== COPY_FD_OK
)
449 diagnose_copy_fd_failure (err
, filename
);
454 /* Print all but the last N_ELIDE lines from the input stream
455 open for reading via file descriptor FD.
456 Buffer the specified number of lines as a linked list of LBUFFERs,
457 adding them as needed. Return true if successful. */
460 elide_tail_lines_pipe (const char *filename
, int fd
, uintmax_t n_elide
)
467 struct linebuffer
*next
;
469 typedef struct linebuffer LBUFFER
;
470 LBUFFER
*first
, *last
, *tmp
;
471 size_t total_lines
= 0; /* Total number of newlines in all buffers. */
473 size_t n_read
; /* Size in bytes of most recent read */
475 first
= last
= xmalloc (sizeof (LBUFFER
));
476 first
->nbytes
= first
->nlines
= 0;
478 tmp
= xmalloc (sizeof (LBUFFER
));
480 /* Always read into a fresh buffer.
481 Read, (producing no output) until we've accumulated at least
482 n_elide newlines, or until EOF, whichever comes first. */
485 n_read
= safe_read (fd
, tmp
->buffer
, BUFSIZ
);
486 if (n_read
== 0 || n_read
== SAFE_READ_ERROR
)
488 tmp
->nbytes
= n_read
;
492 /* Count the number of newlines just read. */
494 char const *buffer_end
= tmp
->buffer
+ n_read
;
495 char const *p
= tmp
->buffer
;
496 while ((p
= memchr (p
, '\n', buffer_end
- p
)))
502 total_lines
+= tmp
->nlines
;
504 /* If there is enough room in the last buffer read, just append the new
505 one to it. This is because when reading from a pipe, 'n_read' can
506 often be very small. */
507 if (tmp
->nbytes
+ last
->nbytes
< BUFSIZ
)
509 memcpy (&last
->buffer
[last
->nbytes
], tmp
->buffer
, tmp
->nbytes
);
510 last
->nbytes
+= tmp
->nbytes
;
511 last
->nlines
+= tmp
->nlines
;
515 /* If there's not enough room, link the new buffer onto the end of
516 the list, then either free up the oldest buffer for the next
517 read if that would leave enough lines, or else malloc a new one.
518 Some compaction mechanism is possible but probably not
520 last
= last
->next
= tmp
;
521 if (n_elide
< total_lines
- first
->nlines
)
523 fwrite (first
->buffer
, 1, first
->nbytes
, stdout
);
525 total_lines
-= first
->nlines
;
529 tmp
= xmalloc (sizeof (LBUFFER
));
535 if (n_read
== SAFE_READ_ERROR
)
537 error (0, errno
, _("error reading %s"), quote (filename
));
542 /* If we read any bytes at all, count the incomplete line
543 on files that don't end with a newline. */
544 if (last
->nbytes
&& last
->buffer
[last
->nbytes
- 1] != '\n')
550 for (tmp
= first
; n_elide
< total_lines
- tmp
->nlines
; tmp
= tmp
->next
)
552 fwrite (tmp
->buffer
, 1, tmp
->nbytes
, stdout
);
553 total_lines
-= tmp
->nlines
;
556 /* Print the first 'total_lines - n_elide' lines of tmp->buffer. */
557 if (n_elide
< total_lines
)
559 size_t n
= total_lines
- n_elide
;
560 char const *buffer_end
= tmp
->buffer
+ tmp
->nbytes
;
561 char const *p
= tmp
->buffer
;
562 while (n
&& (p
= memchr (p
, '\n', buffer_end
- p
)))
568 fwrite (tmp
->buffer
, 1, p
- tmp
->buffer
, stdout
);
581 /* Output all but the last N_LINES lines of the input stream defined by
582 FD, START_POS, and END_POS.
583 START_POS is the starting position of the read pointer for the file
584 associated with FD (may be nonzero).
585 END_POS is the file offset of EOF (one larger than offset of last byte).
586 Return true upon success.
587 Give a diagnostic and return false upon error.
589 NOTE: this code is very similar to that of tail.c's file_lines function.
590 Unfortunately, factoring out some common core looks like it'd result
591 in a less efficient implementation or a messy interface. */
593 elide_tail_lines_seekable (const char *pretty_filename
, int fd
,
595 off_t start_pos
, off_t end_pos
)
601 /* Set 'bytes_read' to the size of the last, probably partial, buffer;
602 0 < 'bytes_read' <= 'BUFSIZ'. */
603 bytes_read
= (pos
- start_pos
) % BUFSIZ
;
606 /* Make 'pos' a multiple of 'BUFSIZ' (0 if the file is short), so that all
607 reads will be on block boundaries, which might increase efficiency. */
609 if (lseek (fd
, pos
, SEEK_SET
) < 0)
611 char offset_buf
[INT_BUFSIZE_BOUND (pos
)];
612 error (0, errno
, _("%s: cannot seek to offset %s"),
613 pretty_filename
, offtostr (pos
, offset_buf
));
616 bytes_read
= safe_read (fd
, buffer
, bytes_read
);
617 if (bytes_read
== SAFE_READ_ERROR
)
619 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
623 /* Count the incomplete line on files that don't end with a newline. */
624 if (bytes_read
&& buffer
[bytes_read
- 1] != '\n')
629 /* Scan backward, counting the newlines in this bufferfull. */
631 size_t n
= bytes_read
;
635 nl
= memrchr (buffer
, '\n', n
);
642 /* If necessary, restore the file pointer and copy
643 input to output up to position, POS. */
646 enum Copy_fd_status err
;
647 if (lseek (fd
, start_pos
, SEEK_SET
) < 0)
649 /* Failed to reposition file pointer. */
651 "%s: unable to restore file pointer to initial offset",
652 quote (pretty_filename
));
656 err
= copy_fd (fd
, stdout
, pos
- start_pos
);
657 if (err
!= COPY_FD_OK
)
659 diagnose_copy_fd_failure (err
, pretty_filename
);
664 /* Output the initial portion of the buffer
665 in which we found the desired newline byte.
666 Don't bother testing for failure for such a small amount.
667 Any failure will be detected upon close. */
668 fwrite (buffer
, 1, n
+ 1, stdout
);
670 /* Set file pointer to the byte after what we've output. */
671 if (lseek (fd
, pos
+ n
+ 1, SEEK_SET
) < 0)
673 error (0, errno
, _("%s: failed to reset file pointer"),
674 quote (pretty_filename
));
681 /* Not enough newlines in that bufferfull. */
682 if (pos
== start_pos
)
684 /* Not enough lines in the file. */
688 if (lseek (fd
, pos
, SEEK_SET
) < 0)
690 char offset_buf
[INT_BUFSIZE_BOUND (pos
)];
691 error (0, errno
, _("%s: cannot seek to offset %s"),
692 pretty_filename
, offtostr (pos
, offset_buf
));
696 bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
697 if (bytes_read
== SAFE_READ_ERROR
)
699 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
703 /* FIXME: is this dead code?
704 Consider the test, pos == start_pos, above. */
710 /* Print all but the last N_ELIDE lines from the input available
711 via file descriptor FD. Return true upon success.
712 Give a diagnostic and return nonzero upon error. */
715 elide_tail_lines_file (const char *filename
, int fd
, uintmax_t n_elide
)
717 if (!presume_input_pipe
)
719 /* Find the offset, OFF, of the Nth newline from the end,
720 but not counting the last byte of the file.
721 If found, write from current position to OFF, inclusive.
722 Otherwise, just return true. */
724 off_t start_pos
= lseek (fd
, 0, SEEK_CUR
);
725 off_t end_pos
= lseek (fd
, 0, SEEK_END
);
726 if (0 <= start_pos
&& start_pos
< end_pos
)
728 /* If the file is empty, we're done. */
732 return elide_tail_lines_seekable (filename
, fd
, n_elide
,
736 /* lseek failed or the end offset precedes start.
740 return elide_tail_lines_pipe (filename
, fd
, n_elide
);
744 head_bytes (const char *filename
, int fd
, uintmax_t bytes_to_write
)
747 size_t bytes_to_read
= BUFSIZ
;
749 while (bytes_to_write
)
752 if (bytes_to_write
< bytes_to_read
)
753 bytes_to_read
= bytes_to_write
;
754 bytes_read
= safe_read (fd
, buffer
, bytes_to_read
);
755 if (bytes_read
== SAFE_READ_ERROR
)
757 error (0, errno
, _("error reading %s"), quote (filename
));
762 if (fwrite (buffer
, 1, bytes_read
, stdout
) < bytes_read
)
763 error (EXIT_FAILURE
, errno
, _("write error"));
764 bytes_to_write
-= bytes_read
;
770 head_lines (const char *filename
, int fd
, uintmax_t lines_to_write
)
774 while (lines_to_write
)
776 size_t bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
777 size_t bytes_to_write
= 0;
779 if (bytes_read
== SAFE_READ_ERROR
)
781 error (0, errno
, _("error reading %s"), quote (filename
));
786 while (bytes_to_write
< bytes_read
)
787 if (buffer
[bytes_to_write
++] == '\n' && --lines_to_write
== 0)
789 off_t n_bytes_past_EOL
= bytes_read
- bytes_to_write
;
790 /* If we have read more data than that on the specified number
791 of lines, try to seek back to the position we would have
792 gotten to had we been reading one byte at a time. */
793 if (lseek (fd
, -n_bytes_past_EOL
, SEEK_CUR
) < 0)
797 if (fstat (fd
, &st
) != 0 || S_ISREG (st
.st_mode
))
798 error (0, e
, _("cannot reposition file pointer for %s"),
803 if (fwrite (buffer
, 1, bytes_to_write
, stdout
) < bytes_to_write
)
804 error (EXIT_FAILURE
, errno
, _("write error"));
810 head (const char *filename
, int fd
, uintmax_t n_units
, bool count_lines
,
814 write_header (filename
);
820 return elide_tail_lines_file (filename
, fd
, n_units
);
824 return elide_tail_bytes_file (filename
, fd
, n_units
);
828 return head_lines (filename
, fd
, n_units
);
830 return head_bytes (filename
, fd
, n_units
);
834 head_file (const char *filename
, uintmax_t n_units
, bool count_lines
,
839 bool is_stdin
= STREQ (filename
, "-");
843 have_read_stdin
= true;
845 filename
= _("standard input");
846 if (O_BINARY
&& ! isatty (STDIN_FILENO
))
847 xfreopen (NULL
, "rb", stdin
);
851 fd
= open (filename
, O_RDONLY
| O_BINARY
);
854 error (0, errno
, _("cannot open %s for reading"), quote (filename
));
859 ok
= head (filename
, fd
, n_units
, count_lines
, elide_from_end
);
860 if (!is_stdin
&& close (fd
) != 0)
862 error (0, errno
, _("closing %s"), quote (filename
));
868 /* Convert a string of decimal digits, N_STRING, with an optional suffinx
869 to an integral value. Upon successful conversion,
870 return that value. If it cannot be converted, give a diagnostic and exit.
871 COUNT_LINES indicates whether N_STRING is a number of bytes or a number
872 of lines. It is used solely to give a more specific diagnostic. */
875 string_to_integer (bool count_lines
, const char *n_string
)
880 s_err
= xstrtoumax (n_string
, NULL
, 10, &n
, "bkKmMGTPEZY0");
882 if (s_err
== LONGINT_OVERFLOW
)
884 error (EXIT_FAILURE
, 0,
885 _("%s: %s is so large that it is not representable"), n_string
,
886 count_lines
? _("number of lines") : _("number of bytes"));
889 if (s_err
!= LONGINT_OK
)
891 error (EXIT_FAILURE
, 0, "%s: %s", n_string
,
893 ? _("invalid number of lines")
894 : _("invalid number of bytes")));
901 main (int argc
, char **argv
)
903 enum header_mode header_mode
= multiple_files
;
908 /* Number of items to print. */
909 uintmax_t n_units
= DEFAULT_NUMBER
;
911 /* If true, interpret the numeric argument as the number of lines.
912 Otherwise, interpret it as the number of bytes. */
913 bool count_lines
= true;
915 /* Elide the specified number of lines or bytes, counting from
916 the end of the file. */
917 bool elide_from_end
= false;
919 /* Initializer for file_list if no file-arguments
920 were specified on the command line. */
921 static char const *const default_file_list
[] = {"-", NULL
};
922 char const *const *file_list
;
924 initialize_main (&argc
, &argv
);
925 set_program_name (argv
[0]);
926 setlocale (LC_ALL
, "");
927 bindtextdomain (PACKAGE
, LOCALEDIR
);
928 textdomain (PACKAGE
);
930 atexit (close_stdout
);
932 have_read_stdin
= false;
934 print_headers
= false;
936 if (1 < argc
&& argv
[1][0] == '-' && ISDIGIT (argv
[1][1]))
939 char *n_string
= ++a
;
941 char multiplier_char
= 0;
943 /* Old option syntax; a dash, one or more digits, and one or
944 more option letters. Move past the number. */
946 while (ISDIGIT (*a
));
948 /* Pointer to the byte after the last digit. */
951 /* Parse any appended option letters. */
965 multiplier_char
= *a
;
977 header_mode
= always
;
981 error (0, 0, _("invalid trailing option -- %c"), *a
);
982 usage (EXIT_FAILURE
);
986 /* Append the multiplier character (if any) onto the end of
987 the digit string. Then add NUL byte if necessary. */
988 *end_n_string
= multiplier_char
;
990 *(++end_n_string
) = 0;
992 n_units
= string_to_integer (count_lines
, n_string
);
994 /* Make the options we just parsed invisible to getopt. */
1000 while ((c
= getopt_long (argc
, argv
, "c:n:qv0123456789", long_options
, NULL
))
1005 case PRESUME_INPUT_PIPE_OPTION
:
1006 presume_input_pipe
= true;
1010 count_lines
= false;
1011 elide_from_end
= (*optarg
== '-');
1014 n_units
= string_to_integer (count_lines
, optarg
);
1019 elide_from_end
= (*optarg
== '-');
1022 n_units
= string_to_integer (count_lines
, optarg
);
1026 header_mode
= never
;
1030 header_mode
= always
;
1033 case_GETOPT_HELP_CHAR
;
1035 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1039 error (0, 0, _("invalid trailing option -- %c"), c
);
1040 usage (EXIT_FAILURE
);
1044 if (header_mode
== always
1045 || (header_mode
== multiple_files
&& optind
< argc
- 1))
1046 print_headers
= true;
1048 if ( ! count_lines
&& elide_from_end
&& OFF_T_MAX
< n_units
)
1050 char umax_buf
[INT_BUFSIZE_BOUND (n_units
)];
1051 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
1052 umaxtostr (n_units
, umax_buf
));
1055 file_list
= (optind
< argc
1056 ? (char const *const *) &argv
[optind
]
1057 : default_file_list
);
1059 if (O_BINARY
&& ! isatty (STDOUT_FILENO
))
1060 xfreopen (NULL
, "wb", stdout
);
1062 for (i
= 0; file_list
[i
]; ++i
)
1063 ok
&= head_file (file_list
[i
], n_units
, count_lines
, elide_from_end
);
1065 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
1066 error (EXIT_FAILURE
, errno
, "-");
1068 exit (ok
? EXIT_SUCCESS
: EXIT_FAILURE
);