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