/* indices.c -- deal with an Info file index. Copyright 1993-2023 Free Software Foundation, Inc. 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 . Originally written by Brian Fox. */ #include "info.h" #include "scan.h" #include "util.h" #include "session.h" #include "echo-area.h" #include "indices.h" #include "variables.h" /* User-visible variable controls the output of info-index-next. */ int show_index_match = 1; /* The combined indices of the last file processed by info_indices_of_file_buffer. */ static REFERENCE **index_index = NULL; /* The offset of the most recently selected index element. */ static int index_offset = -1; /* Whether we are doing initial index search. */ static int index_initial = 0; /* Whether we are doing partial index search */ static int index_partial = 0; /* Variable which holds the last string searched for. */ static char *index_search = NULL; /* A couple of "globals" describing where the initial index was found. */ static char *initial_index_filename = NULL; static char *initial_index_nodename = NULL; /* A structure associating index names with index offset ranges. */ typedef struct { char *name; /* The nodename of this index. */ int first; /* The index in our list of the first entry. */ int last; /* The index in our list of the last entry. */ } INDEX_NAME_ASSOC; /* An array associating index nodenames with index offset ranges. Used for reporting to the user which index node an index entry was found in. */ static INDEX_NAME_ASSOC **index_nodenames = NULL; static size_t index_nodenames_index = 0; static size_t index_nodenames_slots = 0; /* Add the name of NODE, and the range of the associated index elements (passed in ARRAY) to index_nodenames. ARRAY must have at least one element. */ static void add_index_to_index_nodenames (REFERENCE **array, NODE *node) { register int i, last; INDEX_NAME_ASSOC *assoc; for (last = 0; array[last + 1]; last++); assoc = xmalloc (sizeof (INDEX_NAME_ASSOC)); assoc->name = xstrdup (node->nodename); if (!index_nodenames_index) { assoc->first = 0; assoc->last = last; } else { for (i = 0; index_nodenames[i + 1]; i++); assoc->first = 1 + index_nodenames[i]->last; assoc->last = assoc->first + last; } add_pointer_to_array (assoc, index_nodenames_index, index_nodenames, index_nodenames_slots, 10); } static void clear_index_nodenames (void) { int i; if (!index_nodenames) return; for (i = 0; index_nodenames[i]; i++) { free (index_nodenames[i]->name); free (index_nodenames[i]); } index_nodenames_index = 0; index_nodenames[0] = NULL; } /* Find and concatenate the indices of FILE_BUFFER, saving the result in INDEX_INDEX. The indices are defined as the first node in the file containing the word "Index" and any immediately following nodes whose names also contain "Index". All such indices are concatenated and the result returned. */ static void info_indices_of_file_buffer (FILE_BUFFER *file_buffer) { register int i; REFERENCE **result = NULL; /* No file buffer, no indices. */ if (!file_buffer) { free (index_index); index_index = 0; return; } /* If the file is the same as the one that we last built an index for, don't do anything. */ if (initial_index_filename && FILENAME_CMP (initial_index_filename, file_buffer->filename) == 0) { return; } /* Display a message because finding the index entries might take a while. */ if (info_windows_initialized_p) window_message_in_echo_area (_("Finding index entries...")); /* Reset globals describing where the index was found. */ free (initial_index_filename); free (initial_index_nodename); initial_index_filename = NULL; initial_index_nodename = NULL; clear_index_nodenames (); /* Grovel the names of the nodes found in this file. */ if (file_buffer->tags) { TAG *tag; for (i = 0; (tag = file_buffer->tags[i]); i++) { if (strcasestr (tag->nodename, "Index") && tag->cache.nodelen != 0) /* Not an anchor. */ { NODE *node; REFERENCE **menu; node = info_node_of_tag (file_buffer, &file_buffer->tags[i]); if (!node) continue; if ((node->flags & N_IsIndex) && !initial_index_filename) { /* Remember the filename and nodename of this index. */ initial_index_filename = xstrdup (file_buffer->filename); initial_index_nodename = xstrdup (tag->nodename); /* Clear list in case earlier node had "Index" in name. */ clear_index_nodenames (); } menu = node->references; /* If we have a non-empty menu, add this index's nodename and range to our list of index_nodenames. */ if (menu && menu[0]) { add_index_to_index_nodenames (menu, node); /* Concatenate the references found so far. */ { REFERENCE **old_result = result; result = info_concatenate_references (result, menu); free (old_result); } } free_history_node (node); } } } /* If there is a result, clean it up so that every entry has a filename. */ for (i = 0; result && result[i]; i++) if (!result[i]->filename) result[i]->filename = xstrdup (file_buffer->filename); free (index_index); index_index = result; if (info_windows_initialized_p) window_clear_echo_area (); } void info_next_index_match (WINDOW *window, int count); DECLARE_INFO_COMMAND (info_index_search, _("Look up a string in the index for this file")) { FILE_BUFFER *fb; char *line; int old_offset; fb = file_buffer_of_window (window); if (fb) info_indices_of_file_buffer (fb); /* Sets index_index. */ if (!fb || !index_index) { info_error (_("No indices found")); return; } line = info_read_maybe_completing (_("Index entry: "), index_index); /* User aborted? */ if (!line) { info_abort_key (window, 1); return; } /* Empty line means move to the Index node. */ if (!*line) { free (line); if (initial_index_filename && initial_index_nodename) { NODE *node; node = info_get_node (initial_index_filename, initial_index_nodename); info_set_node_of_window (window, node); } return; } /* Start the search either at the first or last index entry. */ if (count < 0) { register int i; for (i = 0; index_index[i]; i++); index_offset = i; } else { index_offset = -1; index_initial = 0; index_partial = 0; } old_offset = index_offset; /* The "last" string searched for is this one. */ free (index_search); index_search = line; info_next_index_match (window, count); /* If the search failed, return the index offset to where it belongs. */ if (index_offset == old_offset) index_offset = -1; } /* Return true if ENT->label matches "S( <[0-9]+>)?", where S stands for the first LEN characters from STR. */ static int index_entry_matches (REFERENCE *ent, const char *str, size_t len) { char *p; if (strncmp (ent->label, str, len)) return 0; p = ent->label + len; if (!*p) return 1; if (p[0] == ' ' && p[1] == '<') { for (p += 2; *p; p++) { if (p[0] == '>' && p[1] == 0) return 1; else if (!isdigit (*p)) return 0; } } return 0; } /* Search for the next occurence of STRING in FB's indices starting at OFFSET in direction DIR. Try to get an exact match, If no match found, progress onto looking for initial matches, then non-initial substrings, updating the values of INDEX_INITIAL and INDEX_PARTIAL. If a match is found, return a pointer to the matching index entry, and set *FOUND_OFFSET to its offset in INDEX_INDEX. Otherwise, return null. If we found a partial match, set *MATCH_OFFSET to the end of the match within the index entry text, else to 0. */ REFERENCE * next_index_match (FILE_BUFFER *fb, char *string, int offset, int dir, int *found_offset, int *match_offset) { int i; int partial_match; size_t search_len; REFERENCE *result; partial_match = 0; search_len = strlen (string); info_indices_of_file_buffer (fb); /* Sets index_index. */ if (!index_index) { info_error (_("No indices found.")); return 0; } if (index_search != string) { free (index_search); index_search = string; } if (!index_initial && !index_partial) { /* First try to find an exact match. */ for (i = offset + dir; i > -1 && index_index[i]; i += dir) if (index_entry_matches (index_index[i], string, search_len)) { *match_offset = 0; break; } if (i < 0 || !index_index[i]) { offset = -1; index_initial = 1; } } if (index_initial) { for (i = offset + dir; i > -1 && index_index[i]; i += dir) if (!index_entry_matches (index_index[i], string, search_len) && !strncmp (index_index[i]->label, string, search_len)) { *match_offset = search_len; break; } if (i < 0 || !index_index[i]) { offset = -1; index_initial = 0; index_partial = 1; } } if (index_partial) { /* Look for substrings, excluding case-matching inital matches. */ for (i = offset + dir; i > -1 && index_index[i]; i += dir) { if (strncmp (index_index[i]->label, string, search_len) != 0) { partial_match = string_in_line (string, index_index[i]->label); if (partial_match != -1) { *match_offset = partial_match; break; } } } if (partial_match <= 0) index_partial = 0; } if (i < 0 || !index_index[i]) result = 0; else { index_offset = i; result = index_index[i]; } *found_offset = i; return result; } /* Display a message saying where the index match was found. */ void report_index_match (int i, int match_offset) { register int j; const char *name = "CAN'T SEE THIS"; char *match; for (j = 0; index_nodenames[j]; j++) { if ((i >= index_nodenames[j]->first) && (i <= index_nodenames[j]->last)) { name = index_nodenames[j]->name; break; } } /* If we had a partial match, indicate to the user which part of the string matched. */ match = xstrdup (index_index[i]->label); if (match_offset > 0 && show_index_match) { int k, ls, start, upper; ls = strlen (index_search); start = match_offset - ls; upper = isupper (match[start]) ? 1 : 0; for (k = 0; k < ls; k++) if (upper) match[k + start] = tolower (match[k + start]); else match[k + start] = toupper (match[k + start]); } { char *format; format = replace_in_documentation (_("Found '%s' in %s. ('\\[next-index-match]' tries to find next.)"), 0); window_message_in_echo_area (format, match, (char *) name); } free (match); } DECLARE_INFO_COMMAND (info_next_index_match, _("Go to the next matching index item from the last '\\[index-search]' command")) { int i; int match_offset; int dir; REFERENCE *result; /* If there is no previous search string, the user hasn't built an index yet. */ if (!index_search) { info_error (_("No previous index search string")); return; } /* The direction of this search is controlled by the value of the numeric argument. */ if (count < 0) dir = -1; else dir = 1; result = next_index_match (file_buffer_of_window (window), index_search, index_offset, dir, &i, &match_offset); /* If that failed, print an error. */ if (!result) { info_error (index_offset >= 0 ? _("No more index entries containing '%s'") : _("No index entries containing '%s'"), index_search); index_offset = -1; return; } /* Report to the user on what we have found. */ report_index_match (i, match_offset); info_select_reference (window, result); } /* Look for the best match of STRING in the indices of FB. If SLOPPY, allow case-insensitive initial substrings to match. Return null if no match is found. Return value should not be freed or modified. This differs from the behaviour of next_index_match in that only _initial_ substrings are considered. */ REFERENCE * look_in_indices (FILE_BUFFER *fb, char *string, int sloppy) { REFERENCE **index_ptr; REFERENCE *nearest = 0; /* Remember the search string so we can use it as the default for 'virtual-index' or 'next-index-match'. */ free (index_search); index_search = xstrdup (string); info_indices_of_file_buffer (fb); /* Sets index_index. */ if (!index_index) return 0; for (index_ptr = index_index; *index_ptr; index_ptr++) { if (!strcmp (string, (*index_ptr)->label)) { nearest = *index_ptr; break; } /* Case-insensitive initial substring. */ if (sloppy && !nearest && !mbsncasecmp (string, (*index_ptr)->label, mbslen (string))) { nearest = *index_ptr; } } return nearest; } /* **************************************************************** */ /* */ /* Info APROPOS: Search every known index. */ /* */ /* **************************************************************** */ /* For every menu item in DIR, search the indices of that file for SEARCH_STRING. */ REFERENCE ** apropos_in_all_indices (char *search_string, int inform) { size_t i, dir_index; REFERENCE **all_indices = NULL; REFERENCE **dir_menu = NULL; NODE *dir_node; dir_node = get_dir_node (); /* It should be safe to assume that dir nodes do not contain any cross-references, i.e., its references list only contains menu items. */ if (dir_node) dir_menu = dir_node->references; if (!dir_menu) { free (dir_node); return NULL; } /* For every menu item in DIR, get the associated file buffer and read the indices of that file buffer. Gather all of the indices into one large one. */ for (dir_index = 0; dir_menu[dir_index]; dir_index++) { REFERENCE **this_index, *this_item; FILE_BUFFER *this_fb, *loaded_file = 0; this_item = dir_menu[dir_index]; if (!this_item->filename) continue; /* If we already scanned this file, don't do that again. In addition to being faster, this also avoids having multiple identical entries in the *Apropos* menu. */ for (i = 0; i < dir_index; i++) if (dir_menu[i]->filename && FILENAME_CMP (this_item->filename, dir_menu[i]->filename) == 0) break; if (i < dir_index) continue; this_fb = check_loaded_file (this_item->filename); if (!this_fb) this_fb = loaded_file = info_find_file (this_item->filename); if (!this_fb) continue; /* Couldn't load file. */ if (this_fb && inform) message_in_echo_area (_("Scanning indices of '%s'..."), this_item->filename); info_indices_of_file_buffer (this_fb); this_index = index_index; if (this_fb && inform) unmessage_in_echo_area (); if (this_index) { /* Remember the filename which contains this set of references. */ for (i = 0; this_index && this_index[i]; i++) if (!this_index[i]->filename) this_index[i]->filename = xstrdup (this_fb->filename); /* Concatenate with the other indices. */ { REFERENCE **old_indices = all_indices; all_indices = info_concatenate_references (all_indices, this_index); free (old_indices); } } /* Try to avoid running out of memory by not loading all of the Info files on the system into memory. This is risky because we may have a pointer into the file buffer, so only free the contents if we have just loaded the file. */ if (loaded_file) { free (loaded_file->contents); loaded_file->contents = NULL; } } /* Build a list of the references which contain SEARCH_STRING. */ if (all_indices) { REFERENCE *entry, **apropos_list = NULL; size_t apropos_list_index = 0; size_t apropos_list_slots = 0; for (i = 0; (entry = all_indices[i]); i++) { if (string_in_line (search_string, entry->label) != -1) { add_pointer_to_array (entry, apropos_list_index, apropos_list, apropos_list_slots, 100); } } free (all_indices); all_indices = apropos_list; } free (dir_node); return all_indices; } static char *apropos_list_nodename = "*Apropos*"; DECLARE_INFO_COMMAND (info_index_apropos, _("Grovel all known info file's indices for a string and build a menu")) { char *line, *prompt; REFERENCE **apropos_list; NODE *apropos_node; struct text_buffer message; if (index_search) xasprintf (&prompt, "%s [%s]: ", _("Index apropos"), index_search); else xasprintf (&prompt, "%s: ", _("Index apropos")); line = info_read_in_echo_area (prompt); free (prompt); window = active_window; /* User aborted? */ if (!line) { info_abort_key (window, 1); return; } /* User typed something? */ if (*line) { free (index_search); index_search = line; } else free (line); /* Try to use the last search string. */ if (index_search && *index_search) { apropos_list = apropos_in_all_indices (index_search, 1); if (!apropos_list) { info_error (_(APROPOS_NONE), index_search); return; } else { /* Create the node. FIXME: Labels and node names taken from the indices of Info files may be in a different character encoding to the one currently being used. This problem is reduced by makeinfo not putting quotation marks from @samp, etc., into node names and index entries. */ register int i; text_buffer_init (&message); text_buffer_add_char (&message, '\n'); text_buffer_printf (&message, _("Index entries containing " "'%s':\n"), index_search); text_buffer_printf (&message, "\n* Menu:"); text_buffer_add_string (&message, "\0\b[index\0\b]", 11); text_buffer_add_char (&message, '\n'); for (i = 0; apropos_list[i]; i++) { int line_start = text_buffer_off (&message); char *filename; /* Remove file extension. */ filename = program_name_from_file_name (apropos_list[i]->filename); /* The label might be identical to that of another index entry in another Info file. Therefore, we make the file name part of the menu entry, to make them all distinct. */ text_buffer_printf (&message, "* %s [%s]: ", apropos_list[i]->label, filename); while (text_buffer_off (&message) - line_start < 40) text_buffer_add_char (&message, ' '); text_buffer_printf (&message, "(%s)%s.", filename, apropos_list[i]->nodename); text_buffer_printf (&message, " (line %ld)\n", apropos_list[i]->line_number); free (filename); } } apropos_node = text_buffer_to_node (&message); { char *old_contents = apropos_node->contents; scan_node_contents (apropos_node, 0, 0); if (old_contents != apropos_node->contents) free (old_contents); } name_internal_node (apropos_node, xstrdup (apropos_list_nodename)); /* Find/Create a window to contain this node. */ { WINDOW *new; NODE *node; /* If a window is visible and showing an apropos list already, re-use it. */ for (new = windows; new; new = new->next) { node = new->node; if (internal_info_node_p (node) && (strcmp (node->nodename, apropos_list_nodename) == 0)) break; } /* If we couldn't find an existing window, try to use the next window in the chain. */ if (!new && window->next) new = window->next; /* If we still don't have a window, make a new one to contain the list. */ if (!new) new = window_make_window (); /* If we couldn't make a new window, use this one. */ if (!new) new = window; /* Lines do not wrap in this window. */ new->flags |= W_NoWrap; info_set_node_of_window (new, apropos_node); active_window = new; } free (apropos_list); } } #define NODECOL 41 #define LINECOL 62 static void format_reference (REFERENCE *ref, const char *filename, struct text_buffer *buf) { size_t n; n = text_buffer_printf (buf, "* %s: ", ref->label); if (n < NODECOL) n += text_buffer_fill (buf, ' ', NODECOL - n); if (ref->filename && strcmp (ref->filename, filename)) n += text_buffer_printf (buf, "(%s)", ref->filename); n += text_buffer_printf (buf, "%s. ", ref->nodename); if (n < LINECOL) n += text_buffer_fill (buf, ' ', LINECOL - n); else { text_buffer_add_char (buf, '\n'); text_buffer_fill (buf, ' ', LINECOL); } text_buffer_printf (buf, "(line %4d)\n", ref->line_number); } NODE * create_virtual_index (FILE_BUFFER *file_buffer, char *index_search) { struct text_buffer text; int i; size_t cnt; NODE *node; text_buffer_init (&text); text_buffer_printf (&text, "File: %s, Node: Index for '%s'\n\n", file_buffer->filename, index_search); text_buffer_printf (&text, _("Virtual Index\n" "*************\n\n" "Index entries that match '%s':\n"), index_search); text_buffer_add_string (&text, "\0\b[index\0\b]", 11); text_buffer_printf (&text, "\n* Menu:\n\n"); cnt = 0; index_offset = -1; index_initial = 0; index_partial = 0; while (1) { REFERENCE *result; int match_offset; result = next_index_match (file_buffer, index_search, index_offset, 1, &i, &match_offset); if (!result) break; format_reference (index_index[i], file_buffer->filename, &text); cnt++; } text_buffer_add_char (&text, '\0'); if (cnt == 0) { text_buffer_free (&text); return 0; } node = info_create_node (); xasprintf (&node->nodename, "Index for '%s'", index_search); node->fullpath = file_buffer->filename; node->contents = text_buffer_base (&text); node->nodelen = text_buffer_off (&text) - 1; node->body_start = strcspn (node->contents, "\n"); node->flags |= N_IsInternal | N_WasRewritten; scan_node_contents (node, 0, 0); return node; } DECLARE_INFO_COMMAND (info_virtual_index, _("List all matches of a string in the index")) { char *prompt, *line; FILE_BUFFER *fb; NODE *node; fb = file_buffer_of_window (window); if (!initial_index_filename || !fb || (FILENAME_CMP (initial_index_filename, fb->filename) != 0)) { window_message_in_echo_area (_("Finding index entries...")); info_indices_of_file_buffer (fb); } if (!index_index) { info_error (_("No indices found.")); return; } /* Default to last search if there is one. */ if (index_search) xasprintf (&prompt, "%s [%s]: ", _("Index topic"), index_search); else xasprintf (&prompt, "%s: ", _("Index topic")); line = info_read_maybe_completing (prompt, index_index); free (prompt); /* User aborted? */ if (!line) { info_abort_key (window, 1); return; } if (*line) { free (index_search); index_search = line; } else if (!index_search) { free (line); return; /* No previous search string, and no string given. */ } node = create_virtual_index (fb, index_search); if (!node) { info_error (_("No index entries containing '%s'."), index_search); return; } info_set_node_of_window (window, node); }