contrib/libreadline/display.c

   1 /* $FreeBSD$ */
   2 /* display.c -- readline redisplay facility. */
   3
   4 /* Copyright (C) 1987-2006 Free Software Foundation, Inc.
   5
   6    This file is part of the GNU Readline Library, a library for
   7    reading lines of text with interactive input and history editing.
   8
   9    The GNU Readline Library is free software; you can redistribute it
  10    and/or modify it under the terms of the GNU General Public License
  11    as published by the Free Software Foundation; either version 2, or
  12    (at your option) any later version.
  13
  14    The GNU Readline Library is distributed in the hope that it will be
  15    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  16    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    The GNU General Public License is often shipped with GNU software, and
  20    is generally kept in a file called COPYING or LICENSE.  If you do not
  21    have a copy of the license, write to the Free Software Foundation,
  22    59 Temple Place, Suite 330, Boston, MA 02111 USA. */
  23 #define READLINE_LIBRARY
  24
  25 #if defined (HAVE_CONFIG_H)
  26 #  include <config.h>
  27 #endif
  28
  29 #include <sys/types.h>
  30
  31 #if defined (HAVE_UNISTD_H)
  32 #  include <unistd.h>
  33 #endif /* HAVE_UNISTD_H */
  34
  35 #include "posixstat.h"
  36
  37 #if defined (HAVE_STDLIB_H)
  38 #  include <stdlib.h>
  39 #else
  40 #  include "ansi_stdlib.h"
  41 #endif /* HAVE_STDLIB_H */
  42
  43 #include <stdio.h>
  44
  45 /* System-specific feature definitions and include files. */
  46 #include "rldefs.h"
  47 #include "rlmbutil.h"
  48
  49 /* Termcap library stuff. */
  50 #include "tcap.h"
  51
  52 /* Some standard library routines. */
  53 #include "readline.h"
  54 #include "history.h"
  55
  56 #include "rlprivate.h"
  57 #include "xmalloc.h"
  58
  59 #if !defined (strchr) && !defined (__STDC__)
  60 extern char *strchr (), *strrchr ();
  61 #endif /* !strchr && !__STDC__ */
  62
  63 static void update_line PARAMS((char *, char *, int, int, int, int));
  64 static void space_to_eol PARAMS((int));
  65 static void delete_chars PARAMS((int));
  66 static void insert_some_chars PARAMS((char *, int, int));
  67 static void cr PARAMS((void));
  68
  69 #if defined (HANDLE_MULTIBYTE)
  70 static int _rl_col_width PARAMS((const char *, int, int));
  71 static int *_rl_wrapped_line;
  72 #else
  73 #  define _rl_col_width(l, s, e)        (((e) <= (s)) ? 0 : (e) - (s))
  74 #endif
  75
  76 static int *inv_lbreaks, *vis_lbreaks;
  77 static int inv_lbsize, vis_lbsize;
  78
  79 /* Heuristic used to decide whether it is faster to move from CUR to NEW
  80    by backing up or outputting a carriage return and moving forward.  CUR
  81    and NEW are either both buffer positions or absolute screen positions. */
  82 #define CR_FASTER(new, cur) (((new) + 1) < ((cur) - (new)))
  83
  84 /* _rl_last_c_pos is an absolute cursor position in multibyte locales and a
  85    buffer index in others.  This macro is used when deciding whether the
  86    current cursor position is in the middle of a prompt string containing
  87    invisible characters. */
  88 #define PROMPT_ENDING_INDEX \
  89   ((MB_CUR_MAX > 1 && rl_byte_oriented == 0) ? prompt_physical_chars : prompt_last_invisible+1)
  90
  91
  92 /* **************************************************************** */
  93 /*                                                                  */
  94 /*                      Display stuff                               */
  95 /*                                                                  */
  96 /* **************************************************************** */
  97
  98 /* This is the stuff that is hard for me.  I never seem to write good
  99    display routines in C.  Let's see how I do this time. */
 100
 101 /* (PWP) Well... Good for a simple line updater, but totally ignores
 102    the problems of input lines longer than the screen width.
 103
 104    update_line and the code that calls it makes a multiple line,
 105    automatically wrapping line update.  Careful attention needs
 106    to be paid to the vertical position variables. */
 107
 108 /* Keep two buffers; one which reflects the current contents of the
 109    screen, and the other to draw what we think the new contents should
 110    be.  Then compare the buffers, and make whatever changes to the
 111    screen itself that we should.  Finally, make the buffer that we
 112    just drew into be the one which reflects the current contents of the
 113    screen, and place the cursor where it belongs.
 114
 115    Commands that want to can fix the display themselves, and then let
 116    this function know that the display has been fixed by setting the
 117    RL_DISPLAY_FIXED variable.  This is good for efficiency. */
 118
 119 /* Application-specific redisplay function. */
 120 rl_voidfunc_t *rl_redisplay_function = rl_redisplay;
 121
 122 /* Global variables declared here. */
 123 /* What YOU turn on when you have handled all redisplay yourself. */
 124 int rl_display_fixed = 0;
 125
 126 int _rl_suppress_redisplay = 0;
 127 int _rl_want_redisplay = 0;
 128
 129 /* The stuff that gets printed out before the actual text of the line.
 130    This is usually pointing to rl_prompt. */
 131 char *rl_display_prompt = (char *)NULL;
 132
 133 /* Pseudo-global variables declared here. */
 134
 135 /* The visible cursor position.  If you print some text, adjust this. */
 136 /* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale
 137    supporting multibyte characters, and an absolute cursor position when
 138    in such a locale.  This is an artifact of the donated multibyte support.
 139    Care must be taken when modifying its value. */
 140 int _rl_last_c_pos = 0;
 141 int _rl_last_v_pos = 0;
 142
 143 static int cpos_adjusted;
 144 static int cpos_buffer_position;
 145
 146 /* Number of lines currently on screen minus 1. */
 147 int _rl_vis_botlin = 0;
 148
 149 /* Variables used only in this file. */
 150 /* The last left edge of text that was displayed.  This is used when
 151    doing horizontal scrolling.  It shifts in thirds of a screenwidth. */
 152 static int last_lmargin;
 153
 154 /* The line display buffers.  One is the line currently displayed on
 155    the screen.  The other is the line about to be displayed. */
 156 static char *visible_line = (char *)NULL;
 157 static char *invisible_line = (char *)NULL;
 158
 159 /* A buffer for `modeline' messages. */
 160 static char msg_buf[128];
 161
 162 /* Non-zero forces the redisplay even if we thought it was unnecessary. */
 163 static int forced_display;
 164
 165 /* Default and initial buffer size.  Can grow. */
 166 static int line_size = 1024;
 167
 168 /* Variables to keep track of the expanded prompt string, which may
 169    include invisible characters. */
 170
 171 static char *local_prompt, *local_prompt_prefix;
 172 static int local_prompt_len;
 173 static int prompt_visible_length, prompt_prefix_length;
 174
 175 /* The number of invisible characters in the line currently being
 176    displayed on the screen. */
 177 static int visible_wrap_offset;
 178
 179 /* The number of invisible characters in the prompt string.  Static so it
 180    can be shared between rl_redisplay and update_line */
 181 static int wrap_offset;
 182
 183 /* The index of the last invisible character in the prompt string. */
 184 static int prompt_last_invisible;
 185
 186 /* The length (buffer offset) of the first line of the last (possibly
 187    multi-line) buffer displayed on the screen. */
 188 static int visible_first_line_len;
 189
 190 /* Number of invisible characters on the first physical line of the prompt.
 191    Only valid when the number of physical characters in the prompt exceeds
 192    (or is equal to) _rl_screenwidth. */
 193 static int prompt_invis_chars_first_line;
 194
 195 static int prompt_last_screen_line;
 196
 197 static int prompt_physical_chars;
 198
 199 /* Variables to save and restore prompt and display information. */
 200
 201 /* These are getting numerous enough that it's time to create a struct. */
 202
 203 static char *saved_local_prompt;
 204 static char *saved_local_prefix;
 205 static int saved_last_invisible;
 206 static int saved_visible_length;
 207 static int saved_prefix_length;
 208 static int saved_local_length;
 209 static int saved_invis_chars_first_line;
 210 static int saved_physical_chars;
 211
 212 /* Expand the prompt string S and return the number of visible
 213    characters in *LP, if LP is not null.  This is currently more-or-less
 214    a placeholder for expansion.  LIP, if non-null is a place to store the
 215    index of the last invisible character in the returned string. NIFLP,
 216    if non-zero, is a place to store the number of invisible characters in
 217    the first prompt line.  The previous are used as byte counts -- indexes
 218    into a character buffer. */
 219
 220 /* Current implementation:
 221         \001 (^A) start non-visible characters
 222         \002 (^B) end non-visible characters
 223    all characters except \001 and \002 (following a \001) are copied to
 224    the returned string; all characters except those between \001 and
 225    \002 are assumed to be `visible'. */
 226
 227 static char *
 228 expand_prompt (pmt, lp, lip, niflp, vlp)
 229      char *pmt;
 230      int *lp, *lip, *niflp, *vlp;
 231 {
 232   char *r, *ret, *p, *igstart;
 233   int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
 234
 235   /* Short-circuit if we can. */
 236   if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (pmt, RL_PROMPT_START_IGNORE) == 0)
 237     {
 238       r = savestring (pmt);
 239       if (lp)
 240         *lp = strlen (r);
 241       if (lip)
 242         *lip = 0;
 243       if (niflp)
 244         *niflp = 0;
 245       if (vlp)
 246         *vlp = lp ? *lp : strlen (r);
 247       return r;
 248     }
 249
 250   l = strlen (pmt);
 251   r = ret = (char *)xmalloc (l + 1);
 252
 253   invfl = 0;    /* invisible chars in first line of prompt */
 254   invflset = 0; /* we only want to set invfl once */
 255
 256   igstart = 0;
 257   for (rl = ignoring = last = ninvis = physchars = 0, p = pmt; p && *p; p++)
 258     {
 259       /* This code strips the invisible character string markers
 260          RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */
 261       if (ignoring == 0 && *p == RL_PROMPT_START_IGNORE)                /* XXX - check ignoring? */
 262         {
 263           ignoring = 1;
 264           igstart = p;
 265           continue;
 266         }
 267       else if (ignoring && *p == RL_PROMPT_END_IGNORE)
 268         {
 269           ignoring = 0;
 270           if (p != (igstart + 1))
 271             last = r - ret - 1;
 272           continue;
 273         }
 274       else
 275         {
 276 #if defined (HANDLE_MULTIBYTE)
 277           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 278             {
 279               pind = p - pmt;
 280               ind = _rl_find_next_mbchar (pmt, pind, 1, MB_FIND_NONZERO);
 281               l = ind - pind;
 282               while (l--)
 283                 *r++ = *p++;
 284               if (!ignoring)
 285                 {
 286                   rl += ind - pind;
 287                   physchars += _rl_col_width (pmt, pind, ind);
 288                 }
 289               else
 290                 ninvis += ind - pind;
 291               p--;                      /* compensate for later increment */
 292             }
 293           else
 294 #endif
 295             {
 296               *r++ = *p;
 297               if (!ignoring)
 298                 {
 299                   rl++;                 /* visible length byte counter */
 300                   physchars++;
 301                 }
 302               else
 303                 ninvis++;               /* invisible chars byte counter */
 304             }
 305
 306           if (invflset == 0 && rl >= _rl_screenwidth)
 307             {
 308               invfl = ninvis;
 309               invflset = 1;
 310             }
 311         }
 312     }
 313
 314   if (rl < _rl_screenwidth)
 315     invfl = ninvis;
 316
 317   *r = '\0';
 318   if (lp)
 319     *lp = rl;
 320   if (lip)
 321     *lip = last;
 322   if (niflp)
 323     *niflp = invfl;
 324   if  (vlp)
 325     *vlp = physchars;
 326   return ret;
 327 }
 328
 329 /* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
 330    PMT and return the rest of PMT. */
 331 char *
 332 _rl_strip_prompt (pmt)
 333      char *pmt;
 334 {
 335   char *ret;
 336
 337   ret = expand_prompt (pmt, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
 338   return ret;
 339 }
 340
 341 /*
 342  * Expand the prompt string into the various display components, if
 343  * necessary.
 344  *
 345  * local_prompt = expanded last line of string in rl_display_prompt
 346  *                (portion after the final newline)
 347  * local_prompt_prefix = portion before last newline of rl_display_prompt,
 348  *                       expanded via expand_prompt
 349  * prompt_visible_length = number of visible characters in local_prompt
 350  * prompt_prefix_length = number of visible characters in local_prompt_prefix
 351  *
 352  * This function is called once per call to readline().  It may also be
 353  * called arbitrarily to expand the primary prompt.
 354  *
 355  * The return value is the number of visible characters on the last line
 356  * of the (possibly multi-line) prompt.
 357  */
 358 int
 359 rl_expand_prompt (prompt)
 360      char *prompt;
 361 {
 362   char *p, *t;
 363   int c;
 364
 365   /* Clear out any saved values. */
 366   FREE (local_prompt);
 367   FREE (local_prompt_prefix);
 368
 369   local_prompt = local_prompt_prefix = (char *)0;
 370   local_prompt_len = 0;
 371   prompt_last_invisible = prompt_invis_chars_first_line = 0;
 372   prompt_visible_length = prompt_physical_chars = 0;
 373
 374   if (prompt == 0 || *prompt == 0)
 375     return (0);
 376
 377   p = strrchr (prompt, '\n');
 378   if (!p)
 379     {
 380       /* The prompt is only one logical line, though it might wrap. */
 381       local_prompt = expand_prompt (prompt, &prompt_visible_length,
 382                                             &prompt_last_invisible,
 383                                             &prompt_invis_chars_first_line,
 384                                             &prompt_physical_chars);
 385       local_prompt_prefix = (char *)0;
 386       local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
 387       return (prompt_visible_length);
 388     }
 389   else
 390     {
 391       /* The prompt spans multiple lines. */
 392       t = ++p;
 393       local_prompt = expand_prompt (p, &prompt_visible_length,
 394                                        &prompt_last_invisible,
 395                                        (int *)NULL,
 396                                        &prompt_physical_chars);
 397       c = *t; *t = '\0';
 398       /* The portion of the prompt string up to and including the
 399          final newline is now null-terminated. */
 400       local_prompt_prefix = expand_prompt (prompt, &prompt_prefix_length,
 401                                                    (int *)NULL,
 402                                                    &prompt_invis_chars_first_line,
 403                                                    (int *)NULL);
 404       *t = c;
 405       local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
 406       return (prompt_prefix_length);
 407     }
 408 }
 409
 410 /* Initialize the VISIBLE_LINE and INVISIBLE_LINE arrays, and their associated
 411    arrays of line break markers.  MINSIZE is the minimum size of VISIBLE_LINE
 412    and INVISIBLE_LINE; if it is greater than LINE_SIZE, LINE_SIZE is
 413    increased.  If the lines have already been allocated, this ensures that
 414    they can hold at least MINSIZE characters. */
 415 static void
 416 init_line_structures (minsize)
 417       int minsize;
 418 {
 419   register int n;
 420
 421   if (invisible_line == 0)      /* initialize it */
 422     {
 423       if (line_size < minsize)
 424         line_size = minsize;
 425       visible_line = (char *)xmalloc (line_size);
 426       invisible_line = (char *)xmalloc (line_size);
 427     }
 428   else if (line_size < minsize) /* ensure it can hold MINSIZE chars */
 429     {
 430       line_size *= 2;
 431       if (line_size < minsize)
 432         line_size = minsize;
 433       visible_line = (char *)xrealloc (visible_line, line_size);
 434       invisible_line = (char *)xrealloc (invisible_line, line_size);
 435     }
 436
 437   for (n = minsize; n < line_size; n++)
 438     {
 439       visible_line[n] = 0;
 440       invisible_line[n] = 1;
 441     }
 442
 443   if (vis_lbreaks == 0)
 444     {
 445       /* should be enough. */
 446       inv_lbsize = vis_lbsize = 256;
 447       inv_lbreaks = (int *)xmalloc (inv_lbsize * sizeof (int));
 448       vis_lbreaks = (int *)xmalloc (vis_lbsize * sizeof (int));
 449 #if defined (HANDLE_MULTIBYTE)
 450       _rl_wrapped_line = (int *)xmalloc (vis_lbsize * sizeof (int));
 451 #endif
 452       inv_lbreaks[0] = vis_lbreaks[0] = 0;
 453     }
 454 }
 455
 456 /* Basic redisplay algorithm. */
 457 void
 458 rl_redisplay ()
 459 {
 460   register int in, out, c, linenum, cursor_linenum;
 461   register char *line;
 462   int inv_botlin, lb_botlin, lb_linenum, o_cpos;
 463   int newlines, lpos, temp, modmark, n0, num;
 464   char *prompt_this_line;
 465 #if defined (HANDLE_MULTIBYTE)
 466   wchar_t wc;
 467   size_t wc_bytes;
 468   int wc_width;
 469   mbstate_t ps;
 470   int _rl_wrapped_multicolumn = 0;
 471 #endif
 472
 473   if (!readline_echoing_p)
 474     return;
 475
 476   if (!rl_display_prompt)
 477     rl_display_prompt = "";
 478
 479   if (invisible_line == 0 || vis_lbreaks == 0)
 480     {
 481       init_line_structures (0);
 482       rl_on_new_line ();
 483     }
 484
 485   /* Draw the line into the buffer. */
 486   cpos_buffer_position = -1;
 487
 488   line = invisible_line;
 489   out = inv_botlin = 0;
 490
 491   /* Mark the line as modified or not.  We only do this for history
 492      lines. */
 493   modmark = 0;
 494   if (_rl_mark_modified_lines && current_history () && rl_undo_list)
 495     {
 496       line[out++] = '*';
 497       line[out] = '\0';
 498       modmark = 1;
 499     }
 500
 501   /* If someone thought that the redisplay was handled, but the currently
 502      visible line has a different modification state than the one about
 503      to become visible, then correct the caller's misconception. */
 504   if (visible_line[0] != invisible_line[0])
 505     rl_display_fixed = 0;
 506
 507   /* If the prompt to be displayed is the `primary' readline prompt (the
 508      one passed to readline()), use the values we have already expanded.
 509      If not, use what's already in rl_display_prompt.  WRAP_OFFSET is the
 510      number of non-visible characters in the prompt string. */
 511   if (rl_display_prompt == rl_prompt || local_prompt)
 512     {
 513       if (local_prompt_prefix && forced_display)
 514         _rl_output_some_chars (local_prompt_prefix, strlen (local_prompt_prefix));
 515
 516       if (local_prompt_len > 0)
 517         {
 518           temp = local_prompt_len + out + 2;
 519           if (temp >= line_size)
 520             {
 521               line_size = (temp + 1024) - (temp % 1024);
 522               visible_line = (char *)xrealloc (visible_line, line_size);
 523               line = invisible_line = (char *)xrealloc (invisible_line, line_size);
 524             }
 525           strncpy (line + out, local_prompt, local_prompt_len);
 526           out += local_prompt_len;
 527         }
 528       line[out] = '\0';
 529       wrap_offset = local_prompt_len - prompt_visible_length;
 530     }
 531   else
 532     {
 533       int pmtlen;
 534       prompt_this_line = strrchr (rl_display_prompt, '\n');
 535       if (!prompt_this_line)
 536         prompt_this_line = rl_display_prompt;
 537       else
 538         {
 539           prompt_this_line++;
 540           pmtlen = prompt_this_line - rl_display_prompt;        /* temp var */
 541           if (forced_display)
 542             {
 543               _rl_output_some_chars (rl_display_prompt, pmtlen);
 544               /* Make sure we are at column zero even after a newline,
 545                  regardless of the state of terminal output processing. */
 546               if (pmtlen < 2 || prompt_this_line[-2] != '\r')
 547                 cr ();
 548             }
 549         }
 550
 551       prompt_physical_chars = pmtlen = strlen (prompt_this_line);
 552       temp = pmtlen + out + 2;
 553       if (temp >= line_size)
 554         {
 555           line_size = (temp + 1024) - (temp % 1024);
 556           visible_line = (char *)xrealloc (visible_line, line_size);
 557           line = invisible_line = (char *)xrealloc (invisible_line, line_size);
 558         }
 559       strncpy (line + out,  prompt_this_line, pmtlen);
 560       out += pmtlen;
 561       line[out] = '\0';
 562       wrap_offset = prompt_invis_chars_first_line = 0;
 563     }
 564
 565 #if defined (HANDLE_MULTIBYTE)
 566 #define CHECK_INV_LBREAKS() \
 567       do { \
 568         if (newlines >= (inv_lbsize - 2)) \
 569           { \
 570             inv_lbsize *= 2; \
 571             inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 572             _rl_wrapped_line = (int *)xrealloc (_rl_wrapped_line, inv_lbsize * sizeof (int)); \
 573           } \
 574       } while (0)
 575 #else
 576 #define CHECK_INV_LBREAKS() \
 577       do { \
 578         if (newlines >= (inv_lbsize - 2)) \
 579           { \
 580             inv_lbsize *= 2; \
 581             inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 582           } \
 583       } while (0)
 584 #endif /* HANDLE_MULTIBYTE */
 585
 586 #if defined (HANDLE_MULTIBYTE)
 587 #define CHECK_LPOS() \
 588       do { \
 589         lpos++; \
 590         if (lpos >= _rl_screenwidth) \
 591           { \
 592             if (newlines >= (inv_lbsize - 2)) \
 593               { \
 594                 inv_lbsize *= 2; \
 595                 inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 596                 _rl_wrapped_line = (int *)xrealloc (_rl_wrapped_line, inv_lbsize * sizeof (int)); \
 597               } \
 598             inv_lbreaks[++newlines] = out; \
 599             _rl_wrapped_line[newlines] = _rl_wrapped_multicolumn; \
 600             lpos = 0; \
 601           } \
 602       } while (0)
 603 #else
 604 #define CHECK_LPOS() \
 605       do { \
 606         lpos++; \
 607         if (lpos >= _rl_screenwidth) \
 608           { \
 609             if (newlines >= (inv_lbsize - 2)) \
 610               { \
 611                 inv_lbsize *= 2; \
 612                 inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 613               } \
 614             inv_lbreaks[++newlines] = out; \
 615             lpos = 0; \
 616           } \
 617       } while (0)
 618 #endif
 619
 620   /* inv_lbreaks[i] is where line i starts in the buffer. */
 621   inv_lbreaks[newlines = 0] = 0;
 622 #if 0
 623   lpos = out - wrap_offset;
 624 #else
 625   lpos = prompt_physical_chars + modmark;
 626 #endif
 627
 628 #if defined (HANDLE_MULTIBYTE)
 629   memset (_rl_wrapped_line, 0, vis_lbsize);
 630   num = 0;
 631 #endif
 632
 633   /* prompt_invis_chars_first_line is the number of invisible characters in
 634      the first physical line of the prompt.
 635      wrap_offset - prompt_invis_chars_first_line is the number of invis
 636      chars on the second line. */
 637
 638   /* what if lpos is already >= _rl_screenwidth before we start drawing the
 639      contents of the command line? */
 640   while (lpos >= _rl_screenwidth)
 641     {
 642       int z;
 643       /* fix from Darin Johnson <darin@acuson.com> for prompt string with
 644          invisible characters that is longer than the screen width.  The
 645          prompt_invis_chars_first_line variable could be made into an array
 646          saying how many invisible characters there are per line, but that's
 647          probably too much work for the benefit gained.  How many people have
 648          prompts that exceed two physical lines?
 649          Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
 650 #if defined (HANDLE_MULTIBYTE)
 651       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 652         {
 653           n0 = num;
 654           temp = local_prompt_len;
 655           while (num < temp)
 656             {
 657               z = _rl_col_width  (local_prompt, n0, num);
 658               if (z > _rl_screenwidth)
 659                 {
 660                   num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
 661                   break;
 662                 }
 663               else if (z == _rl_screenwidth)
 664                 break;
 665               num++;
 666             }
 667           temp = num;
 668         }
 669       else
 670 #endif /* !HANDLE_MULTIBYTE */
 671         temp = ((newlines + 1) * _rl_screenwidth);
 672
 673       /* Now account for invisible characters in the current line. */
 674       temp += ((local_prompt_prefix == 0) ? ((newlines == 0) ? prompt_invis_chars_first_line
 675                                                              : ((newlines == 1) ? wrap_offset : 0))
 676                                           : ((newlines == 0) ? wrap_offset :0));
 677
 678       inv_lbreaks[++newlines] = temp;
 679 #if defined (HANDLE_MULTIBYTE)
 680       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 681         lpos -= _rl_col_width (local_prompt, n0, num);
 682       else
 683 #endif
 684         lpos -= _rl_screenwidth;
 685     }
 686
 687   prompt_last_screen_line = newlines;
 688
 689   /* Draw the rest of the line (after the prompt) into invisible_line, keeping
 690      track of where the cursor is (cpos_buffer_position), the number of the line containing
 691      the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
 692      It maintains an array of line breaks for display (inv_lbreaks).
 693      This handles expanding tabs for display and displaying meta characters. */
 694   lb_linenum = 0;
 695 #if defined (HANDLE_MULTIBYTE)
 696   in = 0;
 697   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 698     {
 699       memset (&ps, 0, sizeof (mbstate_t));
 700       wc_bytes = mbrtowc (&wc, rl_line_buffer, rl_end, &ps);
 701     }
 702   else
 703     wc_bytes = 1;
 704   while (in < rl_end)
 705 #else
 706   for (in = 0; in < rl_end; in++)
 707 #endif
 708     {
 709       c = (unsigned char)rl_line_buffer[in];
 710
 711 #if defined (HANDLE_MULTIBYTE)
 712       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 713         {
 714           if (MB_INVALIDCH (wc_bytes))
 715             {
 716               /* Byte sequence is invalid or shortened.  Assume that the
 717                  first byte represents a character. */
 718               wc_bytes = 1;
 719               /* Assume that a character occupies a single column. */
 720               wc_width = 1;
 721               memset (&ps, 0, sizeof (mbstate_t));
 722             }
 723           else if (MB_NULLWCH (wc_bytes))
 724             break;                      /* Found '\0' */
 725           else
 726             {
 727               temp = wcwidth (wc);
 728               wc_width = (temp >= 0) ? temp : 1;
 729             }
 730         }
 731 #endif
 732
 733       if (out + 8 >= line_size)         /* XXX - 8 for \t */
 734         {
 735           line_size *= 2;
 736           visible_line = (char *)xrealloc (visible_line, line_size);
 737           invisible_line = (char *)xrealloc (invisible_line, line_size);
 738           line = invisible_line;
 739         }
 740
 741       if (in == rl_point)
 742         {
 743           cpos_buffer_position = out;
 744           lb_linenum = newlines;
 745         }
 746
 747 #if defined (HANDLE_MULTIBYTE)
 748       if (META_CHAR (c) && _rl_output_meta_chars == 0)  /* XXX - clean up */
 749 #else
 750       if (META_CHAR (c))
 751 #endif
 752         {
 753           if (_rl_output_meta_chars == 0)
 754             {
 755               sprintf (line + out, "\\%o", c);
 756
 757               if (lpos + 4 >= _rl_screenwidth)
 758                 {
 759                   temp = _rl_screenwidth - lpos;
 760                   CHECK_INV_LBREAKS ();
 761                   inv_lbreaks[++newlines] = out + temp;
 762                   lpos = 4 - temp;
 763                 }
 764               else
 765                 lpos += 4;
 766
 767               out += 4;
 768             }
 769           else
 770             {
 771               line[out++] = c;
 772               CHECK_LPOS();
 773             }
 774         }
 775 #if defined (DISPLAY_TABS)
 776       else if (c == '\t')
 777         {
 778           register int newout;
 779
 780 #if 0
 781           newout = (out | (int)7) + 1;
 782 #else
 783           newout = out + 8 - lpos % 8;
 784 #endif
 785           temp = newout - out;
 786           if (lpos + temp >= _rl_screenwidth)
 787             {
 788               register int temp2;
 789               temp2 = _rl_screenwidth - lpos;
 790               CHECK_INV_LBREAKS ();
 791               inv_lbreaks[++newlines] = out + temp2;
 792               lpos = temp - temp2;
 793               while (out < newout)
 794                 line[out++] = ' ';
 795             }
 796           else
 797             {
 798               while (out < newout)
 799                 line[out++] = ' ';
 800               lpos += temp;
 801             }
 802         }
 803 #endif
 804       else if (c == '\n' && _rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)
 805         {
 806           line[out++] = '\0';   /* XXX - sentinel */
 807           CHECK_INV_LBREAKS ();
 808           inv_lbreaks[++newlines] = out;
 809           lpos = 0;
 810         }
 811       else if (CTRL_CHAR (c) || c == RUBOUT)
 812         {
 813           line[out++] = '^';
 814           CHECK_LPOS();
 815           line[out++] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
 816           CHECK_LPOS();
 817         }
 818       else
 819         {
 820 #if defined (HANDLE_MULTIBYTE)
 821           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 822             {
 823               register int i;
 824
 825               _rl_wrapped_multicolumn = 0;
 826
 827               if (_rl_screenwidth < lpos + wc_width)
 828                 for (i = lpos; i < _rl_screenwidth; i++)
 829                   {
 830                     /* The space will be removed in update_line() */
 831                     line[out++] = ' ';
 832                     _rl_wrapped_multicolumn++;
 833                     CHECK_LPOS();
 834                   }
 835               if (in == rl_point)
 836                 {
 837                   cpos_buffer_position = out;
 838                   lb_linenum = newlines;
 839                 }
 840               for (i = in; i < in+wc_bytes; i++)
 841                 line[out++] = rl_line_buffer[i];
 842               for (i = 0; i < wc_width; i++)
 843                 CHECK_LPOS();
 844             }
 845           else
 846             {
 847               line[out++] = c;
 848               CHECK_LPOS();
 849             }
 850 #else
 851           line[out++] = c;
 852           CHECK_LPOS();
 853 #endif
 854         }
 855
 856 #if defined (HANDLE_MULTIBYTE)
 857       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 858         {
 859           in += wc_bytes;
 860           wc_bytes = mbrtowc (&wc, rl_line_buffer + in, rl_end - in, &ps);
 861         }
 862       else
 863         in++;
 864 #endif
 865
 866     }
 867   line[out] = '\0';
 868   if (cpos_buffer_position < 0)
 869     {
 870       cpos_buffer_position = out;
 871       lb_linenum = newlines;
 872     }
 873
 874   inv_botlin = lb_botlin = newlines;
 875   CHECK_INV_LBREAKS ();
 876   inv_lbreaks[newlines+1] = out;
 877   cursor_linenum = lb_linenum;
 878
 879   /* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.
 880      CURSOR_LINENUM == line number where the cursor should be placed. */
 881
 882   /* PWP: now is when things get a bit hairy.  The visible and invisible
 883      line buffers are really multiple lines, which would wrap every
 884      (screenwidth - 1) characters.  Go through each in turn, finding
 885      the changed region and updating it.  The line order is top to bottom. */
 886
 887   /* If we can move the cursor up and down, then use multiple lines,
 888      otherwise, let long lines display in a single terminal line, and
 889      horizontally scroll it. */
 890
 891   if (_rl_horizontal_scroll_mode == 0 && _rl_term_up && *_rl_term_up)
 892     {
 893       int nleft, pos, changed_screen_line, tx;
 894
 895       if (!rl_display_fixed || forced_display)
 896         {
 897           forced_display = 0;
 898
 899           /* If we have more than a screenful of material to display, then
 900              only display a screenful.  We should display the last screen,
 901              not the first.  */
 902           if (out >= _rl_screenchars)
 903             {
 904               if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 905                 out = _rl_find_prev_mbchar (line, _rl_screenchars, MB_FIND_ANY);
 906               else
 907                 out = _rl_screenchars - 1;
 908             }
 909
 910           /* The first line is at character position 0 in the buffer.  The
 911              second and subsequent lines start at inv_lbreaks[N], offset by
 912              OFFSET (which has already been calculated above).  */
 913
 914 #define W_OFFSET(line, offset) ((line) == 0 ? offset : 0)
 915 #define VIS_LLEN(l)     ((l) > _rl_vis_botlin ? 0 : (vis_lbreaks[l+1] - vis_lbreaks[l]))
 916 #define INV_LLEN(l)     (inv_lbreaks[l+1] - inv_lbreaks[l])
 917 #define VIS_CHARS(line) (visible_line + vis_lbreaks[line])
 918 #define VIS_LINE(line) ((line) > _rl_vis_botlin) ? "" : VIS_CHARS(line)
 919 #define INV_LINE(line) (invisible_line + inv_lbreaks[line])
 920
 921           /* For each line in the buffer, do the updating display. */
 922           for (linenum = 0; linenum <= inv_botlin; linenum++)
 923             {
 924               /* This can lead us astray if we execute a program that changes
 925                  the locale from a non-multibyte to a multibyte one. */
 926               o_cpos = _rl_last_c_pos;
 927               cpos_adjusted = 0;
 928               update_line (VIS_LINE(linenum), INV_LINE(linenum), linenum,
 929                            VIS_LLEN(linenum), INV_LLEN(linenum), inv_botlin);
 930
 931               /* update_line potentially changes _rl_last_c_pos, but doesn't
 932                  take invisible characters into account, since _rl_last_c_pos
 933                  is an absolute cursor position in a multibyte locale.  See
 934                  if compensating here is the right thing, or if we have to
 935                  change update_line itself.  There is one case in which
 936                  update_line adjusts _rl_last_c_pos itself (so it can pass
 937                  _rl_move_cursor_relative accurate values); it communicates
 938                  this back by setting cpos_adjusted.  If we assume that
 939                  _rl_last_c_pos is correct (an absolute cursor position) each
 940                  time update_line is called, then we can assume in our
 941                  calculations that o_cpos does not need to be adjusted by
 942                  wrap_offset. */
 943               if (linenum == 0 && (MB_CUR_MAX > 1 && rl_byte_oriented == 0) &&
 944                   cpos_adjusted == 0 &&
 945                   _rl_last_c_pos != o_cpos &&
 946                   _rl_last_c_pos > wrap_offset &&
 947                   o_cpos < prompt_last_invisible)
 948                 _rl_last_c_pos -= wrap_offset;
 949
 950               /* If this is the line with the prompt, we might need to
 951                  compensate for invisible characters in the new line. Do
 952                  this only if there is not more than one new line (which
 953                  implies that we completely overwrite the old visible line)
 954                  and the new line is shorter than the old.  Make sure we are
 955                  at the end of the new line before clearing. */
 956               if (linenum == 0 &&
 957                   inv_botlin == 0 && _rl_last_c_pos == out &&
 958                   (wrap_offset > visible_wrap_offset) &&
 959                   (_rl_last_c_pos < visible_first_line_len))
 960                 {
 961                   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
 962                     nleft = _rl_screenwidth - _rl_last_c_pos;
 963                   else
 964                     nleft = _rl_screenwidth + wrap_offset - _rl_last_c_pos;
 965                   if (nleft)
 966                     _rl_clear_to_eol (nleft);
 967                 }
 968
 969               /* Since the new first line is now visible, save its length. */
 970               if (linenum == 0)
 971                 visible_first_line_len = (inv_botlin > 0) ? inv_lbreaks[1] : out - wrap_offset;
 972             }
 973
 974           /* We may have deleted some lines.  If so, clear the left over
 975              blank ones at the bottom out. */
 976           if (_rl_vis_botlin > inv_botlin)
 977             {
 978               char *tt;
 979               for (; linenum <= _rl_vis_botlin; linenum++)
 980                 {
 981                   tt = VIS_CHARS (linenum);
 982                   _rl_move_vert (linenum);
 983                   _rl_move_cursor_relative (0, tt);
 984                   _rl_clear_to_eol
 985                     ((linenum == _rl_vis_botlin) ? strlen (tt) : _rl_screenwidth);
 986                 }
 987             }
 988           _rl_vis_botlin = inv_botlin;
 989
 990           /* CHANGED_SCREEN_LINE is set to 1 if we have moved to a
 991              different screen line during this redisplay. */
 992           changed_screen_line = _rl_last_v_pos != cursor_linenum;
 993           if (changed_screen_line)
 994             {
 995               _rl_move_vert (cursor_linenum);
 996               /* If we moved up to the line with the prompt using _rl_term_up,
 997                  the physical cursor position on the screen stays the same,
 998                  but the buffer position needs to be adjusted to account
 999                  for invisible characters. */
1000               if ((MB_CUR_MAX == 1 || rl_byte_oriented) && cursor_linenum == 0 && wrap_offset)
1001                 _rl_last_c_pos += wrap_offset;
1002             }
1003
1004           /* We have to reprint the prompt if it contains invisible
1005              characters, since it's not generally OK to just reprint
1006              the characters from the current cursor position.  But we
1007              only need to reprint it if the cursor is before the last
1008              invisible character in the prompt string. */
1009           nleft = prompt_visible_length + wrap_offset;
1010           if (cursor_linenum == 0 && wrap_offset > 0 && _rl_last_c_pos > 0 &&
1011 #if 0
1012               _rl_last_c_pos <= PROMPT_ENDING_INDEX && local_prompt)
1013 #else
1014               _rl_last_c_pos < PROMPT_ENDING_INDEX && local_prompt)
1015 #endif
1016             {
1017 #if defined (__MSDOS__)
1018               putc ('\r', rl_outstream);
1019 #else
1020               if (_rl_term_cr)
1021                 tputs (_rl_term_cr, 1, _rl_output_character_function);
1022 #endif
1023               _rl_output_some_chars (local_prompt, nleft);
1024               if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1025                 _rl_last_c_pos = _rl_col_width (local_prompt, 0, nleft) - wrap_offset;
1026               else
1027                 _rl_last_c_pos = nleft;
1028             }
1029
1030           /* Where on that line?  And where does that line start
1031              in the buffer? */
1032           pos = inv_lbreaks[cursor_linenum];
1033           /* nleft == number of characters in the line buffer between the
1034              start of the line and the desired cursor position. */
1035           nleft = cpos_buffer_position - pos;
1036
1037           /* NLEFT is now a number of characters in a buffer.  When in a
1038              multibyte locale, however, _rl_last_c_pos is an absolute cursor
1039              position that doesn't take invisible characters in the prompt
1040              into account.  We use a fudge factor to compensate. */
1041
1042           /* Since _rl_backspace() doesn't know about invisible characters in the
1043              prompt, and there's no good way to tell it, we compensate for
1044              those characters here and call _rl_backspace() directly. */
1045           if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos)
1046             {
1047               /* TX == new physical cursor position in multibyte locale. */
1048               if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1049                 tx = _rl_col_width (&visible_line[pos], 0, nleft) - visible_wrap_offset;
1050               else
1051                 tx = nleft;
1052               if (_rl_last_c_pos > tx)
1053                 {
1054                   _rl_backspace (_rl_last_c_pos - tx);  /* XXX */
1055                   _rl_last_c_pos = tx;
1056                 }
1057             }
1058
1059           /* We need to note that in a multibyte locale we are dealing with
1060              _rl_last_c_pos as an absolute cursor position, but moving to a
1061              point specified by a buffer position (NLEFT) that doesn't take
1062              invisible characters into account. */
1063           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1064             _rl_move_cursor_relative (nleft, &invisible_line[pos]);
1065           else if (nleft != _rl_last_c_pos)
1066             _rl_move_cursor_relative (nleft, &invisible_line[pos]);
1067         }
1068     }
1069   else                          /* Do horizontal scrolling. */
1070     {
1071 #define M_OFFSET(margin, offset) ((margin) == 0 ? offset : 0)
1072       int lmargin, ndisp, nleft, phys_c_pos, t;
1073
1074       /* Always at top line. */
1075       _rl_last_v_pos = 0;
1076
1077       /* Compute where in the buffer the displayed line should start.  This
1078          will be LMARGIN. */
1079
1080       /* The number of characters that will be displayed before the cursor. */
1081       ndisp = cpos_buffer_position - wrap_offset;
1082       nleft  = prompt_visible_length + wrap_offset;
1083       /* Where the new cursor position will be on the screen.  This can be
1084          longer than SCREENWIDTH; if it is, lmargin will be adjusted. */
1085       phys_c_pos = cpos_buffer_position - (last_lmargin ? last_lmargin : wrap_offset);
1086       t = _rl_screenwidth / 3;
1087
1088       /* If the number of characters had already exceeded the screenwidth,
1089          last_lmargin will be > 0. */
1090
1091       /* If the number of characters to be displayed is more than the screen
1092          width, compute the starting offset so that the cursor is about
1093          two-thirds of the way across the screen. */
1094       if (phys_c_pos > _rl_screenwidth - 2)
1095         {
1096           lmargin = cpos_buffer_position - (2 * t);
1097           if (lmargin < 0)
1098             lmargin = 0;
1099           /* If the left margin would be in the middle of a prompt with
1100              invisible characters, don't display the prompt at all. */
1101           if (wrap_offset && lmargin > 0 && lmargin < nleft)
1102             lmargin = nleft;
1103         }
1104       else if (ndisp < _rl_screenwidth - 2)             /* XXX - was -1 */
1105         lmargin = 0;
1106       else if (phys_c_pos < 1)
1107         {
1108           /* If we are moving back towards the beginning of the line and
1109              the last margin is no longer correct, compute a new one. */
1110           lmargin = ((cpos_buffer_position - 1) / t) * t;       /* XXX */
1111           if (wrap_offset && lmargin > 0 && lmargin < nleft)
1112             lmargin = nleft;
1113         }
1114       else
1115         lmargin = last_lmargin;
1116
1117       /* If the first character on the screen isn't the first character
1118          in the display line, indicate this with a special character. */
1119       if (lmargin > 0)
1120         line[lmargin] = '<';
1121
1122       /* If SCREENWIDTH characters starting at LMARGIN do not encompass
1123          the whole line, indicate that with a special character at the
1124          right edge of the screen.  If LMARGIN is 0, we need to take the
1125          wrap offset into account. */
1126       t = lmargin + M_OFFSET (lmargin, wrap_offset) + _rl_screenwidth;
1127       if (t < out)
1128         line[t - 1] = '>';
1129
1130       if (!rl_display_fixed || forced_display || lmargin != last_lmargin)
1131         {
1132           forced_display = 0;
1133           update_line (&visible_line[last_lmargin],
1134                        &invisible_line[lmargin],
1135                        0,
1136                        _rl_screenwidth + visible_wrap_offset,
1137                        _rl_screenwidth + (lmargin ? 0 : wrap_offset),
1138                        0);
1139
1140           /* If the visible new line is shorter than the old, but the number
1141              of invisible characters is greater, and we are at the end of
1142              the new line, we need to clear to eol. */
1143           t = _rl_last_c_pos - M_OFFSET (lmargin, wrap_offset);
1144           if ((M_OFFSET (lmargin, wrap_offset) > visible_wrap_offset) &&
1145               (_rl_last_c_pos == out) &&
1146               t < visible_first_line_len)
1147             {
1148               nleft = _rl_screenwidth - t;
1149               _rl_clear_to_eol (nleft);
1150             }
1151           visible_first_line_len = out - lmargin - M_OFFSET (lmargin, wrap_offset);
1152           if (visible_first_line_len > _rl_screenwidth)
1153             visible_first_line_len = _rl_screenwidth;
1154
1155           _rl_move_cursor_relative (cpos_buffer_position - lmargin, &invisible_line[lmargin]);
1156           last_lmargin = lmargin;
1157         }
1158     }
1159   fflush (rl_outstream);
1160
1161   /* Swap visible and non-visible lines. */
1162   {
1163     char *vtemp = visible_line;
1164     int *itemp = vis_lbreaks, ntemp = vis_lbsize;
1165
1166     visible_line = invisible_line;
1167     invisible_line = vtemp;
1168
1169     vis_lbreaks = inv_lbreaks;
1170     inv_lbreaks = itemp;
1171
1172     vis_lbsize = inv_lbsize;
1173     inv_lbsize = ntemp;
1174
1175     rl_display_fixed = 0;
1176     /* If we are displaying on a single line, and last_lmargin is > 0, we
1177        are not displaying any invisible characters, so set visible_wrap_offset
1178        to 0. */
1179     if (_rl_horizontal_scroll_mode && last_lmargin)
1180       visible_wrap_offset = 0;
1181     else
1182       visible_wrap_offset = wrap_offset;
1183   }
1184 }
1185
1186 /* PWP: update_line() is based on finding the middle difference of each
1187    line on the screen; vis:
1188
1189                              /old first difference
1190         /beginning of line   |        /old last same       /old EOL
1191         v                    v        v             v
1192 old:    eddie> Oh, my little gruntle-buggy is to me, as lurgid as
1193 new:    eddie> Oh, my little buggy says to me, as lurgid as
1194         ^                    ^  ^                          ^
1195         \beginning of line   |  \new last same     \new end of line
1196                              \new first difference
1197
1198    All are character pointers for the sake of speed.  Special cases for
1199    no differences, as well as for end of line additions must be handled.
1200
1201    Could be made even smarter, but this works well enough */
1202 static void
1203 update_line (old, new, current_line, omax, nmax, inv_botlin)
1204      register char *old, *new;
1205      int current_line, omax, nmax, inv_botlin;
1206 {
1207   register char *ofd, *ols, *oe, *nfd, *nls, *ne;
1208   int temp, lendiff, wsatend, od, nd;
1209   int current_invis_chars;
1210   int col_lendiff, col_temp;
1211 #if defined (HANDLE_MULTIBYTE)
1212   mbstate_t ps_new, ps_old;
1213   int new_offset, old_offset;
1214 #endif
1215
1216   /* If we're at the right edge of a terminal that supports xn, we're
1217      ready to wrap around, so do so.  This fixes problems with knowing
1218      the exact cursor position and cut-and-paste with certain terminal
1219      emulators.  In this calculation, TEMP is the physical screen
1220      position of the cursor. */
1221   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1222     temp = _rl_last_c_pos;
1223   else
1224     temp = _rl_last_c_pos - W_OFFSET(_rl_last_v_pos, visible_wrap_offset);
1225   if (temp == _rl_screenwidth && _rl_term_autowrap && !_rl_horizontal_scroll_mode
1226         && _rl_last_v_pos == current_line - 1)
1227     {
1228 #if defined (HANDLE_MULTIBYTE)
1229       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1230         {
1231           wchar_t wc;
1232           mbstate_t ps;
1233           int tempwidth, bytes;
1234           size_t ret;
1235
1236           /* This fixes only double-column characters, but if the wrapped
1237              character comsumes more than three columns, spaces will be
1238              inserted in the string buffer. */
1239           if (_rl_wrapped_line[current_line] > 0)
1240             _rl_clear_to_eol (_rl_wrapped_line[current_line]);
1241
1242           memset (&ps, 0, sizeof (mbstate_t));
1243           ret = mbrtowc (&wc, new, MB_CUR_MAX, &ps);
1244           if (MB_INVALIDCH (ret))
1245             {
1246               tempwidth = 1;
1247               ret = 1;
1248             }
1249           else if (MB_NULLWCH (ret))
1250             tempwidth = 0;
1251           else
1252             tempwidth = wcwidth (wc);
1253
1254           if (tempwidth > 0)
1255             {
1256               int count;
1257               bytes = ret;
1258               for (count = 0; count < bytes; count++)
1259                 putc (new[count], rl_outstream);
1260               _rl_last_c_pos = tempwidth;
1261               _rl_last_v_pos++;
1262               memset (&ps, 0, sizeof (mbstate_t));
1263               ret = mbrtowc (&wc, old, MB_CUR_MAX, &ps);
1264               if (ret != 0 && bytes != 0)
1265                 {
1266                   if (MB_INVALIDCH (ret))
1267                     memmove (old+bytes, old+1, strlen (old+1));
1268                   else
1269                     memmove (old+bytes, old+ret, strlen (old+ret));
1270                   memcpy (old, new, bytes);
1271                 }
1272             }
1273           else
1274             {
1275               putc (' ', rl_outstream);
1276               _rl_last_c_pos = 1;
1277               _rl_last_v_pos++;
1278               if (old[0] && new[0])
1279                 old[0] = new[0];
1280             }
1281         }
1282       else
1283 #endif
1284         {
1285           if (new[0])
1286             putc (new[0], rl_outstream);
1287           else
1288             putc (' ', rl_outstream);
1289           _rl_last_c_pos = 1;
1290           _rl_last_v_pos++;
1291           if (old[0] && new[0])
1292             old[0] = new[0];
1293         }
1294     }
1295
1296
1297   /* Find first difference. */
1298 #if defined (HANDLE_MULTIBYTE)
1299   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1300     {
1301       /* See if the old line is a subset of the new line, so that the
1302          only change is adding characters. */
1303       temp = (omax < nmax) ? omax : nmax;
1304       if (memcmp (old, new, temp) == 0)
1305         {
1306           ofd = old + temp;
1307           nfd = new + temp;
1308         }
1309       else
1310         {
1311           memset (&ps_new, 0, sizeof(mbstate_t));
1312           memset (&ps_old, 0, sizeof(mbstate_t));
1313
1314           if (omax == nmax && STREQN (new, old, omax))
1315             {
1316               ofd = old + omax;
1317               nfd = new + nmax;
1318             }
1319           else
1320             {
1321               new_offset = old_offset = 0;
1322               for (ofd = old, nfd = new;
1323                     (ofd - old < omax) && *ofd &&
1324                     _rl_compare_chars(old, old_offset, &ps_old, new, new_offset, &ps_new); )
1325                 {
1326                   old_offset = _rl_find_next_mbchar (old, old_offset, 1, MB_FIND_ANY);
1327                   new_offset = _rl_find_next_mbchar (new, new_offset, 1, MB_FIND_ANY);
1328                   ofd = old + old_offset;
1329                   nfd = new + new_offset;
1330                 }
1331             }
1332         }
1333     }
1334   else
1335 #endif
1336   for (ofd = old, nfd = new;
1337        (ofd - old < omax) && *ofd && (*ofd == *nfd);
1338        ofd++, nfd++)
1339     ;
1340
1341   /* Move to the end of the screen line.  ND and OD are used to keep track
1342      of the distance between ne and new and oe and old, respectively, to
1343      move a subtraction out of each loop. */
1344   for (od = ofd - old, oe = ofd; od < omax && *oe; oe++, od++);
1345   for (nd = nfd - new, ne = nfd; nd < nmax && *ne; ne++, nd++);
1346
1347   /* If no difference, continue to next line. */
1348   if (ofd == oe && nfd == ne)
1349     return;
1350
1351   wsatend = 1;                  /* flag for trailing whitespace */
1352
1353 #if defined (HANDLE_MULTIBYTE)
1354   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1355     {
1356       ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
1357       nls = new + _rl_find_prev_mbchar (new, ne - new, MB_FIND_ANY);
1358       while ((ols > ofd) && (nls > nfd))
1359         {
1360           memset (&ps_old, 0, sizeof (mbstate_t));
1361           memset (&ps_new, 0, sizeof (mbstate_t));
1362
1363 #if 0
1364           /* On advice from jir@yamato.ibm.com */
1365           _rl_adjust_point (old, ols - old, &ps_old);
1366           _rl_adjust_point (new, nls - new, &ps_new);
1367 #endif
1368
1369           if (_rl_compare_chars (old, ols - old, &ps_old, new, nls - new, &ps_new) == 0)
1370             break;
1371
1372           if (*ols == ' ')
1373             wsatend = 0;
1374
1375           ols = old + _rl_find_prev_mbchar (old, ols - old, MB_FIND_ANY);
1376           nls = new + _rl_find_prev_mbchar (new, nls - new, MB_FIND_ANY);
1377         }
1378     }
1379   else
1380     {
1381 #endif /* HANDLE_MULTIBYTE */
1382   ols = oe - 1;                 /* find last same */
1383   nls = ne - 1;
1384   while ((ols > ofd) && (nls > nfd) && (*ols == *nls))
1385     {
1386       if (*ols != ' ')
1387         wsatend = 0;
1388       ols--;
1389       nls--;
1390     }
1391 #if defined (HANDLE_MULTIBYTE)
1392     }
1393 #endif
1394
1395   if (wsatend)
1396     {
1397       ols = oe;
1398       nls = ne;
1399     }
1400 #if defined (HANDLE_MULTIBYTE)
1401   /* This may not work for stateful encoding, but who cares?  To handle
1402      stateful encoding properly, we have to scan each string from the
1403      beginning and compare. */
1404   else if (_rl_compare_chars (ols, 0, NULL, nls, 0, NULL) == 0)
1405 #else
1406   else if (*ols != *nls)
1407 #endif
1408     {
1409       if (*ols)                 /* don't step past the NUL */
1410         {
1411           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1412             ols = old + _rl_find_next_mbchar (old, ols - old, 1, MB_FIND_ANY);
1413           else
1414             ols++;
1415         }
1416       if (*nls)
1417         {
1418           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1419             nls = new + _rl_find_next_mbchar (new, nls - new, 1, MB_FIND_ANY);
1420           else
1421             nls++;
1422         }
1423     }
1424
1425   /* count of invisible characters in the current invisible line. */
1426   current_invis_chars = W_OFFSET (current_line, wrap_offset);
1427   if (_rl_last_v_pos != current_line)
1428     {
1429       _rl_move_vert (current_line);
1430       if ((MB_CUR_MAX == 1 || rl_byte_oriented) && current_line == 0 && visible_wrap_offset)
1431         _rl_last_c_pos += visible_wrap_offset;
1432     }
1433
1434   /* If this is the first line and there are invisible characters in the
1435      prompt string, and the prompt string has not changed, and the current
1436      cursor position is before the last invisible character in the prompt,
1437      and the index of the character to move to is past the end of the prompt
1438      string, then redraw the entire prompt string.  We can only do this
1439      reliably if the terminal supports a `cr' capability.
1440
1441      This is not an efficiency hack -- there is a problem with redrawing
1442      portions of the prompt string if they contain terminal escape
1443      sequences (like drawing the `unbold' sequence without a corresponding
1444      `bold') that manifests itself on certain terminals. */
1445
1446   lendiff = local_prompt_len;
1447   od = ofd - old;       /* index of first difference in visible line */
1448   if (current_line == 0 && !_rl_horizontal_scroll_mode &&
1449       _rl_term_cr && lendiff > prompt_visible_length && _rl_last_c_pos > 0 &&
1450       od >= lendiff && _rl_last_c_pos < PROMPT_ENDING_INDEX)
1451     {
1452 #if defined (__MSDOS__)
1453       putc ('\r', rl_outstream);
1454 #else
1455       tputs (_rl_term_cr, 1, _rl_output_character_function);
1456 #endif
1457       _rl_output_some_chars (local_prompt, lendiff);
1458       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1459         {
1460           /* We take wrap_offset into account here so we can pass correct
1461              information to _rl_move_cursor_relative. */
1462           _rl_last_c_pos = _rl_col_width (local_prompt, 0, lendiff) - wrap_offset;
1463           cpos_adjusted = 1;
1464         }
1465       else
1466         _rl_last_c_pos = lendiff;
1467     }
1468
1469   /* When this function returns, _rl_last_c_pos is correct, and an absolute
1470      cursor postion in multibyte mode, but a buffer index when not in a
1471      multibyte locale. */
1472   _rl_move_cursor_relative (od, old);
1473 #if 1
1474 #if defined (HANDLE_MULTIBYTE)
1475   /* We need to indicate that the cursor position is correct in the presence of
1476      invisible characters in the prompt string.  Let's see if setting this when
1477      we make sure we're at the end of the drawn prompt string works. */
1478   if (current_line == 0 && MB_CUR_MAX > 1 && rl_byte_oriented == 0 && _rl_last_c_pos == prompt_physical_chars)
1479     cpos_adjusted = 1;
1480 #endif
1481 #endif
1482
1483   /* if (len (new) > len (old))
1484      lendiff == difference in buffer
1485      col_lendiff == difference on screen
1486      When not using multibyte characters, these are equal */
1487   lendiff = (nls - nfd) - (ols - ofd);
1488   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1489     col_lendiff = _rl_col_width (new, nfd - new, nls - new) - _rl_col_width (old, ofd - old, ols - old);
1490   else
1491     col_lendiff = lendiff;
1492
1493   /* If we are changing the number of invisible characters in a line, and
1494      the spot of first difference is before the end of the invisible chars,
1495      lendiff needs to be adjusted. */
1496   if (current_line == 0 && !_rl_horizontal_scroll_mode &&
1497       current_invis_chars != visible_wrap_offset)
1498     {
1499       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1500         {
1501           lendiff += visible_wrap_offset - current_invis_chars;
1502           col_lendiff += visible_wrap_offset - current_invis_chars;
1503         }
1504       else
1505         {
1506           lendiff += visible_wrap_offset - current_invis_chars;
1507           col_lendiff = lendiff;
1508         }
1509     }
1510
1511   /* Insert (diff (len (old), len (new)) ch. */
1512   temp = ne - nfd;
1513   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1514     col_temp = _rl_col_width (new, nfd - new, ne - new);
1515   else
1516     col_temp = temp;
1517
1518   if (col_lendiff > 0)  /* XXX - was lendiff */
1519     {
1520       /* Non-zero if we're increasing the number of lines. */
1521       int gl = current_line >= _rl_vis_botlin && inv_botlin > _rl_vis_botlin;
1522       /* Sometimes it is cheaper to print the characters rather than
1523          use the terminal's capabilities.  If we're growing the number
1524          of lines, make sure we actually cause the new line to wrap
1525          around on auto-wrapping terminals. */
1526       if (_rl_terminal_can_insert && ((2 * col_temp) >= col_lendiff || _rl_term_IC) && (!_rl_term_autowrap || !gl))
1527         {
1528           /* If lendiff > prompt_visible_length and _rl_last_c_pos == 0 and
1529              _rl_horizontal_scroll_mode == 1, inserting the characters with
1530              _rl_term_IC or _rl_term_ic will screw up the screen because of the
1531              invisible characters.  We need to just draw them. */
1532           if (*ols && (!_rl_horizontal_scroll_mode || _rl_last_c_pos > 0 ||
1533                         lendiff <= prompt_visible_length || !current_invis_chars))
1534             {
1535               insert_some_chars (nfd, lendiff, col_lendiff);
1536               _rl_last_c_pos += col_lendiff;
1537             }
1538           else if ((MB_CUR_MAX == 1 || rl_byte_oriented != 0) && *ols == 0 && lendiff > 0)
1539             {
1540               /* At the end of a line the characters do not have to
1541                  be "inserted".  They can just be placed on the screen. */
1542               /* However, this screws up the rest of this block, which
1543                  assumes you've done the insert because you can. */
1544               _rl_output_some_chars (nfd, lendiff);
1545               _rl_last_c_pos += col_lendiff;
1546             }
1547           else
1548             {
1549               /* We have horizontal scrolling and we are not inserting at
1550                  the end.  We have invisible characters in this line.  This
1551                  is a dumb update. */
1552               _rl_output_some_chars (nfd, temp);
1553               _rl_last_c_pos += col_temp;
1554               return;
1555             }
1556           /* Copy (new) chars to screen from first diff to last match. */
1557           temp = nls - nfd;
1558           if ((temp - lendiff) > 0)
1559             {
1560               _rl_output_some_chars (nfd + lendiff, temp - lendiff);
1561 #if 1
1562              /* XXX -- this bears closer inspection.  Fixes a redisplay bug
1563                 reported against bash-3.0-alpha by Andreas Schwab involving
1564                 multibyte characters and prompt strings with invisible
1565                 characters, but was previously disabled. */
1566               _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-col_lendiff);
1567 #else
1568               _rl_last_c_pos += _rl_col_width (nfd+lendiff, 0, temp-lendiff);
1569 #endif
1570             }
1571         }
1572       else
1573         {
1574           /* cannot insert chars, write to EOL */
1575           _rl_output_some_chars (nfd, temp);
1576           _rl_last_c_pos += col_temp;
1577           /* If we're in a multibyte locale and were before the last invisible
1578              char in the current line (which implies we just output some invisible
1579              characters) we need to adjust _rl_last_c_pos, since it represents
1580              a physical character position. */
1581         }
1582     }
1583   else                          /* Delete characters from line. */
1584     {
1585       /* If possible and inexpensive to use terminal deletion, then do so. */
1586       if (_rl_term_dc && (2 * col_temp) >= -col_lendiff)
1587         {
1588           /* If all we're doing is erasing the invisible characters in the
1589              prompt string, don't bother.  It screws up the assumptions
1590              about what's on the screen. */
1591           if (_rl_horizontal_scroll_mode && _rl_last_c_pos == 0 &&
1592               -lendiff == visible_wrap_offset)
1593             col_lendiff = 0;
1594
1595           if (col_lendiff)
1596             delete_chars (-col_lendiff); /* delete (diff) characters */
1597
1598           /* Copy (new) chars to screen from first diff to last match */
1599           temp = nls - nfd;
1600           if (temp > 0)
1601             {
1602               _rl_output_some_chars (nfd, temp);
1603               _rl_last_c_pos += _rl_col_width (nfd, 0, temp);;
1604             }
1605         }
1606       /* Otherwise, print over the existing material. */
1607       else
1608         {
1609           if (temp > 0)
1610             {
1611               _rl_output_some_chars (nfd, temp);
1612               _rl_last_c_pos += col_temp;               /* XXX */
1613             }
1614           lendiff = (oe - old) - (ne - new);
1615           if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1616             col_lendiff = _rl_col_width (old, 0, oe - old) - _rl_col_width (new, 0, ne - new);
1617           else
1618             col_lendiff = lendiff;
1619
1620           if (col_lendiff)
1621             {
1622               if (_rl_term_autowrap && current_line < inv_botlin)
1623                 space_to_eol (col_lendiff);
1624               else
1625                 _rl_clear_to_eol (col_lendiff);
1626             }
1627         }
1628     }
1629 }
1630
1631 /* Tell the update routines that we have moved onto a new (empty) line. */
1632 int
1633 rl_on_new_line ()
1634 {
1635   if (visible_line)
1636     visible_line[0] = '\0';
1637
1638   _rl_last_c_pos = _rl_last_v_pos = 0;
1639   _rl_vis_botlin = last_lmargin = 0;
1640   if (vis_lbreaks)
1641     vis_lbreaks[0] = vis_lbreaks[1] = 0;
1642   visible_wrap_offset = 0;
1643   return 0;
1644 }
1645
1646 /* Tell the update routines that we have moved onto a new line with the
1647    prompt already displayed.  Code originally from the version of readline
1648    distributed with CLISP.  rl_expand_prompt must have already been called
1649    (explicitly or implicitly).  This still doesn't work exactly right. */
1650 int
1651 rl_on_new_line_with_prompt ()
1652 {
1653   int prompt_size, i, l, real_screenwidth, newlines;
1654   char *prompt_last_line, *lprompt;
1655
1656   /* Initialize visible_line and invisible_line to ensure that they can hold
1657      the already-displayed prompt. */
1658   prompt_size = strlen (rl_prompt) + 1;
1659   init_line_structures (prompt_size);
1660
1661   /* Make sure the line structures hold the already-displayed prompt for
1662      redisplay. */
1663   lprompt = local_prompt ? local_prompt : rl_prompt;
1664   strcpy (visible_line, lprompt);
1665   strcpy (invisible_line, lprompt);
1666
1667   /* If the prompt contains newlines, take the last tail. */
1668   prompt_last_line = strrchr (rl_prompt, '\n');
1669   if (!prompt_last_line)
1670     prompt_last_line = rl_prompt;
1671
1672   l = strlen (prompt_last_line);
1673   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1674     _rl_last_c_pos = _rl_col_width (prompt_last_line, 0, l);    /* XXX */
1675   else
1676     _rl_last_c_pos = l;
1677
1678   /* Dissect prompt_last_line into screen lines. Note that here we have
1679      to use the real screenwidth. Readline's notion of screenwidth might be
1680      one less, see terminal.c. */
1681   real_screenwidth = _rl_screenwidth + (_rl_term_autowrap ? 0 : 1);
1682   _rl_last_v_pos = l / real_screenwidth;
1683   /* If the prompt length is a multiple of real_screenwidth, we don't know
1684      whether the cursor is at the end of the last line, or already at the
1685      beginning of the next line. Output a newline just to be safe. */
1686   if (l > 0 && (l % real_screenwidth) == 0)
1687     _rl_output_some_chars ("\n", 1);
1688   last_lmargin = 0;
1689
1690   newlines = 0; i = 0;
1691   while (i <= l)
1692     {
1693       _rl_vis_botlin = newlines;
1694       vis_lbreaks[newlines++] = i;
1695       i += real_screenwidth;
1696     }
1697   vis_lbreaks[newlines] = l;
1698   visible_wrap_offset = 0;
1699
1700   rl_display_prompt = rl_prompt;        /* XXX - make sure it's set */
1701
1702   return 0;
1703 }
1704
1705 /* Actually update the display, period. */
1706 int
1707 rl_forced_update_display ()
1708 {
1709   register char *temp;
1710
1711   if (visible_line)
1712     {
1713       temp = visible_line;
1714       while (*temp)
1715         *temp++ = '\0';
1716     }
1717   rl_on_new_line ();
1718   forced_display++;
1719   (*rl_redisplay_function) ();
1720   return 0;
1721 }
1722
1723 /* Move the cursor from _rl_last_c_pos to NEW, which are buffer indices.
1724    (Well, when we don't have multibyte characters, _rl_last_c_pos is a
1725    buffer index.)
1726    DATA is the contents of the screen line of interest; i.e., where
1727    the movement is being done. */
1728 void
1729 _rl_move_cursor_relative (new, data)
1730      int new;
1731      const char *data;
1732 {
1733   register int i;
1734   int woff;                     /* number of invisible chars on current line */
1735   int cpos, dpos;               /* current and desired cursor positions */
1736
1737   woff = W_OFFSET (_rl_last_v_pos, wrap_offset);
1738   cpos = _rl_last_c_pos;
1739 #if defined (HANDLE_MULTIBYTE)
1740   /* If we have multibyte characters, NEW is indexed by the buffer point in
1741      a multibyte string, but _rl_last_c_pos is the display position.  In
1742      this case, NEW's display position is not obvious and must be
1743      calculated.  We need to account for invisible characters in this line,
1744      as long as we are past them and they are counted by _rl_col_width. */
1745   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1746     {
1747       dpos = _rl_col_width (data, 0, new);
1748       if (dpos > prompt_last_invisible)         /* XXX - don't use woff here */
1749         {
1750           dpos -= woff;
1751           /* Since this will be assigned to _rl_last_c_pos at the end (more
1752              precisely, _rl_last_c_pos == dpos when this function returns),
1753              let the caller know. */
1754           cpos_adjusted = 1;
1755         }
1756     }
1757   else
1758 #endif
1759     dpos = new;
1760
1761   /* If we don't have to do anything, then return. */
1762   if (cpos == dpos)
1763     return;
1764
1765   /* It may be faster to output a CR, and then move forwards instead
1766      of moving backwards. */
1767   /* i == current physical cursor position. */
1768 #if defined (HANDLE_MULTIBYTE)
1769   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1770     i = _rl_last_c_pos;
1771   else
1772 #endif
1773   i = _rl_last_c_pos - woff;
1774   if (dpos == 0 || CR_FASTER (dpos, _rl_last_c_pos) ||
1775       (_rl_term_autowrap && i == _rl_screenwidth))
1776     {
1777 #if defined (__MSDOS__)
1778       putc ('\r', rl_outstream);
1779 #else
1780       tputs (_rl_term_cr, 1, _rl_output_character_function);
1781 #endif /* !__MSDOS__ */
1782       cpos = _rl_last_c_pos = 0;
1783     }
1784
1785   if (cpos < dpos)
1786     {
1787       /* Move the cursor forward.  We do it by printing the command
1788          to move the cursor forward if there is one, else print that
1789          portion of the output buffer again.  Which is cheaper? */
1790
1791       /* The above comment is left here for posterity.  It is faster
1792          to print one character (non-control) than to print a control
1793          sequence telling the terminal to move forward one character.
1794          That kind of control is for people who don't know what the
1795          data is underneath the cursor. */
1796
1797       /* However, we need a handle on where the current display position is
1798          in the buffer for the immediately preceding comment to be true.
1799          In multibyte locales, we don't currently have that info available.
1800          Without it, we don't know where the data we have to display begins
1801          in the buffer and we have to go back to the beginning of the screen
1802          line.  In this case, we can use the terminal sequence to move forward
1803          if it's available. */
1804       if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1805         {
1806           if (_rl_term_forward_char)
1807             {
1808               for (i = cpos; i < dpos; i++)
1809                 tputs (_rl_term_forward_char, 1, _rl_output_character_function);
1810             }
1811           else
1812             {
1813               tputs (_rl_term_cr, 1, _rl_output_character_function);
1814               for (i = 0; i < new; i++)
1815                 putc (data[i], rl_outstream);
1816             }
1817         }
1818       else
1819         for (i = cpos; i < new; i++)
1820           putc (data[i], rl_outstream);
1821     }
1822
1823 #if defined (HANDLE_MULTIBYTE)
1824   /* NEW points to the buffer point, but _rl_last_c_pos is the display point.
1825      The byte length of the string is probably bigger than the column width
1826      of the string, which means that if NEW == _rl_last_c_pos, then NEW's
1827      display point is less than _rl_last_c_pos. */
1828 #endif
1829   else if (cpos > dpos)
1830     _rl_backspace (cpos - dpos);
1831
1832   _rl_last_c_pos = dpos;
1833 }
1834
1835 /* PWP: move the cursor up or down. */
1836 void
1837 _rl_move_vert (to)
1838      int to;
1839 {
1840   register int delta, i;
1841
1842   if (_rl_last_v_pos == to || to > _rl_screenheight)
1843     return;
1844
1845   if ((delta = to - _rl_last_v_pos) > 0)
1846     {
1847       for (i = 0; i < delta; i++)
1848         putc ('\n', rl_outstream);
1849 #if defined (__MSDOS__)
1850       putc ('\r', rl_outstream);
1851 #else
1852       tputs (_rl_term_cr, 1, _rl_output_character_function);
1853 #endif
1854       _rl_last_c_pos = 0;
1855     }
1856   else
1857     {                   /* delta < 0 */
1858       if (_rl_term_up && *_rl_term_up)
1859         for (i = 0; i < -delta; i++)
1860           tputs (_rl_term_up, 1, _rl_output_character_function);
1861     }
1862
1863   _rl_last_v_pos = to;          /* Now TO is here */
1864 }
1865
1866 /* Physically print C on rl_outstream.  This is for functions which know
1867    how to optimize the display.  Return the number of characters output. */
1868 int
1869 rl_show_char (c)
1870      int c;
1871 {
1872   int n = 1;
1873   if (META_CHAR (c) && (_rl_output_meta_chars == 0))
1874     {
1875       fprintf (rl_outstream, "M-");
1876       n += 2;
1877       c = UNMETA (c);
1878     }
1879
1880 #if defined (DISPLAY_TABS)
1881   if ((CTRL_CHAR (c) && c != '\t') || c == RUBOUT)
1882 #else
1883   if (CTRL_CHAR (c) || c == RUBOUT)
1884 #endif /* !DISPLAY_TABS */
1885     {
1886       fprintf (rl_outstream, "C-");
1887       n += 2;
1888       c = CTRL_CHAR (c) ? UNCTRL (c) : '?';
1889     }
1890
1891   putc (c, rl_outstream);
1892   fflush (rl_outstream);
1893   return n;
1894 }
1895
1896 int
1897 rl_character_len (c, pos)
1898      register int c, pos;
1899 {
1900   unsigned char uc;
1901
1902   uc = (unsigned char)c;
1903
1904   if (META_CHAR (uc))
1905     return ((_rl_output_meta_chars == 0) ? 4 : 1);
1906
1907   if (uc == '\t')
1908     {
1909 #if defined (DISPLAY_TABS)
1910       return (((pos | 7) + 1) - pos);
1911 #else
1912       return (2);
1913 #endif /* !DISPLAY_TABS */
1914     }
1915
1916   if (CTRL_CHAR (c) || c == RUBOUT)
1917     return (2);
1918
1919   return ((ISPRINT (uc)) ? 1 : 2);
1920 }
1921 /* How to print things in the "echo-area".  The prompt is treated as a
1922    mini-modeline. */
1923 static int msg_saved_prompt = 0;
1924
1925 #if defined (USE_VARARGS)
1926 int
1927 #if defined (PREFER_STDARG)
1928 rl_message (const char *format, ...)
1929 #else
1930 rl_message (va_alist)
1931      va_dcl
1932 #endif
1933 {
1934   va_list args;
1935 #if defined (PREFER_VARARGS)
1936   char *format;
1937 #endif
1938
1939 #if defined (PREFER_STDARG)
1940   va_start (args, format);
1941 #else
1942   va_start (args);
1943   format = va_arg (args, char *);
1944 #endif
1945
1946 #if defined (HAVE_VSNPRINTF)
1947   vsnprintf (msg_buf, sizeof (msg_buf) - 1, format, args);
1948 #else
1949   vsprintf (msg_buf, format, args);
1950   msg_buf[sizeof(msg_buf) - 1] = '\0';  /* overflow? */
1951 #endif
1952   va_end (args);
1953
1954   if (saved_local_prompt == 0)
1955     {
1956       rl_save_prompt ();
1957       msg_saved_prompt = 1;
1958     }
1959   rl_display_prompt = msg_buf;
1960   local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
1961                                          &prompt_last_invisible,
1962                                          &prompt_invis_chars_first_line,
1963                                          &prompt_physical_chars);
1964   local_prompt_prefix = (char *)NULL;
1965   local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
1966   (*rl_redisplay_function) ();
1967
1968   return 0;
1969 }
1970 #else /* !USE_VARARGS */
1971 int
1972 rl_message (format, arg1, arg2)
1973      char *format;
1974 {
1975   sprintf (msg_buf, format, arg1, arg2);
1976   msg_buf[sizeof(msg_buf) - 1] = '\0';  /* overflow? */
1977
1978   rl_display_prompt = msg_buf;
1979   if (saved_local_prompt == 0)
1980     {
1981       rl_save_prompt ();
1982       msg_saved_prompt = 1;
1983     }
1984   local_prompt = expand_prompt (msg_buf, &prompt_visible_length,
1985                                          &prompt_last_invisible,
1986                                          &prompt_invis_chars_first_line,
1987                                          &prompt_physical_chars);
1988   local_prompt_prefix = (char *)NULL;
1989   local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
1990   (*rl_redisplay_function) ();
1991
1992   return 0;
1993 }
1994 #endif /* !USE_VARARGS */
1995
1996 /* How to clear things from the "echo-area". */
1997 int
1998 rl_clear_message ()
1999 {
2000   rl_display_prompt = rl_prompt;
2001   if (msg_saved_prompt)
2002     {
2003       rl_restore_prompt ();
2004       msg_saved_prompt = 0;
2005     }
2006   (*rl_redisplay_function) ();
2007   return 0;
2008 }
2009
2010 int
2011 rl_reset_line_state ()
2012 {
2013   rl_on_new_line ();
2014
2015   rl_display_prompt = rl_prompt ? rl_prompt : "";
2016   forced_display = 1;
2017   return 0;
2018 }
2019
2020 void
2021 rl_save_prompt ()
2022 {
2023   saved_local_prompt = local_prompt;
2024   saved_local_prefix = local_prompt_prefix;
2025   saved_prefix_length = prompt_prefix_length;
2026   saved_local_length = local_prompt_len;
2027   saved_last_invisible = prompt_last_invisible;
2028   saved_visible_length = prompt_visible_length;
2029   saved_invis_chars_first_line = prompt_invis_chars_first_line;
2030   saved_physical_chars = prompt_physical_chars;
2031
2032   local_prompt = local_prompt_prefix = (char *)0;
2033   local_prompt_len = 0;
2034   prompt_last_invisible = prompt_visible_length = prompt_prefix_length = 0;
2035   prompt_invis_chars_first_line = prompt_physical_chars = 0;
2036 }
2037
2038 void
2039 rl_restore_prompt ()
2040 {
2041   FREE (local_prompt);
2042   FREE (local_prompt_prefix);
2043
2044   local_prompt = saved_local_prompt;
2045   local_prompt_prefix = saved_local_prefix;
2046   local_prompt_len = saved_local_length;
2047   prompt_prefix_length = saved_prefix_length;
2048   prompt_last_invisible = saved_last_invisible;
2049   prompt_visible_length = saved_visible_length;
2050   prompt_invis_chars_first_line = saved_invis_chars_first_line;
2051   prompt_physical_chars = saved_physical_chars;
2052
2053   /* can test saved_local_prompt to see if prompt info has been saved. */
2054   saved_local_prompt = saved_local_prefix = (char *)0;
2055   saved_local_length = 0;
2056   saved_last_invisible = saved_visible_length = saved_prefix_length = 0;
2057   saved_invis_chars_first_line = saved_physical_chars = 0;
2058 }
2059
2060 char *
2061 _rl_make_prompt_for_search (pchar)
2062      int pchar;
2063 {
2064   int len;
2065   char *pmt, *p;
2066
2067   rl_save_prompt ();
2068
2069   /* We've saved the prompt, and can do anything with the various prompt
2070      strings we need before they're restored.  We want the unexpanded
2071      portion of the prompt string after any final newline. */
2072   p = rl_prompt ? strrchr (rl_prompt, '\n') : 0;
2073   if (p == 0)
2074     {
2075       len = (rl_prompt && *rl_prompt) ? strlen (rl_prompt) : 0;
2076       pmt = (char *)xmalloc (len + 2);
2077       if (len)
2078         strcpy (pmt, rl_prompt);
2079       pmt[len] = pchar;
2080       pmt[len+1] = '\0';
2081     }
2082   else
2083     {
2084       p++;
2085       len = strlen (p);
2086       pmt = (char *)xmalloc (len + 2);
2087       if (len)
2088         strcpy (pmt, p);
2089       pmt[len] = pchar;
2090       pmt[len+1] = '\0';
2091     }
2092
2093   /* will be overwritten by expand_prompt, called from rl_message */
2094   prompt_physical_chars = saved_physical_chars + 1;
2095   return pmt;
2096 }
2097
2098 /* Quick redisplay hack when erasing characters at the end of the line. */
2099 void
2100 _rl_erase_at_end_of_line (l)
2101      int l;
2102 {
2103   register int i;
2104
2105   _rl_backspace (l);
2106   for (i = 0; i < l; i++)
2107     putc (' ', rl_outstream);
2108   _rl_backspace (l);
2109   for (i = 0; i < l; i++)
2110     visible_line[--_rl_last_c_pos] = '\0';
2111   rl_display_fixed++;
2112 }
2113
2114 /* Clear to the end of the line.  COUNT is the minimum
2115    number of character spaces to clear, */
2116 void
2117 _rl_clear_to_eol (count)
2118      int count;
2119 {
2120   if (_rl_term_clreol)
2121     tputs (_rl_term_clreol, 1, _rl_output_character_function);
2122   else if (count)
2123     space_to_eol (count);
2124 }
2125
2126 /* Clear to the end of the line using spaces.  COUNT is the minimum
2127    number of character spaces to clear, */
2128 static void
2129 space_to_eol (count)
2130      int count;
2131 {
2132   register int i;
2133
2134   for (i = 0; i < count; i++)
2135    putc (' ', rl_outstream);
2136
2137   _rl_last_c_pos += count;
2138 }
2139
2140 void
2141 _rl_clear_screen ()
2142 {
2143   if (_rl_term_clrpag)
2144     tputs (_rl_term_clrpag, 1, _rl_output_character_function);
2145   else
2146     rl_crlf ();
2147 }
2148
2149 /* Insert COUNT characters from STRING to the output stream at column COL. */
2150 static void
2151 insert_some_chars (string, count, col)
2152      char *string;
2153      int count, col;
2154 {
2155 #if defined (__MSDOS__) || defined (__MINGW32__)
2156   _rl_output_some_chars (string, count);
2157 #else
2158   /* DEBUGGING */
2159   if (MB_CUR_MAX == 1 || rl_byte_oriented)
2160     if (count != col)
2161       fprintf(stderr, "readline: debug: insert_some_chars: count (%d) != col (%d)\n", count, col);
2162
2163   /* If IC is defined, then we do not have to "enter" insert mode. */
2164   if (_rl_term_IC)
2165     {
2166       char *buffer;
2167
2168       buffer = tgoto (_rl_term_IC, 0, col);
2169       tputs (buffer, 1, _rl_output_character_function);
2170       _rl_output_some_chars (string, count);
2171     }
2172   else
2173     {
2174       register int i;
2175
2176       /* If we have to turn on insert-mode, then do so. */
2177       if (_rl_term_im && *_rl_term_im)
2178         tputs (_rl_term_im, 1, _rl_output_character_function);
2179
2180       /* If there is a special command for inserting characters, then
2181          use that first to open up the space. */
2182       if (_rl_term_ic && *_rl_term_ic)
2183         {
2184           for (i = col; i--; )
2185             tputs (_rl_term_ic, 1, _rl_output_character_function);
2186         }
2187
2188       /* Print the text. */
2189       _rl_output_some_chars (string, count);
2190
2191       /* If there is a string to turn off insert mode, we had best use
2192          it now. */
2193       if (_rl_term_ei && *_rl_term_ei)
2194         tputs (_rl_term_ei, 1, _rl_output_character_function);
2195     }
2196 #endif /* __MSDOS__ || __MINGW32__ */
2197 }
2198
2199 /* Delete COUNT characters from the display line. */
2200 static void
2201 delete_chars (count)
2202      int count;
2203 {
2204   if (count > _rl_screenwidth)  /* XXX */
2205     return;
2206
2207 #if !defined (__MSDOS__) && !defined (__MINGW32__)
2208   if (_rl_term_DC && *_rl_term_DC)
2209     {
2210       char *buffer;
2211       buffer = tgoto (_rl_term_DC, count, count);
2212       tputs (buffer, count, _rl_output_character_function);
2213     }
2214   else
2215     {
2216       if (_rl_term_dc && *_rl_term_dc)
2217         while (count--)
2218           tputs (_rl_term_dc, 1, _rl_output_character_function);
2219     }
2220 #endif /* !__MSDOS__ && !__MINGW32__ */
2221 }
2222
2223 void
2224 _rl_update_final ()
2225 {
2226   int full_lines;
2227
2228   full_lines = 0;
2229   /* If the cursor is the only thing on an otherwise-blank last line,
2230      compensate so we don't print an extra CRLF. */
2231   if (_rl_vis_botlin && _rl_last_c_pos == 0 &&
2232         visible_line[vis_lbreaks[_rl_vis_botlin]] == 0)
2233     {
2234       _rl_vis_botlin--;
2235       full_lines = 1;
2236     }
2237   _rl_move_vert (_rl_vis_botlin);
2238   /* If we've wrapped lines, remove the final xterm line-wrap flag. */
2239   if (full_lines && _rl_term_autowrap && (VIS_LLEN(_rl_vis_botlin) == _rl_screenwidth))
2240     {
2241       char *last_line;
2242
2243       last_line = &visible_line[vis_lbreaks[_rl_vis_botlin]];
2244       cpos_buffer_position = -1;        /* don't know where we are in buffer */
2245       _rl_move_cursor_relative (_rl_screenwidth - 1, last_line);        /* XXX */
2246       _rl_clear_to_eol (0);
2247       putc (last_line[_rl_screenwidth - 1], rl_outstream);
2248     }
2249   _rl_vis_botlin = 0;
2250   rl_crlf ();
2251   fflush (rl_outstream);
2252   rl_display_fixed++;
2253 }
2254
2255 /* Move to the start of the current line. */
2256 static void
2257 cr ()
2258 {
2259   if (_rl_term_cr)
2260     {
2261 #if defined (__MSDOS__)
2262       putc ('\r', rl_outstream);
2263 #else
2264       tputs (_rl_term_cr, 1, _rl_output_character_function);
2265 #endif
2266       _rl_last_c_pos = 0;
2267     }
2268 }
2269
2270 /* Redraw the last line of a multi-line prompt that may possibly contain
2271    terminal escape sequences.  Called with the cursor at column 0 of the
2272    line to draw the prompt on. */
2273 static void
2274 redraw_prompt (t)
2275      char *t;
2276 {
2277   char *oldp;
2278
2279   oldp = rl_display_prompt;
2280   rl_save_prompt ();
2281
2282   rl_display_prompt = t;
2283   local_prompt = expand_prompt (t, &prompt_visible_length,
2284                                    &prompt_last_invisible,
2285                                    &prompt_invis_chars_first_line,
2286                                    &prompt_physical_chars);
2287   local_prompt_prefix = (char *)NULL;
2288   local_prompt_len = local_prompt ? strlen (local_prompt) : 0;
2289
2290   rl_forced_update_display ();
2291
2292   rl_display_prompt = oldp;
2293   rl_restore_prompt();
2294 }
2295
2296 /* Redisplay the current line after a SIGWINCH is received. */
2297 void
2298 _rl_redisplay_after_sigwinch ()
2299 {
2300   char *t;
2301
2302   /* Clear the current line and put the cursor at column 0.  Make sure
2303      the right thing happens if we have wrapped to a new screen line. */
2304   if (_rl_term_cr)
2305     {
2306 #if defined (__MSDOS__)
2307       putc ('\r', rl_outstream);
2308 #else
2309       tputs (_rl_term_cr, 1, _rl_output_character_function);
2310 #endif
2311       _rl_last_c_pos = 0;
2312 #if defined (__MSDOS__)
2313       space_to_eol (_rl_screenwidth);
2314       putc ('\r', rl_outstream);
2315 #else
2316       if (_rl_term_clreol)
2317         tputs (_rl_term_clreol, 1, _rl_output_character_function);
2318       else
2319         {
2320           space_to_eol (_rl_screenwidth);
2321           tputs (_rl_term_cr, 1, _rl_output_character_function);
2322         }
2323 #endif
2324       if (_rl_last_v_pos > 0)
2325         _rl_move_vert (0);
2326     }
2327   else
2328     rl_crlf ();
2329
2330   /* Redraw only the last line of a multi-line prompt. */
2331   t = strrchr (rl_display_prompt, '\n');
2332   if (t)
2333     redraw_prompt (++t);
2334   else
2335     rl_forced_update_display ();
2336 }
2337
2338 void
2339 _rl_clean_up_for_exit ()
2340 {
2341   if (readline_echoing_p)
2342     {
2343       _rl_move_vert (_rl_vis_botlin);
2344       _rl_vis_botlin = 0;
2345       fflush (rl_outstream);
2346       rl_restart_output (1, 0);
2347     }
2348 }
2349
2350 void
2351 _rl_erase_entire_line ()
2352 {
2353   cr ();
2354   _rl_clear_to_eol (0);
2355   cr ();
2356   fflush (rl_outstream);
2357 }
2358
2359 /* return the `current display line' of the cursor -- the number of lines to
2360    move up to get to the first screen line of the current readline line. */
2361 int
2362 _rl_current_display_line ()
2363 {
2364   int ret, nleft;
2365
2366   /* Find out whether or not there might be invisible characters in the
2367      editing buffer. */
2368   if (rl_display_prompt == rl_prompt)
2369     nleft = _rl_last_c_pos - _rl_screenwidth - rl_visible_prompt_length;
2370   else
2371     nleft = _rl_last_c_pos - _rl_screenwidth;
2372
2373   if (nleft > 0)
2374     ret = 1 + nleft / _rl_screenwidth;
2375   else
2376     ret = 0;
2377
2378   return ret;
2379 }
2380
2381 #if defined (HANDLE_MULTIBYTE)
2382 /* Calculate the number of screen columns occupied by STR from START to END.
2383    In the case of multibyte characters with stateful encoding, we have to
2384    scan from the beginning of the string to take the state into account. */
2385 static int
2386 _rl_col_width (str, start, end)
2387      const char *str;
2388      int start, end;
2389 {
2390   wchar_t wc;
2391   mbstate_t ps;
2392   int tmp, point, width, max;
2393
2394   if (end <= start)
2395     return 0;
2396   if (MB_CUR_MAX == 1 || rl_byte_oriented)
2397     return (end - start);
2398
2399   memset (&ps, 0, sizeof (mbstate_t));
2400
2401   point = 0;
2402   max = end;
2403
2404   while (point < start)
2405     {
2406       tmp = mbrlen (str + point, max, &ps);
2407       if (MB_INVALIDCH ((size_t)tmp))
2408         {
2409           /* In this case, the bytes are invalid or too short to compose a
2410              multibyte character, so we assume that the first byte represents
2411              a single character. */
2412           point++;
2413           max--;
2414
2415           /* Clear the state of the byte sequence, because in this case the
2416              effect of mbstate is undefined. */
2417           memset (&ps, 0, sizeof (mbstate_t));
2418         }
2419       else if (MB_NULLWCH (tmp))
2420         break;          /* Found '\0' */
2421       else
2422         {
2423           point += tmp;
2424           max -= tmp;
2425         }
2426     }
2427
2428   /* If START is not a byte that starts a character, then POINT will be
2429      greater than START.  In this case, assume that (POINT - START) gives
2430      a byte count that is the number of columns of difference. */
2431   width = point - start;
2432
2433   while (point < end)
2434     {
2435       tmp = mbrtowc (&wc, str + point, max, &ps);
2436       if (MB_INVALIDCH ((size_t)tmp))
2437         {
2438           /* In this case, the bytes are invalid or too short to compose a
2439              multibyte character, so we assume that the first byte represents
2440              a single character. */
2441           point++;
2442           max--;
2443
2444           /* and assume that the byte occupies a single column. */
2445           width++;
2446
2447           /* Clear the state of the byte sequence, because in this case the
2448              effect of mbstate is undefined. */
2449           memset (&ps, 0, sizeof (mbstate_t));
2450         }
2451       else if (MB_NULLWCH (tmp))
2452         break;                  /* Found '\0' */
2453       else
2454         {
2455           point += tmp;
2456           max -= tmp;
2457           tmp = wcwidth(wc);
2458           width += (tmp >= 0) ? tmp : 1;
2459         }
2460     }
2461
2462   width += point - end;
2463
2464   return width;
2465 }
2466 #endif /* HANDLE_MULTIBYTE */