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