/usr/src/gnu/usr.bin/texinfo/info/session.c

Bug Summary

File:	src/gnu/usr.bin/texinfo/info/session.c
Warning:	line 2673, column 11 Branch condition evaluates to a garbage value
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 session.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/session.c
1/* session.c -- user windowing interface to Info.
 $Id: session.c,v 1.6 2006/07/17 16:12:36 espie Exp $

 Copyright (C) 1993, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 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.

 Originally written by Brian Fox (bfox@ai.mit.edu). */

23#include "info.h"
24#include "search.h"
25#include <sys/ioctl.h>

27#if defined (HAVE_SYS_TIME_H1)
28#  include <sys/time.h>
29#  define HAVE_STRUCT_TIMEVAL
30#endif /* HAVE_SYS_TIME_H */

32#if defined (HANDLE_MAN_PAGES)
33#  include "man.h"
34#endif

36static void info_clear_pending_input (void);
37static void info_set_pending_input (unsigned char key);
38static void info_handle_pointer (char *label, WINDOW *window);
39static void display_info_keyseq (int expecting_future_input);
40char *node_printed_rep (NODE *node);

42/* **************************************************************** */
43/*                                                                  */
44/*                   Running an Info Session                        */
45/*                                                                  */
46/* **************************************************************** */

48/* The place that we are reading input from. */
49static FILE *info_input_stream = NULL((void *)0);

51/* The last executed command. */
52VFunction *info_last_executed_command = NULL((void *)0);

54/* Becomes non-zero when 'q' is typed to an Info window. */
55int quit_info_immediately = 0;

57/* Array of structures describing for each window which nodes have been
 visited in that window. */
59INFO_WINDOW **info_windows = NULL((void *)0);

61/* Where to add the next window, if we need to add one. */
62static int info_windows_index = 0;

64/* Number of slots allocated to `info_windows'. */
65static int info_windows_slots = 0;

67void remember_window_and_node (WINDOW *window, NODE *node);
68void forget_window_and_nodes (WINDOW *window);
69void display_startup_message_and_start (void);

71/* Begin an info session finding the nodes specified by FILENAME and NODENAMES.
 For each loaded node, create a new window.  Always split the largest of the
 available windows. */
74void
75begin_multiple_window_info_session (char *filename, char **nodenames)
76{
register int i;
WINDOW *window = (WINDOW *)NULL((void *)0);

for (i = 0; nodenames[i]; i++)
  {
    NODE *node;

    node = info_get_node (filename, nodenames[i]);

    if (!node)
      break;

    /* If this is the first node, initialize the info session. */
    if (!window)
      {
        initialize_info_session (node, 1);
        window = active_window;
      }
    else
      {
        /* Find the largest window in WINDOWS, and make that be the active
           one.  Then split it and add our window and node to the list
           of remembered windows and nodes.  Then tile the windows. */
        WINDOW *win, *largest = NULL((void *)0);
        int max_height = 0;

        for (win = windows; win; win = win->next)
          if (win->height > max_height)
            {
              max_height = win->height;
              largest = win;
            }

        if (!largest)
          {
            display_update_display (windows);
            info_error ((char *) msg_cant_find_window, NULL((void *)0), NULL((void *)0));
            info_session ();
            xexit (0);
          }

        active_window = largest;
        window = window_make_window (node);
        if (window)
          {
            window_tile_windows (TILE_INTERNALS1);
            remember_window_and_node (window, node);
          }
        else
          {
            display_update_display (windows);
            info_error ((char *) msg_win_too_small, NULL((void *)0), NULL((void *)0));
            info_session ();
            xexit (0);
          }
      }
  }
display_startup_message_and_start ();
135}

137/* Start an info session with INITIAL_NODE, and an error message in the echo
 area made from FORMAT and ARG. */
139void
140begin_info_session_with_error (NODE *initial_node, char *format,
  void *arg1, void *arg2)
142{
initialize_info_session (initial_node, 1);
info_error (format, arg1, arg2);
info_session ();
146}

148/* Start an info session with INITIAL_NODE. */
149void
150begin_info_session (NODE *initial_node)
151{
initialize_info_session (initial_node, 1);
display_startup_message_and_start ();
154}

156void
157display_startup_message_and_start (void)
158{
char *format;

format = replace_in_documentation
  ((char *) _("Welcome to Info version %s. Type \\[get-help-window] for help, \\[menu-item] for menu item.")((const char *) ("Welcome to Info version %s. Type \\[get-help-window] for help, \\[menu-item] for menu item."
)),
   0);

window_message_in_echo_area (format, VERSION"4.8", NULL((void *)0));
info_session ();
167}

169/* Run an info session with an already initialized window and node. */
170void
171info_session (void)
172{
display_update_display (windows);
info_last_executed_command = NULL((void *)0);
info_read_and_dispatch ();
/* On program exit, leave the cursor at the bottom of the window, and
   restore the terminal I/O. */
terminal_goto_xy (0, screenheight - 1);
terminal_clear_to_eol ();
fflush (stdout(&__sF[1]));
terminal_unprep_terminal ();
close_dribble_file ();
183}

185/* Here is a window-location dependent event loop.  Called from the
 functions info_session (), and from read_xxx_in_echo_area (). */
187void
188info_read_and_dispatch (void)
189{
unsigned char key;
int done;
done = 0;

while (!done && !quit_info_immediately)
  {
    int lk = 0;

    /* If we haven't just gone up or down a line, there is no
       goal column for this window. */
    if ((info_last_executed_command != (VFunction *) info_next_line) &&
        (info_last_executed_command != (VFunction *) info_prev_line))
      active_window->goal_column = -1;

    if (echo_area_is_active)
      {
        lk = echo_area_last_command_was_kill;
        echo_area_prep_read ();
      }

    if (!info_any_buffered_input_p ())
      display_update_display (windows);

    display_cursor_at_point (active_window);
    info_initialize_numeric_arg ();

    initialize_keyseq ();
    key = info_get_input_char ();

    /* No errors yet.  We just read a character, that's all.  Only clear
       the echo_area if it is not currently active. */
    if (!echo_area_is_active)
      window_clear_echo_area ();

    info_error_was_printed = 0;

    /* Do the selected command. */
    info_dispatch_on_key (key, active_window->keymap);

    if (echo_area_is_active)
      {
        /* Echo area commands that do killing increment the value of
           ECHO_AREA_LAST_COMMAND_WAS_KILL.  Thus, if there is no
           change in the value of this variable, the last command
           executed was not a kill command. */
        if (lk == echo_area_last_command_was_kill)
          echo_area_last_command_was_kill = 0;

        if (ea_last_executed_command == (VFunction *) ea_newline ||
            info_aborted_echo_area)
          {
            ea_last_executed_command = (VFunction *)NULL((void *)0);
            done = 1;
          }

        if (info_last_executed_command == (VFunction *) info_quit)
          quit_info_immediately = 1;
      }
    else if (info_last_executed_command == (VFunction *) info_quit)
      done = 1;
  }
251}

253/* Found in signals.c */
254extern void initialize_info_signal_handler (void );

256/* Initialize the first info session by starting the terminal, window,
 and display systems.  If CLEAR_SCREEN is 0, don't clear the screen.  */
258void
259initialize_info_session (NODE *node, int clear_screen)
260{
char *term_name = getenv ("TERM");
terminal_initialize_terminal (term_name);

if (terminal_is_dumb_p)
  {
    if (!term_name)
      term_name = "dumb";

    info_error ((char *) msg_term_too_dumb, term_name, NULL((void *)0));
    xexit (1);
  }

if (clear_screen)
  {
    terminal_prep_terminal ();
    terminal_clear_screen ();
  }

initialize_info_keymaps ();
window_initialize_windows (screenwidth, screenheight);
initialize_info_signal_handler ();
display_initialize_display (screenwidth, screenheight);
info_set_node_of_window (0, active_window, node);

/* Tell the window system how to notify us when a window needs to be
   asynchronously deleted (e.g., user resizes window very small). */
window_deletion_notifier = (VFunction *) forget_window_and_nodes;

/* If input has not been redirected yet, make it come from unbuffered
   standard input. */
if (!info_input_stream)
  {
    setbuf (stdin(&__sF[0]), NULL((void *)0));
    info_input_stream = stdin(&__sF[0]);
  }

info_windows_initialized_p = 1;
298}

300/* Tell Info that input is coming from the file FILENAME. */
301void
302info_set_input_from_file (char *filename)
303{
FILE *stream;

/* Input may include binary characters.  */
stream = fopen (filename, FOPEN_RBIN"r");

if (!stream)
  return;

if ((info_input_stream != (FILE *)NULL((void *)0)) &&
    (info_input_stream != stdin(&__sF[0])))
  fclose (info_input_stream);

info_input_stream = stream;

if (stream != stdin(&__sF[0]))
  display_inhibited = 1;
320}

322/* Return the INFO_WINDOW containing WINDOW, or NULL if there isn't one. */
323static INFO_WINDOW *
324get_info_window_of_window (WINDOW *window)
325{
register int i;
INFO_WINDOW *info_win = (INFO_WINDOW *)NULL((void *)0);

for (i = 0; info_windows && (info_win = info_windows[i]); i++)
  if (info_win->window == window)
    break;

return (info_win);
334}

336/* Reset the remembered pagetop and point of WINDOW to WINDOW's current
 values if the window and node are the same as the current one being
 displayed. */
339void
340set_remembered_pagetop_and_point (WINDOW *window)
341{
INFO_WINDOW *info_win;

info_win = get_info_window_of_window (window);

if (!info_win)
  return;

if (info_win->nodes_index &&
    (info_win->nodes[info_win->current] == window->node))
  {
    info_win->pagetops[info_win->current] = window->pagetop;
    info_win->points[info_win->current] = window->point;
  }
355}

357void
358remember_window_and_node (WINDOW *window, NODE *node)
359{
/* See if we already have this window in our list. */
INFO_WINDOW *info_win = get_info_window_of_window (window);

/* If the window wasn't already on our list, then make a new entry. */
if (!info_win)
  {
    info_win = (INFO_WINDOW *)xmalloc (sizeof (INFO_WINDOW));
    info_win->window = window;
    info_win->nodes = (NODE **)NULL((void *)0);
    info_win->pagetops = (int *)NULL((void *)0);
    info_win->points = (long *)NULL((void *)0);
    info_win->current = 0;
    info_win->nodes_index = 0;
    info_win->nodes_slots = 0;

    add_pointer_to_array (info_win, info_windows_index, info_windows,do { if (info_windows_index + 2 >= info_windows_slots) info_windows
 = (INFO_WINDOW * *)(xrealloc (info_windows, (info_windows_slots
 += 10) * sizeof (INFO_WINDOW *))); info_windows[info_windows_index
++] = (INFO_WINDOW *)info_win; info_windows[info_windows_index
] = (INFO_WINDOW *)((void *)0); } while (0)
                          info_windows_slots, 10, INFO_WINDOW *)do { if (info_windows_index + 2 >= info_windows_slots) info_windows
 = (INFO_WINDOW * *)(xrealloc (info_windows, (info_windows_slots
 += 10) * sizeof (INFO_WINDOW *))); info_windows[info_windows_index
++] = (INFO_WINDOW *)info_win; info_windows[info_windows_index
] = (INFO_WINDOW *)((void *)0); } while (0);
  }

/* If this node, the current pagetop, and the current point are the
   same as the current saved node and pagetop, don't really add this to
   the list of history nodes.  This may happen only at the very
   beginning of the program, I'm not sure.  --karl  */
if (info_win->nodes
    && info_win->current >= 0
    && info_win->nodes[info_win->current]->contents == node->contents
    && info_win->pagetops[info_win->current] == window->pagetop
    && info_win->points[info_win->current] == window->point)
return;

/* Remember this node, the currently displayed pagetop, and the current
   location of point in this window.  Because we are updating pagetops
   and points as well as nodes, it is more efficient to avoid the
   add_pointer_to_array macro here. */
if (info_win->nodes_index + 2 >= info_win->nodes_slots)
  {
    info_win->nodes_slots += 20;
    info_win->nodes = (NODE **) xrealloc (info_win->nodes,
                                    info_win->nodes_slots * sizeof (NODE *));
    info_win->pagetops = (int *) xrealloc (info_win->pagetops,
                                    info_win->nodes_slots * sizeof (int));
    info_win->points = (long *) xrealloc (info_win->points,
                                    info_win->nodes_slots * sizeof (long));
  }

info_win->nodes[info_win->nodes_index] = node;
info_win->pagetops[info_win->nodes_index] = window->pagetop;
info_win->points[info_win->nodes_index] = window->point;
info_win->current = info_win->nodes_index++;
info_win->nodes[info_win->nodes_index] = NULL((void *)0);
info_win->pagetops[info_win->nodes_index] = 0;
info_win->points[info_win->nodes_index] = 0;
412}

414#define DEBUG_FORGET_WINDOW_AND_NODES
415#if defined (DEBUG_FORGET_WINDOW_AND_NODES)
416static void
417consistency_check_info_windows (void)
418{
register int i;

for (i = 0; i < info_windows_index; i++)
  {
    WINDOW *win;

    for (win = windows; win; win = win->next)
      if (win == info_windows[i]->window)
        break;

    if (!win)
      abort ();
  }
432}
433#endif /* DEBUG_FORGET_WINDOW_AND_NODES */

435/* Remove WINDOW and its associated list of nodes from INFO_WINDOWS. */
436void
437forget_window_and_nodes (WINDOW *window)
438{
register int i;
INFO_WINDOW *info_win = (INFO_WINDOW *)NULL((void *)0);

for (i = 0; info_windows && (info_win = info_windows[i]); i++)
  if (info_win->window == window)
    break;

/* If we found the window to forget, then do so. */
if (info_win)
  {
    while (i < info_windows_index)
      {
        info_windows[i] = info_windows[i + 1];
        i++;
      }

    info_windows_index--;
    info_windows[info_windows_index] = (INFO_WINDOW *)NULL((void *)0);

    if (info_win->nodes)
      {
        /* Free the node structures which held onto internal node contents
           here.  This doesn't free the contents; we have a garbage collector
           which does that. */
        for (i = 0; info_win->nodes[i]; i++)
          if (internal_info_node_p (info_win->nodes[i]))
            free (info_win->nodes[i]);
        free (info_win->nodes);

        maybe_free (info_win->pagetops)do { if (info_win->pagetops) free (info_win->pagetops);
 } while (0);
        maybe_free (info_win->points)do { if (info_win->points) free (info_win->points); } while
 (0);
      }

    free (info_win);
  }
474#if defined (DEBUG_FORGET_WINDOW_AND_NODES)
consistency_check_info_windows ();
476#endif /* DEBUG_FORGET_WINDOW_AND_NODES */
477}

479/* Set WINDOW to show NODE.  Remember the new window in our list of Info
 windows.  If we are doing automatic footnote display, also try to display
 the footnotes for this window.  If REMEMBER is nonzero, first call
 set_remembered_pagetop_and_point.  */
483void
484info_set_node_of_window (int remember, WINDOW *window, NODE *node)
485{
if (remember)
  set_remembered_pagetop_and_point (window);

/* Put this node into the window. */
window_set_node_of_window (window, node);

/* Remember this node and window in our list of info windows. */
remember_window_and_node (window, node);

/* If doing auto-footnote display/undisplay, show the footnotes belonging
   to this window's node. */
if (auto_footnotes_p)
  info_get_or_remove_footnotes (window);
499}

501
502/* **************************************************************** */
503/*                                                                  */
504/*                     Info Movement Commands                       */
505/*                                                                  */
506/* **************************************************************** */

508/* Change the pagetop of WINDOW to DESIRED_TOP, perhaps scrolling the screen
 to do so. */
510void
511set_window_pagetop (WINDOW *window, int desired_top)
512{
int point_line, old_pagetop;

if (desired_top < 0)
  desired_top = 0;
else if (desired_top > window->line_count)
  desired_top = window->line_count - 1;

if (window->pagetop == desired_top)
  return;

old_pagetop = window->pagetop;
window->pagetop = desired_top;

/* Make sure that point appears in this window. */
point_line = window_line_of_point (window);
if ((point_line < window->pagetop) ||
    ((point_line - window->pagetop) > window->height - 1))
  window->point =
    window->line_starts[window->pagetop] - window->node->contents;

window->flags |= W_UpdateWindow0x01;

/* Find out which direction to scroll, and scroll the window in that
   direction.  Do this only if there would be a savings in redisplay
   time.  This is true if the amount to scroll is less than the height
   of the window, and if the number of lines scrolled would be greater
   than 10 % of the window's height. */
if (old_pagetop < desired_top)
  {
    int start, end, amount;

    amount = desired_top - old_pagetop;

    if ((amount >= window->height) ||
        (((window->height - amount) * 10) < window->height))
      return;

    start = amount + window->first_row;
    end = window->height + window->first_row;

    display_scroll_display (start, end, -amount);
  }
else
  {
    int start, end, amount;

    amount = old_pagetop - desired_top;

    if ((amount >= window->height) ||
        (((window->height - amount) * 10) < window->height))
      return;

    start = window->first_row;
    end = (window->first_row + window->height) - amount;
    display_scroll_display (start, end, amount);
  }
569}

571/* Immediately make WINDOW->point visible on the screen, and move the
 terminal cursor there. */
573static void
574info_show_point (WINDOW *window)
575{
int old_pagetop;

old_pagetop = window->pagetop;
window_adjust_pagetop (window);
if (old_pagetop != window->pagetop)
  {
    int new_pagetop;

    new_pagetop = window->pagetop;
    window->pagetop = old_pagetop;
    set_window_pagetop (window, new_pagetop);
  }

if (window->flags & W_UpdateWindow0x01)
  display_update_one_window (window);

display_cursor_at_point (window);
593}

595/* Move WINDOW->point from OLD line index to NEW line index. */
596static void
597move_to_new_line (int old, int new, WINDOW *window)
598{
if (old == -1)
  {
    info_error ((char *) msg_cant_find_point, NULL((void *)0), NULL((void *)0));
  }
else
  {
    int goal;

    if (new >= window->line_count || new < 0)
      return;

    goal = window_get_goal_column (window);
    window->goal_column = goal;

    window->point = window->line_starts[new] - window->node->contents;
    window->point += window_chars_to_goal (window->line_starts[new], goal);
    info_show_point (window);
  }
617}

619/* Move WINDOW's point down to the next line if possible. */
620DECLARE_INFO_COMMAND (info_next_line, _("Move down to the next line"))void info_next_line (WINDOW *window, int count, unsigned char
 key)
621{
int old_line, new_line;

if (count < 0)
  info_prev_line (window, -count, key);
else
  {
    old_line = window_line_of_point (window);
    new_line = old_line + count;
    move_to_new_line (old_line, new_line, window);
  }
632}

634/* Move WINDOW's point up to the previous line if possible. */
635DECLARE_INFO_COMMAND (info_prev_line, _("Move up to the previous line"))void info_prev_line (WINDOW *window, int count, unsigned char
 key)
636{
int old_line, new_line;

if (count < 0)
  info_next_line (window, -count, key);
else
  {
    old_line = window_line_of_point (window);
    new_line = old_line - count;
    move_to_new_line (old_line, new_line, window);
  }
647}

649/* Move WINDOW's point to the end of the true line. */
650DECLARE_INFO_COMMAND (info_end_of_line, _("Move to the end of the line"))void info_end_of_line (WINDOW *window, int count, unsigned char
 key)
651{
register int point, len;
register char *buffer;

buffer = window->node->contents;
len = window->node->nodelen;

for (point = window->point;
     (point < len) && (buffer[point] != '\n');
     point++);

if (point != window->point)
  {
    window->point = point;
    info_show_point (window);
  }
667}

669/* Move WINDOW's point to the beginning of the true line. */
670DECLARE_INFO_COMMAND (info_beginning_of_line, _("Move to the start of the line"))void info_beginning_of_line (WINDOW *window, int count, unsigned
 char key)
671{
register int point;
register char *buffer;

buffer = window->node->contents;
point = window->point;

for (; (point) && (buffer[point - 1] != '\n'); point--);

/* If at a line start already, do nothing. */
if (point != window->point)
  {
    window->point = point;
    info_show_point (window);
  }
686}

688/* Move point forward in the node. */
689DECLARE_INFO_COMMAND (info_forward_char, _("Move forward a character"))void info_forward_char (WINDOW *window, int count, unsigned char
 key)
690{
if (count < 0)
  info_backward_char (window, -count, key);
else
  {
    window->point += count;

    if (window->point >= window->node->nodelen)
      window->point = window->node->nodelen - 1;

    info_show_point (window);
  }
702}

704/* Move point backward in the node. */
705DECLARE_INFO_COMMAND (info_backward_char, _("Move backward a character"))void info_backward_char (WINDOW *window, int count, unsigned char
 key)
706{
if (count < 0)
  info_forward_char (window, -count, key);
else
  {
    window->point -= count;

    if (window->point < 0)
      window->point = 0;

    info_show_point (window);
  }
718}

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

722/* Move forward a word in this node. */
723DECLARE_INFO_COMMAND (info_forward_word, _("Move forward a word"))void info_forward_word (WINDOW *window, int count, unsigned char
 key)
724{
long point;
char *buffer;
int end, c;

if (count < 0)
  {
    info_backward_word (window, -count, key);
    return;
  }

point = window->point;
buffer = window->node->contents;
end = window->node->nodelen;

while (count)
  {
    if (point + 1 >= 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 = buffer[point];

    if (!alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
      {
        while (++point < end)
          {
            c = buffer[point];
            if (alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
              break;
          }
      }

    if (point >= end) return;

    while (++point < end)
      {
        c = buffer[point];
        if (!alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
          break;
      }
    --count;
  }
window->point = point;
info_show_point (window);
770}

772DECLARE_INFO_COMMAND (info_backward_word, _("Move backward a word"))void info_backward_word (WINDOW *window, int count, unsigned char
 key)
773{
long point;
char *buffer;
int c;

if (count < 0)
  {
    info_forward_word (window, -count, key);
    return;
  }

buffer = window->node->contents;
point = window->point;

while (count)
  {
    if (point == 0)
      break;

    /* Like info_forward_word (), except that we look at the
       characters just before point. */

    c = buffer[point - 1];

    if (!alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
      {
        while (--point)
          {
            c = buffer[point - 1];
            if (alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
              break;
          }
      }

    while (point)
      {
        c = buffer[point - 1];
        if (!alphabetic (c)(islower (c) || isupper (c) || isdigit (c)))
          break;
        else
          --point;
      }
    --count;
  }
window->point = point;
info_show_point (window);
819}

821/* Variable controlling the behaviour of default scrolling when you are
 already at the bottom of a node.  Possible values are defined in session.h.
 The meanings are:

 IS_Continuous        Try to get first menu item, or failing that, the
                      "Next:" pointer, or failing that, the "Up:" and
                      "Next:" of the up.
 IS_NextOnly          Try to get "Next:" menu item.
 IS_PageOnly          Simply give up at the bottom of a node. */

831int info_scroll_behaviour = IS_Continuous0;

833/* Choices used by the completer when reading a value for the user-visible
 variable "scroll-behaviour". */
835char *info_scroll_choices[] = {
"Continuous", "Next Only", "Page Only", (char *)NULL((void *)0)
837};

839/* Default window sizes for scrolling commands.  */
840int default_window_size = -1;	/* meaning 1 window-full */
841int default_scroll_size = -1;	/* meaning half screen size */

843#define INFO_LABEL_FOUND()(info_parsed_nodename || (info_parsed_filename && !is_dir_name
 (info_parsed_filename))) \
(info_parsed_nodename || (info_parsed_filename \
                          && !is_dir_name (info_parsed_filename)))

847/* Move to 1st menu item, Next, Up/Next, or error in this window. */
848static void
849forward_move_node_structure (WINDOW *window, int behaviour)
850{
switch (behaviour)
  {
  case IS_PageOnly2:
    info_error ((char *) msg_at_node_bottom, NULL((void *)0), NULL((void *)0));
    break;

  case IS_NextOnly1:
    info_next_label_of_node (window->node)info_parse_label ("Next:", window->node);
    if (!info_parsed_nodename && !info_parsed_filename)
      info_error ((char *) msg_no_pointer, (char *) _("Next")((const char *) ("Next")), NULL((void *)0));
    else
      {
        window_message_in_echo_area ((char *) _("Following Next node...")((const char *) ("Following Next node...")),
            NULL((void *)0), NULL((void *)0));
        info_handle_pointer ("Next", window);
      }
    break;

  case IS_Continuous0:
    {
      /* First things first.  If this node contains a menu, move down
         into the menu. */
      {
        REFERENCE **menu;

        menu = info_menu_of_node (window->node);

        if (menu)
          {
            info_free_references (menu);
            window_message_in_echo_area ((char *) _("Selecting first menu item...")((const char *) ("Selecting first menu item...")),
                NULL((void *)0), NULL((void *)0));
            info_menu_digit (window, 1, '1');
            return;
          }
      }

      /* Okay, this node does not contain a menu.  If it contains a
         "Next:" pointer, use that. */
      info_next_label_of_node (window->node)info_parse_label ("Next:", window->node);
      if (INFO_LABEL_FOUND ()(info_parsed_nodename || (info_parsed_filename && !is_dir_name
 (info_parsed_filename))))
        {
          window_message_in_echo_area ((char *) _("Selecting Next node...")((const char *) ("Selecting Next node...")),
              NULL((void *)0), NULL((void *)0));
          info_handle_pointer ("Next", window);
          return;
        }

      /* Okay, there wasn't a "Next:" for this node.  Move "Up:" until we
         can move "Next:".  If that isn't possible, complain that there
         are no more nodes. */
      {
        int up_counter, old_current;
        INFO_WINDOW *info_win;

        /* Remember the current node and location. */
        info_win = get_info_window_of_window (window);
        old_current = info_win->current;

        /* Back up through the "Up:" pointers until we have found a "Next:"
           that isn't the same as the first menu item found in that node. */
        up_counter = 0;
        while (!info_error_was_printed)
          {
            info_up_label_of_node (window->node)info_parse_label ("Up:", window->node);
            if (INFO_LABEL_FOUND ()(info_parsed_nodename || (info_parsed_filename && !is_dir_name
 (info_parsed_filename))))
              {
                info_handle_pointer ("Up", window);
                if (info_error_was_printed)
                  continue;

                up_counter++;

                info_next_label_of_node (window->node)info_parse_label ("Next:", window->node);

                /* If no "Next" pointer, keep backing up. */
                if (!INFO_LABEL_FOUND ()(info_parsed_nodename || (info_parsed_filename && !is_dir_name
 (info_parsed_filename))))
                  continue;

                /* If this node's first menu item is the same as this node's
                   Next pointer, keep backing up. */
                if (!info_parsed_filename)
                  {
                    REFERENCE **menu;
                    char *next_nodename;

                    /* Remember the name of the Next node, since reading
                       the menu can overwrite the contents of the
                       info_parsed_xxx strings. */
                    next_nodename = xstrdup (info_parsed_nodename);

                    menu = info_menu_of_node (window->node);
                    if (menu &&
                        (strcmp
                         (menu[0]->nodename, next_nodename) == 0))
                      {
                        info_free_references (menu);
                        free (next_nodename);
                        continue;
                      }
                    else
                      {
                        /* Restore the world to where it was before
                           reading the menu contents. */
                        info_free_references (menu);
                        free (next_nodename);
                        info_next_label_of_node (window->node)info_parse_label ("Next:", window->node);
                      }
                  }

                /* This node has a "Next" pointer, and it is not the
                   same as the first menu item found in this node. */
                window_message_in_echo_area
                  ((char *) _("Moving Up %d time(s), then Next.")((const char *) ("Moving Up %d time(s), then Next.")),
                   (void *) (long) up_counter, NULL((void *)0));

                info_handle_pointer ("Next", window);
                return;
              }
            else
              {
                /* No more "Up" pointers.  Print an error, and call it
                   quits. */
                register int i;

                for (i = 0; i < up_counter; i++)
                  {
                    info_win->nodes_index--;
                    free (info_win->nodes[info_win->nodes_index]);
                    info_win->nodes[info_win->nodes_index] = (NODE *)NULL((void *)0);
                  }
                info_win->current = old_current;
                window->node = info_win->nodes[old_current];
                window->pagetop = info_win->pagetops[old_current];
                window->point = info_win->points[old_current];
                recalculate_line_starts (window);
                window->flags |= W_UpdateWindow0x01;
                info_error ((char *) _("No more nodes within this document.")((const char *) ("No more nodes within this document.")),
                    NULL((void *)0), NULL((void *)0));
              }
          }
      }
      break;
    }
  }
996}

998/* Move Prev, Up or error in WINDOW depending on BEHAVIOUR. */
999static void
1000backward_move_node_structure (WINDOW *window, int behaviour)
1001{
switch (behaviour)
  {
  case IS_PageOnly2:
    info_error ((char *) msg_at_node_top, NULL((void *)0), NULL((void *)0));
    break;

  case IS_NextOnly1:
    info_prev_label_of_node (window->node)do { info_parse_label ("Prev:", window->node); if (!info_parsed_nodename
 && !info_parsed_filename) info_parse_label ("Previous:"
, window->node); } while (0);
    if (!info_parsed_nodename && !info_parsed_filename)
      info_error ((char *) _("No `Prev' for this node.")((const char *) ("No `Prev' for this node.")), NULL((void *)0), NULL((void *)0));
    else
      {
        window_message_in_echo_area ((char *) _("Moving Prev in this window.")((const char *) ("Moving Prev in this window.")),
            NULL((void *)0), NULL((void *)0));
        info_handle_pointer ("Prev", window);
      }
    break;

  case IS_Continuous0:
    info_prev_label_of_node (window->node)do { info_parse_label ("Prev:", window->node); if (!info_parsed_nodename
 && !info_parsed_filename) info_parse_label ("Previous:"
, window->node); } while (0);

    if (!info_parsed_nodename && (!info_parsed_filename
                                  || is_dir_name (info_parsed_filename)))
      {
        info_up_label_of_node (window->node)info_parse_label ("Up:", window->node);
        if (!info_parsed_nodename && (!info_parsed_filename
                                      || is_dir_name (info_parsed_filename)))
          info_error ((char *)
              _("No `Prev' or `Up' for this node within this document.")((const char *) ("No `Prev' or `Up' for this node within this document."
)),
              NULL((void *)0), NULL((void *)0));
        else
          {
            window_message_in_echo_area ((char *) _("Moving Up in this window.")((const char *) ("Moving Up in this window.")),
                NULL((void *)0), NULL((void *)0));
            info_handle_pointer ("Up", window);
          }
      }
    else
      {
        REFERENCE **menu;
        int inhibit_menu_traversing = 0;

        /* Watch out!  If this node's Prev is the same as the Up, then
           move Up.  Otherwise, we could move Prev, and then to the last
           menu item in the Prev.  This would cause the user to loop
           through a subsection of the info file. */
        if (!info_parsed_filename && info_parsed_nodename)
          {
            char *pnode;

            pnode = xstrdup (info_parsed_nodename);
            info_up_label_of_node (window->node)info_parse_label ("Up:", window->node);

            if (!info_parsed_filename && info_parsed_nodename &&
                strcmp (info_parsed_nodename, pnode) == 0)
              {
                /* The nodes are the same.  Inhibit moving to the last
                   menu item. */
                free (pnode);
                inhibit_menu_traversing = 1;
              }
            else
              {
                free (pnode);
                info_prev_label_of_node (window->node)do { info_parse_label ("Prev:", window->node); if (!info_parsed_nodename
 && !info_parsed_filename) info_parse_label ("Previous:"
, window->node); } while (0);
              }
          }

        /* Move to the previous node.  If this node now contains a menu,
           and we have not inhibited movement to it, move to the node
           corresponding to the last menu item. */
        window_message_in_echo_area ((char *) _("Moving Prev in this window.")((const char *) ("Moving Prev in this window.")),
            NULL((void *)0), NULL((void *)0));
        info_handle_pointer ("Prev", window);

        if (!inhibit_menu_traversing)
          {
            while (!info_error_was_printed &&
                   (menu = info_menu_of_node (window->node)))
              {
                info_free_references (menu);
                window_message_in_echo_area
                  ((char *) _("Moving to `Prev's last menu item.")((const char *) ("Moving to `Prev's last menu item.")), NULL((void *)0), NULL((void *)0));
                info_menu_digit (window, 1, '0');
              }
          }
      }
    break;
  }
1091}

1093/* Move continuously forward through the node structure of this info file. */
1094DECLARE_INFO_COMMAND (info_global_next_node,void info_global_next_node (WINDOW *window, int count, unsigned
 char key)
                    _("Move forwards or down through node structure"))void info_global_next_node (WINDOW *window, int count, unsigned
 char key)
1096{
if (count < 0)
  info_global_prev_node (window, -count, key);
else
  {
    while (count && !info_error_was_printed)
      {
        forward_move_node_structure (window, IS_Continuous0);
        count--;
      }
  }
1107}

1109/* Move continuously backward through the node structure of this info file. */
1110DECLARE_INFO_COMMAND (info_global_prev_node,void info_global_prev_node (WINDOW *window, int count, unsigned
 char key)
                    _("Move backwards or up through node structure"))void info_global_prev_node (WINDOW *window, int count, unsigned
 char key)
1112{
if (count < 0)
  info_global_next_node (window, -count, key);
else
  {
    while (count && !info_error_was_printed)
      {
        backward_move_node_structure (window, IS_Continuous0);
        count--;
      }
  }
1123}

1125static void _scroll_forward(WINDOW *window, int count,
  unsigned char key, int behaviour);
1127static void _scroll_backward(WINDOW *window, int count,
  unsigned char key, int behaviour);

1130static void
1131_scroll_forward(WINDOW *window, int count, unsigned char key, int behaviour)
1132{
if (count < 0)
  _scroll_backward (window, -count, key, behaviour);
else
  {
    int desired_top;

    /* Without an explicit numeric argument, scroll the bottom two
       lines to the top of this window,  Or, if at bottom of window,
       and the chosen behaviour is to scroll through nodes get the
"Next" node for this window. */
    if (default_window_size > 0)
      desired_top = window->pagetop + default_window_size;
    else if (!info_explicit_arg && count == 1)
      {
        desired_top = window->pagetop + (window->height - 2);

        /* If there are no more lines to scroll here, error, or get
           another node, depending on BEHAVIOUR. */
        if (desired_top > window->line_count)
          {
            forward_move_node_structure (window, behaviour);
            return;
          }
      }
    else
      desired_top = window->pagetop + count;

    if (desired_top >= window->line_count)
      desired_top = window->line_count - 2;

    if (window->pagetop > desired_top)
      return;
    else
      set_window_pagetop (window, desired_top);
  }
1168}

1170static void
1171_scroll_backward(WINDOW *window, int count, unsigned char key, int behaviour)
1172{
if (count < 0)
  _scroll_forward (window, -count, key, behaviour);
else
  {
    int desired_top;

    /* Without an explicit numeric argument, scroll the top two lines
       to the bottom of this window, or, depending on the selected
behaviour, move to the previous, or Up'th node. */
    if (default_window_size > 0)
      desired_top = window->pagetop - default_window_size;
    else if (!info_explicit_arg && count == 1)
      {
        desired_top = window->pagetop - (window->height - 2);

        if ((desired_top < 0) && (window->pagetop == 0))
          {
            backward_move_node_structure (window, behaviour);
            return;
          }
      }
    else
      desired_top = window->pagetop - count;

    if (desired_top < 0)
      desired_top = 0;

    set_window_pagetop (window, desired_top);
  }
1202}

1204/* Show the next screen of WINDOW's node. */
1205DECLARE_INFO_COMMAND (info_scroll_forward, _("Scroll forward in this window"))void info_scroll_forward (WINDOW *window, int count, unsigned
 char key)
1206{
_scroll_forward (window, count, key, info_scroll_behaviour);
1208}

1210/* Like info_scroll_forward, but sets default_window_size as a side
 effect.  */
1212DECLARE_INFO_COMMAND (info_scroll_forward_set_window,void info_scroll_forward_set_window (WINDOW *window, int count
, unsigned char key)
      _("Scroll forward in this window and set default window size"))void info_scroll_forward_set_window (WINDOW *window, int count
, unsigned char key)
1214{
if (info_explicit_arg)
  default_window_size = count;
_scroll_forward (window, count, key, info_scroll_behaviour);
1218}

1220/* Show the next screen of WINDOW's node but never advance to next node. */
1221DECLARE_INFO_COMMAND (info_scroll_forward_page_only, _("Scroll forward in this window staying within node"))void info_scroll_forward_page_only (WINDOW *window, int count
, unsigned char key)
1222{
_scroll_forward (window, count, key, IS_PageOnly2);
1224}

1226/* Like info_scroll_forward_page_only, but sets default_window_size as a side
 effect.  */
1228DECLARE_INFO_COMMAND (info_scroll_forward_page_only_set_window,void info_scroll_forward_page_only_set_window (WINDOW *window
, int count, unsigned char key)
      _("Scroll forward in this window staying within node and set default window size"))void info_scroll_forward_page_only_set_window (WINDOW *window
, int count, unsigned char key)
1230{
if (info_explicit_arg)
  default_window_size = count;
_scroll_forward (window, count, key, IS_PageOnly2);
1234}

1236/* Show the previous screen of WINDOW's node. */
1237DECLARE_INFO_COMMAND (info_scroll_backward, _("Scroll backward in this window"))void info_scroll_backward (WINDOW *window, int count, unsigned
 char key)
1238{
_scroll_backward (window, count, key, info_scroll_behaviour);
1240}

1242/* Like info_scroll_backward, but sets default_window_size as a side
 effect.  */
1244DECLARE_INFO_COMMAND (info_scroll_backward_set_window,void info_scroll_backward_set_window (WINDOW *window, int count
, unsigned char key)
      _("Scroll backward in this window and set default window size"))void info_scroll_backward_set_window (WINDOW *window, int count
, unsigned char key)
1246{
if (info_explicit_arg)
  default_window_size = count;
_scroll_backward (window, count, key, info_scroll_behaviour);
1250}

1252/* Show the previous screen of WINDOW's node but never move to previous
 node. */
1254DECLARE_INFO_COMMAND (info_scroll_backward_page_only, _("Scroll backward in this window staying within node"))void info_scroll_backward_page_only (WINDOW *window, int count
, unsigned char key)
1255{
_scroll_backward (window, count, key, IS_PageOnly2);
1257}

1259/* Like info_scroll_backward_page_only, but sets default_window_size as a side
 effect.  */
1261DECLARE_INFO_COMMAND (info_scroll_backward_page_only_set_window,void info_scroll_backward_page_only_set_window (WINDOW *window
, int count, unsigned char key)
      _("Scroll backward in this window staying within node and set default window size"))void info_scroll_backward_page_only_set_window (WINDOW *window
, int count, unsigned char key)
1263{
if (info_explicit_arg)
  default_window_size = count;
_scroll_backward (window, count, key, IS_PageOnly2);
1267}

1269/* Move to the beginning of the node. */
1270DECLARE_INFO_COMMAND (info_beginning_of_node, _("Move to the start of this node"))void info_beginning_of_node (WINDOW *window, int count, unsigned
 char key)
1271{
window->pagetop = window->point = 0;
window->flags |= W_UpdateWindow0x01;
1274}

1276/* Move to the end of the node. */
1277DECLARE_INFO_COMMAND (info_end_of_node, _("Move to the end of this node"))void info_end_of_node (WINDOW *window, int count, unsigned char
 key)
1278{
window->point = window->node->nodelen - 1;
info_show_point (window);
1281}

1283/* Scroll the window forward by N lines.  */
1284DECLARE_INFO_COMMAND (info_down_line, _("Scroll down by lines"))void info_down_line (WINDOW *window, int count, unsigned char
 key)
1285{
if (count < 0)
  info_up_line (window, -count, key);
else
  {
    int desired_top = window->pagetop + count;

    if (desired_top >= window->line_count)
desired_top = window->line_count - 2;

    if (window->pagetop <= desired_top)
set_window_pagetop (window, desired_top);
  }
1298}

1300/* Scroll the window backward by N lines.  */
1301DECLARE_INFO_COMMAND (info_up_line, _("Scroll up by lines"))void info_up_line (WINDOW *window, int count, unsigned char key
)
1302{
if (count < 0)
  info_down_line (window, -count, key);
else
  {
    int desired_top = window->pagetop - count;

    if (desired_top < 0)
desired_top = 0;

    set_window_pagetop (window, desired_top);
  }
1314}

1316/* Scroll the window forward by N lines and remember N as default for
 subsequent commands.  */
1318DECLARE_INFO_COMMAND (info_scroll_half_screen_down,void info_scroll_half_screen_down (WINDOW *window, int count,
 unsigned char key)
      _("Scroll down by half screen size"))void info_scroll_half_screen_down (WINDOW *window, int count,
 unsigned char key)
1320{
if (count < 0)
  info_scroll_half_screen_up (window, -count, key);
else
  {
    int scroll_size = (the_screen->height + 1) / 2;
    int desired_top;

    if (info_explicit_arg)
default_scroll_size = count;
    if (default_scroll_size > 0)
scroll_size = default_scroll_size;

    desired_top = window->pagetop + scroll_size;
    if (desired_top >= window->line_count)
desired_top = window->line_count - 2;

    if (window->pagetop <= desired_top)
set_window_pagetop (window, desired_top);
  }
1340}

1342/* Scroll the window backward by N lines and remember N as default for
 subsequent commands.  */
1344DECLARE_INFO_COMMAND (info_scroll_half_screen_up,void info_scroll_half_screen_up (WINDOW *window, int count, unsigned
 char key)
      _("Scroll up by half screen size"))void info_scroll_half_screen_up (WINDOW *window, int count, unsigned
 char key)
1346{
if (count < 0)
  info_scroll_half_screen_down (window, -count, key);
else
  {
    int scroll_size = (the_screen->height + 1) / 2;
    int desired_top;

    if (info_explicit_arg)
default_scroll_size = count;
    if (default_scroll_size > 0)
scroll_size = default_scroll_size;

    desired_top = window->pagetop - scroll_size;
    if (desired_top < 0)
desired_top = 0;

    set_window_pagetop (window, desired_top);
  }
1365}
1366
1367/* **************************************************************** */
1368/*                                                                  */
1369/*                 Commands for Manipulating Windows                */
1370/*                                                                  */
1371/* **************************************************************** */

1373/* Make the next window in the chain be the active window. */
1374DECLARE_INFO_COMMAND (info_next_window, _("Select the next window"))void info_next_window (WINDOW *window, int count, unsigned char
 key)
1375{
if (count < 0)
  {
    info_prev_window (window, -count, key);
    return;
  }

/* If no other window, error now. */
if (!windows->next && !echo_area_is_active)
  {
    info_error ((char *) msg_one_window, NULL((void *)0), NULL((void *)0));
    return;
  }

while (count--)
  {
    if (window->next)
      window = window->next;
    else
      {
        if (window == the_echo_area || !echo_area_is_active)
          window = windows;
        else
          window = the_echo_area;
      }
  }

if (active_window != window)
  {
    if (auto_footnotes_p)
      info_get_or_remove_footnotes (window);

    window->flags |= W_UpdateWindow0x01;
    active_window = window;
  }
1410}

1412/* Make the previous window in the chain be the active window. */
1413DECLARE_INFO_COMMAND (info_prev_window, _("Select the previous window"))void info_prev_window (WINDOW *window, int count, unsigned char
 key)
1414{
if (count < 0)
  {
    info_next_window (window, -count, key);
    return;
  }

/* Only one window? */

if (!windows->next && !echo_area_is_active)
  {
    info_error ((char *) msg_one_window, NULL((void *)0), NULL((void *)0));
    return;
  }

while (count--)
  {
    /* If we are in the echo area, or if the echo area isn't active and we
       are in the first window, find the last window in the chain. */
    if (window == the_echo_area ||
        (window == windows && !echo_area_is_active))
      {
        register WINDOW *win, *last = NULL((void *)0);

        for (win = windows; win; win = win->next)
          last = win;

        window = last;
      }
    else
      {
        if (window == windows)
          window = the_echo_area;
        else
          window = window->prev;
      }
  }

if (active_window != window)
  {
    if (auto_footnotes_p)
      info_get_or_remove_footnotes (window);

    window->flags |= W_UpdateWindow0x01;
    active_window = window;
  }
1460}

1462/* Split WINDOW into two windows, both showing the same node.  If we
 are automatically tiling windows, re-tile after the split. */
1464DECLARE_INFO_COMMAND (info_split_window, _("Split the current window"))void info_split_window (WINDOW *window, int count, unsigned char
 key)
1465{
WINDOW *split, *old_active;
int pagetop;

/* Remember the current pagetop of the window being split.  If it doesn't
   change, we can scroll its contents around after the split. */
pagetop = window->pagetop;

/* Make the new window. */
old_active = active_window;
active_window = window;
split = window_make_window (window->node);
active_window = old_active;

if (!split)
  {
    info_error ((char *) msg_win_too_small, NULL((void *)0), NULL((void *)0));
  }
else
  {
1485#if defined (SPLIT_BEFORE_ACTIVE)
    /* Try to scroll the old window into its new postion. */
    if (pagetop == window->pagetop)
      {
        int start, end, amount;

        start = split->first_row;
        end = start + window->height;
        amount = split->height + 1;
        display_scroll_display (start, end, amount);
      }
1496#else /* !SPLIT_BEFORE_ACTIVE */
    /* Make sure point still appears in the active window. */
    info_show_point (window);
1499#endif /* !SPLIT_BEFORE_ACTIVE */

    /* If the window just split was one internal to Info, try to display
       something else in it. */
    if (internal_info_node_p (split->node))
      {
        register int i, j;
        INFO_WINDOW *iw;
        NODE *node = (NODE *)NULL((void *)0);
        char *filename;

        for (i = 0; (iw = info_windows[i]); i++)
          {
            for (j = 0; j < iw->nodes_index; j++)
              if (!internal_info_node_p (iw->nodes[j]))
                {
                  if (iw->nodes[j]->parent)
                    filename = iw->nodes[j]->parent;
                  else
                    filename = iw->nodes[j]->filename;

                  node = info_get_node (filename, iw->nodes[j]->nodename);
                  if (node)
                    {
                      window_set_node_of_window (split, node);
                      i = info_windows_index - 1;
                      break;
                    }
                }
          }
      }
    split->pagetop = window->pagetop;

    if (auto_tiling_p)
      window_tile_windows (DONT_TILE_INTERNALS0);
    else
      window_adjust_pagetop (split);

    remember_window_and_node (split, split->node);
  }
1539}

1541/* Delete WINDOW, forgetting the list of last visited nodes.  If we are
 automatically displaying footnotes, show or remove the footnotes
 window.  If we are automatically tiling windows, re-tile after the
 deletion. */
1545DECLARE_INFO_COMMAND (info_delete_window, _("Delete the current window"))void info_delete_window (WINDOW *window, int count, unsigned char
 key)
1546{
if (!windows->next)
  {
    info_error ((char *) msg_cant_kill_last, NULL((void *)0), NULL((void *)0));
  }
else if (window->flags & W_WindowIsPerm0x02)
  {
    info_error ((char *) _("Cannot delete a permanent window")((const char *) ("Cannot delete a permanent window")), NULL((void *)0), NULL((void *)0));
  }
else
  {
    info_delete_window_internal (window);

    if (auto_footnotes_p)
      info_get_or_remove_footnotes (active_window);

    if (auto_tiling_p)
      window_tile_windows (DONT_TILE_INTERNALS0);
  }
1565}

1567/* Do the physical deletion of WINDOW, and forget this window and
 associated nodes. */
1569void
1570info_delete_window_internal (WINDOW *window)
1571{
if (windows->next && ((window->flags & W_WindowIsPerm0x02) == 0))
  {
    /* We not only delete the window from the display, we forget it from
       our list of remembered windows. */
    forget_window_and_nodes (window);
    window_delete_window (window);

    if (echo_area_is_active)
      echo_area_inform_of_deleted_window (window);
  }
1582}

1584/* Just keep WINDOW, deleting all others. */
1585DECLARE_INFO_COMMAND (info_keep_one_window, _("Delete all other windows"))void info_keep_one_window (WINDOW *window, int count, unsigned
 char key)
1586{
int num_deleted;              /* The number of windows we deleted. */
int pagetop, start, end;

/* Remember a few things about this window.  We may be able to speed up
   redisplay later by scrolling its contents. */
pagetop = window->pagetop;
start = window->first_row;
end = start + window->height;

num_deleted = 0;

while (1)
  {
    WINDOW *win;

    /* Find an eligible window and delete it.  If no eligible windows
       are found, we are done.  A window is eligible for deletion if
       is it not permanent, and it is not WINDOW. */
    for (win = windows; win; win = win->next)
      if (win != window && ((win->flags & W_WindowIsPerm0x02) == 0))
        break;

    if (!win)
      break;

    info_delete_window_internal (win);
    num_deleted++;
  }

/* Scroll the contents of this window into the right place so that the
   user doesn't have to wait any longer than necessary for redisplay. */
if (num_deleted)
  {
    int amount;

    amount = (window->first_row - start);
    amount -= (window->pagetop - pagetop);
    display_scroll_display (start, end, amount);
  }

window->flags |= W_UpdateWindow0x01;
1628}

1630/* Scroll the "other" window of WINDOW. */
1631DECLARE_INFO_COMMAND (info_scroll_other_window, _("Scroll the other window"))void info_scroll_other_window (WINDOW *window, int count, unsigned
 char key)
1632{
WINDOW *other;

/* If only one window, give up. */
if (!windows->next)
  {
    info_error ((char *) msg_one_window, NULL((void *)0), NULL((void *)0));
    return;
  }

other = window->next;

if (!other)
  other = window->prev;

info_scroll_forward (other, count, key);
1648}

1650/* Scroll the "other" window of WINDOW. */
1651DECLARE_INFO_COMMAND (info_scroll_other_window_backward,void info_scroll_other_window_backward (WINDOW *window, int count
, unsigned char key)
                    _("Scroll the other window backward"))void info_scroll_other_window_backward (WINDOW *window, int count
, unsigned char key)
1653{
info_scroll_other_window (window, -count, key);
1655}

1657/* Change the size of WINDOW by AMOUNT. */
1658DECLARE_INFO_COMMAND (info_grow_window, _("Grow (or shrink) this window"))void info_grow_window (WINDOW *window, int count, unsigned char
 key)
1659{
window_change_window_height (window, count);
1661}

1663/* When non-zero, tiling takes place automatically when info_split_window
 is called. */
1665int auto_tiling_p = 0;

1667/* Tile all of the visible windows. */
1668DECLARE_INFO_COMMAND (info_tile_windows,void info_tile_windows (WINDOW *window, int count, unsigned char
 key)
  _("Divide the available screen space among the visible windows"))void info_tile_windows (WINDOW *window, int count, unsigned char
 key)
1670{
window_tile_windows (TILE_INTERNALS1);
1672}

1674/* Toggle the state of this window's wrapping of lines. */
1675DECLARE_INFO_COMMAND (info_toggle_wrap,void info_toggle_wrap (WINDOW *window, int count, unsigned char
 key)
            _("Toggle the state of line wrapping in the current window"))void info_toggle_wrap (WINDOW *window, int count, unsigned char
 key)
1677{
window_toggle_wrap (window);
1679}
1680
1681/* **************************************************************** */
1682/*                                                                  */
1683/*                      Info Node Commands                          */
1684/*                                                                  */
1685/* **************************************************************** */

1687/* Return (FILENAME)NODENAME for NODE, or just NODENAME if NODE's
 filename is not set. */
1689char *
1690node_printed_rep (NODE *node)
1691{
char *rep;

if (node->filename)
  {
    char *filename
     = filename_non_directory (node->parent ? node->parent : node->filename);
    rep = xmalloc (1 + strlen (filename) + 1 + strlen (node->nodename) + 1);
    sprintf (rep, "(%s)%s", filename, node->nodename);
  }
else
  rep = node->nodename;

return rep;
1705}


1708/* Using WINDOW for various defaults, select the node referenced by ENTRY
 in it.  If the node is selected, the window and node are remembered. */
1710void
1711info_select_reference (WINDOW *window, REFERENCE *entry)
1712{
NODE *node;
char *filename, *nodename, *file_system_error;

file_system_error = (char *)NULL((void *)0);

filename = entry->filename;
if (!filename)
  filename = window->node->parent;
if (!filename)
  filename = window->node->filename;

if (filename)
  filename = xstrdup (filename);

if (entry->nodename)
  nodename = xstrdup (entry->nodename);
else
  nodename = xstrdup ("Top");

node = info_get_node (filename, nodename);

/* Try something a little weird.  If the node couldn't be found, and the
   reference was of the form "foo::", see if the entry->label can be found
   as a file, with a node of "Top". */
if (!node)
  {
    if (info_recent_file_error)
      file_system_error = xstrdup (info_recent_file_error);

    if (entry->nodename && (strcmp (entry->nodename, entry->label) == 0))
      {
        node = info_get_node (entry->label, "Top");
        if (!node && info_recent_file_error)
          {
            maybe_free (file_system_error)do { if (file_system_error) free (file_system_error); } while
 (0);
            file_system_error = xstrdup (info_recent_file_error);
          }
      }
  }

if (!node)
  {
    if (file_system_error)
      info_error (file_system_error, NULL((void *)0), NULL((void *)0));
    else
      info_error ((char *) msg_cant_find_node, nodename, NULL((void *)0));
  }

maybe_free (file_system_error)do { if (file_system_error) free (file_system_error); } while
 (0);
maybe_free (filename)do { if (filename) free (filename); } while (0);
maybe_free (nodename)do { if (nodename) free (nodename); } while (0);

if (node)
  info_set_node_of_window (1, window, node);
1767}

1769/* Parse the node specification in LINE using WINDOW to default the filename.
 Select the parsed node in WINDOW and remember it, or error if the node
 couldn't be found. */
1772static void
1773info_parse_and_select (char *line, WINDOW *window)
1774{
REFERENCE entry;

info_parse_node (line, DONT_SKIP_NEWLINES0);

entry.nodename = info_parsed_nodename;
entry.filename = info_parsed_filename;
entry.label = "*info-parse-and-select*";

info_select_reference (window, &entry);
1784}

1786/* Given that the values of INFO_PARSED_FILENAME and INFO_PARSED_NODENAME
 are previously filled, try to get the node represented by them into
 WINDOW.  The node should have been pointed to by the LABEL pointer of
 WINDOW->node. */
1790static void
1791info_handle_pointer (char *label, WINDOW *window)
1792{
if (info_parsed_filename || info_parsed_nodename)
  {
    char *filename, *nodename;
    NODE *node;

    filename = nodename = (char *)NULL((void *)0);

    if (info_parsed_filename)
      filename = xstrdup (info_parsed_filename);
    else
      {
        if (window->node->parent)
          filename = xstrdup (window->node->parent);
        else if (window->node->filename)
          filename = xstrdup (window->node->filename);
      }

    if (info_parsed_nodename)
      nodename = xstrdup (info_parsed_nodename);
    else
      nodename = xstrdup ("Top");

    node = info_get_node (filename, nodename);

    if (node)
      {
        INFO_WINDOW *info_win;

        info_win = get_info_window_of_window (window);
        if (info_win)
          {
            info_win->pagetops[info_win->current] = window->pagetop;
            info_win->points[info_win->current] = window->point;
          }
        info_set_node_of_window (1, window, node);
      }
    else
      {
        if (info_recent_file_error)
          info_error (info_recent_file_error, NULL((void *)0), NULL((void *)0));
        else
          info_error ((char *) msg_cant_file_node, filename, nodename);
      }

    free (filename);
    free (nodename);
  }
else
  {
    info_error ((char *) msg_no_pointer, label, NULL((void *)0));
  }
1844}

1846/* Make WINDOW display the "Next:" node of the node currently being
 displayed. */
1848DECLARE_INFO_COMMAND (info_next_node, _("Select the Next node"))void info_next_node (WINDOW *window, int count, unsigned char
 key)
1849{
info_next_label_of_node (window->node)info_parse_label ("Next:", window->node);
info_handle_pointer ("Next", window);
1852}

1854/* Make WINDOW display the "Prev:" node of the node currently being
 displayed. */
1856DECLARE_INFO_COMMAND (info_prev_node, _("Select the Prev node"))void info_prev_node (WINDOW *window, int count, unsigned char
 key)
1857{
info_prev_label_of_node (window->node)do { info_parse_label ("Prev:", window->node); if (!info_parsed_nodename
 && !info_parsed_filename) info_parse_label ("Previous:"
, window->node); } while (0);
info_handle_pointer ("Prev", window);
1860}

1862/* Make WINDOW display the "Up:" node of the node currently being
 displayed. */
1864DECLARE_INFO_COMMAND (info_up_node, _("Select the Up node"))void info_up_node (WINDOW *window, int count, unsigned char key
)
1865{
info_up_label_of_node (window->node)info_parse_label ("Up:", window->node);
info_handle_pointer ("Up", window);
1868}

1870/* Make WINDOW display the last node of this info file. */
1871DECLARE_INFO_COMMAND (info_last_node, _("Select the last node in this file"))void info_last_node (WINDOW *window, int count, unsigned char
 key)
1872{
register int i;
FILE_BUFFER *fb = file_buffer_of_window (window);
NODE *node = (NODE *)NULL((void *)0);

if (fb && fb->tags)
  {
    int last_node_tag_idx = -1;

    /* If no explicit argument, or argument of zero, default to the
       last node.  */
    if (count == 0 || (count == 1 && !info_explicit_arg))
      count = -1;
    for (i = 0; count && fb->tags[i]; i++)
      if (fb->tags[i]->nodelen != 0) /* don't count anchor tags */
        {
          count--;
          last_node_tag_idx = i;
        }
    if (count > 0)
      i = last_node_tag_idx + 1;
    if (i > 0)
      node = info_get_node (fb->filename, fb->tags[i - 1]->nodename);
  }

if (!node)
  info_error ((char *) _("This window has no additional nodes")((const char *) ("This window has no additional nodes")), NULL((void *)0), NULL((void *)0));
else
  info_set_node_of_window (1, window, node);
1901}

1903/* Make WINDOW display the first node of this info file. */
1904DECLARE_INFO_COMMAND (info_first_node, _("Select the first node in this file"))void info_first_node (WINDOW *window, int count, unsigned char
 key)
1905{
FILE_BUFFER *fb = file_buffer_of_window (window);
NODE *node = (NODE *)NULL((void *)0);

/* If no explicit argument, or argument of zero, default to the
   first node.  */
if (count == 0)
  count = 1;
if (fb && fb->tags)
  {
    register int i;
    int last_node_tag_idx = -1;

    for (i = 0; count && fb->tags[i]; i++)
      if (fb->tags[i]->nodelen != 0) /* don't count anchor tags */
        {
          count--;
          last_node_tag_idx = i;
        }
    if (count > 0)
      i = last_node_tag_idx + 1;
    if (i > 0)
      node = info_get_node (fb->filename, fb->tags[i - 1]->nodename);
  }

if (!node)
  info_error ((char *) _("This window has no additional nodes")((const char *) ("This window has no additional nodes")), NULL((void *)0), NULL((void *)0));
else
  info_set_node_of_window (1, window, node);
1934}

1936/* Select the last menu item in WINDOW->node. */
1937DECLARE_INFO_COMMAND (info_last_menu_item,void info_last_menu_item (WINDOW *window, int count, unsigned
 char key)
 _("Select the last item in this node's menu"))void info_last_menu_item (WINDOW *window, int count, unsigned
 char key)
1939{
info_menu_digit (window, 1, '0');
1941}

1943/* Use KEY (a digit) to select the Nth menu item in WINDOW->node. */
1944DECLARE_INFO_COMMAND (info_menu_digit, _("Select this menu item"))void info_menu_digit (WINDOW *window, int count, unsigned char
 key)
1945{
register int i, item;
register REFERENCE **menu;

menu = info_menu_of_node (window->node);

if (!menu)
  {
    info_error ((char *) msg_no_menu_node, NULL((void *)0), NULL((void *)0));
    return;
  }

/* We have the menu.  See if there are this many items in it. */
item = key - '0';

/* Special case.  Item "0" is the last item in this menu. */
if (item == 0)
  for (i = 0; menu[i + 1]; i++);
else
  {
    for (i = 0; menu[i]; i++)
      if (i == item - 1)
        break;
  }

if (menu[i])
  {
    info_select_reference (window, menu[i]);
    if (menu[i]->line_number > 0)
      info_next_line (window, menu[i]->line_number - 1, key);
  }
else
  info_error ((char *) _("There aren't %d items in this menu.")((const char *) ("There aren't %d items in this menu.")),
              (void *) (long) item, NULL((void *)0));

info_free_references (menu);
return;
1982}


1985
1986/* Return a pointer to the xref in XREF_LIST that is nearest to POS, or
 NULL if XREF_LIST is empty.  That is, if POS is within any of the
 given xrefs, return that one.  Otherwise, return the one with the
 nearest beginning or end.  If there are two that are equidistant,
 prefer the one forward.  The return is in newly-allocated memory,
 since the caller frees it.
 
 This is called from info_menu_or_ref_item with XREF_LIST being all
 the xrefs in the node, and POS being point.  The ui function that
 starts it all off is select-reference-this-line.

 This is not the same logic as in info.el.  Info-get-token prefers
 searching backwards to searching forwards, and has a hardwired search
 limit of 200 chars (in Emacs 21.2).  */

2001static REFERENCE **
2002nearest_xref (REFERENCE **xref_list, long int pos)
2003{
int this_xref;
int nearest = -1;
long best_delta = -1;

for (this_xref = 0; xref_list[this_xref]; this_xref++)
  {
    long delta;
    REFERENCE *xref = xref_list[this_xref];
    if (xref->start <= pos && pos <= xref->end)
      { /* POS is within this xref, we're done */
        nearest = this_xref;
        break;
      }
    
    /* See how far POS is from this xref.  Take into account the
       `*Note' that begins the xref, since as far as the user is
       concerned, that's where it starts.  */
    delta = MIN (labs (pos - (xref->start - strlen (INFO_XREF_LABEL))),((labs (pos - (xref->start - strlen ("*Note")))) < (labs
 (pos - xref->end)) ? (labs (pos - (xref->start - strlen
 ("*Note")))) : (labs (pos - xref->end)))
                 labs (pos - xref->end))((labs (pos - (xref->start - strlen ("*Note")))) < (labs
 (pos - xref->end)) ? (labs (pos - (xref->start - strlen
 ("*Note")))) : (labs (pos - xref->end)));
    
    /* It's the <= instead of < that makes us choose the forward xref
       of POS if two are equidistant.  Of course, because of all the
       punctuation surrounding xrefs, it's not necessarily obvious
       where one ends.  */
    if (delta <= best_delta || best_delta < 0)
      {
        nearest = this_xref;
        best_delta = delta;
      }
  }

/* Maybe there was no list to search through.  */
if (nearest < 0)
  return NULL((void *)0);

/* Ok, we have a nearest xref, make a list of it.  */
{
  REFERENCE **ret = xmalloc (sizeof (REFERENCE *) * 2);
  ret[0] = info_copy_reference (xref_list[nearest]);
  ret[1] = NULL((void *)0);
  return ret;
}
2046}


2049/* Read a menu or followed reference from the user defaulting to the
 reference found on the current line, and select that node.  The
 reading is done with completion.  BUILDER is the function used
 to build the list of references.  ASK_P is non-zero if the user
 should be prompted, or zero to select the default item. */
2054static void
2055info_menu_or_ref_item (WINDOW *window, int count,
  unsigned char key, REFERENCE **(*builder) (NODE *node), int ask_p)
2057{
char *line;
REFERENCE *entry;
REFERENCE *defentry = NULL((void *)0);
REFERENCE **menu = (*builder) (window->node);

if (!menu)
  {
    if (builder == info_menu_of_node)
      info_error ((char *) msg_no_menu_node, NULL((void *)0), NULL((void *)0));
    else
      info_error ((char *) msg_no_xref_node, NULL((void *)0), NULL((void *)0));
    return;
  }

/* Default the selected reference to the one which is on the line that
   point is in.  */
{
  REFERENCE **refs = NULL((void *)0);
  int point_line = window_line_of_point (window);

  if (point_line != -1)
    {
      SEARCH_BINDING binding;

      binding.buffer = window->node->contents;
      binding.start = window->line_starts[point_line] - binding.buffer;
      if (window->line_starts[point_line + 1])
        binding.end = window->line_starts[point_line + 1] - binding.buffer;
      else
        binding.end = window->node->nodelen;
      binding.flags = 0;

      if (builder == info_menu_of_node)
        {
          if (point_line)
            {
              binding.start--;
              refs = info_menu_items (&binding);
            }
        }
      else
        {
2100#if defined (HANDLE_MAN_PAGES)
          if (window->node->flags & N_IsManPage0x40)
            refs = manpage_xrefs_in_binding (window->node, &binding);
          else
2104#endif /* HANDLE_MAN_PAGES */
            refs = nearest_xref (menu, window->point);
        }

      if (refs && refs[0])
        {
          if (strcmp (refs[0]->label, "Menu") != 0
              || builder == info_xrefs_of_node)
            {
              int which = 0;

              /* For xrefs, find the closest reference to point,
                 unless we only have one reference (as we will if
                 we've called nearest_xref above).  It would be better
                 to have only one piece of code, but the conditions
                 when we call this are tangled.  */
              if (builder == info_xrefs_of_node && refs[1])
                {
                  int closest = -1;

                  for (; refs[which]; which++)
                    {
                      if (window->point >= refs[which]->start
                          && window->point <= refs[which]->end)
                        {
                          closest = which;
                          break;
                        }
                      else if (window->point < refs[which]->start)
                        break;
                    }
    if (which > 0)
      {
	if (closest == -1)
	  which--;
	else
	  which = closest;
      }
                }

if (which < 0)
  which = 0;
              defentry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
              defentry->label = xstrdup (refs[which]->label);
              defentry->filename = refs[which]->filename;
              defentry->nodename = refs[which]->nodename;
              defentry->line_number = refs[which]->line_number;

              if (defentry->filename)
                defentry->filename = xstrdup (defentry->filename);
              if (defentry->nodename)
                defentry->nodename = xstrdup (defentry->nodename);
            }
          info_free_references (refs);
        }
    }
}

/* If we are going to ask the user a question, do it now. */
if (ask_p)
  {
    char *prompt;

    /* Build the prompt string. */
    if (builder == info_menu_of_node)
      {
        if (defentry)
   {
     prompt = xmalloc (strlen (defentry->label)
		+ strlen (_("Menu item (%s): ")((const char *) ("Menu item (%s): "))));
     sprintf (prompt, _("Menu item (%s): ")((const char *) ("Menu item (%s): ")), defentry->label);
   }
        else
   prompt = xstrdup (_("Menu item: ")((const char *) ("Menu item: ")));
      }
    else
      {
        if (defentry)
   {
     prompt = xmalloc (strlen (defentry->label)
		+ strlen (_("Follow xref (%s): ")((const char *) ("Follow xref (%s): "))));
     sprintf (prompt, _("Follow xref (%s): ")((const char *) ("Follow xref (%s): ")), defentry->label);
   }
        else
   prompt = xstrdup (_("Follow xref: ")((const char *) ("Follow xref: ")));
      }

    line = info_read_completing_in_echo_area (window, prompt, menu);
    free (prompt);

    window = active_window;

    /* User aborts, just quit. */
    if (!line)
      {
        maybe_free (defentry)do { if (defentry) free (defentry); } while (0);
        info_free_references (menu);
        info_abort_key (window, 0, 0);
        return;
      }

    /* If we had a default and the user accepted it, use that. */
    if (!*line)
      {
        free (line);
        if (defentry)
          line = xstrdup (defentry->label);
        else
          line = (char *)NULL((void *)0);
      }
  }
else
  {
    /* Not going to ask any questions.  If we have a default entry, use
       that, otherwise return. */
    if (!defentry)
      return;
    else
      line = xstrdup (defentry->label);
  }

if (line)
  {
    /* It is possible that the references have more than a single
       entry with the same label, and also LINE is down-cased, which
       complicates matters even more.  Try to be as accurate as we
       can: if they've chosen the default, use defentry directly. */
    if (defentry && strcmp (line, defentry->label) == 0)
      entry = defentry;
    else
      /* Find the selected label in the references.  If there are
         more than one label which matches, find the one that's
         closest to point.  */
      {
        register int i;
        int best = -1, min_dist = window->node->nodelen;
        REFERENCE *ref;

        for (i = 0; menu && (ref = menu[i]); i++)
          {
            /* Need to use strcasecmp because LINE is downcased
               inside info_read_completing_in_echo_area.  */
            if (strcasecmp (line, ref->label) == 0)
              {
                /* ref->end is more accurate estimate of position
                   for menus than ref->start.  Go figure.  */
                int dist = abs (window->point - ref->end);

                if (dist < min_dist)
                  {
                    min_dist = dist;
                    best = i;
                  }
              }
          }
        if (best != -1)
          entry = menu[best];
        else
          entry = (REFERENCE *)NULL((void *)0);
      }

    if (!entry && defentry)
      info_error ((char *) _("The reference disappeared! (%s).")((const char *) ("The reference disappeared! (%s).")), line, NULL((void *)0));
    else
      {
        NODE *orig = window->node;
        info_select_reference (window, entry);

        if (builder == info_xrefs_of_node && window->node != orig
            && !(window->node->flags & N_FromAnchor0x80))
          { /* Search for this reference in the node.  */
            long offset;
            long start;

            if (window->line_count > 0)
              start = window->line_starts[1] - window->node->contents;
            else
              start = 0;

            offset =
              info_target_search_node (window->node, entry->label, start);

            if (offset != -1)
              {
                window->point = offset;
                window_adjust_pagetop (window);
              }
          }

          if (entry->line_number > 0)
            /* next_line starts at line 1?  Anyway, the -1 makes it
               move to the right line.  */
            info_next_line (window, entry->line_number - 1, key);
      }

    free (line);
    if (defentry)
      {
        free (defentry->label);
        maybe_free (defentry->filename)do { if (defentry->filename) free (defentry->filename);
 } while (0);
        maybe_free (defentry->nodename)do { if (defentry->nodename) free (defentry->nodename);
 } while (0);
        free (defentry);
      }
  }

info_free_references (menu);

if (!info_error_was_printed)
  window_clear_echo_area ();
2313}

2315/* Read a line (with completion) which is the name of a menu item,
 and select that item. */
2317DECLARE_INFO_COMMAND (info_menu_item, _("Read a menu item and select its node"))void info_menu_item (WINDOW *window, int count, unsigned char
 key)
2318{
info_menu_or_ref_item (window, count, key, info_menu_of_node, 1);
2320}

2322/* Read a line (with completion) which is the name of a reference to
 follow, and select the node. */
2324DECLARE_INFO_COMMANDvoid info_xref_item (WINDOW *window, int count, unsigned char
 key)
(info_xref_item, _("Read a footnote or cross reference and select its node"))void info_xref_item (WINDOW *window, int count, unsigned char
 key)
2326{
info_menu_or_ref_item (window, count, key, info_xrefs_of_node, 1);
2328}

2330/* Position the cursor at the start of this node's menu. */
2331DECLARE_INFO_COMMAND (info_find_menu, _("Move to the start of this node's menu"))void info_find_menu (WINDOW *window, int count, unsigned char
 key)
2332{
SEARCH_BINDING binding;
long position;

binding.buffer = window->node->contents;
binding.start  = 0;
binding.end = window->node->nodelen;
binding.flags = S_FoldCase0x01 | S_SkipDest0x02;

position = search (INFO_MENU_LABEL"\n* Menu:", &binding);

if (position == -1)
  info_error ((char *) msg_no_menu_node, NULL((void *)0), NULL((void *)0));
else
  {
    window->point = position;
    window_adjust_pagetop (window);
    window->flags |= W_UpdateWindow0x01;
  }
2351}

2353/* Visit as many menu items as is possible, each in a separate window. */
2354DECLARE_INFO_COMMAND (info_visit_menu,void info_visit_menu (WINDOW *window, int count, unsigned char
 key)
_("Visit as many menu items at once as possible"))void info_visit_menu (WINDOW *window, int count, unsigned char
 key)
2356{
register int i;
REFERENCE *entry, **menu;

menu = info_menu_of_node (window->node);

if (!menu)
  info_error ((char *) msg_no_menu_node, NULL((void *)0), NULL((void *)0));

for (i = 0; (!info_error_was_printed) && (entry = menu[i]); i++)
  {
    WINDOW *new;

    new = window_make_window (window->node);
    window_tile_windows (TILE_INTERNALS1);

    if (!new)
      info_error ((char *) msg_win_too_small, NULL((void *)0), NULL((void *)0));
    else
      {
        active_window = new;
        info_select_reference (new, entry);
      }
  }
2380}

2382/* Read a line of input which is a node name, and go to that node. */
2383DECLARE_INFO_COMMAND (info_goto_node, _("Read a node name and select it"))void info_goto_node (WINDOW *window, int count, unsigned char
 key)
2384{
char *line;

2387#define GOTO_COMPLETES
2388#if defined (GOTO_COMPLETES)
/* Build a completion list of all of the known nodes. */
{
  register int fbi, i;
  FILE_BUFFER *current;
  REFERENCE **items = (REFERENCE **)NULL((void *)0);
  int items_index = 0;
  int items_slots = 0;

  current = file_buffer_of_window (window);

  for (fbi = 0; info_loaded_files && info_loaded_files[fbi]; fbi++)
    {
      FILE_BUFFER *fb;
      REFERENCE *entry;
      int this_is_the_current_fb;

      fb = info_loaded_files[fbi];
      this_is_the_current_fb = (current == fb);

      entry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
      entry->filename = entry->nodename = (char *)NULL((void *)0);
      entry->label = (char *)xmalloc (4 + strlen (fb->filename));
      sprintf (entry->label, "(%s)*", fb->filename);

      add_pointer_to_arraydo { if (items_index + 2 >= items_slots) items = (REFERENCE
 * *)(xrealloc (items, (items_slots += 10) * sizeof (REFERENCE
 *))); items[items_index++] = (REFERENCE *)entry; items[items_index
] = (REFERENCE *)((void *)0); } while (0)
        (entry, items_index, items, items_slots, 10, REFERENCE *)do { if (items_index + 2 >= items_slots) items = (REFERENCE
 * *)(xrealloc (items, (items_slots += 10) * sizeof (REFERENCE
 *))); items[items_index++] = (REFERENCE *)entry; items[items_index
] = (REFERENCE *)((void *)0); } while (0);

      if (fb->tags)
        {
          for (i = 0; fb->tags[i]; i++)
            {
              entry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
              entry->filename = entry->nodename = (char *)NULL((void *)0);
if (this_is_the_current_fb)
  entry->label = xstrdup (fb->tags[i]->nodename);
else
  {
    entry->label = (char *) xmalloc
      (4 + strlen (fb->filename) +
       strlen (fb->tags[i]->nodename));
    sprintf (entry->label, "(%s)%s",
	     fb->filename, fb->tags[i]->nodename);
  }

              add_pointer_to_arraydo { if (items_index + 2 >= items_slots) items = (REFERENCE
 * *)(xrealloc (items, (items_slots += 100) * sizeof (REFERENCE
 *))); items[items_index++] = (REFERENCE *)entry; items[items_index
] = (REFERENCE *)((void *)0); } while (0)
                (entry, items_index, items, items_slots, 100, REFERENCE *)do { if (items_index + 2 >= items_slots) items = (REFERENCE
 * *)(xrealloc (items, (items_slots += 100) * sizeof (REFERENCE
 *))); items[items_index++] = (REFERENCE *)entry; items[items_index
] = (REFERENCE *)((void *)0); } while (0);
            }
        }
    }
  line = info_read_maybe_completing (window, (char *) _("Goto node: ")((const char *) ("Goto node: ")),
      items);
  info_free_references (items);
}
2442#else /* !GOTO_COMPLETES */
line = info_read_in_echo_area (window, (char *) _("Goto node: ")((const char *) ("Goto node: ")));
2444#endif /* !GOTO_COMPLETES */

/* If the user aborted, quit now. */
if (!line)
  {
    info_abort_key (window, 0, 0);
    return;
  }

canonicalize_whitespace (line);

if (*line)
  info_parse_and_select (line, window);

free (line);
if (!info_error_was_printed)
  window_clear_echo_area ();
2461}
2462
2463/* Follow the menu list in MENUS (list of strings terminated by a NULL
 entry) from INITIAL_NODE.  If can't continue at any point (no menu or
 no menu entry for the next item), return the node so far -- that
 might be INITIAL_NODE itself.  If error, *ERRSTR and *ERRARG[12] will
 be set to the error message and argument for message, otherwise they
 will be NULL.  */

2470NODE *
2471info_follow_menus (NODE *initial_node, char **menus,
  const char **errstr, char **errarg1, char **errarg2)
2473{
NODE *node = NULL((void *)0);
*errstr = *errarg1 = *errarg2 = NULL((void *)0);

for (; *menus; menus++)
  {
    static char *first_arg = NULL((void *)0);
    REFERENCE **menu;
    REFERENCE *entry;
    char *arg = *menus; /* Remember the name of the menu entry we want. */

    /* A leading space is certainly NOT part of a node name.  Most
probably, they typed a space after the separating comma.  The
strings in menus[] have their whitespace canonicalized, so
there's at most one space to ignore.  */
    if (*arg == ' ')
arg++;
    if (!first_arg)
      first_arg = arg;

    /* Build and return a list of the menu items in this node. */
    menu = info_menu_of_node (initial_node);

    /* If no menu item in this node, stop here, but let the user
       continue to use Info.  Perhaps they wanted this node and didn't
       realize it. */
    if (!menu)
      {
        if (arg == first_arg)
          {
            node = make_manpage_node (first_arg);
            if (node)
              goto maybe_got_node;
          }
        *errstr = _("No menu in node `%s'.")((const char *) ("No menu in node `%s'."));
        *errarg1 = node_printed_rep (initial_node);
        return initial_node;
      }

    /* Find the specified menu item. */
    entry = info_get_labeled_reference (arg, menu);

    /* If the item wasn't found, search the list sloppily.  Perhaps this
       user typed "buffer" when they really meant "Buffers". */
    if (!entry)
      {
        int i;
        int best_guess = -1;

        for (i = 0; (entry = menu[i]); i++)
          {
            if (strcasecmp (entry->label, arg) == 0)
              break;
            else
              if ((best_guess == -1)
                  && (strncasecmp (entry->label, arg, strlen (arg)) == 0))
                best_guess = i;
          }

        if (!entry && best_guess != -1)
          entry = menu[best_guess];
      }

    /* If we still failed to find the reference, start Info with the current
       node anyway.  It is probably a misspelling. */
    if (!entry)
      {
        if (arg == first_arg)
          {
     /* Maybe they typed "info foo" instead of "info -f foo".  */
     node = info_get_node (first_arg, 0);
     if (node)
add_file_directory_to_path (first_arg);
     else
node = make_manpage_node (first_arg);
            if (node)
              goto maybe_got_node;
          }

        info_free_references (menu);
        *errstr = _("No menu item `%s' in node `%s'.")((const char *) ("No menu item `%s' in node `%s'."));
        *errarg1 = arg;
        *errarg2 = node_printed_rep (initial_node);
        return initial_node;
      }

    /* We have found the reference that the user specified.  If no
       filename in this reference, define it. */
    if (!entry->filename)
      entry->filename = xstrdup (initial_node->parent ? initial_node->parent
                                                   : initial_node->filename);

    /* Try to find this node.  */
    node = info_get_node (entry->filename, entry->nodename);
    if (!node && arg == first_arg)
{
 node = make_manpage_node (first_arg);
 if (node)
   goto maybe_got_node;
}

    /* Since we cannot find it, try using the label of the entry as a
       file, i.e., "(LABEL)Top".  */
    if (!node && entry->nodename
        && strcmp (entry->label, entry->nodename) == 0)
      node = info_get_node (entry->label, "Top");

  maybe_got_node:
    if (!node)
      {
        *errstr = _("Unable to find node referenced by `%s' in `%s'.")((const char *) ("Unable to find node referenced by `%s' in `%s'."
));
        *errarg1 = xstrdup (entry->label);
        *errarg2 = node_printed_rep (initial_node);
        info_free_references (menu);
        return initial_node;
      }

    info_free_references (menu);

    /* Success.  Go round the loop again.  */
    free (initial_node);
    initial_node = node;
  }

return initial_node;
2598}

2600/* Split STR into individual node names by writing null bytes in wherever
 there are commas and constructing a list of the resulting pointers.
 (We can do this since STR has had canonicalize_whitespace called on it.)
 Return array terminated with NULL.  */

2605static char **
2606split_list_of_nodenames (char *str)
2607{
unsigned len = 2;
char **nodes = xmalloc (len * sizeof (char *));

nodes[len - 2] = str;

while (*str++)
  {
    if (*str == ',')
      {
        *str++ = 0;		/* get past the null byte */
        len++;
        nodes = xrealloc (nodes, len * sizeof (char *));
        nodes[len - 2] = str;
      }
  }

nodes[len - 1] = NULL((void *)0);

return nodes;
2627}


2630/* Read a line of input which is a sequence of menus (starting from
 dir), and follow them.  */
2632DECLARE_INFO_COMMAND (info_menu_sequence,void info_menu_sequence (WINDOW *window, int count, unsigned char
 key)
 _("Read a list of menus starting from dir and follow them"))void info_menu_sequence (WINDOW *window, int count, unsigned char
 key)
2634{
char *line = info_read_in_echo_area (window, (char *) _("Follow menus: ")((const char *) ("Follow menus: ")));

/* If the user aborted, quit now. */
if (!line)
1
Assuming 'line' is non-null→
2
←
Taking false branch→
  {
    info_abort_key (window, 0, 0);
    return;
  }

canonicalize_whitespace (line);

if (*line)
3
←
Assuming the condition is true→
4
←
Taking true branch→
  {
    const char *errstr;
5
←
'errstr' declared without an initial value→
    char *errarg1, *errarg2;
    NODE *dir_node = info_get_node (NULL((void *)0), NULL((void *)0));
    char **nodes = split_list_of_nodenames (line);
    NODE *node = NULL((void *)0);

    /* If DIR_NODE is NULL, they might be reading a file directly,
like in "info -d . -f ./foo".  Try using "Top" instead.  */
    if (!dir_node)
6
←
Assuming 'dir_node' is null→
7
←
Taking true branch→
{
 char *file_name = window->node->parent;

 if (!file_name)
8
←
Assuming 'file_name' is non-null→
9
←
Taking false branch→
   file_name = window->node->filename;
 dir_node = info_get_node (file_name, NULL((void *)0));
}

    /* If we still cannot find the starting point, give up.
We cannot allow a NULL pointer inside info_follow_menus.  */
    if (!dir_node)
10
←
Assuming 'dir_node' is null→
11
←
Taking true branch→
info_error ((char *) msg_cant_find_node, "Top", NULL((void *)0));
    else
node = info_follow_menus (dir_node, nodes, &errstr, &errarg1, &errarg2);

    free (nodes);
    if (!errstr)
12
←
Branch condition evaluates to a garbage value
      info_set_node_of_window (1, window, node);
    else
      info_error ((char *) errstr, errarg1, errarg2);
  }

free (line);
if (!info_error_was_printed)
  window_clear_echo_area ();
2682}

2684/* Search the menu MENU for a (possibly mis-spelled) entry ARG.
 Return the menu entry, or the best guess for what they meant by ARG,
 or NULL if there's nothing in this menu seems to fit the bill.
 If EXACT is non-zero, allow only exact matches.  */
2688static REFERENCE *
2689entry_in_menu (char *arg, REFERENCE **menu, int exact)
2690{
REFERENCE *entry;

/* First, try to find the specified menu item verbatim.  */
entry = info_get_labeled_reference (arg, menu);

/* If the item wasn't found, search the list sloppily.  Perhaps we
   have "Option Summary", but ARG is "option".  */
if (!entry && !exact)
  {
    int i;
    int best_guess = -1;

    for (i = 0; (entry = menu[i]); i++)
{
 if (strcasecmp (entry->label, arg) == 0)
   break;
 else
   if (strncasecmp (entry->label, arg, strlen (arg)) == 0)
     best_guess = i;
}

    if (!entry && best_guess != -1)
entry = menu[best_guess];
  }

return entry;
2717}

2719/* Find the node that is the best candidate to list the PROGRAM's
 invocation info and its command-line options, by looking for menu
 items and chains of menu items with characteristic names.  */
2722void
2723info_intuit_options_node (WINDOW *window, NODE *initial_node, char *program)
2724{
/* The list of node names typical for GNU manuals where the program
   usage and specifically the command-line arguments are described.
   This is pure heuristics.  I gathered these node names by looking
   at all the Info files I could put my hands on.  If you are
   looking for evidence to complain to the GNU project about
   non-uniform style of documentation, here you have your case!  */
static const char *invocation_nodes[] = {
  "%s invocation",
  "Invoking %s",
  "Preliminaries",	/* m4 has Invoking under Preliminaries! */
  "Invocation",
  "Command Arguments",/* Emacs */
  "Invoking `%s'",
  "%s options",
  "Options",
  "Option ",		/* e.g. "Option Summary" */
  "Invoking",
  "All options",	/* tar, paxutils */
  "Arguments",
  "%s cmdline",	/* ar */
  "%s",		/* last resort */
  (const char *)0
};
NODE *node = NULL((void *)0);
REFERENCE **menu;
const char **try_node;

/* We keep looking deeper and deeper in the menu structure until
   there are no more menus or no menu items from the above list.
   Some manuals have the invocation node sitting 3 or 4 levels deep
   in the menu hierarchy...  */
for (node = initial_node; node; initial_node = node)
  {
    REFERENCE *entry = NULL((void *)0);

    /* Build and return a list of the menu items in this node. */
    menu = info_menu_of_node (initial_node);

    /* If no menu item in this node, stop here.  Perhaps this node
is the one they need.  */
    if (!menu)
break;

    /* Look for node names typical for usage nodes in this menu.  */
    for (try_node = invocation_nodes; *try_node; try_node++)
{
 char *nodename;

 nodename = xmalloc (strlen (program) + strlen (*try_node));
 sprintf (nodename, *try_node, program);
 /* The last resort "%s" is dangerous, so we restrict it
           to exact matches here.  */
 entry = entry_in_menu (nodename, menu,
		 strcmp (*try_node, "%s") == 0);
 free (nodename);
 if (entry)
   break;
}

    if (!entry)
break;

    if (!entry->filename)
entry->filename = xstrdup (initial_node->parent ? initial_node->parent
		   : initial_node->filename);
    /* Try to find this node.  */
    node = info_get_node (entry->filename, entry->nodename);
    info_free_references (menu);
    if (!node)
break;
  }

/* We've got our best shot at the invocation node.  Now select it.  */
if (initial_node)
  info_set_node_of_window (1, window, initial_node);
if (!info_error_was_printed)
  window_clear_echo_area ();
2802}

2804/* Given a name of an Info file, find the name of the package it
 describes by removing the leading directories and extensions.  */
2806char *
2807program_name_from_file_name (char *file_name)
2808{
int i;
char *program_name = xstrdup (filename_non_directory (file_name));

for (i = strlen (program_name) - 1; i > 0; i--)
  if (program_name[i] == '.'
&& (FILENAME_CMPNstrncmp (program_name + i, ".info", 5) == 0
   || FILENAME_CMPNstrncmp (program_name + i, ".inf", 4) == 0
2816#ifdef __MSDOS__
   || FILENAME_CMPNstrncmp (program_name + i, ".i", 2) == 0
2818#endif
   || isdigit (program_name[i + 1]))) /* a man page foo.1 */
    {
program_name[i] = 0;
break;
    }
return program_name;
2825}

2827DECLARE_INFO_COMMAND (info_goto_invocation_node,void info_goto_invocation_node (WINDOW *window, int count, unsigned
 char key)
      _("Find the node describing program invocation"))void info_goto_invocation_node (WINDOW *window, int count, unsigned
 char key)
2829{
const char *invocation_prompt = _("Find Invocation node of [%s]: ")((const char *) ("Find Invocation node of [%s]: "));
char *program_name, *line;
char *default_program_name, *prompt, *file_name;
NODE *top_node;

/* Intuit the name of the program they are likely to want.
   We use the file name of the current Info file as a hint.  */
file_name = window->node->parent ? window->node->parent
		   : window->node->filename;
default_program_name = program_name_from_file_name (file_name);

prompt = (char *)xmalloc (strlen (default_program_name) +
	    strlen (invocation_prompt));
sprintf (prompt, invocation_prompt, default_program_name);
line = info_read_in_echo_area (window, prompt);
free (prompt);
if (!line)
  {
    info_abort_key (window, 0, 0);
    return;
  }
if (*line)
  program_name = line;
else
  program_name = default_program_name;

/* In interactive usage they'd probably expect us to begin looking
   from the Top node.  */
top_node = info_get_node (file_name, NULL((void *)0));
if (!top_node)
  info_error ((char *) msg_cant_find_node, "Top", NULL((void *)0));

info_intuit_options_node (window, top_node, program_name);
free (line);
free (default_program_name);
2865}
2866
2867#if defined (HANDLE_MAN_PAGES)
2868DECLARE_INFO_COMMAND (info_man, _("Read a manpage reference and select it"))void info_man (WINDOW *window, int count, unsigned char key)
2869{
char *line;

line = info_read_in_echo_area (window, (char *) _("Get Manpage: ")((const char *) ("Get Manpage: ")));

if (!line)
  {
    info_abort_key (window, 0, 0);
    return;
  }

canonicalize_whitespace (line);

if (*line)
  {
    char *goto_command;

    goto_command = (char *)xmalloc
      (4 + strlen (MANPAGE_FILE_BUFFER_NAME"*manpages*") + strlen (line));

    sprintf (goto_command, "(%s)%s", MANPAGE_FILE_BUFFER_NAME"*manpages*", line);

    info_parse_and_select (goto_command, window);
    free (goto_command);
  }

free (line);
if (!info_error_was_printed)
  window_clear_echo_area ();
2898}
2899#endif /* HANDLE_MAN_PAGES */

2901/* Move to the "Top" node in this file. */
2902DECLARE_INFO_COMMAND (info_top_node, _("Select the node `Top' in this file"))void info_top_node (WINDOW *window, int count, unsigned char key
)
2903{
info_parse_and_select ("Top", window);
2905}

2907/* Move to the node "(dir)Top". */
2908DECLARE_INFO_COMMAND (info_dir_node, _("Select the node `(dir)'"))void info_dir_node (WINDOW *window, int count, unsigned char key
)
2909{
info_parse_and_select ("(dir)Top", window);
2911}

2913
2914/* Read the name of a node to kill.  The list of available nodes comes
 from the nodes appearing in the current window configuration. */
2916static char *
2917read_nodename_to_kill (WINDOW *window)
2918{
int iw;
char *nodename;
INFO_WINDOW *info_win;
REFERENCE **menu = NULL((void *)0);
int menu_index = 0, menu_slots = 0;
char *default_nodename = xstrdup (active_window->node->nodename);
char *prompt = xmalloc (strlen (_("Kill node (%s): ")((const char *) ("Kill node (%s): "))) + strlen (default_nodename));

sprintf (prompt, _("Kill node (%s): ")((const char *) ("Kill node (%s): ")), default_nodename);

for (iw = 0; (info_win = info_windows[iw]); iw++)
  {
    REFERENCE *entry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
    entry->label = xstrdup (info_win->window->node->nodename);
    entry->filename = entry->nodename = (char *)NULL((void *)0);

    add_pointer_to_array (entry, menu_index, menu, menu_slots, 10,do { if (menu_index + 2 >= menu_slots) menu = (REFERENCE *
 *)(xrealloc (menu, (menu_slots += 10) * sizeof (REFERENCE *)
)); menu[menu_index++] = (REFERENCE *)entry; menu[menu_index]
 = (REFERENCE *)((void *)0); } while (0)
                          REFERENCE *)do { if (menu_index + 2 >= menu_slots) menu = (REFERENCE *
 *)(xrealloc (menu, (menu_slots += 10) * sizeof (REFERENCE *)
)); menu[menu_index++] = (REFERENCE *)entry; menu[menu_index]
 = (REFERENCE *)((void *)0); } while (0);
  }

nodename = info_read_completing_in_echo_area (window, prompt, menu);
free (prompt);
info_free_references (menu);
if (nodename && !*nodename)
  {
    free (nodename);
    nodename = default_nodename;
  }
else
  free (default_nodename);

return nodename;
2951}


2954/* Delete NODENAME from this window, showing the most
 recently selected node in this window. */
2956static void
2957kill_node (WINDOW *window, char *nodename)
2958{
int iw, i;
INFO_WINDOW *info_win;
NODE *temp;

/* If there is no nodename to kill, quit now. */
if (!nodename)
  {
    info_abort_key (window, 0, 0);
    return;
  }

/* If there is a nodename, find it in our window list. */
for (iw = 0; (info_win = info_windows[iw]); iw++)
  if (strcmp (nodename, info_win->nodes[info_win->current]->nodename) == 0
&& info_win->window == window)
    break;

if (!info_win)
  {
    if (*nodename)
      info_error ((char *) _("Cannot kill node `%s'")((const char *) ("Cannot kill node `%s'")), nodename, NULL((void *)0));
    else
      window_clear_echo_area ();

    return;
  }

/* If there are no more nodes left anywhere to view, complain and exit. */
if (info_windows_index == 1 && info_windows[0]->nodes_index == 1)
  {
    info_error ((char *) _("Cannot kill the last node")((const char *) ("Cannot kill the last node")), NULL((void *)0), NULL((void *)0));
    return;
  }

/* INFO_WIN contains the node that the user wants to stop viewing.  Delete
   this node from the list of nodes previously shown in this window. */
for (i = info_win->current; i < info_win->nodes_index; i++)
  info_win->nodes[i] = info_win->nodes[i + 1];

/* There is one less node in this window's history list. */
info_win->nodes_index--;

/* Make this window show the most recent history node. */
info_win->current = info_win->nodes_index - 1;

/* If there aren't any nodes left in this window, steal one from the
   next window. */
if (info_win->current < 0)
  {
    INFO_WINDOW *stealer;
    int which, pagetop;
    long point;

    if (info_windows[iw + 1])
      stealer = info_windows[iw + 1];
    else
      stealer = info_windows[0];

    /* If the node being displayed in the next window is not the most
       recently loaded one, get the most recently loaded one. */
    if ((stealer->nodes_index - 1) != stealer->current)
      which = stealer->nodes_index - 1;

    /* Else, if there is another node behind the stealers current node,
       use that one. */
    else if (stealer->current > 0)
      which = stealer->current - 1;

    /* Else, just use the node appearing in STEALER's window. */
    else
      which = stealer->current;

    /* Copy this node. */
    {
      NODE *copy = xmalloc (sizeof (NODE));

      temp = stealer->nodes[which];
      point = stealer->points[which];
      pagetop = stealer->pagetops[which];

      copy->filename = temp->filename;
      copy->parent = temp->parent;
      copy->nodename = temp->nodename;
      copy->contents = temp->contents;
      copy->nodelen = temp->nodelen;
      copy->flags = temp->flags;
      copy->display_pos = temp->display_pos;

      temp = copy;
    }

    window_set_node_of_window (info_win->window, temp);
    window->point = point;
    window->pagetop = pagetop;
    remember_window_and_node (info_win->window, temp);
  }
else
  {
    temp = info_win->nodes[info_win->current];
    temp->display_pos = info_win->points[info_win->current];
    window_set_node_of_window (info_win->window, temp);
  }

if (!info_error_was_printed)
  window_clear_echo_area ();

if (auto_footnotes_p)
  info_get_or_remove_footnotes (window);
3067}

3069/* Kill current node, thus going back one in the node history.  I (karl)
 do not think this is completely correct yet, because of the
 window-changing stuff in kill_node, but it's a lot better than the
 previous implementation, which did not account for nodes being
 visited twice at all.  */
3074DECLARE_INFO_COMMAND (info_history_node,void info_history_node (WINDOW *window, int count, unsigned char
 key)
                    _("Select the most recently selected node"))void info_history_node (WINDOW *window, int count, unsigned char
 key)
3076{
kill_node (window, active_window->node->nodename);
3078}

3080/* Kill named node.  */
3081DECLARE_INFO_COMMAND (info_kill_node, _("Kill this node"))void info_kill_node (WINDOW *window, int count, unsigned char
 key)
3082{
char *nodename = read_nodename_to_kill (window);
kill_node (window, nodename);
3085}

3087
3088/* Read the name of a file and select the entire file. */
3089DECLARE_INFO_COMMAND (info_view_file, _("Read the name of a file and select it"))void info_view_file (WINDOW *window, int count, unsigned char
 key)
3090{
char *line;

line = info_read_in_echo_area (window, (char *) _("Find file: ")((const char *) ("Find file: ")));
if (!line)
  {
    info_abort_key (active_window, 1, 0);
    return;
  }

if (*line)
  {
    NODE *node;

    node = info_get_node (line, "*");
    if (!node)
      {
        if (info_recent_file_error)
          info_error (info_recent_file_error, NULL((void *)0), NULL((void *)0));
        else
          info_error ((char *) _("Cannot find `%s'.")((const char *) ("Cannot find `%s'.")), line, NULL((void *)0));
      }
    else
      info_set_node_of_window (1, window, node);

    free (line);
  }

if (!info_error_was_printed)
  window_clear_echo_area ();
3120}
3121
3122/* **************************************************************** */
3123/*                                                                  */
3124/*                 Dumping and Printing Nodes                       */
3125/*                                                                  */
3126/* **************************************************************** */

3128#define VERBOSE_NODE_DUMPING
3129static void write_node_to_stream (NODE *node, FILE *stream);
3130static void dump_node_to_stream (char *filename, char *nodename,
  FILE *stream, int dump_subnodes);
3132static void initialize_dumping (void);

3134/* Dump the nodes specified by FILENAME and NODENAMES to the file named
 in OUTPUT_FILENAME.  If DUMP_SUBNODES is non-zero, recursively dump
 the nodes which appear in the menu of each node dumped. */
3137void
3138dump_nodes_to_file (char *filename, char **nodenames,
  char *output_filename, int dump_subnodes)
3140{
register int i;
FILE *output_stream;

/* Get the stream to print the nodes to.  Special case of an output
   filename of "-" means to dump the nodes to stdout. */
if (strcmp (output_filename, "-") == 0)
  output_stream = stdout(&__sF[1]);
else
  output_stream = fopen (output_filename, "w");

if (!output_stream)
  {
    info_error ((char *) _("Could not create output file `%s'.")((const char *) ("Could not create output file `%s'.")),
        output_filename, NULL((void *)0));
    return;
  }

/* Print each node to stream. */
initialize_dumping ();
for (i = 0; nodenames[i]; i++)
  dump_node_to_stream (filename, nodenames[i], output_stream, dump_subnodes);

if (output_stream != stdout(&__sF[1]))
  fclose (output_stream);

3166#if defined (VERBOSE_NODE_DUMPING)
info_error ((char *) _("Done.")((const char *) ("Done.")), NULL((void *)0), NULL((void *)0));
3168#endif /* VERBOSE_NODE_DUMPING */
3169}

3171/* A place to remember already dumped nodes. */
3172static char **dumped_already = (char **)NULL((void *)0);
3173static int dumped_already_index = 0;
3174static int dumped_already_slots = 0;

3176static void
3177initialize_dumping (void)
3178{
dumped_already_index = 0;
3180}

3182/* Get and print the node specified by FILENAME and NODENAME to STREAM.
 If DUMP_SUBNODES is non-zero, recursively dump the nodes which appear
 in the menu of each node dumped. */
3185static void
3186dump_node_to_stream (char *filename, char *nodename,
  FILE *stream, int dump_subnodes)
3188{
register int i;
NODE *node;

node = info_get_node (filename, nodename);

if (!node)
  {
    if (info_recent_file_error)
      info_error (info_recent_file_error, NULL((void *)0), NULL((void *)0));
    else
      {
        if (filename && *nodename != '(')
          info_error ((char *) msg_cant_file_node,
              filename_non_directory (filename),
              nodename);
        else
          info_error ((char *) msg_cant_find_node, nodename, NULL((void *)0));
      }
    return;
  }

/* If we have already dumped this node, don't dump it again. */
for (i = 0; i < dumped_already_index; i++)
  if (strcmp (node->nodename, dumped_already[i]) == 0)
    {
      free (node);
      return;
    }
add_pointer_to_array (node->nodename, dumped_already_index, dumped_already,do { if (dumped_already_index + 2 >= dumped_already_slots)
 dumped_already = (char * *)(xrealloc (dumped_already, (dumped_already_slots
 += 50) * sizeof (char *))); dumped_already[dumped_already_index
++] = (char *)node->nodename; dumped_already[dumped_already_index
] = (char *)((void *)0); } while (0)
                      dumped_already_slots, 50, char *)do { if (dumped_already_index + 2 >= dumped_already_slots)
 dumped_already = (char * *)(xrealloc (dumped_already, (dumped_already_slots
 += 50) * sizeof (char *))); dumped_already[dumped_already_index
++] = (char *)node->nodename; dumped_already[dumped_already_index
] = (char *)((void *)0); } while (0);

3220#if defined (VERBOSE_NODE_DUMPING)
/* Maybe we should print some information about the node being output. */
info_error ((char *) _("Writing node %s...")((const char *) ("Writing node %s...")), node_printed_rep (node), NULL((void *)0));
3223#endif /* VERBOSE_NODE_DUMPING */

write_node_to_stream (node, stream);

/* If we are dumping subnodes, get the list of menu items in this node,
   and dump each one recursively. */
if (dump_subnodes)
  {
    REFERENCE **menu = (REFERENCE **)NULL((void *)0);

    /* If this node is an Index, do not dump the menu references. */
    if (string_in_line ("Index", node->nodename) == -1)
      menu = info_menu_of_node (node);

    if (menu)
      {
        for (i = 0; menu[i]; i++)
          {
            /* We don't dump Info files which are different than the
               current one. */
            if (!menu[i]->filename)
              dump_node_to_stream
                (filename, menu[i]->nodename, stream, dump_subnodes);
          }
        info_free_references (menu);
      }
  }

free (node);
3252}

3254/* Dump NODE to FILENAME.  If DUMP_SUBNODES is non-zero, recursively dump
 the nodes which appear in the menu of each node dumped. */
3256void
3257dump_node_to_file (NODE *node, char *filename, int dump_subnodes)
3258{
FILE *output_stream;
char *nodes_filename;

/* Get the stream to print this node to.  Special case of an output
   filename of "-" means to dump the nodes to stdout. */
if (strcmp (filename, "-") == 0)
  output_stream = stdout(&__sF[1]);
else
  output_stream = fopen (filename, "w");

if (!output_stream)
  {
    info_error ((char *) _("Could not create output file `%s'.")((const char *) ("Could not create output file `%s'.")), filename,
        NULL((void *)0));
    return;
  }

if (node->parent)
  nodes_filename = node->parent;
else
  nodes_filename = node->filename;

initialize_dumping ();
dump_node_to_stream
  (nodes_filename, node->nodename, output_stream, dump_subnodes);

if (output_stream != stdout(&__sF[1]))
  fclose (output_stream);

3288#if defined (VERBOSE_NODE_DUMPING)
info_error ((char *) _("Done.")((const char *) ("Done.")), NULL((void *)0), NULL((void *)0));
3290#endif /* VERBOSE_NODE_DUMPING */
3291}

3293#if !defined (DEFAULT_INFO_PRINT_COMMAND"lpr")
3294#  define DEFAULT_INFO_PRINT_COMMAND"lpr" "lpr"
3295#endif /* !DEFAULT_INFO_PRINT_COMMAND */

3297DECLARE_INFO_COMMAND (info_print_node,void info_print_node (WINDOW *window, int count, unsigned char
 key)
_("Pipe the contents of this node through INFO_PRINT_COMMAND"))void info_print_node (WINDOW *window, int count, unsigned char
 key)
3299{
print_node (window->node);
3301}

3303/* Print NODE on a printer piping it into INFO_PRINT_COMMAND. */
3304void
3305print_node (NODE *node)
3306{
FILE *printer_pipe;
char *print_command = getenv ("INFO_PRINT_COMMAND");
int piping = 0;

if (!print_command || !*print_command)
  print_command = DEFAULT_INFO_PRINT_COMMAND"lpr";

/* Note that on MS-DOS/MS-Windows, this MUST open the pipe in the
   (default) text mode, since the printer drivers there need to see
   DOS-style CRLF pairs at the end of each line.

   FIXME: if we are to support Mac-style text files, we might need
   to convert the text here.  */

/* INFO_PRINT_COMMAND which says ">file" means write to that file.
   Presumably, the name of the file is the local printer device.  */
if (*print_command == '>')
  printer_pipe = fopen (++print_command, "w");
else
  {
    printer_pipe = popen (print_command, "w");
    piping = 1;
  }

if (!printer_pipe)
  {
    info_error ((char *) _("Cannot open pipe to `%s'.")((const char *) ("Cannot open pipe to `%s'.")), print_command, NULL((void *)0));
    return;
  }

3337#if defined (VERBOSE_NODE_DUMPING)
/* Maybe we should print some information about the node being output. */
info_error ((char *) _("Printing node %s...")((const char *) ("Printing node %s...")), node_printed_rep (node), NULL((void *)0));
3340#endif /* VERBOSE_NODE_DUMPING */

write_node_to_stream (node, printer_pipe);
if (piping)
  pclose (printer_pipe);
else
  fclose (printer_pipe);

3348#if defined (VERBOSE_NODE_DUMPING)
info_error ((char *) _("Done.")((const char *) ("Done.")), NULL((void *)0), NULL((void *)0));
3350#endif /* VERBOSE_NODE_DUMPING */
3351}

3353static void
3354write_node_to_stream (NODE *node, FILE *stream)
3355{
fwrite (node->contents, 1, node->nodelen, stream);
3357}
3358
3359/* **************************************************************** */
3360/*                                                                  */
3361/*                    Info Searching Commands                       */
3362/*                                                                  */
3363/* **************************************************************** */

3365/* Variable controlling the garbage collection of files briefly visited
 during searches.  Such files are normally gc'ed, unless they were
 compressed to begin with.  If this variable is non-zero, it says
 to gc even those file buffer contents which had to be uncompressed. */
3369int gc_compressed_files = 0;

3371static void info_gc_file_buffers (void);
3372static void info_search_1 (WINDOW *window, int count,
  unsigned char key, int case_sensitive, int ask_for_string);

3375static char *search_string = (char *)NULL((void *)0);
3376static int search_string_size = 0;
3377static int isearch_is_active = 0;

3379static int last_search_direction = 0;
3380static int last_search_case_sensitive = 0;

3382/* Return the file buffer which belongs to WINDOW's node. */
3383FILE_BUFFER *
3384file_buffer_of_window (WINDOW *window)
3385{
/* If this window has no node, then it has no file buffer. */
if (!window->node)
  return ((FILE_BUFFER *)NULL((void *)0));

if (window->node->parent)
  return (info_find_file (window->node->parent));

if (window->node->filename)
  return (info_find_file (window->node->filename));

return ((FILE_BUFFER *)NULL((void *)0));
3397}

3399/* Search for STRING in NODE starting at START.  Return -1 if the string
 was not found, or the location of the string if it was.  If WINDOW is
 passed as non-null, set the window's node to be NODE, its point to be
 the found string, and readjust the window's pagetop.  Final argument
 DIR says which direction to search in.  If it is positive, search
 forward, else backwards. */
3405long
3406info_search_in_node (char *string, NODE *node, long int start,
  WINDOW *window, int dir, int case_sensitive)
3408{
SEARCH_BINDING binding;
long offset;

binding.buffer = node->contents;
binding.start = start;
binding.end = node->nodelen;
binding.flags = 0;
if (!case_sensitive)
  binding.flags |= S_FoldCase0x01;

if (dir < 0)
  {
    binding.end = 0;
    binding.flags |= S_SkipDest0x02;
  }

if (binding.start < 0)
  return (-1);

/* For incremental searches, we always wish to skip past the string. */
if (isearch_is_active)
  binding.flags |= S_SkipDest0x02;

offset = search (string, &binding);

if (offset != -1 && window)
  {
    set_remembered_pagetop_and_point (window);
    if (window->node != node)
      window_set_node_of_window (window, node);
    window->point = offset;
    window_adjust_pagetop (window);
  }
return (offset);
3443}

3445/* Search NODE, looking for the largest possible match of STRING.  Start the
 search at START.  Return the absolute position of the match, or -1, if
 no part of the string could be found. */
3448long
3449info_target_search_node (NODE *node, char *string, long int start)
3450{
register int i;
long offset = 0;
char *target;

target = xstrdup (string);
i = strlen (target);

/* Try repeatedly searching for this string while removing words from
   the end of it. */
while (i)
  {
    target[i] = '\0';
    offset = info_search_in_node (target, node, start, (WINDOW *)NULL((void *)0), 1, 0);

    if (offset != -1)
      break;

    /* Delete the last word from TARGET. */
    for (; i && (!whitespace (target[i])((target[i] == ' ') || (target[i] == '\t')) && (target[i] != ',')); i--);
  }
free (target);
return (offset);
3473}

3475/* Search for STRING starting in WINDOW at point.  If the string is found
 in this node, set point to that position.  Otherwise, get the file buffer
 associated with WINDOW's node, and search through each node in that file.
 If the search fails, return non-zero, else zero.  Side-effect window
 leaving the node and point where the string was found current. */
3480static int
3481info_search_internal (char *string, WINDOW *window,
  int dir, int case_sensitive)
3483{
register int i;
FILE_BUFFER *file_buffer;
char *initial_nodename;
long ret, start = 0;

file_buffer = file_buffer_of_window (window);
initial_nodename = window->node->nodename;

/* This used to begin from window->point, unless this was a repeated
   search command.  But invoking search with an argument loses with
   that logic, since info_last_executed_command is then set to
   info_add_digit_to_numeric_arg.  I think there's no sense in
   ``finding'' a string that is already under the cursor, anyway.  */
ret = info_search_in_node
      (string, window->node, window->point + dir, window, dir,
       case_sensitive);

if (ret != -1)
  {
    /* We won! */
    if (!echo_area_is_active && !isearch_is_active)
      window_clear_echo_area ();
    return (0);
  }

/* The string wasn't found in the current node.  Search through the
   window's file buffer, iff the current node is not "*". */
if (!file_buffer || (strcmp (initial_nodename, "*") == 0))
  return (-1);

/* If this file has tags, search through every subfile, starting at
   this node's subfile and node.  Otherwise, search through the
   file's node list. */
if (file_buffer->tags)
  {
    register int current_tag = 0, number_of_tags;
    char *last_subfile;
    TAG *tag;

    /* Find number of tags and current tag. */
    last_subfile = (char *)NULL((void *)0);
    for (i = 0; file_buffer->tags[i]; i++)
      if (strcmp (initial_nodename, file_buffer->tags[i]->nodename) == 0)
        {
          current_tag = i;
          last_subfile = file_buffer->tags[i]->filename;
        }

    number_of_tags = i;

    /* If there is no last_subfile, our tag wasn't found. */
    if (!last_subfile)
      return (-1);

    /* Search through subsequent nodes, wrapping around to the top
       of the info file until we find the string or return to this
       window's node and point. */
    while (1)
      {
        NODE *node;

        /* Allow C-g to quit the search, failing it if pressed. */
        return_if_control_g (-1)do { info_gather_typeahead (); if (info_input_pending_p () ==
 ((toupper ('g')) & (~0x40))) return (-1); } while (0);

        /* Find the next tag that isn't an anchor.  */
        for (i = current_tag + dir; i != current_tag; i += dir)
          {
            if (i < 0)
              i = number_of_tags - 1;
            else if (i == number_of_tags)
              i = 0;

            tag = file_buffer->tags[i];
            if (tag->nodelen != 0)
              break;
          }

        /* If we got past out starting point, bail out.  */
        if (i == current_tag)
          return (-1);
        current_tag = i;

        if (!echo_area_is_active && (last_subfile != tag->filename))
          {
            window_message_in_echo_area
              ((char *) _("Searching subfile %s ...")((const char *) ("Searching subfile %s ...")),
               filename_non_directory (tag->filename), NULL((void *)0));

            last_subfile = tag->filename;
          }

        node = info_get_node (file_buffer->filename, tag->nodename);

        if (!node)
          {
            /* If not doing i-search... */
            if (!echo_area_is_active)
              {
                if (info_recent_file_error)
                  info_error (info_recent_file_error, NULL((void *)0), NULL((void *)0));
                else
                  info_error ((char *) msg_cant_file_node,
                              filename_non_directory (file_buffer->filename),
                              tag->nodename);
              }
            return (-1);
          }

        if (dir < 0)
          start = tag->nodelen;

        ret =
          info_search_in_node (string, node, start, window, dir,
                               case_sensitive);

        /* Did we find the string in this node? */
        if (ret != -1)
          {
            /* Yes!  We win. */
            remember_window_and_node (window, node);
            if (!echo_area_is_active)
              window_clear_echo_area ();
            return (0);
          }

        /* No.  Free this node, and make sure that we haven't passed
           our starting point. */
        free (node);

        if (strcmp (initial_nodename, tag->nodename) == 0)
          return (-1);
      }
  }
return (-1);
3618}

3620DECLARE_INFO_COMMAND (info_search_case_sensitively,void info_search_case_sensitively (WINDOW *window, int count,
 unsigned char key)
                    _("Read a string and search for it case-sensitively"))void info_search_case_sensitively (WINDOW *window, int count,
 unsigned char key)
3622{
last_search_direction = count > 0 ? 1 : -1;
last_search_case_sensitive = 1;
info_search_1 (window, count, key, 1, 1);
3626}

3628DECLARE_INFO_COMMAND (info_search, _("Read a string and search for it"))void info_search (WINDOW *window, int count, unsigned char key
)
3629{
last_search_direction = count > 0 ? 1 : -1;
last_search_case_sensitive = 0;
info_search_1 (window, count, key, 0, 1);
3633}

3635DECLARE_INFO_COMMAND (info_search_backward,void info_search_backward (WINDOW *window, int count, unsigned
 char key)
      _("Read a string and search backward for it"))void info_search_backward (WINDOW *window, int count, unsigned
 char key)
3637{
last_search_direction = count > 0 ? -1 : 1;
last_search_case_sensitive = 0;
info_search_1 (window, -count, key, 0, 1);
3641}

3643static void
3644info_search_1 (WINDOW *window, int count, unsigned char key,
  int case_sensitive, int ask_for_string)
3646{
char *line, *prompt;
int result, old_pagetop;
int direction;

if (count < 0)
  {
    direction = -1;
    count = -count;
  }
else
  {
    direction = 1;
    if (count == 0)
      count = 1;	/* for backward compatibility */
  }

/* Read a string from the user, defaulting the search to SEARCH_STRING. */
if (!search_string)
  {
    search_string = (char *)xmalloc (search_string_size = 100);
    search_string[0] = '\0';
  }

if (ask_for_string)
  {
    prompt = (char *)xmalloc (strlen (_("%s%sfor string [%s]: ")((const char *) ("%s%sfor string [%s]: ")))
		+ strlen (_("Search backward")((const char *) ("Search backward")))
		+ strlen (_("Search")((const char *) ("Search")))
		+ strlen (_(" case-sensitively ")((const char *) (" case-sensitively ")))
		+ strlen (_(" ")((const char *) (" ")))
		+ strlen (search_string));

    sprintf (prompt, _("%s%sfor string [%s]: ")((const char *) ("%s%sfor string [%s]: ")),
             direction < 0 ? _("Search backward")((const char *) ("Search backward")) : _("Search")((const char *) ("Search")),
             case_sensitive ? _(" case-sensitively ")((const char *) (" case-sensitively ")) : _(" ")((const char *) (" ")),
             search_string);

    line = info_read_in_echo_area (window, prompt);
    free (prompt);

    if (!line)
      {
        info_abort_key (window, 0, 0);
        return;
      }

    if (*line)
      {
        if (strlen (line) + 1 > (unsigned int) search_string_size)
          search_string = (char *) xrealloc
            (search_string, (search_string_size += 50 + strlen (line)));

        strcpy (search_string, line);
        free (line);
      }
  }

/* If the search string includes upper-case letters, make the search
   case-sensitive.  */
if (case_sensitive == 0)
  for (line = search_string; *line; line++)
    if (isupper (*line))
      {
        case_sensitive = 1;
        break;
      }

old_pagetop = active_window->pagetop;
for (result = 0; result == 0 && count--; )
  result = info_search_internal (search_string,
                                 active_window, direction, case_sensitive);

if (result != 0 && !info_error_was_printed)
  info_error ((char *) _("Search failed.")((const char *) ("Search failed.")), NULL((void *)0), NULL((void *)0));
else if (old_pagetop != active_window->pagetop)
  {
    int new_pagetop;

    new_pagetop = active_window->pagetop;
    active_window->pagetop = old_pagetop;
    set_window_pagetop (active_window, new_pagetop);
    if (auto_footnotes_p)
      info_get_or_remove_footnotes (active_window);
  }

/* Perhaps free the unreferenced file buffers that were searched, but
   not retained. */
info_gc_file_buffers ();
3735}

3737DECLARE_INFO_COMMAND (info_search_next,void info_search_next (WINDOW *window, int count, unsigned char
 key)
      _("Repeat last search in the same direction"))void info_search_next (WINDOW *window, int count, unsigned char
 key)
3739{
if (!last_search_direction)
  info_error ((char *) _("No previous search string")((const char *) ("No previous search string")), NULL((void *)0), NULL((void *)0));
else
  info_search_1 (window, last_search_direction * count,
   key, last_search_case_sensitive, 0);
3745}

3747DECLARE_INFO_COMMAND (info_search_previous,void info_search_previous (WINDOW *window, int count, unsigned
 char key)
      _("Repeat last search in the reverse direction"))void info_search_previous (WINDOW *window, int count, unsigned
 char key)
3749{
if (!last_search_direction)
  info_error ((char *) _("No previous search string")((const char *) ("No previous search string")), NULL((void *)0), NULL((void *)0));
else
  info_search_1 (window, -last_search_direction * count,
   key, last_search_case_sensitive, 0);
3755}

3757/* **************************************************************** */
3758/*                                                                  */
3759/*                      Incremental Searching                       */
3760/*                                                                  */
3761/* **************************************************************** */

3763static void incremental_search (WINDOW *window, int count,
  unsigned char ignore);

3766DECLARE_INFO_COMMAND (isearch_forward,void isearch_forward (WINDOW *window, int count, unsigned char
 key)
                    _("Search interactively for a string as you type it"))void isearch_forward (WINDOW *window, int count, unsigned char
 key)
3768{
incremental_search (window, count, key);
3770}

3772DECLARE_INFO_COMMAND (isearch_backward,void isearch_backward (WINDOW *window, int count, unsigned char
 key)
                    _("Search interactively for a string as you type it"))void isearch_backward (WINDOW *window, int count, unsigned char
 key)
3774{
incremental_search (window, -count, key);
3776}

3778/* Incrementally search for a string as it is typed. */
3779/* The last accepted incremental search string. */
3780static char *last_isearch_accepted = (char *)NULL((void *)0);

3782/* The current incremental search string. */
3783static char *isearch_string = (char *)NULL((void *)0);
3784static int isearch_string_index = 0;
3785static int isearch_string_size = 0;
3786static unsigned char isearch_terminate_search_key = ESC'\033';

3788/* Array of search states. */
3789static SEARCH_STATE **isearch_states = (SEARCH_STATE **)NULL((void *)0);
3790static int isearch_states_index = 0;
3791static int isearch_states_slots = 0;

3793/* Push the state of this search. */
3794static void
3795push_isearch (WINDOW *window, int search_index, int direction, int failing)
3796{
SEARCH_STATE *state;

state = (SEARCH_STATE *)xmalloc (sizeof (SEARCH_STATE));
window_get_state (window, state);
state->search_index = search_index;
state->direction = direction;
state->failing = failing;

add_pointer_to_array (state, isearch_states_index, isearch_states,do { if (isearch_states_index + 2 >= isearch_states_slots)
 isearch_states = (SEARCH_STATE * *)(xrealloc (isearch_states
, (isearch_states_slots += 20) * sizeof (SEARCH_STATE *))); isearch_states
[isearch_states_index++] = (SEARCH_STATE *)state; isearch_states
[isearch_states_index] = (SEARCH_STATE *)((void *)0); } while
 (0)
                      isearch_states_slots, 20, SEARCH_STATE *)do { if (isearch_states_index + 2 >= isearch_states_slots)
 isearch_states = (SEARCH_STATE * *)(xrealloc (isearch_states
, (isearch_states_slots += 20) * sizeof (SEARCH_STATE *))); isearch_states
[isearch_states_index++] = (SEARCH_STATE *)state; isearch_states
[isearch_states_index] = (SEARCH_STATE *)((void *)0); } while
 (0);
3807}

3809/* Pop the state of this search to WINDOW, SEARCH_INDEX, and DIRECTION. */
3810static void
3811pop_isearch (WINDOW *window, int *search_index, int *direction, int *failing)
3812{
SEARCH_STATE *state;

if (isearch_states_index)
  {
    isearch_states_index--;
    state = isearch_states[isearch_states_index];
    window_set_state (window, state);
    *search_index = state->search_index;
    *direction = state->direction;
    *failing = state->failing;

    free (state);
    isearch_states[isearch_states_index] = (SEARCH_STATE *)NULL((void *)0);
  }
3827}

3829/* Free the memory used by isearch_states. */
3830static void
3831free_isearch_states (void)
3832{
register int i;

for (i = 0; i < isearch_states_index; i++)
  {
    free (isearch_states[i]);
    isearch_states[i] = (SEARCH_STATE *)NULL((void *)0);
  }
isearch_states_index = 0;
3841}

3843/* Display the current search in the echo area. */
3844static void
3845show_isearch_prompt (int dir, unsigned char *string, int failing_p)
3846{
register int i;
const char *prefix;
char *prompt, *p_rep;
unsigned int prompt_len, p_rep_index, p_rep_size;

if (dir < 0)
  prefix = _("I-search backward: ")((const char *) ("I-search backward: "));
else
  prefix = _("I-search: ")((const char *) ("I-search: "));

p_rep_index = p_rep_size = 0;
p_rep = (char *)NULL((void *)0);
for (i = 0; string[i]; i++)
  {
    char *rep;

    switch (string[i])
      {
      case ' ': rep = " "; break;
      case LFD'\n': rep = "\\n"; break;
      case TAB'\011': rep = "\\t"; break;
      default:
        rep = pretty_keyname (string[i]);
      }
    if ((p_rep_index + strlen (rep) + 1) >= p_rep_size)
      p_rep = (char *)xrealloc (p_rep, p_rep_size += 100);

    strcpy (p_rep + p_rep_index, rep);
    p_rep_index += strlen (rep);
  }

prompt_len = strlen (prefix) + p_rep_index + 1;
if (failing_p)
  prompt_len += strlen (_("Failing ")((const char *) ("Failing ")));
prompt = xmalloc (prompt_len);
sprintf (prompt, "%s%s%s", failing_p ? _("Failing ")((const char *) ("Failing ")) : "", prefix,
         p_rep ? p_rep : "");

window_message_in_echo_area ("%s", prompt, NULL((void *)0));
maybe_free (p_rep)do { if (p_rep) free (p_rep); } while (0);
free (prompt);
display_cursor_at_point (active_window);
3889}

3891static void
3892incremental_search (WINDOW *window, int count, unsigned char ignore)
3893{
unsigned char key;
int last_search_result, search_result, dir;
SEARCH_STATE mystate, orig_state;
char *p;
int case_sensitive = 0;

if (count < 0)
  dir = -1;
else
  dir = 1;

last_search_result = search_result = 0;

window_get_state (window, &orig_state);

isearch_string_index = 0;
if (!isearch_string_size)
  isearch_string = (char *)xmalloc (isearch_string_size = 50);

/* Show the search string in the echo area. */
isearch_string[isearch_string_index] = '\0';
show_isearch_prompt (dir, (unsigned char *) isearch_string, search_result);

isearch_is_active = 1;

while (isearch_is_active)
  {
    VFunction *func = (VFunction *)NULL((void *)0);
    int quoted = 0;

    /* If a recent display was interrupted, then do the redisplay now if
       it is convenient. */
    if (!info_any_buffered_input_p () && display_was_interrupted_p)
      {
        display_update_one_window (window);
        display_cursor_at_point (active_window);
      }

    /* Read a character and dispatch on it. */
    key = info_get_input_char ();
    window_get_state (window, &mystate);

    if (key == DEL'\177' || key == Control ('h')((toupper ('h')) & (~0x40)))
      {
        /* User wants to delete one level of search? */
        if (!isearch_states_index)
          {
            terminal_ring_bell ();
            continue;
          }
        else
          {
            pop_isearch
              (window, &isearch_string_index, &dir, &search_result);
            isearch_string[isearch_string_index] = '\0';
            show_isearch_prompt (dir, (unsigned char *) isearch_string,
                search_result);
            goto after_search;
          }
      }
    else if (key == Control ('q')((toupper ('q')) & (~0x40)))
      {
        key = info_get_input_char ();
        quoted = 1;
      }

    /* We are about to search again, or quit.  Save the current search. */
    push_isearch (window, isearch_string_index, dir, search_result);

    if (quoted)
      goto insert_and_search;

    if (!Meta_p (key)(((key) > ('\177' + 1))) || key > 32)
      {
        /* If this key is not a keymap, get its associated function,
           if any.  If it is a keymap, then it's probably ESC from an
           arrow key, and we handle that case below.  */
        char type = window->keymap[key].type;
        func = type == ISFUNC0
               ? InfoFunction(window->keymap[key].function)((window->keymap[key].function) ? (window->keymap[key].
function)->func : (VFunction *) ((void *)0))
               : NULL((void *)0);  /* function member is a Keymap if ISKMAP */

        if (isprint (key) || (type == ISFUNC0 && func == NULL((void *)0)))
          {
          insert_and_search:

            if (isearch_string_index + 2 >= isearch_string_size)
              isearch_string = (char *)xrealloc
                (isearch_string, isearch_string_size += 100);

            isearch_string[isearch_string_index++] = key;
            isearch_string[isearch_string_index] = '\0';
            goto search_now;
          }
        else if (func == (VFunction *) isearch_forward
            || func == (VFunction *) isearch_backward)
          {
     /* If this key invokes an incremental search, then this
 means that we will either search again in the same
 direction, search again in the reverse direction, or
 insert the last search string that was accepted through
 incremental searching. */
            if ((func == (VFunction *) isearch_forward && dir > 0) ||
                (func == (VFunction *) isearch_backward && dir < 0))
              {
                /* If the user has typed no characters, then insert the
                   last successful search into the current search string. */
                if (isearch_string_index == 0)
                  {
                    /* Of course, there must be something to insert. */
                    if (last_isearch_accepted)
                      {
                        if (strlen ((char *) last_isearch_accepted) + 1
                            >= (unsigned int) isearch_string_size)
                          isearch_string = (char *)
                            xrealloc (isearch_string,
                                      isearch_string_size += 10 +
                                      strlen (last_isearch_accepted));
                        strcpy (isearch_string, last_isearch_accepted);
                        isearch_string_index = strlen (isearch_string);
                        goto search_now;
                      }
                    else
                      continue;
                  }
                else
                  {
                    /* Search again in the same direction.  This means start
                       from a new place if the last search was successful. */
                    if (search_result == 0)
                      window->point += dir;
                  }
              }
            else
              {
                /* Reverse the direction of the search. */
                dir = -dir;
              }
          }
        else if (func == (VFunction *) info_abort_key)
          {
            /* If C-g pressed, and the search is failing, pop the search
               stack back to the last unfailed search. */
            if (isearch_states_index && (search_result != 0))
              {
                terminal_ring_bell ();
                while (isearch_states_index && (search_result != 0))
                  pop_isearch
                    (window, &isearch_string_index, &dir, &search_result);
                isearch_string[isearch_string_index] = '\0';
                show_isearch_prompt (dir, (unsigned char *) isearch_string,
                    search_result);
                continue;
              }
            else
              goto exit_search;
          }
        else
          goto exit_search;
      }
    else
      {
      exit_search:
        /* The character is not printable, or it has a function which is
           non-null.  Exit the search, remembering the search string.  If
           the key is not the same as the isearch_terminate_search_key,
           then push it into pending input. */
        if (isearch_string_index && func != (VFunction *) info_abort_key)
          {
            maybe_free (last_isearch_accepted)do { if (last_isearch_accepted) free (last_isearch_accepted);
 } while (0);
            last_isearch_accepted = xstrdup (isearch_string);
          }

 /* If the key is the isearch_terminate_search_key, but some buffered
    input is pending, it is almost invariably because the ESC key is
    actually the beginning of an escape sequence, like in case they
    pressed an arrow key.  So don't gobble the ESC key, push it back
    into pending input.  */
 /* FIXME: this seems like a kludge!  We need a more reliable
    mechanism to know when ESC is a separate key and when it is
    part of an escape sequence.  */
        if (key != RET'\r'  /* Emacs addicts want RET to get lost */
     && (key != isearch_terminate_search_key
  || info_any_buffered_input_p ()))
          info_set_pending_input (key);

        if (func == (VFunction *) info_abort_key)
          {
            if (isearch_states_index)
              window_set_state (window, &orig_state);
          }

        if (!echo_area_is_active)
          window_clear_echo_area ();

        if (auto_footnotes_p)
          info_get_or_remove_footnotes (active_window);

        isearch_is_active = 0;
        continue;
      }

    /* Search for the contents of isearch_string. */
  search_now:
    show_isearch_prompt (dir, (unsigned char *) isearch_string, search_result);

    /* If the search string includes upper-case letters, make the
       search case-sensitive.  */
    for (p = isearch_string; *p; p++)
      if (isupper (*p))
        {
          case_sensitive = 1;
          break;
        }
    

    if (search_result == 0)
      {
        /* Check to see if the current search string is right here.  If
           we are looking at it, then don't bother calling the search
           function. */
        if (((dir < 0) &&
      ((case_sensitive ? strncmp : strncasecmp)
                          (window->node->contents + window->point,
                           isearch_string, isearch_string_index) == 0)) ||
            ((dir > 0) &&
             ((window->point - isearch_string_index) >= 0) &&
      ((case_sensitive ? strncmp : strncasecmp)
                          (window->node->contents +
                           (window->point - (isearch_string_index - 1)),
                           isearch_string, isearch_string_index) == 0)))
          {
            if (dir > 0)
              window->point++;
          }
        else
          search_result = info_search_internal (isearch_string,
				  window, dir, case_sensitive);
      }

    /* If this search failed, and we didn't already have a failed search,
       then ring the terminal bell. */
    if (search_result != 0 && last_search_result == 0)
      terminal_ring_bell ();

  after_search:
    show_isearch_prompt (dir, (unsigned char *) isearch_string, search_result);

    if (search_result == 0)
      {
        if ((mystate.node == window->node) &&
            (mystate.pagetop != window->pagetop))
          {
            int newtop = window->pagetop;
            window->pagetop = mystate.pagetop;
            set_window_pagetop (window, newtop);
          }
        display_update_one_window (window);
        display_cursor_at_point (window);
      }

    last_search_result = search_result;
  }

/* Free the memory used to remember each search state. */
free_isearch_states ();

/* Perhaps GC some file buffers. */
info_gc_file_buffers ();

/* After searching, leave the window in the correct state. */
if (!echo_area_is_active)
  window_clear_echo_area ();
4167}

4169/* GC some file buffers.  A file buffer can be gc-ed if there we have
 no nodes in INFO_WINDOWS that reference this file buffer's contents.
 Garbage collecting a file buffer means to free the file buffers
 contents. */
4173static void
4174info_gc_file_buffers (void)
4175{
register int fb_index, iw_index, i;
register FILE_BUFFER *fb;
register INFO_WINDOW *iw;

if (!info_loaded_files)
  return;

for (fb_index = 0; (fb = info_loaded_files[fb_index]); fb_index++)
  {
    int fb_referenced_p = 0;

    /* If already gc-ed, do nothing. */
    if (!fb->contents)
      continue;

    /* If this file had to be uncompressed, check to see if we should
       gc it.  This means that the user-variable "gc-compressed-files"
       is non-zero. */
    if ((fb->flags & N_IsCompressed0x08) && !gc_compressed_files)
      continue;

    /* If this file's contents are not gc-able, move on. */
    if (fb->flags & N_CannotGC0x20)
      continue;

    /* Check each INFO_WINDOW to see if it has any nodes which reference
       this file. */
    for (iw_index = 0; (iw = info_windows[iw_index]); iw_index++)
      {
        for (i = 0; iw->nodes && iw->nodes[i]; i++)
          {
            if ((FILENAME_CMPstrcmp (fb->fullpath, iw->nodes[i]->filename) == 0) ||
                (FILENAME_CMPstrcmp (fb->filename, iw->nodes[i]->filename) == 0))
              {
                fb_referenced_p = 1;
                break;
              }
          }
      }

    /* If this file buffer wasn't referenced, free its contents. */
    if (!fb_referenced_p)
      {
        free (fb->contents);
        fb->contents = (char *)NULL((void *)0);
      }
  }
4223}
4224
4225/* **************************************************************** */
4226/*                                                                  */
4227/*                Traversing and Selecting References               */
4228/*                                                                  */
4229/* **************************************************************** */

4231/* Move to the next or previous cross reference in this node. */
4232static void
4233info_move_to_xref (WINDOW *window, int count, unsigned char key, int dir)
4234{
long firstmenu, firstxref;
long nextmenu, nextxref;
long placement = -1;
long start = 0;
NODE *node = window->node;

if (dir < 0)
  start = node->nodelen;

/* This search is only allowed to fail if there is no menu or cross
   reference in the current node.  Otherwise, the first menu or xref
   found is moved to. */

firstmenu = info_search_in_node
  (INFO_MENU_ENTRY_LABEL"\n* ", node, start, (WINDOW *)NULL((void *)0), dir, 0);

/* FIRSTMENU may point directly to the line defining the menu.  Skip that
   and go directly to the first item. */

if (firstmenu != -1)
  {
    char *text = node->contents + firstmenu;

    if (strncmp (text, INFO_MENU_LABEL"\n* Menu:", strlen (INFO_MENU_LABEL"\n* Menu:")) == 0)
      firstmenu = info_search_in_node
        (INFO_MENU_ENTRY_LABEL"\n* ", node, firstmenu + dir, (WINDOW *)NULL((void *)0), dir, 0);
  }

firstxref =
  info_search_in_node (INFO_XREF_LABEL"*Note", node, start, (WINDOW *)NULL((void *)0), dir, 0);

4266#if defined (HANDLE_MAN_PAGES)
if ((firstxref == -1) && (node->flags & N_IsManPage0x40))
  {
    firstxref = locate_manpage_xref (node, start, dir);
  }
4271#endif /* HANDLE_MAN_PAGES */

if (firstmenu == -1 && firstxref == -1)
  {
    info_error ((char *) msg_no_xref_node, NULL((void *)0), NULL((void *)0));
    return;
  }

/* There is at least one cross reference or menu entry in this node.
   Try hard to find the next available one. */

nextmenu = info_search_in_node
  (INFO_MENU_ENTRY_LABEL"\n* ", node, window->point + dir, (WINDOW *)NULL((void *)0), dir, 0);

nextxref = info_search_in_node
  (INFO_XREF_LABEL"*Note", node, window->point + dir, (WINDOW *)NULL((void *)0), dir, 0);

4288#if defined (HANDLE_MAN_PAGES)
if ((nextxref == -1) && (node->flags & N_IsManPage0x40) && (firstxref != -1))
  nextxref = locate_manpage_xref (node, window->point + dir, dir);
4291#endif /* HANDLE_MAN_PAGES */

/* Ignore "Menu:" as a menu item. */
if (nextmenu != -1)
  {
    char *text = node->contents + nextmenu;

    if (strncmp (text, INFO_MENU_LABEL"\n* Menu:", strlen (INFO_MENU_LABEL"\n* Menu:")) == 0)
      nextmenu = info_search_in_node
        (INFO_MENU_ENTRY_LABEL"\n* ", node, nextmenu + dir, (WINDOW *)NULL((void *)0), dir, 0);
  }

/* If there is both a next menu entry, and a next xref entry, choose the
   one which occurs first.  Otherwise, select the one which actually
   appears in this node following point. */
if (nextmenu != -1 && nextxref != -1)
  {
    if (((dir == 1) && (nextmenu < nextxref)) ||
        ((dir == -1) && (nextmenu > nextxref)))
      placement = nextmenu + 1;
    else
      placement = nextxref;
  }
else if (nextmenu != -1)
  placement = nextmenu + 1;
else if (nextxref != -1)
  placement = nextxref;

/* If there was neither a menu or xref entry appearing in this node after
   point, choose the first menu or xref entry appearing in this node. */
if (placement == -1)
  {
    if (firstmenu != -1 && firstxref != -1)
      {
        if (((dir == 1) && (firstmenu < firstxref)) ||
            ((dir == -1) && (firstmenu > firstxref)))
          placement = firstmenu + 1;
        else
          placement = firstxref;
      }
    else if (firstmenu != -1)
      placement = firstmenu + 1;
    else
      placement = firstxref;
  }
window->point = placement;
window_adjust_pagetop (window);
window->flags |= W_UpdateWindow0x01;
4339}

4341DECLARE_INFO_COMMAND (info_move_to_prev_xref,void info_move_to_prev_xref (WINDOW *window, int count, unsigned
 char key)
                    _("Move to the previous cross reference"))void info_move_to_prev_xref (WINDOW *window, int count, unsigned
 char key)
4343{
if (count < 0)
  info_move_to_prev_xref (window, -count, key);
else
  info_move_to_xref (window, count, key, -1);
4348}

4350DECLARE_INFO_COMMAND (info_move_to_next_xref,void info_move_to_next_xref (WINDOW *window, int count, unsigned
 char key)
                    _("Move to the next cross reference"))void info_move_to_next_xref (WINDOW *window, int count, unsigned
 char key)
4352{
if (count < 0)
  info_move_to_next_xref (window, -count, key);
else
  info_move_to_xref (window, count, key, 1);
4357}

4359/* Select the menu item or reference that appears on this line. */
4360DECLARE_INFO_COMMAND (info_select_reference_this_line,void info_select_reference_this_line (WINDOW *window, int count
, unsigned char key)
                    _("Select reference or menu item appearing on this line"))void info_select_reference_this_line (WINDOW *window, int count
, unsigned char key)
4362{
char *line;

if (window->line_starts)
  line = window->line_starts[window_line_of_point (window)];
else
  line = "";

/* If this line contains a menu item, select that one. */
if (strncmp ("* ", line, 2) == 0)
  info_menu_or_ref_item (window, count, key, info_menu_of_node, 0);
else
  info_menu_or_ref_item (window, count, key, info_xrefs_of_node, 0);
4375}
4376
4377/* **************************************************************** */
4378/*                                                                  */
4379/*                  Miscellaneous Info Commands                     */
4380/*                                                                  */
4381/* **************************************************************** */

4383/* What to do when C-g is pressed in a window. */
4384DECLARE_INFO_COMMAND (info_abort_key, _("Cancel current operation"))void info_abort_key (WINDOW *window, int count, unsigned char
 key)
4385{
/* If error printing doesn't oridinarily ring the bell, do it now,
   since C-g always rings the bell.  Otherwise, let the error printer
   do it. */
if (!info_error_rings_bell_p)
  terminal_ring_bell ();
info_error ((char *) _("Quit")((const char *) ("Quit")), NULL((void *)0), NULL((void *)0));

info_initialize_numeric_arg ();
info_clear_pending_input ();
info_last_executed_command = (VFunction *)NULL((void *)0);
4396}

4398/* Move the cursor to the desired line of the window. */
4399DECLARE_INFO_COMMAND (info_move_to_window_line,void info_move_to_window_line (WINDOW *window, int count, unsigned
 char key)
 _("Move the cursor to a specific line of the window"))void info_move_to_window_line (WINDOW *window, int count, unsigned
 char key)
4401{
int line;

/* With no numeric argument of any kind, default to the center line. */
if (!info_explicit_arg && count == 1)
  line = (window->height / 2) + window->pagetop;
else
  {
    if (count < 0)
      line = (window->height + count) + window->pagetop;
    else
      line = window->pagetop + count;
  }

/* If the line doesn't appear in this window, make it do so. */
if ((line - window->pagetop) >= window->height)
  line = window->pagetop + (window->height - 1);

/* If the line is too small, make it fit. */
if (line < window->pagetop)
  line = window->pagetop;

/* If the selected line is past the bottom of the node, force it back. */
if (line >= window->line_count)
  line = window->line_count - 1;

window->point = (window->line_starts[line] - window->node->contents);
4428}

4430/* Clear the screen and redraw its contents.  Given a numeric argument,
 move the line the cursor is on to the COUNT'th line of the window. */
4432DECLARE_INFO_COMMAND (info_redraw_display, _("Redraw the display"))void info_redraw_display (WINDOW *window, int count, unsigned
 char key)
4433{
if ((!info_explicit_arg && count == 1) || echo_area_is_active)
  {
    terminal_clear_screen ();
    display_clear_display (the_display);
    window_mark_chain (windows, W_UpdateWindow0x01);
    display_update_display (windows);
  }
else
  {
    int desired_line, point_line;
    int new_pagetop;

    point_line = window_line_of_point (window) - window->pagetop;

    if (count < 0)
      desired_line = window->height + count;
    else
      desired_line = count;

    if (desired_line < 0)
      desired_line = 0;

    if (desired_line >= window->height)
      desired_line = window->height - 1;

    if (desired_line == point_line)
      return;

    new_pagetop = window->pagetop + (point_line - desired_line);

    set_window_pagetop (window, new_pagetop);
  }
4466}
4467/* This command does nothing.  It is the fact that a key is bound to it
 that has meaning.  See the code at the top of info_session (). */
4469DECLARE_INFO_COMMAND (info_quit, _("Quit using Info"))void info_quit (WINDOW *window, int count, unsigned char key)
4470{}

4472
4473/* **************************************************************** */
4474/*                                                                  */
4475/*               Reading Keys and Dispatching on Them               */
4476/*                                                                  */
4477/* **************************************************************** */

4479/* Declaration only.  Special cased in info_dispatch_on_key ().
 Doc string is to avoid ugly results with describe_key etc.  */
4481DECLARE_INFO_COMMAND (info_do_lowercase_version,void info_do_lowercase_version (WINDOW *window, int count, unsigned
 char key)
      _("Run command bound to this key's lowercase variant"))void info_do_lowercase_version (WINDOW *window, int count, unsigned
 char key)
4483{}

4485static void
4486dispatch_error (char *keyseq)
4487{
char *rep;

rep = pretty_keyseq (keyseq);

if (!echo_area_is_active)
  info_error ((char *) _("Unknown command (%s).")((const char *) ("Unknown command (%s).")), rep, NULL((void *)0));
else
  {
    char *temp = xmalloc (1 + strlen (rep) + strlen (_("\"%s\" is invalid")((const char *) ("\"%s\" is invalid"))));
    sprintf (temp, _("`%s' is invalid")((const char *) ("`%s' is invalid")), rep);
    terminal_ring_bell ();
    inform_in_echo_area (temp);
    free (temp);
  }
4502}

4504/* Keeping track of key sequences. */
4505static char *info_keyseq = (char *)NULL((void *)0);
4506static int info_keyseq_index = 0;
4507static int info_keyseq_size = 0;
4508static int info_keyseq_displayed_p = 0;

4510/* Initialize the length of the current key sequence. */
4511void
4512initialize_keyseq (void)
4513{
info_keyseq_index = 0;
info_keyseq_displayed_p = 0;
4516}

4518/* Add CHARACTER to the current key sequence. */
4519void
4520add_char_to_keyseq (char character)
4521{
if (info_keyseq_index + 2 >= info_keyseq_size)
  info_keyseq = (char *)xrealloc (info_keyseq, info_keyseq_size += 10);

info_keyseq[info_keyseq_index++] = character;
info_keyseq[info_keyseq_index] = '\0';
4527}

4529/* Display the current value of info_keyseq.  If argument EXPECTING is
 non-zero, input is expected to be read after the key sequence is
 displayed, so add an additional prompting character to the sequence. */
4532static void
4533display_info_keyseq (int expecting_future_input)
4534{
char *rep;

rep = pretty_keyseq (info_keyseq);
if (expecting_future_input)
  strcat (rep, "-");

if (echo_area_is_active)
  inform_in_echo_area (rep);
else
  {
    window_message_in_echo_area (rep, NULL((void *)0), NULL((void *)0));
    display_cursor_at_point (active_window);
  }
info_keyseq_displayed_p = 1;
4549}

4551/* Called by interactive commands to read a keystroke. */
4552unsigned char
4553info_get_another_input_char (void)
4554{
int ready = !info_keyseq_displayed_p; /* ready if new and pending key */

/* If there isn't any input currently available, then wait a
   moment looking for input.  If we don't get it fast enough,
   prompt a little bit with the current key sequence. */
if (!info_keyseq_displayed_p)
  {
    ready = 1;
    if (!info_any_buffered_input_p () &&
        !info_input_pending_p ())
      {
4566#if defined (FD_SET)
        struct timeval timer;
        fd_set readfds;

        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 (info_input_stream), &readfds)__fd_set(((!__isthreaded ? ((info_input_stream)->_file) : (
fileno)(info_input_stream))), (&readfds));
        timer.tv_sec = 1;
        timer.tv_usec = 750;
        ready = select (fileno(info_input_stream)(!__isthreaded ? ((info_input_stream)->_file) : (fileno)(info_input_stream
))+1, &readfds, (fd_set *)NULL((void *)0), (fd_set *)NULL((void *)0), &timer);
4575#else
        ready = 0;
4577#endif /* FD_SET */
    }
  }

if (!ready)
  display_info_keyseq (1);

return (info_get_input_char ());
4585}

4587/* Do the command associated with KEY in MAP.  If the associated command is
 really a keymap, then read another key, and dispatch into that map. */
4589void
4590info_dispatch_on_key (unsigned char key, Keymap map)
4591{
4592#if !defined(INFOKEY)
if (Meta_p (key)(((key) > ('\177' + 1))) && (!ISO_Latin_p || map[key].function != ea_insert))
  {
    if (map[ESC'\033'].type == ISKMAP1)
      {
        map = (Keymap)map[ESC'\033'].function;
        add_char_to_keyseq (ESC'\033');
        key = UnMeta (key)((key) & (~0x80));
        info_dispatch_on_key (key, map);
      }
    else
      {
        dispatch_error (info_keyseq);
      }
    return;
  }
4608#endif /* INFOKEY */

switch (map[key].type)
  {
  case ISFUNC0:
    {
      VFunction *func;

      func = InfoFunction(map[key].function)((map[key].function) ? (map[key].function)->func : (VFunction
 *) ((void *)0));
      if (func != (VFunction *)NULL((void *)0))
        {
          /* Special case info_do_lowercase_version (). */
          if (func == (VFunction *) info_do_lowercase_version)
            {
4622#if defined(INFOKEY)
unsigned char lowerkey;

lowerkey = Meta_p(key)(((key) > ('\177' + 1))) ? Meta (tolower (UnMeta (key)))((tolower (((key) & (~0x80)))) | (0x80)) : tolower (key);
if (lowerkey == key)
  {
    add_char_to_keyseq (key);
    dispatch_error (info_keyseq);
    return;
  }
              info_dispatch_on_key (lowerkey, map);
4633#else /* !INFOKEY */
              info_dispatch_on_key (tolower (key), map);
4635#endif /* INFOKEY */
              return;
            }

          add_char_to_keyseq (key);

          if (info_keyseq_displayed_p)
            display_info_keyseq (0);

          {
            WINDOW *where;

            where = active_window;
            (*InfoFunction(map[key].function)((map[key].function) ? (map[key].function)->func : (VFunction
 *) ((void *)0)))
              (active_window, info_numeric_arg * info_numeric_arg_sign, key);

            /* If we have input pending, then the last command was a prefix
               command.  Don't change the value of the last function vars.
               Otherwise, remember the last command executed in the var
               appropriate to the window in which it was executed. */
            if (!info_input_pending_p ())
              {
                if (where == the_echo_area)
                  ea_last_executed_command = InfoFunction(map[key].function)((map[key].function) ? (map[key].function)->func : (VFunction
 *) ((void *)0));
                else
                  info_last_executed_command = InfoFunction(map[key].function)((map[key].function) ? (map[key].function)->func : (VFunction
 *) ((void *)0));
              }
          }
        }
      else
        {
          add_char_to_keyseq (key);
          dispatch_error (info_keyseq);
          return;
        }
    }
    break;

  case ISKMAP1:
    add_char_to_keyseq (key);
    if (map[key].function != (InfoCommand *)NULL((void *)0))
      {
        unsigned char newkey;

        newkey = info_get_another_input_char ();
        info_dispatch_on_key (newkey, (Keymap)map[key].function);
      }
    else
      {
        dispatch_error (info_keyseq);
        return;
      }
    break;
  }
4689}
4690
4691/* **************************************************************** */
4692/*                                                                  */
4693/*                      Numeric Arguments                           */
4694/*                                                                  */
4695/* **************************************************************** */

4697/* Handle C-u style numeric args, as well as M--, and M-digits. */

4699/* Non-zero means that an explicit argument has been passed to this
 command, as in C-u C-v. */
4701int info_explicit_arg = 0;

4703/* The sign of the numeric argument. */
4704int info_numeric_arg_sign = 1;

4706/* The value of the argument itself. */
4707int info_numeric_arg = 1;

4709/* Add the current digit to the argument in progress. */
4710DECLARE_INFO_COMMAND (info_add_digit_to_numeric_arg,void info_add_digit_to_numeric_arg (WINDOW *window, int count
, unsigned char key)
                    _("Add this digit to the current numeric argument"))void info_add_digit_to_numeric_arg (WINDOW *window, int count
, unsigned char key)
4712{
info_numeric_arg_digit_loop (window, 0, key);
4714}

4716/* C-u, universal argument.  Multiply the current argument by 4.
 Read a key.  If the key has nothing to do with arguments, then
 dispatch on it.  If the key is the abort character then abort. */
4719DECLARE_INFO_COMMAND (info_universal_argument,void info_universal_argument (WINDOW *window, int count, unsigned
 char key)
                    _("Start (or multiply by 4) the current numeric argument"))void info_universal_argument (WINDOW *window, int count, unsigned
 char key)
4721{
info_numeric_arg *= 4;
info_numeric_arg_digit_loop (window, 0, 0);
4724}

4726/* Create a default argument. */
4727void
4728info_initialize_numeric_arg (void)
4729{
info_numeric_arg = info_numeric_arg_sign = 1;
info_explicit_arg = 0;
4732}

4734DECLARE_INFO_COMMAND (info_numeric_arg_digit_loop,void info_numeric_arg_digit_loop (WINDOW *window, int count, unsigned
 char key)
                    _("Internally used by \\[universal-argument]"))void info_numeric_arg_digit_loop (WINDOW *window, int count, unsigned
 char key)
4736{
unsigned char pure_key;
Keymap keymap = window->keymap;

while (1)
  {
    if (key)
      pure_key = key;
    else
      {
        if (display_was_interrupted_p && !info_any_buffered_input_p ())
          display_update_display (windows);

        if (active_window != the_echo_area)
          display_cursor_at_point (active_window);

        pure_key = key = info_get_another_input_char ();

4754#if !defined(INFOKEY)
        if (Meta_p (key)(((key) > ('\177' + 1))))
          add_char_to_keyseq (ESC'\033');

        add_char_to_keyseq (UnMeta (key)((key) & (~0x80)));
4759#else /* defined(INFOKEY) */
        add_char_to_keyseq (key);
4761#endif /* defined(INFOKEY) */
      }

4764#if !defined(INFOKEY)
    if (Meta_p (key)(((key) > ('\177' + 1))))
      key = UnMeta (key)((key) & (~0x80));
4767#endif /* !defined(INFOKEY) */

    if (keymap[key].type == ISFUNC0
        && InfoFunction(keymap[key].function)((keymap[key].function) ? (keymap[key].function)->func : (
VFunction *) ((void *)0))
            == (VFunction *) info_universal_argument)
      {
        info_numeric_arg *= 4;
        key = 0;
        continue;
      }

4778#if defined(INFOKEY)
    if (Meta_p (key)(((key) > ('\177' + 1))))
      key = UnMeta (key)((key) & (~0x80));
4781#endif /* !defined(INFOKEY) */


    if (isdigit (key))
      {
        if (info_explicit_arg)
          info_numeric_arg = (info_numeric_arg * 10) + (key - '0');
        else
          info_numeric_arg = (key - '0');
        info_explicit_arg = 1;
      }
    else
      {
        if (key == '-' && !info_explicit_arg)
          {
            info_numeric_arg_sign = -1;
            info_numeric_arg = 1;
          }
        else
          {
            info_keyseq_index--;
            info_dispatch_on_key (pure_key, keymap);
            return;
          }
      }
    key = 0;
  }
4808}
4809
4810/* **************************************************************** */
4811/*                                                                  */
4812/*                      Input Character Buffering                   */
4813/*                                                                  */
4814/* **************************************************************** */

4816/* Character waiting to be read next. */
4817static int pending_input_character = 0;

4819/* How to make there be no pending input. */
4820static void
4821info_clear_pending_input (void)
4822{
pending_input_character = 0;
4824}

4826/* How to set the pending input character. */
4827static void
4828info_set_pending_input (unsigned char key)
4829{
pending_input_character = key;
4831}

4833/* How to see if there is any pending input. */
4834unsigned char
4835info_input_pending_p (void)
4836{
return (pending_input_character);
4838}

4840/* Largest number of characters that we can read in advance. */
4841#define MAX_INFO_INPUT_BUFFERING512 512

4843static int pop_index = 0, push_index = 0;
4844static unsigned char info_input_buffer[MAX_INFO_INPUT_BUFFERING512];

4846/* Add KEY to the buffer of characters to be read. */
4847static void
4848info_push_typeahead (unsigned char key)
4849{
/* Flush all pending input in the case of C-g pressed. */
if (key == Control ('g')((toupper ('g')) & (~0x40)))
  {
    push_index = pop_index;
    info_set_pending_input (Control ('g')((toupper ('g')) & (~0x40)));
  }
else
  {
    info_input_buffer[push_index++] = key;
    if ((unsigned int) push_index >= sizeof (info_input_buffer))
      push_index = 0;
  }
4862}

4864/* Return the amount of space available in INFO_INPUT_BUFFER for new chars. */
4865static int
4866info_input_buffer_space_available (void)
4867{
if (pop_index > push_index)
  return (pop_index - push_index);
else
  return (sizeof (info_input_buffer) - (push_index - pop_index));
4872}

4874/* Get a key from the buffer of characters to be read.
 Return the key in KEY.
 Result is non-zero if there was a key, or 0 if there wasn't. */
4877static int
4878info_get_key_from_typeahead (unsigned char *key)
4879{
if (push_index == pop_index)
  return (0);

*key = info_input_buffer[pop_index++];

if ((unsigned int) pop_index >= sizeof (info_input_buffer))
  pop_index = 0;

return (1);
4889}

4891int
4892info_any_buffered_input_p (void)
4893{
info_gather_typeahead ();
return (push_index != pop_index);
4896}

4898/* If characters are available to be read, then read them and stuff them into
 info_input_buffer.  Otherwise, do nothing. */
4900void
4901info_gather_typeahead (void)
4902{
register int i = 0;
int tty, space_avail;
long chars_avail;
unsigned char input[MAX_INFO_INPUT_BUFFERING512];

tty = fileno (info_input_stream)(!__isthreaded ? ((info_input_stream)->_file) : (fileno)(info_input_stream
));
chars_avail = 0;

space_avail = info_input_buffer_space_available ();

/* If we can just find out how many characters there are to read, do so. */
4914#if defined (FIONREAD((unsigned long)0x40000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('f')) << 8) | ((127))))
{
  ioctl (tty, FIONREAD((unsigned long)0x40000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('f')) << 8) | ((127))), &chars_avail);

  if (chars_avail > space_avail)
    chars_avail = space_avail;

  if (chars_avail)
    chars_avail = read (tty, &input[0], chars_avail);
}
4924#else /* !FIONREAD */
4925#  if defined (O_NDELAY0x0004)
{
  int flags;

  flags = fcntl (tty, F_GETFL3, 0);

  fcntl (tty, F_SETFL4, (flags | O_NDELAY0x0004));
    chars_avail = read (tty, &input[0], space_avail);
  fcntl (tty, F_SETFL4, flags);

  if (chars_avail == -1)
    chars_avail = 0;
}
4938#  else  /* !O_NDELAY */
4939#   ifdef __DJGPP__
{
  extern long pc_term_chars_avail (void);

  if (isatty (tty))
    chars_avail = pc_term_chars_avail ();
  else
    {
/* We could be more accurate by calling ltell, but we have no idea
  whether tty is buffered by stdio functions, and if so, how many
  characters are already waiting in the buffer.  So we punt.  */
struct stat st;

if (fstat (tty, &st) < 0)
 chars_avail = 1;
else
 chars_avail = st.st_size;
    }
  if (chars_avail > space_avail)
    chars_avail = space_avail;
  if (chars_avail)
    chars_avail = read (tty, &input[0], chars_avail);
}
4962#   endif/* __DJGPP__ */
4963#  endif /* O_NDELAY */
4964#endif /* !FIONREAD */

while (i < chars_avail)
  {
    info_push_typeahead (input[i]);
    i++;
  }
4971}

4973/* How to read a single character. */
4974unsigned char
4975info_get_input_char (void)
4976{
unsigned char keystroke;

info_gather_typeahead ();

if (pending_input_character)
  {
    keystroke = pending_input_character;
    pending_input_character = 0;
  }
else if (info_get_key_from_typeahead (&keystroke) == 0)
  {
    int rawkey;
    unsigned char c;
    int tty = fileno (info_input_stream)(!__isthreaded ? ((info_input_stream)->_file) : (fileno)(info_input_stream
));

    /* Using stream I/O causes FIONREAD etc to fail to work
       so unless someone can find a portable way of finding
       out how many characters are currently buffered, we
       should stay with away from stream I/O.
       --Egil Kvaleberg <egilk@sn.no>, January 1997.  */
4997#ifdef EINTR4
    /* Keep reading if we got EINTR, so that we don't just exit.
       --Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>,
       22 Dec 1997.  */
    {
      int n;
      do
 n = read (tty, &c, 1);
      while (n == -1 && errno(*__errno()) == EINTR4);
      rawkey = n == 1 ? c : EOF(-1);
    }
5008#else
    rawkey = (read (tty, &c, 1) == 1) ? c : EOF(-1);
5010#endif

    keystroke = rawkey;

    if (rawkey == EOF(-1))
      {
        if (info_input_stream != stdin(&__sF[0]))
          {
            fclose (info_input_stream);
            info_input_stream = stdin(&__sF[0]);
     tty = fileno (info_input_stream)(!__isthreaded ? ((info_input_stream)->_file) : (fileno)(info_input_stream
));
            display_inhibited = 0;
            display_update_display (windows);
            display_cursor_at_point (active_window);
            rawkey = (read (tty, &c, 1) == 1) ? c : EOF(-1);
            keystroke = rawkey;
          }

        if (rawkey == EOF(-1))
          {
            terminal_unprep_terminal ();
            close_dribble_file ();
            xexit (0);
          }
      }
  }

if (info_dribble_file)
  dribble (keystroke);

return keystroke;
5041}