/
niceSOFT
/
coreutils
Обзор
Документация
Войти
/
niceSOFT
/
coreutils
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
src/ptx.c
2 049 строк
65 KB
Sylvestre Ledru
ptx: fix infinite loop with a nullable --word-regexp
11 авг 2026, 00:24
11 авг 2026, 00:24
f653919
Код
Авторство
О чём код?
/* Permuted index for GNU, with keywords in their context. Copyright (C) 1990-2026 Free Software Foundation, Inc. François Pinard <pinard@iro.umontreal.ca>, 1988. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. François Pinard <pinard@iro.umontreal.ca> */ #include <config.h> #include <getopt.h> #include <sys/types.h> #include "system.h" #include <regex.h> #include "argmatch.h" #include "c-ctype.h" #include "fadvise.h" #include "octhexdigits.h" #include "quote.h" #include "read-file.h" #include "stdio--.h" #include "xstrtol.h" /* The official name of this program (e.g., no 'g' prefix). */ #define PROGRAM_NAME "ptx" /* TRANSLATORS: Please translate "F. Pinard" to "François Pinard" if "ç" (c-with-cedilla) is available in the translation's character set and encoding. */ #define AUTHORS proper_name_lite ("F. Pinard", "Fran\xc3\xa7ois Pinard") /* Number of possible characters in a byte. */ #define CHAR_SET_SIZE 256 /* Debugging the memory allocator. */ #if WITH_DMALLOC # define MALLOC_FUNC_CHECK 1 # include <dmalloc.h> #endif /* Global definitions. */ /* FIXME: There are many unchecked integer overflows in this file, and in theory they could cause this command to have undefined behavior given large inputs or options. This command should diagnose any such overflow and exit. */ /* Program options. */ enum Format { UNKNOWN_FORMAT, /* output format still unknown */ DUMB_FORMAT, /* output for a dumb terminal */ ROFF_FORMAT, /* output for 'troff' or 'nroff' */ TEX_FORMAT /* output for 'TeX' or 'LaTeX' */ }; static bool gnu_extensions = true; /* trigger all GNU extensions */ static bool auto_reference = false; /* refs are 'file_name:line_number:' */ static bool input_reference = false; /* refs at beginning of input lines */ static bool right_reference = false; /* output refs after right context */ static idx_t line_width = -1; /* output line width in characters */ static idx_t gap_size = 3; /* number of spaces between output fields */ static char const *truncation_string = "/"; /* string used to mark line truncations */ static char const *macro_name = "xx"; /* macro name for roff or TeX output */ static enum Format output_format = UNKNOWN_FORMAT; /* output format */ static bool ignore_case = false; /* fold lower to upper for sorting */ static char const *break_file = NULL; /* name of the 'Break chars' file */ static char const *only_file = NULL; /* name of the 'Only words' file */ static char const *ignore_file = NULL; /* name of the 'Ignore words' file */ /* Options that use regular expressions. */ struct regex_data { /* The original regular expression, as a string. */ char const *string; /* The compiled regular expression, and its fastmap. */ struct re_pattern_buffer pattern; char fastmap[UCHAR_MAX + 1]; }; static struct regex_data context_regex; /* end of context */ static struct regex_data word_regex; /* keyword */ /* A BLOCK delimit a region in memory of arbitrary size, like the copy of a whole file. A WORD is similar, except it is intended for smaller regions. A WORD_TABLE may contain several WORDs. */ typedef struct { char *start; /* pointer to beginning of region */ char *end; /* pointer to end + 1 of region */ } BLOCK; typedef struct { char *start; /* pointer to beginning of region */ idx_t size; /* length of the region */ } WORD; typedef struct { WORD *start; /* array of WORDs */ idx_t alloc; /* allocated length */ idx_t length; /* number of used entries */ } WORD_TABLE; /* Pattern description tables. */ /* For each character, provide its folded equivalent. */ static unsigned char folded_chars[CHAR_SET_SIZE]; /* End of context pattern register indices. */ static struct re_registers context_regs; /* Keyword pattern register indices. */ static struct re_registers word_regs; /* A word characters fastmap is used only when no word regexp has been provided. A word is then made up of a sequence of one or more characters allowed by the fastmap. Contains !0 if character allowed in word. Not only this is faster in most cases, but it simplifies the implementation of the Break files. */ static char word_fastmap[CHAR_SET_SIZE]; /* Maximum length of any word read. */ static idx_t maximum_word_length; /* Maximum width of any reference used. */ static idx_t reference_max_width; /* Ignore and Only word tables. */ static WORD_TABLE ignore_table; /* table of words to ignore */ static WORD_TABLE only_table; /* table of words to select */ /* Source text table, and scanning macros. */ static int number_input_files; /* number of text input files */ static intmax_t total_line_count; /* total number of lines seen so far */ static char const **input_file_name; /* array of text input file names */ static intmax_t *file_line_count; /* array of line count values at end */ static BLOCK *text_buffers; /* files to study */ /* SKIP_NON_WHITE used only for getting or skipping the reference. */ #define SKIP_NON_WHITE(cursor, limit) \ while (cursor < limit && ! isspace (to_uchar (*cursor))) \ cursor++ #define SKIP_WHITE(cursor, limit) \ while (cursor < limit && isspace (to_uchar (*cursor))) \ cursor++ #define SKIP_WHITE_BACKWARDS(cursor, start) \ while (cursor > start && isspace (to_uchar (cursor[-1]))) \ cursor-- /* Always advance by at least one byte, lest a nullable word regexp such as 'a*' match the empty string and loop forever. */ #define SKIP_SOMETHING(cursor, limit) \ if (word_regex.string) \ { \ regoff_t count; \ count = re_match (&word_regex.pattern, cursor, limit - cursor, \ 0, NULL); \ if (count == -2) \ matcher_error (); \ cursor += count <= 0 ? 1 : count; \ } \ else if (word_fastmap[to_uchar (*cursor)]) \ while (cursor < limit && word_fastmap[to_uchar (*cursor)]) \ cursor++; \ else \ cursor++ /* Occurrences table. The 'keyword' pointer provides the central word, which is surrounded by a left context and a right context. The 'keyword' and 'length' field allow full 8-bit characters keys, even including NULs. At other places in this program, the name 'keyafter' refers to the keyword followed by its right context. The left context does not extend, towards the beginning of the file, further than a distance given by the 'left' value. This value is relative to the keyword beginning, it is usually negative. This insures that, except for white space, we will never have to backward scan the source text, when it is time to generate the final output lines. The right context, indirectly attainable through the keyword end, does not extend, towards the end of the file, further than a distance given by the 'right' value. This value is relative to the keyword beginning, it is usually positive. When automatic references are used, the 'reference' value is the overall line number in all input files read so far, in this case, it is of type intmax_t. When input references are used, the 'reference' value indicates the distance between the keyword beginning and the start of the reference field, and it fits in ptrdiff_t and is usually negative. */ typedef struct { WORD key; /* description of the keyword */ ptrdiff_t left; /* distance to left context start */ ptrdiff_t right; /* distance to right context end */ intmax_t reference; /* reference descriptor */ int file_index; /* corresponding file */ } OCCURS; /* The various OCCURS tables are indexed by the language. But the time being, there is no such multiple language support. */ static OCCURS *occurs_table[1]; /* all words retained from the read text */ static idx_t occurs_alloc[1]; /* allocated size of occurs_table */ static idx_t number_of_occurs[1]; /* number of used slots in occurs_table */ /* Communication among output routines. */ /* Indicate if special output processing is requested for each character. */ static char edited_flag[CHAR_SET_SIZE]; /* Half of line width, reference excluded. */ static idx_t half_line_width; /* Maximum width of before field. FIXME: Is this nonnegative? That is, should this be idx_t? */ static ptrdiff_t before_max_width; /* Maximum width of keyword-and-after field. FIXME: Is this nonnegative? That is, should this be idx_t? */ static ptrdiff_t keyafter_max_width; /* Length of string that flags truncation. */ static idx_t truncation_string_length; /* When context is limited by lines, wraparound may happen on final output: the 'head' pointer gives access to some supplementary left context which will be seen at the end of the output line, the 'tail' pointer gives access to some supplementary right context which will be seen at the beginning of the output line. */ static BLOCK tail; /* tail field */ static bool tail_truncation; /* flag truncation after the tail field */ static BLOCK before; /* before field */ static bool before_truncation; /* flag truncation before the before field */ static BLOCK keyafter; /* keyword-and-after field */ static bool keyafter_truncation; /* flag truncation after the keyafter field */ static BLOCK head; /* head field */ static bool head_truncation; /* flag truncation before the head field */ static BLOCK reference; /* reference field for input reference mode */ /* Miscellaneous routines. */ /* Diagnose an error in the regular expression matcher. Then exit. */ static void matcher_error (void) { error (EXIT_FAILURE, errno, _("error in regular expression matcher")); } /* Unescape STRING in-place. */ static void unescape_string (char *string) { char *cursor; /* cursor in result */ int value; /* value of \nnn escape */ int length; /* length of \nnn escape */ cursor = string; while (*string) { if (*string == '\\') { string++; switch (*string) { case 'x': /* \xhhh escape, 3 chars maximum */ value = 0; for (length = 0, string++; length < 3 && c_isxdigit (*string); length++, string++) value = value * 16 + fromhex (*string); if (length == 0) { *cursor++ = '\\'; *cursor++ = 'x'; } else *cursor++ = value; break; case '0': /* \0ooo escape, 3 chars maximum */ value = 0; for (length = 0, string++; length < 3 && isoct (*string); length++, string++) value = value * 8 + fromoct (*string); *cursor++ = value; break; case 'a': /* alert */ *cursor++ = '\a'; string++; break; case 'b': /* backspace */ *cursor++ = '\b'; string++; break; case 'c': /* cancel the rest of the output */ while (*string) string++; break; case 'f': /* form feed */ *cursor++ = '\f'; string++; break; case 'n': /* new line */ *cursor++ = '\n'; string++; break; case 'r': /* carriage return */ *cursor++ = '\r'; string++; break; case 't': /* horizontal tab */ *cursor++ = '\t'; string++; break; case 'v': /* vertical tab */ *cursor++ = '\v'; string++; break; case '\0': /* lone backslash at end of string */ /* ignore it */ break; default: *cursor++ = '\\'; *cursor++ = *string++; break; } } else *cursor++ = *string++; } *cursor = '\0'; } /*--------------------------------------------------------------------------. | Compile the regex represented by REGEX, diagnose and abort if any error. | `--------------------------------------------------------------------------*/ static void compile_regex (struct regex_data *regex) { struct re_pattern_buffer *pattern = ®ex->pattern; char const *string = regex->string; char const *message; pattern->buffer = NULL; pattern->allocated = 0; pattern->fastmap = regex->fastmap; pattern->translate = ignore_case ? folded_chars : NULL; message = re_compile_pattern (string, strlen (string), pattern); if (message) error (EXIT_FAILURE, 0, _("%s (for regexp %s)"), message, quote (string)); /* The fastmap should be compiled before 're_match'. The following call is not mandatory, because 're_search' is always called sooner, and it compiles the fastmap if this has not been done yet. */ re_compile_fastmap (pattern); } /*------------------------------------------------------------------------. | This will initialize various tables for pattern match and compiles some | | regexps. | `------------------------------------------------------------------------*/ static void initialize_regex (void) { /* Initialize the case folding table. */ if (ignore_case) for (int character = 0; character < CHAR_SET_SIZE; character++) folded_chars[character] = toupper (character); /* Unless the user already provided a description of the end of line or end of sentence sequence, select an end of line sequence to compile. If the user provided an empty definition, thus disabling end of line or sentence feature, make it null to speed up tests. If GNU extensions are enabled, use end of sentence like in GNU emacs. If disabled, use end of lines. */ if (context_regex.string) { if (!*context_regex.string) context_regex.string = NULL; } else if (gnu_extensions && !input_reference) context_regex.string = "[.?!][]\"')}]*\\($\\|\t\\| \\)[ \t\n]*"; else context_regex.string = "\n"; if (context_regex.string) compile_regex (&context_regex); /* If the user has already provided a non-empty regexp to describe words, compile it. Else, unless this has already been done through a user provided Break character file, construct a fastmap of characters that may appear in a word. If GNU extensions enabled, include only letters of the underlying character set. If disabled, include almost everything, even punctuation; stop only on white space. */ if (word_regex.string) compile_regex (&word_regex); else if (!break_file) { if (gnu_extensions) { /* Simulate \w+. */ for (int character = 0; character < CHAR_SET_SIZE; character++) word_fastmap[character] = !! isalpha (character); } else { /* Simulate [^ \t\n]+. */ memset (word_fastmap, 1, CHAR_SET_SIZE); word_fastmap[' '] = 0; word_fastmap['\t'] = 0; word_fastmap['\n'] = 0; } } } /*------------------------------------------------------------------------. | This routine will attempt to swallow a whole file name FILE_NAME into a | | contiguous region of memory and return a description of it into BLOCK. | | Standard input is assumed whenever FILE_NAME is null, empty or "-". | | | | Previously, in some cases, white space compression was attempted while | | inputting text. This was defeating some regexps like default end of | | sentence, which checks for two consecutive spaces. If white space | | compression is ever reinstated, it should be in output routines. | `------------------------------------------------------------------------*/ static void swallow_file_in_memory (char const *file_name, BLOCK *block) { size_t used_length; /* used length in memory buffer */ /* As special cases, a file name which is null or "-" indicates standard input, which is already opened. In all other cases, open the file from its name. */ bool using_stdin = !file_name || !*file_name || streq (file_name, "-"); if (using_stdin) block->start = fread_file (stdin, 0, &used_length); else block->start = read_file (file_name, 0, &used_length); if (!block->start) error (EXIT_FAILURE, errno, "%s", quotef (using_stdin ? "-" : file_name)); if (using_stdin) clearerr (stdin); block->end = block->start + used_length; } /* Sort and search routines. */ /*--------------------------------------------------------------------------. | Compare two words, FIRST and SECOND, and return 0 if they are identical. | | Return less than 0 if the first word goes before the second; return | | greater than 0 if the first word goes after the second. | | | | If a word is indeed a prefix of the other, the shorter should go first. | `--------------------------------------------------------------------------*/ static int compare_words (const void *void_first, const void *void_second) { WORD const *first = void_first; WORD const *second = void_second; idx_t length = MIN (first->size, second->size); if (ignore_case) { for (idx_t counter = 0; counter < length; counter++) { int value = (folded_chars[to_uchar (first->start[counter])] - folded_chars[to_uchar (second->start[counter])]); if (value != 0) return value; } } else { for (idx_t counter = 0; counter < length; counter++) { int value = (to_uchar (first->start[counter]) - to_uchar (second->start[counter])); if (value != 0) return value; } } return _GL_CMP (first->size, second->size); } /*-----------------------------------------------------------------------. | Decides which of two OCCURS, FIRST or SECOND, should lexicographically | | go first. In case of a tie, preserve the original order through a | | pointer comparison. | `-----------------------------------------------------------------------*/ static int compare_occurs (const void *void_first, const void *void_second) { #define first ((const OCCURS *) void_first) #define second ((const OCCURS *) void_second) int value; value = compare_words (&first->key, &second->key); return (value ? value : _GL_CMP (first->key.start, second->key.start)); #undef first #undef second } /* True if WORD appears in TABLE. Uses a binary search. */ ATTRIBUTE_PURE static bool search_table (WORD *word, WORD_TABLE *table) { idx_t lo = 0; idx_t hi = table->length; while (lo < hi) { idx_t middle = (lo >> 1) + (hi >> 1) + (lo & hi & 1); int value = compare_words (word, table->start + middle); if (value < 0) hi = middle; else if (value > 0) lo = middle + 1; else return true; } return false; } /*---------------------------------------------------------------------. | Sort the whole occurs table in memory. Presumably, 'qsort' does not | | take intermediate copies or table elements, so the sort will be | | stabilized throughout the comparison routine. | `---------------------------------------------------------------------*/ static void sort_found_occurs (void) { /* Only one language for the time being. */ if (number_of_occurs[0]) qsort (occurs_table[0], number_of_occurs[0], sizeof **occurs_table, compare_occurs); } /* Parameter files reading routines. */ /*----------------------------------------------------------------------. | Read a file named FILE_NAME, containing a set of break characters. | | Build a content to the array word_fastmap in which all characters are | | allowed except those found in the file. Characters may be repeated. | `----------------------------------------------------------------------*/ static void digest_break_file (char const *file_name) { BLOCK file_contents; /* to receive a copy of the file */ swallow_file_in_memory (file_name, &file_contents); /* Make the fastmap and record the file contents in it. */ memset (word_fastmap, 1, CHAR_SET_SIZE); for (char *cursor = file_contents.start; cursor < file_contents.end; cursor++) word_fastmap[to_uchar (*cursor)] = 0; if (!gnu_extensions) { /* If GNU extensions are enabled, the only way to avoid newline as a break character is to write all the break characters in the file with no newline at all, not even at the end of the file. If disabled, spaces, tabs and newlines are always considered as break characters even if not included in the break file. */ word_fastmap[' '] = 0; word_fastmap['\t'] = 0; word_fastmap['\n'] = 0; } /* Return the space of the file, which is no more required. */ free (file_contents.start); } /*-----------------------------------------------------------------------. | Read a file named FILE_NAME, containing one word per line, then | | construct in TABLE a table of WORD descriptors for them. The routine | | swallows the whole file in memory; this is at the expense of space | | needed for newlines, which are useless; however, the reading is fast. | `-----------------------------------------------------------------------*/ static void digest_word_file (char const *file_name, WORD_TABLE *table) { BLOCK file_contents; /* to receive a copy of the file */ char *cursor; /* cursor in file copy */ char *word_start; /* start of the current word */ swallow_file_in_memory (file_name, &file_contents); table->start = NULL; table->alloc = 0; table->length = 0; /* Read the whole file. */ cursor = file_contents.start; while (cursor < file_contents.end) { /* Read one line, and save the word in contains. */ word_start = cursor; while (cursor < file_contents.end && *cursor != '\n') cursor++; /* Record the word in table if it is not empty. */ if (cursor > word_start) { if (table->length == table->alloc) table->start = xpalloc (table->start, &table->alloc, 1, -1, sizeof *table->start); table->start[table->length].start = word_start; table->start[table->length].size = cursor - word_start; table->length++; } /* This test allows for an incomplete line at end of file. */ if (cursor < file_contents.end) cursor++; } /* Finally, sort all the words read. */ qsort (table->start, table->length, sizeof table->start[0], compare_words); } /* Keyword recognition and selection. */ /*----------------------------------------------------------------------. | For each keyword in the source text, constructs an OCCURS structure. | `----------------------------------------------------------------------*/ static void find_occurs_in_text (int file_index) { char *scan; /* for scanning the source text */ char *line_start; /* start of the current input line */ char *line_scan; /* newlines scanned until this point */ idx_t reference_length; /* length of reference in input mode */ WORD possible_key; /* possible key, to ease searches */ OCCURS *occurs_cursor; /* current OCCURS under construction */ char *context_start; /* start of left context */ char *context_end; /* end of right context */ char *word_start; /* start of word */ char *word_end; /* end of word */ char *next_context_start; /* next start of left context */ const BLOCK *text_buffer = &text_buffers[file_index]; /* reference_length is always used within 'if (input_reference)'. However, GNU C diagnoses that it may be used uninitialized. The following assignment is merely to shut it up. */ reference_length = 0; /* Tracking where lines start is helpful for reference processing. In auto reference mode, this allows counting lines. In input reference mode, this permits finding the beginning of the references. The first line begins with the file, skip immediately this very first reference in input reference mode, to help further rejection any word found inside it. Also, unconditionally assigning these variable has the happy effect of shutting up lint. */ line_start = text_buffer->start; line_scan = line_start; if (input_reference) { SKIP_NON_WHITE (line_scan, text_buffer->end); reference_length = line_scan - line_start; SKIP_WHITE (line_scan, text_buffer->end); } /* Process the whole buffer, one line or one sentence at a time. */ for (char *cursor = text_buffer->start; cursor < text_buffer->end; cursor = next_context_start) { /* 'context_start' gets initialized before the processing of each line, or once for the whole buffer if no end of line or sentence sequence separator. */ context_start = cursor; /* If an end of line or end of sentence sequence is defined and non-empty, 'next_context_start' will be recomputed to be the end of each line or sentence, before each one is processed. If no such sequence, then 'next_context_start' is set at the end of the whole buffer, which is then considered to be a single line or sentence. This test also accounts for the case of an incomplete line or sentence at the end of the buffer. */ next_context_start = text_buffer->end; if (context_regex.string) switch (re_search (&context_regex.pattern, cursor, text_buffer->end - cursor, 0, text_buffer->end - cursor, &context_regs)) { case -2: matcher_error (); case -1: break; case 0: error (EXIT_FAILURE, 0, _("error: regular expression has a match of length zero:" " %s"), quote (context_regex.string)); default: next_context_start = cursor + context_regs.end[0]; break; } /* Include the separator into the right context, but not any suffix white space in this separator; this insures it will be seen in output and will not take more space than necessary. */ context_end = next_context_start; SKIP_WHITE_BACKWARDS (context_end, context_start); /* Read and process a single input line or sentence, one word at a time. */ while (true) { if (word_regex.string) /* If a word regexp has been compiled, use it to skip at the beginning of the next word. If there is no such word, exit the loop. */ { regoff_t r = re_search (&word_regex.pattern, cursor, context_end - cursor, 0, context_end - cursor, &word_regs); if (r == -2) matcher_error (); if (r == -1) break; word_start = cursor + word_regs.start[0]; word_end = cursor + word_regs.end[0]; } else /* Avoid re_search and use the fastmap to skip to the beginning of the next word. If there is no more word in the buffer, exit the loop. */ { scan = cursor; while (scan < context_end && !word_fastmap[to_uchar (*scan)]) scan++; if (scan == context_end) break; word_start = scan; while (scan < context_end && word_fastmap[to_uchar (*scan)]) scan++; word_end = scan; } /* Skip right to the beginning of the found word. */ cursor = word_start; /* Skip any zero length word. Just advance a single position, then go fetch the next word. */ if (word_end == word_start) { cursor++; continue; } /* This is a genuine, non empty word, so save it as a possible key. Then skip over it. Also, maintain the maximum length of all words read so far. It is mandatory to take the maximum length of all words in the file, without considering if they are actually kept or rejected, because backward jumps at output generation time may fall in *any* word. */ possible_key.start = cursor; possible_key.size = word_end - word_start; cursor += possible_key.size; if (possible_key.size > maximum_word_length) maximum_word_length = possible_key.size; /* In input reference mode, update 'line_start' from its previous value. Count the lines just in case auto reference mode is also selected. If it happens that the word just matched is indeed part of a reference; just ignore it. */ if (input_reference) { while (line_scan < possible_key.start) if (*line_scan == '\n') { total_line_count++; line_scan++; line_start = line_scan; SKIP_NON_WHITE (line_scan, text_buffer->end); reference_length = line_scan - line_start; } else line_scan++; if (line_scan > possible_key.start) continue; } /* Ignore the word if an 'Ignore words' table exists and if it is part of it. Also ignore the word if an 'Only words' table and if it is *not* part of it. It is allowed that both tables be used at once, even if this may look strange for now. Just ignore a word that would appear in both. If regexps are eventually implemented for these tables, the Ignore table could then reject words that would have been previously accepted by the Only table. */ if (ignore_file && search_table (&possible_key, &ignore_table)) continue; if (only_file && !search_table (&possible_key, &only_table)) continue; /* A non-empty word has been found. First of all, insure proper allocation of the next OCCURS, and make a pointer to where it will be constructed. */ if (number_of_occurs[0] == occurs_alloc[0]) occurs_table[0] = xpalloc (occurs_table[0], &occurs_alloc[0], 1, -1, sizeof *occurs_table[0]); occurs_cursor = occurs_table[0] + number_of_occurs[0]; /* Define the reference field, if any. */ if (auto_reference) { /* While auto referencing, update 'line_start' from its previous value, counting lines as we go. If input referencing at the same time, 'line_start' has been advanced earlier, and the following loop is never really executed. */ while (line_scan < possible_key.start) if (*line_scan == '\n') { total_line_count++; line_scan++; line_start = line_scan; SKIP_NON_WHITE (line_scan, text_buffer->end); } else line_scan++; occurs_cursor->reference = total_line_count; } else if (input_reference) { /* If only input referencing, 'line_start' has been computed earlier to detect the case the word matched would be part of the reference. The reference position is simply the value of 'line_start'. */ occurs_cursor->reference = line_start - possible_key.start; if (reference_length > reference_max_width) reference_max_width = reference_length; } /* Exclude the reference from the context in simple cases. */ if (input_reference && line_start == context_start) { SKIP_NON_WHITE (context_start, context_end); SKIP_WHITE (context_start, context_end); } /* Completes the OCCURS structure. */ occurs_cursor->key = possible_key; occurs_cursor->left = context_start - possible_key.start; occurs_cursor->right = context_end - possible_key.start; occurs_cursor->file_index = file_index; number_of_occurs[0]++; } } } /* Formatting and actual output - service routines. */ /*-----------------------------------------. | Prints some NUMBER of spaces on stdout. | `-----------------------------------------*/ static void print_spaces (ptrdiff_t number) { for (ptrdiff_t counter = number; counter > 0; counter--) putchar (' '); } /*-------------------------------------. | Prints the field provided by FIELD. | `-------------------------------------*/ static void print_field (BLOCK field) { /* Whitespace is not really compressed. Instead, each white space character (tab, vt, ht etc.) is printed as one single space. */ for (char *cursor = field.start; cursor < field.end; cursor++) { unsigned char character = *cursor; if (edited_flag[character]) { /* Handle cases which are specific to 'roff' or TeX. All white space processing is done as the default case of this switch. */ switch (character) { case '"': /* In roff output format, double any quote. */ putchar ('"'); putchar ('"'); break; case '$': case '%': case '&': case '#': case '_': /* In TeX output format, precede these with a backslash. */ putchar ('\\'); putchar (character); break; case '{': case '}': /* In TeX output format, precede these with a backslash and force mathematical mode. */ printf ("$\\%c$", character); break; case '\\': /* In TeX output mode, request production of a backslash. */ fputs ("\\backslash{}", stdout); break; default: /* Any other flagged character produces a single space. */ putchar (' '); } } else putchar (*cursor); } } /* Formatting and actual output - planning routines. */ /*--------------------------------------------------------------------. | From information collected from command line options and input file | | readings, compute and fix some output parameter values. | `--------------------------------------------------------------------*/ static void fix_output_parameters (void) { /* In auto reference mode, the maximum width of this field is precomputed and subtracted from the overall line width. Add one for the column which separate the file name from the line number. */ if (auto_reference) { reference_max_width = 0; for (int file_index = 0; file_index < number_input_files; file_index++) { intmax_t line_ordinal = file_line_count[file_index] + 1; if (file_index > 0) line_ordinal -= file_line_count[file_index - 1]; char ordinal_string[INT_BUFSIZE_BOUND (intmax_t)]; idx_t reference_width = sprintf (ordinal_string, "%jd", line_ordinal); if (input_file_name[file_index]) reference_width += strlen (input_file_name[file_index]); if (reference_width > reference_max_width) reference_max_width = reference_width; } reference_max_width++; reference.start = xmalloc (reference_max_width + 1); } /* If the reference appears to the left of the output line, reserve some space for it right away, including one gap size. */ if ((auto_reference || input_reference) && !right_reference) line_width = MAX (0, line_width - (reference_max_width + gap_size)); /* The output lines, minimally, will contain from left to right a left context, a gap, and a keyword followed by the right context with no special intervening gap. Half of the line width is dedicated to the left context and the gap, the other half is dedicated to the keyword and the right context; these values are computed once and for all here. There also are tail and head wrap around fields, used when the keyword is near the beginning or the end of the line, or when some long word cannot fit in, but leave place from wrapped around shorter words. The maximum width of these fields are recomputed separately for each line, on a case by case basis. It is worth noting that it cannot happen that both the tail and head fields are used at once. */ half_line_width = line_width >> 1; before_max_width = half_line_width - gap_size; keyafter_max_width = half_line_width; /* If truncation_string is the empty string, make it null to speed up tests. In this case, truncation_string_length will never get used, so there is no need to set it. */ if (truncation_string && *truncation_string) truncation_string_length = strlen (truncation_string); else truncation_string = NULL; if (gnu_extensions) { /* When flagging truncation at the left of the keyword, the truncation mark goes at the beginning of the before field, unless there is a head field, in which case the mark goes at the left of the head field. When flagging truncation at the right of the keyword, the mark goes at the end of the keyafter field, unless there is a tail field, in which case the mark goes at the end of the tail field. Only eight combination cases could arise for truncation marks: . None. . One beginning the before field. . One beginning the head field. . One ending the keyafter field. . One ending the tail field. . One beginning the before field, another ending the keyafter field. . One ending the tail field, another beginning the before field. . One ending the keyafter field, another beginning the head field. So, there is at most two truncation marks, which could appear both on the left side of the center of the output line, both on the right side, or one on either side. */ before_max_width -= 2 * truncation_string_length; keyafter_max_width -= 2 * truncation_string_length; } else { /* I never figured out exactly how UNIX' ptx plans the output width of its various fields. If GNU extensions are disabled, do not try computing the field widths correctly; instead, use the following formula, which does not completely imitate UNIX' ptx, but almost. */ keyafter_max_width -= 2 * truncation_string_length + 1; } if (before_max_width < 0) before_max_width = 0; /* Compute which characters need special output processing. Initialize by flagging any white space character. Some systems do not consider form feed as a space character, but we do. */ for (int character = 0; character < CHAR_SET_SIZE; character++) edited_flag[character] = !! isspace (character); edited_flag['\f'] = 1; /* Complete the special character flagging according to selected output format. */ switch (output_format) { case UNKNOWN_FORMAT: /* Should never happen. */ case DUMB_FORMAT: break; case ROFF_FORMAT: /* 'Quote' characters should be doubled. */ edited_flag['"'] = 1; break; case TEX_FORMAT: /* Various characters need special processing. */ for (char const *cursor = "$%&#_{}\\"; *cursor; cursor++) edited_flag[to_uchar (*cursor)] = 1; break; } } /*------------------------------------------------------------------. | Compute the position and length of all the output fields, given a | | pointer to some OCCURS. | `------------------------------------------------------------------*/ static void define_all_fields (OCCURS *occurs) { ptrdiff_t tail_max_width; /* allowable width of tail field */ ptrdiff_t head_max_width; /* allowable width of head field */ char *cursor; /* running cursor in source text */ char *left_context_start; /* start of left context */ char *right_context_end; /* end of right context */ char *left_field_start; /* conservative start for 'head'/'before' */ char const *file_name; /* file name for reference */ intmax_t line_ordinal; /* line ordinal for reference */ char const *buffer_start; /* start of buffered file for this occurs */ char const *buffer_end; /* end of buffered file for this occurs */ /* Define 'keyafter', start of left context and end of right context. 'keyafter' starts at the saved position for keyword and extend to the right from the end of the keyword, eating separators or full words, but not beyond maximum allowed width for 'keyafter' field or limit for the right context. Suffix spaces will be removed afterwards. */ keyafter.start = occurs->key.start; keyafter.end = keyafter.start + occurs->key.size; left_context_start = keyafter.start + occurs->left; right_context_end = keyafter.start + occurs->right; buffer_start = text_buffers[occurs->file_index].start; buffer_end = text_buffers[occurs->file_index].end; cursor = keyafter.end; while (cursor < right_context_end && cursor <= keyafter.start + keyafter_max_width) { keyafter.end = cursor; SKIP_SOMETHING (cursor, right_context_end); } if (cursor <= keyafter.start + keyafter_max_width) keyafter.end = cursor; keyafter_truncation = truncation_string && keyafter.end < right_context_end; SKIP_WHITE_BACKWARDS (keyafter.end, keyafter.start); /* When the left context is wide, it might take some time to catch up from the left context boundary to the beginning of the 'head' or 'before' fields. So, in this case, to speed the catchup, we jump back from the keyword, using some secure distance, possibly falling in the middle of a word. A secure backward jump would be at least half the maximum width of a line, plus the size of the longest word met in the whole input. We conclude this backward jump by a skip forward of at least one word. In this manner, we should not inadvertently accept only part of a word. From the reached point, when it will be time to fix the beginning of 'head' or 'before' fields, we will skip forward words or delimiters until we get sufficiently near. */ if (-occurs->left > half_line_width + maximum_word_length) { left_field_start = keyafter.start - (half_line_width + maximum_word_length); SKIP_SOMETHING (left_field_start, keyafter.start); } else left_field_start = keyafter.start + occurs->left; /* 'before' certainly ends at the keyword, but not including separating spaces. It starts after than the saved value for the left context, by advancing it until it falls inside the maximum allowed width for the before field. There will be no prefix spaces either. 'before' only advances by skipping single separators or whole words. */ before.start = left_field_start; before.end = keyafter.start; SKIP_WHITE_BACKWARDS (before.end, before.start); while (before.start + before_max_width < before.end) SKIP_SOMETHING (before.start, before.end); if (truncation_string) { cursor = before.start; SKIP_WHITE_BACKWARDS (cursor, buffer_start); before_truncation = cursor > left_context_start; } else before_truncation = false; SKIP_WHITE (before.start, buffer_end); /* The tail could not take more columns than what has been left in the left context field, and a gap is mandatory. It starts after the right context, and does not contain prefixed spaces. It ends at the end of line, the end of buffer or when the tail field is full, whichever comes first. It cannot contain only part of a word, and has no suffixed spaces. */ tail_max_width = before_max_width - (before.end - before.start) - gap_size; if (tail_max_width > 0) { tail.start = keyafter.end; SKIP_WHITE (tail.start, buffer_end); tail.end = tail.start; cursor = tail.end; while (cursor < right_context_end && cursor < tail.start + tail_max_width) { tail.end = cursor; SKIP_SOMETHING (cursor, right_context_end); } if (cursor < tail.start + tail_max_width) tail.end = cursor; if (tail.end > tail.start) { keyafter_truncation = false; tail_truncation = truncation_string && tail.end < right_context_end; } else tail_truncation = false; SKIP_WHITE_BACKWARDS (tail.end, tail.start); } else { /* No place left for a tail field. */ tail.start = NULL; tail.end = NULL; tail_truncation = false; } /* 'head' could not take more columns than what has been left in the right context field, and a gap is mandatory. It ends before the left context, and does not contain suffixed spaces. Its pointer is advanced until the head field has shrunk to its allowed width. It cannot contain only part of a word, and has no suffixed spaces. */ head_max_width = keyafter_max_width - (keyafter.end - keyafter.start) - gap_size; if (head_max_width > 0) { head.end = before.start; SKIP_WHITE_BACKWARDS (head.end, buffer_start); head.start = left_field_start; while (head.start + head_max_width < head.end) SKIP_SOMETHING (head.start, head.end); if (head.end > head.start) { before_truncation = false; head_truncation = (truncation_string && head.start > left_context_start); } else head_truncation = false; SKIP_WHITE (head.start, head.end); } else { /* No place left for a head field. */ head.start = NULL; head.end = NULL; head_truncation = false; } if (auto_reference) { /* Construct the reference text in preallocated space from the file name and the line number. Standard input yields an empty file name. Ensure line numbers are 1 based, even if they are computed 0 based. */ file_name = input_file_name[occurs->file_index]; if (!file_name) file_name = ""; line_ordinal = occurs->reference + 1; if (occurs->file_index > 0) line_ordinal -= file_line_count[occurs->file_index - 1]; char *file_end = stpcpy (reference.start, file_name); reference.end = file_end + sprintf (file_end, ":%jd", line_ordinal); } else if (input_reference) { /* Reference starts at saved position for reference and extends right until some white space is met. */ reference.start = keyafter.start + occurs->reference; reference.end = reference.start; SKIP_NON_WHITE (reference.end, right_context_end); } } /* Formatting and actual output - control routines. */ /*----------------------------------------------------------------------. | Output the current output fields as one line for 'troff' or 'nroff'. | `----------------------------------------------------------------------*/ static void output_one_roff_line (void) { /* Output the 'tail' field. */ printf (".%s \"", macro_name); print_field (tail); if (tail_truncation) fputs (truncation_string, stdout); putchar ('"'); /* Output the 'before' field. */ fputs (" \"", stdout); if (before_truncation) fputs (truncation_string, stdout); print_field (before); putchar ('"'); /* Output the 'keyafter' field. */ fputs (" \"", stdout); print_field (keyafter); if (keyafter_truncation) fputs (truncation_string, stdout); putchar ('"'); /* Output the 'head' field. */ fputs (" \"", stdout); if (head_truncation) fputs (truncation_string, stdout); print_field (head); putchar ('"'); /* Conditionally output the 'reference' field. */ if (auto_reference || input_reference) { fputs (" \"", stdout); print_field (reference); putchar ('"'); } putchar ('\n'); } /*---------------------------------------------------------. | Output the current output fields as one line for 'TeX'. | `---------------------------------------------------------*/ static void output_one_tex_line (void) { BLOCK key; /* key field, isolated */ BLOCK after; /* after field, isolated */ char *cursor; /* running cursor in source text */ printf ("\\%s ", macro_name); putchar ('{'); print_field (tail); fputs ("}{", stdout); print_field (before); fputs ("}{", stdout); key.start = keyafter.start; after.end = keyafter.end; cursor = keyafter.start; SKIP_SOMETHING (cursor, keyafter.end); key.end = cursor; after.start = cursor; print_field (key); fputs ("}{", stdout); print_field (after); fputs ("}{", stdout); print_field (head); putchar ('}'); if (auto_reference || input_reference) { putchar ('{'); print_field (reference); putchar ('}'); } putchar ('\n'); } /*-------------------------------------------------------------------. | Output the current output fields as one line for a dumb terminal. | `-------------------------------------------------------------------*/ static void output_one_dumb_line (void) { if (!right_reference) { if (auto_reference) { /* Output the 'reference' field, in such a way that GNU emacs next-error will handle it. The ending colon is taken from the gap which follows. */ print_field (reference); putchar (':'); print_spaces (reference_max_width + gap_size - (reference.end - reference.start) - 1); } else { /* Output the 'reference' field and its following gap. */ print_field (reference); print_spaces (reference_max_width + gap_size - (reference.end - reference.start)); } } if (tail.start < tail.end) { /* Output the 'tail' field. */ print_field (tail); if (tail_truncation) fputs (truncation_string, stdout); print_spaces (half_line_width - gap_size - (before.end - before.start) - (before_truncation ? truncation_string_length : 0) - (tail.end - tail.start) - (tail_truncation ? truncation_string_length : 0)); } else print_spaces (half_line_width - gap_size - (before.end - before.start) - (before_truncation ? truncation_string_length : 0)); /* Output the 'before' field. */ if (before_truncation) fputs (truncation_string, stdout); print_field (before); print_spaces (gap_size); /* Output the 'keyafter' field. */ print_field (keyafter); if (keyafter_truncation) fputs (truncation_string, stdout); if (head.start < head.end) { /* Output the 'head' field. */ print_spaces (half_line_width - (keyafter.end - keyafter.start) - (keyafter_truncation ? truncation_string_length : 0) - (head.end - head.start) - (head_truncation ? truncation_string_length : 0)); if (head_truncation) fputs (truncation_string, stdout); print_field (head); } else if ((auto_reference || input_reference) && right_reference) print_spaces (half_line_width - (keyafter.end - keyafter.start) - (keyafter_truncation ? truncation_string_length : 0)); if ((auto_reference || input_reference) && right_reference) { /* Output the 'reference' field. */ print_spaces (gap_size); print_field (reference); } putchar ('\n'); } /*------------------------------------------------------------------------. | Scan the whole occurs table and, for each entry, output one line in the | | appropriate format. | `------------------------------------------------------------------------*/ static void generate_all_output (void) { OCCURS *occurs_cursor; /* current keyword entry being processed */ /* The following assignments are useful to provide default values in case line contexts or references are not used, in which case these variables would never be computed. */ tail.start = NULL; tail.end = NULL; tail_truncation = false; head.start = NULL; head.end = NULL; head_truncation = false; /* Loop over all keyword occurrences. */ occurs_cursor = occurs_table[0]; for (idx_t occurs_index = 0; occurs_index < number_of_occurs[0]; occurs_index++) { /* Compute the exact size of every field and whenever truncation flags are present or not. */ define_all_fields (occurs_cursor); /* Produce one output line according to selected format. */ switch (output_format) { case UNKNOWN_FORMAT: /* Should never happen. */ case DUMB_FORMAT: output_one_dumb_line (); break; case ROFF_FORMAT: output_one_roff_line (); break; case TEX_FORMAT: output_one_tex_line (); break; } /* Advance the cursor into the occurs table. */ occurs_cursor++; } } /* Option decoding and main program. */ /*------------------------------------------------------. | Print program identification and options, then exit. | `------------------------------------------------------*/ void usage (int status) { if (status != EXIT_SUCCESS) emit_try_help (); else { printf (_("\ Usage: %s [OPTION]... [INPUT]... (without -G)\n\ or: %s -G [OPTION]... [INPUT [OUTPUT]]\n"), program_name, program_name); fputs (_("\ Output a permuted index, including context, of the words in the input files.\n\ "), stdout); emit_stdin_note (); emit_mandatory_arg_note (); oputs (_("\ -A, --auto-reference output automatically generated references\n\ ")); oputs (_("\ -G, --traditional behave more like System V 'ptx'\n\ ")); oputs (_("\ -F, --flag-truncation=STRING use STRING for flagging line truncations.\n\ The default is '/'\n\ ")); oputs (_("\ -M, --macro-name=STRING macro name to use instead of 'xx'\n\ ")); oputs (_("\ -O, --format=roff generate output as roff directives\n\ ")); oputs (_("\ -R, --right-side-refs put references at right, not counted in -w\n\ ")); oputs (_("\ -S, --sentence-regexp=REGEXP for end of lines or end of sentences\n\ ")); oputs (_("\ -T, --format=tex generate output as TeX directives\n\ ")); oputs (_("\ -W, --word-regexp=REGEXP use REGEXP to match each keyword\n\ ")); oputs (_("\ -b, --break-file=FILE word break characters in this FILE\n\ ")); oputs (_("\ -f, --ignore-case fold lower case to upper case for sorting\n\ ")); oputs (_("\ -g, --gap-size=NUMBER gap size in columns between output fields\n\ ")); oputs (_("\ -i, --ignore-file=FILE read ignore word list from FILE\n\ ")); oputs (_("\ -o, --only-file=FILE read only word list from this FILE\n\ ")); oputs (_("\ -r, --references first field of each line is a reference\n\ ")); oputs (_("\ -t, --typeset-mode change the default width from 72 to 100\n\ ")); oputs (_("\ -w, --width=NUMBER output width in columns, reference excluded\n\ ")); oputs (HELP_OPTION_DESCRIPTION); oputs (VERSION_OPTION_DESCRIPTION); emit_ancillary_info (PROGRAM_NAME); } exit (status); } /*----------------------------------------------------------------------. | Main program. Decode ARGC arguments passed through the ARGV array of | | strings, then launch execution. | `----------------------------------------------------------------------*/ /* For long options that have no equivalent short option, use a non-character as a pseudo short option, starting with CHAR_MAX + 1. */ enum { FORMAT_OPTION = CHAR_MAX + 1 }; /* Long options equivalences. */ static struct option const long_options[] = { {"auto-reference", no_argument, NULL, 'A'}, {"break-file", required_argument, NULL, 'b'}, {"flag-truncation", required_argument, NULL, 'F'}, {"ignore-case", no_argument, NULL, 'f'}, {"gap-size", required_argument, NULL, 'g'}, {"ignore-file", required_argument, NULL, 'i'}, {"macro-name", required_argument, NULL, 'M'}, {"only-file", required_argument, NULL, 'o'}, {"references", no_argument, NULL, 'r'}, {"right-side-refs", no_argument, NULL, 'R'}, {"format", required_argument, NULL, FORMAT_OPTION}, {"sentence-regexp", required_argument, NULL, 'S'}, {"traditional", no_argument, NULL, 'G'}, {"typeset-mode", no_argument, NULL, 't'}, {"width", required_argument, NULL, 'w'}, {"word-regexp", required_argument, NULL, 'W'}, {GETOPT_HELP_OPTION_DECL}, {GETOPT_VERSION_OPTION_DECL}, {NULL, 0, NULL, 0}, }; static char const *const format_args[] = { "roff", "tex", NULL }; static enum Format const format_vals[] = { ROFF_FORMAT, TEX_FORMAT }; int main (int argc, char **argv) { int optchar; /* argument character */ int file_index; /* index in text input file arrays */ /* Decode program options. */ initialize_main (&argc, &argv); set_program_name (argv[0]); setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); atexit (close_stdout); while (optchar = getopt_long (argc, argv, "AF:GM:ORS:TW:b:i:fg:o:trw:", long_options, NULL), optchar != EOF) { switch (optchar) { default: usage (EXIT_FAILURE); case 'G': gnu_extensions = false; break; case 'b': break_file = optarg; break; case 'f': ignore_case = true; break; case 'g': { intmax_t tmp; if (! (xstrtoimax (optarg, NULL, 0, &tmp, "") == LONGINT_OK && 0 < tmp && tmp <= IDX_MAX)) error (EXIT_FAILURE, 0, _("invalid gap width: %s"), quote (optarg)); gap_size = tmp; break; } case 'i': ignore_file = optarg; break; case 'o': only_file = optarg; break; case 'r': input_reference = true; break; case 't': if (line_width < 0) line_width = 100; break; case 'w': { intmax_t tmp; if (! (xstrtoimax (optarg, NULL, 0, &tmp, "") == LONGINT_OK && 0 < tmp && tmp <= IDX_MAX)) error (EXIT_FAILURE, 0, _("invalid line width: %s"), quote (optarg)); line_width = tmp; break; } case 'A': auto_reference = true; break; case 'F': truncation_string = optarg; unescape_string (optarg); break; case 'M': macro_name = optarg; break; case 'O': output_format = ROFF_FORMAT; break; case 'R': right_reference = true; break; case 'S': context_regex.string = optarg; unescape_string (optarg); break; case 'T': output_format = TEX_FORMAT; break; case 'W': word_regex.string = optarg; unescape_string (optarg); if (!*word_regex.string) word_regex.string = NULL; break; case FORMAT_OPTION: output_format = XARGMATCH ("--format", optarg, format_args, format_vals); break; case_GETOPT_HELP_CHAR; case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); } } if (line_width < 0) line_width = 72; /* Process remaining arguments. If GNU extensions are enabled, process all arguments as input parameters. If disabled, accept at most two arguments, the second of which is an output parameter. */ if (optind == argc) { /* No more argument simply means: read standard input. */ input_file_name = xmalloc (sizeof *input_file_name); file_line_count = xmalloc (sizeof *file_line_count); text_buffers = xmalloc (sizeof *text_buffers); number_input_files = 1; input_file_name[0] = NULL; } else if (gnu_extensions) { number_input_files = argc - optind; input_file_name = xnmalloc (number_input_files, sizeof *input_file_name); file_line_count = xnmalloc (number_input_files, sizeof *file_line_count); text_buffers = xnmalloc (number_input_files, sizeof *text_buffers); for (file_index = 0; file_index < number_input_files; file_index++) { if (!*argv[optind] || streq (argv[optind], "-")) input_file_name[file_index] = NULL; else input_file_name[file_index] = argv[optind]; optind++; } } else { /* There is one necessary input file. */ number_input_files = 1; input_file_name = xmalloc (sizeof *input_file_name); file_line_count = xmalloc (sizeof *file_line_count); text_buffers = xmalloc (sizeof *text_buffers); if (!*argv[optind] || streq (argv[optind], "-")) input_file_name[0] = NULL; else input_file_name[0] = argv[optind]; optind++; /* Redirect standard output, only if requested. */ if (optind < argc) { if (! freopen (argv[optind], "w", stdout)) error (EXIT_FAILURE, errno, "%s", quotef (argv[optind])); optind++; } /* Diagnose any other argument as an error. */ if (optind < argc) { error (0, 0, _("extra operand %s"), quote (argv[optind])); usage (EXIT_FAILURE); } } /* If the output format has not been explicitly selected, choose dumb terminal format if GNU extensions are enabled, else 'roff' format. */ if (output_format == UNKNOWN_FORMAT) output_format = gnu_extensions ? DUMB_FORMAT : ROFF_FORMAT; /* Initialize the main tables. */ initialize_regex (); /* Read 'Break character' file, if any. */ if (break_file) digest_break_file (break_file); /* Read 'Ignore words' file and 'Only words' files, if any. If any of these files is empty, reset the name of the file to null, to avoid unnecessary calls to search_table. */ if (ignore_file) { digest_word_file (ignore_file, &ignore_table); if (ignore_table.length == 0) ignore_file = NULL; } if (only_file) { digest_word_file (only_file, &only_table); if (only_table.length == 0) only_file = NULL; } /* Prepare to study all the input files. */ number_of_occurs[0] = 0; total_line_count = 0; maximum_word_length = 0; reference_max_width = 0; for (file_index = 0; file_index < number_input_files; file_index++) { BLOCK *text_buffer = text_buffers + file_index; /* Read the file contents into memory, then study it. */ swallow_file_in_memory (input_file_name[file_index], text_buffer); find_occurs_in_text (file_index); /* Maintain for each file how many lines has been read so far when its end is reached. Incrementing the count first is a simple kludge to handle a possible incomplete line at end of file. */ total_line_count++; file_line_count[file_index] = total_line_count; } /* Do the output process phase. */ sort_found_occurs (); fix_output_parameters (); generate_all_output (); /* All done. */ return EXIT_SUCCESS; }