home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / OS2 / gnuinfo.zip / info / echo-area.c < prev    next >
C/C++ Source or Header  |  1997-12-27  |  45KB  |  1,506 lines
  1. /* echo-area.c -- How to read a line in the echo area.
  2.    $Id: echo-area.c,v 1.8 1997/07/24 21:13:45 karl Exp $
  3.  
  4.    Copyright (C) 1993, 97 Free Software Foundation, Inc.
  5.  
  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2, or (at your option)
  9.    any later version.
  10.  
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19.  
  20.    Written by Brian Fox (bfox@ai.mit.edu). */
  21.  
  22. #include "info.h"
  23.  
  24. #if defined (FD_SET)
  25. #  if defined (hpux)
  26. #    define fd_set_cast(x) (int *)(x)
  27. #  else
  28. #    define fd_set_cast(x) (fd_set *)(x)
  29. #  endif /* !hpux */
  30. #endif /* FD_SET */
  31.  
  32. /* Non-zero means that C-g was used to quit reading input. */
  33. int info_aborted_echo_area = 0;
  34.  
  35. /* Non-zero means that the echo area is being used to read input. */
  36. int echo_area_is_active = 0;
  37.  
  38. /* The address of the last command executed in the echo area. */
  39. VFunction *ea_last_executed_command = (VFunction *)NULL;
  40.  
  41. /* Non-zero means that the last command executed while reading input
  42.    killed some text. */
  43. int echo_area_last_command_was_kill = 0;
  44.  
  45. /* Variables which hold on to the current state of the input line. */
  46. static char input_line[1 + EA_MAX_INPUT];
  47. static char *input_line_prompt;
  48. static int input_line_point;
  49. static int input_line_beg;
  50. static int input_line_end;
  51. static NODE input_line_node = {
  52.   (char *)NULL, (char *)NULL, (char *)NULL, input_line, EA_MAX_INPUT, 0
  53. };
  54.  
  55. static void echo_area_initialize_node ();
  56. static void push_echo_area (), pop_echo_area ();
  57. static int echo_area_stack_contains_completions_p ();
  58.  
  59. static void ea_kill_text ();
  60.  
  61. /* Non-zero means we force the user to complete. */
  62. static int echo_area_must_complete_p = 0;
  63. static int completions_window_p ();
  64.  
  65. /* If non-null, this is a window which was specifically created to display
  66.    possible completions output.  We remember it so we can delete it when
  67.    appropriate. */
  68. static WINDOW *echo_area_completions_window = (WINDOW *)NULL;
  69.  
  70. /* Variables which keep track of the window which was active prior to
  71.    entering the echo area. */
  72. static WINDOW *calling_window = (WINDOW *)NULL;
  73. static NODE *calling_window_node = (NODE *)NULL;
  74. static long calling_window_point = 0;
  75. static long calling_window_pagetop = 0;
  76.  
  77. /* Remember the node and pertinent variables of the calling window. */
  78. static void
  79. remember_calling_window (window)
  80.      WINDOW *window;
  81. {
  82.   /* Only do this if the calling window is not the completions window, or,
  83.      if it is the completions window and there is no other window. */
  84.   if (!completions_window_p (window) ||
  85.       ((window == windows) && !(window->next)))
  86.     {
  87.       calling_window = window;
  88.       calling_window_node = window->node;
  89.       calling_window_point = window->point;
  90.       calling_window_pagetop = window->pagetop;
  91.     }
  92. }
  93.  
  94. /* Restore the caller's window so that it shows the node that it was showing
  95.    on entry to info_read_xxx_echo_area (). */
  96. static void
  97. restore_calling_window ()
  98. {
  99.   register WINDOW *win, *compwin = (WINDOW *)NULL;
  100.  
  101.   /* If the calling window is still visible, and it is the window that
  102.      we used for completions output, then restore the calling window. */
  103.   for (win = windows; win; win = win->next)
  104.     {
  105.       if (completions_window_p (win))
  106.         compwin = win;
  107.  
  108.       if (win == calling_window && win == compwin)
  109.         {
  110.           window_set_node_of_window (calling_window, calling_window_node);
  111.           calling_window->point = calling_window_point;
  112.           calling_window->pagetop = calling_window_pagetop;
  113.           compwin = (WINDOW *)NULL;
  114.           break;
  115.         }
  116.     }
  117.  
  118.   /* Delete the completions window if it is still present, it isn't the
  119.      last window on the screen, and there aren't any prior echo area reads
  120.      pending which created a completions window. */
  121.   if (compwin)
  122.     {
  123.       if ((compwin != windows || windows->next) &&
  124.           !echo_area_stack_contains_completions_p ())
  125.         {
  126.           WINDOW *next;
  127.           int pagetop, start, end, amount;
  128.  
  129.           next = compwin->next;
  130.           if (next)
  131.             {
  132.               start = next->first_row;
  133.               end = start + next->height;
  134.               amount = - (compwin->height + 1);
  135.               pagetop = next->pagetop;
  136.             }
  137.  
  138.           info_delete_window_internal (compwin);
  139.  
  140.           /* This is not necessary because info_delete_window_internal ()
  141.              calls echo_area_inform_of_deleted_window (), which does the
  142.              right thing. */
  143. #if defined (UNNECESSARY)
  144.           echo_area_completions_window = (WINDOW *)NULL;
  145. #endif /* UNNECESSARY */
  146.  
  147.           if (next)
  148.             {
  149.               display_scroll_display (start, end, amount);
  150.               next->pagetop = pagetop;
  151.               display_update_display (windows);
  152.             }
  153.         }
  154.     }
  155. }
  156.  
  157. /* Set up a new input line with PROMPT. */
  158. static void
  159. initialize_input_line (prompt)
  160.      char *prompt;
  161. {
  162.   input_line_prompt = prompt;
  163.   if (prompt)
  164.     strcpy (input_line, prompt);
  165.   else
  166.     input_line[0] = '\0';
  167.  
  168.   input_line_beg = input_line_end = input_line_point = strlen (prompt);
  169. }
  170.  
  171. static char *
  172. echo_area_after_read ()
  173. {
  174.   char *return_value;
  175.  
  176.   if (info_aborted_echo_area)
  177.     {
  178.       info_aborted_echo_area = 0;
  179.       return_value = (char *)NULL;
  180.     }
  181.   else
  182.     {
  183.       if (input_line_beg == input_line_end)
  184.         return_value = xstrdup ("");
  185.       else
  186.         {
  187.           int line_len = input_line_end - input_line_beg;
  188.           return_value = (char *) xmalloc (1 + line_len);
  189.           strncpy (return_value, &input_line[input_line_beg], line_len);
  190.           return_value[line_len] = '\0';
  191.         }
  192.     }
  193.   return (return_value);
  194. }
  195.  
  196. /* Read a line of text in the echo area.  Return a malloc ()'ed string,
  197.    or NULL if the user aborted out of this read.  WINDOW is the currently
  198.    active window, so that we can restore it when we need to.  PROMPT, if
  199.    non-null, is a prompt to print before reading the line. */
  200. char *
  201. info_read_in_echo_area (window, prompt)
  202.      WINDOW *window;
  203.      char *prompt;
  204. {
  205.   char *line;
  206.  
  207.   /* If the echo area is already active, remember the current state. */
  208.   if (echo_area_is_active)
  209.     push_echo_area ();
  210.  
  211.   /* Initialize our local variables. */
  212.   initialize_input_line (prompt);
  213.  
  214.   /* Initialize the echo area for the first (but maybe not the last) time. */
  215.   echo_area_initialize_node ();
  216.  
  217.   /* Save away the original node of this window, and the window itself,
  218.      so echo area commands can temporarily use this window. */
  219.   remember_calling_window (window);
  220.  
  221.   /* Let the rest of Info know that the echo area is active. */
  222.   echo_area_is_active++;
  223.   active_window = the_echo_area;
  224.  
  225.   /* Read characters in the echo area. */
  226.   info_read_and_dispatch ();
  227.  
  228.   echo_area_is_active--;
  229.  
  230.   /* Restore the original active window and show point in it. */
  231.   active_window = calling_window;
  232.   restore_calling_window ();
  233.   display_cursor_at_point (active_window);
  234.   fflush (stdout);
  235.  
  236.   /* Get the value of the line. */
  237.   line = echo_area_after_read ();
  238.  
  239.   /* If there is a previous loop waiting for us, restore it now. */
  240.   if (echo_area_is_active)
  241.     pop_echo_area ();
  242.  
  243.   /* Return the results to the caller. */
  244.   return (line);
  245. }
  246.  
  247. /* (re) Initialize the echo area node. */
  248. static void
  249. echo_area_initialize_node ()
  250. {
  251.   register int i;
  252.  
  253.   for (i = input_line_end; i < sizeof (input_line); i++)
  254.     input_line[i] = ' ';
  255.  
  256.   input_line[i - 1] = '\n';
  257.   window_set_node_of_window (the_echo_area, &input_line_node);
  258.   input_line[input_line_end] = '\n';
  259. }
  260.  
  261. /* Prepare to read characters in the echo area.  This can initialize the
  262.    echo area node, but its primary purpose is to side effect the input
  263.    line buffer contents. */
  264. void
  265. echo_area_prep_read ()
  266. {
  267.   if (the_echo_area->node != &input_line_node)
  268.     echo_area_initialize_node ();
  269.  
  270.   the_echo_area->point = input_line_point;
  271.   input_line[input_line_end] = '\n';
  272.   display_update_one_window (the_echo_area);
  273.   display_cursor_at_point (active_window);
  274. }
  275.  
  276.  
  277. /* **************************************************************** */
  278. /*                                                                  */
  279. /*                   Echo Area Movement Commands                    */
  280. /*                                                                  */
  281. /* **************************************************************** */
  282.  
  283. DECLARE_INFO_COMMAND (ea_forward, _("Move forward a character"))
  284. {
  285.   if (count < 0)
  286.     ea_backward (window, -count, key);
  287.   else
  288.     {
  289.       input_line_point += count;
  290.       if (input_line_point > input_line_end)
  291.         input_line_point = input_line_end;
  292.     }
  293. }
  294.  
  295. DECLARE_INFO_COMMAND (ea_backward, _("Move backward a character"))
  296. {
  297.   if (count < 0)
  298.     ea_forward (window, -count, key);
  299.   else
  300.     {
  301.       input_line_point -= count;
  302.       if (input_line_point < input_line_beg)
  303.         input_line_point = input_line_beg;
  304.     }
  305. }
  306.  
  307. DECLARE_INFO_COMMAND (ea_beg_of_line, _("Move to the start of this line"))
  308. {
  309.   input_line_point = input_line_beg;
  310. }
  311.  
  312. DECLARE_INFO_COMMAND (ea_end_of_line, _("Move to the end of this line"))
  313. {
  314.   input_line_point = input_line_end;
  315. }
  316.  
  317. #define alphabetic(c) (islower (c) || isupper (c) || isdigit (c))
  318.  
  319. /* Move forward a word in the input line. */
  320. DECLARE_INFO_COMMAND (ea_forward_word, _("Move forward a word"))
  321. {
  322.   int c;
  323.  
  324.   if (count < 0)
  325.     ea_backward_word (window, -count, key);
  326.   else
  327.     {
  328.       while (count--)
  329.         {
  330.           if (input_line_point == input_line_end)
  331.             return;
  332.  
  333.           /* If we are not in a word, move forward until we are in one.
  334.              Then, move forward until we hit a non-alphabetic character. */
  335.           c = input_line[input_line_point];
  336.  
  337.           if (!alphabetic (c))
  338.             {
  339.               while (++input_line_point < input_line_end)
  340.                 {
  341.                   c = input_line[input_line_point];
  342.                   if (alphabetic (c))
  343.                     break;
  344.                 }
  345.             }
  346.  
  347.           if (input_line_point == input_line_end)
  348.             return;
  349.  
  350.           while (++input_line_point < input_line_end)
  351.             {
  352.               c = input_line[input_line_point];
  353.               if (!alphabetic (c))
  354.                 break;
  355.             }
  356.         }
  357.     }
  358. }
  359.  
  360. DECLARE_INFO_COMMAND (ea_backward_word, _("Move backward a word"))
  361. {
  362.   int c;
  363.  
  364.   if (count < 0)
  365.     ea_forward_word (window, -count, key);
  366.   else
  367.     {
  368.       while (count--)
  369.         {
  370.           if (input_line_point == input_line_beg)
  371.             return;
  372.  
  373.           /* Like ea_forward_word (), except that we look at the
  374.              characters just before point. */
  375.  
  376.           c = input_line[input_line_point - 1];
  377.  
  378.           if (!alphabetic (c))
  379.             {
  380.               while ((--input_line_point) != input_line_beg)
  381.                 {
  382.                   c = input_line[input_line_point - 1];
  383.                   if (alphabetic (c))
  384.                     break;
  385.                 }
  386.             }
  387.  
  388.           while (input_line_point != input_line_beg)
  389.             {
  390.               c = input_line[input_line_point - 1];
  391.               if (!alphabetic (c))
  392.                 break;
  393.               else
  394.                 --input_line_point;
  395.             }
  396.         }
  397.     }
  398. }
  399.  
  400. DECLARE_INFO_COMMAND (ea_delete, _("Delete the character under the cursor"))
  401. {
  402.   register int i;
  403.  
  404.   if (count < 0)
  405.     ea_rubout (window, -count, key);
  406.   else
  407.     {
  408.       if (input_line_point == input_line_end)
  409.         return;
  410.  
  411.       if (info_explicit_arg || count > 1)
  412.         {
  413.           int orig_point;
  414.  
  415.           orig_point = input_line_point;
  416.           ea_forward (window, count, key);
  417.           ea_kill_text (orig_point, input_line_point);
  418.           input_line_point = orig_point;
  419.         }
  420.       else
  421.         {
  422.           for (i = input_line_point; i < input_line_end; i++)
  423.             input_line[i] = input_line[i + 1];
  424.  
  425.           input_line_end--;
  426.         }
  427.     }
  428. }
  429.  
  430. DECLARE_INFO_COMMAND (ea_rubout, _("Delete the character behind the cursor"))
  431. {
  432.   if (count < 0)
  433.     ea_delete (window, -count, key);
  434.   else
  435.     {
  436.       int start;
  437.  
  438.       if (input_line_point == input_line_beg)
  439.         return;
  440.  
  441.       start = input_line_point;
  442.       ea_backward (window, count, key);
  443.  
  444.       if (info_explicit_arg || count > 1)
  445.         ea_kill_text (start, input_line_point);
  446.       else
  447.         ea_delete (window, count, key);
  448.     }
  449. }
  450.  
  451. DECLARE_INFO_COMMAND (ea_abort, _("Cancel or quit operation"))
  452. {
  453.   /* If any text, just discard it, and restore the calling window's node.
  454.      If no text, quit. */
  455.   if (input_line_end != input_line_beg)
  456.     {
  457.       terminal_ring_bell ();
  458.       input_line_end = input_line_point = input_line_beg;
  459.       if (calling_window->node != calling_window_node)
  460.         restore_calling_window ();
  461.     }
  462.   else
  463.     info_aborted_echo_area = 1;
  464. }
  465.  
  466. DECLARE_INFO_COMMAND (ea_newline, _("Accept (or force completion of) this line"))
  467. {
  468.   /* Stub does nothing.  Simply here to see if it has been executed. */
  469. }
  470.  
  471. DECLARE_INFO_COMMAND (ea_quoted_insert, _("Insert next character verbatim"))
  472. {
  473.   unsigned char character;
  474.  
  475.   character = info_get_another_input_char ();
  476.   ea_insert (window, count, character);
  477. }
  478.  
  479. DECLARE_INFO_COMMAND (ea_insert, _("Insert this character"))
  480. {
  481.   register int i;
  482.  
  483.   if ((input_line_end + 1) == EA_MAX_INPUT)
  484.     {
  485.       terminal_ring_bell ();
  486.       return;
  487.     }
  488.  
  489.   for (i = input_line_end + 1; i != input_line_point; i--)
  490.     input_line[i] = input_line[i - 1];
  491.  
  492.   input_line[input_line_point] = key;
  493.   input_line_point++;
  494.   input_line_end++;
  495. }
  496.  
  497. DECLARE_INFO_COMMAND (ea_tab_insert, _("Insert a TAB character"))
  498. {
  499.   ea_insert (window, count, '\t');
  500. }
  501.  
  502. /* Transpose the characters at point.  If point is at the end of the line,
  503.    then transpose the characters before point. */
  504. DECLARE_INFO_COMMAND (ea_transpose_chars, _("Transpose characters at point"))
  505. {
  506.   /* Handle conditions that would make it impossible to transpose
  507.      characters. */
  508.   if (!count || !input_line_point || (input_line_end - input_line_beg) < 2)
  509.     return;
  510.  
  511.   while (count)
  512.     {
  513.       int t;
  514.       if (input_line_point == input_line_end)
  515.         {
  516.           t = input_line[input_line_point - 1];
  517.  
  518.           input_line[input_line_point - 1] = input_line[input_line_point - 2];
  519.           input_line[input_line_point - 2] = t;
  520.         }
  521.       else
  522.         {
  523.           t = input_line[input_line_point];
  524.  
  525.           input_line[input_line_point] = input_line[input_line_point - 1];
  526.           input_line[input_line_point - 1] = t;
  527.  
  528.           if (count < 0 && input_line_point != input_line_beg)
  529.             input_line_point--;
  530.           else
  531.             input_line_point++;
  532.         }
  533.  
  534.       if (count < 0)
  535.         count++;
  536.       else
  537.         count--;
  538.     }
  539. }
  540.  
  541. /* **************************************************************** */
  542. /*                                                                  */
  543. /*                   Echo Area Killing and Yanking                  */
  544. /*                                                                  */
  545. /* **************************************************************** */
  546.  
  547. static char **kill_ring = (char **)NULL;
  548. static int kill_ring_index = 0; /* Number of kills appearing in KILL_RING. */
  549. static int kill_ring_slots = 0; /* Number of slots allocated to KILL_RING. */
  550. static int kill_ring_loc = 0;   /* Location of current yank pointer. */
  551.  
  552. /* The largest number of kills that we remember at one time. */
  553. static int max_retained_kills = 15;
  554.  
  555. DECLARE_INFO_COMMAND (ea_yank, _("Yank back the contents of the last kill"))
  556. {
  557.   register int i;
  558.   register char *text;
  559.  
  560.   if (!kill_ring_index)
  561.     {
  562.       inform_in_echo_area (_("Kill ring is empty"));
  563.       return;
  564.     }
  565.  
  566.   text = kill_ring[kill_ring_loc];
  567.  
  568.   for (i = 0; text[i]; i++)
  569.     ea_insert (window, 1, text[i]);
  570. }
  571.  
  572. /* If the last command was yank, or yank_pop, and the text just before
  573.    point is identical to the current kill item, then delete that text
  574.    from the line, rotate the index down, and yank back some other text. */
  575. DECLARE_INFO_COMMAND (ea_yank_pop, _("Yank back a previous kill"))
  576. {
  577.   register int len;
  578.  
  579.   if (((ea_last_executed_command != ea_yank) &&
  580.        (ea_last_executed_command != ea_yank_pop)) ||
  581.       (kill_ring_index == 0))
  582.     return;
  583.  
  584.   len = strlen (kill_ring[kill_ring_loc]);
  585.  
  586.   /* Delete the last yanked item from the line. */
  587.   {
  588.     register int i, counter;
  589.  
  590.     counter = input_line_end - input_line_point;
  591.     
  592.     for (i = input_line_point - len; counter; i++, counter--)
  593.       input_line[i] = input_line[i + len];
  594.  
  595.     input_line_end -= len;
  596.     input_line_point -= len;
  597.   }
  598.  
  599.   /* Get a previous kill, and yank that. */
  600.   kill_ring_loc--;
  601.   if (kill_ring_loc < 0)
  602.     kill_ring_loc = kill_ring_index - 1;
  603.  
  604.   ea_yank (window, count, key);
  605. }
  606.  
  607. /* Delete the text from point to end of line. */
  608. DECLARE_INFO_COMMAND (ea_kill_line, _("Kill to the end of the line"))
  609. {
  610.   if (count < 0)
  611.     {
  612.       ea_kill_text (input_line_point, input_line_beg);
  613.       input_line_point = input_line_beg;
  614.     }
  615.   else
  616.     ea_kill_text (input_line_point, input_line_end);
  617. }
  618.  
  619. /* Delete the text from point to beg of line. */
  620. DECLARE_INFO_COMMAND (ea_backward_kill_line,
  621.                       _("Kill to the beginning of the line"))
  622. {
  623.   if (count < 0)
  624.     ea_kill_text (input_line_point, input_line_end);
  625.   else
  626.     {
  627.       ea_kill_text (input_line_point, input_line_beg);
  628.       input_line_point = input_line_beg;
  629.     }
  630. }
  631.  
  632. /* Delete from point to the end of the current word. */
  633. DECLARE_INFO_COMMAND (ea_kill_word, _("Kill the word following the cursor"))
  634. {
  635.   int orig_point = input_line_point;
  636.  
  637.   if (count < 0)
  638.     ea_backward_kill_word (window, -count, key);
  639.   else
  640.     {
  641.       ea_forward_word (window, count, key);
  642.  
  643.       if (input_line_point != orig_point)
  644.         ea_kill_text (orig_point, input_line_point);
  645.  
  646.       input_line_point = orig_point;
  647.     }
  648. }
  649.  
  650. /* Delete from point to the start of the current word. */
  651. DECLARE_INFO_COMMAND (ea_backward_kill_word,
  652.                       _("Kill the word preceding the cursor"))
  653. {
  654.   int orig_point = input_line_point;
  655.  
  656.   if (count < 0)
  657.     ea_kill_word (window, -count, key);
  658.   else
  659.     {
  660.       ea_backward_word (window, count, key);
  661.  
  662.       if (input_line_point != orig_point)
  663.         ea_kill_text (orig_point, input_line_point);
  664.     }
  665. }
  666.  
  667. /* The way to kill something.  This appends or prepends to the last
  668.    kill, if the last command was a kill command.  If FROM is less
  669.    than TO, then the killed text is appended to the most recent kill,
  670.    otherwise it is prepended.  If the last command was not a kill command,
  671.    then a new slot is made for this kill. */
  672. static void
  673. ea_kill_text (from, to)
  674.      int from, to;
  675. {
  676.   register int i, counter, distance;
  677.   int killing_backwards, slot;
  678.   char *killed_text;
  679.  
  680.   killing_backwards = (from > to);
  681.  
  682.   /* If killing backwards, reverse the values of FROM and TO. */
  683.   if (killing_backwards)
  684.     {
  685.       int temp = from;
  686.       from = to;
  687.       to = temp;
  688.     }
  689.  
  690.   /* Remember the text that we are about to delete. */
  691.   distance = to - from;
  692.   killed_text = (char *)xmalloc (1 + distance);
  693.   strncpy (killed_text, &input_line[from], distance);
  694.   killed_text[distance] = '\0';
  695.  
  696.   /* Actually delete the text from the line. */
  697.   counter = input_line_end - to;
  698.  
  699.   for (i = from; counter; i++, counter--)
  700.     input_line[i] = input_line[i + distance];
  701.  
  702.   input_line_end -= distance;
  703.  
  704.   /* If the last command was a kill, append or prepend the killed text to
  705.      the last command's killed text. */
  706.   if (echo_area_last_command_was_kill)
  707.     {
  708.       char *old, *new;
  709.  
  710.       slot = kill_ring_loc;
  711.       old = kill_ring[slot];
  712.       new = (char *)xmalloc (1 + strlen (old) + strlen (killed_text));
  713.  
  714.       if (killing_backwards)
  715.         {
  716.           /* Prepend TEXT to current kill. */
  717.           strcpy (new, killed_text);
  718.           strcat (new, old);
  719.         }
  720.       else
  721.         {
  722.           /* Append TEXT to current kill. */
  723.           strcpy (new, old);
  724.           strcat (new, killed_text);
  725.         }
  726.  
  727.       free (old);
  728.       free (killed_text);
  729.       kill_ring[slot] = new;
  730.     }
  731.   else
  732.     {
  733.       /* Try to store the kill in a new slot, unless that would cause there
  734.          to be too many remembered kills. */
  735.       slot = kill_ring_index;
  736.  
  737.       if (slot == max_retained_kills)
  738.         slot = 0;
  739.  
  740.       if (slot + 1 > kill_ring_slots)
  741.         kill_ring = (char **) xrealloc
  742.           (kill_ring,
  743.            (kill_ring_slots += max_retained_kills) * sizeof (char *));
  744.  
  745.       if (slot != kill_ring_index)
  746.         free (kill_ring[slot]);
  747.       else
  748.         kill_ring_index++;
  749.  
  750.       kill_ring[slot] = killed_text;
  751.  
  752.       kill_ring_loc = slot;
  753.     }
  754.  
  755.   /* Notice that the last command was a kill. */
  756.   echo_area_last_command_was_kill++;
  757. }
  758.  
  759. /* **************************************************************** */
  760. /*                                                                  */
  761. /*                      Echo Area Completion                        */
  762. /*                                                                  */
  763. /* **************************************************************** */
  764.  
  765. /* Pointer to an array of REFERENCE to complete over. */
  766. static REFERENCE **echo_area_completion_items = (REFERENCE **)NULL;
  767.  
  768. /* Sorted array of REFERENCE * which is the possible completions found in
  769.    the variable echo_area_completion_items.  If there is only one element,
  770.    it is the only possible completion. */
  771. static REFERENCE **completions_found = (REFERENCE **)NULL;
  772. static int completions_found_index = 0;
  773. static int completions_found_slots = 0;
  774.  
  775. /* The lowest common denominator found while completing. */
  776. static REFERENCE *LCD_completion;
  777.  
  778. /* Internal functions used by the user calls. */
  779. static void build_completions (), completions_must_be_rebuilt ();
  780.  
  781. /* Variable which holds the output of completions. */
  782. static NODE *possible_completions_output_node = (NODE *)NULL;
  783.  
  784. static char *compwin_name = "*Completions*";
  785.  
  786. /* Return non-zero if WINDOW is a window used for completions output. */
  787. static int
  788. completions_window_p (window)
  789.      WINDOW *window;
  790. {
  791.   int result = 0;
  792.  
  793.   if (internal_info_node_p (window->node) &&
  794.       (strcmp (window->node->nodename, compwin_name) == 0))
  795.     result = 1;
  796.  
  797.   return (result);
  798. }
  799.  
  800. /* Workhorse for completion readers.  If FORCE is non-zero, the user cannot
  801.    exit unless the line read completes, or is empty. */
  802. char *
  803. info_read_completing_internal (window, prompt, completions, force)
  804.      WINDOW *window;
  805.      char *prompt;
  806.      REFERENCE **completions;
  807.      int force;
  808. {
  809.   char *line;
  810.  
  811.   /* If the echo area is already active, remember the current state. */
  812.   if (echo_area_is_active)
  813.     push_echo_area ();
  814.  
  815.   echo_area_must_complete_p = force;
  816.  
  817.   /* Initialize our local variables. */
  818.   initialize_input_line (prompt);
  819.  
  820.   /* Initialize the echo area for the first (but maybe not the last) time. */
  821.   echo_area_initialize_node ();
  822.  
  823.   /* Save away the original node of this window, and the window itself,
  824.      so echo area commands can temporarily use this window. */
  825.   remember_calling_window (window);
  826.  
  827.   /* Save away the list of items to complete over. */
  828.   echo_area_completion_items = completions;
  829.   completions_must_be_rebuilt ();
  830.  
  831.   active_window = the_echo_area;
  832.   echo_area_is_active++;
  833.  
  834.   /* Read characters in the echo area. */
  835.   while (1)
  836.     {
  837.       info_read_and_dispatch ();
  838.  
  839.       line = echo_area_after_read ();
  840.  
  841.       /* Force the completion to take place if the user hasn't accepted
  842.          a default or aborted, and if FORCE is active. */
  843.       if (force && line && *line && completions)
  844.         {
  845.           register int i;
  846.  
  847.           build_completions ();
  848.  
  849.           /* If there is only one completion, then make the line be that
  850.              completion. */
  851.           if (completions_found_index == 1)
  852.             {
  853.               free (line);
  854.               line = xstrdup (completions_found[0]->label);
  855.               break;
  856.             }
  857.  
  858.           /* If one of the completions matches exactly, then that is okay, so
  859.              return the current line. */
  860.           for (i = 0; i < completions_found_index; i++)
  861.             if (strcasecmp (completions_found[i]->label, line) == 0)
  862.               {
  863.                 free (line);
  864.                 line = xstrdup (completions_found[i]->label);
  865.                 break;
  866.               }
  867.  
  868.           /* If no match, go back and try again. */
  869.           if (i == completions_found_index)
  870.             {
  871.               inform_in_echo_area (_("Not complete"));
  872.               continue;
  873.             }
  874.         }
  875.       break;
  876.     }
  877.   echo_area_is_active--;
  878.  
  879.   /* Restore the original active window and show point in it. */
  880.   active_window = calling_window;
  881.   restore_calling_window ();
  882.   display_cursor_at_point (active_window);
  883.   fflush (stdout);
  884.  
  885.   echo_area_completion_items = (REFERENCE **)NULL;
  886.   completions_must_be_rebuilt ();
  887.  
  888.   /* If there is a previous loop waiting for us, restore it now. */
  889.   if (echo_area_is_active)
  890.     pop_echo_area ();
  891.  
  892.   return (line);
  893. }
  894.   
  895. /* Read a line in the echo area with completion over COMPLETIONS. */
  896. char *
  897. info_read_completing_in_echo_area (window, prompt, completions)
  898.      WINDOW *window;
  899.      char *prompt;
  900.      REFERENCE **completions;
  901. {
  902.   return (info_read_completing_internal (window, prompt, completions, 1));
  903. }
  904.  
  905. /* Read a line in the echo area allowing completion over COMPLETIONS, but
  906.    not requiring it. */
  907. char *
  908. info_read_maybe_completing (window, prompt, completions)
  909.      WINDOW *window;
  910.      char *prompt;
  911.      REFERENCE **completions;
  912. {
  913.   return (info_read_completing_internal (window, prompt, completions, 0));
  914. }
  915.  
  916. DECLARE_INFO_COMMAND (ea_possible_completions, _("List possible completions"))
  917. {
  918.   if (!echo_area_completion_items)
  919.     {
  920.       ea_insert (window, count, key);
  921.       return;
  922.     }
  923.  
  924.   build_completions ();
  925.  
  926.   if (!completions_found_index)
  927.     {
  928.       terminal_ring_bell ();
  929.       inform_in_echo_area (_("No completions"));
  930.     }
  931.   else if ((completions_found_index == 1) && (key != '?'))
  932.     {
  933.       inform_in_echo_area (_("Sole completion"));
  934.     }
  935.   else
  936.     {
  937.       register int i, l;
  938.       int limit, count, max_label = 0;
  939.  
  940.       initialize_message_buffer ();
  941.       printf_to_message_buffer
  942.         (_("There %s %d "), completions_found_index == 1 ? _("is") : _("are"),
  943.          completions_found_index);
  944.       printf_to_message_buffer
  945.         (_("completion%s:\n"), completions_found_index == 1 ? "" : "s");
  946.  
  947.       /* Find the maximum length of a label. */
  948.       for (i = 0; i < completions_found_index; i++)
  949.         {
  950.           int len = strlen (completions_found[i]->label);
  951.           if (len > max_label)
  952.             max_label = len;
  953.         }
  954.  
  955.       max_label += 4;
  956.  
  957.       /* Find out how many columns we should print in. */
  958.       limit = calling_window->width / max_label;
  959.       if (limit != 1 && (limit * max_label == calling_window->width))
  960.         limit--;
  961.  
  962.       /* Avoid a possible floating exception.  If max_label > width then
  963.          the limit will be 0 and a divide-by-zero fault will result. */
  964.       if (limit == 0)
  965.         limit = 1;
  966.  
  967.       /* How many iterations of the printing loop? */
  968.       count = (completions_found_index + (limit - 1)) / limit;
  969.  
  970.       /* Watch out for special case.  If the number of completions is less
  971.          than LIMIT, then just do the inner printing loop. */
  972.       if (completions_found_index < limit)
  973.         count = 1;
  974.  
  975.       /* Print the sorted items, up-and-down alphabetically. */
  976.       for (i = 0; i < count; i++)
  977.         {
  978.           register int j;
  979.  
  980.           for (j = 0, l = i; j < limit; j++)
  981.             {
  982.               if (l >= completions_found_index)
  983.                 break;
  984.               else
  985.                 {
  986.                   char *label;
  987.                   int printed_length, k;
  988.  
  989.                   label = completions_found[l]->label;
  990.                   printed_length = strlen (label);
  991.                   printf_to_message_buffer ("%s", label);
  992.  
  993.                   if (j + 1 < limit)
  994.                     {
  995.                       for (k = 0; k < max_label - printed_length; k++)
  996.                         printf_to_message_buffer (" ");
  997.                     }
  998.                 }
  999.               l += count;
  1000.             }
  1001.           printf_to_message_buffer ("\n");
  1002.         }
  1003.  
  1004.       /* Make a new node to hold onto possible completions.  Don't destroy
  1005.          dangling pointers. */
  1006.       {
  1007.         NODE *temp;
  1008.  
  1009.         temp = message_buffer_to_node ();
  1010.         add_gcable_pointer (temp->contents);
  1011.         name_internal_node (temp, compwin_name);
  1012.         possible_completions_output_node = temp;
  1013.       }
  1014.  
  1015.       /* Find a suitable window for displaying the completions output.
  1016.          First choice is an existing window showing completions output.
  1017.          If there is only one window, and it is large, make another
  1018.          (smaller) window, and use that one.  Otherwise, use the caller's
  1019.          window. */
  1020.       {
  1021.         WINDOW *compwin;
  1022.  
  1023.         compwin = get_internal_info_window (compwin_name);
  1024.  
  1025.         if (!compwin)
  1026.           {
  1027.             /* If we can split the window to display most of the completion
  1028.                items, then do so. */
  1029.             if (calling_window->height > (count * 2)
  1030.         && calling_window->height / 2 >= WINDOW_MIN_SIZE)
  1031.               {
  1032.                 int start, pagetop;
  1033. #ifdef SPLIT_BEFORE_ACTIVE
  1034.                 int end;
  1035. #endif
  1036.  
  1037.                 active_window = calling_window;
  1038.  
  1039.                 /* Perhaps we can scroll this window on redisplay. */
  1040.                 start = calling_window->first_row;
  1041.                 pagetop = calling_window->pagetop;
  1042.  
  1043.                 compwin =
  1044.                   window_make_window (possible_completions_output_node);
  1045.                 active_window = the_echo_area;
  1046.                 window_change_window_height
  1047.                   (compwin, -(compwin->height - (count + 2)));
  1048.  
  1049.                 window_adjust_pagetop (calling_window);
  1050.                 remember_calling_window (calling_window);
  1051.  
  1052. #if defined (SPLIT_BEFORE_ACTIVE)
  1053.                 /* If the pagetop hasn't changed, scrolling the calling
  1054.                    window is a reasonable thing to do. */
  1055.                 if (pagetop == calling_window->pagetop)
  1056.                   {
  1057.                     end = start + calling_window->height;
  1058.                     display_scroll_display
  1059.                       (start, end, calling_window->prev->height + 1);
  1060.                   }
  1061. #else /* !SPLIT_BEFORE_ACTIVE */
  1062.                 /* If the pagetop has changed, set the new pagetop here. */
  1063.                 if (pagetop != calling_window->pagetop)
  1064.                   {
  1065.                     int newtop = calling_window->pagetop;
  1066.                     calling_window->pagetop = pagetop;
  1067.                     set_window_pagetop (calling_window, newtop);
  1068.                   }
  1069. #endif /* !SPLIT_BEFORE_ACTIVE */
  1070.  
  1071.                 echo_area_completions_window = compwin;
  1072.                 remember_window_and_node (compwin, compwin->node);
  1073.               }
  1074.             else
  1075.               compwin = calling_window;
  1076.           }
  1077.  
  1078.         if (compwin->node != possible_completions_output_node)
  1079.           {
  1080.             window_set_node_of_window
  1081.               (compwin, possible_completions_output_node);
  1082.             remember_window_and_node (compwin, compwin->node);
  1083.           }
  1084.  
  1085.         display_update_display (windows);
  1086.       }
  1087.     }
  1088. }
  1089.  
  1090. DECLARE_INFO_COMMAND (ea_complete, _("Insert completion"))
  1091. {
  1092.   if (!echo_area_completion_items)
  1093.     {
  1094.       ea_insert (window, count, key);
  1095.       return;
  1096.     }
  1097.  
  1098.   /* If KEY is SPC, and we are not forcing completion to take place, simply
  1099.      insert the key. */
  1100.   if (!echo_area_must_complete_p && key == SPC)
  1101.     {
  1102.       ea_insert (window, count, key);
  1103.       return;
  1104.     }
  1105.  
  1106.   if (ea_last_executed_command == ea_complete)
  1107.     {
  1108.       /* If the keypress is a SPC character, and we have already tried
  1109.          completing once, and there are several completions, then check
  1110.          the batch of completions to see if any continue with a space.
  1111.          If there are some, insert the space character and continue. */
  1112.       if (key == SPC && completions_found_index > 1)
  1113.         {
  1114.           register int i, offset;
  1115.  
  1116.           offset = input_line_end - input_line_beg;
  1117.  
  1118.           for (i = 0; i < completions_found_index; i++)
  1119.             if (completions_found[i]->label[offset] == ' ')
  1120.               break;
  1121.  
  1122.           if (completions_found[i])
  1123.             ea_insert (window, 1, ' ');
  1124.           else
  1125.             {
  1126.               ea_possible_completions (window, count, key);
  1127.               return;
  1128.             }
  1129.         }
  1130.       else
  1131.         {
  1132.           ea_possible_completions (window, count, key);
  1133.           return;
  1134.         }
  1135.     }
  1136.  
  1137.   input_line_point = input_line_end;
  1138.   build_completions ();
  1139.  
  1140.   if (!completions_found_index)
  1141.     terminal_ring_bell ();
  1142.   else if (LCD_completion->label[0] == '\0')
  1143.     ea_possible_completions (window, count, key);
  1144.   else
  1145.     {
  1146.       register int i;
  1147.       input_line_point = input_line_end = input_line_beg;
  1148.       for (i = 0; LCD_completion->label[i]; i++)
  1149.         ea_insert (window, 1, LCD_completion->label[i]);
  1150.     }
  1151. }
  1152.  
  1153. /* Utility REFERENCE used to store possible LCD. */
  1154. static REFERENCE LCD_reference = { (char *)NULL, (char *)NULL, (char *)NULL };
  1155.  
  1156. static void remove_completion_duplicates ();
  1157.  
  1158. /* Variables which remember the state of the most recent call
  1159.    to build_completions (). */
  1160. static char *last_completion_request = (char *)NULL;
  1161. static REFERENCE **last_completion_items = (REFERENCE **)NULL;
  1162.  
  1163. /* How to tell the completion builder to reset internal state. */
  1164. static void
  1165. completions_must_be_rebuilt ()
  1166. {
  1167.   maybe_free (last_completion_request);
  1168.   last_completion_request = (char *)NULL;
  1169.   last_completion_items = (REFERENCE **)NULL;
  1170. }
  1171.  
  1172. /* Build a list of possible completions from echo_area_completion_items,
  1173.    and the contents of input_line. */
  1174. static void
  1175. build_completions ()
  1176. {
  1177.   register int i, len;
  1178.   register REFERENCE *entry;
  1179.   char *request;
  1180.   int informed_of_lengthy_job = 0;
  1181.  
  1182.   /* If there are no items to complete over, exit immediately. */
  1183.   if (!echo_area_completion_items)
  1184.     {
  1185.       completions_found_index = 0;
  1186.       LCD_completion = (REFERENCE *)NULL;
  1187.       return;
  1188.     }
  1189.  
  1190.   /* Check to see if this call to build completions is the same as the last
  1191.      call to build completions. */
  1192.   len = input_line_end - input_line_beg;
  1193.   request = (char *)xmalloc (1 + len);
  1194.   strncpy (request, &input_line[input_line_beg], len);
  1195.   request[len] = '\0';
  1196.  
  1197.   if (last_completion_request && last_completion_items &&
  1198.       last_completion_items == echo_area_completion_items &&
  1199.       (strcmp (last_completion_request, request) == 0))
  1200.     {
  1201.       free (request);
  1202.       return;
  1203.     }
  1204.  
  1205.   maybe_free (last_completion_request);
  1206.   last_completion_request = request;
  1207.   last_completion_items = echo_area_completion_items;
  1208.  
  1209.   /* Always start at the beginning of the list. */
  1210.   completions_found_index = 0;
  1211.   LCD_completion = (REFERENCE *)NULL;
  1212.  
  1213.   for (i = 0; (entry = echo_area_completion_items[i]); i++)
  1214.     {
  1215.       if (strncasecmp (request, entry->label, len) == 0)
  1216.         add_pointer_to_array (entry, completions_found_index,
  1217.                               completions_found, completions_found_slots,
  1218.                               20, REFERENCE *);
  1219.  
  1220.       if (!informed_of_lengthy_job && completions_found_index > 100)
  1221.         {
  1222.           informed_of_lengthy_job = 1;
  1223.           window_message_in_echo_area (_("Building completions..."));
  1224.         }
  1225.     }
  1226.  
  1227.   if (!completions_found_index)
  1228.     return;
  1229.  
  1230.   /* Sort and prune duplicate entries from the completions array. */
  1231.   remove_completion_duplicates ();
  1232.  
  1233.   /* If there is only one completion, just return that. */
  1234.   if (completions_found_index == 1)
  1235.     {
  1236.       LCD_completion = completions_found[0];
  1237.       return;
  1238.     }
  1239.  
  1240.   /* Find the least common denominator. */
  1241.   {
  1242.     long shortest = 100000;
  1243.  
  1244.     for (i = 1; i < completions_found_index; i++)
  1245.       {
  1246.         register int j;
  1247.         int c1, c2;
  1248.  
  1249.         for (j = 0;
  1250.              (c1 = info_tolower (completions_found[i - 1]->label[j])) &&
  1251.              (c2 = info_tolower (completions_found[i]->label[j]));
  1252.              j++)
  1253.           if (c1 != c2)
  1254.             break;
  1255.  
  1256.         if (shortest > j)
  1257.           shortest = j;
  1258.       }
  1259.  
  1260.     maybe_free (LCD_reference.label);
  1261.     LCD_reference.label = (char *)xmalloc (1 + shortest);
  1262.     strncpy (LCD_reference.label, completions_found[0]->label, shortest);
  1263.     LCD_reference.label[shortest] = '\0';
  1264.     LCD_completion = &LCD_reference;
  1265.   }
  1266.  
  1267.   if (informed_of_lengthy_job)
  1268.     echo_area_initialize_node ();
  1269. }
  1270.  
  1271. /* Function called by qsort. */
  1272. static int
  1273. compare_references (entry1, entry2)
  1274.      REFERENCE **entry1, **entry2;
  1275. {
  1276.   return (strcasecmp ((*entry1)->label, (*entry2)->label));
  1277. }
  1278.  
  1279. /* Prune duplicate entries from COMPLETIONS_FOUND. */
  1280. static void
  1281. remove_completion_duplicates ()
  1282. {
  1283.   register int i, j;
  1284.   REFERENCE **temp;
  1285.   int newlen;
  1286.  
  1287.   if (!completions_found_index)
  1288.     return;
  1289.  
  1290.   /* Sort the items. */
  1291.   qsort (completions_found, completions_found_index, sizeof (REFERENCE *),
  1292.          compare_references);
  1293.  
  1294.   for (i = 0, newlen = 1; i < completions_found_index - 1; i++)
  1295.     {
  1296.       if (strcmp (completions_found[i]->label,
  1297.                   completions_found[i + 1]->label) == 0)
  1298.         completions_found[i] = (REFERENCE *)NULL;
  1299.       else
  1300.         newlen++;
  1301.     }
  1302.  
  1303.   /* We have marked all the dead slots.  It is faster to copy the live slots
  1304.      twice than to prune the dead slots one by one. */
  1305.   temp = (REFERENCE **)xmalloc ((1 + newlen) * sizeof (REFERENCE *));
  1306.   for (i = 0, j = 0; i < completions_found_index; i++)
  1307.     if (completions_found[i])
  1308.       temp[j++] = completions_found[i];
  1309.  
  1310.   for (i = 0; i < newlen; i++)
  1311.     completions_found[i] = temp[i];
  1312.  
  1313.   completions_found[i] = (REFERENCE *)NULL;
  1314.   completions_found_index = newlen;
  1315.   free (temp);
  1316. }
  1317.  
  1318. /* Scroll the "other" window.  If there is a window showing completions, scroll
  1319.    that one, otherwise scroll the window which was active on entering the read
  1320.    function. */
  1321. DECLARE_INFO_COMMAND (ea_scroll_completions_window, _("Scroll the completions window"))
  1322. {
  1323.   WINDOW *compwin;
  1324.   int old_pagetop;
  1325.  
  1326.   compwin = get_internal_info_window (compwin_name);
  1327.  
  1328.   if (!compwin)
  1329.     compwin = calling_window;
  1330.  
  1331.   old_pagetop = compwin->pagetop;
  1332.  
  1333.   /* Let info_scroll_forward () do the work, and print any messages that
  1334.      need to be displayed. */
  1335.   info_scroll_forward (compwin, count, key);
  1336. }
  1337.  
  1338. /* Function which gets called when an Info window is deleted while the
  1339.    echo area is active.  WINDOW is the window which has just been deleted. */
  1340. void
  1341. echo_area_inform_of_deleted_window (window)
  1342.      WINDOW *window;
  1343. {
  1344.   /* If this is the calling_window, forget what we remembered about it. */
  1345.   if (window == calling_window)
  1346.     {
  1347.       if (active_window != the_echo_area)
  1348.         remember_calling_window (active_window);
  1349.       else
  1350.         remember_calling_window (windows);
  1351.     }
  1352.  
  1353.   /* If this window was the echo_area_completions_window, then notice that
  1354.      the window has been deleted. */
  1355.   if (window == echo_area_completions_window)
  1356.     echo_area_completions_window = (WINDOW *)NULL;
  1357. }
  1358.  
  1359. /* **************************************************************** */
  1360. /*                                                                  */
  1361. /*                 Pushing and Popping the Echo Area                */
  1362. /*                                                                  */
  1363. /* **************************************************************** */
  1364.  
  1365. /* Push and Pop the echo area. */
  1366. typedef struct {
  1367.   char *line;
  1368.   char *prompt;
  1369.   REFERENCE **comp_items;
  1370.   int point, beg, end;
  1371.   int must_complete;
  1372.   NODE node;
  1373.   WINDOW *compwin;
  1374. } PUSHED_EA;
  1375.  
  1376. static PUSHED_EA **pushed_echo_areas = (PUSHED_EA **)NULL;
  1377. static int pushed_echo_areas_index = 0;
  1378. static int pushed_echo_areas_slots = 0;
  1379.  
  1380. /* Pushing the echo_area has a side effect of zeroing the completion_items. */
  1381. static void
  1382. push_echo_area ()
  1383. {
  1384.   PUSHED_EA *pushed;
  1385.  
  1386.   pushed = (PUSHED_EA *)xmalloc (sizeof (PUSHED_EA));
  1387.   pushed->line = xstrdup (input_line);
  1388.   pushed->prompt = input_line_prompt;
  1389.   pushed->point = input_line_point;
  1390.   pushed->beg = input_line_beg;
  1391.   pushed->end = input_line_end;
  1392.   pushed->node = input_line_node;
  1393.   pushed->comp_items = echo_area_completion_items;
  1394.   pushed->must_complete = echo_area_must_complete_p;
  1395.   pushed->compwin = echo_area_completions_window;
  1396.  
  1397.   add_pointer_to_array (pushed, pushed_echo_areas_index, pushed_echo_areas,
  1398.                         pushed_echo_areas_slots, 4, PUSHED_EA *);
  1399.  
  1400.   echo_area_completion_items = (REFERENCE **)NULL;
  1401. }
  1402.  
  1403. static void
  1404. pop_echo_area ()
  1405. {
  1406.   PUSHED_EA *popped;
  1407.  
  1408.   popped = pushed_echo_areas[--pushed_echo_areas_index];
  1409.  
  1410.   strcpy (input_line, popped->line);
  1411.   free (popped->line);
  1412.   input_line_prompt = popped->prompt;
  1413.   input_line_point = popped->point;
  1414.   input_line_beg = popped->beg;
  1415.   input_line_end = popped->end;
  1416.   input_line_node = popped->node;
  1417.   echo_area_completion_items = popped->comp_items;
  1418.   echo_area_must_complete_p = popped->must_complete;
  1419.   echo_area_completions_window = popped->compwin;
  1420.   completions_must_be_rebuilt ();
  1421.  
  1422.   /* If the completion window no longer exists, forget about it. */
  1423.   if (echo_area_completions_window)
  1424.     {
  1425.       register WINDOW *win;
  1426.  
  1427.       for (win = windows; win; win = win->next)
  1428.         if (echo_area_completions_window == win)
  1429.           break;
  1430.  
  1431.       /* If the window wasn't found, then it has already been deleted. */
  1432.       if (!win)
  1433.         echo_area_completions_window = (WINDOW *)NULL;
  1434.     }
  1435.  
  1436.   free (popped);
  1437. }
  1438.  
  1439. /* Returns non-zero if any of the prior stacked calls to read in the echo
  1440.    area produced a completions window. */
  1441. static int
  1442. echo_area_stack_contains_completions_p ()
  1443. {
  1444.   register int i;
  1445.  
  1446.   for (i = 0; i < pushed_echo_areas_index; i++)
  1447.     if (pushed_echo_areas[i]->compwin)
  1448.       return (1);
  1449.  
  1450.   return (0);
  1451. }
  1452.  
  1453. /* **************************************************************** */
  1454. /*                                                                  */
  1455. /*             Error Messages While Reading in Echo Area            */
  1456. /*                                                                  */
  1457. /* **************************************************************** */
  1458.  
  1459. #if defined (HAVE_SYS_TIME_H)
  1460. #  include <sys/time.h>
  1461. #  define HAVE_STRUCT_TIMEVAL
  1462. #endif /* HAVE_SYS_TIME_H */
  1463.  
  1464. static void
  1465. pause_or_input ()
  1466. {
  1467. #if defined (FD_SET) && !defined(__EMX__)
  1468.   struct timeval timer;
  1469.   fd_set readfds;
  1470.   int ready;
  1471.  
  1472.   FD_ZERO (&readfds);
  1473.   FD_SET (fileno (stdin), &readfds);
  1474.   timer.tv_sec = 2;
  1475.   timer.tv_usec = 750;
  1476.   ready = select (fileno (stdin) + 1, &readfds, (fd_set *) NULL,
  1477.                   (fd_set *) NULL, &timer);
  1478. #endif /* FD_SET */
  1479. }
  1480.  
  1481. /* Print MESSAGE right after the end of the current line, and wait
  1482.    for input or 2.75 seconds, whichever comes first.  Then flush the
  1483.    informational message that was printed. */
  1484. void
  1485. inform_in_echo_area (message)
  1486.      char *message;
  1487. {
  1488.   register int i;
  1489.   char *text;
  1490.  
  1491.   text = xstrdup (message);
  1492.   for (i = 0; text[i] && text[i] != '\n'; i++);
  1493.   text[i] = '\0';
  1494.  
  1495.   echo_area_initialize_node ();
  1496.   sprintf (&input_line[input_line_end], "%s[%s]\n",
  1497.            echo_area_is_active ? " ": "", text);
  1498.   free (text);
  1499.   the_echo_area->point = input_line_point;
  1500.   display_update_one_window (the_echo_area);
  1501.   display_cursor_at_point (active_window);
  1502.   fflush (stdout);
  1503.   pause_or_input ();
  1504.   echo_area_initialize_node ();
  1505. }
  1506.