1 /* pr -- convert text files for printing.
2 Copyright (C) 88, 91, 1995-2001 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)
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 /* By Pete TerMaat, with considerable refinement by Roland Huebner. */
20 /* Things to watch: Sys V screws up on ...
21 pr -n -3 -s: /usr/dict/words
22 pr -m -o10 -n /usr/dict/words{,,,}
23 pr -6 -a -n -o5 /usr/dict/words
27 Keep a things_to_do list of functions to call when we know we have
28 something to print. Cleaner than current series of checks.
30 Improve the printing of control prefixes.
32 Expand the filename in the centered header line to a full pathname.
37 If the input_tab_char differs from the default value TAB
38 (`-e[CHAR[...]]' is used), any input text tab is expanded to the
39 default width of 8 spaces (compare char_to_clump). - Same as SunOS
42 The treatment of the number_separator (compare add_line_number):
43 The default value TAB of the number_separator (`-n[SEP[...]]') doesn't
44 be thought to be an input character. An optional `-e'-input has no
46 - With single column output
47 only one POSIX requirement has to be met:
48 The default n-separator should be a TAB. The consequence is a
49 different width between the number an the text if the output position
50 of the separator changes, i.e. it depends upon the left margin used.
51 That's not nice but easy-to-use together with the defaults of other
52 utilities, e.g. sort or cut. - Same as SunOS does.
53 - With multicolumn output
54 two conflicting POSIX requirements exist:
55 First `default n-separator is TAB', second `output text columns shall
56 be of equal width'. Moreover POSIX specifies the number+separator a
57 part of the column, together with `-COLUMN' and `-a -COLUMN'.
58 (With -m output the number shall occupy each line only once. Exactly
59 the same situation as single column output exists.)
60 GNU pr gives priority to the 2nd requirement and observes POSIX
61 column definition. The n-separator TAB is expanded to the same number
62 of spaces in each column using the default value 8. Tabification is
63 only performed if it is compatible with the output position.
64 Consequence: The output text columns are of equal width. The layout
65 of a page does not change if the left margin varies. - Looks better
66 than the SunOS approach.
67 SunOS pr gives priority to the 1st requirement. n-separator TAB
68 width varies with each column. Only the width of text part of the
70 Consequence: The output text columns don't have equal width. The
71 widths and the layout of the whole page varies with the left margin.
72 An overflow of the line length (without margin) over the input value
75 The interference of the POSIX-compliant small letter options -w and -s:
76 (`interference' means `setting a _separator_ with -s switches off the
77 column sturctur and the default - not generally - page_width,
79 options: text form / separator: equivalent new capital
80 -w l -s[x] letter options:
81 --------------------------------------------------------------------
82 1. -- -- columns / space --
83 trunc. to page_width = 72
84 2. -- -s[:] full lines / TAB[:] -J -S["<TAB>"|:]
86 3. -w l -- columns / space -W l
87 trunc. to page_width = l
88 4. -w l -s[:] columns / no sep.[:] -W l -S[:]
89 trunc. to page_width = l
90 --------------------------------------------------------------------
95 Including version 1.22i:
96 Some SMALL LETTER options has been redefined with the object of a
97 better POSIX compliance. The output of some further cases has been
98 adapted to other UNIXes. A violation of downward compatibility has to
100 Some NEW CAPITAL LETTER options ( -J, -S, -W) has been introduced to
101 turn off unexpected interferences of small letter options (-s and -w
102 together with the three column options).
103 -N option and the second argument LAST_PAGE of +FIRST_PAGE offer more
104 flexibility; The detailed handling of form feeds set in the input
105 files requires -T option.
107 Capital letter options dominate small letter ones.
109 Some of the option-arguments cannot be specified as separate arguments
110 from the preceding option letter (already stated in POSIX specification).
112 Form feeds in the input cause page breaks in the output. Multiple
113 form feeds produce empty pages.
115 +FIRST_PAGE[:LAST_PAGE], --pages=FIRST_PAGE[:LAST_PAGE]
116 begin [stop] printing with page FIRST_[LAST_]PAGE
118 -COLUMN, --columns=COLUMN
119 Produce output that is COLUMN columns wide and
120 print columns down, unless -a is used. Balance number of
121 lines in the columns on each page.
123 -a, --across Print columns across rather than down, used
124 together with -COLUMN. The input
129 will be printed with `-a -3' as
133 -b Balance columns on the last page.
134 -b is no longer an independent option. It's always used
135 together with -COLUMN (unless -a is used) to get a
136 consistent formulation with "FF set by hand" in input
137 files. Each formfeed found terminates the number of lines
138 to be read with the actual page. The situation for
139 printing columns down is equivalent to that on the last
140 page. So we need a balancing.
142 Keeping -b as an underground option guarantees some
143 downward compatibility. Utilities using pr with -b
144 (a most frequently used form) still work as usual.
146 -c, --show-control-chars
147 Print unprintable characters as control prefixes.
148 Control-g is printed as ^G (use hat notation) and
149 octal backslash notation.
151 -d, --double-space Double space the output.
153 -D FORMAT, --date-format=FORMAT Use FORMAT for the header date.
155 -e[CHAR[WIDTH]], --expand-tabs[=CHAR[WIDTH]]
156 Expand tabs to spaces on input. Optional argument CHAR
157 is the input TAB character. (Default is TAB). Optional
158 argument WIDTH is the input TAB character's width.
161 -F, -f, --form-feed Use formfeeds instead of newlines to separate
162 pages. A three line HEADER is used, no TRAILER with -F,
163 without -F both HEADER and TRAILER are made of five lines.
165 -h HEADER, --header=HEADER
166 Replace the filename in the header with the string HEADER.
167 A centered header is used.
169 -i[CHAR[WIDTH]], --output-tabs[=CHAR[WIDTH]]
170 Replace spaces with tabs on output. Optional argument
171 CHAR is the output TAB character. (Default is TAB).
172 Optional argument WIDTH is the output TAB character's
173 width. (Default is 8)
175 -J, --join-lines Merge lines of full length, turns off -W/-w
176 line truncation, no column alignment, -S[STRING] sets
177 separators, works with all column options
178 (-COLUMN | -a -COLUMN | -m).
179 -J has been introduced (together with -W and -S) to
180 disentangle the old (POSIX compliant) options -w, -s
181 along with the 3 column options.
183 -l PAGE_LENGTH, --length=PAGE_LENGTH
184 Set the page length to PAGE_LENGTH lines. Default is 66,
185 including 5 lines of HEADER and 5 lines of TRAILER
186 without -F, but only 3 lines of HEADER and no TRAILER
187 with -F (i.e the number of text lines defaults to 56 or
190 -m, --merge Print files in parallel; pad_across_to align
191 columns; truncate lines and print separator strings;
192 Do it also with empty columns to get a continuous line
193 numbering and column marking by separators throughout
194 the whole merged file.
196 Empty pages in some input files produce empty columns
197 [marked by separators] in the merged pages. Completely
198 empty merged pages show no column separators at all.
200 The layout of a merged page is ruled by the largest form
201 feed distance of the single pages at that page. Shorter
202 columns will be filled up with empty lines.
204 Together with -J option join lines of full length and
205 set separators when -S option is used.
207 -n[SEP[DIGITS]], --number-lines[=SEP[DIGITS]]
208 Provide DIGITS digit line numbering (default for DIGITS
209 is 5). With multicolumn output the number occupies the
210 first DIGITS column positions of each text column or only
211 each line of -m output.
212 With single column output the number precedes each line
214 Optional argument SEP is the character appended to the
215 line number to separate it from the text followed.
216 The default separator is a TAB. In a strict sense a TAB
217 is always printed with single column output only. The
218 TAB-width varies with the TAB-position, e.g. with the
219 left margin specified by -o option.
220 With multicolumn output priority is given to `equal width
221 of output columns' (a POSIX specification). The TAB-width
222 is fixed to the value of the 1st column and does not
223 change with different values of left margin. That means a
224 fixed number of spaces is always printed in the place of
225 a TAB. The tabification depends upon the output
228 Default counting of the line numbers starts with 1st
229 line of the input file (not the 1st line printed,
230 compare the --page option and -N option).
232 -N NUMBER, --first-line-number=NUMBER
233 Start line counting with the number NUMBER at the 1st
234 line of first page printed (mostly not the 1st line of
237 -o MARGIN, --indent=MARGIN
238 Offset each line with a margin MARGIN spaces wide.
239 Total page width is the size of the margin plus the
240 PAGE_WIDTH set with -W/-w option.
242 -r, --no-file-warnings
243 Omit warning when a file cannot be opened.
245 -s[CHAR], --separator[=CHAR]
246 Separate columns by a single character CHAR, default for
247 CHAR is the TAB character without -w and 'no char' with -w.
248 Without `-s' default separator `space' is set.
249 -s[CHAR] turns off line truncation of all 3 column options
250 (-COLUMN|-a -COLUMN|-m) except -w is set. That is a POSIX
251 compliant formulation. The source code translates -s into
252 the new options -S and -J, also -W if required.
254 -S[STRING], --sep-string[=STRING]
255 Separate columns by any string STRING. The -S option
256 doesn't react upon the -W/-w option (unlike -s option
257 does). It defines a separator nothing else.
258 Without -S: Default separator TAB is used with -J and
259 `space' otherwise (same as -S" ").
260 With -S only: No separator is used, same as -S"".
261 Quotes should be used with blanks and some shell active
263 Don't use -S "STRING". Some of the options don't allow the
264 option letter to be separated from its argument. -S/-s is
265 one of them. That's POSIX compliant.
267 -t, --omit-header Do not print headers or footers but retain form
268 feeds set in the input files.
270 -T, --omit-pagination
271 Do not print headers or footers, eliminate any pagination
272 by form feeds set in the input files.
274 -v, --show-nonprinting
275 Print unprintable characters as escape sequences. Use
276 octal backslash notation. Control-G becomes \007.
278 -w PAGE_WIDTH, --width=PAGE_WIDTH
279 Set page width to PAGE_WIDTH characters for multiple
280 text-column output only (default for PAGE_WIDTH is 72).
281 -s[CHAR] turns off the default page width and any line
282 truncation. Lines of full length will be merged,
283 regardless of the column options set. A POSIX compliant
286 -W PAGE_WIDTH, --page-width=PAGE_WIDTH
287 Set the page width to PAGE_WIDTH characters. That's valid
288 with and without a column option. Text lines will be
289 truncated, unless -J is used. Together with one of the
290 column options (-COLUMN| -a -COLUMN| -m) column alignment
292 Default is 72 characters.
293 Without -W PAGE_WIDTH
294 - but with one of the column options default truncation of
295 72 characters is used (to keep downward compatibility
296 and to simplify most frequently met column tasks).
297 Column alignment and column separators are used.
298 - and without any of the column options NO line truncation
299 is used (to keep downward compatibility and to meet most
300 frequent tasks). That's equivalent to -W 72 -J .
302 With/without -W PAGE_WIDTH the header line is always
303 truncated to avoid line overflow.
305 (In pr versions newer than 1.14 -S option does no longer
315 #include <sys/types.h>
318 #include "closeout.h"
320 #include "mbswidth.h"
323 /* The official name of this program (e.g., no `g' prefix). */
324 #define PROGRAM_NAME "pr"
326 #define AUTHORS N_ ("Pete TerMaat and Roland Huebner")
333 /* Used with start_position in the struct COLUMN described below.
334 If start_position == ANYWHERE, we aren't truncating columns and
335 can begin printing a column anywhere. Otherwise we must pad to
336 the horizontal position start_position. */
339 /* Each column has one of these structures allocated for it.
340 If we're only dealing with one file, fp is the same for all
343 The general strategy is to spend time setting up these column
344 structures (storing columns if necessary), after which printing
345 is a matter of flitting from column to column and calling
348 Parallel files, single files printing across in multiple
349 columns, and single files printing down in multiple columns all
350 fit the same printing loop.
352 print_func Function used to print lines in this column.
353 If we're storing this column it will be
354 print_stored(), Otherwise it will be read_line().
356 char_func Function used to process characters in this column.
357 If we're storing this column it will be store_char(),
358 otherwise it will be print_char().
360 current_line Index of the current entry in line_vector, which
361 contains the index of the first character of the
362 current line in buff[].
364 lines_stored Number of lines in this column which are stored in
367 lines_to_print If we're storing this column, lines_to_print is
368 the number of stored_lines which remain to be
369 printed. Otherwise it is the number of lines
370 we can print without exceeding lines_per_body.
372 start_position The horizontal position we want to be in before we
373 print the first character in this column.
375 numbered True means precede this column with a line number. */
380 FILE *fp; /* Input stream for this column. */
381 char *name; /* File name. */
385 FF_FOUND, /* used with -b option, set with \f, changed
386 to ON_HOLD after print_header */
387 ON_HOLD, /* Hit a form feed. */
390 status; /* Status of the file pointer. */
392 /* Func to print lines in this col. */
393 int (*print_func) PARAMS ((struct COLUMN *));
395 /* Func to print/store chars in this col. */
396 void (*char_func) PARAMS ((int));
398 int current_line; /* Index of current place in line_vector. */
399 int lines_stored; /* Number of lines stored in buff. */
400 int lines_to_print; /* No. lines stored or space left on page. */
401 int start_position; /* Horizontal position of first char. */
403 int full_page_printed; /* True means printed without a FF found. */
405 /* p->full_page_printed controls a special case of "FF set by hand":
406 True means a full page has been printed without FF found. To avoid an
407 additional empty page we have to ignore a FF immediately following in
411 typedef struct COLUMN COLUMN;
413 #define NULLCOL (COLUMN *)0
415 static int char_to_clump PARAMS ((int c));
416 static int read_line PARAMS ((COLUMN *p));
417 static int print_page PARAMS ((void));
418 static int print_stored PARAMS ((COLUMN *p));
419 static int open_file PARAMS ((char *name, COLUMN *p));
420 static int skip_to_page PARAMS ((int page));
421 static void print_header PARAMS ((void));
422 static void pad_across_to PARAMS ((int position));
423 static void add_line_number PARAMS ((COLUMN *p));
424 static void getoptarg PARAMS ((char *arg, char switch_char, char *character,
426 void usage PARAMS ((int status));
427 static void print_files PARAMS ((int number_of_files, char **av));
428 static void init_parameters PARAMS ((int number_of_files));
429 static void init_header PARAMS ((char *filename, int desc));
430 static int init_fps PARAMS ((int number_of_files, char **av));
431 static void init_funcs PARAMS ((void));
432 static void init_store_cols PARAMS ((void));
433 static void store_columns PARAMS ((void));
434 static void balance PARAMS ((int total_stored));
435 static void store_char PARAMS ((int c));
436 static void pad_down PARAMS ((int lines));
437 static void read_rest_of_line PARAMS ((COLUMN *p));
438 static void skip_read PARAMS ((COLUMN *p, int column_number));
439 static void print_char PARAMS ((int c));
440 static void cleanup PARAMS ((void));
441 static void first_last_page PARAMS ((char *pages));
442 static void print_sep_string PARAMS ((void));
443 static void separator_string PARAMS ((const char *optarg_S));
445 /* The name under which this program was invoked. */
448 /* All of the columns to print. */
449 static COLUMN *column_vector;
451 /* When printing a single file in multiple downward columns,
452 we store the leftmost columns contiguously in buff.
453 To print a line from buff, get the index of the first character
454 from line_vector[i], and print up to line_vector[i + 1]. */
457 /* Index of the position in buff where the next character
459 static int buff_current;
461 /* The number of characters in buff.
462 Used for allocation of buff and to detect overflow of buff. */
463 static int buff_allocated;
465 /* Array of indices into buff.
466 Each entry is an index of the first character of a line.
467 This is used when storing lines to facilitate shuffling when
468 we do column balancing on the last page. */
469 static int *line_vector;
471 /* Array of horizonal positions.
472 For each line in line_vector, end_vector[line] is the horizontal
473 position we are in after printing that line. We keep track of this
474 so that we know how much we need to pad to prepare for the next
476 static int *end_vector;
478 /* (-m) True means we're printing multiple files in parallel. */
479 static int parallel_files = FALSE;
481 /* (-m) True means a line starts with some empty columns (some files
482 already CLOSED or ON_HOLD) which we have to align. */
483 static int align_empty_cols;
485 /* (-m) True means we have not yet found any printable column in a line.
486 align_empty_cols = TRUE has to be maintained. */
487 static int empty_line;
489 /* (-m) False means printable column output precedes a form feed found.
490 Column alignment is done only once. No additional action with that form
492 True means we found only a form feed in a column. Maybe we have to do
493 some column alignment with that form feed. */
496 /* (-[0-9]+) True means we're given an option explicitly specifying
497 number of columns. Used to detect when this option is used with -m
498 and when translating old options to new/long options. */
499 static int explicit_columns = FALSE;
501 /* (-t|-T) False means we aren't printing headers and footers. */
502 static int extremities = TRUE;
504 /* (-t) True means we retain all FF set by hand in input files.
505 False is set with -T option. */
506 static int keep_FF = FALSE;
507 static int print_a_FF = FALSE;
509 /* True means we need to print a header as soon as we know we've got input
510 to print after it. */
511 static int print_a_header;
513 /* (-f) True means use formfeeds instead of newlines to separate pages. */
514 static int use_form_feed = FALSE;
516 /* True means we have read the standard input. */
517 static int have_read_stdin = FALSE;
519 /* True means the -a flag has been given. */
520 static int print_across_flag = FALSE;
522 /* True means we're printing one file in multiple (>1) downward columns. */
523 static int storing_columns = TRUE;
525 /* (-b) True means balance columns on the last page as Sys V does. */
526 /* That's no longer an independent option. With storing_columns = TRUE
527 balance_columns = TRUE is used too (s. function init_parameters).
528 We get a consistent formulation with "FF set by hand" in input files. */
529 static int balance_columns = FALSE;
531 /* (-l) Number of lines on a page, including header and footer lines. */
532 static int lines_per_page = 66;
534 /* Number of lines in the header and footer can be reset to 0 using
536 static int lines_per_header = 5;
537 static int lines_per_body;
538 static int lines_per_footer = 5;
540 /* (-w|-W) Width in characters of the page. Does not include the width of
542 static int chars_per_line = 72;
544 /* (-w|W) True means we truncate lines longer than chars_per_column. */
545 static int truncate_lines = FALSE;
547 /* (-J) True means we join lines without any line truncation. -J
548 dominates -w option. */
549 static int join_lines = FALSE;
551 /* Number of characters in a column. Based on col_sep_length and
553 static int chars_per_column;
555 /* (-e) True means convert tabs to spaces on input. */
556 static int untabify_input = FALSE;
558 /* (-e) The input tab character. */
559 static char input_tab_char = '\t';
561 /* (-e) Tabstops are at chars_per_tab, 2*chars_per_tab, 3*chars_per_tab, ...
562 where the leftmost column is 1. */
563 static int chars_per_input_tab = 8;
565 /* (-i) True means convert spaces to tabs on output. */
566 static int tabify_output = FALSE;
568 /* (-i) The output tab character. */
569 static char output_tab_char = '\t';
571 /* (-i) The width of the output tab. */
572 static int chars_per_output_tab = 8;
574 /* Keeps track of pending white space. When we hit a nonspace
575 character after some whitespace, we print whitespace, tabbing
576 if necessary to get to output_position + spaces_not_printed. */
577 static int spaces_not_printed;
579 /* (-o) Number of spaces in the left margin (tabs used when possible). */
580 static int chars_per_margin = 0;
582 /* Position where the next character will fall.
583 Leftmost position is 0 + chars_per_margin.
584 Rightmost position is chars_per_margin + chars_per_line - 1.
585 This is important for converting spaces to tabs on output. */
586 static int output_position;
588 /* Horizontal position relative to the current file.
589 (output_position depends on where we are on the page;
590 input_position depends on where we are in the file.)
591 Important for converting tabs to spaces on input. */
592 static int input_position;
594 /* Count number of failed opens so we can exit with nonzero
595 status if there were any. */
596 static int failed_opens = 0;
598 /* The number of spaces taken up if we print a tab character with width
599 c_ from position h_. */
600 #define TAB_WIDTH(c_, h_) ((c_) - ((h_) % (c_)))
602 /* The horizontal position we'll be at after printing a tab character
603 of width c_ from the position h_. */
604 #define POS_AFTER_TAB(c_, h_) ((h_) + TAB_WIDTH (c_, h_))
606 /* (-NNN) Number of columns of text to print. */
607 static int columns = 1;
609 /* (+NNN:MMM) Page numbers on which to begin and stop printing.
610 first_page_number = 0 will be used to check input only. */
611 static int first_page_number = 0;
612 static int last_page_number = 0;
614 /* Number of files open (not closed, not on hold). */
615 static int files_ready_to_read = 0;
617 /* Current page number. Displayed in header. */
618 static int page_number;
620 /* Current line number. Displayed when -n flag is specified.
622 When printing files in parallel (-m flag), line numbering is as follows:
626 When printing files across (-a flag), ...
630 Otherwise, line numbering is as follows:
633 static int line_number;
635 /* With line_number overflow, we use power_10 to cut off the higher-order
636 digits of the line_number */
639 /* (-n) True means lines should be preceded by numbers. */
640 static int numbered_lines = FALSE;
642 /* (-n) Character which follows each line number. */
643 static char number_separator = '\t';
645 /* (-n) line counting starts with 1st line of input file (not with 1st
646 line of 1st page printed). */
647 static int line_count = 1;
649 /* (-n) True means counting of skipped lines starts with 1st line of
650 input file. False means -N option is used in addition, counting of
651 skipped lines not required. */
652 static int skip_count = TRUE;
654 /* (-N) Counting starts with start_line_number = NUMBER at 1st line of
655 first page printed, usually not 1st page of input file. */
656 static int start_line_num = 1;
658 /* (-n) Width in characters of a line number. */
659 static int chars_per_number = 5;
661 /* Used when widening the first column to accommodate numbers -- only
662 needed when printing files in parallel. Includes width of both the
663 number and the number_separator. */
664 static int number_width;
666 /* Buffer sprintf uses to format a line number. */
667 static char *number_buff;
669 /* (-v) True means unprintable characters are printed as escape sequences.
670 control-g becomes \007. */
671 static int use_esc_sequence = FALSE;
673 /* (-c) True means unprintable characters are printed as control prefixes.
674 control-g becomes ^G. */
675 static int use_cntrl_prefix = FALSE;
677 /* (-d) True means output is double spaced. */
678 static int double_space = FALSE;
680 /* Number of files opened initially in init_files. Should be 1
681 unless we're printing multiple files in parallel. */
682 static int total_files = 0;
684 /* (-r) True means don't complain if we can't open a file. */
685 static int ignore_failed_opens = FALSE;
687 /* (-S) True means we separate columns with a specified string.
688 -S option does not affect line truncation nor column alignment. */
689 static int use_col_separator = FALSE;
691 /* String used to separate columns if the -S option has been specified.
692 Default without -S but together with one of the column options
693 -a|COLUMN|-m is a `space' and with the -J option a `tab'. */
694 static char *col_sep_string = "";
695 static int col_sep_length = 0;
696 static char *column_separator = " ";
697 static char *line_separator = "\t";
699 /* Number of separator characters waiting to be printed as soon as we
700 know that we have any input remaining to be printed. */
701 static int separators_not_printed;
703 /* Position we need to pad to, as soon as we know that we have input
704 remaining to be printed. */
705 static int padding_not_printed;
707 /* True means we should pad the end of the page. Remains false until we
708 know we have a page to print. */
709 static int pad_vertically;
711 /* (-h) String of characters used in place of the filename in the header. */
712 static char *custom_header;
714 /* (-D) Date format for the header. */
715 static char const *date_format;
717 /* Date and file name for the header. */
718 static char *date_text;
719 static char const *file_text;
721 /* Output columns available, not counting the date and file name. */
722 static int header_width_available;
724 static int *clump_buff;
726 /* True means we read the line no. lines_per_body in skip_read
727 called by skip_to_page. That variable controls the coincidence of a
728 "FF set by hand" and "full_page_printed", see above the definition of
730 static int last_line = FALSE;
732 /* For long options that have no equivalent short option, use a
733 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
736 PAGES_OPTION = CHAR_MAX + 1,
740 static struct option const long_options[] =
742 {"pages", required_argument, NULL, PAGES_OPTION},
743 {"columns", required_argument, NULL, COLUMNS_OPTION},
744 {"across", no_argument, NULL, 'a'},
745 {"show-control-chars", no_argument, NULL, 'c'},
746 {"double-space", no_argument, NULL, 'd'},
747 {"date-format", required_argument, NULL, 'D'},
748 {"expand-tabs", optional_argument, NULL, 'e'},
749 {"form-feed", no_argument, NULL, 'f'},
750 {"header", required_argument, NULL, 'h'},
751 {"output-tabs", optional_argument, NULL, 'i'},
752 {"join-lines", no_argument, NULL, 'J'},
753 {"length", required_argument, NULL, 'l'},
754 {"merge", no_argument, NULL, 'm'},
755 {"number-lines", optional_argument, NULL, 'n'},
756 {"first-line-number", required_argument, NULL, 'N'},
757 {"indent", required_argument, NULL, 'o'},
758 {"no-file-warnings", no_argument, NULL, 'r'},
759 {"separator", optional_argument, NULL, 's'},
760 {"sep-string", optional_argument, NULL, 'S'},
761 {"omit-header", no_argument, NULL, 't'},
762 {"omit-pagination", no_argument, NULL, 'T'},
763 {"show-nonprinting", no_argument, NULL, 'v'},
764 {"width", required_argument, NULL, 'w'},
765 {"page-width", required_argument, NULL, 'W'},
766 {GETOPT_HELP_OPTION_DECL},
767 {GETOPT_VERSION_OPTION_DECL},
771 /* Return the number of columns that have either an open file or
775 cols_ready_to_print (void)
782 for (q = column_vector, i = 0; i < columns; ++q, ++i)
783 if (q->status == OPEN ||
784 q->status == FF_FOUND || /* With -b: To print a header only */
785 (storing_columns && q->lines_stored > 0 && q->lines_to_print > 0))
790 /* Estimate first_ / last_page_number
791 using option +FIRST_PAGE:LAST_PAGE */
794 first_last_page (char *pages)
800 error (0, 0, _("`--pages' invalid range of page numbers: `%s'"), pages);
804 str1 = strchr (pages, ':');
810 if (xstrtol (pages, NULL, 10, &tmp_long, "") != LONGINT_OK
811 || tmp_long < 1 || tmp_long > INT_MAX)
812 error (EXIT_FAILURE, 0, _("`--pages' invalid starting page number: `%s'"),
814 first_page_number = (int) tmp_long;
822 if (xstrtol (str1 + 1, NULL, 10, &tmp_long, "") != LONGINT_OK
823 || tmp_long <= 0 || tmp_long > INT_MAX)
824 error (EXIT_FAILURE, 0, _("`--pages' invalid ending page number: `%s'"),
826 last_page_number = (int) tmp_long;
829 if (first_page_number > last_page_number)
830 error (EXIT_FAILURE, 0,
831 _("`--pages' starting page number is larger than ending page number"));
834 /* Estimate length of col_sep_string with option -S[STRING] */
837 separator_string (const char *optarg_S)
839 col_sep_length = (int) strlen (optarg_S);
840 col_sep_string = (char *) xmalloc (col_sep_length + 1);
841 strcpy (col_sep_string, optarg_S);
845 main (int argc, char **argv)
850 int old_options = FALSE;
855 program_name = argv[0];
856 setlocale (LC_ALL, "");
857 bindtextdomain (PACKAGE, LOCALEDIR);
858 textdomain (PACKAGE);
860 atexit (close_stdout);
863 file_names = (argc > 1
864 ? (char **) xmalloc ((argc - 1) * sizeof (char *))
867 while ((c = getopt_long (argc, argv,
868 "-0123456789abcdD:e::fFh:i::Jl:mn::N:o:rs::S::tTvw:W:",
874 accum = accum * 10 + c - '0';
881 explicit_columns = TRUE;
887 case 0: /* getopt long option */
890 case 1: /* Non-option argument. */
893 /* long option --page dominates old `+FIRST_PAGE ...' */
894 if (first_page_number <= 0 && last_page_number <= 0)
895 first_last_page (optarg);
898 file_names[n_files++] = optarg;
901 case PAGES_OPTION: /* --pages=FIRST_PAGE[:LAST_PAGE] */
902 { /* dominates old opt +... */
904 first_last_page (optarg);
906 error (EXIT_FAILURE, 0,
907 _("`--pages=FIRST_PAGE[:LAST_PAGE]' missing argument"));
911 case COLUMNS_OPTION: /* --columns=COLUMN */
914 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
915 || tmp_long <= 0 || tmp_long > INT_MAX)
917 error (EXIT_FAILURE, 0,
918 _("`--columns=COLUMN' invalid number of columns: `%s'"),
921 columns = (int) tmp_long;
926 print_across_flag = TRUE;
927 storing_columns = FALSE;
930 balance_columns = TRUE;
933 use_cntrl_prefix = TRUE;
939 date_format = optarg;
943 getoptarg (optarg, 'e', &input_tab_char,
944 &chars_per_input_tab);
945 /* Could check tab width > 0. */
946 untabify_input = TRUE;
950 use_form_feed = TRUE;
953 custom_header = optarg;
957 getoptarg (optarg, 'i', &output_tab_char,
958 &chars_per_output_tab);
959 /* Could check tab width > 0. */
960 tabify_output = TRUE;
968 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
969 || tmp_long <= 0 || tmp_long > INT_MAX)
971 error (EXIT_FAILURE, 0,
972 _("`-l PAGE_LENGTH' invalid number of lines: `%s'"),
975 lines_per_page = (int) tmp_long;
979 parallel_files = TRUE;
980 storing_columns = FALSE;
983 numbered_lines = TRUE;
985 getoptarg (optarg, 'n', &number_separator,
992 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
993 || tmp_long > INT_MAX)
995 error (EXIT_FAILURE, 0,
996 _("`-N NUMBER' invalid starting line number: `%s'"),
999 start_line_num = (int) tmp_long;
1005 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1006 || tmp_long < 0 || tmp_long > INT_MAX)
1007 error (EXIT_FAILURE, 0,
1008 _("`-o MARGIN' invalid line offset: `%s'"), optarg);
1009 chars_per_margin = (int) tmp_long;
1013 ignore_failed_opens = TRUE;
1018 if (!use_col_separator && optarg)
1019 separator_string (optarg);
1023 /* Reset an additional input of -s, -S dominates -s */
1024 col_sep_string = "";
1026 use_col_separator = TRUE;
1028 separator_string (optarg);
1031 extremities = FALSE;
1035 extremities = FALSE;
1039 use_esc_sequence = TRUE;
1046 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1047 || tmp_long <= 0 || tmp_long > INT_MAX)
1048 error (EXIT_FAILURE, 0,
1049 _("`-w PAGE_WIDTH' invalid number of characters: `%s'"), optarg);
1050 if (!truncate_lines) chars_per_line = (int) tmp_long;
1054 old_w = FALSE; /* dominates -w */
1055 truncate_lines = TRUE;
1058 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1059 || tmp_long <= 0 || tmp_long > INT_MAX)
1060 error (EXIT_FAILURE, 0,
1061 _("`-W PAGE_WIDTH' invalid number of characters: `%s'"), optarg);
1062 chars_per_line = (int) tmp_long;
1065 case_GETOPT_HELP_CHAR;
1066 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1074 date_format = (getenv ("POSIXLY_CORRECT")
1075 ? dcgettext (NULL, "%b %e %H:%M %Y", LC_TIME)
1076 : "%Y-%m-%d %H:%M");
1078 /* Now we can set a reasonable initial value: */
1079 if (first_page_number == 0)
1080 first_page_number = 1;
1082 if (parallel_files && explicit_columns)
1083 error (EXIT_FAILURE, 0,
1084 _("Cannot specify number of columns when printing in parallel."));
1086 if (parallel_files && print_across_flag)
1087 error (EXIT_FAILURE, 0,
1088 _("Cannot specify both printing across and printing in parallel."));
1090 /* Translate some old short options to new/long options.
1091 To meet downward compatibility with other UNIX pr utilities
1092 and some POSIX specifications. */
1098 if (parallel_files || explicit_columns)
1101 truncate_lines = TRUE;
1103 /* adapt HP-UX and SunOS: -s = no separator;
1105 use_col_separator = TRUE;
1108 /* old -w sets width with columns only
1112 else if (!use_col_separator)
1114 /* No -S option read */
1115 if (old_s && (parallel_files || explicit_columns))
1117 if (!truncate_lines)
1119 /* old -s (without -w and -W) annuls column alignment,
1120 uses fields, activate -J */
1122 if (col_sep_length > 0)
1124 use_col_separator = TRUE;
1128 /* adapt HP-UX and SunOS: -s = no separator;
1130 use_col_separator = TRUE;
1135 for (; optind < argc; optind++)
1137 file_names[n_files++] = argv[optind];
1142 /* No file arguments specified; read from standard input. */
1143 print_files (0, NULL);
1148 print_files (n_files, file_names);
1152 for (i = 0; i < n_files; i++)
1153 print_files (1, &file_names[i]);
1159 if (have_read_stdin && fclose (stdin) == EOF)
1160 error (EXIT_FAILURE, errno, _("standard input"));
1161 if (failed_opens > 0)
1162 exit (EXIT_FAILURE);
1163 exit (EXIT_SUCCESS);
1166 /* Parse options of the form -scNNN.
1168 Example: -nck, where 'n' is the option, c is the optional number
1169 separator, and k is the optional width of the field used when printing
1173 getoptarg (char *arg, char switch_char, char *character, int *number)
1175 if (!ISDIGIT (*arg))
1176 *character = *arg++;
1180 if (xstrtol (arg, NULL, 10, &tmp_long, "") != LONGINT_OK
1181 || tmp_long <= 0 || tmp_long > INT_MAX)
1184 _("`-%c' extra characters or invalid number in the argument: `%s'"),
1188 *number = (int) tmp_long;
1192 /* Set parameters related to formatting. */
1195 init_parameters (int number_of_files)
1197 int chars_used_by_number = 0;
1201 lines_per_header = 3;
1202 lines_per_footer = 0;
1205 lines_per_body = lines_per_page - lines_per_header - lines_per_footer;
1206 if (lines_per_body <= 0)
1208 extremities = FALSE;
1211 if (extremities == FALSE)
1212 lines_per_body = lines_per_page;
1215 lines_per_body = lines_per_body / 2;
1217 /* If input is stdin, cannot print parallel files. BSD dumps core
1219 if (number_of_files == 0)
1220 parallel_files = FALSE;
1223 columns = number_of_files;
1225 /* One file, multi columns down: -b option is set to get a consistent
1226 formulation with "FF set by hand" in input files. */
1227 if (storing_columns)
1228 balance_columns = TRUE;
1230 /* Tabification is assumed for multiple columns. */
1233 if (!use_col_separator)
1235 /* Use default separator */
1237 col_sep_string = line_separator;
1239 col_sep_string = column_separator;
1242 use_col_separator = TRUE;
1244 /* It's rather pointless to define a TAB separator with column
1246 else if (!join_lines && *col_sep_string == '\t')
1247 col_sep_string = column_separator;
1249 truncate_lines = TRUE;
1250 untabify_input = TRUE;
1251 tabify_output = TRUE;
1254 storing_columns = FALSE;
1256 /* -J dominates -w in any case */
1258 truncate_lines = FALSE;
1263 int chars_per_default_tab = 8;
1265 line_count = start_line_num;
1267 /* To allow input tab-expansion (-e sensitive) use:
1268 if (number_separator == input_tab_char)
1269 number_width = chars_per_number +
1270 TAB_WIDTH (chars_per_input_tab, chars_per_number); */
1272 /* Estimate chars_per_text without any margin and keep it constant. */
1273 if (number_separator == '\t')
1274 number_width = chars_per_number +
1275 TAB_WIDTH (chars_per_default_tab, chars_per_number);
1277 number_width = chars_per_number + 1;
1279 /* The number is part of the column width unless we are
1280 printing files in parallel. */
1282 chars_used_by_number = number_width;
1284 /* We use power_10 to cut off the higher-order digits of the
1285 line_number in function add_line_number */
1286 tmp_i = chars_per_number;
1287 for (power_10 = 1; tmp_i > 0; --tmp_i)
1288 power_10 = 10 * power_10;
1291 chars_per_column = (chars_per_line - chars_used_by_number -
1292 (columns - 1) * col_sep_length) / columns;
1294 if (chars_per_column < 1)
1295 error (EXIT_FAILURE, 0, _("page width too narrow"));
1299 if (number_buff != NULL)
1301 number_buff = (char *) xmalloc (2 * chars_per_number);
1304 /* Pick the maximum between the tab width and the width of an
1306 The width of an escape sequence (4) isn't the lower limit any longer.
1307 We've to use 8 as the lower limit, if we use chars_per_default_tab = 8
1308 to expand a tab which is not an input_tab-char. */
1309 if (clump_buff != NULL)
1311 clump_buff = (int *) xmalloc ((chars_per_input_tab > 8
1312 ? chars_per_input_tab : 8) * sizeof (int));
1315 /* Open the necessary files,
1316 maintaining a COLUMN structure for each column.
1318 With multiple files, each column p has a different p->fp.
1319 With single files, each column p has the same p->fp.
1320 Return 1 if (number_of_files > 0) and no files can be opened,
1323 With each column/file p, p->full_page_printed is initialized,
1324 see also open_file. */
1327 init_fps (int number_of_files, char **av)
1336 if (column_vector != NULLCOL)
1337 free ((char *) column_vector);
1338 column_vector = (COLUMN *) xmalloc (columns * sizeof (COLUMN));
1342 files_left = number_of_files;
1343 for (p = column_vector; files_left--; ++p, ++av)
1345 if (open_file (*av, p) == 0)
1353 init_header ("", -1);
1358 if (number_of_files > 0)
1360 if (open_file (*av, p) == 0)
1362 init_header (*av, fileno (p->fp));
1363 p->lines_stored = 0;
1367 p->name = _("standard input");
1369 have_read_stdin = TRUE;
1371 p->full_page_printed = FALSE;
1373 init_header ("", -1);
1374 p->lines_stored = 0;
1377 firstname = p->name;
1379 for (i = columns - 1, ++p; i; --i, ++p)
1381 p->name = firstname;
1384 p->full_page_printed = FALSE;
1385 p->lines_stored = 0;
1388 files_ready_to_read = total_files;
1392 /* Determine print_func and char_func, the functions
1393 used by each column for printing and/or storing.
1395 Determine the horizontal position desired when we begin
1396 printing a column (p->start_position). */
1404 h = chars_per_margin;
1406 if (!truncate_lines)
1410 /* When numbering lines of parallel files, we enlarge the
1411 first column to accomodate the number. Looks better than
1412 the Sys V approach. */
1413 if (parallel_files && numbered_lines)
1414 h_next = h + chars_per_column + number_width;
1416 h_next = h + chars_per_column;
1419 /* Enlarge p->start_position of first column to use the same form of
1420 padding_not_printed with all columns. */
1421 h = h + col_sep_length;
1423 /* This loop takes care of all but the rightmost column. */
1425 for (p = column_vector, i = 1; i < columns; ++p, ++i)
1427 if (storing_columns) /* One file, multi columns down. */
1429 p->char_func = store_char;
1430 p->print_func = print_stored;
1433 /* One file, multi columns across; or parallel files. */
1435 p->char_func = print_char;
1436 p->print_func = read_line;
1439 /* Number only the first column when printing files in
1441 p->numbered = numbered_lines && (!parallel_files || i == 1);
1442 p->start_position = h;
1444 /* If we don't truncate lines, all start_positions are
1445 ANYWHERE, except the first column's start_position when
1448 if (!truncate_lines)
1455 h = h_next + col_sep_length;
1456 h_next = h + chars_per_column;
1460 /* The rightmost column.
1462 Doesn't need to be stored unless we intend to balance
1463 columns on the last page. */
1464 if (storing_columns && balance_columns)
1466 p->char_func = store_char;
1467 p->print_func = print_stored;
1471 p->char_func = print_char;
1472 p->print_func = read_line;
1475 p->numbered = numbered_lines && (!parallel_files || i == 1);
1476 p->start_position = h;
1479 /* Open a file. Return nonzero if successful, zero if failed.
1481 With each file p, p->full_page_printed is initialized,
1482 see also init_fps. */
1485 open_file (char *name, COLUMN *p)
1487 if (STREQ (name, "-"))
1489 p->name = _("standard input");
1491 have_read_stdin = 1;
1496 p->fp = fopen (name, "r");
1501 if (!ignore_failed_opens)
1502 error (0, errno, "%s", name);
1506 p->full_page_printed = FALSE;
1511 /* Close the file in P.
1513 If we aren't dealing with multiple files in parallel, we change
1514 the status of all columns in the column list to reflect the close. */
1517 close_file (COLUMN *p)
1522 if (p->status == CLOSED)
1525 error (EXIT_FAILURE, errno, "%s", p->name);
1526 if (p->fp != stdin && fclose (p->fp) == EOF)
1527 error (EXIT_FAILURE, errno, "%s", p->name);
1529 if (!parallel_files)
1531 for (q = column_vector, i = columns; i; ++q, --i)
1534 if (q->lines_stored == 0)
1536 q->lines_to_print = 0;
1543 p->lines_to_print = 0;
1546 --files_ready_to_read;
1549 /* Put a file on hold until we start a new page,
1550 since we've hit a form feed.
1552 If we aren't dealing with parallel files, we must change the
1553 status of all columns in the column list. */
1556 hold_file (COLUMN *p)
1561 if (!parallel_files)
1562 for (q = column_vector, i = columns; i; ++q, --i)
1564 if (storing_columns)
1565 q->status = FF_FOUND;
1567 q->status = ON_HOLD;
1570 p->status = ON_HOLD;
1572 p->lines_to_print = 0;
1573 --files_ready_to_read;
1576 /* Undo hold_file -- go through the column list and change any
1577 ON_HOLD columns to OPEN. Used at the end of each page. */
1585 for (p = column_vector; i; --i, ++p)
1586 if (p->status == ON_HOLD)
1589 files_ready_to_read++;
1592 if (storing_columns)
1594 if (column_vector->status == CLOSED)
1595 /* We use the info to output an error message in skip_to_page. */
1596 files_ready_to_read = 0;
1598 files_ready_to_read = 1;
1602 /* Print a single file, or multiple files in parallel.
1604 Set up the list of columns, opening the necessary files.
1605 Allocate space for storing columns, if necessary.
1606 Skip to first_page_number, if user has asked to skip leading pages.
1607 Determine which functions are appropriate to store/print lines
1609 Print the file(s). */
1612 print_files (int number_of_files, char **av)
1614 init_parameters (number_of_files);
1615 if (init_fps (number_of_files, av))
1617 if (storing_columns)
1620 if (first_page_number > 1)
1622 if (!skip_to_page (first_page_number))
1625 page_number = first_page_number;
1632 line_number = line_count;
1633 while (print_page ())
1637 /* Initialize header information.
1638 If DESC is non-negative, it is a file descriptor open to
1639 FILENAME for reading. */
1642 init_header (char *filename, int desc)
1645 char initbuf[MAX (256, INT_STRLEN_BOUND (long) + 1)];
1649 /* If parallel files or standard input, use current date. */
1650 if (STREQ (filename, "-"))
1652 if (desc < 0 || fstat (desc, &st) != 0)
1653 st.st_mtime = time (NULL);
1656 tm = localtime (&st.st_mtime);
1658 sprintf (buf, "%ld", (long) st.st_mtime);
1661 size_t bufsize = sizeof initbuf;
1665 if (strftime (buf, bufsize, date_format, tm) || ! *buf)
1667 buf = alloca (bufsize *= 2);
1673 date_text = xstrdup (buf);
1674 file_text = custom_header ? custom_header : desc < 0 ? "" : filename;
1675 header_width_available = (chars_per_line
1676 - mbswidth (date_text, 0)
1677 - mbswidth (file_text, 0));
1680 /* Set things up for printing a page
1682 Scan through the columns ...
1683 Determine which are ready to print
1684 (i.e., which have lines stored or open files)
1685 Set p->lines_to_print appropriately
1686 (to p->lines_stored if we're storing, or lines_per_body
1687 if we're reading straight from the file)
1688 Keep track of this total so we know when to stop printing */
1696 if (storing_columns)
1699 for (j = columns - 1, p = column_vector; j; --j, ++p)
1701 p->lines_to_print = p->lines_stored;
1705 if (balance_columns)
1707 p->lines_to_print = p->lines_stored;
1709 /* Since we're not balancing columns, we don't need to store
1710 the rightmost column. Read it straight from the file. */
1713 if (p->status == OPEN)
1715 p->lines_to_print = lines_per_body;
1718 p->lines_to_print = 0;
1722 for (j = columns, p = column_vector; j; --j, ++p)
1723 if (p->status == OPEN)
1725 p->lines_to_print = lines_per_body;
1728 p->lines_to_print = 0;
1731 /* Align empty columns and print separators.
1732 Empty columns will be formed by files with status ON_HOLD or CLOSED
1733 when printing multiple files in parallel. */
1736 align_column (COLUMN *p)
1738 padding_not_printed = p->start_position;
1739 if (padding_not_printed - col_sep_length > 0)
1741 pad_across_to (padding_not_printed - col_sep_length);
1742 padding_not_printed = ANYWHERE;
1745 if (use_col_separator)
1746 print_sep_string ();
1749 add_line_number (p);
1754 As long as there are lines left on the page and columns ready to print,
1755 Scan across the column list
1756 if the column has stored lines or the file is open
1757 pad to the appropriate spot
1759 pad the remainder of the page with \n or \f as requested
1760 reset the status of all files -- any files which where on hold because
1761 of formfeeds are now put back into the lineup. */
1767 int lines_left_on_page;
1770 /* Used as an accumulator (with | operator) of successive values of
1771 pad_vertically. The trick is to set pad_vertically
1772 to zero before each run through the inner loop, then after that
1773 loop, it tells us whether a line was actually printed (whether a
1774 newline needs to be output -- or two for double spacing). But those
1775 values have to be accumulated (in pv) so we can invoke pad_down
1776 properly after the outer loop completes. */
1781 if (cols_ready_to_print () == 0)
1785 print_a_header = TRUE;
1787 /* Don't pad unless we know a page was printed. */
1788 pad_vertically = FALSE;
1791 lines_left_on_page = lines_per_body;
1793 lines_left_on_page *= 2;
1795 while (lines_left_on_page > 0 && cols_ready_to_print () > 0)
1797 output_position = 0;
1798 spaces_not_printed = 0;
1799 separators_not_printed = 0;
1800 pad_vertically = FALSE;
1801 align_empty_cols = FALSE;
1804 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
1807 if (p->lines_to_print > 0 || p->status == FF_FOUND)
1810 padding_not_printed = p->start_position;
1811 if (!(p->print_func) (p))
1812 read_rest_of_line (p);
1813 pv |= pad_vertically;
1815 --p->lines_to_print;
1816 if (p->lines_to_print <= 0)
1818 if (cols_ready_to_print () <= 0)
1822 /* File p changed its status to ON_HOLD or CLOSED */
1823 if (parallel_files && p->status != OPEN)
1826 align_empty_cols = TRUE;
1827 else if (p->status == CLOSED ||
1828 (p->status == ON_HOLD && FF_only))
1832 else if (parallel_files)
1834 /* File status ON_HOLD or CLOSED */
1836 align_empty_cols = TRUE;
1841 /* We need it also with an empty column */
1842 if (use_col_separator)
1843 ++separators_not_printed;
1849 --lines_left_on_page;
1852 if (cols_ready_to_print () <= 0 && !extremities)
1855 if (double_space && pv)
1858 --lines_left_on_page;
1862 if (lines_left_on_page == 0)
1863 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
1864 if (p->status == OPEN)
1865 p->full_page_printed = TRUE;
1867 pad_vertically = pv;
1869 if (pad_vertically && extremities)
1870 pad_down (lines_left_on_page + lines_per_footer);
1871 else if (keep_FF && print_a_FF)
1877 if (last_page_number && page_number > last_page_number)
1878 return FALSE; /* Stop printing with LAST_PAGE */
1880 reset_status (); /* Change ON_HOLD to OPEN. */
1882 return TRUE; /* More pages to go. */
1885 /* Allocate space for storing columns.
1887 This is necessary when printing multiple columns from a single file.
1888 Lines are stored consecutively in buff, separated by '\0'.
1890 The following doesn't apply any longer - any tuning possible?
1891 (We can't use a fixed offset since with the '-s' flag lines aren't
1894 We maintain a list (line_vector) of pointers to the beginnings
1895 of lines in buff. We allocate one more than the number of lines
1896 because the last entry tells us the index of the last character,
1897 which we need to know in order to print the last line in buff. */
1900 init_store_cols (void)
1902 int total_lines = lines_per_body * columns;
1903 int chars_if_truncate = total_lines * (chars_per_column + 1);
1905 if (line_vector != NULL)
1906 free ((int *) line_vector);
1907 /* FIXME: here's where it was allocated. */
1908 line_vector = (int *) xmalloc ((total_lines + 1) * sizeof (int *));
1910 if (end_vector != NULL)
1911 free ((int *) end_vector);
1912 end_vector = (int *) xmalloc (total_lines * sizeof (int *));
1916 buff_allocated = (use_col_separator
1917 ? 2 * chars_if_truncate
1918 : chars_if_truncate); /* Tune this. */
1919 buff = (char *) xmalloc (buff_allocated);
1922 /* Store all but the rightmost column.
1923 (Used when printing a single file in multiple downward columns)
1926 set p->current_line to be the index in line_vector of the
1927 first line in the column
1928 For each line in the column
1929 store the line in buff
1930 add to line_vector the index of the line's first char
1931 buff_start is the index in buff of the first character in the
1935 store_columns (void)
1940 int last_col; /* The rightmost column which will be saved in buff */
1946 if (balance_columns)
1949 last_col = columns - 1;
1951 for (i = 1, p = column_vector; i <= last_col; ++i, ++p)
1952 p->lines_stored = 0;
1954 for (i = 1, p = column_vector; i <= last_col && files_ready_to_read;
1957 p->current_line = line;
1958 for (j = lines_per_body; j && files_ready_to_read; --j)
1960 if (p->status == OPEN) /* Redundant. Clean up. */
1965 read_rest_of_line (p);
1967 if (p->status == OPEN
1968 || buff_start != buff_current)
1971 line_vector[line] = buff_start;
1972 end_vector[line++] = input_position;
1973 buff_start = buff_current;
1978 /* Keep track of the location of the last char in buff. */
1979 line_vector[line] = buff_start;
1981 if (balance_columns)
1986 balance (int total_stored)
1992 for (i = 1, p = column_vector; i <= columns; ++i, ++p)
1994 lines = total_stored / columns;
1995 if (i <= total_stored % columns)
1998 p->lines_stored = lines;
1999 p->current_line = first_line;
2001 first_line += lines;
2005 /* Store a character in the buffer. */
2010 if (buff_current >= buff_allocated)
2012 /* May be too generous. */
2013 buff_allocated = 2 * buff_allocated;
2014 buff = (char *) xrealloc (buff, buff_allocated * sizeof (char));
2016 buff[buff_current++] = (char) c;
2020 add_line_number (COLUMN *p)
2026 /* Cutting off the higher-order digits is more informative than
2027 lower-order cut off*/
2028 if (line_number < power_10)
2029 sprintf (number_buff, "%*d", chars_per_number, line_number);
2032 left_cut = line_number % power_10;
2033 sprintf (number_buff, "%0*d", chars_per_number, left_cut);
2037 for (i = chars_per_number; i > 0; i--)
2038 (p->char_func) ((int) *s++);
2042 /* Tabification is assumed for multiple columns, also for n-separators,
2043 but `default n-separator = TAB' hasn't been given priority over
2044 equal column_width also specified by POSIX. */
2045 if (number_separator == '\t')
2047 i = number_width - chars_per_number;
2049 (p->char_func) ((int) ' ');
2052 (p->char_func) ((int) number_separator);
2055 /* To comply with POSIX, we avoid any expansion of default TAB
2056 separator with a single column output. No column_width requirement
2057 has to be considered. */
2059 (p->char_func) ((int) number_separator);
2060 if (number_separator == '\t')
2061 output_position = POS_AFTER_TAB (chars_per_output_tab,
2065 if (truncate_lines && !parallel_files)
2066 input_position += number_width;
2069 /* Print (or store) padding until the current horizontal position
2073 pad_across_to (int position)
2075 register int h = output_position;
2078 spaces_not_printed = position - output_position;
2081 while (++h <= position)
2083 output_position = position;
2087 /* Pad to the bottom of the page.
2089 If the user has requested a formfeed, use one.
2090 Otherwise, use newlines. */
2093 pad_down (int lines)
2100 for (i = lines; i; --i)
2104 /* Read the rest of the line.
2106 Read from the current column's file until an end of line is
2107 hit. Used when we've truncated a line and we no longer need
2108 to print or store its characters. */
2111 read_rest_of_line (COLUMN *p)
2116 while ((c = getc (f)) != '\n')
2120 if ((c = getc (f)) != '\n')
2135 /* Read a line with skip_to_page.
2137 Read from the current column's file until an end of line is
2138 hit. Used when we read full lines to skip pages.
2139 With skip_to_page we have to check for FF-coincidence which is done
2140 in function read_line otherwise.
2141 Count lines of skipped pages to find the line number of 1st page
2142 printed relative to 1st line of input file (start_line_num). */
2145 skip_read (COLUMN *p, int column_number)
2149 int i, single_ff = FALSE;
2152 /* Read 1st character in a line or any character succeeding a FF */
2153 if ((c = getc (f)) == '\f' && p->full_page_printed)
2154 /* A FF-coincidence with a previous full_page_printed.
2155 To avoid an additional empty page, eliminate the FF */
2156 if ((c = getc (f)) == '\n')
2159 p->full_page_printed = FALSE;
2161 /* 1st character a FF means a single FF without any printable
2162 characters. Don't count it as a line with -n option. */
2166 /* Preparing for a FF-coincidence: Maybe we finish that page
2167 without a FF found */
2169 p->full_page_printed = TRUE;
2175 /* No FF-coincidence possible,
2176 no catching up of a FF-coincidence with next page */
2179 if (!parallel_files)
2180 for (q = column_vector, i = columns; i; ++q, --i)
2181 q->full_page_printed = FALSE;
2183 p->full_page_printed = FALSE;
2186 if ((c = getc (f)) != '\n')
2200 if ((!parallel_files || column_number == 1) && !single_ff)
2204 /* If we're tabifying output,
2206 When print_char encounters white space it keeps track
2207 of our desired horizontal position and delays printing
2208 until this function is called. */
2211 print_white_space (void)
2214 register int h_old = output_position;
2215 register int goal = h_old + spaces_not_printed;
2217 while (goal - h_old > 1
2218 && (h_new = POS_AFTER_TAB (chars_per_output_tab, h_old)) <= goal)
2220 putchar (output_tab_char);
2223 while (++h_old <= goal)
2226 output_position = goal;
2227 spaces_not_printed = 0;
2230 /* Print column separators.
2232 We keep a count until we know that we'll be printing a line,
2233 then print_sep_string() is called. */
2239 int l = col_sep_length;
2243 if (separators_not_printed <= 0)
2245 /* We'll be starting a line with chars_per_margin, anything else? */
2246 if (spaces_not_printed > 0)
2247 print_white_space ();
2251 for (; separators_not_printed > 0; --separators_not_printed)
2255 /* 3 types of sep_strings: spaces only, spaces and chars,
2259 /* We're tabifying output; consecutive spaces in
2260 sep_string may have to be converted to tabs */
2262 ++spaces_not_printed;
2266 if (spaces_not_printed > 0)
2267 print_white_space ();
2272 /* sep_string ends with some spaces */
2273 if (spaces_not_printed > 0)
2274 print_white_space ();
2279 /* Print (or store, depending on p->char_func) a clump of N
2283 print_clump (COLUMN *p, int n, int *clump)
2286 (p->char_func) (*clump++);
2289 /* Print a character.
2291 Update the following comment: process-char hasn't been used any
2293 If we're tabifying, all tabs have been converted to spaces by
2294 process_char(). Keep a count of consecutive spaces, and when
2295 a nonspace is encountered, call print_white_space() to print the
2296 required number of tabs and spaces. */
2305 ++spaces_not_printed;
2308 else if (spaces_not_printed > 0)
2309 print_white_space ();
2311 /* Nonprintables are assumed to have width 0, except '\b'. */
2323 /* Skip to page PAGE before printing.
2324 PAGE may be larger than total number of pages. */
2327 skip_to_page (int page)
2332 for (n = 1; n < page; ++n)
2334 for (i = 1; i < lines_per_body; ++i)
2336 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2337 if (p->status == OPEN)
2341 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2342 if (p->status == OPEN)
2345 if (storing_columns) /* change FF_FOUND to ON_HOLD */
2346 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2347 if (p->status != CLOSED)
2348 p->status = ON_HOLD;
2353 if (files_ready_to_read < 1)
2355 /* It's very helpful, normally the total number of pages is
2356 not known in advance. */
2358 _("starting page number larger than total number of pages: `%d'"),
2363 return files_ready_to_read > 0;
2368 Formfeeds are assumed to use up two lines at the beginning of
2374 char page_text[256 + INT_STRLEN_BOUND (int)];
2375 int available_width;
2382 output_position = 0;
2383 pad_across_to (chars_per_margin);
2384 print_white_space ();
2386 /* The translator must ensure that formatting the translation of
2387 "Page %d" does not generate more than (sizeof page_text - 1)
2389 sprintf (page_text, _("Page %d"), page_number++);
2390 available_width = header_width_available - mbswidth (page_text, 0);
2391 available_width = MAX (0, available_width);
2392 lhs_spaces = available_width >> 1;
2393 rhs_spaces = available_width - lhs_spaces;
2395 printf ("%s%*s%s%*s%s\n\n\n",
2396 date_text, lhs_spaces, " ", file_text, rhs_spaces, " ", page_text);
2398 print_a_header = FALSE;
2399 output_position = 0;
2402 /* Print (or store, if p->char_func is store_char()) a line.
2404 Read a character to determine whether we have a line or not.
2405 (We may hit EOF, \n, or \f)
2407 Once we know we have a line,
2408 set pad_vertically = TRUE, meaning it's safe
2409 to pad down at the end of the page, since we do have a page.
2410 print a header if needed.
2411 pad across to padding_not_printed if needed.
2412 print any separators which need to be printed.
2413 print a line number if it needs to be printed.
2415 Print the clump which corresponds to the first character.
2417 Enter a loop and keep printing until an end of line condition
2418 exists, or until we exceed chars_per_column.
2420 Return FALSE if we exceed chars_per_column before reading
2421 an end of line character, TRUE otherwise. */
2424 read_line (COLUMN *p)
2427 int chars IF_LINT (= 0);
2428 int last_input_position;
2432 /* read 1st character in each line or any character succeeding a FF: */
2435 last_input_position = input_position;
2437 if (c == '\f' && p->full_page_printed)
2438 if ((c = getc (p->fp)) == '\n')
2440 p->full_page_printed = FALSE;
2445 if ((c = getc (p->fp)) != '\n')
2448 if (print_a_header && !storing_columns)
2450 pad_vertically = TRUE;
2463 chars = char_to_clump (c);
2466 if (truncate_lines && input_position > chars_per_column)
2468 input_position = last_input_position;
2472 if (p->char_func != store_char)
2474 pad_vertically = TRUE;
2476 if (print_a_header && !storing_columns)
2479 if (parallel_files && align_empty_cols)
2481 /* We have to align empty columns at the beginning of a line. */
2482 k = separators_not_printed;
2483 separators_not_printed = 0;
2484 for (j = 1, q = column_vector; j <= k; ++j, ++q)
2487 separators_not_printed += 1;
2489 padding_not_printed = p->start_position;
2491 spaces_not_printed = chars_per_column;
2493 spaces_not_printed = 0;
2494 align_empty_cols = FALSE;
2497 if (padding_not_printed - col_sep_length > 0)
2499 pad_across_to (padding_not_printed - col_sep_length);
2500 padding_not_printed = ANYWHERE;
2503 if (use_col_separator)
2504 print_sep_string ();
2508 add_line_number (p);
2514 print_clump (p, chars, clump_buff);
2525 if ((c = getc (p->fp)) != '\n')
2536 last_input_position = input_position;
2537 chars = char_to_clump (c);
2538 if (truncate_lines && input_position > chars_per_column)
2540 input_position = last_input_position;
2544 print_clump (p, chars, clump_buff);
2548 /* Print a line from buff.
2550 If this function has been called, we know we have "something to
2551 print". But it remains to be seen whether we have a real text page
2552 or an empty page (a single form feed) with/without a header only.
2553 Therefore first we set pad_vertically to TRUE and print a header
2555 If FF_FOUND and we are using -t|-T option we omit any newline by
2556 setting pad_vertically to FALSE (see print_page).
2557 Otherwise we pad across if necessary, print separators if necessary
2558 and text of COLUMN *p.
2560 Return TRUE, meaning there is no need to call read_rest_of_line. */
2563 print_stored (COLUMN *p)
2568 int line = p->current_line++;
2569 register char *first = &buff[line_vector[line]];
2571 UMR: Uninitialized memory read:
2572 * This is occurring while in:
2573 print_stored [pr.c:2239]
2574 * Reading 4 bytes from 0x5148c in the heap.
2575 * Address 0x5148c is 4 bytes into a malloc'd block at 0x51488 of 676 bytes
2576 * This block was allocated from:
2578 xmalloc [xmalloc.c:94]
2579 init_store_cols [pr.c:1648]
2581 register char *last = &buff[line_vector[line + 1]];
2583 pad_vertically = TRUE;
2588 if (p->status == FF_FOUND)
2590 for (i = 1, q = column_vector; i <= columns; ++i, ++q)
2591 q->status = ON_HOLD;
2592 if (column_vector->lines_to_print <= 0)
2595 pad_vertically = FALSE;
2596 return TRUE; /* print a header only */
2600 if (padding_not_printed - col_sep_length > 0)
2602 pad_across_to (padding_not_printed - col_sep_length);
2603 padding_not_printed = ANYWHERE;
2606 if (use_col_separator)
2607 print_sep_string ();
2609 while (first != last)
2610 print_char (*first++);
2612 if (spaces_not_printed == 0)
2614 output_position = p->start_position + end_vector[line];
2615 if (p->start_position - col_sep_length == chars_per_margin)
2616 output_position -= col_sep_length;
2622 /* Convert a character to the proper format and return the number of
2623 characters in the resulting clump. Increment input_position by
2624 the width of the clump.
2626 Tabs are converted to clumps of spaces.
2627 Nonprintable characters may be converted to clumps of escape
2628 sequences or control prefixes.
2630 Note: the width of a clump is not necessarily equal to the number of
2631 characters in clump_buff. (e.g, the width of '\b' is -1, while the
2632 number of characters is 1.) */
2635 char_to_clump (int c)
2637 register int *s = clump_buff;
2642 int chars_per_c = 8;
2644 if (c == input_tab_char)
2645 chars_per_c = chars_per_input_tab;
2647 if (c == input_tab_char || c == '\t')
2649 width = TAB_WIDTH (chars_per_c, input_position);
2653 for (i = width; i; --i)
2664 else if (!ISPRINT (c))
2666 if (use_esc_sequence)
2671 sprintf (esc_buff, "%03o", c);
2672 for (i = 0; i <= 2; ++i)
2673 *s++ = (int) esc_buff[i];
2675 else if (use_cntrl_prefix)
2689 sprintf (esc_buff, "%03o", c);
2690 for (i = 0; i <= 2; ++i)
2691 *s++ = (int) esc_buff[i];
2714 input_position += width;
2718 /* We've just printed some files and need to clean up things before
2719 looking for more options and printing the next batch of files.
2721 Free everything we've xmalloc'ed, except `header'. */
2731 free (column_vector);
2740 /* Complain, print a usage message, and die. */
2746 fprintf (stderr, _("Try `%s --help' for more information.\n"),
2751 Usage: %s [OPTION]... [FILE]...\n\
2756 Paginate or columnate FILE(s) for printing.\n\
2758 Mandatory arguments to long options are mandatory for short options too.\n\
2759 +FIRST_PAGE[:LAST_PAGE], --pages=FIRST_PAGE[:LAST_PAGE]\n\
2760 begin [stop] printing with page FIRST_[LAST_]PAGE\n\
2761 -COLUMN, --columns=COLUMN\n\
2762 produce COLUMN-column output and print columns down,\n\
2763 unless -a is used. Balance number of lines in the\n\
2764 columns on each page.\n\
2767 -a, --across print columns across rather than down, used together\n\
2769 -c, --show-control-chars\n\
2770 use hat notation (^G) and octal backslash notation\n\
2771 -d, --double-space\n\
2772 double space the output\n\
2775 -D, --date-format=FORMAT\n\
2776 use FORMAT for the header date\n\
2777 -e[CHAR[WIDTH]], --expand-tabs[=CHAR[WIDTH]]\n\
2778 expand input CHARs (TABs) to tab WIDTH (8)\n\
2779 -F, -f, --form-feed\n\
2780 use form feeds instead of newlines to separate pages\n\
2781 (by a 3-line page header with -F or a 5-line header\n\
2782 and trailer without -F)\n\
2785 -h HEADER, --header=HEADER\n\
2786 use a centered HEADER instead of filename in page header,\n\
2787 -h \"\" prints a blank line, don't use -h\"\"\n\
2788 -i[CHAR[WIDTH]], --output-tabs[=CHAR[WIDTH]]\n\
2789 replace spaces with CHARs (TABs) to tab WIDTH (8)\n\
2790 -J, --join-lines merge full lines, turns off -W line truncation, no column\n\
2791 alignment, -S[STRING] sets separators\n\
2794 -l PAGE_LENGTH, --length=PAGE_LENGTH\n\
2795 set the page length to PAGE_LENGTH (66) lines\n\
2796 (default number of lines of text 56, and with -F 63)\n\
2797 -m, --merge print all files in parallel, one in each column,\n\
2798 truncate lines, but join lines of full length with -J\n\
2801 -n[SEP[DIGITS]], --number-lines[=SEP[DIGITS]]\n\
2802 number lines, use DIGITS (5) digits, then SEP (TAB),\n\
2803 default counting starts with 1st line of input file\n\
2804 -N NUMBER, --first-line-number=NUMBER\n\
2805 start counting with NUMBER at 1st line of first\n\
2806 page printed (see +FIRST_PAGE)\n\
2809 -o MARGIN, --indent=MARGIN\n\
2810 offset each line with MARGIN (zero) spaces, do not\n\
2811 affect -w or -W, MARGIN will be added to PAGE_WIDTH\n\
2812 -r, --no-file-warnings\n\
2813 omit warning when a file cannot be opened\n\
2816 -s[CHAR],--separator[=CHAR]\n\
2817 separate columns by a single character, default for CHAR\n\
2818 is the <TAB> character without -w and \'no char\' with -w\n\
2819 -s[CHAR] turns off line truncation of all 3 column\n\
2820 options (-COLUMN|-a -COLUMN|-m) except -w is set\n\
2823 -S[STRING], --sep-string[=STRING]\n\
2824 separate columns by an optional STRING, don't use\n\
2825 -S \"STRING\", -S only: No separator used (same as -S\"\"),\n\
2826 without -S: Default separator <TAB> with -J and <space>\n\
2827 otherwise (same as -S\" \"), no effect on column options\n\
2828 -t, --omit-header omit page headers and trailers\n\
2831 -T, --omit-pagination\n\
2832 omit page headers and trailers, eliminate any pagination\n\
2833 by form feeds set in input files\n\
2834 -v, --show-nonprinting\n\
2835 use octal backslash notation\n\
2836 -w PAGE_WIDTH, --width=PAGE_WIDTH\n\
2837 set page width to PAGE_WIDTH (72) characters for\n\
2838 multiple text-column output only, -s[char] turns off (72)\n\
2841 -W PAGE_WIDTH, --page-width=PAGE_WIDTH\n\
2842 set page width to PAGE_WIDTH (72) characters always,\n\
2843 truncate lines, except -J option is set, no interference\n\
2845 --help display this help and exit\n\
2846 --version output version information and exit\n\
2850 -T implied by -l nn when nn <= 10 or <= 3 with -F. With no FILE, or when\n\
2851 FILE is -, read standard input.\n\
2853 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
2855 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);