Subversion Repositories Open64

/* display.c -- readline redisplay facility. */

/* Copyright (C) 1987-2006 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for

   reading lines of text with interactive input and history editing.

   The GNU Readline Library 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.

   The GNU Readline Library 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.

   The GNU General Public License is often shipped with GNU software, and

   is generally kept in a file called COPYING or LICENSE.  If you do not

   have a copy of the license, write to the Free Software Foundation,

   59 Temple Place, Suite 330, Boston, MA 02111 USA. */

#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)

#  include <config.h>

#endif

#include <sys/types.h>

#if defined (HAVE_UNISTD_H)

#  include <unistd.h>

#endif /* HAVE_UNISTD_H */

#include "posixstat.h"

#if defined (HAVE_STDLIB_H)

#  include <stdlib.h>

#else

#  include "ansi_stdlib.h"

#endif /* HAVE_STDLIB_H */

#include <stdio.h>

/* System-specific feature definitions and include files. */

#include "rldefs.h"

#include "rlmbutil.h"

/* Termcap library stuff. */

#include "tcap.h"

/* Some standard library routines. */

#include "readline.h"

#include "history.h"

#include "rlprivate.h"

#include "xmalloc.h"

#if !defined (strchr) && !defined (__STDC__)

extern char *strchr (), *strrchr ();

#endif /* !strchr && !__STDC__ */

static void update_line PARAMS((char *, char *, int, int, int, int));

static void space_to_eol PARAMS((int));

static void delete_chars PARAMS((int));

static void insert_some_chars PARAMS((char *, int, int));

static void cr PARAMS((void));

#if defined (HANDLE_MULTIBYTE)

static int _rl_col_width PARAMS((const char *, int, int));

static int *_rl_wrapped_line;

#else

#  define _rl_col_width(l, s, e)  (((e) <= (s)) ? 0 : (e) - (s))

#endif

static int *inv_lbreaks, *vis_lbreaks;

static int inv_lbsize, vis_lbsize;

/* Heuristic used to decide whether it is faster to move from CUR to NEW

   by backing up or outputting a carriage return and moving forward.  CUR

   and NEW are either both buffer positions or absolute screen positions. */

#define CR_FASTER(new, cur) (((new) + 1) < ((cur) - (new)))

/* _rl_last_c_pos is an absolute cursor position in multibyte locales and a

   buffer index in others.  This macro is used when deciding whether the

   current cursor position is in the middle of a prompt string containing

   invisible characters. */

#define PROMPT_ENDING_INDEX \

  ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) ? prompt_physical_chars : prompt_last_invisible+1)

/* **************************************************************** */

/*                    */

/*      Display stuff           */

/*                    */

/* **************************************************************** */

/* This is the stuff that is hard for me.  I never seem to write good

   display routines in C.  Let's see how I do this time. */

/* (PWP) Well... Good for a simple line updater, but totally ignores

   the problems of input lines longer than the screen width.

   update_line and the code that calls it makes a multiple line,

   automatically wrapping line update.  Careful attention needs

   to be paid to the vertical position variables. */

/* Keep two buffers; one which reflects the current contents of the

   screen, and the other to draw what we think the new contents should

   be.  Then compare the buffers, and make whatever changes to the

   screen itself that we should.  Finally, make the buffer that we

   just drew into be the one which reflects the current contents of the

   screen, and place the cursor where it belongs.

   Commands that want to can fix the display themselves, and then let

   this function know that the display has been fixed by setting the

   RL_DISPLAY_FIXED variable.  This is good for efficiency. */

/* Application-specific redisplay function. */

rl_voidfunc_t *rl_redisplay_function = rl_redisplay;

/* Global variables declared here. */

/* What YOU turn on when you have handled all redisplay yourself. */

int rl_display_fixed = 0;

int _rl_suppress_redisplay = 0;

int _rl_want_redisplay = 0;

/* The stuff that gets printed out before the actual text of the line.

   This is usually pointing to rl_prompt. */

char *rl_display_prompt = (char *)NULL;

/* Pseudo-global variables declared here. */

/* The visible cursor position.  If you print some text, adjust this. */

/* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale

   supporting multibyte characters, and an absolute cursor position when

   in such a locale.  This is an artifact of the donated multibyte support.

   Care must be taken when modifying its value. */

int _rl_last_c_pos = 0;

int _rl_last_v_pos = 0;

static int cpos_adjusted;

static int cpos_buffer_position;

/* Number of lines currently on screen minus 1. */

int _rl_vis_botlin = 0;

/* Variables used only in this file. */

/* The last left edge of text that was displayed.  This is used when

   doing horizontal scrolling.  It shifts in thirds of a screenwidth. */

static int last_lmargin;

/* The line display buffers.  One is the line currently displayed on

   the screen.  The other is the line about to be displayed. */

static char *visible_line = (char *)NULL;

static char *invisible_line = (char *)NULL;

/* A buffer for `modeline' messages. */

static char msg_buf[128];

/* Non-zero forces the redisplay even if we thought it was unnecessary. */

static int forced_display;

/* Default and initial buffer size.  Can grow. */

static int line_size = 1024;

/* Variables to keep track of the expanded prompt string, which may

   include invisible characters. */

static char *local_prompt, *local_prompt_prefix;

static int local_prompt_len;

static int prompt_visible_length, prompt_prefix_length;

/* The number of invisible characters in the line currently being

   displayed on the screen. */

static int visible_wrap_offset;

/* The number of invisible characters in the prompt string.  Static so it

   can be shared between rl_redisplay and update_line */

static int wrap_offset;

/* The index of the last invisible character in the prompt string. */

static int prompt_last_invisible;

/* The length (buffer offset) of the first line of the last (possibly

   multi-line) buffer displayed on the screen. */

static int visible_first_line_len;

/* Number of invisible characters on the first physical line of the prompt.

   Only valid when the number of physical characters in the prompt exceeds

   (or is equal to) _rl_screenwidth. */

static int prompt_invis_chars_first_line;

static int prompt_last_screen_line;

static int prompt_physical_chars;

/* Variables to save and restore prompt and display information. */

/* These are getting numerous enough that it's time to create a struct. */

static char *saved_local_prompt;

static char *saved_local_prefix;

static int saved_last_invisible;

static int saved_visible_length;

static int saved_prefix_length;

static int saved_local_length;

static int saved_invis_chars_first_line;

static int saved_physical_chars;

/* Expand the prompt string S and return the number of visible

   characters in *LP, if LP is not null.  This is currently more-or-less

   a placeholder for expansion.  LIP, if non-null is a place to store the

   index of the last invisible character in the returned string. NIFLP,

   if non-zero, is a place to store the number of invisible characters in

   the first prompt line.  The previous are used as byte counts -- indexes

   into a character buffer. */

/* Current implementation:

  \001 (^A) start non-visible characters

  \002 (^B) end non-visible characters

   all characters except \001 and \002 (following a \001) are copied to

   the returned string; all characters except those between \001 and

   \002 are assumed to be `visible'. */

static char *

expand_prompt (pmt, lp, lip, niflp, vlp)

     char *pmt;

     int *lp, *lip, *niflp, *vlp;

{

  char *r, *ret, *p, *igstart;

  int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;

  /* Short-circuit if we can. */

  if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0)

    {

      r = savestring (pmt);

      if (lp)

  *lp = strlen (r);

      if (lip)

  *lip = 0;

      if (niflp)

  *niflp = 0;

      if (vlp)

  *vlp = lp ? *lp : strlen (r);

      return r;

    }

  l = strlen (pmt);

  r = ret = (char *)xmalloc (l + 1);

  invfl = 0;  /* invisible chars in first line of prompt */

  invflset = 0; /* we only want to set invfl once */

  igstart = 0;

  for (rl = ignoring = last = ninvis = physchars = 0, p = pmt; p && *p; p++)

    {

      /* This code strips the invisible character string markers

   RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */

      if (ignoring == 0 && *p == RL_PROMPT_START_IGNORE)    /* XXX - check ignoring? */

  {

    ignoring = 1;

    igstart = p;

    continue;

  }

      else if (ignoring && *p == RL_PROMPT_END_IGNORE)

  {

    ignoring = 0;

    if (p != (igstart + 1))

      last = r - ret - 1;

    continue;

  }

      else

  {

#if defined (HANDLE_MULTIBYTE)

    if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

      {

        pind = p - pmt;

        ind = _rl_find_next_mbchar (pmt, pind, 1, MB_FIND_NONZERO);

        l = ind - pind;

        while (l--)

          *r++ = *p++;

        if (!ignoring)

    {

      rl += ind - pind;

      physchars += _rl_col_width (pmt, pind, ind);

    }

        else

    ninvis += ind - pind;

        p--;      /* compensate for later increment */

      }

    else

#endif

      {

        *r++ = *p;

        if (!ignoring)

    {

      rl++;     /* visible length byte counter */

      physchars++;

    }

        else

    ninvis++;   /* invisible chars byte counter */

      }

    if (invflset == 0 && rl >= _rl_screenwidth)

      {

        invfl = ninvis;

        invflset = 1;

      }

  }

    }

  if (rl < _rl_screenwidth)

    invfl = ninvis;

  *r = '\0';

  if (lp)

    *lp = rl;

  if (lip)

    *lip = last;

  if (niflp)

    *niflp = invfl;

  if  (vlp)

    *vlp = physchars;

  return ret;

}

/* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from

   PMT and return the rest of PMT. */

char *

_rl_strip_prompt (pmt)

     char *pmt;

{

  char *ret;

  ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);

  return ret;

}

/*

 * Expand the prompt string into the various display components, if

 * necessary.

 *

 * local_prompt = expanded last line of string in rl_display_prompt

 *      (portion after the final newline)

 * local_prompt_prefix = portion before last newline of rl_display_prompt,

 *       expanded via expand_prompt

 * prompt_visible_length = number of visible characters in local_prompt

 * prompt_prefix_length = number of visible characters in local_prompt_prefix

 *

 * This function is called once per call to readline().  It may also be

 * called arbitrarily to expand the primary prompt.

 *

 * The return value is the number of visible characters on the last line

 * of the (possibly multi-line) prompt.

 */

int

rl_expand_prompt (prompt)

     char *prompt;

{

  char *p, *t;

  int c;

  /* Clear out any saved values. */

  FREE (local_prompt);

  FREE (local_prompt_prefix);

  local_prompt = local_prompt_prefix = (char *)0;

  local_prompt_len = 0;

  prompt_last_invisible = prompt_invis_chars_first_line = 0;

  prompt_visible_length = prompt_physical_chars = 0;

  if (prompt == 0 || *prompt == 0)

    return (0);

  p = strrchr (prompt, '\n');

  if (!p)

    {

      /* The prompt is only one logical line, though it might wrap. */

      local_prompt = expand_prompt (prompt, &prompt_visible_length,

              &prompt_last_invisible,

              &prompt_invis_chars_first_line,

              &prompt_physical_chars);

      local_prompt_prefix = (char *)0;

      local_prompt_len = local_prompt ? strlen (local_prompt) : 0;

      return (prompt_visible_length);

    }

  else

    {

      /* The prompt spans multiple lines. */

      t = ++p;

      local_prompt = expand_prompt (p, &prompt_visible_length,

               &prompt_last_invisible,

               (int *)NULL,

               &prompt_physical_chars);

      c = *t; *t = '\0';

      /* The portion of the prompt string up to and including the

   final newline is now null-terminated. */

      local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,

               (int *)NULL,

               &prompt_invis_chars_first_line,

               (int *)NULL);

      *t = c;

      local_prompt_len = local_prompt ? strlen (local_prompt) : 0;

      return (prompt_prefix_length);

    }

}

/* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated

   arrays of line break markers.  MINSIZE is the minimum size of VISIBLE_LINE

   and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is

   increased.  If the lines have already been allocated, this ensures that

   they can hold at least MINSIZE characters. */

static void

init_line_structures (minsize)

      int minsize;

{

  register int n;

  if (invisible_line == 0)  /* initialize it */

    {

      if (line_size < minsize)

  line_size = minsize;

      visible_line = (char *)xmalloc (line_size);

      invisible_line = (char *)xmalloc (line_size);

    }

  else if (line_size < minsize) /* ensure it can hold MINSIZE chars */

    {

      line_size *= 2;

      if (line_size < minsize)

  line_size = minsize;

      visible_line = (char *)xrealloc (visible_line, line_size);

      invisible_line = (char *)xrealloc (invisible_line, line_size);

    }

  for (n = minsize; n < line_size; n++)

    {

      visible_line[n] = 0;

      invisible_line[n] = 1;

    }

  if (vis_lbreaks == 0)

    {

      /* should be enough. */

      inv_lbsize = vis_lbsize = 256;

      inv_lbreaks = (int *)xmalloc (inv_lbsize * sizeof (int));

      vis_lbreaks = (int *)xmalloc (vis_lbsize * sizeof (int));

#if defined (HANDLE_MULTIBYTE)

      _rl_wrapped_line = (int *)xmalloc (vis_lbsize * sizeof (int));

#endif

      inv_lbreaks[0] = vis_lbreaks[0] = 0;

    }

}

/* Basic redisplay algorithm. */

void

rl_redisplay ()

{

  register int in, out, c, linenum, cursor_linenum;

  register char *line;

  int inv_botlin, lb_botlin, lb_linenum, o_cpos;

  int newlines, lpos, temp, modmark, n0, num;

  char *prompt_this_line;

#if defined (HANDLE_MULTIBYTE)

  wchar_t wc;

  size_t wc_bytes;

  int wc_width;

  mbstate_t ps;

  int _rl_wrapped_multicolumn = 0;

#endif

  if (!readline_echoing_p)

    return;

  if (!rl_display_prompt)

    rl_display_prompt = "";

  if (invisible_line == 0 || vis_lbreaks == 0)

    {

      init_line_structures (0);

      rl_on_new_line ();

    }

  /* Draw the line into the buffer. */

  cpos_buffer_position = -1;

  line = invisible_line;

  out = inv_botlin = 0;

  /* Mark the line as modified or not.  We only do this for history

     lines. */

  modmark = 0;

  if (_rl_mark_modified_lines && current_history () && rl_undo_list)

    {

      line[out++] = '*';

      line[out] = '\0';

      modmark = 1;

    }

  /* If someone thought that the redisplay was handled, but the currently

     visible line has a different modification state than the one about

     to become visible, then correct the caller's misconception. */

  if (visible_line[0] != invisible_line[0])

    rl_display_fixed = 0;

  /* If the prompt to be displayed is the `primary' readline prompt (the

     one passed to readline()), use the values we have already expanded.

     If not, use what's already in rl_display_prompt.  WRAP_OFFSET is the

     number of non-visible characters in the prompt string. */

  if (rl_display_prompt == rl_prompt || local_prompt)

    {

      if (local_prompt_prefix && forced_display)

  _rl_output_some_chars (local_prompt_prefix, strlen (local_prompt_prefix));

      if (local_prompt_len > 0)

  {

    temp = local_prompt_len + out + 2;

    if (temp >= line_size)

      {

        line_size = (temp + 1024) - (temp % 1024);

        visible_line = (char *)xrealloc (visible_line, line_size);

        line = invisible_line = (char *)xrealloc (invisible_line, line_size);

      }

    strncpy (line + out, local_prompt, local_prompt_len);

    out += local_prompt_len;

  }

      line[out] = '\0';

      wrap_offset = local_prompt_len - prompt_visible_length;

    }

  else

    {

      int pmtlen;

      prompt_this_line = strrchr (rl_display_prompt, '\n');

      if (!prompt_this_line)

  prompt_this_line = rl_display_prompt;

      else

  {

    prompt_this_line++;

    pmtlen = prompt_this_line - rl_display_prompt;  /* temp var */

    if (forced_display)

      {

        _rl_output_some_chars (rl_display_prompt, pmtlen);

        /* Make sure we are at column zero even after a newline,

     regardless of the state of terminal output processing. */

        if (pmtlen < 2 || prompt_this_line[-2] != '\r')

    cr ();

      }

  }

      prompt_physical_chars = pmtlen = strlen (prompt_this_line);

      temp = pmtlen + out + 2;

      if (temp >= line_size)

  {

    line_size = (temp + 1024) - (temp % 1024);

    visible_line = (char *)xrealloc (visible_line, line_size);

    line = invisible_line = (char *)xrealloc (invisible_line, line_size);

  }

      strncpy (line + out,  prompt_this_line, pmtlen);

      out += pmtlen;

      line[out] = '\0';

      wrap_offset = prompt_invis_chars_first_line = 0;

    }

#define CHECK_INV_LBREAKS() \

      do { \

  if (newlines >= (inv_lbsize - 2)) \

    { \

      inv_lbsize *= 2; \

      inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \

    } \

      } while (0)

#if defined (HANDLE_MULTIBYTE)

#define CHECK_LPOS() \

      do { \

  lpos++; \

  if (lpos >= _rl_screenwidth) \

    { \

      if (newlines >= (inv_lbsize - 2)) \

        { \

    inv_lbsize *= 2; \

    inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \

    _rl_wrapped_line = (int *)xrealloc (_rl_wrapped_line, inv_lbsize * sizeof (int)); \

        } \

      inv_lbreaks[++newlines] = out; \

      _rl_wrapped_line[newlines] = _rl_wrapped_multicolumn; \

      lpos = 0; \

    } \

      } while (0)

#else

#define CHECK_LPOS() \

      do { \

  lpos++; \

  if (lpos >= _rl_screenwidth) \

    { \

      if (newlines >= (inv_lbsize - 2)) \

        { \

    inv_lbsize *= 2; \

    inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \

        } \

      inv_lbreaks[++newlines] = out; \

      lpos = 0; \

    } \

      } while (0)

#endif

  /* inv_lbreaks[i] is where line i starts in the buffer. */

  inv_lbreaks[newlines = 0] = 0;

#if 0

  lpos = out - wrap_offset;

#else

  lpos = prompt_physical_chars + modmark;

#endif

#if defined (HANDLE_MULTIBYTE)

  memset (_rl_wrapped_line, 0, vis_lbsize);

  num = 0;

#endif

  /* prompt_invis_chars_first_line is the number of invisible characters in

     the first physical line of the prompt.

     wrap_offset - prompt_invis_chars_first_line is the number of invis

     chars on the second line. */

  /* what if lpos is already >= _rl_screenwidth before we start drawing the

     contents of the command line? */

  while (lpos >= _rl_screenwidth)

    {

      int z;

      /* fix from Darin Johnson <darin@acuson.com> for prompt string with

         invisible characters that is longer than the screen width.  The

         prompt_invis_chars_first_line variable could be made into an array

         saying how many invisible characters there are per line, but that's

         probably too much work for the benefit gained.  How many people have

         prompts that exceed two physical lines?

         Additional logic fix from Edward Catmur <ed@catmur.co.uk> */

#if defined (HANDLE_MULTIBYTE)

      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

  {

    n0 = num;

          temp = local_prompt_len;

          while (num < temp)

      {

        z = _rl_col_width  (local_prompt, n0, num);

        if (z > _rl_screenwidth)

    {

            num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);

            break;

    }

        else if (z == _rl_screenwidth)

          break;

        num++;

      }

          temp = num;

  }

      else

#endif /* !HANDLE_MULTIBYTE */

  temp = ((newlines + 1) * _rl_screenwidth);

      /* Now account for invisible characters in the current line. */

      temp += ((local_prompt_prefix == 0) ? ((newlines == 0) ? prompt_invis_chars_first_line

                   : ((newlines == 1) ? wrap_offset : 0))

            : ((newlines == 0) ? wrap_offset :0));

      inv_lbreaks[++newlines] = temp;

#if defined (HANDLE_MULTIBYTE)

      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

  lpos -= _rl_col_width (local_prompt, n0, num);

      else

#endif

  lpos -= _rl_screenwidth;

    }

  prompt_last_screen_line = newlines;

  /* Draw the rest of the line (after the prompt) into invisible_line, keeping

     track of where the cursor is (cpos_buffer_position), the number of the line containing

     the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).

     It maintains an array of line breaks for display (inv_lbreaks).

     This handles expanding tabs for display and displaying meta characters. */

  lb_linenum = 0;

#if defined (HANDLE_MULTIBYTE)

  in = 0;

  if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

    {

      memset (&ps, 0, sizeof (mbstate_t));

      wc_bytes = mbrtowc (&wc, rl_line_buffer, rl_end, &ps);

    }

  else

    wc_bytes = 1;

  while (in < rl_end)

#else

  for (in = 0; in < rl_end; in++)

#endif

    {

      c = (unsigned char)rl_line_buffer[in];

#if defined (HANDLE_MULTIBYTE)

      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

  {

    if (MB_INVALIDCH (wc_bytes))

      {

        /* Byte sequence is invalid or shortened.  Assume that the

           first byte represents a character. */

        wc_bytes = 1;

        /* Assume that a character occupies a single column. */

        wc_width = 1;

        memset (&ps, 0, sizeof (mbstate_t));

      }

    else if (MB_NULLWCH (wc_bytes))

      break;      /* Found '\0' */

    else

      {

        temp = wcwidth (wc);

        wc_width = (temp >= 0) ? temp : 1;

      }

  }

#endif

      if (out + 8 >= line_size)   /* XXX - 8 for \t */

  {

    line_size *= 2;

    visible_line = (char *)xrealloc (visible_line, line_size);

    invisible_line = (char *)xrealloc (invisible_line, line_size);

    line = invisible_line;

  }

      if (in == rl_point)

  {

    cpos_buffer_position = out;

    lb_linenum = newlines;

  }

#if defined (HANDLE_MULTIBYTE)

      if (META_CHAR (c) && _rl_output_meta_chars == 0)  /* XXX - clean up */

#else

      if (META_CHAR (c))

#endif

  {

    if (_rl_output_meta_chars == 0)

      {

        sprintf (line + out, "\\%o", c);

        if (lpos + 4 >= _rl_screenwidth)

    {

      temp = _rl_screenwidth - lpos;

      CHECK_INV_LBREAKS ();

      inv_lbreaks[++newlines] = out + temp;

      lpos = 4 - temp;

    }

        else

    lpos += 4;

        out += 4;

      }

    else

      {

        line[out++] = c;

        CHECK_LPOS();

      }

  }

#if defined (DISPLAY_TABS)

      else if (c == '\t')

  {

    register int newout;

#if 0

    newout = (out | (int)7) + 1;

#else

    newout = out + 8 - lpos % 8;

#endif

    temp = newout - out;

    if (lpos + temp >= _rl_screenwidth)

      {

        register int temp2;

        temp2 = _rl_screenwidth - lpos;

        CHECK_INV_LBREAKS ();

        inv_lbreaks[++newlines] = out + temp2;

        lpos = temp - temp2;

        while (out < newout)

    line[out++] = ' ';

      }

    else

      {

        while (out < newout)

    line[out++] = ' ';

        lpos += temp;

      }

  }

#endif

      else if (c == '\n' && _rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)

  {

    line[out++] = '\0'; /* XXX - sentinel */

    CHECK_INV_LBREAKS ();

    inv_lbreaks[++newlines] = out;

    lpos = 0;

  }

      else if (CTRL_CHAR (c) || c == RUBOUT)

  {

    line[out++] = '^';

    CHECK_LPOS();

    line[out++] = CTRL_CHAR (c) ? UNCTRL (c) : '?';

    CHECK_LPOS();

  }

      else

  {

#if defined (HANDLE_MULTIBYTE)

    if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

      {

        register int i;

        _rl_wrapped_multicolumn = 0;

        if (_rl_screenwidth < lpos + wc_width)

    for (i = lpos; i < _rl_screenwidth; i++)

      {

        /* The space will be removed in update_line() */

        line[out++] = ' ';

        _rl_wrapped_multicolumn++;

        CHECK_LPOS();

      }

        if (in == rl_point)

    {

      cpos_buffer_position = out;

      lb_linenum = newlines;

    }

        for (i = in; i < in+wc_bytes; i++)

    line[out++] = rl_line_buffer[i];

        for (i = 0; i < wc_width; i++)

    CHECK_LPOS();

      }

    else

      {

        line[out++] = c;

        CHECK_LPOS();

      }

#else

    line[out++] = c;

    CHECK_LPOS();

#endif

  }

#if defined (HANDLE_MULTIBYTE)

      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

  {

    in += wc_bytes;

    wc_bytes = mbrtowc (&wc, rl_line_buffer + in, rl_end - in, &ps);

  }

      else

        in++;

#endif

    }

  line[out] = '\0';

  if (cpos_buffer_position < 0)

    {

      cpos_buffer_position = out;

      lb_linenum = newlines;

    }

  inv_botlin = lb_botlin = newlines;

  CHECK_INV_LBREAKS ();

  inv_lbreaks[newlines+1] = out;

  cursor_linenum = lb_linenum;

  /* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.

     CURSOR_LINENUM == line number where the cursor should be placed. */

  /* PWP: now is when things get a bit hairy.  The visible and invisible

     line buffers are really multiple lines, which would wrap every

     (screenwidth - 1) characters.  Go through each in turn, finding

     the changed region and updating it.  The line order is top to bottom. */

  /* If we can move the cursor up and down, then use multiple lines,

     otherwise, let long lines display in a single terminal line, and

     horizontally scroll it. */

  if (_rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)

    {

      int nleft, pos, changed_screen_line, tx;

      if (!rl_display_fixed || forced_display)

  {

    forced_display = 0;

    /* If we have more than a screenful of material to display, then

       only display a screenful.  We should display the last screen,

       not the first.  */

    if (out >= _rl_screenchars)

      {

        if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

    out = _rl_find_prev_mbchar (line, _rl_screenchars, MB_FIND_ANY);

        else

    out = _rl_screenchars - 1;

      }

    /* The first line is at character position 0 in the buffer.  The

       second and subsequent lines start at inv_lbreaks[N], offset by

       OFFSET (which has already been calculated above).  */

#define W_OFFSET(line, offset) ((line) == 0 ? offset : 0)

#define VIS_LLEN(l) ((l) > _rl_vis_botlin ? 0 : (vis_lbreaks[l+1] - vis_lbreaks[l]))

#define INV_LLEN(l) (inv_lbreaks[l+1] - inv_lbreaks[l])

#define VIS_CHARS(line) (visible_line + vis_lbreaks[line])

#define VIS_LINE(line) ((line) > _rl_vis_botlin) ? "" : VIS_CHARS(line)

#define INV_LINE(line) (invisible_line + inv_lbreaks[line])

    /* For each line in the buffer, do the updating display. */

    for (linenum = 0; linenum <= inv_botlin; linenum++)

      {

        /* This can lead us astray if we execute a program that changes

     the locale from a non-multibyte to a multibyte one. */

        o_cpos = _rl_last_c_pos;

        cpos_adjusted = 0;

        update_line (VIS_LINE(linenum), INV_LINE(linenum), linenum,

         VIS_LLEN(linenum), INV_LLEN(linenum), inv_botlin);

        /* update_line potentially changes _rl_last_c_pos, but doesn't

     take invisible characters into account, since _rl_last_c_pos

     is an absolute cursor position in a multibyte locale.  See

     if compensating here is the right thing, or if we have to

     change update_line itself.  There is one case in which

     update_line adjusts _rl_last_c_pos itself (so it can pass

     _rl_move_cursor_relative accurate values); it communicates

     this back by setting cpos_adjusted.  If we assume that

     _rl_last_c_pos is correct (an absolute cursor position) each

     time update_line is called, then we can assume in our

     calculations that o_cpos does not need to be adjusted by

     wrap_offset. */

        if (linenum == 0 && (MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&

      cpos_adjusted == 0 &&

      _rl_last_c_pos != o_cpos &&

      _rl_last_c_pos > wrap_offset &&

      o_cpos < prompt_last_invisible)

    _rl_last_c_pos -= wrap_offset;

        /* If this is the line with the prompt, we might need to

     compensate for invisible characters in the new line. Do

     this only if there is not more than one new line (which

     implies that we completely overwrite the old visible line)

     and the new line is shorter than the old.  Make sure we are

     at the end of the new line before clearing. */

        if (linenum == 0 &&

      inv_botlin == 0 && _rl_last_c_pos == out &&

      (wrap_offset > visible_wrap_offset) &&

      (_rl_last_c_pos < visible_first_line_len))

    {

      if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)

        nleft = _rl_screenwidth - _rl_last_c_pos;

      else

        nleft = _rl_screenwidth + wrap_offset - _rl_last_c_pos;

      if (nleft)

        _rl_clear_to_eol (nleft);

    }

        /* Since the new first line is now visible, save its length. */

        if (linenum == 0)

    visible_first_line_len = (inv_botlin > 0) ? inv_lbreaks[1] : out - wrap_offset;

      }

    /* We may have deleted some lines.  If so, clear the left over

       blank ones at the bottom out. */

    if (_rl_vis_botlin > inv_botlin)

      {

        char *tt;

        for (; linenum <= _rl_vis_botlin; linenum++)

    {

      tt = VIS_CHARS (linenum);

      _rl_move_vert (linenum);

      _rl_move_cursor_relative (0, tt);

      _rl_clear_to_eol

        ((linenum == _rl_vis_botlin) ? strlen (tt) : _rl_screenwidth);

    }

      }

    _rl_vis_botlin = inv_botlin;

    /* CHANGED_SCREEN_LINE is set to 1 if we have moved to a

       different screen line during this redisplay. */

    changed_screen_line = _rl_last_v_pos != cursor_linenum;

    if (changed_screen_line)

      {

        _rl_move_vert (cursor_linenum);

        /* If we moved up to the line with the prompt using _rl_term_up,