diff options
Diffstat (limited to 'Build/source/utils/texinfo/info/echo-area.c')
| -rw-r--r-- | Build/source/utils/texinfo/info/echo-area.c | 1524 |
1 files changed, 1524 insertions, 0 deletions
diff --git a/Build/source/utils/texinfo/info/echo-area.c b/Build/source/utils/texinfo/info/echo-area.c new file mode 100644 index 00000000000..31385c88a37 --- /dev/null +++ b/Build/source/utils/texinfo/info/echo-area.c @@ -0,0 +1,1524 @@ +/* echo-area.c -- how to read a line in the echo area. + $Id: echo-area.c,v 1.7 2004/12/14 00:15:36 karl Exp $ + + Copyright (C) 1993, 1997, 1998, 1999, 2001, 2004 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 2, 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, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Written by Brian Fox (bfox@ai.mit.edu). */ + +#include "info.h" + +#if defined (FD_SET) +# if defined (hpux) +# define fd_set_cast(x) (int *)(x) +# else +# define fd_set_cast(x) (fd_set *)(x) +# endif /* !hpux */ +#endif /* FD_SET */ + +/* Non-zero means that C-g was used to quit reading input. */ +int info_aborted_echo_area = 0; + +/* Non-zero means that the echo area is being used to read input. */ +int echo_area_is_active = 0; + +/* The address of the last command executed in the echo area. */ +VFunction *ea_last_executed_command = (VFunction *)NULL; + +/* Non-zero means that the last command executed while reading input + killed some text. */ +int echo_area_last_command_was_kill = 0; + +/* Variables which hold on to the current state of the input line. */ +static char input_line[1 + EA_MAX_INPUT]; +static char *input_line_prompt; +static int input_line_point; +static int input_line_beg; +static int input_line_end; +static NODE input_line_node = { + (char *)NULL, (char *)NULL, (char *)NULL, input_line, + EA_MAX_INPUT, 0, N_IsInternal +}; + +static void echo_area_initialize_node (void); +static void push_echo_area (void), pop_echo_area (void); +static int echo_area_stack_contains_completions_p (void); + +static void ea_kill_text (int from, int to); + +/* Non-zero means we force the user to complete. */ +static int echo_area_must_complete_p = 0; +static int completions_window_p (WINDOW *window); + +/* If non-null, this is a window which was specifically created to display + possible completions output. We remember it so we can delete it when + appropriate. */ +static WINDOW *echo_area_completions_window = (WINDOW *)NULL; + +/* Variables which keep track of the window which was active prior to + entering the echo area. */ +static WINDOW *calling_window = (WINDOW *)NULL; +static NODE *calling_window_node = (NODE *)NULL; +static long calling_window_point = 0; +static long calling_window_pagetop = 0; + +/* Remember the node and pertinent variables of the calling window. */ +static void +remember_calling_window (WINDOW *window) +{ + /* Only do this if the calling window is not the completions window, or, + if it is the completions window and there is no other window. */ + if (!completions_window_p (window) || + ((window == windows) && !(window->next))) + { + calling_window = window; + calling_window_node = window->node; + calling_window_point = window->point; + calling_window_pagetop = window->pagetop; + } +} + +/* Restore the caller's window so that it shows the node that it was showing + on entry to info_read_xxx_echo_area (). */ +static void +restore_calling_window (void) +{ + register WINDOW *win, *compwin = (WINDOW *)NULL; + + /* If the calling window is still visible, and it is the window that + we used for completions output, then restore the calling window. */ + for (win = windows; win; win = win->next) + { + if (completions_window_p (win)) + compwin = win; + + if (win == calling_window && win == compwin) + { + window_set_node_of_window (calling_window, calling_window_node); + calling_window->point = calling_window_point; + calling_window->pagetop = calling_window_pagetop; + compwin = (WINDOW *)NULL; + break; + } + } + + /* Delete the completions window if it is still present, it isn't the + last window on the screen, and there aren't any prior echo area reads + pending which created a completions window. */ + if (compwin) + { + if ((compwin != windows || windows->next) && + !echo_area_stack_contains_completions_p ()) + { + WINDOW *next; + int pagetop = 0; + int start = 0; + int end = 0; + int amount = 0; + + next = compwin->next; + if (next) + { + start = next->first_row; + end = start + next->height; + amount = - (compwin->height + 1); + pagetop = next->pagetop; + } + + info_delete_window_internal (compwin); + + /* This is not necessary because info_delete_window_internal () + calls echo_area_inform_of_deleted_window (), which does the + right thing. */ +#if defined (UNNECESSARY) + echo_area_completions_window = (WINDOW *)NULL; +#endif /* UNNECESSARY */ + + if (next) + { + display_scroll_display (start, end, amount); + next->pagetop = pagetop; + display_update_display (windows); + } + } + } +} + +/* Set up a new input line with PROMPT. */ +static void +initialize_input_line (char *prompt) +{ + input_line_prompt = prompt; + if (prompt) + strcpy (input_line, prompt); + else + input_line[0] = '\0'; + + input_line_beg = input_line_end = input_line_point = strlen (prompt); +} + +static char * +echo_area_after_read (void) +{ + char *return_value; + + if (info_aborted_echo_area) + { + info_aborted_echo_area = 0; + return_value = (char *)NULL; + } + else + { + if (input_line_beg == input_line_end) + return_value = xstrdup (""); + else + { + int line_len = input_line_end - input_line_beg; + return_value = (char *) xmalloc (1 + line_len); + strncpy (return_value, &input_line[input_line_beg], line_len); + return_value[line_len] = '\0'; + } + } + return (return_value); +} + +/* Read a line of text in the echo area. Return a malloc ()'ed string, + or NULL if the user aborted out of this read. WINDOW is the currently + active window, so that we can restore it when we need to. PROMPT, if + non-null, is a prompt to print before reading the line. */ +char * +info_read_in_echo_area (WINDOW *window, char *prompt) +{ + char *line; + + /* If the echo area is already active, remember the current state. */ + if (echo_area_is_active) + push_echo_area (); + + /* Initialize our local variables. */ + initialize_input_line (prompt); + + /* Initialize the echo area for the first (but maybe not the last) time. */ + echo_area_initialize_node (); + + /* Save away the original node of this window, and the window itself, + so echo area commands can temporarily use this window. */ + remember_calling_window (window); + + /* Let the rest of Info know that the echo area is active. */ + echo_area_is_active++; + active_window = the_echo_area; + + /* Read characters in the echo area. */ + info_read_and_dispatch (); + + echo_area_is_active--; + + /* Restore the original active window and show point in it. */ + active_window = calling_window; + restore_calling_window (); + display_cursor_at_point (active_window); + fflush (stdout); + + /* Get the value of the line. */ + line = echo_area_after_read (); + + /* If there is a previous loop waiting for us, restore it now. */ + if (echo_area_is_active) + pop_echo_area (); + + /* Return the results to the caller. */ + return (line); +} + +/* (re) Initialize the echo area node. */ +static void +echo_area_initialize_node (void) +{ + register int i; + + for (i = input_line_end; (unsigned int) i < sizeof (input_line); i++) + input_line[i] = ' '; + + input_line[i - 1] = '\n'; + window_set_node_of_window (the_echo_area, &input_line_node); + input_line[input_line_end] = '\n'; +} + +/* Prepare to read characters in the echo area. This can initialize the + echo area node, but its primary purpose is to side effect the input + line buffer contents. */ +void +echo_area_prep_read (void) +{ + if (the_echo_area->node != &input_line_node) + echo_area_initialize_node (); + + the_echo_area->point = input_line_point; + input_line[input_line_end] = '\n'; + display_update_one_window (the_echo_area); + display_cursor_at_point (active_window); +} + + +/* **************************************************************** */ +/* */ +/* Echo Area Movement Commands */ +/* */ +/* **************************************************************** */ + +DECLARE_INFO_COMMAND (ea_forward, _("Move forward a character")) +{ + if (count < 0) + ea_backward (window, -count, key); + else + { + input_line_point += count; + if (input_line_point > input_line_end) + input_line_point = input_line_end; + } +} + +DECLARE_INFO_COMMAND (ea_backward, _("Move backward a character")) +{ + if (count < 0) + ea_forward (window, -count, key); + else + { + input_line_point -= count; + if (input_line_point < input_line_beg) + input_line_point = input_line_beg; + } +} + +DECLARE_INFO_COMMAND (ea_beg_of_line, _("Move to the start of this line")) +{ + input_line_point = input_line_beg; +} + +DECLARE_INFO_COMMAND (ea_end_of_line, _("Move to the end of this line")) +{ + input_line_point = input_line_end; +} + +#define alphabetic(c) (islower (c) || isupper (c) || isdigit (c)) + +/* Move forward a word in the input line. */ +DECLARE_INFO_COMMAND (ea_forward_word, _("Move forward a word")) +{ + int c; + + if (count < 0) + ea_backward_word (window, -count, key); + else + { + while (count--) + { + if (input_line_point == input_line_end) + return; + + /* If we are not in a word, move forward until we are in one. + Then, move forward until we hit a non-alphabetic character. */ + c = input_line[input_line_point]; + + if (!alphabetic (c)) + { + while (++input_line_point < input_line_end) + { + c = input_line[input_line_point]; + if (alphabetic (c)) + break; + } + } + + if (input_line_point == input_line_end) + return; + + while (++input_line_point < input_line_end) + { + c = input_line[input_line_point]; + if (!alphabetic (c)) + break; + } + } + } +} + +DECLARE_INFO_COMMAND (ea_backward_word, _("Move backward a word")) +{ + int c; + + if (count < 0) + ea_forward_word (window, -count, key); + else + { + while (count--) + { + if (input_line_point == input_line_beg) + return; + + /* Like ea_forward_word (), except that we look at the + characters just before point. */ + + c = input_line[input_line_point - 1]; + + if (!alphabetic (c)) + { + while ((--input_line_point) != input_line_beg) + { + c = input_line[input_line_point - 1]; + if (alphabetic (c)) + break; + } + } + + while (input_line_point != input_line_beg) + { + c = input_line[input_line_point - 1]; + if (!alphabetic (c)) + break; + else + --input_line_point; + } + } + } +} + +DECLARE_INFO_COMMAND (ea_delete, _("Delete the character under the cursor")) +{ + register int i; + + if (count < 0) + ea_rubout (window, -count, key); + else + { + if (input_line_point == input_line_end) + return; + + if (info_explicit_arg || count > 1) + { + int orig_point; + + orig_point = input_line_point; + ea_forward (window, count, key); + ea_kill_text (orig_point, input_line_point); + input_line_point = orig_point; + } + else + { + for (i = input_line_point; i < input_line_end; i++) + input_line[i] = input_line[i + 1]; + + input_line_end--; + } + } +} + +DECLARE_INFO_COMMAND (ea_rubout, _("Delete the character behind the cursor")) +{ + if (count < 0) + ea_delete (window, -count, key); + else + { + int start; + + if (input_line_point == input_line_beg) + return; + + start = input_line_point; + ea_backward (window, count, key); + + if (info_explicit_arg || count > 1) + ea_kill_text (start, input_line_point); + else + ea_delete (window, count, key); + } +} + +DECLARE_INFO_COMMAND (ea_abort, _("Cancel or quit operation")) +{ + /* If any text, just discard it, and restore the calling window's node. + If no text, quit. */ + if (input_line_end != input_line_beg) + { + terminal_ring_bell (); + input_line_end = input_line_point = input_line_beg; + if (calling_window->node != calling_window_node) + restore_calling_window (); + } + else + info_aborted_echo_area = 1; +} + +DECLARE_INFO_COMMAND (ea_newline, _("Accept (or force completion of) this line")) +{ + /* Stub does nothing. Simply here to see if it has been executed. */ +} + +DECLARE_INFO_COMMAND (ea_quoted_insert, _("Insert next character verbatim")) +{ + unsigned char character; + + character = info_get_another_input_char (); + ea_insert (window, count, character); +} + +DECLARE_INFO_COMMAND (ea_insert, _("Insert this character")) +{ + register int i; + + if ((input_line_end + 1) == EA_MAX_INPUT) + { + terminal_ring_bell (); + return; + } + + for (i = input_line_end + 1; i != input_line_point; i--) + input_line[i] = input_line[i - 1]; + + input_line[input_line_point] = key; + input_line_point++; + input_line_end++; +} + +DECLARE_INFO_COMMAND (ea_tab_insert, _("Insert a TAB character")) +{ + ea_insert (window, count, '\t'); +} + +/* Transpose the characters at point. If point is at the end of the line, + then transpose the characters before point. */ +DECLARE_INFO_COMMAND (ea_transpose_chars, _("Transpose characters at point")) +{ + /* Handle conditions that would make it impossible to transpose + characters. */ + if (!count || !input_line_point || (input_line_end - input_line_beg) < 2) + return; + + while (count) + { + int t; + if (input_line_point == input_line_end) + { + t = input_line[input_line_point - 1]; + + input_line[input_line_point - 1] = input_line[input_line_point - 2]; + input_line[input_line_point - 2] = t; + } + else + { + t = input_line[input_line_point]; + + input_line[input_line_point] = input_line[input_line_point - 1]; + input_line[input_line_point - 1] = t; + + if (count < 0 && input_line_point != input_line_beg) + input_line_point--; + else + input_line_point++; + } + + if (count < 0) + count++; + else + count--; + } +} + +/* **************************************************************** */ +/* */ +/* Echo Area Killing and Yanking */ +/* */ +/* **************************************************************** */ + +static char **kill_ring = (char **)NULL; +static int kill_ring_index = 0; /* Number of kills appearing in KILL_RING. */ +static int kill_ring_slots = 0; /* Number of slots allocated to KILL_RING. */ +static int kill_ring_loc = 0; /* Location of current yank pointer. */ + +/* The largest number of kills that we remember at one time. */ +static int max_retained_kills = 15; + +DECLARE_INFO_COMMAND (ea_yank, _("Yank back the contents of the last kill")) +{ + register int i; + register char *text; + + if (!kill_ring_index) + { + inform_in_echo_area ((char *) _("Kill ring is empty")); + return; + } + + text = kill_ring[kill_ring_loc]; + + for (i = 0; text[i]; i++) + ea_insert (window, 1, text[i]); +} + +/* If the last command was yank, or yank_pop, and the text just before + point is identical to the current kill item, then delete that text + from the line, rotate the index down, and yank back some other text. */ +DECLARE_INFO_COMMAND (ea_yank_pop, _("Yank back a previous kill")) +{ + register int len; + + if (((ea_last_executed_command != (VFunction *) ea_yank) && + (ea_last_executed_command != (VFunction *) ea_yank_pop)) || + (kill_ring_index == 0)) + return; + + len = strlen (kill_ring[kill_ring_loc]); + + /* Delete the last yanked item from the line. */ + { + register int i, counter; + + counter = input_line_end - input_line_point; + + for (i = input_line_point - len; counter; i++, counter--) + input_line[i] = input_line[i + len]; + + input_line_end -= len; + input_line_point -= len; + } + + /* Get a previous kill, and yank that. */ + kill_ring_loc--; + if (kill_ring_loc < 0) + kill_ring_loc = kill_ring_index - 1; + + ea_yank (window, count, key); +} + +/* Delete the text from point to end of line. */ +DECLARE_INFO_COMMAND (ea_kill_line, _("Kill to the end of the line")) +{ + if (count < 0) + { + ea_kill_text (input_line_point, input_line_beg); + input_line_point = input_line_beg; + } + else + ea_kill_text (input_line_point, input_line_end); +} + +/* Delete the text from point to beg of line. */ +DECLARE_INFO_COMMAND (ea_backward_kill_line, + _("Kill to the beginning of the line")) +{ + if (count < 0) + ea_kill_text (input_line_point, input_line_end); + else + { + ea_kill_text (input_line_point, input_line_beg); + input_line_point = input_line_beg; + } +} + +/* Delete from point to the end of the current word. */ +DECLARE_INFO_COMMAND (ea_kill_word, _("Kill the word following the cursor")) +{ + int orig_point = input_line_point; + + if (count < 0) + ea_backward_kill_word (window, -count, key); + else + { + ea_forward_word (window, count, key); + + if (input_line_point != orig_point) + ea_kill_text (orig_point, input_line_point); + + input_line_point = orig_point; + } +} + +/* Delete from point to the start of the current word. */ +DECLARE_INFO_COMMAND (ea_backward_kill_word, + _("Kill the word preceding the cursor")) +{ + int orig_point = input_line_point; + + if (count < 0) + ea_kill_word (window, -count, key); + else + { + ea_backward_word (window, count, key); + + if (input_line_point != orig_point) + ea_kill_text (orig_point, input_line_point); + } +} + +/* The way to kill something. This appends or prepends to the last + kill, if the last command was a kill command. If FROM is less + than TO, then the killed text is appended to the most recent kill, + otherwise it is prepended. If the last command was not a kill command, + then a new slot is made for this kill. */ +static void +ea_kill_text (int from, int to) +{ + register int i, counter, distance; + int killing_backwards, slot; + char *killed_text; + + killing_backwards = (from > to); + + /* If killing backwards, reverse the values of FROM and TO. */ + if (killing_backwards) + { + int temp = from; + from = to; + to = temp; + } + + /* Remember the text that we are about to delete. */ + distance = to - from; + killed_text = (char *)xmalloc (1 + distance); + strncpy (killed_text, &input_line[from], distance); + killed_text[distance] = '\0'; + + /* Actually delete the text from the line. */ + counter = input_line_end - to; + + for (i = from; counter; i++, counter--) + input_line[i] = input_line[i + distance]; + + input_line_end -= distance; + + /* If the last command was a kill, append or prepend the killed text to + the last command's killed text. */ + if (echo_area_last_command_was_kill) + { + char *old, *new; + + slot = kill_ring_loc; + old = kill_ring[slot]; + new = (char *)xmalloc (1 + strlen (old) + strlen (killed_text)); + + if (killing_backwards) + { + /* Prepend TEXT to current kill. */ + strcpy (new, killed_text); + strcat (new, old); + } + else + { + /* Append TEXT to current kill. */ + strcpy (new, old); + strcat (new, killed_text); + } + + free (old); + free (killed_text); + kill_ring[slot] = new; + } + else + { + /* Try to store the kill in a new slot, unless that would cause there + to be too many remembered kills. */ + slot = kill_ring_index; + + if (slot == max_retained_kills) + slot = 0; + + if (slot + 1 > kill_ring_slots) + kill_ring = (char **) xrealloc + (kill_ring, + (kill_ring_slots += max_retained_kills) * sizeof (char *)); + + if (slot != kill_ring_index) + free (kill_ring[slot]); + else + kill_ring_index++; + + kill_ring[slot] = killed_text; + + kill_ring_loc = slot; + } + + /* Notice that the last command was a kill. */ + echo_area_last_command_was_kill++; +} + +/* **************************************************************** */ +/* */ +/* Echo Area Completion */ +/* */ +/* **************************************************************** */ + +/* Pointer to an array of REFERENCE to complete over. */ +static REFERENCE **echo_area_completion_items = (REFERENCE **)NULL; + +/* Sorted array of REFERENCE * which is the possible completions found in + the variable echo_area_completion_items. If there is only one element, + it is the only possible completion. */ +static REFERENCE **completions_found = (REFERENCE **)NULL; +static int completions_found_index = 0; +static int completions_found_slots = 0; + +/* The lowest common denominator found while completing. */ +static REFERENCE *LCD_completion; + +/* Internal functions used by the user calls. */ +static void build_completions (void), completions_must_be_rebuilt (void); + +/* Variable which holds the output of completions. */ +static NODE *possible_completions_output_node = (NODE *)NULL; + +static char *compwin_name = "*Completions*"; + +/* Return non-zero if WINDOW is a window used for completions output. */ +static int +completions_window_p (WINDOW *window) +{ + int result = 0; + + if (internal_info_node_p (window->node) && + (strcmp (window->node->nodename, compwin_name) == 0)) + result = 1; + + return (result); +} + +/* Workhorse for completion readers. If FORCE is non-zero, the user cannot + exit unless the line read completes, or is empty. */ +char * +info_read_completing_internal (WINDOW *window, char *prompt, + REFERENCE **completions, int force) +{ + char *line; + + /* If the echo area is already active, remember the current state. */ + if (echo_area_is_active) + push_echo_area (); + + echo_area_must_complete_p = force; + + /* Initialize our local variables. */ + initialize_input_line (prompt); + + /* Initialize the echo area for the first (but maybe not the last) time. */ + echo_area_initialize_node (); + + /* Save away the original node of this window, and the window itself, + so echo area commands can temporarily use this window. */ + remember_calling_window (window); + + /* Save away the list of items to complete over. */ + echo_area_completion_items = completions; + completions_must_be_rebuilt (); + + active_window = the_echo_area; + echo_area_is_active++; + + /* Read characters in the echo area. */ + while (1) + { + info_read_and_dispatch (); + + line = echo_area_after_read (); + + /* Force the completion to take place if the user hasn't accepted + a default or aborted, and if FORCE is active. */ + if (force && line && *line && completions) + { + register int i; + + build_completions (); + + /* If there is only one completion, then make the line be that + completion. */ + if (completions_found_index == 1) + { + free (line); + line = xstrdup (completions_found[0]->label); + break; + } + + /* If one of the completions matches exactly, then that is okay, so + return the current line. */ + for (i = 0; i < completions_found_index; i++) + if (strcasecmp (completions_found[i]->label, line) == 0) + { + free (line); + line = xstrdup (completions_found[i]->label); + break; + } + + /* If no match, go back and try again. */ + if (i == completions_found_index) + { + if (!completions_found_index) + inform_in_echo_area ((char *) _("No completions")); + else + inform_in_echo_area ((char *) _("Not complete")); + continue; + } + } + break; + } + echo_area_is_active--; + + /* Restore the original active window and show point in it. */ + active_window = calling_window; + restore_calling_window (); + display_cursor_at_point (active_window); + fflush (stdout); + + echo_area_completion_items = (REFERENCE **)NULL; + completions_must_be_rebuilt (); + + /* If there is a previous loop waiting for us, restore it now. */ + if (echo_area_is_active) + pop_echo_area (); + + return (line); +} + +/* Read a line in the echo area with completion over COMPLETIONS. */ +char * +info_read_completing_in_echo_area (WINDOW *window, + char *prompt, REFERENCE **completions) +{ + return (info_read_completing_internal (window, prompt, completions, 1)); +} + +/* Read a line in the echo area allowing completion over COMPLETIONS, but + not requiring it. */ +char * +info_read_maybe_completing (WINDOW *window, + char *prompt, REFERENCE **completions) +{ + return (info_read_completing_internal (window, prompt, completions, 0)); +} + +DECLARE_INFO_COMMAND (ea_possible_completions, _("List possible completions")) +{ + if (!echo_area_completion_items) + { + ea_insert (window, count, key); + return; + } + + build_completions (); + + if (!completions_found_index) + { + terminal_ring_bell (); + inform_in_echo_area ((char *) _("No completions")); + } + else if ((completions_found_index == 1) && (key != '?')) + { + inform_in_echo_area ((char *) _("Sole completion")); + } + else + { + register int i, l; + int limit, iterations, max_label = 0; + + initialize_message_buffer (); + printf_to_message_buffer (completions_found_index == 1 + ? (char *) _("One completion:\n") + : (char *) _("%d completions:\n"), + (void *) (long) completions_found_index, + NULL, NULL); + + /* Find the maximum length of a label. */ + for (i = 0; i < completions_found_index; i++) + { + int len = strlen (completions_found[i]->label); + if (len > max_label) + max_label = len; + } + + max_label += 4; + + /* Find out how many columns we should print in. */ + limit = calling_window->width / max_label; + if (limit != 1 && (limit * max_label == calling_window->width)) + limit--; + + /* Avoid a possible floating exception. If max_label > width then + the limit will be 0 and a divide-by-zero fault will result. */ + if (limit == 0) + limit = 1; + + /* How many iterations of the printing loop? */ + iterations = (completions_found_index + (limit - 1)) / limit; + + /* Watch out for special case. If the number of completions is less + than LIMIT, then just do the inner printing loop. */ + if (completions_found_index < limit) + iterations = 1; + + /* Print the sorted items, up-and-down alphabetically. */ + for (i = 0; i < iterations; i++) + { + register int j; + + for (j = 0, l = i; j < limit; j++) + { + if (l >= completions_found_index) + break; + else + { + char *label; + int printed_length, k; + + label = completions_found[l]->label; + printed_length = strlen (label); + printf_to_message_buffer ("%s", label, NULL, NULL); + + if (j + 1 < limit) + { + for (k = 0; k < max_label - printed_length; k++) + printf_to_message_buffer (" ", NULL, NULL, NULL); + } + } + l += iterations; + } + printf_to_message_buffer ("\n", NULL, NULL, NULL); + } + + /* Make a new node to hold onto possible completions. Don't destroy + dangling pointers. */ + { + NODE *temp; + + temp = message_buffer_to_node (); + add_gcable_pointer (temp->contents); + name_internal_node (temp, compwin_name); + possible_completions_output_node = temp; + } + + /* Find a suitable window for displaying the completions output. + First choice is an existing window showing completions output. + If there is only one window, and it is large, make another + (smaller) window, and use that one. Otherwise, use the caller's + window. */ + { + WINDOW *compwin; + + compwin = get_internal_info_window (compwin_name); + + if (!compwin) + { + /* If we can split the window to display most of the completion + items, then do so. */ + if (calling_window->height > (iterations * 2) + && calling_window->height / 2 >= WINDOW_MIN_SIZE) + { + int start, pagetop; +#ifdef SPLIT_BEFORE_ACTIVE + int end; +#endif + + active_window = calling_window; + + /* Perhaps we can scroll this window on redisplay. */ + start = calling_window->first_row; + pagetop = calling_window->pagetop; + + compwin = + window_make_window (possible_completions_output_node); + active_window = the_echo_area; + window_change_window_height + (compwin, -(compwin->height - (iterations + 2))); + + window_adjust_pagetop (calling_window); + remember_calling_window (calling_window); + +#if defined (SPLIT_BEFORE_ACTIVE) + /* If the pagetop hasn't changed, scrolling the calling + window is a reasonable thing to do. */ + if (pagetop == calling_window->pagetop) + { + end = start + calling_window->height; + display_scroll_display + (start, end, calling_window->prev->height + 1); + } +#else /* !SPLIT_BEFORE_ACTIVE */ + /* If the pagetop has changed, set the new pagetop here. */ + if (pagetop != calling_window->pagetop) + { + int newtop = calling_window->pagetop; + calling_window->pagetop = pagetop; + set_window_pagetop (calling_window, newtop); + } +#endif /* !SPLIT_BEFORE_ACTIVE */ + + echo_area_completions_window = compwin; + remember_window_and_node (compwin, compwin->node); + } + else + compwin = calling_window; + } + + if (compwin->node != possible_completions_output_node) + { + window_set_node_of_window + (compwin, possible_completions_output_node); + remember_window_and_node (compwin, compwin->node); + } + + display_update_display (windows); + } + } +} + +DECLARE_INFO_COMMAND (ea_complete, _("Insert completion")) +{ + if (!echo_area_completion_items) + { + ea_insert (window, count, key); + return; + } + + /* If KEY is SPC, and we are not forcing completion to take place, simply + insert the key. */ + if (!echo_area_must_complete_p && key == SPC) + { + ea_insert (window, count, key); + return; + } + + if (ea_last_executed_command == (VFunction *) ea_complete) + { + /* If the keypress is a SPC character, and we have already tried + completing once, and there are several completions, then check + the batch of completions to see if any continue with a space. + If there are some, insert the space character and continue. */ + if (key == SPC && completions_found_index > 1) + { + register int i, offset; + + offset = input_line_end - input_line_beg; + + for (i = 0; i < completions_found_index; i++) + if (completions_found[i]->label[offset] == ' ') + break; + + if (completions_found[i]) + ea_insert (window, 1, ' '); + else + { + ea_possible_completions (window, count, key); + return; + } + } + else + { + ea_possible_completions (window, count, key); + return; + } + } + + input_line_point = input_line_end; + build_completions (); + + if (!completions_found_index) + terminal_ring_bell (); + else if (LCD_completion->label[0] == '\0') + ea_possible_completions (window, count, key); + else + { + register int i; + input_line_point = input_line_end = input_line_beg; + for (i = 0; LCD_completion->label[i]; i++) + ea_insert (window, 1, LCD_completion->label[i]); + } +} + +/* Utility REFERENCE used to store possible LCD. */ +static REFERENCE LCD_reference = { + (char *)NULL, (char *)NULL, (char *)NULL, 0, 0, 0 +}; + +static void remove_completion_duplicates (void); + +/* Variables which remember the state of the most recent call + to build_completions (). */ +static char *last_completion_request = (char *)NULL; +static REFERENCE **last_completion_items = (REFERENCE **)NULL; + +/* How to tell the completion builder to reset internal state. */ +static void +completions_must_be_rebuilt (void) +{ + maybe_free (last_completion_request); + last_completion_request = (char *)NULL; + last_completion_items = (REFERENCE **)NULL; +} + +/* Build a list of possible completions from echo_area_completion_items, + and the contents of input_line. */ +static void +build_completions (void) +{ + register int i, len; + register REFERENCE *entry; + char *request; + int informed_of_lengthy_job = 0; + + /* If there are no items to complete over, exit immediately. */ + if (!echo_area_completion_items) + { + completions_found_index = 0; + LCD_completion = (REFERENCE *)NULL; + return; + } + + /* Check to see if this call to build completions is the same as the last + call to build completions. */ + len = input_line_end - input_line_beg; + request = (char *)xmalloc (1 + len); + strncpy (request, &input_line[input_line_beg], len); + request[len] = '\0'; + + if (last_completion_request && last_completion_items && + last_completion_items == echo_area_completion_items && + (strcmp (last_completion_request, request) == 0)) + { + free (request); + return; + } + + maybe_free (last_completion_request); + last_completion_request = request; + last_completion_items = echo_area_completion_items; + + /* Always start at the beginning of the list. */ + completions_found_index = 0; + LCD_completion = (REFERENCE *)NULL; + + for (i = 0; (entry = echo_area_completion_items[i]); i++) + { + if (strncasecmp (request, entry->label, len) == 0) + add_pointer_to_array (entry, completions_found_index, + completions_found, completions_found_slots, + 20, REFERENCE *); + + if (!informed_of_lengthy_job && completions_found_index > 100) + { + informed_of_lengthy_job = 1; + window_message_in_echo_area ((char *) _("Building completions..."), + NULL, NULL); + } + } + + if (!completions_found_index) + return; + + /* Sort and prune duplicate entries from the completions array. */ + remove_completion_duplicates (); + + /* If there is only one completion, just return that. */ + if (completions_found_index == 1) + { + LCD_completion = completions_found[0]; + return; + } + + /* Find the least common denominator. */ + { + long shortest = 100000; + + for (i = 1; i < completions_found_index; i++) + { + register int j; + int c1, c2; + + for (j = 0; + (c1 = info_tolower (completions_found[i - 1]->label[j])) && + (c2 = info_tolower (completions_found[i]->label[j])); + j++) + if (c1 != c2) + break; + + if (shortest > j) + shortest = j; + } + + maybe_free (LCD_reference.label); + LCD_reference.label = (char *)xmalloc (1 + shortest); + /* Since both the sorting done inside remove_completion_duplicates + and all the comparisons above are case-insensitive, it's + possible that the completion we are going to return is + identical to what the user typed but for the letter-case. This + is confusing, since the user could type FOOBAR<TAB> and get her + string change letter-case for no good reason. So try to find a + possible completion whose letter-case is identical, and if so, + use that. */ + if (completions_found_index > 1) + { + int req_len = strlen (request); + + for (i = 0; i < completions_found_index; i++) + if (strncmp (request, completions_found[i]->label, req_len) == 0) + break; + /* If none of the candidates match exactly, use the first one. */ + if (i >= completions_found_index) + i = 0; + } + strncpy (LCD_reference.label, completions_found[i]->label, shortest); + LCD_reference.label[shortest] = '\0'; + LCD_completion = &LCD_reference; + } + + if (informed_of_lengthy_job) + echo_area_initialize_node (); +} + +/* Function called by qsort. */ +static int +compare_references (const void *entry1, const void *entry2) +{ + REFERENCE **e1 = (REFERENCE **) entry1; + REFERENCE **e2 = (REFERENCE **) entry2; + + return (strcasecmp ((*e1)->label, (*e2)->label)); +} + +/* Prune duplicate entries from COMPLETIONS_FOUND. */ +static void +remove_completion_duplicates (void) +{ + register int i, j; + REFERENCE **temp; + int newlen; + + if (!completions_found_index) + return; + + /* Sort the items. */ + qsort (completions_found, completions_found_index, sizeof (REFERENCE *), + compare_references); + + for (i = 0, newlen = 1; i < completions_found_index - 1; i++) + { + if (strcmp (completions_found[i]->label, + completions_found[i + 1]->label) == 0) + completions_found[i] = (REFERENCE *)NULL; + else + newlen++; + } + + /* We have marked all the dead slots. It is faster to copy the live slots + twice than to prune the dead slots one by one. */ + temp = (REFERENCE **)xmalloc ((1 + newlen) * sizeof (REFERENCE *)); + for (i = 0, j = 0; i < completions_found_index; i++) + if (completions_found[i]) + temp[j++] = completions_found[i]; + + for (i = 0; i < newlen; i++) + completions_found[i] = temp[i]; + + completions_found[i] = (REFERENCE *)NULL; + completions_found_index = newlen; + free (temp); +} + +/* Scroll the "other" window. If there is a window showing completions, scroll + that one, otherwise scroll the window which was active on entering the read + function. */ +DECLARE_INFO_COMMAND (ea_scroll_completions_window, _("Scroll the completions window")) +{ + WINDOW *compwin; + int old_pagetop; + + compwin = get_internal_info_window (compwin_name); + + if (!compwin) + compwin = calling_window; + + old_pagetop = compwin->pagetop; + + /* Let info_scroll_forward () do the work, and print any messages that + need to be displayed. */ + info_scroll_forward (compwin, count, key); +} + +/* Function which gets called when an Info window is deleted while the + echo area is active. WINDOW is the window which has just been deleted. */ +void +echo_area_inform_of_deleted_window (WINDOW *window) +{ + /* If this is the calling_window, forget what we remembered about it. */ + if (window == calling_window) + { + if (active_window != the_echo_area) + remember_calling_window (active_window); + else + remember_calling_window (windows); + } + + /* If this window was the echo_area_completions_window, then notice that + the window has been deleted. */ + if (window == echo_area_completions_window) + echo_area_completions_window = (WINDOW *)NULL; +} + +/* **************************************************************** */ +/* */ +/* Pushing and Popping the Echo Area */ +/* */ +/* **************************************************************** */ + +/* Push and Pop the echo area. */ +typedef struct { + char *line; + char *prompt; + REFERENCE **comp_items; + int point, beg, end; + int must_complete; + NODE node; + WINDOW *compwin; +} PUSHED_EA; + +static PUSHED_EA **pushed_echo_areas = (PUSHED_EA **)NULL; +static int pushed_echo_areas_index = 0; +static int pushed_echo_areas_slots = 0; + +/* Pushing the echo_area has a side effect of zeroing the completion_items. */ +static void +push_echo_area (void) +{ + PUSHED_EA *pushed; + + pushed = (PUSHED_EA *)xmalloc (sizeof (PUSHED_EA)); + pushed->line = xstrdup (input_line); + pushed->prompt = input_line_prompt; + pushed->point = input_line_point; + pushed->beg = input_line_beg; + pushed->end = input_line_end; + pushed->node = input_line_node; + pushed->comp_items = echo_area_completion_items; + pushed->must_complete = echo_area_must_complete_p; + pushed->compwin = echo_area_completions_window; + + add_pointer_to_array (pushed, pushed_echo_areas_index, pushed_echo_areas, + pushed_echo_areas_slots, 4, PUSHED_EA *); + + echo_area_completion_items = (REFERENCE **)NULL; +} + +static void +pop_echo_area (void) +{ + PUSHED_EA *popped; + + popped = pushed_echo_areas[--pushed_echo_areas_index]; + + strcpy (input_line, popped->line); + free (popped->line); + input_line_prompt = popped->prompt; + input_line_point = popped->point; + input_line_beg = popped->beg; + input_line_end = popped->end; + input_line_node = popped->node; + echo_area_completion_items = popped->comp_items; + echo_area_must_complete_p = popped->must_complete; + echo_area_completions_window = popped->compwin; + completions_must_be_rebuilt (); + + /* If the completion window no longer exists, forget about it. */ + if (echo_area_completions_window) + { + register WINDOW *win; + + for (win = windows; win; win = win->next) + if (echo_area_completions_window == win) + break; + + /* If the window wasn't found, then it has already been deleted. */ + if (!win) + echo_area_completions_window = (WINDOW *)NULL; + } + + free (popped); +} + +/* Returns non-zero if any of the prior stacked calls to read in the echo + area produced a completions window. */ +static int +echo_area_stack_contains_completions_p (void) +{ + register int i; + + for (i = 0; i < pushed_echo_areas_index; i++) + if (pushed_echo_areas[i]->compwin) + return (1); + + return (0); +} + +/* **************************************************************** */ +/* */ +/* Error Messages While Reading in Echo Area */ +/* */ +/* **************************************************************** */ + +#if defined (HAVE_SYS_TIME_H) +# include <sys/time.h> +# define HAVE_STRUCT_TIMEVAL +#endif /* HAVE_SYS_TIME_H */ + +static void +pause_or_input (void) +{ +#ifdef FD_SET + struct timeval timer; + fd_set readfds; + int ready; + + FD_ZERO (&readfds); + FD_SET (fileno (stdin), &readfds); + timer.tv_sec = 2; + timer.tv_usec = 0; + ready = select (fileno (stdin) + 1, &readfds, (fd_set *) NULL, + (fd_set *) NULL, &timer); +#endif /* FD_SET */ +} + +/* Print MESSAGE right after the end of the current line, and wait + for input or a couple of seconds, whichever comes first. Then flush the + informational message that was printed. */ +void +inform_in_echo_area (const char *message) +{ + int i; + char *text; + int avail = EA_MAX_INPUT + 1 - input_line_end; + + text = xstrdup (message); + for (i = 0; text[i] && text[i] != '\n' && i < avail; i++) + ; + text[i] = 0; + + echo_area_initialize_node (); + sprintf (&input_line[input_line_end], "%s[%s]\n", + echo_area_is_active ? " ": "", text); + free (text); + the_echo_area->point = input_line_point; + display_update_one_window (the_echo_area); + display_cursor_at_point (active_window); + fflush (stdout); + pause_or_input (); + echo_area_initialize_node (); +} |