1 /* vi:set ts=8 sts=4 sw=4 noet: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 10 /* 11 * misc2.c: Various functions. 12 */ 13 #include "vim.h" 14 15 static char_u *username = NULL; /* cached result of mch_get_user_name() */ 16 17 static char_u *ff_expand_buffer = NULL; /* used for expanding filenames */ 18 19 #if defined(FEAT_VIRTUALEDIT) || defined(PROTO) 20 static int coladvance2(pos_T *pos, int addspaces, int finetune, colnr_T wcol); 21 22 /* 23 * Return TRUE if in the current mode we need to use virtual. 24 */ 25 int 26 virtual_active(void) 27 { 28 /* While an operator is being executed we return "virtual_op", because 29 * VIsual_active has already been reset, thus we can't check for "block" 30 * being used. */ 31 if (virtual_op != MAYBE) 32 return virtual_op; 33 return (ve_flags == VE_ALL 34 || ((ve_flags & VE_BLOCK) && VIsual_active && VIsual_mode == Ctrl_V) 35 || ((ve_flags & VE_INSERT) && (State & INSERT))); 36 } 37 38 /* 39 * Get the screen position of the cursor. 40 */ 41 int 42 getviscol(void) 43 { 44 colnr_T x; 45 46 getvvcol(curwin, &curwin->w_cursor, &x, NULL, NULL); 47 return (int)x; 48 } 49 50 /* 51 * Get the screen position of character col with a coladd in the cursor line. 52 */ 53 int 54 getviscol2(colnr_T col, colnr_T coladd) 55 { 56 colnr_T x; 57 pos_T pos; 58 59 pos.lnum = curwin->w_cursor.lnum; 60 pos.col = col; 61 pos.coladd = coladd; 62 getvvcol(curwin, &pos, &x, NULL, NULL); 63 return (int)x; 64 } 65 66 /* 67 * Go to column "wcol", and add/insert white space as necessary to get the 68 * cursor in that column. 69 * The caller must have saved the cursor line for undo! 70 */ 71 int 72 coladvance_force(colnr_T wcol) 73 { 74 int rc = coladvance2(&curwin->w_cursor, TRUE, FALSE, wcol); 75 76 if (wcol == MAXCOL) 77 curwin->w_valid &= ~VALID_VIRTCOL; 78 else 79 { 80 /* Virtcol is valid */ 81 curwin->w_valid |= VALID_VIRTCOL; 82 curwin->w_virtcol = wcol; 83 } 84 return rc; 85 } 86 #endif 87 88 /* 89 * Try to advance the Cursor to the specified screen column. 90 * If virtual editing: fine tune the cursor position. 91 * Note that all virtual positions off the end of a line should share 92 * a curwin->w_cursor.col value (n.b. this is equal to STRLEN(line)), 93 * beginning at coladd 0. 94 * 95 * return OK if desired column is reached, FAIL if not 96 */ 97 int 98 coladvance(colnr_T wcol) 99 { 100 int rc = getvpos(&curwin->w_cursor, wcol); 101 102 if (wcol == MAXCOL || rc == FAIL) 103 curwin->w_valid &= ~VALID_VIRTCOL; 104 else if (*ml_get_cursor() != TAB) 105 { 106 /* Virtcol is valid when not on a TAB */ 107 curwin->w_valid |= VALID_VIRTCOL; 108 curwin->w_virtcol = wcol; 109 } 110 return rc; 111 } 112 113 /* 114 * Return in "pos" the position of the cursor advanced to screen column "wcol". 115 * return OK if desired column is reached, FAIL if not 116 */ 117 int 118 getvpos(pos_T *pos, colnr_T wcol) 119 { 120 #ifdef FEAT_VIRTUALEDIT 121 return coladvance2(pos, FALSE, virtual_active(), wcol); 122 } 123 124 static int 125 coladvance2( 126 pos_T *pos, 127 int addspaces, /* change the text to achieve our goal? */ 128 int finetune, /* change char offset for the exact column */ 129 colnr_T wcol) /* column to move to */ 130 { 131 #endif 132 int idx; 133 char_u *ptr; 134 char_u *line; 135 colnr_T col = 0; 136 int csize = 0; 137 int one_more; 138 #ifdef FEAT_LINEBREAK 139 int head = 0; 140 #endif 141 142 one_more = (State & INSERT) 143 || restart_edit != NUL 144 || (VIsual_active && *p_sel != 'o') 145 #ifdef FEAT_VIRTUALEDIT 146 || ((ve_flags & VE_ONEMORE) && wcol < MAXCOL) 147 #endif 148 ; 149 line = ml_get_buf(curbuf, pos->lnum, FALSE); 150 151 if (wcol >= MAXCOL) 152 { 153 idx = (int)STRLEN(line) - 1 + one_more; 154 col = wcol; 155 156 #ifdef FEAT_VIRTUALEDIT 157 if ((addspaces || finetune) && !VIsual_active) 158 { 159 curwin->w_curswant = linetabsize(line) + one_more; 160 if (curwin->w_curswant > 0) 161 --curwin->w_curswant; 162 } 163 #endif 164 } 165 else 166 { 167 #ifdef FEAT_VIRTUALEDIT 168 int width = curwin->w_width - win_col_off(curwin); 169 170 if (finetune 171 && curwin->w_p_wrap 172 && curwin->w_width != 0 173 && wcol >= (colnr_T)width) 174 { 175 csize = linetabsize(line); 176 if (csize > 0) 177 csize--; 178 179 if (wcol / width > (colnr_T)csize / width 180 && ((State & INSERT) == 0 || (int)wcol > csize + 1)) 181 { 182 /* In case of line wrapping don't move the cursor beyond the 183 * right screen edge. In Insert mode allow going just beyond 184 * the last character (like what happens when typing and 185 * reaching the right window edge). */ 186 wcol = (csize / width + 1) * width - 1; 187 } 188 } 189 #endif 190 191 ptr = line; 192 while (col <= wcol && *ptr != NUL) 193 { 194 /* Count a tab for what it's worth (if list mode not on) */ 195 #ifdef FEAT_LINEBREAK 196 csize = win_lbr_chartabsize(curwin, line, ptr, col, &head); 197 MB_PTR_ADV(ptr); 198 #else 199 csize = lbr_chartabsize_adv(line, &ptr, col); 200 #endif 201 col += csize; 202 } 203 idx = (int)(ptr - line); 204 /* 205 * Handle all the special cases. The virtual_active() check 206 * is needed to ensure that a virtual position off the end of 207 * a line has the correct indexing. The one_more comparison 208 * replaces an explicit add of one_more later on. 209 */ 210 if (col > wcol || (!virtual_active() && one_more == 0)) 211 { 212 idx -= 1; 213 # ifdef FEAT_LINEBREAK 214 /* Don't count the chars from 'showbreak'. */ 215 csize -= head; 216 # endif 217 col -= csize; 218 } 219 220 #ifdef FEAT_VIRTUALEDIT 221 if (virtual_active() 222 && addspaces 223 && ((col != wcol && col != wcol + 1) || csize > 1)) 224 { 225 /* 'virtualedit' is set: The difference between wcol and col is 226 * filled with spaces. */ 227 228 if (line[idx] == NUL) 229 { 230 /* Append spaces */ 231 int correct = wcol - col; 232 char_u *newline = alloc(idx + correct + 1); 233 int t; 234 235 if (newline == NULL) 236 return FAIL; 237 238 for (t = 0; t < idx; ++t) 239 newline[t] = line[t]; 240 241 for (t = 0; t < correct; ++t) 242 newline[t + idx] = ' '; 243 244 newline[idx + correct] = NUL; 245 246 ml_replace(pos->lnum, newline, FALSE); 247 changed_bytes(pos->lnum, (colnr_T)idx); 248 idx += correct; 249 col = wcol; 250 } 251 else 252 { 253 /* Break a tab */ 254 int linelen = (int)STRLEN(line); 255 int correct = wcol - col - csize + 1; /* negative!! */ 256 char_u *newline; 257 int t, s = 0; 258 int v; 259 260 if (-correct > csize) 261 return FAIL; 262 263 newline = alloc(linelen + csize); 264 if (newline == NULL) 265 return FAIL; 266 267 for (t = 0; t < linelen; t++) 268 { 269 if (t != idx) 270 newline[s++] = line[t]; 271 else 272 for (v = 0; v < csize; v++) 273 newline[s++] = ' '; 274 } 275 276 newline[linelen + csize - 1] = NUL; 277 278 ml_replace(pos->lnum, newline, FALSE); 279 changed_bytes(pos->lnum, idx); 280 idx += (csize - 1 + correct); 281 col += correct; 282 } 283 } 284 #endif 285 } 286 287 if (idx < 0) 288 pos->col = 0; 289 else 290 pos->col = idx; 291 292 #ifdef FEAT_VIRTUALEDIT 293 pos->coladd = 0; 294 295 if (finetune) 296 { 297 if (wcol == MAXCOL) 298 { 299 /* The width of the last character is used to set coladd. */ 300 if (!one_more) 301 { 302 colnr_T scol, ecol; 303 304 getvcol(curwin, pos, &scol, NULL, &ecol); 305 pos->coladd = ecol - scol; 306 } 307 } 308 else 309 { 310 int b = (int)wcol - (int)col; 311 312 /* The difference between wcol and col is used to set coladd. */ 313 if (b > 0 && b < (MAXCOL - 2 * curwin->w_width)) 314 pos->coladd = b; 315 316 col += b; 317 } 318 } 319 #endif 320 321 #ifdef FEAT_MBYTE 322 /* prevent from moving onto a trail byte */ 323 if (has_mbyte) 324 mb_adjustpos(curbuf, pos); 325 #endif 326 327 if (col < wcol) 328 return FAIL; 329 return OK; 330 } 331 332 /* 333 * Increment the cursor position. See inc() for return values. 334 */ 335 int 336 inc_cursor(void) 337 { 338 return inc(&curwin->w_cursor); 339 } 340 341 /* 342 * Increment the line pointer "lp" crossing line boundaries as necessary. 343 * Return 1 when going to the next line. 344 * Return 2 when moving forward onto a NUL at the end of the line). 345 * Return -1 when at the end of file. 346 * Return 0 otherwise. 347 */ 348 int 349 inc(pos_T *lp) 350 { 351 char_u *p = ml_get_pos(lp); 352 353 if (*p != NUL) /* still within line, move to next char (may be NUL) */ 354 { 355 #ifdef FEAT_MBYTE 356 if (has_mbyte) 357 { 358 int l = (*mb_ptr2len)(p); 359 360 lp->col += l; 361 return ((p[l] != NUL) ? 0 : 2); 362 } 363 #endif 364 lp->col++; 365 #ifdef FEAT_VIRTUALEDIT 366 lp->coladd = 0; 367 #endif 368 return ((p[1] != NUL) ? 0 : 2); 369 } 370 if (lp->lnum != curbuf->b_ml.ml_line_count) /* there is a next line */ 371 { 372 lp->col = 0; 373 lp->lnum++; 374 #ifdef FEAT_VIRTUALEDIT 375 lp->coladd = 0; 376 #endif 377 return 1; 378 } 379 return -1; 380 } 381 382 /* 383 * incl(lp): same as inc(), but skip the NUL at the end of non-empty lines 384 */ 385 int 386 incl(pos_T *lp) 387 { 388 int r; 389 390 if ((r = inc(lp)) >= 1 && lp->col) 391 r = inc(lp); 392 return r; 393 } 394 395 /* 396 * dec(p) 397 * 398 * Decrement the line pointer 'p' crossing line boundaries as necessary. 399 * Return 1 when crossing a line, -1 when at start of file, 0 otherwise. 400 */ 401 int 402 dec_cursor(void) 403 { 404 return dec(&curwin->w_cursor); 405 } 406 407 int 408 dec(pos_T *lp) 409 { 410 char_u *p; 411 412 #ifdef FEAT_VIRTUALEDIT 413 lp->coladd = 0; 414 #endif 415 if (lp->col > 0) /* still within line */ 416 { 417 lp->col--; 418 #ifdef FEAT_MBYTE 419 if (has_mbyte) 420 { 421 p = ml_get(lp->lnum); 422 lp->col -= (*mb_head_off)(p, p + lp->col); 423 } 424 #endif 425 return 0; 426 } 427 if (lp->lnum > 1) /* there is a prior line */ 428 { 429 lp->lnum--; 430 p = ml_get(lp->lnum); 431 lp->col = (colnr_T)STRLEN(p); 432 #ifdef FEAT_MBYTE 433 if (has_mbyte) 434 lp->col -= (*mb_head_off)(p, p + lp->col); 435 #endif 436 return 1; 437 } 438 return -1; /* at start of file */ 439 } 440 441 /* 442 * decl(lp): same as dec(), but skip the NUL at the end of non-empty lines 443 */ 444 int 445 decl(pos_T *lp) 446 { 447 int r; 448 449 if ((r = dec(lp)) == 1 && lp->col) 450 r = dec(lp); 451 return r; 452 } 453 454 /* 455 * Get the line number relative to the current cursor position, i.e. the 456 * difference between line number and cursor position. Only look for lines that 457 * can be visible, folded lines don't count. 458 */ 459 linenr_T 460 get_cursor_rel_lnum( 461 win_T *wp, 462 linenr_T lnum) /* line number to get the result for */ 463 { 464 linenr_T cursor = wp->w_cursor.lnum; 465 linenr_T retval = 0; 466 467 #ifdef FEAT_FOLDING 468 if (hasAnyFolding(wp)) 469 { 470 if (lnum > cursor) 471 { 472 while (lnum > cursor) 473 { 474 (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL); 475 /* if lnum and cursor are in the same fold, 476 * now lnum <= cursor */ 477 if (lnum > cursor) 478 retval++; 479 lnum--; 480 } 481 } 482 else if (lnum < cursor) 483 { 484 while (lnum < cursor) 485 { 486 (void)hasFoldingWin(wp, lnum, NULL, &lnum, TRUE, NULL); 487 /* if lnum and cursor are in the same fold, 488 * now lnum >= cursor */ 489 if (lnum < cursor) 490 retval--; 491 lnum++; 492 } 493 } 494 /* else if (lnum == cursor) 495 * retval = 0; 496 */ 497 } 498 else 499 #endif 500 retval = lnum - cursor; 501 502 return retval; 503 } 504 505 /* 506 * Make sure "pos.lnum" and "pos.col" are valid in "buf". 507 * This allows for the col to be on the NUL byte. 508 */ 509 void 510 check_pos(buf_T *buf, pos_T *pos) 511 { 512 char_u *line; 513 colnr_T len; 514 515 if (pos->lnum > buf->b_ml.ml_line_count) 516 pos->lnum = buf->b_ml.ml_line_count; 517 518 if (pos->col > 0) 519 { 520 line = ml_get_buf(buf, pos->lnum, FALSE); 521 len = (colnr_T)STRLEN(line); 522 if (pos->col > len) 523 pos->col = len; 524 } 525 } 526 527 /* 528 * Make sure curwin->w_cursor.lnum is valid. 529 */ 530 void 531 check_cursor_lnum(void) 532 { 533 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) 534 { 535 #ifdef FEAT_FOLDING 536 /* If there is a closed fold at the end of the file, put the cursor in 537 * its first line. Otherwise in the last line. */ 538 if (!hasFolding(curbuf->b_ml.ml_line_count, 539 &curwin->w_cursor.lnum, NULL)) 540 #endif 541 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 542 } 543 if (curwin->w_cursor.lnum <= 0) 544 curwin->w_cursor.lnum = 1; 545 } 546 547 /* 548 * Make sure curwin->w_cursor.col is valid. 549 */ 550 void 551 check_cursor_col(void) 552 { 553 check_cursor_col_win(curwin); 554 } 555 556 /* 557 * Make sure win->w_cursor.col is valid. 558 */ 559 void 560 check_cursor_col_win(win_T *win) 561 { 562 colnr_T len; 563 #ifdef FEAT_VIRTUALEDIT 564 colnr_T oldcol = win->w_cursor.col; 565 colnr_T oldcoladd = win->w_cursor.col + win->w_cursor.coladd; 566 #endif 567 568 len = (colnr_T)STRLEN(ml_get_buf(win->w_buffer, win->w_cursor.lnum, FALSE)); 569 if (len == 0) 570 win->w_cursor.col = 0; 571 else if (win->w_cursor.col >= len) 572 { 573 /* Allow cursor past end-of-line when: 574 * - in Insert mode or restarting Insert mode 575 * - in Visual mode and 'selection' isn't "old" 576 * - 'virtualedit' is set */ 577 if ((State & INSERT) || restart_edit 578 || (VIsual_active && *p_sel != 'o') 579 #ifdef FEAT_VIRTUALEDIT 580 || (ve_flags & VE_ONEMORE) 581 #endif 582 || virtual_active()) 583 win->w_cursor.col = len; 584 else 585 { 586 win->w_cursor.col = len - 1; 587 #ifdef FEAT_MBYTE 588 /* Move the cursor to the head byte. */ 589 if (has_mbyte) 590 mb_adjustpos(win->w_buffer, &win->w_cursor); 591 #endif 592 } 593 } 594 else if (win->w_cursor.col < 0) 595 win->w_cursor.col = 0; 596 597 #ifdef FEAT_VIRTUALEDIT 598 /* If virtual editing is on, we can leave the cursor on the old position, 599 * only we must set it to virtual. But don't do it when at the end of the 600 * line. */ 601 if (oldcol == MAXCOL) 602 win->w_cursor.coladd = 0; 603 else if (ve_flags == VE_ALL) 604 { 605 if (oldcoladd > win->w_cursor.col) 606 { 607 win->w_cursor.coladd = oldcoladd - win->w_cursor.col; 608 609 /* Make sure that coladd is not more than the char width. 610 * Not for the last character, coladd is then used when the cursor 611 * is actually after the last character. */ 612 if (win->w_cursor.col + 1 < len && win->w_cursor.coladd > 0) 613 { 614 int cs, ce; 615 616 getvcol(win, &win->w_cursor, &cs, NULL, &ce); 617 if (win->w_cursor.coladd > ce - cs) 618 win->w_cursor.coladd = ce - cs; 619 } 620 } 621 else 622 /* avoid weird number when there is a miscalculation or overflow */ 623 win->w_cursor.coladd = 0; 624 } 625 #endif 626 } 627 628 /* 629 * make sure curwin->w_cursor in on a valid character 630 */ 631 void 632 check_cursor(void) 633 { 634 check_cursor_lnum(); 635 check_cursor_col(); 636 } 637 638 #if defined(FEAT_TEXTOBJ) || defined(PROTO) 639 /* 640 * Make sure curwin->w_cursor is not on the NUL at the end of the line. 641 * Allow it when in Visual mode and 'selection' is not "old". 642 */ 643 void 644 adjust_cursor_col(void) 645 { 646 if (curwin->w_cursor.col > 0 647 && (!VIsual_active || *p_sel == 'o') 648 && gchar_cursor() == NUL) 649 --curwin->w_cursor.col; 650 } 651 #endif 652 653 /* 654 * When curwin->w_leftcol has changed, adjust the cursor position. 655 * Return TRUE if the cursor was moved. 656 */ 657 int 658 leftcol_changed(void) 659 { 660 long lastcol; 661 colnr_T s, e; 662 int retval = FALSE; 663 664 changed_cline_bef_curs(); 665 lastcol = curwin->w_leftcol + curwin->w_width - curwin_col_off() - 1; 666 validate_virtcol(); 667 668 /* 669 * If the cursor is right or left of the screen, move it to last or first 670 * character. 671 */ 672 if (curwin->w_virtcol > (colnr_T)(lastcol - p_siso)) 673 { 674 retval = TRUE; 675 coladvance((colnr_T)(lastcol - p_siso)); 676 } 677 else if (curwin->w_virtcol < curwin->w_leftcol + p_siso) 678 { 679 retval = TRUE; 680 (void)coladvance((colnr_T)(curwin->w_leftcol + p_siso)); 681 } 682 683 /* 684 * If the start of the character under the cursor is not on the screen, 685 * advance the cursor one more char. If this fails (last char of the 686 * line) adjust the scrolling. 687 */ 688 getvvcol(curwin, &curwin->w_cursor, &s, NULL, &e); 689 if (e > (colnr_T)lastcol) 690 { 691 retval = TRUE; 692 coladvance(s - 1); 693 } 694 else if (s < curwin->w_leftcol) 695 { 696 retval = TRUE; 697 if (coladvance(e + 1) == FAIL) /* there isn't another character */ 698 { 699 curwin->w_leftcol = s; /* adjust w_leftcol instead */ 700 changed_cline_bef_curs(); 701 } 702 } 703 704 if (retval) 705 curwin->w_set_curswant = TRUE; 706 redraw_later(NOT_VALID); 707 return retval; 708 } 709 710 /********************************************************************** 711 * Various routines dealing with allocation and deallocation of memory. 712 */ 713 714 #if defined(MEM_PROFILE) || defined(PROTO) 715 716 # define MEM_SIZES 8200 717 static long_u mem_allocs[MEM_SIZES]; 718 static long_u mem_frees[MEM_SIZES]; 719 static long_u mem_allocated; 720 static long_u mem_freed; 721 static long_u mem_peak; 722 static long_u num_alloc; 723 static long_u num_freed; 724 725 static void mem_pre_alloc_s(size_t *sizep); 726 static void mem_pre_alloc_l(long_u *sizep); 727 static void mem_post_alloc(void **pp, size_t size); 728 static void mem_pre_free(void **pp); 729 730 static void 731 mem_pre_alloc_s(size_t *sizep) 732 { 733 *sizep += sizeof(size_t); 734 } 735 736 static void 737 mem_pre_alloc_l(long_u *sizep) 738 { 739 *sizep += sizeof(size_t); 740 } 741 742 static void 743 mem_post_alloc( 744 void **pp, 745 size_t size) 746 { 747 if (*pp == NULL) 748 return; 749 size -= sizeof(size_t); 750 *(long_u *)*pp = size; 751 if (size <= MEM_SIZES-1) 752 mem_allocs[size-1]++; 753 else 754 mem_allocs[MEM_SIZES-1]++; 755 mem_allocated += size; 756 if (mem_allocated - mem_freed > mem_peak) 757 mem_peak = mem_allocated - mem_freed; 758 num_alloc++; 759 *pp = (void *)((char *)*pp + sizeof(size_t)); 760 } 761 762 static void 763 mem_pre_free(void **pp) 764 { 765 long_u size; 766 767 *pp = (void *)((char *)*pp - sizeof(size_t)); 768 size = *(size_t *)*pp; 769 if (size <= MEM_SIZES-1) 770 mem_frees[size-1]++; 771 else 772 mem_frees[MEM_SIZES-1]++; 773 mem_freed += size; 774 num_freed++; 775 } 776 777 /* 778 * called on exit via atexit() 779 */ 780 void 781 vim_mem_profile_dump(void) 782 { 783 int i, j; 784 785 printf("\r\n"); 786 j = 0; 787 for (i = 0; i < MEM_SIZES - 1; i++) 788 { 789 if (mem_allocs[i] || mem_frees[i]) 790 { 791 if (mem_frees[i] > mem_allocs[i]) 792 printf("\r\n%s", _("ERROR: ")); 793 printf("[%4d / %4lu-%-4lu] ", i + 1, mem_allocs[i], mem_frees[i]); 794 j++; 795 if (j > 3) 796 { 797 j = 0; 798 printf("\r\n"); 799 } 800 } 801 } 802 803 i = MEM_SIZES - 1; 804 if (mem_allocs[i]) 805 { 806 printf("\r\n"); 807 if (mem_frees[i] > mem_allocs[i]) 808 puts(_("ERROR: ")); 809 printf("[>%d / %4lu-%-4lu]", i, mem_allocs[i], mem_frees[i]); 810 } 811 812 printf(_("\n[bytes] total alloc-freed %lu-%lu, in use %lu, peak use %lu\n"), 813 mem_allocated, mem_freed, mem_allocated - mem_freed, mem_peak); 814 printf(_("[calls] total re/malloc()'s %lu, total free()'s %lu\n\n"), 815 num_alloc, num_freed); 816 } 817 818 #endif /* MEM_PROFILE */ 819 820 #ifdef FEAT_EVAL 821 static int alloc_does_fail(long_u size); 822 823 static int 824 alloc_does_fail(long_u size) 825 { 826 if (alloc_fail_countdown == 0) 827 { 828 if (--alloc_fail_repeat <= 0) 829 alloc_fail_id = 0; 830 do_outofmem_msg(size); 831 return TRUE; 832 } 833 --alloc_fail_countdown; 834 return FALSE; 835 } 836 #endif 837 838 /* 839 * Some memory is reserved for error messages and for being able to 840 * call mf_release_all(), which needs some memory for mf_trans_add(). 841 */ 842 #define KEEP_ROOM (2 * 8192L) 843 #define KEEP_ROOM_KB (KEEP_ROOM / 1024L) 844 845 /* 846 * Note: if unsigned is 16 bits we can only allocate up to 64K with alloc(). 847 * Use lalloc for larger blocks. 848 */ 849 char_u * 850 alloc(unsigned size) 851 { 852 return (lalloc((long_u)size, TRUE)); 853 } 854 855 /* 856 * alloc() with an ID for alloc_fail(). 857 */ 858 char_u * 859 alloc_id(unsigned size, alloc_id_T id UNUSED) 860 { 861 #ifdef FEAT_EVAL 862 if (alloc_fail_id == id && alloc_does_fail((long_u)size)) 863 return NULL; 864 #endif 865 return (lalloc((long_u)size, TRUE)); 866 } 867 868 /* 869 * Allocate memory and set all bytes to zero. 870 */ 871 char_u * 872 alloc_clear(unsigned size) 873 { 874 char_u *p; 875 876 p = lalloc((long_u)size, TRUE); 877 if (p != NULL) 878 (void)vim_memset(p, 0, (size_t)size); 879 return p; 880 } 881 882 /* 883 * alloc() with check for maximum line length 884 */ 885 char_u * 886 alloc_check(unsigned size) 887 { 888 #if !defined(UNIX) 889 if (sizeof(int) == 2 && size > 0x7fff) 890 { 891 /* Don't hide this message */ 892 emsg_silent = 0; 893 EMSG(_("E340: Line is becoming too long")); 894 return NULL; 895 } 896 #endif 897 return (lalloc((long_u)size, TRUE)); 898 } 899 900 /* 901 * Allocate memory like lalloc() and set all bytes to zero. 902 */ 903 char_u * 904 lalloc_clear(long_u size, int message) 905 { 906 char_u *p; 907 908 p = (lalloc(size, message)); 909 if (p != NULL) 910 (void)vim_memset(p, 0, (size_t)size); 911 return p; 912 } 913 914 /* 915 * Low level memory allocation function. 916 * This is used often, KEEP IT FAST! 917 */ 918 char_u * 919 lalloc(long_u size, int message) 920 { 921 char_u *p; /* pointer to new storage space */ 922 static int releasing = FALSE; /* don't do mf_release_all() recursive */ 923 int try_again; 924 #if defined(HAVE_AVAIL_MEM) 925 static long_u allocated = 0; /* allocated since last avail check */ 926 #endif 927 928 /* Safety check for allocating zero bytes */ 929 if (size == 0) 930 { 931 /* Don't hide this message */ 932 emsg_silent = 0; 933 IEMSGN(_("E341: Internal error: lalloc(%ld, )"), size); 934 return NULL; 935 } 936 937 #ifdef MEM_PROFILE 938 mem_pre_alloc_l(&size); 939 #endif 940 941 /* 942 * Loop when out of memory: Try to release some memfile blocks and 943 * if some blocks are released call malloc again. 944 */ 945 for (;;) 946 { 947 /* 948 * Handle three kind of systems: 949 * 1. No check for available memory: Just return. 950 * 2. Slow check for available memory: call mch_avail_mem() after 951 * allocating KEEP_ROOM amount of memory. 952 * 3. Strict check for available memory: call mch_avail_mem() 953 */ 954 if ((p = (char_u *)malloc((size_t)size)) != NULL) 955 { 956 #ifndef HAVE_AVAIL_MEM 957 /* 1. No check for available memory: Just return. */ 958 goto theend; 959 #else 960 /* 2. Slow check for available memory: call mch_avail_mem() after 961 * allocating (KEEP_ROOM / 2) amount of memory. */ 962 allocated += size; 963 if (allocated < KEEP_ROOM / 2) 964 goto theend; 965 allocated = 0; 966 967 /* 3. check for available memory: call mch_avail_mem() */ 968 if (mch_avail_mem(TRUE) < KEEP_ROOM_KB && !releasing) 969 { 970 free((char *)p); /* System is low... no go! */ 971 p = NULL; 972 } 973 else 974 goto theend; 975 #endif 976 } 977 /* 978 * Remember that mf_release_all() is being called to avoid an endless 979 * loop, because mf_release_all() may call alloc() recursively. 980 */ 981 if (releasing) 982 break; 983 releasing = TRUE; 984 985 clear_sb_text(TRUE); /* free any scrollback text */ 986 try_again = mf_release_all(); /* release as many blocks as possible */ 987 988 releasing = FALSE; 989 if (!try_again) 990 break; 991 } 992 993 if (message && p == NULL) 994 do_outofmem_msg(size); 995 996 theend: 997 #ifdef MEM_PROFILE 998 mem_post_alloc((void **)&p, (size_t)size); 999 #endif 1000 return p; 1001 } 1002 1003 /* 1004 * lalloc() with an ID for alloc_fail(). 1005 */ 1006 char_u * 1007 lalloc_id(long_u size, int message, alloc_id_T id UNUSED) 1008 { 1009 #ifdef FEAT_EVAL 1010 if (alloc_fail_id == id && alloc_does_fail(size)) 1011 return NULL; 1012 #endif 1013 return (lalloc((long_u)size, message)); 1014 } 1015 1016 #if defined(MEM_PROFILE) || defined(PROTO) 1017 /* 1018 * realloc() with memory profiling. 1019 */ 1020 void * 1021 mem_realloc(void *ptr, size_t size) 1022 { 1023 void *p; 1024 1025 mem_pre_free(&ptr); 1026 mem_pre_alloc_s(&size); 1027 1028 p = realloc(ptr, size); 1029 1030 mem_post_alloc(&p, size); 1031 1032 return p; 1033 } 1034 #endif 1035 1036 /* 1037 * Avoid repeating the error message many times (they take 1 second each). 1038 * Did_outofmem_msg is reset when a character is read. 1039 */ 1040 void 1041 do_outofmem_msg(long_u size) 1042 { 1043 if (!did_outofmem_msg) 1044 { 1045 /* Don't hide this message */ 1046 emsg_silent = 0; 1047 1048 /* Must come first to avoid coming back here when printing the error 1049 * message fails, e.g. when setting v:errmsg. */ 1050 did_outofmem_msg = TRUE; 1051 1052 EMSGN(_("E342: Out of memory! (allocating %lu bytes)"), size); 1053 } 1054 } 1055 1056 #if defined(EXITFREE) || defined(PROTO) 1057 1058 # if defined(FEAT_SEARCHPATH) 1059 static void free_findfile(void); 1060 # endif 1061 1062 /* 1063 * Free everything that we allocated. 1064 * Can be used to detect memory leaks, e.g., with ccmalloc. 1065 * NOTE: This is tricky! Things are freed that functions depend on. Don't be 1066 * surprised if Vim crashes... 1067 * Some things can't be freed, esp. things local to a library function. 1068 */ 1069 void 1070 free_all_mem(void) 1071 { 1072 buf_T *buf, *nextbuf; 1073 1074 /* When we cause a crash here it is caught and Vim tries to exit cleanly. 1075 * Don't try freeing everything again. */ 1076 if (entered_free_all_mem) 1077 return; 1078 entered_free_all_mem = TRUE; 1079 1080 # ifdef FEAT_AUTOCMD 1081 /* Don't want to trigger autocommands from here on. */ 1082 block_autocmds(); 1083 # endif 1084 1085 /* Close all tabs and windows. Reset 'equalalways' to avoid redraws. */ 1086 p_ea = FALSE; 1087 if (first_tabpage->tp_next != NULL) 1088 do_cmdline_cmd((char_u *)"tabonly!"); 1089 if (!ONE_WINDOW) 1090 do_cmdline_cmd((char_u *)"only!"); 1091 1092 # if defined(FEAT_SPELL) 1093 /* Free all spell info. */ 1094 spell_free_all(); 1095 # endif 1096 1097 # if defined(FEAT_USR_CMDS) 1098 /* Clear user commands (before deleting buffers). */ 1099 ex_comclear(NULL); 1100 # endif 1101 1102 # ifdef FEAT_MENU 1103 /* Clear menus. */ 1104 do_cmdline_cmd((char_u *)"aunmenu *"); 1105 # ifdef FEAT_MULTI_LANG 1106 do_cmdline_cmd((char_u *)"menutranslate clear"); 1107 # endif 1108 # endif 1109 1110 /* Clear mappings, abbreviations, breakpoints. */ 1111 do_cmdline_cmd((char_u *)"lmapclear"); 1112 do_cmdline_cmd((char_u *)"xmapclear"); 1113 do_cmdline_cmd((char_u *)"mapclear"); 1114 do_cmdline_cmd((char_u *)"mapclear!"); 1115 do_cmdline_cmd((char_u *)"abclear"); 1116 # if defined(FEAT_EVAL) 1117 do_cmdline_cmd((char_u *)"breakdel *"); 1118 # endif 1119 # if defined(FEAT_PROFILE) 1120 do_cmdline_cmd((char_u *)"profdel *"); 1121 # endif 1122 # if defined(FEAT_KEYMAP) 1123 do_cmdline_cmd((char_u *)"set keymap="); 1124 #endif 1125 1126 # ifdef FEAT_TITLE 1127 free_titles(); 1128 # endif 1129 # if defined(FEAT_SEARCHPATH) 1130 free_findfile(); 1131 # endif 1132 1133 /* Obviously named calls. */ 1134 # if defined(FEAT_AUTOCMD) 1135 free_all_autocmds(); 1136 # endif 1137 clear_termcodes(); 1138 free_all_marks(); 1139 alist_clear(&global_alist); 1140 free_homedir(); 1141 # if defined(FEAT_CMDL_COMPL) 1142 free_users(); 1143 # endif 1144 free_search_patterns(); 1145 free_old_sub(); 1146 free_last_insert(); 1147 free_prev_shellcmd(); 1148 free_regexp_stuff(); 1149 free_tag_stuff(); 1150 free_cd_dir(); 1151 # ifdef FEAT_SIGNS 1152 free_signs(); 1153 # endif 1154 # ifdef FEAT_EVAL 1155 set_expr_line(NULL); 1156 # endif 1157 # ifdef FEAT_DIFF 1158 diff_clear(curtab); 1159 # endif 1160 clear_sb_text(TRUE); /* free any scrollback text */ 1161 1162 /* Free some global vars. */ 1163 vim_free(username); 1164 # ifdef FEAT_CLIPBOARD 1165 vim_regfree(clip_exclude_prog); 1166 # endif 1167 vim_free(last_cmdline); 1168 # ifdef FEAT_CMDHIST 1169 vim_free(new_last_cmdline); 1170 # endif 1171 set_keep_msg(NULL, 0); 1172 vim_free(ff_expand_buffer); 1173 1174 /* Clear cmdline history. */ 1175 p_hi = 0; 1176 # ifdef FEAT_CMDHIST 1177 init_history(); 1178 # endif 1179 1180 #ifdef FEAT_QUICKFIX 1181 { 1182 win_T *win; 1183 tabpage_T *tab; 1184 1185 qf_free_all(NULL); 1186 /* Free all location lists */ 1187 FOR_ALL_TAB_WINDOWS(tab, win) 1188 qf_free_all(win); 1189 } 1190 #endif 1191 1192 /* Close all script inputs. */ 1193 close_all_scripts(); 1194 1195 /* Destroy all windows. Must come before freeing buffers. */ 1196 win_free_all(); 1197 1198 /* Free all option values. Must come after closing windows. */ 1199 free_all_options(); 1200 1201 /* Free all buffers. Reset 'autochdir' to avoid accessing things that 1202 * were freed already. */ 1203 #ifdef FEAT_AUTOCHDIR 1204 p_acd = FALSE; 1205 #endif 1206 for (buf = firstbuf; buf != NULL; ) 1207 { 1208 bufref_T bufref; 1209 1210 set_bufref(&bufref, buf); 1211 nextbuf = buf->b_next; 1212 close_buffer(NULL, buf, DOBUF_WIPE, FALSE); 1213 if (bufref_valid(&bufref)) 1214 buf = nextbuf; /* didn't work, try next one */ 1215 else 1216 buf = firstbuf; 1217 } 1218 1219 #ifdef FEAT_ARABIC 1220 free_cmdline_buf(); 1221 #endif 1222 1223 /* Clear registers. */ 1224 clear_registers(); 1225 ResetRedobuff(); 1226 ResetRedobuff(); 1227 1228 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11) 1229 vim_free(serverDelayedStartName); 1230 #endif 1231 1232 /* highlight info */ 1233 free_highlight(); 1234 1235 reset_last_sourcing(); 1236 1237 free_tabpage(first_tabpage); 1238 first_tabpage = NULL; 1239 1240 # ifdef UNIX 1241 /* Machine-specific free. */ 1242 mch_free_mem(); 1243 # endif 1244 1245 /* message history */ 1246 for (;;) 1247 if (delete_first_msg() == FAIL) 1248 break; 1249 1250 # ifdef FEAT_JOB_CHANNEL 1251 channel_free_all(); 1252 # endif 1253 #ifdef FEAT_TIMERS 1254 timer_free_all(); 1255 #endif 1256 # ifdef FEAT_EVAL 1257 /* must be after channel_free_all() with unrefs partials */ 1258 eval_clear(); 1259 # endif 1260 # ifdef FEAT_JOB_CHANNEL 1261 /* must be after eval_clear() with unrefs jobs */ 1262 job_free_all(); 1263 # endif 1264 1265 free_termoptions(); 1266 1267 /* screenlines (can't display anything now!) */ 1268 free_screenlines(); 1269 1270 #if defined(USE_XSMP) 1271 xsmp_close(); 1272 #endif 1273 #ifdef FEAT_GUI_GTK 1274 gui_mch_free_all(); 1275 #endif 1276 clear_hl_tables(); 1277 1278 vim_free(IObuff); 1279 vim_free(NameBuff); 1280 } 1281 #endif 1282 1283 /* 1284 * Copy "string" into newly allocated memory. 1285 */ 1286 char_u * 1287 vim_strsave(char_u *string) 1288 { 1289 char_u *p; 1290 unsigned len; 1291 1292 len = (unsigned)STRLEN(string) + 1; 1293 p = alloc(len); 1294 if (p != NULL) 1295 mch_memmove(p, string, (size_t)len); 1296 return p; 1297 } 1298 1299 /* 1300 * Copy up to "len" bytes of "string" into newly allocated memory and 1301 * terminate with a NUL. 1302 * The allocated memory always has size "len + 1", also when "string" is 1303 * shorter. 1304 */ 1305 char_u * 1306 vim_strnsave(char_u *string, int len) 1307 { 1308 char_u *p; 1309 1310 p = alloc((unsigned)(len + 1)); 1311 if (p != NULL) 1312 { 1313 STRNCPY(p, string, len); 1314 p[len] = NUL; 1315 } 1316 return p; 1317 } 1318 1319 /* 1320 * Same as vim_strsave(), but any characters found in esc_chars are preceded 1321 * by a backslash. 1322 */ 1323 char_u * 1324 vim_strsave_escaped(char_u *string, char_u *esc_chars) 1325 { 1326 return vim_strsave_escaped_ext(string, esc_chars, '\\', FALSE); 1327 } 1328 1329 /* 1330 * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape 1331 * characters where rem_backslash() would remove the backslash. 1332 * Escape the characters with "cc". 1333 */ 1334 char_u * 1335 vim_strsave_escaped_ext( 1336 char_u *string, 1337 char_u *esc_chars, 1338 int cc, 1339 int bsl) 1340 { 1341 char_u *p; 1342 char_u *p2; 1343 char_u *escaped_string; 1344 unsigned length; 1345 #ifdef FEAT_MBYTE 1346 int l; 1347 #endif 1348 1349 /* 1350 * First count the number of backslashes required. 1351 * Then allocate the memory and insert them. 1352 */ 1353 length = 1; /* count the trailing NUL */ 1354 for (p = string; *p; p++) 1355 { 1356 #ifdef FEAT_MBYTE 1357 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) 1358 { 1359 length += l; /* count a multibyte char */ 1360 p += l - 1; 1361 continue; 1362 } 1363 #endif 1364 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p))) 1365 ++length; /* count a backslash */ 1366 ++length; /* count an ordinary char */ 1367 } 1368 escaped_string = alloc(length); 1369 if (escaped_string != NULL) 1370 { 1371 p2 = escaped_string; 1372 for (p = string; *p; p++) 1373 { 1374 #ifdef FEAT_MBYTE 1375 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) 1376 { 1377 mch_memmove(p2, p, (size_t)l); 1378 p2 += l; 1379 p += l - 1; /* skip multibyte char */ 1380 continue; 1381 } 1382 #endif 1383 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p))) 1384 *p2++ = cc; 1385 *p2++ = *p; 1386 } 1387 *p2 = NUL; 1388 } 1389 return escaped_string; 1390 } 1391 1392 /* 1393 * Return TRUE when 'shell' has "csh" in the tail. 1394 */ 1395 int 1396 csh_like_shell(void) 1397 { 1398 return (strstr((char *)gettail(p_sh), "csh") != NULL); 1399 } 1400 1401 /* 1402 * Escape "string" for use as a shell argument with system(). 1403 * This uses single quotes, except when we know we need to use double quotes 1404 * (MS-DOS and MS-Windows without 'shellslash' set). 1405 * Escape a newline, depending on the 'shell' option. 1406 * When "do_special" is TRUE also replace "!", "%", "#" and things starting 1407 * with "<" like "<cfile>". 1408 * When "do_newline" is FALSE do not escape newline unless it is csh shell. 1409 * Returns the result in allocated memory, NULL if we have run out. 1410 */ 1411 char_u * 1412 vim_strsave_shellescape(char_u *string, int do_special, int do_newline) 1413 { 1414 unsigned length; 1415 char_u *p; 1416 char_u *d; 1417 char_u *escaped_string; 1418 int l; 1419 int csh_like; 1420 1421 /* Only csh and similar shells expand '!' within single quotes. For sh and 1422 * the like we must not put a backslash before it, it will be taken 1423 * literally. If do_special is set the '!' will be escaped twice. 1424 * Csh also needs to have "\n" escaped twice when do_special is set. */ 1425 csh_like = csh_like_shell(); 1426 1427 /* First count the number of extra bytes required. */ 1428 length = (unsigned)STRLEN(string) + 3; /* two quotes and a trailing NUL */ 1429 for (p = string; *p != NUL; MB_PTR_ADV(p)) 1430 { 1431 # ifdef WIN32 1432 if (!p_ssl) 1433 { 1434 if (*p == '"') 1435 ++length; /* " -> "" */ 1436 } 1437 else 1438 # endif 1439 if (*p == '\'') 1440 length += 3; /* ' => '\'' */ 1441 if ((*p == '\n' && (csh_like || do_newline)) 1442 || (*p == '!' && (csh_like || do_special))) 1443 { 1444 ++length; /* insert backslash */ 1445 if (csh_like && do_special) 1446 ++length; /* insert backslash */ 1447 } 1448 if (do_special && find_cmdline_var(p, &l) >= 0) 1449 { 1450 ++length; /* insert backslash */ 1451 p += l - 1; 1452 } 1453 } 1454 1455 /* Allocate memory for the result and fill it. */ 1456 escaped_string = alloc(length); 1457 if (escaped_string != NULL) 1458 { 1459 d = escaped_string; 1460 1461 /* add opening quote */ 1462 # ifdef WIN32 1463 if (!p_ssl) 1464 *d++ = '"'; 1465 else 1466 # endif 1467 *d++ = '\''; 1468 1469 for (p = string; *p != NUL; ) 1470 { 1471 # ifdef WIN32 1472 if (!p_ssl) 1473 { 1474 if (*p == '"') 1475 { 1476 *d++ = '"'; 1477 *d++ = '"'; 1478 ++p; 1479 continue; 1480 } 1481 } 1482 else 1483 # endif 1484 if (*p == '\'') 1485 { 1486 *d++ = '\''; 1487 *d++ = '\\'; 1488 *d++ = '\''; 1489 *d++ = '\''; 1490 ++p; 1491 continue; 1492 } 1493 if ((*p == '\n' && (csh_like || do_newline)) 1494 || (*p == '!' && (csh_like || do_special))) 1495 { 1496 *d++ = '\\'; 1497 if (csh_like && do_special) 1498 *d++ = '\\'; 1499 *d++ = *p++; 1500 continue; 1501 } 1502 if (do_special && find_cmdline_var(p, &l) >= 0) 1503 { 1504 *d++ = '\\'; /* insert backslash */ 1505 while (--l >= 0) /* copy the var */ 1506 *d++ = *p++; 1507 continue; 1508 } 1509 1510 MB_COPY_CHAR(p, d); 1511 } 1512 1513 /* add terminating quote and finish with a NUL */ 1514 # ifdef WIN32 1515 if (!p_ssl) 1516 *d++ = '"'; 1517 else 1518 # endif 1519 *d++ = '\''; 1520 *d = NUL; 1521 } 1522 1523 return escaped_string; 1524 } 1525 1526 /* 1527 * Like vim_strsave(), but make all characters uppercase. 1528 * This uses ASCII lower-to-upper case translation, language independent. 1529 */ 1530 char_u * 1531 vim_strsave_up(char_u *string) 1532 { 1533 char_u *p1; 1534 1535 p1 = vim_strsave(string); 1536 vim_strup(p1); 1537 return p1; 1538 } 1539 1540 /* 1541 * Like vim_strnsave(), but make all characters uppercase. 1542 * This uses ASCII lower-to-upper case translation, language independent. 1543 */ 1544 char_u * 1545 vim_strnsave_up(char_u *string, int len) 1546 { 1547 char_u *p1; 1548 1549 p1 = vim_strnsave(string, len); 1550 vim_strup(p1); 1551 return p1; 1552 } 1553 1554 /* 1555 * ASCII lower-to-upper case translation, language independent. 1556 */ 1557 void 1558 vim_strup( 1559 char_u *p) 1560 { 1561 char_u *p2; 1562 int c; 1563 1564 if (p != NULL) 1565 { 1566 p2 = p; 1567 while ((c = *p2) != NUL) 1568 #ifdef EBCDIC 1569 *p2++ = isalpha(c) ? toupper(c) : c; 1570 #else 1571 *p2++ = (c < 'a' || c > 'z') ? c : (c - 0x20); 1572 #endif 1573 } 1574 } 1575 1576 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO) 1577 /* 1578 * Make string "s" all upper-case and return it in allocated memory. 1579 * Handles multi-byte characters as well as possible. 1580 * Returns NULL when out of memory. 1581 */ 1582 char_u * 1583 strup_save(char_u *orig) 1584 { 1585 char_u *p; 1586 char_u *res; 1587 1588 res = p = vim_strsave(orig); 1589 1590 if (res != NULL) 1591 while (*p != NUL) 1592 { 1593 # ifdef FEAT_MBYTE 1594 int l; 1595 1596 if (enc_utf8) 1597 { 1598 int c, uc; 1599 int newl; 1600 char_u *s; 1601 1602 c = utf_ptr2char(p); 1603 uc = utf_toupper(c); 1604 1605 /* Reallocate string when byte count changes. This is rare, 1606 * thus it's OK to do another malloc()/free(). */ 1607 l = utf_ptr2len(p); 1608 newl = utf_char2len(uc); 1609 if (newl != l) 1610 { 1611 s = alloc((unsigned)STRLEN(res) + 1 + newl - l); 1612 if (s == NULL) 1613 { 1614 vim_free(res); 1615 return NULL; 1616 } 1617 mch_memmove(s, res, p - res); 1618 STRCPY(s + (p - res) + newl, p + l); 1619 p = s + (p - res); 1620 vim_free(res); 1621 res = s; 1622 } 1623 1624 utf_char2bytes(uc, p); 1625 p += newl; 1626 } 1627 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) 1628 p += l; /* skip multi-byte character */ 1629 else 1630 # endif 1631 { 1632 *p = TOUPPER_LOC(*p); /* note that toupper() can be a macro */ 1633 p++; 1634 } 1635 } 1636 1637 return res; 1638 } 1639 1640 /* 1641 * Make string "s" all lower-case and return it in allocated memory. 1642 * Handles multi-byte characters as well as possible. 1643 * Returns NULL when out of memory. 1644 */ 1645 char_u * 1646 strlow_save(char_u *orig) 1647 { 1648 char_u *p; 1649 char_u *res; 1650 1651 res = p = vim_strsave(orig); 1652 1653 if (res != NULL) 1654 while (*p != NUL) 1655 { 1656 # ifdef FEAT_MBYTE 1657 int l; 1658 1659 if (enc_utf8) 1660 { 1661 int c, lc; 1662 int newl; 1663 char_u *s; 1664 1665 c = utf_ptr2char(p); 1666 lc = utf_tolower(c); 1667 1668 /* Reallocate string when byte count changes. This is rare, 1669 * thus it's OK to do another malloc()/free(). */ 1670 l = utf_ptr2len(p); 1671 newl = utf_char2len(lc); 1672 if (newl != l) 1673 { 1674 s = alloc((unsigned)STRLEN(res) + 1 + newl - l); 1675 if (s == NULL) 1676 { 1677 vim_free(res); 1678 return NULL; 1679 } 1680 mch_memmove(s, res, p - res); 1681 STRCPY(s + (p - res) + newl, p + l); 1682 p = s + (p - res); 1683 vim_free(res); 1684 res = s; 1685 } 1686 1687 utf_char2bytes(lc, p); 1688 p += newl; 1689 } 1690 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) 1691 p += l; /* skip multi-byte character */ 1692 else 1693 # endif 1694 { 1695 *p = TOLOWER_LOC(*p); /* note that tolower() can be a macro */ 1696 p++; 1697 } 1698 } 1699 1700 return res; 1701 } 1702 #endif 1703 1704 /* 1705 * delete spaces at the end of a string 1706 */ 1707 void 1708 del_trailing_spaces(char_u *ptr) 1709 { 1710 char_u *q; 1711 1712 q = ptr + STRLEN(ptr); 1713 while (--q > ptr && VIM_ISWHITE(q[0]) && q[-1] != '\\' && q[-1] != Ctrl_V) 1714 *q = NUL; 1715 } 1716 1717 /* 1718 * Like strncpy(), but always terminate the result with one NUL. 1719 * "to" must be "len + 1" long! 1720 */ 1721 void 1722 vim_strncpy(char_u *to, char_u *from, size_t len) 1723 { 1724 STRNCPY(to, from, len); 1725 to[len] = NUL; 1726 } 1727 1728 /* 1729 * Like strcat(), but make sure the result fits in "tosize" bytes and is 1730 * always NUL terminated. "from" and "to" may overlap. 1731 */ 1732 void 1733 vim_strcat(char_u *to, char_u *from, size_t tosize) 1734 { 1735 size_t tolen = STRLEN(to); 1736 size_t fromlen = STRLEN(from); 1737 1738 if (tolen + fromlen + 1 > tosize) 1739 { 1740 mch_memmove(to + tolen, from, tosize - tolen - 1); 1741 to[tosize - 1] = NUL; 1742 } 1743 else 1744 mch_memmove(to + tolen, from, fromlen + 1); 1745 } 1746 1747 /* 1748 * Isolate one part of a string option where parts are separated with 1749 * "sep_chars". 1750 * The part is copied into "buf[maxlen]". 1751 * "*option" is advanced to the next part. 1752 * The length is returned. 1753 */ 1754 int 1755 copy_option_part( 1756 char_u **option, 1757 char_u *buf, 1758 int maxlen, 1759 char *sep_chars) 1760 { 1761 int len = 0; 1762 char_u *p = *option; 1763 1764 /* skip '.' at start of option part, for 'suffixes' */ 1765 if (*p == '.') 1766 buf[len++] = *p++; 1767 while (*p != NUL && vim_strchr((char_u *)sep_chars, *p) == NULL) 1768 { 1769 /* 1770 * Skip backslash before a separator character and space. 1771 */ 1772 if (p[0] == '\\' && vim_strchr((char_u *)sep_chars, p[1]) != NULL) 1773 ++p; 1774 if (len < maxlen - 1) 1775 buf[len++] = *p; 1776 ++p; 1777 } 1778 buf[len] = NUL; 1779 1780 if (*p != NUL && *p != ',') /* skip non-standard separator */ 1781 ++p; 1782 p = skip_to_option_part(p); /* p points to next file name */ 1783 1784 *option = p; 1785 return len; 1786 } 1787 1788 /* 1789 * Replacement for free() that ignores NULL pointers. 1790 * Also skip free() when exiting for sure, this helps when we caught a deadly 1791 * signal that was caused by a crash in free(). 1792 */ 1793 void 1794 vim_free(void *x) 1795 { 1796 if (x != NULL && !really_exiting) 1797 { 1798 #ifdef MEM_PROFILE 1799 mem_pre_free(&x); 1800 #endif 1801 free(x); 1802 } 1803 } 1804 1805 #ifndef HAVE_MEMSET 1806 void * 1807 vim_memset(void *ptr, int c, size_t size) 1808 { 1809 char *p = ptr; 1810 1811 while (size-- > 0) 1812 *p++ = c; 1813 return ptr; 1814 } 1815 #endif 1816 1817 #if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO) 1818 /* 1819 * Compare two strings, ignoring case, using current locale. 1820 * Doesn't work for multi-byte characters. 1821 * return 0 for match, < 0 for smaller, > 0 for bigger 1822 */ 1823 int 1824 vim_stricmp(char *s1, char *s2) 1825 { 1826 int i; 1827 1828 for (;;) 1829 { 1830 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2); 1831 if (i != 0) 1832 return i; /* this character different */ 1833 if (*s1 == NUL) 1834 break; /* strings match until NUL */ 1835 ++s1; 1836 ++s2; 1837 } 1838 return 0; /* strings match */ 1839 } 1840 #endif 1841 1842 #if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO) 1843 /* 1844 * Compare two strings, for length "len", ignoring case, using current locale. 1845 * Doesn't work for multi-byte characters. 1846 * return 0 for match, < 0 for smaller, > 0 for bigger 1847 */ 1848 int 1849 vim_strnicmp(char *s1, char *s2, size_t len) 1850 { 1851 int i; 1852 1853 while (len > 0) 1854 { 1855 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2); 1856 if (i != 0) 1857 return i; /* this character different */ 1858 if (*s1 == NUL) 1859 break; /* strings match until NUL */ 1860 ++s1; 1861 ++s2; 1862 --len; 1863 } 1864 return 0; /* strings match */ 1865 } 1866 #endif 1867 1868 /* 1869 * Version of strchr() and strrchr() that handle unsigned char strings 1870 * with characters from 128 to 255 correctly. It also doesn't return a 1871 * pointer to the NUL at the end of the string. 1872 */ 1873 char_u * 1874 vim_strchr(char_u *string, int c) 1875 { 1876 char_u *p; 1877 int b; 1878 1879 p = string; 1880 #ifdef FEAT_MBYTE 1881 if (enc_utf8 && c >= 0x80) 1882 { 1883 while (*p != NUL) 1884 { 1885 int l = utfc_ptr2len(p); 1886 1887 /* Avoid matching an illegal byte here. */ 1888 if (utf_ptr2char(p) == c && l > 1) 1889 return p; 1890 p += l; 1891 } 1892 return NULL; 1893 } 1894 if (enc_dbcs != 0 && c > 255) 1895 { 1896 int n2 = c & 0xff; 1897 1898 c = ((unsigned)c >> 8) & 0xff; 1899 while ((b = *p) != NUL) 1900 { 1901 if (b == c && p[1] == n2) 1902 return p; 1903 p += (*mb_ptr2len)(p); 1904 } 1905 return NULL; 1906 } 1907 if (has_mbyte) 1908 { 1909 while ((b = *p) != NUL) 1910 { 1911 if (b == c) 1912 return p; 1913 p += (*mb_ptr2len)(p); 1914 } 1915 return NULL; 1916 } 1917 #endif 1918 while ((b = *p) != NUL) 1919 { 1920 if (b == c) 1921 return p; 1922 ++p; 1923 } 1924 return NULL; 1925 } 1926 1927 /* 1928 * Version of strchr() that only works for bytes and handles unsigned char 1929 * strings with characters above 128 correctly. It also doesn't return a 1930 * pointer to the NUL at the end of the string. 1931 */ 1932 char_u * 1933 vim_strbyte(char_u *string, int c) 1934 { 1935 char_u *p = string; 1936 1937 while (*p != NUL) 1938 { 1939 if (*p == c) 1940 return p; 1941 ++p; 1942 } 1943 return NULL; 1944 } 1945 1946 /* 1947 * Search for last occurrence of "c" in "string". 1948 * Return NULL if not found. 1949 * Does not handle multi-byte char for "c"! 1950 */ 1951 char_u * 1952 vim_strrchr(char_u *string, int c) 1953 { 1954 char_u *retval = NULL; 1955 char_u *p = string; 1956 1957 while (*p) 1958 { 1959 if (*p == c) 1960 retval = p; 1961 MB_PTR_ADV(p); 1962 } 1963 return retval; 1964 } 1965 1966 /* 1967 * Vim's version of strpbrk(), in case it's missing. 1968 * Don't generate a prototype for this, causes problems when it's not used. 1969 */ 1970 #ifndef PROTO 1971 # ifndef HAVE_STRPBRK 1972 # ifdef vim_strpbrk 1973 # undef vim_strpbrk 1974 # endif 1975 char_u * 1976 vim_strpbrk(char_u *s, char_u *charset) 1977 { 1978 while (*s) 1979 { 1980 if (vim_strchr(charset, *s) != NULL) 1981 return s; 1982 MB_PTR_ADV(s); 1983 } 1984 return NULL; 1985 } 1986 # endif 1987 #endif 1988 1989 /* 1990 * Vim has its own isspace() function, because on some machines isspace() 1991 * can't handle characters above 128. 1992 */ 1993 int 1994 vim_isspace(int x) 1995 { 1996 return ((x >= 9 && x <= 13) || x == ' '); 1997 } 1998 1999 /************************************************************************ 2000 * Functions for handling growing arrays. 2001 */ 2002 2003 /* 2004 * Clear an allocated growing array. 2005 */ 2006 void 2007 ga_clear(garray_T *gap) 2008 { 2009 vim_free(gap->ga_data); 2010 ga_init(gap); 2011 } 2012 2013 /* 2014 * Clear a growing array that contains a list of strings. 2015 */ 2016 void 2017 ga_clear_strings(garray_T *gap) 2018 { 2019 int i; 2020 2021 for (i = 0; i < gap->ga_len; ++i) 2022 vim_free(((char_u **)(gap->ga_data))[i]); 2023 ga_clear(gap); 2024 } 2025 2026 /* 2027 * Initialize a growing array. Don't forget to set ga_itemsize and 2028 * ga_growsize! Or use ga_init2(). 2029 */ 2030 void 2031 ga_init(garray_T *gap) 2032 { 2033 gap->ga_data = NULL; 2034 gap->ga_maxlen = 0; 2035 gap->ga_len = 0; 2036 } 2037 2038 void 2039 ga_init2(garray_T *gap, int itemsize, int growsize) 2040 { 2041 ga_init(gap); 2042 gap->ga_itemsize = itemsize; 2043 gap->ga_growsize = growsize; 2044 } 2045 2046 /* 2047 * Make room in growing array "gap" for at least "n" items. 2048 * Return FAIL for failure, OK otherwise. 2049 */ 2050 int 2051 ga_grow(garray_T *gap, int n) 2052 { 2053 size_t old_len; 2054 size_t new_len; 2055 char_u *pp; 2056 2057 if (gap->ga_maxlen - gap->ga_len < n) 2058 { 2059 if (n < gap->ga_growsize) 2060 n = gap->ga_growsize; 2061 new_len = gap->ga_itemsize * (gap->ga_len + n); 2062 pp = (gap->ga_data == NULL) 2063 ? alloc((unsigned)new_len) : vim_realloc(gap->ga_data, new_len); 2064 if (pp == NULL) 2065 return FAIL; 2066 old_len = gap->ga_itemsize * gap->ga_maxlen; 2067 vim_memset(pp + old_len, 0, new_len - old_len); 2068 gap->ga_maxlen = gap->ga_len + n; 2069 gap->ga_data = pp; 2070 } 2071 return OK; 2072 } 2073 2074 /* 2075 * For a growing array that contains a list of strings: concatenate all the 2076 * strings with a separating "sep". 2077 * Returns NULL when out of memory. 2078 */ 2079 char_u * 2080 ga_concat_strings(garray_T *gap, char *sep) 2081 { 2082 int i; 2083 int len = 0; 2084 int sep_len = (int)STRLEN(sep); 2085 char_u *s; 2086 char_u *p; 2087 2088 for (i = 0; i < gap->ga_len; ++i) 2089 len += (int)STRLEN(((char_u **)(gap->ga_data))[i]) + sep_len; 2090 2091 s = alloc(len + 1); 2092 if (s != NULL) 2093 { 2094 *s = NUL; 2095 p = s; 2096 for (i = 0; i < gap->ga_len; ++i) 2097 { 2098 if (p != s) 2099 { 2100 STRCPY(p, sep); 2101 p += sep_len; 2102 } 2103 STRCPY(p, ((char_u **)(gap->ga_data))[i]); 2104 p += STRLEN(p); 2105 } 2106 } 2107 return s; 2108 } 2109 2110 #if defined(FEAT_VIMINFO) || defined(FEAT_EVAL) || defined(PROTO) 2111 /* 2112 * Make a copy of string "p" and add it to "gap". 2113 * When out of memory nothing changes. 2114 */ 2115 void 2116 ga_add_string(garray_T *gap, char_u *p) 2117 { 2118 char_u *cp = vim_strsave(p); 2119 2120 if (cp != NULL) 2121 { 2122 if (ga_grow(gap, 1) == OK) 2123 ((char_u **)(gap->ga_data))[gap->ga_len++] = cp; 2124 else 2125 vim_free(cp); 2126 } 2127 } 2128 #endif 2129 2130 /* 2131 * Concatenate a string to a growarray which contains characters. 2132 * When "s" is NULL does not do anything. 2133 * Note: Does NOT copy the NUL at the end! 2134 */ 2135 void 2136 ga_concat(garray_T *gap, char_u *s) 2137 { 2138 int len; 2139 2140 if (s == NULL || *s == NUL) 2141 return; 2142 len = (int)STRLEN(s); 2143 if (ga_grow(gap, len) == OK) 2144 { 2145 mch_memmove((char *)gap->ga_data + gap->ga_len, s, (size_t)len); 2146 gap->ga_len += len; 2147 } 2148 } 2149 2150 /* 2151 * Append one byte to a growarray which contains bytes. 2152 */ 2153 void 2154 ga_append(garray_T *gap, int c) 2155 { 2156 if (ga_grow(gap, 1) == OK) 2157 { 2158 *((char *)gap->ga_data + gap->ga_len) = c; 2159 ++gap->ga_len; 2160 } 2161 } 2162 2163 #if (defined(UNIX) && !defined(USE_SYSTEM)) || defined(WIN3264) \ 2164 || defined(PROTO) 2165 /* 2166 * Append the text in "gap" below the cursor line and clear "gap". 2167 */ 2168 void 2169 append_ga_line(garray_T *gap) 2170 { 2171 /* Remove trailing CR. */ 2172 if (gap->ga_len > 0 2173 && !curbuf->b_p_bin 2174 && ((char_u *)gap->ga_data)[gap->ga_len - 1] == CAR) 2175 --gap->ga_len; 2176 ga_append(gap, NUL); 2177 ml_append(curwin->w_cursor.lnum++, gap->ga_data, 0, FALSE); 2178 gap->ga_len = 0; 2179 } 2180 #endif 2181 2182 /************************************************************************ 2183 * functions that use lookup tables for various things, generally to do with 2184 * special key codes. 2185 */ 2186 2187 /* 2188 * Some useful tables. 2189 */ 2190 2191 static struct modmasktable 2192 { 2193 short mod_mask; /* Bit-mask for particular key modifier */ 2194 short mod_flag; /* Bit(s) for particular key modifier */ 2195 char_u name; /* Single letter name of modifier */ 2196 } mod_mask_table[] = 2197 { 2198 {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'M'}, 2199 {MOD_MASK_META, MOD_MASK_META, (char_u)'T'}, 2200 {MOD_MASK_CTRL, MOD_MASK_CTRL, (char_u)'C'}, 2201 {MOD_MASK_SHIFT, MOD_MASK_SHIFT, (char_u)'S'}, 2202 {MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, (char_u)'2'}, 2203 {MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, (char_u)'3'}, 2204 {MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, (char_u)'4'}, 2205 #ifdef MACOS_X 2206 {MOD_MASK_CMD, MOD_MASK_CMD, (char_u)'D'}, 2207 #endif 2208 /* 'A' must be the last one */ 2209 {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'A'}, 2210 {0, 0, NUL} 2211 /* NOTE: when adding an entry, update MAX_KEY_NAME_LEN! */ 2212 }; 2213 2214 /* 2215 * Shifted key terminal codes and their unshifted equivalent. 2216 * Don't add mouse codes here, they are handled separately! 2217 */ 2218 #define MOD_KEYS_ENTRY_SIZE 5 2219 2220 static char_u modifier_keys_table[] = 2221 { 2222 /* mod mask with modifier without modifier */ 2223 MOD_MASK_SHIFT, '&', '9', '@', '1', /* begin */ 2224 MOD_MASK_SHIFT, '&', '0', '@', '2', /* cancel */ 2225 MOD_MASK_SHIFT, '*', '1', '@', '4', /* command */ 2226 MOD_MASK_SHIFT, '*', '2', '@', '5', /* copy */ 2227 MOD_MASK_SHIFT, '*', '3', '@', '6', /* create */ 2228 MOD_MASK_SHIFT, '*', '4', 'k', 'D', /* delete char */ 2229 MOD_MASK_SHIFT, '*', '5', 'k', 'L', /* delete line */ 2230 MOD_MASK_SHIFT, '*', '7', '@', '7', /* end */ 2231 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', /* end */ 2232 MOD_MASK_SHIFT, '*', '9', '@', '9', /* exit */ 2233 MOD_MASK_SHIFT, '*', '0', '@', '0', /* find */ 2234 MOD_MASK_SHIFT, '#', '1', '%', '1', /* help */ 2235 MOD_MASK_SHIFT, '#', '2', 'k', 'h', /* home */ 2236 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', /* home */ 2237 MOD_MASK_SHIFT, '#', '3', 'k', 'I', /* insert */ 2238 MOD_MASK_SHIFT, '#', '4', 'k', 'l', /* left arrow */ 2239 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', /* left arrow */ 2240 MOD_MASK_SHIFT, '%', 'a', '%', '3', /* message */ 2241 MOD_MASK_SHIFT, '%', 'b', '%', '4', /* move */ 2242 MOD_MASK_SHIFT, '%', 'c', '%', '5', /* next */ 2243 MOD_MASK_SHIFT, '%', 'd', '%', '7', /* options */ 2244 MOD_MASK_SHIFT, '%', 'e', '%', '8', /* previous */ 2245 MOD_MASK_SHIFT, '%', 'f', '%', '9', /* print */ 2246 MOD_MASK_SHIFT, '%', 'g', '%', '0', /* redo */ 2247 MOD_MASK_SHIFT, '%', 'h', '&', '3', /* replace */ 2248 MOD_MASK_SHIFT, '%', 'i', 'k', 'r', /* right arr. */ 2249 MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', /* right arr. */ 2250 MOD_MASK_SHIFT, '%', 'j', '&', '5', /* resume */ 2251 MOD_MASK_SHIFT, '!', '1', '&', '6', /* save */ 2252 MOD_MASK_SHIFT, '!', '2', '&', '7', /* suspend */ 2253 MOD_MASK_SHIFT, '!', '3', '&', '8', /* undo */ 2254 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', /* up arrow */ 2255 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', /* down arrow */ 2256 2257 /* vt100 F1 */ 2258 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1, KS_EXTRA, (int)KE_XF1, 2259 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2, KS_EXTRA, (int)KE_XF2, 2260 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3, KS_EXTRA, (int)KE_XF3, 2261 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4, KS_EXTRA, (int)KE_XF4, 2262 2263 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1, 'k', '1', /* F1 */ 2264 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2, 'k', '2', 2265 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3, 'k', '3', 2266 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4, 'k', '4', 2267 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5, 'k', '5', 2268 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6, 'k', '6', 2269 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7, 'k', '7', 2270 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8, 'k', '8', 2271 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9, 'k', '9', 2272 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10, 'k', ';', /* F10 */ 2273 2274 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11, 'F', '1', 2275 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12, 'F', '2', 2276 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13, 'F', '3', 2277 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14, 'F', '4', 2278 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15, 'F', '5', 2279 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16, 'F', '6', 2280 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17, 'F', '7', 2281 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18, 'F', '8', 2282 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19, 'F', '9', 2283 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20, 'F', 'A', 2284 2285 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21, 'F', 'B', 2286 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22, 'F', 'C', 2287 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23, 'F', 'D', 2288 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24, 'F', 'E', 2289 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25, 'F', 'F', 2290 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26, 'F', 'G', 2291 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27, 'F', 'H', 2292 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28, 'F', 'I', 2293 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29, 'F', 'J', 2294 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30, 'F', 'K', 2295 2296 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31, 'F', 'L', 2297 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32, 'F', 'M', 2298 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33, 'F', 'N', 2299 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34, 'F', 'O', 2300 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35, 'F', 'P', 2301 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36, 'F', 'Q', 2302 MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37, 'F', 'R', 2303 2304 /* TAB pseudo code*/ 2305 MOD_MASK_SHIFT, 'k', 'B', KS_EXTRA, (int)KE_TAB, 2306 2307 NUL 2308 }; 2309 2310 static struct key_name_entry 2311 { 2312 int key; /* Special key code or ascii value */ 2313 char_u *name; /* Name of key */ 2314 } key_names_table[] = 2315 { 2316 {' ', (char_u *)"Space"}, 2317 {TAB, (char_u *)"Tab"}, 2318 {K_TAB, (char_u *)"Tab"}, 2319 {NL, (char_u *)"NL"}, 2320 {NL, (char_u *)"NewLine"}, /* Alternative name */ 2321 {NL, (char_u *)"LineFeed"}, /* Alternative name */ 2322 {NL, (char_u *)"LF"}, /* Alternative name */ 2323 {CAR, (char_u *)"CR"}, 2324 {CAR, (char_u *)"Return"}, /* Alternative name */ 2325 {CAR, (char_u *)"Enter"}, /* Alternative name */ 2326 {K_BS, (char_u *)"BS"}, 2327 {K_BS, (char_u *)"BackSpace"}, /* Alternative name */ 2328 {ESC, (char_u *)"Esc"}, 2329 {CSI, (char_u *)"CSI"}, 2330 {K_CSI, (char_u *)"xCSI"}, 2331 {'|', (char_u *)"Bar"}, 2332 {'\\', (char_u *)"Bslash"}, 2333 {K_DEL, (char_u *)"Del"}, 2334 {K_DEL, (char_u *)"Delete"}, /* Alternative name */ 2335 {K_KDEL, (char_u *)"kDel"}, 2336 {K_UP, (char_u *)"Up"}, 2337 {K_DOWN, (char_u *)"Down"}, 2338 {K_LEFT, (char_u *)"Left"}, 2339 {K_RIGHT, (char_u *)"Right"}, 2340 {K_XUP, (char_u *)"xUp"}, 2341 {K_XDOWN, (char_u *)"xDown"}, 2342 {K_XLEFT, (char_u *)"xLeft"}, 2343 {K_XRIGHT, (char_u *)"xRight"}, 2344 {K_PS, (char_u *)"PasteStart"}, 2345 {K_PE, (char_u *)"PasteEnd"}, 2346 2347 {K_F1, (char_u *)"F1"}, 2348 {K_F2, (char_u *)"F2"}, 2349 {K_F3, (char_u *)"F3"}, 2350 {K_F4, (char_u *)"F4"}, 2351 {K_F5, (char_u *)"F5"}, 2352 {K_F6, (char_u *)"F6"}, 2353 {K_F7, (char_u *)"F7"}, 2354 {K_F8, (char_u *)"F8"}, 2355 {K_F9, (char_u *)"F9"}, 2356 {K_F10, (char_u *)"F10"}, 2357 2358 {K_F11, (char_u *)"F11"}, 2359 {K_F12, (char_u *)"F12"}, 2360 {K_F13, (char_u *)"F13"}, 2361 {K_F14, (char_u *)"F14"}, 2362 {K_F15, (char_u *)"F15"}, 2363 {K_F16, (char_u *)"F16"}, 2364 {K_F17, (char_u *)"F17"}, 2365 {K_F18, (char_u *)"F18"}, 2366 {K_F19, (char_u *)"F19"}, 2367 {K_F20, (char_u *)"F20"}, 2368 2369 {K_F21, (char_u *)"F21"}, 2370 {K_F22, (char_u *)"F22"}, 2371 {K_F23, (char_u *)"F23"}, 2372 {K_F24, (char_u *)"F24"}, 2373 {K_F25, (char_u *)"F25"}, 2374 {K_F26, (char_u *)"F26"}, 2375 {K_F27, (char_u *)"F27"}, 2376 {K_F28, (char_u *)"F28"}, 2377 {K_F29, (char_u *)"F29"}, 2378 {K_F30, (char_u *)"F30"}, 2379 2380 {K_F31, (char_u *)"F31"}, 2381 {K_F32, (char_u *)"F32"}, 2382 {K_F33, (char_u *)"F33"}, 2383 {K_F34, (char_u *)"F34"}, 2384 {K_F35, (char_u *)"F35"}, 2385 {K_F36, (char_u *)"F36"}, 2386 {K_F37, (char_u *)"F37"}, 2387 2388 {K_XF1, (char_u *)"xF1"}, 2389 {K_XF2, (char_u *)"xF2"}, 2390 {K_XF3, (char_u *)"xF3"}, 2391 {K_XF4, (char_u *)"xF4"}, 2392 2393 {K_HELP, (char_u *)"Help"}, 2394 {K_UNDO, (char_u *)"Undo"}, 2395 {K_INS, (char_u *)"Insert"}, 2396 {K_INS, (char_u *)"Ins"}, /* Alternative name */ 2397 {K_KINS, (char_u *)"kInsert"}, 2398 {K_HOME, (char_u *)"Home"}, 2399 {K_KHOME, (char_u *)"kHome"}, 2400 {K_XHOME, (char_u *)"xHome"}, 2401 {K_ZHOME, (char_u *)"zHome"}, 2402 {K_END, (char_u *)"End"}, 2403 {K_KEND, (char_u *)"kEnd"}, 2404 {K_XEND, (char_u *)"xEnd"}, 2405 {K_ZEND, (char_u *)"zEnd"}, 2406 {K_PAGEUP, (char_u *)"PageUp"}, 2407 {K_PAGEDOWN, (char_u *)"PageDown"}, 2408 {K_KPAGEUP, (char_u *)"kPageUp"}, 2409 {K_KPAGEDOWN, (char_u *)"kPageDown"}, 2410 2411 {K_KPLUS, (char_u *)"kPlus"}, 2412 {K_KMINUS, (char_u *)"kMinus"}, 2413 {K_KDIVIDE, (char_u *)"kDivide"}, 2414 {K_KMULTIPLY, (char_u *)"kMultiply"}, 2415 {K_KENTER, (char_u *)"kEnter"}, 2416 {K_KPOINT, (char_u *)"kPoint"}, 2417 2418 {K_K0, (char_u *)"k0"}, 2419 {K_K1, (char_u *)"k1"}, 2420 {K_K2, (char_u *)"k2"}, 2421 {K_K3, (char_u *)"k3"}, 2422 {K_K4, (char_u *)"k4"}, 2423 {K_K5, (char_u *)"k5"}, 2424 {K_K6, (char_u *)"k6"}, 2425 {K_K7, (char_u *)"k7"}, 2426 {K_K8, (char_u *)"k8"}, 2427 {K_K9, (char_u *)"k9"}, 2428 2429 {'<', (char_u *)"lt"}, 2430 2431 {K_MOUSE, (char_u *)"Mouse"}, 2432 #ifdef FEAT_MOUSE_NET 2433 {K_NETTERM_MOUSE, (char_u *)"NetMouse"}, 2434 #endif 2435 #ifdef FEAT_MOUSE_DEC 2436 {K_DEC_MOUSE, (char_u *)"DecMouse"}, 2437 #endif 2438 #ifdef FEAT_MOUSE_JSB 2439 {K_JSBTERM_MOUSE, (char_u *)"JsbMouse"}, 2440 #endif 2441 #ifdef FEAT_MOUSE_PTERM 2442 {K_PTERM_MOUSE, (char_u *)"PtermMouse"}, 2443 #endif 2444 #ifdef FEAT_MOUSE_URXVT 2445 {K_URXVT_MOUSE, (char_u *)"UrxvtMouse"}, 2446 #endif 2447 #ifdef FEAT_MOUSE_SGR 2448 {K_SGR_MOUSE, (char_u *)"SgrMouse"}, 2449 {K_SGR_MOUSERELEASE, (char_u *)"SgrMouseRelelase"}, 2450 #endif 2451 {K_LEFTMOUSE, (char_u *)"LeftMouse"}, 2452 {K_LEFTMOUSE_NM, (char_u *)"LeftMouseNM"}, 2453 {K_LEFTDRAG, (char_u *)"LeftDrag"}, 2454 {K_LEFTRELEASE, (char_u *)"LeftRelease"}, 2455 {K_LEFTRELEASE_NM, (char_u *)"LeftReleaseNM"}, 2456 {K_MIDDLEMOUSE, (char_u *)"MiddleMouse"}, 2457 {K_MIDDLEDRAG, (char_u *)"MiddleDrag"}, 2458 {K_MIDDLERELEASE, (char_u *)"MiddleRelease"}, 2459 {K_RIGHTMOUSE, (char_u *)"RightMouse"}, 2460 {K_RIGHTDRAG, (char_u *)"RightDrag"}, 2461 {K_RIGHTRELEASE, (char_u *)"RightRelease"}, 2462 {K_MOUSEDOWN, (char_u *)"ScrollWheelUp"}, 2463 {K_MOUSEUP, (char_u *)"ScrollWheelDown"}, 2464 {K_MOUSELEFT, (char_u *)"ScrollWheelRight"}, 2465 {K_MOUSERIGHT, (char_u *)"ScrollWheelLeft"}, 2466 {K_MOUSEDOWN, (char_u *)"MouseDown"}, /* OBSOLETE: Use */ 2467 {K_MOUSEUP, (char_u *)"MouseUp"}, /* ScrollWheelXXX instead */ 2468 {K_X1MOUSE, (char_u *)"X1Mouse"}, 2469 {K_X1DRAG, (char_u *)"X1Drag"}, 2470 {K_X1RELEASE, (char_u *)"X1Release"}, 2471 {K_X2MOUSE, (char_u *)"X2Mouse"}, 2472 {K_X2DRAG, (char_u *)"X2Drag"}, 2473 {K_X2RELEASE, (char_u *)"X2Release"}, 2474 {K_DROP, (char_u *)"Drop"}, 2475 {K_ZERO, (char_u *)"Nul"}, 2476 #ifdef FEAT_EVAL 2477 {K_SNR, (char_u *)"SNR"}, 2478 #endif 2479 {K_PLUG, (char_u *)"Plug"}, 2480 {K_CURSORHOLD, (char_u *)"CursorHold"}, 2481 {0, NULL} 2482 /* NOTE: When adding a long name update MAX_KEY_NAME_LEN. */ 2483 }; 2484 2485 #define KEY_NAMES_TABLE_LEN (sizeof(key_names_table) / sizeof(struct key_name_entry)) 2486 2487 #ifdef FEAT_MOUSE 2488 static struct mousetable 2489 { 2490 int pseudo_code; /* Code for pseudo mouse event */ 2491 int button; /* Which mouse button is it? */ 2492 int is_click; /* Is it a mouse button click event? */ 2493 int is_drag; /* Is it a mouse drag event? */ 2494 } mouse_table[] = 2495 { 2496 {(int)KE_LEFTMOUSE, MOUSE_LEFT, TRUE, FALSE}, 2497 #ifdef FEAT_GUI 2498 {(int)KE_LEFTMOUSE_NM, MOUSE_LEFT, TRUE, FALSE}, 2499 #endif 2500 {(int)KE_LEFTDRAG, MOUSE_LEFT, FALSE, TRUE}, 2501 {(int)KE_LEFTRELEASE, MOUSE_LEFT, FALSE, FALSE}, 2502 #ifdef FEAT_GUI 2503 {(int)KE_LEFTRELEASE_NM, MOUSE_LEFT, FALSE, FALSE}, 2504 #endif 2505 {(int)KE_MIDDLEMOUSE, MOUSE_MIDDLE, TRUE, FALSE}, 2506 {(int)KE_MIDDLEDRAG, MOUSE_MIDDLE, FALSE, TRUE}, 2507 {(int)KE_MIDDLERELEASE, MOUSE_MIDDLE, FALSE, FALSE}, 2508 {(int)KE_RIGHTMOUSE, MOUSE_RIGHT, TRUE, FALSE}, 2509 {(int)KE_RIGHTDRAG, MOUSE_RIGHT, FALSE, TRUE}, 2510 {(int)KE_RIGHTRELEASE, MOUSE_RIGHT, FALSE, FALSE}, 2511 {(int)KE_X1MOUSE, MOUSE_X1, TRUE, FALSE}, 2512 {(int)KE_X1DRAG, MOUSE_X1, FALSE, TRUE}, 2513 {(int)KE_X1RELEASE, MOUSE_X1, FALSE, FALSE}, 2514 {(int)KE_X2MOUSE, MOUSE_X2, TRUE, FALSE}, 2515 {(int)KE_X2DRAG, MOUSE_X2, FALSE, TRUE}, 2516 {(int)KE_X2RELEASE, MOUSE_X2, FALSE, FALSE}, 2517 /* DRAG without CLICK */ 2518 {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, TRUE}, 2519 /* RELEASE without CLICK */ 2520 {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, FALSE}, 2521 {0, 0, 0, 0}, 2522 }; 2523 #endif /* FEAT_MOUSE */ 2524 2525 /* 2526 * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given 2527 * modifier name ('S' for Shift, 'C' for Ctrl etc). 2528 */ 2529 int 2530 name_to_mod_mask(int c) 2531 { 2532 int i; 2533 2534 c = TOUPPER_ASC(c); 2535 for (i = 0; mod_mask_table[i].mod_mask != 0; i++) 2536 if (c == mod_mask_table[i].name) 2537 return mod_mask_table[i].mod_flag; 2538 return 0; 2539 } 2540 2541 /* 2542 * Check if if there is a special key code for "key" that includes the 2543 * modifiers specified. 2544 */ 2545 int 2546 simplify_key(int key, int *modifiers) 2547 { 2548 int i; 2549 int key0; 2550 int key1; 2551 2552 if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) 2553 { 2554 /* TAB is a special case */ 2555 if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) 2556 { 2557 *modifiers &= ~MOD_MASK_SHIFT; 2558 return K_S_TAB; 2559 } 2560 key0 = KEY2TERMCAP0(key); 2561 key1 = KEY2TERMCAP1(key); 2562 for (i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) 2563 if (key0 == modifier_keys_table[i + 3] 2564 && key1 == modifier_keys_table[i + 4] 2565 && (*modifiers & modifier_keys_table[i])) 2566 { 2567 *modifiers &= ~modifier_keys_table[i]; 2568 return TERMCAP2KEY(modifier_keys_table[i + 1], 2569 modifier_keys_table[i + 2]); 2570 } 2571 } 2572 return key; 2573 } 2574 2575 /* 2576 * Change <xHome> to <Home>, <xUp> to <Up>, etc. 2577 */ 2578 int 2579 handle_x_keys(int key) 2580 { 2581 switch (key) 2582 { 2583 case K_XUP: return K_UP; 2584 case K_XDOWN: return K_DOWN; 2585 case K_XLEFT: return K_LEFT; 2586 case K_XRIGHT: return K_RIGHT; 2587 case K_XHOME: return K_HOME; 2588 case K_ZHOME: return K_HOME; 2589 case K_XEND: return K_END; 2590 case K_ZEND: return K_END; 2591 case K_XF1: return K_F1; 2592 case K_XF2: return K_F2; 2593 case K_XF3: return K_F3; 2594 case K_XF4: return K_F4; 2595 case K_S_XF1: return K_S_F1; 2596 case K_S_XF2: return K_S_F2; 2597 case K_S_XF3: return K_S_F3; 2598 case K_S_XF4: return K_S_F4; 2599 } 2600 return key; 2601 } 2602 2603 /* 2604 * Return a string which contains the name of the given key when the given 2605 * modifiers are down. 2606 */ 2607 char_u * 2608 get_special_key_name(int c, int modifiers) 2609 { 2610 static char_u string[MAX_KEY_NAME_LEN + 1]; 2611 2612 int i, idx; 2613 int table_idx; 2614 char_u *s; 2615 2616 string[0] = '<'; 2617 idx = 1; 2618 2619 /* Key that stands for a normal character. */ 2620 if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY) 2621 c = KEY2TERMCAP1(c); 2622 2623 /* 2624 * Translate shifted special keys into unshifted keys and set modifier. 2625 * Same for CTRL and ALT modifiers. 2626 */ 2627 if (IS_SPECIAL(c)) 2628 { 2629 for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE) 2630 if ( KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1] 2631 && (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) 2632 { 2633 modifiers |= modifier_keys_table[i]; 2634 c = TERMCAP2KEY(modifier_keys_table[i + 3], 2635 modifier_keys_table[i + 4]); 2636 break; 2637 } 2638 } 2639 2640 /* try to find the key in the special key table */ 2641 table_idx = find_special_key_in_table(c); 2642 2643 /* 2644 * When not a known special key, and not a printable character, try to 2645 * extract modifiers. 2646 */ 2647 if (c > 0 2648 #ifdef FEAT_MBYTE 2649 && (*mb_char2len)(c) == 1 2650 #endif 2651 ) 2652 { 2653 if (table_idx < 0 2654 && (!vim_isprintc(c) || (c & 0x7f) == ' ') 2655 && (c & 0x80)) 2656 { 2657 c &= 0x7f; 2658 modifiers |= MOD_MASK_ALT; 2659 /* try again, to find the un-alted key in the special key table */ 2660 table_idx = find_special_key_in_table(c); 2661 } 2662 if (table_idx < 0 && !vim_isprintc(c) && c < ' ') 2663 { 2664 #ifdef EBCDIC 2665 c = CtrlChar(c); 2666 #else 2667 c += '@'; 2668 #endif 2669 modifiers |= MOD_MASK_CTRL; 2670 } 2671 } 2672 2673 /* translate the modifier into a string */ 2674 for (i = 0; mod_mask_table[i].name != 'A'; i++) 2675 if ((modifiers & mod_mask_table[i].mod_mask) 2676 == mod_mask_table[i].mod_flag) 2677 { 2678 string[idx++] = mod_mask_table[i].name; 2679 string[idx++] = (char_u)'-'; 2680 } 2681 2682 if (table_idx < 0) /* unknown special key, may output t_xx */ 2683 { 2684 if (IS_SPECIAL(c)) 2685 { 2686 string[idx++] = 't'; 2687 string[idx++] = '_'; 2688 string[idx++] = KEY2TERMCAP0(c); 2689 string[idx++] = KEY2TERMCAP1(c); 2690 } 2691 /* Not a special key, only modifiers, output directly */ 2692 else 2693 { 2694 #ifdef FEAT_MBYTE 2695 if (has_mbyte && (*mb_char2len)(c) > 1) 2696 idx += (*mb_char2bytes)(c, string + idx); 2697 else 2698 #endif 2699 if (vim_isprintc(c)) 2700 string[idx++] = c; 2701 else 2702 { 2703 s = transchar(c); 2704 while (*s) 2705 string[idx++] = *s++; 2706 } 2707 } 2708 } 2709 else /* use name of special key */ 2710 { 2711 size_t len = STRLEN(key_names_table[table_idx].name); 2712 2713 if (len + idx + 2 <= MAX_KEY_NAME_LEN) 2714 { 2715 STRCPY(string + idx, key_names_table[table_idx].name); 2716 idx += (int)len; 2717 } 2718 } 2719 string[idx++] = '>'; 2720 string[idx] = NUL; 2721 return string; 2722 } 2723 2724 /* 2725 * Try translating a <> name at (*srcp)[] to dst[]. 2726 * Return the number of characters added to dst[], zero for no match. 2727 * If there is a match, srcp is advanced to after the <> name. 2728 * dst[] must be big enough to hold the result (up to six characters)! 2729 */ 2730 int 2731 trans_special( 2732 char_u **srcp, 2733 char_u *dst, 2734 int keycode, /* prefer key code, e.g. K_DEL instead of DEL */ 2735 int in_string) /* TRUE when inside a double quoted string */ 2736 { 2737 int modifiers = 0; 2738 int key; 2739 int dlen = 0; 2740 2741 key = find_special_key(srcp, &modifiers, keycode, FALSE, in_string); 2742 if (key == 0) 2743 return 0; 2744 2745 /* Put the appropriate modifier in a string */ 2746 if (modifiers != 0) 2747 { 2748 dst[dlen++] = K_SPECIAL; 2749 dst[dlen++] = KS_MODIFIER; 2750 dst[dlen++] = modifiers; 2751 } 2752 2753 if (IS_SPECIAL(key)) 2754 { 2755 dst[dlen++] = K_SPECIAL; 2756 dst[dlen++] = KEY2TERMCAP0(key); 2757 dst[dlen++] = KEY2TERMCAP1(key); 2758 } 2759 #ifdef FEAT_MBYTE 2760 else if (has_mbyte && !keycode) 2761 dlen += (*mb_char2bytes)(key, dst + dlen); 2762 #endif 2763 else if (keycode) 2764 dlen = (int)(add_char2buf(key, dst + dlen) - dst); 2765 else 2766 dst[dlen++] = key; 2767 2768 return dlen; 2769 } 2770 2771 /* 2772 * Try translating a <> name at (*srcp)[], return the key and modifiers. 2773 * srcp is advanced to after the <> name. 2774 * returns 0 if there is no match. 2775 */ 2776 int 2777 find_special_key( 2778 char_u **srcp, 2779 int *modp, 2780 int keycode, /* prefer key code, e.g. K_DEL instead of DEL */ 2781 int keep_x_key, /* don't translate xHome to Home key */ 2782 int in_string) /* TRUE in string, double quote is escaped */ 2783 { 2784 char_u *last_dash; 2785 char_u *end_of_name; 2786 char_u *src; 2787 char_u *bp; 2788 int modifiers; 2789 int bit; 2790 int key; 2791 uvarnumber_T n; 2792 int l; 2793 2794 src = *srcp; 2795 if (src[0] != '<') 2796 return 0; 2797 2798 /* Find end of modifier list */ 2799 last_dash = src; 2800 for (bp = src + 1; *bp == '-' || vim_isIDc(*bp); bp++) 2801 { 2802 if (*bp == '-') 2803 { 2804 last_dash = bp; 2805 if (bp[1] != NUL) 2806 { 2807 #ifdef FEAT_MBYTE 2808 if (has_mbyte) 2809 l = mb_ptr2len(bp + 1); 2810 else 2811 #endif 2812 l = 1; 2813 /* Anything accepted, like <C-?>. 2814 * <C-"> or <M-"> are not special in strings as " is 2815 * the string delimiter. With a backslash it works: <M-\"> */ 2816 if (!(in_string && bp[1] == '"') && bp[2] == '>') 2817 bp += l; 2818 else if (in_string && bp[1] == '\\' && bp[2] == '"' 2819 && bp[3] == '>') 2820 bp += 2; 2821 } 2822 } 2823 if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3]) 2824 bp += 3; /* skip t_xx, xx may be '-' or '>' */ 2825 else if (STRNICMP(bp, "char-", 5) == 0) 2826 { 2827 vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0); 2828 bp += l + 5; 2829 break; 2830 } 2831 } 2832 2833 if (*bp == '>') /* found matching '>' */ 2834 { 2835 end_of_name = bp + 1; 2836 2837 /* Which modifiers are given? */ 2838 modifiers = 0x0; 2839 for (bp = src + 1; bp < last_dash; bp++) 2840 { 2841 if (*bp != '-') 2842 { 2843 bit = name_to_mod_mask(*bp); 2844 if (bit == 0x0) 2845 break; /* Illegal modifier name */ 2846 modifiers |= bit; 2847 } 2848 } 2849 2850 /* 2851 * Legal modifier name. 2852 */ 2853 if (bp >= last_dash) 2854 { 2855 if (STRNICMP(last_dash + 1, "char-", 5) == 0 2856 && VIM_ISDIGIT(last_dash[6])) 2857 { 2858 /* <Char-123> or <Char-033> or <Char-0x33> */ 2859 vim_str2nr(last_dash + 6, NULL, NULL, STR2NR_ALL, NULL, &n, 0); 2860 key = (int)n; 2861 } 2862 else 2863 { 2864 int off = 1; 2865 2866 /* Modifier with single letter, or special key name. */ 2867 if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') 2868 off = 2; 2869 #ifdef FEAT_MBYTE 2870 if (has_mbyte) 2871 l = mb_ptr2len(last_dash + off); 2872 else 2873 #endif 2874 l = 1; 2875 if (modifiers != 0 && last_dash[l + off] == '>') 2876 key = PTR2CHAR(last_dash + off); 2877 else 2878 { 2879 key = get_special_key_code(last_dash + off); 2880 if (!keep_x_key) 2881 key = handle_x_keys(key); 2882 } 2883 } 2884 2885 /* 2886 * get_special_key_code() may return NUL for invalid 2887 * special key name. 2888 */ 2889 if (key != NUL) 2890 { 2891 /* 2892 * Only use a modifier when there is no special key code that 2893 * includes the modifier. 2894 */ 2895 key = simplify_key(key, &modifiers); 2896 2897 if (!keycode) 2898 { 2899 /* don't want keycode, use single byte code */ 2900 if (key == K_BS) 2901 key = BS; 2902 else if (key == K_DEL || key == K_KDEL) 2903 key = DEL; 2904 } 2905 2906 /* 2907 * Normal Key with modifier: Try to make a single byte code. 2908 */ 2909 if (!IS_SPECIAL(key)) 2910 key = extract_modifiers(key, &modifiers); 2911 2912 *modp = modifiers; 2913 *srcp = end_of_name; 2914 return key; 2915 } 2916 } 2917 } 2918 return 0; 2919 } 2920 2921 /* 2922 * Try to include modifiers in the key. 2923 * Changes "Shift-a" to 'A', "Alt-A" to 0xc0, etc. 2924 */ 2925 int 2926 extract_modifiers(int key, int *modp) 2927 { 2928 int modifiers = *modp; 2929 2930 #ifdef MACOS_X 2931 /* Command-key really special, no fancynest */ 2932 if (!(modifiers & MOD_MASK_CMD)) 2933 #endif 2934 if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) 2935 { 2936 key = TOUPPER_ASC(key); 2937 modifiers &= ~MOD_MASK_SHIFT; 2938 } 2939 if ((modifiers & MOD_MASK_CTRL) 2940 #ifdef EBCDIC 2941 /* * TODO: EBCDIC Better use: 2942 * && (Ctrl_chr(key) || key == '?') 2943 * ??? */ 2944 && strchr("?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_", key) 2945 != NULL 2946 #else 2947 && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key)) 2948 #endif 2949 ) 2950 { 2951 key = Ctrl_chr(key); 2952 modifiers &= ~MOD_MASK_CTRL; 2953 /* <C-@> is <Nul> */ 2954 if (key == 0) 2955 key = K_ZERO; 2956 } 2957 #ifdef MACOS_X 2958 /* Command-key really special, no fancynest */ 2959 if (!(modifiers & MOD_MASK_CMD)) 2960 #endif 2961 if ((modifiers & MOD_MASK_ALT) && key < 0x80 2962 #ifdef FEAT_MBYTE 2963 && !enc_dbcs /* avoid creating a lead byte */ 2964 #endif 2965 ) 2966 { 2967 key |= 0x80; 2968 modifiers &= ~MOD_MASK_ALT; /* remove the META modifier */ 2969 } 2970 2971 *modp = modifiers; 2972 return key; 2973 } 2974 2975 /* 2976 * Try to find key "c" in the special key table. 2977 * Return the index when found, -1 when not found. 2978 */ 2979 int 2980 find_special_key_in_table(int c) 2981 { 2982 int i; 2983 2984 for (i = 0; key_names_table[i].name != NULL; i++) 2985 if (c == key_names_table[i].key) 2986 break; 2987 if (key_names_table[i].name == NULL) 2988 i = -1; 2989 return i; 2990 } 2991 2992 /* 2993 * Find the special key with the given name (the given string does not have to 2994 * end with NUL, the name is assumed to end before the first non-idchar). 2995 * If the name starts with "t_" the next two characters are interpreted as a 2996 * termcap name. 2997 * Return the key code, or 0 if not found. 2998 */ 2999 int 3000 get_special_key_code(char_u *name) 3001 { 3002 char_u *table_name; 3003 char_u string[3]; 3004 int i, j; 3005 3006 /* 3007 * If it's <t_xx> we get the code for xx from the termcap 3008 */ 3009 if (name[0] == 't' && name[1] == '_' && name[2] != NUL && name[3] != NUL) 3010 { 3011 string[0] = name[2]; 3012 string[1] = name[3]; 3013 string[2] = NUL; 3014 if (add_termcap_entry(string, FALSE) == OK) 3015 return TERMCAP2KEY(name[2], name[3]); 3016 } 3017 else 3018 for (i = 0; key_names_table[i].name != NULL; i++) 3019 { 3020 table_name = key_names_table[i].name; 3021 for (j = 0; vim_isIDc(name[j]) && table_name[j] != NUL; j++) 3022 if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) 3023 break; 3024 if (!vim_isIDc(name[j]) && table_name[j] == NUL) 3025 return key_names_table[i].key; 3026 } 3027 return 0; 3028 } 3029 3030 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 3031 char_u * 3032 get_key_name(int i) 3033 { 3034 if (i >= (int)KEY_NAMES_TABLE_LEN) 3035 return NULL; 3036 return key_names_table[i].name; 3037 } 3038 #endif 3039 3040 #if defined(FEAT_MOUSE) || defined(PROTO) 3041 /* 3042 * Look up the given mouse code to return the relevant information in the other 3043 * arguments. Return which button is down or was released. 3044 */ 3045 int 3046 get_mouse_button(int code, int *is_click, int *is_drag) 3047 { 3048 int i; 3049 3050 for (i = 0; mouse_table[i].pseudo_code; i++) 3051 if (code == mouse_table[i].pseudo_code) 3052 { 3053 *is_click = mouse_table[i].is_click; 3054 *is_drag = mouse_table[i].is_drag; 3055 return mouse_table[i].button; 3056 } 3057 return 0; /* Shouldn't get here */ 3058 } 3059 3060 /* 3061 * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on 3062 * the given information about which mouse button is down, and whether the 3063 * mouse was clicked, dragged or released. 3064 */ 3065 int 3066 get_pseudo_mouse_code( 3067 int button, /* eg MOUSE_LEFT */ 3068 int is_click, 3069 int is_drag) 3070 { 3071 int i; 3072 3073 for (i = 0; mouse_table[i].pseudo_code; i++) 3074 if (button == mouse_table[i].button 3075 && is_click == mouse_table[i].is_click 3076 && is_drag == mouse_table[i].is_drag) 3077 { 3078 #ifdef FEAT_GUI 3079 /* Trick: a non mappable left click and release has mouse_col -1 3080 * or added MOUSE_COLOFF. Used for 'mousefocus' in 3081 * gui_mouse_moved() */ 3082 if (mouse_col < 0 || mouse_col > MOUSE_COLOFF) 3083 { 3084 if (mouse_col < 0) 3085 mouse_col = 0; 3086 else 3087 mouse_col -= MOUSE_COLOFF; 3088 if (mouse_table[i].pseudo_code == (int)KE_LEFTMOUSE) 3089 return (int)KE_LEFTMOUSE_NM; 3090 if (mouse_table[i].pseudo_code == (int)KE_LEFTRELEASE) 3091 return (int)KE_LEFTRELEASE_NM; 3092 } 3093 #endif 3094 return mouse_table[i].pseudo_code; 3095 } 3096 return (int)KE_IGNORE; /* not recognized, ignore it */ 3097 } 3098 #endif /* FEAT_MOUSE */ 3099 3100 /* 3101 * Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC. 3102 */ 3103 int 3104 get_fileformat(buf_T *buf) 3105 { 3106 int c = *buf->b_p_ff; 3107 3108 if (buf->b_p_bin || c == 'u') 3109 return EOL_UNIX; 3110 if (c == 'm') 3111 return EOL_MAC; 3112 return EOL_DOS; 3113 } 3114 3115 /* 3116 * Like get_fileformat(), but override 'fileformat' with "p" for "++opt=val" 3117 * argument. 3118 */ 3119 int 3120 get_fileformat_force( 3121 buf_T *buf, 3122 exarg_T *eap) /* can be NULL! */ 3123 { 3124 int c; 3125 3126 if (eap != NULL && eap->force_ff != 0) 3127 c = eap->cmd[eap->force_ff]; 3128 else 3129 { 3130 if ((eap != NULL && eap->force_bin != 0) 3131 ? (eap->force_bin == FORCE_BIN) : buf->b_p_bin) 3132 return EOL_UNIX; 3133 c = *buf->b_p_ff; 3134 } 3135 if (c == 'u') 3136 return EOL_UNIX; 3137 if (c == 'm') 3138 return EOL_MAC; 3139 return EOL_DOS; 3140 } 3141 3142 /* 3143 * Set the current end-of-line type to EOL_DOS, EOL_UNIX or EOL_MAC. 3144 * Sets both 'textmode' and 'fileformat'. 3145 * Note: Does _not_ set global value of 'textmode'! 3146 */ 3147 void 3148 set_fileformat( 3149 int t, 3150 int opt_flags) /* OPT_LOCAL and/or OPT_GLOBAL */ 3151 { 3152 char *p = NULL; 3153 3154 switch (t) 3155 { 3156 case EOL_DOS: 3157 p = FF_DOS; 3158 curbuf->b_p_tx = TRUE; 3159 break; 3160 case EOL_UNIX: 3161 p = FF_UNIX; 3162 curbuf->b_p_tx = FALSE; 3163 break; 3164 case EOL_MAC: 3165 p = FF_MAC; 3166 curbuf->b_p_tx = FALSE; 3167 break; 3168 } 3169 if (p != NULL) 3170 set_string_option_direct((char_u *)"ff", -1, (char_u *)p, 3171 OPT_FREE | opt_flags, 0); 3172 3173 /* This may cause the buffer to become (un)modified. */ 3174 check_status(curbuf); 3175 redraw_tabline = TRUE; 3176 #ifdef FEAT_TITLE 3177 need_maketitle = TRUE; /* set window title later */ 3178 #endif 3179 } 3180 3181 /* 3182 * Return the default fileformat from 'fileformats'. 3183 */ 3184 int 3185 default_fileformat(void) 3186 { 3187 switch (*p_ffs) 3188 { 3189 case 'm': return EOL_MAC; 3190 case 'd': return EOL_DOS; 3191 } 3192 return EOL_UNIX; 3193 } 3194 3195 /* 3196 * Call shell. Calls mch_call_shell, with 'shellxquote' added. 3197 */ 3198 int 3199 call_shell(char_u *cmd, int opt) 3200 { 3201 char_u *ncmd; 3202 int retval; 3203 #ifdef FEAT_PROFILE 3204 proftime_T wait_time; 3205 #endif 3206 3207 if (p_verbose > 3) 3208 { 3209 verbose_enter(); 3210 smsg((char_u *)_("Calling shell to execute: \"%s\""), 3211 cmd == NULL ? p_sh : cmd); 3212 out_char('\n'); 3213 cursor_on(); 3214 verbose_leave(); 3215 } 3216 3217 #ifdef FEAT_PROFILE 3218 if (do_profiling == PROF_YES) 3219 prof_child_enter(&wait_time); 3220 #endif 3221 3222 if (*p_sh == NUL) 3223 { 3224 EMSG(_(e_shellempty)); 3225 retval = -1; 3226 } 3227 else 3228 { 3229 #ifdef FEAT_GUI_MSWIN 3230 /* Don't hide the pointer while executing a shell command. */ 3231 gui_mch_mousehide(FALSE); 3232 #endif 3233 #ifdef FEAT_GUI 3234 ++hold_gui_events; 3235 #endif 3236 /* The external command may update a tags file, clear cached tags. */ 3237 tag_freematch(); 3238 3239 if (cmd == NULL || *p_sxq == NUL) 3240 retval = mch_call_shell(cmd, opt); 3241 else 3242 { 3243 char_u *ecmd = cmd; 3244 3245 if (*p_sxe != NUL && STRCMP(p_sxq, "(") == 0) 3246 { 3247 ecmd = vim_strsave_escaped_ext(cmd, p_sxe, '^', FALSE); 3248 if (ecmd == NULL) 3249 ecmd = cmd; 3250 } 3251 ncmd = alloc((unsigned)(STRLEN(ecmd) + STRLEN(p_sxq) * 2 + 1)); 3252 if (ncmd != NULL) 3253 { 3254 STRCPY(ncmd, p_sxq); 3255 STRCAT(ncmd, ecmd); 3256 /* When 'shellxquote' is ( append ). 3257 * When 'shellxquote' is "( append )". */ 3258 STRCAT(ncmd, STRCMP(p_sxq, "(") == 0 ? (char_u *)")" 3259 : STRCMP(p_sxq, "\"(") == 0 ? (char_u *)")\"" 3260 : p_sxq); 3261 retval = mch_call_shell(ncmd, opt); 3262 vim_free(ncmd); 3263 } 3264 else 3265 retval = -1; 3266 if (ecmd != cmd) 3267 vim_free(ecmd); 3268 } 3269 #ifdef FEAT_GUI 3270 --hold_gui_events; 3271 #endif 3272 /* 3273 * Check the window size, in case it changed while executing the 3274 * external command. 3275 */ 3276 shell_resized_check(); 3277 } 3278 3279 #ifdef FEAT_EVAL 3280 set_vim_var_nr(VV_SHELL_ERROR, (long)retval); 3281 # ifdef FEAT_PROFILE 3282 if (do_profiling == PROF_YES) 3283 prof_child_exit(&wait_time); 3284 # endif 3285 #endif 3286 3287 return retval; 3288 } 3289 3290 /* 3291 * VISUAL, SELECTMODE and OP_PENDING State are never set, they are equal to 3292 * NORMAL State with a condition. This function returns the real State. 3293 */ 3294 int 3295 get_real_state(void) 3296 { 3297 if (State & NORMAL) 3298 { 3299 if (VIsual_active) 3300 { 3301 if (VIsual_select) 3302 return SELECTMODE; 3303 return VISUAL; 3304 } 3305 else if (finish_op) 3306 return OP_PENDING; 3307 } 3308 return State; 3309 } 3310 3311 #if defined(FEAT_MBYTE) || defined(PROTO) 3312 /* 3313 * Return TRUE if "p" points to just after a path separator. 3314 * Takes care of multi-byte characters. 3315 * "b" must point to the start of the file name 3316 */ 3317 int 3318 after_pathsep(char_u *b, char_u *p) 3319 { 3320 return p > b && vim_ispathsep(p[-1]) 3321 && (!has_mbyte || (*mb_head_off)(b, p - 1) == 0); 3322 } 3323 #endif 3324 3325 /* 3326 * Return TRUE if file names "f1" and "f2" are in the same directory. 3327 * "f1" may be a short name, "f2" must be a full path. 3328 */ 3329 int 3330 same_directory(char_u *f1, char_u *f2) 3331 { 3332 char_u ffname[MAXPATHL]; 3333 char_u *t1; 3334 char_u *t2; 3335 3336 /* safety check */ 3337 if (f1 == NULL || f2 == NULL) 3338 return FALSE; 3339 3340 (void)vim_FullName(f1, ffname, MAXPATHL, FALSE); 3341 t1 = gettail_sep(ffname); 3342 t2 = gettail_sep(f2); 3343 return (t1 - ffname == t2 - f2 3344 && pathcmp((char *)ffname, (char *)f2, (int)(t1 - ffname)) == 0); 3345 } 3346 3347 #if defined(FEAT_SESSION) || defined(MSWIN) || defined(FEAT_GUI_MAC) \ 3348 || defined(FEAT_GUI_GTK) \ 3349 || defined(FEAT_SUN_WORKSHOP) || defined(FEAT_NETBEANS_INTG) \ 3350 || defined(PROTO) 3351 /* 3352 * Change to a file's directory. 3353 * Caller must call shorten_fnames()! 3354 * Return OK or FAIL. 3355 */ 3356 int 3357 vim_chdirfile(char_u *fname) 3358 { 3359 char_u dir[MAXPATHL]; 3360 3361 vim_strncpy(dir, fname, MAXPATHL - 1); 3362 *gettail_sep(dir) = NUL; 3363 return mch_chdir((char *)dir) == 0 ? OK : FAIL; 3364 } 3365 #endif 3366 3367 #if defined(STAT_IGNORES_SLASH) || defined(PROTO) 3368 /* 3369 * Check if "name" ends in a slash and is not a directory. 3370 * Used for systems where stat() ignores a trailing slash on a file name. 3371 * The Vim code assumes a trailing slash is only ignored for a directory. 3372 */ 3373 static int 3374 illegal_slash(const char *name) 3375 { 3376 if (name[0] == NUL) 3377 return FALSE; /* no file name is not illegal */ 3378 if (name[strlen(name) - 1] != '/') 3379 return FALSE; /* no trailing slash */ 3380 if (mch_isdir((char_u *)name)) 3381 return FALSE; /* trailing slash for a directory */ 3382 return TRUE; 3383 } 3384 3385 /* 3386 * Special implementation of mch_stat() for Solaris. 3387 */ 3388 int 3389 vim_stat(const char *name, stat_T *stp) 3390 { 3391 /* On Solaris stat() accepts "file/" as if it was "file". Return -1 if 3392 * the name ends in "/" and it's not a directory. */ 3393 return illegal_slash(name) ? -1 : stat(name, stp); 3394 } 3395 #endif 3396 3397 #if defined(CURSOR_SHAPE) || defined(PROTO) 3398 3399 /* 3400 * Handling of cursor and mouse pointer shapes in various modes. 3401 */ 3402 3403 cursorentry_T shape_table[SHAPE_IDX_COUNT] = 3404 { 3405 /* The values will be filled in from the 'guicursor' and 'mouseshape' 3406 * defaults when Vim starts. 3407 * Adjust the SHAPE_IDX_ defines when making changes! */ 3408 {0, 0, 0, 700L, 400L, 250L, 0, 0, "n", SHAPE_CURSOR+SHAPE_MOUSE}, 3409 {0, 0, 0, 700L, 400L, 250L, 0, 0, "v", SHAPE_CURSOR+SHAPE_MOUSE}, 3410 {0, 0, 0, 700L, 400L, 250L, 0, 0, "i", SHAPE_CURSOR+SHAPE_MOUSE}, 3411 {0, 0, 0, 700L, 400L, 250L, 0, 0, "r", SHAPE_CURSOR+SHAPE_MOUSE}, 3412 {0, 0, 0, 700L, 400L, 250L, 0, 0, "c", SHAPE_CURSOR+SHAPE_MOUSE}, 3413 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ci", SHAPE_CURSOR+SHAPE_MOUSE}, 3414 {0, 0, 0, 700L, 400L, 250L, 0, 0, "cr", SHAPE_CURSOR+SHAPE_MOUSE}, 3415 {0, 0, 0, 700L, 400L, 250L, 0, 0, "o", SHAPE_CURSOR+SHAPE_MOUSE}, 3416 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ve", SHAPE_CURSOR+SHAPE_MOUSE}, 3417 {0, 0, 0, 0L, 0L, 0L, 0, 0, "e", SHAPE_MOUSE}, 3418 {0, 0, 0, 0L, 0L, 0L, 0, 0, "s", SHAPE_MOUSE}, 3419 {0, 0, 0, 0L, 0L, 0L, 0, 0, "sd", SHAPE_MOUSE}, 3420 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vs", SHAPE_MOUSE}, 3421 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vd", SHAPE_MOUSE}, 3422 {0, 0, 0, 0L, 0L, 0L, 0, 0, "m", SHAPE_MOUSE}, 3423 {0, 0, 0, 0L, 0L, 0L, 0, 0, "ml", SHAPE_MOUSE}, 3424 {0, 0, 0, 100L, 100L, 100L, 0, 0, "sm", SHAPE_CURSOR}, 3425 }; 3426 3427 #ifdef FEAT_MOUSESHAPE 3428 /* 3429 * Table with names for mouse shapes. Keep in sync with all the tables for 3430 * mch_set_mouse_shape()!. 3431 */ 3432 static char * mshape_names[] = 3433 { 3434 "arrow", /* default, must be the first one */ 3435 "blank", /* hidden */ 3436 "beam", 3437 "updown", 3438 "udsizing", 3439 "leftright", 3440 "lrsizing", 3441 "busy", 3442 "no", 3443 "crosshair", 3444 "hand1", 3445 "hand2", 3446 "pencil", 3447 "question", 3448 "rightup-arrow", 3449 "up-arrow", 3450 NULL 3451 }; 3452 #endif 3453 3454 /* 3455 * Parse the 'guicursor' option ("what" is SHAPE_CURSOR) or 'mouseshape' 3456 * ("what" is SHAPE_MOUSE). 3457 * Returns error message for an illegal option, NULL otherwise. 3458 */ 3459 char_u * 3460 parse_shape_opt(int what) 3461 { 3462 char_u *modep; 3463 char_u *colonp; 3464 char_u *commap; 3465 char_u *slashp; 3466 char_u *p, *endp; 3467 int idx = 0; /* init for GCC */ 3468 int all_idx; 3469 int len; 3470 int i; 3471 long n; 3472 int found_ve = FALSE; /* found "ve" flag */ 3473 int round; 3474 3475 /* 3476 * First round: check for errors; second round: do it for real. 3477 */ 3478 for (round = 1; round <= 2; ++round) 3479 { 3480 /* 3481 * Repeat for all comma separated parts. 3482 */ 3483 #ifdef FEAT_MOUSESHAPE 3484 if (what == SHAPE_MOUSE) 3485 modep = p_mouseshape; 3486 else 3487 #endif 3488 modep = p_guicursor; 3489 while (*modep != NUL) 3490 { 3491 colonp = vim_strchr(modep, ':'); 3492 commap = vim_strchr(modep, ','); 3493 3494 if (colonp == NULL || (commap != NULL && commap < colonp)) 3495 return (char_u *)N_("E545: Missing colon"); 3496 if (colonp == modep) 3497 return (char_u *)N_("E546: Illegal mode"); 3498 3499 /* 3500 * Repeat for all mode's before the colon. 3501 * For the 'a' mode, we loop to handle all the modes. 3502 */ 3503 all_idx = -1; 3504 while (modep < colonp || all_idx >= 0) 3505 { 3506 if (all_idx < 0) 3507 { 3508 /* Find the mode. */ 3509 if (modep[1] == '-' || modep[1] == ':') 3510 len = 1; 3511 else 3512 len = 2; 3513 if (len == 1 && TOLOWER_ASC(modep[0]) == 'a') 3514 all_idx = SHAPE_IDX_COUNT - 1; 3515 else 3516 { 3517 for (idx = 0; idx < SHAPE_IDX_COUNT; ++idx) 3518 if (STRNICMP(modep, shape_table[idx].name, len) 3519 == 0) 3520 break; 3521 if (idx == SHAPE_IDX_COUNT 3522 || (shape_table[idx].used_for & what) == 0) 3523 return (char_u *)N_("E546: Illegal mode"); 3524 if (len == 2 && modep[0] == 'v' && modep[1] == 'e') 3525 found_ve = TRUE; 3526 } 3527 modep += len + 1; 3528 } 3529 3530 if (all_idx >= 0) 3531 idx = all_idx--; 3532 else if (round == 2) 3533 { 3534 #ifdef FEAT_MOUSESHAPE 3535 if (what == SHAPE_MOUSE) 3536 { 3537 /* Set the default, for the missing parts */ 3538 shape_table[idx].mshape = 0; 3539 } 3540 else 3541 #endif 3542 { 3543 /* Set the defaults, for the missing parts */ 3544 shape_table[idx].shape = SHAPE_BLOCK; 3545 shape_table[idx].blinkwait = 700L; 3546 shape_table[idx].blinkon = 400L; 3547 shape_table[idx].blinkoff = 250L; 3548 } 3549 } 3550 3551 /* Parse the part after the colon */ 3552 for (p = colonp + 1; *p && *p != ','; ) 3553 { 3554 #ifdef FEAT_MOUSESHAPE 3555 if (what == SHAPE_MOUSE) 3556 { 3557 for (i = 0; ; ++i) 3558 { 3559 if (mshape_names[i] == NULL) 3560 { 3561 if (!VIM_ISDIGIT(*p)) 3562 return (char_u *)N_("E547: Illegal mouseshape"); 3563 if (round == 2) 3564 shape_table[idx].mshape = 3565 getdigits(&p) + MSHAPE_NUMBERED; 3566 else 3567 (void)getdigits(&p); 3568 break; 3569 } 3570 len = (int)STRLEN(mshape_names[i]); 3571 if (STRNICMP(p, mshape_names[i], len) == 0) 3572 { 3573 if (round == 2) 3574 shape_table[idx].mshape = i; 3575 p += len; 3576 break; 3577 } 3578 } 3579 } 3580 else /* if (what == SHAPE_MOUSE) */ 3581 #endif 3582 { 3583 /* 3584 * First handle the ones with a number argument. 3585 */ 3586 i = *p; 3587 len = 0; 3588 if (STRNICMP(p, "ver", 3) == 0) 3589 len = 3; 3590 else if (STRNICMP(p, "hor", 3) == 0) 3591 len = 3; 3592 else if (STRNICMP(p, "blinkwait", 9) == 0) 3593 len = 9; 3594 else if (STRNICMP(p, "blinkon", 7) == 0) 3595 len = 7; 3596 else if (STRNICMP(p, "blinkoff", 8) == 0) 3597 len = 8; 3598 if (len != 0) 3599 { 3600 p += len; 3601 if (!VIM_ISDIGIT(*p)) 3602 return (char_u *)N_("E548: digit expected"); 3603 n = getdigits(&p); 3604 if (len == 3) /* "ver" or "hor" */ 3605 { 3606 if (n == 0) 3607 return (char_u *)N_("E549: Illegal percentage"); 3608 if (round == 2) 3609 { 3610 if (TOLOWER_ASC(i) == 'v') 3611 shape_table[idx].shape = SHAPE_VER; 3612 else 3613 shape_table[idx].shape = SHAPE_HOR; 3614 shape_table[idx].percentage = n; 3615 } 3616 } 3617 else if (round == 2) 3618 { 3619 if (len == 9) 3620 shape_table[idx].blinkwait = n; 3621 else if (len == 7) 3622 shape_table[idx].blinkon = n; 3623 else 3624 shape_table[idx].blinkoff = n; 3625 } 3626 } 3627 else if (STRNICMP(p, "block", 5) == 0) 3628 { 3629 if (round == 2) 3630 shape_table[idx].shape = SHAPE_BLOCK; 3631 p += 5; 3632 } 3633 else /* must be a highlight group name then */ 3634 { 3635 endp = vim_strchr(p, '-'); 3636 if (commap == NULL) /* last part */ 3637 { 3638 if (endp == NULL) 3639 endp = p + STRLEN(p); /* find end of part */ 3640 } 3641 else if (endp > commap || endp == NULL) 3642 endp = commap; 3643 slashp = vim_strchr(p, '/'); 3644 if (slashp != NULL && slashp < endp) 3645 { 3646 /* "group/langmap_group" */ 3647 i = syn_check_group(p, (int)(slashp - p)); 3648 p = slashp + 1; 3649 } 3650 if (round == 2) 3651 { 3652 shape_table[idx].id = syn_check_group(p, 3653 (int)(endp - p)); 3654 shape_table[idx].id_lm = shape_table[idx].id; 3655 if (slashp != NULL && slashp < endp) 3656 shape_table[idx].id = i; 3657 } 3658 p = endp; 3659 } 3660 } /* if (what != SHAPE_MOUSE) */ 3661 3662 if (*p == '-') 3663 ++p; 3664 } 3665 } 3666 modep = p; 3667 if (*modep == ',') 3668 ++modep; 3669 } 3670 } 3671 3672 /* If the 's' flag is not given, use the 'v' cursor for 's' */ 3673 if (!found_ve) 3674 { 3675 #ifdef FEAT_MOUSESHAPE 3676 if (what == SHAPE_MOUSE) 3677 { 3678 shape_table[SHAPE_IDX_VE].mshape = shape_table[SHAPE_IDX_V].mshape; 3679 } 3680 else 3681 #endif 3682 { 3683 shape_table[SHAPE_IDX_VE].shape = shape_table[SHAPE_IDX_V].shape; 3684 shape_table[SHAPE_IDX_VE].percentage = 3685 shape_table[SHAPE_IDX_V].percentage; 3686 shape_table[SHAPE_IDX_VE].blinkwait = 3687 shape_table[SHAPE_IDX_V].blinkwait; 3688 shape_table[SHAPE_IDX_VE].blinkon = 3689 shape_table[SHAPE_IDX_V].blinkon; 3690 shape_table[SHAPE_IDX_VE].blinkoff = 3691 shape_table[SHAPE_IDX_V].blinkoff; 3692 shape_table[SHAPE_IDX_VE].id = shape_table[SHAPE_IDX_V].id; 3693 shape_table[SHAPE_IDX_VE].id_lm = shape_table[SHAPE_IDX_V].id_lm; 3694 } 3695 } 3696 3697 return NULL; 3698 } 3699 3700 # if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \ 3701 || defined(FEAT_MOUSESHAPE) || defined(PROTO) 3702 /* 3703 * Return the index into shape_table[] for the current mode. 3704 * When "mouse" is TRUE, consider indexes valid for the mouse pointer. 3705 */ 3706 int 3707 get_shape_idx(int mouse) 3708 { 3709 #ifdef FEAT_MOUSESHAPE 3710 if (mouse && (State == HITRETURN || State == ASKMORE)) 3711 { 3712 # ifdef FEAT_GUI 3713 int x, y; 3714 gui_mch_getmouse(&x, &y); 3715 if (Y_2_ROW(y) == Rows - 1) 3716 return SHAPE_IDX_MOREL; 3717 # endif 3718 return SHAPE_IDX_MORE; 3719 } 3720 if (mouse && drag_status_line) 3721 return SHAPE_IDX_SDRAG; 3722 if (mouse && drag_sep_line) 3723 return SHAPE_IDX_VDRAG; 3724 #endif 3725 if (!mouse && State == SHOWMATCH) 3726 return SHAPE_IDX_SM; 3727 #ifdef FEAT_VREPLACE 3728 if (State & VREPLACE_FLAG) 3729 return SHAPE_IDX_R; 3730 #endif 3731 if (State & REPLACE_FLAG) 3732 return SHAPE_IDX_R; 3733 if (State & INSERT) 3734 return SHAPE_IDX_I; 3735 if (State & CMDLINE) 3736 { 3737 if (cmdline_at_end()) 3738 return SHAPE_IDX_C; 3739 if (cmdline_overstrike()) 3740 return SHAPE_IDX_CR; 3741 return SHAPE_IDX_CI; 3742 } 3743 if (finish_op) 3744 return SHAPE_IDX_O; 3745 if (VIsual_active) 3746 { 3747 if (*p_sel == 'e') 3748 return SHAPE_IDX_VE; 3749 else 3750 return SHAPE_IDX_V; 3751 } 3752 return SHAPE_IDX_N; 3753 } 3754 #endif 3755 3756 # if defined(FEAT_MOUSESHAPE) || defined(PROTO) 3757 static int old_mouse_shape = 0; 3758 3759 /* 3760 * Set the mouse shape: 3761 * If "shape" is -1, use shape depending on the current mode, 3762 * depending on the current state. 3763 * If "shape" is -2, only update the shape when it's CLINE or STATUS (used 3764 * when the mouse moves off the status or command line). 3765 */ 3766 void 3767 update_mouseshape(int shape_idx) 3768 { 3769 int new_mouse_shape; 3770 3771 /* Only works in GUI mode. */ 3772 if (!gui.in_use || gui.starting) 3773 return; 3774 3775 /* Postpone the updating when more is to come. Speeds up executing of 3776 * mappings. */ 3777 if (shape_idx == -1 && char_avail()) 3778 { 3779 postponed_mouseshape = TRUE; 3780 return; 3781 } 3782 3783 /* When ignoring the mouse don't change shape on the statusline. */ 3784 if (*p_mouse == NUL 3785 && (shape_idx == SHAPE_IDX_CLINE 3786 || shape_idx == SHAPE_IDX_STATUS 3787 || shape_idx == SHAPE_IDX_VSEP)) 3788 shape_idx = -2; 3789 3790 if (shape_idx == -2 3791 && old_mouse_shape != shape_table[SHAPE_IDX_CLINE].mshape 3792 && old_mouse_shape != shape_table[SHAPE_IDX_STATUS].mshape 3793 && old_mouse_shape != shape_table[SHAPE_IDX_VSEP].mshape) 3794 return; 3795 if (shape_idx < 0) 3796 new_mouse_shape = shape_table[get_shape_idx(TRUE)].mshape; 3797 else 3798 new_mouse_shape = shape_table[shape_idx].mshape; 3799 if (new_mouse_shape != old_mouse_shape) 3800 { 3801 mch_set_mouse_shape(new_mouse_shape); 3802 old_mouse_shape = new_mouse_shape; 3803 } 3804 postponed_mouseshape = FALSE; 3805 } 3806 # endif 3807 3808 #endif /* CURSOR_SHAPE */ 3809 3810 3811 /* TODO: make some #ifdef for this */ 3812 /*--------[ file searching ]-------------------------------------------------*/ 3813 /* 3814 * File searching functions for 'path', 'tags' and 'cdpath' options. 3815 * External visible functions: 3816 * vim_findfile_init() creates/initialises the search context 3817 * vim_findfile_free_visited() free list of visited files/dirs of search 3818 * context 3819 * vim_findfile() find a file in the search context 3820 * vim_findfile_cleanup() cleanup/free search context created by 3821 * vim_findfile_init() 3822 * 3823 * All static functions and variables start with 'ff_' 3824 * 3825 * In general it works like this: 3826 * First you create yourself a search context by calling vim_findfile_init(). 3827 * It is possible to give a search context from a previous call to 3828 * vim_findfile_init(), so it can be reused. After this you call vim_findfile() 3829 * until you are satisfied with the result or it returns NULL. On every call it 3830 * returns the next file which matches the conditions given to 3831 * vim_findfile_init(). If it doesn't find a next file it returns NULL. 3832 * 3833 * It is possible to call vim_findfile_init() again to reinitialise your search 3834 * with some new parameters. Don't forget to pass your old search context to 3835 * it, so it can reuse it and especially reuse the list of already visited 3836 * directories. If you want to delete the list of already visited directories 3837 * simply call vim_findfile_free_visited(). 3838 * 3839 * When you are done call vim_findfile_cleanup() to free the search context. 3840 * 3841 * The function vim_findfile_init() has a long comment, which describes the 3842 * needed parameters. 3843 * 3844 * 3845 * 3846 * ATTENTION: 3847 * ========== 3848 * Also we use an allocated search context here, this functions are NOT 3849 * thread-safe!!!!! 3850 * 3851 * To minimize parameter passing (or because I'm to lazy), only the 3852 * external visible functions get a search context as a parameter. This is 3853 * then assigned to a static global, which is used throughout the local 3854 * functions. 3855 */ 3856 3857 /* 3858 * type for the directory search stack 3859 */ 3860 typedef struct ff_stack 3861 { 3862 struct ff_stack *ffs_prev; 3863 3864 /* the fix part (no wildcards) and the part containing the wildcards 3865 * of the search path 3866 */ 3867 char_u *ffs_fix_path; 3868 #ifdef FEAT_PATH_EXTRA 3869 char_u *ffs_wc_path; 3870 #endif 3871 3872 /* files/dirs found in the above directory, matched by the first wildcard 3873 * of wc_part 3874 */ 3875 char_u **ffs_filearray; 3876 int ffs_filearray_size; 3877 char_u ffs_filearray_cur; /* needed for partly handled dirs */ 3878 3879 /* to store status of partly handled directories 3880 * 0: we work on this directory for the first time 3881 * 1: this directory was partly searched in an earlier step 3882 */ 3883 int ffs_stage; 3884 3885 /* How deep are we in the directory tree? 3886 * Counts backward from value of level parameter to vim_findfile_init 3887 */ 3888 int ffs_level; 3889 3890 /* Did we already expand '**' to an empty string? */ 3891 int ffs_star_star_empty; 3892 } ff_stack_T; 3893 3894 /* 3895 * type for already visited directories or files. 3896 */ 3897 typedef struct ff_visited 3898 { 3899 struct ff_visited *ffv_next; 3900 3901 #ifdef FEAT_PATH_EXTRA 3902 /* Visited directories are different if the wildcard string are 3903 * different. So we have to save it. 3904 */ 3905 char_u *ffv_wc_path; 3906 #endif 3907 /* for unix use inode etc for comparison (needed because of links), else 3908 * use filename. 3909 */ 3910 #ifdef UNIX 3911 int ffv_dev_valid; /* ffv_dev and ffv_ino were set */ 3912 dev_t ffv_dev; /* device number */ 3913 ino_t ffv_ino; /* inode number */ 3914 #endif 3915 /* The memory for this struct is allocated according to the length of 3916 * ffv_fname. 3917 */ 3918 char_u ffv_fname[1]; /* actually longer */ 3919 } ff_visited_T; 3920 3921 /* 3922 * We might have to manage several visited lists during a search. 3923 * This is especially needed for the tags option. If tags is set to: 3924 * "./++/tags,./++/TAGS,++/tags" (replace + with *) 3925 * So we have to do 3 searches: 3926 * 1) search from the current files directory downward for the file "tags" 3927 * 2) search from the current files directory downward for the file "TAGS" 3928 * 3) search from Vims current directory downwards for the file "tags" 3929 * As you can see, the first and the third search are for the same file, so for 3930 * the third search we can use the visited list of the first search. For the 3931 * second search we must start from a empty visited list. 3932 * The struct ff_visited_list_hdr is used to manage a linked list of already 3933 * visited lists. 3934 */ 3935 typedef struct ff_visited_list_hdr 3936 { 3937 struct ff_visited_list_hdr *ffvl_next; 3938 3939 /* the filename the attached visited list is for */ 3940 char_u *ffvl_filename; 3941 3942 ff_visited_T *ffvl_visited_list; 3943 3944 } ff_visited_list_hdr_T; 3945 3946 3947 /* 3948 * '**' can be expanded to several directory levels. 3949 * Set the default maximum depth. 3950 */ 3951 #define FF_MAX_STAR_STAR_EXPAND ((char_u)30) 3952 3953 /* 3954 * The search context: 3955 * ffsc_stack_ptr: the stack for the dirs to search 3956 * ffsc_visited_list: the currently active visited list 3957 * ffsc_dir_visited_list: the currently active visited list for search dirs 3958 * ffsc_visited_lists_list: the list of all visited lists 3959 * ffsc_dir_visited_lists_list: the list of all visited lists for search dirs 3960 * ffsc_file_to_search: the file to search for 3961 * ffsc_start_dir: the starting directory, if search path was relative 3962 * ffsc_fix_path: the fix part of the given path (without wildcards) 3963 * Needed for upward search. 3964 * ffsc_wc_path: the part of the given path containing wildcards 3965 * ffsc_level: how many levels of dirs to search downwards 3966 * ffsc_stopdirs_v: array of stop directories for upward search 3967 * ffsc_find_what: FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE 3968 * ffsc_tagfile: searching for tags file, don't use 'suffixesadd' 3969 */ 3970 typedef struct ff_search_ctx_T 3971 { 3972 ff_stack_T *ffsc_stack_ptr; 3973 ff_visited_list_hdr_T *ffsc_visited_list; 3974 ff_visited_list_hdr_T *ffsc_dir_visited_list; 3975 ff_visited_list_hdr_T *ffsc_visited_lists_list; 3976 ff_visited_list_hdr_T *ffsc_dir_visited_lists_list; 3977 char_u *ffsc_file_to_search; 3978 char_u *ffsc_start_dir; 3979 char_u *ffsc_fix_path; 3980 #ifdef FEAT_PATH_EXTRA 3981 char_u *ffsc_wc_path; 3982 int ffsc_level; 3983 char_u **ffsc_stopdirs_v; 3984 #endif 3985 int ffsc_find_what; 3986 int ffsc_tagfile; 3987 } ff_search_ctx_T; 3988 3989 /* locally needed functions */ 3990 #ifdef FEAT_PATH_EXTRA 3991 static int ff_check_visited(ff_visited_T **, char_u *, char_u *); 3992 #else 3993 static int ff_check_visited(ff_visited_T **, char_u *); 3994 #endif 3995 static void vim_findfile_free_visited_list(ff_visited_list_hdr_T **list_headp); 3996 static void ff_free_visited_list(ff_visited_T *vl); 3997 static ff_visited_list_hdr_T* ff_get_visited_list(char_u *, ff_visited_list_hdr_T **list_headp); 3998 #ifdef FEAT_PATH_EXTRA 3999 static int ff_wc_equal(char_u *s1, char_u *s2); 4000 #endif 4001 4002 static void ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr); 4003 static ff_stack_T *ff_pop(ff_search_ctx_T *search_ctx); 4004 static void ff_clear(ff_search_ctx_T *search_ctx); 4005 static void ff_free_stack_element(ff_stack_T *stack_ptr); 4006 #ifdef FEAT_PATH_EXTRA 4007 static ff_stack_T *ff_create_stack_element(char_u *, char_u *, int, int); 4008 #else 4009 static ff_stack_T *ff_create_stack_element(char_u *, int, int); 4010 #endif 4011 #ifdef FEAT_PATH_EXTRA 4012 static int ff_path_in_stoplist(char_u *, int, char_u **); 4013 #endif 4014 4015 static char_u e_pathtoolong[] = N_("E854: path too long for completion"); 4016 4017 #if 0 4018 /* 4019 * if someone likes findfirst/findnext, here are the functions 4020 * NOT TESTED!! 4021 */ 4022 4023 static void *ff_fn_search_context = NULL; 4024 4025 char_u * 4026 vim_findfirst(char_u *path, char_u *filename, int level) 4027 { 4028 ff_fn_search_context = 4029 vim_findfile_init(path, filename, NULL, level, TRUE, FALSE, 4030 ff_fn_search_context, rel_fname); 4031 if (NULL == ff_fn_search_context) 4032 return NULL; 4033 else 4034 return vim_findnext() 4035 } 4036 4037 char_u * 4038 vim_findnext(void) 4039 { 4040 char_u *ret = vim_findfile(ff_fn_search_context); 4041 4042 if (NULL == ret) 4043 { 4044 vim_findfile_cleanup(ff_fn_search_context); 4045 ff_fn_search_context = NULL; 4046 } 4047 return ret; 4048 } 4049 #endif 4050 4051 /* 4052 * Initialization routine for vim_findfile(). 4053 * 4054 * Returns the newly allocated search context or NULL if an error occurred. 4055 * 4056 * Don't forget to clean up by calling vim_findfile_cleanup() if you are done 4057 * with the search context. 4058 * 4059 * Find the file 'filename' in the directory 'path'. 4060 * The parameter 'path' may contain wildcards. If so only search 'level' 4061 * directories deep. The parameter 'level' is the absolute maximum and is 4062 * not related to restricts given to the '**' wildcard. If 'level' is 100 4063 * and you use '**200' vim_findfile() will stop after 100 levels. 4064 * 4065 * 'filename' cannot contain wildcards! It is used as-is, no backslashes to 4066 * escape special characters. 4067 * 4068 * If 'stopdirs' is not NULL and nothing is found downward, the search is 4069 * restarted on the next higher directory level. This is repeated until the 4070 * start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the 4071 * format ";*<dirname>*\(;<dirname>\)*;\=$". 4072 * 4073 * If the 'path' is relative, the starting dir for the search is either VIM's 4074 * current dir or if the path starts with "./" the current files dir. 4075 * If the 'path' is absolute, the starting dir is that part of the path before 4076 * the first wildcard. 4077 * 4078 * Upward search is only done on the starting dir. 4079 * 4080 * If 'free_visited' is TRUE the list of already visited files/directories is 4081 * cleared. Set this to FALSE if you just want to search from another 4082 * directory, but want to be sure that no directory from a previous search is 4083 * searched again. This is useful if you search for a file at different places. 4084 * The list of visited files/dirs can also be cleared with the function 4085 * vim_findfile_free_visited(). 4086 * 4087 * Set the parameter 'find_what' to FINDFILE_DIR if you want to search for 4088 * directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both. 4089 * 4090 * A search context returned by a previous call to vim_findfile_init() can be 4091 * passed in the parameter "search_ctx_arg". This context is reused and 4092 * reinitialized with the new parameters. The list of already visited 4093 * directories from this context is only deleted if the parameter 4094 * "free_visited" is true. Be aware that the passed "search_ctx_arg" is freed 4095 * if the reinitialization fails. 4096 * 4097 * If you don't have a search context from a previous call "search_ctx_arg" 4098 * must be NULL. 4099 * 4100 * This function silently ignores a few errors, vim_findfile() will have 4101 * limited functionality then. 4102 */ 4103 void * 4104 vim_findfile_init( 4105 char_u *path, 4106 char_u *filename, 4107 char_u *stopdirs UNUSED, 4108 int level, 4109 int free_visited, 4110 int find_what, 4111 void *search_ctx_arg, 4112 int tagfile, /* expanding names of tags files */ 4113 char_u *rel_fname) /* file name to use for "." */ 4114 { 4115 #ifdef FEAT_PATH_EXTRA 4116 char_u *wc_part; 4117 #endif 4118 ff_stack_T *sptr; 4119 ff_search_ctx_T *search_ctx; 4120 4121 /* If a search context is given by the caller, reuse it, else allocate a 4122 * new one. 4123 */ 4124 if (search_ctx_arg != NULL) 4125 search_ctx = search_ctx_arg; 4126 else 4127 { 4128 search_ctx = (ff_search_ctx_T*)alloc((unsigned)sizeof(ff_search_ctx_T)); 4129 if (search_ctx == NULL) 4130 goto error_return; 4131 vim_memset(search_ctx, 0, sizeof(ff_search_ctx_T)); 4132 } 4133 search_ctx->ffsc_find_what = find_what; 4134 search_ctx->ffsc_tagfile = tagfile; 4135 4136 /* clear the search context, but NOT the visited lists */ 4137 ff_clear(search_ctx); 4138 4139 /* clear visited list if wanted */ 4140 if (free_visited == TRUE) 4141 vim_findfile_free_visited(search_ctx); 4142 else 4143 { 4144 /* Reuse old visited lists. Get the visited list for the given 4145 * filename. If no list for the current filename exists, creates a new 4146 * one. */ 4147 search_ctx->ffsc_visited_list = ff_get_visited_list(filename, 4148 &search_ctx->ffsc_visited_lists_list); 4149 if (search_ctx->ffsc_visited_list == NULL) 4150 goto error_return; 4151 search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename, 4152 &search_ctx->ffsc_dir_visited_lists_list); 4153 if (search_ctx->ffsc_dir_visited_list == NULL) 4154 goto error_return; 4155 } 4156 4157 if (ff_expand_buffer == NULL) 4158 { 4159 ff_expand_buffer = (char_u*)alloc(MAXPATHL); 4160 if (ff_expand_buffer == NULL) 4161 goto error_return; 4162 } 4163 4164 /* Store information on starting dir now if path is relative. 4165 * If path is absolute, we do that later. */ 4166 if (path[0] == '.' 4167 && (vim_ispathsep(path[1]) || path[1] == NUL) 4168 && (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL) 4169 && rel_fname != NULL) 4170 { 4171 int len = (int)(gettail(rel_fname) - rel_fname); 4172 4173 if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) 4174 { 4175 /* Make the start dir an absolute path name. */ 4176 vim_strncpy(ff_expand_buffer, rel_fname, len); 4177 search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, FALSE); 4178 } 4179 else 4180 search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len); 4181 if (search_ctx->ffsc_start_dir == NULL) 4182 goto error_return; 4183 if (*++path != NUL) 4184 ++path; 4185 } 4186 else if (*path == NUL || !vim_isAbsName(path)) 4187 { 4188 #ifdef BACKSLASH_IN_FILENAME 4189 /* "c:dir" needs "c:" to be expanded, otherwise use current dir */ 4190 if (*path != NUL && path[1] == ':') 4191 { 4192 char_u drive[3]; 4193 4194 drive[0] = path[0]; 4195 drive[1] = ':'; 4196 drive[2] = NUL; 4197 if (vim_FullName(drive, ff_expand_buffer, MAXPATHL, TRUE) == FAIL) 4198 goto error_return; 4199 path += 2; 4200 } 4201 else 4202 #endif 4203 if (mch_dirname(ff_expand_buffer, MAXPATHL) == FAIL) 4204 goto error_return; 4205 4206 search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer); 4207 if (search_ctx->ffsc_start_dir == NULL) 4208 goto error_return; 4209 4210 #ifdef BACKSLASH_IN_FILENAME 4211 /* A path that starts with "/dir" is relative to the drive, not to the 4212 * directory (but not for "//machine/dir"). Only use the drive name. */ 4213 if ((*path == '/' || *path == '\\') 4214 && path[1] != path[0] 4215 && search_ctx->ffsc_start_dir[1] == ':') 4216 search_ctx->ffsc_start_dir[2] = NUL; 4217 #endif 4218 } 4219 4220 #ifdef FEAT_PATH_EXTRA 4221 /* 4222 * If stopdirs are given, split them into an array of pointers. 4223 * If this fails (mem allocation), there is no upward search at all or a 4224 * stop directory is not recognized -> continue silently. 4225 * If stopdirs just contains a ";" or is empty, 4226 * search_ctx->ffsc_stopdirs_v will only contain a NULL pointer. This 4227 * is handled as unlimited upward search. See function 4228 * ff_path_in_stoplist() for details. 4229 */ 4230 if (stopdirs != NULL) 4231 { 4232 char_u *walker = stopdirs; 4233 int dircount; 4234 4235 while (*walker == ';') 4236 walker++; 4237 4238 dircount = 1; 4239 search_ctx->ffsc_stopdirs_v = 4240 (char_u **)alloc((unsigned)sizeof(char_u *)); 4241 4242 if (search_ctx->ffsc_stopdirs_v != NULL) 4243 { 4244 do 4245 { 4246 char_u *helper; 4247 void *ptr; 4248 4249 helper = walker; 4250 ptr = vim_realloc(search_ctx->ffsc_stopdirs_v, 4251 (dircount + 1) * sizeof(char_u *)); 4252 if (ptr) 4253 search_ctx->ffsc_stopdirs_v = ptr; 4254 else 4255 /* ignore, keep what we have and continue */ 4256 break; 4257 walker = vim_strchr(walker, ';'); 4258 if (walker) 4259 { 4260 search_ctx->ffsc_stopdirs_v[dircount-1] = 4261 vim_strnsave(helper, (int)(walker - helper)); 4262 walker++; 4263 } 4264 else 4265 /* this might be "", which means ascent till top 4266 * of directory tree. 4267 */ 4268 search_ctx->ffsc_stopdirs_v[dircount-1] = 4269 vim_strsave(helper); 4270 4271 dircount++; 4272 4273 } while (walker != NULL); 4274 search_ctx->ffsc_stopdirs_v[dircount-1] = NULL; 4275 } 4276 } 4277 #endif 4278 4279 #ifdef FEAT_PATH_EXTRA 4280 search_ctx->ffsc_level = level; 4281 4282 /* split into: 4283 * -fix path 4284 * -wildcard_stuff (might be NULL) 4285 */ 4286 wc_part = vim_strchr(path, '*'); 4287 if (wc_part != NULL) 4288 { 4289 int llevel; 4290 int len; 4291 char *errpt; 4292 4293 /* save the fix part of the path */ 4294 search_ctx->ffsc_fix_path = vim_strnsave(path, (int)(wc_part - path)); 4295 4296 /* 4297 * copy wc_path and add restricts to the '**' wildcard. 4298 * The octet after a '**' is used as a (binary) counter. 4299 * So '**3' is transposed to '**^C' ('^C' is ASCII value 3) 4300 * or '**76' is transposed to '**N'( 'N' is ASCII value 76). 4301 * For EBCDIC you get different character values. 4302 * If no restrict is given after '**' the default is used. 4303 * Due to this technique the path looks awful if you print it as a 4304 * string. 4305 */ 4306 len = 0; 4307 while (*wc_part != NUL) 4308 { 4309 if (len + 5 >= MAXPATHL) 4310 { 4311 EMSG(_(e_pathtoolong)); 4312 break; 4313 } 4314 if (STRNCMP(wc_part, "**", 2) == 0) 4315 { 4316 ff_expand_buffer[len++] = *wc_part++; 4317 ff_expand_buffer[len++] = *wc_part++; 4318 4319 llevel = strtol((char *)wc_part, &errpt, 10); 4320 if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255) 4321 ff_expand_buffer[len++] = llevel; 4322 else if ((char_u *)errpt != wc_part && llevel == 0) 4323 /* restrict is 0 -> remove already added '**' */ 4324 len -= 2; 4325 else 4326 ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND; 4327 wc_part = (char_u *)errpt; 4328 if (*wc_part != NUL && !vim_ispathsep(*wc_part)) 4329 { 4330 EMSG2(_("E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."), PATHSEPSTR); 4331 goto error_return; 4332 } 4333 } 4334 else 4335 ff_expand_buffer[len++] = *wc_part++; 4336 } 4337 ff_expand_buffer[len] = NUL; 4338 search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer); 4339 4340 if (search_ctx->ffsc_wc_path == NULL) 4341 goto error_return; 4342 } 4343 else 4344 #endif 4345 search_ctx->ffsc_fix_path = vim_strsave(path); 4346 4347 if (search_ctx->ffsc_start_dir == NULL) 4348 { 4349 /* store the fix part as startdir. 4350 * This is needed if the parameter path is fully qualified. 4351 */ 4352 search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path); 4353 if (search_ctx->ffsc_start_dir == NULL) 4354 goto error_return; 4355 search_ctx->ffsc_fix_path[0] = NUL; 4356 } 4357 4358 /* create an absolute path */ 4359 if (STRLEN(search_ctx->ffsc_start_dir) 4360 + STRLEN(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) 4361 { 4362 EMSG(_(e_pathtoolong)); 4363 goto error_return; 4364 } 4365 STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir); 4366 add_pathsep(ff_expand_buffer); 4367 { 4368 int eb_len = (int)STRLEN(ff_expand_buffer); 4369 char_u *buf = alloc(eb_len 4370 + (int)STRLEN(search_ctx->ffsc_fix_path) + 1); 4371 4372 STRCPY(buf, ff_expand_buffer); 4373 STRCPY(buf + eb_len, search_ctx->ffsc_fix_path); 4374 if (mch_isdir(buf)) 4375 { 4376 STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path); 4377 add_pathsep(ff_expand_buffer); 4378 } 4379 #ifdef FEAT_PATH_EXTRA 4380 else 4381 { 4382 char_u *p = gettail(search_ctx->ffsc_fix_path); 4383 char_u *wc_path = NULL; 4384 char_u *temp = NULL; 4385 int len = 0; 4386 4387 if (p > search_ctx->ffsc_fix_path) 4388 { 4389 len = (int)(p - search_ctx->ffsc_fix_path) - 1; 4390 STRNCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, len); 4391 add_pathsep(ff_expand_buffer); 4392 } 4393 else 4394 len = (int)STRLEN(search_ctx->ffsc_fix_path); 4395 4396 if (search_ctx->ffsc_wc_path != NULL) 4397 { 4398 wc_path = vim_strsave(search_ctx->ffsc_wc_path); 4399 temp = alloc((int)(STRLEN(search_ctx->ffsc_wc_path) 4400 + STRLEN(search_ctx->ffsc_fix_path + len) 4401 + 1)); 4402 if (temp == NULL || wc_path == NULL) 4403 { 4404 vim_free(buf); 4405 vim_free(temp); 4406 vim_free(wc_path); 4407 goto error_return; 4408 } 4409 4410 STRCPY(temp, search_ctx->ffsc_fix_path + len); 4411 STRCAT(temp, search_ctx->ffsc_wc_path); 4412 vim_free(search_ctx->ffsc_wc_path); 4413 vim_free(wc_path); 4414 search_ctx->ffsc_wc_path = temp; 4415 } 4416 } 4417 #endif 4418 vim_free(buf); 4419 } 4420 4421 sptr = ff_create_stack_element(ff_expand_buffer, 4422 #ifdef FEAT_PATH_EXTRA 4423 search_ctx->ffsc_wc_path, 4424 #endif 4425 level, 0); 4426 4427 if (sptr == NULL) 4428 goto error_return; 4429 4430 ff_push(search_ctx, sptr); 4431 4432 search_ctx->ffsc_file_to_search = vim_strsave(filename); 4433 if (search_ctx->ffsc_file_to_search == NULL) 4434 goto error_return; 4435 4436 return search_ctx; 4437 4438 error_return: 4439 /* 4440 * We clear the search context now! 4441 * Even when the caller gave us a (perhaps valid) context we free it here, 4442 * as we might have already destroyed it. 4443 */ 4444 vim_findfile_cleanup(search_ctx); 4445 return NULL; 4446 } 4447 4448 #if defined(FEAT_PATH_EXTRA) || defined(PROTO) 4449 /* 4450 * Get the stopdir string. Check that ';' is not escaped. 4451 */ 4452 char_u * 4453 vim_findfile_stopdir(char_u *buf) 4454 { 4455 char_u *r_ptr = buf; 4456 4457 while (*r_ptr != NUL && *r_ptr != ';') 4458 { 4459 if (r_ptr[0] == '\\' && r_ptr[1] == ';') 4460 { 4461 /* Overwrite the escape char, 4462 * use STRLEN(r_ptr) to move the trailing '\0'. */ 4463 STRMOVE(r_ptr, r_ptr + 1); 4464 r_ptr++; 4465 } 4466 r_ptr++; 4467 } 4468 if (*r_ptr == ';') 4469 { 4470 *r_ptr = 0; 4471 r_ptr++; 4472 } 4473 else if (*r_ptr == NUL) 4474 r_ptr = NULL; 4475 return r_ptr; 4476 } 4477 #endif 4478 4479 /* 4480 * Clean up the given search context. Can handle a NULL pointer. 4481 */ 4482 void 4483 vim_findfile_cleanup(void *ctx) 4484 { 4485 if (ctx == NULL) 4486 return; 4487 4488 vim_findfile_free_visited(ctx); 4489 ff_clear(ctx); 4490 vim_free(ctx); 4491 } 4492 4493 /* 4494 * Find a file in a search context. 4495 * The search context was created with vim_findfile_init() above. 4496 * Return a pointer to an allocated file name or NULL if nothing found. 4497 * To get all matching files call this function until you get NULL. 4498 * 4499 * If the passed search_context is NULL, NULL is returned. 4500 * 4501 * The search algorithm is depth first. To change this replace the 4502 * stack with a list (don't forget to leave partly searched directories on the 4503 * top of the list). 4504 */ 4505 char_u * 4506 vim_findfile(void *search_ctx_arg) 4507 { 4508 char_u *file_path; 4509 #ifdef FEAT_PATH_EXTRA 4510 char_u *rest_of_wildcards; 4511 char_u *path_end = NULL; 4512 #endif 4513 ff_stack_T *stackp; 4514 #if defined(FEAT_SEARCHPATH) || defined(FEAT_PATH_EXTRA) 4515 int len; 4516 #endif 4517 int i; 4518 char_u *p; 4519 #ifdef FEAT_SEARCHPATH 4520 char_u *suf; 4521 #endif 4522 ff_search_ctx_T *search_ctx; 4523 4524 if (search_ctx_arg == NULL) 4525 return NULL; 4526 4527 search_ctx = (ff_search_ctx_T *)search_ctx_arg; 4528 4529 /* 4530 * filepath is used as buffer for various actions and as the storage to 4531 * return a found filename. 4532 */ 4533 if ((file_path = alloc((int)MAXPATHL)) == NULL) 4534 return NULL; 4535 4536 #ifdef FEAT_PATH_EXTRA 4537 /* store the end of the start dir -- needed for upward search */ 4538 if (search_ctx->ffsc_start_dir != NULL) 4539 path_end = &search_ctx->ffsc_start_dir[ 4540 STRLEN(search_ctx->ffsc_start_dir)]; 4541 #endif 4542 4543 #ifdef FEAT_PATH_EXTRA 4544 /* upward search loop */ 4545 for (;;) 4546 { 4547 #endif 4548 /* downward search loop */ 4549 for (;;) 4550 { 4551 /* check if user user wants to stop the search*/ 4552 ui_breakcheck(); 4553 if (got_int) 4554 break; 4555 4556 /* get directory to work on from stack */ 4557 stackp = ff_pop(search_ctx); 4558 if (stackp == NULL) 4559 break; 4560 4561 /* 4562 * TODO: decide if we leave this test in 4563 * 4564 * GOOD: don't search a directory(-tree) twice. 4565 * BAD: - check linked list for every new directory entered. 4566 * - check for double files also done below 4567 * 4568 * Here we check if we already searched this directory. 4569 * We already searched a directory if: 4570 * 1) The directory is the same. 4571 * 2) We would use the same wildcard string. 4572 * 4573 * Good if you have links on same directory via several ways 4574 * or you have selfreferences in directories (e.g. SuSE Linux 6.3: 4575 * /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop) 4576 * 4577 * This check is only needed for directories we work on for the 4578 * first time (hence stackp->ff_filearray == NULL) 4579 */ 4580 if (stackp->ffs_filearray == NULL 4581 && ff_check_visited(&search_ctx->ffsc_dir_visited_list 4582 ->ffvl_visited_list, 4583 stackp->ffs_fix_path 4584 #ifdef FEAT_PATH_EXTRA 4585 , stackp->ffs_wc_path 4586 #endif 4587 ) == FAIL) 4588 { 4589 #ifdef FF_VERBOSE 4590 if (p_verbose >= 5) 4591 { 4592 verbose_enter_scroll(); 4593 smsg((char_u *)"Already Searched: %s (%s)", 4594 stackp->ffs_fix_path, stackp->ffs_wc_path); 4595 /* don't overwrite this either */ 4596 msg_puts((char_u *)"\n"); 4597 verbose_leave_scroll(); 4598 } 4599 #endif 4600 ff_free_stack_element(stackp); 4601 continue; 4602 } 4603 #ifdef FF_VERBOSE 4604 else if (p_verbose >= 5) 4605 { 4606 verbose_enter_scroll(); 4607 smsg((char_u *)"Searching: %s (%s)", 4608 stackp->ffs_fix_path, stackp->ffs_wc_path); 4609 /* don't overwrite this either */ 4610 msg_puts((char_u *)"\n"); 4611 verbose_leave_scroll(); 4612 } 4613 #endif 4614 4615 /* check depth */ 4616 if (stackp->ffs_level <= 0) 4617 { 4618 ff_free_stack_element(stackp); 4619 continue; 4620 } 4621 4622 file_path[0] = NUL; 4623 4624 /* 4625 * If no filearray till now expand wildcards 4626 * The function expand_wildcards() can handle an array of paths 4627 * and all possible expands are returned in one array. We use this 4628 * to handle the expansion of '**' into an empty string. 4629 */ 4630 if (stackp->ffs_filearray == NULL) 4631 { 4632 char_u *dirptrs[2]; 4633 4634 /* we use filepath to build the path expand_wildcards() should 4635 * expand. 4636 */ 4637 dirptrs[0] = file_path; 4638 dirptrs[1] = NULL; 4639 4640 /* if we have a start dir copy it in */ 4641 if (!vim_isAbsName(stackp->ffs_fix_path) 4642 && search_ctx->ffsc_start_dir) 4643 { 4644 if (STRLEN(search_ctx->ffsc_start_dir) + 1 < MAXPATHL) 4645 { 4646 STRCPY(file_path, search_ctx->ffsc_start_dir); 4647 add_pathsep(file_path); 4648 } 4649 else 4650 goto fail; 4651 } 4652 4653 /* append the fix part of the search path */ 4654 if (STRLEN(file_path) + STRLEN(stackp->ffs_fix_path) + 1 < MAXPATHL) 4655 { 4656 STRCAT(file_path, stackp->ffs_fix_path); 4657 add_pathsep(file_path); 4658 } 4659 else 4660 goto fail; 4661 4662 #ifdef FEAT_PATH_EXTRA 4663 rest_of_wildcards = stackp->ffs_wc_path; 4664 if (*rest_of_wildcards != NUL) 4665 { 4666 len = (int)STRLEN(file_path); 4667 if (STRNCMP(rest_of_wildcards, "**", 2) == 0) 4668 { 4669 /* pointer to the restrict byte 4670 * The restrict byte is not a character! 4671 */ 4672 p = rest_of_wildcards + 2; 4673 4674 if (*p > 0) 4675 { 4676 (*p)--; 4677 if (len + 1 < MAXPATHL) 4678 file_path[len++] = '*'; 4679 else 4680 goto fail; 4681 } 4682 4683 if (*p == 0) 4684 { 4685 /* remove '**<numb> from wildcards */ 4686 STRMOVE(rest_of_wildcards, rest_of_wildcards + 3); 4687 } 4688 else 4689 rest_of_wildcards += 3; 4690 4691 if (stackp->ffs_star_star_empty == 0) 4692 { 4693 /* if not done before, expand '**' to empty */ 4694 stackp->ffs_star_star_empty = 1; 4695 dirptrs[1] = stackp->ffs_fix_path; 4696 } 4697 } 4698 4699 /* 4700 * Here we copy until the next path separator or the end of 4701 * the path. If we stop at a path separator, there is 4702 * still something else left. This is handled below by 4703 * pushing every directory returned from expand_wildcards() 4704 * on the stack again for further search. 4705 */ 4706 while (*rest_of_wildcards 4707 && !vim_ispathsep(*rest_of_wildcards)) 4708 if (len + 1 < MAXPATHL) 4709 file_path[len++] = *rest_of_wildcards++; 4710 else 4711 goto fail; 4712 4713 file_path[len] = NUL; 4714 if (vim_ispathsep(*rest_of_wildcards)) 4715 rest_of_wildcards++; 4716 } 4717 #endif 4718 4719 /* 4720 * Expand wildcards like "*" and "$VAR". 4721 * If the path is a URL don't try this. 4722 */ 4723 if (path_with_url(dirptrs[0])) 4724 { 4725 stackp->ffs_filearray = (char_u **) 4726 alloc((unsigned)sizeof(char *)); 4727 if (stackp->ffs_filearray != NULL 4728 && (stackp->ffs_filearray[0] 4729 = vim_strsave(dirptrs[0])) != NULL) 4730 stackp->ffs_filearray_size = 1; 4731 else 4732 stackp->ffs_filearray_size = 0; 4733 } 4734 else 4735 /* Add EW_NOTWILD because the expanded path may contain 4736 * wildcard characters that are to be taken literally. 4737 * This is a bit of a hack. */ 4738 expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs, 4739 &stackp->ffs_filearray_size, 4740 &stackp->ffs_filearray, 4741 EW_DIR|EW_ADDSLASH|EW_SILENT|EW_NOTWILD); 4742 4743 stackp->ffs_filearray_cur = 0; 4744 stackp->ffs_stage = 0; 4745 } 4746 #ifdef FEAT_PATH_EXTRA 4747 else 4748 rest_of_wildcards = &stackp->ffs_wc_path[ 4749 STRLEN(stackp->ffs_wc_path)]; 4750 #endif 4751 4752 if (stackp->ffs_stage == 0) 4753 { 4754 /* this is the first time we work on this directory */ 4755 #ifdef FEAT_PATH_EXTRA 4756 if (*rest_of_wildcards == NUL) 4757 #endif 4758 { 4759 /* 4760 * We don't have further wildcards to expand, so we have to 4761 * check for the final file now. 4762 */ 4763 for (i = stackp->ffs_filearray_cur; 4764 i < stackp->ffs_filearray_size; ++i) 4765 { 4766 if (!path_with_url(stackp->ffs_filearray[i]) 4767 && !mch_isdir(stackp->ffs_filearray[i])) 4768 continue; /* not a directory */ 4769 4770 /* prepare the filename to be checked for existence 4771 * below */ 4772 if (STRLEN(stackp->ffs_filearray[i]) + 1 4773 + STRLEN(search_ctx->ffsc_file_to_search) < MAXPATHL) 4774 { 4775 STRCPY(file_path, stackp->ffs_filearray[i]); 4776 add_pathsep(file_path); 4777 STRCAT(file_path, search_ctx->ffsc_file_to_search); 4778 } 4779 else 4780 goto fail; 4781 4782 /* 4783 * Try without extra suffix and then with suffixes 4784 * from 'suffixesadd'. 4785 */ 4786 #ifdef FEAT_SEARCHPATH 4787 len = (int)STRLEN(file_path); 4788 if (search_ctx->ffsc_tagfile) 4789 suf = (char_u *)""; 4790 else 4791 suf = curbuf->b_p_sua; 4792 for (;;) 4793 #endif 4794 { 4795 /* if file exists and we didn't already find it */ 4796 if ((path_with_url(file_path) 4797 || (mch_getperm(file_path) >= 0 4798 && (search_ctx->ffsc_find_what 4799 == FINDFILE_BOTH 4800 || ((search_ctx->ffsc_find_what 4801 == FINDFILE_DIR) 4802 == mch_isdir(file_path))))) 4803 #ifndef FF_VERBOSE 4804 && (ff_check_visited( 4805 &search_ctx->ffsc_visited_list->ffvl_visited_list, 4806 file_path 4807 #ifdef FEAT_PATH_EXTRA 4808 , (char_u *)"" 4809 #endif 4810 ) == OK) 4811 #endif 4812 ) 4813 { 4814 #ifdef FF_VERBOSE 4815 if (ff_check_visited( 4816 &search_ctx->ffsc_visited_list->ffvl_visited_list, 4817 file_path 4818 #ifdef FEAT_PATH_EXTRA 4819 , (char_u *)"" 4820 #endif 4821 ) == FAIL) 4822 { 4823 if (p_verbose >= 5) 4824 { 4825 verbose_enter_scroll(); 4826 smsg((char_u *)"Already: %s", 4827 file_path); 4828 /* don't overwrite this either */ 4829 msg_puts((char_u *)"\n"); 4830 verbose_leave_scroll(); 4831 } 4832 continue; 4833 } 4834 #endif 4835 4836 /* push dir to examine rest of subdirs later */ 4837 stackp->ffs_filearray_cur = i + 1; 4838 ff_push(search_ctx, stackp); 4839 4840 if (!path_with_url(file_path)) 4841 simplify_filename(file_path); 4842 if (mch_dirname(ff_expand_buffer, MAXPATHL) 4843 == OK) 4844 { 4845 p = shorten_fname(file_path, 4846 ff_expand_buffer); 4847 if (p != NULL) 4848 STRMOVE(file_path, p); 4849 } 4850 #ifdef FF_VERBOSE 4851 if (p_verbose >= 5) 4852 { 4853 verbose_enter_scroll(); 4854 smsg((char_u *)"HIT: %s", file_path); 4855 /* don't overwrite this either */ 4856 msg_puts((char_u *)"\n"); 4857 verbose_leave_scroll(); 4858 } 4859 #endif 4860 return file_path; 4861 } 4862 4863 #ifdef FEAT_SEARCHPATH 4864 /* Not found or found already, try next suffix. */ 4865 if (*suf == NUL) 4866 break; 4867 copy_option_part(&suf, file_path + len, 4868 MAXPATHL - len, ","); 4869 #endif 4870 } 4871 } 4872 } 4873 #ifdef FEAT_PATH_EXTRA 4874 else 4875 { 4876 /* 4877 * still wildcards left, push the directories for further 4878 * search 4879 */ 4880 for (i = stackp->ffs_filearray_cur; 4881 i < stackp->ffs_filearray_size; ++i) 4882 { 4883 if (!mch_isdir(stackp->ffs_filearray[i])) 4884 continue; /* not a directory */ 4885 4886 ff_push(search_ctx, 4887 ff_create_stack_element( 4888 stackp->ffs_filearray[i], 4889 rest_of_wildcards, 4890 stackp->ffs_level - 1, 0)); 4891 } 4892 } 4893 #endif 4894 stackp->ffs_filearray_cur = 0; 4895 stackp->ffs_stage = 1; 4896 } 4897 4898 #ifdef FEAT_PATH_EXTRA 4899 /* 4900 * if wildcards contains '**' we have to descent till we reach the 4901 * leaves of the directory tree. 4902 */ 4903 if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) 4904 { 4905 for (i = stackp->ffs_filearray_cur; 4906 i < stackp->ffs_filearray_size; ++i) 4907 { 4908 if (fnamecmp(stackp->ffs_filearray[i], 4909 stackp->ffs_fix_path) == 0) 4910 continue; /* don't repush same directory */ 4911 if (!mch_isdir(stackp->ffs_filearray[i])) 4912 continue; /* not a directory */ 4913 ff_push(search_ctx, 4914 ff_create_stack_element(stackp->ffs_filearray[i], 4915 stackp->ffs_wc_path, stackp->ffs_level - 1, 1)); 4916 } 4917 } 4918 #endif 4919 4920 /* we are done with the current directory */ 4921 ff_free_stack_element(stackp); 4922 4923 } 4924 4925 #ifdef FEAT_PATH_EXTRA 4926 /* If we reached this, we didn't find anything downwards. 4927 * Let's check if we should do an upward search. 4928 */ 4929 if (search_ctx->ffsc_start_dir 4930 && search_ctx->ffsc_stopdirs_v != NULL && !got_int) 4931 { 4932 ff_stack_T *sptr; 4933 4934 /* is the last starting directory in the stop list? */ 4935 if (ff_path_in_stoplist(search_ctx->ffsc_start_dir, 4936 (int)(path_end - search_ctx->ffsc_start_dir), 4937 search_ctx->ffsc_stopdirs_v) == TRUE) 4938 break; 4939 4940 /* cut of last dir */ 4941 while (path_end > search_ctx->ffsc_start_dir 4942 && vim_ispathsep(*path_end)) 4943 path_end--; 4944 while (path_end > search_ctx->ffsc_start_dir 4945 && !vim_ispathsep(path_end[-1])) 4946 path_end--; 4947 *path_end = 0; 4948 path_end--; 4949 4950 if (*search_ctx->ffsc_start_dir == 0) 4951 break; 4952 4953 if (STRLEN(search_ctx->ffsc_start_dir) + 1 4954 + STRLEN(search_ctx->ffsc_fix_path) < MAXPATHL) 4955 { 4956 STRCPY(file_path, search_ctx->ffsc_start_dir); 4957 add_pathsep(file_path); 4958 STRCAT(file_path, search_ctx->ffsc_fix_path); 4959 } 4960 else 4961 goto fail; 4962 4963 /* create a new stack entry */ 4964 sptr = ff_create_stack_element(file_path, 4965 search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0); 4966 if (sptr == NULL) 4967 break; 4968 ff_push(search_ctx, sptr); 4969 } 4970 else 4971 break; 4972 } 4973 #endif 4974 4975 fail: 4976 vim_free(file_path); 4977 return NULL; 4978 } 4979 4980 /* 4981 * Free the list of lists of visited files and directories 4982 * Can handle it if the passed search_context is NULL; 4983 */ 4984 void 4985 vim_findfile_free_visited(void *search_ctx_arg) 4986 { 4987 ff_search_ctx_T *search_ctx; 4988 4989 if (search_ctx_arg == NULL) 4990 return; 4991 4992 search_ctx = (ff_search_ctx_T *)search_ctx_arg; 4993 vim_findfile_free_visited_list(&search_ctx->ffsc_visited_lists_list); 4994 vim_findfile_free_visited_list(&search_ctx->ffsc_dir_visited_lists_list); 4995 } 4996 4997 static void 4998 vim_findfile_free_visited_list(ff_visited_list_hdr_T **list_headp) 4999 { 5000 ff_visited_list_hdr_T *vp; 5001 5002 while (*list_headp != NULL) 5003 { 5004 vp = (*list_headp)->ffvl_next; 5005 ff_free_visited_list((*list_headp)->ffvl_visited_list); 5006 5007 vim_free((*list_headp)->ffvl_filename); 5008 vim_free(*list_headp); 5009 *list_headp = vp; 5010 } 5011 *list_headp = NULL; 5012 } 5013 5014 static void 5015 ff_free_visited_list(ff_visited_T *vl) 5016 { 5017 ff_visited_T *vp; 5018 5019 while (vl != NULL) 5020 { 5021 vp = vl->ffv_next; 5022 #ifdef FEAT_PATH_EXTRA 5023 vim_free(vl->ffv_wc_path); 5024 #endif 5025 vim_free(vl); 5026 vl = vp; 5027 } 5028 vl = NULL; 5029 } 5030 5031 /* 5032 * Returns the already visited list for the given filename. If none is found it 5033 * allocates a new one. 5034 */ 5035 static ff_visited_list_hdr_T* 5036 ff_get_visited_list( 5037 char_u *filename, 5038 ff_visited_list_hdr_T **list_headp) 5039 { 5040 ff_visited_list_hdr_T *retptr = NULL; 5041 5042 /* check if a visited list for the given filename exists */ 5043 if (*list_headp != NULL) 5044 { 5045 retptr = *list_headp; 5046 while (retptr != NULL) 5047 { 5048 if (fnamecmp(filename, retptr->ffvl_filename) == 0) 5049 { 5050 #ifdef FF_VERBOSE 5051 if (p_verbose >= 5) 5052 { 5053 verbose_enter_scroll(); 5054 smsg((char_u *)"ff_get_visited_list: FOUND list for %s", 5055 filename); 5056 /* don't overwrite this either */ 5057 msg_puts((char_u *)"\n"); 5058 verbose_leave_scroll(); 5059 } 5060 #endif 5061 return retptr; 5062 } 5063 retptr = retptr->ffvl_next; 5064 } 5065 } 5066 5067 #ifdef FF_VERBOSE 5068 if (p_verbose >= 5) 5069 { 5070 verbose_enter_scroll(); 5071 smsg((char_u *)"ff_get_visited_list: new list for %s", filename); 5072 /* don't overwrite this either */ 5073 msg_puts((char_u *)"\n"); 5074 verbose_leave_scroll(); 5075 } 5076 #endif 5077 5078 /* 5079 * if we reach this we didn't find a list and we have to allocate new list 5080 */ 5081 retptr = (ff_visited_list_hdr_T*)alloc((unsigned)sizeof(*retptr)); 5082 if (retptr == NULL) 5083 return NULL; 5084 5085 retptr->ffvl_visited_list = NULL; 5086 retptr->ffvl_filename = vim_strsave(filename); 5087 if (retptr->ffvl_filename == NULL) 5088 { 5089 vim_free(retptr); 5090 return NULL; 5091 } 5092 retptr->ffvl_next = *list_headp; 5093 *list_headp = retptr; 5094 5095 return retptr; 5096 } 5097 5098 #ifdef FEAT_PATH_EXTRA 5099 /* 5100 * check if two wildcard paths are equal. Returns TRUE or FALSE. 5101 * They are equal if: 5102 * - both paths are NULL 5103 * - they have the same length 5104 * - char by char comparison is OK 5105 * - the only differences are in the counters behind a '**', so 5106 * '**\20' is equal to '**\24' 5107 */ 5108 static int 5109 ff_wc_equal(char_u *s1, char_u *s2) 5110 { 5111 int i, j; 5112 int c1 = NUL; 5113 int c2 = NUL; 5114 int prev1 = NUL; 5115 int prev2 = NUL; 5116 5117 if (s1 == s2) 5118 return TRUE; 5119 5120 if (s1 == NULL || s2 == NULL) 5121 return FALSE; 5122 5123 for (i = 0, j = 0; s1[i] != NUL && s2[j] != NUL;) 5124 { 5125 c1 = PTR2CHAR(s1 + i); 5126 c2 = PTR2CHAR(s2 + j); 5127 5128 if ((p_fic ? MB_TOLOWER(c1) != MB_TOLOWER(c2) : c1 != c2) 5129 && (prev1 != '*' || prev2 != '*')) 5130 return FALSE; 5131 prev2 = prev1; 5132 prev1 = c1; 5133 5134 i += MB_PTR2LEN(s1 + i); 5135 j += MB_PTR2LEN(s2 + j); 5136 } 5137 return s1[i] == s2[j]; 5138 } 5139 #endif 5140 5141 /* 5142 * maintains the list of already visited files and dirs 5143 * returns FAIL if the given file/dir is already in the list 5144 * returns OK if it is newly added 5145 * 5146 * TODO: What to do on memory allocation problems? 5147 * -> return TRUE - Better the file is found several times instead of 5148 * never. 5149 */ 5150 static int 5151 ff_check_visited( 5152 ff_visited_T **visited_list, 5153 char_u *fname 5154 #ifdef FEAT_PATH_EXTRA 5155 , char_u *wc_path 5156 #endif 5157 ) 5158 { 5159 ff_visited_T *vp; 5160 #ifdef UNIX 5161 stat_T st; 5162 int url = FALSE; 5163 #endif 5164 5165 /* For an URL we only compare the name, otherwise we compare the 5166 * device/inode (unix) or the full path name (not Unix). */ 5167 if (path_with_url(fname)) 5168 { 5169 vim_strncpy(ff_expand_buffer, fname, MAXPATHL - 1); 5170 #ifdef UNIX 5171 url = TRUE; 5172 #endif 5173 } 5174 else 5175 { 5176 ff_expand_buffer[0] = NUL; 5177 #ifdef UNIX 5178 if (mch_stat((char *)fname, &st) < 0) 5179 #else 5180 if (vim_FullName(fname, ff_expand_buffer, MAXPATHL, TRUE) == FAIL) 5181 #endif 5182 return FAIL; 5183 } 5184 5185 /* check against list of already visited files */ 5186 for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) 5187 { 5188 if ( 5189 #ifdef UNIX 5190 !url ? (vp->ffv_dev_valid && vp->ffv_dev == st.st_dev 5191 && vp->ffv_ino == st.st_ino) 5192 : 5193 #endif 5194 fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0 5195 ) 5196 { 5197 #ifdef FEAT_PATH_EXTRA 5198 /* are the wildcard parts equal */ 5199 if (ff_wc_equal(vp->ffv_wc_path, wc_path) == TRUE) 5200 #endif 5201 /* already visited */ 5202 return FAIL; 5203 } 5204 } 5205 5206 /* 5207 * New file/dir. Add it to the list of visited files/dirs. 5208 */ 5209 vp = (ff_visited_T *)alloc((unsigned)(sizeof(ff_visited_T) 5210 + STRLEN(ff_expand_buffer))); 5211 5212 if (vp != NULL) 5213 { 5214 #ifdef UNIX 5215 if (!url) 5216 { 5217 vp->ffv_dev_valid = TRUE; 5218 vp->ffv_ino = st.st_ino; 5219 vp->ffv_dev = st.st_dev; 5220 vp->ffv_fname[0] = NUL; 5221 } 5222 else 5223 { 5224 vp->ffv_dev_valid = FALSE; 5225 #endif 5226 STRCPY(vp->ffv_fname, ff_expand_buffer); 5227 #ifdef UNIX 5228 } 5229 #endif 5230 #ifdef FEAT_PATH_EXTRA 5231 if (wc_path != NULL) 5232 vp->ffv_wc_path = vim_strsave(wc_path); 5233 else 5234 vp->ffv_wc_path = NULL; 5235 #endif 5236 5237 vp->ffv_next = *visited_list; 5238 *visited_list = vp; 5239 } 5240 5241 return OK; 5242 } 5243 5244 /* 5245 * create stack element from given path pieces 5246 */ 5247 static ff_stack_T * 5248 ff_create_stack_element( 5249 char_u *fix_part, 5250 #ifdef FEAT_PATH_EXTRA 5251 char_u *wc_part, 5252 #endif 5253 int level, 5254 int star_star_empty) 5255 { 5256 ff_stack_T *new; 5257 5258 new = (ff_stack_T *)alloc((unsigned)sizeof(ff_stack_T)); 5259 if (new == NULL) 5260 return NULL; 5261 5262 new->ffs_prev = NULL; 5263 new->ffs_filearray = NULL; 5264 new->ffs_filearray_size = 0; 5265 new->ffs_filearray_cur = 0; 5266 new->ffs_stage = 0; 5267 new->ffs_level = level; 5268 new->ffs_star_star_empty = star_star_empty; 5269 5270 /* the following saves NULL pointer checks in vim_findfile */ 5271 if (fix_part == NULL) 5272 fix_part = (char_u *)""; 5273 new->ffs_fix_path = vim_strsave(fix_part); 5274 5275 #ifdef FEAT_PATH_EXTRA 5276 if (wc_part == NULL) 5277 wc_part = (char_u *)""; 5278 new->ffs_wc_path = vim_strsave(wc_part); 5279 #endif 5280 5281 if (new->ffs_fix_path == NULL 5282 #ifdef FEAT_PATH_EXTRA 5283 || new->ffs_wc_path == NULL 5284 #endif 5285 ) 5286 { 5287 ff_free_stack_element(new); 5288 new = NULL; 5289 } 5290 5291 return new; 5292 } 5293 5294 /* 5295 * Push a dir on the directory stack. 5296 */ 5297 static void 5298 ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr) 5299 { 5300 /* check for NULL pointer, not to return an error to the user, but 5301 * to prevent a crash */ 5302 if (stack_ptr != NULL) 5303 { 5304 stack_ptr->ffs_prev = search_ctx->ffsc_stack_ptr; 5305 search_ctx->ffsc_stack_ptr = stack_ptr; 5306 } 5307 } 5308 5309 /* 5310 * Pop a dir from the directory stack. 5311 * Returns NULL if stack is empty. 5312 */ 5313 static ff_stack_T * 5314 ff_pop(ff_search_ctx_T *search_ctx) 5315 { 5316 ff_stack_T *sptr; 5317 5318 sptr = search_ctx->ffsc_stack_ptr; 5319 if (search_ctx->ffsc_stack_ptr != NULL) 5320 search_ctx->ffsc_stack_ptr = search_ctx->ffsc_stack_ptr->ffs_prev; 5321 5322 return sptr; 5323 } 5324 5325 /* 5326 * free the given stack element 5327 */ 5328 static void 5329 ff_free_stack_element(ff_stack_T *stack_ptr) 5330 { 5331 /* vim_free handles possible NULL pointers */ 5332 vim_free(stack_ptr->ffs_fix_path); 5333 #ifdef FEAT_PATH_EXTRA 5334 vim_free(stack_ptr->ffs_wc_path); 5335 #endif 5336 5337 if (stack_ptr->ffs_filearray != NULL) 5338 FreeWild(stack_ptr->ffs_filearray_size, stack_ptr->ffs_filearray); 5339 5340 vim_free(stack_ptr); 5341 } 5342 5343 /* 5344 * Clear the search context, but NOT the visited list. 5345 */ 5346 static void 5347 ff_clear(ff_search_ctx_T *search_ctx) 5348 { 5349 ff_stack_T *sptr; 5350 5351 /* clear up stack */ 5352 while ((sptr = ff_pop(search_ctx)) != NULL) 5353 ff_free_stack_element(sptr); 5354 5355 vim_free(search_ctx->ffsc_file_to_search); 5356 vim_free(search_ctx->ffsc_start_dir); 5357 vim_free(search_ctx->ffsc_fix_path); 5358 #ifdef FEAT_PATH_EXTRA 5359 vim_free(search_ctx->ffsc_wc_path); 5360 #endif 5361 5362 #ifdef FEAT_PATH_EXTRA 5363 if (search_ctx->ffsc_stopdirs_v != NULL) 5364 { 5365 int i = 0; 5366 5367 while (search_ctx->ffsc_stopdirs_v[i] != NULL) 5368 { 5369 vim_free(search_ctx->ffsc_stopdirs_v[i]); 5370 i++; 5371 } 5372 vim_free(search_ctx->ffsc_stopdirs_v); 5373 } 5374 search_ctx->ffsc_stopdirs_v = NULL; 5375 #endif 5376 5377 /* reset everything */ 5378 search_ctx->ffsc_file_to_search = NULL; 5379 search_ctx->ffsc_start_dir = NULL; 5380 search_ctx->ffsc_fix_path = NULL; 5381 #ifdef FEAT_PATH_EXTRA 5382 search_ctx->ffsc_wc_path = NULL; 5383 search_ctx->ffsc_level = 0; 5384 #endif 5385 } 5386 5387 #ifdef FEAT_PATH_EXTRA 5388 /* 5389 * check if the given path is in the stopdirs 5390 * returns TRUE if yes else FALSE 5391 */ 5392 static int 5393 ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v) 5394 { 5395 int i = 0; 5396 5397 /* eat up trailing path separators, except the first */ 5398 while (path_len > 1 && vim_ispathsep(path[path_len - 1])) 5399 path_len--; 5400 5401 /* if no path consider it as match */ 5402 if (path_len == 0) 5403 return TRUE; 5404 5405 for (i = 0; stopdirs_v[i] != NULL; i++) 5406 { 5407 if ((int)STRLEN(stopdirs_v[i]) > path_len) 5408 { 5409 /* match for parent directory. So '/home' also matches 5410 * '/home/rks'. Check for PATHSEP in stopdirs_v[i], else 5411 * '/home/r' would also match '/home/rks' 5412 */ 5413 if (fnamencmp(stopdirs_v[i], path, path_len) == 0 5414 && vim_ispathsep(stopdirs_v[i][path_len])) 5415 return TRUE; 5416 } 5417 else 5418 { 5419 if (fnamecmp(stopdirs_v[i], path) == 0) 5420 return TRUE; 5421 } 5422 } 5423 return FALSE; 5424 } 5425 #endif 5426 5427 #if defined(FEAT_SEARCHPATH) || defined(PROTO) 5428 /* 5429 * Find the file name "ptr[len]" in the path. Also finds directory names. 5430 * 5431 * On the first call set the parameter 'first' to TRUE to initialize 5432 * the search. For repeating calls to FALSE. 5433 * 5434 * Repeating calls will return other files called 'ptr[len]' from the path. 5435 * 5436 * Only on the first call 'ptr' and 'len' are used. For repeating calls they 5437 * don't need valid values. 5438 * 5439 * If nothing found on the first call the option FNAME_MESS will issue the 5440 * message: 5441 * 'Can't find file "<file>" in path' 5442 * On repeating calls: 5443 * 'No more file "<file>" found in path' 5444 * 5445 * options: 5446 * FNAME_MESS give error message when not found 5447 * 5448 * Uses NameBuff[]! 5449 * 5450 * Returns an allocated string for the file name. NULL for error. 5451 * 5452 */ 5453 char_u * 5454 find_file_in_path( 5455 char_u *ptr, /* file name */ 5456 int len, /* length of file name */ 5457 int options, 5458 int first, /* use count'th matching file name */ 5459 char_u *rel_fname) /* file name searching relative to */ 5460 { 5461 return find_file_in_path_option(ptr, len, options, first, 5462 *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path, 5463 FINDFILE_BOTH, rel_fname, curbuf->b_p_sua); 5464 } 5465 5466 static char_u *ff_file_to_find = NULL; 5467 static void *fdip_search_ctx = NULL; 5468 5469 #if defined(EXITFREE) 5470 static void 5471 free_findfile(void) 5472 { 5473 vim_free(ff_file_to_find); 5474 vim_findfile_cleanup(fdip_search_ctx); 5475 } 5476 #endif 5477 5478 /* 5479 * Find the directory name "ptr[len]" in the path. 5480 * 5481 * options: 5482 * FNAME_MESS give error message when not found 5483 * FNAME_UNESC unescape backslashes. 5484 * 5485 * Uses NameBuff[]! 5486 * 5487 * Returns an allocated string for the file name. NULL for error. 5488 */ 5489 char_u * 5490 find_directory_in_path( 5491 char_u *ptr, /* file name */ 5492 int len, /* length of file name */ 5493 int options, 5494 char_u *rel_fname) /* file name searching relative to */ 5495 { 5496 return find_file_in_path_option(ptr, len, options, TRUE, p_cdpath, 5497 FINDFILE_DIR, rel_fname, (char_u *)""); 5498 } 5499 5500 char_u * 5501 find_file_in_path_option( 5502 char_u *ptr, /* file name */ 5503 int len, /* length of file name */ 5504 int options, 5505 int first, /* use count'th matching file name */ 5506 char_u *path_option, /* p_path or p_cdpath */ 5507 int find_what, /* FINDFILE_FILE, _DIR or _BOTH */ 5508 char_u *rel_fname, /* file name we are looking relative to. */ 5509 char_u *suffixes) /* list of suffixes, 'suffixesadd' option */ 5510 { 5511 static char_u *dir; 5512 static int did_findfile_init = FALSE; 5513 char_u save_char; 5514 char_u *file_name = NULL; 5515 char_u *buf = NULL; 5516 int rel_to_curdir; 5517 #ifdef AMIGA 5518 struct Process *proc = (struct Process *)FindTask(0L); 5519 APTR save_winptr = proc->pr_WindowPtr; 5520 5521 /* Avoid a requester here for a volume that doesn't exist. */ 5522 proc->pr_WindowPtr = (APTR)-1L; 5523 #endif 5524 5525 if (first == TRUE) 5526 { 5527 /* copy file name into NameBuff, expanding environment variables */ 5528 save_char = ptr[len]; 5529 ptr[len] = NUL; 5530 expand_env_esc(ptr, NameBuff, MAXPATHL, FALSE, TRUE, NULL); 5531 ptr[len] = save_char; 5532 5533 vim_free(ff_file_to_find); 5534 ff_file_to_find = vim_strsave(NameBuff); 5535 if (ff_file_to_find == NULL) /* out of memory */ 5536 { 5537 file_name = NULL; 5538 goto theend; 5539 } 5540 if (options & FNAME_UNESC) 5541 { 5542 /* Change all "\ " to " ". */ 5543 for (ptr = ff_file_to_find; *ptr != NUL; ++ptr) 5544 if (ptr[0] == '\\' && ptr[1] == ' ') 5545 mch_memmove(ptr, ptr + 1, STRLEN(ptr)); 5546 } 5547 } 5548 5549 rel_to_curdir = (ff_file_to_find[0] == '.' 5550 && (ff_file_to_find[1] == NUL 5551 || vim_ispathsep(ff_file_to_find[1]) 5552 || (ff_file_to_find[1] == '.' 5553 && (ff_file_to_find[2] == NUL 5554 || vim_ispathsep(ff_file_to_find[2]))))); 5555 if (vim_isAbsName(ff_file_to_find) 5556 /* "..", "../path", "." and "./path": don't use the path_option */ 5557 || rel_to_curdir 5558 #if defined(MSWIN) 5559 /* handle "\tmp" as absolute path */ 5560 || vim_ispathsep(ff_file_to_find[0]) 5561 /* handle "c:name" as absolute path */ 5562 || (ff_file_to_find[0] != NUL && ff_file_to_find[1] == ':') 5563 #endif 5564 #ifdef AMIGA 5565 /* handle ":tmp" as absolute path */ 5566 || ff_file_to_find[0] == ':' 5567 #endif 5568 ) 5569 { 5570 /* 5571 * Absolute path, no need to use "path_option". 5572 * If this is not a first call, return NULL. We already returned a 5573 * filename on the first call. 5574 */ 5575 if (first == TRUE) 5576 { 5577 int l; 5578 int run; 5579 5580 if (path_with_url(ff_file_to_find)) 5581 { 5582 file_name = vim_strsave(ff_file_to_find); 5583 goto theend; 5584 } 5585 5586 /* When FNAME_REL flag given first use the directory of the file. 5587 * Otherwise or when this fails use the current directory. */ 5588 for (run = 1; run <= 2; ++run) 5589 { 5590 l = (int)STRLEN(ff_file_to_find); 5591 if (run == 1 5592 && rel_to_curdir 5593 && (options & FNAME_REL) 5594 && rel_fname != NULL 5595 && STRLEN(rel_fname) + l < MAXPATHL) 5596 { 5597 STRCPY(NameBuff, rel_fname); 5598 STRCPY(gettail(NameBuff), ff_file_to_find); 5599 l = (int)STRLEN(NameBuff); 5600 } 5601 else 5602 { 5603 STRCPY(NameBuff, ff_file_to_find); 5604 run = 2; 5605 } 5606 5607 /* When the file doesn't exist, try adding parts of 5608 * 'suffixesadd'. */ 5609 buf = suffixes; 5610 for (;;) 5611 { 5612 if (mch_getperm(NameBuff) >= 0 5613 && (find_what == FINDFILE_BOTH 5614 || ((find_what == FINDFILE_DIR) 5615 == mch_isdir(NameBuff)))) 5616 { 5617 file_name = vim_strsave(NameBuff); 5618 goto theend; 5619 } 5620 if (*buf == NUL) 5621 break; 5622 copy_option_part(&buf, NameBuff + l, MAXPATHL - l, ","); 5623 } 5624 } 5625 } 5626 } 5627 else 5628 { 5629 /* 5630 * Loop over all paths in the 'path' or 'cdpath' option. 5631 * When "first" is set, first setup to the start of the option. 5632 * Otherwise continue to find the next match. 5633 */ 5634 if (first == TRUE) 5635 { 5636 /* vim_findfile_free_visited can handle a possible NULL pointer */ 5637 vim_findfile_free_visited(fdip_search_ctx); 5638 dir = path_option; 5639 did_findfile_init = FALSE; 5640 } 5641 5642 for (;;) 5643 { 5644 if (did_findfile_init) 5645 { 5646 file_name = vim_findfile(fdip_search_ctx); 5647 if (file_name != NULL) 5648 break; 5649 5650 did_findfile_init = FALSE; 5651 } 5652 else 5653 { 5654 char_u *r_ptr; 5655 5656 if (dir == NULL || *dir == NUL) 5657 { 5658 /* We searched all paths of the option, now we can 5659 * free the search context. */ 5660 vim_findfile_cleanup(fdip_search_ctx); 5661 fdip_search_ctx = NULL; 5662 break; 5663 } 5664 5665 if ((buf = alloc((int)(MAXPATHL))) == NULL) 5666 break; 5667 5668 /* copy next path */ 5669 buf[0] = 0; 5670 copy_option_part(&dir, buf, MAXPATHL, " ,"); 5671 5672 #ifdef FEAT_PATH_EXTRA 5673 /* get the stopdir string */ 5674 r_ptr = vim_findfile_stopdir(buf); 5675 #else 5676 r_ptr = NULL; 5677 #endif 5678 fdip_search_ctx = vim_findfile_init(buf, ff_file_to_find, 5679 r_ptr, 100, FALSE, find_what, 5680 fdip_search_ctx, FALSE, rel_fname); 5681 if (fdip_search_ctx != NULL) 5682 did_findfile_init = TRUE; 5683 vim_free(buf); 5684 } 5685 } 5686 } 5687 if (file_name == NULL && (options & FNAME_MESS)) 5688 { 5689 if (first == TRUE) 5690 { 5691 if (find_what == FINDFILE_DIR) 5692 EMSG2(_("E344: Can't find directory \"%s\" in cdpath"), 5693 ff_file_to_find); 5694 else 5695 EMSG2(_("E345: Can't find file \"%s\" in path"), 5696 ff_file_to_find); 5697 } 5698 else 5699 { 5700 if (find_what == FINDFILE_DIR) 5701 EMSG2(_("E346: No more directory \"%s\" found in cdpath"), 5702 ff_file_to_find); 5703 else 5704 EMSG2(_("E347: No more file \"%s\" found in path"), 5705 ff_file_to_find); 5706 } 5707 } 5708 5709 theend: 5710 #ifdef AMIGA 5711 proc->pr_WindowPtr = save_winptr; 5712 #endif 5713 return file_name; 5714 } 5715 5716 #endif /* FEAT_SEARCHPATH */ 5717 5718 /* 5719 * Change directory to "new_dir". If FEAT_SEARCHPATH is defined, search 5720 * 'cdpath' for relative directory names, otherwise just mch_chdir(). 5721 */ 5722 int 5723 vim_chdir(char_u *new_dir) 5724 { 5725 #ifndef FEAT_SEARCHPATH 5726 return mch_chdir((char *)new_dir); 5727 #else 5728 char_u *dir_name; 5729 int r; 5730 5731 dir_name = find_directory_in_path(new_dir, (int)STRLEN(new_dir), 5732 FNAME_MESS, curbuf->b_ffname); 5733 if (dir_name == NULL) 5734 return -1; 5735 r = mch_chdir((char *)dir_name); 5736 vim_free(dir_name); 5737 return r; 5738 #endif 5739 } 5740 5741 /* 5742 * Get user name from machine-specific function. 5743 * Returns the user name in "buf[len]". 5744 * Some systems are quite slow in obtaining the user name (Windows NT), thus 5745 * cache the result. 5746 * Returns OK or FAIL. 5747 */ 5748 int 5749 get_user_name(char_u *buf, int len) 5750 { 5751 if (username == NULL) 5752 { 5753 if (mch_get_user_name(buf, len) == FAIL) 5754 return FAIL; 5755 username = vim_strsave(buf); 5756 } 5757 else 5758 vim_strncpy(buf, username, len - 1); 5759 return OK; 5760 } 5761 5762 #ifndef HAVE_QSORT 5763 /* 5764 * Our own qsort(), for systems that don't have it. 5765 * It's simple and slow. From the K&R C book. 5766 */ 5767 void 5768 qsort( 5769 void *base, 5770 size_t elm_count, 5771 size_t elm_size, 5772 int (*cmp)(const void *, const void *)) 5773 { 5774 char_u *buf; 5775 char_u *p1; 5776 char_u *p2; 5777 int i, j; 5778 int gap; 5779 5780 buf = alloc((unsigned)elm_size); 5781 if (buf == NULL) 5782 return; 5783 5784 for (gap = elm_count / 2; gap > 0; gap /= 2) 5785 for (i = gap; i < elm_count; ++i) 5786 for (j = i - gap; j >= 0; j -= gap) 5787 { 5788 /* Compare the elements. */ 5789 p1 = (char_u *)base + j * elm_size; 5790 p2 = (char_u *)base + (j + gap) * elm_size; 5791 if ((*cmp)((void *)p1, (void *)p2) <= 0) 5792 break; 5793 /* Exchange the elements. */ 5794 mch_memmove(buf, p1, elm_size); 5795 mch_memmove(p1, p2, elm_size); 5796 mch_memmove(p2, buf, elm_size); 5797 } 5798 5799 vim_free(buf); 5800 } 5801 #endif 5802 5803 /* 5804 * Sort an array of strings. 5805 */ 5806 static int 5807 #ifdef __BORLANDC__ 5808 _RTLENTRYF 5809 #endif 5810 sort_compare(const void *s1, const void *s2); 5811 5812 static int 5813 #ifdef __BORLANDC__ 5814 _RTLENTRYF 5815 #endif 5816 sort_compare(const void *s1, const void *s2) 5817 { 5818 return STRCMP(*(char **)s1, *(char **)s2); 5819 } 5820 5821 void 5822 sort_strings( 5823 char_u **files, 5824 int count) 5825 { 5826 qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare); 5827 } 5828 5829 #if !defined(NO_EXPANDPATH) || defined(PROTO) 5830 /* 5831 * Compare path "p[]" to "q[]". 5832 * If "maxlen" >= 0 compare "p[maxlen]" to "q[maxlen]" 5833 * Return value like strcmp(p, q), but consider path separators. 5834 */ 5835 int 5836 pathcmp(const char *p, const char *q, int maxlen) 5837 { 5838 int i, j; 5839 int c1, c2; 5840 const char *s = NULL; 5841 5842 for (i = 0, j = 0; maxlen < 0 || (i < maxlen && j < maxlen);) 5843 { 5844 c1 = PTR2CHAR((char_u *)p + i); 5845 c2 = PTR2CHAR((char_u *)q + j); 5846 5847 /* End of "p": check if "q" also ends or just has a slash. */ 5848 if (c1 == NUL) 5849 { 5850 if (c2 == NUL) /* full match */ 5851 return 0; 5852 s = q; 5853 i = j; 5854 break; 5855 } 5856 5857 /* End of "q": check if "p" just has a slash. */ 5858 if (c2 == NUL) 5859 { 5860 s = p; 5861 break; 5862 } 5863 5864 if ((p_fic ? MB_TOUPPER(c1) != MB_TOUPPER(c2) : c1 != c2) 5865 #ifdef BACKSLASH_IN_FILENAME 5866 /* consider '/' and '\\' to be equal */ 5867 && !((c1 == '/' && c2 == '\\') 5868 || (c1 == '\\' && c2 == '/')) 5869 #endif 5870 ) 5871 { 5872 if (vim_ispathsep(c1)) 5873 return -1; 5874 if (vim_ispathsep(c2)) 5875 return 1; 5876 return p_fic ? MB_TOUPPER(c1) - MB_TOUPPER(c2) 5877 : c1 - c2; /* no match */ 5878 } 5879 5880 i += MB_PTR2LEN((char_u *)p + i); 5881 j += MB_PTR2LEN((char_u *)q + j); 5882 } 5883 if (s == NULL) /* "i" or "j" ran into "maxlen" */ 5884 return 0; 5885 5886 c1 = PTR2CHAR((char_u *)s + i); 5887 c2 = PTR2CHAR((char_u *)s + i + MB_PTR2LEN((char_u *)s + i)); 5888 /* ignore a trailing slash, but not "//" or ":/" */ 5889 if (c2 == NUL 5890 && i > 0 5891 && !after_pathsep((char_u *)s, (char_u *)s + i) 5892 #ifdef BACKSLASH_IN_FILENAME 5893 && (c1 == '/' || c1 == '\\') 5894 #else 5895 && c1 == '/' 5896 #endif 5897 ) 5898 return 0; /* match with trailing slash */ 5899 if (s == q) 5900 return -1; /* no match */ 5901 return 1; 5902 } 5903 #endif 5904 5905 /* 5906 * The putenv() implementation below comes from the "screen" program. 5907 * Included with permission from Juergen Weigert. 5908 * See pty.c for the copyright notice. 5909 */ 5910 5911 /* 5912 * putenv -- put value into environment 5913 * 5914 * Usage: i = putenv (string) 5915 * int i; 5916 * char *string; 5917 * 5918 * where string is of the form <name>=<value>. 5919 * Putenv returns 0 normally, -1 on error (not enough core for malloc). 5920 * 5921 * Putenv may need to add a new name into the environment, or to 5922 * associate a value longer than the current value with a particular 5923 * name. So, to make life simpler, putenv() copies your entire 5924 * environment into the heap (i.e. malloc()) from the stack 5925 * (i.e. where it resides when your process is initiated) the first 5926 * time you call it. 5927 * 5928 * (history removed, not very interesting. See the "screen" sources.) 5929 */ 5930 5931 #if !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) 5932 5933 #define EXTRASIZE 5 /* increment to add to env. size */ 5934 5935 static int envsize = -1; /* current size of environment */ 5936 extern char **environ; /* the global which is your env. */ 5937 5938 static int findenv(char *name); /* look for a name in the env. */ 5939 static int newenv(void); /* copy env. from stack to heap */ 5940 static int moreenv(void); /* incr. size of env. */ 5941 5942 int 5943 putenv(const char *string) 5944 { 5945 int i; 5946 char *p; 5947 5948 if (envsize < 0) 5949 { /* first time putenv called */ 5950 if (newenv() < 0) /* copy env. to heap */ 5951 return -1; 5952 } 5953 5954 i = findenv((char *)string); /* look for name in environment */ 5955 5956 if (i < 0) 5957 { /* name must be added */ 5958 for (i = 0; environ[i]; i++); 5959 if (i >= (envsize - 1)) 5960 { /* need new slot */ 5961 if (moreenv() < 0) 5962 return -1; 5963 } 5964 p = (char *)alloc((unsigned)(strlen(string) + 1)); 5965 if (p == NULL) /* not enough core */ 5966 return -1; 5967 environ[i + 1] = 0; /* new end of env. */ 5968 } 5969 else 5970 { /* name already in env. */ 5971 p = vim_realloc(environ[i], strlen(string) + 1); 5972 if (p == NULL) 5973 return -1; 5974 } 5975 sprintf(p, "%s", string); /* copy into env. */ 5976 environ[i] = p; 5977 5978 return 0; 5979 } 5980 5981 static int 5982 findenv(char *name) 5983 { 5984 char *namechar, *envchar; 5985 int i, found; 5986 5987 found = 0; 5988 for (i = 0; environ[i] && !found; i++) 5989 { 5990 envchar = environ[i]; 5991 namechar = name; 5992 while (*namechar && *namechar != '=' && (*namechar == *envchar)) 5993 { 5994 namechar++; 5995 envchar++; 5996 } 5997 found = ((*namechar == '\0' || *namechar == '=') && *envchar == '='); 5998 } 5999 return found ? i - 1 : -1; 6000 } 6001 6002 static int 6003 newenv(void) 6004 { 6005 char **env, *elem; 6006 int i, esize; 6007 6008 for (i = 0; environ[i]; i++) 6009 ; 6010 6011 esize = i + EXTRASIZE + 1; 6012 env = (char **)alloc((unsigned)(esize * sizeof (elem))); 6013 if (env == NULL) 6014 return -1; 6015 6016 for (i = 0; environ[i]; i++) 6017 { 6018 elem = (char *)alloc((unsigned)(strlen(environ[i]) + 1)); 6019 if (elem == NULL) 6020 return -1; 6021 env[i] = elem; 6022 strcpy(elem, environ[i]); 6023 } 6024 6025 env[i] = 0; 6026 environ = env; 6027 envsize = esize; 6028 return 0; 6029 } 6030 6031 static int 6032 moreenv(void) 6033 { 6034 int esize; 6035 char **env; 6036 6037 esize = envsize + EXTRASIZE; 6038 env = (char **)vim_realloc((char *)environ, esize * sizeof (*env)); 6039 if (env == 0) 6040 return -1; 6041 environ = env; 6042 envsize = esize; 6043 return 0; 6044 } 6045 6046 # ifdef USE_VIMPTY_GETENV 6047 /* 6048 * Used for mch_getenv() for Mac. 6049 */ 6050 char_u * 6051 vimpty_getenv(const char_u *string) 6052 { 6053 int i; 6054 char_u *p; 6055 6056 if (envsize < 0) 6057 return NULL; 6058 6059 i = findenv((char *)string); 6060 6061 if (i < 0) 6062 return NULL; 6063 6064 p = vim_strchr((char_u *)environ[i], '='); 6065 return (p + 1); 6066 } 6067 # endif 6068 6069 #endif /* !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) */ 6070 6071 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO) 6072 /* 6073 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have 6074 * rights to write into. 6075 */ 6076 int 6077 filewritable(char_u *fname) 6078 { 6079 int retval = 0; 6080 #if defined(UNIX) || defined(VMS) 6081 int perm = 0; 6082 #endif 6083 6084 #if defined(UNIX) || defined(VMS) 6085 perm = mch_getperm(fname); 6086 #endif 6087 if ( 6088 # ifdef WIN3264 6089 mch_writable(fname) && 6090 # else 6091 # if defined(UNIX) || defined(VMS) 6092 (perm & 0222) && 6093 # endif 6094 # endif 6095 mch_access((char *)fname, W_OK) == 0 6096 ) 6097 { 6098 ++retval; 6099 if (mch_isdir(fname)) 6100 ++retval; 6101 } 6102 return retval; 6103 } 6104 #endif 6105 6106 #if defined(FEAT_SPELL) || defined(FEAT_PERSISTENT_UNDO) || defined(PROTO) 6107 /* 6108 * Read 2 bytes from "fd" and turn them into an int, MSB first. 6109 */ 6110 int 6111 get2c(FILE *fd) 6112 { 6113 int n; 6114 6115 n = getc(fd); 6116 n = (n << 8) + getc(fd); 6117 return n; 6118 } 6119 6120 /* 6121 * Read 3 bytes from "fd" and turn them into an int, MSB first. 6122 */ 6123 int 6124 get3c(FILE *fd) 6125 { 6126 int n; 6127 6128 n = getc(fd); 6129 n = (n << 8) + getc(fd); 6130 n = (n << 8) + getc(fd); 6131 return n; 6132 } 6133 6134 /* 6135 * Read 4 bytes from "fd" and turn them into an int, MSB first. 6136 */ 6137 int 6138 get4c(FILE *fd) 6139 { 6140 /* Use unsigned rather than int otherwise result is undefined 6141 * when left-shift sets the MSB. */ 6142 unsigned n; 6143 6144 n = (unsigned)getc(fd); 6145 n = (n << 8) + (unsigned)getc(fd); 6146 n = (n << 8) + (unsigned)getc(fd); 6147 n = (n << 8) + (unsigned)getc(fd); 6148 return (int)n; 6149 } 6150 6151 /* 6152 * Read 8 bytes from "fd" and turn them into a time_T, MSB first. 6153 */ 6154 time_T 6155 get8ctime(FILE *fd) 6156 { 6157 time_T n = 0; 6158 int i; 6159 6160 for (i = 0; i < 8; ++i) 6161 n = (n << 8) + getc(fd); 6162 return n; 6163 } 6164 6165 /* 6166 * Read a string of length "cnt" from "fd" into allocated memory. 6167 * Returns NULL when out of memory or unable to read that many bytes. 6168 */ 6169 char_u * 6170 read_string(FILE *fd, int cnt) 6171 { 6172 char_u *str; 6173 int i; 6174 int c; 6175 6176 /* allocate memory */ 6177 str = alloc((unsigned)cnt + 1); 6178 if (str != NULL) 6179 { 6180 /* Read the string. Quit when running into the EOF. */ 6181 for (i = 0; i < cnt; ++i) 6182 { 6183 c = getc(fd); 6184 if (c == EOF) 6185 { 6186 vim_free(str); 6187 return NULL; 6188 } 6189 str[i] = c; 6190 } 6191 str[i] = NUL; 6192 } 6193 return str; 6194 } 6195 6196 /* 6197 * Write a number to file "fd", MSB first, in "len" bytes. 6198 */ 6199 int 6200 put_bytes(FILE *fd, long_u nr, int len) 6201 { 6202 int i; 6203 6204 for (i = len - 1; i >= 0; --i) 6205 if (putc((int)(nr >> (i * 8)), fd) == EOF) 6206 return FAIL; 6207 return OK; 6208 } 6209 6210 #ifdef _MSC_VER 6211 # if (_MSC_VER <= 1200) 6212 /* This line is required for VC6 without the service pack. Also see the 6213 * matching #pragma below. */ 6214 # pragma optimize("", off) 6215 # endif 6216 #endif 6217 6218 /* 6219 * Write time_T to file "fd" in 8 bytes. 6220 * Returns FAIL when the write failed. 6221 */ 6222 int 6223 put_time(FILE *fd, time_T the_time) 6224 { 6225 char_u buf[8]; 6226 6227 time_to_bytes(the_time, buf); 6228 return fwrite(buf, (size_t)8, (size_t)1, fd) == 1 ? OK : FAIL; 6229 } 6230 6231 /* 6232 * Write time_T to "buf[8]". 6233 */ 6234 void 6235 time_to_bytes(time_T the_time, char_u *buf) 6236 { 6237 int c; 6238 int i; 6239 int bi = 0; 6240 time_T wtime = the_time; 6241 6242 /* time_T can be up to 8 bytes in size, more than long_u, thus we 6243 * can't use put_bytes() here. 6244 * Another problem is that ">>" may do an arithmetic shift that keeps the 6245 * sign. This happens for large values of wtime. A cast to long_u may 6246 * truncate if time_T is 8 bytes. So only use a cast when it is 4 bytes, 6247 * it's safe to assume that long_u is 4 bytes or more and when using 8 6248 * bytes the top bit won't be set. */ 6249 for (i = 7; i >= 0; --i) 6250 { 6251 if (i + 1 > (int)sizeof(time_T)) 6252 /* ">>" doesn't work well when shifting more bits than avail */ 6253 buf[bi++] = 0; 6254 else 6255 { 6256 #if defined(SIZEOF_TIME_T) && SIZEOF_TIME_T > 4 6257 c = (int)(wtime >> (i * 8)); 6258 #else 6259 c = (int)((long_u)wtime >> (i * 8)); 6260 #endif 6261 buf[bi++] = c; 6262 } 6263 } 6264 } 6265 6266 #ifdef _MSC_VER 6267 # if (_MSC_VER <= 1200) 6268 # pragma optimize("", on) 6269 # endif 6270 #endif 6271 6272 #endif 6273 6274 #if (defined(FEAT_MBYTE) && defined(FEAT_QUICKFIX)) \ 6275 || defined(FEAT_SPELL) || defined(PROTO) 6276 /* 6277 * Return TRUE if string "s" contains a non-ASCII character (128 or higher). 6278 * When "s" is NULL FALSE is returned. 6279 */ 6280 int 6281 has_non_ascii(char_u *s) 6282 { 6283 char_u *p; 6284 6285 if (s != NULL) 6286 for (p = s; *p != NUL; ++p) 6287 if (*p >= 128) 6288 return TRUE; 6289 return FALSE; 6290 } 6291 #endif 6292 6293 #if defined(MESSAGE_QUEUE) || defined(PROTO) 6294 /* 6295 * Process messages that have been queued for netbeans or clientserver. 6296 * Also check if any jobs have ended. 6297 * These functions can call arbitrary vimscript and should only be called when 6298 * it is safe to do so. 6299 */ 6300 void 6301 parse_queued_messages(void) 6302 { 6303 /* For Win32 mch_breakcheck() does not check for input, do it here. */ 6304 # if defined(WIN32) && defined(FEAT_JOB_CHANNEL) 6305 channel_handle_events(FALSE); 6306 # endif 6307 6308 # ifdef FEAT_NETBEANS_INTG 6309 /* Process the queued netbeans messages. */ 6310 netbeans_parse_messages(); 6311 # endif 6312 # ifdef FEAT_JOB_CHANNEL 6313 /* Write any buffer lines still to be written. */ 6314 channel_write_any_lines(); 6315 6316 /* Process the messages queued on channels. */ 6317 channel_parse_messages(); 6318 # endif 6319 # if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11) 6320 /* Process the queued clientserver messages. */ 6321 server_parse_messages(); 6322 # endif 6323 # ifdef FEAT_JOB_CHANNEL 6324 /* Check if any jobs have ended. */ 6325 job_check_ended(); 6326 # endif 6327 } 6328 #endif 6329 6330 #ifndef PROTO /* proto is defined in vim.h */ 6331 # ifdef ELAPSED_TIMEVAL 6332 /* 6333 * Return time in msec since "start_tv". 6334 */ 6335 long 6336 elapsed(struct timeval *start_tv) 6337 { 6338 struct timeval now_tv; 6339 6340 gettimeofday(&now_tv, NULL); 6341 return (now_tv.tv_sec - start_tv->tv_sec) * 1000L 6342 + (now_tv.tv_usec - start_tv->tv_usec) / 1000L; 6343 } 6344 # endif 6345 6346 # ifdef ELAPSED_TICKCOUNT 6347 /* 6348 * Return time in msec since "start_tick". 6349 */ 6350 long 6351 elapsed(DWORD start_tick) 6352 { 6353 DWORD now = GetTickCount(); 6354 6355 return (long)now - (long)start_tick; 6356 } 6357 # endif 6358 #endif 6359