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