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

Bug Summary

File:	src/gnu/usr.bin/texinfo/info/window.c
Warning:	line 145, column 13 Use of memory after it is freed
Annotated Source Code

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

 Copyright (C) 1993, 1997, 1998, 2001, 2002, 2003, 2004 Free Software
 Foundation, Inc.

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

23#include "info.h"
24#include "nodes.h"
25#include "window.h"
26#include "display.h"
27#include "info-utils.h"
28#include "infomap.h"

30/* The window which describes the screen. */
31WINDOW *the_screen = NULL((void *)0);

33/* The window which describes the echo area. */
34WINDOW *the_echo_area = NULL((void *)0);

36/* The list of windows in Info. */
37WINDOW *windows = NULL((void *)0);

39/* Pointer to the active window in WINDOW_LIST. */
40WINDOW *active_window = NULL((void *)0);

42/* The size of the echo area in Info.  It never changes, irregardless of the
 size of the screen. */
44#define ECHO_AREA_HEIGHT1 1

46/* Macro returns the amount of space that the echo area truly requires relative
 to the entire screen. */
48#define echo_area_required(1 + the_echo_area->height) (1 + the_echo_area->height)

50/* Initalize the window system by creating THE_SCREEN and THE_ECHO_AREA.
 Create the first window ever.
 You pass the dimensions of the total screen size. */
53void
54window_initialize_windows (int width, int height)
55{
the_screen = xmalloc (sizeof (WINDOW));
the_echo_area = xmalloc (sizeof (WINDOW));
windows = xmalloc (sizeof (WINDOW));
active_window = windows;

zero_mem (the_screen, sizeof (WINDOW))memset (the_screen, 0, sizeof (WINDOW));
zero_mem (the_echo_area, sizeof (WINDOW))memset (the_echo_area, 0, sizeof (WINDOW));
zero_mem (active_window, sizeof (WINDOW))memset (active_window, 0, sizeof (WINDOW));

/* None of these windows has a goal column yet. */
the_echo_area->goal_column = -1;
active_window->goal_column = -1;
the_screen->goal_column = -1;

/* The active and echo_area windows are visible.
   The echo_area is permanent.
   The screen is permanent. */
active_window->flags = W_WindowVisible0x04;
the_echo_area->flags = W_WindowIsPerm0x02 | W_InhibitMode0x08 | W_WindowVisible0x04;
the_screen->flags    = W_WindowIsPerm0x02;

/* The height of the echo area never changes.  It is statically set right
   here, and it must be at least 1 line for display.  The size of the
   initial window cannot be the same size as the screen, since the screen
   includes the echo area.  So, we make the height of the initial window
   equal to the screen's displayable region minus the height of the echo
   area. */
the_echo_area->height = ECHO_AREA_HEIGHT1;
active_window->height = the_screen->height - 1 - the_echo_area->height;
window_new_screen_size (width, height);
1
Calling 'window_new_screen_size'→

/* The echo area uses a different keymap than normal info windows. */
the_echo_area->keymap = echo_area_keymap;
active_window->keymap = info_keymap;
90}

92/* Given that the size of the screen has changed to WIDTH and HEIGHT
 from whatever it was before (found in the_screen->height, ->width),
 change the size (and possibly location) of each window in the screen.
 If a window would become too small, call the function DELETER on it,
 after deleting the window from our chain of windows.  If DELETER is NULL,
 nothing extra is done.  The last window can never be deleted, but it can
 become invisible. */

100/* If non-null, a function to call with WINDOW as argument when the function
 window_new_screen_size () has deleted WINDOW. */
102VFunction *window_deletion_notifier = NULL((void *)0);

104void
105window_new_screen_size (int width, int height)
106{
register WINDOW *win;
int delta_height, delta_each, delta_leftover;
int numwins;

/* If no change, do nothing. */
if (width == the_screen->width && height == the_screen->height)
2
←
Assuming 'width' is not equal to field 'width'→
  return;

/* If the new window height is too small, make it be zero. */
if (height < (WINDOW_MIN_SIZE(2 + 1) + the_echo_area->height))
3
←
Assuming the condition is false→
4
←
Taking false branch→
  height = 0;
if (width < 0)
5
←
Assuming 'width' is >= 0→
6
←
Taking false branch→
  width = 0;

/* Find out how many windows will change. */
for (numwins = 0, win = windows; win; win = win->next, numwins++);
7
←
Loop condition is true.  Entering loop body→
8
←
Loop condition is true.  Entering loop body→
9
←
Loop condition is false. Execution continues on line 130→

/* See if some windows will need to be deleted.  This is the case if
   the screen is getting smaller, and the available space divided by
   the number of windows is less than WINDOW_MIN_SIZE.  In that case,
   delete some windows and try again until there is either enough
   space to divy up among the windows, or until there is only one
   window left. */
while ((height - echo_area_required(1 + the_echo_area->height)) / numwins <= WINDOW_MIN_SIZE(2 + 1))
10
←
Assuming the condition is true→
11
←
Loop condition is true.  Entering loop body→
40
←
Assuming the condition is true→
41
←
Loop condition is true.  Entering loop body→
  {
    /* If only one window, make the size of it be zero, and return
       immediately. */
    if (!windows->next11.1
Field 'next' is non-null
1
Field 'next' is non-null
)
12
←
Taking false branch→
42
←
Taking false branch→
      {
        windows->height = 0;
        maybe_free (windows->line_starts)do { if (windows->line_starts) free (windows->line_starts
); } while (0);
        windows->line_starts = NULL((void *)0);
        windows->line_count = 0;
        break;
      }

    /* If we have some temporary windows, delete one of them. */
    for (win = windows; win; win = win->next)
13
←
Loop condition is true.  Entering loop body→
15
←
Loop condition is true.  Entering loop body→
43
←
Loop condition is true.  Entering loop body→
45
←
Loop condition is true.  Entering loop body→
      if (win->flags & W_TempWindow0x40)
14
←
Taking false branch→
16
←
Assuming the condition is true→
17
←
Taking true branch→
44
←
Taking false branch→
46
←
Use of memory after it is freed
        break;
18
←
 Execution continues on line 149→

    /* Otherwise, delete the first window, and try again. */
    if (!win18.1
'win' is non-null
)
19
←
Taking false branch→
      win = windows;

    if (window_deletion_notifier)
20
←
Assuming 'window_deletion_notifier' is null→
21
←
Taking false branch→
      (*window_deletion_notifier) (win);

    window_delete_window (win);
22
←
Calling 'window_delete_window'→
39
←
Returning; memory was released via 1st parameter→
    numwins--;
  }

/* The screen has changed height and width. */
delta_height = height - the_screen->height;   /* This is how much. */
the_screen->height = height;                  /* This is the new height. */
the_screen->width = width;                    /* This is the new width. */

/* Set the start of the echo area. */
the_echo_area->first_row = height - the_echo_area->height;
the_echo_area->width = width;

/* Check to see if the screen can really be changed this way. */
if ((!windows->next) && ((windows->height == 0) && (delta_height < 0)))
  return;

/* Divide the change in height among the available windows. */
delta_each = delta_height / numwins;
delta_leftover = delta_height - (delta_each * numwins);

/* Change the height of each window in the chain by delta_each.  Change
   the height of the last window in the chain by delta_each and by the
   leftover amount of change.  Change the width of each window to be
   WIDTH. */
for (win = windows; win; win = win->next)
  {
    if ((win->width != width) && ((win->flags & W_InhibitMode0x08) == 0))
      {
        win->width = width;
        maybe_free (win->modeline)do { if (win->modeline) free (win->modeline); } while (
0);
        win->modeline = xmalloc (1 + width);
      }

    win->height += delta_each;

    /* If the previous height of this window was zero, it was the only
       window, and it was not visible.  Thus we need to compensate for
       the echo_area. */
    if (win->height == delta_each)
      win->height -= (1 + the_echo_area->height);

    /* If this is not the first window in the chain, then change the
       first row of it.  We cannot just add delta_each to the first row,
       since this window's first row is the sum of the collective increases
       that have gone before it.  So we just add one to the location of the
       previous window's modeline. */
    if (win->prev)
      win->first_row = (win->prev->first_row + win->prev->height) + 1;

    /* The last window in the chain gets the extra space (or shrinkage). */
    if (!win->next)
      win->height += delta_leftover;

    if (win->node)
      recalculate_line_starts (win);

    win->flags |= W_UpdateWindow0x01;
  }

/* If the screen got smaller, check over the windows just shrunk to
   keep them within bounds.  Some of the windows may have gotten smaller
   than WINDOW_MIN_HEIGHT in which case some of the other windows are
   larger than the available display space in the screen.  Because of our
   intial test above, we know that there is enough space for all of the
   windows. */
if ((delta_each < 0) && ((windows->height != 0) && windows->next))
  {
    int avail;

    avail = the_screen->height - (numwins + the_echo_area->height);
    win = windows;

    while (win)
      {
        if ((win->height < WINDOW_MIN_HEIGHT2) ||
            (win->height > avail))
          {
            WINDOW *lastwin = NULL((void *)0);

            /* Split the space among the available windows. */
            delta_each = avail / numwins;
            delta_leftover = avail - (delta_each * numwins);

            for (win = windows; win; win = win->next)
              {
                lastwin = win;
                if (win->prev)
                  win->first_row =
                    (win->prev->first_row + win->prev->height) + 1;
                win->height = delta_each;
              }

            /* Give the leftover space (if any) to the last window. */
            lastwin->height += delta_leftover;
            break;
          }
        else
          win= win->next;
      }
  }
256}

258/* Make a new window showing NODE, and return that window structure.
 If NODE is passed as NULL, then show the node showing in the active
 window.  If the window could not be made return a NULL pointer.  The
 active window is not changed.*/
262WINDOW *
263window_make_window (NODE *node)
264{
WINDOW *window;

if (!node)
  node = active_window->node;

/* If there isn't enough room to make another window, return now. */
if ((active_window->height / 2) < WINDOW_MIN_SIZE(2 + 1))
  return (NULL((void *)0));

/* Make and initialize the new window.
   The fudging about with -1 and +1 is because the following window in the
   chain cannot start at window->height, since that is where the modeline
   for the previous window is displayed.  The inverse adjustment is made
   in window_delete_window (). */
window = xmalloc (sizeof (WINDOW));
window->width = the_screen->width;
window->height = (active_window->height / 2) - 1;
282#if defined (SPLIT_BEFORE_ACTIVE)
window->first_row = active_window->first_row;
284#else
window->first_row = active_window->first_row +
  (active_window->height - window->height);
287#endif
window->keymap = info_keymap;
window->goal_column = -1;
window->modeline = xmalloc (1 + window->width);
window->line_starts = NULL((void *)0);
window->flags = W_UpdateWindow0x01 | W_WindowVisible0x04;
window_set_node_of_window (window, node);

/* Adjust the height of the old active window. */
active_window->height -= (window->height + 1);
297#if defined (SPLIT_BEFORE_ACTIVE)
active_window->first_row += (window->height + 1);
299#endif
active_window->flags |= W_UpdateWindow0x01;

/* Readjust the new and old windows so that their modelines and contents
   will be displayed correctly. */
304#if defined (NOTDEF)
/* We don't have to do this for WINDOW since window_set_node_of_window ()
   already did. */
window_adjust_pagetop (window);
window_make_modeline (window);
309#endif /* NOTDEF */

/* We do have to readjust the existing active window. */
window_adjust_pagetop (active_window);
window_make_modeline (active_window);

315#if defined (SPLIT_BEFORE_ACTIVE)
/* This window is just before the active one.  The active window gets
   bumped down one.  The active window is not changed. */
window->next = active_window;

window->prev = active_window->prev;
active_window->prev = window;

if (window->prev)
  window->prev->next = window;
else
  windows = window;
327#else
/* This window is just after the active one.  Which window is active is
   not changed. */
window->prev = active_window;
window->next = active_window->next;
active_window->next = window;
if (window->next)
  window->next->prev = window;
335#endif /* !SPLIT_BEFORE_ACTIVE */
return (window);
337}

339/* These useful macros make it possible to read the code in
 window_change_window_height (). */
341#define grow_me_shrinking_next(me, next, diff)do { me->height += diff; next->height -= diff; next->
first_row += diff; window_adjust_pagetop (next); } while (0) \
do { \
  me->height += diff; \
  next->height -= diff; \
  next->first_row += diff; \
  window_adjust_pagetop (next); \
} while (0)

349#define grow_me_shrinking_prev(me, prev, diff)do { me->height += diff; prev->height -= diff; me->first_row
 -=diff; window_adjust_pagetop (prev); } while (0) \
do { \
  me->height += diff; \
  prev->height -= diff; \
  me->first_row -=diff; \
  window_adjust_pagetop (prev); \
} while (0)

357#define shrink_me_growing_next(me, next, diff)do { me->height -= diff; next->height += diff; next->
first_row -= diff; window_adjust_pagetop (next); } while (0) \
do { \
  me->height -= diff; \
  next->height += diff; \
  next->first_row -= diff; \
  window_adjust_pagetop (next); \
} while (0)

365#define shrink_me_growing_prev(me, prev, diff)do { me->height -= diff; prev->height += diff; me->first_row
 += diff; window_adjust_pagetop (prev); } while (0) \
do { \
  me->height -= diff; \
  prev->height += diff; \
  me->first_row += diff; \
  window_adjust_pagetop (prev); \
} while (0)

373/* Change the height of WINDOW by AMOUNT.  This also automagically adjusts
 the previous and next windows in the chain.  If there is only one user
 window, then no change takes place. */
376void
377window_change_window_height (WINDOW *window, int amount)
378{
register WINDOW *win, *prev, *next;

/* If there is only one window, or if the amount of change is zero,
   return immediately. */
if (!windows->next || amount == 0)
  return;

/* Find this window in our chain. */
for (win = windows; win; win = win->next)
  if (win == window)
    break;

/* If the window is isolated (i.e., doesn't appear in our window list,
   then quit now. */
if (!win)
  return;

/* Change the height of this window by AMOUNT, if that is possible.
   It can be impossible if there isn't enough available room on the
   screen, or if the resultant window would be too small. */

  prev = window->prev;
  next = window->next;

/* WINDOW decreasing in size? */
if (amount < 0)
  {
    int abs_amount = -amount; /* It is easier to deal with this way. */

    /* If the resultant window would be too small, stop here. */
    if ((window->height - abs_amount) < WINDOW_MIN_HEIGHT2)
      return;

    /* If we have two neighboring windows, choose the smaller one to get
       larger. */
    if (next && prev)
      {
        if (prev->height < next->height)
          shrink_me_growing_prev (window, prev, abs_amount)do { window->height -= abs_amount; prev->height += abs_amount
; window->first_row += abs_amount; window_adjust_pagetop (
prev); } while (0);
        else
          shrink_me_growing_next (window, next, abs_amount)do { window->height -= abs_amount; next->height += abs_amount
; next->first_row -= abs_amount; window_adjust_pagetop (next
); } while (0);
      }
    else if (next)
      shrink_me_growing_next (window, next, abs_amount)do { window->height -= abs_amount; next->height += abs_amount
; next->first_row -= abs_amount; window_adjust_pagetop (next
); } while (0);
    else
      shrink_me_growing_prev (window, prev, abs_amount)do { window->height -= abs_amount; prev->height += abs_amount
; window->first_row += abs_amount; window_adjust_pagetop (
prev); } while (0);
  }

/* WINDOW increasing in size? */
if (amount > 0)
  {
    int total_avail, next_avail = 0, prev_avail = 0;

    if (next)
      next_avail = next->height - WINDOW_MIN_SIZE(2 + 1);

    if (prev)
      prev_avail = prev->height - WINDOW_MIN_SIZE(2 + 1);

    total_avail = next_avail + prev_avail;

    /* If there isn't enough space available to grow this window, give up. */
    if (amount > total_avail)
      return;

    /* If there aren't two neighboring windows, or if one of the neighbors
       is larger than the other one by at least AMOUNT, grow that one. */
    if ((next && !prev) || ((next_avail - amount) >= prev_avail))
      grow_me_shrinking_next (window, next, amount)do { window->height += amount; next->height -= amount; next
->first_row += amount; window_adjust_pagetop (next); } while
 (0);
    else if ((prev && !next) || ((prev_avail - amount) >= next_avail))
      grow_me_shrinking_prev (window, prev, amount)do { window->height += amount; prev->height -= amount; window
->first_row -=amount; window_adjust_pagetop (prev); } while
 (0);
    else
      {
        int change;

        /* This window has two neighbors.  They both must be shrunk in to
           make enough space for WINDOW to grow.  Make them both the same
           size. */
        if (prev_avail > next_avail)
          {
            change = prev_avail - next_avail;
            grow_me_shrinking_prev (window, prev, change)do { window->height += change; prev->height -= change; window
->first_row -=change; window_adjust_pagetop (prev); } while
 (0);
            amount -= change;
          }
        else
          {
            change = next_avail - prev_avail;
            grow_me_shrinking_next (window, next, change)do { window->height += change; next->height -= change; next
->first_row += change; window_adjust_pagetop (next); } while
 (0);
            amount -= change;
          }

        /* Both neighbors are the same size.  Split the difference in
           AMOUNT between them. */
        while (amount)
          {
            window->height++;
            amount--;

            /* Odd numbers grow next, even grow prev. */
            if (amount & 1)
              {
                prev->height--;
                window->first_row--;
              }
            else
              {
                next->height--;
                next->first_row++;
              }
          }
        window_adjust_pagetop (prev);
        window_adjust_pagetop (next);
      }
  }
if (prev)
  prev->flags |= W_UpdateWindow0x01;

if (next)
  next->flags |= W_UpdateWindow0x01;

window->flags |= W_UpdateWindow0x01;
window_adjust_pagetop (window);
501}

503/* Tile all of the windows currently displayed in the global variable
 WINDOWS.  If argument STYLE is TILE_INTERNALS, tile windows displaying
 internal nodes as well, otherwise do not change the height of such
 windows. */
507void
508window_tile_windows (int style)
509{
WINDOW *win, *last_adjusted;
int numwins, avail, per_win_height, leftover;
int do_internals;

numwins = avail = 0;
do_internals = (style == TILE_INTERNALS1);

for (win = windows; win; win = win->next)
  if (do_internals || !win->node ||
      (win->node->flags & N_IsInternal0x10) == 0)
    {
      avail += win->height;
      numwins++;
    }

if (numwins <= 1 || !the_screen->height)
  return;

/* Find the size for each window.  Divide the size of the usable portion
   of the screen by the number of windows. */
per_win_height = avail / numwins;
leftover = avail - (per_win_height * numwins);

last_adjusted = NULL((void *)0);
for (win = windows; win; win = win->next)
  {
    if (do_internals || !win->node ||
        (win->node->flags & N_IsInternal0x10) == 0)
      {
        last_adjusted = win;
        win->height = per_win_height;
      }
  }

if (last_adjusted)
  last_adjusted->height += leftover;

/* Readjust the first_row of every window in the chain. */
for (win = windows; win; win = win->next)
  {
    if (win->prev)
      win->first_row = win->prev->first_row + win->prev->height + 1;

    window_adjust_pagetop (win);
    win->flags |= W_UpdateWindow0x01;
  }
556}

558/* Toggle the state of line wrapping in WINDOW.  This can do a bit of fancy
 redisplay. */
560void
561window_toggle_wrap (WINDOW *window)
562{
if (window->flags & W_NoWrap0x10)
  window->flags &= ~W_NoWrap0x10;
else
  window->flags |= W_NoWrap0x10;

if (window != the_echo_area)
  {
    char **old_starts;
    int old_lines, old_pagetop;

    old_starts = window->line_starts;
    old_lines = window->line_count;
    old_pagetop = window->pagetop;

    calculate_line_starts (window);

    /* Make sure that point appears within this window. */
    window_adjust_pagetop (window);

    /* If the pagetop hasn't changed maybe we can do some scrolling now
       to speed up the display.  Many of the line starts will be the same,
       so scrolling here is a very good optimization.*/
    if (old_pagetop == window->pagetop)
      display_scroll_line_starts
        (window, old_pagetop, old_starts, old_lines);
    maybe_free (old_starts)do { if (old_starts) free (old_starts); } while (0);
  }
window->flags |= W_UpdateWindow0x01;
591}

593/* Set WINDOW to display NODE. */
594void
595window_set_node_of_window (WINDOW *window, NODE *node)
596{
window->node = node;
window->pagetop = 0;
window->point = 0;
recalculate_line_starts (window);
window->flags |= W_UpdateWindow0x01;
/* The display_pos member is nonzero if we're displaying an anchor.  */
window->point = node ? node->display_pos : 0;
window_adjust_pagetop (window);
window_make_modeline (window);
606}
607
608/* Delete WINDOW from the list of known windows.  If this window was the
 active window, make the next window in the chain be the active window.
 If the active window is the next or previous window, choose that window
 as the recipient of the extra space.  Otherwise, prefer the next window. */
612void
613window_delete_window (WINDOW *window)
614{
WINDOW *next, *prev, *window_to_fix;

next = window->next;
prev = window->prev;

/* You cannot delete the only window or a permanent window. */
if ((!next22.1
'next' is null
 && !prev) || (window->flags & W_WindowIsPerm0x02))
23
←
Assuming 'prev' is non-null→
24
←
Assuming the condition is false→
25
←
Taking false branch→
  return;

if (next25.1
'next' is null
)
26
←
Taking false branch→
  next->prev = prev;

if (!prev26.1
'prev' is non-null
)
27
←
Taking false branch→
  windows = next;
else
  prev->next = next;

if (window->line_starts)
28
←
Assuming field 'line_starts' is null→
29
←
Taking false branch→
  free (window->line_starts);

if (window->modeline)
30
←
Assuming field 'modeline' is null→
31
←
Taking false branch→
  free (window->modeline);

if (window == active_window)
32
←
Assuming 'window' is not equal to 'active_window'→
33
←
Taking false branch→
  {
    /* If there isn't a next window, then there must be a previous one,
       since we cannot delete the last window.  If there is a next window,
       prefer to use that as the active window. */
    if (next)
      active_window = next;
    else
      active_window = prev;
  }

if (next33.1
'next' is null
 && active_window == next)
  window_to_fix = next;
else if (prev33.2
'prev' is non-null
 && active_window == prev)
34
←
Assuming 'active_window' is equal to 'prev'→
35
←
Taking true branch→
  window_to_fix = prev;
else if (next)
  window_to_fix = next;
else if (prev)
  window_to_fix = prev;
else
  window_to_fix = windows;
  
if (window_to_fix->first_row > window->first_row)
36
←
Assuming 'window_to_fix->first_row' is <= 'window->first_row'→
37
←
Taking false branch→
  {
    int diff;

    /* Try to adjust the visible part of the node so that as little
       text as possible has to move. */
    diff = window_to_fix->first_row - window->first_row;
    window_to_fix->first_row = window->first_row;

    window_to_fix->pagetop -= diff;
    if (window_to_fix->pagetop < 0)
      window_to_fix->pagetop = 0;
  }

/* The `+ 1' is to offset the difference between the first_row locations.
   See the code in window_make_window (). */
window_to_fix->height += window->height + 1;
window_to_fix->flags |= W_UpdateWindow0x01;

free (window);
38
←
Memory is released→
680}

682/* For every window in CHAIN, set the flags member to have FLAG set. */
683void
684window_mark_chain (WINDOW *chain, int flag)
685{
register WINDOW *win;

for (win = chain; win; win = win->next)
  win->flags |= flag;
690}

692/* For every window in CHAIN, clear the flags member of FLAG. */
693void
694window_unmark_chain (WINDOW *chain, int flag)
695{
register WINDOW *win;

for (win = chain; win; win = win->next)
  win->flags &= ~flag;
700}

702/* Return the number of characters it takes to display CHARACTER on the
 screen at HPOS. */
704int
705character_width (int character, int hpos)
706{
int printable_limit = 127;
int width = 1;

if (ISO_Latin_p)
  printable_limit = 255;

if (character > printable_limit)
  width = 3;
else if (iscntrl (character))
  {
    switch (character)
      {
      case '\r':
      case '\n':
        width = the_screen->width - hpos;
        break;
      case '\t':
        width = ((hpos + 8) & 0xf8) - hpos;
        break;
      default:
        width = 2;
      }
  }
else if (character == DEL'\177')
  width = 2;

return (width);
734}

736/* Return the number of characters it takes to display STRING on the screen
 at HPOS. */
738int
739string_width (char *string, int hpos)
740{
register int i, width, this_char_width;

for (width = 0, i = 0; string[i]; i++)
  {
    /* Support ANSI escape sequences for -R.  */
    if (raw_escapes_p
 && string[i] == '\033'
 && string[i+1] == '['
 && isdigit (string[i+2])
 && (string[i+3] == 'm'
     || (isdigit (string[i+3]) && string[i+4] == 'm')))
{
 while (string[i] != 'm')
   i++;
 this_char_width = 0;
}
    else
this_char_width = character_width (string[i], hpos);
    width += this_char_width;
    hpos += this_char_width;
  }
return (width);
763}

765/* Quickly guess the approximate number of lines that NODE would
 take to display.  This really only counts carriage returns. */
767int
768window_physical_lines (NODE *node)
769{
register int i, lines;
char *contents;

if (!node)
  return (0);

contents = node->contents;
for (i = 0, lines = 1; i < node->nodelen; i++)
  if (contents[i] == '\n')
    lines++;

return (lines);
782}

784/* Calculate a list of line starts for the node belonging to WINDOW.  The line
 starts are pointers to the actual text within WINDOW->NODE. */
786void
787calculate_line_starts (WINDOW *window)
788{
register int i, hpos;
char **line_starts = NULL((void *)0);
int line_starts_index = 0, line_starts_slots = 0;
int bump_index;
NODE *node;

window->line_starts = NULL((void *)0);
window->line_count = 0;
node = window->node;

if (!node)
  return;

/* Grovel the node starting at the top, and for each line calculate the
   width of the characters appearing in that line.  Add each line start
   to our array. */
i = 0;
hpos = 0;
bump_index = 0;

while (i < node->nodelen)
  {
    char *line = node->contents + i;
    unsigned int cwidth, c;

    add_pointer_to_array (line, line_starts_index, line_starts,do { if (line_starts_index + 2 >= line_starts_slots) line_starts
 = (char * *)(xrealloc (line_starts, (line_starts_slots += 100
) * sizeof (char *))); line_starts[line_starts_index++] = (char
 *)line; line_starts[line_starts_index] = (char *)((void *)0)
; } while (0)
                          line_starts_slots, 100, char *)do { if (line_starts_index + 2 >= line_starts_slots) line_starts
 = (char * *)(xrealloc (line_starts, (line_starts_slots += 100
) * sizeof (char *))); line_starts[line_starts_index++] = (char
 *)line; line_starts[line_starts_index] = (char *)((void *)0)
; } while (0);
    if (bump_index)
      {
        i++;
        bump_index = 0;
      }

    while (1)
      {
 /* The cast to unsigned char is for 8-bit characters, which
    could be passed as negative integers to character_width
    and wreak havoc on some naive implementations of iscntrl.  */
        c = (unsigned char) node->contents[i];

 /* Support ANSI escape sequences for -R.  */
 if (raw_escapes_p
     && c == '\033'
     && node->contents[i+1] == '['
     && isdigit (node->contents[i+2]))
   {
     if (node->contents[i+3] == 'm')
{
  i += 3;
  cwidth = 0;
}
     else if (isdigit (node->contents[i+3])
       && node->contents[i+4] == 'm')
{
  i += 4;
  cwidth = 0;
}
     else
cwidth = character_width (c, hpos);
   }
 else
   cwidth = character_width (c, hpos);

        /* If this character fits within this line, just do the next one. */
        if ((hpos + cwidth) < (unsigned int) window->width)
          {
            i++;
            hpos += cwidth;
            continue;
          }
        else
          {
            /* If this character would position the cursor at the start of
               the next printed screen line, then do the next line. */
            if (c == '\n' || c == '\r' || c == '\t')
              {
                i++;
                hpos = 0;
                break;
              }
            else
              {
                /* This character passes the window width border.  Postion
                   the cursor after the printed character, but remember this
                   line start as where this character is.  A bit tricky. */

                /* If this window doesn't wrap lines, proceed to the next
                   physical line here. */
                if (window->flags & W_NoWrap0x10)
                  {
                    hpos = 0;
                    while (i < node->nodelen && node->contents[i] != '\n')
                      i++;

                    if (node->contents[i] == '\n')
                      i++;
                  }
                else
                  {
                    hpos = the_screen->width - hpos;
                    bump_index++;
                  }
                break;
              }
          }
      }
  }
window->line_starts = line_starts;
window->line_count = line_starts_index;
898}

900/* Given WINDOW, recalculate the line starts for the node it displays. */
901void
902recalculate_line_starts (WINDOW *window)
903{
maybe_free (window->line_starts)do { if (window->line_starts) free (window->line_starts
); } while (0);
calculate_line_starts (window);
906}

908/* Global variable control redisplay of scrolled windows.  If non-zero, it
 is the desired number of lines to scroll the window in order to make
 point visible.  A user might set this to 1 for smooth scrolling.  If
 set to zero, the line containing point is centered within the window. */
912int window_scroll_step = 0;

914/* Adjust the pagetop of WINDOW such that the cursor point will be visible. */
915void
916window_adjust_pagetop (WINDOW *window)
917{
register int line = 0;
char *contents;

if (!window->node)
  return;

contents = window->node->contents;

/* Find the first printed line start which is after WINDOW->point. */
for (line = 0; line < window->line_count; line++)
  {
    char *line_start;

    line_start = window->line_starts[line];

    if ((line_start - contents) > window->point)
      break;
  }

/* The line index preceding the line start which is past point is the
   one containing point. */
line--;

/* If this line appears in the current displayable page, do nothing.
   Otherwise, adjust the top of the page to make this line visible. */
if ((line < window->pagetop) ||
    (line - window->pagetop > (window->height - 1)))
  {
    /* The user-settable variable "scroll-step" is used to attempt
       to make point visible, iff it is non-zero.  If that variable
       is zero, then the line containing point is centered within
       the window. */
    if (window_scroll_step < window->height)
      {
        if ((line < window->pagetop) &&
            ((window->pagetop - window_scroll_step) <= line))
          window->pagetop -= window_scroll_step;
        else if ((line - window->pagetop > (window->height - 1)) &&
                 ((line - (window->pagetop + window_scroll_step)
                   < window->height)))
          window->pagetop += window_scroll_step;
        else
          window->pagetop = line - ((window->height - 1) / 2);
      }
    else
      window->pagetop = line - ((window->height - 1) / 2);

    if (window->pagetop < 0)
      window->pagetop = 0;
    window->flags |= W_UpdateWindow0x01;
  }
969}

971/* Return the index of the line containing point. */
972int
973window_line_of_point (WINDOW *window)
974{
register int i, start = 0;

/* Try to optimize.  Check to see if point is past the pagetop for
   this window, and if so, start searching forward from there. */
if ((window->pagetop > -1 && window->pagetop < window->line_count) &&
    (window->line_starts[window->pagetop] - window->node->contents)
    <= window->point)
  start = window->pagetop;

for (i = start; i < window->line_count; i++)
  {
    if ((window->line_starts[i] - window->node->contents) > window->point)
      break;
  }

return (i - 1);
991}

993/* Get and return the goal column for this window. */
994int
995window_get_goal_column (WINDOW *window)
996{
if (!window->node)
  return (-1);

if (window->goal_column != -1)
  return (window->goal_column);

/* Okay, do the work.  Find the printed offset of the cursor
   in this window. */
return (window_get_cursor_column (window));
1006}

1008/* Get and return the printed column offset of the cursor in this window. */
1009int
1010window_get_cursor_column (WINDOW *window)
1011{
int i, hpos, end;
char *line;

i = window_line_of_point (window);

if (i < 0)
  return (-1);

line = window->line_starts[i];
end = window->point - (line - window->node->contents);

for (hpos = 0, i = 0; i < end; i++)
  {
    /* Support ANSI escape sequences for -R.  */
    if (raw_escapes_p
 && line[i] == '\033'
 && line[i+1] == '['
 && isdigit (line[i+2]))
{
 if (line[i+3] == 'm')
   i += 3;
 else if (isdigit (line[i+3]) && line[i+4] == 'm')
   i += 4;
 else
   hpos += character_width (line[i], hpos);
}
    else
hpos += character_width (line[i], hpos);
  }

return (hpos);
1043}

1045/* Count the number of characters in LINE that precede the printed column
 offset of GOAL. */
1047int
1048window_chars_to_goal (char *line, int goal)
1049{
register int i, check = 0, hpos;

for (hpos = 0, i = 0; line[i] != '\n'; i++)
  {
    /* Support ANSI escape sequences for -R.  */
    if (raw_escapes_p
 && line[i] == '\033'
 && line[i+1] == '['
 && isdigit (line[i+2])
 && (line[i+3] == 'm'
     || (isdigit (line[i+3]) && line[i+4] == 'm')))
while (line[i] != 'm')
 i++;
    else
check = hpos + character_width (line[i], hpos);

    if (check > goal)
      break;

    hpos = check;
  }
return (i);
1072}

1074/* Create a modeline for WINDOW, and store it in window->modeline. */
1075void
1076window_make_modeline (WINDOW *window)
1077{
register int i;
char *modeline;
char location_indicator[4];
int lines_remaining;

/* Only make modelines for those windows which have one. */
if (window->flags & W_InhibitMode0x08)
  return;

/* Find the number of lines actually displayed in this window. */
lines_remaining = window->line_count - window->pagetop;

if (window->pagetop == 0)
  {
    if (lines_remaining <= window->height)
      strcpy (location_indicator, "All");
    else
      strcpy (location_indicator, "Top");
  }
else
  {
    if (lines_remaining <= window->height)
      strcpy (location_indicator, "Bot");
    else
      {
        float pt, lc;
        int percentage;

        pt = (float)window->pagetop;
        lc = (float)window->line_count;

        percentage = 100 * (pt / lc);

        sprintf (location_indicator, "%2d%%", percentage);
      }
  }

/* Calculate the maximum size of the information to stick in MODELINE. */
{
  int modeline_len = 0;
  char *parent = NULL((void *)0), *filename = "*no file*";
  char *nodename = "*no node*";
  const char *update_message = NULL((void *)0);
  NODE *node = window->node;

  if (node)
    {
      if (node->nodename)
        nodename = node->nodename;

      if (node->parent)
        {
          parent = filename_non_directory (node->parent);
          modeline_len += strlen ("Subfile: ") + strlen (node->filename);
        }

      if (node->filename)
        filename = filename_non_directory (node->filename);

      if (node->flags & N_UpdateTags0x04)
        update_message = _("--*** Tags out of Date ***")((const char *) ("--*** Tags out of Date ***"));
    }

  if (update_message)
    modeline_len += strlen (update_message);
  modeline_len += strlen (filename);
  modeline_len += strlen (nodename);
  modeline_len += 4;          /* strlen (location_indicator). */

  /* 10 for the decimal representation of the number of lines in this
     node, and the remainder of the text that can appear in the line. */
  modeline_len += 10 + strlen (_("-----Info: (), lines ----, ")((const char *) ("-----Info: (), lines ----, ")));
  modeline_len += window->width;

  modeline = xmalloc (1 + modeline_len);

  /* Special internal windows have no filename. */
  if (!parent && !*filename)
    sprintf (modeline, _("-%s---Info: %s, %d lines --%s--")((const char *) ("-%s---Info: %s, %d lines --%s--")),
             (window->flags & W_NoWrap0x10) ? "$" : "-",
             nodename, window->line_count, location_indicator);
  else
    sprintf (modeline, _("-%s%s-Info: (%s)%s, %d lines --%s--")((const char *) ("-%s%s-Info: (%s)%s, %d lines --%s--")),
             (window->flags & W_NoWrap0x10) ? "$" : "-",
             (node && (node->flags & N_IsCompressed0x08)) ? "zz" : "--",
             parent ? parent : filename,
             nodename, window->line_count, location_indicator);

  if (parent)
    sprintf (modeline + strlen (modeline), _(" Subfile: %s")((const char *) (" Subfile: %s")), filename);

  if (update_message)
    sprintf (modeline + strlen (modeline), "%s", update_message);

  i = strlen (modeline);

  if (i >= window->width)
    modeline[window->width] = '\0';
  else
    {
      while (i < window->width)
        modeline[i++] = '-';
      modeline[i] = '\0';
    }

  strcpy (window->modeline, modeline);
  free (modeline);
}
1186}

1188/* Make WINDOW start displaying at PERCENT percentage of its node. */
1189void
1190window_goto_percentage (WINDOW *window, int percent)
1191{
int desired_line;

if (!percent)
  desired_line = 0;
else
  desired_line =
    (int) ((float)window->line_count * ((float)percent / 100.0));

window->pagetop = desired_line;
window->point =
  window->line_starts[window->pagetop] - window->node->contents;
window->flags |= W_UpdateWindow0x01;
window_make_modeline (window);
1205}

1207/* Get the state of WINDOW, and save it in STATE. */
1208void
1209window_get_state (WINDOW *window, SEARCH_STATE *state)
1210{
state->node = window->node;
state->pagetop = window->pagetop;
state->point = window->point;
1214}

1216/* Set the node, pagetop, and point of WINDOW. */
1217void
1218window_set_state (WINDOW *window, SEARCH_STATE *state)
1219{
if (window->node != state->node)
  window_set_node_of_window (window, state->node);
window->pagetop = state->pagetop;
window->point = state->point;
1224}

1226
1227/* Manipulating home-made nodes.  */

1229/* A place to buffer echo area messages. */
1230static NODE *echo_area_node = NULL((void *)0);

1232/* Make the node of the_echo_area be an empty one. */
1233static void
1234free_echo_area (void)
1235{
if (echo_area_node)
  {
    maybe_free (echo_area_node->contents)do { if (echo_area_node->contents) free (echo_area_node->
contents); } while (0);
    free (echo_area_node);
  }

echo_area_node = NULL((void *)0);
window_set_node_of_window (the_echo_area, echo_area_node);
1244}

1246/* Clear the echo area, removing any message that is already present.
 The echo area is cleared immediately. */
1248void
1249window_clear_echo_area (void)
1250{
free_echo_area ();
display_update_one_window (the_echo_area);
1253}

1255/* Make a message appear in the echo area, built from FORMAT, ARG1 and ARG2.
 The arguments are treated similar to printf () arguments, but not all of
 printf () hair is present.  The message appears immediately.  If there was
 already a message appearing in the echo area, it is removed. */
1259void
1260window_message_in_echo_area (char *format, void *arg1, void *arg2)
1261{
free_echo_area ();
echo_area_node = build_message_node (format, arg1, arg2);
window_set_node_of_window (the_echo_area, echo_area_node);
display_update_one_window (the_echo_area);
1266}

1268/* Place a temporary message in the echo area built from FORMAT, ARG1
 and ARG2.  The message appears immediately, but does not destroy
 any existing message.  A future call to unmessage_in_echo_area ()
 restores the old contents. */
1272static NODE **old_echo_area_nodes = NULL((void *)0);
1273static int old_echo_area_nodes_index = 0;
1274static int old_echo_area_nodes_slots = 0;

1276void
1277message_in_echo_area (char *format, void *arg1, void *arg2)
1278{
if (echo_area_node)
  {
    add_pointer_to_array (echo_area_node, old_echo_area_nodes_index,do { if (old_echo_area_nodes_index + 2 >= old_echo_area_nodes_slots
) old_echo_area_nodes = (NODE * *)(xrealloc (old_echo_area_nodes
, (old_echo_area_nodes_slots += 4) * sizeof (NODE *))); old_echo_area_nodes
[old_echo_area_nodes_index++] = (NODE *)echo_area_node; old_echo_area_nodes
[old_echo_area_nodes_index] = (NODE *)((void *)0); } while (0
)
                          old_echo_area_nodes, old_echo_area_nodes_slots,do { if (old_echo_area_nodes_index + 2 >= old_echo_area_nodes_slots
) old_echo_area_nodes = (NODE * *)(xrealloc (old_echo_area_nodes
, (old_echo_area_nodes_slots += 4) * sizeof (NODE *))); old_echo_area_nodes
[old_echo_area_nodes_index++] = (NODE *)echo_area_node; old_echo_area_nodes
[old_echo_area_nodes_index] = (NODE *)((void *)0); } while (0
)
                          4, NODE *)do { if (old_echo_area_nodes_index + 2 >= old_echo_area_nodes_slots
) old_echo_area_nodes = (NODE * *)(xrealloc (old_echo_area_nodes
, (old_echo_area_nodes_slots += 4) * sizeof (NODE *))); old_echo_area_nodes
[old_echo_area_nodes_index++] = (NODE *)echo_area_node; old_echo_area_nodes
[old_echo_area_nodes_index] = (NODE *)((void *)0); } while (0
);
  }
echo_area_node = NULL((void *)0);
window_message_in_echo_area (format, arg1, arg2);
1287}

1289void
1290unmessage_in_echo_area (void)
1291{
free_echo_area ();

if (old_echo_area_nodes_index)
  echo_area_node = old_echo_area_nodes[--old_echo_area_nodes_index];

window_set_node_of_window (the_echo_area, echo_area_node);
display_update_one_window (the_echo_area);
1299}

1301/* A place to build a message. */
1302static char *message_buffer = NULL((void *)0);
1303static int message_buffer_index = 0;
1304static int message_buffer_size = 0;

1306/* Ensure that there is enough space to stuff LENGTH characters into
 MESSAGE_BUFFER. */
1308static void
1309message_buffer_resize (int length)
1310{
if (!message_buffer)
  {
    message_buffer_size = length + 1;
    message_buffer = xmalloc (message_buffer_size);
    message_buffer_index = 0;
  }

while (message_buffer_size <= message_buffer_index + length)
  message_buffer = (char *)
    xrealloc (message_buffer,
              message_buffer_size += 100 + (2 * length));
1322}

1324/* Format MESSAGE_BUFFER with the results of printing FORMAT with ARG1 and
 ARG2. */
1326static void
1327build_message_buffer (char *format, void *arg1, void *arg2, void *arg3)
1328{
register int i, len;
void *args[3];
int arg_index = 0;

args[0] = arg1;
args[1] = arg2;
args[2] = arg3;

len = strlen (format);

message_buffer_resize (len);

for (i = 0; format[i]; i++)
  {
    if (format[i] != '%')
      {
        message_buffer[message_buffer_index++] = format[i];
        len--;
      }
    else
      {
        char c;
        char *fmt_start = format + i;
        char *fmt;
        int fmt_len, formatted_len;
 int paramed = 0;

format_again:
        i++;
        while (format[i] && strchr ("-. +0123456789", format[i]))
          i++;
        c = format[i];

        if (c == '\0')
          abort ();

 if (c == '$') {
   /* position parameter parameter */
   /* better to use bprintf from bfox's metahtml? */
   arg_index = atoi(fmt_start + 1) - 1;
   if (arg_index < 0)
     arg_index = 0;
   if (arg_index >= 2)
     arg_index = 1;
   paramed = 1;
   goto format_again;
 }

        fmt_len = format + i - fmt_start + 1;
        fmt = (char *) xmalloc (fmt_len + 1);
        strncpy (fmt, fmt_start, fmt_len);
        fmt[fmt_len] = '\0';

 if (paramed) {
   /* removed positioned parameter */
   char *p;
   for (p = fmt + 1; *p && *p != '$'; p++) {
     ;
   }
   strcpy(fmt + 1, p + 1);
 }

        /* If we have "%-98s", maybe 98 calls for a longer string.  */
        if (fmt_len > 2)
          {
            int j;

            for (j = fmt_len - 2; j >= 0; j--)
              if (isdigit (fmt[j]) || fmt[j] == '$')
                break;

            formatted_len = atoi (fmt + j);
          }
        else
          formatted_len = c == 's' ? 0 : 1; /* %s can produce empty string */

        switch (c)
          {
          case '%':           /* Insert a percent sign. */
            message_buffer_resize (len + formatted_len);
            sprintf
              (message_buffer + message_buffer_index, fmt, "%");
            message_buffer_index += formatted_len;
            break;

          case 's':           /* Insert the current arg as a string. */
            {
              char *string;
              int string_len;

              string = (char *)args[arg_index++];
              string_len = strlen (string);

              if (formatted_len > string_len)
                string_len = formatted_len;
              message_buffer_resize (len + string_len);
              sprintf
                (message_buffer + message_buffer_index, fmt, string);
              message_buffer_index += string_len;
            }
            break;

          case 'd':           /* Insert the current arg as an integer. */
            {
              long long_val;
              int integer;

              long_val = (long)args[arg_index++];
              integer = (int)long_val;

              message_buffer_resize (len + formatted_len > 32
                                     ? formatted_len : 32);
              sprintf
                (message_buffer + message_buffer_index, fmt, integer);
              message_buffer_index = strlen (message_buffer);
            }
            break;

          case 'c':           /* Insert the current arg as a character. */
            {
              long long_val;
              int character;

              long_val = (long)args[arg_index++];
              character = (int)long_val;

              message_buffer_resize (len + formatted_len);
              sprintf
                (message_buffer + message_buffer_index, fmt, character);
              message_buffer_index += formatted_len;
            }
            break;

          default:
            abort ();
          }
        free (fmt);
      }
  }
message_buffer[message_buffer_index] = '\0';
1469}

1471/* Build a new node which has FORMAT printed with ARG1 and ARG2 as the
 contents. */
1473NODE *
1474build_message_node (char *format, void *arg1, void *arg2)
1475{
NODE *node;

message_buffer_index = 0;
build_message_buffer (format, arg1, arg2, 0);

node = message_buffer_to_node ();
return (node);
1483}

1485/* Convert the contents of the message buffer to a node. */
1486NODE *
1487message_buffer_to_node (void)
1488{
NODE *node;

node = xmalloc (sizeof (NODE));
node->filename = NULL((void *)0);
node->parent = NULL((void *)0);
node->nodename = NULL((void *)0);
node->flags = 0;
node->display_pos =0;

/* Make sure that this buffer ends with a newline. */
node->nodelen = 1 + strlen (message_buffer);
node->contents = xmalloc (1 + node->nodelen);
strcpy (node->contents, message_buffer);
node->contents[node->nodelen - 1] = '\n';
node->contents[node->nodelen] = '\0';
return (node);
1505}

1507/* Useful functions can be called from outside of window.c. */
1508void
1509initialize_message_buffer (void)
1510{
message_buffer_index = 0;
1512}

1514/* Print FORMAT with ARG1,2 to the end of the current message buffer. */
1515void
1516printf_to_message_buffer (char *format, void *arg1, void *arg2, void *arg3)
1517{
build_message_buffer (format, arg1, arg2, arg3);
1519}

1521/* Return the current horizontal position of the "cursor" on the most
 recently output message buffer line. */
1523int
1524message_buffer_length_this_line (void)
1525{
register int i;

if (!message_buffer_index)
  return (0);

for (i = message_buffer_index; i && message_buffer[i - 1] != '\n'; i--);

return (string_width (message_buffer + i, 0));
1534}

1536/* Pad STRING to COUNT characters by inserting blanks. */
1537int
1538pad_to (int count, char *string)
1539{
register int i;

i = strlen (string);

if (i >= count)
  string[i++] = ' ';
else
  {
    while (i < count)
      string[i++] = ' ';
  }
string[i] = '\0';

return (i);
1554}