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 int msg_check_screen(void); 32 static void redir_write(char_u *s, int maxlen); 33 #ifdef FEAT_CON_DIALOG 34 static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfltbutton); 35 static int confirm_msg_used = FALSE; /* displaying confirm_msg */ 36 static char_u *confirm_msg = NULL; /* ":confirm" message */ 37 static char_u *confirm_msg_tail; /* tail of confirm_msg */ 38 #endif 39 #ifdef FEAT_JOB_CHANNEL 40 static int emsg_to_channel_log = FALSE; 41 #endif 42 43 struct msg_hist 44 { 45 struct msg_hist *next; 46 char_u *msg; 47 int attr; 48 }; 49 50 static struct msg_hist *first_msg_hist = NULL; 51 static struct msg_hist *last_msg_hist = NULL; 52 static int msg_hist_len = 0; 53 54 static FILE *verbose_fd = NULL; 55 static int verbose_did_open = FALSE; 56 57 /* 58 * When writing messages to the screen, there are many different situations. 59 * A number of variables is used to remember the current state: 60 * msg_didany TRUE when messages were written since the last time the 61 * user reacted to a prompt. 62 * Reset: After hitting a key for the hit-return prompt, 63 * hitting <CR> for the command line or input(). 64 * Set: When any message is written to the screen. 65 * msg_didout TRUE when something was written to the current line. 66 * Reset: When advancing to the next line, when the current 67 * text can be overwritten. 68 * Set: When any message is written to the screen. 69 * msg_nowait No extra delay for the last drawn message. 70 * Used in normal_cmd() before the mode message is drawn. 71 * emsg_on_display There was an error message recently. Indicates that there 72 * should be a delay before redrawing. 73 * msg_scroll The next message should not overwrite the current one. 74 * msg_scrolled How many lines the screen has been scrolled (because of 75 * messages). Used in update_screen() to scroll the screen 76 * back. Incremented each time the screen scrolls a line. 77 * msg_scrolled_ign TRUE when msg_scrolled is non-zero and msg_puts_attr() 78 * writes something without scrolling should not make 79 * need_wait_return to be set. This is a hack to make ":ts" 80 * work without an extra prompt. 81 * lines_left Number of lines available for messages before the 82 * more-prompt is to be given. -1 when not set. 83 * need_wait_return TRUE when the hit-return prompt is needed. 84 * Reset: After giving the hit-return prompt, when the user 85 * has answered some other prompt. 86 * Set: When the ruler or typeahead display is overwritten, 87 * scrolling the screen for some message. 88 * keep_msg Message to be displayed after redrawing the screen, in 89 * main_loop(). 90 * This is an allocated string or NULL when not used. 91 */ 92 93 /* 94 * msg(s) - displays the string 's' on the status line 95 * When terminal not initialized (yet) mch_errmsg(..) is used. 96 * return TRUE if wait_return not called 97 */ 98 int 99 msg(char *s) 100 { 101 return msg_attr_keep(s, 0, FALSE); 102 } 103 104 /* 105 * Like msg() but keep it silent when 'verbosefile' is set. 106 */ 107 int 108 verb_msg(char *s) 109 { 110 int n; 111 112 verbose_enter(); 113 n = msg_attr_keep(s, 0, FALSE); 114 verbose_leave(); 115 116 return n; 117 } 118 119 int 120 msg_attr(char *s, int attr) 121 { 122 return msg_attr_keep(s, attr, FALSE); 123 } 124 125 int 126 msg_attr_keep( 127 char *s, 128 int attr, 129 int keep) /* TRUE: set keep_msg if it doesn't scroll */ 130 { 131 static int entered = 0; 132 int retval; 133 char_u *buf = NULL; 134 135 /* Skip messages not matching ":filter pattern". 136 * Don't filter when there is an error. */ 137 if (!emsg_on_display && message_filtered((char_u *)s)) 138 return TRUE; 139 140 #ifdef FEAT_EVAL 141 if (attr == 0) 142 set_vim_var_string(VV_STATUSMSG, (char_u *)s, -1); 143 #endif 144 145 /* 146 * It is possible that displaying a messages causes a problem (e.g., 147 * when redrawing the window), which causes another message, etc.. To 148 * break this loop, limit the recursiveness to 3 levels. 149 */ 150 if (entered >= 3) 151 return TRUE; 152 ++entered; 153 154 /* Add message to history (unless it's a repeated kept message or a 155 * truncated message) */ 156 if ((char_u *)s != keep_msg 157 || (*s != '<' 158 && last_msg_hist != NULL 159 && last_msg_hist->msg != NULL 160 && STRCMP(s, last_msg_hist->msg))) 161 add_msg_hist((char_u *)s, -1, attr); 162 163 #ifdef FEAT_JOB_CHANNEL 164 if (emsg_to_channel_log) 165 /* Write message in the channel log. */ 166 ch_log(NULL, "ERROR: %s", (char *)s); 167 #endif 168 169 /* When displaying keep_msg, don't let msg_start() free it, caller must do 170 * that. */ 171 if ((char_u *)s == keep_msg) 172 keep_msg = NULL; 173 174 /* Truncate the message if needed. */ 175 msg_start(); 176 buf = msg_strtrunc((char_u *)s, FALSE); 177 if (buf != NULL) 178 s = (char *)buf; 179 180 msg_outtrans_attr((char_u *)s, attr); 181 msg_clr_eos(); 182 retval = msg_end(); 183 184 if (keep && retval && vim_strsize((char_u *)s) 185 < (int)(Rows - cmdline_row - 1) * Columns + sc_col) 186 set_keep_msg((char_u *)s, 0); 187 188 vim_free(buf); 189 --entered; 190 return retval; 191 } 192 193 /* 194 * Truncate a string such that it can be printed without causing a scroll. 195 * Returns an allocated string or NULL when no truncating is done. 196 */ 197 char_u * 198 msg_strtrunc( 199 char_u *s, 200 int force) /* always truncate */ 201 { 202 char_u *buf = NULL; 203 int len; 204 int room; 205 206 /* May truncate message to avoid a hit-return prompt */ 207 if ((!msg_scroll && !need_wait_return && shortmess(SHM_TRUNCALL) 208 && !exmode_active && msg_silent == 0) || force) 209 { 210 len = vim_strsize(s); 211 if (msg_scrolled != 0) 212 /* Use all the columns. */ 213 room = (int)(Rows - msg_row) * Columns - 1; 214 else 215 /* Use up to 'showcmd' column. */ 216 room = (int)(Rows - msg_row - 1) * Columns + sc_col - 1; 217 if (len > room && room > 0) 218 { 219 if (enc_utf8) 220 /* may have up to 18 bytes per cell (6 per char, up to two 221 * composing chars) */ 222 len = (room + 2) * 18; 223 else if (enc_dbcs == DBCS_JPNU) 224 /* may have up to 2 bytes per cell for euc-jp */ 225 len = (room + 2) * 2; 226 else 227 len = room + 2; 228 buf = alloc(len); 229 if (buf != NULL) 230 trunc_string(s, buf, room, len); 231 } 232 } 233 return buf; 234 } 235 236 /* 237 * Truncate a string "s" to "buf" with cell width "room". 238 * "s" and "buf" may be equal. 239 */ 240 void 241 trunc_string( 242 char_u *s, 243 char_u *buf, 244 int room_in, 245 int buflen) 246 { 247 size_t room = room_in - 3; /* "..." takes 3 chars */ 248 size_t half; 249 size_t len = 0; 250 int e; 251 int i; 252 int n; 253 254 if (room_in < 3) 255 room = 0; 256 half = room / 2; 257 258 /* First part: Start of the string. */ 259 for (e = 0; len < half && e < buflen; ++e) 260 { 261 if (s[e] == NUL) 262 { 263 /* text fits without truncating! */ 264 buf[e] = NUL; 265 return; 266 } 267 n = ptr2cells(s + e); 268 if (len + n > half) 269 break; 270 len += n; 271 buf[e] = s[e]; 272 if (has_mbyte) 273 for (n = (*mb_ptr2len)(s + e); --n > 0; ) 274 { 275 if (++e == buflen) 276 break; 277 buf[e] = s[e]; 278 } 279 } 280 281 /* Last part: End of the string. */ 282 i = e; 283 if (enc_dbcs != 0) 284 { 285 /* For DBCS going backwards in a string is slow, but 286 * computing the cell width isn't too slow: go forward 287 * until the rest fits. */ 288 n = vim_strsize(s + i); 289 while (len + n > room) 290 { 291 n -= ptr2cells(s + i); 292 i += (*mb_ptr2len)(s + i); 293 } 294 } 295 else if (enc_utf8) 296 { 297 /* For UTF-8 we can go backwards easily. */ 298 half = i = (int)STRLEN(s); 299 for (;;) 300 { 301 do 302 half = half - utf_head_off(s, s + half - 1) - 1; 303 while (half > 0 && utf_iscomposing(utf_ptr2char(s + half))); 304 n = ptr2cells(s + half); 305 if (len + n > room || half == 0) 306 break; 307 len += n; 308 i = (int)half; 309 } 310 } 311 else 312 { 313 for (i = (int)STRLEN(s); len + (n = ptr2cells(s + i - 1)) <= room; --i) 314 len += n; 315 } 316 317 318 if (i <= e + 3) 319 { 320 /* text fits without truncating */ 321 if (s != buf) 322 { 323 len = STRLEN(s); 324 if (len >= (size_t)buflen) 325 len = buflen - 1; 326 len = len - e + 1; 327 if (len < 1) 328 buf[e - 1] = NUL; 329 else 330 mch_memmove(buf + e, s + e, len); 331 } 332 } 333 else if (e + 3 < buflen) 334 { 335 /* set the middle and copy the last part */ 336 mch_memmove(buf + e, "...", (size_t)3); 337 len = STRLEN(s + i) + 1; 338 if (len >= (size_t)buflen - e - 3) 339 len = buflen - e - 3 - 1; 340 mch_memmove(buf + e + 3, s + i, len); 341 buf[e + 3 + len - 1] = NUL; 342 } 343 else 344 { 345 /* can't fit in the "...", just truncate it */ 346 buf[e - 1] = NUL; 347 } 348 } 349 350 /* 351 * Automatic prototype generation does not understand this function. 352 * Note: Caller of smsg() and smsg_attr() must check the resulting string is 353 * shorter than IOSIZE!!! 354 */ 355 #ifndef PROTO 356 357 int vim_snprintf(char *str, size_t str_m, const char *fmt, ...); 358 359 int 360 smsg(const char *s, ...) 361 { 362 va_list arglist; 363 364 va_start(arglist, s); 365 vim_vsnprintf((char *)IObuff, IOSIZE, s, arglist); 366 va_end(arglist); 367 return msg((char *)IObuff); 368 } 369 370 int 371 smsg_attr(int attr, const char *s, ...) 372 { 373 va_list arglist; 374 375 va_start(arglist, s); 376 vim_vsnprintf((char *)IObuff, IOSIZE, s, arglist); 377 va_end(arglist); 378 return msg_attr((char *)IObuff, attr); 379 } 380 381 int 382 smsg_attr_keep(int attr, const char *s, ...) 383 { 384 va_list arglist; 385 386 va_start(arglist, s); 387 vim_vsnprintf((char *)IObuff, IOSIZE, s, arglist); 388 va_end(arglist); 389 return msg_attr_keep((char *)IObuff, attr, TRUE); 390 } 391 392 #endif 393 394 /* 395 * Remember the last sourcing name/lnum used in an error message, so that it 396 * isn't printed each time when it didn't change. 397 */ 398 static int last_sourcing_lnum = 0; 399 static char_u *last_sourcing_name = NULL; 400 401 /* 402 * Reset the last used sourcing name/lnum. Makes sure it is displayed again 403 * for the next error message; 404 */ 405 void 406 reset_last_sourcing(void) 407 { 408 VIM_CLEAR(last_sourcing_name); 409 last_sourcing_lnum = 0; 410 } 411 412 /* 413 * Return TRUE if "sourcing_name" differs from "last_sourcing_name". 414 */ 415 static int 416 other_sourcing_name(void) 417 { 418 if (sourcing_name != NULL) 419 { 420 if (last_sourcing_name != NULL) 421 return STRCMP(sourcing_name, last_sourcing_name) != 0; 422 return TRUE; 423 } 424 return FALSE; 425 } 426 427 /* 428 * Get the message about the source, as used for an error message. 429 * Returns an allocated string with room for one more character. 430 * Returns NULL when no message is to be given. 431 */ 432 static char_u * 433 get_emsg_source(void) 434 { 435 char_u *Buf, *p; 436 437 if (sourcing_name != NULL && other_sourcing_name()) 438 { 439 p = (char_u *)_("Error detected while processing %s:"); 440 Buf = alloc(STRLEN(sourcing_name) + STRLEN(p)); 441 if (Buf != NULL) 442 sprintf((char *)Buf, (char *)p, sourcing_name); 443 return Buf; 444 } 445 return NULL; 446 } 447 448 /* 449 * Get the message about the source lnum, as used for an error message. 450 * Returns an allocated string with room for one more character. 451 * Returns NULL when no message is to be given. 452 */ 453 static char_u * 454 get_emsg_lnum(void) 455 { 456 char_u *Buf, *p; 457 458 /* lnum is 0 when executing a command from the command line 459 * argument, we don't want a line number then */ 460 if (sourcing_name != NULL 461 && (other_sourcing_name() || sourcing_lnum != last_sourcing_lnum) 462 && sourcing_lnum != 0) 463 { 464 p = (char_u *)_("line %4ld:"); 465 Buf = alloc(STRLEN(p) + 20); 466 if (Buf != NULL) 467 sprintf((char *)Buf, (char *)p, (long)sourcing_lnum); 468 return Buf; 469 } 470 return NULL; 471 } 472 473 /* 474 * Display name and line number for the source of an error. 475 * Remember the file name and line number, so that for the next error the info 476 * is only displayed if it changed. 477 */ 478 void 479 msg_source(int attr) 480 { 481 char_u *p; 482 483 ++no_wait_return; 484 p = get_emsg_source(); 485 if (p != NULL) 486 { 487 msg_attr((char *)p, attr); 488 vim_free(p); 489 } 490 p = get_emsg_lnum(); 491 if (p != NULL) 492 { 493 msg_attr((char *)p, HL_ATTR(HLF_N)); 494 vim_free(p); 495 last_sourcing_lnum = sourcing_lnum; /* only once for each line */ 496 } 497 498 /* remember the last sourcing name printed, also when it's empty */ 499 if (sourcing_name == NULL || other_sourcing_name()) 500 { 501 vim_free(last_sourcing_name); 502 if (sourcing_name == NULL) 503 last_sourcing_name = NULL; 504 else 505 last_sourcing_name = vim_strsave(sourcing_name); 506 } 507 --no_wait_return; 508 } 509 510 /* 511 * Return TRUE if not giving error messages right now: 512 * If "emsg_off" is set: no error messages at the moment. 513 * If "msg" is in 'debug': do error message but without side effects. 514 * If "emsg_skip" is set: never do error messages. 515 */ 516 int 517 emsg_not_now(void) 518 { 519 if ((emsg_off > 0 && vim_strchr(p_debug, 'm') == NULL 520 && vim_strchr(p_debug, 't') == NULL) 521 #ifdef FEAT_EVAL 522 || emsg_skip > 0 523 #endif 524 ) 525 return TRUE; 526 return FALSE; 527 } 528 529 #if defined(FEAT_EVAL) || defined(PROTO) 530 static garray_T ignore_error_list = GA_EMPTY; 531 532 void 533 ignore_error_for_testing(char_u *error) 534 { 535 if (ignore_error_list.ga_itemsize == 0) 536 ga_init2(&ignore_error_list, sizeof(char_u *), 1); 537 538 if (STRCMP("RESET", error) == 0) 539 ga_clear_strings(&ignore_error_list); 540 else 541 ga_add_string(&ignore_error_list, error); 542 } 543 544 static int 545 ignore_error(char_u *msg) 546 { 547 int i; 548 549 for (i = 0; i < ignore_error_list.ga_len; ++i) 550 if (strstr((char *)msg, 551 (char *)((char_u **)(ignore_error_list.ga_data))[i]) != NULL) 552 return TRUE; 553 return FALSE; 554 } 555 #endif 556 557 #if !defined(HAVE_STRERROR) || defined(PROTO) 558 /* 559 * Replacement for perror() that behaves more or less like emsg() was called. 560 * v:errmsg will be set and called_emsg will be set. 561 */ 562 void 563 do_perror(char *msg) 564 { 565 perror(msg); 566 ++emsg_silent; 567 emsg(msg); 568 --emsg_silent; 569 } 570 #endif 571 572 /* 573 * emsg_core() - display an error message 574 * 575 * Rings the bell, if appropriate, and calls message() to do the real work 576 * When terminal not initialized (yet) mch_errmsg(..) is used. 577 * 578 * Return TRUE if wait_return not called. 579 * Note: caller must check 'emsg_not_now()' before calling this. 580 */ 581 static int 582 emsg_core(char_u *s) 583 { 584 int attr; 585 char_u *p; 586 int r; 587 #ifdef FEAT_EVAL 588 int ignore = FALSE; 589 int severe; 590 #endif 591 592 #ifdef FEAT_EVAL 593 /* When testing some errors are turned into a normal message. */ 594 if (ignore_error(s)) 595 /* don't call msg() if it results in a dialog */ 596 return msg_use_printf() ? FALSE : msg((char *)s); 597 #endif 598 599 called_emsg = TRUE; 600 601 #ifdef FEAT_EVAL 602 /* If "emsg_severe" is TRUE: When an error exception is to be thrown, 603 * prefer this message over previous messages for the same command. */ 604 severe = emsg_severe; 605 emsg_severe = FALSE; 606 #endif 607 608 if (!emsg_off || vim_strchr(p_debug, 't') != NULL) 609 { 610 #ifdef FEAT_EVAL 611 /* 612 * Cause a throw of an error exception if appropriate. Don't display 613 * the error message in this case. (If no matching catch clause will 614 * be found, the message will be displayed later on.) "ignore" is set 615 * when the message should be ignored completely (used for the 616 * interrupt message). 617 */ 618 if (cause_errthrow(s, severe, &ignore) == TRUE) 619 { 620 if (!ignore) 621 ++did_emsg; 622 return TRUE; 623 } 624 625 /* set "v:errmsg", also when using ":silent! cmd" */ 626 set_vim_var_string(VV_ERRMSG, s, -1); 627 #endif 628 629 /* 630 * When using ":silent! cmd" ignore error messages. 631 * But do write it to the redirection file. 632 */ 633 if (emsg_silent != 0) 634 { 635 if (emsg_noredir == 0) 636 { 637 msg_start(); 638 p = get_emsg_source(); 639 if (p != NULL) 640 { 641 STRCAT(p, "\n"); 642 redir_write(p, -1); 643 vim_free(p); 644 } 645 p = get_emsg_lnum(); 646 if (p != NULL) 647 { 648 STRCAT(p, "\n"); 649 redir_write(p, -1); 650 vim_free(p); 651 } 652 redir_write(s, -1); 653 } 654 #ifdef FEAT_JOB_CHANNEL 655 ch_log(NULL, "ERROR: %s", (char *)s); 656 #endif 657 return TRUE; 658 } 659 660 ex_exitval = 1; 661 662 /* Reset msg_silent, an error causes messages to be switched back on. 663 */ 664 msg_silent = 0; 665 cmd_silent = FALSE; 666 667 if (global_busy) /* break :global command */ 668 ++global_busy; 669 670 if (p_eb) 671 beep_flush(); /* also includes flush_buffers() */ 672 else 673 flush_buffers(FLUSH_MINIMAL); // flush internal buffers 674 ++did_emsg; // flag for DoOneCmd() 675 #ifdef FEAT_EVAL 676 did_uncaught_emsg = TRUE; 677 #endif 678 } 679 680 emsg_on_display = TRUE; /* remember there is an error message */ 681 ++msg_scroll; /* don't overwrite a previous message */ 682 attr = HL_ATTR(HLF_E); /* set highlight mode for error messages */ 683 if (msg_scrolled != 0) 684 need_wait_return = TRUE; /* needed in case emsg() is called after 685 * wait_return has reset need_wait_return 686 * and a redraw is expected because 687 * msg_scrolled is non-zero */ 688 689 #ifdef FEAT_JOB_CHANNEL 690 emsg_to_channel_log = TRUE; 691 #endif 692 /* 693 * Display name and line number for the source of the error. 694 */ 695 msg_source(attr); 696 697 /* 698 * Display the error message itself. 699 */ 700 msg_nowait = FALSE; /* wait for this msg */ 701 r = msg_attr((char *)s, attr); 702 703 #ifdef FEAT_JOB_CHANNEL 704 emsg_to_channel_log = FALSE; 705 #endif 706 return r; 707 } 708 709 /* 710 * Print an error message. 711 */ 712 int 713 emsg(char *s) 714 { 715 /* Skip this if not giving error messages at the moment. */ 716 if (!emsg_not_now()) 717 return emsg_core((char_u *)s); 718 return TRUE; /* no error messages at the moment */ 719 } 720 721 #ifndef PROTO // manual proto with __attribute__ 722 /* 723 * Print an error message with format string and variable arguments. 724 * Note: caller must not pass 'IObuff' as 1st argument. 725 */ 726 int 727 semsg(const char *s, ...) 728 { 729 /* Skip this if not giving error messages at the moment. */ 730 if (!emsg_not_now()) 731 { 732 va_list ap; 733 734 va_start(ap, s); 735 vim_vsnprintf((char *)IObuff, IOSIZE, s, ap); 736 va_end(ap); 737 return emsg_core(IObuff); 738 } 739 return TRUE; /* no error messages at the moment */ 740 } 741 #endif 742 743 /* 744 * Same as emsg(...), but abort on error when ABORT_ON_INTERNAL_ERROR is 745 * defined. It is used for internal errors only, so that they can be 746 * detected when fuzzing vim. 747 */ 748 void 749 iemsg(char *s) 750 { 751 if (!emsg_not_now()) 752 emsg_core((char_u *)s); 753 #ifdef ABORT_ON_INTERNAL_ERROR 754 abort(); 755 #endif 756 } 757 758 #ifndef PROTO // manual proto with __attribute__ 759 /* 760 * Same as semsg(...) but abort on error when ABORT_ON_INTERNAL_ERROR is 761 * defined. It is used for internal errors only, so that they can be 762 * detected when fuzzing vim. 763 * Note: caller must not pass 'IObuff' as 1st argument. 764 */ 765 void 766 siemsg(const char *s, ...) 767 { 768 if (!emsg_not_now()) 769 { 770 va_list ap; 771 772 va_start(ap, s); 773 vim_vsnprintf((char *)IObuff, IOSIZE, s, ap); 774 va_end(ap); 775 emsg_core(IObuff); 776 } 777 # ifdef ABORT_ON_INTERNAL_ERROR 778 abort(); 779 # endif 780 } 781 #endif 782 783 /* 784 * Give an "Internal error" message. 785 */ 786 void 787 internal_error(char *where) 788 { 789 siemsg(_(e_intern2), where); 790 } 791 792 /* emsg3() and emsgn() are in misc2.c to avoid warnings for the prototypes. */ 793 794 void 795 emsg_invreg(int name) 796 { 797 semsg(_("E354: Invalid register name: '%s'"), transchar(name)); 798 } 799 800 /* 801 * Like msg(), but truncate to a single line if p_shm contains 't', or when 802 * "force" is TRUE. This truncates in another way as for normal messages. 803 * Careful: The string may be changed by msg_may_trunc()! 804 * Returns a pointer to the printed message, if wait_return() not called. 805 */ 806 char * 807 msg_trunc_attr(char *s, int force, int attr) 808 { 809 int n; 810 char *ts; 811 812 /* Add message to history before truncating */ 813 add_msg_hist((char_u *)s, -1, attr); 814 815 ts = (char *)msg_may_trunc(force, (char_u *)s); 816 817 msg_hist_off = TRUE; 818 n = msg_attr(ts, attr); 819 msg_hist_off = FALSE; 820 821 if (n) 822 return ts; 823 return NULL; 824 } 825 826 /* 827 * Check if message "s" should be truncated at the start (for filenames). 828 * Return a pointer to where the truncated message starts. 829 * Note: May change the message by replacing a character with '<'. 830 */ 831 char_u * 832 msg_may_trunc(int force, char_u *s) 833 { 834 int n; 835 int room; 836 837 room = (int)(Rows - cmdline_row - 1) * Columns + sc_col - 1; 838 if ((force || (shortmess(SHM_TRUNC) && !exmode_active)) 839 && (n = (int)STRLEN(s) - room) > 0) 840 { 841 if (has_mbyte) 842 { 843 int size = vim_strsize(s); 844 845 /* There may be room anyway when there are multibyte chars. */ 846 if (size <= room) 847 return s; 848 849 for (n = 0; size >= room; ) 850 { 851 size -= (*mb_ptr2cells)(s + n); 852 n += (*mb_ptr2len)(s + n); 853 } 854 --n; 855 } 856 s += n; 857 *s = '<'; 858 } 859 return s; 860 } 861 862 static void 863 add_msg_hist( 864 char_u *s, 865 int len, /* -1 for undetermined length */ 866 int attr) 867 { 868 struct msg_hist *p; 869 870 if (msg_hist_off || msg_silent != 0) 871 return; 872 873 /* Don't let the message history get too big */ 874 while (msg_hist_len > MAX_MSG_HIST_LEN) 875 (void)delete_first_msg(); 876 877 /* allocate an entry and add the message at the end of the history */ 878 p = ALLOC_ONE(struct msg_hist); 879 if (p != NULL) 880 { 881 if (len < 0) 882 len = (int)STRLEN(s); 883 /* remove leading and trailing newlines */ 884 while (len > 0 && *s == '\n') 885 { 886 ++s; 887 --len; 888 } 889 while (len > 0 && s[len - 1] == '\n') 890 --len; 891 p->msg = vim_strnsave(s, len); 892 p->next = NULL; 893 p->attr = attr; 894 if (last_msg_hist != NULL) 895 last_msg_hist->next = p; 896 last_msg_hist = p; 897 if (first_msg_hist == NULL) 898 first_msg_hist = last_msg_hist; 899 ++msg_hist_len; 900 } 901 } 902 903 /* 904 * Delete the first (oldest) message from the history. 905 * Returns FAIL if there are no messages. 906 */ 907 int 908 delete_first_msg(void) 909 { 910 struct msg_hist *p; 911 912 if (msg_hist_len <= 0) 913 return FAIL; 914 p = first_msg_hist; 915 first_msg_hist = p->next; 916 if (first_msg_hist == NULL) 917 last_msg_hist = NULL; /* history is empty */ 918 vim_free(p->msg); 919 vim_free(p); 920 --msg_hist_len; 921 return OK; 922 } 923 924 /* 925 * ":messages" command. 926 */ 927 void 928 ex_messages(exarg_T *eap) 929 { 930 struct msg_hist *p; 931 char_u *s; 932 int c = 0; 933 934 if (STRCMP(eap->arg, "clear") == 0) 935 { 936 int keep = eap->addr_count == 0 ? 0 : eap->line2; 937 938 while (msg_hist_len > keep) 939 (void)delete_first_msg(); 940 return; 941 } 942 943 if (*eap->arg != NUL) 944 { 945 emsg(_(e_invarg)); 946 return; 947 } 948 949 msg_hist_off = TRUE; 950 951 p = first_msg_hist; 952 if (eap->addr_count != 0) 953 { 954 /* Count total messages */ 955 for (; p != NULL && !got_int; p = p->next) 956 c++; 957 958 c -= eap->line2; 959 960 /* Skip without number of messages specified */ 961 for (p = first_msg_hist; p != NULL && !got_int && c > 0; 962 p = p->next, c--); 963 } 964 965 if (p == first_msg_hist) 966 { 967 s = mch_getenv((char_u *)"LANG"); 968 if (s != NULL && *s != NUL) 969 // The next comment is extracted by xgettext and put in po file for 970 // translators to read. 971 msg_attr( 972 // Translator: Please replace the name and email address 973 // with the appropriate text for your translation. 974 _("Messages maintainer: Bram Moolenaar <[email protected]>"), 975 HL_ATTR(HLF_T)); 976 } 977 978 /* Display what was not skipped. */ 979 for (; p != NULL && !got_int; p = p->next) 980 if (p->msg != NULL) 981 msg_attr((char *)p->msg, p->attr); 982 983 msg_hist_off = FALSE; 984 } 985 986 #if defined(FEAT_CON_DIALOG) || defined(FIND_REPLACE_DIALOG) || defined(PROTO) 987 /* 988 * Call this after prompting the user. This will avoid a hit-return message 989 * and a delay. 990 */ 991 void 992 msg_end_prompt(void) 993 { 994 need_wait_return = FALSE; 995 emsg_on_display = FALSE; 996 cmdline_row = msg_row; 997 msg_col = 0; 998 msg_clr_eos(); 999 lines_left = -1; 1000 } 1001 #endif 1002 1003 /* 1004 * Wait for the user to hit a key (normally Enter). 1005 * If "redraw" is TRUE, clear and redraw the screen. 1006 * If "redraw" is FALSE, just redraw the screen. 1007 * If "redraw" is -1, don't redraw at all. 1008 */ 1009 void 1010 wait_return(int redraw) 1011 { 1012 int c; 1013 int oldState; 1014 int tmpState; 1015 int had_got_int; 1016 int save_reg_recording; 1017 FILE *save_scriptout; 1018 1019 if (redraw == TRUE) 1020 must_redraw = CLEAR; 1021 1022 /* If using ":silent cmd", don't wait for a return. Also don't set 1023 * need_wait_return to do it later. */ 1024 if (msg_silent != 0) 1025 return; 1026 1027 /* 1028 * When inside vgetc(), we can't wait for a typed character at all. 1029 * With the global command (and some others) we only need one return at 1030 * the end. Adjust cmdline_row to avoid the next message overwriting the 1031 * last one. 1032 */ 1033 if (vgetc_busy > 0) 1034 return; 1035 need_wait_return = TRUE; 1036 if (no_wait_return) 1037 { 1038 if (!exmode_active) 1039 cmdline_row = msg_row; 1040 return; 1041 } 1042 1043 redir_off = TRUE; /* don't redirect this message */ 1044 oldState = State; 1045 if (quit_more) 1046 { 1047 c = CAR; /* just pretend CR was hit */ 1048 quit_more = FALSE; 1049 got_int = FALSE; 1050 } 1051 else if (exmode_active) 1052 { 1053 msg_puts(" "); /* make sure the cursor is on the right line */ 1054 c = CAR; /* no need for a return in ex mode */ 1055 got_int = FALSE; 1056 } 1057 else 1058 { 1059 /* Make sure the hit-return prompt is on screen when 'guioptions' was 1060 * just changed. */ 1061 screenalloc(FALSE); 1062 1063 State = HITRETURN; 1064 #ifdef FEAT_MOUSE 1065 setmouse(); 1066 #endif 1067 #ifdef USE_ON_FLY_SCROLL 1068 dont_scroll = TRUE; /* disallow scrolling here */ 1069 #endif 1070 cmdline_row = msg_row; 1071 1072 /* Avoid the sequence that the user types ":" at the hit-return prompt 1073 * to start an Ex command, but the file-changed dialog gets in the 1074 * way. */ 1075 if (need_check_timestamps) 1076 check_timestamps(FALSE); 1077 1078 hit_return_msg(); 1079 1080 do 1081 { 1082 /* Remember "got_int", if it is set vgetc() probably returns a 1083 * CTRL-C, but we need to loop then. */ 1084 had_got_int = got_int; 1085 1086 /* Don't do mappings here, we put the character back in the 1087 * typeahead buffer. */ 1088 ++no_mapping; 1089 ++allow_keys; 1090 1091 /* Temporarily disable Recording. If Recording is active, the 1092 * character will be recorded later, since it will be added to the 1093 * typebuf after the loop */ 1094 save_reg_recording = reg_recording; 1095 save_scriptout = scriptout; 1096 reg_recording = 0; 1097 scriptout = NULL; 1098 c = safe_vgetc(); 1099 if (had_got_int && !global_busy) 1100 got_int = FALSE; 1101 --no_mapping; 1102 --allow_keys; 1103 reg_recording = save_reg_recording; 1104 scriptout = save_scriptout; 1105 1106 #ifdef FEAT_CLIPBOARD 1107 /* Strange way to allow copying (yanking) a modeless selection at 1108 * the hit-enter prompt. Use CTRL-Y, because the same is used in 1109 * Cmdline-mode and it's harmless when there is no selection. */ 1110 if (c == Ctrl_Y && clip_star.state == SELECT_DONE) 1111 { 1112 clip_copy_modeless_selection(TRUE); 1113 c = K_IGNORE; 1114 } 1115 #endif 1116 1117 /* 1118 * Allow scrolling back in the messages. 1119 * Also accept scroll-down commands when messages fill the screen, 1120 * to avoid that typing one 'j' too many makes the messages 1121 * disappear. 1122 */ 1123 if (p_more && !p_cp) 1124 { 1125 if (c == 'b' || c == 'k' || c == 'u' || c == 'g' 1126 || c == K_UP || c == K_PAGEUP) 1127 { 1128 if (msg_scrolled > Rows) 1129 /* scroll back to show older messages */ 1130 do_more_prompt(c); 1131 else 1132 { 1133 msg_didout = FALSE; 1134 c = K_IGNORE; 1135 msg_col = 1136 #ifdef FEAT_RIGHTLEFT 1137 cmdmsg_rl ? Columns - 1 : 1138 #endif 1139 0; 1140 } 1141 if (quit_more) 1142 { 1143 c = CAR; /* just pretend CR was hit */ 1144 quit_more = FALSE; 1145 got_int = FALSE; 1146 } 1147 else if (c != K_IGNORE) 1148 { 1149 c = K_IGNORE; 1150 hit_return_msg(); 1151 } 1152 } 1153 else if (msg_scrolled > Rows - 2 1154 && (c == 'j' || c == 'd' || c == 'f' 1155 || c == K_DOWN || c == K_PAGEDOWN)) 1156 c = K_IGNORE; 1157 } 1158 } while ((had_got_int && c == Ctrl_C) 1159 || c == K_IGNORE 1160 #ifdef FEAT_GUI 1161 || c == K_VER_SCROLLBAR || c == K_HOR_SCROLLBAR 1162 #endif 1163 #ifdef FEAT_MOUSE 1164 || c == K_LEFTDRAG || c == K_LEFTRELEASE 1165 || c == K_MIDDLEDRAG || c == K_MIDDLERELEASE 1166 || c == K_RIGHTDRAG || c == K_RIGHTRELEASE 1167 || c == K_MOUSELEFT || c == K_MOUSERIGHT 1168 || c == K_MOUSEDOWN || c == K_MOUSEUP 1169 || c == K_MOUSEMOVE 1170 || (!mouse_has(MOUSE_RETURN) 1171 && mouse_row < msg_row 1172 && (c == K_LEFTMOUSE 1173 || c == K_MIDDLEMOUSE 1174 || c == K_RIGHTMOUSE 1175 || c == K_X1MOUSE 1176 || c == K_X2MOUSE)) 1177 #endif 1178 ); 1179 ui_breakcheck(); 1180 #ifdef FEAT_MOUSE 1181 /* 1182 * Avoid that the mouse-up event causes visual mode to start. 1183 */ 1184 if (c == K_LEFTMOUSE || c == K_MIDDLEMOUSE || c == K_RIGHTMOUSE 1185 || c == K_X1MOUSE || c == K_X2MOUSE) 1186 (void)jump_to_mouse(MOUSE_SETPOS, NULL, 0); 1187 else 1188 #endif 1189 if (vim_strchr((char_u *)"\r\n ", c) == NULL && c != Ctrl_C) 1190 { 1191 /* Put the character back in the typeahead buffer. Don't use the 1192 * stuff buffer, because lmaps wouldn't work. */ 1193 ins_char_typebuf(c); 1194 do_redraw = TRUE; /* need a redraw even though there is 1195 typeahead */ 1196 } 1197 } 1198 redir_off = FALSE; 1199 1200 /* 1201 * If the user hits ':', '?' or '/' we get a command line from the next 1202 * line. 1203 */ 1204 if (c == ':' || c == '?' || c == '/') 1205 { 1206 if (!exmode_active) 1207 cmdline_row = msg_row; 1208 skip_redraw = TRUE; /* skip redraw once */ 1209 do_redraw = FALSE; 1210 #ifdef FEAT_TERMINAL 1211 skip_term_loop = TRUE; 1212 #endif 1213 } 1214 1215 /* 1216 * If the window size changed set_shellsize() will redraw the screen. 1217 * Otherwise the screen is only redrawn if 'redraw' is set and no ':' 1218 * typed. 1219 */ 1220 tmpState = State; 1221 State = oldState; /* restore State before set_shellsize */ 1222 #ifdef FEAT_MOUSE 1223 setmouse(); 1224 #endif 1225 msg_check(); 1226 1227 #if defined(UNIX) || defined(VMS) 1228 /* 1229 * When switching screens, we need to output an extra newline on exit. 1230 */ 1231 if (swapping_screen() && !termcap_active) 1232 newline_on_exit = TRUE; 1233 #endif 1234 1235 need_wait_return = FALSE; 1236 did_wait_return = TRUE; 1237 emsg_on_display = FALSE; /* can delete error message now */ 1238 lines_left = -1; /* reset lines_left at next msg_start() */ 1239 reset_last_sourcing(); 1240 if (keep_msg != NULL && vim_strsize(keep_msg) >= 1241 (Rows - cmdline_row - 1) * Columns + sc_col) 1242 VIM_CLEAR(keep_msg); /* don't redisplay message, it's too long */ 1243 1244 if (tmpState == SETWSIZE) /* got resize event while in vgetc() */ 1245 { 1246 starttermcap(); /* start termcap before redrawing */ 1247 shell_resized(); 1248 } 1249 else if (!skip_redraw 1250 && (redraw == TRUE || (msg_scrolled != 0 && redraw != -1))) 1251 { 1252 starttermcap(); /* start termcap before redrawing */ 1253 redraw_later(VALID); 1254 } 1255 } 1256 1257 /* 1258 * Write the hit-return prompt. 1259 */ 1260 static void 1261 hit_return_msg(void) 1262 { 1263 int save_p_more = p_more; 1264 1265 p_more = FALSE; /* don't want see this message when scrolling back */ 1266 if (msg_didout) /* start on a new line */ 1267 msg_putchar('\n'); 1268 if (got_int) 1269 msg_puts(_("Interrupt: ")); 1270 1271 msg_puts_attr(_("Press ENTER or type command to continue"), HL_ATTR(HLF_R)); 1272 if (!msg_use_printf()) 1273 msg_clr_eos(); 1274 p_more = save_p_more; 1275 } 1276 1277 /* 1278 * Set "keep_msg" to "s". Free the old value and check for NULL pointer. 1279 */ 1280 void 1281 set_keep_msg(char_u *s, int attr) 1282 { 1283 vim_free(keep_msg); 1284 if (s != NULL && msg_silent == 0) 1285 keep_msg = vim_strsave(s); 1286 else 1287 keep_msg = NULL; 1288 keep_msg_more = FALSE; 1289 keep_msg_attr = attr; 1290 } 1291 1292 #if defined(FEAT_TERMRESPONSE) || defined(PROTO) 1293 /* 1294 * If there currently is a message being displayed, set "keep_msg" to it, so 1295 * that it will be displayed again after redraw. 1296 */ 1297 void 1298 set_keep_msg_from_hist(void) 1299 { 1300 if (keep_msg == NULL && last_msg_hist != NULL && msg_scrolled == 0 1301 && (State & NORMAL)) 1302 set_keep_msg(last_msg_hist->msg, last_msg_hist->attr); 1303 } 1304 #endif 1305 1306 /* 1307 * Prepare for outputting characters in the command line. 1308 */ 1309 void 1310 msg_start(void) 1311 { 1312 int did_return = FALSE; 1313 1314 if (!msg_silent) 1315 VIM_CLEAR(keep_msg); 1316 1317 #ifdef FEAT_EVAL 1318 if (need_clr_eos) 1319 { 1320 /* Halfway an ":echo" command and getting an (error) message: clear 1321 * any text from the command. */ 1322 need_clr_eos = FALSE; 1323 msg_clr_eos(); 1324 } 1325 #endif 1326 1327 if (!msg_scroll && full_screen) /* overwrite last message */ 1328 { 1329 msg_row = cmdline_row; 1330 msg_col = 1331 #ifdef FEAT_RIGHTLEFT 1332 cmdmsg_rl ? Columns - 1 : 1333 #endif 1334 0; 1335 } 1336 else if (msg_didout) /* start message on next line */ 1337 { 1338 msg_putchar('\n'); 1339 did_return = TRUE; 1340 if (exmode_active != EXMODE_NORMAL) 1341 cmdline_row = msg_row; 1342 } 1343 if (!msg_didany || lines_left < 0) 1344 msg_starthere(); 1345 if (msg_silent == 0) 1346 { 1347 msg_didout = FALSE; /* no output on current line yet */ 1348 cursor_off(); 1349 } 1350 1351 /* when redirecting, may need to start a new line. */ 1352 if (!did_return) 1353 redir_write((char_u *)"\n", -1); 1354 } 1355 1356 /* 1357 * Note that the current msg position is where messages start. 1358 */ 1359 void 1360 msg_starthere(void) 1361 { 1362 lines_left = cmdline_row; 1363 msg_didany = FALSE; 1364 } 1365 1366 void 1367 msg_putchar(int c) 1368 { 1369 msg_putchar_attr(c, 0); 1370 } 1371 1372 void 1373 msg_putchar_attr(int c, int attr) 1374 { 1375 char_u buf[MB_MAXBYTES + 1]; 1376 1377 if (IS_SPECIAL(c)) 1378 { 1379 buf[0] = K_SPECIAL; 1380 buf[1] = K_SECOND(c); 1381 buf[2] = K_THIRD(c); 1382 buf[3] = NUL; 1383 } 1384 else 1385 buf[(*mb_char2bytes)(c, buf)] = NUL; 1386 msg_puts_attr((char *)buf, attr); 1387 } 1388 1389 void 1390 msg_outnum(long n) 1391 { 1392 char buf[20]; 1393 1394 sprintf(buf, "%ld", n); 1395 msg_puts(buf); 1396 } 1397 1398 void 1399 msg_home_replace(char_u *fname) 1400 { 1401 msg_home_replace_attr(fname, 0); 1402 } 1403 1404 #if defined(FEAT_FIND_ID) || defined(PROTO) 1405 void 1406 msg_home_replace_hl(char_u *fname) 1407 { 1408 msg_home_replace_attr(fname, HL_ATTR(HLF_D)); 1409 } 1410 #endif 1411 1412 static void 1413 msg_home_replace_attr(char_u *fname, int attr) 1414 { 1415 char_u *name; 1416 1417 name = home_replace_save(NULL, fname); 1418 if (name != NULL) 1419 msg_outtrans_attr(name, attr); 1420 vim_free(name); 1421 } 1422 1423 /* 1424 * Output 'len' characters in 'str' (including NULs) with translation 1425 * if 'len' is -1, output upto a NUL character. 1426 * Use attributes 'attr'. 1427 * Return the number of characters it takes on the screen. 1428 */ 1429 int 1430 msg_outtrans(char_u *str) 1431 { 1432 return msg_outtrans_attr(str, 0); 1433 } 1434 1435 int 1436 msg_outtrans_attr(char_u *str, int attr) 1437 { 1438 return msg_outtrans_len_attr(str, (int)STRLEN(str), attr); 1439 } 1440 1441 int 1442 msg_outtrans_len(char_u *str, int len) 1443 { 1444 return msg_outtrans_len_attr(str, len, 0); 1445 } 1446 1447 /* 1448 * Output one character at "p". Return pointer to the next character. 1449 * Handles multi-byte characters. 1450 */ 1451 char_u * 1452 msg_outtrans_one(char_u *p, int attr) 1453 { 1454 int l; 1455 1456 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) 1457 { 1458 msg_outtrans_len_attr(p, l, attr); 1459 return p + l; 1460 } 1461 msg_puts_attr((char *)transchar_byte(*p), attr); 1462 return p + 1; 1463 } 1464 1465 int 1466 msg_outtrans_len_attr(char_u *msgstr, int len, int attr) 1467 { 1468 int retval = 0; 1469 char_u *str = msgstr; 1470 char_u *plain_start = msgstr; 1471 char_u *s; 1472 int mb_l; 1473 int c; 1474 1475 /* if MSG_HIST flag set, add message to history */ 1476 if (attr & MSG_HIST) 1477 { 1478 add_msg_hist(str, len, attr); 1479 attr &= ~MSG_HIST; 1480 } 1481 1482 /* If the string starts with a composing character first draw a space on 1483 * which the composing char can be drawn. */ 1484 if (enc_utf8 && utf_iscomposing(utf_ptr2char(msgstr))) 1485 msg_puts_attr(" ", attr); 1486 1487 /* 1488 * Go over the string. Special characters are translated and printed. 1489 * Normal characters are printed several at a time. 1490 */ 1491 while (--len >= 0) 1492 { 1493 if (enc_utf8) 1494 /* Don't include composing chars after the end. */ 1495 mb_l = utfc_ptr2len_len(str, len + 1); 1496 else if (has_mbyte) 1497 mb_l = (*mb_ptr2len)(str); 1498 else 1499 mb_l = 1; 1500 if (has_mbyte && mb_l > 1) 1501 { 1502 c = (*mb_ptr2char)(str); 1503 if (vim_isprintc(c)) 1504 /* printable multi-byte char: count the cells. */ 1505 retval += (*mb_ptr2cells)(str); 1506 else 1507 { 1508 /* unprintable multi-byte char: print the printable chars so 1509 * far and the translation of the unprintable char. */ 1510 if (str > plain_start) 1511 msg_puts_attr_len((char *)plain_start, 1512 (int)(str - plain_start), attr); 1513 plain_start = str + mb_l; 1514 msg_puts_attr((char *)transchar(c), 1515 attr == 0 ? HL_ATTR(HLF_8) : attr); 1516 retval += char2cells(c); 1517 } 1518 len -= mb_l - 1; 1519 str += mb_l; 1520 } 1521 else 1522 { 1523 s = transchar_byte(*str); 1524 if (s[1] != NUL) 1525 { 1526 /* unprintable char: print the printable chars so far and the 1527 * translation of the unprintable char. */ 1528 if (str > plain_start) 1529 msg_puts_attr_len((char *)plain_start, 1530 (int)(str - plain_start), attr); 1531 plain_start = str + 1; 1532 msg_puts_attr((char *)s, attr == 0 ? HL_ATTR(HLF_8) : attr); 1533 retval += (int)STRLEN(s); 1534 } 1535 else 1536 ++retval; 1537 ++str; 1538 } 1539 } 1540 1541 if (str > plain_start) 1542 /* print the printable chars at the end */ 1543 msg_puts_attr_len((char *)plain_start, (int)(str - plain_start), attr); 1544 1545 return retval; 1546 } 1547 1548 #if defined(FEAT_QUICKFIX) || defined(PROTO) 1549 void 1550 msg_make(char_u *arg) 1551 { 1552 int i; 1553 static char_u *str = (char_u *)"eeffoc", *rs = (char_u *)"Plon#dqg#vxjduB"; 1554 1555 arg = skipwhite(arg); 1556 for (i = 5; *arg && i >= 0; --i) 1557 if (*arg++ != str[i]) 1558 break; 1559 if (i < 0) 1560 { 1561 msg_putchar('\n'); 1562 for (i = 0; rs[i]; ++i) 1563 msg_putchar(rs[i] - 3); 1564 } 1565 } 1566 #endif 1567 1568 /* 1569 * Output the string 'str' upto a NUL character. 1570 * Return the number of characters it takes on the screen. 1571 * 1572 * If K_SPECIAL is encountered, then it is taken in conjunction with the 1573 * following character and shown as <F1>, <S-Up> etc. Any other character 1574 * which is not printable shown in <> form. 1575 * If 'from' is TRUE (lhs of a mapping), a space is shown as <Space>. 1576 * If a character is displayed in one of these special ways, is also 1577 * highlighted (its highlight name is '8' in the p_hl variable). 1578 * Otherwise characters are not highlighted. 1579 * This function is used to show mappings, where we want to see how to type 1580 * the character/string -- webb 1581 */ 1582 int 1583 msg_outtrans_special( 1584 char_u *strstart, 1585 int from, // TRUE for lhs of a mapping 1586 int maxlen) // screen columns, 0 for unlimeted 1587 { 1588 char_u *str = strstart; 1589 int retval = 0; 1590 char *text; 1591 int attr; 1592 int len; 1593 1594 attr = HL_ATTR(HLF_8); 1595 while (*str != NUL) 1596 { 1597 /* Leading and trailing spaces need to be displayed in <> form. */ 1598 if ((str == strstart || str[1] == NUL) && *str == ' ') 1599 { 1600 text = "<Space>"; 1601 ++str; 1602 } 1603 else 1604 text = (char *)str2special(&str, from); 1605 len = vim_strsize((char_u *)text); 1606 if (maxlen > 0 && retval + len >= maxlen) 1607 break; 1608 /* Highlight special keys */ 1609 msg_puts_attr(text, len > 1 1610 && (*mb_ptr2len)((char_u *)text) <= 1 ? attr : 0); 1611 retval += len; 1612 } 1613 return retval; 1614 } 1615 1616 #if defined(FEAT_EVAL) || defined(PROTO) 1617 /* 1618 * Return the lhs or rhs of a mapping, with the key codes turned into printable 1619 * strings, in an allocated string. 1620 */ 1621 char_u * 1622 str2special_save( 1623 char_u *str, 1624 int is_lhs) /* TRUE for lhs, FALSE for rhs */ 1625 { 1626 garray_T ga; 1627 char_u *p = str; 1628 1629 ga_init2(&ga, 1, 40); 1630 while (*p != NUL) 1631 ga_concat(&ga, str2special(&p, is_lhs)); 1632 ga_append(&ga, NUL); 1633 return (char_u *)ga.ga_data; 1634 } 1635 #endif 1636 1637 /* 1638 * Return the printable string for the key codes at "*sp". 1639 * Used for translating the lhs or rhs of a mapping to printable chars. 1640 * Advances "sp" to the next code. 1641 */ 1642 char_u * 1643 str2special( 1644 char_u **sp, 1645 int from) /* TRUE for lhs of mapping */ 1646 { 1647 int c; 1648 static char_u buf[7]; 1649 char_u *str = *sp; 1650 int modifiers = 0; 1651 int special = FALSE; 1652 1653 if (has_mbyte) 1654 { 1655 char_u *p; 1656 1657 /* Try to un-escape a multi-byte character. Return the un-escaped 1658 * string if it is a multi-byte character. */ 1659 p = mb_unescape(sp); 1660 if (p != NULL) 1661 return p; 1662 } 1663 1664 c = *str; 1665 if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL) 1666 { 1667 if (str[1] == KS_MODIFIER) 1668 { 1669 modifiers = str[2]; 1670 str += 3; 1671 c = *str; 1672 } 1673 if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL) 1674 { 1675 c = TO_SPECIAL(str[1], str[2]); 1676 str += 2; 1677 } 1678 if (IS_SPECIAL(c) || modifiers) /* special key */ 1679 special = TRUE; 1680 } 1681 1682 if (has_mbyte && !IS_SPECIAL(c)) 1683 { 1684 int len = (*mb_ptr2len)(str); 1685 1686 /* For multi-byte characters check for an illegal byte. */ 1687 if (has_mbyte && MB_BYTE2LEN(*str) > len) 1688 { 1689 transchar_nonprint(buf, c); 1690 *sp = str + 1; 1691 return buf; 1692 } 1693 /* Since 'special' is TRUE the multi-byte character 'c' will be 1694 * processed by get_special_key_name() */ 1695 c = (*mb_ptr2char)(str); 1696 *sp = str + len; 1697 } 1698 else 1699 *sp = str + 1; 1700 1701 /* Make unprintable characters in <> form, also <M-Space> and <Tab>. 1702 * Use <Space> only for lhs of a mapping. */ 1703 if (special || char2cells(c) > 1 || (from && c == ' ')) 1704 return get_special_key_name(c, modifiers); 1705 buf[0] = c; 1706 buf[1] = NUL; 1707 return buf; 1708 } 1709 1710 /* 1711 * Translate a key sequence into special key names. 1712 */ 1713 void 1714 str2specialbuf(char_u *sp, char_u *buf, int len) 1715 { 1716 char_u *s; 1717 1718 *buf = NUL; 1719 while (*sp) 1720 { 1721 s = str2special(&sp, FALSE); 1722 if ((int)(STRLEN(s) + STRLEN(buf)) < len) 1723 STRCAT(buf, s); 1724 } 1725 } 1726 1727 /* 1728 * print line for :print or :list command 1729 */ 1730 void 1731 msg_prt_line(char_u *s, int list) 1732 { 1733 int c; 1734 int col = 0; 1735 int n_extra = 0; 1736 int c_extra = 0; 1737 int c_final = 0; 1738 char_u *p_extra = NULL; /* init to make SASC shut up */ 1739 int n; 1740 int attr = 0; 1741 char_u *trail = NULL; 1742 int l; 1743 char_u buf[MB_MAXBYTES + 1]; 1744 1745 if (curwin->w_p_list) 1746 list = TRUE; 1747 1748 /* find start of trailing whitespace */ 1749 if (list && lcs_trail) 1750 { 1751 trail = s + STRLEN(s); 1752 while (trail > s && VIM_ISWHITE(trail[-1])) 1753 --trail; 1754 } 1755 1756 /* output a space for an empty line, otherwise the line will be 1757 * overwritten */ 1758 if (*s == NUL && !(list && lcs_eol != NUL)) 1759 msg_putchar(' '); 1760 1761 while (!got_int) 1762 { 1763 if (n_extra > 0) 1764 { 1765 --n_extra; 1766 if (n_extra == 0 && c_final) 1767 c = c_final; 1768 else if (c_extra) 1769 c = c_extra; 1770 else 1771 c = *p_extra++; 1772 } 1773 else if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1) 1774 { 1775 col += (*mb_ptr2cells)(s); 1776 if (lcs_nbsp != NUL && list 1777 && (mb_ptr2char(s) == 160 1778 || mb_ptr2char(s) == 0x202f)) 1779 { 1780 mb_char2bytes(lcs_nbsp, buf); 1781 buf[(*mb_ptr2len)(buf)] = NUL; 1782 } 1783 else 1784 { 1785 mch_memmove(buf, s, (size_t)l); 1786 buf[l] = NUL; 1787 } 1788 msg_puts((char *)buf); 1789 s += l; 1790 continue; 1791 } 1792 else 1793 { 1794 attr = 0; 1795 c = *s++; 1796 if (c == TAB && (!list || lcs_tab1)) 1797 { 1798 /* tab amount depends on current column */ 1799 #ifdef FEAT_VARTABS 1800 n_extra = tabstop_padding(col, curbuf->b_p_ts, 1801 curbuf->b_p_vts_array) - 1; 1802 #else 1803 n_extra = curbuf->b_p_ts - col % curbuf->b_p_ts - 1; 1804 #endif 1805 if (!list) 1806 { 1807 c = ' '; 1808 c_extra = ' '; 1809 c_final = NUL; 1810 } 1811 else 1812 { 1813 c = (n_extra == 0 && lcs_tab3) ? lcs_tab3 : lcs_tab1; 1814 c_extra = lcs_tab2; 1815 c_final = lcs_tab3; 1816 attr = HL_ATTR(HLF_8); 1817 } 1818 } 1819 else if (c == 160 && list && lcs_nbsp != NUL) 1820 { 1821 c = lcs_nbsp; 1822 attr = HL_ATTR(HLF_8); 1823 } 1824 else if (c == NUL && list && lcs_eol != NUL) 1825 { 1826 p_extra = (char_u *)""; 1827 c_extra = NUL; 1828 c_final = NUL; 1829 n_extra = 1; 1830 c = lcs_eol; 1831 attr = HL_ATTR(HLF_AT); 1832 --s; 1833 } 1834 else if (c != NUL && (n = byte2cells(c)) > 1) 1835 { 1836 n_extra = n - 1; 1837 p_extra = transchar_byte(c); 1838 c_extra = NUL; 1839 c_final = NUL; 1840 c = *p_extra++; 1841 /* Use special coloring to be able to distinguish <hex> from 1842 * the same in plain text. */ 1843 attr = HL_ATTR(HLF_8); 1844 } 1845 else if (c == ' ' && trail != NULL && s > trail) 1846 { 1847 c = lcs_trail; 1848 attr = HL_ATTR(HLF_8); 1849 } 1850 else if (c == ' ' && list && lcs_space != NUL) 1851 { 1852 c = lcs_space; 1853 attr = HL_ATTR(HLF_8); 1854 } 1855 } 1856 1857 if (c == NUL) 1858 break; 1859 1860 msg_putchar_attr(c, attr); 1861 col++; 1862 } 1863 msg_clr_eos(); 1864 } 1865 1866 /* 1867 * Use screen_puts() to output one multi-byte character. 1868 * Return the pointer "s" advanced to the next character. 1869 */ 1870 static char_u * 1871 screen_puts_mbyte(char_u *s, int l, int attr) 1872 { 1873 int cw; 1874 1875 msg_didout = TRUE; /* remember that line is not empty */ 1876 cw = (*mb_ptr2cells)(s); 1877 if (cw > 1 && ( 1878 #ifdef FEAT_RIGHTLEFT 1879 cmdmsg_rl ? msg_col <= 1 : 1880 #endif 1881 msg_col == Columns - 1)) 1882 { 1883 /* Doesn't fit, print a highlighted '>' to fill it up. */ 1884 msg_screen_putchar('>', HL_ATTR(HLF_AT)); 1885 return s; 1886 } 1887 1888 screen_puts_len(s, l, msg_row, msg_col, attr); 1889 #ifdef FEAT_RIGHTLEFT 1890 if (cmdmsg_rl) 1891 { 1892 msg_col -= cw; 1893 if (msg_col == 0) 1894 { 1895 msg_col = Columns; 1896 ++msg_row; 1897 } 1898 } 1899 else 1900 #endif 1901 { 1902 msg_col += cw; 1903 if (msg_col >= Columns) 1904 { 1905 msg_col = 0; 1906 ++msg_row; 1907 } 1908 } 1909 return s + l; 1910 } 1911 1912 /* 1913 * Output a string to the screen at position msg_row, msg_col. 1914 * Update msg_row and msg_col for the next message. 1915 */ 1916 void 1917 msg_puts(char *s) 1918 { 1919 msg_puts_attr(s, 0); 1920 } 1921 1922 void 1923 msg_puts_title(char *s) 1924 { 1925 msg_puts_attr(s, HL_ATTR(HLF_T)); 1926 } 1927 1928 /* 1929 * Show a message in such a way that it always fits in the line. Cut out a 1930 * part in the middle and replace it with "..." when necessary. 1931 * Does not handle multi-byte characters! 1932 */ 1933 void 1934 msg_outtrans_long_attr(char_u *longstr, int attr) 1935 { 1936 msg_outtrans_long_len_attr(longstr, (int)STRLEN(longstr), attr); 1937 } 1938 1939 void 1940 msg_outtrans_long_len_attr(char_u *longstr, int len, int attr) 1941 { 1942 int slen = len; 1943 int room; 1944 1945 room = Columns - msg_col; 1946 if (len > room && room >= 20) 1947 { 1948 slen = (room - 3) / 2; 1949 msg_outtrans_len_attr(longstr, slen, attr); 1950 msg_puts_attr("...", HL_ATTR(HLF_8)); 1951 } 1952 msg_outtrans_len_attr(longstr + len - slen, slen, attr); 1953 } 1954 1955 /* 1956 * Basic function for writing a message with highlight attributes. 1957 */ 1958 void 1959 msg_puts_attr(char *s, int attr) 1960 { 1961 msg_puts_attr_len(s, -1, attr); 1962 } 1963 1964 /* 1965 * Like msg_puts_attr(), but with a maximum length "maxlen" (in bytes). 1966 * When "maxlen" is -1 there is no maximum length. 1967 * When "maxlen" is >= 0 the message is not put in the history. 1968 */ 1969 static void 1970 msg_puts_attr_len(char *str, int maxlen, int attr) 1971 { 1972 /* 1973 * If redirection is on, also write to the redirection file. 1974 */ 1975 redir_write((char_u *)str, maxlen); 1976 1977 /* 1978 * Don't print anything when using ":silent cmd". 1979 */ 1980 if (msg_silent != 0) 1981 return; 1982 1983 /* if MSG_HIST flag set, add message to history */ 1984 if ((attr & MSG_HIST) && maxlen < 0) 1985 { 1986 add_msg_hist((char_u *)str, -1, attr); 1987 attr &= ~MSG_HIST; 1988 } 1989 1990 /* 1991 * When writing something to the screen after it has scrolled, requires a 1992 * wait-return prompt later. Needed when scrolling, resetting 1993 * need_wait_return after some prompt, and then outputting something 1994 * without scrolling 1995 */ 1996 if (msg_scrolled != 0 && !msg_scrolled_ign) 1997 need_wait_return = TRUE; 1998 msg_didany = TRUE; /* remember that something was outputted */ 1999 2000 /* 2001 * If there is no valid screen, use fprintf so we can see error messages. 2002 * If termcap is not active, we may be writing in an alternate console 2003 * window, cursor positioning may not work correctly (window size may be 2004 * different, e.g. for Win32 console) or we just don't know where the 2005 * cursor is. 2006 */ 2007 if (msg_use_printf()) 2008 msg_puts_printf((char_u *)str, maxlen); 2009 else 2010 msg_puts_display((char_u *)str, maxlen, attr, FALSE); 2011 } 2012 2013 /* 2014 * The display part of msg_puts_attr_len(). 2015 * May be called recursively to display scroll-back text. 2016 */ 2017 static void 2018 msg_puts_display( 2019 char_u *str, 2020 int maxlen, 2021 int attr, 2022 int recurse) 2023 { 2024 char_u *s = str; 2025 char_u *t_s = str; /* string from "t_s" to "s" is still todo */ 2026 int t_col = 0; /* screen cells todo, 0 when "t_s" not used */ 2027 int l; 2028 int cw; 2029 char_u *sb_str = str; 2030 int sb_col = msg_col; 2031 int wrap; 2032 int did_last_char; 2033 2034 did_wait_return = FALSE; 2035 while ((maxlen < 0 || (int)(s - str) < maxlen) && *s != NUL) 2036 { 2037 /* 2038 * We are at the end of the screen line when: 2039 * - When outputting a newline. 2040 * - When outputting a character in the last column. 2041 */ 2042 if (!recurse && msg_row >= Rows - 1 && (*s == '\n' || ( 2043 #ifdef FEAT_RIGHTLEFT 2044 cmdmsg_rl 2045 ? ( 2046 msg_col <= 1 2047 || (*s == TAB && msg_col <= 7) 2048 || (has_mbyte && (*mb_ptr2cells)(s) > 1 && msg_col <= 2)) 2049 : 2050 #endif 2051 (msg_col + t_col >= Columns - 1 2052 || (*s == TAB && msg_col + t_col >= ((Columns - 1) & ~7)) 2053 || (has_mbyte && (*mb_ptr2cells)(s) > 1 2054 && msg_col + t_col >= Columns - 2))))) 2055 { 2056 /* 2057 * The screen is scrolled up when at the last row (some terminals 2058 * scroll automatically, some don't. To avoid problems we scroll 2059 * ourselves). 2060 */ 2061 if (t_col > 0) 2062 /* output postponed text */ 2063 t_puts(&t_col, t_s, s, attr); 2064 2065 /* When no more prompt and no more room, truncate here */ 2066 if (msg_no_more && lines_left == 0) 2067 break; 2068 2069 /* Scroll the screen up one line. */ 2070 msg_scroll_up(); 2071 2072 msg_row = Rows - 2; 2073 if (msg_col >= Columns) /* can happen after screen resize */ 2074 msg_col = Columns - 1; 2075 2076 /* Display char in last column before showing more-prompt. */ 2077 if (*s >= ' ' 2078 #ifdef FEAT_RIGHTLEFT 2079 && !cmdmsg_rl 2080 #endif 2081 ) 2082 { 2083 if (has_mbyte) 2084 { 2085 if (enc_utf8 && maxlen >= 0) 2086 /* avoid including composing chars after the end */ 2087 l = utfc_ptr2len_len(s, (int)((str + maxlen) - s)); 2088 else 2089 l = (*mb_ptr2len)(s); 2090 s = screen_puts_mbyte(s, l, attr); 2091 } 2092 else 2093 msg_screen_putchar(*s++, attr); 2094 did_last_char = TRUE; 2095 } 2096 else 2097 did_last_char = FALSE; 2098 2099 if (p_more) 2100 /* store text for scrolling back */ 2101 store_sb_text(&sb_str, s, attr, &sb_col, TRUE); 2102 2103 inc_msg_scrolled(); 2104 need_wait_return = TRUE; /* may need wait_return in main() */ 2105 redraw_cmdline = TRUE; 2106 if (cmdline_row > 0 && !exmode_active) 2107 --cmdline_row; 2108 2109 /* 2110 * If screen is completely filled and 'more' is set then wait 2111 * for a character. 2112 */ 2113 if (lines_left > 0) 2114 --lines_left; 2115 if (p_more && lines_left == 0 && State != HITRETURN 2116 && !msg_no_more && !exmode_active) 2117 { 2118 #ifdef FEAT_CON_DIALOG 2119 if (do_more_prompt(NUL)) 2120 s = confirm_msg_tail; 2121 #else 2122 (void)do_more_prompt(NUL); 2123 #endif 2124 if (quit_more) 2125 return; 2126 } 2127 2128 /* When we displayed a char in last column need to check if there 2129 * is still more. */ 2130 if (did_last_char) 2131 continue; 2132 } 2133 2134 wrap = *s == '\n' 2135 || msg_col + t_col >= Columns 2136 || (has_mbyte && (*mb_ptr2cells)(s) > 1 2137 && msg_col + t_col >= Columns - 1); 2138 if (t_col > 0 && (wrap || *s == '\r' || *s == '\b' 2139 || *s == '\t' || *s == BELL)) 2140 /* output any postponed text */ 2141 t_puts(&t_col, t_s, s, attr); 2142 2143 if (wrap && p_more && !recurse) 2144 /* store text for scrolling back */ 2145 store_sb_text(&sb_str, s, attr, &sb_col, TRUE); 2146 2147 if (*s == '\n') /* go to next line */ 2148 { 2149 msg_didout = FALSE; /* remember that line is empty */ 2150 #ifdef FEAT_RIGHTLEFT 2151 if (cmdmsg_rl) 2152 msg_col = Columns - 1; 2153 else 2154 #endif 2155 msg_col = 0; 2156 if (++msg_row >= Rows) /* safety check */ 2157 msg_row = Rows - 1; 2158 } 2159 else if (*s == '\r') /* go to column 0 */ 2160 { 2161 msg_col = 0; 2162 } 2163 else if (*s == '\b') /* go to previous char */ 2164 { 2165 if (msg_col) 2166 --msg_col; 2167 } 2168 else if (*s == TAB) /* translate Tab into spaces */ 2169 { 2170 do 2171 msg_screen_putchar(' ', attr); 2172 while (msg_col & 7); 2173 } 2174 else if (*s == BELL) /* beep (from ":sh") */ 2175 vim_beep(BO_SH); 2176 else 2177 { 2178 if (has_mbyte) 2179 { 2180 cw = (*mb_ptr2cells)(s); 2181 if (enc_utf8 && maxlen >= 0) 2182 /* avoid including composing chars after the end */ 2183 l = utfc_ptr2len_len(s, (int)((str + maxlen) - s)); 2184 else 2185 l = (*mb_ptr2len)(s); 2186 } 2187 else 2188 { 2189 cw = 1; 2190 l = 1; 2191 } 2192 2193 /* When drawing from right to left or when a double-wide character 2194 * doesn't fit, draw a single character here. Otherwise collect 2195 * characters and draw them all at once later. */ 2196 if ( 2197 # ifdef FEAT_RIGHTLEFT 2198 cmdmsg_rl || 2199 # endif 2200 (cw > 1 && msg_col + t_col >= Columns - 1)) 2201 { 2202 if (l > 1) 2203 s = screen_puts_mbyte(s, l, attr) - 1; 2204 else 2205 msg_screen_putchar(*s, attr); 2206 } 2207 else 2208 { 2209 /* postpone this character until later */ 2210 if (t_col == 0) 2211 t_s = s; 2212 t_col += cw; 2213 s += l - 1; 2214 } 2215 } 2216 ++s; 2217 } 2218 2219 /* output any postponed text */ 2220 if (t_col > 0) 2221 t_puts(&t_col, t_s, s, attr); 2222 if (p_more && !recurse) 2223 store_sb_text(&sb_str, s, attr, &sb_col, FALSE); 2224 2225 msg_check(); 2226 } 2227 2228 /* 2229 * Return TRUE when ":filter pattern" was used and "msg" does not match 2230 * "pattern". 2231 */ 2232 int 2233 message_filtered(char_u *msg) 2234 { 2235 int match; 2236 2237 if (cmdmod.filter_regmatch.regprog == NULL) 2238 return FALSE; 2239 match = vim_regexec(&cmdmod.filter_regmatch, msg, (colnr_T)0); 2240 return cmdmod.filter_force ? match : !match; 2241 } 2242 2243 /* 2244 * Scroll the screen up one line for displaying the next message line. 2245 */ 2246 static void 2247 msg_scroll_up(void) 2248 { 2249 #ifdef FEAT_GUI 2250 /* Remove the cursor before scrolling, ScreenLines[] is going 2251 * to become invalid. */ 2252 if (gui.in_use) 2253 gui_undraw_cursor(); 2254 #endif 2255 /* scrolling up always works */ 2256 mch_disable_flush(); 2257 screen_del_lines(0, 0, 1, (int)Rows, TRUE, 0, NULL); 2258 mch_enable_flush(); 2259 2260 if (!can_clear((char_u *)" ")) 2261 { 2262 /* Scrolling up doesn't result in the right background. Set the 2263 * background here. It's not efficient, but avoids that we have to do 2264 * it all over the code. */ 2265 screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0); 2266 2267 /* Also clear the last char of the last but one line if it was not 2268 * cleared before to avoid a scroll-up. */ 2269 if (ScreenAttrs[LineOffset[Rows - 2] + Columns - 1] == (sattr_T)-1) 2270 screen_fill((int)Rows - 2, (int)Rows - 1, 2271 (int)Columns - 1, (int)Columns, ' ', ' ', 0); 2272 } 2273 } 2274 2275 /* 2276 * Increment "msg_scrolled". 2277 */ 2278 static void 2279 inc_msg_scrolled(void) 2280 { 2281 #ifdef FEAT_EVAL 2282 if (*get_vim_var_str(VV_SCROLLSTART) == NUL) 2283 { 2284 char_u *p = sourcing_name; 2285 char_u *tofree = NULL; 2286 int len; 2287 2288 /* v:scrollstart is empty, set it to the script/function name and line 2289 * number */ 2290 if (p == NULL) 2291 p = (char_u *)_("Unknown"); 2292 else 2293 { 2294 len = (int)STRLEN(p) + 40; 2295 tofree = alloc(len); 2296 if (tofree != NULL) 2297 { 2298 vim_snprintf((char *)tofree, len, _("%s line %ld"), 2299 p, (long)sourcing_lnum); 2300 p = tofree; 2301 } 2302 } 2303 set_vim_var_string(VV_SCROLLSTART, p, -1); 2304 vim_free(tofree); 2305 } 2306 #endif 2307 ++msg_scrolled; 2308 if (must_redraw < VALID) 2309 must_redraw = VALID; 2310 } 2311 2312 /* 2313 * To be able to scroll back at the "more" and "hit-enter" prompts we need to 2314 * store the displayed text and remember where screen lines start. 2315 */ 2316 typedef struct msgchunk_S msgchunk_T; 2317 struct msgchunk_S 2318 { 2319 msgchunk_T *sb_next; 2320 msgchunk_T *sb_prev; 2321 char sb_eol; /* TRUE when line ends after this text */ 2322 int sb_msg_col; /* column in which text starts */ 2323 int sb_attr; /* text attributes */ 2324 char_u sb_text[1]; /* text to be displayed, actually longer */ 2325 }; 2326 2327 static msgchunk_T *last_msgchunk = NULL; /* last displayed text */ 2328 2329 static msgchunk_T *msg_sb_start(msgchunk_T *mps); 2330 2331 typedef enum { 2332 SB_CLEAR_NONE = 0, 2333 SB_CLEAR_ALL, 2334 SB_CLEAR_CMDLINE_BUSY, 2335 SB_CLEAR_CMDLINE_DONE 2336 } sb_clear_T; 2337 2338 /* When to clear text on next msg. */ 2339 static sb_clear_T do_clear_sb_text = SB_CLEAR_NONE; 2340 2341 /* 2342 * Store part of a printed message for displaying when scrolling back. 2343 */ 2344 static void 2345 store_sb_text( 2346 char_u **sb_str, /* start of string */ 2347 char_u *s, /* just after string */ 2348 int attr, 2349 int *sb_col, 2350 int finish) /* line ends */ 2351 { 2352 msgchunk_T *mp; 2353 2354 if (do_clear_sb_text == SB_CLEAR_ALL 2355 || do_clear_sb_text == SB_CLEAR_CMDLINE_DONE) 2356 { 2357 clear_sb_text(do_clear_sb_text == SB_CLEAR_ALL); 2358 do_clear_sb_text = SB_CLEAR_NONE; 2359 } 2360 2361 if (s > *sb_str) 2362 { 2363 mp = alloc(sizeof(msgchunk_T) + (s - *sb_str)); 2364 if (mp != NULL) 2365 { 2366 mp->sb_eol = finish; 2367 mp->sb_msg_col = *sb_col; 2368 mp->sb_attr = attr; 2369 vim_strncpy(mp->sb_text, *sb_str, s - *sb_str); 2370 2371 if (last_msgchunk == NULL) 2372 { 2373 last_msgchunk = mp; 2374 mp->sb_prev = NULL; 2375 } 2376 else 2377 { 2378 mp->sb_prev = last_msgchunk; 2379 last_msgchunk->sb_next = mp; 2380 last_msgchunk = mp; 2381 } 2382 mp->sb_next = NULL; 2383 } 2384 } 2385 else if (finish && last_msgchunk != NULL) 2386 last_msgchunk->sb_eol = TRUE; 2387 2388 *sb_str = s; 2389 *sb_col = 0; 2390 } 2391 2392 /* 2393 * Finished showing messages, clear the scroll-back text on the next message. 2394 */ 2395 void 2396 may_clear_sb_text(void) 2397 { 2398 do_clear_sb_text = SB_CLEAR_ALL; 2399 } 2400 2401 /* 2402 * Starting to edit the command line, do not clear messages now. 2403 */ 2404 void 2405 sb_text_start_cmdline(void) 2406 { 2407 do_clear_sb_text = SB_CLEAR_CMDLINE_BUSY; 2408 msg_sb_eol(); 2409 } 2410 2411 /* 2412 * Ending to edit the command line. Clear old lines but the last one later. 2413 */ 2414 void 2415 sb_text_end_cmdline(void) 2416 { 2417 do_clear_sb_text = SB_CLEAR_CMDLINE_DONE; 2418 } 2419 2420 /* 2421 * Clear any text remembered for scrolling back. 2422 * When "all" is FALSE keep the last line. 2423 * Called when redrawing the screen. 2424 */ 2425 void 2426 clear_sb_text(int all) 2427 { 2428 msgchunk_T *mp; 2429 msgchunk_T **lastp; 2430 2431 if (all) 2432 lastp = &last_msgchunk; 2433 else 2434 { 2435 if (last_msgchunk == NULL) 2436 return; 2437 lastp = &last_msgchunk->sb_prev; 2438 } 2439 2440 while (*lastp != NULL) 2441 { 2442 mp = (*lastp)->sb_prev; 2443 vim_free(*lastp); 2444 *lastp = mp; 2445 } 2446 } 2447 2448 /* 2449 * "g<" command. 2450 */ 2451 void 2452 show_sb_text(void) 2453 { 2454 msgchunk_T *mp; 2455 2456 /* Only show something if there is more than one line, otherwise it looks 2457 * weird, typing a command without output results in one line. */ 2458 mp = msg_sb_start(last_msgchunk); 2459 if (mp == NULL || mp->sb_prev == NULL) 2460 vim_beep(BO_MESS); 2461 else 2462 { 2463 do_more_prompt('G'); 2464 wait_return(FALSE); 2465 } 2466 } 2467 2468 /* 2469 * Move to the start of screen line in already displayed text. 2470 */ 2471 static msgchunk_T * 2472 msg_sb_start(msgchunk_T *mps) 2473 { 2474 msgchunk_T *mp = mps; 2475 2476 while (mp != NULL && mp->sb_prev != NULL && !mp->sb_prev->sb_eol) 2477 mp = mp->sb_prev; 2478 return mp; 2479 } 2480 2481 /* 2482 * Mark the last message chunk as finishing the line. 2483 */ 2484 void 2485 msg_sb_eol(void) 2486 { 2487 if (last_msgchunk != NULL) 2488 last_msgchunk->sb_eol = TRUE; 2489 } 2490 2491 /* 2492 * Display a screen line from previously displayed text at row "row". 2493 * Returns a pointer to the text for the next line (can be NULL). 2494 */ 2495 static msgchunk_T * 2496 disp_sb_line(int row, msgchunk_T *smp) 2497 { 2498 msgchunk_T *mp = smp; 2499 char_u *p; 2500 2501 for (;;) 2502 { 2503 msg_row = row; 2504 msg_col = mp->sb_msg_col; 2505 p = mp->sb_text; 2506 if (*p == '\n') /* don't display the line break */ 2507 ++p; 2508 msg_puts_display(p, -1, mp->sb_attr, TRUE); 2509 if (mp->sb_eol || mp->sb_next == NULL) 2510 break; 2511 mp = mp->sb_next; 2512 } 2513 return mp->sb_next; 2514 } 2515 2516 /* 2517 * Output any postponed text for msg_puts_attr_len(). 2518 */ 2519 static void 2520 t_puts( 2521 int *t_col, 2522 char_u *t_s, 2523 char_u *s, 2524 int attr) 2525 { 2526 /* output postponed text */ 2527 msg_didout = TRUE; /* remember that line is not empty */ 2528 screen_puts_len(t_s, (int)(s - t_s), msg_row, msg_col, attr); 2529 msg_col += *t_col; 2530 *t_col = 0; 2531 /* If the string starts with a composing character don't increment the 2532 * column position for it. */ 2533 if (enc_utf8 && utf_iscomposing(utf_ptr2char(t_s))) 2534 --msg_col; 2535 if (msg_col >= Columns) 2536 { 2537 msg_col = 0; 2538 ++msg_row; 2539 } 2540 } 2541 2542 /* 2543 * Returns TRUE when messages should be printed with mch_errmsg(). 2544 * This is used when there is no valid screen, so we can see error messages. 2545 * If termcap is not active, we may be writing in an alternate console 2546 * window, cursor positioning may not work correctly (window size may be 2547 * different, e.g. for Win32 console) or we just don't know where the 2548 * cursor is. 2549 */ 2550 int 2551 msg_use_printf(void) 2552 { 2553 return (!msg_check_screen() 2554 #if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) 2555 # ifdef VIMDLL 2556 || (!gui.in_use && !termcap_active) 2557 # else 2558 || !termcap_active 2559 # endif 2560 #endif 2561 || (swapping_screen() && !termcap_active) 2562 ); 2563 } 2564 2565 /* 2566 * Print a message when there is no valid screen. 2567 */ 2568 static void 2569 msg_puts_printf(char_u *str, int maxlen) 2570 { 2571 char_u *s = str; 2572 char_u *buf = NULL; 2573 char_u *p = s; 2574 2575 #ifdef MSWIN 2576 if (!(silent_mode && p_verbose == 0)) 2577 mch_settmode(TMODE_COOK); /* handle CR and NL correctly */ 2578 #endif 2579 while ((maxlen < 0 || (int)(s - str) < maxlen) && *s != NUL) 2580 { 2581 if (!(silent_mode && p_verbose == 0)) 2582 { 2583 // NL --> CR NL translation (for Unix, not for "--version") 2584 if (*s == NL) 2585 { 2586 int n = (int)(s - p); 2587 2588 buf = alloc(n + 3); 2589 memcpy(buf, p, n); 2590 if (!info_message) 2591 buf[n++] = CAR; 2592 buf[n++] = NL; 2593 buf[n++] = NUL; 2594 if (info_message) // informative message, not an error 2595 mch_msg((char *)buf); 2596 else 2597 mch_errmsg((char *)buf); 2598 vim_free(buf); 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 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 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_BROWSE) || defined(PROTO) 3956 /* 3957 * Generic browse function. Calls gui_mch_browse() when possible. 3958 * Later this may pop-up a non-GUI file selector (external command?). 3959 */ 3960 char_u * 3961 do_browse( 3962 int flags, /* BROWSE_SAVE and BROWSE_DIR */ 3963 char_u *title, /* title for the window */ 3964 char_u *dflt, /* default file name (may include directory) */ 3965 char_u *ext, /* extension added */ 3966 char_u *initdir, /* initial directory, NULL for current dir or 3967 when using path from "dflt" */ 3968 char_u *filter, /* file name filter */ 3969 buf_T *buf) /* buffer to read/write for */ 3970 { 3971 char_u *fname; 3972 static char_u *last_dir = NULL; /* last used directory */ 3973 char_u *tofree = NULL; 3974 int save_browse = cmdmod.browse; 3975 3976 /* Must turn off browse to avoid that autocommands will get the 3977 * flag too! */ 3978 cmdmod.browse = FALSE; 3979 3980 if (title == NULL || *title == NUL) 3981 { 3982 if (flags & BROWSE_DIR) 3983 title = (char_u *)_("Select Directory dialog"); 3984 else if (flags & BROWSE_SAVE) 3985 title = (char_u *)_("Save File dialog"); 3986 else 3987 title = (char_u *)_("Open File dialog"); 3988 } 3989 3990 /* When no directory specified, use default file name, default dir, buffer 3991 * dir, last dir or current dir */ 3992 if ((initdir == NULL || *initdir == NUL) && dflt != NULL && *dflt != NUL) 3993 { 3994 if (mch_isdir(dflt)) /* default file name is a directory */ 3995 { 3996 initdir = dflt; 3997 dflt = NULL; 3998 } 3999 else if (gettail(dflt) != dflt) /* default file name includes a path */ 4000 { 4001 tofree = vim_strsave(dflt); 4002 if (tofree != NULL) 4003 { 4004 initdir = tofree; 4005 *gettail(initdir) = NUL; 4006 dflt = gettail(dflt); 4007 } 4008 } 4009 } 4010 4011 if (initdir == NULL || *initdir == NUL) 4012 { 4013 /* When 'browsedir' is a directory, use it */ 4014 if (STRCMP(p_bsdir, "last") != 0 4015 && STRCMP(p_bsdir, "buffer") != 0 4016 && STRCMP(p_bsdir, "current") != 0 4017 && mch_isdir(p_bsdir)) 4018 initdir = p_bsdir; 4019 /* When saving or 'browsedir' is "buffer", use buffer fname */ 4020 else if (((flags & BROWSE_SAVE) || *p_bsdir == 'b') 4021 && buf != NULL && buf->b_ffname != NULL) 4022 { 4023 if (dflt == NULL || *dflt == NUL) 4024 dflt = gettail(curbuf->b_ffname); 4025 tofree = vim_strsave(curbuf->b_ffname); 4026 if (tofree != NULL) 4027 { 4028 initdir = tofree; 4029 *gettail(initdir) = NUL; 4030 } 4031 } 4032 /* When 'browsedir' is "last", use dir from last browse */ 4033 else if (*p_bsdir == 'l') 4034 initdir = last_dir; 4035 /* When 'browsedir is "current", use current directory. This is the 4036 * default already, leave initdir empty. */ 4037 } 4038 4039 # ifdef FEAT_GUI 4040 if (gui.in_use) /* when this changes, also adjust f_has()! */ 4041 { 4042 if (filter == NULL 4043 # ifdef FEAT_EVAL 4044 && (filter = get_var_value((char_u *)"b:browsefilter")) == NULL 4045 && (filter = get_var_value((char_u *)"g:browsefilter")) == NULL 4046 # endif 4047 ) 4048 filter = BROWSE_FILTER_DEFAULT; 4049 if (flags & BROWSE_DIR) 4050 { 4051 # if defined(FEAT_GUI_GTK) || defined(MSWIN) 4052 /* For systems that have a directory dialog. */ 4053 fname = gui_mch_browsedir(title, initdir); 4054 # else 4055 /* Generic solution for selecting a directory: select a file and 4056 * remove the file name. */ 4057 fname = gui_mch_browse(0, title, dflt, ext, initdir, (char_u *)""); 4058 # endif 4059 # if !defined(FEAT_GUI_GTK) 4060 /* Win32 adds a dummy file name, others return an arbitrary file 4061 * name. GTK+ 2 returns only the directory, */ 4062 if (fname != NULL && *fname != NUL && !mch_isdir(fname)) 4063 { 4064 /* Remove the file name. */ 4065 char_u *tail = gettail_sep(fname); 4066 4067 if (tail == fname) 4068 *tail++ = '.'; /* use current dir */ 4069 *tail = NUL; 4070 } 4071 # endif 4072 } 4073 else 4074 fname = gui_mch_browse(flags & BROWSE_SAVE, 4075 title, dflt, ext, initdir, (char_u *)_(filter)); 4076 4077 /* We hang around in the dialog for a while, the user might do some 4078 * things to our files. The Win32 dialog allows deleting or renaming 4079 * a file, check timestamps. */ 4080 need_check_timestamps = TRUE; 4081 did_check_timestamps = FALSE; 4082 } 4083 else 4084 # endif 4085 { 4086 /* TODO: non-GUI file selector here */ 4087 emsg(_("E338: Sorry, no file browser in console mode")); 4088 fname = NULL; 4089 } 4090 4091 /* keep the directory for next time */ 4092 if (fname != NULL) 4093 { 4094 vim_free(last_dir); 4095 last_dir = vim_strsave(fname); 4096 if (last_dir != NULL && !(flags & BROWSE_DIR)) 4097 { 4098 *gettail(last_dir) = NUL; 4099 if (*last_dir == NUL) 4100 { 4101 /* filename only returned, must be in current dir */ 4102 vim_free(last_dir); 4103 last_dir = alloc(MAXPATHL); 4104 if (last_dir != NULL) 4105 mch_dirname(last_dir, MAXPATHL); 4106 } 4107 } 4108 } 4109 4110 vim_free(tofree); 4111 cmdmod.browse = save_browse; 4112 4113 return fname; 4114 } 4115 #endif 4116 4117 #if defined(FEAT_EVAL) 4118 static char *e_printf = N_("E766: Insufficient arguments for printf()"); 4119 4120 /* 4121 * Get number argument from "idxp" entry in "tvs". First entry is 1. 4122 */ 4123 static varnumber_T 4124 tv_nr(typval_T *tvs, int *idxp) 4125 { 4126 int idx = *idxp - 1; 4127 varnumber_T n = 0; 4128 int err = FALSE; 4129 4130 if (tvs[idx].v_type == VAR_UNKNOWN) 4131 emsg(_(e_printf)); 4132 else 4133 { 4134 ++*idxp; 4135 n = tv_get_number_chk(&tvs[idx], &err); 4136 if (err) 4137 n = 0; 4138 } 4139 return n; 4140 } 4141 4142 /* 4143 * Get string argument from "idxp" entry in "tvs". First entry is 1. 4144 * If "tofree" is NULL tv_get_string_chk() is used. Some types (e.g. List) 4145 * are not converted to a string. 4146 * If "tofree" is not NULL echo_string() is used. All types are converted to 4147 * a string with the same format as ":echo". The caller must free "*tofree". 4148 * Returns NULL for an error. 4149 */ 4150 static char * 4151 tv_str(typval_T *tvs, int *idxp, char_u **tofree) 4152 { 4153 int idx = *idxp - 1; 4154 char *s = NULL; 4155 static char_u numbuf[NUMBUFLEN]; 4156 4157 if (tvs[idx].v_type == VAR_UNKNOWN) 4158 emsg(_(e_printf)); 4159 else 4160 { 4161 ++*idxp; 4162 if (tofree != NULL) 4163 s = (char *)echo_string(&tvs[idx], tofree, numbuf, get_copyID()); 4164 else 4165 s = (char *)tv_get_string_chk(&tvs[idx]); 4166 } 4167 return s; 4168 } 4169 4170 # ifdef FEAT_FLOAT 4171 /* 4172 * Get float argument from "idxp" entry in "tvs". First entry is 1. 4173 */ 4174 static double 4175 tv_float(typval_T *tvs, int *idxp) 4176 { 4177 int idx = *idxp - 1; 4178 double f = 0; 4179 4180 if (tvs[idx].v_type == VAR_UNKNOWN) 4181 emsg(_(e_printf)); 4182 else 4183 { 4184 ++*idxp; 4185 if (tvs[idx].v_type == VAR_FLOAT) 4186 f = tvs[idx].vval.v_float; 4187 else if (tvs[idx].v_type == VAR_NUMBER) 4188 f = (double)tvs[idx].vval.v_number; 4189 else 4190 emsg(_("E807: Expected Float argument for printf()")); 4191 } 4192 return f; 4193 } 4194 # endif 4195 #endif 4196 4197 #ifdef FEAT_FLOAT 4198 /* 4199 * Return the representation of infinity for printf() function: 4200 * "-inf", "inf", "+inf", " inf", "-INF", "INF", "+INF" or " INF". 4201 */ 4202 static const char * 4203 infinity_str(int positive, 4204 char fmt_spec, 4205 int force_sign, 4206 int space_for_positive) 4207 { 4208 static const char *table[] = 4209 { 4210 "-inf", "inf", "+inf", " inf", 4211 "-INF", "INF", "+INF", " INF" 4212 }; 4213 int idx = positive * (1 + force_sign + force_sign * space_for_positive); 4214 4215 if (ASCII_ISUPPER(fmt_spec)) 4216 idx += 4; 4217 return table[idx]; 4218 } 4219 #endif 4220 4221 /* 4222 * This code was included to provide a portable vsnprintf() and snprintf(). 4223 * Some systems may provide their own, but we always use this one for 4224 * consistency. 4225 * 4226 * This code is based on snprintf.c - a portable implementation of snprintf 4227 * by Mark Martinec <[email protected]>, Version 2.2, 2000-10-06. 4228 * Included with permission. It was heavily modified to fit in Vim. 4229 * The original code, including useful comments, can be found here: 4230 * http://www.ijs.si/software/snprintf/ 4231 * 4232 * This snprintf() only supports the following conversion specifiers: 4233 * s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below) 4234 * with flags: '-', '+', ' ', '0' and '#'. 4235 * An asterisk is supported for field width as well as precision. 4236 * 4237 * Limited support for floating point was added: 'f', 'F', 'e', 'E', 'g', 'G'. 4238 * 4239 * Length modifiers 'h' (short int) and 'l' (long int) and 'll' (long long int) 4240 * are supported. 4241 * 4242 * The locale is not used, the string is used as a byte string. This is only 4243 * relevant for double-byte encodings where the second byte may be '%'. 4244 * 4245 * It is permitted for "str_m" to be zero, and it is permitted to specify NULL 4246 * pointer for resulting string argument if "str_m" is zero (as per ISO C99). 4247 * 4248 * The return value is the number of characters which would be generated 4249 * for the given input, excluding the trailing NUL. If this value 4250 * is greater or equal to "str_m", not all characters from the result 4251 * have been stored in str, output bytes beyond the ("str_m"-1) -th character 4252 * are discarded. If "str_m" is greater than zero it is guaranteed 4253 * the resulting string will be NUL-terminated. 4254 */ 4255 4256 /* 4257 * When va_list is not supported we only define vim_snprintf(). 4258 * 4259 * vim_vsnprintf_typval() can be invoked with either "va_list" or a list of 4260 * "typval_T". When the latter is not used it must be NULL. 4261 */ 4262 4263 /* When generating prototypes all of this is skipped, cproto doesn't 4264 * understand this. */ 4265 #ifndef PROTO 4266 4267 /* Like vim_vsnprintf() but append to the string. */ 4268 int 4269 vim_snprintf_add(char *str, size_t str_m, const char *fmt, ...) 4270 { 4271 va_list ap; 4272 int str_l; 4273 size_t len = STRLEN(str); 4274 size_t space; 4275 4276 if (str_m <= len) 4277 space = 0; 4278 else 4279 space = str_m - len; 4280 va_start(ap, fmt); 4281 str_l = vim_vsnprintf(str + len, space, fmt, ap); 4282 va_end(ap); 4283 return str_l; 4284 } 4285 4286 int 4287 vim_snprintf(char *str, size_t str_m, const char *fmt, ...) 4288 { 4289 va_list ap; 4290 int str_l; 4291 4292 va_start(ap, fmt); 4293 str_l = vim_vsnprintf(str, str_m, fmt, ap); 4294 va_end(ap); 4295 return str_l; 4296 } 4297 4298 int 4299 vim_vsnprintf( 4300 char *str, 4301 size_t str_m, 4302 const char *fmt, 4303 va_list ap) 4304 { 4305 return vim_vsnprintf_typval(str, str_m, fmt, ap, NULL); 4306 } 4307 4308 int 4309 vim_vsnprintf_typval( 4310 char *str, 4311 size_t str_m, 4312 const char *fmt, 4313 va_list ap, 4314 typval_T *tvs) 4315 { 4316 size_t str_l = 0; 4317 const char *p = fmt; 4318 int arg_idx = 1; 4319 4320 if (p == NULL) 4321 p = ""; 4322 while (*p != NUL) 4323 { 4324 if (*p != '%') 4325 { 4326 char *q = strchr(p + 1, '%'); 4327 size_t n = (q == NULL) ? STRLEN(p) : (size_t)(q - p); 4328 4329 /* Copy up to the next '%' or NUL without any changes. */ 4330 if (str_l < str_m) 4331 { 4332 size_t avail = str_m - str_l; 4333 4334 mch_memmove(str + str_l, p, n > avail ? avail : n); 4335 } 4336 p += n; 4337 str_l += n; 4338 } 4339 else 4340 { 4341 size_t min_field_width = 0, precision = 0; 4342 int zero_padding = 0, precision_specified = 0, justify_left = 0; 4343 int alternate_form = 0, force_sign = 0; 4344 4345 /* If both the ' ' and '+' flags appear, the ' ' flag should be 4346 * ignored. */ 4347 int space_for_positive = 1; 4348 4349 /* allowed values: \0, h, l, L */ 4350 char length_modifier = '\0'; 4351 4352 /* temporary buffer for simple numeric->string conversion */ 4353 # if defined(FEAT_FLOAT) 4354 # define TMP_LEN 350 /* On my system 1e308 is the biggest number possible. 4355 * That sounds reasonable to use as the maximum 4356 * printable. */ 4357 # elif defined(FEAT_NUM64) 4358 # define TMP_LEN 66 4359 # else 4360 # define TMP_LEN 34 4361 # endif 4362 char tmp[TMP_LEN]; 4363 4364 /* string address in case of string argument */ 4365 const char *str_arg = NULL; 4366 4367 /* natural field width of arg without padding and sign */ 4368 size_t str_arg_l; 4369 4370 /* unsigned char argument value - only defined for c conversion. 4371 * N.B. standard explicitly states the char argument for the c 4372 * conversion is unsigned */ 4373 unsigned char uchar_arg; 4374 4375 /* number of zeros to be inserted for numeric conversions as 4376 * required by the precision or minimal field width */ 4377 size_t number_of_zeros_to_pad = 0; 4378 4379 /* index into tmp where zero padding is to be inserted */ 4380 size_t zero_padding_insertion_ind = 0; 4381 4382 /* current conversion specifier character */ 4383 char fmt_spec = '\0'; 4384 4385 /* buffer for 's' and 'S' specs */ 4386 char_u *tofree = NULL; 4387 4388 4389 p++; /* skip '%' */ 4390 4391 /* parse flags */ 4392 while (*p == '0' || *p == '-' || *p == '+' || *p == ' ' 4393 || *p == '#' || *p == '\'') 4394 { 4395 switch (*p) 4396 { 4397 case '0': zero_padding = 1; break; 4398 case '-': justify_left = 1; break; 4399 case '+': force_sign = 1; space_for_positive = 0; break; 4400 case ' ': force_sign = 1; 4401 /* If both the ' ' and '+' flags appear, the ' ' 4402 * flag should be ignored */ 4403 break; 4404 case '#': alternate_form = 1; break; 4405 case '\'': break; 4406 } 4407 p++; 4408 } 4409 /* If the '0' and '-' flags both appear, the '0' flag should be 4410 * ignored. */ 4411 4412 /* parse field width */ 4413 if (*p == '*') 4414 { 4415 int j; 4416 4417 p++; 4418 j = 4419 # if defined(FEAT_EVAL) 4420 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4421 # endif 4422 va_arg(ap, int); 4423 if (j >= 0) 4424 min_field_width = j; 4425 else 4426 { 4427 min_field_width = -j; 4428 justify_left = 1; 4429 } 4430 } 4431 else if (VIM_ISDIGIT((int)(*p))) 4432 { 4433 /* size_t could be wider than unsigned int; make sure we treat 4434 * argument like common implementations do */ 4435 unsigned int uj = *p++ - '0'; 4436 4437 while (VIM_ISDIGIT((int)(*p))) 4438 uj = 10 * uj + (unsigned int)(*p++ - '0'); 4439 min_field_width = uj; 4440 } 4441 4442 /* parse precision */ 4443 if (*p == '.') 4444 { 4445 p++; 4446 precision_specified = 1; 4447 if (*p == '*') 4448 { 4449 int j; 4450 4451 j = 4452 # if defined(FEAT_EVAL) 4453 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4454 # endif 4455 va_arg(ap, int); 4456 p++; 4457 if (j >= 0) 4458 precision = j; 4459 else 4460 { 4461 precision_specified = 0; 4462 precision = 0; 4463 } 4464 } 4465 else if (VIM_ISDIGIT((int)(*p))) 4466 { 4467 /* size_t could be wider than unsigned int; make sure we 4468 * treat argument like common implementations do */ 4469 unsigned int uj = *p++ - '0'; 4470 4471 while (VIM_ISDIGIT((int)(*p))) 4472 uj = 10 * uj + (unsigned int)(*p++ - '0'); 4473 precision = uj; 4474 } 4475 } 4476 4477 /* parse 'h', 'l' and 'll' length modifiers */ 4478 if (*p == 'h' || *p == 'l') 4479 { 4480 length_modifier = *p; 4481 p++; 4482 if (length_modifier == 'l' && *p == 'l') 4483 { 4484 /* double l = long long */ 4485 # ifdef FEAT_NUM64 4486 length_modifier = 'L'; 4487 # else 4488 length_modifier = 'l'; /* treat it as a single 'l' */ 4489 # endif 4490 p++; 4491 } 4492 } 4493 fmt_spec = *p; 4494 4495 /* common synonyms: */ 4496 switch (fmt_spec) 4497 { 4498 case 'i': fmt_spec = 'd'; break; 4499 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break; 4500 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break; 4501 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break; 4502 default: break; 4503 } 4504 4505 # if defined(FEAT_EVAL) && defined(FEAT_NUM64) 4506 switch (fmt_spec) 4507 { 4508 case 'd': case 'u': case 'o': case 'x': case 'X': 4509 if (tvs != NULL && length_modifier == '\0') 4510 length_modifier = 'L'; 4511 } 4512 # endif 4513 4514 /* get parameter value, do initial processing */ 4515 switch (fmt_spec) 4516 { 4517 /* '%' and 'c' behave similar to 's' regarding flags and field 4518 * widths */ 4519 case '%': 4520 case 'c': 4521 case 's': 4522 case 'S': 4523 str_arg_l = 1; 4524 switch (fmt_spec) 4525 { 4526 case '%': 4527 str_arg = p; 4528 break; 4529 4530 case 'c': 4531 { 4532 int j; 4533 4534 j = 4535 # if defined(FEAT_EVAL) 4536 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4537 # endif 4538 va_arg(ap, int); 4539 /* standard demands unsigned char */ 4540 uchar_arg = (unsigned char)j; 4541 str_arg = (char *)&uchar_arg; 4542 break; 4543 } 4544 4545 case 's': 4546 case 'S': 4547 str_arg = 4548 # if defined(FEAT_EVAL) 4549 tvs != NULL ? tv_str(tvs, &arg_idx, &tofree) : 4550 # endif 4551 va_arg(ap, char *); 4552 if (str_arg == NULL) 4553 { 4554 str_arg = "[NULL]"; 4555 str_arg_l = 6; 4556 } 4557 /* make sure not to address string beyond the specified 4558 * precision !!! */ 4559 else if (!precision_specified) 4560 str_arg_l = strlen(str_arg); 4561 /* truncate string if necessary as requested by precision */ 4562 else if (precision == 0) 4563 str_arg_l = 0; 4564 else 4565 { 4566 /* Don't put the #if inside memchr(), it can be a 4567 * macro. */ 4568 /* memchr on HP does not like n > 2^31 !!! */ 4569 char *q = memchr(str_arg, '\0', 4570 precision <= (size_t)0x7fffffffL ? precision 4571 : (size_t)0x7fffffffL); 4572 str_arg_l = (q == NULL) ? precision 4573 : (size_t)(q - str_arg); 4574 } 4575 if (fmt_spec == 'S') 4576 { 4577 if (min_field_width != 0) 4578 min_field_width += STRLEN(str_arg) 4579 - mb_string2cells((char_u *)str_arg, -1); 4580 if (precision) 4581 { 4582 char_u *p1 = (char_u *)str_arg; 4583 size_t i; 4584 4585 for (i = 0; i < precision && *p1; i++) 4586 p1 += mb_ptr2len(p1); 4587 4588 str_arg_l = precision = p1 - (char_u *)str_arg; 4589 } 4590 } 4591 break; 4592 4593 default: 4594 break; 4595 } 4596 break; 4597 4598 case 'd': case 'u': 4599 case 'b': case 'B': 4600 case 'o': 4601 case 'x': case 'X': 4602 case 'p': 4603 { 4604 /* NOTE: the u, b, o, x, X and p conversion specifiers 4605 * imply the value is unsigned; d implies a signed 4606 * value */ 4607 4608 /* 0 if numeric argument is zero (or if pointer is 4609 * NULL for 'p'), +1 if greater than zero (or nonzero 4610 * for unsigned arguments), -1 if negative (unsigned 4611 * argument is never negative) */ 4612 int arg_sign = 0; 4613 4614 /* only defined for length modifier h, or for no 4615 * length modifiers */ 4616 int int_arg = 0; 4617 unsigned int uint_arg = 0; 4618 4619 /* only defined for length modifier l */ 4620 long int long_arg = 0; 4621 unsigned long int ulong_arg = 0; 4622 4623 # ifdef FEAT_NUM64 4624 /* only defined for length modifier ll */ 4625 varnumber_T llong_arg = 0; 4626 uvarnumber_T ullong_arg = 0; 4627 # endif 4628 4629 /* only defined for b conversion */ 4630 uvarnumber_T bin_arg = 0; 4631 4632 /* pointer argument value -only defined for p 4633 * conversion */ 4634 void *ptr_arg = NULL; 4635 4636 if (fmt_spec == 'p') 4637 { 4638 length_modifier = '\0'; 4639 ptr_arg = 4640 # if defined(FEAT_EVAL) 4641 tvs != NULL ? (void *)tv_str(tvs, &arg_idx, 4642 NULL) : 4643 # endif 4644 va_arg(ap, void *); 4645 if (ptr_arg != NULL) 4646 arg_sign = 1; 4647 } 4648 else if (fmt_spec == 'b' || fmt_spec == 'B') 4649 { 4650 bin_arg = 4651 # if defined(FEAT_EVAL) 4652 tvs != NULL ? 4653 (uvarnumber_T)tv_nr(tvs, &arg_idx) : 4654 # endif 4655 va_arg(ap, uvarnumber_T); 4656 if (bin_arg != 0) 4657 arg_sign = 1; 4658 } 4659 else if (fmt_spec == 'd') 4660 { 4661 /* signed */ 4662 switch (length_modifier) 4663 { 4664 case '\0': 4665 case 'h': 4666 /* char and short arguments are passed as int. */ 4667 int_arg = 4668 # if defined(FEAT_EVAL) 4669 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4670 # endif 4671 va_arg(ap, int); 4672 if (int_arg > 0) 4673 arg_sign = 1; 4674 else if (int_arg < 0) 4675 arg_sign = -1; 4676 break; 4677 case 'l': 4678 long_arg = 4679 # if defined(FEAT_EVAL) 4680 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4681 # endif 4682 va_arg(ap, long int); 4683 if (long_arg > 0) 4684 arg_sign = 1; 4685 else if (long_arg < 0) 4686 arg_sign = -1; 4687 break; 4688 # ifdef FEAT_NUM64 4689 case 'L': 4690 llong_arg = 4691 # if defined(FEAT_EVAL) 4692 tvs != NULL ? tv_nr(tvs, &arg_idx) : 4693 # endif 4694 va_arg(ap, varnumber_T); 4695 if (llong_arg > 0) 4696 arg_sign = 1; 4697 else if (llong_arg < 0) 4698 arg_sign = -1; 4699 break; 4700 # endif 4701 } 4702 } 4703 else 4704 { 4705 /* unsigned */ 4706 switch (length_modifier) 4707 { 4708 case '\0': 4709 case 'h': 4710 uint_arg = 4711 # if defined(FEAT_EVAL) 4712 tvs != NULL ? (unsigned) 4713 tv_nr(tvs, &arg_idx) : 4714 # endif 4715 va_arg(ap, unsigned int); 4716 if (uint_arg != 0) 4717 arg_sign = 1; 4718 break; 4719 case 'l': 4720 ulong_arg = 4721 # if defined(FEAT_EVAL) 4722 tvs != NULL ? (unsigned long) 4723 tv_nr(tvs, &arg_idx) : 4724 # endif 4725 va_arg(ap, unsigned long int); 4726 if (ulong_arg != 0) 4727 arg_sign = 1; 4728 break; 4729 # ifdef FEAT_NUM64 4730 case 'L': 4731 ullong_arg = 4732 # if defined(FEAT_EVAL) 4733 tvs != NULL ? (uvarnumber_T) 4734 tv_nr(tvs, &arg_idx) : 4735 # endif 4736 va_arg(ap, uvarnumber_T); 4737 if (ullong_arg != 0) 4738 arg_sign = 1; 4739 break; 4740 # endif 4741 } 4742 } 4743 4744 str_arg = tmp; 4745 str_arg_l = 0; 4746 4747 /* NOTE: 4748 * For d, i, u, o, x, and X conversions, if precision is 4749 * specified, the '0' flag should be ignored. This is so 4750 * with Solaris 2.6, Digital UNIX 4.0, HPUX 10, Linux, 4751 * FreeBSD, NetBSD; but not with Perl. 4752 */ 4753 if (precision_specified) 4754 zero_padding = 0; 4755 if (fmt_spec == 'd') 4756 { 4757 if (force_sign && arg_sign >= 0) 4758 tmp[str_arg_l++] = space_for_positive ? ' ' : '+'; 4759 /* leave negative numbers for sprintf to handle, to 4760 * avoid handling tricky cases like (short int)-32768 */ 4761 } 4762 else if (alternate_form) 4763 { 4764 if (arg_sign != 0 4765 && (fmt_spec == 'b' || fmt_spec == 'B' 4766 || fmt_spec == 'x' || fmt_spec == 'X') ) 4767 { 4768 tmp[str_arg_l++] = '0'; 4769 tmp[str_arg_l++] = fmt_spec; 4770 } 4771 /* alternate form should have no effect for p 4772 * conversion, but ... */ 4773 } 4774 4775 zero_padding_insertion_ind = str_arg_l; 4776 if (!precision_specified) 4777 precision = 1; /* default precision is 1 */ 4778 if (precision == 0 && arg_sign == 0) 4779 { 4780 /* When zero value is formatted with an explicit 4781 * precision 0, the resulting formatted string is 4782 * empty (d, i, u, b, B, o, x, X, p). */ 4783 } 4784 else 4785 { 4786 char f[6]; 4787 int f_l = 0; 4788 4789 /* construct a simple format string for sprintf */ 4790 f[f_l++] = '%'; 4791 if (!length_modifier) 4792 ; 4793 else if (length_modifier == 'L') 4794 { 4795 # ifdef FEAT_NUM64 4796 # ifdef MSWIN 4797 f[f_l++] = 'I'; 4798 f[f_l++] = '6'; 4799 f[f_l++] = '4'; 4800 # else 4801 f[f_l++] = 'l'; 4802 f[f_l++] = 'l'; 4803 # endif 4804 # else 4805 f[f_l++] = 'l'; 4806 # endif 4807 } 4808 else 4809 f[f_l++] = length_modifier; 4810 f[f_l++] = fmt_spec; 4811 f[f_l++] = '\0'; 4812 4813 if (fmt_spec == 'p') 4814 str_arg_l += sprintf(tmp + str_arg_l, f, ptr_arg); 4815 else if (fmt_spec == 'b' || fmt_spec == 'B') 4816 { 4817 char b[8 * sizeof(uvarnumber_T)]; 4818 size_t b_l = 0; 4819 uvarnumber_T bn = bin_arg; 4820 4821 do 4822 { 4823 b[sizeof(b) - ++b_l] = '0' + (bn & 0x1); 4824 bn >>= 1; 4825 } 4826 while (bn != 0); 4827 4828 memcpy(tmp + str_arg_l, b + sizeof(b) - b_l, b_l); 4829 str_arg_l += b_l; 4830 } 4831 else if (fmt_spec == 'd') 4832 { 4833 /* signed */ 4834 switch (length_modifier) 4835 { 4836 case '\0': 4837 case 'h': str_arg_l += sprintf( 4838 tmp + str_arg_l, f, int_arg); 4839 break; 4840 case 'l': str_arg_l += sprintf( 4841 tmp + str_arg_l, f, long_arg); 4842 break; 4843 # ifdef FEAT_NUM64 4844 case 'L': str_arg_l += sprintf( 4845 tmp + str_arg_l, f, llong_arg); 4846 break; 4847 # endif 4848 } 4849 } 4850 else 4851 { 4852 /* unsigned */ 4853 switch (length_modifier) 4854 { 4855 case '\0': 4856 case 'h': str_arg_l += sprintf( 4857 tmp + str_arg_l, f, uint_arg); 4858 break; 4859 case 'l': str_arg_l += sprintf( 4860 tmp + str_arg_l, f, ulong_arg); 4861 break; 4862 # ifdef FEAT_NUM64 4863 case 'L': str_arg_l += sprintf( 4864 tmp + str_arg_l, f, ullong_arg); 4865 break; 4866 # endif 4867 } 4868 } 4869 4870 /* include the optional minus sign and possible 4871 * "0x" in the region before the zero padding 4872 * insertion point */ 4873 if (zero_padding_insertion_ind < str_arg_l 4874 && tmp[zero_padding_insertion_ind] == '-') 4875 zero_padding_insertion_ind++; 4876 if (zero_padding_insertion_ind + 1 < str_arg_l 4877 && tmp[zero_padding_insertion_ind] == '0' 4878 && (tmp[zero_padding_insertion_ind + 1] == 'x' 4879 || tmp[zero_padding_insertion_ind + 1] == 'X')) 4880 zero_padding_insertion_ind += 2; 4881 } 4882 4883 { 4884 size_t num_of_digits = str_arg_l 4885 - zero_padding_insertion_ind; 4886 4887 if (alternate_form && fmt_spec == 'o' 4888 /* unless zero is already the first 4889 * character */ 4890 && !(zero_padding_insertion_ind < str_arg_l 4891 && tmp[zero_padding_insertion_ind] == '0')) 4892 { 4893 /* assure leading zero for alternate-form 4894 * octal numbers */ 4895 if (!precision_specified 4896 || precision < num_of_digits + 1) 4897 { 4898 /* precision is increased to force the 4899 * first character to be zero, except if a 4900 * zero value is formatted with an 4901 * explicit precision of zero */ 4902 precision = num_of_digits + 1; 4903 } 4904 } 4905 /* zero padding to specified precision? */ 4906 if (num_of_digits < precision) 4907 number_of_zeros_to_pad = precision - num_of_digits; 4908 } 4909 /* zero padding to specified minimal field width? */ 4910 if (!justify_left && zero_padding) 4911 { 4912 int n = (int)(min_field_width - (str_arg_l 4913 + number_of_zeros_to_pad)); 4914 if (n > 0) 4915 number_of_zeros_to_pad += n; 4916 } 4917 break; 4918 } 4919 4920 # ifdef FEAT_FLOAT 4921 case 'f': 4922 case 'F': 4923 case 'e': 4924 case 'E': 4925 case 'g': 4926 case 'G': 4927 { 4928 /* Floating point. */ 4929 double f; 4930 double abs_f; 4931 char format[40]; 4932 int l; 4933 int remove_trailing_zeroes = FALSE; 4934 4935 f = 4936 # if defined(FEAT_EVAL) 4937 tvs != NULL ? tv_float(tvs, &arg_idx) : 4938 # endif 4939 va_arg(ap, double); 4940 abs_f = f < 0 ? -f : f; 4941 4942 if (fmt_spec == 'g' || fmt_spec == 'G') 4943 { 4944 /* Would be nice to use %g directly, but it prints 4945 * "1.0" as "1", we don't want that. */ 4946 if ((abs_f >= 0.001 && abs_f < 10000000.0) 4947 || abs_f == 0.0) 4948 fmt_spec = ASCII_ISUPPER(fmt_spec) ? 'F' : 'f'; 4949 else 4950 fmt_spec = fmt_spec == 'g' ? 'e' : 'E'; 4951 remove_trailing_zeroes = TRUE; 4952 } 4953 4954 if ((fmt_spec == 'f' || fmt_spec == 'F') && 4955 # ifdef VAX 4956 abs_f > 1.0e38 4957 # else 4958 abs_f > 1.0e307 4959 # endif 4960 ) 4961 { 4962 /* Avoid a buffer overflow */ 4963 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec, 4964 force_sign, space_for_positive)); 4965 str_arg_l = STRLEN(tmp); 4966 zero_padding = 0; 4967 } 4968 else 4969 { 4970 if (isnan(f)) 4971 { 4972 /* Not a number: nan or NAN */ 4973 STRCPY(tmp, ASCII_ISUPPER(fmt_spec) ? "NAN" 4974 : "nan"); 4975 str_arg_l = 3; 4976 zero_padding = 0; 4977 } 4978 else if (isinf(f)) 4979 { 4980 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec, 4981 force_sign, space_for_positive)); 4982 str_arg_l = STRLEN(tmp); 4983 zero_padding = 0; 4984 } 4985 else 4986 { 4987 /* Regular float number */ 4988 format[0] = '%'; 4989 l = 1; 4990 if (force_sign) 4991 format[l++] = space_for_positive ? ' ' : '+'; 4992 if (precision_specified) 4993 { 4994 size_t max_prec = TMP_LEN - 10; 4995 4996 /* Make sure we don't get more digits than we 4997 * have room for. */ 4998 if ((fmt_spec == 'f' || fmt_spec == 'F') 4999 && abs_f > 1.0) 5000 max_prec -= (size_t)log10(abs_f); 5001 if (precision > max_prec) 5002 precision = max_prec; 5003 l += sprintf(format + l, ".%d", (int)precision); 5004 } 5005 format[l] = fmt_spec == 'F' ? 'f' : fmt_spec; 5006 format[l + 1] = NUL; 5007 5008 str_arg_l = sprintf(tmp, format, f); 5009 } 5010 5011 if (remove_trailing_zeroes) 5012 { 5013 int i; 5014 char *tp; 5015 5016 /* Using %g or %G: remove superfluous zeroes. */ 5017 if (fmt_spec == 'f' || fmt_spec == 'F') 5018 tp = tmp + str_arg_l - 1; 5019 else 5020 { 5021 tp = (char *)vim_strchr((char_u *)tmp, 5022 fmt_spec == 'e' ? 'e' : 'E'); 5023 if (tp != NULL) 5024 { 5025 /* Remove superfluous '+' and leading 5026 * zeroes from the exponent. */ 5027 if (tp[1] == '+') 5028 { 5029 /* Change "1.0e+07" to "1.0e07" */ 5030 STRMOVE(tp + 1, tp + 2); 5031 --str_arg_l; 5032 } 5033 i = (tp[1] == '-') ? 2 : 1; 5034 while (tp[i] == '0') 5035 { 5036 /* Change "1.0e07" to "1.0e7" */ 5037 STRMOVE(tp + i, tp + i + 1); 5038 --str_arg_l; 5039 } 5040 --tp; 5041 } 5042 } 5043 5044 if (tp != NULL && !precision_specified) 5045 /* Remove trailing zeroes, but keep the one 5046 * just after a dot. */ 5047 while (tp > tmp + 2 && *tp == '0' 5048 && tp[-1] != '.') 5049 { 5050 STRMOVE(tp, tp + 1); 5051 --tp; 5052 --str_arg_l; 5053 } 5054 } 5055 else 5056 { 5057 char *tp; 5058 5059 /* Be consistent: some printf("%e") use 1.0e+12 5060 * and some 1.0e+012. Remove one zero in the last 5061 * case. */ 5062 tp = (char *)vim_strchr((char_u *)tmp, 5063 fmt_spec == 'e' ? 'e' : 'E'); 5064 if (tp != NULL && (tp[1] == '+' || tp[1] == '-') 5065 && tp[2] == '0' 5066 && vim_isdigit(tp[3]) 5067 && vim_isdigit(tp[4])) 5068 { 5069 STRMOVE(tp + 2, tp + 3); 5070 --str_arg_l; 5071 } 5072 } 5073 } 5074 if (zero_padding && min_field_width > str_arg_l 5075 && (tmp[0] == '-' || force_sign)) 5076 { 5077 /* padding 0's should be inserted after the sign */ 5078 number_of_zeros_to_pad = min_field_width - str_arg_l; 5079 zero_padding_insertion_ind = 1; 5080 } 5081 str_arg = tmp; 5082 break; 5083 } 5084 # endif 5085 5086 default: 5087 /* unrecognized conversion specifier, keep format string 5088 * as-is */ 5089 zero_padding = 0; /* turn zero padding off for non-numeric 5090 conversion */ 5091 justify_left = 1; 5092 min_field_width = 0; /* reset flags */ 5093 5094 /* discard the unrecognized conversion, just keep * 5095 * the unrecognized conversion character */ 5096 str_arg = p; 5097 str_arg_l = 0; 5098 if (*p != NUL) 5099 str_arg_l++; /* include invalid conversion specifier 5100 unchanged if not at end-of-string */ 5101 break; 5102 } 5103 5104 if (*p != NUL) 5105 p++; /* step over the just processed conversion specifier */ 5106 5107 /* insert padding to the left as requested by min_field_width; 5108 * this does not include the zero padding in case of numerical 5109 * conversions*/ 5110 if (!justify_left) 5111 { 5112 /* left padding with blank or zero */ 5113 int pn = (int)(min_field_width - (str_arg_l + number_of_zeros_to_pad)); 5114 5115 if (pn > 0) 5116 { 5117 if (str_l < str_m) 5118 { 5119 size_t avail = str_m - str_l; 5120 5121 vim_memset(str + str_l, zero_padding ? '0' : ' ', 5122 (size_t)pn > avail ? avail 5123 : (size_t)pn); 5124 } 5125 str_l += pn; 5126 } 5127 } 5128 5129 /* zero padding as requested by the precision or by the minimal 5130 * field width for numeric conversions required? */ 5131 if (number_of_zeros_to_pad == 0) 5132 { 5133 /* will not copy first part of numeric right now, * 5134 * force it to be copied later in its entirety */ 5135 zero_padding_insertion_ind = 0; 5136 } 5137 else 5138 { 5139 /* insert first part of numerics (sign or '0x') before zero 5140 * padding */ 5141 int zn = (int)zero_padding_insertion_ind; 5142 5143 if (zn > 0) 5144 { 5145 if (str_l < str_m) 5146 { 5147 size_t avail = str_m - str_l; 5148 5149 mch_memmove(str + str_l, str_arg, 5150 (size_t)zn > avail ? avail 5151 : (size_t)zn); 5152 } 5153 str_l += zn; 5154 } 5155 5156 /* insert zero padding as requested by the precision or min 5157 * field width */ 5158 zn = (int)number_of_zeros_to_pad; 5159 if (zn > 0) 5160 { 5161 if (str_l < str_m) 5162 { 5163 size_t avail = str_m - str_l; 5164 5165 vim_memset(str + str_l, '0', 5166 (size_t)zn > avail ? avail 5167 : (size_t)zn); 5168 } 5169 str_l += zn; 5170 } 5171 } 5172 5173 /* insert formatted string 5174 * (or as-is conversion specifier for unknown conversions) */ 5175 { 5176 int sn = (int)(str_arg_l - zero_padding_insertion_ind); 5177 5178 if (sn > 0) 5179 { 5180 if (str_l < str_m) 5181 { 5182 size_t avail = str_m - str_l; 5183 5184 mch_memmove(str + str_l, 5185 str_arg + zero_padding_insertion_ind, 5186 (size_t)sn > avail ? avail : (size_t)sn); 5187 } 5188 str_l += sn; 5189 } 5190 } 5191 5192 /* insert right padding */ 5193 if (justify_left) 5194 { 5195 /* right blank padding to the field width */ 5196 int pn = (int)(min_field_width 5197 - (str_arg_l + number_of_zeros_to_pad)); 5198 5199 if (pn > 0) 5200 { 5201 if (str_l < str_m) 5202 { 5203 size_t avail = str_m - str_l; 5204 5205 vim_memset(str + str_l, ' ', 5206 (size_t)pn > avail ? avail 5207 : (size_t)pn); 5208 } 5209 str_l += pn; 5210 } 5211 } 5212 vim_free(tofree); 5213 } 5214 } 5215 5216 if (str_m > 0) 5217 { 5218 /* make sure the string is nul-terminated even at the expense of 5219 * overwriting the last character (shouldn't happen, but just in case) 5220 * */ 5221 str[str_l <= str_m - 1 ? str_l : str_m - 1] = '\0'; 5222 } 5223 5224 if (tvs != NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN) 5225 emsg(_("E767: Too many arguments to printf()")); 5226 5227 /* Return the number of characters formatted (excluding trailing nul 5228 * character), that is, the number of characters that would have been 5229 * written to the buffer if it were large enough. */ 5230 return (int)str_l; 5231 } 5232 5233 #endif /* PROTO */ 5234