1 /* head -- output first part of file(s)
2 Copyright (C) 89, 90, 91, 1995-2006, 2008-2009 Free Software
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 /* Options: (see usage)
19 Reads from standard input if no files are given or when a filename of
21 By default, filename headers are printed only if more than one file
23 By default, prints the first 10 lines (head -n 10).
25 David MacKenzie <djm@gnu.ai.mit.edu> */
31 #include <sys/types.h>
36 #include "full-write.h"
37 #include "full-read.h"
39 #include "safe-read.h"
43 /* The official name of this program (e.g., no `g' prefix). */
44 #define PROGRAM_NAME "head"
47 proper_name ("David MacKenzie"), \
48 proper_name ("Jim Meyering")
50 /* Number of lines/chars/blocks to head. */
51 #define DEFAULT_NUMBER 10
53 /* Useful only when eliding tail bytes or lines.
54 If true, skip the is-regular-file test used to determine whether
55 to use the lseek optimization. Instead, use the more general (and
56 more expensive) code unconditionally. Intended solely for testing. */
57 static bool presume_input_pipe
;
59 /* If true, print filename headers. */
60 static bool print_headers
;
62 /* When to print the filename banners. */
65 multiple_files
, always
, never
68 /* Have we ever read standard input? */
69 static bool have_read_stdin
;
76 COPY_FD_UNEXPECTED_EOF
79 /* For long options that have no equivalent short option, use a
80 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
83 PRESUME_INPUT_PIPE_OPTION
= CHAR_MAX
+ 1
86 static struct option
const long_options
[] =
88 {"bytes", required_argument
, NULL
, 'c'},
89 {"lines", required_argument
, NULL
, 'n'},
90 {"-presume-input-pipe", no_argument
, NULL
,
91 PRESUME_INPUT_PIPE_OPTION
}, /* do not document */
92 {"quiet", no_argument
, NULL
, 'q'},
93 {"silent", no_argument
, NULL
, 'q'},
94 {"verbose", no_argument
, NULL
, 'v'},
95 {GETOPT_HELP_OPTION_DECL
},
96 {GETOPT_VERSION_OPTION_DECL
},
103 if (status
!= EXIT_SUCCESS
)
104 fprintf (stderr
, _("Try `%s --help' for more information.\n"),
109 Usage: %s [OPTION]... [FILE]...\n\
113 Print the first 10 lines of each FILE to standard output.\n\
114 With more than one FILE, precede each with a header giving the file name.\n\
115 With no FILE, or when FILE is -, read standard input.\n\
119 Mandatory arguments to long options are mandatory for short options too.\n\
122 -c, --bytes=[-]K print the first K bytes of each file;\n\
123 with the leading `-', print all but the last\n\
124 K bytes of each file\n\
125 -n, --lines=[-]K print the first K lines instead of the first 10;\n\
126 with the leading `-', print all but the last\n\
127 K lines of each file\n\
130 -q, --quiet, --silent never print headers giving file names\n\
131 -v, --verbose always print headers giving file names\n\
133 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
134 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
137 K may have a multiplier suffix:\n\
138 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
139 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
141 emit_bug_reporting_address ();
147 diagnose_copy_fd_failure (enum Copy_fd_status err
, char const *filename
)
151 case COPY_FD_READ_ERROR
:
152 error (0, errno
, _("error reading %s"), quote (filename
));
154 case COPY_FD_WRITE_ERROR
:
155 error (0, errno
, _("error writing %s"), quote (filename
));
157 case COPY_FD_UNEXPECTED_EOF
:
158 error (0, errno
, _("%s: file has shrunk too much"), quote (filename
));
166 write_header (const char *filename
)
168 static bool first_file
= true;
170 printf ("%s==> %s <==\n", (first_file
? "" : "\n"), filename
);
174 /* Copy no more than N_BYTES from file descriptor SRC_FD to O_STREAM.
175 Return an appropriate indication of success or failure. */
177 static enum Copy_fd_status
178 copy_fd (int src_fd
, FILE *o_stream
, uintmax_t n_bytes
)
181 const size_t buf_size
= sizeof (buf
);
183 /* Copy the file contents. */
186 size_t n_to_read
= MIN (buf_size
, n_bytes
);
187 size_t n_read
= safe_read (src_fd
, buf
, n_to_read
);
188 if (n_read
== SAFE_READ_ERROR
)
189 return COPY_FD_READ_ERROR
;
193 if (n_read
== 0 && n_bytes
!= 0)
194 return COPY_FD_UNEXPECTED_EOF
;
196 if (fwrite (buf
, 1, n_read
, o_stream
) < n_read
)
197 return COPY_FD_WRITE_ERROR
;
203 /* Print all but the last N_ELIDE lines from the input available via
204 the non-seekable file descriptor FD. Return true upon success.
205 Give a diagnostic and return false upon error. */
207 elide_tail_bytes_pipe (const char *filename
, int fd
, uintmax_t n_elide_0
)
209 size_t n_elide
= n_elide_0
;
211 #ifndef HEAD_TAIL_PIPE_READ_BUFSIZE
212 # define HEAD_TAIL_PIPE_READ_BUFSIZE BUFSIZ
214 #define READ_BUFSIZE HEAD_TAIL_PIPE_READ_BUFSIZE
216 /* If we're eliding no more than this many bytes, then it's ok to allocate
217 more memory in order to use a more time-efficient algorithm.
218 FIXME: use a fraction of available memory instead, as in sort.
219 FIXME: is this even worthwhile? */
220 #ifndef HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
221 # define HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD 1024 * 1024
224 #if HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD < 2 * READ_BUFSIZE
225 "HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD must be at least 2 * READ_BUFSIZE"
228 if (SIZE_MAX
< n_elide_0
+ READ_BUFSIZE
)
230 char umax_buf
[INT_BUFSIZE_BOUND (uintmax_t)];
231 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
232 umaxtostr (n_elide_0
, umax_buf
));
235 /* Two cases to consider...
236 1) n_elide is small enough that we can afford to double-buffer:
237 allocate 2 * (READ_BUFSIZE + n_elide) bytes
238 2) n_elide is too big for that, so we allocate only
239 (READ_BUFSIZE + n_elide) bytes
241 FIXME: profile, to see if double-buffering is worthwhile
243 CAUTION: do not fail (out of memory) when asked to elide
244 a ridiculous amount, but when given only a small input. */
246 if (n_elide
<= HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
)
251 size_t n_to_read
= READ_BUFSIZE
+ n_elide
;
254 b
[0] = xnmalloc (2, n_to_read
);
255 b
[1] = b
[0] + n_to_read
;
257 for (i
= false; ! eof
; i
= !i
)
259 size_t n_read
= full_read (fd
, b
[i
], n_to_read
);
261 if (n_read
< n_to_read
)
265 error (0, errno
, _("error reading %s"), quote (filename
));
271 if (n_read
<= n_elide
)
275 /* The input is no larger than the number of bytes
276 to elide. So there's nothing to output, and
281 delta
= n_elide
- n_read
;
287 /* Output any (but maybe just part of the) elided data from
288 the previous round. */
291 /* Don't bother checking for errors here.
292 If there's a failure, the test of the following
293 fwrite or in close_stdout will catch it. */
294 fwrite (b
[!i
] + READ_BUFSIZE
, 1, n_elide
- delta
, stdout
);
299 && fwrite (b
[i
], 1, n_read
- n_elide
, stdout
) < n_read
- n_elide
)
301 error (0, errno
, _("write error"));
312 /* Read blocks of size READ_BUFSIZE, until we've read at least n_elide
313 bytes. Then, for each new buffer we read, also write an old one. */
318 bool buffered_enough
;
321 /* Round n_elide up to a multiple of READ_BUFSIZE. */
322 size_t rem
= READ_BUFSIZE
- (n_elide
% READ_BUFSIZE
);
323 size_t n_elide_round
= n_elide
+ rem
;
324 size_t n_bufs
= n_elide_round
/ READ_BUFSIZE
+ 1;
325 b
= xcalloc (n_bufs
, sizeof *b
);
327 buffered_enough
= false;
328 for (i
= 0, i_next
= 1; !eof
; i
= i_next
, i_next
= (i_next
+ 1) % n_bufs
)
331 b
[i
] = xmalloc (READ_BUFSIZE
);
332 n_read
= full_read (fd
, b
[i
], READ_BUFSIZE
);
333 if (n_read
< READ_BUFSIZE
)
337 error (0, errno
, _("error reading %s"), quote (filename
));
345 buffered_enough
= true;
349 if (fwrite (b
[i_next
], 1, n_read
, stdout
) < n_read
)
351 error (0, errno
, _("write error"));
358 /* Output any remainder: rem bytes from b[i] + n_read. */
363 size_t n_bytes_left_in_b_i
= READ_BUFSIZE
- n_read
;
364 if (rem
< n_bytes_left_in_b_i
)
366 fwrite (b
[i
] + n_read
, 1, rem
, stdout
);
370 fwrite (b
[i
] + n_read
, 1, n_bytes_left_in_b_i
, stdout
);
371 fwrite (b
[i_next
], 1, rem
- n_bytes_left_in_b_i
, stdout
);
374 else if (i
+ 1 == n_bufs
)
376 /* This happens when n_elide < file_size < n_elide_round.
380 |---------!---------!---------!---------|
381 |---- n_elide ---------|
384 |---- file size -----------|
386 |---- n_elide_round ----------|
388 size_t y
= READ_BUFSIZE
- rem
;
389 size_t x
= n_read
- y
;
390 fwrite (b
[i_next
], 1, x
, stdout
);
395 for (i
= 0; i
< n_bufs
; i
++)
403 /* Print all but the last N_ELIDE lines from the input available
404 via file descriptor FD. Return true upon success.
405 Give a diagnostic and return false upon error. */
407 /* NOTE: if the input file shrinks by more than N_ELIDE bytes between
408 the length determination and the actual reading, then head fails. */
411 elide_tail_bytes_file (const char *filename
, int fd
, uintmax_t n_elide
)
415 if (presume_input_pipe
|| fstat (fd
, &stats
) || ! S_ISREG (stats
.st_mode
))
417 return elide_tail_bytes_pipe (filename
, fd
, n_elide
);
421 off_t current_pos
, end_pos
;
422 uintmax_t bytes_remaining
;
424 enum Copy_fd_status err
;
426 if ((current_pos
= lseek (fd
, (off_t
) 0, SEEK_CUR
)) == -1
427 || (end_pos
= lseek (fd
, (off_t
) 0, SEEK_END
)) == -1)
429 error (0, errno
, _("cannot lseek %s"), quote (filename
));
433 /* Be careful here. The current position may actually be
434 beyond the end of the file. */
435 bytes_remaining
= (diff
= end_pos
- current_pos
) < 0 ? 0 : diff
;
437 if (bytes_remaining
<= n_elide
)
440 /* Seek back to `current' position, then copy the required
441 number of bytes from fd. */
442 if (lseek (fd
, (off_t
) 0, current_pos
) == -1)
444 error (0, errno
, _("%s: cannot lseek back to original position"),
449 err
= copy_fd (fd
, stdout
, bytes_remaining
- n_elide
);
450 if (err
== COPY_FD_OK
)
453 diagnose_copy_fd_failure (err
, filename
);
458 /* Print all but the last N_ELIDE lines from the input stream
459 open for reading via file descriptor FD.
460 Buffer the specified number of lines as a linked list of LBUFFERs,
461 adding them as needed. Return true if successful. */
464 elide_tail_lines_pipe (const char *filename
, int fd
, uintmax_t n_elide
)
471 struct linebuffer
*next
;
473 typedef struct linebuffer LBUFFER
;
474 LBUFFER
*first
, *last
, *tmp
;
475 size_t total_lines
= 0; /* Total number of newlines in all buffers. */
477 size_t n_read
; /* Size in bytes of most recent read */
479 first
= last
= xmalloc (sizeof (LBUFFER
));
480 first
->nbytes
= first
->nlines
= 0;
482 tmp
= xmalloc (sizeof (LBUFFER
));
484 /* Always read into a fresh buffer.
485 Read, (producing no output) until we've accumulated at least
486 n_elide newlines, or until EOF, whichever comes first. */
489 n_read
= safe_read (fd
, tmp
->buffer
, BUFSIZ
);
490 if (n_read
== 0 || n_read
== SAFE_READ_ERROR
)
492 tmp
->nbytes
= n_read
;
496 /* Count the number of newlines just read. */
498 char const *buffer_end
= tmp
->buffer
+ n_read
;
499 char const *p
= tmp
->buffer
;
500 while ((p
= memchr (p
, '\n', buffer_end
- p
)))
506 total_lines
+= tmp
->nlines
;
508 /* If there is enough room in the last buffer read, just append the new
509 one to it. This is because when reading from a pipe, `n_read' can
510 often be very small. */
511 if (tmp
->nbytes
+ last
->nbytes
< BUFSIZ
)
513 memcpy (&last
->buffer
[last
->nbytes
], tmp
->buffer
, tmp
->nbytes
);
514 last
->nbytes
+= tmp
->nbytes
;
515 last
->nlines
+= tmp
->nlines
;
519 /* If there's not enough room, link the new buffer onto the end of
520 the list, then either free up the oldest buffer for the next
521 read if that would leave enough lines, or else malloc a new one.
522 Some compaction mechanism is possible but probably not
524 last
= last
->next
= tmp
;
525 if (n_elide
< total_lines
- first
->nlines
)
527 fwrite (first
->buffer
, 1, first
->nbytes
, stdout
);
529 total_lines
-= first
->nlines
;
533 tmp
= xmalloc (sizeof (LBUFFER
));
539 if (n_read
== SAFE_READ_ERROR
)
541 error (0, errno
, _("error reading %s"), quote (filename
));
546 /* If we read any bytes at all, count the incomplete line
547 on files that don't end with a newline. */
548 if (last
->nbytes
&& last
->buffer
[last
->nbytes
- 1] != '\n')
554 for (tmp
= first
; n_elide
< total_lines
- tmp
->nlines
; tmp
= tmp
->next
)
556 fwrite (tmp
->buffer
, 1, tmp
->nbytes
, stdout
);
557 total_lines
-= tmp
->nlines
;
560 /* Print the first `total_lines - n_elide' lines of tmp->buffer. */
561 if (n_elide
< total_lines
)
563 size_t n
= total_lines
- n_elide
;
564 char const *buffer_end
= tmp
->buffer
+ tmp
->nbytes
;
565 char const *p
= tmp
->buffer
;
566 while (n
&& (p
= memchr (p
, '\n', buffer_end
- p
)))
572 fwrite (tmp
->buffer
, 1, p
- tmp
->buffer
, stdout
);
585 /* Output all but the last N_LINES lines of the input stream defined by
586 FD, START_POS, and END_POS.
587 START_POS is the starting position of the read pointer for the file
588 associated with FD (may be nonzero).
589 END_POS is the file offset of EOF (one larger than offset of last byte).
590 Return true upon success.
591 Give a diagnostic and return false upon error.
593 NOTE: this code is very similar to that of tail.c's file_lines function.
594 Unfortunately, factoring out some common core looks like it'd result
595 in a less efficient implementation or a messy interface. */
597 elide_tail_lines_seekable (const char *pretty_filename
, int fd
,
599 off_t start_pos
, off_t end_pos
)
605 /* Set `bytes_read' to the size of the last, probably partial, buffer;
606 0 < `bytes_read' <= `BUFSIZ'. */
607 bytes_read
= (pos
- start_pos
) % BUFSIZ
;
610 /* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
611 reads will be on block boundaries, which might increase efficiency. */
613 if (lseek (fd
, pos
, SEEK_SET
) < 0)
615 char offset_buf
[INT_BUFSIZE_BOUND (off_t
)];
616 error (0, errno
, _("%s: cannot seek to offset %s"),
617 pretty_filename
, offtostr (pos
, offset_buf
));
620 bytes_read
= safe_read (fd
, buffer
, bytes_read
);
621 if (bytes_read
== SAFE_READ_ERROR
)
623 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
627 /* Count the incomplete line on files that don't end with a newline. */
628 if (bytes_read
&& buffer
[bytes_read
- 1] != '\n')
633 /* Scan backward, counting the newlines in this bufferfull. */
635 size_t n
= bytes_read
;
639 nl
= memrchr (buffer
, '\n', n
);
646 /* If necessary, restore the file pointer and copy
647 input to output up to position, POS. */
650 enum Copy_fd_status err
;
651 if (lseek (fd
, start_pos
, SEEK_SET
) < 0)
653 /* Failed to reposition file pointer. */
655 "%s: unable to restore file pointer to initial offset",
656 quote (pretty_filename
));
660 err
= copy_fd (fd
, stdout
, pos
- start_pos
);
661 if (err
!= COPY_FD_OK
)
663 diagnose_copy_fd_failure (err
, pretty_filename
);
668 /* Output the initial portion of the buffer
669 in which we found the desired newline byte.
670 Don't bother testing for failure for such a small amount.
671 Any failure will be detected upon close. */
672 fwrite (buffer
, 1, n
+ 1, stdout
);
677 /* Not enough newlines in that bufferfull. */
678 if (pos
== start_pos
)
680 /* Not enough lines in the file. */
684 if (lseek (fd
, pos
, SEEK_SET
) < 0)
686 char offset_buf
[INT_BUFSIZE_BOUND (off_t
)];
687 error (0, errno
, _("%s: cannot seek to offset %s"),
688 pretty_filename
, offtostr (pos
, offset_buf
));
692 bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
693 if (bytes_read
== SAFE_READ_ERROR
)
695 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
699 /* FIXME: is this dead code?
700 Consider the test, pos == start_pos, above. */
706 /* Print all but the last N_ELIDE lines from the input available
707 via file descriptor FD. Return true upon success.
708 Give a diagnostic and return nonzero upon error. */
711 elide_tail_lines_file (const char *filename
, int fd
, uintmax_t n_elide
)
713 if (!presume_input_pipe
)
715 /* Find the offset, OFF, of the Nth newline from the end,
716 but not counting the last byte of the file.
717 If found, write from current position to OFF, inclusive.
718 Otherwise, just return true. */
720 off_t start_pos
= lseek (fd
, (off_t
) 0, SEEK_CUR
);
721 off_t end_pos
= lseek (fd
, (off_t
) 0, SEEK_END
);
722 if (0 <= start_pos
&& start_pos
< end_pos
)
724 /* If the file is empty, we're done. */
728 return elide_tail_lines_seekable (filename
, fd
, n_elide
,
732 /* lseek failed or the end offset precedes start.
736 return elide_tail_lines_pipe (filename
, fd
, n_elide
);
740 head_bytes (const char *filename
, int fd
, uintmax_t bytes_to_write
)
743 size_t bytes_to_read
= BUFSIZ
;
745 while (bytes_to_write
)
748 if (bytes_to_write
< bytes_to_read
)
749 bytes_to_read
= bytes_to_write
;
750 bytes_read
= safe_read (fd
, buffer
, bytes_to_read
);
751 if (bytes_read
== SAFE_READ_ERROR
)
753 error (0, errno
, _("error reading %s"), quote (filename
));
758 if (fwrite (buffer
, 1, bytes_read
, stdout
) < bytes_read
)
759 error (EXIT_FAILURE
, errno
, _("write error"));
760 bytes_to_write
-= bytes_read
;
766 head_lines (const char *filename
, int fd
, uintmax_t lines_to_write
)
770 while (lines_to_write
)
772 size_t bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
773 size_t bytes_to_write
= 0;
775 if (bytes_read
== SAFE_READ_ERROR
)
777 error (0, errno
, _("error reading %s"), quote (filename
));
782 while (bytes_to_write
< bytes_read
)
783 if (buffer
[bytes_to_write
++] == '\n' && --lines_to_write
== 0)
785 off_t n_bytes_past_EOL
= bytes_read
- bytes_to_write
;
786 /* If we have read more data than that on the specified number
787 of lines, try to seek back to the position we would have
788 gotten to had we been reading one byte at a time. */
789 if (lseek (fd
, -n_bytes_past_EOL
, SEEK_CUR
) < 0)
793 if (fstat (fd
, &st
) != 0 || S_ISREG (st
.st_mode
))
794 error (0, e
, _("cannot reposition file pointer for %s"),
799 if (fwrite (buffer
, 1, bytes_to_write
, stdout
) < bytes_to_write
)
800 error (EXIT_FAILURE
, errno
, _("write error"));
806 head (const char *filename
, int fd
, uintmax_t n_units
, bool count_lines
,
810 write_header (filename
);
816 return elide_tail_lines_file (filename
, fd
, n_units
);
820 return elide_tail_bytes_file (filename
, fd
, n_units
);
824 return head_lines (filename
, fd
, n_units
);
826 return head_bytes (filename
, fd
, n_units
);
830 head_file (const char *filename
, uintmax_t n_units
, bool count_lines
,
835 bool is_stdin
= STREQ (filename
, "-");
839 have_read_stdin
= true;
841 filename
= _("standard input");
842 if (O_BINARY
&& ! isatty (STDIN_FILENO
))
843 xfreopen (NULL
, "rb", stdin
);
847 fd
= open (filename
, O_RDONLY
| O_BINARY
);
850 error (0, errno
, _("cannot open %s for reading"), quote (filename
));
855 ok
= head (filename
, fd
, n_units
, count_lines
, elide_from_end
);
856 if (!is_stdin
&& close (fd
) != 0)
858 error (0, errno
, _("closing %s"), quote (filename
));
864 /* Convert a string of decimal digits, N_STRING, with an optional suffinx
865 to an integral value. Upon successful conversion,
866 return that value. If it cannot be converted, give a diagnostic and exit.
867 COUNT_LINES indicates whether N_STRING is a number of bytes or a number
868 of lines. It is used solely to give a more specific diagnostic. */
871 string_to_integer (bool count_lines
, const char *n_string
)
876 s_err
= xstrtoumax (n_string
, NULL
, 10, &n
, "bkKmMGTPEZY0");
878 if (s_err
== LONGINT_OVERFLOW
)
880 error (EXIT_FAILURE
, 0,
881 _("%s: %s is so large that it is not representable"), n_string
,
882 count_lines
? _("number of lines") : _("number of bytes"));
885 if (s_err
!= LONGINT_OK
)
887 error (EXIT_FAILURE
, 0, "%s: %s", n_string
,
889 ? _("invalid number of lines")
890 : _("invalid number of bytes")));
897 main (int argc
, char **argv
)
899 enum header_mode header_mode
= multiple_files
;
904 /* Number of items to print. */
905 uintmax_t n_units
= DEFAULT_NUMBER
;
907 /* If true, interpret the numeric argument as the number of lines.
908 Otherwise, interpret it as the number of bytes. */
909 bool count_lines
= true;
911 /* Elide the specified number of lines or bytes, counting from
912 the end of the file. */
913 bool elide_from_end
= false;
915 /* Initializer for file_list if no file-arguments
916 were specified on the command line. */
917 static char const *const default_file_list
[] = {"-", NULL
};
918 char const *const *file_list
;
920 initialize_main (&argc
, &argv
);
921 set_program_name (argv
[0]);
922 setlocale (LC_ALL
, "");
923 bindtextdomain (PACKAGE
, LOCALEDIR
);
924 textdomain (PACKAGE
);
926 atexit (close_stdout
);
928 have_read_stdin
= false;
930 print_headers
= false;
932 if (1 < argc
&& argv
[1][0] == '-' && ISDIGIT (argv
[1][1]))
935 char *n_string
= ++a
;
937 char multiplier_char
= 0;
939 /* Old option syntax; a dash, one or more digits, and one or
940 more option letters. Move past the number. */
942 while (ISDIGIT (*a
));
944 /* Pointer to the byte after the last digit. */
947 /* Parse any appended option letters. */
961 multiplier_char
= *a
;
973 header_mode
= always
;
977 error (0, 0, _("invalid trailing option -- %c"), *a
);
978 usage (EXIT_FAILURE
);
982 /* Append the multiplier character (if any) onto the end of
983 the digit string. Then add NUL byte if necessary. */
984 *end_n_string
= multiplier_char
;
986 *(++end_n_string
) = 0;
988 n_units
= string_to_integer (count_lines
, n_string
);
990 /* Make the options we just parsed invisible to getopt. */
996 while ((c
= getopt_long (argc
, argv
, "c:n:qv0123456789", long_options
, NULL
))
1001 case PRESUME_INPUT_PIPE_OPTION
:
1002 presume_input_pipe
= true;
1006 count_lines
= false;
1007 elide_from_end
= (*optarg
== '-');
1010 n_units
= string_to_integer (count_lines
, optarg
);
1015 elide_from_end
= (*optarg
== '-');
1018 n_units
= string_to_integer (count_lines
, optarg
);
1022 header_mode
= never
;
1026 header_mode
= always
;
1029 case_GETOPT_HELP_CHAR
;
1031 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1035 error (0, 0, _("invalid trailing option -- %c"), c
);
1036 usage (EXIT_FAILURE
);
1040 if (header_mode
== always
1041 || (header_mode
== multiple_files
&& optind
< argc
- 1))
1042 print_headers
= true;
1044 if ( ! count_lines
&& elide_from_end
&& OFF_T_MAX
< n_units
)
1046 char umax_buf
[INT_BUFSIZE_BOUND (uintmax_t)];
1047 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
1048 umaxtostr (n_units
, umax_buf
));
1051 file_list
= (optind
< argc
1052 ? (char const *const *) &argv
[optind
]
1053 : default_file_list
);
1055 if (O_BINARY
&& ! isatty (STDOUT_FILENO
))
1056 xfreopen (NULL
, "wb", stdout
);
1058 for (i
= 0; file_list
[i
]; ++i
)
1059 ok
&= head_file (file_list
[i
], n_units
, count_lines
, elide_from_end
);
1061 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
1062 error (EXIT_FAILURE
, errno
, "-");
1064 exit (ok
? EXIT_SUCCESS
: EXIT_FAILURE
);