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