1 /* head -- output first part of file(s)
2 Copyright (C) 1989-1991, 1995-2006, 2008-2012 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\
116 Mandatory arguments to long options are mandatory for short options too.\n\
119 -c, --bytes=[-]K print the first K bytes of each file;\n\
120 with the leading '-', print all but the last\n\
121 K bytes of each file\n\
122 -n, --lines=[-]K print the first K lines instead of the first 10;\n\
123 with the leading '-', print all but the last\n\
124 K lines of each file\n\
127 -q, --quiet, --silent never print headers giving file names\n\
128 -v, --verbose always print headers giving file names\n\
130 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
131 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
134 K may have a multiplier suffix:\n\
135 b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
136 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
138 emit_ancillary_info ();
144 diagnose_copy_fd_failure (enum Copy_fd_status err
, char const *filename
)
148 case COPY_FD_READ_ERROR
:
149 error (0, errno
, _("error reading %s"), quote (filename
));
151 case COPY_FD_WRITE_ERROR
:
152 error (0, errno
, _("error writing %s"), quote (filename
));
154 case COPY_FD_UNEXPECTED_EOF
:
155 error (0, errno
, _("%s: file has shrunk too much"), quote (filename
));
163 write_header (const char *filename
)
165 static bool first_file
= true;
167 printf ("%s==> %s <==\n", (first_file
? "" : "\n"), filename
);
171 /* Copy no more than N_BYTES from file descriptor SRC_FD to O_STREAM.
172 Return an appropriate indication of success or failure. */
174 static enum Copy_fd_status
175 copy_fd (int src_fd
, FILE *o_stream
, uintmax_t n_bytes
)
178 const size_t buf_size
= sizeof (buf
);
180 /* Copy the file contents. */
183 size_t n_to_read
= MIN (buf_size
, n_bytes
);
184 size_t n_read
= safe_read (src_fd
, buf
, n_to_read
);
185 if (n_read
== SAFE_READ_ERROR
)
186 return COPY_FD_READ_ERROR
;
190 if (n_read
== 0 && n_bytes
!= 0)
191 return COPY_FD_UNEXPECTED_EOF
;
193 if (fwrite (buf
, 1, n_read
, o_stream
) < n_read
)
194 return COPY_FD_WRITE_ERROR
;
200 /* Print all but the last N_ELIDE lines from the input available via
201 the non-seekable file descriptor FD. Return true upon success.
202 Give a diagnostic and return false upon error. */
204 elide_tail_bytes_pipe (const char *filename
, int fd
, uintmax_t n_elide_0
)
206 size_t n_elide
= n_elide_0
;
208 #ifndef HEAD_TAIL_PIPE_READ_BUFSIZE
209 # define HEAD_TAIL_PIPE_READ_BUFSIZE BUFSIZ
211 #define READ_BUFSIZE HEAD_TAIL_PIPE_READ_BUFSIZE
213 /* If we're eliding no more than this many bytes, then it's ok to allocate
214 more memory in order to use a more time-efficient algorithm.
215 FIXME: use a fraction of available memory instead, as in sort.
216 FIXME: is this even worthwhile? */
217 #ifndef HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
218 # define HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD 1024 * 1024
221 #if HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD < 2 * READ_BUFSIZE
222 "HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD must be at least 2 * READ_BUFSIZE"
225 if (SIZE_MAX
< n_elide_0
+ READ_BUFSIZE
)
227 char umax_buf
[INT_BUFSIZE_BOUND (n_elide_0
)];
228 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
229 umaxtostr (n_elide_0
, umax_buf
));
232 /* Two cases to consider...
233 1) n_elide is small enough that we can afford to double-buffer:
234 allocate 2 * (READ_BUFSIZE + n_elide) bytes
235 2) n_elide is too big for that, so we allocate only
236 (READ_BUFSIZE + n_elide) bytes
238 FIXME: profile, to see if double-buffering is worthwhile
240 CAUTION: do not fail (out of memory) when asked to elide
241 a ridiculous amount, but when given only a small input. */
243 if (n_elide
<= HEAD_TAIL_PIPE_BYTECOUNT_THRESHOLD
)
248 size_t n_to_read
= READ_BUFSIZE
+ n_elide
;
251 b
[0] = xnmalloc (2, n_to_read
);
252 b
[1] = b
[0] + n_to_read
;
254 for (i
= false; ! eof
; i
= !i
)
256 size_t n_read
= full_read (fd
, b
[i
], n_to_read
);
258 if (n_read
< n_to_read
)
262 error (0, errno
, _("error reading %s"), quote (filename
));
268 if (n_read
<= n_elide
)
272 /* The input is no larger than the number of bytes
273 to elide. So there's nothing to output, and
278 delta
= n_elide
- n_read
;
284 /* Output any (but maybe just part of the) elided data from
285 the previous round. */
288 /* Don't bother checking for errors here.
289 If there's a failure, the test of the following
290 fwrite or in close_stdout will catch it. */
291 fwrite (b
[!i
] + READ_BUFSIZE
, 1, n_elide
- delta
, stdout
);
296 && fwrite (b
[i
], 1, n_read
- n_elide
, stdout
) < n_read
- n_elide
)
298 error (0, errno
, _("write error"));
309 /* Read blocks of size READ_BUFSIZE, until we've read at least n_elide
310 bytes. Then, for each new buffer we read, also write an old one. */
315 bool buffered_enough
;
318 /* Round n_elide up to a multiple of READ_BUFSIZE. */
319 size_t rem
= READ_BUFSIZE
- (n_elide
% READ_BUFSIZE
);
320 size_t n_elide_round
= n_elide
+ rem
;
321 size_t n_bufs
= n_elide_round
/ READ_BUFSIZE
+ 1;
322 b
= xcalloc (n_bufs
, sizeof *b
);
324 buffered_enough
= false;
325 for (i
= 0, i_next
= 1; !eof
; i
= i_next
, i_next
= (i_next
+ 1) % n_bufs
)
328 b
[i
] = xmalloc (READ_BUFSIZE
);
329 n_read
= full_read (fd
, b
[i
], READ_BUFSIZE
);
330 if (n_read
< READ_BUFSIZE
)
334 error (0, errno
, _("error reading %s"), quote (filename
));
342 buffered_enough
= true;
346 if (fwrite (b
[i_next
], 1, n_read
, stdout
) < n_read
)
348 error (0, errno
, _("write error"));
355 /* Output any remainder: rem bytes from b[i] + n_read. */
360 size_t n_bytes_left_in_b_i
= READ_BUFSIZE
- n_read
;
361 if (rem
< n_bytes_left_in_b_i
)
363 fwrite (b
[i
] + n_read
, 1, rem
, stdout
);
367 fwrite (b
[i
] + n_read
, 1, n_bytes_left_in_b_i
, stdout
);
368 fwrite (b
[i_next
], 1, rem
- n_bytes_left_in_b_i
, stdout
);
371 else if (i
+ 1 == n_bufs
)
373 /* This happens when n_elide < file_size < n_elide_round.
377 |---------!---------!---------!---------|
378 |---- n_elide ---------|
381 |---- file size -----------|
383 |---- n_elide_round ----------|
385 size_t y
= READ_BUFSIZE
- rem
;
386 size_t x
= n_read
- y
;
387 fwrite (b
[i_next
], 1, x
, stdout
);
392 for (i
= 0; i
< n_bufs
; i
++)
400 /* Print all but the last N_ELIDE lines from the input available
401 via file descriptor FD. Return true upon success.
402 Give a diagnostic and return false upon error. */
404 /* NOTE: if the input file shrinks by more than N_ELIDE bytes between
405 the length determination and the actual reading, then head fails. */
408 elide_tail_bytes_file (const char *filename
, int fd
, uintmax_t n_elide
)
412 if (presume_input_pipe
|| fstat (fd
, &stats
) || ! S_ISREG (stats
.st_mode
))
414 return elide_tail_bytes_pipe (filename
, fd
, n_elide
);
418 off_t current_pos
, end_pos
;
419 uintmax_t bytes_remaining
;
421 enum Copy_fd_status err
;
423 if ((current_pos
= lseek (fd
, 0, SEEK_CUR
)) == -1
424 || (end_pos
= lseek (fd
, 0, SEEK_END
)) == -1)
426 error (0, errno
, _("cannot lseek %s"), quote (filename
));
430 /* Be careful here. The current position may actually be
431 beyond the end of the file. */
432 bytes_remaining
= (diff
= end_pos
- current_pos
) < 0 ? 0 : diff
;
434 if (bytes_remaining
<= n_elide
)
437 /* Seek back to 'current' position, then copy the required
438 number of bytes from fd. */
439 if (lseek (fd
, 0, current_pos
) == -1)
441 error (0, errno
, _("%s: cannot lseek back to original position"),
446 err
= copy_fd (fd
, stdout
, bytes_remaining
- n_elide
);
447 if (err
== COPY_FD_OK
)
450 diagnose_copy_fd_failure (err
, filename
);
455 /* Print all but the last N_ELIDE lines from the input stream
456 open for reading via file descriptor FD.
457 Buffer the specified number of lines as a linked list of LBUFFERs,
458 adding them as needed. Return true if successful. */
461 elide_tail_lines_pipe (const char *filename
, int fd
, uintmax_t n_elide
)
468 struct linebuffer
*next
;
470 typedef struct linebuffer LBUFFER
;
471 LBUFFER
*first
, *last
, *tmp
;
472 size_t total_lines
= 0; /* Total number of newlines in all buffers. */
474 size_t n_read
; /* Size in bytes of most recent read */
476 first
= last
= xmalloc (sizeof (LBUFFER
));
477 first
->nbytes
= first
->nlines
= 0;
479 tmp
= xmalloc (sizeof (LBUFFER
));
481 /* Always read into a fresh buffer.
482 Read, (producing no output) until we've accumulated at least
483 n_elide newlines, or until EOF, whichever comes first. */
486 n_read
= safe_read (fd
, tmp
->buffer
, BUFSIZ
);
487 if (n_read
== 0 || n_read
== SAFE_READ_ERROR
)
489 tmp
->nbytes
= n_read
;
493 /* Count the number of newlines just read. */
495 char const *buffer_end
= tmp
->buffer
+ n_read
;
496 char const *p
= tmp
->buffer
;
497 while ((p
= memchr (p
, '\n', buffer_end
- p
)))
503 total_lines
+= tmp
->nlines
;
505 /* If there is enough room in the last buffer read, just append the new
506 one to it. This is because when reading from a pipe, 'n_read' can
507 often be very small. */
508 if (tmp
->nbytes
+ last
->nbytes
< BUFSIZ
)
510 memcpy (&last
->buffer
[last
->nbytes
], tmp
->buffer
, tmp
->nbytes
);
511 last
->nbytes
+= tmp
->nbytes
;
512 last
->nlines
+= tmp
->nlines
;
516 /* If there's not enough room, link the new buffer onto the end of
517 the list, then either free up the oldest buffer for the next
518 read if that would leave enough lines, or else malloc a new one.
519 Some compaction mechanism is possible but probably not
521 last
= last
->next
= tmp
;
522 if (n_elide
< total_lines
- first
->nlines
)
524 fwrite (first
->buffer
, 1, first
->nbytes
, stdout
);
526 total_lines
-= first
->nlines
;
530 tmp
= xmalloc (sizeof (LBUFFER
));
536 if (n_read
== SAFE_READ_ERROR
)
538 error (0, errno
, _("error reading %s"), quote (filename
));
543 /* If we read any bytes at all, count the incomplete line
544 on files that don't end with a newline. */
545 if (last
->nbytes
&& last
->buffer
[last
->nbytes
- 1] != '\n')
551 for (tmp
= first
; n_elide
< total_lines
- tmp
->nlines
; tmp
= tmp
->next
)
553 fwrite (tmp
->buffer
, 1, tmp
->nbytes
, stdout
);
554 total_lines
-= tmp
->nlines
;
557 /* Print the first 'total_lines - n_elide' lines of tmp->buffer. */
558 if (n_elide
< total_lines
)
560 size_t n
= total_lines
- n_elide
;
561 char const *buffer_end
= tmp
->buffer
+ tmp
->nbytes
;
562 char const *p
= tmp
->buffer
;
563 while (n
&& (p
= memchr (p
, '\n', buffer_end
- p
)))
569 fwrite (tmp
->buffer
, 1, p
- tmp
->buffer
, stdout
);
582 /* Output all but the last N_LINES lines of the input stream defined by
583 FD, START_POS, and END_POS.
584 START_POS is the starting position of the read pointer for the file
585 associated with FD (may be nonzero).
586 END_POS is the file offset of EOF (one larger than offset of last byte).
587 Return true upon success.
588 Give a diagnostic and return false upon error.
590 NOTE: this code is very similar to that of tail.c's file_lines function.
591 Unfortunately, factoring out some common core looks like it'd result
592 in a less efficient implementation or a messy interface. */
594 elide_tail_lines_seekable (const char *pretty_filename
, int fd
,
596 off_t start_pos
, off_t end_pos
)
602 /* Set 'bytes_read' to the size of the last, probably partial, buffer;
603 0 < 'bytes_read' <= 'BUFSIZ'. */
604 bytes_read
= (pos
- start_pos
) % BUFSIZ
;
607 /* Make 'pos' a multiple of 'BUFSIZ' (0 if the file is short), so that all
608 reads will be on block boundaries, which might increase efficiency. */
610 if (lseek (fd
, pos
, SEEK_SET
) < 0)
612 char offset_buf
[INT_BUFSIZE_BOUND (pos
)];
613 error (0, errno
, _("%s: cannot seek to offset %s"),
614 pretty_filename
, offtostr (pos
, offset_buf
));
617 bytes_read
= safe_read (fd
, buffer
, bytes_read
);
618 if (bytes_read
== SAFE_READ_ERROR
)
620 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
624 /* Count the incomplete line on files that don't end with a newline. */
625 if (bytes_read
&& buffer
[bytes_read
- 1] != '\n')
630 /* Scan backward, counting the newlines in this bufferfull. */
632 size_t n
= bytes_read
;
636 nl
= memrchr (buffer
, '\n', n
);
643 /* If necessary, restore the file pointer and copy
644 input to output up to position, POS. */
647 enum Copy_fd_status err
;
648 if (lseek (fd
, start_pos
, SEEK_SET
) < 0)
650 /* Failed to reposition file pointer. */
652 "%s: unable to restore file pointer to initial offset",
653 quote (pretty_filename
));
657 err
= copy_fd (fd
, stdout
, pos
- start_pos
);
658 if (err
!= COPY_FD_OK
)
660 diagnose_copy_fd_failure (err
, pretty_filename
);
665 /* Output the initial portion of the buffer
666 in which we found the desired newline byte.
667 Don't bother testing for failure for such a small amount.
668 Any failure will be detected upon close. */
669 fwrite (buffer
, 1, n
+ 1, stdout
);
674 /* Not enough newlines in that bufferfull. */
675 if (pos
== start_pos
)
677 /* Not enough lines in the file. */
681 if (lseek (fd
, pos
, SEEK_SET
) < 0)
683 char offset_buf
[INT_BUFSIZE_BOUND (pos
)];
684 error (0, errno
, _("%s: cannot seek to offset %s"),
685 pretty_filename
, offtostr (pos
, offset_buf
));
689 bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
690 if (bytes_read
== SAFE_READ_ERROR
)
692 error (0, errno
, _("error reading %s"), quote (pretty_filename
));
696 /* FIXME: is this dead code?
697 Consider the test, pos == start_pos, above. */
703 /* Print all but the last N_ELIDE lines from the input available
704 via file descriptor FD. Return true upon success.
705 Give a diagnostic and return nonzero upon error. */
708 elide_tail_lines_file (const char *filename
, int fd
, uintmax_t n_elide
)
710 if (!presume_input_pipe
)
712 /* Find the offset, OFF, of the Nth newline from the end,
713 but not counting the last byte of the file.
714 If found, write from current position to OFF, inclusive.
715 Otherwise, just return true. */
717 off_t start_pos
= lseek (fd
, 0, SEEK_CUR
);
718 off_t end_pos
= lseek (fd
, 0, SEEK_END
);
719 if (0 <= start_pos
&& start_pos
< end_pos
)
721 /* If the file is empty, we're done. */
725 return elide_tail_lines_seekable (filename
, fd
, n_elide
,
729 /* lseek failed or the end offset precedes start.
733 return elide_tail_lines_pipe (filename
, fd
, n_elide
);
737 head_bytes (const char *filename
, int fd
, uintmax_t bytes_to_write
)
740 size_t bytes_to_read
= BUFSIZ
;
742 while (bytes_to_write
)
745 if (bytes_to_write
< bytes_to_read
)
746 bytes_to_read
= bytes_to_write
;
747 bytes_read
= safe_read (fd
, buffer
, bytes_to_read
);
748 if (bytes_read
== SAFE_READ_ERROR
)
750 error (0, errno
, _("error reading %s"), quote (filename
));
755 if (fwrite (buffer
, 1, bytes_read
, stdout
) < bytes_read
)
756 error (EXIT_FAILURE
, errno
, _("write error"));
757 bytes_to_write
-= bytes_read
;
763 head_lines (const char *filename
, int fd
, uintmax_t lines_to_write
)
767 while (lines_to_write
)
769 size_t bytes_read
= safe_read (fd
, buffer
, BUFSIZ
);
770 size_t bytes_to_write
= 0;
772 if (bytes_read
== SAFE_READ_ERROR
)
774 error (0, errno
, _("error reading %s"), quote (filename
));
779 while (bytes_to_write
< bytes_read
)
780 if (buffer
[bytes_to_write
++] == '\n' && --lines_to_write
== 0)
782 off_t n_bytes_past_EOL
= bytes_read
- bytes_to_write
;
783 /* If we have read more data than that on the specified number
784 of lines, try to seek back to the position we would have
785 gotten to had we been reading one byte at a time. */
786 if (lseek (fd
, -n_bytes_past_EOL
, SEEK_CUR
) < 0)
790 if (fstat (fd
, &st
) != 0 || S_ISREG (st
.st_mode
))
791 error (0, e
, _("cannot reposition file pointer for %s"),
796 if (fwrite (buffer
, 1, bytes_to_write
, stdout
) < bytes_to_write
)
797 error (EXIT_FAILURE
, errno
, _("write error"));
803 head (const char *filename
, int fd
, uintmax_t n_units
, bool count_lines
,
807 write_header (filename
);
813 return elide_tail_lines_file (filename
, fd
, n_units
);
817 return elide_tail_bytes_file (filename
, fd
, n_units
);
821 return head_lines (filename
, fd
, n_units
);
823 return head_bytes (filename
, fd
, n_units
);
827 head_file (const char *filename
, uintmax_t n_units
, bool count_lines
,
832 bool is_stdin
= STREQ (filename
, "-");
836 have_read_stdin
= true;
838 filename
= _("standard input");
839 if (O_BINARY
&& ! isatty (STDIN_FILENO
))
840 xfreopen (NULL
, "rb", stdin
);
844 fd
= open (filename
, O_RDONLY
| O_BINARY
);
847 error (0, errno
, _("cannot open %s for reading"), quote (filename
));
852 ok
= head (filename
, fd
, n_units
, count_lines
, elide_from_end
);
853 if (!is_stdin
&& close (fd
) != 0)
855 error (0, errno
, _("closing %s"), quote (filename
));
861 /* Convert a string of decimal digits, N_STRING, with an optional suffinx
862 to an integral value. Upon successful conversion,
863 return that value. If it cannot be converted, give a diagnostic and exit.
864 COUNT_LINES indicates whether N_STRING is a number of bytes or a number
865 of lines. It is used solely to give a more specific diagnostic. */
868 string_to_integer (bool count_lines
, const char *n_string
)
873 s_err
= xstrtoumax (n_string
, NULL
, 10, &n
, "bkKmMGTPEZY0");
875 if (s_err
== LONGINT_OVERFLOW
)
877 error (EXIT_FAILURE
, 0,
878 _("%s: %s is so large that it is not representable"), n_string
,
879 count_lines
? _("number of lines") : _("number of bytes"));
882 if (s_err
!= LONGINT_OK
)
884 error (EXIT_FAILURE
, 0, "%s: %s", n_string
,
886 ? _("invalid number of lines")
887 : _("invalid number of bytes")));
894 main (int argc
, char **argv
)
896 enum header_mode header_mode
= multiple_files
;
901 /* Number of items to print. */
902 uintmax_t n_units
= DEFAULT_NUMBER
;
904 /* If true, interpret the numeric argument as the number of lines.
905 Otherwise, interpret it as the number of bytes. */
906 bool count_lines
= true;
908 /* Elide the specified number of lines or bytes, counting from
909 the end of the file. */
910 bool elide_from_end
= false;
912 /* Initializer for file_list if no file-arguments
913 were specified on the command line. */
914 static char const *const default_file_list
[] = {"-", NULL
};
915 char const *const *file_list
;
917 initialize_main (&argc
, &argv
);
918 set_program_name (argv
[0]);
919 setlocale (LC_ALL
, "");
920 bindtextdomain (PACKAGE
, LOCALEDIR
);
921 textdomain (PACKAGE
);
923 atexit (close_stdout
);
925 have_read_stdin
= false;
927 print_headers
= false;
929 if (1 < argc
&& argv
[1][0] == '-' && ISDIGIT (argv
[1][1]))
932 char *n_string
= ++a
;
934 char multiplier_char
= 0;
936 /* Old option syntax; a dash, one or more digits, and one or
937 more option letters. Move past the number. */
939 while (ISDIGIT (*a
));
941 /* Pointer to the byte after the last digit. */
944 /* Parse any appended option letters. */
958 multiplier_char
= *a
;
970 header_mode
= always
;
974 error (0, 0, _("invalid trailing option -- %c"), *a
);
975 usage (EXIT_FAILURE
);
979 /* Append the multiplier character (if any) onto the end of
980 the digit string. Then add NUL byte if necessary. */
981 *end_n_string
= multiplier_char
;
983 *(++end_n_string
) = 0;
985 n_units
= string_to_integer (count_lines
, n_string
);
987 /* Make the options we just parsed invisible to getopt. */
993 while ((c
= getopt_long (argc
, argv
, "c:n:qv0123456789", long_options
, NULL
))
998 case PRESUME_INPUT_PIPE_OPTION
:
999 presume_input_pipe
= true;
1003 count_lines
= false;
1004 elide_from_end
= (*optarg
== '-');
1007 n_units
= string_to_integer (count_lines
, optarg
);
1012 elide_from_end
= (*optarg
== '-');
1015 n_units
= string_to_integer (count_lines
, optarg
);
1019 header_mode
= never
;
1023 header_mode
= always
;
1026 case_GETOPT_HELP_CHAR
;
1028 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
1032 error (0, 0, _("invalid trailing option -- %c"), c
);
1033 usage (EXIT_FAILURE
);
1037 if (header_mode
== always
1038 || (header_mode
== multiple_files
&& optind
< argc
- 1))
1039 print_headers
= true;
1041 if ( ! count_lines
&& elide_from_end
&& OFF_T_MAX
< n_units
)
1043 char umax_buf
[INT_BUFSIZE_BOUND (n_units
)];
1044 error (EXIT_FAILURE
, 0, _("%s: number of bytes is too large"),
1045 umaxtostr (n_units
, umax_buf
));
1048 file_list
= (optind
< argc
1049 ? (char const *const *) &argv
[optind
]
1050 : default_file_list
);
1052 if (O_BINARY
&& ! isatty (STDOUT_FILENO
))
1053 xfreopen (NULL
, "wb", stdout
);
1055 for (i
= 0; file_list
[i
]; ++i
)
1056 ok
&= head_file (file_list
[i
], n_units
, count_lines
, elide_from_end
);
1058 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
1059 error (EXIT_FAILURE
, errno
, "-");
1061 exit (ok
? EXIT_SUCCESS
: EXIT_FAILURE
);