src/message.c

   1 /* vi:set ts=8 sts=4 sw=4 noet:
   2  *
   3  * VIM - Vi IMproved    by Bram Moolenaar
   4  *
   5  * Do ":help uganda"  in Vim to read copying and usage conditions.
   6  * Do ":help credits" in Vim to see a list of people who contributed.
   7  * See README.txt for an overview of the Vim source code.
   8  */
   9
  10 /*
  11  * message.c: functions for displaying messages on the command line
  12  */
  13
  14 #define MESSAGE_FILE            /* don't include prototype for smsg() */
  15 #define USING_FLOAT_STUFF
  16
  17 #include "vim.h"
  18
  19 static int other_sourcing_name(void);
  20 static char_u *get_emsg_source(void);
  21 static char_u *get_emsg_lnum(void);
  22 static void add_msg_hist(char_u *s, int len, int attr);
  23 static void hit_return_msg(void);
  24 static void msg_home_replace_attr(char_u *fname, int attr);
  25 #ifdef FEAT_MBYTE
  26 static char_u *screen_puts_mbyte(char_u *s, int l, int attr);
  27 #endif
  28 static void msg_puts_attr_len(char_u *str, int maxlen, int attr);
  29 static void msg_puts_display(char_u *str, int maxlen, int attr, int recurse);
  30 static void msg_scroll_up(void);
  31 static void inc_msg_scrolled(void);
  32 static void store_sb_text(char_u **sb_str, char_u *s, int attr, int *sb_col, int finish);
  33 static void t_puts(int *t_col, char_u *t_s, char_u *s, int attr);
  34 static void msg_puts_printf(char_u *str, int maxlen);
  35 static int do_more_prompt(int typed_char);
  36 static void msg_screen_putchar(int c, int attr);
  37 static int  msg_check_screen(void);
  38 static void redir_write(char_u *s, int maxlen);
  39 #ifdef FEAT_CON_DIALOG
  40 static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfltbutton);
  41 static int      confirm_msg_used = FALSE;       /* displaying confirm_msg */
  42 static char_u   *confirm_msg = NULL;            /* ":confirm" message */
  43 static char_u   *confirm_msg_tail;              /* tail of confirm_msg */
  44 #endif
  45 #ifdef FEAT_JOB_CHANNEL
  46 static int emsg_to_channel_log = FALSE;
  47 #endif
  48
  49 struct msg_hist
  50 {
  51     struct msg_hist     *next;
  52     char_u              *msg;
  53     int                 attr;
  54 };
  55
  56 static struct msg_hist *first_msg_hist = NULL;
  57 static struct msg_hist *last_msg_hist = NULL;
  58 static int msg_hist_len = 0;
  59
  60 static FILE *verbose_fd = NULL;
  61 static int  verbose_did_open = FALSE;
  62
  63 /*
  64  * When writing messages to the screen, there are many different situations.
  65  * A number of variables is used to remember the current state:
  66  * msg_didany       TRUE when messages were written since the last time the
  67  *                  user reacted to a prompt.
  68  *                  Reset: After hitting a key for the hit-return prompt,
  69  *                  hitting <CR> for the command line or input().
  70  *                  Set: When any message is written to the screen.
  71  * msg_didout       TRUE when something was written to the current line.
  72  *                  Reset: When advancing to the next line, when the current
  73  *                  text can be overwritten.
  74  *                  Set: When any message is written to the screen.
  75  * msg_nowait       No extra delay for the last drawn message.
  76  *                  Used in normal_cmd() before the mode message is drawn.
  77  * emsg_on_display  There was an error message recently.  Indicates that there
  78  *                  should be a delay before redrawing.
  79  * msg_scroll       The next message should not overwrite the current one.
  80  * msg_scrolled     How many lines the screen has been scrolled (because of
  81  *                  messages).  Used in update_screen() to scroll the screen
  82  *                  back.  Incremented each time the screen scrolls a line.
  83  * msg_scrolled_ign  TRUE when msg_scrolled is non-zero and msg_puts_attr()
  84  *                  writes something without scrolling should not make
  85  *                  need_wait_return to be set.  This is a hack to make ":ts"
  86  *                  work without an extra prompt.
  87  * lines_left       Number of lines available for messages before the
  88  *                  more-prompt is to be given.  -1 when not set.
  89  * need_wait_return TRUE when the hit-return prompt is needed.
  90  *                  Reset: After giving the hit-return prompt, when the user
  91  *                  has answered some other prompt.
  92  *                  Set: When the ruler or typeahead display is overwritten,
  93  *                  scrolling the screen for some message.
  94  * keep_msg         Message to be displayed after redrawing the screen, in
  95  *                  main_loop().
  96  *                  This is an allocated string or NULL when not used.
  97  */
  98
  99 /*
 100  * msg(s) - displays the string 's' on the status line
 101  * When terminal not initialized (yet) mch_errmsg(..) is used.
 102  * return TRUE if wait_return not called
 103  */
 104     int
 105 msg(char_u *s)
 106 {
 107     return msg_attr_keep(s, 0, FALSE);
 108 }
 109
 110 #if defined(FEAT_EVAL) || defined(FEAT_X11) || defined(USE_XSMP) \
 111     || defined(FEAT_GUI_GTK) || defined(PROTO)
 112 /*
 113  * Like msg() but keep it silent when 'verbosefile' is set.
 114  */
 115     int
 116 verb_msg(char_u *s)
 117 {
 118     int         n;
 119
 120     verbose_enter();
 121     n = msg_attr_keep(s, 0, FALSE);
 122     verbose_leave();
 123
 124     return n;
 125 }
 126 #endif
 127
 128     int
 129 msg_attr(char_u *s, int attr)
 130 {
 131     return msg_attr_keep(s, attr, FALSE);
 132 }
 133
 134     int
 135 msg_attr_keep(
 136     char_u      *s,
 137     int         attr,
 138     int         keep)       /* TRUE: set keep_msg if it doesn't scroll */
 139 {
 140     static int  entered = 0;
 141     int         retval;
 142     char_u      *buf = NULL;
 143
 144     /* Skip messages not matching ":filter pattern".
 145      * Don't filter when there is an error. */
 146     if (!emsg_on_display && message_filtered(s))
 147         return TRUE;
 148
 149 #ifdef FEAT_EVAL
 150     if (attr == 0)
 151         set_vim_var_string(VV_STATUSMSG, s, -1);
 152 #endif
 153
 154     /*
 155      * It is possible that displaying a messages causes a problem (e.g.,
 156      * when redrawing the window), which causes another message, etc..  To
 157      * break this loop, limit the recursiveness to 3 levels.
 158      */
 159     if (entered >= 3)
 160         return TRUE;
 161     ++entered;
 162
 163     /* Add message to history (unless it's a repeated kept message or a
 164      * truncated message) */
 165     if (s != keep_msg
 166             || (*s != '<'
 167                 && last_msg_hist != NULL
 168                 && last_msg_hist->msg != NULL
 169                 && STRCMP(s, last_msg_hist->msg)))
 170         add_msg_hist(s, -1, attr);
 171
 172 #ifdef FEAT_JOB_CHANNEL
 173     if (emsg_to_channel_log)
 174     {
 175         /* Write message in the channel log. */
 176         ch_logs(NULL, "ERROR: %s", (char *)s);
 177     }
 178 #endif
 179
 180     /* When displaying keep_msg, don't let msg_start() free it, caller must do
 181      * that. */
 182     if (s == keep_msg)
 183         keep_msg = NULL;
 184
 185     /* Truncate the message if needed. */
 186     msg_start();
 187     buf = msg_strtrunc(s, FALSE);
 188     if (buf != NULL)
 189         s = buf;
 190
 191     msg_outtrans_attr(s, attr);
 192     msg_clr_eos();
 193     retval = msg_end();
 194
 195     if (keep && retval && vim_strsize(s) < (int)(Rows - cmdline_row - 1)
 196                                                            * Columns + sc_col)
 197         set_keep_msg(s, 0);
 198
 199     vim_free(buf);
 200     --entered;
 201     return retval;
 202 }
 203
 204 /*
 205  * Truncate a string such that it can be printed without causing a scroll.
 206  * Returns an allocated string or NULL when no truncating is done.
 207  */
 208     char_u *
 209 msg_strtrunc(
 210     char_u      *s,
 211     int         force)      /* always truncate */
 212 {
 213     char_u      *buf = NULL;
 214     int         len;
 215     int         room;
 216
 217     /* May truncate message to avoid a hit-return prompt */
 218     if ((!msg_scroll && !need_wait_return && shortmess(SHM_TRUNCALL)
 219                                && !exmode_active && msg_silent == 0) || force)
 220     {
 221         len = vim_strsize(s);
 222         if (msg_scrolled != 0)
 223             /* Use all the columns. */
 224             room = (int)(Rows - msg_row) * Columns - 1;
 225         else
 226             /* Use up to 'showcmd' column. */
 227             room = (int)(Rows - msg_row - 1) * Columns + sc_col - 1;
 228         if (len > room && room > 0)
 229         {
 230 #ifdef FEAT_MBYTE
 231             if (enc_utf8)
 232                 /* may have up to 18 bytes per cell (6 per char, up to two
 233                  * composing chars) */
 234                 len = (room + 2) * 18;
 235             else if (enc_dbcs == DBCS_JPNU)
 236                 /* may have up to 2 bytes per cell for euc-jp */
 237                 len = (room + 2) * 2;
 238             else
 239 #endif
 240                 len = room + 2;
 241             buf = alloc(len);
 242             if (buf != NULL)
 243                 trunc_string(s, buf, room, len);
 244         }
 245     }
 246     return buf;
 247 }
 248
 249 /*
 250  * Truncate a string "s" to "buf" with cell width "room".
 251  * "s" and "buf" may be equal.
 252  */
 253     void
 254 trunc_string(
 255     char_u      *s,
 256     char_u      *buf,
 257     int         room_in,
 258     int         buflen)
 259 {
 260     size_t      room = room_in - 3; /* "..." takes 3 chars */
 261     size_t      half;
 262     size_t      len = 0;
 263     int         e;
 264     int         i;
 265     int         n;
 266
 267     if (room_in < 3)
 268         room = 0;
 269     half = room / 2;
 270
 271     /* First part: Start of the string. */
 272     for (e = 0; len < half && e < buflen; ++e)
 273     {
 274         if (s[e] == NUL)
 275         {
 276             /* text fits without truncating! */
 277             buf[e] = NUL;
 278             return;
 279         }
 280         n = ptr2cells(s + e);
 281         if (len + n > half)
 282             break;
 283         len += n;
 284         buf[e] = s[e];
 285 #ifdef FEAT_MBYTE
 286         if (has_mbyte)
 287             for (n = (*mb_ptr2len)(s + e); --n > 0; )
 288             {
 289                 if (++e == buflen)
 290                     break;
 291                 buf[e] = s[e];
 292             }
 293 #endif
 294     }
 295
 296     /* Last part: End of the string. */
 297     i = e;
 298 #ifdef FEAT_MBYTE
 299     if (enc_dbcs != 0)
 300     {
 301         /* For DBCS going backwards in a string is slow, but
 302          * computing the cell width isn't too slow: go forward
 303          * until the rest fits. */
 304         n = vim_strsize(s + i);
 305         while (len + n > room)
 306         {
 307             n -= ptr2cells(s + i);
 308             i += (*mb_ptr2len)(s + i);
 309         }
 310     }
 311     else if (enc_utf8)
 312     {
 313         /* For UTF-8 we can go backwards easily. */
 314         half = i = (int)STRLEN(s);
 315         for (;;)
 316         {
 317             do
 318                 half = half - utf_head_off(s, s + half - 1) - 1;
 319             while (half > 0 && utf_iscomposing(utf_ptr2char(s + half)));
 320             n = ptr2cells(s + half);
 321             if (len + n > room || half == 0)
 322                 break;
 323             len += n;
 324             i = (int)half;
 325         }
 326     }
 327     else
 328 #endif
 329     {
 330         for (i = (int)STRLEN(s); len + (n = ptr2cells(s + i - 1)) <= room; --i)
 331             len += n;
 332     }
 333
 334
 335     if (i <= e + 3)
 336     {
 337         /* text fits without truncating */
 338         if (s != buf)
 339         {
 340             len = STRLEN(s);
 341             if (len >= (size_t)buflen)
 342                 len = buflen - 1;
 343             len = len - e + 1;
 344             if (len < 1)
 345                 buf[e - 1] = NUL;
 346             else
 347                 mch_memmove(buf + e, s + e, len);
 348         }
 349     }
 350     else if (e + 3 < buflen)
 351     {
 352         /* set the middle and copy the last part */
 353         mch_memmove(buf + e, "...", (size_t)3);
 354         len = STRLEN(s + i) + 1;
 355         if (len >= (size_t)buflen - e - 3)
 356             len = buflen - e - 3 - 1;
 357         mch_memmove(buf + e + 3, s + i, len);
 358         buf[e + 3 + len - 1] = NUL;
 359     }
 360     else
 361     {
 362         /* can't fit in the "...", just truncate it */
 363         buf[e - 1] = NUL;
 364     }
 365 }
 366
 367 /*
 368  * Automatic prototype generation does not understand this function.
 369  * Note: Caller of smgs() and smsg_attr() must check the resulting string is
 370  * shorter than IOSIZE!!!
 371  */
 372 #ifndef PROTO
 373
 374 int vim_snprintf(char *str, size_t str_m, char *fmt, ...);
 375
 376     int
 377 # ifdef __BORLANDC__
 378 _RTLENTRYF
 379 # endif
 380 smsg(char_u *s, ...)
 381 {
 382     va_list arglist;
 383
 384     va_start(arglist, s);
 385     vim_vsnprintf((char *)IObuff, IOSIZE, (char *)s, arglist, NULL);
 386     va_end(arglist);
 387     return msg(IObuff);
 388 }
 389
 390     int
 391 # ifdef __BORLANDC__
 392 _RTLENTRYF
 393 # endif
 394 smsg_attr(int attr, char_u *s, ...)
 395 {
 396     va_list arglist;
 397
 398     va_start(arglist, s);
 399     vim_vsnprintf((char *)IObuff, IOSIZE, (char *)s, arglist, NULL);
 400     va_end(arglist);
 401     return msg_attr(IObuff, attr);
 402 }
 403
 404 #endif
 405
 406 /*
 407  * Remember the last sourcing name/lnum used in an error message, so that it
 408  * isn't printed each time when it didn't change.
 409  */
 410 static int      last_sourcing_lnum = 0;
 411 static char_u   *last_sourcing_name = NULL;
 412
 413 /*
 414  * Reset the last used sourcing name/lnum.  Makes sure it is displayed again
 415  * for the next error message;
 416  */
 417     void
 418 reset_last_sourcing(void)
 419 {
 420     vim_free(last_sourcing_name);
 421     last_sourcing_name = NULL;
 422     last_sourcing_lnum = 0;
 423 }
 424
 425 /*
 426  * Return TRUE if "sourcing_name" differs from "last_sourcing_name".
 427  */
 428     static int
 429 other_sourcing_name(void)
 430 {
 431     if (sourcing_name != NULL)
 432     {
 433         if (last_sourcing_name != NULL)
 434             return STRCMP(sourcing_name, last_sourcing_name) != 0;
 435         return TRUE;
 436     }
 437     return FALSE;
 438 }
 439
 440 /*
 441  * Get the message about the source, as used for an error message.
 442  * Returns an allocated string with room for one more character.
 443  * Returns NULL when no message is to be given.
 444  */
 445     static char_u *
 446 get_emsg_source(void)
 447 {
 448     char_u      *Buf, *p;
 449
 450     if (sourcing_name != NULL && other_sourcing_name())
 451     {
 452         p = (char_u *)_("Error detected while processing %s:");
 453         Buf = alloc((unsigned)(STRLEN(sourcing_name) + STRLEN(p)));
 454         if (Buf != NULL)
 455             sprintf((char *)Buf, (char *)p, sourcing_name);
 456         return Buf;
 457     }
 458     return NULL;
 459 }
 460
 461 /*
 462  * Get the message about the source lnum, as used for an error message.
 463  * Returns an allocated string with room for one more character.
 464  * Returns NULL when no message is to be given.
 465  */
 466     static char_u *
 467 get_emsg_lnum(void)
 468 {
 469     char_u      *Buf, *p;
 470
 471     /* lnum is 0 when executing a command from the command line
 472      * argument, we don't want a line number then */
 473     if (sourcing_name != NULL
 474             && (other_sourcing_name() || sourcing_lnum != last_sourcing_lnum)
 475             && sourcing_lnum != 0)
 476     {
 477         p = (char_u *)_("line %4ld:");
 478         Buf = alloc((unsigned)(STRLEN(p) + 20));
 479         if (Buf != NULL)
 480             sprintf((char *)Buf, (char *)p, (long)sourcing_lnum);
 481         return Buf;
 482     }
 483     return NULL;
 484 }
 485
 486 /*
 487  * Display name and line number for the source of an error.
 488  * Remember the file name and line number, so that for the next error the info
 489  * is only displayed if it changed.
 490  */
 491     void
 492 msg_source(int attr)
 493 {
 494     char_u      *p;
 495
 496     ++no_wait_return;
 497     p = get_emsg_source();
 498     if (p != NULL)
 499     {
 500         msg_attr(p, attr);
 501         vim_free(p);
 502     }
 503     p = get_emsg_lnum();
 504     if (p != NULL)
 505     {
 506         msg_attr(p, HL_ATTR(HLF_N));
 507         vim_free(p);
 508         last_sourcing_lnum = sourcing_lnum;  /* only once for each line */
 509     }
 510
 511     /* remember the last sourcing name printed, also when it's empty */
 512     if (sourcing_name == NULL || other_sourcing_name())
 513     {
 514         vim_free(last_sourcing_name);
 515         if (sourcing_name == NULL)
 516             last_sourcing_name = NULL;
 517         else
 518             last_sourcing_name = vim_strsave(sourcing_name);
 519     }
 520     --no_wait_return;
 521 }
 522
 523 /*
 524  * Return TRUE if not giving error messages right now:
 525  * If "emsg_off" is set: no error messages at the moment.
 526  * If "msg" is in 'debug': do error message but without side effects.
 527  * If "emsg_skip" is set: never do error messages.
 528  */
 529     int
 530 emsg_not_now(void)
 531 {
 532     if ((emsg_off > 0 && vim_strchr(p_debug, 'm') == NULL
 533                                           && vim_strchr(p_debug, 't') == NULL)
 534 #ifdef FEAT_EVAL
 535             || emsg_skip > 0
 536 #endif
 537             )
 538         return TRUE;
 539     return FALSE;
 540 }
 541
 542 #if defined(FEAT_EVAL) || defined(PROTO)
 543 static garray_T ignore_error_list = GA_EMPTY;
 544
 545     void
 546 ignore_error_for_testing(char_u *error)
 547 {
 548     if (ignore_error_list.ga_itemsize == 0)
 549         ga_init2(&ignore_error_list, sizeof(char_u *), 1);
 550
 551     ga_add_string(&ignore_error_list, error);
 552 }
 553
 554     static int
 555 ignore_error(char_u *msg)
 556 {
 557     int i;
 558
 559     for (i = 0; i < ignore_error_list.ga_len; ++i)
 560         if (strstr((char *)msg,
 561                   (char *)((char_u **)(ignore_error_list.ga_data))[i]) != NULL)
 562             return TRUE;
 563     return FALSE;
 564 }
 565 #endif
 566
 567 #if !defined(HAVE_STRERROR) || defined(PROTO)
 568 /*
 569  * Replacement for perror() that behaves more or less like emsg() was called.
 570  * v:errmsg will be set and called_emsg will be set.
 571  */
 572     void
 573 do_perror(char *msg)
 574 {
 575     perror(msg);
 576     ++emsg_silent;
 577     emsg((char_u *)msg);
 578     --emsg_silent;
 579 }
 580 #endif
 581
 582 /*
 583  * emsg() - display an error message
 584  *
 585  * Rings the bell, if appropriate, and calls message() to do the real work
 586  * When terminal not initialized (yet) mch_errmsg(..) is used.
 587  *
 588  * return TRUE if wait_return not called
 589  */
 590     int
 591 emsg(char_u *s)
 592 {
 593     int         attr;
 594     char_u      *p;
 595     int         r;
 596 #ifdef FEAT_EVAL
 597     int         ignore = FALSE;
 598     int         severe;
 599 #endif
 600
 601     /* Skip this if not giving error messages at the moment. */
 602     if (emsg_not_now())
 603         return TRUE;
 604
 605 #ifdef FEAT_EVAL
 606     /* When testing some errors are turned into a normal message. */
 607     if (ignore_error(s))
 608         /* don't call msg() if it results in a dialog */
 609         return msg_use_printf() ? FALSE : msg(s);
 610 #endif
 611
 612     called_emsg = TRUE;
 613
 614     /*
 615      * If "emsg_severe" is TRUE: When an error exception is to be thrown,
 616      * prefer this message over previous messages for the same command.
 617      */
 618 #ifdef FEAT_EVAL
 619     severe = emsg_severe;
 620     emsg_severe = FALSE;
 621 #endif
 622
 623     if (!emsg_off || vim_strchr(p_debug, 't') != NULL)
 624     {
 625 #ifdef FEAT_EVAL
 626         /*
 627          * Cause a throw of an error exception if appropriate.  Don't display
 628          * the error message in this case.  (If no matching catch clause will
 629          * be found, the message will be displayed later on.)  "ignore" is set
 630          * when the message should be ignored completely (used for the
 631          * interrupt message).
 632          */
 633         if (cause_errthrow(s, severe, &ignore) == TRUE)
 634         {
 635             if (!ignore)
 636                 did_emsg = TRUE;
 637             return TRUE;
 638         }
 639
 640         /* set "v:errmsg", also when using ":silent! cmd" */
 641         set_vim_var_string(VV_ERRMSG, s, -1);
 642 #endif
 643
 644         /*
 645          * When using ":silent! cmd" ignore error messages.
 646          * But do write it to the redirection file.
 647          */
 648         if (emsg_silent != 0)
 649         {
 650             if (emsg_noredir == 0)
 651             {
 652                 msg_start();
 653                 p = get_emsg_source();
 654                 if (p != NULL)
 655                 {
 656                     STRCAT(p, "\n");
 657                     redir_write(p, -1);
 658                     vim_free(p);
 659                 }
 660                 p = get_emsg_lnum();
 661                 if (p != NULL)
 662                 {
 663                     STRCAT(p, "\n");
 664                     redir_write(p, -1);
 665                     vim_free(p);
 666                 }
 667                 redir_write(s, -1);
 668             }
 669 #ifdef FEAT_JOB_CHANNEL
 670             ch_logs(NULL, "ERROR: %s", (char *)s);
 671 #endif
 672             return TRUE;
 673         }
 674
 675         ex_exitval = 1;
 676
 677         /* Reset msg_silent, an error causes messages to be switched back on. */
 678         msg_silent = 0;
 679         cmd_silent = FALSE;
 680
 681         if (global_busy)                /* break :global command */
 682             ++global_busy;
 683
 684         if (p_eb)
 685             beep_flush();               /* also includes flush_buffers() */
 686         else
 687             flush_buffers(FALSE);       /* flush internal buffers */
 688         did_emsg = TRUE;                /* flag for DoOneCmd() */
 689     }
 690
 691     emsg_on_display = TRUE;     /* remember there is an error message */
 692     ++msg_scroll;               /* don't overwrite a previous message */
 693     attr = HL_ATTR(HLF_E);      /* set highlight mode for error messages */
 694     if (msg_scrolled != 0)
 695         need_wait_return = TRUE;    /* needed in case emsg() is called after
 696                                      * wait_return has reset need_wait_return
 697                                      * and a redraw is expected because
 698                                      * msg_scrolled is non-zero */
 699
 700 #ifdef FEAT_JOB_CHANNEL
 701     emsg_to_channel_log = TRUE;
 702 #endif
 703     /*
 704      * Display name and line number for the source of the error.
 705      */
 706     msg_source(attr);
 707
 708     /*
 709      * Display the error message itself.
 710      */
 711     msg_nowait = FALSE;                 /* wait for this msg */
 712     r = msg_attr(s, attr);
 713
 714 #ifdef FEAT_JOB_CHANNEL
 715     emsg_to_channel_log = FALSE;
 716 #endif
 717     return r;
 718 }
 719
 720
 721 /*
 722  * Print an error message with one "%s" and one string argument.
 723  */
 724     int
 725 emsg2(char_u *s, char_u *a1)
 726 {
 727     return emsg3(s, a1, NULL);
 728 }
 729
 730 /*
 731  * Print an error message with one or two "%s" and one or two string arguments.
 732  * This is not in message.c to avoid a warning for prototypes.
 733  */
 734     int
 735 emsg3(char_u *s, char_u *a1, char_u *a2)
 736 {
 737     if (emsg_not_now())
 738         return TRUE;            /* no error messages at the moment */
 739     vim_snprintf((char *)IObuff, IOSIZE, (char *)s, a1, a2);
 740     return emsg(IObuff);
 741 }
 742
 743 /*
 744  * Print an error message with one "%ld" and one long int argument.
 745  * This is not in message.c to avoid a warning for prototypes.
 746  */
 747     int
 748 emsgn(char_u *s, long n)
 749 {
 750     if (emsg_not_now())
 751         return TRUE;            /* no error messages at the moment */
 752     vim_snprintf((char *)IObuff, IOSIZE, (char *)s, n);
 753     return emsg(IObuff);
 754 }
 755
 756 /*
 757  * Same as emsg(...), but abort on error when ABORT_ON_INTERNAL_ERROR is
 758  * defined. It is used for internal errors only, so that they can be
 759  * detected when fuzzing vim.
 760  */
 761     void
 762 iemsg(char_u *s)
 763 {
 764     msg(s);
 765 #ifdef ABORT_ON_INTERNAL_ERROR
 766     abort();
 767 #endif
 768 }
 769
 770
 771 /*
 772  * Same as emsg2(...) but abort on error when ABORT_ON_INTERNAL_ERROR is
 773  * defined. It is used for internal errors only, so that they can be
 774  * detected when fuzzing vim.
 775  */
 776     void
 777 iemsg2(char_u *s, char_u *a1)
 778 {
 779     emsg2(s, a1);
 780 #ifdef ABORT_ON_INTERNAL_ERROR
 781     abort();
 782 #endif
 783 }
 784
 785 /*
 786  * Same as emsgn(...) but abort on error when ABORT_ON_INTERNAL_ERROR is
 787  * defined. It is used for internal errors only, so that they can be
 788  * detected when fuzzing vim.
 789  */
 790     void
 791 iemsgn(char_u *s, long n)
 792 {
 793     emsgn(s, n);
 794 #ifdef ABORT_ON_INTERNAL_ERROR
 795     abort();
 796 #endif
 797 }
 798
 799 /*
 800  * Give an "Internal error" message.
 801  */
 802     void
 803 internal_error(char *where)
 804 {
 805     IEMSG2(_(e_intern2), where);
 806 }
 807
 808 /* emsg3() and emsgn() are in misc2.c to avoid warnings for the prototypes. */
 809
 810     void
 811 emsg_invreg(int name)
 812 {
 813     EMSG2(_("E354: Invalid register name: '%s'"), transchar(name));
 814 }
 815
 816 /*
 817  * Like msg(), but truncate to a single line if p_shm contains 't', or when
 818  * "force" is TRUE.  This truncates in another way as for normal messages.
 819  * Careful: The string may be changed by msg_may_trunc()!
 820  * Returns a pointer to the printed message, if wait_return() not called.
 821  */
 822     char_u *
 823 msg_trunc_attr(char_u *s, int force, int attr)
 824 {
 825     int         n;
 826
 827     /* Add message to history before truncating */
 828     add_msg_hist(s, -1, attr);
 829
 830     s = msg_may_trunc(force, s);
 831
 832     msg_hist_off = TRUE;
 833     n = msg_attr(s, attr);
 834     msg_hist_off = FALSE;
 835
 836     if (n)
 837         return s;
 838     return NULL;
 839 }
 840
 841 /*
 842  * Check if message "s" should be truncated at the start (for filenames).
 843  * Return a pointer to where the truncated message starts.
 844  * Note: May change the message by replacing a character with '<'.
 845  */
 846     char_u *
 847 msg_may_trunc(int force, char_u *s)
 848 {
 849     int         n;
 850     int         room;
 851
 852     room = (int)(Rows - cmdline_row - 1) * Columns + sc_col - 1;
 853     if ((force || (shortmess(SHM_TRUNC) && !exmode_active))
 854             && (n = (int)STRLEN(s) - room) > 0)
 855     {
 856 #ifdef FEAT_MBYTE
 857         if (has_mbyte)
 858         {
 859             int size = vim_strsize(s);
 860
 861             /* There may be room anyway when there are multibyte chars. */
 862             if (size <= room)
 863                 return s;
 864
 865             for (n = 0; size >= room; )
 866             {
 867                 size -= (*mb_ptr2cells)(s + n);
 868                 n += (*mb_ptr2len)(s + n);
 869             }
 870             --n;
 871         }
 872 #endif
 873         s += n;
 874         *s = '<';
 875     }
 876     return s;
 877 }
 878
 879     static void
 880 add_msg_hist(
 881     char_u      *s,
 882     int         len,            /* -1 for undetermined length */
 883     int         attr)
 884 {
 885     struct msg_hist *p;
 886
 887     if (msg_hist_off || msg_silent != 0)
 888         return;
 889
 890     /* Don't let the message history get too big */
 891     while (msg_hist_len > MAX_MSG_HIST_LEN)
 892         (void)delete_first_msg();
 893
 894     /* allocate an entry and add the message at the end of the history */
 895     p = (struct msg_hist *)alloc((int)sizeof(struct msg_hist));
 896     if (p != NULL)
 897     {
 898         if (len < 0)
 899             len = (int)STRLEN(s);
 900         /* remove leading and trailing newlines */
 901         while (len > 0 && *s == '\n')
 902         {
 903             ++s;
 904             --len;
 905         }
 906         while (len > 0 && s[len - 1] == '\n')
 907             --len;
 908         p->msg = vim_strnsave(s, len);
 909         p->next = NULL;
 910         p->attr = attr;
 911         if (last_msg_hist != NULL)
 912             last_msg_hist->next = p;
 913         last_msg_hist = p;
 914         if (first_msg_hist == NULL)
 915             first_msg_hist = last_msg_hist;
 916         ++msg_hist_len;
 917     }
 918 }
 919
 920 /*
 921  * Delete the first (oldest) message from the history.
 922  * Returns FAIL if there are no messages.
 923  */
 924     int
 925 delete_first_msg(void)
 926 {
 927     struct msg_hist *p;
 928
 929     if (msg_hist_len <= 0)
 930         return FAIL;
 931     p = first_msg_hist;
 932     first_msg_hist = p->next;
 933     if (first_msg_hist == NULL)
 934         last_msg_hist = NULL;  /* history is empty */
 935     vim_free(p->msg);
 936     vim_free(p);
 937     --msg_hist_len;
 938     return OK;
 939 }
 940
 941 /*
 942  * ":messages" command.
 943  */
 944     void
 945 ex_messages(exarg_T *eap)
 946 {
 947     struct msg_hist *p;
 948     char_u          *s;
 949     int             c = 0;
 950
 951     if (STRCMP(eap->arg, "clear") == 0)
 952     {
 953         int keep = eap->addr_count == 0 ? 0 : eap->line2;
 954
 955         while (msg_hist_len > keep)
 956             (void)delete_first_msg();
 957         return;
 958     }
 959
 960     if (*eap->arg != NUL)
 961     {
 962         EMSG(_(e_invarg));
 963         return;
 964     }
 965
 966     msg_hist_off = TRUE;
 967
 968     p = first_msg_hist;
 969     if (eap->addr_count != 0)
 970     {
 971         /* Count total messages */
 972         for (; p != NULL && !got_int; p = p->next)
 973             c++;
 974
 975         c -= eap->line2;
 976
 977         /* Skip without number of messages specified */
 978         for (p = first_msg_hist; p != NULL && !got_int && c > 0;
 979                                                     p = p->next, c--);
 980     }
 981
 982     if (p == first_msg_hist)
 983     {
 984         s = mch_getenv((char_u *)"LANG");
 985         if (s != NULL && *s != NUL)
 986             msg_attr((char_u *)
 987                     _("Messages maintainer: Bram Moolenaar <Bram@vim.org>"),
 988                     HL_ATTR(HLF_T));
 989     }
 990
 991     /* Display what was not skipped. */
 992     for (; p != NULL && !got_int; p = p->next)
 993         if (p->msg != NULL)
 994             msg_attr(p->msg, p->attr);
 995
 996     msg_hist_off = FALSE;
 997 }
 998
 999 #if defined(FEAT_CON_DIALOG) || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
1000 /*
1001  * Call this after prompting the user.  This will avoid a hit-return message
1002  * and a delay.
1003  */
1004     void
1005 msg_end_prompt(void)
1006 {
1007     need_wait_return = FALSE;
1008     emsg_on_display = FALSE;
1009     cmdline_row = msg_row;
1010     msg_col = 0;
1011     msg_clr_eos();
1012     lines_left = -1;
1013 }
1014 #endif
1015
1016 /*
1017  * wait for the user to hit a key (normally a return)
1018  * if 'redraw' is TRUE, clear and redraw the screen
1019  * if 'redraw' is FALSE, just redraw the screen
1020  * if 'redraw' is -1, don't redraw at all
1021  */
1022     void
1023 wait_return(int redraw)
1024 {
1025     int         c;
1026     int         oldState;
1027     int         tmpState;
1028     int         had_got_int;
1029     int         save_Recording;
1030     FILE        *save_scriptout;
1031
1032     if (redraw == TRUE)
1033         must_redraw = CLEAR;
1034
1035     /* If using ":silent cmd", don't wait for a return.  Also don't set
1036      * need_wait_return to do it later. */
1037     if (msg_silent != 0)
1038         return;
1039
1040     /*
1041      * When inside vgetc(), we can't wait for a typed character at all.
1042      * With the global command (and some others) we only need one return at
1043      * the end. Adjust cmdline_row to avoid the next message overwriting the
1044      * last one.
1045      */
1046     if (vgetc_busy > 0)
1047         return;
1048     need_wait_return = TRUE;
1049     if (no_wait_return)
1050     {
1051         if (!exmode_active)
1052             cmdline_row = msg_row;
1053         return;
1054     }
1055
1056     redir_off = TRUE;           /* don't redirect this message */
1057     oldState = State;
1058     if (quit_more)
1059     {
1060         c = CAR;                /* just pretend CR was hit */
1061         quit_more = FALSE;
1062         got_int = FALSE;
1063     }
1064     else if (exmode_active)
1065     {
1066         MSG_PUTS(" ");          /* make sure the cursor is on the right line */
1067         c = CAR;                /* no need for a return in ex mode */
1068         got_int = FALSE;
1069     }
1070     else
1071     {
1072         /* Make sure the hit-return prompt is on screen when 'guioptions' was
1073          * just changed. */
1074         screenalloc(FALSE);
1075
1076         State = HITRETURN;
1077 #ifdef FEAT_MOUSE
1078         setmouse();
1079 #endif
1080 #ifdef USE_ON_FLY_SCROLL
1081         dont_scroll = TRUE;             /* disallow scrolling here */
1082 #endif
1083         cmdline_row = msg_row;
1084
1085         /* Avoid the sequence that the user types ":" at the hit-return prompt
1086          * to start an Ex command, but the file-changed dialog gets in the
1087          * way. */
1088         if (need_check_timestamps)
1089             check_timestamps(FALSE);
1090
1091         hit_return_msg();
1092
1093         do
1094         {
1095             /* Remember "got_int", if it is set vgetc() probably returns a
1096              * CTRL-C, but we need to loop then. */
1097             had_got_int = got_int;
1098
1099             /* Don't do mappings here, we put the character back in the
1100              * typeahead buffer. */
1101             ++no_mapping;
1102             ++allow_keys;
1103
1104             /* Temporarily disable Recording. If Recording is active, the
1105              * character will be recorded later, since it will be added to the
1106              * typebuf after the loop */
1107             save_Recording = Recording;
1108             save_scriptout = scriptout;
1109             Recording = FALSE;
1110             scriptout = NULL;
1111             c = safe_vgetc();
1112             if (had_got_int && !global_busy)
1113                 got_int = FALSE;
1114             --no_mapping;
1115             --allow_keys;
1116             Recording = save_Recording;
1117             scriptout = save_scriptout;
1118
1119 #ifdef FEAT_CLIPBOARD
1120             /* Strange way to allow copying (yanking) a modeless selection at
1121              * the hit-enter prompt.  Use CTRL-Y, because the same is used in
1122              * Cmdline-mode and it's harmless when there is no selection. */
1123             if (c == Ctrl_Y && clip_star.state == SELECT_DONE)
1124             {
1125                 clip_copy_modeless_selection(TRUE);
1126                 c = K_IGNORE;
1127             }
1128 #endif
1129
1130             /*
1131              * Allow scrolling back in the messages.
1132              * Also accept scroll-down commands when messages fill the screen,
1133              * to avoid that typing one 'j' too many makes the messages
1134              * disappear.
1135              */
1136             if (p_more && !p_cp)
1137             {
1138                 if (c == 'b' || c == 'k' || c == 'u' || c == 'g'
1139                                                 || c == K_UP || c == K_PAGEUP)
1140                 {
1141                     if (msg_scrolled > Rows)
1142                         /* scroll back to show older messages */
1143                         do_more_prompt(c);
1144                     else
1145                     {
1146                         msg_didout = FALSE;
1147                         c = K_IGNORE;
1148                         msg_col =
1149 #ifdef FEAT_RIGHTLEFT
1150                             cmdmsg_rl ? Columns - 1 :
1151 #endif
1152                             0;
1153                     }
1154                     if (quit_more)
1155                     {
1156                         c = CAR;                /* just pretend CR was hit */
1157                         quit_more = FALSE;
1158                         got_int = FALSE;
1159                     }
1160                     else if (c != K_IGNORE)
1161                     {
1162                         c = K_IGNORE;
1163                         hit_return_msg();
1164                     }
1165                 }
1166                 else if (msg_scrolled > Rows - 2
1167                          && (c == 'j' || c == 'd' || c == 'f'
1168                                            || c == K_DOWN || c == K_PAGEDOWN))
1169                     c = K_IGNORE;
1170             }
1171         } while ((had_got_int && c == Ctrl_C)
1172                                 || c == K_IGNORE
1173 #ifdef FEAT_GUI
1174                                 || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR
1175 #endif
1176 #ifdef FEAT_MOUSE
1177                                 || c == K_LEFTDRAG   || c == K_LEFTRELEASE
1178                                 || c == K_MIDDLEDRAG || c == K_MIDDLERELEASE
1179                                 || c == K_RIGHTDRAG  || c == K_RIGHTRELEASE
1180                                 || c == K_MOUSELEFT  || c == K_MOUSERIGHT
1181                                 || c == K_MOUSEDOWN  || c == K_MOUSEUP
1182                                 || (!mouse_has(MOUSE_RETURN)
1183                                     && mouse_row < msg_row
1184                                     && (c == K_LEFTMOUSE
1185                                         || c == K_MIDDLEMOUSE
1186                                         || c == K_RIGHTMOUSE
1187                                         || c == K_X1MOUSE
1188                                         || c == K_X2MOUSE))
1189 #endif
1190                                 );
1191         ui_breakcheck();
1192 #ifdef FEAT_MOUSE
1193         /*
1194          * Avoid that the mouse-up event causes visual mode to start.
1195          */
1196         if (c == K_LEFTMOUSE || c == K_MIDDLEMOUSE || c == K_RIGHTMOUSE
1197                                           || c == K_X1MOUSE || c == K_X2MOUSE)
1198             (void)jump_to_mouse(MOUSE_SETPOS, NULL, 0);
1199         else
1200 #endif
1201             if (vim_strchr((char_u *)"\r\n ", c) == NULL && c != Ctrl_C)
1202         {
1203             /* Put the character back in the typeahead buffer.  Don't use the
1204              * stuff buffer, because lmaps wouldn't work. */
1205             ins_char_typebuf(c);
1206             do_redraw = TRUE;       /* need a redraw even though there is
1207                                        typeahead */
1208         }
1209     }
1210     redir_off = FALSE;
1211
1212     /*
1213      * If the user hits ':', '?' or '/' we get a command line from the next
1214      * line.
1215      */
1216     if (c == ':' || c == '?' || c == '/')
1217     {
1218         if (!exmode_active)
1219             cmdline_row = msg_row;
1220         skip_redraw = TRUE;         /* skip redraw once */
1221         do_redraw = FALSE;
1222     }
1223
1224     /*
1225      * If the window size changed set_shellsize() will redraw the screen.
1226      * Otherwise the screen is only redrawn if 'redraw' is set and no ':'
1227      * typed.
1228      */
1229     tmpState = State;
1230     State = oldState;               /* restore State before set_shellsize */
1231 #ifdef FEAT_MOUSE
1232     setmouse();
1233 #endif
1234     msg_check();
1235
1236 #if defined(UNIX) || defined(VMS)
1237     /*
1238      * When switching screens, we need to output an extra newline on exit.
1239      */
1240     if (swapping_screen() && !termcap_active)
1241         newline_on_exit = TRUE;
1242 #endif
1243
1244     need_wait_return = FALSE;
1245     did_wait_return = TRUE;
1246     emsg_on_display = FALSE;    /* can delete error message now */
1247     lines_left = -1;            /* reset lines_left at next msg_start() */
1248     reset_last_sourcing();
1249     if (keep_msg != NULL && vim_strsize(keep_msg) >=
1250                                   (Rows - cmdline_row - 1) * Columns + sc_col)
1251     {
1252         vim_free(keep_msg);
1253         keep_msg = NULL;            /* don't redisplay message, it's too long */
1254     }
1255
1256     if (tmpState == SETWSIZE)       /* got resize event while in vgetc() */
1257     {
1258         starttermcap();             /* start termcap before redrawing */
1259         shell_resized();
1260     }
1261     else if (!skip_redraw
1262             && (redraw == TRUE || (msg_scrolled != 0 && redraw != -1)))
1263     {
1264         starttermcap();             /* start termcap before redrawing */
1265         redraw_later(VALID);
1266     }
1267 }
1268
1269 /*
1270  * Write the hit-return prompt.
1271  */
1272     static void
1273 hit_return_msg(void)
1274 {
1275     int         save_p_more = p_more;
1276
1277     p_more = FALSE;     /* don't want see this message when scrolling back */
1278     if (msg_didout)     /* start on a new line */
1279         msg_putchar('\n');
1280     if (got_int)
1281         MSG_PUTS(_("Interrupt: "));
1282
1283     MSG_PUTS_ATTR(_("Press ENTER or type command to continue"), HL_ATTR(HLF_R));
1284     if (!msg_use_printf())
1285         msg_clr_eos();
1286     p_more = save_p_more;
1287 }
1288
1289 /*
1290  * Set "keep_msg" to "s".  Free the old value and check for NULL pointer.
1291  */
1292     void
1293 set_keep_msg(char_u *s, int attr)
1294 {
1295     vim_free(keep_msg);
1296     if (s != NULL && msg_silent == 0)
1297         keep_msg = vim_strsave(s);
1298     else
1299         keep_msg = NULL;
1300     keep_msg_more = FALSE;
1301     keep_msg_attr = attr;
1302 }
1303
1304 #if defined(FEAT_TERMRESPONSE) || defined(PROTO)
1305 /*
1306  * If there currently is a message being displayed, set "keep_msg" to it, so
1307  * that it will be displayed again after redraw.
1308  */
1309     void
1310 set_keep_msg_from_hist(void)
1311 {
1312     if (keep_msg == NULL && last_msg_hist != NULL && msg_scrolled == 0
1313                                                           && (State & NORMAL))
1314         set_keep_msg(last_msg_hist->msg, last_msg_hist->attr);
1315 }
1316 #endif
1317
1318 /*
1319  * Prepare for outputting characters in the command line.
1320  */
1321     void
1322 msg_start(void)
1323 {
1324     int         did_return = FALSE;
1325
1326     if (!msg_silent)
1327     {
1328         vim_free(keep_msg);
1329         keep_msg = NULL;                /* don't display old message now */
1330     }
1331
1332 #ifdef FEAT_EVAL
1333     if (need_clr_eos)
1334     {
1335         /* Halfway an ":echo" command and getting an (error) message: clear
1336          * any text from the command. */
1337         need_clr_eos = FALSE;
1338         msg_clr_eos();
1339     }
1340 #endif
1341
1342     if (!msg_scroll && full_screen)     /* overwrite last message */
1343     {
1344         msg_row = cmdline_row;
1345         msg_col =
1346 #ifdef FEAT_RIGHTLEFT
1347             cmdmsg_rl ? Columns - 1 :
1348 #endif
1349             0;
1350     }
1351     else if (msg_didout)                    /* start message on next line */
1352     {
1353         msg_putchar('\n');
1354         did_return = TRUE;
1355         if (exmode_active != EXMODE_NORMAL)
1356             cmdline_row = msg_row;
1357     }
1358     if (!msg_didany || lines_left < 0)
1359         msg_starthere();
1360     if (msg_silent == 0)
1361     {
1362         msg_didout = FALSE;                 /* no output on current line yet */
1363         cursor_off();
1364     }
1365
1366     /* when redirecting, may need to start a new line. */
1367     if (!did_return)
1368         redir_write((char_u *)"\n", -1);
1369 }
1370
1371 /*
1372  * Note that the current msg position is where messages start.
1373  */
1374     void
1375 msg_starthere(void)
1376 {
1377     lines_left = cmdline_row;
1378     msg_didany = FALSE;
1379 }
1380
1381     void
1382 msg_putchar(int c)
1383 {
1384     msg_putchar_attr(c, 0);
1385 }
1386
1387     void
1388 msg_putchar_attr(int c, int attr)
1389 {
1390 #ifdef FEAT_MBYTE
1391     char_u      buf[MB_MAXBYTES + 1];
1392 #else
1393     char_u      buf[4];
1394 #endif
1395
1396     if (IS_SPECIAL(c))
1397     {
1398         buf[0] = K_SPECIAL;
1399         buf[1] = K_SECOND(c);
1400         buf[2] = K_THIRD(c);
1401         buf[3] = NUL;
1402     }
1403     else
1404     {
1405 #ifdef FEAT_MBYTE
1406         buf[(*mb_char2bytes)(c, buf)] = NUL;
1407 #else
1408         buf[0] = c;
1409         buf[1] = NUL;
1410 #endif
1411     }
1412     msg_puts_attr(buf, attr);
1413 }
1414
1415     void
1416 msg_outnum(long n)
1417 {
1418     char_u      buf[20];
1419
1420     sprintf((char *)buf, "%ld", n);
1421     msg_puts(buf);
1422 }
1423
1424     void
1425 msg_home_replace(char_u *fname)
1426 {
1427     msg_home_replace_attr(fname, 0);
1428 }
1429
1430 #if defined(FEAT_FIND_ID) || defined(PROTO)
1431     void
1432 msg_home_replace_hl(char_u *fname)
1433 {
1434     msg_home_replace_attr(fname, HL_ATTR(HLF_D));
1435 }
1436 #endif
1437
1438     static void
1439 msg_home_replace_attr(char_u *fname, int attr)
1440 {
1441     char_u      *name;
1442
1443     name = home_replace_save(NULL, fname);
1444     if (name != NULL)
1445         msg_outtrans_attr(name, attr);
1446     vim_free(name);
1447 }
1448
1449 /*
1450  * Output 'len' characters in 'str' (including NULs) with translation
1451  * if 'len' is -1, output upto a NUL character.
1452  * Use attributes 'attr'.
1453  * Return the number of characters it takes on the screen.
1454  */
1455     int
1456 msg_outtrans(char_u *str)
1457 {
1458     return msg_outtrans_attr(str, 0);
1459 }
1460
1461     int
1462 msg_outtrans_attr(char_u *str, int attr)
1463 {
1464     return msg_outtrans_len_attr(str, (int)STRLEN(str), attr);
1465 }
1466
1467     int
1468 msg_outtrans_len(char_u *str, int len)
1469 {
1470     return msg_outtrans_len_attr(str, len, 0);
1471 }
1472
1473 /*
1474  * Output one character at "p".  Return pointer to the next character.
1475  * Handles multi-byte characters.
1476  */
1477     char_u *
1478 msg_outtrans_one(char_u *p, int attr)
1479 {
1480 #ifdef FEAT_MBYTE
1481     int         l;
1482
1483     if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
1484     {
1485         msg_outtrans_len_attr(p, l, attr);
1486         return p + l;
1487     }
1488 #endif
1489     msg_puts_attr(transchar_byte(*p), attr);
1490     return p + 1;
1491 }
1492
1493     int
1494 msg_outtrans_len_attr(char_u *msgstr, int len, int attr)
1495 {
1496     int         retval = 0;
1497     char_u      *str = msgstr;
1498     char_u      *plain_start = msgstr;
1499     char_u      *s;
1500 #ifdef FEAT_MBYTE
1501     int         mb_l;
1502     int         c;
1503 #endif
1504
1505     /* if MSG_HIST flag set, add message to history */
1506     if (attr & MSG_HIST)
1507     {
1508         add_msg_hist(str, len, attr);
1509         attr &= ~MSG_HIST;
1510     }
1511
1512 #ifdef FEAT_MBYTE
1513     /* If the string starts with a composing character first draw a space on
1514      * which the composing char can be drawn. */
1515     if (enc_utf8 && utf_iscomposing(utf_ptr2char(msgstr)))
1516         msg_puts_attr((char_u *)" ", attr);
1517 #endif
1518
1519     /*
1520      * Go over the string.  Special characters are translated and printed.
1521      * Normal characters are printed several at a time.
1522      */
1523     while (--len >= 0)
1524     {
1525 #ifdef FEAT_MBYTE
1526         if (enc_utf8)
1527             /* Don't include composing chars after the end. */
1528             mb_l = utfc_ptr2len_len(str, len + 1);
1529         else if (has_mbyte)
1530             mb_l = (*mb_ptr2len)(str);
1531         else
1532             mb_l = 1;
1533         if (has_mbyte && mb_l > 1)
1534         {
1535             c = (*mb_ptr2char)(str);
1536             if (vim_isprintc(c))
1537                 /* printable multi-byte char: count the cells. */
1538                 retval += (*mb_ptr2cells)(str);
1539             else
1540             {
1541                 /* unprintable multi-byte char: print the printable chars so
1542                  * far and the translation of the unprintable char. */
1543                 if (str > plain_start)
1544                     msg_puts_attr_len(plain_start, (int)(str - plain_start),
1545                                                                         attr);
1546                 plain_start = str + mb_l;
1547                 msg_puts_attr(transchar(c), attr == 0 ? HL_ATTR(HLF_8) : attr);
1548                 retval += char2cells(c);
1549             }
1550             len -= mb_l - 1;
1551             str += mb_l;
1552         }
1553         else
1554 #endif
1555         {
1556             s = transchar_byte(*str);
1557             if (s[1] != NUL)
1558             {
1559                 /* unprintable char: print the printable chars so far and the
1560                  * translation of the unprintable char. */
1561                 if (str > plain_start)
1562                     msg_puts_attr_len(plain_start, (int)(str - plain_start),
1563                                                                         attr);
1564                 plain_start = str + 1;
1565                 msg_puts_attr(s, attr == 0 ? HL_ATTR(HLF_8) : attr);
1566                 retval += (int)STRLEN(s);
1567             }
1568             else
1569                 ++retval;
1570             ++str;
1571         }
1572     }
1573
1574     if (str > plain_start)
1575         /* print the printable chars at the end */
1576         msg_puts_attr_len(plain_start, (int)(str - plain_start), attr);
1577
1578     return retval;
1579 }
1580
1581 #if defined(FEAT_QUICKFIX) || defined(PROTO)
1582     void
1583 msg_make(char_u *arg)
1584 {
1585     int     i;
1586     static char_u *str = (char_u *)"eeffoc", *rs = (char_u *)"Plon#dqg#vxjduB";
1587
1588     arg = skipwhite(arg);
1589     for (i = 5; *arg && i >= 0; --i)
1590         if (*arg++ != str[i])
1591             break;
1592     if (i < 0)
1593     {
1594         msg_putchar('\n');
1595         for (i = 0; rs[i]; ++i)
1596             msg_putchar(rs[i] - 3);
1597     }
1598 }
1599 #endif
1600
1601 /*
1602  * Output the string 'str' upto a NUL character.
1603  * Return the number of characters it takes on the screen.
1604  *
1605  * If K_SPECIAL is encountered, then it is taken in conjunction with the
1606  * following character and shown as <F1>, <S-Up> etc.  Any other character
1607  * which is not printable shown in <> form.
1608  * If 'from' is TRUE (lhs of a mapping), a space is shown as <Space>.
1609  * If a character is displayed in one of these special ways, is also
1610  * highlighted (its highlight name is '8' in the p_hl variable).
1611  * Otherwise characters are not highlighted.
1612  * This function is used to show mappings, where we want to see how to type
1613  * the character/string -- webb
1614  */
1615     int
1616 msg_outtrans_special(
1617     char_u      *strstart,
1618     int         from)   /* TRUE for lhs of a mapping */
1619 {
1620     char_u      *str = strstart;
1621     int         retval = 0;
1622     char_u      *string;
1623     int         attr;
1624     int         len;
1625
1626     attr = HL_ATTR(HLF_8);
1627     while (*str != NUL)
1628     {
1629         /* Leading and trailing spaces need to be displayed in <> form. */
1630         if ((str == strstart || str[1] == NUL) && *str == ' ')
1631         {
1632             string = (char_u *)"<Space>";
1633             ++str;
1634         }
1635         else
1636             string = str2special(&str, from);
1637         len = vim_strsize(string);
1638         /* Highlight special keys */
1639         msg_puts_attr(string, len > 1
1640 #ifdef FEAT_MBYTE
1641                 && (*mb_ptr2len)(string) <= 1
1642 #endif
1643                 ? attr : 0);
1644         retval += len;
1645     }
1646     return retval;
1647 }
1648
1649 #if defined(FEAT_EVAL) || defined(PROTO)
1650 /*
1651  * Return the lhs or rhs of a mapping, with the key codes turned into printable
1652  * strings, in an allocated string.
1653  */
1654     char_u *
1655 str2special_save(
1656     char_u  *str,
1657     int     is_lhs)  /* TRUE for lhs, FALSE for rhs */
1658 {
1659     garray_T    ga;
1660     char_u      *p = str;
1661
1662     ga_init2(&ga, 1, 40);
1663     while (*p != NUL)
1664         ga_concat(&ga, str2special(&p, is_lhs));
1665     ga_append(&ga, NUL);
1666     return (char_u *)ga.ga_data;
1667 }
1668 #endif
1669
1670 /*
1671  * Return the printable string for the key codes at "*sp".
1672  * Used for translating the lhs or rhs of a mapping to printable chars.
1673  * Advances "sp" to the next code.
1674  */
1675     char_u *
1676 str2special(
1677     char_u      **sp,
1678     int         from)   /* TRUE for lhs of mapping */
1679 {
1680     int                 c;
1681     static char_u       buf[7];
1682     char_u              *str = *sp;
1683     int                 modifiers = 0;
1684     int                 special = FALSE;
1685
1686 #ifdef FEAT_MBYTE
1687     if (has_mbyte)
1688     {
1689         char_u  *p;
1690
1691         /* Try to un-escape a multi-byte character.  Return the un-escaped
1692          * string if it is a multi-byte character. */
1693         p = mb_unescape(sp);
1694         if (p != NULL)
1695             return p;
1696     }
1697 #endif
1698
1699     c = *str;
1700     if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL)
1701     {
1702         if (str[1] == KS_MODIFIER)
1703         {
1704             modifiers = str[2];
1705             str += 3;
1706             c = *str;
1707         }
1708         if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL)
1709         {
1710             c = TO_SPECIAL(str[1], str[2]);
1711             str += 2;
1712             if (c == KS_ZERO)   /* display <Nul> as ^@ or <Nul> */
1713                 c = NUL;
1714         }
1715         if (IS_SPECIAL(c) || modifiers) /* special key */
1716             special = TRUE;
1717     }
1718
1719 #ifdef FEAT_MBYTE
1720     if (has_mbyte && !IS_SPECIAL(c))
1721     {
1722         int len = (*mb_ptr2len)(str);
1723
1724         /* For multi-byte characters check for an illegal byte. */
1725         if (has_mbyte && MB_BYTE2LEN(*str) > len)
1726         {
1727             transchar_nonprint(buf, c);
1728             *sp = str + 1;
1729             return buf;
1730         }
1731         /* Since 'special' is TRUE the multi-byte character 'c' will be
1732          * processed by get_special_key_name() */
1733         c = (*mb_ptr2char)(str);
1734         *sp = str + len;
1735     }
1736     else
1737 #endif
1738         *sp = str + 1;
1739
1740     /* Make unprintable characters in <> form, also <M-Space> and <Tab>.
1741      * Use <Space> only for lhs of a mapping. */
1742     if (special || char2cells(c) > 1 || (from && c == ' '))
1743         return get_special_key_name(c, modifiers);
1744     buf[0] = c;
1745     buf[1] = NUL;
1746     return buf;
1747 }
1748
1749 /*
1750  * Translate a key sequence into special key names.
1751  */
1752     void
1753 str2specialbuf(char_u *sp, char_u *buf, int len)
1754 {
1755     char_u      *s;
1756
1757     *buf = NUL;
1758     while (*sp)
1759     {
1760         s = str2special(&sp, FALSE);
1761         if ((int)(STRLEN(s) + STRLEN(buf)) < len)
1762             STRCAT(buf, s);
1763     }
1764 }
1765
1766 /*
1767  * print line for :print or :list command
1768  */
1769     void
1770 msg_prt_line(char_u *s, int list)
1771 {
1772     int         c;
1773     int         col = 0;
1774     int         n_extra = 0;
1775     int         c_extra = 0;
1776     char_u      *p_extra = NULL;            /* init to make SASC shut up */
1777     int         n;
1778     int         attr = 0;
1779     char_u      *trail = NULL;
1780 #ifdef FEAT_MBYTE
1781     int         l;
1782     char_u      buf[MB_MAXBYTES + 1];
1783 #endif
1784
1785     if (curwin->w_p_list)
1786         list = TRUE;
1787
1788     /* find start of trailing whitespace */
1789     if (list && lcs_trail)
1790     {
1791         trail = s + STRLEN(s);
1792         while (trail > s && VIM_ISWHITE(trail[-1]))
1793             --trail;
1794     }
1795
1796     /* output a space for an empty line, otherwise the line will be
1797      * overwritten */
1798     if (*s == NUL && !(list && lcs_eol != NUL))
1799         msg_putchar(' ');
1800
1801     while (!got_int)
1802     {
1803         if (n_extra > 0)
1804         {
1805             --n_extra;
1806             if (c_extra)
1807                 c = c_extra;
1808             else
1809                 c = *p_extra++;
1810         }
1811 #ifdef FEAT_MBYTE
1812         else if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1)
1813         {
1814             col += (*mb_ptr2cells)(s);
1815             if (lcs_nbsp != NUL && list
1816                     && (mb_ptr2char(s) == 160
1817                         || mb_ptr2char(s) == 0x202f))
1818             {
1819                 mb_char2bytes(lcs_nbsp, buf);
1820                 buf[(*mb_ptr2len)(buf)] = NUL;
1821             }
1822             else
1823             {
1824                 mch_memmove(buf, s, (size_t)l);
1825                 buf[l] = NUL;
1826             }
1827             msg_puts(buf);
1828             s += l;
1829             continue;
1830         }
1831 #endif
1832         else
1833         {
1834             attr = 0;
1835             c = *s++;
1836             if (c == TAB && (!list || lcs_tab1))
1837             {
1838                 /* tab amount depends on current column */
1839                 n_extra = curbuf->b_p_ts - col % curbuf->b_p_ts - 1;
1840                 if (!list)
1841                 {
1842                     c = ' ';
1843                     c_extra = ' ';
1844                 }
1845                 else
1846                 {
1847                     c = lcs_tab1;
1848                     c_extra = lcs_tab2;
1849                     attr = HL_ATTR(HLF_8);
1850                 }
1851             }
1852             else if (c == 160 && list && lcs_nbsp != NUL)
1853             {
1854                 c = lcs_nbsp;
1855                 attr = HL_ATTR(HLF_8);
1856             }
1857             else if (c == NUL && list && lcs_eol != NUL)
1858             {
1859                 p_extra = (char_u *)"";
1860                 c_extra = NUL;
1861                 n_extra = 1;
1862                 c = lcs_eol;
1863                 attr = HL_ATTR(HLF_AT);
1864                 --s;
1865             }
1866             else if (c != NUL && (n = byte2cells(c)) > 1)
1867             {
1868                 n_extra = n - 1;
1869                 p_extra = transchar_byte(c);
1870                 c_extra = NUL;
1871                 c = *p_extra++;
1872                 /* Use special coloring to be able to distinguish <hex> from
1873                  * the same in plain text. */
1874                 attr = HL_ATTR(HLF_8);
1875             }
1876             else if (c == ' ' && trail != NULL && s > trail)
1877             {
1878                 c = lcs_trail;
1879                 attr = HL_ATTR(HLF_8);
1880             }
1881             else if (c == ' ' && list && lcs_space != NUL)
1882             {
1883                 c = lcs_space;
1884                 attr = HL_ATTR(HLF_8);
1885             }
1886         }
1887
1888         if (c == NUL)
1889             break;
1890
1891         msg_putchar_attr(c, attr);
1892         col++;
1893     }
1894     msg_clr_eos();
1895 }
1896
1897 #ifdef FEAT_MBYTE
1898 /*
1899  * Use screen_puts() to output one multi-byte character.
1900  * Return the pointer "s" advanced to the next character.
1901  */
1902     static char_u *
1903 screen_puts_mbyte(char_u *s, int l, int attr)
1904 {
1905     int         cw;
1906
1907     msg_didout = TRUE;          /* remember that line is not empty */
1908     cw = (*mb_ptr2cells)(s);
1909     if (cw > 1 && (
1910 #ifdef FEAT_RIGHTLEFT
1911                 cmdmsg_rl ? msg_col <= 1 :
1912 #endif
1913                 msg_col == Columns - 1))
1914     {
1915         /* Doesn't fit, print a highlighted '>' to fill it up. */
1916         msg_screen_putchar('>', HL_ATTR(HLF_AT));
1917         return s;
1918     }
1919
1920     screen_puts_len(s, l, msg_row, msg_col, attr);
1921 #ifdef FEAT_RIGHTLEFT
1922     if (cmdmsg_rl)
1923     {
1924         msg_col -= cw;
1925         if (msg_col == 0)
1926         {
1927             msg_col = Columns;
1928             ++msg_row;
1929         }
1930     }
1931     else
1932 #endif
1933     {
1934         msg_col += cw;
1935         if (msg_col >= Columns)
1936         {
1937             msg_col = 0;
1938             ++msg_row;
1939         }
1940     }
1941     return s + l;
1942 }
1943 #endif
1944
1945 /*
1946  * Output a string to the screen at position msg_row, msg_col.
1947  * Update msg_row and msg_col for the next message.
1948  */
1949     void
1950 msg_puts(char_u *s)
1951 {
1952     msg_puts_attr(s, 0);
1953 }
1954
1955     void
1956 msg_puts_title(
1957     char_u      *s)
1958 {
1959     msg_puts_attr(s, HL_ATTR(HLF_T));
1960 }
1961
1962 /*
1963  * Show a message in such a way that it always fits in the line.  Cut out a
1964  * part in the middle and replace it with "..." when necessary.
1965  * Does not handle multi-byte characters!
1966  */
1967     void
1968 msg_puts_long_attr(char_u *longstr, int attr)
1969 {
1970     msg_puts_long_len_attr(longstr, (int)STRLEN(longstr), attr);
1971 }
1972
1973     void
1974 msg_puts_long_len_attr(char_u *longstr, int len, int attr)
1975 {
1976     int         slen = len;
1977     int         room;
1978
1979     room = Columns - msg_col;
1980     if (len > room && room >= 20)
1981     {
1982         slen = (room - 3) / 2;
1983         msg_outtrans_len_attr(longstr, slen, attr);
1984         msg_puts_attr((char_u *)"...", HL_ATTR(HLF_8));
1985     }
1986     msg_outtrans_len_attr(longstr + len - slen, slen, attr);
1987 }
1988
1989 /*
1990  * Basic function for writing a message with highlight attributes.
1991  */
1992     void
1993 msg_puts_attr(char_u *s, int attr)
1994 {
1995     msg_puts_attr_len(s, -1, attr);
1996 }
1997
1998 /*
1999  * Like msg_puts_attr(), but with a maximum length "maxlen" (in bytes).
2000  * When "maxlen" is -1 there is no maximum length.
2001  * When "maxlen" is >= 0 the message is not put in the history.
2002  */
2003     static void
2004 msg_puts_attr_len(char_u *str, int maxlen, int attr)
2005 {
2006     /*
2007      * If redirection is on, also write to the redirection file.
2008      */
2009     redir_write(str, maxlen);
2010
2011     /*
2012      * Don't print anything when using ":silent cmd".
2013      */
2014     if (msg_silent != 0)
2015         return;
2016
2017     /* if MSG_HIST flag set, add message to history */
2018     if ((attr & MSG_HIST) && maxlen < 0)
2019     {
2020         add_msg_hist(str, -1, attr);
2021         attr &= ~MSG_HIST;
2022     }
2023
2024     /*
2025      * When writing something to the screen after it has scrolled, requires a
2026      * wait-return prompt later.  Needed when scrolling, resetting
2027      * need_wait_return after some prompt, and then outputting something
2028      * without scrolling
2029      */
2030     if (msg_scrolled != 0 && !msg_scrolled_ign)
2031         need_wait_return = TRUE;
2032     msg_didany = TRUE;          /* remember that something was outputted */
2033
2034     /*
2035      * If there is no valid screen, use fprintf so we can see error messages.
2036      * If termcap is not active, we may be writing in an alternate console
2037      * window, cursor positioning may not work correctly (window size may be
2038      * different, e.g. for Win32 console) or we just don't know where the
2039      * cursor is.
2040      */
2041     if (msg_use_printf())
2042         msg_puts_printf(str, maxlen);
2043     else
2044         msg_puts_display(str, maxlen, attr, FALSE);
2045 }
2046
2047 /*
2048  * The display part of msg_puts_attr_len().
2049  * May be called recursively to display scroll-back text.
2050  */
2051     static void
2052 msg_puts_display(
2053     char_u      *str,
2054     int         maxlen,
2055     int         attr,
2056     int         recurse)
2057 {
2058     char_u      *s = str;
2059     char_u      *t_s = str;     /* string from "t_s" to "s" is still todo */
2060     int         t_col = 0;      /* screen cells todo, 0 when "t_s" not used */
2061 #ifdef FEAT_MBYTE
2062     int         l;
2063     int         cw;
2064 #endif
2065     char_u      *sb_str = str;
2066     int         sb_col = msg_col;
2067     int         wrap;
2068     int         did_last_char;
2069
2070     did_wait_return = FALSE;
2071     while ((maxlen < 0 || (int)(s - str) < maxlen) && *s != NUL)
2072     {
2073         /*
2074          * We are at the end of the screen line when:
2075          * - When outputting a newline.
2076          * - When outputting a character in the last column.
2077          */
2078         if (!recurse && msg_row >= Rows - 1 && (*s == '\n' || (
2079 #ifdef FEAT_RIGHTLEFT
2080                     cmdmsg_rl
2081                     ? (
2082                         msg_col <= 1
2083                         || (*s == TAB && msg_col <= 7)
2084 # ifdef FEAT_MBYTE
2085                         || (has_mbyte && (*mb_ptr2cells)(s) > 1 && msg_col <= 2)
2086 # endif
2087                       )
2088                     :
2089 #endif
2090                       (msg_col + t_col >= Columns - 1
2091                        || (*s == TAB && msg_col + t_col >= ((Columns - 1) & ~7))
2092 # ifdef FEAT_MBYTE
2093                        || (has_mbyte && (*mb_ptr2cells)(s) > 1
2094                                             && msg_col + t_col >= Columns - 2)
2095 # endif
2096                       ))))
2097         {
2098             /*
2099              * The screen is scrolled up when at the last row (some terminals
2100              * scroll automatically, some don't.  To avoid problems we scroll
2101              * ourselves).
2102              */
2103             if (t_col > 0)
2104                 /* output postponed text */
2105                 t_puts(&t_col, t_s, s, attr);
2106
2107             /* When no more prompt and no more room, truncate here */
2108             if (msg_no_more && lines_left == 0)
2109                 break;
2110
2111             /* Scroll the screen up one line. */
2112             msg_scroll_up();
2113
2114             msg_row = Rows - 2;
2115             if (msg_col >= Columns)     /* can happen after screen resize */
2116                 msg_col = Columns - 1;
2117
2118             /* Display char in last column before showing more-prompt. */
2119             if (*s >= ' '
2120 #ifdef FEAT_RIGHTLEFT
2121                     && !cmdmsg_rl
2122 #endif
2123                )
2124             {
2125 #ifdef FEAT_MBYTE
2126                 if (has_mbyte)
2127                 {
2128                     if (enc_utf8 && maxlen >= 0)
2129                         /* avoid including composing chars after the end */
2130                         l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
2131                     else
2132                         l = (*mb_ptr2len)(s);
2133                     s = screen_puts_mbyte(s, l, attr);
2134                 }
2135                 else
2136 #endif
2137                     msg_screen_putchar(*s++, attr);
2138                 did_last_char = TRUE;
2139             }
2140             else
2141                 did_last_char = FALSE;
2142
2143             if (p_more)
2144                 /* store text for scrolling back */
2145                 store_sb_text(&sb_str, s, attr, &sb_col, TRUE);
2146
2147             inc_msg_scrolled();
2148             need_wait_return = TRUE; /* may need wait_return in main() */
2149             redraw_cmdline = TRUE;
2150             if (cmdline_row > 0 && !exmode_active)
2151                 --cmdline_row;
2152
2153             /*
2154              * If screen is completely filled and 'more' is set then wait
2155              * for a character.
2156              */
2157             if (lines_left > 0)
2158                 --lines_left;
2159             if (p_more && lines_left == 0 && State != HITRETURN
2160                                             && !msg_no_more && !exmode_active)
2161             {
2162 #ifdef FEAT_CON_DIALOG
2163                 if (do_more_prompt(NUL))
2164                     s = confirm_msg_tail;
2165 #else
2166                 (void)do_more_prompt(NUL);
2167 #endif
2168                 if (quit_more)
2169                     return;
2170             }
2171
2172             /* When we displayed a char in last column need to check if there
2173              * is still more. */
2174             if (did_last_char)
2175                 continue;
2176         }
2177
2178         wrap = *s == '\n'
2179                     || msg_col + t_col >= Columns
2180 #ifdef FEAT_MBYTE
2181                     || (has_mbyte && (*mb_ptr2cells)(s) > 1
2182                                             && msg_col + t_col >= Columns - 1)
2183 #endif
2184                     ;
2185         if (t_col > 0 && (wrap || *s == '\r' || *s == '\b'
2186                                                  || *s == '\t' || *s == BELL))
2187             /* output any postponed text */
2188             t_puts(&t_col, t_s, s, attr);
2189
2190         if (wrap && p_more && !recurse)
2191             /* store text for scrolling back */
2192             store_sb_text(&sb_str, s, attr, &sb_col, TRUE);
2193
2194         if (*s == '\n')             /* go to next line */
2195         {
2196             msg_didout = FALSE;     /* remember that line is empty */
2197 #ifdef FEAT_RIGHTLEFT
2198             if (cmdmsg_rl)
2199                 msg_col = Columns - 1;
2200             else
2201 #endif
2202                 msg_col = 0;
2203             if (++msg_row >= Rows)  /* safety check */
2204                 msg_row = Rows - 1;
2205         }
2206         else if (*s == '\r')        /* go to column 0 */
2207         {
2208             msg_col = 0;
2209         }
2210         else if (*s == '\b')        /* go to previous char */
2211         {
2212             if (msg_col)
2213                 --msg_col;
2214         }
2215         else if (*s == TAB)         /* translate Tab into spaces */
2216         {
2217             do
2218                 msg_screen_putchar(' ', attr);
2219             while (msg_col & 7);
2220         }
2221         else if (*s == BELL)            /* beep (from ":sh") */
2222             vim_beep(BO_SH);
2223         else
2224         {
2225 #ifdef FEAT_MBYTE
2226             if (has_mbyte)
2227             {
2228                 cw = (*mb_ptr2cells)(s);
2229                 if (enc_utf8 && maxlen >= 0)
2230                     /* avoid including composing chars after the end */
2231                     l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
2232                 else
2233                     l = (*mb_ptr2len)(s);
2234             }
2235             else
2236             {
2237                 cw = 1;
2238                 l = 1;
2239             }
2240 #endif
2241             /* When drawing from right to left or when a double-wide character
2242              * doesn't fit, draw a single character here.  Otherwise collect
2243              * characters and draw them all at once later. */
2244 #if defined(FEAT_RIGHTLEFT) || defined(FEAT_MBYTE)
2245             if (
2246 # ifdef FEAT_RIGHTLEFT
2247                     cmdmsg_rl
2248 #  ifdef FEAT_MBYTE
2249                     ||
2250 #  endif
2251 # endif
2252 # ifdef FEAT_MBYTE
2253                     (cw > 1 && msg_col + t_col >= Columns - 1)
2254 # endif
2255                     )
2256             {
2257 # ifdef FEAT_MBYTE
2258                 if (l > 1)
2259                     s = screen_puts_mbyte(s, l, attr) - 1;
2260                 else
2261 # endif
2262                     msg_screen_putchar(*s, attr);
2263             }
2264             else
2265 #endif
2266             {
2267                 /* postpone this character until later */
2268                 if (t_col == 0)
2269                     t_s = s;
2270 #ifdef FEAT_MBYTE
2271                 t_col += cw;
2272                 s += l - 1;
2273 #else
2274                 ++t_col;
2275 #endif
2276             }
2277         }
2278         ++s;
2279     }
2280
2281     /* output any postponed text */
2282     if (t_col > 0)
2283         t_puts(&t_col, t_s, s, attr);
2284     if (p_more && !recurse)
2285         store_sb_text(&sb_str, s, attr, &sb_col, FALSE);
2286
2287     msg_check();
2288 }
2289
2290 /*
2291  * Return TRUE when ":filter pattern" was used and "msg" does not match
2292  * "pattern".
2293  */
2294     int
2295 message_filtered(char_u *msg)
2296 {
2297     int match;
2298
2299     if (cmdmod.filter_regmatch.regprog == NULL)
2300         return FALSE;
2301     match = vim_regexec(&cmdmod.filter_regmatch, msg, (colnr_T)0);
2302     return cmdmod.filter_force ? match : !match;
2303 }
2304
2305 /*
2306  * Scroll the screen up one line for displaying the next message line.
2307  */
2308     static void
2309 msg_scroll_up(void)
2310 {
2311 #ifdef FEAT_GUI
2312     /* Remove the cursor before scrolling, ScreenLines[] is going
2313      * to become invalid. */
2314     if (gui.in_use)
2315         gui_undraw_cursor();
2316 #endif
2317     /* scrolling up always works */
2318     screen_del_lines(0, 0, 1, (int)Rows, TRUE, NULL);
2319
2320     if (!can_clear((char_u *)" "))
2321     {
2322         /* Scrolling up doesn't result in the right background.  Set the
2323          * background here.  It's not efficient, but avoids that we have to do
2324          * it all over the code. */
2325         screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
2326
2327         /* Also clear the last char of the last but one line if it was not
2328          * cleared before to avoid a scroll-up. */
2329         if (ScreenAttrs[LineOffset[Rows - 2] + Columns - 1] == (sattr_T)-1)
2330             screen_fill((int)Rows - 2, (int)Rows - 1,
2331                                  (int)Columns - 1, (int)Columns, ' ', ' ', 0);
2332     }
2333 }
2334
2335 /*
2336  * Increment "msg_scrolled".
2337  */
2338     static void
2339 inc_msg_scrolled(void)
2340 {
2341 #ifdef FEAT_EVAL
2342     if (*get_vim_var_str(VV_SCROLLSTART) == NUL)
2343     {
2344         char_u      *p = sourcing_name;
2345         char_u      *tofree = NULL;
2346         int         len;
2347
2348         /* v:scrollstart is empty, set it to the script/function name and line
2349          * number */
2350         if (p == NULL)
2351             p = (char_u *)_("Unknown");
2352         else
2353         {
2354             len = (int)STRLEN(p) + 40;
2355             tofree = alloc(len);
2356             if (tofree != NULL)
2357             {
2358                 vim_snprintf((char *)tofree, len, _("%s line %ld"),
2359                                                       p, (long)sourcing_lnum);
2360                 p = tofree;
2361             }
2362         }
2363         set_vim_var_string(VV_SCROLLSTART, p, -1);
2364         vim_free(tofree);
2365     }
2366 #endif
2367     ++msg_scrolled;
2368     if (must_redraw < VALID)
2369         must_redraw = VALID;
2370 }
2371
2372 /*
2373  * To be able to scroll back at the "more" and "hit-enter" prompts we need to
2374  * store the displayed text and remember where screen lines start.
2375  */
2376 typedef struct msgchunk_S msgchunk_T;
2377 struct msgchunk_S
2378 {
2379     msgchunk_T  *sb_next;
2380     msgchunk_T  *sb_prev;
2381     char        sb_eol;         /* TRUE when line ends after this text */
2382     int         sb_msg_col;     /* column in which text starts */
2383     int         sb_attr;        /* text attributes */
2384     char_u      sb_text[1];     /* text to be displayed, actually longer */
2385 };
2386
2387 static msgchunk_T *last_msgchunk = NULL; /* last displayed text */
2388
2389 static msgchunk_T *msg_sb_start(msgchunk_T *mps);
2390 static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp);
2391
2392 typedef enum {
2393     SB_CLEAR_NONE = 0,
2394     SB_CLEAR_ALL,
2395     SB_CLEAR_CMDLINE_BUSY,
2396     SB_CLEAR_CMDLINE_DONE
2397 } sb_clear_T;
2398
2399 /* When to clear text on next msg. */
2400 static sb_clear_T do_clear_sb_text = SB_CLEAR_NONE;
2401
2402 /*
2403  * Store part of a printed message for displaying when scrolling back.
2404  */
2405     static void
2406 store_sb_text(
2407     char_u      **sb_str,       /* start of string */
2408     char_u      *s,             /* just after string */
2409     int         attr,
2410     int         *sb_col,
2411     int         finish)         /* line ends */
2412 {
2413     msgchunk_T  *mp;
2414
2415     if (do_clear_sb_text == SB_CLEAR_ALL
2416             || do_clear_sb_text == SB_CLEAR_CMDLINE_DONE)
2417     {
2418         clear_sb_text(do_clear_sb_text == SB_CLEAR_ALL);
2419         do_clear_sb_text = SB_CLEAR_NONE;
2420     }
2421
2422     if (s > *sb_str)
2423     {
2424         mp = (msgchunk_T *)alloc((int)(sizeof(msgchunk_T) + (s - *sb_str)));
2425         if (mp != NULL)
2426         {
2427             mp->sb_eol = finish;
2428             mp->sb_msg_col = *sb_col;
2429             mp->sb_attr = attr;
2430             vim_strncpy(mp->sb_text, *sb_str, s - *sb_str);
2431
2432             if (last_msgchunk == NULL)
2433             {
2434                 last_msgchunk = mp;
2435                 mp->sb_prev = NULL;
2436             }
2437             else
2438             {
2439                 mp->sb_prev = last_msgchunk;
2440                 last_msgchunk->sb_next = mp;
2441                 last_msgchunk = mp;
2442             }
2443             mp->sb_next = NULL;
2444         }
2445     }
2446     else if (finish && last_msgchunk != NULL)
2447         last_msgchunk->sb_eol = TRUE;
2448
2449     *sb_str = s;
2450     *sb_col = 0;
2451 }
2452
2453 /*
2454  * Finished showing messages, clear the scroll-back text on the next message.
2455  */
2456     void
2457 may_clear_sb_text(void)
2458 {
2459     do_clear_sb_text = SB_CLEAR_ALL;
2460 }
2461
2462 /*
2463  * Starting to edit the command line, do not clear messages now.
2464  */
2465     void
2466 sb_text_start_cmdline(void)
2467 {
2468     do_clear_sb_text = SB_CLEAR_CMDLINE_BUSY;
2469     msg_sb_eol();
2470 }
2471
2472 /*
2473  * Ending to edit the command line.  Clear old lines but the last one later.
2474  */
2475     void
2476 sb_text_end_cmdline(void)
2477 {
2478     do_clear_sb_text = SB_CLEAR_CMDLINE_DONE;
2479 }
2480
2481 /*
2482  * Clear any text remembered for scrolling back.
2483  * When "all" is FALSE keep the last line.
2484  * Called when redrawing the screen.
2485  */
2486     void
2487 clear_sb_text(int all)
2488 {
2489     msgchunk_T  *mp;
2490     msgchunk_T  **lastp;
2491
2492     if (all)
2493         lastp = &last_msgchunk;
2494     else
2495     {
2496         if (last_msgchunk == NULL)
2497             return;
2498         lastp = &last_msgchunk->sb_prev;
2499     }
2500
2501     while (*lastp != NULL)
2502     {
2503         mp = (*lastp)->sb_prev;
2504         vim_free(*lastp);
2505         *lastp = mp;
2506     }
2507 }
2508
2509 /*
2510  * "g<" command.
2511  */
2512     void
2513 show_sb_text(void)
2514 {
2515     msgchunk_T  *mp;
2516
2517     /* Only show something if there is more than one line, otherwise it looks
2518      * weird, typing a command without output results in one line. */
2519     mp = msg_sb_start(last_msgchunk);
2520     if (mp == NULL || mp->sb_prev == NULL)
2521         vim_beep(BO_MESS);
2522     else
2523     {
2524         do_more_prompt('G');
2525         wait_return(FALSE);
2526     }
2527 }
2528
2529 /*
2530  * Move to the start of screen line in already displayed text.
2531  */
2532     static msgchunk_T *
2533 msg_sb_start(msgchunk_T *mps)
2534 {
2535     msgchunk_T *mp = mps;
2536
2537     while (mp != NULL && mp->sb_prev != NULL && !mp->sb_prev->sb_eol)
2538         mp = mp->sb_prev;
2539     return mp;
2540 }
2541
2542 /*
2543  * Mark the last message chunk as finishing the line.
2544  */
2545     void
2546 msg_sb_eol(void)
2547 {
2548     if (last_msgchunk != NULL)
2549         last_msgchunk->sb_eol = TRUE;
2550 }
2551
2552 /*
2553  * Display a screen line from previously displayed text at row "row".
2554  * Returns a pointer to the text for the next line (can be NULL).
2555  */
2556     static msgchunk_T *
2557 disp_sb_line(int row, msgchunk_T *smp)
2558 {
2559     msgchunk_T  *mp = smp;
2560     char_u      *p;
2561
2562     for (;;)
2563     {
2564         msg_row = row;
2565         msg_col = mp->sb_msg_col;
2566         p = mp->sb_text;
2567         if (*p == '\n')     /* don't display the line break */
2568             ++p;
2569         msg_puts_display(p, -1, mp->sb_attr, TRUE);
2570         if (mp->sb_eol || mp->sb_next == NULL)
2571             break;
2572         mp = mp->sb_next;
2573     }
2574     return mp->sb_next;
2575 }
2576
2577 /*
2578  * Output any postponed text for msg_puts_attr_len().
2579  */
2580     static void
2581 t_puts(
2582     int         *t_col,
2583     char_u      *t_s,
2584     char_u      *s,
2585     int         attr)
2586 {
2587     /* output postponed text */
2588     msg_didout = TRUE;          /* remember that line is not empty */
2589     screen_puts_len(t_s, (int)(s - t_s), msg_row, msg_col, attr);
2590     msg_col += *t_col;
2591     *t_col = 0;
2592 #ifdef FEAT_MBYTE
2593     /* If the string starts with a composing character don't increment the
2594      * column position for it. */
2595     if (enc_utf8 && utf_iscomposing(utf_ptr2char(t_s)))
2596         --msg_col;
2597 #endif
2598     if (msg_col >= Columns)
2599     {
2600         msg_col = 0;
2601         ++msg_row;
2602     }
2603 }
2604
2605 /*
2606  * Returns TRUE when messages should be printed with mch_errmsg().
2607  * This is used when there is no valid screen, so we can see error messages.
2608  * If termcap is not active, we may be writing in an alternate console
2609  * window, cursor positioning may not work correctly (window size may be
2610  * different, e.g. for Win32 console) or we just don't know where the
2611  * cursor is.
2612  */
2613     int
2614 msg_use_printf(void)
2615 {
2616     return (!msg_check_screen()
2617 #if defined(WIN3264) && !defined(FEAT_GUI_MSWIN)
2618             || !termcap_active
2619 #endif
2620             || (swapping_screen() && !termcap_active)
2621                );
2622 }
2623
2624 /*
2625  * Print a message when there is no valid screen.
2626  */
2627     static void
2628 msg_puts_printf(char_u *str, int maxlen)
2629 {
2630     char_u      *s = str;
2631     char_u      buf[4];
2632     char_u      *p;
2633
2634 #ifdef WIN3264
2635     if (!(silent_mode && p_verbose == 0))
2636         mch_settmode(TMODE_COOK);       /* handle '\r' and '\n' correctly */
2637 #endif
2638     while ((maxlen < 0 || (int)(s - str) < maxlen) && *s != NUL)
2639     {
2640         if (!(silent_mode && p_verbose == 0))
2641         {
2642             /* NL --> CR NL translation (for Unix, not for "--version") */
2643             /* NL --> CR translation (for Mac) */
2644             p = &buf[0];
2645             if (*s == '\n' && !info_message)
2646                 *p++ = '\r';
2647 #if defined(USE_CR) && !defined(MACOS_X_UNIX)
2648             else
2649 #endif
2650                 *p++ = *s;
2651             *p = '\0';
2652             if (info_message)   /* informative message, not an error */
2653                 mch_msg((char *)buf);
2654             else
2655                 mch_errmsg((char *)buf);
2656         }
2657
2658         /* primitive way to compute the current column */
2659 #ifdef FEAT_RIGHTLEFT
2660         if (cmdmsg_rl)
2661         {
2662             if (*s == '\r' || *s == '\n')
2663                 msg_col = Columns - 1;
2664             else
2665                 --msg_col;
2666         }
2667         else
2668 #endif
2669         {
2670             if (*s == '\r' || *s == '\n')
2671                 msg_col = 0;
2672             else
2673                 ++msg_col;
2674         }
2675         ++s;
2676     }
2677     msg_didout = TRUE;      /* assume that line is not empty */
2678
2679 #ifdef WIN3264
2680     if (!(silent_mode && p_verbose == 0))
2681         mch_settmode(TMODE_RAW);
2682 #endif
2683 }
2684
2685 /*
2686  * Show the more-prompt and handle the user response.
2687  * This takes care of scrolling back and displaying previously displayed text.
2688  * When at hit-enter prompt "typed_char" is the already typed character,
2689  * otherwise it's NUL.
2690  * Returns TRUE when jumping ahead to "confirm_msg_tail".
2691  */
2692     static int
2693 do_more_prompt(int typed_char)
2694 {
2695     static int  entered = FALSE;
2696     int         used_typed_char = typed_char;
2697     int         oldState = State;
2698     int         c;
2699 #ifdef FEAT_CON_DIALOG
2700     int         retval = FALSE;
2701 #endif
2702     int         toscroll;
2703     msgchunk_T  *mp_last = NULL;
2704     msgchunk_T  *mp;
2705     int         i;
2706
2707     /* We get called recursively when a timer callback outputs a message. In
2708      * that case don't show another prompt. Also when at the hit-Enter prompt
2709      * and nothing was typed. */
2710     if (entered || (State == HITRETURN && typed_char == 0))
2711         return FALSE;
2712     entered = TRUE;
2713
2714     if (typed_char == 'G')
2715     {
2716         /* "g<": Find first line on the last page. */
2717         mp_last = msg_sb_start(last_msgchunk);
2718         for (i = 0; i < Rows - 2 && mp_last != NULL
2719                                              && mp_last->sb_prev != NULL; ++i)
2720             mp_last = msg_sb_start(mp_last->sb_prev);
2721     }
2722
2723     State = ASKMORE;
2724 #ifdef FEAT_MOUSE
2725     setmouse();
2726 #endif
2727     if (typed_char == NUL)
2728         msg_moremsg(FALSE);
2729     for (;;)
2730     {
2731         /*
2732          * Get a typed character directly from the user.
2733          */
2734         if (used_typed_char != NUL)
2735         {
2736             c = used_typed_char;        /* was typed at hit-enter prompt */
2737             used_typed_char = NUL;
2738         }
2739         else
2740             c = get_keystroke();
2741
2742 #if defined(FEAT_MENU) && defined(FEAT_GUI)
2743         if (c == K_MENU)
2744         {
2745             int idx = get_menu_index(current_menu, ASKMORE);
2746
2747             /* Used a menu.  If it starts with CTRL-Y, it must
2748              * be a "Copy" for the clipboard.  Otherwise
2749              * assume that we end */
2750             if (idx == MENU_INDEX_INVALID)
2751                 continue;
2752             c = *current_menu->strings[idx];
2753             if (c != NUL && current_menu->strings[idx][1] != NUL)
2754                 ins_typebuf(current_menu->strings[idx] + 1,
2755                                 current_menu->noremap[idx], 0, TRUE,
2756                                                    current_menu->silent[idx]);
2757         }
2758 #endif
2759
2760         toscroll = 0;
2761         switch (c)
2762         {
2763         case BS:                /* scroll one line back */
2764         case K_BS:
2765         case 'k':
2766         case K_UP:
2767             toscroll = -1;
2768             break;
2769
2770         case CAR:               /* one extra line */
2771         case NL:
2772         case 'j':
2773         case K_DOWN:
2774             toscroll = 1;
2775             break;
2776
2777         case 'u':               /* Up half a page */
2778             toscroll = -(Rows / 2);
2779             break;
2780
2781         case 'd':               /* Down half a page */
2782             toscroll = Rows / 2;
2783             break;
2784
2785         case 'b':               /* one page back */
2786         case K_PAGEUP:
2787             toscroll = -(Rows - 1);
2788             break;
2789
2790         case ' ':               /* one extra page */
2791         case 'f':
2792         case K_PAGEDOWN:
2793         case K_LEFTMOUSE:
2794             toscroll = Rows - 1;
2795             break;
2796
2797         case 'g':               /* all the way back to the start */
2798             toscroll = -999999;
2799             break;
2800
2801         case 'G':               /* all the way to the end */
2802             toscroll = 999999;
2803             lines_left = 999999;
2804             break;
2805
2806         case ':':               /* start new command line */
2807 #ifdef FEAT_CON_DIALOG
2808             if (!confirm_msg_used)
2809 #endif
2810             {
2811                 /* Since got_int is set all typeahead will be flushed, but we
2812                  * want to keep this ':', remember that in a special way. */
2813                 typeahead_noflush(':');
2814                 cmdline_row = Rows - 1;         /* put ':' on this line */
2815                 skip_redraw = TRUE;             /* skip redraw once */
2816                 need_wait_return = FALSE;       /* don't wait in main() */
2817             }
2818             /*FALLTHROUGH*/
2819         case 'q':               /* quit */
2820         case Ctrl_C:
2821         case ESC:
2822 #ifdef FEAT_CON_DIALOG
2823             if (confirm_msg_used)
2824             {
2825                 /* Jump to the choices of the dialog. */
2826                 retval = TRUE;
2827             }
2828             else
2829 #endif
2830             {
2831                 got_int = TRUE;
2832                 quit_more = TRUE;
2833             }
2834             /* When there is some more output (wrapping line) display that
2835              * without another prompt. */
2836             lines_left = Rows - 1;
2837             break;
2838
2839 #ifdef FEAT_CLIPBOARD
2840         case Ctrl_Y:
2841             /* Strange way to allow copying (yanking) a modeless
2842              * selection at the more prompt.  Use CTRL-Y,
2843              * because the same is used in Cmdline-mode and at the
2844              * hit-enter prompt.  However, scrolling one line up
2845              * might be expected... */
2846             if (clip_star.state == SELECT_DONE)
2847                 clip_copy_modeless_selection(TRUE);
2848             continue;
2849 #endif
2850         default:                /* no valid response */
2851             msg_moremsg(TRUE);
2852             continue;
2853         }
2854
2855         if (toscroll != 0)
2856         {
2857             if (toscroll < 0)
2858             {
2859                 /* go to start of last line */
2860                 if (mp_last == NULL)
2861                     mp = msg_sb_start(last_msgchunk);
2862                 else if (mp_last->sb_prev != NULL)
2863                     mp = msg_sb_start(mp_last->sb_prev);
2864                 else
2865                     mp = NULL;
2866
2867                 /* go to start of line at top of the screen */
2868                 for (i = 0; i < Rows - 2 && mp != NULL && mp->sb_prev != NULL;
2869                                                                           ++i)
2870                     mp = msg_sb_start(mp->sb_prev);
2871
2872                 if (mp != NULL && mp->sb_prev != NULL)
2873                 {
2874                     /* Find line to be displayed at top. */
2875                     for (i = 0; i > toscroll; --i)
2876                     {
2877                         if (mp == NULL || mp->sb_prev == NULL)
2878                             break;
2879                         mp = msg_sb_start(mp->sb_prev);
2880                         if (mp_last == NULL)
2881                             mp_last = msg_sb_start(last_msgchunk);
2882                         else
2883                             mp_last = msg_sb_start(mp_last->sb_prev);
2884                     }
2885
2886                     if (toscroll == -1 && screen_ins_lines(0, 0, 1,
2887                                                        (int)Rows, NULL) == OK)
2888                     {
2889                         /* display line at top */
2890                         (void)disp_sb_line(0, mp);
2891                     }
2892                     else
2893                     {
2894                         /* redisplay all lines */
2895                         screenclear();
2896                         for (i = 0; mp != NULL && i < Rows - 1; ++i)
2897                         {
2898                             mp = disp_sb_line(i, mp);
2899                             ++msg_scrolled;
2900                         }
2901                     }
2902                     toscroll = 0;
2903                 }
2904             }
2905             else
2906             {
2907                 /* First display any text that we scrolled back. */
2908                 while (toscroll > 0 && mp_last != NULL)
2909                 {
2910                     /* scroll up, display line at bottom */
2911                     msg_scroll_up();
2912                     inc_msg_scrolled();
2913                     screen_fill((int)Rows - 2, (int)Rows - 1, 0,
2914                                                    (int)Columns, ' ', ' ', 0);
2915                     mp_last = disp_sb_line((int)Rows - 2, mp_last);
2916                     --toscroll;
2917                 }
2918             }
2919
2920             if (toscroll <= 0)
2921             {
2922                 /* displayed the requested text, more prompt again */
2923                 screen_fill((int)Rows - 1, (int)Rows, 0,
2924                                                    (int)Columns, ' ', ' ', 0);
2925                 msg_moremsg(FALSE);
2926                 continue;
2927             }
2928
2929             /* display more text, return to caller */
2930             lines_left = toscroll;
2931         }
2932
2933         break;
2934     }
2935
2936     /* clear the --more-- message */
2937     screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
2938     State = oldState;
2939 #ifdef FEAT_MOUSE
2940     setmouse();
2941 #endif
2942     if (quit_more)
2943     {
2944         msg_row = Rows - 1;
2945         msg_col = 0;
2946     }
2947 #ifdef FEAT_RIGHTLEFT
2948     else if (cmdmsg_rl)
2949         msg_col = Columns - 1;
2950 #endif
2951
2952     entered = FALSE;
2953 #ifdef FEAT_CON_DIALOG
2954     return retval;
2955 #else
2956     return FALSE;
2957 #endif
2958 }
2959
2960 #if defined(USE_MCH_ERRMSG) || defined(PROTO)
2961
2962 #ifdef mch_errmsg
2963 # undef mch_errmsg
2964 #endif
2965 #ifdef mch_msg
2966 # undef mch_msg
2967 #endif
2968
2969 /*
2970  * Give an error message.  To be used when the screen hasn't been initialized
2971  * yet.  When stderr can't be used, collect error messages until the GUI has
2972  * started and they can be displayed in a message box.
2973  */
2974     void
2975 mch_errmsg(char *str)
2976 {
2977     int         len;
2978
2979 #if (defined(UNIX) || defined(FEAT_GUI)) && !defined(ALWAYS_USE_GUI)
2980     /* On Unix use stderr if it's a tty.
2981      * When not going to start the GUI also use stderr.
2982      * On Mac, when started from Finder, stderr is the console. */
2983     if (
2984 # ifdef UNIX
2985 #  ifdef MACOS_X_UNIX
2986             (isatty(2) && strcmp("/dev/console", ttyname(2)) != 0)
2987 #  else
2988             isatty(2)
2989 #  endif
2990 #  ifdef FEAT_GUI
2991             ||
2992 #  endif
2993 # endif
2994 # ifdef FEAT_GUI
2995             !(gui.in_use || gui.starting)
2996 # endif
2997             )
2998     {
2999         fprintf(stderr, "%s", str);
3000         return;
3001     }
3002 #endif
3003
3004     /* avoid a delay for a message that isn't there */
3005     emsg_on_display = FALSE;
3006
3007     len = (int)STRLEN(str) + 1;
3008     if (error_ga.ga_growsize == 0)
3009     {
3010         error_ga.ga_growsize = 80;
3011         error_ga.ga_itemsize = 1;
3012     }
3013     if (ga_grow(&error_ga, len) == OK)
3014     {
3015         mch_memmove((char_u *)error_ga.ga_data + error_ga.ga_len,
3016                                                           (char_u *)str, len);
3017 #ifdef UNIX
3018         /* remove CR characters, they are displayed */
3019         {
3020             char_u      *p;
3021
3022             p = (char_u *)error_ga.ga_data + error_ga.ga_len;
3023             for (;;)
3024             {
3025                 p = vim_strchr(p, '\r');
3026                 if (p == NULL)
3027                     break;
3028                 *p = ' ';
3029             }
3030         }
3031 #endif
3032         --len;          /* don't count the NUL at the end */
3033         error_ga.ga_len += len;
3034     }
3035 }
3036
3037 /*
3038  * Give a message.  To be used when the screen hasn't been initialized yet.
3039  * When there is no tty, collect messages until the GUI has started and they
3040  * can be displayed in a message box.
3041  */
3042     void
3043 mch_msg(char *str)
3044 {
3045 #if (defined(UNIX) || defined(FEAT_GUI)) && !defined(ALWAYS_USE_GUI)
3046     /* On Unix use stdout if we have a tty.  This allows "vim -h | more" and
3047      * uses mch_errmsg() when started from the desktop.
3048      * When not going to start the GUI also use stdout.
3049      * On Mac, when started from Finder, stderr is the console. */
3050     if (
3051 #  ifdef UNIX
3052 #   ifdef MACOS_X_UNIX
3053             (isatty(2) && strcmp("/dev/console", ttyname(2)) != 0)
3054 #   else
3055             isatty(2)
3056 #    endif
3057 #   ifdef FEAT_GUI
3058             ||
3059 #   endif
3060 #  endif
3061 #  ifdef FEAT_GUI
3062             !(gui.in_use || gui.starting)
3063 #  endif
3064             )
3065     {
3066         printf("%s", str);
3067         return;
3068     }
3069 # endif
3070     mch_errmsg(str);
3071 }
3072 #endif /* USE_MCH_ERRMSG */
3073
3074 /*
3075  * Put a character on the screen at the current message position and advance
3076  * to the next position.  Only for printable ASCII!
3077  */
3078     static void
3079 msg_screen_putchar(int c, int attr)
3080 {
3081     msg_didout = TRUE;          /* remember that line is not empty */
3082     screen_putchar(c, msg_row, msg_col, attr);
3083 #ifdef FEAT_RIGHTLEFT
3084     if (cmdmsg_rl)
3085     {
3086         if (--msg_col == 0)
3087         {
3088             msg_col = Columns;
3089             ++msg_row;
3090         }
3091     }
3092     else
3093 #endif
3094     {
3095         if (++msg_col >= Columns)
3096         {
3097             msg_col = 0;
3098             ++msg_row;
3099         }
3100     }
3101 }
3102
3103     void
3104 msg_moremsg(int full)
3105 {
3106     int         attr;
3107     char_u      *s = (char_u *)_("-- More --");
3108
3109     attr = HL_ATTR(HLF_M);
3110     screen_puts(s, (int)Rows - 1, 0, attr);
3111     if (full)
3112         screen_puts((char_u *)
3113                 _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
3114                 (int)Rows - 1, vim_strsize(s), attr);
3115 }
3116
3117 /*
3118  * Repeat the message for the current mode: ASKMORE, EXTERNCMD, CONFIRM or
3119  * exmode_active.
3120  */
3121     void
3122 repeat_message(void)
3123 {
3124     if (State == ASKMORE)
3125     {
3126         msg_moremsg(TRUE);      /* display --more-- message again */
3127         msg_row = Rows - 1;
3128     }
3129 #ifdef FEAT_CON_DIALOG
3130     else if (State == CONFIRM)
3131     {
3132         display_confirm_msg();  /* display ":confirm" message again */
3133         msg_row = Rows - 1;
3134     }
3135 #endif
3136     else if (State == EXTERNCMD)
3137     {
3138         windgoto(msg_row, msg_col); /* put cursor back */
3139     }
3140     else if (State == HITRETURN || State == SETWSIZE)
3141     {
3142         if (msg_row == Rows - 1)
3143         {
3144             /* Avoid drawing the "hit-enter" prompt below the previous one,
3145              * overwrite it.  Esp. useful when regaining focus and a
3146              * FocusGained autocmd exists but didn't draw anything. */
3147             msg_didout = FALSE;
3148             msg_col = 0;
3149             msg_clr_eos();
3150         }
3151         hit_return_msg();
3152         msg_row = Rows - 1;
3153     }
3154 }
3155
3156 /*
3157  * msg_check_screen - check if the screen is initialized.
3158  * Also check msg_row and msg_col, if they are too big it may cause a crash.
3159  * While starting the GUI the terminal codes will be set for the GUI, but the
3160  * output goes to the terminal.  Don't use the terminal codes then.
3161  */
3162     static int
3163 msg_check_screen(void)
3164 {
3165     if (!full_screen || !screen_valid(FALSE))
3166         return FALSE;
3167
3168     if (msg_row >= Rows)
3169         msg_row = Rows - 1;
3170     if (msg_col >= Columns)
3171         msg_col = Columns - 1;
3172     return TRUE;
3173 }
3174
3175 /*
3176  * Clear from current message position to end of screen.
3177  * Skip this when ":silent" was used, no need to clear for redirection.
3178  */
3179     void
3180 msg_clr_eos(void)
3181 {
3182     if (msg_silent == 0)
3183         msg_clr_eos_force();
3184 }
3185
3186 /*
3187  * Clear from current message position to end of screen.
3188  * Note: msg_col is not updated, so we remember the end of the message
3189  * for msg_check().
3190  */
3191     void
3192 msg_clr_eos_force(void)
3193 {
3194     if (msg_use_printf())
3195     {
3196         if (full_screen)        /* only when termcap codes are valid */
3197         {
3198             if (*T_CD)
3199                 out_str(T_CD);  /* clear to end of display */
3200             else if (*T_CE)
3201                 out_str(T_CE);  /* clear to end of line */
3202         }
3203     }
3204     else
3205     {
3206 #ifdef FEAT_RIGHTLEFT
3207         if (cmdmsg_rl)
3208         {
3209             screen_fill(msg_row, msg_row + 1, 0, msg_col + 1, ' ', ' ', 0);
3210             screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
3211         }
3212         else
3213 #endif
3214         {
3215             screen_fill(msg_row, msg_row + 1, msg_col, (int)Columns,
3216                                                                  ' ', ' ', 0);
3217             screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
3218         }
3219     }
3220 }
3221
3222 /*
3223  * Clear the command line.
3224  */
3225     void
3226 msg_clr_cmdline(void)
3227 {
3228     msg_row = cmdline_row;
3229     msg_col = 0;
3230     msg_clr_eos_force();
3231 }
3232
3233 /*
3234  * end putting a message on the screen
3235  * call wait_return if the message does not fit in the available space
3236  * return TRUE if wait_return not called.
3237  */
3238     int
3239 msg_end(void)
3240 {
3241     /*
3242      * If the string is larger than the window,
3243      * or the ruler option is set and we run into it,
3244      * we have to redraw the window.
3245      * Do not do this if we are abandoning the file or editing the command line.
3246      */
3247     if (!exiting && need_wait_return && !(State & CMDLINE))
3248     {
3249         wait_return(FALSE);
3250         return FALSE;
3251     }
3252     out_flush();
3253     return TRUE;
3254 }
3255
3256 /*
3257  * If the written message runs into the shown command or ruler, we have to
3258  * wait for hit-return and redraw the window later.
3259  */
3260     void
3261 msg_check(void)
3262 {
3263     if (msg_row == Rows - 1 && msg_col >= sc_col)
3264     {
3265         need_wait_return = TRUE;
3266         redraw_cmdline = TRUE;
3267     }
3268 }
3269
3270 /*
3271  * May write a string to the redirection file.
3272  * When "maxlen" is -1 write the whole string, otherwise up to "maxlen" bytes.
3273  */
3274     static void
3275 redir_write(char_u *str, int maxlen)
3276 {
3277     char_u      *s = str;
3278     static int  cur_col = 0;
3279
3280     /* Don't do anything for displaying prompts and the like. */
3281     if (redir_off)
3282         return;
3283
3284     /* If 'verbosefile' is set prepare for writing in that file. */
3285     if (*p_vfile != NUL && verbose_fd == NULL)
3286         verbose_open();
3287
3288     if (redirecting())
3289     {
3290         /* If the string doesn't start with CR or NL, go to msg_col */
3291         if (*s != '\n' && *s != '\r')
3292         {
3293             while (cur_col < msg_col)
3294             {
3295 #ifdef FEAT_EVAL
3296                 if (redir_execute)
3297                     execute_redir_str((char_u *)" ", -1);
3298                 else if (redir_reg)
3299                     write_reg_contents(redir_reg, (char_u *)" ", -1, TRUE);
3300                 else if (redir_vname)
3301                     var_redir_str((char_u *)" ", -1);
3302                 else
3303 #endif
3304                     if (redir_fd != NULL)
3305                     fputs(" ", redir_fd);
3306                 if (verbose_fd != NULL)
3307                     fputs(" ", verbose_fd);
3308                 ++cur_col;
3309             }
3310         }
3311
3312 #ifdef FEAT_EVAL
3313         if (redir_execute)
3314             execute_redir_str(s, maxlen);
3315         else if (redir_reg)
3316             write_reg_contents(redir_reg, s, maxlen, TRUE);
3317         else if (redir_vname)
3318             var_redir_str(s, maxlen);
3319 #endif
3320
3321         /* Write and adjust the current column. */
3322         while (*s != NUL && (maxlen < 0 || (int)(s - str) < maxlen))
3323         {
3324 #ifdef FEAT_EVAL
3325             if (!redir_reg && !redir_vname && !redir_execute)
3326 #endif
3327                 if (redir_fd != NULL)
3328                     putc(*s, redir_fd);
3329             if (verbose_fd != NULL)
3330                 putc(*s, verbose_fd);
3331             if (*s == '\r' || *s == '\n')
3332                 cur_col = 0;
3333             else if (*s == '\t')
3334                 cur_col += (8 - cur_col % 8);
3335             else
3336                 ++cur_col;
3337             ++s;
3338         }
3339
3340         if (msg_silent != 0)    /* should update msg_col */
3341             msg_col = cur_col;
3342     }
3343 }
3344
3345     int
3346 redirecting(void)
3347 {
3348     return redir_fd != NULL || *p_vfile != NUL
3349 #ifdef FEAT_EVAL
3350                           || redir_reg || redir_vname || redir_execute
3351 #endif
3352                                        ;
3353 }
3354
3355 /*
3356  * Before giving verbose message.
3357  * Must always be called paired with verbose_leave()!
3358  */
3359     void
3360 verbose_enter(void)
3361 {
3362     if (*p_vfile != NUL)
3363         ++msg_silent;
3364 }
3365
3366 /*
3367  * After giving verbose message.
3368  * Must always be called paired with verbose_enter()!
3369  */
3370     void
3371 verbose_leave(void)
3372 {
3373     if (*p_vfile != NUL)
3374         if (--msg_silent < 0)
3375             msg_silent = 0;
3376 }
3377
3378 /*
3379  * Like verbose_enter() and set msg_scroll when displaying the message.
3380  */
3381     void
3382 verbose_enter_scroll(void)
3383 {
3384     if (*p_vfile != NUL)
3385         ++msg_silent;
3386     else
3387         /* always scroll up, don't overwrite */
3388         msg_scroll = TRUE;
3389 }
3390
3391 /*
3392  * Like verbose_leave() and set cmdline_row when displaying the message.
3393  */
3394     void
3395 verbose_leave_scroll(void)
3396 {
3397     if (*p_vfile != NUL)
3398     {
3399         if (--msg_silent < 0)
3400             msg_silent = 0;
3401     }
3402     else
3403         cmdline_row = msg_row;
3404 }
3405
3406 /*
3407  * Called when 'verbosefile' is set: stop writing to the file.
3408  */
3409     void
3410 verbose_stop(void)
3411 {
3412     if (verbose_fd != NULL)
3413     {
3414         fclose(verbose_fd);
3415         verbose_fd = NULL;
3416     }
3417     verbose_did_open = FALSE;
3418 }
3419
3420 /*
3421  * Open the file 'verbosefile'.
3422  * Return FAIL or OK.
3423  */
3424     int
3425 verbose_open(void)
3426 {
3427     if (verbose_fd == NULL && !verbose_did_open)
3428     {
3429         /* Only give the error message once. */
3430         verbose_did_open = TRUE;
3431
3432         verbose_fd = mch_fopen((char *)p_vfile, "a");
3433         if (verbose_fd == NULL)
3434         {
3435             EMSG2(_(e_notopen), p_vfile);
3436             return FAIL;
3437         }
3438     }
3439     return OK;
3440 }
3441
3442 /*
3443  * Give a warning message (for searching).
3444  * Use 'w' highlighting and may repeat the message after redrawing
3445  */
3446     void
3447 give_warning(char_u *message, int hl)
3448 {
3449     /* Don't do this for ":silent". */
3450     if (msg_silent != 0)
3451         return;
3452
3453     /* Don't want a hit-enter prompt here. */
3454     ++no_wait_return;
3455
3456 #ifdef FEAT_EVAL
3457     set_vim_var_string(VV_WARNINGMSG, message, -1);
3458 #endif
3459     vim_free(keep_msg);
3460     keep_msg = NULL;
3461     if (hl)
3462         keep_msg_attr = HL_ATTR(HLF_W);
3463     else
3464         keep_msg_attr = 0;
3465     if (msg_attr(message, keep_msg_attr) && msg_scrolled == 0)
3466         set_keep_msg(message, keep_msg_attr);
3467     msg_didout = FALSE;     /* overwrite this message */
3468     msg_nowait = TRUE;      /* don't wait for this message */
3469     msg_col = 0;
3470
3471     --no_wait_return;
3472 }
3473
3474 /*
3475  * Advance msg cursor to column "col".
3476  */
3477     void
3478 msg_advance(int col)
3479 {
3480     if (msg_silent != 0)        /* nothing to advance to */
3481     {
3482         msg_col = col;          /* for redirection, may fill it up later */
3483         return;
3484     }
3485     if (col >= Columns)         /* not enough room */
3486         col = Columns - 1;
3487 #ifdef FEAT_RIGHTLEFT
3488     if (cmdmsg_rl)
3489         while (msg_col > Columns - col)
3490             msg_putchar(' ');
3491     else
3492 #endif
3493         while (msg_col < col)
3494             msg_putchar(' ');
3495 }
3496
3497 #if defined(FEAT_CON_DIALOG) || defined(PROTO)
3498 /*
3499  * Used for "confirm()" function, and the :confirm command prefix.
3500  * Versions which haven't got flexible dialogs yet, and console
3501  * versions, get this generic handler which uses the command line.
3502  *
3503  * type  = one of:
3504  *         VIM_QUESTION, VIM_INFO, VIM_WARNING, VIM_ERROR or VIM_GENERIC
3505  * title = title string (can be NULL for default)
3506  * (neither used in console dialogs at the moment)
3507  *
3508  * Format of the "buttons" string:
3509  * "Button1Name\nButton2Name\nButton3Name"
3510  * The first button should normally be the default/accept
3511  * The second button should be the 'Cancel' button
3512  * Other buttons- use your imagination!
3513  * A '&' in a button name becomes a shortcut, so each '&' should be before a
3514  * different letter.
3515  */
3516     int
3517 do_dialog(
3518     int         type UNUSED,
3519     char_u      *title UNUSED,
3520     char_u      *message,
3521     char_u      *buttons,
3522     int         dfltbutton,
3523     char_u      *textfield UNUSED,      /* IObuff for inputdialog(), NULL
3524                                            otherwise */
3525     int         ex_cmd)     /* when TRUE pressing : accepts default and starts
3526                                Ex command */
3527 {
3528     int         oldState;
3529     int         retval = 0;
3530     char_u      *hotkeys;
3531     int         c;
3532     int         i;
3533
3534 #ifndef NO_CONSOLE
3535     /* Don't output anything in silent mode ("ex -s") */
3536     if (silent_mode)
3537         return dfltbutton;   /* return default option */
3538 #endif
3539
3540 #ifdef FEAT_GUI_DIALOG
3541     /* When GUI is running and 'c' not in 'guioptions', use the GUI dialog */
3542     if (gui.in_use && vim_strchr(p_go, GO_CONDIALOG) == NULL)
3543     {
3544         c = gui_mch_dialog(type, title, message, buttons, dfltbutton,
3545                                                            textfield, ex_cmd);
3546         /* avoid a hit-enter prompt without clearing the cmdline */
3547         need_wait_return = FALSE;
3548         emsg_on_display = FALSE;
3549         cmdline_row = msg_row;
3550
3551         /* Flush output to avoid that further messages and redrawing is done
3552          * in the wrong order. */
3553         out_flush();
3554         gui_mch_update();
3555
3556         return c;
3557     }
3558 #endif
3559
3560     oldState = State;
3561     State = CONFIRM;
3562 #ifdef FEAT_MOUSE
3563     setmouse();
3564 #endif
3565
3566     /*
3567      * Since we wait for a keypress, don't make the
3568      * user press RETURN as well afterwards.
3569      */
3570     ++no_wait_return;
3571     hotkeys = msg_show_console_dialog(message, buttons, dfltbutton);
3572
3573     if (hotkeys != NULL)
3574     {
3575         for (;;)
3576         {
3577             /* Get a typed character directly from the user. */
3578             c = get_keystroke();
3579             switch (c)
3580             {
3581             case CAR:           /* User accepts default option */
3582             case NL:
3583                 retval = dfltbutton;
3584                 break;
3585             case Ctrl_C:        /* User aborts/cancels */
3586             case ESC:
3587                 retval = 0;
3588                 break;
3589             default:            /* Could be a hotkey? */
3590                 if (c < 0)      /* special keys are ignored here */
3591                     continue;
3592                 if (c == ':' && ex_cmd)
3593                 {
3594                     retval = dfltbutton;
3595                     ins_char_typebuf(':');
3596                     break;
3597                 }
3598
3599                 /* Make the character lowercase, as chars in "hotkeys" are. */
3600                 c = MB_TOLOWER(c);
3601                 retval = 1;
3602                 for (i = 0; hotkeys[i]; ++i)
3603                 {
3604 #ifdef FEAT_MBYTE
3605                     if (has_mbyte)
3606                     {
3607                         if ((*mb_ptr2char)(hotkeys + i) == c)
3608                             break;
3609                         i += (*mb_ptr2len)(hotkeys + i) - 1;
3610                     }
3611                     else
3612 #endif
3613                         if (hotkeys[i] == c)
3614                             break;
3615                     ++retval;
3616                 }
3617                 if (hotkeys[i])
3618                     break;
3619                 /* No hotkey match, so keep waiting */
3620                 continue;
3621             }
3622             break;
3623         }
3624
3625         vim_free(hotkeys);
3626     }
3627
3628     State = oldState;
3629 #ifdef FEAT_MOUSE
3630     setmouse();
3631 #endif
3632     --no_wait_return;
3633     msg_end_prompt();
3634
3635     return retval;
3636 }
3637
3638 static int copy_char(char_u *from, char_u *to, int lowercase);
3639
3640 /*
3641  * Copy one character from "*from" to "*to", taking care of multi-byte
3642  * characters.  Return the length of the character in bytes.
3643  */
3644     static int
3645 copy_char(
3646     char_u      *from,
3647     char_u      *to,
3648     int         lowercase)      /* make character lower case */
3649 {
3650 #ifdef FEAT_MBYTE
3651     int         len;
3652     int         c;
3653
3654     if (has_mbyte)
3655     {
3656         if (lowercase)
3657         {
3658             c = MB_TOLOWER((*mb_ptr2char)(from));
3659             return (*mb_char2bytes)(c, to);
3660         }
3661         else
3662         {
3663             len = (*mb_ptr2len)(from);
3664             mch_memmove(to, from, (size_t)len);
3665             return len;
3666         }
3667     }
3668     else
3669 #endif
3670     {
3671         if (lowercase)
3672             *to = (char_u)TOLOWER_LOC(*from);
3673         else
3674             *to = *from;
3675         return 1;
3676     }
3677 }
3678
3679 /*
3680  * Format the dialog string, and display it at the bottom of
3681  * the screen. Return a string of hotkey chars (if defined) for
3682  * each 'button'. If a button has no hotkey defined, the first character of
3683  * the button is used.
3684  * The hotkeys can be multi-byte characters, but without combining chars.
3685  *
3686  * Returns an allocated string with hotkeys, or NULL for error.
3687  */
3688     static char_u *
3689 msg_show_console_dialog(
3690     char_u      *message,
3691     char_u      *buttons,
3692     int         dfltbutton)
3693 {
3694     int         len = 0;
3695 #ifdef FEAT_MBYTE
3696 # define HOTK_LEN (has_mbyte ? MB_MAXBYTES : 1)
3697 #else
3698 # define HOTK_LEN 1
3699 #endif
3700     int         lenhotkey = HOTK_LEN;   /* count first button */
3701     char_u      *hotk = NULL;
3702     char_u      *msgp = NULL;
3703     char_u      *hotkp = NULL;
3704     char_u      *r;
3705     int         copy;
3706 #define HAS_HOTKEY_LEN 30
3707     char_u      has_hotkey[HAS_HOTKEY_LEN];
3708     int         first_hotkey = FALSE;   /* first char of button is hotkey */
3709     int         idx;
3710
3711     has_hotkey[0] = FALSE;
3712
3713     /*
3714      * First loop: compute the size of memory to allocate.
3715      * Second loop: copy to the allocated memory.
3716      */
3717     for (copy = 0; copy <= 1; ++copy)
3718     {
3719         r = buttons;
3720         idx = 0;
3721         while (*r)
3722         {
3723             if (*r == DLG_BUTTON_SEP)
3724             {
3725                 if (copy)
3726                 {
3727                     *msgp++ = ',';
3728                     *msgp++ = ' ';          /* '\n' -> ', ' */
3729
3730                     /* advance to next hotkey and set default hotkey */
3731 #ifdef FEAT_MBYTE
3732                     if (has_mbyte)
3733                         hotkp += STRLEN(hotkp);
3734                     else
3735 #endif
3736                         ++hotkp;
3737                     hotkp[copy_char(r + 1, hotkp, TRUE)] = NUL;
3738                     if (dfltbutton)
3739                         --dfltbutton;
3740
3741                     /* If no hotkey is specified first char is used. */
3742                     if (idx < HAS_HOTKEY_LEN - 1 && !has_hotkey[++idx])
3743                         first_hotkey = TRUE;
3744                 }
3745                 else
3746                 {
3747                     len += 3;               /* '\n' -> ', '; 'x' -> '(x)' */
3748                     lenhotkey += HOTK_LEN;  /* each button needs a hotkey */
3749                     if (idx < HAS_HOTKEY_LEN - 1)
3750                         has_hotkey[++idx] = FALSE;
3751                 }
3752             }
3753             else if (*r == DLG_HOTKEY_CHAR || first_hotkey)
3754             {
3755                 if (*r == DLG_HOTKEY_CHAR)
3756                     ++r;
3757                 first_hotkey = FALSE;
3758                 if (copy)
3759                 {
3760                     if (*r == DLG_HOTKEY_CHAR)          /* '&&a' -> '&a' */
3761                         *msgp++ = *r;
3762                     else
3763                     {
3764                         /* '&a' -> '[a]' */
3765                         *msgp++ = (dfltbutton == 1) ? '[' : '(';
3766                         msgp += copy_char(r, msgp, FALSE);
3767                         *msgp++ = (dfltbutton == 1) ? ']' : ')';
3768
3769                         /* redefine hotkey */
3770                         hotkp[copy_char(r, hotkp, TRUE)] = NUL;
3771                     }
3772                 }
3773                 else
3774                 {
3775                     ++len;          /* '&a' -> '[a]' */
3776                     if (idx < HAS_HOTKEY_LEN - 1)
3777                         has_hotkey[idx] = TRUE;
3778                 }
3779             }
3780             else
3781             {
3782                 /* everything else copy literally */
3783                 if (copy)
3784                     msgp += copy_char(r, msgp, FALSE);
3785             }
3786
3787             /* advance to the next character */
3788             MB_PTR_ADV(r);
3789         }
3790
3791         if (copy)
3792         {
3793             *msgp++ = ':';
3794             *msgp++ = ' ';
3795             *msgp = NUL;
3796         }
3797         else
3798         {
3799             len += (int)(STRLEN(message)
3800                         + 2                     /* for the NL's */
3801                         + STRLEN(buttons)
3802                         + 3);                   /* for the ": " and NUL */
3803             lenhotkey++;                        /* for the NUL */
3804
3805             /* If no hotkey is specified first char is used. */
3806             if (!has_hotkey[0])
3807             {
3808                 first_hotkey = TRUE;
3809                 len += 2;               /* "x" -> "[x]" */
3810             }
3811
3812             /*
3813              * Now allocate and load the strings
3814              */
3815             vim_free(confirm_msg);
3816             confirm_msg = alloc(len);
3817             if (confirm_msg == NULL)
3818                 return NULL;
3819             *confirm_msg = NUL;
3820             hotk = alloc(lenhotkey);
3821             if (hotk == NULL)
3822                 return NULL;
3823
3824             *confirm_msg = '\n';
3825             STRCPY(confirm_msg + 1, message);
3826
3827             msgp = confirm_msg + 1 + STRLEN(message);
3828             hotkp = hotk;
3829
3830             /* Define first default hotkey.  Keep the hotkey string NUL
3831              * terminated to avoid reading past the end. */
3832             hotkp[copy_char(buttons, hotkp, TRUE)] = NUL;
3833
3834             /* Remember where the choices start, displaying starts here when
3835              * "hotkp" typed at the more prompt. */
3836             confirm_msg_tail = msgp;
3837             *msgp++ = '\n';
3838         }
3839     }
3840
3841     display_confirm_msg();
3842     return hotk;
3843 }
3844
3845 /*
3846  * Display the ":confirm" message.  Also called when screen resized.
3847  */
3848     void
3849 display_confirm_msg(void)
3850 {
3851     /* avoid that 'q' at the more prompt truncates the message here */
3852     ++confirm_msg_used;
3853     if (confirm_msg != NULL)
3854         msg_puts_attr(confirm_msg, HL_ATTR(HLF_M));
3855     --confirm_msg_used;
3856 }
3857
3858 #endif /* FEAT_CON_DIALOG */
3859
3860 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
3861
3862     int
3863 vim_dialog_yesno(
3864     int         type,
3865     char_u      *title,
3866     char_u      *message,
3867     int         dflt)
3868 {
3869     if (do_dialog(type,
3870                 title == NULL ? (char_u *)_("Question") : title,
3871                 message,
3872                 (char_u *)_("&Yes\n&No"), dflt, NULL, FALSE) == 1)
3873         return VIM_YES;
3874     return VIM_NO;
3875 }
3876
3877     int
3878 vim_dialog_yesnocancel(
3879     int         type,
3880     char_u      *title,
3881     char_u      *message,
3882     int         dflt)
3883 {
3884     switch (do_dialog(type,
3885                 title == NULL ? (char_u *)_("Question") : title,
3886                 message,
3887                 (char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, FALSE))
3888     {
3889         case 1: return VIM_YES;
3890         case 2: return VIM_NO;
3891     }
3892     return VIM_CANCEL;
3893 }
3894
3895     int
3896 vim_dialog_yesnoallcancel(
3897     int         type,
3898     char_u      *title,
3899     char_u      *message,
3900     int         dflt)
3901 {
3902     switch (do_dialog(type,
3903                 title == NULL ? (char_u *)"Question" : title,
3904                 message,
3905                 (char_u *)_("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
3906                                                            dflt, NULL, FALSE))
3907     {
3908         case 1: return VIM_YES;
3909         case 2: return VIM_NO;
3910         case 3: return VIM_ALL;
3911         case 4: return VIM_DISCARDALL;
3912     }
3913     return VIM_CANCEL;
3914 }
3915
3916 #endif /* FEAT_GUI_DIALOG || FEAT_CON_DIALOG */
3917
3918 #if defined(FEAT_BROWSE) || defined(PROTO)
3919 /*
3920  * Generic browse function.  Calls gui_mch_browse() when possible.
3921  * Later this may pop-up a non-GUI file selector (external command?).
3922  */
3923     char_u *
3924 do_browse(
3925     int         flags,          /* BROWSE_SAVE and BROWSE_DIR */
3926     char_u      *title,         /* title for the window */
3927     char_u      *dflt,          /* default file name (may include directory) */
3928     char_u      *ext,           /* extension added */
3929     char_u      *initdir,       /* initial directory, NULL for current dir or
3930                                    when using path from "dflt" */
3931     char_u      *filter,        /* file name filter */
3932     buf_T       *buf)           /* buffer to read/write for */
3933 {
3934     char_u              *fname;
3935     static char_u       *last_dir = NULL;    /* last used directory */
3936     char_u              *tofree = NULL;
3937     int                 save_browse = cmdmod.browse;
3938
3939     /* Must turn off browse to avoid that autocommands will get the
3940      * flag too!  */
3941     cmdmod.browse = FALSE;
3942
3943     if (title == NULL || *title == NUL)
3944     {
3945         if (flags & BROWSE_DIR)
3946             title = (char_u *)_("Select Directory dialog");
3947         else if (flags & BROWSE_SAVE)
3948             title = (char_u *)_("Save File dialog");
3949         else
3950             title = (char_u *)_("Open File dialog");
3951     }
3952
3953     /* When no directory specified, use default file name, default dir, buffer
3954      * dir, last dir or current dir */
3955     if ((initdir == NULL || *initdir == NUL) && dflt != NULL && *dflt != NUL)
3956     {
3957         if (mch_isdir(dflt))            /* default file name is a directory */
3958         {
3959             initdir = dflt;
3960             dflt = NULL;
3961         }
3962         else if (gettail(dflt) != dflt) /* default file name includes a path */
3963         {
3964             tofree = vim_strsave(dflt);
3965             if (tofree != NULL)
3966             {
3967                 initdir = tofree;
3968                 *gettail(initdir) = NUL;
3969                 dflt = gettail(dflt);
3970             }
3971         }
3972     }
3973
3974     if (initdir == NULL || *initdir == NUL)
3975     {
3976         /* When 'browsedir' is a directory, use it */
3977         if (STRCMP(p_bsdir, "last") != 0
3978                 && STRCMP(p_bsdir, "buffer") != 0
3979                 && STRCMP(p_bsdir, "current") != 0
3980                 && mch_isdir(p_bsdir))
3981             initdir = p_bsdir;
3982         /* When saving or 'browsedir' is "buffer", use buffer fname */
3983         else if (((flags & BROWSE_SAVE) || *p_bsdir == 'b')
3984                 && buf != NULL && buf->b_ffname != NULL)
3985         {
3986             if (dflt == NULL || *dflt == NUL)
3987                 dflt = gettail(curbuf->b_ffname);
3988             tofree = vim_strsave(curbuf->b_ffname);
3989             if (tofree != NULL)
3990             {
3991                 initdir = tofree;
3992                 *gettail(initdir) = NUL;
3993             }
3994         }
3995         /* When 'browsedir' is "last", use dir from last browse */
3996         else if (*p_bsdir == 'l')
3997             initdir = last_dir;
3998         /* When 'browsedir is "current", use current directory.  This is the
3999          * default already, leave initdir empty. */
4000     }
4001
4002 # ifdef FEAT_GUI
4003     if (gui.in_use)             /* when this changes, also adjust f_has()! */
4004     {
4005         if (filter == NULL
4006 #  ifdef FEAT_EVAL
4007                 && (filter = get_var_value((char_u *)"b:browsefilter")) == NULL
4008                 && (filter = get_var_value((char_u *)"g:browsefilter")) == NULL
4009 #  endif
4010         )
4011             filter = BROWSE_FILTER_DEFAULT;
4012         if (flags & BROWSE_DIR)
4013         {
4014 #  if defined(FEAT_GUI_GTK) || defined(WIN3264)
4015             /* For systems that have a directory dialog. */
4016             fname = gui_mch_browsedir(title, initdir);
4017 #  else
4018             /* Generic solution for selecting a directory: select a file and
4019              * remove the file name. */
4020             fname = gui_mch_browse(0, title, dflt, ext, initdir, (char_u *)"");
4021 #  endif
4022 #  if !defined(FEAT_GUI_GTK)
4023             /* Win32 adds a dummy file name, others return an arbitrary file
4024              * name.  GTK+ 2 returns only the directory, */
4025             if (fname != NULL && *fname != NUL && !mch_isdir(fname))
4026             {
4027                 /* Remove the file name. */
4028                 char_u      *tail = gettail_sep(fname);
4029
4030                 if (tail == fname)
4031                     *tail++ = '.';      /* use current dir */
4032                 *tail = NUL;
4033             }
4034 #  endif
4035         }
4036         else
4037             fname = gui_mch_browse(flags & BROWSE_SAVE,
4038                                            title, dflt, ext, initdir, filter);
4039
4040         /* We hang around in the dialog for a while, the user might do some
4041          * things to our files.  The Win32 dialog allows deleting or renaming
4042          * a file, check timestamps. */
4043         need_check_timestamps = TRUE;
4044         did_check_timestamps = FALSE;
4045     }
4046     else
4047 # endif
4048     {
4049         /* TODO: non-GUI file selector here */
4050         EMSG(_("E338: Sorry, no file browser in console mode"));
4051         fname = NULL;
4052     }
4053
4054     /* keep the directory for next time */
4055     if (fname != NULL)
4056     {
4057         vim_free(last_dir);
4058         last_dir = vim_strsave(fname);
4059         if (last_dir != NULL && !(flags & BROWSE_DIR))
4060         {
4061             *gettail(last_dir) = NUL;
4062             if (*last_dir == NUL)
4063             {
4064                 /* filename only returned, must be in current dir */
4065                 vim_free(last_dir);
4066                 last_dir = alloc(MAXPATHL);
4067                 if (last_dir != NULL)
4068                     mch_dirname(last_dir, MAXPATHL);
4069             }
4070         }
4071     }
4072
4073     vim_free(tofree);
4074     cmdmod.browse = save_browse;
4075
4076     return fname;
4077 }
4078 #endif
4079
4080 #if defined(FEAT_EVAL)
4081 static char *e_printf = N_("E766: Insufficient arguments for printf()");
4082
4083 static varnumber_T tv_nr(typval_T *tvs, int *idxp);
4084 static char *tv_str(typval_T *tvs, int *idxp, char_u **tofree);
4085 # ifdef FEAT_FLOAT
4086 static double tv_float(typval_T *tvs, int *idxp);
4087 # endif
4088
4089 /*
4090  * Get number argument from "idxp" entry in "tvs".  First entry is 1.
4091  */
4092     static varnumber_T
4093 tv_nr(typval_T *tvs, int *idxp)
4094 {
4095     int         idx = *idxp - 1;
4096     varnumber_T n = 0;
4097     int         err = FALSE;
4098
4099     if (tvs[idx].v_type == VAR_UNKNOWN)
4100         EMSG(_(e_printf));
4101     else
4102     {
4103         ++*idxp;
4104         n = get_tv_number_chk(&tvs[idx], &err);
4105         if (err)
4106             n = 0;
4107     }
4108     return n;
4109 }
4110
4111 /*
4112  * Get string argument from "idxp" entry in "tvs".  First entry is 1.
4113  * If "tofree" is NULL get_tv_string_chk() is used.  Some types (e.g. List)
4114  * are not converted to a string.
4115  * If "tofree" is not NULL echo_string() is used.  All types are converted to
4116  * a string with the same format as ":echo".  The caller must free "*tofree".
4117  * Returns NULL for an error.
4118  */
4119     static char *
4120 tv_str(typval_T *tvs, int *idxp, char_u **tofree)
4121 {
4122     int             idx = *idxp - 1;
4123     char            *s = NULL;
4124     static char_u   numbuf[NUMBUFLEN];
4125
4126     if (tvs[idx].v_type == VAR_UNKNOWN)
4127         EMSG(_(e_printf));
4128     else
4129     {
4130         ++*idxp;
4131         if (tofree != NULL)
4132             s = (char *)echo_string(&tvs[idx], tofree, numbuf, get_copyID());
4133         else
4134             s = (char *)get_tv_string_chk(&tvs[idx]);
4135     }
4136     return s;
4137 }
4138
4139 # ifdef FEAT_FLOAT
4140 /*
4141  * Get float argument from "idxp" entry in "tvs".  First entry is 1.
4142  */
4143     static double
4144 tv_float(typval_T *tvs, int *idxp)
4145 {
4146     int         idx = *idxp - 1;
4147     double      f = 0;
4148
4149     if (tvs[idx].v_type == VAR_UNKNOWN)
4150         EMSG(_(e_printf));
4151     else
4152     {
4153         ++*idxp;
4154         if (tvs[idx].v_type == VAR_FLOAT)
4155             f = tvs[idx].vval.v_float;
4156         else if (tvs[idx].v_type == VAR_NUMBER)
4157             f = (double)tvs[idx].vval.v_number;
4158         else
4159             EMSG(_("E807: Expected Float argument for printf()"));
4160     }
4161     return f;
4162 }
4163 # endif
4164 #endif
4165
4166 #ifdef FEAT_FLOAT
4167 /*
4168  * Return the representation of infinity for printf() function:
4169  * "-inf", "inf", "+inf", " inf", "-INF", "INF", "+INF" or " INF".
4170  */
4171     static const char *
4172 infinity_str(int positive,
4173              char fmt_spec,
4174              int force_sign,
4175              int space_for_positive)
4176 {
4177     static const char *table[] =
4178     {
4179         "-inf", "inf", "+inf", " inf",
4180         "-INF", "INF", "+INF", " INF"
4181     };
4182     int idx = positive * (1 + force_sign + force_sign * space_for_positive);
4183
4184     if (ASCII_ISUPPER(fmt_spec))
4185         idx += 4;
4186     return table[idx];
4187 }
4188 #endif
4189
4190 /*
4191  * This code was included to provide a portable vsnprintf() and snprintf().
4192  * Some systems may provide their own, but we always use this one for
4193  * consistency.
4194  *
4195  * This code is based on snprintf.c - a portable implementation of snprintf
4196  * by Mark Martinec <mark.martinec@ijs.si>, Version 2.2, 2000-10-06.
4197  * Included with permission.  It was heavily modified to fit in Vim.
4198  * The original code, including useful comments, can be found here:
4199  *      http://www.ijs.si/software/snprintf/
4200  *
4201  * This snprintf() only supports the following conversion specifiers:
4202  * s, c, d, u, o, x, X, p  (and synonyms: i, D, U, O - see below)
4203  * with flags: '-', '+', ' ', '0' and '#'.
4204  * An asterisk is supported for field width as well as precision.
4205  *
4206  * Limited support for floating point was added: 'f', 'F', 'e', 'E', 'g', 'G'.
4207  *
4208  * Length modifiers 'h' (short int) and 'l' (long int) and 'll' (long long int)
4209  * are supported.
4210  *
4211  * The locale is not used, the string is used as a byte string.  This is only
4212  * relevant for double-byte encodings where the second byte may be '%'.
4213  *
4214  * It is permitted for "str_m" to be zero, and it is permitted to specify NULL
4215  * pointer for resulting string argument if "str_m" is zero (as per ISO C99).
4216  *
4217  * The return value is the number of characters which would be generated
4218  * for the given input, excluding the trailing NUL. If this value
4219  * is greater or equal to "str_m", not all characters from the result
4220  * have been stored in str, output bytes beyond the ("str_m"-1) -th character
4221  * are discarded. If "str_m" is greater than zero it is guaranteed
4222  * the resulting string will be NUL-terminated.
4223  */
4224
4225 /*
4226  * When va_list is not supported we only define vim_snprintf().
4227  *
4228  * vim_vsnprintf() can be invoked with either "va_list" or a list of
4229  * "typval_T".  When the latter is not used it must be NULL.
4230  */
4231
4232 /* When generating prototypes all of this is skipped, cproto doesn't
4233  * understand this. */
4234 #ifndef PROTO
4235
4236 /* Like vim_vsnprintf() but append to the string. */
4237     int
4238 vim_snprintf_add(char *str, size_t str_m, char *fmt, ...)
4239 {
4240     va_list     ap;
4241     int         str_l;
4242     size_t      len = STRLEN(str);
4243     size_t      space;
4244
4245     if (str_m <= len)
4246         space = 0;
4247     else
4248         space = str_m - len;
4249     va_start(ap, fmt);
4250     str_l = vim_vsnprintf(str + len, space, fmt, ap, NULL);
4251     va_end(ap);
4252     return str_l;
4253 }
4254
4255     int
4256 vim_snprintf(char *str, size_t str_m, char *fmt, ...)
4257 {
4258     va_list     ap;
4259     int         str_l;
4260
4261     va_start(ap, fmt);
4262     str_l = vim_vsnprintf(str, str_m, fmt, ap, NULL);
4263     va_end(ap);
4264     return str_l;
4265 }
4266
4267     int
4268 vim_vsnprintf(
4269     char        *str,
4270     size_t      str_m,
4271     char        *fmt,
4272     va_list     ap,
4273     typval_T    *tvs)
4274 {
4275     size_t      str_l = 0;
4276     char        *p = fmt;
4277     int         arg_idx = 1;
4278
4279     if (p == NULL)
4280         p = "";
4281     while (*p != NUL)
4282     {
4283         if (*p != '%')
4284         {
4285             char    *q = strchr(p + 1, '%');
4286             size_t  n = (q == NULL) ? STRLEN(p) : (size_t)(q - p);
4287
4288             /* Copy up to the next '%' or NUL without any changes. */
4289             if (str_l < str_m)
4290             {
4291                 size_t avail = str_m - str_l;
4292
4293                 mch_memmove(str + str_l, p, n > avail ? avail : n);
4294             }
4295             p += n;
4296             str_l += n;
4297         }
4298         else
4299         {
4300             size_t  min_field_width = 0, precision = 0;
4301             int     zero_padding = 0, precision_specified = 0, justify_left = 0;
4302             int     alternate_form = 0, force_sign = 0;
4303
4304             /* If both the ' ' and '+' flags appear, the ' ' flag should be
4305              * ignored. */
4306             int     space_for_positive = 1;
4307
4308             /* allowed values: \0, h, l, L */
4309             char    length_modifier = '\0';
4310
4311             /* temporary buffer for simple numeric->string conversion */
4312 # if defined(FEAT_FLOAT)
4313 #  define TMP_LEN 350   /* On my system 1e308 is the biggest number possible.
4314                          * That sounds reasonable to use as the maximum
4315                          * printable. */
4316 # elif defined(FEAT_NUM64)
4317 #  define TMP_LEN 66
4318 # else
4319 #  define TMP_LEN 34
4320 # endif
4321             char    tmp[TMP_LEN];
4322
4323             /* string address in case of string argument */
4324             char    *str_arg;
4325
4326             /* natural field width of arg without padding and sign */
4327             size_t  str_arg_l;
4328
4329             /* unsigned char argument value - only defined for c conversion.
4330              * N.B. standard explicitly states the char argument for the c
4331              * conversion is unsigned */
4332             unsigned char uchar_arg;
4333
4334             /* number of zeros to be inserted for numeric conversions as
4335              * required by the precision or minimal field width */
4336             size_t  number_of_zeros_to_pad = 0;
4337
4338             /* index into tmp where zero padding is to be inserted */
4339             size_t  zero_padding_insertion_ind = 0;
4340
4341             /* current conversion specifier character */
4342             char    fmt_spec = '\0';
4343
4344             /* buffer for 's' and 'S' specs */
4345             char_u  *tofree = NULL;
4346
4347
4348             str_arg = NULL;
4349             p++;  /* skip '%' */
4350
4351             /* parse flags */
4352             while (*p == '0' || *p == '-' || *p == '+' || *p == ' '
4353                                                    || *p == '#' || *p == '\'')
4354             {
4355                 switch (*p)
4356                 {
4357                     case '0': zero_padding = 1; break;
4358                     case '-': justify_left = 1; break;
4359                     case '+': force_sign = 1; space_for_positive = 0; break;
4360                     case ' ': force_sign = 1;
4361                               /* If both the ' ' and '+' flags appear, the ' '
4362                                * flag should be ignored */
4363                               break;
4364                     case '#': alternate_form = 1; break;
4365                     case '\'': break;
4366                 }
4367                 p++;
4368             }
4369             /* If the '0' and '-' flags both appear, the '0' flag should be
4370              * ignored. */
4371
4372             /* parse field width */
4373             if (*p == '*')
4374             {
4375                 int j;
4376
4377                 p++;
4378                 j =
4379 # if defined(FEAT_EVAL)
4380                     tvs != NULL ? tv_nr(tvs, &arg_idx) :
4381 # endif
4382                         va_arg(ap, int);
4383                 if (j >= 0)
4384                     min_field_width = j;
4385                 else
4386                 {
4387                     min_field_width = -j;
4388                     justify_left = 1;
4389                 }
4390             }
4391             else if (VIM_ISDIGIT((int)(*p)))
4392             {
4393                 /* size_t could be wider than unsigned int; make sure we treat
4394                  * argument like common implementations do */
4395                 unsigned int uj = *p++ - '0';
4396
4397                 while (VIM_ISDIGIT((int)(*p)))
4398                     uj = 10 * uj + (unsigned int)(*p++ - '0');
4399                 min_field_width = uj;
4400             }
4401
4402             /* parse precision */
4403             if (*p == '.')
4404             {
4405                 p++;
4406                 precision_specified = 1;
4407                 if (*p == '*')
4408                 {
4409                     int j;
4410
4411                     j =
4412 # if defined(FEAT_EVAL)
4413                         tvs != NULL ? tv_nr(tvs, &arg_idx) :
4414 # endif
4415                             va_arg(ap, int);
4416                     p++;
4417                     if (j >= 0)
4418                         precision = j;
4419                     else
4420                     {
4421                         precision_specified = 0;
4422                         precision = 0;
4423                     }
4424                 }
4425                 else if (VIM_ISDIGIT((int)(*p)))
4426                 {
4427                     /* size_t could be wider than unsigned int; make sure we
4428                      * treat argument like common implementations do */
4429                     unsigned int uj = *p++ - '0';
4430
4431                     while (VIM_ISDIGIT((int)(*p)))
4432                         uj = 10 * uj + (unsigned int)(*p++ - '0');
4433                     precision = uj;
4434                 }
4435             }
4436
4437             /* parse 'h', 'l' and 'll' length modifiers */
4438             if (*p == 'h' || *p == 'l')
4439             {
4440                 length_modifier = *p;
4441                 p++;
4442                 if (length_modifier == 'l' && *p == 'l')
4443                 {
4444                     /* double l = long long */
4445 # ifdef FEAT_NUM64
4446                     length_modifier = 'L';
4447 # else
4448                     length_modifier = 'l';      /* treat it as a single 'l' */
4449 # endif
4450                     p++;
4451                 }
4452             }
4453             fmt_spec = *p;
4454
4455             /* common synonyms: */
4456             switch (fmt_spec)
4457             {
4458                 case 'i': fmt_spec = 'd'; break;
4459                 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
4460                 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
4461                 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
4462                 default: break;
4463             }
4464
4465 # if defined(FEAT_EVAL) && defined(FEAT_NUM64)
4466             switch (fmt_spec)
4467             {
4468                 case 'd': case 'u': case 'o': case 'x': case 'X':
4469                     if (tvs != NULL && length_modifier == '\0')
4470                         length_modifier = 'L';
4471             }
4472 # endif
4473
4474             /* get parameter value, do initial processing */
4475             switch (fmt_spec)
4476             {
4477                 /* '%' and 'c' behave similar to 's' regarding flags and field
4478                  * widths */
4479             case '%':
4480             case 'c':
4481             case 's':
4482             case 'S':
4483                 length_modifier = '\0';
4484                 str_arg_l = 1;
4485                 switch (fmt_spec)
4486                 {
4487                 case '%':
4488                     str_arg = p;
4489                     break;
4490
4491                 case 'c':
4492                     {
4493                         int j;
4494
4495                         j =
4496 # if defined(FEAT_EVAL)
4497                             tvs != NULL ? tv_nr(tvs, &arg_idx) :
4498 # endif
4499                                 va_arg(ap, int);
4500                         /* standard demands unsigned char */
4501                         uchar_arg = (unsigned char)j;
4502                         str_arg = (char *)&uchar_arg;
4503                         break;
4504                     }
4505
4506                 case 's':
4507                 case 'S':
4508                     str_arg =
4509 # if defined(FEAT_EVAL)
4510                                 tvs != NULL ? tv_str(tvs, &arg_idx, &tofree) :
4511 # endif
4512                                     va_arg(ap, char *);
4513                     if (str_arg == NULL)
4514                     {
4515                         str_arg = "[NULL]";
4516                         str_arg_l = 6;
4517                     }
4518                     /* make sure not to address string beyond the specified
4519                      * precision !!! */
4520                     else if (!precision_specified)
4521                         str_arg_l = strlen(str_arg);
4522                     /* truncate string if necessary as requested by precision */
4523                     else if (precision == 0)
4524                         str_arg_l = 0;
4525                     else
4526                     {
4527                         /* Don't put the #if inside memchr(), it can be a
4528                          * macro. */
4529 # if VIM_SIZEOF_INT <= 2
4530                         char *q = memchr(str_arg, '\0', precision);
4531 # else
4532                         /* memchr on HP does not like n > 2^31  !!! */
4533                         char *q = memchr(str_arg, '\0',
4534                                   precision <= (size_t)0x7fffffffL ? precision
4535                                                        : (size_t)0x7fffffffL);
4536 # endif
4537                         str_arg_l = (q == NULL) ? precision
4538                                                       : (size_t)(q - str_arg);
4539                     }
4540 # ifdef FEAT_MBYTE
4541                     if (fmt_spec == 'S')
4542                     {
4543                         if (min_field_width != 0)
4544                             min_field_width += STRLEN(str_arg)
4545                                      - mb_string2cells((char_u *)str_arg, -1);
4546                         if (precision)
4547                         {
4548                             char_u *p1 = (char_u *)str_arg;
4549                             size_t i;
4550
4551                             for (i = 0; i < precision && *p1; i++)
4552                                 p1 += mb_ptr2len(p1);
4553
4554                             str_arg_l = precision = p1 - (char_u *)str_arg;
4555                         }
4556                     }
4557 # endif
4558                     break;
4559
4560                 default:
4561                     break;
4562                 }
4563                 break;
4564
4565             case 'd': case 'u':
4566             case 'b': case 'B':
4567             case 'o':
4568             case 'x': case 'X':
4569             case 'p':
4570                 {
4571                     /* NOTE: the u, b, o, x, X and p conversion specifiers
4572                      * imply the value is unsigned;  d implies a signed
4573                      * value */
4574
4575                     /* 0 if numeric argument is zero (or if pointer is
4576                      * NULL for 'p'), +1 if greater than zero (or nonzero
4577                      * for unsigned arguments), -1 if negative (unsigned
4578                      * argument is never negative) */
4579                     int arg_sign = 0;
4580
4581                     /* only defined for length modifier h, or for no
4582                      * length modifiers */
4583                     int int_arg = 0;
4584                     unsigned int uint_arg = 0;
4585
4586                     /* only defined for length modifier l */
4587                     long int long_arg = 0;
4588                     unsigned long int ulong_arg = 0;
4589
4590 # ifdef FEAT_NUM64
4591                     /* only defined for length modifier ll */
4592                     varnumber_T llong_arg = 0;
4593                     uvarnumber_T ullong_arg = 0;
4594 # endif
4595
4596                     /* only defined for b conversion */
4597                     uvarnumber_T bin_arg = 0;
4598
4599                     /* pointer argument value -only defined for p
4600                      * conversion */
4601                     void *ptr_arg = NULL;
4602
4603                     if (fmt_spec == 'p')
4604                     {
4605                         length_modifier = '\0';
4606                         ptr_arg =
4607 # if defined(FEAT_EVAL)
4608                                  tvs != NULL ? (void *)tv_str(tvs, &arg_idx,
4609                                                                         NULL) :
4610 # endif
4611                                         va_arg(ap, void *);
4612                         if (ptr_arg != NULL)
4613                             arg_sign = 1;
4614                     }
4615                     else if (fmt_spec == 'b' || fmt_spec == 'B')
4616                     {
4617                         bin_arg =
4618 # if defined(FEAT_EVAL)
4619                                     tvs != NULL ?
4620                                            (uvarnumber_T)tv_nr(tvs, &arg_idx) :
4621 # endif
4622                                         va_arg(ap, uvarnumber_T);
4623                         if (bin_arg != 0)
4624                             arg_sign = 1;
4625                     }
4626                     else if (fmt_spec == 'd')
4627                     {
4628                         /* signed */
4629                         switch (length_modifier)
4630                         {
4631                         case '\0':
4632                         case 'h':
4633                             /* char and short arguments are passed as int. */
4634                             int_arg =
4635 # if defined(FEAT_EVAL)
4636                                         tvs != NULL ? tv_nr(tvs, &arg_idx) :
4637 # endif
4638                                             va_arg(ap, int);
4639                             if (int_arg > 0)
4640                                 arg_sign =  1;
4641                             else if (int_arg < 0)
4642                                 arg_sign = -1;
4643                             break;
4644                         case 'l':
4645                             long_arg =
4646 # if defined(FEAT_EVAL)
4647                                         tvs != NULL ? tv_nr(tvs, &arg_idx) :
4648 # endif
4649                                             va_arg(ap, long int);
4650                             if (long_arg > 0)
4651                                 arg_sign =  1;
4652                             else if (long_arg < 0)
4653                                 arg_sign = -1;
4654                             break;
4655 # ifdef FEAT_NUM64
4656                         case 'L':
4657                             llong_arg =
4658 #  if defined(FEAT_EVAL)
4659                                         tvs != NULL ? tv_nr(tvs, &arg_idx) :
4660 #  endif
4661                                             va_arg(ap, varnumber_T);
4662                             if (llong_arg > 0)
4663                                 arg_sign =  1;
4664                             else if (llong_arg < 0)
4665                                 arg_sign = -1;
4666                             break;
4667 # endif
4668                         }
4669                     }
4670                     else
4671                     {
4672                         /* unsigned */
4673                         switch (length_modifier)
4674                         {
4675                             case '\0':
4676                             case 'h':
4677                                 uint_arg =
4678 # if defined(FEAT_EVAL)
4679                                             tvs != NULL ? (unsigned)
4680                                                         tv_nr(tvs, &arg_idx) :
4681 # endif
4682                                                 va_arg(ap, unsigned int);
4683                                 if (uint_arg != 0)
4684                                     arg_sign = 1;
4685                                 break;
4686                             case 'l':
4687                                 ulong_arg =
4688 # if defined(FEAT_EVAL)
4689                                             tvs != NULL ? (unsigned long)
4690                                                         tv_nr(tvs, &arg_idx) :
4691 # endif
4692                                                 va_arg(ap, unsigned long int);
4693                                 if (ulong_arg != 0)
4694                                     arg_sign = 1;
4695                                 break;
4696 # ifdef FEAT_NUM64
4697                             case 'L':
4698                                 ullong_arg =
4699 #  if defined(FEAT_EVAL)
4700                                             tvs != NULL ? (uvarnumber_T)
4701                                                         tv_nr(tvs, &arg_idx) :
4702 #  endif
4703                                                 va_arg(ap, uvarnumber_T);
4704                                 if (ullong_arg != 0)
4705                                     arg_sign = 1;
4706                                 break;
4707 # endif
4708                         }
4709                     }
4710
4711                     str_arg = tmp;
4712                     str_arg_l = 0;
4713
4714                     /* NOTE:
4715                      *   For d, i, u, o, x, and X conversions, if precision is
4716                      *   specified, the '0' flag should be ignored. This is so
4717                      *   with Solaris 2.6, Digital UNIX 4.0, HPUX 10, Linux,
4718                      *   FreeBSD, NetBSD; but not with Perl.
4719                      */
4720                     if (precision_specified)
4721                         zero_padding = 0;
4722                     if (fmt_spec == 'd')
4723                     {
4724                         if (force_sign && arg_sign >= 0)
4725                             tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
4726                         /* leave negative numbers for sprintf to handle, to
4727                          * avoid handling tricky cases like (short int)-32768 */
4728                     }
4729                     else if (alternate_form)
4730                     {
4731                         if (arg_sign != 0
4732                                      && (fmt_spec == 'b' || fmt_spec == 'B'
4733                                       || fmt_spec == 'x' || fmt_spec == 'X') )
4734                         {
4735                             tmp[str_arg_l++] = '0';
4736                             tmp[str_arg_l++] = fmt_spec;
4737                         }
4738                         /* alternate form should have no effect for p
4739                          * conversion, but ... */
4740                     }
4741
4742                     zero_padding_insertion_ind = str_arg_l;
4743                     if (!precision_specified)
4744                         precision = 1;   /* default precision is 1 */
4745                     if (precision == 0 && arg_sign == 0)
4746                     {
4747                         /* When zero value is formatted with an explicit
4748                          * precision 0, the resulting formatted string is
4749                          * empty (d, i, u, b, B, o, x, X, p).   */
4750                     }
4751                     else
4752                     {
4753                         char    f[6];
4754                         int     f_l = 0;
4755
4756                         /* construct a simple format string for sprintf */
4757                         f[f_l++] = '%';
4758                         if (!length_modifier)
4759                             ;
4760                         else if (length_modifier == 'L')
4761                         {
4762 # ifdef FEAT_NUM64
4763 #  ifdef WIN3264
4764                             f[f_l++] = 'I';
4765                             f[f_l++] = '6';
4766                             f[f_l++] = '4';
4767 #  else
4768                             f[f_l++] = 'l';
4769                             f[f_l++] = 'l';
4770 #  endif
4771 # else
4772                             f[f_l++] = 'l';
4773 # endif
4774                         }
4775                         else
4776                             f[f_l++] = length_modifier;
4777                         f[f_l++] = fmt_spec;
4778                         f[f_l++] = '\0';
4779
4780                         if (fmt_spec == 'p')
4781                             str_arg_l += sprintf(tmp + str_arg_l, f, ptr_arg);
4782                         else if (fmt_spec == 'b' || fmt_spec == 'B')
4783                         {
4784                             char            b[8 * sizeof(uvarnumber_T)];
4785                             size_t          b_l = 0;
4786                             uvarnumber_T    bn = bin_arg;
4787
4788                             do
4789                             {
4790                                 b[sizeof(b) - ++b_l] = '0' + (bn & 0x1);
4791                                 bn >>= 1;
4792                             }
4793                             while (bn != 0);
4794
4795                             memcpy(tmp + str_arg_l, b + sizeof(b) - b_l, b_l);
4796                             str_arg_l += b_l;
4797                         }
4798                         else if (fmt_spec == 'd')
4799                         {
4800                             /* signed */
4801                             switch (length_modifier)
4802                             {
4803                             case '\0':
4804                             case 'h': str_arg_l += sprintf(
4805                                                  tmp + str_arg_l, f, int_arg);
4806                                       break;
4807                             case 'l': str_arg_l += sprintf(
4808                                                 tmp + str_arg_l, f, long_arg);
4809                                       break;
4810 # ifdef FEAT_NUM64
4811                             case 'L': str_arg_l += sprintf(
4812                                                tmp + str_arg_l, f, llong_arg);
4813                                       break;
4814 # endif
4815                             }
4816                         }
4817                         else
4818                         {
4819                             /* unsigned */
4820                             switch (length_modifier)
4821                             {
4822                             case '\0':
4823                             case 'h': str_arg_l += sprintf(
4824                                                 tmp + str_arg_l, f, uint_arg);
4825                                       break;
4826                             case 'l': str_arg_l += sprintf(
4827                                                tmp + str_arg_l, f, ulong_arg);
4828                                       break;
4829 # ifdef FEAT_NUM64
4830                             case 'L': str_arg_l += sprintf(
4831                                               tmp + str_arg_l, f, ullong_arg);
4832                                       break;
4833 # endif
4834                             }
4835                         }
4836
4837                         /* include the optional minus sign and possible
4838                          * "0x" in the region before the zero padding
4839                          * insertion point */
4840                         if (zero_padding_insertion_ind < str_arg_l
4841                                 && tmp[zero_padding_insertion_ind] == '-')
4842                             zero_padding_insertion_ind++;
4843                         if (zero_padding_insertion_ind + 1 < str_arg_l
4844                                 && tmp[zero_padding_insertion_ind]   == '0'
4845                                 && (tmp[zero_padding_insertion_ind + 1] == 'x'
4846                                  || tmp[zero_padding_insertion_ind + 1] == 'X'))
4847                             zero_padding_insertion_ind += 2;
4848                     }
4849
4850                     {
4851                         size_t num_of_digits = str_arg_l
4852                                                  - zero_padding_insertion_ind;
4853
4854                         if (alternate_form && fmt_spec == 'o'
4855                                 /* unless zero is already the first
4856                                  * character */
4857                                 && !(zero_padding_insertion_ind < str_arg_l
4858                                     && tmp[zero_padding_insertion_ind] == '0'))
4859                         {
4860                             /* assure leading zero for alternate-form
4861                              * octal numbers */
4862                             if (!precision_specified
4863                                              || precision < num_of_digits + 1)
4864                             {
4865                                 /* precision is increased to force the
4866                                  * first character to be zero, except if a
4867                                  * zero value is formatted with an
4868                                  * explicit precision of zero */
4869                                 precision = num_of_digits + 1;
4870                                 precision_specified = 1;
4871                             }
4872                         }
4873                         /* zero padding to specified precision? */
4874                         if (num_of_digits < precision)
4875                             number_of_zeros_to_pad = precision - num_of_digits;
4876                     }
4877                     /* zero padding to specified minimal field width? */
4878                     if (!justify_left && zero_padding)
4879                     {
4880                         int n = (int)(min_field_width - (str_arg_l
4881                                                     + number_of_zeros_to_pad));
4882                         if (n > 0)
4883                             number_of_zeros_to_pad += n;
4884                     }
4885                     break;
4886                 }
4887
4888 # ifdef FEAT_FLOAT
4889             case 'f':
4890             case 'F':
4891             case 'e':
4892             case 'E':
4893             case 'g':
4894             case 'G':
4895                 {
4896                     /* Floating point. */
4897                     double      f;
4898                     double      abs_f;
4899                     char        format[40];
4900                     int         l;
4901                     int         remove_trailing_zeroes = FALSE;
4902
4903                     f =
4904 #  if defined(FEAT_EVAL)
4905                         tvs != NULL ? tv_float(tvs, &arg_idx) :
4906 #  endif
4907                             va_arg(ap, double);
4908                     abs_f = f < 0 ? -f : f;
4909
4910                     if (fmt_spec == 'g' || fmt_spec == 'G')
4911                     {
4912                         /* Would be nice to use %g directly, but it prints
4913                          * "1.0" as "1", we don't want that. */
4914                         if ((abs_f >= 0.001 && abs_f < 10000000.0)
4915                                                               || abs_f == 0.0)
4916                             fmt_spec = ASCII_ISUPPER(fmt_spec) ? 'F' : 'f';
4917                         else
4918                             fmt_spec = fmt_spec == 'g' ? 'e' : 'E';
4919                         remove_trailing_zeroes = TRUE;
4920                     }
4921
4922                     if ((fmt_spec == 'f' || fmt_spec == 'F') &&
4923 #  ifdef VAX
4924                             abs_f > 1.0e38
4925 #  else
4926                             abs_f > 1.0e307
4927 #  endif
4928                             )
4929                     {
4930                         /* Avoid a buffer overflow */
4931                         STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
4932                                               force_sign, space_for_positive));
4933                         str_arg_l = STRLEN(tmp);
4934                         zero_padding = 0;
4935                     }
4936                     else
4937                     {
4938                         if (isnan(f))
4939                         {
4940                             /* Not a number: nan or NAN */
4941                             STRCPY(tmp, ASCII_ISUPPER(fmt_spec) ? "NAN"
4942                                                                       : "nan");
4943                             str_arg_l = 3;
4944                             zero_padding = 0;
4945                         }
4946                         else if (isinf(f))
4947                         {
4948                             STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
4949                                               force_sign, space_for_positive));
4950                             str_arg_l = STRLEN(tmp);
4951                             zero_padding = 0;
4952                         }
4953                         else
4954                         {
4955                             /* Regular float number */
4956                             format[0] = '%';
4957                             l = 1;
4958                             if (force_sign)
4959                                 format[l++] = space_for_positive ? ' ' : '+';
4960                             if (precision_specified)
4961                             {
4962                                 size_t max_prec = TMP_LEN - 10;
4963
4964                                 /* Make sure we don't get more digits than we
4965                                  * have room for. */
4966                                 if ((fmt_spec == 'f' || fmt_spec == 'F')
4967                                                                 && abs_f > 1.0)
4968                                     max_prec -= (size_t)log10(abs_f);
4969                                 if (precision > max_prec)
4970                                     precision = max_prec;
4971                                 l += sprintf(format + l, ".%d", (int)precision);
4972                             }
4973                             format[l] = fmt_spec == 'F' ? 'f' : fmt_spec;
4974                             format[l + 1] = NUL;
4975
4976                             str_arg_l = sprintf(tmp, format, f);
4977                         }
4978
4979                         if (remove_trailing_zeroes)
4980                         {
4981                             int i;
4982                             char *tp;
4983
4984                             /* Using %g or %G: remove superfluous zeroes. */
4985                             if (fmt_spec == 'f' || fmt_spec == 'F')
4986                                 tp = tmp + str_arg_l - 1;
4987                             else
4988                             {
4989                                 tp = (char *)vim_strchr((char_u *)tmp,
4990                                                  fmt_spec == 'e' ? 'e' : 'E');
4991                                 if (tp != NULL)
4992                                 {
4993                                     /* Remove superfluous '+' and leading
4994                                      * zeroes from the exponent. */
4995                                     if (tp[1] == '+')
4996                                     {
4997                                         /* Change "1.0e+07" to "1.0e07" */
4998                                         STRMOVE(tp + 1, tp + 2);
4999                                         --str_arg_l;
5000                                     }
5001                                     i = (tp[1] == '-') ? 2 : 1;
5002                                     while (tp[i] == '0')
5003                                     {
5004                                         /* Change "1.0e07" to "1.0e7" */
5005                                         STRMOVE(tp + i, tp + i + 1);
5006                                         --str_arg_l;
5007                                     }
5008                                     --tp;
5009                                 }
5010                             }
5011
5012                             if (tp != NULL && !precision_specified)
5013                                 /* Remove trailing zeroes, but keep the one
5014                                  * just after a dot. */
5015                                 while (tp > tmp + 2 && *tp == '0'
5016                                                              && tp[-1] != '.')
5017                                 {
5018                                     STRMOVE(tp, tp + 1);
5019                                     --tp;
5020                                     --str_arg_l;
5021                                 }
5022                         }
5023                         else
5024                         {
5025                             char *tp;
5026
5027                             /* Be consistent: some printf("%e") use 1.0e+12
5028                              * and some 1.0e+012.  Remove one zero in the last
5029                              * case. */
5030                             tp = (char *)vim_strchr((char_u *)tmp,
5031                                                  fmt_spec == 'e' ? 'e' : 'E');
5032                             if (tp != NULL && (tp[1] == '+' || tp[1] == '-')
5033                                           && tp[2] == '0'
5034                                           && vim_isdigit(tp[3])
5035                                           && vim_isdigit(tp[4]))
5036                             {
5037                                 STRMOVE(tp + 2, tp + 3);
5038                                 --str_arg_l;
5039                             }
5040                         }
5041                     }
5042                     if (zero_padding && min_field_width > str_arg_l
5043                                               && (tmp[0] == '-' || force_sign))
5044                     {
5045                         /* padding 0's should be inserted after the sign */
5046                         number_of_zeros_to_pad = min_field_width - str_arg_l;
5047                         zero_padding_insertion_ind = 1;
5048                     }
5049                     str_arg = tmp;
5050                     break;
5051                 }
5052 # endif
5053
5054             default:
5055                 /* unrecognized conversion specifier, keep format string
5056                  * as-is */
5057                 zero_padding = 0;  /* turn zero padding off for non-numeric
5058                                       conversion */
5059                 justify_left = 1;
5060                 min_field_width = 0;                /* reset flags */
5061
5062                 /* discard the unrecognized conversion, just keep *
5063                  * the unrecognized conversion character          */
5064                 str_arg = p;
5065                 str_arg_l = 0;
5066                 if (*p != NUL)
5067                     str_arg_l++;  /* include invalid conversion specifier
5068                                      unchanged if not at end-of-string */
5069                 break;
5070             }
5071
5072             if (*p != NUL)
5073                 p++;     /* step over the just processed conversion specifier */
5074
5075             /* insert padding to the left as requested by min_field_width;
5076              * this does not include the zero padding in case of numerical
5077              * conversions*/
5078             if (!justify_left)
5079             {
5080                 /* left padding with blank or zero */
5081                 int pn = (int)(min_field_width - (str_arg_l + number_of_zeros_to_pad));
5082
5083                 if (pn > 0)
5084                 {
5085                     if (str_l < str_m)
5086                     {
5087                         size_t avail = str_m - str_l;
5088
5089                         vim_memset(str + str_l, zero_padding ? '0' : ' ',
5090                                              (size_t)pn > avail ? avail
5091                                                                 : (size_t)pn);
5092                     }
5093                     str_l += pn;
5094                 }
5095             }
5096
5097             /* zero padding as requested by the precision or by the minimal
5098              * field width for numeric conversions required? */
5099             if (number_of_zeros_to_pad == 0)
5100             {
5101                 /* will not copy first part of numeric right now, *
5102                  * force it to be copied later in its entirety    */
5103                 zero_padding_insertion_ind = 0;
5104             }
5105             else
5106             {
5107                 /* insert first part of numerics (sign or '0x') before zero
5108                  * padding */
5109                 int zn = (int)zero_padding_insertion_ind;
5110
5111                 if (zn > 0)
5112                 {
5113                     if (str_l < str_m)
5114                     {
5115                         size_t avail = str_m - str_l;
5116
5117                         mch_memmove(str + str_l, str_arg,
5118                                              (size_t)zn > avail ? avail
5119                                                                 : (size_t)zn);
5120                     }
5121                     str_l += zn;
5122                 }
5123
5124                 /* insert zero padding as requested by the precision or min
5125                  * field width */
5126                 zn = (int)number_of_zeros_to_pad;
5127                 if (zn > 0)
5128                 {
5129                     if (str_l < str_m)
5130                     {
5131                         size_t avail = str_m-str_l;
5132
5133                         vim_memset(str + str_l, '0',
5134                                              (size_t)zn > avail ? avail
5135                                                                 : (size_t)zn);
5136                     }
5137                     str_l += zn;
5138                 }
5139             }
5140
5141             /* insert formatted string
5142              * (or as-is conversion specifier for unknown conversions) */
5143             {
5144                 int sn = (int)(str_arg_l - zero_padding_insertion_ind);
5145
5146                 if (sn > 0)
5147                 {
5148                     if (str_l < str_m)
5149                     {
5150                         size_t avail = str_m - str_l;
5151
5152                         mch_memmove(str + str_l,
5153                                 str_arg + zero_padding_insertion_ind,
5154                                 (size_t)sn > avail ? avail : (size_t)sn);
5155                     }
5156                     str_l += sn;
5157                 }
5158             }
5159
5160             /* insert right padding */
5161             if (justify_left)
5162             {
5163                 /* right blank padding to the field width */
5164                 int pn = (int)(min_field_width
5165                                       - (str_arg_l + number_of_zeros_to_pad));
5166
5167                 if (pn > 0)
5168                 {
5169                     if (str_l < str_m)
5170                     {
5171                         size_t avail = str_m - str_l;
5172
5173                         vim_memset(str + str_l, ' ',
5174                                              (size_t)pn > avail ? avail
5175                                                                 : (size_t)pn);
5176                     }
5177                     str_l += pn;
5178                 }
5179             }
5180             vim_free(tofree);
5181         }
5182     }
5183
5184     if (str_m > 0)
5185     {
5186         /* make sure the string is nul-terminated even at the expense of
5187          * overwriting the last character (shouldn't happen, but just in case)
5188          * */
5189         str[str_l <= str_m - 1 ? str_l : str_m - 1] = '\0';
5190     }
5191
5192     if (tvs != NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN)
5193         EMSG(_("E767: Too many arguments to printf()"));
5194
5195     /* Return the number of characters formatted (excluding trailing nul
5196      * character), that is, the number of characters that would have been
5197      * written to the buffer if it were large enough. */
5198     return (int)str_l;
5199 }
5200
5201 #endif /* PROTO */