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. */
379 FILE *fp; /* Input stream for this column. */
380 char *name; /* File name. */
384 FF_FOUND, /* used with -b option, set with \f, changed
385 to ON_HOLD after print_header */
386 ON_HOLD, /* Hit a form feed. */
389 status; /* Status of the file pointer. */
390 int (*print_func) (); /* Func to print lines in this col. */
391 void (*char_func) (); /* Func to print/store chars in this col. */
392 int current_line; /* Index of current place in line_vector. */
393 int lines_stored; /* Number of lines stored in buff. */
394 int lines_to_print; /* No. lines stored or space left on page. */
395 int start_position; /* Horizontal position of first char. */
397 int full_page_printed; /* True means printed without a FF found. */
399 /* p->full_page_printed controls a special case of "FF set by hand":
400 True means a full page has been printed without FF found. To avoid an
401 additional empty page we have to ignore a FF immediately following in
405 typedef struct COLUMN COLUMN;
407 #define NULLCOL (COLUMN *)0
409 static int char_to_clump PARAMS ((int c));
410 static int read_line PARAMS ((COLUMN *p));
411 static int print_page PARAMS ((void));
412 static int print_stored PARAMS ((COLUMN *p));
413 static int open_file PARAMS ((char *name, COLUMN *p));
414 static int skip_to_page PARAMS ((int page));
415 static void print_header PARAMS ((void));
416 static void pad_across_to PARAMS ((int position));
417 static void add_line_number PARAMS ((COLUMN *p));
418 static void getoptarg PARAMS ((char *arg, char switch_char, char *character,
420 void usage PARAMS ((int status));
421 static void print_files PARAMS ((int number_of_files, char **av));
422 static void init_parameters PARAMS ((int number_of_files));
423 static void init_header PARAMS ((char *filename, int desc));
424 static int init_fps PARAMS ((int number_of_files, char **av));
425 static void init_funcs PARAMS ((void));
426 static void init_store_cols PARAMS ((void));
427 static void store_columns PARAMS ((void));
428 static void balance PARAMS ((int total_stored));
429 static void store_char PARAMS ((int c));
430 static void pad_down PARAMS ((int lines));
431 static void read_rest_of_line PARAMS ((COLUMN *p));
432 static void skip_read PARAMS ((COLUMN *p, int column_number));
433 static void print_char PARAMS ((int c));
434 static void cleanup PARAMS ((void));
435 static void first_last_page PARAMS ((char *pages));
436 static void print_sep_string PARAMS ((void));
437 static void separator_string PARAMS ((const char *optarg_S));
439 /* The name under which this program was invoked. */
442 /* All of the columns to print. */
443 static COLUMN *column_vector;
445 /* When printing a single file in multiple downward columns,
446 we store the leftmost columns contiguously in buff.
447 To print a line from buff, get the index of the first character
448 from line_vector[i], and print up to line_vector[i + 1]. */
451 /* Index of the position in buff where the next character
453 static int buff_current;
455 /* The number of characters in buff.
456 Used for allocation of buff and to detect overflow of buff. */
457 static int buff_allocated;
459 /* Array of indices into buff.
460 Each entry is an index of the first character of a line.
461 This is used when storing lines to facilitate shuffling when
462 we do column balancing on the last page. */
463 static int *line_vector;
465 /* Array of horizonal positions.
466 For each line in line_vector, end_vector[line] is the horizontal
467 position we are in after printing that line. We keep track of this
468 so that we know how much we need to pad to prepare for the next
470 static int *end_vector;
472 /* (-m) True means we're printing multiple files in parallel. */
473 static int parallel_files = FALSE;
475 /* (-m) True means a line starts with some empty columns (some files
476 already CLOSED or ON_HOLD) which we have to align. */
477 static int align_empty_cols;
479 /* (-m) True means we have not yet found any printable column in a line.
480 align_empty_cols = TRUE has to be maintained. */
481 static int empty_line;
483 /* (-m) False means printable column output precedes a form feed found.
484 Column alignment is done only once. No additional action with that form
486 True means we found only a form feed in a column. Maybe we have to do
487 some column alignment with that form feed. */
490 /* (-[0-9]+) True means we're given an option explicitly specifying
491 number of columns. Used to detect when this option is used with -m
492 and when translating old options to new/long options. */
493 static int explicit_columns = FALSE;
495 /* (-t|-T) False means we aren't printing headers and footers. */
496 static int extremities = TRUE;
498 /* (-t) True means we retain all FF set by hand in input files.
499 False is set with -T option. */
500 static int keep_FF = FALSE;
501 static int print_a_FF = FALSE;
503 /* True means we need to print a header as soon as we know we've got input
504 to print after it. */
505 static int print_a_header;
507 /* (-f) True means use formfeeds instead of newlines to separate pages. */
508 static int use_form_feed = FALSE;
510 /* True means we have read the standard input. */
511 static int have_read_stdin = FALSE;
513 /* True means the -a flag has been given. */
514 static int print_across_flag = FALSE;
516 /* True means we're printing one file in multiple (>1) downward columns. */
517 static int storing_columns = TRUE;
519 /* (-b) True means balance columns on the last page as Sys V does. */
520 /* That's no longer an independent option. With storing_columns = TRUE
521 balance_columns = TRUE is used too (s. function init_parameters).
522 We get a consistent formulation with "FF set by hand" in input files. */
523 static int balance_columns = FALSE;
525 /* (-l) Number of lines on a page, including header and footer lines. */
526 static int lines_per_page = 66;
528 /* Number of lines in the header and footer can be reset to 0 using
530 static int lines_per_header = 5;
531 static int lines_per_body;
532 static int lines_per_footer = 5;
534 /* (-w|-W) Width in characters of the page. Does not include the width of
536 static int chars_per_line = 72;
538 /* (-w|W) True means we truncate lines longer than chars_per_column. */
539 static int truncate_lines = FALSE;
541 /* (-J) True means we join lines without any line truncation. -J
542 dominates -w option. */
543 static int join_lines = FALSE;
545 /* Number of characters in a column. Based on col_sep_length and
547 static int chars_per_column;
549 /* (-e) True means convert tabs to spaces on input. */
550 static int untabify_input = FALSE;
552 /* (-e) The input tab character. */
553 static char input_tab_char = '\t';
555 /* (-e) Tabstops are at chars_per_tab, 2*chars_per_tab, 3*chars_per_tab, ...
556 where the leftmost column is 1. */
557 static int chars_per_input_tab = 8;
559 /* (-i) True means convert spaces to tabs on output. */
560 static int tabify_output = FALSE;
562 /* (-i) The output tab character. */
563 static char output_tab_char = '\t';
565 /* (-i) The width of the output tab. */
566 static int chars_per_output_tab = 8;
568 /* Keeps track of pending white space. When we hit a nonspace
569 character after some whitespace, we print whitespace, tabbing
570 if necessary to get to output_position + spaces_not_printed. */
571 static int spaces_not_printed;
573 /* (-o) Number of spaces in the left margin (tabs used when possible). */
574 static int chars_per_margin = 0;
576 /* Position where the next character will fall.
577 Leftmost position is 0 + chars_per_margin.
578 Rightmost position is chars_per_margin + chars_per_line - 1.
579 This is important for converting spaces to tabs on output. */
580 static int output_position;
582 /* Horizontal position relative to the current file.
583 (output_position depends on where we are on the page;
584 input_position depends on where we are in the file.)
585 Important for converting tabs to spaces on input. */
586 static int input_position;
588 /* Count number of failed opens so we can exit with nonzero
589 status if there were any. */
590 static int failed_opens = 0;
592 /* The number of spaces taken up if we print a tab character with width
593 c_ from position h_. */
594 #define TAB_WIDTH(c_, h_) ((c_) - ((h_) % (c_)))
596 /* The horizontal position we'll be at after printing a tab character
597 of width c_ from the position h_. */
598 #define POS_AFTER_TAB(c_, h_) ((h_) + TAB_WIDTH (c_, h_))
600 /* (-NNN) Number of columns of text to print. */
601 static int columns = 1;
603 /* (+NNN:MMM) Page numbers on which to begin and stop printing.
604 first_page_number = 0 will be used to check input only. */
605 static int first_page_number = 0;
606 static int last_page_number = 0;
608 /* Number of files open (not closed, not on hold). */
609 static int files_ready_to_read = 0;
611 /* Current page number. Displayed in header. */
612 static int page_number;
614 /* Current line number. Displayed when -n flag is specified.
616 When printing files in parallel (-m flag), line numbering is as follows:
620 When printing files across (-a flag), ...
624 Otherwise, line numbering is as follows:
627 static int line_number;
629 /* With line_number overflow, we use power_10 to cut off the higher-order
630 digits of the line_number */
633 /* (-n) True means lines should be preceded by numbers. */
634 static int numbered_lines = FALSE;
636 /* (-n) Character which follows each line number. */
637 static char number_separator = '\t';
639 /* (-n) line counting starts with 1st line of input file (not with 1st
640 line of 1st page printed). */
641 static int line_count = 1;
643 /* (-n) True means counting of skipped lines starts with 1st line of
644 input file. False means -N option is used in addition, counting of
645 skipped lines not required. */
646 static int skip_count = TRUE;
648 /* (-N) Counting starts with start_line_number = NUMBER at 1st line of
649 first page printed, usually not 1st page of input file. */
650 static int start_line_num = 1;
652 /* (-n) Width in characters of a line number. */
653 static int chars_per_number = 5;
655 /* Used when widening the first column to accommodate numbers -- only
656 needed when printing files in parallel. Includes width of both the
657 number and the number_separator. */
658 static int number_width;
660 /* Buffer sprintf uses to format a line number. */
661 static char *number_buff;
663 /* (-v) True means unprintable characters are printed as escape sequences.
664 control-g becomes \007. */
665 static int use_esc_sequence = FALSE;
667 /* (-c) True means unprintable characters are printed as control prefixes.
668 control-g becomes ^G. */
669 static int use_cntrl_prefix = FALSE;
671 /* (-d) True means output is double spaced. */
672 static int double_space = FALSE;
674 /* Number of files opened initially in init_files. Should be 1
675 unless we're printing multiple files in parallel. */
676 static int total_files = 0;
678 /* (-r) True means don't complain if we can't open a file. */
679 static int ignore_failed_opens = FALSE;
681 /* (-S) True means we separate columns with a specified string.
682 -S option does not affect line truncation nor column alignment. */
683 static int use_col_separator = FALSE;
685 /* String used to separate columns if the -S option has been specified.
686 Default without -S but together with one of the column options
687 -a|COLUMN|-m is a `space' and with the -J option a `tab'. */
688 static char *col_sep_string = "";
689 static int col_sep_length = 0;
690 static char *column_separator = " ";
691 static char *line_separator = "\t";
693 /* Number of separator characters waiting to be printed as soon as we
694 know that we have any input remaining to be printed. */
695 static int separators_not_printed;
697 /* Position we need to pad to, as soon as we know that we have input
698 remaining to be printed. */
699 static int padding_not_printed;
701 /* True means we should pad the end of the page. Remains false until we
702 know we have a page to print. */
703 static int pad_vertically;
705 /* (-h) String of characters used in place of the filename in the header. */
706 static char *custom_header;
708 /* (-D) Date format for the header. */
709 static char const *date_format;
711 /* Date and file name for the header. */
712 static char *date_text;
713 static char const *file_text;
715 /* Output columns available, not counting the date and file name. */
716 static int header_width_available;
718 static int *clump_buff;
720 /* True means we read the line no. lines_per_body in skip_read
721 called by skip_to_page. That variable controls the coincidence of a
722 "FF set by hand" and "full_page_printed", see above the definition of
724 static int last_line = FALSE;
726 /* For long options that have no equivalent short option, use a
727 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
730 PAGES_OPTION = CHAR_MAX + 1,
734 static struct option const long_options[] =
736 {"pages", required_argument, NULL, PAGES_OPTION},
737 {"columns", required_argument, NULL, COLUMNS_OPTION},
738 {"across", no_argument, NULL, 'a'},
739 {"show-control-chars", no_argument, NULL, 'c'},
740 {"double-space", no_argument, NULL, 'd'},
741 {"date-format", required_argument, NULL, 'D'},
742 {"expand-tabs", optional_argument, NULL, 'e'},
743 {"form-feed", no_argument, NULL, 'f'},
744 {"header", required_argument, NULL, 'h'},
745 {"output-tabs", optional_argument, NULL, 'i'},
746 {"join-lines", no_argument, NULL, 'J'},
747 {"length", required_argument, NULL, 'l'},
748 {"merge", no_argument, NULL, 'm'},
749 {"number-lines", optional_argument, NULL, 'n'},
750 {"first-line-number", required_argument, NULL, 'N'},
751 {"indent", required_argument, NULL, 'o'},
752 {"no-file-warnings", no_argument, NULL, 'r'},
753 {"separator", optional_argument, NULL, 's'},
754 {"sep-string", optional_argument, NULL, 'S'},
755 {"omit-header", no_argument, NULL, 't'},
756 {"omit-pagination", no_argument, NULL, 'T'},
757 {"show-nonprinting", no_argument, NULL, 'v'},
758 {"width", required_argument, NULL, 'w'},
759 {"page-width", required_argument, NULL, 'W'},
760 {GETOPT_HELP_OPTION_DECL},
761 {GETOPT_VERSION_OPTION_DECL},
765 /* Return the number of columns that have either an open file or
769 cols_ready_to_print (void)
776 for (q = column_vector, i = 0; i < columns; ++q, ++i)
777 if (q->status == OPEN ||
778 q->status == FF_FOUND || /* With -b: To print a header only */
779 (storing_columns && q->lines_stored > 0 && q->lines_to_print > 0))
784 /* Estimate first_ / last_page_number
785 using option +FIRST_PAGE:LAST_PAGE */
788 first_last_page (char *pages)
794 error (0, 0, _("`--pages' invalid range of page numbers: `%s'"), pages);
798 str1 = strchr (pages, ':');
804 if (xstrtol (pages, NULL, 10, &tmp_long, "") != LONGINT_OK
805 || tmp_long < 1 || tmp_long > INT_MAX)
806 error (EXIT_FAILURE, 0, _("`--pages' invalid starting page number: `%s'"),
808 first_page_number = (int) tmp_long;
816 if (xstrtol (str1 + 1, NULL, 10, &tmp_long, "") != LONGINT_OK
817 || tmp_long <= 0 || tmp_long > INT_MAX)
818 error (EXIT_FAILURE, 0, _("`--pages' invalid ending page number: `%s'"),
820 last_page_number = (int) tmp_long;
823 if (first_page_number > last_page_number)
824 error (EXIT_FAILURE, 0,
825 _("`--pages' starting page number is larger than ending page number"));
828 /* Estimate length of col_sep_string with option -S[STRING] */
831 separator_string (const char *optarg_S)
833 col_sep_length = (int) strlen (optarg_S);
834 col_sep_string = (char *) xmalloc (col_sep_length + 1);
835 strcpy (col_sep_string, optarg_S);
839 main (int argc, char **argv)
844 int old_options = FALSE;
849 program_name = argv[0];
850 setlocale (LC_ALL, "");
851 bindtextdomain (PACKAGE, LOCALEDIR);
852 textdomain (PACKAGE);
854 atexit (close_stdout);
857 file_names = (argc > 1
858 ? (char **) xmalloc ((argc - 1) * sizeof (char *))
861 while ((c = getopt_long (argc, argv,
862 "-0123456789abcdD:e::fFh:i::Jl:mn::N:o:rs::S::tTvw:W:",
868 accum = accum * 10 + c - '0';
875 explicit_columns = TRUE;
881 case 0: /* getopt long option */
884 case 1: /* Non-option argument. */
887 /* long option --page dominates old `+FIRST_PAGE ...' */
888 if (first_page_number <= 0 && last_page_number <= 0)
889 first_last_page (optarg);
892 file_names[n_files++] = optarg;
895 case PAGES_OPTION: /* --pages=FIRST_PAGE[:LAST_PAGE] */
896 { /* dominates old opt +... */
898 first_last_page (optarg);
900 error (EXIT_FAILURE, 0,
901 _("`--pages=FIRST_PAGE[:LAST_PAGE]' missing argument"));
905 case COLUMNS_OPTION: /* --columns=COLUMN */
908 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
909 || tmp_long <= 0 || tmp_long > INT_MAX)
911 error (EXIT_FAILURE, 0,
912 _("`--columns=COLUMN' invalid number of columns: `%s'"),
915 columns = (int) tmp_long;
920 print_across_flag = TRUE;
921 storing_columns = FALSE;
924 balance_columns = TRUE;
927 use_cntrl_prefix = TRUE;
933 date_format = optarg;
937 getoptarg (optarg, 'e', &input_tab_char,
938 &chars_per_input_tab);
939 /* Could check tab width > 0. */
940 untabify_input = TRUE;
944 use_form_feed = TRUE;
947 custom_header = optarg;
951 getoptarg (optarg, 'i', &output_tab_char,
952 &chars_per_output_tab);
953 /* Could check tab width > 0. */
954 tabify_output = TRUE;
962 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
963 || tmp_long <= 0 || tmp_long > INT_MAX)
965 error (EXIT_FAILURE, 0,
966 _("`-l PAGE_LENGTH' invalid number of lines: `%s'"),
969 lines_per_page = (int) tmp_long;
973 parallel_files = TRUE;
974 storing_columns = FALSE;
977 numbered_lines = TRUE;
979 getoptarg (optarg, 'n', &number_separator,
986 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
987 || tmp_long > INT_MAX)
989 error (EXIT_FAILURE, 0,
990 _("`-N NUMBER' invalid starting line number: `%s'"),
993 start_line_num = (int) tmp_long;
999 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1000 || tmp_long < 0 || tmp_long > INT_MAX)
1001 error (EXIT_FAILURE, 0,
1002 _("`-o MARGIN' invalid line offset: `%s'"), optarg);
1003 chars_per_margin = (int) tmp_long;
1007 ignore_failed_opens = TRUE;
1012 if (!use_col_separator && optarg)
1013 separator_string (optarg);
1017 /* Reset an additional input of -s, -S dominates -s */
1018 col_sep_string = "";
1020 use_col_separator = TRUE;
1022 separator_string (optarg);
1025 extremities = FALSE;
1029 extremities = FALSE;
1033 use_esc_sequence = TRUE;
1040 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1041 || tmp_long <= 0 || tmp_long > INT_MAX)
1042 error (EXIT_FAILURE, 0,
1043 _("`-w PAGE_WIDTH' invalid number of characters: `%s'"), optarg);
1044 if (!truncate_lines) chars_per_line = (int) tmp_long;
1048 old_w = FALSE; /* dominates -w */
1049 truncate_lines = TRUE;
1052 if (xstrtol (optarg, NULL, 10, &tmp_long, "") != LONGINT_OK
1053 || tmp_long <= 0 || tmp_long > INT_MAX)
1054 error (EXIT_FAILURE, 0,
1055 _("`-W PAGE_WIDTH' invalid number of characters: `%s'"), optarg);
1056 chars_per_line = (int) tmp_long;
1059 case_GETOPT_HELP_CHAR;
1060 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1068 date_format = (getenv ("POSIXLY_CORRECT")
1069 ? dcgettext (NULL, "%b %e %H:%M %Y", LC_TIME)
1070 : "%Y-%m-%d %H:%M");
1072 /* Now we can set a reasonable initial value: */
1073 if (first_page_number == 0)
1074 first_page_number = 1;
1076 if (parallel_files && explicit_columns)
1077 error (EXIT_FAILURE, 0,
1078 _("Cannot specify number of columns when printing in parallel."));
1080 if (parallel_files && print_across_flag)
1081 error (EXIT_FAILURE, 0,
1082 _("Cannot specify both printing across and printing in parallel."));
1084 /* Translate some old short options to new/long options.
1085 To meet downward compatibility with other UNIX pr utilities
1086 and some POSIX specifications. */
1092 if (parallel_files || explicit_columns)
1095 truncate_lines = TRUE;
1097 /* adapt HP-UX and SunOS: -s = no separator;
1099 use_col_separator = TRUE;
1102 /* old -w sets width with columns only
1106 else if (!use_col_separator)
1108 /* No -S option read */
1109 if (old_s && (parallel_files || explicit_columns))
1111 if (!truncate_lines)
1113 /* old -s (without -w and -W) annuls column alignment,
1114 uses fields, activate -J */
1116 if (col_sep_length > 0)
1118 use_col_separator = TRUE;
1122 /* adapt HP-UX and SunOS: -s = no separator;
1124 use_col_separator = TRUE;
1129 for (; optind < argc; optind++)
1131 file_names[n_files++] = argv[optind];
1136 /* No file arguments specified; read from standard input. */
1137 print_files (0, NULL);
1142 print_files (n_files, file_names);
1146 for (i = 0; i < n_files; i++)
1147 print_files (1, &file_names[i]);
1153 if (have_read_stdin && fclose (stdin) == EOF)
1154 error (EXIT_FAILURE, errno, _("standard input"));
1155 if (failed_opens > 0)
1156 exit (EXIT_FAILURE);
1157 exit (EXIT_SUCCESS);
1160 /* Parse options of the form -scNNN.
1162 Example: -nck, where 'n' is the option, c is the optional number
1163 separator, and k is the optional width of the field used when printing
1167 getoptarg (char *arg, char switch_char, char *character, int *number)
1169 if (!ISDIGIT (*arg))
1170 *character = *arg++;
1174 if (xstrtol (arg, NULL, 10, &tmp_long, "") != LONGINT_OK
1175 || tmp_long <= 0 || tmp_long > INT_MAX)
1178 _("`-%c' extra characters or invalid number in the argument: `%s'"),
1182 *number = (int) tmp_long;
1186 /* Set parameters related to formatting. */
1189 init_parameters (int number_of_files)
1191 int chars_used_by_number = 0;
1195 lines_per_header = 3;
1196 lines_per_footer = 0;
1199 lines_per_body = lines_per_page - lines_per_header - lines_per_footer;
1200 if (lines_per_body <= 0)
1202 extremities = FALSE;
1205 if (extremities == FALSE)
1206 lines_per_body = lines_per_page;
1209 lines_per_body = lines_per_body / 2;
1211 /* If input is stdin, cannot print parallel files. BSD dumps core
1213 if (number_of_files == 0)
1214 parallel_files = FALSE;
1217 columns = number_of_files;
1219 /* One file, multi columns down: -b option is set to get a consistent
1220 formulation with "FF set by hand" in input files. */
1221 if (storing_columns)
1222 balance_columns = TRUE;
1224 /* Tabification is assumed for multiple columns. */
1227 if (!use_col_separator)
1229 /* Use default separator */
1231 col_sep_string = line_separator;
1233 col_sep_string = column_separator;
1236 use_col_separator = TRUE;
1238 /* It's rather pointless to define a TAB separator with column
1240 else if (!join_lines && *col_sep_string == '\t')
1241 col_sep_string = column_separator;
1243 truncate_lines = TRUE;
1244 untabify_input = TRUE;
1245 tabify_output = TRUE;
1248 storing_columns = FALSE;
1250 /* -J dominates -w in any case */
1252 truncate_lines = FALSE;
1257 int chars_per_default_tab = 8;
1259 line_count = start_line_num;
1261 /* To allow input tab-expansion (-e sensitive) use:
1262 if (number_separator == input_tab_char)
1263 number_width = chars_per_number +
1264 TAB_WIDTH (chars_per_input_tab, chars_per_number); */
1266 /* Estimate chars_per_text without any margin and keep it constant. */
1267 if (number_separator == '\t')
1268 number_width = chars_per_number +
1269 TAB_WIDTH (chars_per_default_tab, chars_per_number);
1271 number_width = chars_per_number + 1;
1273 /* The number is part of the column width unless we are
1274 printing files in parallel. */
1276 chars_used_by_number = number_width;
1278 /* We use power_10 to cut off the higher-order digits of the
1279 line_number in function add_line_number */
1280 tmp_i = chars_per_number;
1281 for (power_10 = 1; tmp_i > 0; --tmp_i)
1282 power_10 = 10 * power_10;
1285 chars_per_column = (chars_per_line - chars_used_by_number -
1286 (columns - 1) * col_sep_length) / columns;
1288 if (chars_per_column < 1)
1289 error (EXIT_FAILURE, 0, _("page width too narrow"));
1293 if (number_buff != NULL)
1295 number_buff = (char *) xmalloc (2 * chars_per_number);
1298 /* Pick the maximum between the tab width and the width of an
1300 The width of an escape sequence (4) isn't the lower limit any longer.
1301 We've to use 8 as the lower limit, if we use chars_per_default_tab = 8
1302 to expand a tab which is not an input_tab-char. */
1303 if (clump_buff != NULL)
1305 clump_buff = (int *) xmalloc ((chars_per_input_tab > 8
1306 ? chars_per_input_tab : 8) * sizeof (int));
1309 /* Open the necessary files,
1310 maintaining a COLUMN structure for each column.
1312 With multiple files, each column p has a different p->fp.
1313 With single files, each column p has the same p->fp.
1314 Return 1 if (number_of_files > 0) and no files can be opened,
1317 With each column/file p, p->full_page_printed is initialized,
1318 see also open_file. */
1321 init_fps (int number_of_files, char **av)
1330 if (column_vector != NULLCOL)
1331 free ((char *) column_vector);
1332 column_vector = (COLUMN *) xmalloc (columns * sizeof (COLUMN));
1336 files_left = number_of_files;
1337 for (p = column_vector; files_left--; ++p, ++av)
1339 if (open_file (*av, p) == 0)
1347 init_header ("", -1);
1352 if (number_of_files > 0)
1354 if (open_file (*av, p) == 0)
1356 init_header (*av, fileno (p->fp));
1357 p->lines_stored = 0;
1361 p->name = _("standard input");
1363 have_read_stdin = TRUE;
1365 p->full_page_printed = FALSE;
1367 init_header ("", -1);
1368 p->lines_stored = 0;
1371 firstname = p->name;
1373 for (i = columns - 1, ++p; i; --i, ++p)
1375 p->name = firstname;
1378 p->full_page_printed = FALSE;
1379 p->lines_stored = 0;
1382 files_ready_to_read = total_files;
1386 /* Determine print_func and char_func, the functions
1387 used by each column for printing and/or storing.
1389 Determine the horizontal position desired when we begin
1390 printing a column (p->start_position). */
1398 h = chars_per_margin;
1400 if (!truncate_lines)
1404 /* When numbering lines of parallel files, we enlarge the
1405 first column to accomodate the number. Looks better than
1406 the Sys V approach. */
1407 if (parallel_files && numbered_lines)
1408 h_next = h + chars_per_column + number_width;
1410 h_next = h + chars_per_column;
1413 /* Enlarge p->start_position of first column to use the same form of
1414 padding_not_printed with all columns. */
1415 h = h + col_sep_length;
1417 /* This loop takes care of all but the rightmost column. */
1419 for (p = column_vector, i = 1; i < columns; ++p, ++i)
1421 if (storing_columns) /* One file, multi columns down. */
1423 p->char_func = store_char;
1424 p->print_func = print_stored;
1427 /* One file, multi columns across; or parallel files. */
1429 p->char_func = print_char;
1430 p->print_func = read_line;
1433 /* Number only the first column when printing files in
1435 p->numbered = numbered_lines && (!parallel_files || i == 1);
1436 p->start_position = h;
1438 /* If we don't truncate lines, all start_positions are
1439 ANYWHERE, except the first column's start_position when
1442 if (!truncate_lines)
1449 h = h_next + col_sep_length;
1450 h_next = h + chars_per_column;
1454 /* The rightmost column.
1456 Doesn't need to be stored unless we intend to balance
1457 columns on the last page. */
1458 if (storing_columns && balance_columns)
1460 p->char_func = store_char;
1461 p->print_func = print_stored;
1465 p->char_func = print_char;
1466 p->print_func = read_line;
1469 p->numbered = numbered_lines && (!parallel_files || i == 1);
1470 p->start_position = h;
1473 /* Open a file. Return nonzero if successful, zero if failed.
1475 With each file p, p->full_page_printed is initialized,
1476 see also init_fps. */
1479 open_file (char *name, COLUMN *p)
1481 if (STREQ (name, "-"))
1483 p->name = _("standard input");
1485 have_read_stdin = 1;
1490 p->fp = fopen (name, "r");
1495 if (!ignore_failed_opens)
1496 error (0, errno, "%s", name);
1500 p->full_page_printed = FALSE;
1505 /* Close the file in P.
1507 If we aren't dealing with multiple files in parallel, we change
1508 the status of all columns in the column list to reflect the close. */
1511 close_file (COLUMN *p)
1516 if (p->status == CLOSED)
1519 error (EXIT_FAILURE, errno, "%s", p->name);
1520 if (p->fp != stdin && fclose (p->fp) == EOF)
1521 error (EXIT_FAILURE, errno, "%s", p->name);
1523 if (!parallel_files)
1525 for (q = column_vector, i = columns; i; ++q, --i)
1528 if (q->lines_stored == 0)
1530 q->lines_to_print = 0;
1537 p->lines_to_print = 0;
1540 --files_ready_to_read;
1543 /* Put a file on hold until we start a new page,
1544 since we've hit a form feed.
1546 If we aren't dealing with parallel files, we must change the
1547 status of all columns in the column list. */
1550 hold_file (COLUMN *p)
1555 if (!parallel_files)
1556 for (q = column_vector, i = columns; i; ++q, --i)
1558 if (storing_columns)
1559 q->status = FF_FOUND;
1561 q->status = ON_HOLD;
1564 p->status = ON_HOLD;
1566 p->lines_to_print = 0;
1567 --files_ready_to_read;
1570 /* Undo hold_file -- go through the column list and change any
1571 ON_HOLD columns to OPEN. Used at the end of each page. */
1579 for (p = column_vector; i; --i, ++p)
1580 if (p->status == ON_HOLD)
1583 files_ready_to_read++;
1586 if (storing_columns)
1588 if (column_vector->status == CLOSED)
1589 /* We use the info to output an error message in skip_to_page. */
1590 files_ready_to_read = 0;
1592 files_ready_to_read = 1;
1596 /* Print a single file, or multiple files in parallel.
1598 Set up the list of columns, opening the necessary files.
1599 Allocate space for storing columns, if necessary.
1600 Skip to first_page_number, if user has asked to skip leading pages.
1601 Determine which functions are appropriate to store/print lines
1603 Print the file(s). */
1606 print_files (int number_of_files, char **av)
1608 init_parameters (number_of_files);
1609 if (init_fps (number_of_files, av))
1611 if (storing_columns)
1614 if (first_page_number > 1)
1616 if (!skip_to_page (first_page_number))
1619 page_number = first_page_number;
1626 line_number = line_count;
1627 while (print_page ())
1631 /* Initialize header information.
1632 If DESC is non-negative, it is a file descriptor open to
1633 FILENAME for reading. */
1636 init_header (char *filename, int desc)
1639 char initbuf[MAX (256, INT_STRLEN_BOUND (long) + 1)];
1643 /* If parallel files or standard input, use current date. */
1644 if (STREQ (filename, "-"))
1646 if (desc < 0 || fstat (desc, &st) != 0)
1647 st.st_mtime = time (NULL);
1650 tm = localtime (&st.st_mtime);
1652 sprintf (buf, "%ld", (long) st.st_mtime);
1655 size_t bufsize = sizeof initbuf;
1659 if (strftime (buf, bufsize, date_format, tm) || ! *buf)
1661 buf = alloca (bufsize *= 2);
1667 date_text = xstrdup (buf);
1668 file_text = custom_header ? custom_header : desc < 0 ? "" : filename;
1669 header_width_available = (chars_per_line
1670 - mbswidth (date_text, 0)
1671 - mbswidth (file_text, 0));
1674 /* Set things up for printing a page
1676 Scan through the columns ...
1677 Determine which are ready to print
1678 (i.e., which have lines stored or open files)
1679 Set p->lines_to_print appropriately
1680 (to p->lines_stored if we're storing, or lines_per_body
1681 if we're reading straight from the file)
1682 Keep track of this total so we know when to stop printing */
1690 if (storing_columns)
1693 for (j = columns - 1, p = column_vector; j; --j, ++p)
1695 p->lines_to_print = p->lines_stored;
1699 if (balance_columns)
1701 p->lines_to_print = p->lines_stored;
1703 /* Since we're not balancing columns, we don't need to store
1704 the rightmost column. Read it straight from the file. */
1707 if (p->status == OPEN)
1709 p->lines_to_print = lines_per_body;
1712 p->lines_to_print = 0;
1716 for (j = columns, p = column_vector; j; --j, ++p)
1717 if (p->status == OPEN)
1719 p->lines_to_print = lines_per_body;
1722 p->lines_to_print = 0;
1725 /* Align empty columns and print separators.
1726 Empty columns will be formed by files with status ON_HOLD or CLOSED
1727 when printing multiple files in parallel. */
1730 align_column (COLUMN *p)
1732 padding_not_printed = p->start_position;
1733 if (padding_not_printed - col_sep_length > 0)
1735 pad_across_to (padding_not_printed - col_sep_length);
1736 padding_not_printed = ANYWHERE;
1739 if (use_col_separator)
1740 print_sep_string ();
1743 add_line_number (p);
1748 As long as there are lines left on the page and columns ready to print,
1749 Scan across the column list
1750 if the column has stored lines or the file is open
1751 pad to the appropriate spot
1753 pad the remainder of the page with \n or \f as requested
1754 reset the status of all files -- any files which where on hold because
1755 of formfeeds are now put back into the lineup. */
1761 int lines_left_on_page;
1764 /* Used as an accumulator (with | operator) of successive values of
1765 pad_vertically. The trick is to set pad_vertically
1766 to zero before each run through the inner loop, then after that
1767 loop, it tells us whether a line was actually printed (whether a
1768 newline needs to be output -- or two for double spacing). But those
1769 values have to be accumulated (in pv) so we can invoke pad_down
1770 properly after the outer loop completes. */
1775 if (cols_ready_to_print () == 0)
1779 print_a_header = TRUE;
1781 /* Don't pad unless we know a page was printed. */
1782 pad_vertically = FALSE;
1785 lines_left_on_page = lines_per_body;
1787 lines_left_on_page *= 2;
1789 while (lines_left_on_page > 0 && cols_ready_to_print () > 0)
1791 output_position = 0;
1792 spaces_not_printed = 0;
1793 separators_not_printed = 0;
1794 pad_vertically = FALSE;
1795 align_empty_cols = FALSE;
1798 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
1801 if (p->lines_to_print > 0 || p->status == FF_FOUND)
1804 padding_not_printed = p->start_position;
1805 if (!(p->print_func) (p))
1806 read_rest_of_line (p);
1807 pv |= pad_vertically;
1809 --p->lines_to_print;
1810 if (p->lines_to_print <= 0)
1812 if (cols_ready_to_print () <= 0)
1816 /* File p changed its status to ON_HOLD or CLOSED */
1817 if (parallel_files && p->status != OPEN)
1820 align_empty_cols = TRUE;
1821 else if (p->status == CLOSED ||
1822 (p->status == ON_HOLD && FF_only))
1826 else if (parallel_files)
1828 /* File status ON_HOLD or CLOSED */
1830 align_empty_cols = TRUE;
1835 /* We need it also with an empty column */
1836 if (use_col_separator)
1837 ++separators_not_printed;
1843 --lines_left_on_page;
1846 if (cols_ready_to_print () <= 0 && !extremities)
1849 if (double_space && pv)
1852 --lines_left_on_page;
1856 if (lines_left_on_page == 0)
1857 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
1858 if (p->status == OPEN)
1859 p->full_page_printed = TRUE;
1861 pad_vertically = pv;
1863 if (pad_vertically && extremities)
1864 pad_down (lines_left_on_page + lines_per_footer);
1865 else if (keep_FF && print_a_FF)
1871 if (last_page_number && page_number > last_page_number)
1872 return FALSE; /* Stop printing with LAST_PAGE */
1874 reset_status (); /* Change ON_HOLD to OPEN. */
1876 return TRUE; /* More pages to go. */
1879 /* Allocate space for storing columns.
1881 This is necessary when printing multiple columns from a single file.
1882 Lines are stored consecutively in buff, separated by '\0'.
1884 The following doesn't apply any longer - any tuning possible?
1885 (We can't use a fixed offset since with the '-s' flag lines aren't
1888 We maintain a list (line_vector) of pointers to the beginnings
1889 of lines in buff. We allocate one more than the number of lines
1890 because the last entry tells us the index of the last character,
1891 which we need to know in order to print the last line in buff. */
1894 init_store_cols (void)
1896 int total_lines = lines_per_body * columns;
1897 int chars_if_truncate = total_lines * (chars_per_column + 1);
1899 if (line_vector != NULL)
1900 free ((int *) line_vector);
1901 /* FIXME: here's where it was allocated. */
1902 line_vector = (int *) xmalloc ((total_lines + 1) * sizeof (int *));
1904 if (end_vector != NULL)
1905 free ((int *) end_vector);
1906 end_vector = (int *) xmalloc (total_lines * sizeof (int *));
1910 buff_allocated = (use_col_separator
1911 ? 2 * chars_if_truncate
1912 : chars_if_truncate); /* Tune this. */
1913 buff = (char *) xmalloc (buff_allocated);
1916 /* Store all but the rightmost column.
1917 (Used when printing a single file in multiple downward columns)
1920 set p->current_line to be the index in line_vector of the
1921 first line in the column
1922 For each line in the column
1923 store the line in buff
1924 add to line_vector the index of the line's first char
1925 buff_start is the index in buff of the first character in the
1929 store_columns (void)
1934 int last_col; /* The rightmost column which will be saved in buff */
1940 if (balance_columns)
1943 last_col = columns - 1;
1945 for (i = 1, p = column_vector; i <= last_col; ++i, ++p)
1946 p->lines_stored = 0;
1948 for (i = 1, p = column_vector; i <= last_col && files_ready_to_read;
1951 p->current_line = line;
1952 for (j = lines_per_body; j && files_ready_to_read; --j)
1954 if (p->status == OPEN) /* Redundant. Clean up. */
1959 read_rest_of_line (p);
1961 if (p->status == OPEN
1962 || buff_start != buff_current)
1965 line_vector[line] = buff_start;
1966 end_vector[line++] = input_position;
1967 buff_start = buff_current;
1972 /* Keep track of the location of the last char in buff. */
1973 line_vector[line] = buff_start;
1975 if (balance_columns)
1980 balance (int total_stored)
1986 for (i = 1, p = column_vector; i <= columns; ++i, ++p)
1988 lines = total_stored / columns;
1989 if (i <= total_stored % columns)
1992 p->lines_stored = lines;
1993 p->current_line = first_line;
1995 first_line += lines;
1999 /* Store a character in the buffer. */
2004 if (buff_current >= buff_allocated)
2006 /* May be too generous. */
2007 buff_allocated = 2 * buff_allocated;
2008 buff = (char *) xrealloc (buff, buff_allocated * sizeof (char));
2010 buff[buff_current++] = (char) c;
2014 add_line_number (COLUMN *p)
2020 /* Cutting off the higher-order digits is more informative than
2021 lower-order cut off*/
2022 if (line_number < power_10)
2023 sprintf (number_buff, "%*d", chars_per_number, line_number);
2026 left_cut = line_number % power_10;
2027 sprintf (number_buff, "%0*d", chars_per_number, left_cut);
2031 for (i = chars_per_number; i > 0; i--)
2032 (p->char_func) ((int) *s++);
2036 /* Tabification is assumed for multiple columns, also for n-separators,
2037 but `default n-separator = TAB' hasn't been given priority over
2038 equal column_width also specified by POSIX. */
2039 if (number_separator == '\t')
2041 i = number_width - chars_per_number;
2043 (p->char_func) ((int) ' ');
2046 (p->char_func) ((int) number_separator);
2049 /* To comply with POSIX, we avoid any expansion of default TAB
2050 separator with a single column output. No column_width requirement
2051 has to be considered. */
2053 (p->char_func) ((int) number_separator);
2054 if (number_separator == '\t')
2055 output_position = POS_AFTER_TAB (chars_per_output_tab,
2059 if (truncate_lines && !parallel_files)
2060 input_position += number_width;
2063 /* Print (or store) padding until the current horizontal position
2067 pad_across_to (int position)
2069 register int h = output_position;
2072 spaces_not_printed = position - output_position;
2075 while (++h <= position)
2077 output_position = position;
2081 /* Pad to the bottom of the page.
2083 If the user has requested a formfeed, use one.
2084 Otherwise, use newlines. */
2087 pad_down (int lines)
2094 for (i = lines; i; --i)
2098 /* Read the rest of the line.
2100 Read from the current column's file until an end of line is
2101 hit. Used when we've truncated a line and we no longer need
2102 to print or store its characters. */
2105 read_rest_of_line (COLUMN *p)
2110 while ((c = getc (f)) != '\n')
2114 if ((c = getc (f)) != '\n')
2129 /* Read a line with skip_to_page.
2131 Read from the current column's file until an end of line is
2132 hit. Used when we read full lines to skip pages.
2133 With skip_to_page we have to check for FF-coincidence which is done
2134 in function read_line otherwise.
2135 Count lines of skipped pages to find the line number of 1st page
2136 printed relative to 1st line of input file (start_line_num). */
2139 skip_read (COLUMN *p, int column_number)
2143 int i, single_ff = FALSE;
2146 /* Read 1st character in a line or any character succeeding a FF */
2147 if ((c = getc (f)) == '\f' && p->full_page_printed)
2148 /* A FF-coincidence with a previous full_page_printed.
2149 To avoid an additional empty page, eliminate the FF */
2150 if ((c = getc (f)) == '\n')
2153 p->full_page_printed = FALSE;
2155 /* 1st character a FF means a single FF without any printable
2156 characters. Don't count it as a line with -n option. */
2160 /* Preparing for a FF-coincidence: Maybe we finish that page
2161 without a FF found */
2163 p->full_page_printed = TRUE;
2169 /* No FF-coincidence possible,
2170 no catching up of a FF-coincidence with next page */
2173 if (!parallel_files)
2174 for (q = column_vector, i = columns; i; ++q, --i)
2175 q->full_page_printed = FALSE;
2177 p->full_page_printed = FALSE;
2180 if ((c = getc (f)) != '\n')
2194 if ((!parallel_files || column_number == 1) && !single_ff)
2198 /* If we're tabifying output,
2200 When print_char encounters white space it keeps track
2201 of our desired horizontal position and delays printing
2202 until this function is called. */
2205 print_white_space (void)
2208 register int h_old = output_position;
2209 register int goal = h_old + spaces_not_printed;
2211 while (goal - h_old > 1
2212 && (h_new = POS_AFTER_TAB (chars_per_output_tab, h_old)) <= goal)
2214 putchar (output_tab_char);
2217 while (++h_old <= goal)
2220 output_position = goal;
2221 spaces_not_printed = 0;
2224 /* Print column separators.
2226 We keep a count until we know that we'll be printing a line,
2227 then print_sep_string() is called. */
2233 int l = col_sep_length;
2237 if (separators_not_printed <= 0)
2239 /* We'll be starting a line with chars_per_margin, anything else? */
2240 if (spaces_not_printed > 0)
2241 print_white_space ();
2245 for (; separators_not_printed > 0; --separators_not_printed)
2249 /* 3 types of sep_strings: spaces only, spaces and chars,
2253 /* We're tabifying output; consecutive spaces in
2254 sep_string may have to be converted to tabs */
2256 ++spaces_not_printed;
2260 if (spaces_not_printed > 0)
2261 print_white_space ();
2266 /* sep_string ends with some spaces */
2267 if (spaces_not_printed > 0)
2268 print_white_space ();
2273 /* Print (or store, depending on p->char_func) a clump of N
2277 print_clump (COLUMN *p, int n, int *clump)
2280 (p->char_func) (*clump++);
2283 /* Print a character.
2285 Update the following comment: process-char hasn't been used any
2287 If we're tabifying, all tabs have been converted to spaces by
2288 process_char(). Keep a count of consecutive spaces, and when
2289 a nonspace is encountered, call print_white_space() to print the
2290 required number of tabs and spaces. */
2299 ++spaces_not_printed;
2302 else if (spaces_not_printed > 0)
2303 print_white_space ();
2305 /* Nonprintables are assumed to have width 0, except '\b'. */
2317 /* Skip to page PAGE before printing.
2318 PAGE may be larger than total number of pages. */
2321 skip_to_page (int page)
2326 for (n = 1; n < page; ++n)
2328 for (i = 1; i < lines_per_body; ++i)
2330 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2331 if (p->status == OPEN)
2335 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2336 if (p->status == OPEN)
2339 if (storing_columns) /* change FF_FOUND to ON_HOLD */
2340 for (j = 1, p = column_vector; j <= columns; ++j, ++p)
2341 if (p->status != CLOSED)
2342 p->status = ON_HOLD;
2347 if (files_ready_to_read < 1)
2349 /* It's very helpful, normally the total number of pages is
2350 not known in advance. */
2352 _("starting page number larger than total number of pages: `%d'"),
2357 return files_ready_to_read > 0;
2362 Formfeeds are assumed to use up two lines at the beginning of
2368 char page_text[256 + INT_STRLEN_BOUND (int)];
2369 int available_width;
2376 output_position = 0;
2377 pad_across_to (chars_per_margin);
2378 print_white_space ();
2380 /* The translator must ensure that formatting the translation of
2381 "Page %d" does not generate more than (sizeof page_text - 1)
2383 sprintf (page_text, _("Page %d"), page_number++);
2384 available_width = header_width_available - mbswidth (page_text, 0);
2385 available_width = MAX (0, available_width);
2386 lhs_spaces = available_width >> 1;
2387 rhs_spaces = available_width - lhs_spaces;
2389 printf ("%s%*s%s%*s%s\n\n\n",
2390 date_text, lhs_spaces, " ", file_text, rhs_spaces, " ", page_text);
2392 print_a_header = FALSE;
2393 output_position = 0;
2396 /* Print (or store, if p->char_func is store_char()) a line.
2398 Read a character to determine whether we have a line or not.
2399 (We may hit EOF, \n, or \f)
2401 Once we know we have a line,
2402 set pad_vertically = TRUE, meaning it's safe
2403 to pad down at the end of the page, since we do have a page.
2404 print a header if needed.
2405 pad across to padding_not_printed if needed.
2406 print any separators which need to be printed.
2407 print a line number if it needs to be printed.
2409 Print the clump which corresponds to the first character.
2411 Enter a loop and keep printing until an end of line condition
2412 exists, or until we exceed chars_per_column.
2414 Return FALSE if we exceed chars_per_column before reading
2415 an end of line character, TRUE otherwise. */
2418 read_line (COLUMN *p)
2421 int chars IF_LINT (= 0);
2422 int last_input_position;
2426 /* read 1st character in each line or any character succeeding a FF: */
2429 last_input_position = input_position;
2431 if (c == '\f' && p->full_page_printed)
2432 if ((c = getc (p->fp)) == '\n')
2434 p->full_page_printed = FALSE;
2439 if ((c = getc (p->fp)) != '\n')
2442 if (print_a_header && !storing_columns)
2444 pad_vertically = TRUE;
2457 chars = char_to_clump (c);
2460 if (truncate_lines && input_position > chars_per_column)
2462 input_position = last_input_position;
2466 if (p->char_func != store_char)
2468 pad_vertically = TRUE;
2470 if (print_a_header && !storing_columns)
2473 if (parallel_files && align_empty_cols)
2475 /* We have to align empty columns at the beginning of a line. */
2476 k = separators_not_printed;
2477 separators_not_printed = 0;
2478 for (j = 1, q = column_vector; j <= k; ++j, ++q)
2481 separators_not_printed += 1;
2483 padding_not_printed = p->start_position;
2485 spaces_not_printed = chars_per_column;
2487 spaces_not_printed = 0;
2488 align_empty_cols = FALSE;
2491 if (padding_not_printed - col_sep_length > 0)
2493 pad_across_to (padding_not_printed - col_sep_length);
2494 padding_not_printed = ANYWHERE;
2497 if (use_col_separator)
2498 print_sep_string ();
2502 add_line_number (p);
2508 print_clump (p, chars, clump_buff);
2519 if ((c = getc (p->fp)) != '\n')
2530 last_input_position = input_position;
2531 chars = char_to_clump (c);
2532 if (truncate_lines && input_position > chars_per_column)
2534 input_position = last_input_position;
2538 print_clump (p, chars, clump_buff);
2542 /* Print a line from buff.
2544 If this function has been called, we know we have "something to
2545 print". But it remains to be seen whether we have a real text page
2546 or an empty page (a single form feed) with/without a header only.
2547 Therefore first we set pad_vertically to TRUE and print a header
2549 If FF_FOUND and we are using -t|-T option we omit any newline by
2550 setting pad_vertically to FALSE (see print_page).
2551 Otherwise we pad across if necessary, print separators if necessary
2552 and text of COLUMN *p.
2554 Return TRUE, meaning there is no need to call read_rest_of_line. */
2557 print_stored (COLUMN *p)
2562 int line = p->current_line++;
2563 register char *first = &buff[line_vector[line]];
2565 UMR: Uninitialized memory read:
2566 * This is occurring while in:
2567 print_stored [pr.c:2239]
2568 * Reading 4 bytes from 0x5148c in the heap.
2569 * Address 0x5148c is 4 bytes into a malloc'd block at 0x51488 of 676 bytes
2570 * This block was allocated from:
2572 xmalloc [xmalloc.c:94]
2573 init_store_cols [pr.c:1648]
2575 register char *last = &buff[line_vector[line + 1]];
2577 pad_vertically = TRUE;
2582 if (p->status == FF_FOUND)
2584 for (i = 1, q = column_vector; i <= columns; ++i, ++q)
2585 q->status = ON_HOLD;
2586 if (column_vector->lines_to_print <= 0)
2589 pad_vertically = FALSE;
2590 return TRUE; /* print a header only */
2594 if (padding_not_printed - col_sep_length > 0)
2596 pad_across_to (padding_not_printed - col_sep_length);
2597 padding_not_printed = ANYWHERE;
2600 if (use_col_separator)
2601 print_sep_string ();
2603 while (first != last)
2604 print_char (*first++);
2606 if (spaces_not_printed == 0)
2608 output_position = p->start_position + end_vector[line];
2609 if (p->start_position - col_sep_length == chars_per_margin)
2610 output_position -= col_sep_length;
2616 /* Convert a character to the proper format and return the number of
2617 characters in the resulting clump. Increment input_position by
2618 the width of the clump.
2620 Tabs are converted to clumps of spaces.
2621 Nonprintable characters may be converted to clumps of escape
2622 sequences or control prefixes.
2624 Note: the width of a clump is not necessarily equal to the number of
2625 characters in clump_buff. (e.g, the width of '\b' is -1, while the
2626 number of characters is 1.) */
2629 char_to_clump (int c)
2631 register int *s = clump_buff;
2636 int chars_per_c = 8;
2638 if (c == input_tab_char)
2639 chars_per_c = chars_per_input_tab;
2641 if (c == input_tab_char || c == '\t')
2643 width = TAB_WIDTH (chars_per_c, input_position);
2647 for (i = width; i; --i)
2658 else if (!ISPRINT (c))
2660 if (use_esc_sequence)
2665 sprintf (esc_buff, "%03o", c);
2666 for (i = 0; i <= 2; ++i)
2667 *s++ = (int) esc_buff[i];
2669 else if (use_cntrl_prefix)
2683 sprintf (esc_buff, "%03o", c);
2684 for (i = 0; i <= 2; ++i)
2685 *s++ = (int) esc_buff[i];
2708 input_position += width;
2712 /* We've just printed some files and need to clean up things before
2713 looking for more options and printing the next batch of files.
2715 Free everything we've xmalloc'ed, except `header'. */
2725 free (column_vector);
2734 /* Complain, print a usage message, and die. */
2740 fprintf (stderr, _("Try `%s --help' for more information.\n"),
2745 Usage: %s [OPTION]... [FILE]...\n\
2750 Paginate or columnate FILE(s) for printing.\n\
2752 +FIRST_PAGE[:LAST_PAGE], --pages=FIRST_PAGE[:LAST_PAGE]\n\
2753 begin [stop] printing with page FIRST_[LAST_]PAGE\n\
2754 -COLUMN, --columns=COLUMN\n\
2755 produce COLUMN-column output and print columns down,\n\
2756 unless -a is used. Balance number of lines in the\n\
2757 columns on each page.\n\
2758 -a, --across print columns across rather than down, used together\n\
2760 -c, --show-control-chars\n\
2761 use hat notation (^G) and octal backslash notation\n\
2762 -d, --double-space\n\
2763 double space the output\n\
2764 -D, --date-format=FORMAT\n\
2765 use FORMAT for the header date\n\
2766 -e[CHAR[WIDTH]], --expand-tabs[=CHAR[WIDTH]]\n\
2767 expand input CHARs (TABs) to tab WIDTH (8)\n\
2768 -F, -f, --form-feed\n\
2769 use form feeds instead of newlines to separate pages\n\
2770 (by a 3-line page header with -F or a 5-line header\n\
2771 and trailer without -F)\n\
2774 -h HEADER, --header=HEADER\n\
2775 use a centered HEADER instead of filename in page header,\n\
2776 -h \"\" prints a blank line, don't use -h\"\"\n\
2777 -i[CHAR[WIDTH]], --output-tabs[=CHAR[WIDTH]]\n\
2778 replace spaces with CHARs (TABs) to tab WIDTH (8)\n\
2779 -J, --join-lines merge full lines, turns off -W line truncation, no column\n\
2780 alignment, -S[STRING] sets separators\n\
2781 -l PAGE_LENGTH, --length=PAGE_LENGTH\n\
2782 set the page length to PAGE_LENGTH (66) lines\n\
2783 (default number of lines of text 56, and with -F 63)\n\
2784 -m, --merge print all files in parallel, one in each column,\n\
2785 truncate lines, but join lines of full length with -J\n\
2786 -n[SEP[DIGITS]], --number-lines[=SEP[DIGITS]]\n\
2787 number lines, use DIGITS (5) digits, then SEP (TAB),\n\
2788 default counting starts with 1st line of input file\n\
2789 -N NUMBER, --first-line-number=NUMBER\n\
2790 start counting with NUMBER at 1st line of first\n\
2791 page printed (see +FIRST_PAGE)\n\
2792 -o MARGIN, --indent=MARGIN\n\
2793 offset each line with MARGIN (zero) spaces, do not\n\
2794 affect -w or -W, MARGIN will be added to PAGE_WIDTH\n\
2795 -r, --no-file-warnings\n\
2796 omit warning when a file cannot be opened\n\
2799 -s[CHAR],--separator[=CHAR]\n\
2800 separate columns by a single character, default for CHAR\n\
2801 is the <TAB> character without -w and \'no char\' with -w\n\
2802 -s[CHAR] turns off line truncation of all 3 column\n\
2803 options (-COLUMN|-a -COLUMN|-m) except -w is set\n\
2804 -S[STRING], --sep-string[=STRING]\n\
2805 separate columns by an optional STRING, don't use\n\
2806 -S \"STRING\", -S only: No separator used (same as -S\"\"),\n\
2807 without -S: Default separator <TAB> with -J and <space>\n\
2808 otherwise (same as -S\" \"), no effect on column options\n\
2809 -t, --omit-header omit page headers and trailers\n\
2810 -T, --omit-pagination\n\
2811 omit page headers and trailers, eliminate any pagination\n\
2812 by form feeds set in input files\n\
2813 -v, --show-nonprinting\n\
2814 use octal backslash notation\n\
2815 -w PAGE_WIDTH, --width=PAGE_WIDTH\n\
2816 set page width to PAGE_WIDTH (72) characters for\n\
2817 multiple text-column output only, -s[char] turns off (72)\n\
2818 -W PAGE_WIDTH, --page-width=PAGE_WIDTH\n\
2819 set page width to PAGE_WIDTH (72) characters always,\n\
2820 truncate lines, except -J option is set, no interference\n\
2822 --help display this help and exit\n\
2823 --version output version information and exit\n\
2825 -T implied by -l nn when nn <= 10 or <= 3 with -F. With no FILE, or when\n\
2826 FILE is -, read standard input.\n\
2828 puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
2830 exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);