1 /* Permuted index for GNU, with keywords in their context.
2 Copyright (C) 1990, 1991, 1993, 1998-2009 Free Software Foundation, Inc.
3 François Pinard <pinard@iro.umontreal.ca>, 1988.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 François Pinard <pinard@iro.umontreal.ca> */
23 #include <sys/types.h>
34 /* The official name of this program (e.g., no `g' prefix). */
35 #define PROGRAM_NAME "ptx"
37 /* TRANSLATORS: Please translate "F. Pinard" to "François Pinard"
38 if "ç" (c-with-cedilla) is available in the translation's character
40 #define AUTHORS proper_name_utf8 ("F. Pinard", "Fran\xc3\xa7ois Pinard")
42 /* Number of possible characters in a byte. */
43 #define CHAR_SET_SIZE 256
45 #define ISODIGIT(C) ((C) >= '0' && (C) <= '7')
46 #define HEXTOBIN(C) ((C) >= 'a' && (C) <= 'f' ? (C)-'a'+10 \
47 : (C) >= 'A' && (C) <= 'F' ? (C)-'A'+10 : (C)-'0')
48 #define OCTTOBIN(C) ((C) - '0')
50 /* Debugging the memory allocator. */
53 # define MALLOC_FUNC_CHECK 1
57 /* Global definitions. */
59 /* FIXME: There are many unchecked integer overflows in this file,
60 that will cause this command to misbehave given large inputs or
61 options. Many of the "int" values below should be "size_t" or
62 something else like that. */
64 /* Reallocation step when swallowing non regular files. The value is not
65 the actual reallocation step, but its base two logarithm. */
66 #define SWALLOW_REALLOC_LOG 12
68 /* Program options. */
72 UNKNOWN_FORMAT
, /* output format still unknown */
73 DUMB_FORMAT
, /* output for a dumb terminal */
74 ROFF_FORMAT
, /* output for `troff' or `nroff' */
75 TEX_FORMAT
/* output for `TeX' or `LaTeX' */
78 static bool gnu_extensions
= true; /* trigger all GNU extensions */
79 static bool auto_reference
= false; /* refs are `file_name:line_number:' */
80 static bool input_reference
= false; /* refs at beginning of input lines */
81 static bool right_reference
= false; /* output refs after right context */
82 static int line_width
= 72; /* output line width in characters */
83 static int gap_size
= 3; /* number of spaces between output fields */
84 static const char *truncation_string
= "/";
85 /* string used to mark line truncations */
86 static const char *macro_name
= "xx"; /* macro name for roff or TeX output */
87 static enum Format output_format
= UNKNOWN_FORMAT
;
90 static bool ignore_case
= false; /* fold lower to upper for sorting */
91 static const char *break_file
= NULL
; /* name of the `Break characters' file */
92 static const char *only_file
= NULL
; /* name of the `Only words' file */
93 static const char *ignore_file
= NULL
; /* name of the `Ignore words' file */
95 /* Options that use regular expressions. */
98 /* The original regular expression, as a string. */
101 /* The compiled regular expression, and its fastmap. */
102 struct re_pattern_buffer pattern
;
103 char fastmap
[UCHAR_MAX
+ 1];
106 static struct regex_data context_regex
; /* end of context */
107 static struct regex_data word_regex
; /* keyword */
109 /* A BLOCK delimit a region in memory of arbitrary size, like the copy of a
110 whole file. A WORD is something smaller, its length should fit in a
111 short integer. A WORD_TABLE may contain several WORDs. */
115 char *start
; /* pointer to beginning of region */
116 char *end
; /* pointer to end + 1 of region */
122 char *start
; /* pointer to beginning of region */
123 short int size
; /* length of the region */
129 WORD
*start
; /* array of WORDs */
130 size_t alloc
; /* allocated length */
131 size_t length
; /* number of used entries */
135 /* Pattern description tables. */
137 /* For each character, provide its folded equivalent. */
138 static unsigned char folded_chars
[CHAR_SET_SIZE
];
140 /* End of context pattern register indices. */
141 static struct re_registers context_regs
;
143 /* Keyword pattern register indices. */
144 static struct re_registers word_regs
;
146 /* A word characters fastmap is used only when no word regexp has been
147 provided. A word is then made up of a sequence of one or more characters
148 allowed by the fastmap. Contains !0 if character allowed in word. Not
149 only this is faster in most cases, but it simplifies the implementation
150 of the Break files. */
151 static char word_fastmap
[CHAR_SET_SIZE
];
153 /* Maximum length of any word read. */
154 static int maximum_word_length
;
156 /* Maximum width of any reference used. */
157 static int reference_max_width
;
159 /* Ignore and Only word tables. */
161 static WORD_TABLE ignore_table
; /* table of words to ignore */
162 static WORD_TABLE only_table
; /* table of words to select */
164 /* Source text table, and scanning macros. */
166 static int number_input_files
; /* number of text input files */
167 static int total_line_count
; /* total number of lines seen so far */
168 static const char **input_file_name
; /* array of text input file names */
169 static int *file_line_count
; /* array of `total_line_count' values at end */
171 static BLOCK text_buffer
; /* file to study */
173 /* SKIP_NON_WHITE used only for getting or skipping the reference. */
175 #define SKIP_NON_WHITE(cursor, limit) \
176 while (cursor < limit && ! isspace (to_uchar (*cursor))) \
179 #define SKIP_WHITE(cursor, limit) \
180 while (cursor < limit && isspace (to_uchar (*cursor))) \
183 #define SKIP_WHITE_BACKWARDS(cursor, start) \
184 while (cursor > start && isspace (to_uchar (cursor[-1]))) \
187 #define SKIP_SOMETHING(cursor, limit) \
188 if (word_regex.string) \
191 count = re_match (&word_regex.pattern, cursor, limit - cursor, 0, NULL); \
194 cursor += count == -1 ? 1 : count; \
196 else if (word_fastmap[to_uchar (*cursor)]) \
197 while (cursor < limit && word_fastmap[to_uchar (*cursor)]) \
202 /* Occurrences table.
204 The `keyword' pointer provides the central word, which is surrounded
205 by a left context and a right context. The `keyword' and `length'
206 field allow full 8-bit characters keys, even including NULs. At other
207 places in this program, the name `keyafter' refers to the keyword
208 followed by its right context.
210 The left context does not extend, towards the beginning of the file,
211 further than a distance given by the `left' value. This value is
212 relative to the keyword beginning, it is usually negative. This
213 insures that, except for white space, we will never have to backward
214 scan the source text, when it is time to generate the final output
217 The right context, indirectly attainable through the keyword end, does
218 not extend, towards the end of the file, further than a distance given
219 by the `right' value. This value is relative to the keyword
220 beginning, it is usually positive.
222 When automatic references are used, the `reference' value is the
223 overall line number in all input files read so far, in this case, it
224 is of type (int). When input references are used, the `reference'
225 value indicates the distance between the keyword beginning and the
226 start of the reference field, it is of type (DELTA) and usually
229 typedef short int DELTA
; /* to hold displacement within one context */
233 WORD key
; /* description of the keyword */
234 DELTA left
; /* distance to left context start */
235 DELTA right
; /* distance to right context end */
236 int reference
; /* reference descriptor */
240 /* The various OCCURS tables are indexed by the language. But the time
241 being, there is no such multiple language support. */
243 static OCCURS
*occurs_table
[1]; /* all words retained from the read text */
244 static size_t occurs_alloc
[1]; /* allocated size of occurs_table */
245 static size_t number_of_occurs
[1]; /* number of used slots in occurs_table */
248 /* Communication among output routines. */
250 /* Indicate if special output processing is requested for each character. */
251 static char edited_flag
[CHAR_SET_SIZE
];
253 static int half_line_width
; /* half of line width, reference excluded */
254 static int before_max_width
; /* maximum width of before field */
255 static int keyafter_max_width
; /* maximum width of keyword-and-after field */
256 static int truncation_string_length
;/* length of string used to flag truncation */
258 /* When context is limited by lines, wraparound may happen on final output:
259 the `head' pointer gives access to some supplementary left context which
260 will be seen at the end of the output line, the `tail' pointer gives
261 access to some supplementary right context which will be seen at the
262 beginning of the output line. */
264 static BLOCK tail
; /* tail field */
265 static int tail_truncation
; /* flag truncation after the tail field */
267 static BLOCK before
; /* before field */
268 static int before_truncation
; /* flag truncation before the before field */
270 static BLOCK keyafter
; /* keyword-and-after field */
271 static int keyafter_truncation
; /* flag truncation after the keyafter field */
273 static BLOCK head
; /* head field */
274 static int head_truncation
; /* flag truncation before the head field */
276 static BLOCK reference
; /* reference field for input reference mode */
278 /* Miscellaneous routines. */
280 /* Diagnose an error in the regular expression matcher. Then exit. */
282 static void ATTRIBUTE_NORETURN
285 error (0, errno
, _("error in regular expression matcher"));
289 /*------------------------------------------------------.
290 | Duplicate string STRING, while evaluating \-escapes. |
291 `------------------------------------------------------*/
293 /* Loosely adapted from GNU sh-utils printf.c code. */
296 copy_unescaped_string (const char *string
)
298 char *result
; /* allocated result */
299 char *cursor
; /* cursor in result */
300 int value
; /* value of \nnn escape */
301 int length
; /* length of \nnn escape */
303 result
= xmalloc (strlen (string
) + 1);
313 case 'x': /* \xhhh escape, 3 chars maximum */
315 for (length
= 0, string
++;
316 length
< 3 && isxdigit (to_uchar (*string
));
318 value
= value
* 16 + HEXTOBIN (*string
);
328 case '0': /* \0ooo escape, 3 chars maximum */
330 for (length
= 0, string
++;
331 length
< 3 && ISODIGIT (*string
);
333 value
= value
* 8 + OCTTOBIN (*string
);
337 case 'a': /* alert */
346 case 'b': /* backspace */
351 case 'c': /* cancel the rest of the output */
356 case 'f': /* form feed */
361 case 'n': /* new line */
366 case 'r': /* carriage return */
371 case 't': /* horizontal tab */
376 case 'v': /* vertical tab */
385 case '\0': /* lone backslash at end of string */
391 *cursor
++ = *string
++;
396 *cursor
++ = *string
++;
403 /*--------------------------------------------------------------------------.
404 | Compile the regex represented by REGEX, diagnose and abort if any error. |
405 `--------------------------------------------------------------------------*/
408 compile_regex (struct regex_data
*regex
)
410 struct re_pattern_buffer
*pattern
= ®ex
->pattern
;
411 char const *string
= regex
->string
;
414 pattern
->buffer
= NULL
;
415 pattern
->allocated
= 0;
416 pattern
->fastmap
= regex
->fastmap
;
417 pattern
->translate
= ignore_case
? folded_chars
: NULL
;
419 message
= re_compile_pattern (string
, strlen (string
), pattern
);
421 error (EXIT_FAILURE
, 0, _("%s (for regexp %s)"), message
, quote (string
));
423 /* The fastmap should be compiled before `re_match'. The following
424 call is not mandatory, because `re_search' is always called sooner,
425 and it compiles the fastmap if this has not been done yet. */
427 re_compile_fastmap (pattern
);
430 /*------------------------------------------------------------------------.
431 | This will initialize various tables for pattern match and compiles some |
433 `------------------------------------------------------------------------*/
436 initialize_regex (void)
438 int character
; /* character value */
440 /* Initialize the case folding table. */
443 for (character
= 0; character
< CHAR_SET_SIZE
; character
++)
444 folded_chars
[character
] = toupper (character
);
446 /* Unless the user already provided a description of the end of line or
447 end of sentence sequence, select an end of line sequence to compile.
448 If the user provided an empty definition, thus disabling end of line
449 or sentence feature, make it NULL to speed up tests. If GNU
450 extensions are enabled, use end of sentence like in GNU emacs. If
451 disabled, use end of lines. */
453 if (context_regex
.string
)
455 if (!*context_regex
.string
)
456 context_regex
.string
= NULL
;
458 else if (gnu_extensions
&& !input_reference
)
459 context_regex
.string
= "[.?!][]\"')}]*\\($\\|\t\\| \\)[ \t\n]*";
461 context_regex
.string
= "\n";
463 if (context_regex
.string
)
464 compile_regex (&context_regex
);
466 /* If the user has already provided a non-empty regexp to describe
467 words, compile it. Else, unless this has already been done through
468 a user provided Break character file, construct a fastmap of
469 characters that may appear in a word. If GNU extensions enabled,
470 include only letters of the underlying character set. If disabled,
471 include almost everything, even punctuations; stop only on white
474 if (word_regex
.string
)
475 compile_regex (&word_regex
);
476 else if (!break_file
)
483 for (character
= 0; character
< CHAR_SET_SIZE
; character
++)
484 word_fastmap
[character
] = !! isalpha (character
);
489 /* Simulate [^ \t\n]+. */
491 memset (word_fastmap
, 1, CHAR_SET_SIZE
);
492 word_fastmap
[' '] = 0;
493 word_fastmap
['\t'] = 0;
494 word_fastmap
['\n'] = 0;
499 /*------------------------------------------------------------------------.
500 | This routine will attempt to swallow a whole file name FILE_NAME into a |
501 | contiguous region of memory and return a description of it into BLOCK. |
502 | Standard input is assumed whenever FILE_NAME is NULL, empty or "-". |
504 | Previously, in some cases, white space compression was attempted while |
505 | inputting text. This was defeating some regexps like default end of |
506 | sentence, which checks for two consecutive spaces. If white space |
507 | compression is ever reinstated, it should be in output routines. |
508 `------------------------------------------------------------------------*/
511 swallow_file_in_memory (const char *file_name
, BLOCK
*block
)
513 int file_handle
; /* file descriptor number */
514 struct stat stat_block
; /* stat block for file */
515 size_t allocated_length
; /* allocated length of memory buffer */
516 size_t used_length
; /* used length in memory buffer */
517 int read_length
; /* number of character gotten on last read */
519 /* As special cases, a file name which is NULL or "-" indicates standard
520 input, which is already opened. In all other cases, open the file from
522 bool using_stdin
= !file_name
|| !*file_name
|| STREQ (file_name
, "-");
524 file_handle
= STDIN_FILENO
;
526 if ((file_handle
= open (file_name
, O_RDONLY
)) < 0)
527 error (EXIT_FAILURE
, errno
, "%s", file_name
);
529 /* If the file is a plain, regular file, allocate the memory buffer all at
530 once and swallow the file in one blow. In other cases, read the file
531 repeatedly in smaller chunks until we have it all, reallocating memory
532 once in a while, as we go. */
534 if (fstat (file_handle
, &stat_block
) < 0)
535 error (EXIT_FAILURE
, errno
, "%s", file_name
);
537 if (S_ISREG (stat_block
.st_mode
))
539 size_t in_memory_size
;
541 block
->start
= xmalloc ((size_t) stat_block
.st_size
);
543 if ((in_memory_size
= read (file_handle
,
544 block
->start
, (size_t) stat_block
.st_size
))
545 != stat_block
.st_size
)
548 /* On MSDOS, in memory size may be smaller than the file
549 size, because of end of line conversions. But it can
550 never be smaller than half the file size, because the
551 minimum is when all lines are empty and terminated by
553 if (in_memory_size
!= (size_t)-1
554 && in_memory_size
>= stat_block
.st_size
/ 2)
555 block
->start
= xrealloc (block
->start
, in_memory_size
);
557 #endif /* not MSDOS */
559 error (EXIT_FAILURE
, errno
, "%s", file_name
);
561 block
->end
= block
->start
+ in_memory_size
;
565 block
->start
= xmalloc ((size_t) 1 << SWALLOW_REALLOC_LOG
);
567 allocated_length
= (1 << SWALLOW_REALLOC_LOG
);
569 while (read_length
= read (file_handle
,
570 block
->start
+ used_length
,
571 allocated_length
- used_length
),
574 used_length
+= read_length
;
575 if (used_length
== allocated_length
)
577 allocated_length
+= (1 << SWALLOW_REALLOC_LOG
);
579 = xrealloc (block
->start
, allocated_length
);
584 error (EXIT_FAILURE
, errno
, "%s", file_name
);
586 block
->end
= block
->start
+ used_length
;
589 /* Close the file, but only if it was not the standard input. */
591 if (! using_stdin
&& close (file_handle
) != 0)
592 error (EXIT_FAILURE
, errno
, "%s", file_name
);
595 /* Sort and search routines. */
597 /*--------------------------------------------------------------------------.
598 | Compare two words, FIRST and SECOND, and return 0 if they are identical. |
599 | Return less than 0 if the first word goes before the second; return |
600 | greater than 0 if the first word goes after the second. |
602 | If a word is indeed a prefix of the other, the shorter should go first. |
603 `--------------------------------------------------------------------------*/
606 compare_words (const void *void_first
, const void *void_second
)
608 #define first ((const WORD *) void_first)
609 #define second ((const WORD *) void_second)
610 int length
; /* minimum of two lengths */
611 int counter
; /* cursor in words */
612 int value
; /* value of comparison */
614 length
= first
->size
< second
->size
? first
->size
: second
->size
;
618 for (counter
= 0; counter
< length
; counter
++)
620 value
= (folded_chars
[to_uchar (first
->start
[counter
])]
621 - folded_chars
[to_uchar (second
->start
[counter
])]);
628 for (counter
= 0; counter
< length
; counter
++)
630 value
= (to_uchar (first
->start
[counter
])
631 - to_uchar (second
->start
[counter
]));
637 return first
->size
- second
->size
;
642 /*-----------------------------------------------------------------------.
643 | Decides which of two OCCURS, FIRST or SECOND, should lexicographically |
644 | go first. In case of a tie, preserve the original order through a |
645 | pointer comparison. |
646 `-----------------------------------------------------------------------*/
649 compare_occurs (const void *void_first
, const void *void_second
)
651 #define first ((const OCCURS *) void_first)
652 #define second ((const OCCURS *) void_second)
655 value
= compare_words (&first
->key
, &second
->key
);
656 return value
== 0 ? first
->key
.start
- second
->key
.start
: value
;
661 /*------------------------------------------------------------.
662 | Return !0 if WORD appears in TABLE. Uses a binary search. |
663 `------------------------------------------------------------*/
666 search_table (WORD
*word
, WORD_TABLE
*table
)
668 int lowest
; /* current lowest possible index */
669 int highest
; /* current highest possible index */
670 int middle
; /* current middle index */
671 int value
; /* value from last comparison */
674 highest
= table
->length
- 1;
675 while (lowest
<= highest
)
677 middle
= (lowest
+ highest
) / 2;
678 value
= compare_words (word
, table
->start
+ middle
);
680 highest
= middle
- 1;
689 /*---------------------------------------------------------------------.
690 | Sort the whole occurs table in memory. Presumably, `qsort' does not |
691 | take intermediate copies or table elements, so the sort will be |
692 | stabilized throughout the comparison routine. |
693 `---------------------------------------------------------------------*/
696 sort_found_occurs (void)
699 /* Only one language for the time being. */
701 qsort (occurs_table
[0], number_of_occurs
[0], sizeof **occurs_table
,
705 /* Parameter files reading routines. */
707 /*----------------------------------------------------------------------.
708 | Read a file named FILE_NAME, containing a set of break characters. |
709 | Build a content to the array word_fastmap in which all characters are |
710 | allowed except those found in the file. Characters may be repeated. |
711 `----------------------------------------------------------------------*/
714 digest_break_file (const char *file_name
)
716 BLOCK file_contents
; /* to receive a copy of the file */
717 char *cursor
; /* cursor in file copy */
719 swallow_file_in_memory (file_name
, &file_contents
);
721 /* Make the fastmap and record the file contents in it. */
723 memset (word_fastmap
, 1, CHAR_SET_SIZE
);
724 for (cursor
= file_contents
.start
; cursor
< file_contents
.end
; cursor
++)
725 word_fastmap
[to_uchar (*cursor
)] = 0;
730 /* If GNU extensions are enabled, the only way to avoid newline as
731 a break character is to write all the break characters in the
732 file with no newline at all, not even at the end of the file.
733 If disabled, spaces, tabs and newlines are always considered as
734 break characters even if not included in the break file. */
736 word_fastmap
[' '] = 0;
737 word_fastmap
['\t'] = 0;
738 word_fastmap
['\n'] = 0;
741 /* Return the space of the file, which is no more required. */
743 free (file_contents
.start
);
746 /*-----------------------------------------------------------------------.
747 | Read a file named FILE_NAME, containing one word per line, then |
748 | construct in TABLE a table of WORD descriptors for them. The routine |
749 | swallows the whole file in memory; this is at the expense of space |
750 | needed for newlines, which are useless; however, the reading is fast. |
751 `-----------------------------------------------------------------------*/
754 digest_word_file (const char *file_name
, WORD_TABLE
*table
)
756 BLOCK file_contents
; /* to receive a copy of the file */
757 char *cursor
; /* cursor in file copy */
758 char *word_start
; /* start of the current word */
760 swallow_file_in_memory (file_name
, &file_contents
);
766 /* Read the whole file. */
768 cursor
= file_contents
.start
;
769 while (cursor
< file_contents
.end
)
772 /* Read one line, and save the word in contains. */
775 while (cursor
< file_contents
.end
&& *cursor
!= '\n')
778 /* Record the word in table if it is not empty. */
780 if (cursor
> word_start
)
782 if (table
->length
== table
->alloc
)
784 if ((SIZE_MAX
/ sizeof *table
->start
- 1) / 2 < table
->alloc
)
786 table
->alloc
= table
->alloc
* 2 + 1;
787 table
->start
= xrealloc (table
->start
,
788 table
->alloc
* sizeof *table
->start
);
791 table
->start
[table
->length
].start
= word_start
;
792 table
->start
[table
->length
].size
= cursor
- word_start
;
796 /* This test allows for an incomplete line at end of file. */
798 if (cursor
< file_contents
.end
)
802 /* Finally, sort all the words read. */
804 qsort (table
->start
, table
->length
, sizeof table
->start
[0], compare_words
);
807 /* Keyword recognition and selection. */
809 /*----------------------------------------------------------------------.
810 | For each keyword in the source text, constructs an OCCURS structure. |
811 `----------------------------------------------------------------------*/
814 find_occurs_in_text (void)
816 char *cursor
; /* for scanning the source text */
817 char *scan
; /* for scanning the source text also */
818 char *line_start
; /* start of the current input line */
819 char *line_scan
; /* newlines scanned until this point */
820 int reference_length
; /* length of reference in input mode */
821 WORD possible_key
; /* possible key, to ease searches */
822 OCCURS
*occurs_cursor
; /* current OCCURS under construction */
824 char *context_start
; /* start of left context */
825 char *context_end
; /* end of right context */
826 char *word_start
; /* start of word */
827 char *word_end
; /* end of word */
828 char *next_context_start
; /* next start of left context */
830 /* reference_length is always used within `if (input_reference)'.
831 However, GNU C diagnoses that it may be used uninitialized. The
832 following assignment is merely to shut it up. */
834 reference_length
= 0;
836 /* Tracking where lines start is helpful for reference processing. In
837 auto reference mode, this allows counting lines. In input reference
838 mode, this permits finding the beginning of the references.
840 The first line begins with the file, skip immediately this very first
841 reference in input reference mode, to help further rejection any word
842 found inside it. Also, unconditionally assigning these variable has
843 the happy effect of shutting up lint. */
845 line_start
= text_buffer
.start
;
846 line_scan
= line_start
;
849 SKIP_NON_WHITE (line_scan
, text_buffer
.end
);
850 reference_length
= line_scan
- line_start
;
851 SKIP_WHITE (line_scan
, text_buffer
.end
);
854 /* Process the whole buffer, one line or one sentence at a time. */
856 for (cursor
= text_buffer
.start
;
857 cursor
< text_buffer
.end
;
858 cursor
= next_context_start
)
861 /* `context_start' gets initialized before the processing of each
862 line, or once for the whole buffer if no end of line or sentence
863 sequence separator. */
865 context_start
= cursor
;
867 /* If a end of line or end of sentence sequence is defined and
868 non-empty, `next_context_start' will be recomputed to be the end of
869 each line or sentence, before each one is processed. If no such
870 sequence, then `next_context_start' is set at the end of the whole
871 buffer, which is then considered to be a single line or sentence.
872 This test also accounts for the case of an incomplete line or
873 sentence at the end of the buffer. */
875 next_context_start
= text_buffer
.end
;
876 if (context_regex
.string
)
877 switch (re_search (&context_regex
.pattern
, cursor
,
878 text_buffer
.end
- cursor
,
879 0, text_buffer
.end
- cursor
, &context_regs
))
888 next_context_start
= cursor
+ context_regs
.end
[0];
892 /* Include the separator into the right context, but not any suffix
893 white space in this separator; this insures it will be seen in
894 output and will not take more space than necessary. */
896 context_end
= next_context_start
;
897 SKIP_WHITE_BACKWARDS (context_end
, context_start
);
899 /* Read and process a single input line or sentence, one word at a
904 if (word_regex
.string
)
906 /* If a word regexp has been compiled, use it to skip at the
907 beginning of the next word. If there is no such word, exit
911 regoff_t r
= re_search (&word_regex
.pattern
, cursor
,
912 context_end
- cursor
,
913 0, context_end
- cursor
, &word_regs
);
918 word_start
= cursor
+ word_regs
.start
[0];
919 word_end
= cursor
+ word_regs
.end
[0];
923 /* Avoid re_search and use the fastmap to skip to the
924 beginning of the next word. If there is no more word in
925 the buffer, exit the loop. */
929 while (scan
< context_end
930 && !word_fastmap
[to_uchar (*scan
)])
933 if (scan
== context_end
)
938 while (scan
< context_end
939 && word_fastmap
[to_uchar (*scan
)])
945 /* Skip right to the beginning of the found word. */
949 /* Skip any zero length word. Just advance a single position,
950 then go fetch the next word. */
952 if (word_end
== word_start
)
958 /* This is a genuine, non empty word, so save it as a possible
959 key. Then skip over it. Also, maintain the maximum length of
960 all words read so far. It is mandatory to take the maximum
961 length of all words in the file, without considering if they
962 are actually kept or rejected, because backward jumps at output
963 generation time may fall in *any* word. */
965 possible_key
.start
= cursor
;
966 possible_key
.size
= word_end
- word_start
;
967 cursor
+= possible_key
.size
;
969 if (possible_key
.size
> maximum_word_length
)
970 maximum_word_length
= possible_key
.size
;
972 /* In input reference mode, update `line_start' from its previous
973 value. Count the lines just in case auto reference mode is
974 also selected. If it happens that the word just matched is
975 indeed part of a reference; just ignore it. */
979 while (line_scan
< possible_key
.start
)
980 if (*line_scan
== '\n')
984 line_start
= line_scan
;
985 SKIP_NON_WHITE (line_scan
, text_buffer
.end
);
986 reference_length
= line_scan
- line_start
;
990 if (line_scan
> possible_key
.start
)
994 /* Ignore the word if an `Ignore words' table exists and if it is
995 part of it. Also ignore the word if an `Only words' table and
996 if it is *not* part of it.
998 It is allowed that both tables be used at once, even if this
999 may look strange for now. Just ignore a word that would appear
1000 in both. If regexps are eventually implemented for these
1001 tables, the Ignore table could then reject words that would
1002 have been previously accepted by the Only table. */
1004 if (ignore_file
&& search_table (&possible_key
, &ignore_table
))
1006 if (only_file
&& !search_table (&possible_key
, &only_table
))
1009 /* A non-empty word has been found. First of all, insure
1010 proper allocation of the next OCCURS, and make a pointer to
1011 where it will be constructed. */
1013 if (number_of_occurs
[0] == occurs_alloc
[0])
1015 if ((SIZE_MAX
/ sizeof *occurs_table
[0] - 1) / 2
1018 occurs_alloc
[0] = occurs_alloc
[0] * 2 + 1;
1019 occurs_table
[0] = xrealloc (occurs_table
[0],
1020 occurs_alloc
[0] * sizeof *occurs_table
[0]);
1023 occurs_cursor
= occurs_table
[0] + number_of_occurs
[0];
1025 /* Define the refence field, if any. */
1030 /* While auto referencing, update `line_start' from its
1031 previous value, counting lines as we go. If input
1032 referencing at the same time, `line_start' has been
1033 advanced earlier, and the following loop is never really
1036 while (line_scan
< possible_key
.start
)
1037 if (*line_scan
== '\n')
1041 line_start
= line_scan
;
1042 SKIP_NON_WHITE (line_scan
, text_buffer
.end
);
1047 occurs_cursor
->reference
= total_line_count
;
1049 else if (input_reference
)
1052 /* If only input referencing, `line_start' has been computed
1053 earlier to detect the case the word matched would be part
1054 of the reference. The reference position is simply the
1055 value of `line_start'. */
1057 occurs_cursor
->reference
1058 = (DELTA
) (line_start
- possible_key
.start
);
1059 if (reference_length
> reference_max_width
)
1060 reference_max_width
= reference_length
;
1063 /* Exclude the reference from the context in simple cases. */
1065 if (input_reference
&& line_start
== context_start
)
1067 SKIP_NON_WHITE (context_start
, context_end
);
1068 SKIP_WHITE (context_start
, context_end
);
1071 /* Completes the OCCURS structure. */
1073 occurs_cursor
->key
= possible_key
;
1074 occurs_cursor
->left
= context_start
- possible_key
.start
;
1075 occurs_cursor
->right
= context_end
- possible_key
.start
;
1077 number_of_occurs
[0]++;
1082 /* Formatting and actual output - service routines. */
1084 /*-----------------------------------------.
1085 | Prints some NUMBER of spaces on stdout. |
1086 `-----------------------------------------*/
1089 print_spaces (int number
)
1093 for (counter
= number
; counter
> 0; counter
--)
1097 /*-------------------------------------.
1098 | Prints the field provided by FIELD. |
1099 `-------------------------------------*/
1102 print_field (BLOCK field
)
1104 char *cursor
; /* Cursor in field to print */
1105 int base
; /* Base character, without diacritic */
1106 int diacritic
; /* Diacritic code for the character */
1108 /* Whitespace is not really compressed. Instead, each white space
1109 character (tab, vt, ht etc.) is printed as one single space. */
1111 for (cursor
= field
.start
; cursor
< field
.end
; cursor
++)
1113 unsigned char character
= *cursor
;
1114 if (edited_flag
[character
])
1117 /* First check if this is a diacriticized character.
1119 This works only for TeX. I do not know how diacriticized
1120 letters work with `roff'. Please someone explain it to me! */
1122 diacritic
= todiac (character
);
1123 if (diacritic
!= 0 && output_format
== TEX_FORMAT
)
1125 base
= tobase (character
);
1129 case 1: /* Latin diphthongs */
1133 fputs ("\\oe{}", stdout
);
1137 fputs ("\\OE{}", stdout
);
1141 fputs ("\\ae{}", stdout
);
1145 fputs ("\\AE{}", stdout
);
1153 case 2: /* Acute accent */
1154 printf ("\\'%s%c", (base
== 'i' ? "\\" : ""), base
);
1157 case 3: /* Grave accent */
1158 printf ("\\`%s%c", (base
== 'i' ? "\\" : ""), base
);
1161 case 4: /* Circumflex accent */
1162 printf ("\\^%s%c", (base
== 'i' ? "\\" : ""), base
);
1165 case 5: /* Diaeresis */
1166 printf ("\\\"%s%c", (base
== 'i' ? "\\" : ""), base
);
1169 case 6: /* Tilde accent */
1170 printf ("\\~%s%c", (base
== 'i' ? "\\" : ""), base
);
1173 case 7: /* Cedilla */
1174 printf ("\\c{%c}", base
);
1177 case 8: /* Small circle beneath */
1181 fputs ("\\aa{}", stdout
);
1185 fputs ("\\AA{}", stdout
);
1193 case 9: /* Strike through */
1197 fputs ("\\o{}", stdout
);
1201 fputs ("\\O{}", stdout
);
1212 /* This is not a diacritic character, so handle cases which are
1213 really specific to `roff' or TeX. All white space processing
1214 is done as the default case of this switch. */
1219 /* In roff output format, double any quote. */
1229 /* In TeX output format, precede these with a backslash. */
1231 putchar (character
);
1236 /* In TeX output format, precede these with a backslash and
1237 force mathematical mode. */
1238 printf ("$\\%c$", character
);
1242 /* In TeX output mode, request production of a backslash. */
1243 fputs ("\\backslash{}", stdout
);
1247 /* Any other flagged character produces a single space. */
1256 /* Formatting and actual output - planning routines. */
1258 /*--------------------------------------------------------------------.
1259 | From information collected from command line options and input file |
1260 | readings, compute and fix some output parameter values. |
1261 `--------------------------------------------------------------------*/
1264 fix_output_parameters (void)
1266 int file_index
; /* index in text input file arrays */
1267 int line_ordinal
; /* line ordinal value for reference */
1268 char ordinal_string
[12]; /* edited line ordinal for reference */
1269 int reference_width
; /* width for the whole reference */
1270 int character
; /* character ordinal */
1271 const char *cursor
; /* cursor in some constant strings */
1273 /* In auto reference mode, the maximum width of this field is
1274 precomputed and subtracted from the overall line width. Add one for
1275 the column which separate the file name from the line number. */
1279 reference_max_width
= 0;
1280 for (file_index
= 0; file_index
< number_input_files
; file_index
++)
1282 line_ordinal
= file_line_count
[file_index
] + 1;
1284 line_ordinal
-= file_line_count
[file_index
- 1];
1285 sprintf (ordinal_string
, "%d", line_ordinal
);
1286 reference_width
= strlen (ordinal_string
);
1287 if (input_file_name
[file_index
])
1288 reference_width
+= strlen (input_file_name
[file_index
]);
1289 if (reference_width
> reference_max_width
)
1290 reference_max_width
= reference_width
;
1292 reference_max_width
++;
1293 reference
.start
= xmalloc ((size_t) reference_max_width
+ 1);
1296 /* If the reference appears to the left of the output line, reserve some
1297 space for it right away, including one gap size. */
1299 if ((auto_reference
|| input_reference
) && !right_reference
)
1300 line_width
-= reference_max_width
+ gap_size
;
1302 /* The output lines, minimally, will contain from left to right a left
1303 context, a gap, and a keyword followed by the right context with no
1304 special intervening gap. Half of the line width is dedicated to the
1305 left context and the gap, the other half is dedicated to the keyword
1306 and the right context; these values are computed once and for all here.
1307 There also are tail and head wrap around fields, used when the keyword
1308 is near the beginning or the end of the line, or when some long word
1309 cannot fit in, but leave place from wrapped around shorter words. The
1310 maximum width of these fields are recomputed separately for each line,
1311 on a case by case basis. It is worth noting that it cannot happen that
1312 both the tail and head fields are used at once. */
1314 half_line_width
= line_width
/ 2;
1315 before_max_width
= half_line_width
- gap_size
;
1316 keyafter_max_width
= half_line_width
;
1318 /* If truncation_string is the empty string, make it NULL to speed up
1319 tests. In this case, truncation_string_length will never get used, so
1320 there is no need to set it. */
1322 if (truncation_string
&& *truncation_string
)
1323 truncation_string_length
= strlen (truncation_string
);
1325 truncation_string
= NULL
;
1330 /* When flagging truncation at the left of the keyword, the
1331 truncation mark goes at the beginning of the before field,
1332 unless there is a head field, in which case the mark goes at the
1333 left of the head field. When flagging truncation at the right
1334 of the keyword, the mark goes at the end of the keyafter field,
1335 unless there is a tail field, in which case the mark goes at the
1336 end of the tail field. Only eight combination cases could arise
1337 for truncation marks:
1340 . One beginning the before field.
1341 . One beginning the head field.
1342 . One ending the keyafter field.
1343 . One ending the tail field.
1344 . One beginning the before field, another ending the keyafter field.
1345 . One ending the tail field, another beginning the before field.
1346 . One ending the keyafter field, another beginning the head field.
1348 So, there is at most two truncation marks, which could appear both
1349 on the left side of the center of the output line, both on the
1350 right side, or one on either side. */
1352 before_max_width
-= 2 * truncation_string_length
;
1353 if (before_max_width
< 0)
1354 before_max_width
= 0;
1355 keyafter_max_width
-= 2 * truncation_string_length
;
1360 /* I never figured out exactly how UNIX' ptx plans the output width
1361 of its various fields. If GNU extensions are disabled, do not
1362 try computing the field widths correctly; instead, use the
1363 following formula, which does not completely imitate UNIX' ptx,
1366 keyafter_max_width
-= 2 * truncation_string_length
+ 1;
1369 /* Compute which characters need special output processing. Initialize
1370 by flagging any white space character. Some systems do not consider
1371 form feed as a space character, but we do. */
1373 for (character
= 0; character
< CHAR_SET_SIZE
; character
++)
1374 edited_flag
[character
] = !! isspace (character
);
1375 edited_flag
['\f'] = 1;
1377 /* Complete the special character flagging according to selected output
1380 switch (output_format
)
1382 case UNKNOWN_FORMAT
:
1383 /* Should never happen. */
1390 /* `Quote' characters should be doubled. */
1392 edited_flag
['"'] = 1;
1397 /* Various characters need special processing. */
1399 for (cursor
= "$%&#_{}\\"; *cursor
; cursor
++)
1400 edited_flag
[to_uchar (*cursor
)] = 1;
1402 /* Any character with 8th bit set will print to a single space, unless
1403 it is diacriticized. */
1405 for (character
= 0200; character
< CHAR_SET_SIZE
; character
++)
1406 edited_flag
[character
] = todiac (character
) != 0;
1411 /*------------------------------------------------------------------.
1412 | Compute the position and length of all the output fields, given a |
1413 | pointer to some OCCURS. |
1414 `------------------------------------------------------------------*/
1417 define_all_fields (OCCURS
*occurs
)
1419 int tail_max_width
; /* allowable width of tail field */
1420 int head_max_width
; /* allowable width of head field */
1421 char *cursor
; /* running cursor in source text */
1422 char *left_context_start
; /* start of left context */
1423 char *right_context_end
; /* end of right context */
1424 char *left_field_start
; /* conservative start for `head'/`before' */
1425 int file_index
; /* index in text input file arrays */
1426 const char *file_name
; /* file name for reference */
1427 int line_ordinal
; /* line ordinal for reference */
1429 /* Define `keyafter', start of left context and end of right context.
1430 `keyafter' starts at the saved position for keyword and extend to the
1431 right from the end of the keyword, eating separators or full words, but
1432 not beyond maximum allowed width for `keyafter' field or limit for the
1433 right context. Suffix spaces will be removed afterwards. */
1435 keyafter
.start
= occurs
->key
.start
;
1436 keyafter
.end
= keyafter
.start
+ occurs
->key
.size
;
1437 left_context_start
= keyafter
.start
+ occurs
->left
;
1438 right_context_end
= keyafter
.start
+ occurs
->right
;
1440 cursor
= keyafter
.end
;
1441 while (cursor
< right_context_end
1442 && cursor
<= keyafter
.start
+ keyafter_max_width
)
1444 keyafter
.end
= cursor
;
1445 SKIP_SOMETHING (cursor
, right_context_end
);
1447 if (cursor
<= keyafter
.start
+ keyafter_max_width
)
1448 keyafter
.end
= cursor
;
1450 keyafter_truncation
= truncation_string
&& keyafter
.end
< right_context_end
;
1452 SKIP_WHITE_BACKWARDS (keyafter
.end
, keyafter
.start
);
1454 /* When the left context is wide, it might take some time to catch up from
1455 the left context boundary to the beginning of the `head' or `before'
1456 fields. So, in this case, to speed the catchup, we jump back from the
1457 keyword, using some secure distance, possibly falling in the middle of
1458 a word. A secure backward jump would be at least half the maximum
1459 width of a line, plus the size of the longest word met in the whole
1460 input. We conclude this backward jump by a skip forward of at least
1461 one word. In this manner, we should not inadvertently accept only part
1462 of a word. From the reached point, when it will be time to fix the
1463 beginning of `head' or `before' fields, we will skip forward words or
1464 delimiters until we get sufficiently near. */
1466 if (-occurs
->left
> half_line_width
+ maximum_word_length
)
1469 = keyafter
.start
- (half_line_width
+ maximum_word_length
);
1470 SKIP_SOMETHING (left_field_start
, keyafter
.start
);
1473 left_field_start
= keyafter
.start
+ occurs
->left
;
1475 /* `before' certainly ends at the keyword, but not including separating
1476 spaces. It starts after than the saved value for the left context, by
1477 advancing it until it falls inside the maximum allowed width for the
1478 before field. There will be no prefix spaces either. `before' only
1479 advances by skipping single separators or whole words. */
1481 before
.start
= left_field_start
;
1482 before
.end
= keyafter
.start
;
1483 SKIP_WHITE_BACKWARDS (before
.end
, before
.start
);
1485 while (before
.start
+ before_max_width
< before
.end
)
1486 SKIP_SOMETHING (before
.start
, before
.end
);
1488 if (truncation_string
)
1490 cursor
= before
.start
;
1491 SKIP_WHITE_BACKWARDS (cursor
, text_buffer
.start
);
1492 before_truncation
= cursor
> left_context_start
;
1495 before_truncation
= 0;
1497 SKIP_WHITE (before
.start
, text_buffer
.end
);
1499 /* The tail could not take more columns than what has been left in the
1500 left context field, and a gap is mandatory. It starts after the
1501 right context, and does not contain prefixed spaces. It ends at
1502 the end of line, the end of buffer or when the tail field is full,
1503 whichever comes first. It cannot contain only part of a word, and
1504 has no suffixed spaces. */
1507 = before_max_width
- (before
.end
- before
.start
) - gap_size
;
1509 if (tail_max_width
> 0)
1511 tail
.start
= keyafter
.end
;
1512 SKIP_WHITE (tail
.start
, text_buffer
.end
);
1514 tail
.end
= tail
.start
;
1516 while (cursor
< right_context_end
1517 && cursor
< tail
.start
+ tail_max_width
)
1520 SKIP_SOMETHING (cursor
, right_context_end
);
1523 if (cursor
< tail
.start
+ tail_max_width
)
1526 if (tail
.end
> tail
.start
)
1528 keyafter_truncation
= 0;
1529 tail_truncation
= truncation_string
&& tail
.end
< right_context_end
;
1532 tail_truncation
= 0;
1534 SKIP_WHITE_BACKWARDS (tail
.end
, tail
.start
);
1539 /* No place left for a tail field. */
1543 tail_truncation
= 0;
1546 /* `head' could not take more columns than what has been left in the right
1547 context field, and a gap is mandatory. It ends before the left
1548 context, and does not contain suffixed spaces. Its pointer is advanced
1549 until the head field has shrunk to its allowed width. It cannot
1550 contain only part of a word, and has no suffixed spaces. */
1553 = keyafter_max_width
- (keyafter
.end
- keyafter
.start
) - gap_size
;
1555 if (head_max_width
> 0)
1557 head
.end
= before
.start
;
1558 SKIP_WHITE_BACKWARDS (head
.end
, text_buffer
.start
);
1560 head
.start
= left_field_start
;
1561 while (head
.start
+ head_max_width
< head
.end
)
1562 SKIP_SOMETHING (head
.start
, head
.end
);
1564 if (head
.end
> head
.start
)
1566 before_truncation
= 0;
1567 head_truncation
= (truncation_string
1568 && head
.start
> left_context_start
);
1571 head_truncation
= 0;
1573 SKIP_WHITE (head
.start
, head
.end
);
1578 /* No place left for a head field. */
1582 head_truncation
= 0;
1588 /* Construct the reference text in preallocated space from the file
1589 name and the line number. Find out in which file the reference
1590 occurred. Standard input yields an empty file name. Insure line
1591 numbers are one based, even if they are computed zero based. */
1594 while (file_line_count
[file_index
] < occurs
->reference
)
1597 file_name
= input_file_name
[file_index
];
1601 line_ordinal
= occurs
->reference
+ 1;
1603 line_ordinal
-= file_line_count
[file_index
- 1];
1605 sprintf (reference
.start
, "%s:%d", file_name
, line_ordinal
);
1606 reference
.end
= reference
.start
+ strlen (reference
.start
);
1608 else if (input_reference
)
1611 /* Reference starts at saved position for reference and extends right
1612 until some white space is met. */
1614 reference
.start
= keyafter
.start
+ (DELTA
) occurs
->reference
;
1615 reference
.end
= reference
.start
;
1616 SKIP_NON_WHITE (reference
.end
, right_context_end
);
1620 /* Formatting and actual output - control routines. */
1622 /*----------------------------------------------------------------------.
1623 | Output the current output fields as one line for `troff' or `nroff'. |
1624 `----------------------------------------------------------------------*/
1627 output_one_roff_line (void)
1629 /* Output the `tail' field. */
1631 printf (".%s \"", macro_name
);
1633 if (tail_truncation
)
1634 fputs (truncation_string
, stdout
);
1637 /* Output the `before' field. */
1639 fputs (" \"", stdout
);
1640 if (before_truncation
)
1641 fputs (truncation_string
, stdout
);
1642 print_field (before
);
1645 /* Output the `keyafter' field. */
1647 fputs (" \"", stdout
);
1648 print_field (keyafter
);
1649 if (keyafter_truncation
)
1650 fputs (truncation_string
, stdout
);
1653 /* Output the `head' field. */
1655 fputs (" \"", stdout
);
1656 if (head_truncation
)
1657 fputs (truncation_string
, stdout
);
1661 /* Conditionally output the `reference' field. */
1663 if (auto_reference
|| input_reference
)
1665 fputs (" \"", stdout
);
1666 print_field (reference
);
1673 /*---------------------------------------------------------.
1674 | Output the current output fields as one line for `TeX'. |
1675 `---------------------------------------------------------*/
1678 output_one_tex_line (void)
1680 BLOCK key
; /* key field, isolated */
1681 BLOCK after
; /* after field, isolated */
1682 char *cursor
; /* running cursor in source text */
1684 printf ("\\%s ", macro_name
);
1687 fputs ("}{", stdout
);
1688 print_field (before
);
1689 fputs ("}{", stdout
);
1690 key
.start
= keyafter
.start
;
1691 after
.end
= keyafter
.end
;
1692 cursor
= keyafter
.start
;
1693 SKIP_SOMETHING (cursor
, keyafter
.end
);
1695 after
.start
= cursor
;
1697 fputs ("}{", stdout
);
1698 print_field (after
);
1699 fputs ("}{", stdout
);
1702 if (auto_reference
|| input_reference
)
1705 print_field (reference
);
1711 /*-------------------------------------------------------------------.
1712 | Output the current output fields as one line for a dumb terminal. |
1713 `-------------------------------------------------------------------*/
1716 output_one_dumb_line (void)
1718 if (!right_reference
)
1723 /* Output the `reference' field, in such a way that GNU emacs
1724 next-error will handle it. The ending colon is taken from the
1725 gap which follows. */
1727 print_field (reference
);
1729 print_spaces (reference_max_width
1731 - (reference
.end
- reference
.start
)
1737 /* Output the `reference' field and its following gap. */
1739 print_field (reference
);
1740 print_spaces (reference_max_width
1742 - (reference
.end
- reference
.start
));
1746 if (tail
.start
< tail
.end
)
1748 /* Output the `tail' field. */
1751 if (tail_truncation
)
1752 fputs (truncation_string
, stdout
);
1754 print_spaces (half_line_width
- gap_size
1755 - (before
.end
- before
.start
)
1756 - (before_truncation
? truncation_string_length
: 0)
1757 - (tail
.end
- tail
.start
)
1758 - (tail_truncation
? truncation_string_length
: 0));
1761 print_spaces (half_line_width
- gap_size
1762 - (before
.end
- before
.start
)
1763 - (before_truncation
? truncation_string_length
: 0));
1765 /* Output the `before' field. */
1767 if (before_truncation
)
1768 fputs (truncation_string
, stdout
);
1769 print_field (before
);
1771 print_spaces (gap_size
);
1773 /* Output the `keyafter' field. */
1775 print_field (keyafter
);
1776 if (keyafter_truncation
)
1777 fputs (truncation_string
, stdout
);
1779 if (head
.start
< head
.end
)
1781 /* Output the `head' field. */
1783 print_spaces (half_line_width
1784 - (keyafter
.end
- keyafter
.start
)
1785 - (keyafter_truncation
? truncation_string_length
: 0)
1786 - (head
.end
- head
.start
)
1787 - (head_truncation
? truncation_string_length
: 0));
1788 if (head_truncation
)
1789 fputs (truncation_string
, stdout
);
1794 if ((auto_reference
|| input_reference
) && right_reference
)
1795 print_spaces (half_line_width
1796 - (keyafter
.end
- keyafter
.start
)
1797 - (keyafter_truncation
? truncation_string_length
: 0));
1799 if ((auto_reference
|| input_reference
) && right_reference
)
1801 /* Output the `reference' field. */
1803 print_spaces (gap_size
);
1804 print_field (reference
);
1810 /*------------------------------------------------------------------------.
1811 | Scan the whole occurs table and, for each entry, output one line in the |
1812 | appropriate format. |
1813 `------------------------------------------------------------------------*/
1816 generate_all_output (void)
1818 size_t occurs_index
; /* index of keyword entry being processed */
1819 OCCURS
*occurs_cursor
; /* current keyword entry being processed */
1821 /* The following assignments are useful to provide default values in case
1822 line contexts or references are not used, in which case these variables
1823 would never be computed. */
1827 tail_truncation
= 0;
1831 head_truncation
= 0;
1833 /* Loop over all keyword occurrences. */
1835 occurs_cursor
= occurs_table
[0];
1837 for (occurs_index
= 0; occurs_index
< number_of_occurs
[0]; occurs_index
++)
1839 /* Compute the exact size of every field and whenever truncation flags
1840 are present or not. */
1842 define_all_fields (occurs_cursor
);
1844 /* Produce one output line according to selected format. */
1846 switch (output_format
)
1848 case UNKNOWN_FORMAT
:
1849 /* Should never happen. */
1852 output_one_dumb_line ();
1856 output_one_roff_line ();
1860 output_one_tex_line ();
1864 /* Advance the cursor into the occurs table. */
1870 /* Option decoding and main program. */
1872 /*------------------------------------------------------.
1873 | Print program identification and options, then exit. |
1874 `------------------------------------------------------*/
1879 if (status
!= EXIT_SUCCESS
)
1880 fprintf (stderr
, _("Try `%s --help' for more information.\n"),
1885 Usage: %s [OPTION]... [INPUT]... (without -G)\n\
1886 or: %s -G [OPTION]... [INPUT [OUTPUT]]\n"),
1887 program_name
, program_name
);
1889 Output a permuted index, including context, of the words in the input files.\n\
1893 Mandatory arguments to long options are mandatory for short options too.\n\
1896 -A, --auto-reference output automatically generated references\n\
1897 -G, --traditional behave more like System V `ptx'\n\
1898 -F, --flag-truncation=STRING use STRING for flagging line truncations\n\
1901 -M, --macro-name=STRING macro name to use instead of `xx'\n\
1902 -O, --format=roff generate output as roff directives\n\
1903 -R, --right-side-refs put references at right, not counted in -w\n\
1904 -S, --sentence-regexp=REGEXP for end of lines or end of sentences\n\
1905 -T, --format=tex generate output as TeX directives\n\
1908 -W, --word-regexp=REGEXP use REGEXP to match each keyword\n\
1909 -b, --break-file=FILE word break characters in this FILE\n\
1910 -f, --ignore-case fold lower case to upper case for sorting\n\
1911 -g, --gap-size=NUMBER gap size in columns between output fields\n\
1912 -i, --ignore-file=FILE read ignore word list from FILE\n\
1913 -o, --only-file=FILE read only word list from this FILE\n\
1916 -r, --references first field of each line is a reference\n\
1917 -t, --typeset-mode - not implemented -\n\
1918 -w, --width=NUMBER output width in columns, reference excluded\n\
1920 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
1921 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
1924 With no FILE or if FILE is -, read Standard Input. `-F /' by default.\n\
1926 emit_ancillary_info ();
1931 /*----------------------------------------------------------------------.
1932 | Main program. Decode ARGC arguments passed through the ARGV array of |
1933 | strings, then launch execution. |
1934 `----------------------------------------------------------------------*/
1936 /* Long options equivalences. */
1937 static struct option
const long_options
[] =
1939 {"auto-reference", no_argument
, NULL
, 'A'},
1940 {"break-file", required_argument
, NULL
, 'b'},
1941 {"flag-truncation", required_argument
, NULL
, 'F'},
1942 {"ignore-case", no_argument
, NULL
, 'f'},
1943 {"gap-size", required_argument
, NULL
, 'g'},
1944 {"ignore-file", required_argument
, NULL
, 'i'},
1945 {"macro-name", required_argument
, NULL
, 'M'},
1946 {"only-file", required_argument
, NULL
, 'o'},
1947 {"references", no_argument
, NULL
, 'r'},
1948 {"right-side-refs", no_argument
, NULL
, 'R'},
1949 {"format", required_argument
, NULL
, 10},
1950 {"sentence-regexp", required_argument
, NULL
, 'S'},
1951 {"traditional", no_argument
, NULL
, 'G'},
1952 {"typeset-mode", no_argument
, NULL
, 't'},
1953 {"width", required_argument
, NULL
, 'w'},
1954 {"word-regexp", required_argument
, NULL
, 'W'},
1955 {GETOPT_HELP_OPTION_DECL
},
1956 {GETOPT_VERSION_OPTION_DECL
},
1960 static char const* const format_args
[] =
1965 static enum Format
const format_vals
[] =
1967 ROFF_FORMAT
, TEX_FORMAT
1971 main (int argc
, char **argv
)
1973 int optchar
; /* argument character */
1974 int file_index
; /* index in text input file arrays */
1976 /* Decode program options. */
1978 initialize_main (&argc
, &argv
);
1979 set_program_name (argv
[0]);
1980 setlocale (LC_ALL
, "");
1981 bindtextdomain (PACKAGE
, LOCALEDIR
);
1982 textdomain (PACKAGE
);
1984 atexit (close_stdout
);
1986 #if HAVE_SETCHRCLASS
1990 while (optchar
= getopt_long (argc
, argv
, "AF:GM:ORS:TW:b:i:fg:o:trw:",
1991 long_options
, NULL
),
1997 usage (EXIT_FAILURE
);
2000 gnu_extensions
= false;
2004 break_file
= optarg
;
2013 unsigned long int tmp_ulong
;
2014 if (xstrtoul (optarg
, NULL
, 0, &tmp_ulong
, NULL
) != LONGINT_OK
2015 || ! (0 < tmp_ulong
&& tmp_ulong
<= INT_MAX
))
2016 error (EXIT_FAILURE
, 0, _("invalid gap width: %s"),
2018 gap_size
= tmp_ulong
;
2023 ignore_file
= optarg
;
2031 input_reference
= true;
2035 /* Yet to understand... */
2040 unsigned long int tmp_ulong
;
2041 if (xstrtoul (optarg
, NULL
, 0, &tmp_ulong
, NULL
) != LONGINT_OK
2042 || ! (0 < tmp_ulong
&& tmp_ulong
<= INT_MAX
))
2043 error (EXIT_FAILURE
, 0, _("invalid line width: %s"),
2045 line_width
= tmp_ulong
;
2050 auto_reference
= true;
2054 truncation_string
= copy_unescaped_string (optarg
);
2058 macro_name
= optarg
;
2062 output_format
= ROFF_FORMAT
;
2066 right_reference
= true;
2070 context_regex
.string
= copy_unescaped_string (optarg
);
2074 output_format
= TEX_FORMAT
;
2078 word_regex
.string
= copy_unescaped_string (optarg
);
2079 if (!*word_regex
.string
)
2080 word_regex
.string
= NULL
;
2084 output_format
= XARGMATCH ("--format", optarg
,
2085 format_args
, format_vals
);
2086 case_GETOPT_HELP_CHAR
;
2088 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
2092 /* Process remaining arguments. If GNU extensions are enabled, process
2093 all arguments as input parameters. If disabled, accept at most two
2094 arguments, the second of which is an output parameter. */
2099 /* No more argument simply means: read standard input. */
2101 input_file_name
= xmalloc (sizeof *input_file_name
);
2102 file_line_count
= xmalloc (sizeof *file_line_count
);
2103 number_input_files
= 1;
2104 input_file_name
[0] = NULL
;
2106 else if (gnu_extensions
)
2108 number_input_files
= argc
- optind
;
2109 input_file_name
= xmalloc (number_input_files
* sizeof *input_file_name
);
2110 file_line_count
= xmalloc (number_input_files
* sizeof *file_line_count
);
2112 for (file_index
= 0; file_index
< number_input_files
; file_index
++)
2114 if (!*argv
[optind
] || STREQ (argv
[optind
], "-"))
2115 input_file_name
[file_index
] = NULL
;
2117 input_file_name
[file_index
] = argv
[optind
];
2124 /* There is one necessary input file. */
2126 number_input_files
= 1;
2127 input_file_name
= xmalloc (sizeof *input_file_name
);
2128 file_line_count
= xmalloc (sizeof *file_line_count
);
2129 if (!*argv
[optind
] || STREQ (argv
[optind
], "-"))
2130 input_file_name
[0] = NULL
;
2132 input_file_name
[0] = argv
[optind
];
2135 /* Redirect standard output, only if requested. */
2139 if (! freopen (argv
[optind
], "w", stdout
))
2140 error (EXIT_FAILURE
, errno
, "%s", argv
[optind
]);
2144 /* Diagnose any other argument as an error. */
2148 error (0, 0, _("extra operand %s"), quote (argv
[optind
]));
2149 usage (EXIT_FAILURE
);
2153 /* If the output format has not been explicitly selected, choose dumb
2154 terminal format if GNU extensions are enabled, else `roff' format. */
2156 if (output_format
== UNKNOWN_FORMAT
)
2157 output_format
= gnu_extensions
? DUMB_FORMAT
: ROFF_FORMAT
;
2159 /* Initialize the main tables. */
2161 initialize_regex ();
2163 /* Read `Break character' file, if any. */
2166 digest_break_file (break_file
);
2168 /* Read `Ignore words' file and `Only words' files, if any. If any of
2169 these files is empty, reset the name of the file to NULL, to avoid
2170 unnecessary calls to search_table. */
2174 digest_word_file (ignore_file
, &ignore_table
);
2175 if (ignore_table
.length
== 0)
2181 digest_word_file (only_file
, &only_table
);
2182 if (only_table
.length
== 0)
2186 /* Prepare to study all the input files. */
2188 number_of_occurs
[0] = 0;
2189 total_line_count
= 0;
2190 maximum_word_length
= 0;
2191 reference_max_width
= 0;
2193 for (file_index
= 0; file_index
< number_input_files
; file_index
++)
2196 /* Read the file in core, than study it. */
2198 swallow_file_in_memory (input_file_name
[file_index
], &text_buffer
);
2199 find_occurs_in_text ();
2201 /* Maintain for each file how many lines has been read so far when its
2202 end is reached. Incrementing the count first is a simple kludge to
2203 handle a possible incomplete line at end of file. */
2206 file_line_count
[file_index
] = total_line_count
;
2209 /* Do the output process phase. */
2211 sort_found_occurs ();
2212 fix_output_parameters ();
2213 generate_all_output ();
2217 exit (EXIT_SUCCESS
);