Constify add_setshow_*
[deliverable/binutils-gdb.git] / gdb / tui / tui-win.c
index 8cde063b909cedf350c0e387c08e7685cc250225..cbeff1f3a2d0d693927edd1f8dc15a82e3da564e 100644 (file)
@@ -1,7 +1,6 @@
 /* TUI window generic functions.
 
 /* TUI window generic functions.
 
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
-   Foundation, Inc.
+   Copyright (C) 1998-2017 Free Software Foundation, Inc.
 
    Contributed by Hewlett-Packard Company.
 
 
    Contributed by Hewlett-Packard Company.
 
@@ -9,7 +8,7 @@
 
    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
 
    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 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -18,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* This module contains procedures for handling tui window functions
    like resize, scrolling, scrolling, changing focus, etc.
 
 /* This module contains procedures for handling tui window functions
    like resize, scrolling, scrolling, changing focus, etc.
 #include "cli/cli-cmds.h"
 #include "top.h"
 #include "source.h"
 #include "cli/cli-cmds.h"
 #include "top.h"
 #include "source.h"
+#include "event-loop.h"
 
 #include "tui/tui.h"
 
 #include "tui/tui.h"
+#include "tui/tui-io.h"
 #include "tui/tui-data.h"
 #include "tui/tui-wingeneral.h"
 #include "tui/tui-stack.h"
 #include "tui/tui-data.h"
 #include "tui/tui-wingeneral.h"
 #include "tui/tui-stack.h"
 #include "tui/tui-source.h"
 #include "tui/tui-winsource.h"
 #include "tui/tui-windata.h"
 #include "tui/tui-source.h"
 #include "tui/tui-winsource.h"
 #include "tui/tui-windata.h"
+#include "tui/tui-win.h"
 
 
-#ifdef HAVE_NCURSES_H       
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
-
-#include <string.h>
+#include "gdb_curses.h"
 #include <ctype.h>
 #include <ctype.h>
-#include <readline/readline.h>
+#include "readline/readline.h"
+
+#include <signal.h>
 
 /*******************************
 ** Static Local Decls
 ********************************/
 
 /*******************************
 ** Static Local Decls
 ********************************/
-static void _makeVisibleWithNewHeight (TuiWinInfoPtr);
-static void _makeInvisibleAndSetNewHeight (TuiWinInfoPtr, int);
-static TuiStatus _tuiAdjustWinHeights (TuiWinInfoPtr, int);
-static int _newHeightOk (TuiWinInfoPtr, int);
-static void _tuiSetTabWidth_command (char *, int);
-static void _tuiRefreshAll_command (char *, int);
-static void _tuiSetWinHeight_command (char *, int);
-static void _tuiXDBsetWinHeight_command (char *, int);
-static void _tuiAllWindowsInfo (char *, int);
-static void _tuiSetFocus_command (char *, int);
-static void _tuiScrollForward_command (char *, int);
-static void _tuiScrollBackward_command (char *, int);
-static void _tuiScrollLeft_command (char *, int);
-static void _tuiScrollRight_command (char *, int);
-static void _parseScrollingArgs (char *, TuiWinInfoPtr *, int *);
+static void make_visible_with_new_height (struct tui_win_info *);
+static void make_invisible_and_set_new_height (struct tui_win_info *, 
+                                              int);
+static enum tui_status tui_adjust_win_heights (struct tui_win_info *, 
+                                              int);
+static int new_height_ok (struct tui_win_info *, int);
+static void tui_set_tab_width_command (const char *, int);
+static void tui_refresh_all_command (const char *, int);
+static void tui_set_win_height_command (const char *, int);
+static void tui_all_windows_info (const char *, int);
+static void tui_set_focus_command (const char *, int);
+static void tui_scroll_forward_command (const char *, int);
+static void tui_scroll_backward_command (const char *, int);
+static void tui_scroll_left_command (const char *, int);
+static void tui_scroll_right_command (const char *, int);
+static void parse_scrolling_args (const char *, 
+                                 struct tui_win_info **, 
+                                 int *);
 
 
 /***************************************
 ** DEFINITIONS
 ***************************************/
 
 
 /***************************************
 ** DEFINITIONS
 ***************************************/
-#define WIN_HEIGHT_USAGE      "Usage: winheight <win_name> [+ | -] <#lines>\n"
-#define XDBWIN_HEIGHT_USAGE   "Usage: w <#lines>\n"
-#define FOCUS_USAGE           "Usage: focus {<win> | next | prev}\n"
+#define WIN_HEIGHT_USAGE    "Usage: winheight <win_name> [+ | -] <#lines>\n"
+#define XDBWIN_HEIGHT_USAGE "Usage: w <#lines>\n"
+#define FOCUS_USAGE         "Usage: focus {<win> | next | prev}\n"
 
 /***************************************
 ** PUBLIC FUNCTIONS
 
 /***************************************
 ** PUBLIC FUNCTIONS
@@ -109,7 +106,7 @@ static void _parseScrollingArgs (char *, TuiWinInfoPtr *, int *);
 #endif
 
 /* Possible values for tui-border-kind variable.  */
 #endif
 
 /* Possible values for tui-border-kind variable.  */
-static const char *tui_border_kind_enums[] = {
+static const char *const tui_border_kind_enums[] = {
   "space",
   "ascii",
   "acs",
   "space",
   "ascii",
   "acs",
@@ -117,7 +114,7 @@ static const char *tui_border_kind_enums[] = {
 };
 
 /* Possible values for tui-border-mode and tui-active-border-mode.  */
 };
 
 /* Possible values for tui-border-mode and tui-active-border-mode.  */
-static const char *tui_border_mode_enums[] = {
+static const char *const tui_border_mode_enums[] = {
   "normal",
   "standout",
   "reverse",
   "normal",
   "standout",
   "reverse",
@@ -204,11 +201,43 @@ struct tui_translate tui_border_kind_translate_lrcorner[] = {
 
 /* Tui configuration variables controlled with set/show command.  */
 const char *tui_active_border_mode = "bold-standout";
 
 /* Tui configuration variables controlled with set/show command.  */
 const char *tui_active_border_mode = "bold-standout";
+static void
+show_tui_active_border_mode (struct ui_file *file,
+                            int from_tty,
+                            struct cmd_list_element *c, 
+                            const char *value)
+{
+  fprintf_filtered (file, _("\
+The attribute mode to use for the active TUI window border is \"%s\".\n"),
+                   value);
+}
+
 const char *tui_border_mode = "normal";
 const char *tui_border_mode = "normal";
+static void
+show_tui_border_mode (struct ui_file *file, 
+                     int from_tty,
+                     struct cmd_list_element *c, 
+                     const char *value)
+{
+  fprintf_filtered (file, _("\
+The attribute mode to use for the TUI window borders is \"%s\".\n"),
+                   value);
+}
+
 const char *tui_border_kind = "acs";
 const char *tui_border_kind = "acs";
+static void
+show_tui_border_kind (struct ui_file *file, 
+                     int from_tty,
+                     struct cmd_list_element *c, 
+                     const char *value)
+{
+  fprintf_filtered (file, _("The kind of border for TUI windows is \"%s\".\n"),
+                   value);
+}
 
 
-/* Tui internal configuration variables.  These variables are
-   updated by tui_update_variables to reflect the tui configuration
+
+/* Tui internal configuration variables.  These variables are updated
+   by tui_update_variables to reflect the tui configuration
    variables.  */
 chtype tui_border_vline;
 chtype tui_border_hline;
    variables.  */
 chtype tui_border_vline;
 chtype tui_border_hline;
@@ -241,7 +270,7 @@ translate (const char *name, struct tui_translate *table)
    Returns 1 if the configuration has changed and the screen should
    be redrawn.  */
 int
    Returns 1 if the configuration has changed and the screen should
    be redrawn.  */
 int
-tui_update_variables ()
+tui_update_variables (void)
 {
   int need_redraw = 0;
   struct tui_translate *entry;
 {
   int need_redraw = 0;
   struct tui_translate *entry;
@@ -287,296 +316,386 @@ tui_update_variables ()
 }
 
 static void
 }
 
 static void
-set_tui_cmd (char *args, int from_tty)
+set_tui_cmd (const char *args, int from_tty)
+{
+}
+
+static void
+show_tui_cmd (const char *args, int from_tty)
+{
+}
+
+static struct cmd_list_element *tuilist;
+
+static void
+tui_command (const char *args, int from_tty)
+{
+  printf_unfiltered (_("\"tui\" must be followed by the name of a "
+                     "tui command.\n"));
+  help_list (tuilist, "tui ", all_commands, gdb_stdout);
+}
+
+struct cmd_list_element **
+tui_get_cmd_list (void)
+{
+  if (tuilist == 0)
+    add_prefix_cmd ("tui", class_tui, tui_command,
+                    _("Text User Interface commands."),
+                    &tuilist, "tui ", 0, &cmdlist);
+  return &tuilist;
+}
+
+/* The set_func hook of "set tui ..." commands that affect the window
+   borders on the TUI display.  */
+void
+tui_set_var_cmd (const char *null_args,
+                int from_tty, struct cmd_list_element *c)
+{
+  if (tui_update_variables () && tui_active)
+    tui_rehighlight_all ();
+}
+
+/* Generic window name completion function.  Complete window name pointed
+   to by TEXT and WORD.  If INCLUDE_NEXT_PREV_P is true then the special
+   window names 'next' and 'prev' will also be considered as possible
+   completions of the window name.  */
+
+static void
+window_name_completer (completion_tracker &tracker,
+                      int include_next_prev_p,
+                      const char *text, const char *word)
+{
+  VEC (const_char_ptr) *completion_name_vec = NULL;
+  int win_type;
+
+  for (win_type = SRC_WIN; win_type < MAX_MAJOR_WINDOWS; win_type++)
+    {
+      const char *completion_name = NULL;
+
+      /* We can't focus on an invisible window.  */
+      if (tui_win_list[win_type] == NULL
+         || !tui_win_list[win_type]->generic.is_visible)
+       continue;
+
+      completion_name = tui_win_name (&tui_win_list [win_type]->generic);
+      gdb_assert (completion_name != NULL);
+      VEC_safe_push (const_char_ptr, completion_name_vec, completion_name);
+    }
+
+  /* If no windows are considered visible then the TUI has not yet been
+     initialized.  But still "focus src" and "focus cmd" will work because
+     invoking the focus command will entail initializing the TUI which sets the
+     default layout to SRC_COMMAND.  */
+  if (VEC_length (const_char_ptr, completion_name_vec) == 0)
+    {
+      VEC_safe_push (const_char_ptr, completion_name_vec, SRC_NAME);
+      VEC_safe_push (const_char_ptr, completion_name_vec, CMD_NAME);
+    }
+
+  if (include_next_prev_p)
+    {
+      VEC_safe_push (const_char_ptr, completion_name_vec, "next");
+      VEC_safe_push (const_char_ptr, completion_name_vec, "prev");
+    }
+
+  VEC_safe_push (const_char_ptr, completion_name_vec, NULL);
+  complete_on_enum (tracker,
+                   VEC_address (const_char_ptr, completion_name_vec),
+                   text, word);
+
+  VEC_free (const_char_ptr, completion_name_vec);
+}
+
+/* Complete possible window names to focus on.  TEXT is the complete text
+   entered so far, WORD is the word currently being completed.  */
+
+static void
+focus_completer (struct cmd_list_element *ignore,
+                completion_tracker &tracker,
+                const char *text, const char *word)
 {
 {
+  window_name_completer (tracker, 1, text, word);
 }
 
 }
 
+/* Complete possible window names for winheight command.  TEXT is the
+   complete text entered so far, WORD is the word currently being
+   completed.  */
+
 static void
 static void
-show_tui_cmd (char *args, int from_tty)
+winheight_completer (struct cmd_list_element *ignore,
+                    completion_tracker &tracker,
+                    const char *text, const char *word)
 {
 {
+  /* The first word is the window name.  That we can complete.  Subsequent
+     words can't be completed.  */
+  if (word != text)
+    return;
+
+  window_name_completer (tracker, 0, text, word);
 }
 
 }
 
-/*
-   ** _initialize_tuiWin().
-   **        Function to initialize gdb commands, for tui window manipulation.
- */
+/* Function to initialize gdb commands, for tui window
+   manipulation.  */
+
 void
 void
-_initialize_tuiWin (void)
+_initialize_tui_win (void)
 {
 {
-  struct cmd_list_element *c;
   static struct cmd_list_element *tui_setlist;
   static struct cmd_list_element *tui_showlist;
   static struct cmd_list_element *tui_setlist;
   static struct cmd_list_element *tui_showlist;
+  struct cmd_list_element *cmd;
 
   /* Define the classes of commands.
      They will appear in the help list in the reverse of this order.  */
 
   /* Define the classes of commands.
      They will appear in the help list in the reverse of this order.  */
-  add_cmd ("tui", class_tui, NULL,
-          "Text User Interface commands.",
-          &cmdlist);
-
   add_prefix_cmd ("tui", class_tui, set_tui_cmd,
   add_prefix_cmd ("tui", class_tui, set_tui_cmd,
-                  "TUI configuration variables",
+                  _("TUI configuration variables"),
                  &tui_setlist, "set tui ",
                  &tui_setlist, "set tui ",
-                 0/*allow-unknown*/, &setlist);
+                 0 /* allow-unknown */, &setlist);
   add_prefix_cmd ("tui", class_tui, show_tui_cmd,
   add_prefix_cmd ("tui", class_tui, show_tui_cmd,
-                  "TUI configuration variables",
+                  _("TUI configuration variables"),
                  &tui_showlist, "show tui ",
                  &tui_showlist, "show tui ",
-                 0/*allow-unknown*/, &showlist);
-
-  add_com ("refresh", class_tui, _tuiRefreshAll_command,
-           "Refresh the terminal display.\n");
-  if (xdb_commands)
-    add_com_alias ("U", "refresh", class_tui, 0);
-  add_com ("tabset", class_tui, _tuiSetTabWidth_command,
-           "Set the width (in characters) of tab stops.\n\
-Usage: tabset <n>\n");
-  add_com ("winheight", class_tui, _tuiSetWinHeight_command,
-           "Set the height of a specified window.\n\
+                 0 /* allow-unknown */, &showlist);
+
+  add_com ("refresh", class_tui, tui_refresh_all_command,
+           _("Refresh the terminal display.\n"));
+  add_com ("tabset", class_tui, tui_set_tab_width_command, _("\
+Set the width (in characters) of tab stops.\n\
+Usage: tabset <n>\n"));
+  cmd = add_com ("winheight", class_tui, tui_set_win_height_command, _("\
+Set or modify the height of a specified window.\n\
 Usage: winheight <win_name> [+ | -] <#lines>\n\
 Window names are:\n\
 src  : the source window\n\
 cmd  : the command window\n\
 asm  : the disassembly window\n\
 Usage: winheight <win_name> [+ | -] <#lines>\n\
 Window names are:\n\
 src  : the source window\n\
 cmd  : the command window\n\
 asm  : the disassembly window\n\
-regs : the register display\n");
+regs : the register display\n"));
   add_com_alias ("wh", "winheight", class_tui, 0);
   add_com_alias ("wh", "winheight", class_tui, 0);
-  add_info ("win", _tuiAllWindowsInfo,
-            "List of all displayed windows.\n");
-  add_com ("focus", class_tui, _tuiSetFocus_command,
-           "Set focus to named window or next/prev window.\n\
+  set_cmd_completer (cmd, winheight_completer);
+  add_info ("win", tui_all_windows_info,
+           _("List of all displayed windows.\n"));
+  cmd = add_com ("focus", class_tui, tui_set_focus_command, _("\
+Set focus to named window or next/prev window.\n\
 Usage: focus {<win> | next | prev}\n\
 Valid Window names are:\n\
 src  : the source window\n\
 asm  : the disassembly window\n\
 regs : the register display\n\
 Usage: focus {<win> | next | prev}\n\
 Valid Window names are:\n\
 src  : the source window\n\
 asm  : the disassembly window\n\
 regs : the register display\n\
-cmd  : the command window\n");
+cmd  : the command window\n"));
   add_com_alias ("fs", "focus", class_tui, 0);
   add_com_alias ("fs", "focus", class_tui, 0);
-  add_com ("+", class_tui, _tuiScrollForward_command,
-           "Scroll window forward.\nUsage: + [win] [n]\n");
-  add_com ("-", class_tui, _tuiScrollBackward_command,
-           "Scroll window backward.\nUsage: - [win] [n]\n");
-  add_com ("<", class_tui, _tuiScrollLeft_command,
-           "Scroll window forward.\nUsage: < [win] [n]\n");
-  add_com (">", class_tui, _tuiScrollRight_command,
-           "Scroll window backward.\nUsage: > [win] [n]\n");
-  if (xdb_commands)
-    add_com ("w", class_xdb, _tuiXDBsetWinHeight_command,
-             "XDB compatibility command for setting the height of a command window.\n\
-Usage: w <#lines>\n");
+  set_cmd_completer (cmd, focus_completer);
+  add_com ("+", class_tui, tui_scroll_forward_command, _("\
+Scroll window forward.\n\
+Usage: + [win] [n]\n"));
+  add_com ("-", class_tui, tui_scroll_backward_command, _("\
+Scroll window backward.\n\
+Usage: - [win] [n]\n"));
+  add_com ("<", class_tui, tui_scroll_left_command, _("\
+Scroll window text to the left.\n\
+Usage: < [win] [n]\n"));
+  add_com (">", class_tui, tui_scroll_right_command, _("\
+Scroll window text to the right.\n\
+Usage: > [win] [n]\n"));
 
   /* Define the tui control variables.  */
 
   /* Define the tui control variables.  */
-  c = add_set_enum_cmd
-    ("border-kind", no_class,
-     tui_border_kind_enums, &tui_border_kind,
-     "Set the kind of border for TUI windows.\n"
-     "This variable controls the border of TUI windows:\n"
-     "space           use a white space\n"
-     "ascii           use ascii characters + - | for the border\n"
-     "acs             use the Alternate Character Set\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
-
-  c = add_set_enum_cmd
-    ("border-mode", no_class,
-     tui_border_mode_enums, &tui_border_mode,
-     "Set the attribute mode to use for the TUI window borders.\n"
-     "This variable controls the attributes to use for the window borders:\n"
-     "normal          normal display\n"
-     "standout        use highlight mode of terminal\n"
-     "reverse         use reverse video mode\n"
-     "half            use half bright\n"
-     "half-standout   use half bright and standout mode\n"
-     "bold            use extra bright or bold\n"
-     "bold-standout   use extra bright or bold with standout mode\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
-
-  c = add_set_enum_cmd
-    ("active-border-mode", no_class,
-     tui_border_mode_enums, &tui_active_border_mode,
-     "Set the attribute mode to use for the active TUI window border.\n"
-     "This variable controls the attributes to use for the active window border:\n"
-     "normal          normal display\n"
-     "standout        use highlight mode of terminal\n"
-     "reverse         use reverse video mode\n"
-     "half            use half bright\n"
-     "half-standout   use half bright and standout mode\n"
-     "bold            use extra bright or bold\n"
-     "bold-standout   use extra bright or bold with standout mode\n",
-     &tui_setlist);
-  add_show_from_set (c, &tui_showlist);
+  add_setshow_enum_cmd ("border-kind", no_class, tui_border_kind_enums,
+                       &tui_border_kind, _("\
+Set the kind of border for TUI windows."), _("\
+Show the kind of border for TUI windows."), _("\
+This variable controls the border of TUI windows:\n\
+space           use a white space\n\
+ascii           use ascii characters + - | for the border\n\
+acs             use the Alternate Character Set"),
+                       tui_set_var_cmd,
+                       show_tui_border_kind,
+                       &tui_setlist, &tui_showlist);
+
+  add_setshow_enum_cmd ("border-mode", no_class, tui_border_mode_enums,
+                       &tui_border_mode, _("\
+Set the attribute mode to use for the TUI window borders."), _("\
+Show the attribute mode to use for the TUI window borders."), _("\
+This variable controls the attributes to use for the window borders:\n\
+normal          normal display\n\
+standout        use highlight mode of terminal\n\
+reverse         use reverse video mode\n\
+half            use half bright\n\
+half-standout   use half bright and standout mode\n\
+bold            use extra bright or bold\n\
+bold-standout   use extra bright or bold with standout mode"),
+                       tui_set_var_cmd,
+                       show_tui_border_mode,
+                       &tui_setlist, &tui_showlist);
+
+  add_setshow_enum_cmd ("active-border-mode", no_class, tui_border_mode_enums,
+                       &tui_active_border_mode, _("\
+Set the attribute mode to use for the active TUI window border."), _("\
+Show the attribute mode to use for the active TUI window border."), _("\
+This variable controls the attributes to use for the active window border:\n\
+normal          normal display\n\
+standout        use highlight mode of terminal\n\
+reverse         use reverse video mode\n\
+half            use half bright\n\
+half-standout   use half bright and standout mode\n\
+bold            use extra bright or bold\n\
+bold-standout   use extra bright or bold with standout mode"),
+                       tui_set_var_cmd,
+                       show_tui_active_border_mode,
+                       &tui_setlist, &tui_showlist);
 }
 
 /* Update gdb's knowledge of the terminal size.  */
 void
 }
 
 /* Update gdb's knowledge of the terminal size.  */
 void
-tui_update_gdb_sizes ()
+tui_update_gdb_sizes (void)
 {
 {
-  char cmd[50];
-  int screenheight, screenwidth;
+  int width, height;
 
 
-  rl_get_screen_size (&screenheight, &screenwidth);
-  /* Set to TUI command window dimension or use readline values.  */
-  sprintf (cmd, "set width %d",
-           tui_active ? cmdWin->generic.width : screenwidth);
-  execute_command (cmd, 0);
-  sprintf (cmd, "set height %d",
-           tui_active ? cmdWin->generic.height : screenheight);
-  execute_command (cmd, 0);
+  if (tui_active)
+    {
+      width = TUI_CMD_WIN->generic.width;
+      height = TUI_CMD_WIN->generic.height;
+    }
+  else
+    {
+      width = tui_term_width ();
+      height = tui_term_height ();
+    }
+
+  set_screen_width_and_height (width, height);
 }
 
 
 }
 
 
-/*
-   ** tuiSetWinFocusTo
-   **        Set the logical focus to winInfo
- */
+/* Set the logical focus to win_info.  */
 void
 void
-tuiSetWinFocusTo (TuiWinInfoPtr winInfo)
+tui_set_win_focus_to (struct tui_win_info *win_info)
 {
 {
-  if (m_winPtrNotNull (winInfo))
+  if (win_info != NULL)
     {
     {
-      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-
-      if (m_winPtrNotNull (winWithFocus) &&
-         winWithFocus->generic.type != CMD_WIN)
-       tui_unhighlight_win (winWithFocus);
-      tuiSetWinWithFocus (winInfo);
-      if (winInfo->generic.type != CMD_WIN)
-       tui_highlight_win (winInfo);
+      struct tui_win_info *win_with_focus = tui_win_with_focus ();
+
+      if (win_with_focus != NULL
+         && win_with_focus->generic.type != CMD_WIN)
+       tui_unhighlight_win (win_with_focus);
+      tui_set_win_with_focus (win_info);
+      if (win_info->generic.type != CMD_WIN)
+       tui_highlight_win (win_info);
     }
     }
-
-  return;
-}                              /* tuiSetWinFocusTo */
+}
 
 
 
 
-/*
-   ** tuiScrollForward().
- */
 void
 void
-tuiScrollForward (TuiWinInfoPtr winToScroll, int numToScroll)
+tui_scroll_forward (struct tui_win_info *win_to_scroll, 
+                   int num_to_scroll)
 {
 {
-  if (winToScroll != cmdWin)
+  if (win_to_scroll != TUI_CMD_WIN)
     {
     {
-      int _numToScroll = numToScroll;
-
-      if (numToScroll == 0)
-       _numToScroll = winToScroll->generic.height - 3;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport.  If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin)
-       tuiVerticalSourceScroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
-       tui_vertical_disassem_scroll (FORWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
-       tui_vertical_data_scroll (FORWARD_SCROLL, _numToScroll);
+      int _num_to_scroll = num_to_scroll;
+
+      if (num_to_scroll == 0)
+       _num_to_scroll = win_to_scroll->generic.height - 3;
+
+      /* If we are scrolling the source or disassembly window, do a
+         "psuedo" scroll since not all of the source is in memory,
+         only what is in the viewport.  If win_to_scroll is the
+         command window do nothing since the term should handle
+         it.  */
+      if (win_to_scroll == TUI_SRC_WIN)
+       tui_vertical_source_scroll (FORWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DISASM_WIN)
+       tui_vertical_disassem_scroll (FORWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DATA_WIN)
+       tui_vertical_data_scroll (FORWARD_SCROLL, _num_to_scroll);
     }
     }
+}
 
 
-  return;
-}                              /* tuiScrollForward */
-
-
-/*
-   ** tuiScrollBackward().
- */
 void
 void
-tuiScrollBackward (TuiWinInfoPtr winToScroll, int numToScroll)
+tui_scroll_backward (struct tui_win_info *win_to_scroll, 
+                    int num_to_scroll)
 {
 {
-  if (winToScroll != cmdWin)
+  if (win_to_scroll != TUI_CMD_WIN)
     {
     {
-      int _numToScroll = numToScroll;
-
-      if (numToScroll == 0)
-       _numToScroll = winToScroll->generic.height - 3;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport.  If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin)
-       tuiVerticalSourceScroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == disassemWin)
-       tui_vertical_disassem_scroll (BACKWARD_SCROLL, _numToScroll);
-      else if (winToScroll == dataWin)
-       tui_vertical_data_scroll (BACKWARD_SCROLL, _numToScroll);
+      int _num_to_scroll = num_to_scroll;
+
+      if (num_to_scroll == 0)
+       _num_to_scroll = win_to_scroll->generic.height - 3;
+
+      /* If we are scrolling the source or disassembly window, do a
+         "psuedo" scroll since not all of the source is in memory,
+         only what is in the viewport.  If win_to_scroll is the
+         command window do nothing since the term should handle
+         it.  */
+      if (win_to_scroll == TUI_SRC_WIN)
+       tui_vertical_source_scroll (BACKWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DISASM_WIN)
+       tui_vertical_disassem_scroll (BACKWARD_SCROLL, _num_to_scroll);
+      else if (win_to_scroll == TUI_DATA_WIN)
+       tui_vertical_data_scroll (BACKWARD_SCROLL, _num_to_scroll);
     }
     }
-  return;
-}                              /* tuiScrollBackward */
+}
 
 
 
 
-/*
-   ** tuiScrollLeft().
- */
 void
 void
-tuiScrollLeft (TuiWinInfoPtr winToScroll, int numToScroll)
+tui_scroll_left (struct tui_win_info *win_to_scroll,
+                int num_to_scroll)
 {
 {
-  if (winToScroll != cmdWin)
+  if (win_to_scroll != TUI_CMD_WIN)
     {
     {
-      int _numToScroll = numToScroll;
-
-      if (_numToScroll == 0)
-       _numToScroll = 1;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport. If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin || winToScroll == disassemWin)
-       tui_horizontal_source_scroll (winToScroll, LEFT_SCROLL, _numToScroll);
+      int _num_to_scroll = num_to_scroll;
+
+      if (_num_to_scroll == 0)
+       _num_to_scroll = 1;
+
+      /* If we are scrolling the source or disassembly window, do a
+         "psuedo" scroll since not all of the source is in memory,
+         only what is in the viewport. If win_to_scroll is the command
+         window do nothing since the term should handle it.  */
+      if (win_to_scroll == TUI_SRC_WIN
+         || win_to_scroll == TUI_DISASM_WIN)
+       tui_horizontal_source_scroll (win_to_scroll, LEFT_SCROLL,
+                                     _num_to_scroll);
     }
     }
-  return;
-}                              /* tuiScrollLeft */
+}
 
 
 
 
-/*
-   ** tuiScrollRight().
- */
 void
 void
-tuiScrollRight (TuiWinInfoPtr winToScroll, int numToScroll)
+tui_scroll_right (struct tui_win_info *win_to_scroll, 
+                 int num_to_scroll)
 {
 {
-  if (winToScroll != cmdWin)
+  if (win_to_scroll != TUI_CMD_WIN)
     {
     {
-      int _numToScroll = numToScroll;
-
-      if (_numToScroll == 0)
-       _numToScroll = 1;
-      /*
-         ** If we are scrolling the source or disassembly window, do a
-         ** "psuedo" scroll since not all of the source is in memory,
-         ** only what is in the viewport. If winToScroll is the
-         ** command window do nothing since the term should handle it.
-       */
-      if (winToScroll == srcWin || winToScroll == disassemWin)
-       tui_horizontal_source_scroll (winToScroll, RIGHT_SCROLL, _numToScroll);
+      int _num_to_scroll = num_to_scroll;
+
+      if (_num_to_scroll == 0)
+       _num_to_scroll = 1;
+
+      /* If we are scrolling the source or disassembly window, do a
+         "psuedo" scroll since not all of the source is in memory,
+         only what is in the viewport. If win_to_scroll is the command
+         window do nothing since the term should handle it.  */
+      if (win_to_scroll == TUI_SRC_WIN
+         || win_to_scroll == TUI_DISASM_WIN)
+       tui_horizontal_source_scroll (win_to_scroll, RIGHT_SCROLL,
+                                     _num_to_scroll);
     }
     }
-  return;
-}                              /* tuiScrollRight */
+}
 
 
 
 
-/*
-   ** tui_scroll().
-   **    Scroll a window.  Arguments are passed through a va_list.
- */
+/* Scroll a window.  Arguments are passed through a va_list.  */
 void
 void
-tui_scroll (TuiScrollDirection direction,
-           TuiWinInfoPtr winToScroll,
-           int numToScroll)
+tui_scroll (enum tui_scroll_direction direction,
+           struct tui_win_info *win_to_scroll,
+           int num_to_scroll)
 {
   switch (direction)
     {
     case FORWARD_SCROLL:
 {
   switch (direction)
     {
     case FORWARD_SCROLL:
-      tuiScrollForward (winToScroll, numToScroll);
+      tui_scroll_forward (win_to_scroll, num_to_scroll);
       break;
     case BACKWARD_SCROLL:
       break;
     case BACKWARD_SCROLL:
-      tuiScrollBackward (winToScroll, numToScroll);
+      tui_scroll_backward (win_to_scroll, num_to_scroll);
       break;
     case LEFT_SCROLL:
       break;
     case LEFT_SCROLL:
-      tuiScrollLeft (winToScroll, numToScroll);
+      tui_scroll_left (win_to_scroll, num_to_scroll);
       break;
     case RIGHT_SCROLL:
       break;
     case RIGHT_SCROLL:
-      tuiScrollRight (winToScroll, numToScroll);
+      tui_scroll_right (win_to_scroll, num_to_scroll);
       break;
     default:
       break;
       break;
     default:
       break;
@@ -584,28 +703,26 @@ tui_scroll (TuiScrollDirection direction,
 }
 
 
 }
 
 
-/*
-   ** tuiRefreshAll().
- */
 void
 void
-tuiRefreshAll (void)
+tui_refresh_all_win (void)
 {
 {
-  TuiWinType type;
+  int type;
 
   clearok (curscr, TRUE);
 
   clearok (curscr, TRUE);
-  tui_refresh_all (winList);
+  tui_refresh_all (tui_win_list);
   for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
     {
   for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
     {
-      if (winList[type] && winList[type]->generic.isVisible)
+      if (tui_win_list[type] 
+         && tui_win_list[type]->generic.is_visible)
        {
          switch (type)
            {
            case SRC_WIN:
            case DISASSEM_WIN:
        {
          switch (type)
            {
            case SRC_WIN:
            case DISASSEM_WIN:
-             tui_show_source_content (winList[type]);
-             tui_check_and_display_highlight_if_needed (winList[type]);
-             tui_erase_exec_info_content (winList[type]);
-             tui_update_exec_info (winList[type]);
+             tui_show_source_content (tui_win_list[type]);
+             tui_check_and_display_highlight_if_needed (tui_win_list[type]);
+             tui_erase_exec_info_content (tui_win_list[type]);
+             tui_update_exec_info (tui_win_list[type]);
              break;
            case DATA_WIN:
              tui_refresh_data_win ();
              break;
            case DATA_WIN:
              tui_refresh_data_win ();
@@ -618,188 +735,244 @@ tuiRefreshAll (void)
   tui_show_locator_content ();
 }
 
   tui_show_locator_content ();
 }
 
+void
+tui_rehighlight_all (void)
+{
+  int type;
+
+  for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
+    tui_check_and_display_highlight_if_needed (tui_win_list[type]);
+}
 
 
-/*
-   ** tuiResizeAll().
-   **      Resize all the windows based on the the terminal size.  This
-   **      function gets called from within the readline sinwinch handler.
- */
+/* Resize all the windows based on the terminal size.  This function
+   gets called from within the readline sinwinch handler.  */
 void
 void
-tuiResizeAll (void)
+tui_resize_all (void)
 {
 {
-  int heightDiff, widthDiff;
+  int height_diff, width_diff;
   int screenheight, screenwidth;
 
   rl_get_screen_size (&screenheight, &screenwidth);
   int screenheight, screenwidth;
 
   rl_get_screen_size (&screenheight, &screenwidth);
-  widthDiff = screenwidth - termWidth ();
-  heightDiff = screenheight - termHeight ();
-  if (heightDiff || widthDiff)
+  width_diff = screenwidth - tui_term_width ();
+  height_diff = screenheight - tui_term_height ();
+  if (height_diff || width_diff)
     {
     {
-      TuiLayoutType curLayout = currentLayout ();
-      TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
-      TuiWinInfoPtr firstWin, secondWin;
-      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-      TuiWinType winType;
-      int newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
-
-      /* turn keypad off while we resize */
-      if (winWithFocus != cmdWin)
-       keypad (cmdWin->generic.handle, FALSE);
+      enum tui_layout_type cur_layout = tui_current_layout ();
+      struct tui_win_info *win_with_focus = tui_win_with_focus ();
+      struct tui_win_info *first_win;
+      struct tui_win_info *second_win;
+      struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
+      int win_type;
+      int new_height, split_diff, cmd_split_diff, num_wins_displayed = 2;
+
+#ifdef HAVE_RESIZE_TERM
+      resize_term (screenheight, screenwidth);
+#endif      
+      /* Turn keypad off while we resize.  */
+      if (win_with_focus != TUI_CMD_WIN)
+       keypad (TUI_CMD_WIN->generic.handle, FALSE);
       tui_update_gdb_sizes ();
       tui_update_gdb_sizes ();
-      setTermHeightTo (screenheight);
-      setTermWidthTo (screenwidth);
-      if (curLayout == SRC_DISASSEM_COMMAND ||
-       curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND)
-       numWinsDisplayed++;
-      splitDiff = heightDiff / numWinsDisplayed;
-      cmdSplitDiff = splitDiff;
-      if (heightDiff % numWinsDisplayed)
+      tui_set_term_height_to (screenheight);
+      tui_set_term_width_to (screenwidth);
+      if (cur_layout == SRC_DISASSEM_COMMAND 
+         || cur_layout == SRC_DATA_COMMAND
+         || cur_layout == DISASSEM_DATA_COMMAND)
+       num_wins_displayed++;
+      split_diff = height_diff / num_wins_displayed;
+      cmd_split_diff = split_diff;
+      if (height_diff % num_wins_displayed)
        {
        {
-         if (heightDiff < 0)
-           cmdSplitDiff--;
+         if (height_diff < 0)
+           cmd_split_diff--;
          else
          else
-           cmdSplitDiff++;
-       }
-      /* now adjust each window */
-      clear ();
+           cmd_split_diff++;
+       }
+      /* Now adjust each window.  */
+      /* erase + clearok are used instead of a straightforward clear as
+         AIX 5.3 does not define clear.  */
+      erase ();
+      clearok (curscr, TRUE);
       refresh ();
       refresh ();
-      switch (curLayout)
-       {
+      switch (cur_layout)
+       {
        case SRC_COMMAND:
        case DISASSEM_COMMAND:
        case SRC_COMMAND:
        case DISASSEM_COMMAND:
-         firstWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-         firstWin->generic.width += widthDiff;
-         locator->width += widthDiff;
-         /* check for invalid heights */
-         if (heightDiff == 0)
-           newHeight = firstWin->generic.height;
-         else if ((firstWin->generic.height + splitDiff) >=
+         first_win = (struct tui_win_info *) (tui_source_windows ())->list[0];
+         first_win->generic.width += width_diff;
+         locator->width += width_diff;
+         /* Check for invalid heights.  */
+         if (height_diff == 0)
+           new_height = first_win->generic.height;
+         else if ((first_win->generic.height + split_diff) >=
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
-           newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
-         else if ((firstWin->generic.height + splitDiff) <= 0)
-           newHeight = MIN_WIN_HEIGHT;
+           new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+         else if ((first_win->generic.height + split_diff) <= 0)
+           new_height = MIN_WIN_HEIGHT;
          else
          else
-           newHeight = firstWin->generic.height + splitDiff;
-
-         _makeInvisibleAndSetNewHeight (firstWin, newHeight);
-         cmdWin->generic.origin.y = locator->origin.y + 1;
-         cmdWin->generic.width += widthDiff;
-         newHeight = screenheight - cmdWin->generic.origin.y;
-         _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
-         _makeVisibleWithNewHeight (firstWin);
-         _makeVisibleWithNewHeight (cmdWin);
-         if (firstWin->generic.contentSize <= 0)
-           tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
+           new_height = first_win->generic.height + split_diff;
+
+         locator->origin.y = new_height + 1;
+         make_invisible_and_set_new_height (first_win, new_height);
+         TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+         TUI_CMD_WIN->generic.width += width_diff;
+         new_height = screenheight - TUI_CMD_WIN->generic.origin.y;
+         make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
+         make_visible_with_new_height (first_win);
+         make_visible_with_new_height (TUI_CMD_WIN);
+         if (first_win->generic.content_size <= 0)
+           tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
          break;
        default:
          break;
        default:
-         if (curLayout == SRC_DISASSEM_COMMAND)
+         if (cur_layout == SRC_DISASSEM_COMMAND)
            {
            {
-             firstWin = srcWin;
-             firstWin->generic.width += widthDiff;
-             secondWin = disassemWin;
-             secondWin->generic.width += widthDiff;
+             first_win = TUI_SRC_WIN;
+             first_win->generic.width += width_diff;
+             second_win = TUI_DISASM_WIN;
+             second_win->generic.width += width_diff;
            }
          else
            {
            }
          else
            {
-             firstWin = dataWin;
-             firstWin->generic.width += widthDiff;
-             secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-             secondWin->generic.width += widthDiff;
+             first_win = TUI_DATA_WIN;
+             first_win->generic.width += width_diff;
+             second_win = (struct tui_win_info *)
+               (tui_source_windows ())->list[0];
+             second_win->generic.width += width_diff;
            }
            }
-         /* Change the first window's height/width */
-         /* check for invalid heights */
-         if (heightDiff == 0)
-           newHeight = firstWin->generic.height;
-         else if ((firstWin->generic.height +
-                   secondWin->generic.height + (splitDiff * 2)) >=
+         /* Change the first window's height/width */
+         /* Check for invalid heights.  */
+         if (height_diff == 0)
+           new_height = first_win->generic.height;
+         else if ((first_win->generic.height +
+                   second_win->generic.height + (split_diff * 2)) >=
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
-           newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
-         else if ((firstWin->generic.height + splitDiff) <= 0)
-           newHeight = MIN_WIN_HEIGHT;
+           new_height = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
+         else if ((first_win->generic.height + split_diff) <= 0)
+           new_height = MIN_WIN_HEIGHT;
          else
          else
-           newHeight = firstWin->generic.height + splitDiff;
-         _makeInvisibleAndSetNewHeight (firstWin, newHeight);
-
-         if (firstWin == dataWin && widthDiff != 0)
-           firstWin->detail.dataDisplayInfo.regsColumnCount =
-             tui_calculate_regs_column_count (
-                         firstWin->detail.dataDisplayInfo.regsDisplayType);
-         locator->width += widthDiff;
-
-         /* Change the second window's height/width */
-         /* check for invalid heights */
-         if (heightDiff == 0)
-           newHeight = secondWin->generic.height;
-         else if ((firstWin->generic.height +
-                   secondWin->generic.height + (splitDiff * 2)) >=
+           new_height = first_win->generic.height + split_diff;
+         make_invisible_and_set_new_height (first_win, new_height);
+
+         locator->width += width_diff;
+
+         /* Change the second window's height/width.  */
+         /* Check for invalid heights.  */
+         if (height_diff == 0)
+           new_height = second_win->generic.height;
+         else if ((first_win->generic.height +
+                   second_win->generic.height + (split_diff * 2)) >=
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
            {
                   (screenheight - MIN_CMD_WIN_HEIGHT - 1))
            {
-             newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
-             if (newHeight % 2)
-               newHeight = (newHeight / 2) + 1;
+             new_height = screenheight - MIN_CMD_WIN_HEIGHT - 1;
+             if (new_height % 2)
+               new_height = (new_height / 2) + 1;
              else
              else
-               newHeight /= 2;
+               new_height /= 2;
            }
            }
-         else if ((secondWin->generic.height + splitDiff) <= 0)
-           newHeight = MIN_WIN_HEIGHT;
+         else if ((second_win->generic.height + split_diff) <= 0)
+           new_height = MIN_WIN_HEIGHT;
          else
          else
-           newHeight = secondWin->generic.height + splitDiff;
-         secondWin->generic.origin.y = firstWin->generic.height - 1;
-         _makeInvisibleAndSetNewHeight (secondWin, newHeight);
-
-         /* Change the command window's height/width */
-         cmdWin->generic.origin.y = locator->origin.y + 1;
-         _makeInvisibleAndSetNewHeight (
-                            cmdWin, cmdWin->generic.height + cmdSplitDiff);
-         _makeVisibleWithNewHeight (firstWin);
-         _makeVisibleWithNewHeight (secondWin);
-         _makeVisibleWithNewHeight (cmdWin);
-         if (firstWin->generic.contentSize <= 0)
-           tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
-         if (secondWin->generic.contentSize <= 0)
-           tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
+           new_height = second_win->generic.height + split_diff;
+         second_win->generic.origin.y = first_win->generic.height - 1;
+         make_invisible_and_set_new_height (second_win, new_height);
+
+         /* Change the command window's height/width.  */
+         TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+         make_invisible_and_set_new_height (TUI_CMD_WIN,
+                                            TUI_CMD_WIN->generic.height
+                                            + cmd_split_diff);
+         make_visible_with_new_height (first_win);
+         make_visible_with_new_height (second_win);
+         make_visible_with_new_height (TUI_CMD_WIN);
+         if (first_win->generic.content_size <= 0)
+           tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+         if (second_win->generic.content_size <= 0)
+           tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
          break;
        }
          break;
        }
-      /*
-         ** Now remove all invisible windows, and their content so that they get
-         ** created again when called for with the new size
-       */
-      for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
+      /* Now remove all invisible windows, and their content so that
+         they get created again when called for with the new size.  */
+      for (win_type = SRC_WIN; (win_type < MAX_MAJOR_WINDOWS); win_type++)
        {
        {
-         if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
-             !winList[winType]->generic.isVisible)
+         if (win_type != CMD_WIN 
+             && (tui_win_list[win_type] != NULL)
+             && !tui_win_list[win_type]->generic.is_visible)
            {
            {
-             freeWindow (winList[winType]);
-             winList[winType] = (TuiWinInfoPtr) NULL;
+             tui_free_window (tui_win_list[win_type]);
+             tui_win_list[win_type] = NULL;
            }
        }
            }
        }
-      tuiSetWinResizedTo (TRUE);
-      /* turn keypad back on, unless focus is in the command window */
-      if (winWithFocus != cmdWin)
-       keypad (cmdWin->generic.handle, TRUE);
+      /* Turn keypad back on, unless focus is in the command
+        window.  */
+      if (win_with_focus != TUI_CMD_WIN)
+       keypad (TUI_CMD_WIN->generic.handle, TRUE);
     }
     }
-  return;
-}                              /* tuiResizeAll */
+}
 
 
+#ifdef SIGWINCH
+/* Token for use by TUI's asynchronous SIGWINCH handler.  */
+static struct async_signal_handler *tui_sigwinch_token;
 
 
-/*
-   ** tuiSigwinchHandler()
-   **    SIGWINCH signal handler for the tui.  This signal handler is
-   **    always called, even when the readline package clears signals
-   **    because it is set as the old_sigwinch() (TUI only)
- */
-void
-tuiSigwinchHandler (int signal)
+/* TUI's SIGWINCH signal handler.  */
+static void
+tui_sigwinch_handler (int signal)
 {
 {
-  /*
-     ** Say that a resize was done so that the readline can do it
-     ** later when appropriate.
-   */
-  tuiSetWinResizedTo (TRUE);
+  mark_async_signal_handler (tui_sigwinch_token);
+  tui_set_win_resized_to (TRUE);
+}
 
 
-  return;
-}                              /* tuiSigwinchHandler */
+/* Callback for asynchronously resizing TUI following a SIGWINCH signal.  */
+static void
+tui_async_resize_screen (gdb_client_data arg)
+{
+  rl_resize_terminal ();
 
 
+  if (!tui_active)
+    {
+      int screen_height, screen_width;
+
+      rl_get_screen_size (&screen_height, &screen_width);
+      set_screen_width_and_height (screen_width, screen_height);
+
+      /* win_resized is left set so that the next call to tui_enable()
+        resizes the TUI windows.  */
+    }
+  else
+    {
+      tui_set_win_resized_to (FALSE);
+      tui_resize_all ();
+      tui_refresh_all_win ();
+      tui_update_gdb_sizes ();
+      tui_redisplay_readline ();
+    }
+}
+#endif
+
+/* Initialize TUI's SIGWINCH signal handler.  Note that the handler is not
+   uninstalled when we exit TUI, so the handler should not assume that TUI is
+   always active.  */
+void
+tui_initialize_win (void)
+{
+#ifdef SIGWINCH
+  tui_sigwinch_token
+    = create_async_signal_handler (tui_async_resize_screen, NULL);
+
+  {
+#ifdef HAVE_SIGACTION
+    struct sigaction old_winch;
+
+    memset (&old_winch, 0, sizeof (old_winch));
+    old_winch.sa_handler = &tui_sigwinch_handler;
+#ifdef SA_RESTART
+    old_winch.sa_flags = SA_RESTART;
+#endif
+    sigaction (SIGWINCH, &old_winch, NULL);
+#else
+    signal (SIGWINCH, &tui_sigwinch_handler);
+#endif
+  }
+#endif
+}
 
 
 /*************************
 
 
 /*************************
@@ -807,177 +980,148 @@ tuiSigwinchHandler (int signal)
 **************************/
 
 
 **************************/
 
 
-/*
-   ** _tuiScrollForward_command().
- */
 static void
 static void
-_tuiScrollForward_command (char *arg, int fromTTY)
+tui_scroll_forward_command (const char *arg, int from_tty)
 {
 {
-  int numToScroll = 1;
-  TuiWinInfoPtr winToScroll;
+  int num_to_scroll = 1;
+  struct tui_win_info *win_to_scroll;
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg == (char *) NULL)
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg == (char *) NULL)
-    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
+    parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
   else
   else
-    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (FORWARD_SCROLL, winToScroll, numToScroll);
+    parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (FORWARD_SCROLL, win_to_scroll, num_to_scroll);
 }
 
 
 }
 
 
-/*
-   ** _tuiScrollBackward_command().
- */
 static void
 static void
-_tuiScrollBackward_command (char *arg, int fromTTY)
+tui_scroll_backward_command (const char *arg, int from_tty)
 {
 {
-  int numToScroll = 1;
-  TuiWinInfoPtr winToScroll;
+  int num_to_scroll = 1;
+  struct tui_win_info *win_to_scroll;
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg == (char *) NULL)
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg == (char *) NULL)
-    _parseScrollingArgs (arg, &winToScroll, (int *) NULL);
+    parse_scrolling_args (arg, &win_to_scroll, (int *) NULL);
   else
   else
-    _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (BACKWARD_SCROLL, winToScroll, numToScroll);
+    parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (BACKWARD_SCROLL, win_to_scroll, num_to_scroll);
 }
 
 
 }
 
 
-/*
-   ** _tuiScrollLeft_command().
- */
 static void
 static void
-_tuiScrollLeft_command (char *arg, int fromTTY)
+tui_scroll_left_command (const char *arg, int from_tty)
 {
 {
-  int numToScroll;
-  TuiWinInfoPtr winToScroll;
+  int num_to_scroll;
+  struct tui_win_info *win_to_scroll;
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
-  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (LEFT_SCROLL, winToScroll, numToScroll);
+  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (LEFT_SCROLL, win_to_scroll, num_to_scroll);
 }
 
 
 }
 
 
-/*
-   ** _tuiScrollRight_command().
- */
 static void
 static void
-_tuiScrollRight_command (char *arg, int fromTTY)
+tui_scroll_right_command (const char *arg, int from_tty)
 {
 {
-  int numToScroll;
-  TuiWinInfoPtr winToScroll;
+  int num_to_scroll;
+  struct tui_win_info *win_to_scroll;
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
-  _parseScrollingArgs (arg, &winToScroll, &numToScroll);
-  tui_scroll (RIGHT_SCROLL, winToScroll, numToScroll);
+  parse_scrolling_args (arg, &win_to_scroll, &num_to_scroll);
+  tui_scroll (RIGHT_SCROLL, win_to_scroll, num_to_scroll);
 }
 
 
 }
 
 
-/*
-   ** _tuiSetFocus().
-   **     Set focus to the window named by 'arg'
- */
+/* Set focus to the window named by 'arg'.  */
 static void
 static void
-_tuiSetFocus (char *arg, int fromTTY)
+tui_set_focus (const char *arg, int from_tty)
 {
   if (arg != (char *) NULL)
     {
 {
   if (arg != (char *) NULL)
     {
-      char *bufPtr = (char *) xstrdup (arg);
+      char *buf_ptr = (char *) xstrdup (arg);
       int i;
       int i;
-      TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
+      struct tui_win_info *win_info = NULL;
 
 
-      for (i = 0; (i < strlen (bufPtr)); i++)
-       bufPtr[i] = toupper (arg[i]);
+      for (i = 0; (i < strlen (buf_ptr)); i++)
+       buf_ptr[i] = tolower (arg[i]);
 
 
-      if (subset_compare (bufPtr, "NEXT"))
-       winInfo = tuiNextWin (tuiWinWithFocus ());
-      else if (subset_compare (bufPtr, "PREV"))
-       winInfo = tuiPrevWin (tuiWinWithFocus ());
+      if (subset_compare (buf_ptr, "next"))
+       win_info = tui_next_win (tui_win_with_focus ());
+      else if (subset_compare (buf_ptr, "prev"))
+       win_info = tui_prev_win (tui_win_with_focus ());
       else
       else
-       winInfo = partialWinByName (bufPtr);
+       win_info = tui_partial_win_by_name (buf_ptr);
 
 
-      if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
-       warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
+      if (win_info == (struct tui_win_info *) NULL
+         || !win_info->generic.is_visible)
+       warning (_("Invalid window specified. \n\
+The window name specified must be valid and visible.\n"));
       else
        {
       else
        {
-         tuiSetWinFocusTo (winInfo);
-         keypad (cmdWin->generic.handle, (winInfo != cmdWin));
+         tui_set_win_focus_to (win_info);
+         keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
        }
 
        }
 
-      if (dataWin && dataWin->generic.isVisible)
+      if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
        tui_refresh_data_win ();
        tui_refresh_data_win ();
-      tuiFree (bufPtr);
-      printf_filtered ("Focus set to %s window.\n",
-                      winName ((TuiGenWinInfoPtr) tuiWinWithFocus ()));
+      xfree (buf_ptr);
+      printf_filtered (_("Focus set to %s window.\n"),
+                      tui_win_name (&tui_win_with_focus ()->generic));
     }
   else
     }
   else
-    warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
-
-  return;
-}                              /* _tuiSetFocus */
+    warning (_("Incorrect Number of Arguments.\n%s"), FOCUS_USAGE);
+}
 
 
-/*
-   ** _tuiSetFocus_command()
- */
 static void
 static void
-_tuiSetFocus_command (char *arg, int fromTTY)
+tui_set_focus_command (const char *arg, int from_tty)
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
-  _tuiSetFocus (arg, fromTTY);
+  tui_set_focus (arg, from_tty);
 }
 
 
 }
 
 
-/*
-   ** _tuiAllWindowsInfo().
- */
 static void
 static void
-_tuiAllWindowsInfo (char *arg, int fromTTY)
+tui_all_windows_info (const char *arg, int from_tty)
 {
 {
-  TuiWinType type;
-  TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
+  int type;
+  struct tui_win_info *win_with_focus = tui_win_with_focus ();
 
   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
 
   for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
-    if (winList[type] && winList[type]->generic.isVisible)
+    if (tui_win_list[type] 
+       && tui_win_list[type]->generic.is_visible)
       {
       {
-       if (winWithFocus == winList[type])
+       if (win_with_focus == tui_win_list[type])
          printf_filtered ("        %s\t(%d lines)  <has focus>\n",
          printf_filtered ("        %s\t(%d lines)  <has focus>\n",
-                          winName (&winList[type]->generic),
-                          winList[type]->generic.height);
+                          tui_win_name (&tui_win_list[type]->generic),
+                          tui_win_list[type]->generic.height);
        else
          printf_filtered ("        %s\t(%d lines)\n",
        else
          printf_filtered ("        %s\t(%d lines)\n",
-                          winName (&winList[type]->generic),
-                          winList[type]->generic.height);
+                          tui_win_name (&tui_win_list[type]->generic),
+                          tui_win_list[type]->generic.height);
       }
       }
-
-  return;
-}                              /* _tuiAllWindowsInfo */
+}
 
 
 
 
-/*
-   ** _tuiRefreshAll_command().
- */
 static void
 static void
-_tuiRefreshAll_command (char *arg, int fromTTY)
+tui_refresh_all_command (const char *arg, int from_tty)
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 
-  tuiRefreshAll ();
+  tui_refresh_all_win ();
 }
 
 
 }
 
 
-/*
-   ** _tuiSetWinTabWidth_command().
-   **        Set the height of the specified window.
- */
+/* Set the tab width of the specified window.  */
 static void
 static void
-_tuiSetTabWidth_command (char *arg, int fromTTY)
+tui_set_tab_width_command (const char *arg, int from_tty)
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
@@ -987,367 +1131,328 @@ _tuiSetTabWidth_command (char *arg, int fromTTY)
 
       ts = atoi (arg);
       if (ts > 0)
 
       ts = atoi (arg);
       if (ts > 0)
-       tuiSetDefaultTabLen (ts);
+       {
+         tui_set_default_tab_len (ts);
+         /* We don't really change the height of any windows, but
+            calling these 2 functions causes a complete regeneration
+            and redisplay of the window's contents, which will take
+            the new tab width into account.  */
+         if (tui_win_list[SRC_WIN]
+             && tui_win_list[SRC_WIN]->generic.is_visible)
+           {
+             make_invisible_and_set_new_height (TUI_SRC_WIN,
+                                                TUI_SRC_WIN->generic.height);
+             make_visible_with_new_height (TUI_SRC_WIN);
+           }
+         if (tui_win_list[DISASSEM_WIN]
+             && tui_win_list[DISASSEM_WIN]->generic.is_visible)
+           {
+             make_invisible_and_set_new_height (TUI_DISASM_WIN,
+                                                TUI_DISASM_WIN->generic.height);
+             make_visible_with_new_height (TUI_DISASM_WIN);
+           }
+       }
       else
       else
-       warning ("Tab widths greater than 0 must be specified.\n");
+       warning (_("Tab widths greater than 0 must be specified."));
     }
     }
-
-  return;
-}                              /* _tuiSetTabWidth_command */
+}
 
 
 
 
-/*
-   ** _tuiSetWinHeight().
-   **        Set the height of the specified window.
- */
+/* Set the height of the specified window.  */
 static void
 static void
-_tuiSetWinHeight (char *arg, int fromTTY)
+tui_set_win_height (const char *arg, int from_tty)
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg != (char *) NULL)
     {
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
   if (arg != (char *) NULL)
     {
-      char *buf = xstrdup (arg);
-      char *bufPtr = buf;
-      char *wname = (char *) NULL;
-      int newHeight, i;
-      TuiWinInfoPtr winInfo;
-
-      wname = bufPtr;
-      bufPtr = strchr (bufPtr, ' ');
-      if (bufPtr != (char *) NULL)
+      std::string copy = arg;
+      char *buf = &copy[0];
+      char *buf_ptr = buf;
+      char *wname = NULL;
+      int new_height, i;
+      struct tui_win_info *win_info;
+
+      wname = buf_ptr;
+      buf_ptr = strchr (buf_ptr, ' ');
+      if (buf_ptr != (char *) NULL)
        {
        {
-         *bufPtr = (char) 0;
+         *buf_ptr = (char) 0;
 
 
-         /*
-            ** Validate the window name
-          */
+         /* Validate the window name.  */
          for (i = 0; i < strlen (wname); i++)
          for (i = 0; i < strlen (wname); i++)
-           wname[i] = toupper (wname[i]);
-         winInfo = partialWinByName (wname);
+           wname[i] = tolower (wname[i]);
+         win_info = tui_partial_win_by_name (wname);
 
 
-         if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
-           warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
+         if (win_info == (struct tui_win_info *) NULL
+             || !win_info->generic.is_visible)
+           warning (_("Invalid window specified. \n\
+The window name specified must be valid and visible.\n"));
          else
            {
          else
            {
-             /* Process the size */
-             while (*(++bufPtr) == ' ')
+             /* Process the size */
+             while (*(++buf_ptr) == ' ')
                ;
 
                ;
 
-             if (*bufPtr != (char) 0)
+             if (*buf_ptr != (char) 0)
                {
                  int negate = FALSE;
                {
                  int negate = FALSE;
-                 int fixedSize = TRUE;
-                 int inputNo;;
+                 int fixed_size = TRUE;
+                 int input_no;;
 
 
-                 if (*bufPtr == '+' || *bufPtr == '-')
+                 if (*buf_ptr == '+' || *buf_ptr == '-')
                    {
                    {
-                     if (*bufPtr == '-')
+                     if (*buf_ptr == '-')
                        negate = TRUE;
                        negate = TRUE;
-                     fixedSize = FALSE;
-                     bufPtr++;
+                     fixed_size = FALSE;
+                     buf_ptr++;
                    }
                    }
-                 inputNo = atoi (bufPtr);
-                 if (inputNo > 0)
+                 input_no = atoi (buf_ptr);
+                 if (input_no > 0)
                    {
                      if (negate)
                    {
                      if (negate)
-                       inputNo *= (-1);
-                     if (fixedSize)
-                       newHeight = inputNo;
+                       input_no *= (-1);
+                     if (fixed_size)
+                       new_height = input_no;
                      else
                      else
-                       newHeight = winInfo->generic.height + inputNo;
-                     /*
-                        ** Now change the window's height, and adjust all
-                        ** other windows around it
-                      */
-                     if (_tuiAdjustWinHeights (winInfo,
-                                               newHeight) == TUI_FAILURE)
-                       warning ("Invalid window height specified.\n%s",
+                       new_height = win_info->generic.height + input_no;
+
+                     /* Now change the window's height, and adjust
+                        all other windows around it.  */
+                     if (tui_adjust_win_heights (win_info,
+                                               new_height) == TUI_FAILURE)
+                       warning (_("Invalid window height specified.\n%s"),
                                 WIN_HEIGHT_USAGE);
                      else
                         tui_update_gdb_sizes ();
                    }
                  else
                                 WIN_HEIGHT_USAGE);
                      else
                         tui_update_gdb_sizes ();
                    }
                  else
-                   warning ("Invalid window height specified.\n%s",
+                   warning (_("Invalid window height specified.\n%s"),
                             WIN_HEIGHT_USAGE);
                }
            }
        }
       else
        printf_filtered (WIN_HEIGHT_USAGE);
                             WIN_HEIGHT_USAGE);
                }
            }
        }
       else
        printf_filtered (WIN_HEIGHT_USAGE);
-
-      if (buf != (char *) NULL)
-       tuiFree (buf);
     }
   else
     printf_filtered (WIN_HEIGHT_USAGE);
     }
   else
     printf_filtered (WIN_HEIGHT_USAGE);
-
-  return;
-}                              /* _tuiSetWinHeight */
-
-/*
-   ** _tuiSetWinHeight_command().
-   **        Set the height of the specified window, with va_list.
- */
-static void
-_tuiSetWinHeight_command (char *arg, int fromTTY)
-{
-  /* Make sure the curses mode is enabled.  */
-  tui_enable ();
-  _tuiSetWinHeight (arg, fromTTY);
 }
 
 }
 
-
-/*
-   ** _tuiXDBsetWinHeight().
-   **        XDB Compatibility command for setting the window height.  This will
-   **        increase or decrease the command window by the specified amount.
- */
+/* Set the height of the specified window, with va_list.  */
 static void
 static void
-_tuiXDBsetWinHeight (char *arg, int fromTTY)
+tui_set_win_height_command (const char *arg, int from_tty)
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
 {
   /* Make sure the curses mode is enabled.  */
   tui_enable ();
-  if (arg != (char *) NULL)
-    {
-      int inputNo = atoi (arg);
-
-      if (inputNo > 0)
-       {                       /* Add 1 for the locator */
-         int newHeight = termHeight () - (inputNo + 1);
-
-         if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
-             _tuiAdjustWinHeights (winList[CMD_WIN],
-                                   newHeight) == TUI_FAILURE)
-           warning ("Invalid window height specified.\n%s",
-                    XDBWIN_HEIGHT_USAGE);
-       }
-      else
-       warning ("Invalid window height specified.\n%s",
-                XDBWIN_HEIGHT_USAGE);
-    }
-  else
-    warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
-
-  return;
-}                              /* _tuiXDBsetWinHeight */
-
-/*
-   ** _tuiSetWinHeight_command().
-   **        Set the height of the specified window, with va_list.
- */
-static void
-_tuiXDBsetWinHeight_command (char *arg, int fromTTY)
-{
-  _tuiXDBsetWinHeight (arg, fromTTY);
+  tui_set_win_height (arg, from_tty);
 }
 
 }
 
-
-/*
-   ** _tuiAdjustWinHeights().
-   **        Function to adjust all window heights around the primary
- */
-static TuiStatus
-_tuiAdjustWinHeights (TuiWinInfoPtr primaryWinInfo, int newHeight)
+/* Function to adjust all window heights around the primary.   */
+static enum tui_status
+tui_adjust_win_heights (struct tui_win_info *primary_win_info,
+                       int new_height)
 {
 {
-  TuiStatus status = TUI_FAILURE;
+  enum tui_status status = TUI_FAILURE;
 
 
-  if (_newHeightOk (primaryWinInfo, newHeight))
+  if (new_height_ok (primary_win_info, new_height))
     {
       status = TUI_SUCCESS;
     {
       status = TUI_SUCCESS;
-      if (newHeight != primaryWinInfo->generic.height)
+      if (new_height != primary_win_info->generic.height)
        {
          int diff;
        {
          int diff;
-         TuiWinInfoPtr winInfo;
-         TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
-         TuiLayoutType curLayout = currentLayout ();
+         struct tui_win_info *win_info;
+         struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
+         enum tui_layout_type cur_layout = tui_current_layout ();
 
 
-         diff = (newHeight - primaryWinInfo->generic.height) * (-1);
-         if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
+         diff = (new_height - primary_win_info->generic.height) * (-1);
+         if (cur_layout == SRC_COMMAND 
+             || cur_layout == DISASSEM_COMMAND)
            {
            {
-             TuiWinInfoPtr srcWinInfo;
+             struct tui_win_info *src_win_info;
 
 
-             _makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
-             if (primaryWinInfo->generic.type == CMD_WIN)
+             make_invisible_and_set_new_height (primary_win_info, new_height);
+             if (primary_win_info->generic.type == CMD_WIN)
                {
                {
-                 winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
-                 srcWinInfo = winInfo;
+                 win_info = (tui_source_windows ())->list[0];
+                 src_win_info = win_info;
                }
              else
                {
                }
              else
                {
-                 winInfo = winList[CMD_WIN];
-                 srcWinInfo = primaryWinInfo;
+                 win_info = tui_win_list[CMD_WIN];
+                 src_win_info = primary_win_info;
                }
                }
-             _makeInvisibleAndSetNewHeight (winInfo,
-                                            winInfo->generic.height + diff);
-             cmdWin->generic.origin.y = locator->origin.y + 1;
-             _makeVisibleWithNewHeight (winInfo);
-             _makeVisibleWithNewHeight (primaryWinInfo);
-             if (srcWinInfo->generic.contentSize <= 0)
-               tui_erase_source_content (srcWinInfo, EMPTY_SOURCE_PROMPT);
+             make_invisible_and_set_new_height (win_info,
+                                            win_info->generic.height + diff);
+             TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+             make_visible_with_new_height (win_info);
+             make_visible_with_new_height (primary_win_info);
+             if (src_win_info->generic.content_size <= 0)
+               tui_erase_source_content (src_win_info, EMPTY_SOURCE_PROMPT);
            }
          else
            {
            }
          else
            {
-             TuiWinInfoPtr firstWin, secondWin;
+             struct tui_win_info *first_win;
+             struct tui_win_info *second_win;
 
 
-             if (curLayout == SRC_DISASSEM_COMMAND)
+             if (cur_layout == SRC_DISASSEM_COMMAND)
                {
                {
-                 firstWin = srcWin;
-                 secondWin = disassemWin;
+                 first_win = TUI_SRC_WIN;
+                 second_win = TUI_DISASM_WIN;
                }
              else
                {
                }
              else
                {
-                 firstWin = dataWin;
-                 secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
+                 first_win = TUI_DATA_WIN;
+                 second_win = (tui_source_windows ())->list[0];
                }
                }
-             if (primaryWinInfo == cmdWin)
-               {               /*
-                                  ** Split the change in height accross the 1st & 2nd windows
-                                  ** adjusting them as well.
-                                */
-                 int firstSplitDiff = diff / 2;        /* subtract the locator */
-                 int secondSplitDiff = firstSplitDiff;
+             if (primary_win_info == TUI_CMD_WIN)
+               { /* Split the change in height accross the 1st & 2nd
+                    windows, adjusting them as well.  */
+                 /* Subtract the locator.  */
+                 int first_split_diff = diff / 2;
+                 int second_split_diff = first_split_diff;
 
                  if (diff % 2)
                    {
 
                  if (diff % 2)
                    {
-                     if (firstWin->generic.height >
-                         secondWin->generic.height)
+                     if (first_win->generic.height >
+                         second_win->generic.height)
                        if (diff < 0)
                        if (diff < 0)
-                         firstSplitDiff--;
+                         first_split_diff--;
                        else
                        else
-                         firstSplitDiff++;
+                         first_split_diff++;
                      else
                        {
                          if (diff < 0)
                      else
                        {
                          if (diff < 0)
-                           secondSplitDiff--;
+                           second_split_diff--;
                          else
                          else
-                           secondSplitDiff++;
+                           second_split_diff++;
                        }
                    }
                        }
                    }
-                 /* make sure that the minimum hieghts are honored */
-                 while ((firstWin->generic.height + firstSplitDiff) < 3)
+                 /* Make sure that the minimum hieghts are
+                    honored.  */
+                 while ((first_win->generic.height + first_split_diff) < 3)
                    {
                    {
-                     firstSplitDiff++;
-                     secondSplitDiff--;
+                     first_split_diff++;
+                     second_split_diff--;
                    }
                    }
-                 while ((secondWin->generic.height + secondSplitDiff) < 3)
+                 while ((second_win->generic.height + second_split_diff) < 3)
                    {
                    {
-                     secondSplitDiff++;
-                     firstSplitDiff--;
+                     second_split_diff++;
+                     first_split_diff--;
                    }
                    }
-                 _makeInvisibleAndSetNewHeight (
-                                                 firstWin,
-                                firstWin->generic.height + firstSplitDiff);
-                 secondWin->generic.origin.y = firstWin->generic.height - 1;
-                 _makeInvisibleAndSetNewHeight (
-                   secondWin, secondWin->generic.height + secondSplitDiff);
-                 cmdWin->generic.origin.y = locator->origin.y + 1;
-                 _makeInvisibleAndSetNewHeight (cmdWin, newHeight);
+                 make_invisible_and_set_new_height (
+                                                 first_win,
+                                first_win->generic.height + first_split_diff);
+                 second_win->generic.origin.y = first_win->generic.height - 1;
+                 make_invisible_and_set_new_height (second_win,
+                                                    second_win->generic.height
+                                                    + second_split_diff);
+                 TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+                 make_invisible_and_set_new_height (TUI_CMD_WIN, new_height);
                }
              else
                {
                }
              else
                {
-                 if ((cmdWin->generic.height + diff) < 1)
-                   {           /*
-                                  ** If there is no way to increase the command window
-                                  ** take real estate from the 1st or 2nd window.
-                                */
-                     if ((cmdWin->generic.height + diff) < 1)
+                 if ((TUI_CMD_WIN->generic.height + diff) < 1)
+                   { /* If there is no way to increase the command
+                        window take real estate from the 1st or 2nd
+                        window.  */
+                     if ((TUI_CMD_WIN->generic.height + diff) < 1)
                        {
                          int i;
                        {
                          int i;
-                         for (i = cmdWin->generic.height + diff;
+
+                         for (i = TUI_CMD_WIN->generic.height + diff;
                               (i < 1); i++)
                               (i < 1); i++)
-                           if (primaryWinInfo == firstWin)
-                             secondWin->generic.height--;
+                           if (primary_win_info == first_win)
+                             second_win->generic.height--;
                            else
                            else
-                             firstWin->generic.height--;
+                             first_win->generic.height--;
                        }
                    }
                        }
                    }
-                 if (primaryWinInfo == firstWin)
-                   _makeInvisibleAndSetNewHeight (firstWin, newHeight);
+                 if (primary_win_info == first_win)
+                   make_invisible_and_set_new_height (first_win, new_height);
                  else
                  else
-                   _makeInvisibleAndSetNewHeight (
-                                                   firstWin,
-                                                 firstWin->generic.height);
-                 secondWin->generic.origin.y = firstWin->generic.height - 1;
-                 if (primaryWinInfo == secondWin)
-                   _makeInvisibleAndSetNewHeight (secondWin, newHeight);
+                   make_invisible_and_set_new_height (
+                                                   first_win,
+                                                 first_win->generic.height);
+                 second_win->generic.origin.y = first_win->generic.height - 1;
+                 if (primary_win_info == second_win)
+                   make_invisible_and_set_new_height (second_win, new_height);
                  else
                  else
-                   _makeInvisibleAndSetNewHeight (
-                                     secondWin, secondWin->generic.height);
-                 cmdWin->generic.origin.y = locator->origin.y + 1;
-                 if ((cmdWin->generic.height + diff) < 1)
-                   _makeInvisibleAndSetNewHeight (cmdWin, 1);
+                   make_invisible_and_set_new_height (
+                                     second_win, second_win->generic.height);
+                 TUI_CMD_WIN->generic.origin.y = locator->origin.y + 1;
+                 if ((TUI_CMD_WIN->generic.height + diff) < 1)
+                   make_invisible_and_set_new_height (TUI_CMD_WIN, 1);
                  else
                  else
-                   _makeInvisibleAndSetNewHeight (
-                                    cmdWin, cmdWin->generic.height + diff);
+                   make_invisible_and_set_new_height (TUI_CMD_WIN,
+                                                      TUI_CMD_WIN->generic.height + diff);
                }
                }
-             _makeVisibleWithNewHeight (cmdWin);
-             _makeVisibleWithNewHeight (secondWin);
-             _makeVisibleWithNewHeight (firstWin);
-             if (firstWin->generic.contentSize <= 0)
-               tui_erase_source_content (firstWin, EMPTY_SOURCE_PROMPT);
-             if (secondWin->generic.contentSize <= 0)
-               tui_erase_source_content (secondWin, EMPTY_SOURCE_PROMPT);
+             make_visible_with_new_height (TUI_CMD_WIN);
+             make_visible_with_new_height (second_win);
+             make_visible_with_new_height (first_win);
+             if (first_win->generic.content_size <= 0)
+               tui_erase_source_content (first_win, EMPTY_SOURCE_PROMPT);
+             if (second_win->generic.content_size <= 0)
+               tui_erase_source_content (second_win, EMPTY_SOURCE_PROMPT);
            }
        }
     }
 
   return status;
            }
        }
     }
 
   return status;
-}                              /* _tuiAdjustWinHeights */
+}
 
 
 
 
-/*
-   ** _makeInvisibleAndSetNewHeight().
-   **        Function make the target window (and auxillary windows associated
-   **        with the targer) invisible, and set the new height and location.
- */
+/* Function make the target window (and auxillary windows associated
+   with the targer) invisible, and set the new height and
+   location.  */
 static void
 static void
-_makeInvisibleAndSetNewHeight (TuiWinInfoPtr winInfo, int height)
+make_invisible_and_set_new_height (struct tui_win_info *win_info, 
+                                  int height)
 {
   int i;
 {
   int i;
-  TuiGenWinInfoPtr genWinInfo;
+  struct tui_gen_win_info *gen_win_info;
 
 
-  tui_make_invisible (&winInfo->generic);
-  winInfo->generic.height = height;
+  tui_make_invisible (&win_info->generic);
+  win_info->generic.height = height;
   if (height > 1)
   if (height > 1)
-    winInfo->generic.viewportHeight = height - 1;
+    win_info->generic.viewport_height = height - 1;
   else
   else
-    winInfo->generic.viewportHeight = height;
-  if (winInfo != cmdWin)
-    winInfo->generic.viewportHeight--;
+    win_info->generic.viewport_height = height;
+  if (win_info != TUI_CMD_WIN)
+    win_info->generic.viewport_height--;
 
 
-  /* Now deal with the auxillary windows associated with winInfo */
-  switch (winInfo->generic.type)
+  /* Now deal with the auxillary windows associated with win_info.  */
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      genWinInfo = winInfo->detail.sourceInfo.executionInfo;
-      tui_make_invisible (genWinInfo);
-      genWinInfo->height = height;
-      genWinInfo->origin.y = winInfo->generic.origin.y;
+      gen_win_info = win_info->detail.source_info.execution_info;
+      tui_make_invisible (gen_win_info);
+      gen_win_info->height = height;
+      gen_win_info->origin.y = win_info->generic.origin.y;
       if (height > 1)
       if (height > 1)
-       genWinInfo->viewportHeight = height - 1;
+       gen_win_info->viewport_height = height - 1;
       else
       else
-       genWinInfo->viewportHeight = height;
-      if (winInfo != cmdWin)
-       genWinInfo->viewportHeight--;
+       gen_win_info->viewport_height = height;
+      if (win_info != TUI_CMD_WIN)
+       gen_win_info->viewport_height--;
 
 
-      if (m_hasLocator (winInfo))
+      if (tui_win_has_locator (win_info))
        {
        {
-         genWinInfo = locatorWinInfoPtr ();
-         tui_make_invisible (genWinInfo);
-         genWinInfo->origin.y = winInfo->generic.origin.y + height;
+         gen_win_info = tui_locator_win_info_ptr ();
+         tui_make_invisible (gen_win_info);
+         gen_win_info->origin.y = win_info->generic.origin.y + height;
        }
       break;
     case DATA_WIN:
        }
       break;
     case DATA_WIN:
-      /* delete all data item windows */
-      for (i = 0; i < winInfo->generic.contentSize; i++)
+      /* Delete all data item windows.  */
+      for (i = 0; i < win_info->generic.content_size; i++)
        {
        {
-         genWinInfo = (TuiGenWinInfoPtr) & ((TuiWinElementPtr)
-                     winInfo->generic.content[i])->whichElement.dataWindow;
-         tui_delete_win (genWinInfo->handle);
-         genWinInfo->handle = (WINDOW *) NULL;
+         gen_win_info = (struct tui_gen_win_info *)
+           &((struct tui_win_element *)
+             win_info->generic.content[i])->which_element.data_window;
+         tui_delete_win (gen_win_info->handle);
+         gen_win_info->handle = NULL;
        }
       break;
     default:
        }
       break;
     default:
@@ -1356,58 +1461,58 @@ _makeInvisibleAndSetNewHeight (TuiWinInfoPtr winInfo, int height)
 }
 
 
 }
 
 
-/*
-   ** _makeVisibleWithNewHeight().
-   **        Function to make the windows with new heights visible.
-   **        This means re-creating the windows' content since the window
-   **        had to be destroyed to be made invisible.
- */
+/* Function to make the windows with new heights visible.  This means
+   re-creating the windows' content since the window had to be
+   destroyed to be made invisible.  */
 static void
 static void
-_makeVisibleWithNewHeight (TuiWinInfoPtr winInfo)
+make_visible_with_new_height (struct tui_win_info *win_info)
 {
   struct symtab *s;
 
 {
   struct symtab *s;
 
-  tui_make_visible (&winInfo->generic);
-  tui_check_and_display_highlight_if_needed (winInfo);
-  switch (winInfo->generic.type)
+  tui_make_visible (&win_info->generic);
+  tui_check_and_display_highlight_if_needed (win_info);
+  switch (win_info->generic.type)
     {
     case SRC_WIN:
     case DISASSEM_WIN:
     {
     case SRC_WIN:
     case DISASSEM_WIN:
-      freeWinContent (winInfo->detail.sourceInfo.executionInfo);
-      tui_make_visible (winInfo->detail.sourceInfo.executionInfo);
-      if (winInfo->generic.content != (OpaquePtr) NULL)
+      tui_free_win_content (win_info->detail.source_info.execution_info);
+      tui_make_visible (win_info->detail.source_info.execution_info);
+      if (win_info->generic.content != NULL)
        {
        {
-         TuiLineOrAddress lineOrAddr;
+         struct gdbarch *gdbarch = win_info->detail.source_info.gdbarch;
+         struct tui_line_or_address line_or_addr;
          struct symtab_and_line cursal
            = get_current_source_symtab_and_line ();
 
          struct symtab_and_line cursal
            = get_current_source_symtab_and_line ();
 
-         if (winInfo->generic.type == SRC_WIN)
-           lineOrAddr.lineNo =
-             winInfo->detail.sourceInfo.startLineOrAddr.lineNo;
-         else
-           lineOrAddr.addr =
-             winInfo->detail.sourceInfo.startLineOrAddr.addr;
-         freeWinContent (&winInfo->generic);
-         tui_update_source_window (winInfo, cursal.symtab, lineOrAddr, TRUE);
+         line_or_addr = win_info->detail.source_info.start_line_or_addr;
+         tui_free_win_content (&win_info->generic);
+         tui_update_source_window (win_info, gdbarch,
+                                   cursal.symtab, line_or_addr, TRUE);
        }
        }
-      else if (deprecated_selected_frame != (struct frame_info *) NULL)
+      else if (deprecated_safe_get_selected_frame () != NULL)
        {
        {
-         TuiLineOrAddress line;
-         struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
+         struct tui_line_or_address line;
+         struct symtab_and_line cursal
+           = get_current_source_symtab_and_line ();
+         struct frame_info *frame = deprecated_safe_get_selected_frame ();
+         struct gdbarch *gdbarch = get_frame_arch (frame);
 
 
-         s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
-         if (winInfo->generic.type == SRC_WIN)
-           line.lineNo = cursal.line;
+         s = find_pc_line_symtab (get_frame_pc (frame));
+         if (win_info->generic.type == SRC_WIN)
+           {
+             line.loa = LOA_LINE;
+             line.u.line_no = cursal.line;
+           }
          else
            {
          else
            {
-             find_line_pc (s, cursal.line, &line.addr);
+             line.loa = LOA_ADDRESS;
+             find_line_pc (s, cursal.line, &line.u.addr);
            }
            }
-         tui_update_source_window (winInfo, s, line, TRUE);
+         tui_update_source_window (win_info, gdbarch, s, line, TRUE);
        }
        }
-      if (m_hasLocator (winInfo))
+      if (tui_win_has_locator (win_info))
        {
        {
-         tui_make_visible (locatorWinInfoPtr ());
+         tui_make_visible (tui_locator_win_info_ptr ());
          tui_show_locator_content ();
        }
       break;
          tui_show_locator_content ();
        }
       break;
@@ -1415,199 +1520,195 @@ _makeVisibleWithNewHeight (TuiWinInfoPtr winInfo)
       tui_display_all_data ();
       break;
     case CMD_WIN:
       tui_display_all_data ();
       break;
     case CMD_WIN:
-      winInfo->detail.commandInfo.curLine = 0;
-      winInfo->detail.commandInfo.curch = 0;
-      wmove (winInfo->generic.handle,
-            winInfo->detail.commandInfo.curLine,
-            winInfo->detail.commandInfo.curch);
+#ifdef HAVE_WRESIZE
+      wresize (TUI_CMD_WIN->generic.handle,
+              TUI_CMD_WIN->generic.height,
+              TUI_CMD_WIN->generic.width);
+#endif
+      mvwin (TUI_CMD_WIN->generic.handle,
+            TUI_CMD_WIN->generic.origin.y,
+            TUI_CMD_WIN->generic.origin.x);
+      wmove (win_info->generic.handle, 0, 0);
       break;
     default:
       break;
     }
       break;
     default:
       break;
     }
-
-  return;
-}                              /* _makeVisibleWithNewHeight */
+}
 
 
 static int
 
 
 static int
-_newHeightOk (TuiWinInfoPtr primaryWinInfo, int newHeight)
+new_height_ok (struct tui_win_info *primary_win_info, 
+              int new_height)
 {
 {
-  int ok = (newHeight < termHeight ());
+  int ok = (new_height < tui_term_height ());
 
   if (ok)
     {
       int diff;
 
   if (ok)
     {
       int diff;
-      TuiLayoutType curLayout = currentLayout ();
+      enum tui_layout_type cur_layout = tui_current_layout ();
 
 
-      diff = (newHeight - primaryWinInfo->generic.height) * (-1);
-      if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
+      diff = (new_height - primary_win_info->generic.height) * (-1);
+      if (cur_layout == SRC_COMMAND || cur_layout == DISASSEM_COMMAND)
        {
        {
-         ok = ((primaryWinInfo->generic.type == CMD_WIN &&
-                newHeight <= (termHeight () - 4) &&
-                newHeight >= MIN_CMD_WIN_HEIGHT) ||
-               (primaryWinInfo->generic.type != CMD_WIN &&
-                newHeight <= (termHeight () - 2) &&
-                newHeight >= MIN_WIN_HEIGHT));
+         ok = ((primary_win_info->generic.type == CMD_WIN 
+                && new_height <= (tui_term_height () - 4) 
+                && new_height >= MIN_CMD_WIN_HEIGHT) 
+               || (primary_win_info->generic.type != CMD_WIN 
+                   && new_height <= (tui_term_height () - 2) 
+                   && new_height >= MIN_WIN_HEIGHT));
          if (ok)
          if (ok)
-           {                   /* check the total height */
-             TuiWinInfoPtr winInfo;
+           {                   /* Check the total height.  */
+             struct tui_win_info *win_info;
 
 
-             if (primaryWinInfo == cmdWin)
-               winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
+             if (primary_win_info == TUI_CMD_WIN)
+               win_info = (tui_source_windows ())->list[0];
              else
              else
-               winInfo = cmdWin;
-             ok = ((newHeight +
-                    (winInfo->generic.height + diff)) <= termHeight ());
+               win_info = TUI_CMD_WIN;
+             ok = ((new_height +
+                    (win_info->generic.height + diff)) <= tui_term_height ());
            }
        }
       else
        {
            }
        }
       else
        {
-         int curTotalHeight, totalHeight, minHeight = 0;
-         TuiWinInfoPtr firstWin, secondWin;
+         int cur_total_height, total_height, min_height = 0;
+         struct tui_win_info *first_win;
+         struct tui_win_info *second_win;
 
 
-         if (curLayout == SRC_DISASSEM_COMMAND)
+         if (cur_layout == SRC_DISASSEM_COMMAND)
            {
            {
-             firstWin = srcWin;
-             secondWin = disassemWin;
+             first_win = TUI_SRC_WIN;
+             second_win = TUI_DISASM_WIN;
            }
          else
            {
            }
          else
            {
-             firstWin = dataWin;
-             secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
+             first_win = TUI_DATA_WIN;
+             second_win = (tui_source_windows ())->list[0];
            }
            }
-         /*
-            ** We could simply add all the heights to obtain the same result
-            ** but below is more explicit since we subtract 1 for the
-            ** line that the first and second windows share, and add one
-            ** for the locator.
-          */
-         totalHeight = curTotalHeight =
-           (firstWin->generic.height + secondWin->generic.height - 1)
-           + cmdWin->generic.height + 1 /*locator */ ;
-         if (primaryWinInfo == cmdWin)
+         /* We could simply add all the heights to obtain the same
+            result but below is more explicit since we subtract 1 for
+            the line that the first and second windows share, and add
+            one for the locator.  */
+         total_height = cur_total_height =
+           (first_win->generic.height + second_win->generic.height - 1)
+           + TUI_CMD_WIN->generic.height + 1;  /* Locator. */
+         if (primary_win_info == TUI_CMD_WIN)
            {
            {
-             /* locator included since first & second win share a line */
-             ok = ((firstWin->generic.height +
-                    secondWin->generic.height + diff) >=
-                   (MIN_WIN_HEIGHT * 2) &&
-                   newHeight >= MIN_CMD_WIN_HEIGHT);
+             /* Locator included since first & second win share a line.  */
+             ok = ((first_win->generic.height +
+                    second_win->generic.height + diff) >=
+                   (MIN_WIN_HEIGHT * 2) 
+                   && new_height >= MIN_CMD_WIN_HEIGHT);
              if (ok)
                {
              if (ok)
                {
-                 totalHeight = newHeight + (firstWin->generic.height +
-                                         secondWin->generic.height + diff);
-                 minHeight = MIN_CMD_WIN_HEIGHT;
+                 total_height = new_height + 
+                   (first_win->generic.height +
+                    second_win->generic.height + diff);
+                 min_height = MIN_CMD_WIN_HEIGHT;
                }
            }
          else
            {
                }
            }
          else
            {
-             minHeight = MIN_WIN_HEIGHT;
-             /*
-                ** First see if we can increase/decrease the command
-                ** window.  And make sure that the command window is
-                ** at least 1 line
-              */
-             ok = ((cmdWin->generic.height + diff) > 0);
+             min_height = MIN_WIN_HEIGHT;
+
+             /* First see if we can increase/decrease the command
+                window.  And make sure that the command window is at
+                least 1 line.  */
+             ok = ((TUI_CMD_WIN->generic.height + diff) > 0);
              if (!ok)
              if (!ok)
-               {               /*
-                                  ** Looks like we have to increase/decrease one of
-                                  ** the other windows
-                                */
-                 if (primaryWinInfo == firstWin)
-                   ok = (secondWin->generic.height + diff) >= minHeight;
+               { /* Looks like we have to increase/decrease one of
+                    the other windows.  */
+                 if (primary_win_info == first_win)
+                   ok = (second_win->generic.height + diff) >= min_height;
                  else
                  else
-                   ok = (firstWin->generic.height + diff) >= minHeight;
+                   ok = (first_win->generic.height + diff) >= min_height;
                }
              if (ok)
                {
                }
              if (ok)
                {
-                 if (primaryWinInfo == firstWin)
-                   totalHeight = newHeight +
-                     secondWin->generic.height +
-                     cmdWin->generic.height + diff;
+                 if (primary_win_info == first_win)
+                   total_height = new_height +
+                     second_win->generic.height +
+                     TUI_CMD_WIN->generic.height + diff;
                  else
                  else
-                   totalHeight = newHeight +
-                     firstWin->generic.height +
-                     cmdWin->generic.height + diff;
+                   total_height = new_height +
+                     first_win->generic.height +
+                     TUI_CMD_WIN->generic.height + diff;
                }
            }
                }
            }
-         /*
-            ** Now make sure that the proposed total height doesn't exceed
-            ** the old total height.
-          */
+         /* Now make sure that the proposed total height doesn't
+            exceed the old total height.  */
          if (ok)
          if (ok)
-           ok = (newHeight >= minHeight && totalHeight <= curTotalHeight);
+           ok = (new_height >= min_height 
+                 && total_height <= cur_total_height);
        }
     }
 
   return ok;
        }
     }
 
   return ok;
-}                              /* _newHeightOk */
+}
 
 
 
 
-/*
-   ** _parseScrollingArgs().
- */
 static void
 static void
-_parseScrollingArgs (char *arg, TuiWinInfoPtr * winToScroll, int *numToScroll)
+parse_scrolling_args (const char *arg, 
+                     struct tui_win_info **win_to_scroll,
+                     int *num_to_scroll)
 {
 {
-  if (numToScroll)
-    *numToScroll = 0;
-  *winToScroll = tuiWinWithFocus ();
-
-  /*
-     ** First set up the default window to scroll, in case there is no
-     ** window name arg
-   */
+  if (num_to_scroll)
+    *num_to_scroll = 0;
+  *win_to_scroll = tui_win_with_focus ();
+
+  /* First set up the default window to scroll, in case there is no
+     window name arg.  */
   if (arg != (char *) NULL)
     {
   if (arg != (char *) NULL)
     {
-      char *buf, *bufPtr;
+      char *buf_ptr;
 
 
-      /* process the number of lines to scroll */
-      buf = bufPtr = xstrdup (arg);
-      if (isdigit (*bufPtr))
+      /* Process the number of lines to scroll.  */
+      std::string copy = arg;
+      buf_ptr = &copy[0];
+      if (isdigit (*buf_ptr))
        {
        {
-         char *numStr;
+         char *num_str;
 
 
-         numStr = bufPtr;
-         bufPtr = strchr (bufPtr, ' ');
-         if (bufPtr != (char *) NULL)
+         num_str = buf_ptr;
+         buf_ptr = strchr (buf_ptr, ' ');
+         if (buf_ptr != (char *) NULL)
            {
            {
-             *bufPtr = (char) 0;
-             if (numToScroll)
-               *numToScroll = atoi (numStr);
-             bufPtr++;
+             *buf_ptr = (char) 0;
+             if (num_to_scroll)
+               *num_to_scroll = atoi (num_str);
+             buf_ptr++;
            }
            }
-         else if (numToScroll)
-           *numToScroll = atoi (numStr);
+         else if (num_to_scroll)
+           *num_to_scroll = atoi (num_str);
        }
 
        }
 
-      /* process the window name if one is specified */
-      if (bufPtr != (char *) NULL)
+      /* Process the window name if one is specified.  */
+      if (buf_ptr != (char *) NULL)
        {
        {
-         char *wname;
-         int i;
+         const char *wname;
 
 
-         if (*bufPtr == ' ')
-           while (*(++bufPtr) == ' ')
+         if (*buf_ptr == ' ')
+           while (*(++buf_ptr) == ' ')
              ;
 
              ;
 
-         if (*bufPtr != (char) 0)
-           wname = bufPtr;
+         if (*buf_ptr != (char) 0)
+           {
+             /* Validate the window name.  */
+             for (char *p = buf_ptr; *p != '\0'; p++)
+               *p = tolower (*p);
+
+             wname = buf_ptr;
+           }
          else
            wname = "?";
          
          else
            wname = "?";
          
-         /* Validate the window name */
-         for (i = 0; i < strlen (wname); i++)
-           wname[i] = toupper (wname[i]);
-         *winToScroll = partialWinByName (wname);
-
-         if (*winToScroll == (TuiWinInfoPtr) NULL ||
-             !(*winToScroll)->generic.isVisible)
-           warning ("Invalid window specified. \n\
-The window name specified must be valid and visible.\n");
-         else if (*winToScroll == cmdWin)
-           *winToScroll = (TuiWinInfoPtr) (sourceWindows ())->list[0];
+         *win_to_scroll = tui_partial_win_by_name (wname);
+
+         if (*win_to_scroll == (struct tui_win_info *) NULL
+             || !(*win_to_scroll)->generic.is_visible)
+           error (_("Invalid window specified. \n\
+The window name specified must be valid and visible.\n"));
+         else if (*win_to_scroll == TUI_CMD_WIN)
+           *win_to_scroll = (tui_source_windows ())->list[0];
        }
        }
-      tuiFree (buf);
     }
     }
-
-  return;
-}                              /* _parseScrollingArgs */
+}
This page took 0.101589 seconds and 4 git commands to generate.