/usr/src/gnu/usr.bin/texinfo/info/echo-area.c

Bug Summary

File:	src/gnu/usr.bin/texinfo/info/echo-area.c
Warning:	line 171, column 56 Null pointer passed as 1st argument to string length function
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name echo-area.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/texinfo/obj/info -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -D LOCALEDIR="/usr/share/locale" -D INFODIR="/usr/share/info" -D INFODIR2="/usr/share/info" -I . -I /usr/src/gnu/usr.bin/texinfo/info -I .. -I . -I /usr/src/gnu/usr.bin/texinfo/lib -I ../intl -I .. -I /usr/src/gnu/usr.bin/texinfo/info -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/texinfo/obj/info -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/texinfo/info/echo-area.c
1/* echo-area.c -- how to read a line in the echo area.
 $Id: echo-area.c,v 1.5 2006/07/17 16:12:36 espie 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). */

23#include "info.h"

25#if defined (FD_SET)
26#  if defined (hpux)
27#    define fd_set_cast(x)(fd_set *)(x) (int *)(x)
28#  else
29#    define fd_set_cast(x)(fd_set *)(x) (fd_set *)(x)
30#  endif /* !hpux */
31#endif /* FD_SET */

33/* Non-zero means that C-g was used to quit reading input. */
34int info_aborted_echo_area = 0;

36/* Non-zero means that the echo area is being used to read input. */
37int echo_area_is_active = 0;

39/* The address of the last command executed in the echo area. */
40VFunction *ea_last_executed_command = (VFunction *)NULL((void *)0);

42/* Non-zero means that the last command executed while reading input
 killed some text. */
44int echo_area_last_command_was_kill = 0;

46/* Variables which hold on to the current state of the input line. */
47static char input_line[1 + EA_MAX_INPUT256];
48static char *input_line_prompt;
49static int input_line_point;
50static int input_line_beg;
51static int input_line_end;
52static NODE input_line_node = {
(char *)NULL((void *)0), (char *)NULL((void *)0), (char *)NULL((void *)0), input_line,
EA_MAX_INPUT256, 0, N_IsInternal0x10
55};

57static void echo_area_initialize_node (void);
58static void push_echo_area (void), pop_echo_area (void);
59static int echo_area_stack_contains_completions_p (void);

61static void ea_kill_text (int from, int to);

63/* Non-zero means we force the user to complete. */
64static int echo_area_must_complete_p = 0;
65static int completions_window_p (WINDOW *window);

67/* 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. */
70static WINDOW *echo_area_completions_window = (WINDOW *)NULL((void *)0);

72/* Variables which keep track of the window which was active prior to
 entering the echo area. */
74static WINDOW *calling_window = (WINDOW *)NULL((void *)0);
75static NODE *calling_window_node = (NODE *)NULL((void *)0);
76static long calling_window_point = 0;
77static long calling_window_pagetop = 0;

79/* Remember the node and pertinent variables of the calling window. */
80static void
81remember_calling_window (WINDOW *window)
82{
/* 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;
  }
93}

95/* Restore the caller's window so that it shows the node that it was showing
 on entry to info_read_xxx_echo_area (). */
97static void
98restore_calling_window (void)
99{
register WINDOW *win, *compwin = (WINDOW *)NULL((void *)0);

/* 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((void *)0);
        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. */
147#if defined (UNNECESSARY)
        echo_area_completions_window = (WINDOW *)NULL((void *)0);
149#endif /* UNNECESSARY */

        if (next)
          {
            display_scroll_display (start, end, amount);
            next->pagetop = pagetop;
            display_update_display (windows);
          }
      }
  }
159}

161/* Set up a new input line with PROMPT. */
162static void
163initialize_input_line (char *prompt)
164{
input_line_prompt = prompt;
if (prompt)
5
←
Assuming 'prompt' is null→
6
←
Taking false branch→
  strcpy (input_line, prompt);
else
  input_line[0] = '\0';

input_line_beg = input_line_end = input_line_point = strlen (prompt);
7
←
Null pointer passed as 1st argument to string length function
172}

174static char *
175echo_area_after_read (void)
176{
char *return_value;

if (info_aborted_echo_area)
  {
    info_aborted_echo_area = 0;
    return_value = (char *)NULL((void *)0);
  }
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);
197}

199/* 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. */
203char *
204info_read_in_echo_area (WINDOW *window, char *prompt)
205{
char *line;

/* If the echo area is already active, remember the current state. */
if (echo_area_is_active)
1
Assuming 'echo_area_is_active' is 0→
2
←
Taking false branch→
  push_echo_area ();

/* Initialize our local variables. */
initialize_input_line (prompt);
3
←
Passing value via 1st parameter 'prompt'→
4
←
Calling 'initialize_input_line'→

/* 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(&__sF[1]));

/* 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);
246}

248/* (re) Initialize the echo area node. */
249static void
250echo_area_initialize_node (void)
251{
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';
260}

262/* 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. */
265void
266echo_area_prep_read (void)
267{
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);
275}

277
278/* **************************************************************** */
279/*                                                                  */
280/*                   Echo Area Movement Commands                    */
281/*                                                                  */
282/* **************************************************************** */

284DECLARE_INFO_COMMAND (ea_forward, _("Move forward a character"))void ea_forward (WINDOW *window, int count, unsigned char key
)
285{
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;
  }
294}

296DECLARE_INFO_COMMAND (ea_backward, _("Move backward a character"))void ea_backward (WINDOW *window, int count, unsigned char key
)
297{
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;
  }
306}

308DECLARE_INFO_COMMAND (ea_beg_of_line, _("Move to the start of this line"))void ea_beg_of_line (WINDOW *window, int count, unsigned char
 key)
309{
input_line_point = input_line_beg;
311}

313DECLARE_INFO_COMMAND (ea_end_of_line, _("Move to the end of this line"))void ea_end_of_line (WINDOW *window, int count, unsigned char
 key)
314{
input_line_point = input_line_end;
316}

318#define alphabetic(c)(islower (c) || isupper (c) || isdigit (c)) (islower (c) || isupper (c) || isdigit (c))

320/* Move forward a word in the input line. */
321DECLARE_INFO_COMMAND (ea_forward_word, _("Move forward a word"))void ea_forward_word (WINDOW *window, int count, unsigned char
 key)
322{
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)(islower (c) || isupper (c) || isdigit (c)))
          {
            while (++input_line_point < input_line_end)
              {
                c = input_line[input_line_point];
                if (alphabetic (c)(islower (c) || isupper (c) || isdigit (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)(islower (c) || isupper (c) || isdigit (c)))
              break;
          }
      }
  }
359}

361DECLARE_INFO_COMMAND (ea_backward_word, _("Move backward a word"))void ea_backward_word (WINDOW *window, int count, unsigned char
 key)
362{
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)(islower (c) || isupper (c) || isdigit (c)))
          {
            while ((--input_line_point) != input_line_beg)
              {
                c = input_line[input_line_point - 1];
                if (alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
                  break;
              }
          }

        while (input_line_point != input_line_beg)
          {
            c = input_line[input_line_point - 1];
            if (!alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
              break;
            else
              --input_line_point;
          }
      }
  }
399}

401DECLARE_INFO_COMMAND (ea_delete, _("Delete the character under the cursor"))void ea_delete (WINDOW *window, int count, unsigned char key)
402{
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--;
      }
  }
429}

431DECLARE_INFO_COMMAND (ea_rubout, _("Delete the character behind the cursor"))void ea_rubout (WINDOW *window, int count, unsigned char key)
432{
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);
  }
450}

452DECLARE_INFO_COMMAND (ea_abort, _("Cancel or quit operation"))void ea_abort (WINDOW *window, int count, unsigned char key)
453{
/* 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;
465}

467DECLARE_INFO_COMMAND (ea_newline, _("Accept (or force completion of) this line"))void ea_newline (WINDOW *window, int count, unsigned char key
)
468{
/* Stub does nothing.  Simply here to see if it has been executed. */
470}

472DECLARE_INFO_COMMAND (ea_quoted_insert, _("Insert next character verbatim"))void ea_quoted_insert (WINDOW *window, int count, unsigned char
 key)
473{
unsigned char character;

character = info_get_another_input_char ();
ea_insert (window, count, character);
478}

480DECLARE_INFO_COMMAND (ea_insert, _("Insert this character"))void ea_insert (WINDOW *window, int count, unsigned char key)
481{
register int i;

if ((input_line_end + 1) == EA_MAX_INPUT256)
  {
    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++;
496}

498DECLARE_INFO_COMMAND (ea_tab_insert, _("Insert a TAB character"))void ea_tab_insert (WINDOW *window, int count, unsigned char key
)
499{
ea_insert (window, count, '\t');
501}

503/* Transpose the characters at point.  If point is at the end of the line,
 then transpose the characters before point. */
505DECLARE_INFO_COMMAND (ea_transpose_chars, _("Transpose characters at point"))void ea_transpose_chars (WINDOW *window, int count, unsigned char
 key)
506{
/* 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--;
  }
540}
541
542/* **************************************************************** */
543/*                                                                  */
544/*                   Echo Area Killing and Yanking                  */
545/*                                                                  */
546/* **************************************************************** */

548static char **kill_ring = (char **)NULL((void *)0);
549static int kill_ring_index = 0; /* Number of kills appearing in KILL_RING. */
550static int kill_ring_slots = 0; /* Number of slots allocated to KILL_RING. */
551static int kill_ring_loc = 0;   /* Location of current yank pointer. */

553/* The largest number of kills that we remember at one time. */
554static int max_retained_kills = 15;

556DECLARE_INFO_COMMAND (ea_yank, _("Yank back the contents of the last kill"))void ea_yank (WINDOW *window, int count, unsigned char key)
557{
register int i;
register char *text;

if (!kill_ring_index)
  {
    inform_in_echo_area ((char *) _("Kill ring is empty")((const char *) ("Kill ring is empty")));
    return;
  }

text = kill_ring[kill_ring_loc];

for (i = 0; text[i]; i++)
  ea_insert (window, 1, text[i]);
571}

573/* 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. */
576DECLARE_INFO_COMMAND (ea_yank_pop, _("Yank back a previous kill"))void ea_yank_pop (WINDOW *window, int count, unsigned char key
)
577{
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);
606}

608/* Delete the text from point to end of line. */
609DECLARE_INFO_COMMAND (ea_kill_line, _("Kill to the end of the line"))void ea_kill_line (WINDOW *window, int count, unsigned char key
)
610{
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);
618}

620/* Delete the text from point to beg of line. */
621DECLARE_INFO_COMMAND (ea_backward_kill_line,void ea_backward_kill_line (WINDOW *window, int count, unsigned
 char key)
                    _("Kill to the beginning of the line"))void ea_backward_kill_line (WINDOW *window, int count, unsigned
 char key)
623{
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;
  }
631}

633/* Delete from point to the end of the current word. */
634DECLARE_INFO_COMMAND (ea_kill_word, _("Kill the word following the cursor"))void ea_kill_word (WINDOW *window, int count, unsigned char key
)
635{
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;
  }
649}

651/* Delete from point to the start of the current word. */
652DECLARE_INFO_COMMAND (ea_backward_kill_word,void ea_backward_kill_word (WINDOW *window, int count, unsigned
 char key)
                    _("Kill the word preceding the cursor"))void ea_backward_kill_word (WINDOW *window, int count, unsigned
 char key)
654{
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);
  }
666}

668/* 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. */
673static void
674ea_kill_text (int from, int to)
675{
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++;
757}
758
759/* **************************************************************** */
760/*                                                                  */
761/*                      Echo Area Completion                        */
762/*                                                                  */
763/* **************************************************************** */

765/* Pointer to an array of REFERENCE to complete over. */
766static REFERENCE **echo_area_completion_items = (REFERENCE **)NULL((void *)0);

768/* 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. */
771static REFERENCE **completions_found = (REFERENCE **)NULL((void *)0);
772static int completions_found_index = 0;
773static int completions_found_slots = 0;

775/* The lowest common denominator found while completing. */
776static REFERENCE *LCD_completion;

778/* Internal functions used by the user calls. */
779static void build_completions (void), completions_must_be_rebuilt (void);

781/* Variable which holds the output of completions. */
782static NODE *possible_completions_output_node = (NODE *)NULL((void *)0);

784static char *compwin_name = "*Completions*";

786/* Return non-zero if WINDOW is a window used for completions output. */
787static int
788completions_window_p (WINDOW *window)
789{
int result = 0;

if (internal_info_node_p (window->node) &&
    (strcmp (window->node->nodename, compwin_name) == 0))
  result = 1;

return (result);
797}

799/* Workhorse for completion readers.  If FORCE is non-zero, the user cannot
 exit unless the line read completes, or is empty. */
801char *
802info_read_completing_internal (WINDOW *window, char *prompt,
  REFERENCE **completions, int force)
804{
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")((const char *) ("No completions")));
            else
              inform_in_echo_area ((char *) _("Not complete")((const 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(&__sF[1]));

echo_area_completion_items = (REFERENCE **)NULL((void *)0);
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);
892}

894/* Read a line in the echo area with completion over COMPLETIONS. */
895char *
896info_read_completing_in_echo_area (WINDOW *window,
  char *prompt, REFERENCE **completions)
898{
return (info_read_completing_internal (window, prompt, completions, 1));
900}

902/* Read a line in the echo area allowing completion over COMPLETIONS, but
 not requiring it. */
904char *
905info_read_maybe_completing (WINDOW *window,
  char *prompt, REFERENCE **completions)
907{
return (info_read_completing_internal (window, prompt, completions, 0));
909}

911DECLARE_INFO_COMMAND (ea_possible_completions, _("List possible completions"))void ea_possible_completions (WINDOW *window, int count, unsigned
 char key)
912{
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")((const char *) ("No completions")));
  }
else if ((completions_found_index == 1) && (key != '?'))
  {
    inform_in_echo_area ((char *) _("Sole completion")((const 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")((const char *) ("One completion:\n"))
                              : (char *) _("%d completions:\n")((const char *) ("%d completions:\n")),
		(void *) (long) completions_found_index,
		NULL((void *)0), NULL((void *)0));

    /* 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((void *)0), NULL((void *)0));

                if (j + 1 < limit)
                  {
                    for (k = 0; k < max_label - printed_length; k++)
                      printf_to_message_buffer (" ", NULL((void *)0), NULL((void *)0), NULL((void *)0));
                  }
              }
            l += iterations;
          }
        printf_to_message_buffer ("\n", NULL((void *)0), NULL((void *)0), NULL((void *)0));
      }

    /* 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(2 + 1))
            {
              int start, pagetop;
1028#ifdef SPLIT_BEFORE_ACTIVE
              int end;
1030#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);

1047#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);
                }
1056#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);
                }
1064#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);
    }
  }
1083}

1085DECLARE_INFO_COMMAND (ea_complete, _("Insert completion"))void ea_complete (WINDOW *window, int count, unsigned char key
)
1086{
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]);
  }
1146}

1148/* Utility REFERENCE used to store possible LCD. */
1149static REFERENCE LCD_reference = {
  (char *)NULL((void *)0), (char *)NULL((void *)0), (char *)NULL((void *)0), 0, 0, 0
1151};

1153static void remove_completion_duplicates (void);

1155/* Variables which remember the state of the most recent call
 to build_completions (). */
1157static char *last_completion_request = (char *)NULL((void *)0);
1158static REFERENCE **last_completion_items = (REFERENCE **)NULL((void *)0);

1160/* How to tell the completion builder to reset internal state. */
1161static void
1162completions_must_be_rebuilt (void)
1163{
maybe_free (last_completion_request)do { if (last_completion_request) free (last_completion_request
); } while (0);
last_completion_request = (char *)NULL((void *)0);
last_completion_items = (REFERENCE **)NULL((void *)0);
1167}

1169/* Build a list of possible completions from echo_area_completion_items,
 and the contents of input_line. */
1171static void
1172build_completions (void)
1173{
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((void *)0);
    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)do { if (last_completion_request) free (last_completion_request
); } while (0);
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((void *)0);

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,do { if (completions_found_index + 2 >= completions_found_slots
) completions_found = (REFERENCE * *)(xrealloc (completions_found
, (completions_found_slots += 20) * sizeof (REFERENCE *))); completions_found
[completions_found_index++] = (REFERENCE *)entry; completions_found
[completions_found_index] = (REFERENCE *)((void *)0); } while
 (0)
                            completions_found, completions_found_slots,do { if (completions_found_index + 2 >= completions_found_slots
) completions_found = (REFERENCE * *)(xrealloc (completions_found
, (completions_found_slots += 20) * sizeof (REFERENCE *))); completions_found
[completions_found_index++] = (REFERENCE *)entry; completions_found
[completions_found_index] = (REFERENCE *)((void *)0); } while
 (0)
                            20, REFERENCE *)do { if (completions_found_index + 2 >= completions_found_slots
) completions_found = (REFERENCE * *)(xrealloc (completions_found
, (completions_found_slots += 20) * sizeof (REFERENCE *))); completions_found
[completions_found_index++] = (REFERENCE *)entry; completions_found
[completions_found_index] = (REFERENCE *)((void *)0); } while
 (0);

    if (!informed_of_lengthy_job && completions_found_index > 100)
      {
        informed_of_lengthy_job = 1;
        window_message_in_echo_area ((char *) _("Building completions...")((const char *) ("Building completions...")),
            NULL((void *)0), NULL((void *)0));
      }
  }

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])(isupper (completions_found[i - 1]->label[j]) ? tolower (completions_found
[i - 1]->label[j]) : completions_found[i - 1]->label[j]
)) &&
           (c2 = info_tolower (completions_found[i]->label[j])(isupper (completions_found[i]->label[j]) ? tolower (completions_found
[i]->label[j]) : completions_found[i]->label[j]));
           j++)
        if (c1 != c2)
          break;

      if (shortest > j)
        shortest = j;
    }

  maybe_free (LCD_reference.label)do { if (LCD_reference.label) free (LCD_reference.label); } while
 (0);
  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 ();
1286}

1288/* Function called by qsort. */
1289static int
1290compare_references (const void *entry1, const void *entry2)
1291{
REFERENCE **e1 = (REFERENCE **) entry1;
REFERENCE **e2 = (REFERENCE **) entry2;

return (strcasecmp ((*e1)->label, (*e2)->label));
1296}

1298/* Prune duplicate entries from COMPLETIONS_FOUND. */
1299static void
1300remove_completion_duplicates (void)
1301{
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((void *)0);
    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((void *)0);
completions_found_index = newlen;
free (temp);
1335}

1337/* 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. */
1340DECLARE_INFO_COMMAND (ea_scroll_completions_window, _("Scroll the completions window"))void ea_scroll_completions_window (WINDOW *window, int count,
 unsigned char key)
1341{
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);
1355}

1357/* 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. */
1359void
1360echo_area_inform_of_deleted_window (WINDOW *window)
1361{
/* 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((void *)0);
1375}
1376
1377/* **************************************************************** */
1378/*                                                                  */
1379/*                 Pushing and Popping the Echo Area                */
1380/*                                                                  */
1381/* **************************************************************** */

1383/* Push and Pop the echo area. */
1384typedef struct {
char *line;
char *prompt;
REFERENCE **comp_items;
int point, beg, end;
int must_complete;
NODE node;
WINDOW *compwin;
1392} PUSHED_EA;

1394static PUSHED_EA **pushed_echo_areas = (PUSHED_EA **)NULL((void *)0);
1395static int pushed_echo_areas_index = 0;
1396static int pushed_echo_areas_slots = 0;

1398/* Pushing the echo_area has a side effect of zeroing the completion_items. */
1399static void
1400push_echo_area (void)
1401{
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,do { if (pushed_echo_areas_index + 2 >= pushed_echo_areas_slots
) pushed_echo_areas = (PUSHED_EA * *)(xrealloc (pushed_echo_areas
, (pushed_echo_areas_slots += 4) * sizeof (PUSHED_EA *))); pushed_echo_areas
[pushed_echo_areas_index++] = (PUSHED_EA *)pushed; pushed_echo_areas
[pushed_echo_areas_index] = (PUSHED_EA *)((void *)0); } while
 (0)
                      pushed_echo_areas_slots, 4, PUSHED_EA *)do { if (pushed_echo_areas_index + 2 >= pushed_echo_areas_slots
) pushed_echo_areas = (PUSHED_EA * *)(xrealloc (pushed_echo_areas
, (pushed_echo_areas_slots += 4) * sizeof (PUSHED_EA *))); pushed_echo_areas
[pushed_echo_areas_index++] = (PUSHED_EA *)pushed; pushed_echo_areas
[pushed_echo_areas_index] = (PUSHED_EA *)((void *)0); } while
 (0);

echo_area_completion_items = (REFERENCE **)NULL((void *)0);
1419}

1421static void
1422pop_echo_area (void)
1423{
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((void *)0);
  }

free (popped);
1455}

1457/* Returns non-zero if any of the prior stacked calls to read in the echo
 area produced a completions window. */
1459static int
1460echo_area_stack_contains_completions_p (void)
1461{
register int i;

for (i = 0; i < pushed_echo_areas_index; i++)
  if (pushed_echo_areas[i]->compwin)
    return (1);

return (0);
1469}
1470
1471/* **************************************************************** */
1472/*                                                                  */
1473/*             Error Messages While Reading in Echo Area            */
1474/*                                                                  */
1475/* **************************************************************** */

1477#if defined (HAVE_SYS_TIME_H1)
1478#  include <sys/time.h>
1479#  define HAVE_STRUCT_TIMEVAL
1480#endif /* HAVE_SYS_TIME_H */

1482static void
1483pause_or_input (void)
1484{
1485#ifdef FD_SET
struct timeval timer;
fd_set readfds;
int ready;

FD_ZERO (&readfds)do { fd_set *_p = (&readfds); __size_t _n = (((1024) + ((
((unsigned)(sizeof(__fd_mask) * 8))) - 1)) / (((unsigned)(sizeof
(__fd_mask) * 8)))); while (_n > 0) _p->fds_bits[--_n] =
 0; } while (0);
FD_SET (fileno (stdin), &readfds)__fd_set(((!__isthreaded ? (((&__sF[0]))->_file) : (fileno
)((&__sF[0])))), (&readfds));
timer.tv_sec = 2;
timer.tv_usec = 0;
ready = select (fileno (stdin)(!__isthreaded ? (((&__sF[0]))->_file) : (fileno)((&
__sF[0]))) + 1, &readfds, (fd_set *) NULL((void *)0),
                (fd_set *) NULL((void *)0), &timer);
1496#endif /* FD_SET */
1497}

1499/* 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. */
1502void
1503inform_in_echo_area (const char *message)
1504{
int i;
char *text;
int avail = EA_MAX_INPUT256 + 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(&__sF[1]));
pause_or_input ();
echo_area_initialize_node ();
1524}