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_MOUSEMOVE, (char_u *)"MouseMove"}, 2457 {K_MIDDLEMOUSE, (char_u *)"MiddleMouse"}, 2458 {K_MIDDLEDRAG, (char_u *)"MiddleDrag"}, 2459 {K_MIDDLERELEASE, (char_u *)"MiddleRelease"}, 2460 {K_RIGHTMOUSE, (char_u *)"RightMouse"}, 2461 {K_RIGHTDRAG, (char_u *)"RightDrag"}, 2462 {K_RIGHTRELEASE, (char_u *)"RightRelease"}, 2463 {K_MOUSEDOWN, (char_u *)"ScrollWheelUp"}, 2464 {K_MOUSEUP, (char_u *)"ScrollWheelDown"}, 2465 {K_MOUSELEFT, (char_u *)"ScrollWheelRight"}, 2466 {K_MOUSERIGHT, (char_u *)"ScrollWheelLeft"}, 2467 {K_MOUSEDOWN, (char_u *)"MouseDown"}, /* OBSOLETE: Use */ 2468 {K_MOUSEUP, (char_u *)"MouseUp"}, /* ScrollWheelXXX instead */ 2469 {K_X1MOUSE, (char_u *)"X1Mouse"}, 2470 {K_X1DRAG, (char_u *)"X1Drag"}, 2471 {K_X1RELEASE, (char_u *)"X1Release"}, 2472 {K_X2MOUSE, (char_u *)"X2Mouse"}, 2473 {K_X2DRAG, (char_u *)"X2Drag"}, 2474 {K_X2RELEASE, (char_u *)"X2Release"}, 2475 {K_DROP, (char_u *)"Drop"}, 2476 {K_ZERO, (char_u *)"Nul"}, 2477 #ifdef FEAT_EVAL 2478 {K_SNR, (char_u *)"SNR"}, 2479 #endif 2480 {K_PLUG, (char_u *)"Plug"}, 2481 {K_CURSORHOLD, (char_u *)"CursorHold"}, 2482 {0, NULL} 2483 /* NOTE: When adding a long name update MAX_KEY_NAME_LEN. */ 2484 }; 2485 2486 #define KEY_NAMES_TABLE_LEN (sizeof(key_names_table) / sizeof(struct key_name_entry)) 2487 2488 #ifdef FEAT_MOUSE 2489 static struct mousetable 2490 { 2491 int pseudo_code; /* Code for pseudo mouse event */ 2492 int button; /* Which mouse button is it? */ 2493 int is_click; /* Is it a mouse button click event? */ 2494 int is_drag; /* Is it a mouse drag event? */ 2495 } mouse_table[] = 2496 { 2497 {(int)KE_LEFTMOUSE, MOUSE_LEFT, TRUE, FALSE}, 2498 #ifdef FEAT_GUI 2499 {(int)KE_LEFTMOUSE_NM, MOUSE_LEFT, TRUE, FALSE}, 2500 #endif 2501 {(int)KE_LEFTDRAG, MOUSE_LEFT, FALSE, TRUE}, 2502 {(int)KE_LEFTRELEASE, MOUSE_LEFT, FALSE, FALSE}, 2503 #ifdef FEAT_GUI 2504 {(int)KE_LEFTRELEASE_NM, MOUSE_LEFT, FALSE, FALSE}, 2505 #endif 2506 {(int)KE_MIDDLEMOUSE, MOUSE_MIDDLE, TRUE, FALSE}, 2507 {(int)KE_MIDDLEDRAG, MOUSE_MIDDLE, FALSE, TRUE}, 2508 {(int)KE_MIDDLERELEASE, MOUSE_MIDDLE, FALSE, FALSE}, 2509 {(int)KE_RIGHTMOUSE, MOUSE_RIGHT, TRUE, FALSE}, 2510 {(int)KE_RIGHTDRAG, MOUSE_RIGHT, FALSE, TRUE}, 2511 {(int)KE_RIGHTRELEASE, MOUSE_RIGHT, FALSE, FALSE}, 2512 {(int)KE_X1MOUSE, MOUSE_X1, TRUE, FALSE}, 2513 {(int)KE_X1DRAG, MOUSE_X1, FALSE, TRUE}, 2514 {(int)KE_X1RELEASE, MOUSE_X1, FALSE, FALSE}, 2515 {(int)KE_X2MOUSE, MOUSE_X2, TRUE, FALSE}, 2516 {(int)KE_X2DRAG, MOUSE_X2, FALSE, TRUE}, 2517 {(int)KE_X2RELEASE, MOUSE_X2, FALSE, FALSE}, 2518 /* DRAG without CLICK */ 2519 {(int)KE_MOUSEMOVE, MOUSE_RELEASE, FALSE, TRUE}, 2520 /* RELEASE without CLICK */ 2521 {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, FALSE}, 2522 {0, 0, 0, 0}, 2523 }; 2524 #endif /* FEAT_MOUSE */ 2525 2526 /* 2527 * Return the modifier mask bit (MOD_MASK_*) which corresponds to the given 2528 * modifier name ('S' for Shift, 'C' for Ctrl etc). 2529 */ 2530 int 2531 name_to_mod_mask(int c) 2532 { 2533 int i; 2534 2535 c = TOUPPER_ASC(c); 2536 for (i = 0; mod_mask_table[i].mod_mask != 0; i++) 2537 if (c == mod_mask_table[i].name) 2538 return mod_mask_table[i].mod_flag; 2539 return 0; 2540 } 2541 2542 /* 2543 * Check if if there is a special key code for "key" that includes the 2544 * modifiers specified. 2545 */ 2546 int 2547 simplify_key(int key, int *modifiers) 2548 { 2549 int i; 2550 int key0; 2551 int key1; 2552 2553 if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) 2554 { 2555 /* TAB is a special case */ 2556 if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) 2557 { 2558 *modifiers &= ~MOD_MASK_SHIFT; 2559 return K_S_TAB; 2560 } 2561 key0 = KEY2TERMCAP0(key); 2562 key1 = KEY2TERMCAP1(key); 2563 for (i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) 2564 if (key0 == modifier_keys_table[i + 3] 2565 && key1 == modifier_keys_table[i + 4] 2566 && (*modifiers & modifier_keys_table[i])) 2567 { 2568 *modifiers &= ~modifier_keys_table[i]; 2569 return TERMCAP2KEY(modifier_keys_table[i + 1], 2570 modifier_keys_table[i + 2]); 2571 } 2572 } 2573 return key; 2574 } 2575 2576 /* 2577 * Change <xHome> to <Home>, <xUp> to <Up>, etc. 2578 */ 2579 int 2580 handle_x_keys(int key) 2581 { 2582 switch (key) 2583 { 2584 case K_XUP: return K_UP; 2585 case K_XDOWN: return K_DOWN; 2586 case K_XLEFT: return K_LEFT; 2587 case K_XRIGHT: return K_RIGHT; 2588 case K_XHOME: return K_HOME; 2589 case K_ZHOME: return K_HOME; 2590 case K_XEND: return K_END; 2591 case K_ZEND: return K_END; 2592 case K_XF1: return K_F1; 2593 case K_XF2: return K_F2; 2594 case K_XF3: return K_F3; 2595 case K_XF4: return K_F4; 2596 case K_S_XF1: return K_S_F1; 2597 case K_S_XF2: return K_S_F2; 2598 case K_S_XF3: return K_S_F3; 2599 case K_S_XF4: return K_S_F4; 2600 } 2601 return key; 2602 } 2603 2604 /* 2605 * Return a string which contains the name of the given key when the given 2606 * modifiers are down. 2607 */ 2608 char_u * 2609 get_special_key_name(int c, int modifiers) 2610 { 2611 static char_u string[MAX_KEY_NAME_LEN + 1]; 2612 2613 int i, idx; 2614 int table_idx; 2615 char_u *s; 2616 2617 string[0] = '<'; 2618 idx = 1; 2619 2620 /* Key that stands for a normal character. */ 2621 if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY) 2622 c = KEY2TERMCAP1(c); 2623 2624 /* 2625 * Translate shifted special keys into unshifted keys and set modifier. 2626 * Same for CTRL and ALT modifiers. 2627 */ 2628 if (IS_SPECIAL(c)) 2629 { 2630 for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE) 2631 if ( KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1] 2632 && (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) 2633 { 2634 modifiers |= modifier_keys_table[i]; 2635 c = TERMCAP2KEY(modifier_keys_table[i + 3], 2636 modifier_keys_table[i + 4]); 2637 break; 2638 } 2639 } 2640 2641 /* try to find the key in the special key table */ 2642 table_idx = find_special_key_in_table(c); 2643 2644 /* 2645 * When not a known special key, and not a printable character, try to 2646 * extract modifiers. 2647 */ 2648 if (c > 0 2649 #ifdef FEAT_MBYTE 2650 && (*mb_char2len)(c) == 1 2651 #endif 2652 ) 2653 { 2654 if (table_idx < 0 2655 && (!vim_isprintc(c) || (c & 0x7f) == ' ') 2656 && (c & 0x80)) 2657 { 2658 c &= 0x7f; 2659 modifiers |= MOD_MASK_ALT; 2660 /* try again, to find the un-alted key in the special key table */ 2661 table_idx = find_special_key_in_table(c); 2662 } 2663 if (table_idx < 0 && !vim_isprintc(c) && c < ' ') 2664 { 2665 #ifdef EBCDIC 2666 c = CtrlChar(c); 2667 #else 2668 c += '@'; 2669 #endif 2670 modifiers |= MOD_MASK_CTRL; 2671 } 2672 } 2673 2674 /* translate the modifier into a string */ 2675 for (i = 0; mod_mask_table[i].name != 'A'; i++) 2676 if ((modifiers & mod_mask_table[i].mod_mask) 2677 == mod_mask_table[i].mod_flag) 2678 { 2679 string[idx++] = mod_mask_table[i].name; 2680 string[idx++] = (char_u)'-'; 2681 } 2682 2683 if (table_idx < 0) /* unknown special key, may output t_xx */ 2684 { 2685 if (IS_SPECIAL(c)) 2686 { 2687 string[idx++] = 't'; 2688 string[idx++] = '_'; 2689 string[idx++] = KEY2TERMCAP0(c); 2690 string[idx++] = KEY2TERMCAP1(c); 2691 } 2692 /* Not a special key, only modifiers, output directly */ 2693 else 2694 { 2695 #ifdef FEAT_MBYTE 2696 if (has_mbyte && (*mb_char2len)(c) > 1) 2697 idx += (*mb_char2bytes)(c, string + idx); 2698 else 2699 #endif 2700 if (vim_isprintc(c)) 2701 string[idx++] = c; 2702 else 2703 { 2704 s = transchar(c); 2705 while (*s) 2706 string[idx++] = *s++; 2707 } 2708 } 2709 } 2710 else /* use name of special key */ 2711 { 2712 size_t len = STRLEN(key_names_table[table_idx].name); 2713 2714 if (len + idx + 2 <= MAX_KEY_NAME_LEN) 2715 { 2716 STRCPY(string + idx, key_names_table[table_idx].name); 2717 idx += (int)len; 2718 } 2719 } 2720 string[idx++] = '>'; 2721 string[idx] = NUL; 2722 return string; 2723 } 2724 2725 /* 2726 * Try translating a <> name at (*srcp)[] to dst[]. 2727 * Return the number of characters added to dst[], zero for no match. 2728 * If there is a match, srcp is advanced to after the <> name. 2729 * dst[] must be big enough to hold the result (up to six characters)! 2730 */ 2731 int 2732 trans_special( 2733 char_u **srcp, 2734 char_u *dst, 2735 int keycode, /* prefer key code, e.g. K_DEL instead of DEL */ 2736 int in_string) /* TRUE when inside a double quoted string */ 2737 { 2738 int modifiers = 0; 2739 int key; 2740 int dlen = 0; 2741 2742 key = find_special_key(srcp, &modifiers, keycode, FALSE, in_string); 2743 if (key == 0) 2744 return 0; 2745 2746 /* Put the appropriate modifier in a string */ 2747 if (modifiers != 0) 2748 { 2749 dst[dlen++] = K_SPECIAL; 2750 dst[dlen++] = KS_MODIFIER; 2751 dst[dlen++] = modifiers; 2752 } 2753 2754 if (IS_SPECIAL(key)) 2755 { 2756 dst[dlen++] = K_SPECIAL; 2757 dst[dlen++] = KEY2TERMCAP0(key); 2758 dst[dlen++] = KEY2TERMCAP1(key); 2759 } 2760 #ifdef FEAT_MBYTE 2761 else if (has_mbyte && !keycode) 2762 dlen += (*mb_char2bytes)(key, dst + dlen); 2763 #endif 2764 else if (keycode) 2765 dlen = (int)(add_char2buf(key, dst + dlen) - dst); 2766 else 2767 dst[dlen++] = key; 2768 2769 return dlen; 2770 } 2771 2772 /* 2773 * Try translating a <> name at (*srcp)[], return the key and modifiers. 2774 * srcp is advanced to after the <> name. 2775 * returns 0 if there is no match. 2776 */ 2777 int 2778 find_special_key( 2779 char_u **srcp, 2780 int *modp, 2781 int keycode, /* prefer key code, e.g. K_DEL instead of DEL */ 2782 int keep_x_key, /* don't translate xHome to Home key */ 2783 int in_string) /* TRUE in string, double quote is escaped */ 2784 { 2785 char_u *last_dash; 2786 char_u *end_of_name; 2787 char_u *src; 2788 char_u *bp; 2789 int modifiers; 2790 int bit; 2791 int key; 2792 uvarnumber_T n; 2793 int l; 2794 2795 src = *srcp; 2796 if (src[0] != '<') 2797 return 0; 2798 2799 /* Find end of modifier list */ 2800 last_dash = src; 2801 for (bp = src + 1; *bp == '-' || vim_isIDc(*bp); bp++) 2802 { 2803 if (*bp == '-') 2804 { 2805 last_dash = bp; 2806 if (bp[1] != NUL) 2807 { 2808 #ifdef FEAT_MBYTE 2809 if (has_mbyte) 2810 l = mb_ptr2len(bp + 1); 2811 else 2812 #endif 2813 l = 1; 2814 /* Anything accepted, like <C-?>. 2815 * <C-"> or <M-"> are not special in strings as " is 2816 * the string delimiter. With a backslash it works: <M-\"> */ 2817 if (!(in_string && bp[1] == '"') && bp[2] == '>') 2818 bp += l; 2819 else if (in_string && bp[1] == '\\' && bp[2] == '"' 2820 && bp[3] == '>') 2821 bp += 2; 2822 } 2823 } 2824 if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3]) 2825 bp += 3; /* skip t_xx, xx may be '-' or '>' */ 2826 else if (STRNICMP(bp, "char-", 5) == 0) 2827 { 2828 vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0); 2829 bp += l + 5; 2830 break; 2831 } 2832 } 2833 2834 if (*bp == '>') /* found matching '>' */ 2835 { 2836 end_of_name = bp + 1; 2837 2838 /* Which modifiers are given? */ 2839 modifiers = 0x0; 2840 for (bp = src + 1; bp < last_dash; bp++) 2841 { 2842 if (*bp != '-') 2843 { 2844 bit = name_to_mod_mask(*bp); 2845 if (bit == 0x0) 2846 break; /* Illegal modifier name */ 2847 modifiers |= bit; 2848 } 2849 } 2850 2851 /* 2852 * Legal modifier name. 2853 */ 2854 if (bp >= last_dash) 2855 { 2856 if (STRNICMP(last_dash + 1, "char-", 5) == 0 2857 && VIM_ISDIGIT(last_dash[6])) 2858 { 2859 /* <Char-123> or <Char-033> or <Char-0x33> */ 2860 vim_str2nr(last_dash + 6, NULL, NULL, STR2NR_ALL, NULL, &n, 0); 2861 key = (int)n; 2862 } 2863 else 2864 { 2865 int off = 1; 2866 2867 /* Modifier with single letter, or special key name. */ 2868 if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') 2869 off = 2; 2870 #ifdef FEAT_MBYTE 2871 if (has_mbyte) 2872 l = mb_ptr2len(last_dash + off); 2873 else 2874 #endif 2875 l = 1; 2876 if (modifiers != 0 && last_dash[l + off] == '>') 2877 key = PTR2CHAR(last_dash + off); 2878 else 2879 { 2880 key = get_special_key_code(last_dash + off); 2881 if (!keep_x_key) 2882 key = handle_x_keys(key); 2883 } 2884 } 2885 2886 /* 2887 * get_special_key_code() may return NUL for invalid 2888 * special key name. 2889 */ 2890 if (key != NUL) 2891 { 2892 /* 2893 * Only use a modifier when there is no special key code that 2894 * includes the modifier. 2895 */ 2896 key = simplify_key(key, &modifiers); 2897 2898 if (!keycode) 2899 { 2900 /* don't want keycode, use single byte code */ 2901 if (key == K_BS) 2902 key = BS; 2903 else if (key == K_DEL || key == K_KDEL) 2904 key = DEL; 2905 } 2906 2907 /* 2908 * Normal Key with modifier: Try to make a single byte code. 2909 */ 2910 if (!IS_SPECIAL(key)) 2911 key = extract_modifiers(key, &modifiers); 2912 2913 *modp = modifiers; 2914 *srcp = end_of_name; 2915 return key; 2916 } 2917 } 2918 } 2919 return 0; 2920 } 2921 2922 /* 2923 * Try to include modifiers in the key. 2924 * Changes "Shift-a" to 'A', "Alt-A" to 0xc0, etc. 2925 */ 2926 int 2927 extract_modifiers(int key, int *modp) 2928 { 2929 int modifiers = *modp; 2930 2931 #ifdef MACOS_X 2932 /* Command-key really special, no fancynest */ 2933 if (!(modifiers & MOD_MASK_CMD)) 2934 #endif 2935 if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) 2936 { 2937 key = TOUPPER_ASC(key); 2938 modifiers &= ~MOD_MASK_SHIFT; 2939 } 2940 if ((modifiers & MOD_MASK_CTRL) 2941 #ifdef EBCDIC 2942 /* * TODO: EBCDIC Better use: 2943 * && (Ctrl_chr(key) || key == '?') 2944 * ??? */ 2945 && strchr("?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_", key) 2946 != NULL 2947 #else 2948 && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key)) 2949 #endif 2950 ) 2951 { 2952 key = Ctrl_chr(key); 2953 modifiers &= ~MOD_MASK_CTRL; 2954 /* <C-@> is <Nul> */ 2955 if (key == 0) 2956 key = K_ZERO; 2957 } 2958 #ifdef MACOS_X 2959 /* Command-key really special, no fancynest */ 2960 if (!(modifiers & MOD_MASK_CMD)) 2961 #endif 2962 if ((modifiers & MOD_MASK_ALT) && key < 0x80 2963 #ifdef FEAT_MBYTE 2964 && !enc_dbcs /* avoid creating a lead byte */ 2965 #endif 2966 ) 2967 { 2968 key |= 0x80; 2969 modifiers &= ~MOD_MASK_ALT; /* remove the META modifier */ 2970 } 2971 2972 *modp = modifiers; 2973 return key; 2974 } 2975 2976 /* 2977 * Try to find key "c" in the special key table. 2978 * Return the index when found, -1 when not found. 2979 */ 2980 int 2981 find_special_key_in_table(int c) 2982 { 2983 int i; 2984 2985 for (i = 0; key_names_table[i].name != NULL; i++) 2986 if (c == key_names_table[i].key) 2987 break; 2988 if (key_names_table[i].name == NULL) 2989 i = -1; 2990 return i; 2991 } 2992 2993 /* 2994 * Find the special key with the given name (the given string does not have to 2995 * end with NUL, the name is assumed to end before the first non-idchar). 2996 * If the name starts with "t_" the next two characters are interpreted as a 2997 * termcap name. 2998 * Return the key code, or 0 if not found. 2999 */ 3000 int 3001 get_special_key_code(char_u *name) 3002 { 3003 char_u *table_name; 3004 char_u string[3]; 3005 int i, j; 3006 3007 /* 3008 * If it's <t_xx> we get the code for xx from the termcap 3009 */ 3010 if (name[0] == 't' && name[1] == '_' && name[2] != NUL && name[3] != NUL) 3011 { 3012 string[0] = name[2]; 3013 string[1] = name[3]; 3014 string[2] = NUL; 3015 if (add_termcap_entry(string, FALSE) == OK) 3016 return TERMCAP2KEY(name[2], name[3]); 3017 } 3018 else 3019 for (i = 0; key_names_table[i].name != NULL; i++) 3020 { 3021 table_name = key_names_table[i].name; 3022 for (j = 0; vim_isIDc(name[j]) && table_name[j] != NUL; j++) 3023 if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) 3024 break; 3025 if (!vim_isIDc(name[j]) && table_name[j] == NUL) 3026 return key_names_table[i].key; 3027 } 3028 return 0; 3029 } 3030 3031 #if defined(FEAT_CMDL_COMPL) || defined(PROTO) 3032 char_u * 3033 get_key_name(int i) 3034 { 3035 if (i >= (int)KEY_NAMES_TABLE_LEN) 3036 return NULL; 3037 return key_names_table[i].name; 3038 } 3039 #endif 3040 3041 #if defined(FEAT_MOUSE) || defined(PROTO) 3042 /* 3043 * Look up the given mouse code to return the relevant information in the other 3044 * arguments. Return which button is down or was released. 3045 */ 3046 int 3047 get_mouse_button(int code, int *is_click, int *is_drag) 3048 { 3049 int i; 3050 3051 for (i = 0; mouse_table[i].pseudo_code; i++) 3052 if (code == mouse_table[i].pseudo_code) 3053 { 3054 *is_click = mouse_table[i].is_click; 3055 *is_drag = mouse_table[i].is_drag; 3056 return mouse_table[i].button; 3057 } 3058 return 0; /* Shouldn't get here */ 3059 } 3060 3061 /* 3062 * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on 3063 * the given information about which mouse button is down, and whether the 3064 * mouse was clicked, dragged or released. 3065 */ 3066 int 3067 get_pseudo_mouse_code( 3068 int button, /* eg MOUSE_LEFT */ 3069 int is_click, 3070 int is_drag) 3071 { 3072 int i; 3073 3074 for (i = 0; mouse_table[i].pseudo_code; i++) 3075 if (button == mouse_table[i].button 3076 && is_click == mouse_table[i].is_click 3077 && is_drag == mouse_table[i].is_drag) 3078 { 3079 #ifdef FEAT_GUI 3080 /* Trick: a non mappable left click and release has mouse_col -1 3081 * or added MOUSE_COLOFF. Used for 'mousefocus' in 3082 * gui_mouse_moved() */ 3083 if (mouse_col < 0 || mouse_col > MOUSE_COLOFF) 3084 { 3085 if (mouse_col < 0) 3086 mouse_col = 0; 3087 else 3088 mouse_col -= MOUSE_COLOFF; 3089 if (mouse_table[i].pseudo_code == (int)KE_LEFTMOUSE) 3090 return (int)KE_LEFTMOUSE_NM; 3091 if (mouse_table[i].pseudo_code == (int)KE_LEFTRELEASE) 3092 return (int)KE_LEFTRELEASE_NM; 3093 } 3094 #endif 3095 return mouse_table[i].pseudo_code; 3096 } 3097 return (int)KE_IGNORE; /* not recognized, ignore it */ 3098 } 3099 #endif /* FEAT_MOUSE */ 3100 3101 /* 3102 * Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC. 3103 */ 3104 int 3105 get_fileformat(buf_T *buf) 3106 { 3107 int c = *buf->b_p_ff; 3108 3109 if (buf->b_p_bin || c == 'u') 3110 return EOL_UNIX; 3111 if (c == 'm') 3112 return EOL_MAC; 3113 return EOL_DOS; 3114 } 3115 3116 /* 3117 * Like get_fileformat(), but override 'fileformat' with "p" for "++opt=val" 3118 * argument. 3119 */ 3120 int 3121 get_fileformat_force( 3122 buf_T *buf, 3123 exarg_T *eap) /* can be NULL! */ 3124 { 3125 int c; 3126 3127 if (eap != NULL && eap->force_ff != 0) 3128 c = eap->cmd[eap->force_ff]; 3129 else 3130 { 3131 if ((eap != NULL && eap->force_bin != 0) 3132 ? (eap->force_bin == FORCE_BIN) : buf->b_p_bin) 3133 return EOL_UNIX; 3134 c = *buf->b_p_ff; 3135 } 3136 if (c == 'u') 3137 return EOL_UNIX; 3138 if (c == 'm') 3139 return EOL_MAC; 3140 return EOL_DOS; 3141 } 3142 3143 /* 3144 * Set the current end-of-line type to EOL_DOS, EOL_UNIX or EOL_MAC. 3145 * Sets both 'textmode' and 'fileformat'. 3146 * Note: Does _not_ set global value of 'textmode'! 3147 */ 3148 void 3149 set_fileformat( 3150 int t, 3151 int opt_flags) /* OPT_LOCAL and/or OPT_GLOBAL */ 3152 { 3153 char *p = NULL; 3154 3155 switch (t) 3156 { 3157 case EOL_DOS: 3158 p = FF_DOS; 3159 curbuf->b_p_tx = TRUE; 3160 break; 3161 case EOL_UNIX: 3162 p = FF_UNIX; 3163 curbuf->b_p_tx = FALSE; 3164 break; 3165 case EOL_MAC: 3166 p = FF_MAC; 3167 curbuf->b_p_tx = FALSE; 3168 break; 3169 } 3170 if (p != NULL) 3171 set_string_option_direct((char_u *)"ff", -1, (char_u *)p, 3172 OPT_FREE | opt_flags, 0); 3173 3174 /* This may cause the buffer to become (un)modified. */ 3175 check_status(curbuf); 3176 redraw_tabline = TRUE; 3177 #ifdef FEAT_TITLE 3178 need_maketitle = TRUE; /* set window title later */ 3179 #endif 3180 } 3181 3182 /* 3183 * Return the default fileformat from 'fileformats'. 3184 */ 3185 int 3186 default_fileformat(void) 3187 { 3188 switch (*p_ffs) 3189 { 3190 case 'm': return EOL_MAC; 3191 case 'd': return EOL_DOS; 3192 } 3193 return EOL_UNIX; 3194 } 3195 3196 /* 3197 * Call shell. Calls mch_call_shell, with 'shellxquote' added. 3198 */ 3199 int 3200 call_shell(char_u *cmd, int opt) 3201 { 3202 char_u *ncmd; 3203 int retval; 3204 #ifdef FEAT_PROFILE 3205 proftime_T wait_time; 3206 #endif 3207 3208 if (p_verbose > 3) 3209 { 3210 verbose_enter(); 3211 smsg((char_u *)_("Calling shell to execute: \"%s\""), 3212 cmd == NULL ? p_sh : cmd); 3213 out_char('\n'); 3214 cursor_on(); 3215 verbose_leave(); 3216 } 3217 3218 #ifdef FEAT_PROFILE 3219 if (do_profiling == PROF_YES) 3220 prof_child_enter(&wait_time); 3221 #endif 3222 3223 if (*p_sh == NUL) 3224 { 3225 EMSG(_(e_shellempty)); 3226 retval = -1; 3227 } 3228 else 3229 { 3230 #ifdef FEAT_GUI_MSWIN 3231 /* Don't hide the pointer while executing a shell command. */ 3232 gui_mch_mousehide(FALSE); 3233 #endif 3234 #ifdef FEAT_GUI 3235 ++hold_gui_events; 3236 #endif 3237 /* The external command may update a tags file, clear cached tags. */ 3238 tag_freematch(); 3239 3240 if (cmd == NULL || *p_sxq == NUL) 3241 retval = mch_call_shell(cmd, opt); 3242 else 3243 { 3244 char_u *ecmd = cmd; 3245 3246 if (*p_sxe != NUL && STRCMP(p_sxq, "(") == 0) 3247 { 3248 ecmd = vim_strsave_escaped_ext(cmd, p_sxe, '^', FALSE); 3249 if (ecmd == NULL) 3250 ecmd = cmd; 3251 } 3252 ncmd = alloc((unsigned)(STRLEN(ecmd) + STRLEN(p_sxq) * 2 + 1)); 3253 if (ncmd != NULL) 3254 { 3255 STRCPY(ncmd, p_sxq); 3256 STRCAT(ncmd, ecmd); 3257 /* When 'shellxquote' is ( append ). 3258 * When 'shellxquote' is "( append )". */ 3259 STRCAT(ncmd, STRCMP(p_sxq, "(") == 0 ? (char_u *)")" 3260 : STRCMP(p_sxq, "\"(") == 0 ? (char_u *)")\"" 3261 : p_sxq); 3262 retval = mch_call_shell(ncmd, opt); 3263 vim_free(ncmd); 3264 } 3265 else 3266 retval = -1; 3267 if (ecmd != cmd) 3268 vim_free(ecmd); 3269 } 3270 #ifdef FEAT_GUI 3271 --hold_gui_events; 3272 #endif 3273 /* 3274 * Check the window size, in case it changed while executing the 3275 * external command. 3276 */ 3277 shell_resized_check(); 3278 } 3279 3280 #ifdef FEAT_EVAL 3281 set_vim_var_nr(VV_SHELL_ERROR, (long)retval); 3282 # ifdef FEAT_PROFILE 3283 if (do_profiling == PROF_YES) 3284 prof_child_exit(&wait_time); 3285 # endif 3286 #endif 3287 3288 return retval; 3289 } 3290 3291 /* 3292 * VISUAL, SELECTMODE and OP_PENDING State are never set, they are equal to 3293 * NORMAL State with a condition. This function returns the real State. 3294 */ 3295 int 3296 get_real_state(void) 3297 { 3298 if (State & NORMAL) 3299 { 3300 if (VIsual_active) 3301 { 3302 if (VIsual_select) 3303 return SELECTMODE; 3304 return VISUAL; 3305 } 3306 else if (finish_op) 3307 return OP_PENDING; 3308 } 3309 return State; 3310 } 3311 3312 #if defined(FEAT_MBYTE) || defined(PROTO) 3313 /* 3314 * Return TRUE if "p" points to just after a path separator. 3315 * Takes care of multi-byte characters. 3316 * "b" must point to the start of the file name 3317 */ 3318 int 3319 after_pathsep(char_u *b, char_u *p) 3320 { 3321 return p > b && vim_ispathsep(p[-1]) 3322 && (!has_mbyte || (*mb_head_off)(b, p - 1) == 0); 3323 } 3324 #endif 3325 3326 /* 3327 * Return TRUE if file names "f1" and "f2" are in the same directory. 3328 * "f1" may be a short name, "f2" must be a full path. 3329 */ 3330 int 3331 same_directory(char_u *f1, char_u *f2) 3332 { 3333 char_u ffname[MAXPATHL]; 3334 char_u *t1; 3335 char_u *t2; 3336 3337 /* safety check */ 3338 if (f1 == NULL || f2 == NULL) 3339 return FALSE; 3340 3341 (void)vim_FullName(f1, ffname, MAXPATHL, FALSE); 3342 t1 = gettail_sep(ffname); 3343 t2 = gettail_sep(f2); 3344 return (t1 - ffname == t2 - f2 3345 && pathcmp((char *)ffname, (char *)f2, (int)(t1 - ffname)) == 0); 3346 } 3347 3348 #if defined(FEAT_SESSION) || defined(MSWIN) || defined(FEAT_GUI_MAC) \ 3349 || defined(FEAT_GUI_GTK) \ 3350 || defined(FEAT_SUN_WORKSHOP) || defined(FEAT_NETBEANS_INTG) \ 3351 || defined(PROTO) 3352 /* 3353 * Change to a file's directory. 3354 * Caller must call shorten_fnames()! 3355 * Return OK or FAIL. 3356 */ 3357 int 3358 vim_chdirfile(char_u *fname) 3359 { 3360 char_u dir[MAXPATHL]; 3361 3362 vim_strncpy(dir, fname, MAXPATHL - 1); 3363 *gettail_sep(dir) = NUL; 3364 return mch_chdir((char *)dir) == 0 ? OK : FAIL; 3365 } 3366 #endif 3367 3368 #if defined(STAT_IGNORES_SLASH) || defined(PROTO) 3369 /* 3370 * Check if "name" ends in a slash and is not a directory. 3371 * Used for systems where stat() ignores a trailing slash on a file name. 3372 * The Vim code assumes a trailing slash is only ignored for a directory. 3373 */ 3374 static int 3375 illegal_slash(const char *name) 3376 { 3377 if (name[0] == NUL) 3378 return FALSE; /* no file name is not illegal */ 3379 if (name[strlen(name) - 1] != '/') 3380 return FALSE; /* no trailing slash */ 3381 if (mch_isdir((char_u *)name)) 3382 return FALSE; /* trailing slash for a directory */ 3383 return TRUE; 3384 } 3385 3386 /* 3387 * Special implementation of mch_stat() for Solaris. 3388 */ 3389 int 3390 vim_stat(const char *name, stat_T *stp) 3391 { 3392 /* On Solaris stat() accepts "file/" as if it was "file". Return -1 if 3393 * the name ends in "/" and it's not a directory. */ 3394 return illegal_slash(name) ? -1 : stat(name, stp); 3395 } 3396 #endif 3397 3398 #if defined(CURSOR_SHAPE) || defined(PROTO) 3399 3400 /* 3401 * Handling of cursor and mouse pointer shapes in various modes. 3402 */ 3403 3404 cursorentry_T shape_table[SHAPE_IDX_COUNT] = 3405 { 3406 /* The values will be filled in from the 'guicursor' and 'mouseshape' 3407 * defaults when Vim starts. 3408 * Adjust the SHAPE_IDX_ defines when making changes! */ 3409 {0, 0, 0, 700L, 400L, 250L, 0, 0, "n", SHAPE_CURSOR+SHAPE_MOUSE}, 3410 {0, 0, 0, 700L, 400L, 250L, 0, 0, "v", SHAPE_CURSOR+SHAPE_MOUSE}, 3411 {0, 0, 0, 700L, 400L, 250L, 0, 0, "i", SHAPE_CURSOR+SHAPE_MOUSE}, 3412 {0, 0, 0, 700L, 400L, 250L, 0, 0, "r", SHAPE_CURSOR+SHAPE_MOUSE}, 3413 {0, 0, 0, 700L, 400L, 250L, 0, 0, "c", SHAPE_CURSOR+SHAPE_MOUSE}, 3414 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ci", SHAPE_CURSOR+SHAPE_MOUSE}, 3415 {0, 0, 0, 700L, 400L, 250L, 0, 0, "cr", SHAPE_CURSOR+SHAPE_MOUSE}, 3416 {0, 0, 0, 700L, 400L, 250L, 0, 0, "o", SHAPE_CURSOR+SHAPE_MOUSE}, 3417 {0, 0, 0, 700L, 400L, 250L, 0, 0, "ve", SHAPE_CURSOR+SHAPE_MOUSE}, 3418 {0, 0, 0, 0L, 0L, 0L, 0, 0, "e", SHAPE_MOUSE}, 3419 {0, 0, 0, 0L, 0L, 0L, 0, 0, "s", SHAPE_MOUSE}, 3420 {0, 0, 0, 0L, 0L, 0L, 0, 0, "sd", SHAPE_MOUSE}, 3421 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vs", SHAPE_MOUSE}, 3422 {0, 0, 0, 0L, 0L, 0L, 0, 0, "vd", SHAPE_MOUSE}, 3423 {0, 0, 0, 0L, 0L, 0L, 0, 0, "m", SHAPE_MOUSE}, 3424 {0, 0, 0, 0L, 0L, 0L, 0, 0, "ml", SHAPE_MOUSE}, 3425 {0, 0, 0, 100L, 100L, 100L, 0, 0, "sm", SHAPE_CURSOR}, 3426 }; 3427 3428 #ifdef FEAT_MOUSESHAPE 3429 /* 3430 * Table with names for mouse shapes. Keep in sync with all the tables for 3431 * mch_set_mouse_shape()!. 3432 */ 3433 static char * mshape_names[] = 3434 { 3435 "arrow", /* default, must be the first one */ 3436 "blank", /* hidden */ 3437 "beam", 3438 "updown", 3439 "udsizing", 3440 "leftright", 3441 "lrsizing", 3442 "busy", 3443 "no", 3444 "crosshair", 3445 "hand1", 3446 "hand2", 3447 "pencil", 3448 "question", 3449 "rightup-arrow", 3450 "up-arrow", 3451 NULL 3452 }; 3453 #endif 3454 3455 /* 3456 * Parse the 'guicursor' option ("what" is SHAPE_CURSOR) or 'mouseshape' 3457 * ("what" is SHAPE_MOUSE). 3458 * Returns error message for an illegal option, NULL otherwise. 3459 */ 3460 char_u * 3461 parse_shape_opt(int what) 3462 { 3463 char_u *modep; 3464 char_u *colonp; 3465 char_u *commap; 3466 char_u *slashp; 3467 char_u *p, *endp; 3468 int idx = 0; /* init for GCC */ 3469 int all_idx; 3470 int len; 3471 int i; 3472 long n; 3473 int found_ve = FALSE; /* found "ve" flag */ 3474 int round; 3475 3476 /* 3477 * First round: check for errors; second round: do it for real. 3478 */ 3479 for (round = 1; round <= 2; ++round) 3480 { 3481 /* 3482 * Repeat for all comma separated parts. 3483 */ 3484 #ifdef FEAT_MOUSESHAPE 3485 if (what == SHAPE_MOUSE) 3486 modep = p_mouseshape; 3487 else 3488 #endif 3489 modep = p_guicursor; 3490 while (*modep != NUL) 3491 { 3492 colonp = vim_strchr(modep, ':'); 3493 commap = vim_strchr(modep, ','); 3494 3495 if (colonp == NULL || (commap != NULL && commap < colonp)) 3496 return (char_u *)N_("E545: Missing colon"); 3497 if (colonp == modep) 3498 return (char_u *)N_("E546: Illegal mode"); 3499 3500 /* 3501 * Repeat for all mode's before the colon. 3502 * For the 'a' mode, we loop to handle all the modes. 3503 */ 3504 all_idx = -1; 3505 while (modep < colonp || all_idx >= 0) 3506 { 3507 if (all_idx < 0) 3508 { 3509 /* Find the mode. */ 3510 if (modep[1] == '-' || modep[1] == ':') 3511 len = 1; 3512 else 3513 len = 2; 3514 if (len == 1 && TOLOWER_ASC(modep[0]) == 'a') 3515 all_idx = SHAPE_IDX_COUNT - 1; 3516 else 3517 { 3518 for (idx = 0; idx < SHAPE_IDX_COUNT; ++idx) 3519 if (STRNICMP(modep, shape_table[idx].name, len) 3520 == 0) 3521 break; 3522 if (idx == SHAPE_IDX_COUNT 3523 || (shape_table[idx].used_for & what) == 0) 3524 return (char_u *)N_("E546: Illegal mode"); 3525 if (len == 2 && modep[0] == 'v' && modep[1] == 'e') 3526 found_ve = TRUE; 3527 } 3528 modep += len + 1; 3529 } 3530 3531 if (all_idx >= 0) 3532 idx = all_idx--; 3533 else if (round == 2) 3534 { 3535 #ifdef FEAT_MOUSESHAPE 3536 if (what == SHAPE_MOUSE) 3537 { 3538 /* Set the default, for the missing parts */ 3539 shape_table[idx].mshape = 0; 3540 } 3541 else 3542 #endif 3543 { 3544 /* Set the defaults, for the missing parts */ 3545 shape_table[idx].shape = SHAPE_BLOCK; 3546 shape_table[idx].blinkwait = 700L; 3547 shape_table[idx].blinkon = 400L; 3548 shape_table[idx].blinkoff = 250L; 3549 } 3550 } 3551 3552 /* Parse the part after the colon */ 3553 for (p = colonp + 1; *p && *p != ','; ) 3554 { 3555 #ifdef FEAT_MOUSESHAPE 3556 if (what == SHAPE_MOUSE) 3557 { 3558 for (i = 0; ; ++i) 3559 { 3560 if (mshape_names[i] == NULL) 3561 { 3562 if (!VIM_ISDIGIT(*p)) 3563 return (char_u *)N_("E547: Illegal mouseshape"); 3564 if (round == 2) 3565 shape_table[idx].mshape = 3566 getdigits(&p) + MSHAPE_NUMBERED; 3567 else 3568 (void)getdigits(&p); 3569 break; 3570 } 3571 len = (int)STRLEN(mshape_names[i]); 3572 if (STRNICMP(p, mshape_names[i], len) == 0) 3573 { 3574 if (round == 2) 3575 shape_table[idx].mshape = i; 3576 p += len; 3577 break; 3578 } 3579 } 3580 } 3581 else /* if (what == SHAPE_MOUSE) */ 3582 #endif 3583 { 3584 /* 3585 * First handle the ones with a number argument. 3586 */ 3587 i = *p; 3588 len = 0; 3589 if (STRNICMP(p, "ver", 3) == 0) 3590 len = 3; 3591 else if (STRNICMP(p, "hor", 3) == 0) 3592 len = 3; 3593 else if (STRNICMP(p, "blinkwait", 9) == 0) 3594 len = 9; 3595 else if (STRNICMP(p, "blinkon", 7) == 0) 3596 len = 7; 3597 else if (STRNICMP(p, "blinkoff", 8) == 0) 3598 len = 8; 3599 if (len != 0) 3600 { 3601 p += len; 3602 if (!VIM_ISDIGIT(*p)) 3603 return (char_u *)N_("E548: digit expected"); 3604 n = getdigits(&p); 3605 if (len == 3) /* "ver" or "hor" */ 3606 { 3607 if (n == 0) 3608 return (char_u *)N_("E549: Illegal percentage"); 3609 if (round == 2) 3610 { 3611 if (TOLOWER_ASC(i) == 'v') 3612 shape_table[idx].shape = SHAPE_VER; 3613 else 3614 shape_table[idx].shape = SHAPE_HOR; 3615 shape_table[idx].percentage = n; 3616 } 3617 } 3618 else if (round == 2) 3619 { 3620 if (len == 9) 3621 shape_table[idx].blinkwait = n; 3622 else if (len == 7) 3623 shape_table[idx].blinkon = n; 3624 else 3625 shape_table[idx].blinkoff = n; 3626 } 3627 } 3628 else if (STRNICMP(p, "block", 5) == 0) 3629 { 3630 if (round == 2) 3631 shape_table[idx].shape = SHAPE_BLOCK; 3632 p += 5; 3633 } 3634 else /* must be a highlight group name then */ 3635 { 3636 endp = vim_strchr(p, '-'); 3637 if (commap == NULL) /* last part */ 3638 { 3639 if (endp == NULL) 3640 endp = p + STRLEN(p); /* find end of part */ 3641 } 3642 else if (endp > commap || endp == NULL) 3643 endp = commap; 3644 slashp = vim_strchr(p, '/'); 3645 if (slashp != NULL && slashp < endp) 3646 { 3647 /* "group/langmap_group" */ 3648 i = syn_check_group(p, (int)(slashp - p)); 3649 p = slashp + 1; 3650 } 3651 if (round == 2) 3652 { 3653 shape_table[idx].id = syn_check_group(p, 3654 (int)(endp - p)); 3655 shape_table[idx].id_lm = shape_table[idx].id; 3656 if (slashp != NULL && slashp < endp) 3657 shape_table[idx].id = i; 3658 } 3659 p = endp; 3660 } 3661 } /* if (what != SHAPE_MOUSE) */ 3662 3663 if (*p == '-') 3664 ++p; 3665 } 3666 } 3667 modep = p; 3668 if (*modep == ',') 3669 ++modep; 3670 } 3671 } 3672 3673 /* If the 's' flag is not given, use the 'v' cursor for 's' */ 3674 if (!found_ve) 3675 { 3676 #ifdef FEAT_MOUSESHAPE 3677 if (what == SHAPE_MOUSE) 3678 { 3679 shape_table[SHAPE_IDX_VE].mshape = shape_table[SHAPE_IDX_V].mshape; 3680 } 3681 else 3682 #endif 3683 { 3684 shape_table[SHAPE_IDX_VE].shape = shape_table[SHAPE_IDX_V].shape; 3685 shape_table[SHAPE_IDX_VE].percentage = 3686 shape_table[SHAPE_IDX_V].percentage; 3687 shape_table[SHAPE_IDX_VE].blinkwait = 3688 shape_table[SHAPE_IDX_V].blinkwait; 3689 shape_table[SHAPE_IDX_VE].blinkon = 3690 shape_table[SHAPE_IDX_V].blinkon; 3691 shape_table[SHAPE_IDX_VE].blinkoff = 3692 shape_table[SHAPE_IDX_V].blinkoff; 3693 shape_table[SHAPE_IDX_VE].id = shape_table[SHAPE_IDX_V].id; 3694 shape_table[SHAPE_IDX_VE].id_lm = shape_table[SHAPE_IDX_V].id_lm; 3695 } 3696 } 3697 3698 return NULL; 3699 } 3700 3701 # if defined(MCH_CURSOR_SHAPE) || defined(FEAT_GUI) \ 3702 || defined(FEAT_MOUSESHAPE) || defined(PROTO) 3703 /* 3704 * Return the index into shape_table[] for the current mode. 3705 * When "mouse" is TRUE, consider indexes valid for the mouse pointer. 3706 */ 3707 int 3708 get_shape_idx(int mouse) 3709 { 3710 #ifdef FEAT_MOUSESHAPE 3711 if (mouse && (State == HITRETURN || State == ASKMORE)) 3712 { 3713 # ifdef FEAT_GUI 3714 int x, y; 3715 gui_mch_getmouse(&x, &y); 3716 if (Y_2_ROW(y) == Rows - 1) 3717 return SHAPE_IDX_MOREL; 3718 # endif 3719 return SHAPE_IDX_MORE; 3720 } 3721 if (mouse && drag_status_line) 3722 return SHAPE_IDX_SDRAG; 3723 if (mouse && drag_sep_line) 3724 return SHAPE_IDX_VDRAG; 3725 #endif 3726 if (!mouse && State == SHOWMATCH) 3727 return SHAPE_IDX_SM; 3728 #ifdef FEAT_VREPLACE 3729 if (State & VREPLACE_FLAG) 3730 return SHAPE_IDX_R; 3731 #endif 3732 if (State & REPLACE_FLAG) 3733 return SHAPE_IDX_R; 3734 if (State & INSERT) 3735 return SHAPE_IDX_I; 3736 if (State & CMDLINE) 3737 { 3738 if (cmdline_at_end()) 3739 return SHAPE_IDX_C; 3740 if (cmdline_overstrike()) 3741 return SHAPE_IDX_CR; 3742 return SHAPE_IDX_CI; 3743 } 3744 if (finish_op) 3745 return SHAPE_IDX_O; 3746 if (VIsual_active) 3747 { 3748 if (*p_sel == 'e') 3749 return SHAPE_IDX_VE; 3750 else 3751 return SHAPE_IDX_V; 3752 } 3753 return SHAPE_IDX_N; 3754 } 3755 #endif 3756 3757 # if defined(FEAT_MOUSESHAPE) || defined(PROTO) 3758 static int old_mouse_shape = 0; 3759 3760 /* 3761 * Set the mouse shape: 3762 * If "shape" is -1, use shape depending on the current mode, 3763 * depending on the current state. 3764 * If "shape" is -2, only update the shape when it's CLINE or STATUS (used 3765 * when the mouse moves off the status or command line). 3766 */ 3767 void 3768 update_mouseshape(int shape_idx) 3769 { 3770 int new_mouse_shape; 3771 3772 /* Only works in GUI mode. */ 3773 if (!gui.in_use || gui.starting) 3774 return; 3775 3776 /* Postpone the updating when more is to come. Speeds up executing of 3777 * mappings. */ 3778 if (shape_idx == -1 && char_avail()) 3779 { 3780 postponed_mouseshape = TRUE; 3781 return; 3782 } 3783 3784 /* When ignoring the mouse don't change shape on the statusline. */ 3785 if (*p_mouse == NUL 3786 && (shape_idx == SHAPE_IDX_CLINE 3787 || shape_idx == SHAPE_IDX_STATUS 3788 || shape_idx == SHAPE_IDX_VSEP)) 3789 shape_idx = -2; 3790 3791 if (shape_idx == -2 3792 && old_mouse_shape != shape_table[SHAPE_IDX_CLINE].mshape 3793 && old_mouse_shape != shape_table[SHAPE_IDX_STATUS].mshape 3794 && old_mouse_shape != shape_table[SHAPE_IDX_VSEP].mshape) 3795 return; 3796 if (shape_idx < 0) 3797 new_mouse_shape = shape_table[get_shape_idx(TRUE)].mshape; 3798 else 3799 new_mouse_shape = shape_table[shape_idx].mshape; 3800 if (new_mouse_shape != old_mouse_shape) 3801 { 3802 mch_set_mouse_shape(new_mouse_shape); 3803 old_mouse_shape = new_mouse_shape; 3804 } 3805 postponed_mouseshape = FALSE; 3806 } 3807 # endif 3808 3809 #endif /* CURSOR_SHAPE */ 3810 3811 3812 /* TODO: make some #ifdef for this */ 3813 /*--------[ file searching ]-------------------------------------------------*/ 3814 /* 3815 * File searching functions for 'path', 'tags' and 'cdpath' options. 3816 * External visible functions: 3817 * vim_findfile_init() creates/initialises the search context 3818 * vim_findfile_free_visited() free list of visited files/dirs of search 3819 * context 3820 * vim_findfile() find a file in the search context 3821 * vim_findfile_cleanup() cleanup/free search context created by 3822 * vim_findfile_init() 3823 * 3824 * All static functions and variables start with 'ff_' 3825 * 3826 * In general it works like this: 3827 * First you create yourself a search context by calling vim_findfile_init(). 3828 * It is possible to give a search context from a previous call to 3829 * vim_findfile_init(), so it can be reused. After this you call vim_findfile() 3830 * until you are satisfied with the result or it returns NULL. On every call it 3831 * returns the next file which matches the conditions given to 3832 * vim_findfile_init(). If it doesn't find a next file it returns NULL. 3833 * 3834 * It is possible to call vim_findfile_init() again to reinitialise your search 3835 * with some new parameters. Don't forget to pass your old search context to 3836 * it, so it can reuse it and especially reuse the list of already visited 3837 * directories. If you want to delete the list of already visited directories 3838 * simply call vim_findfile_free_visited(). 3839 * 3840 * When you are done call vim_findfile_cleanup() to free the search context. 3841 * 3842 * The function vim_findfile_init() has a long comment, which describes the 3843 * needed parameters. 3844 * 3845 * 3846 * 3847 * ATTENTION: 3848 * ========== 3849 * Also we use an allocated search context here, this functions are NOT 3850 * thread-safe!!!!! 3851 * 3852 * To minimize parameter passing (or because I'm to lazy), only the 3853 * external visible functions get a search context as a parameter. This is 3854 * then assigned to a static global, which is used throughout the local 3855 * functions. 3856 */ 3857 3858 /* 3859 * type for the directory search stack 3860 */ 3861 typedef struct ff_stack 3862 { 3863 struct ff_stack *ffs_prev; 3864 3865 /* the fix part (no wildcards) and the part containing the wildcards 3866 * of the search path 3867 */ 3868 char_u *ffs_fix_path; 3869 #ifdef FEAT_PATH_EXTRA 3870 char_u *ffs_wc_path; 3871 #endif 3872 3873 /* files/dirs found in the above directory, matched by the first wildcard 3874 * of wc_part 3875 */ 3876 char_u **ffs_filearray; 3877 int ffs_filearray_size; 3878 char_u ffs_filearray_cur; /* needed for partly handled dirs */ 3879 3880 /* to store status of partly handled directories 3881 * 0: we work on this directory for the first time 3882 * 1: this directory was partly searched in an earlier step 3883 */ 3884 int ffs_stage; 3885 3886 /* How deep are we in the directory tree? 3887 * Counts backward from value of level parameter to vim_findfile_init 3888 */ 3889 int ffs_level; 3890 3891 /* Did we already expand '**' to an empty string? */ 3892 int ffs_star_star_empty; 3893 } ff_stack_T; 3894 3895 /* 3896 * type for already visited directories or files. 3897 */ 3898 typedef struct ff_visited 3899 { 3900 struct ff_visited *ffv_next; 3901 3902 #ifdef FEAT_PATH_EXTRA 3903 /* Visited directories are different if the wildcard string are 3904 * different. So we have to save it. 3905 */ 3906 char_u *ffv_wc_path; 3907 #endif 3908 /* for unix use inode etc for comparison (needed because of links), else 3909 * use filename. 3910 */ 3911 #ifdef UNIX 3912 int ffv_dev_valid; /* ffv_dev and ffv_ino were set */ 3913 dev_t ffv_dev; /* device number */ 3914 ino_t ffv_ino; /* inode number */ 3915 #endif 3916 /* The memory for this struct is allocated according to the length of 3917 * ffv_fname. 3918 */ 3919 char_u ffv_fname[1]; /* actually longer */ 3920 } ff_visited_T; 3921 3922 /* 3923 * We might have to manage several visited lists during a search. 3924 * This is especially needed for the tags option. If tags is set to: 3925 * "./++/tags,./++/TAGS,++/tags" (replace + with *) 3926 * So we have to do 3 searches: 3927 * 1) search from the current files directory downward for the file "tags" 3928 * 2) search from the current files directory downward for the file "TAGS" 3929 * 3) search from Vims current directory downwards for the file "tags" 3930 * As you can see, the first and the third search are for the same file, so for 3931 * the third search we can use the visited list of the first search. For the 3932 * second search we must start from a empty visited list. 3933 * The struct ff_visited_list_hdr is used to manage a linked list of already 3934 * visited lists. 3935 */ 3936 typedef struct ff_visited_list_hdr 3937 { 3938 struct ff_visited_list_hdr *ffvl_next; 3939 3940 /* the filename the attached visited list is for */ 3941 char_u *ffvl_filename; 3942 3943 ff_visited_T *ffvl_visited_list; 3944 3945 } ff_visited_list_hdr_T; 3946 3947 3948 /* 3949 * '**' can be expanded to several directory levels. 3950 * Set the default maximum depth. 3951 */ 3952 #define FF_MAX_STAR_STAR_EXPAND ((char_u)30) 3953 3954 /* 3955 * The search context: 3956 * ffsc_stack_ptr: the stack for the dirs to search 3957 * ffsc_visited_list: the currently active visited list 3958 * ffsc_dir_visited_list: the currently active visited list for search dirs 3959 * ffsc_visited_lists_list: the list of all visited lists 3960 * ffsc_dir_visited_lists_list: the list of all visited lists for search dirs 3961 * ffsc_file_to_search: the file to search for 3962 * ffsc_start_dir: the starting directory, if search path was relative 3963 * ffsc_fix_path: the fix part of the given path (without wildcards) 3964 * Needed for upward search. 3965 * ffsc_wc_path: the part of the given path containing wildcards 3966 * ffsc_level: how many levels of dirs to search downwards 3967 * ffsc_stopdirs_v: array of stop directories for upward search 3968 * ffsc_find_what: FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE 3969 * ffsc_tagfile: searching for tags file, don't use 'suffixesadd' 3970 */ 3971 typedef struct ff_search_ctx_T 3972 { 3973 ff_stack_T *ffsc_stack_ptr; 3974 ff_visited_list_hdr_T *ffsc_visited_list; 3975 ff_visited_list_hdr_T *ffsc_dir_visited_list; 3976 ff_visited_list_hdr_T *ffsc_visited_lists_list; 3977 ff_visited_list_hdr_T *ffsc_dir_visited_lists_list; 3978 char_u *ffsc_file_to_search; 3979 char_u *ffsc_start_dir; 3980 char_u *ffsc_fix_path; 3981 #ifdef FEAT_PATH_EXTRA 3982 char_u *ffsc_wc_path; 3983 int ffsc_level; 3984 char_u **ffsc_stopdirs_v; 3985 #endif 3986 int ffsc_find_what; 3987 int ffsc_tagfile; 3988 } ff_search_ctx_T; 3989 3990 /* locally needed functions */ 3991 #ifdef FEAT_PATH_EXTRA 3992 static int ff_check_visited(ff_visited_T **, char_u *, char_u *); 3993 #else 3994 static int ff_check_visited(ff_visited_T **, char_u *); 3995 #endif 3996 static void vim_findfile_free_visited_list(ff_visited_list_hdr_T **list_headp); 3997 static void ff_free_visited_list(ff_visited_T *vl); 3998 static ff_visited_list_hdr_T* ff_get_visited_list(char_u *, ff_visited_list_hdr_T **list_headp); 3999 #ifdef FEAT_PATH_EXTRA 4000 static int ff_wc_equal(char_u *s1, char_u *s2); 4001 #endif 4002 4003 static void ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr); 4004 static ff_stack_T *ff_pop(ff_search_ctx_T *search_ctx); 4005 static void ff_clear(ff_search_ctx_T *search_ctx); 4006 static void ff_free_stack_element(ff_stack_T *stack_ptr); 4007 #ifdef FEAT_PATH_EXTRA 4008 static ff_stack_T *ff_create_stack_element(char_u *, char_u *, int, int); 4009 #else 4010 static ff_stack_T *ff_create_stack_element(char_u *, int, int); 4011 #endif 4012 #ifdef FEAT_PATH_EXTRA 4013 static int ff_path_in_stoplist(char_u *, int, char_u **); 4014 #endif 4015 4016 static char_u e_pathtoolong[] = N_("E854: path too long for completion"); 4017 4018 #if 0 4019 /* 4020 * if someone likes findfirst/findnext, here are the functions 4021 * NOT TESTED!! 4022 */ 4023 4024 static void *ff_fn_search_context = NULL; 4025 4026 char_u * 4027 vim_findfirst(char_u *path, char_u *filename, int level) 4028 { 4029 ff_fn_search_context = 4030 vim_findfile_init(path, filename, NULL, level, TRUE, FALSE, 4031 ff_fn_search_context, rel_fname); 4032 if (NULL == ff_fn_search_context) 4033 return NULL; 4034 else 4035 return vim_findnext() 4036 } 4037 4038 char_u * 4039 vim_findnext(void) 4040 { 4041 char_u *ret = vim_findfile(ff_fn_search_context); 4042 4043 if (NULL == ret) 4044 { 4045 vim_findfile_cleanup(ff_fn_search_context); 4046 ff_fn_search_context = NULL; 4047 } 4048 return ret; 4049 } 4050 #endif 4051 4052 /* 4053 * Initialization routine for vim_findfile(). 4054 * 4055 * Returns the newly allocated search context or NULL if an error occurred. 4056 * 4057 * Don't forget to clean up by calling vim_findfile_cleanup() if you are done 4058 * with the search context. 4059 * 4060 * Find the file 'filename' in the directory 'path'. 4061 * The parameter 'path' may contain wildcards. If so only search 'level' 4062 * directories deep. The parameter 'level' is the absolute maximum and is 4063 * not related to restricts given to the '**' wildcard. If 'level' is 100 4064 * and you use '**200' vim_findfile() will stop after 100 levels. 4065 * 4066 * 'filename' cannot contain wildcards! It is used as-is, no backslashes to 4067 * escape special characters. 4068 * 4069 * If 'stopdirs' is not NULL and nothing is found downward, the search is 4070 * restarted on the next higher directory level. This is repeated until the 4071 * start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the 4072 * format ";*<dirname>*\(;<dirname>\)*;\=$". 4073 * 4074 * If the 'path' is relative, the starting dir for the search is either VIM's 4075 * current dir or if the path starts with "./" the current files dir. 4076 * If the 'path' is absolute, the starting dir is that part of the path before 4077 * the first wildcard. 4078 * 4079 * Upward search is only done on the starting dir. 4080 * 4081 * If 'free_visited' is TRUE the list of already visited files/directories is 4082 * cleared. Set this to FALSE if you just want to search from another 4083 * directory, but want to be sure that no directory from a previous search is 4084 * searched again. This is useful if you search for a file at different places. 4085 * The list of visited files/dirs can also be cleared with the function 4086 * vim_findfile_free_visited(). 4087 * 4088 * Set the parameter 'find_what' to FINDFILE_DIR if you want to search for 4089 * directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both. 4090 * 4091 * A search context returned by a previous call to vim_findfile_init() can be 4092 * passed in the parameter "search_ctx_arg". This context is reused and 4093 * reinitialized with the new parameters. The list of already visited 4094 * directories from this context is only deleted if the parameter 4095 * "free_visited" is true. Be aware that the passed "search_ctx_arg" is freed 4096 * if the reinitialization fails. 4097 * 4098 * If you don't have a search context from a previous call "search_ctx_arg" 4099 * must be NULL. 4100 * 4101 * This function silently ignores a few errors, vim_findfile() will have 4102 * limited functionality then. 4103 */ 4104 void * 4105 vim_findfile_init( 4106 char_u *path, 4107 char_u *filename, 4108 char_u *stopdirs UNUSED, 4109 int level, 4110 int free_visited, 4111 int find_what, 4112 void *search_ctx_arg, 4113 int tagfile, /* expanding names of tags files */ 4114 char_u *rel_fname) /* file name to use for "." */ 4115 { 4116 #ifdef FEAT_PATH_EXTRA 4117 char_u *wc_part; 4118 #endif 4119 ff_stack_T *sptr; 4120 ff_search_ctx_T *search_ctx; 4121 4122 /* If a search context is given by the caller, reuse it, else allocate a 4123 * new one. 4124 */ 4125 if (search_ctx_arg != NULL) 4126 search_ctx = search_ctx_arg; 4127 else 4128 { 4129 search_ctx = (ff_search_ctx_T*)alloc((unsigned)sizeof(ff_search_ctx_T)); 4130 if (search_ctx == NULL) 4131 goto error_return; 4132 vim_memset(search_ctx, 0, sizeof(ff_search_ctx_T)); 4133 } 4134 search_ctx->ffsc_find_what = find_what; 4135 search_ctx->ffsc_tagfile = tagfile; 4136 4137 /* clear the search context, but NOT the visited lists */ 4138 ff_clear(search_ctx); 4139 4140 /* clear visited list if wanted */ 4141 if (free_visited == TRUE) 4142 vim_findfile_free_visited(search_ctx); 4143 else 4144 { 4145 /* Reuse old visited lists. Get the visited list for the given 4146 * filename. If no list for the current filename exists, creates a new 4147 * one. */ 4148 search_ctx->ffsc_visited_list = ff_get_visited_list(filename, 4149 &search_ctx->ffsc_visited_lists_list); 4150 if (search_ctx->ffsc_visited_list == NULL) 4151 goto error_return; 4152 search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename, 4153 &search_ctx->ffsc_dir_visited_lists_list); 4154 if (search_ctx->ffsc_dir_visited_list == NULL) 4155 goto error_return; 4156 } 4157 4158 if (ff_expand_buffer == NULL) 4159 { 4160 ff_expand_buffer = (char_u*)alloc(MAXPATHL); 4161 if (ff_expand_buffer == NULL) 4162 goto error_return; 4163 } 4164 4165 /* Store information on starting dir now if path is relative. 4166 * If path is absolute, we do that later. */ 4167 if (path[0] == '.' 4168 && (vim_ispathsep(path[1]) || path[1] == NUL) 4169 && (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL) 4170 && rel_fname != NULL) 4171 { 4172 int len = (int)(gettail(rel_fname) - rel_fname); 4173 4174 if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) 4175 { 4176 /* Make the start dir an absolute path name. */ 4177 vim_strncpy(ff_expand_buffer, rel_fname, len); 4178 search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, FALSE); 4179 } 4180 else 4181 search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len); 4182 if (search_ctx->ffsc_start_dir == NULL) 4183 goto error_return; 4184 if (*++path != NUL) 4185 ++path; 4186 } 4187 else if (*path == NUL || !vim_isAbsName(path)) 4188 { 4189 #ifdef BACKSLASH_IN_FILENAME 4190 /* "c:dir" needs "c:" to be expanded, otherwise use current dir */ 4191 if (*path != NUL && path[1] == ':') 4192 { 4193 char_u drive[3]; 4194 4195 drive[0] = path[0]; 4196 drive[1] = ':'; 4197 drive[2] = NUL; 4198 if (vim_FullName(drive, ff_expand_buffer, MAXPATHL, TRUE) == FAIL) 4199 goto error_return; 4200 path += 2; 4201 } 4202 else 4203 #endif 4204 if (mch_dirname(ff_expand_buffer, MAXPATHL) == FAIL) 4205 goto error_return; 4206 4207 search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer); 4208 if (search_ctx->ffsc_start_dir == NULL) 4209 goto error_return; 4210 4211 #ifdef BACKSLASH_IN_FILENAME 4212 /* A path that starts with "/dir" is relative to the drive, not to the 4213 * directory (but not for "//machine/dir"). Only use the drive name. */ 4214 if ((*path == '/' || *path == '\\') 4215 && path[1] != path[0] 4216 && search_ctx->ffsc_start_dir[1] == ':') 4217 search_ctx->ffsc_start_dir[2] = NUL; 4218 #endif 4219 } 4220 4221 #ifdef FEAT_PATH_EXTRA 4222 /* 4223 * If stopdirs are given, split them into an array of pointers. 4224 * If this fails (mem allocation), there is no upward search at all or a 4225 * stop directory is not recognized -> continue silently. 4226 * If stopdirs just contains a ";" or is empty, 4227 * search_ctx->ffsc_stopdirs_v will only contain a NULL pointer. This 4228 * is handled as unlimited upward search. See function 4229 * ff_path_in_stoplist() for details. 4230 */ 4231 if (stopdirs != NULL) 4232 { 4233 char_u *walker = stopdirs; 4234 int dircount; 4235 4236 while (*walker == ';') 4237 walker++; 4238 4239 dircount = 1; 4240 search_ctx->ffsc_stopdirs_v = 4241 (char_u **)alloc((unsigned)sizeof(char_u *)); 4242 4243 if (search_ctx->ffsc_stopdirs_v != NULL) 4244 { 4245 do 4246 { 4247 char_u *helper; 4248 void *ptr; 4249 4250 helper = walker; 4251 ptr = vim_realloc(search_ctx->ffsc_stopdirs_v, 4252 (dircount + 1) * sizeof(char_u *)); 4253 if (ptr) 4254 search_ctx->ffsc_stopdirs_v = ptr; 4255 else 4256 /* ignore, keep what we have and continue */ 4257 break; 4258 walker = vim_strchr(walker, ';'); 4259 if (walker) 4260 { 4261 search_ctx->ffsc_stopdirs_v[dircount-1] = 4262 vim_strnsave(helper, (int)(walker - helper)); 4263 walker++; 4264 } 4265 else 4266 /* this might be "", which means ascent till top 4267 * of directory tree. 4268 */ 4269 search_ctx->ffsc_stopdirs_v[dircount-1] = 4270 vim_strsave(helper); 4271 4272 dircount++; 4273 4274 } while (walker != NULL); 4275 search_ctx->ffsc_stopdirs_v[dircount-1] = NULL; 4276 } 4277 } 4278 #endif 4279 4280 #ifdef FEAT_PATH_EXTRA 4281 search_ctx->ffsc_level = level; 4282 4283 /* split into: 4284 * -fix path 4285 * -wildcard_stuff (might be NULL) 4286 */ 4287 wc_part = vim_strchr(path, '*'); 4288 if (wc_part != NULL) 4289 { 4290 int llevel; 4291 int len; 4292 char *errpt; 4293 4294 /* save the fix part of the path */ 4295 search_ctx->ffsc_fix_path = vim_strnsave(path, (int)(wc_part - path)); 4296 4297 /* 4298 * copy wc_path and add restricts to the '**' wildcard. 4299 * The octet after a '**' is used as a (binary) counter. 4300 * So '**3' is transposed to '**^C' ('^C' is ASCII value 3) 4301 * or '**76' is transposed to '**N'( 'N' is ASCII value 76). 4302 * For EBCDIC you get different character values. 4303 * If no restrict is given after '**' the default is used. 4304 * Due to this technique the path looks awful if you print it as a 4305 * string. 4306 */ 4307 len = 0; 4308 while (*wc_part != NUL) 4309 { 4310 if (len + 5 >= MAXPATHL) 4311 { 4312 EMSG(_(e_pathtoolong)); 4313 break; 4314 } 4315 if (STRNCMP(wc_part, "**", 2) == 0) 4316 { 4317 ff_expand_buffer[len++] = *wc_part++; 4318 ff_expand_buffer[len++] = *wc_part++; 4319 4320 llevel = strtol((char *)wc_part, &errpt, 10); 4321 if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255) 4322 ff_expand_buffer[len++] = llevel; 4323 else if ((char_u *)errpt != wc_part && llevel == 0) 4324 /* restrict is 0 -> remove already added '**' */ 4325 len -= 2; 4326 else 4327 ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND; 4328 wc_part = (char_u *)errpt; 4329 if (*wc_part != NUL && !vim_ispathsep(*wc_part)) 4330 { 4331 EMSG2(_("E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."), PATHSEPSTR); 4332 goto error_return; 4333 } 4334 } 4335 else 4336 ff_expand_buffer[len++] = *wc_part++; 4337 } 4338 ff_expand_buffer[len] = NUL; 4339 search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer); 4340 4341 if (search_ctx->ffsc_wc_path == NULL) 4342 goto error_return; 4343 } 4344 else 4345 #endif 4346 search_ctx->ffsc_fix_path = vim_strsave(path); 4347 4348 if (search_ctx->ffsc_start_dir == NULL) 4349 { 4350 /* store the fix part as startdir. 4351 * This is needed if the parameter path is fully qualified. 4352 */ 4353 search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path); 4354 if (search_ctx->ffsc_start_dir == NULL) 4355 goto error_return; 4356 search_ctx->ffsc_fix_path[0] = NUL; 4357 } 4358 4359 /* create an absolute path */ 4360 if (STRLEN(search_ctx->ffsc_start_dir) 4361 + STRLEN(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) 4362 { 4363 EMSG(_(e_pathtoolong)); 4364 goto error_return; 4365 } 4366 STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir); 4367 add_pathsep(ff_expand_buffer); 4368 { 4369 int eb_len = (int)STRLEN(ff_expand_buffer); 4370 char_u *buf = alloc(eb_len 4371 + (int)STRLEN(search_ctx->ffsc_fix_path) + 1); 4372 4373 STRCPY(buf, ff_expand_buffer); 4374 STRCPY(buf + eb_len, search_ctx->ffsc_fix_path); 4375 if (mch_isdir(buf)) 4376 { 4377 STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path); 4378 add_pathsep(ff_expand_buffer); 4379 } 4380 #ifdef FEAT_PATH_EXTRA 4381 else 4382 { 4383 char_u *p = gettail(search_ctx->ffsc_fix_path); 4384 char_u *wc_path = NULL; 4385 char_u *temp = NULL; 4386 int len = 0; 4387 4388 if (p > search_ctx->ffsc_fix_path) 4389 { 4390 len = (int)(p - search_ctx->ffsc_fix_path) - 1; 4391 STRNCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, len); 4392 add_pathsep(ff_expand_buffer); 4393 } 4394 else 4395 len = (int)STRLEN(search_ctx->ffsc_fix_path); 4396 4397 if (search_ctx->ffsc_wc_path != NULL) 4398 { 4399 wc_path = vim_strsave(search_ctx->ffsc_wc_path); 4400 temp = alloc((int)(STRLEN(search_ctx->ffsc_wc_path) 4401 + STRLEN(search_ctx->ffsc_fix_path + len) 4402 + 1)); 4403 if (temp == NULL || wc_path == NULL) 4404 { 4405 vim_free(buf); 4406 vim_free(temp); 4407 vim_free(wc_path); 4408 goto error_return; 4409 } 4410 4411 STRCPY(temp, search_ctx->ffsc_fix_path + len); 4412 STRCAT(temp, search_ctx->ffsc_wc_path); 4413 vim_free(search_ctx->ffsc_wc_path); 4414 vim_free(wc_path); 4415 search_ctx->ffsc_wc_path = temp; 4416 } 4417 } 4418 #endif 4419 vim_free(buf); 4420 } 4421 4422 sptr = ff_create_stack_element(ff_expand_buffer, 4423 #ifdef FEAT_PATH_EXTRA 4424 search_ctx->ffsc_wc_path, 4425 #endif 4426 level, 0); 4427 4428 if (sptr == NULL) 4429 goto error_return; 4430 4431 ff_push(search_ctx, sptr); 4432 4433 search_ctx->ffsc_file_to_search = vim_strsave(filename); 4434 if (search_ctx->ffsc_file_to_search == NULL) 4435 goto error_return; 4436 4437 return search_ctx; 4438 4439 error_return: 4440 /* 4441 * We clear the search context now! 4442 * Even when the caller gave us a (perhaps valid) context we free it here, 4443 * as we might have already destroyed it. 4444 */ 4445 vim_findfile_cleanup(search_ctx); 4446 return NULL; 4447 } 4448 4449 #if defined(FEAT_PATH_EXTRA) || defined(PROTO) 4450 /* 4451 * Get the stopdir string. Check that ';' is not escaped. 4452 */ 4453 char_u * 4454 vim_findfile_stopdir(char_u *buf) 4455 { 4456 char_u *r_ptr = buf; 4457 4458 while (*r_ptr != NUL && *r_ptr != ';') 4459 { 4460 if (r_ptr[0] == '\\' && r_ptr[1] == ';') 4461 { 4462 /* Overwrite the escape char, 4463 * use STRLEN(r_ptr) to move the trailing '\0'. */ 4464 STRMOVE(r_ptr, r_ptr + 1); 4465 r_ptr++; 4466 } 4467 r_ptr++; 4468 } 4469 if (*r_ptr == ';') 4470 { 4471 *r_ptr = 0; 4472 r_ptr++; 4473 } 4474 else if (*r_ptr == NUL) 4475 r_ptr = NULL; 4476 return r_ptr; 4477 } 4478 #endif 4479 4480 /* 4481 * Clean up the given search context. Can handle a NULL pointer. 4482 */ 4483 void 4484 vim_findfile_cleanup(void *ctx) 4485 { 4486 if (ctx == NULL) 4487 return; 4488 4489 vim_findfile_free_visited(ctx); 4490 ff_clear(ctx); 4491 vim_free(ctx); 4492 } 4493 4494 /* 4495 * Find a file in a search context. 4496 * The search context was created with vim_findfile_init() above. 4497 * Return a pointer to an allocated file name or NULL if nothing found. 4498 * To get all matching files call this function until you get NULL. 4499 * 4500 * If the passed search_context is NULL, NULL is returned. 4501 * 4502 * The search algorithm is depth first. To change this replace the 4503 * stack with a list (don't forget to leave partly searched directories on the 4504 * top of the list). 4505 */ 4506 char_u * 4507 vim_findfile(void *search_ctx_arg) 4508 { 4509 char_u *file_path; 4510 #ifdef FEAT_PATH_EXTRA 4511 char_u *rest_of_wildcards; 4512 char_u *path_end = NULL; 4513 #endif 4514 ff_stack_T *stackp; 4515 #if defined(FEAT_SEARCHPATH) || defined(FEAT_PATH_EXTRA) 4516 int len; 4517 #endif 4518 int i; 4519 char_u *p; 4520 #ifdef FEAT_SEARCHPATH 4521 char_u *suf; 4522 #endif 4523 ff_search_ctx_T *search_ctx; 4524 4525 if (search_ctx_arg == NULL) 4526 return NULL; 4527 4528 search_ctx = (ff_search_ctx_T *)search_ctx_arg; 4529 4530 /* 4531 * filepath is used as buffer for various actions and as the storage to 4532 * return a found filename. 4533 */ 4534 if ((file_path = alloc((int)MAXPATHL)) == NULL) 4535 return NULL; 4536 4537 #ifdef FEAT_PATH_EXTRA 4538 /* store the end of the start dir -- needed for upward search */ 4539 if (search_ctx->ffsc_start_dir != NULL) 4540 path_end = &search_ctx->ffsc_start_dir[ 4541 STRLEN(search_ctx->ffsc_start_dir)]; 4542 #endif 4543 4544 #ifdef FEAT_PATH_EXTRA 4545 /* upward search loop */ 4546 for (;;) 4547 { 4548 #endif 4549 /* downward search loop */ 4550 for (;;) 4551 { 4552 /* check if user user wants to stop the search*/ 4553 ui_breakcheck(); 4554 if (got_int) 4555 break; 4556 4557 /* get directory to work on from stack */ 4558 stackp = ff_pop(search_ctx); 4559 if (stackp == NULL) 4560 break; 4561 4562 /* 4563 * TODO: decide if we leave this test in 4564 * 4565 * GOOD: don't search a directory(-tree) twice. 4566 * BAD: - check linked list for every new directory entered. 4567 * - check for double files also done below 4568 * 4569 * Here we check if we already searched this directory. 4570 * We already searched a directory if: 4571 * 1) The directory is the same. 4572 * 2) We would use the same wildcard string. 4573 * 4574 * Good if you have links on same directory via several ways 4575 * or you have selfreferences in directories (e.g. SuSE Linux 6.3: 4576 * /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop) 4577 * 4578 * This check is only needed for directories we work on for the 4579 * first time (hence stackp->ff_filearray == NULL) 4580 */ 4581 if (stackp->ffs_filearray == NULL 4582 && ff_check_visited(&search_ctx->ffsc_dir_visited_list 4583 ->ffvl_visited_list, 4584 stackp->ffs_fix_path 4585 #ifdef FEAT_PATH_EXTRA 4586 , stackp->ffs_wc_path 4587 #endif 4588 ) == FAIL) 4589 { 4590 #ifdef FF_VERBOSE 4591 if (p_verbose >= 5) 4592 { 4593 verbose_enter_scroll(); 4594 smsg((char_u *)"Already Searched: %s (%s)", 4595 stackp->ffs_fix_path, stackp->ffs_wc_path); 4596 /* don't overwrite this either */ 4597 msg_puts((char_u *)"\n"); 4598 verbose_leave_scroll(); 4599 } 4600 #endif 4601 ff_free_stack_element(stackp); 4602 continue; 4603 } 4604 #ifdef FF_VERBOSE 4605 else if (p_verbose >= 5) 4606 { 4607 verbose_enter_scroll(); 4608 smsg((char_u *)"Searching: %s (%s)", 4609 stackp->ffs_fix_path, stackp->ffs_wc_path); 4610 /* don't overwrite this either */ 4611 msg_puts((char_u *)"\n"); 4612 verbose_leave_scroll(); 4613 } 4614 #endif 4615 4616 /* check depth */ 4617 if (stackp->ffs_level <= 0) 4618 { 4619 ff_free_stack_element(stackp); 4620 continue; 4621 } 4622 4623 file_path[0] = NUL; 4624 4625 /* 4626 * If no filearray till now expand wildcards 4627 * The function expand_wildcards() can handle an array of paths 4628 * and all possible expands are returned in one array. We use this 4629 * to handle the expansion of '**' into an empty string. 4630 */ 4631 if (stackp->ffs_filearray == NULL) 4632 { 4633 char_u *dirptrs[2]; 4634 4635 /* we use filepath to build the path expand_wildcards() should 4636 * expand. 4637 */ 4638 dirptrs[0] = file_path; 4639 dirptrs[1] = NULL; 4640 4641 /* if we have a start dir copy it in */ 4642 if (!vim_isAbsName(stackp->ffs_fix_path) 4643 && search_ctx->ffsc_start_dir) 4644 { 4645 if (STRLEN(search_ctx->ffsc_start_dir) + 1 < MAXPATHL) 4646 { 4647 STRCPY(file_path, search_ctx->ffsc_start_dir); 4648 add_pathsep(file_path); 4649 } 4650 else 4651 goto fail; 4652 } 4653 4654 /* append the fix part of the search path */ 4655 if (STRLEN(file_path) + STRLEN(stackp->ffs_fix_path) + 1 < MAXPATHL) 4656 { 4657 STRCAT(file_path, stackp->ffs_fix_path); 4658 add_pathsep(file_path); 4659 } 4660 else 4661 goto fail; 4662 4663 #ifdef FEAT_PATH_EXTRA 4664 rest_of_wildcards = stackp->ffs_wc_path; 4665 if (*rest_of_wildcards != NUL) 4666 { 4667 len = (int)STRLEN(file_path); 4668 if (STRNCMP(rest_of_wildcards, "**", 2) == 0) 4669 { 4670 /* pointer to the restrict byte 4671 * The restrict byte is not a character! 4672 */ 4673 p = rest_of_wildcards + 2; 4674 4675 if (*p > 0) 4676 { 4677 (*p)--; 4678 if (len + 1 < MAXPATHL) 4679 file_path[len++] = '*'; 4680 else 4681 goto fail; 4682 } 4683 4684 if (*p == 0) 4685 { 4686 /* remove '**<numb> from wildcards */ 4687 STRMOVE(rest_of_wildcards, rest_of_wildcards + 3); 4688 } 4689 else 4690 rest_of_wildcards += 3; 4691 4692 if (stackp->ffs_star_star_empty == 0) 4693 { 4694 /* if not done before, expand '**' to empty */ 4695 stackp->ffs_star_star_empty = 1; 4696 dirptrs[1] = stackp->ffs_fix_path; 4697 } 4698 } 4699 4700 /* 4701 * Here we copy until the next path separator or the end of 4702 * the path. If we stop at a path separator, there is 4703 * still something else left. This is handled below by 4704 * pushing every directory returned from expand_wildcards() 4705 * on the stack again for further search. 4706 */ 4707 while (*rest_of_wildcards 4708 && !vim_ispathsep(*rest_of_wildcards)) 4709 if (len + 1 < MAXPATHL) 4710 file_path[len++] = *rest_of_wildcards++; 4711 else 4712 goto fail; 4713 4714 file_path[len] = NUL; 4715 if (vim_ispathsep(*rest_of_wildcards)) 4716 rest_of_wildcards++; 4717 } 4718 #endif 4719 4720 /* 4721 * Expand wildcards like "*" and "$VAR". 4722 * If the path is a URL don't try this. 4723 */ 4724 if (path_with_url(dirptrs[0])) 4725 { 4726 stackp->ffs_filearray = (char_u **) 4727 alloc((unsigned)sizeof(char *)); 4728 if (stackp->ffs_filearray != NULL 4729 && (stackp->ffs_filearray[0] 4730 = vim_strsave(dirptrs[0])) != NULL) 4731 stackp->ffs_filearray_size = 1; 4732 else 4733 stackp->ffs_filearray_size = 0; 4734 } 4735 else 4736 /* Add EW_NOTWILD because the expanded path may contain 4737 * wildcard characters that are to be taken literally. 4738 * This is a bit of a hack. */ 4739 expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs, 4740 &stackp->ffs_filearray_size, 4741 &stackp->ffs_filearray, 4742 EW_DIR|EW_ADDSLASH|EW_SILENT|EW_NOTWILD); 4743 4744 stackp->ffs_filearray_cur = 0; 4745 stackp->ffs_stage = 0; 4746 } 4747 #ifdef FEAT_PATH_EXTRA 4748 else 4749 rest_of_wildcards = &stackp->ffs_wc_path[ 4750 STRLEN(stackp->ffs_wc_path)]; 4751 #endif 4752 4753 if (stackp->ffs_stage == 0) 4754 { 4755 /* this is the first time we work on this directory */ 4756 #ifdef FEAT_PATH_EXTRA 4757 if (*rest_of_wildcards == NUL) 4758 #endif 4759 { 4760 /* 4761 * We don't have further wildcards to expand, so we have to 4762 * check for the final file now. 4763 */ 4764 for (i = stackp->ffs_filearray_cur; 4765 i < stackp->ffs_filearray_size; ++i) 4766 { 4767 if (!path_with_url(stackp->ffs_filearray[i]) 4768 && !mch_isdir(stackp->ffs_filearray[i])) 4769 continue; /* not a directory */ 4770 4771 /* prepare the filename to be checked for existence 4772 * below */ 4773 if (STRLEN(stackp->ffs_filearray[i]) + 1 4774 + STRLEN(search_ctx->ffsc_file_to_search) < MAXPATHL) 4775 { 4776 STRCPY(file_path, stackp->ffs_filearray[i]); 4777 add_pathsep(file_path); 4778 STRCAT(file_path, search_ctx->ffsc_file_to_search); 4779 } 4780 else 4781 goto fail; 4782 4783 /* 4784 * Try without extra suffix and then with suffixes 4785 * from 'suffixesadd'. 4786 */ 4787 #ifdef FEAT_SEARCHPATH 4788 len = (int)STRLEN(file_path); 4789 if (search_ctx->ffsc_tagfile) 4790 suf = (char_u *)""; 4791 else 4792 suf = curbuf->b_p_sua; 4793 for (;;) 4794 #endif 4795 { 4796 /* if file exists and we didn't already find it */ 4797 if ((path_with_url(file_path) 4798 || (mch_getperm(file_path) >= 0 4799 && (search_ctx->ffsc_find_what 4800 == FINDFILE_BOTH 4801 || ((search_ctx->ffsc_find_what 4802 == FINDFILE_DIR) 4803 == mch_isdir(file_path))))) 4804 #ifndef FF_VERBOSE 4805 && (ff_check_visited( 4806 &search_ctx->ffsc_visited_list->ffvl_visited_list, 4807 file_path 4808 #ifdef FEAT_PATH_EXTRA 4809 , (char_u *)"" 4810 #endif 4811 ) == OK) 4812 #endif 4813 ) 4814 { 4815 #ifdef FF_VERBOSE 4816 if (ff_check_visited( 4817 &search_ctx->ffsc_visited_list->ffvl_visited_list, 4818 file_path 4819 #ifdef FEAT_PATH_EXTRA 4820 , (char_u *)"" 4821 #endif 4822 ) == FAIL) 4823 { 4824 if (p_verbose >= 5) 4825 { 4826 verbose_enter_scroll(); 4827 smsg((char_u *)"Already: %s", 4828 file_path); 4829 /* don't overwrite this either */ 4830 msg_puts((char_u *)"\n"); 4831 verbose_leave_scroll(); 4832 } 4833 continue; 4834 } 4835 #endif 4836 4837 /* push dir to examine rest of subdirs later */ 4838 stackp->ffs_filearray_cur = i + 1; 4839 ff_push(search_ctx, stackp); 4840 4841 if (!path_with_url(file_path)) 4842 simplify_filename(file_path); 4843 if (mch_dirname(ff_expand_buffer, MAXPATHL) 4844 == OK) 4845 { 4846 p = shorten_fname(file_path, 4847 ff_expand_buffer); 4848 if (p != NULL) 4849 STRMOVE(file_path, p); 4850 } 4851 #ifdef FF_VERBOSE 4852 if (p_verbose >= 5) 4853 { 4854 verbose_enter_scroll(); 4855 smsg((char_u *)"HIT: %s", file_path); 4856 /* don't overwrite this either */ 4857 msg_puts((char_u *)"\n"); 4858 verbose_leave_scroll(); 4859 } 4860 #endif 4861 return file_path; 4862 } 4863 4864 #ifdef FEAT_SEARCHPATH 4865 /* Not found or found already, try next suffix. */ 4866 if (*suf == NUL) 4867 break; 4868 copy_option_part(&suf, file_path + len, 4869 MAXPATHL - len, ","); 4870 #endif 4871 } 4872 } 4873 } 4874 #ifdef FEAT_PATH_EXTRA 4875 else 4876 { 4877 /* 4878 * still wildcards left, push the directories for further 4879 * search 4880 */ 4881 for (i = stackp->ffs_filearray_cur; 4882 i < stackp->ffs_filearray_size; ++i) 4883 { 4884 if (!mch_isdir(stackp->ffs_filearray[i])) 4885 continue; /* not a directory */ 4886 4887 ff_push(search_ctx, 4888 ff_create_stack_element( 4889 stackp->ffs_filearray[i], 4890 rest_of_wildcards, 4891 stackp->ffs_level - 1, 0)); 4892 } 4893 } 4894 #endif 4895 stackp->ffs_filearray_cur = 0; 4896 stackp->ffs_stage = 1; 4897 } 4898 4899 #ifdef FEAT_PATH_EXTRA 4900 /* 4901 * if wildcards contains '**' we have to descent till we reach the 4902 * leaves of the directory tree. 4903 */ 4904 if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) 4905 { 4906 for (i = stackp->ffs_filearray_cur; 4907 i < stackp->ffs_filearray_size; ++i) 4908 { 4909 if (fnamecmp(stackp->ffs_filearray[i], 4910 stackp->ffs_fix_path) == 0) 4911 continue; /* don't repush same directory */ 4912 if (!mch_isdir(stackp->ffs_filearray[i])) 4913 continue; /* not a directory */ 4914 ff_push(search_ctx, 4915 ff_create_stack_element(stackp->ffs_filearray[i], 4916 stackp->ffs_wc_path, stackp->ffs_level - 1, 1)); 4917 } 4918 } 4919 #endif 4920 4921 /* we are done with the current directory */ 4922 ff_free_stack_element(stackp); 4923 4924 } 4925 4926 #ifdef FEAT_PATH_EXTRA 4927 /* If we reached this, we didn't find anything downwards. 4928 * Let's check if we should do an upward search. 4929 */ 4930 if (search_ctx->ffsc_start_dir 4931 && search_ctx->ffsc_stopdirs_v != NULL && !got_int) 4932 { 4933 ff_stack_T *sptr; 4934 4935 /* is the last starting directory in the stop list? */ 4936 if (ff_path_in_stoplist(search_ctx->ffsc_start_dir, 4937 (int)(path_end - search_ctx->ffsc_start_dir), 4938 search_ctx->ffsc_stopdirs_v) == TRUE) 4939 break; 4940 4941 /* cut of last dir */ 4942 while (path_end > search_ctx->ffsc_start_dir 4943 && vim_ispathsep(*path_end)) 4944 path_end--; 4945 while (path_end > search_ctx->ffsc_start_dir 4946 && !vim_ispathsep(path_end[-1])) 4947 path_end--; 4948 *path_end = 0; 4949 path_end--; 4950 4951 if (*search_ctx->ffsc_start_dir == 0) 4952 break; 4953 4954 if (STRLEN(search_ctx->ffsc_start_dir) + 1 4955 + STRLEN(search_ctx->ffsc_fix_path) < MAXPATHL) 4956 { 4957 STRCPY(file_path, search_ctx->ffsc_start_dir); 4958 add_pathsep(file_path); 4959 STRCAT(file_path, search_ctx->ffsc_fix_path); 4960 } 4961 else 4962 goto fail; 4963 4964 /* create a new stack entry */ 4965 sptr = ff_create_stack_element(file_path, 4966 search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0); 4967 if (sptr == NULL) 4968 break; 4969 ff_push(search_ctx, sptr); 4970 } 4971 else 4972 break; 4973 } 4974 #endif 4975 4976 fail: 4977 vim_free(file_path); 4978 return NULL; 4979 } 4980 4981 /* 4982 * Free the list of lists of visited files and directories 4983 * Can handle it if the passed search_context is NULL; 4984 */ 4985 void 4986 vim_findfile_free_visited(void *search_ctx_arg) 4987 { 4988 ff_search_ctx_T *search_ctx; 4989 4990 if (search_ctx_arg == NULL) 4991 return; 4992 4993 search_ctx = (ff_search_ctx_T *)search_ctx_arg; 4994 vim_findfile_free_visited_list(&search_ctx->ffsc_visited_lists_list); 4995 vim_findfile_free_visited_list(&search_ctx->ffsc_dir_visited_lists_list); 4996 } 4997 4998 static void 4999 vim_findfile_free_visited_list(ff_visited_list_hdr_T **list_headp) 5000 { 5001 ff_visited_list_hdr_T *vp; 5002 5003 while (*list_headp != NULL) 5004 { 5005 vp = (*list_headp)->ffvl_next; 5006 ff_free_visited_list((*list_headp)->ffvl_visited_list); 5007 5008 vim_free((*list_headp)->ffvl_filename); 5009 vim_free(*list_headp); 5010 *list_headp = vp; 5011 } 5012 *list_headp = NULL; 5013 } 5014 5015 static void 5016 ff_free_visited_list(ff_visited_T *vl) 5017 { 5018 ff_visited_T *vp; 5019 5020 while (vl != NULL) 5021 { 5022 vp = vl->ffv_next; 5023 #ifdef FEAT_PATH_EXTRA 5024 vim_free(vl->ffv_wc_path); 5025 #endif 5026 vim_free(vl); 5027 vl = vp; 5028 } 5029 vl = NULL; 5030 } 5031 5032 /* 5033 * Returns the already visited list for the given filename. If none is found it 5034 * allocates a new one. 5035 */ 5036 static ff_visited_list_hdr_T* 5037 ff_get_visited_list( 5038 char_u *filename, 5039 ff_visited_list_hdr_T **list_headp) 5040 { 5041 ff_visited_list_hdr_T *retptr = NULL; 5042 5043 /* check if a visited list for the given filename exists */ 5044 if (*list_headp != NULL) 5045 { 5046 retptr = *list_headp; 5047 while (retptr != NULL) 5048 { 5049 if (fnamecmp(filename, retptr->ffvl_filename) == 0) 5050 { 5051 #ifdef FF_VERBOSE 5052 if (p_verbose >= 5) 5053 { 5054 verbose_enter_scroll(); 5055 smsg((char_u *)"ff_get_visited_list: FOUND list for %s", 5056 filename); 5057 /* don't overwrite this either */ 5058 msg_puts((char_u *)"\n"); 5059 verbose_leave_scroll(); 5060 } 5061 #endif 5062 return retptr; 5063 } 5064 retptr = retptr->ffvl_next; 5065 } 5066 } 5067 5068 #ifdef FF_VERBOSE 5069 if (p_verbose >= 5) 5070 { 5071 verbose_enter_scroll(); 5072 smsg((char_u *)"ff_get_visited_list: new list for %s", filename); 5073 /* don't overwrite this either */ 5074 msg_puts((char_u *)"\n"); 5075 verbose_leave_scroll(); 5076 } 5077 #endif 5078 5079 /* 5080 * if we reach this we didn't find a list and we have to allocate new list 5081 */ 5082 retptr = (ff_visited_list_hdr_T*)alloc((unsigned)sizeof(*retptr)); 5083 if (retptr == NULL) 5084 return NULL; 5085 5086 retptr->ffvl_visited_list = NULL; 5087 retptr->ffvl_filename = vim_strsave(filename); 5088 if (retptr->ffvl_filename == NULL) 5089 { 5090 vim_free(retptr); 5091 return NULL; 5092 } 5093 retptr->ffvl_next = *list_headp; 5094 *list_headp = retptr; 5095 5096 return retptr; 5097 } 5098 5099 #ifdef FEAT_PATH_EXTRA 5100 /* 5101 * check if two wildcard paths are equal. Returns TRUE or FALSE. 5102 * They are equal if: 5103 * - both paths are NULL 5104 * - they have the same length 5105 * - char by char comparison is OK 5106 * - the only differences are in the counters behind a '**', so 5107 * '**\20' is equal to '**\24' 5108 */ 5109 static int 5110 ff_wc_equal(char_u *s1, char_u *s2) 5111 { 5112 int i, j; 5113 int c1 = NUL; 5114 int c2 = NUL; 5115 int prev1 = NUL; 5116 int prev2 = NUL; 5117 5118 if (s1 == s2) 5119 return TRUE; 5120 5121 if (s1 == NULL || s2 == NULL) 5122 return FALSE; 5123 5124 for (i = 0, j = 0; s1[i] != NUL && s2[j] != NUL;) 5125 { 5126 c1 = PTR2CHAR(s1 + i); 5127 c2 = PTR2CHAR(s2 + j); 5128 5129 if ((p_fic ? MB_TOLOWER(c1) != MB_TOLOWER(c2) : c1 != c2) 5130 && (prev1 != '*' || prev2 != '*')) 5131 return FALSE; 5132 prev2 = prev1; 5133 prev1 = c1; 5134 5135 i += MB_PTR2LEN(s1 + i); 5136 j += MB_PTR2LEN(s2 + j); 5137 } 5138 return s1[i] == s2[j]; 5139 } 5140 #endif 5141 5142 /* 5143 * maintains the list of already visited files and dirs 5144 * returns FAIL if the given file/dir is already in the list 5145 * returns OK if it is newly added 5146 * 5147 * TODO: What to do on memory allocation problems? 5148 * -> return TRUE - Better the file is found several times instead of 5149 * never. 5150 */ 5151 static int 5152 ff_check_visited( 5153 ff_visited_T **visited_list, 5154 char_u *fname 5155 #ifdef FEAT_PATH_EXTRA 5156 , char_u *wc_path 5157 #endif 5158 ) 5159 { 5160 ff_visited_T *vp; 5161 #ifdef UNIX 5162 stat_T st; 5163 int url = FALSE; 5164 #endif 5165 5166 /* For an URL we only compare the name, otherwise we compare the 5167 * device/inode (unix) or the full path name (not Unix). */ 5168 if (path_with_url(fname)) 5169 { 5170 vim_strncpy(ff_expand_buffer, fname, MAXPATHL - 1); 5171 #ifdef UNIX 5172 url = TRUE; 5173 #endif 5174 } 5175 else 5176 { 5177 ff_expand_buffer[0] = NUL; 5178 #ifdef UNIX 5179 if (mch_stat((char *)fname, &st) < 0) 5180 #else 5181 if (vim_FullName(fname, ff_expand_buffer, MAXPATHL, TRUE) == FAIL) 5182 #endif 5183 return FAIL; 5184 } 5185 5186 /* check against list of already visited files */ 5187 for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) 5188 { 5189 if ( 5190 #ifdef UNIX 5191 !url ? (vp->ffv_dev_valid && vp->ffv_dev == st.st_dev 5192 && vp->ffv_ino == st.st_ino) 5193 : 5194 #endif 5195 fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0 5196 ) 5197 { 5198 #ifdef FEAT_PATH_EXTRA 5199 /* are the wildcard parts equal */ 5200 if (ff_wc_equal(vp->ffv_wc_path, wc_path) == TRUE) 5201 #endif 5202 /* already visited */ 5203 return FAIL; 5204 } 5205 } 5206 5207 /* 5208 * New file/dir. Add it to the list of visited files/dirs. 5209 */ 5210 vp = (ff_visited_T *)alloc((unsigned)(sizeof(ff_visited_T) 5211 + STRLEN(ff_expand_buffer))); 5212 5213 if (vp != NULL) 5214 { 5215 #ifdef UNIX 5216 if (!url) 5217 { 5218 vp->ffv_dev_valid = TRUE; 5219 vp->ffv_ino = st.st_ino; 5220 vp->ffv_dev = st.st_dev; 5221 vp->ffv_fname[0] = NUL; 5222 } 5223 else 5224 { 5225 vp->ffv_dev_valid = FALSE; 5226 #endif 5227 STRCPY(vp->ffv_fname, ff_expand_buffer); 5228 #ifdef UNIX 5229 } 5230 #endif 5231 #ifdef FEAT_PATH_EXTRA 5232 if (wc_path != NULL) 5233 vp->ffv_wc_path = vim_strsave(wc_path); 5234 else 5235 vp->ffv_wc_path = NULL; 5236 #endif 5237 5238 vp->ffv_next = *visited_list; 5239 *visited_list = vp; 5240 } 5241 5242 return OK; 5243 } 5244 5245 /* 5246 * create stack element from given path pieces 5247 */ 5248 static ff_stack_T * 5249 ff_create_stack_element( 5250 char_u *fix_part, 5251 #ifdef FEAT_PATH_EXTRA 5252 char_u *wc_part, 5253 #endif 5254 int level, 5255 int star_star_empty) 5256 { 5257 ff_stack_T *new; 5258 5259 new = (ff_stack_T *)alloc((unsigned)sizeof(ff_stack_T)); 5260 if (new == NULL) 5261 return NULL; 5262 5263 new->ffs_prev = NULL; 5264 new->ffs_filearray = NULL; 5265 new->ffs_filearray_size = 0; 5266 new->ffs_filearray_cur = 0; 5267 new->ffs_stage = 0; 5268 new->ffs_level = level; 5269 new->ffs_star_star_empty = star_star_empty; 5270 5271 /* the following saves NULL pointer checks in vim_findfile */ 5272 if (fix_part == NULL) 5273 fix_part = (char_u *)""; 5274 new->ffs_fix_path = vim_strsave(fix_part); 5275 5276 #ifdef FEAT_PATH_EXTRA 5277 if (wc_part == NULL) 5278 wc_part = (char_u *)""; 5279 new->ffs_wc_path = vim_strsave(wc_part); 5280 #endif 5281 5282 if (new->ffs_fix_path == NULL 5283 #ifdef FEAT_PATH_EXTRA 5284 || new->ffs_wc_path == NULL 5285 #endif 5286 ) 5287 { 5288 ff_free_stack_element(new); 5289 new = NULL; 5290 } 5291 5292 return new; 5293 } 5294 5295 /* 5296 * Push a dir on the directory stack. 5297 */ 5298 static void 5299 ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr) 5300 { 5301 /* check for NULL pointer, not to return an error to the user, but 5302 * to prevent a crash */ 5303 if (stack_ptr != NULL) 5304 { 5305 stack_ptr->ffs_prev = search_ctx->ffsc_stack_ptr; 5306 search_ctx->ffsc_stack_ptr = stack_ptr; 5307 } 5308 } 5309 5310 /* 5311 * Pop a dir from the directory stack. 5312 * Returns NULL if stack is empty. 5313 */ 5314 static ff_stack_T * 5315 ff_pop(ff_search_ctx_T *search_ctx) 5316 { 5317 ff_stack_T *sptr; 5318 5319 sptr = search_ctx->ffsc_stack_ptr; 5320 if (search_ctx->ffsc_stack_ptr != NULL) 5321 search_ctx->ffsc_stack_ptr = search_ctx->ffsc_stack_ptr->ffs_prev; 5322 5323 return sptr; 5324 } 5325 5326 /* 5327 * free the given stack element 5328 */ 5329 static void 5330 ff_free_stack_element(ff_stack_T *stack_ptr) 5331 { 5332 /* vim_free handles possible NULL pointers */ 5333 vim_free(stack_ptr->ffs_fix_path); 5334 #ifdef FEAT_PATH_EXTRA 5335 vim_free(stack_ptr->ffs_wc_path); 5336 #endif 5337 5338 if (stack_ptr->ffs_filearray != NULL) 5339 FreeWild(stack_ptr->ffs_filearray_size, stack_ptr->ffs_filearray); 5340 5341 vim_free(stack_ptr); 5342 } 5343 5344 /* 5345 * Clear the search context, but NOT the visited list. 5346 */ 5347 static void 5348 ff_clear(ff_search_ctx_T *search_ctx) 5349 { 5350 ff_stack_T *sptr; 5351 5352 /* clear up stack */ 5353 while ((sptr = ff_pop(search_ctx)) != NULL) 5354 ff_free_stack_element(sptr); 5355 5356 vim_free(search_ctx->ffsc_file_to_search); 5357 vim_free(search_ctx->ffsc_start_dir); 5358 vim_free(search_ctx->ffsc_fix_path); 5359 #ifdef FEAT_PATH_EXTRA 5360 vim_free(search_ctx->ffsc_wc_path); 5361 #endif 5362 5363 #ifdef FEAT_PATH_EXTRA 5364 if (search_ctx->ffsc_stopdirs_v != NULL) 5365 { 5366 int i = 0; 5367 5368 while (search_ctx->ffsc_stopdirs_v[i] != NULL) 5369 { 5370 vim_free(search_ctx->ffsc_stopdirs_v[i]); 5371 i++; 5372 } 5373 vim_free(search_ctx->ffsc_stopdirs_v); 5374 } 5375 search_ctx->ffsc_stopdirs_v = NULL; 5376 #endif 5377 5378 /* reset everything */ 5379 search_ctx->ffsc_file_to_search = NULL; 5380 search_ctx->ffsc_start_dir = NULL; 5381 search_ctx->ffsc_fix_path = NULL; 5382 #ifdef FEAT_PATH_EXTRA 5383 search_ctx->ffsc_wc_path = NULL; 5384 search_ctx->ffsc_level = 0; 5385 #endif 5386 } 5387 5388 #ifdef FEAT_PATH_EXTRA 5389 /* 5390 * check if the given path is in the stopdirs 5391 * returns TRUE if yes else FALSE 5392 */ 5393 static int 5394 ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v) 5395 { 5396 int i = 0; 5397 5398 /* eat up trailing path separators, except the first */ 5399 while (path_len > 1 && vim_ispathsep(path[path_len - 1])) 5400 path_len--; 5401 5402 /* if no path consider it as match */ 5403 if (path_len == 0) 5404 return TRUE; 5405 5406 for (i = 0; stopdirs_v[i] != NULL; i++) 5407 { 5408 if ((int)STRLEN(stopdirs_v[i]) > path_len) 5409 { 5410 /* match for parent directory. So '/home' also matches 5411 * '/home/rks'. Check for PATHSEP in stopdirs_v[i], else 5412 * '/home/r' would also match '/home/rks' 5413 */ 5414 if (fnamencmp(stopdirs_v[i], path, path_len) == 0 5415 && vim_ispathsep(stopdirs_v[i][path_len])) 5416 return TRUE; 5417 } 5418 else 5419 { 5420 if (fnamecmp(stopdirs_v[i], path) == 0) 5421 return TRUE; 5422 } 5423 } 5424 return FALSE; 5425 } 5426 #endif 5427 5428 #if defined(FEAT_SEARCHPATH) || defined(PROTO) 5429 /* 5430 * Find the file name "ptr[len]" in the path. Also finds directory names. 5431 * 5432 * On the first call set the parameter 'first' to TRUE to initialize 5433 * the search. For repeating calls to FALSE. 5434 * 5435 * Repeating calls will return other files called 'ptr[len]' from the path. 5436 * 5437 * Only on the first call 'ptr' and 'len' are used. For repeating calls they 5438 * don't need valid values. 5439 * 5440 * If nothing found on the first call the option FNAME_MESS will issue the 5441 * message: 5442 * 'Can't find file "<file>" in path' 5443 * On repeating calls: 5444 * 'No more file "<file>" found in path' 5445 * 5446 * options: 5447 * FNAME_MESS give error message when not found 5448 * 5449 * Uses NameBuff[]! 5450 * 5451 * Returns an allocated string for the file name. NULL for error. 5452 * 5453 */ 5454 char_u * 5455 find_file_in_path( 5456 char_u *ptr, /* file name */ 5457 int len, /* length of file name */ 5458 int options, 5459 int first, /* use count'th matching file name */ 5460 char_u *rel_fname) /* file name searching relative to */ 5461 { 5462 return find_file_in_path_option(ptr, len, options, first, 5463 *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path, 5464 FINDFILE_BOTH, rel_fname, curbuf->b_p_sua); 5465 } 5466 5467 static char_u *ff_file_to_find = NULL; 5468 static void *fdip_search_ctx = NULL; 5469 5470 #if defined(EXITFREE) 5471 static void 5472 free_findfile(void) 5473 { 5474 vim_free(ff_file_to_find); 5475 vim_findfile_cleanup(fdip_search_ctx); 5476 } 5477 #endif 5478 5479 /* 5480 * Find the directory name "ptr[len]" in the path. 5481 * 5482 * options: 5483 * FNAME_MESS give error message when not found 5484 * FNAME_UNESC unescape backslashes. 5485 * 5486 * Uses NameBuff[]! 5487 * 5488 * Returns an allocated string for the file name. NULL for error. 5489 */ 5490 char_u * 5491 find_directory_in_path( 5492 char_u *ptr, /* file name */ 5493 int len, /* length of file name */ 5494 int options, 5495 char_u *rel_fname) /* file name searching relative to */ 5496 { 5497 return find_file_in_path_option(ptr, len, options, TRUE, p_cdpath, 5498 FINDFILE_DIR, rel_fname, (char_u *)""); 5499 } 5500 5501 char_u * 5502 find_file_in_path_option( 5503 char_u *ptr, /* file name */ 5504 int len, /* length of file name */ 5505 int options, 5506 int first, /* use count'th matching file name */ 5507 char_u *path_option, /* p_path or p_cdpath */ 5508 int find_what, /* FINDFILE_FILE, _DIR or _BOTH */ 5509 char_u *rel_fname, /* file name we are looking relative to. */ 5510 char_u *suffixes) /* list of suffixes, 'suffixesadd' option */ 5511 { 5512 static char_u *dir; 5513 static int did_findfile_init = FALSE; 5514 char_u save_char; 5515 char_u *file_name = NULL; 5516 char_u *buf = NULL; 5517 int rel_to_curdir; 5518 #ifdef AMIGA 5519 struct Process *proc = (struct Process *)FindTask(0L); 5520 APTR save_winptr = proc->pr_WindowPtr; 5521 5522 /* Avoid a requester here for a volume that doesn't exist. */ 5523 proc->pr_WindowPtr = (APTR)-1L; 5524 #endif 5525 5526 if (first == TRUE) 5527 { 5528 /* copy file name into NameBuff, expanding environment variables */ 5529 save_char = ptr[len]; 5530 ptr[len] = NUL; 5531 expand_env_esc(ptr, NameBuff, MAXPATHL, FALSE, TRUE, NULL); 5532 ptr[len] = save_char; 5533 5534 vim_free(ff_file_to_find); 5535 ff_file_to_find = vim_strsave(NameBuff); 5536 if (ff_file_to_find == NULL) /* out of memory */ 5537 { 5538 file_name = NULL; 5539 goto theend; 5540 } 5541 if (options & FNAME_UNESC) 5542 { 5543 /* Change all "\ " to " ". */ 5544 for (ptr = ff_file_to_find; *ptr != NUL; ++ptr) 5545 if (ptr[0] == '\\' && ptr[1] == ' ') 5546 mch_memmove(ptr, ptr + 1, STRLEN(ptr)); 5547 } 5548 } 5549 5550 rel_to_curdir = (ff_file_to_find[0] == '.' 5551 && (ff_file_to_find[1] == NUL 5552 || vim_ispathsep(ff_file_to_find[1]) 5553 || (ff_file_to_find[1] == '.' 5554 && (ff_file_to_find[2] == NUL 5555 || vim_ispathsep(ff_file_to_find[2]))))); 5556 if (vim_isAbsName(ff_file_to_find) 5557 /* "..", "../path", "." and "./path": don't use the path_option */ 5558 || rel_to_curdir 5559 #if defined(MSWIN) 5560 /* handle "\tmp" as absolute path */ 5561 || vim_ispathsep(ff_file_to_find[0]) 5562 /* handle "c:name" as absolute path */ 5563 || (ff_file_to_find[0] != NUL && ff_file_to_find[1] == ':') 5564 #endif 5565 #ifdef AMIGA 5566 /* handle ":tmp" as absolute path */ 5567 || ff_file_to_find[0] == ':' 5568 #endif 5569 ) 5570 { 5571 /* 5572 * Absolute path, no need to use "path_option". 5573 * If this is not a first call, return NULL. We already returned a 5574 * filename on the first call. 5575 */ 5576 if (first == TRUE) 5577 { 5578 int l; 5579 int run; 5580 5581 if (path_with_url(ff_file_to_find)) 5582 { 5583 file_name = vim_strsave(ff_file_to_find); 5584 goto theend; 5585 } 5586 5587 /* When FNAME_REL flag given first use the directory of the file. 5588 * Otherwise or when this fails use the current directory. */ 5589 for (run = 1; run <= 2; ++run) 5590 { 5591 l = (int)STRLEN(ff_file_to_find); 5592 if (run == 1 5593 && rel_to_curdir 5594 && (options & FNAME_REL) 5595 && rel_fname != NULL 5596 && STRLEN(rel_fname) + l < MAXPATHL) 5597 { 5598 STRCPY(NameBuff, rel_fname); 5599 STRCPY(gettail(NameBuff), ff_file_to_find); 5600 l = (int)STRLEN(NameBuff); 5601 } 5602 else 5603 { 5604 STRCPY(NameBuff, ff_file_to_find); 5605 run = 2; 5606 } 5607 5608 /* When the file doesn't exist, try adding parts of 5609 * 'suffixesadd'. */ 5610 buf = suffixes; 5611 for (;;) 5612 { 5613 if (mch_getperm(NameBuff) >= 0 5614 && (find_what == FINDFILE_BOTH 5615 || ((find_what == FINDFILE_DIR) 5616 == mch_isdir(NameBuff)))) 5617 { 5618 file_name = vim_strsave(NameBuff); 5619 goto theend; 5620 } 5621 if (*buf == NUL) 5622 break; 5623 copy_option_part(&buf, NameBuff + l, MAXPATHL - l, ","); 5624 } 5625 } 5626 } 5627 } 5628 else 5629 { 5630 /* 5631 * Loop over all paths in the 'path' or 'cdpath' option. 5632 * When "first" is set, first setup to the start of the option. 5633 * Otherwise continue to find the next match. 5634 */ 5635 if (first == TRUE) 5636 { 5637 /* vim_findfile_free_visited can handle a possible NULL pointer */ 5638 vim_findfile_free_visited(fdip_search_ctx); 5639 dir = path_option; 5640 did_findfile_init = FALSE; 5641 } 5642 5643 for (;;) 5644 { 5645 if (did_findfile_init) 5646 { 5647 file_name = vim_findfile(fdip_search_ctx); 5648 if (file_name != NULL) 5649 break; 5650 5651 did_findfile_init = FALSE; 5652 } 5653 else 5654 { 5655 char_u *r_ptr; 5656 5657 if (dir == NULL || *dir == NUL) 5658 { 5659 /* We searched all paths of the option, now we can 5660 * free the search context. */ 5661 vim_findfile_cleanup(fdip_search_ctx); 5662 fdip_search_ctx = NULL; 5663 break; 5664 } 5665 5666 if ((buf = alloc((int)(MAXPATHL))) == NULL) 5667 break; 5668 5669 /* copy next path */ 5670 buf[0] = 0; 5671 copy_option_part(&dir, buf, MAXPATHL, " ,"); 5672 5673 #ifdef FEAT_PATH_EXTRA 5674 /* get the stopdir string */ 5675 r_ptr = vim_findfile_stopdir(buf); 5676 #else 5677 r_ptr = NULL; 5678 #endif 5679 fdip_search_ctx = vim_findfile_init(buf, ff_file_to_find, 5680 r_ptr, 100, FALSE, find_what, 5681 fdip_search_ctx, FALSE, rel_fname); 5682 if (fdip_search_ctx != NULL) 5683 did_findfile_init = TRUE; 5684 vim_free(buf); 5685 } 5686 } 5687 } 5688 if (file_name == NULL && (options & FNAME_MESS)) 5689 { 5690 if (first == TRUE) 5691 { 5692 if (find_what == FINDFILE_DIR) 5693 EMSG2(_("E344: Can't find directory \"%s\" in cdpath"), 5694 ff_file_to_find); 5695 else 5696 EMSG2(_("E345: Can't find file \"%s\" in path"), 5697 ff_file_to_find); 5698 } 5699 else 5700 { 5701 if (find_what == FINDFILE_DIR) 5702 EMSG2(_("E346: No more directory \"%s\" found in cdpath"), 5703 ff_file_to_find); 5704 else 5705 EMSG2(_("E347: No more file \"%s\" found in path"), 5706 ff_file_to_find); 5707 } 5708 } 5709 5710 theend: 5711 #ifdef AMIGA 5712 proc->pr_WindowPtr = save_winptr; 5713 #endif 5714 return file_name; 5715 } 5716 5717 #endif /* FEAT_SEARCHPATH */ 5718 5719 /* 5720 * Change directory to "new_dir". If FEAT_SEARCHPATH is defined, search 5721 * 'cdpath' for relative directory names, otherwise just mch_chdir(). 5722 */ 5723 int 5724 vim_chdir(char_u *new_dir) 5725 { 5726 #ifndef FEAT_SEARCHPATH 5727 return mch_chdir((char *)new_dir); 5728 #else 5729 char_u *dir_name; 5730 int r; 5731 5732 dir_name = find_directory_in_path(new_dir, (int)STRLEN(new_dir), 5733 FNAME_MESS, curbuf->b_ffname); 5734 if (dir_name == NULL) 5735 return -1; 5736 r = mch_chdir((char *)dir_name); 5737 vim_free(dir_name); 5738 return r; 5739 #endif 5740 } 5741 5742 /* 5743 * Get user name from machine-specific function. 5744 * Returns the user name in "buf[len]". 5745 * Some systems are quite slow in obtaining the user name (Windows NT), thus 5746 * cache the result. 5747 * Returns OK or FAIL. 5748 */ 5749 int 5750 get_user_name(char_u *buf, int len) 5751 { 5752 if (username == NULL) 5753 { 5754 if (mch_get_user_name(buf, len) == FAIL) 5755 return FAIL; 5756 username = vim_strsave(buf); 5757 } 5758 else 5759 vim_strncpy(buf, username, len - 1); 5760 return OK; 5761 } 5762 5763 #ifndef HAVE_QSORT 5764 /* 5765 * Our own qsort(), for systems that don't have it. 5766 * It's simple and slow. From the K&R C book. 5767 */ 5768 void 5769 qsort( 5770 void *base, 5771 size_t elm_count, 5772 size_t elm_size, 5773 int (*cmp)(const void *, const void *)) 5774 { 5775 char_u *buf; 5776 char_u *p1; 5777 char_u *p2; 5778 int i, j; 5779 int gap; 5780 5781 buf = alloc((unsigned)elm_size); 5782 if (buf == NULL) 5783 return; 5784 5785 for (gap = elm_count / 2; gap > 0; gap /= 2) 5786 for (i = gap; i < elm_count; ++i) 5787 for (j = i - gap; j >= 0; j -= gap) 5788 { 5789 /* Compare the elements. */ 5790 p1 = (char_u *)base + j * elm_size; 5791 p2 = (char_u *)base + (j + gap) * elm_size; 5792 if ((*cmp)((void *)p1, (void *)p2) <= 0) 5793 break; 5794 /* Exchange the elements. */ 5795 mch_memmove(buf, p1, elm_size); 5796 mch_memmove(p1, p2, elm_size); 5797 mch_memmove(p2, buf, elm_size); 5798 } 5799 5800 vim_free(buf); 5801 } 5802 #endif 5803 5804 /* 5805 * Sort an array of strings. 5806 */ 5807 static int 5808 #ifdef __BORLANDC__ 5809 _RTLENTRYF 5810 #endif 5811 sort_compare(const void *s1, const void *s2); 5812 5813 static int 5814 #ifdef __BORLANDC__ 5815 _RTLENTRYF 5816 #endif 5817 sort_compare(const void *s1, const void *s2) 5818 { 5819 return STRCMP(*(char **)s1, *(char **)s2); 5820 } 5821 5822 void 5823 sort_strings( 5824 char_u **files, 5825 int count) 5826 { 5827 qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare); 5828 } 5829 5830 #if !defined(NO_EXPANDPATH) || defined(PROTO) 5831 /* 5832 * Compare path "p[]" to "q[]". 5833 * If "maxlen" >= 0 compare "p[maxlen]" to "q[maxlen]" 5834 * Return value like strcmp(p, q), but consider path separators. 5835 */ 5836 int 5837 pathcmp(const char *p, const char *q, int maxlen) 5838 { 5839 int i, j; 5840 int c1, c2; 5841 const char *s = NULL; 5842 5843 for (i = 0, j = 0; maxlen < 0 || (i < maxlen && j < maxlen);) 5844 { 5845 c1 = PTR2CHAR((char_u *)p + i); 5846 c2 = PTR2CHAR((char_u *)q + j); 5847 5848 /* End of "p": check if "q" also ends or just has a slash. */ 5849 if (c1 == NUL) 5850 { 5851 if (c2 == NUL) /* full match */ 5852 return 0; 5853 s = q; 5854 i = j; 5855 break; 5856 } 5857 5858 /* End of "q": check if "p" just has a slash. */ 5859 if (c2 == NUL) 5860 { 5861 s = p; 5862 break; 5863 } 5864 5865 if ((p_fic ? MB_TOUPPER(c1) != MB_TOUPPER(c2) : c1 != c2) 5866 #ifdef BACKSLASH_IN_FILENAME 5867 /* consider '/' and '\\' to be equal */ 5868 && !((c1 == '/' && c2 == '\\') 5869 || (c1 == '\\' && c2 == '/')) 5870 #endif 5871 ) 5872 { 5873 if (vim_ispathsep(c1)) 5874 return -1; 5875 if (vim_ispathsep(c2)) 5876 return 1; 5877 return p_fic ? MB_TOUPPER(c1) - MB_TOUPPER(c2) 5878 : c1 - c2; /* no match */ 5879 } 5880 5881 i += MB_PTR2LEN((char_u *)p + i); 5882 j += MB_PTR2LEN((char_u *)q + j); 5883 } 5884 if (s == NULL) /* "i" or "j" ran into "maxlen" */ 5885 return 0; 5886 5887 c1 = PTR2CHAR((char_u *)s + i); 5888 c2 = PTR2CHAR((char_u *)s + i + MB_PTR2LEN((char_u *)s + i)); 5889 /* ignore a trailing slash, but not "//" or ":/" */ 5890 if (c2 == NUL 5891 && i > 0 5892 && !after_pathsep((char_u *)s, (char_u *)s + i) 5893 #ifdef BACKSLASH_IN_FILENAME 5894 && (c1 == '/' || c1 == '\\') 5895 #else 5896 && c1 == '/' 5897 #endif 5898 ) 5899 return 0; /* match with trailing slash */ 5900 if (s == q) 5901 return -1; /* no match */ 5902 return 1; 5903 } 5904 #endif 5905 5906 /* 5907 * The putenv() implementation below comes from the "screen" program. 5908 * Included with permission from Juergen Weigert. 5909 * See pty.c for the copyright notice. 5910 */ 5911 5912 /* 5913 * putenv -- put value into environment 5914 * 5915 * Usage: i = putenv (string) 5916 * int i; 5917 * char *string; 5918 * 5919 * where string is of the form <name>=<value>. 5920 * Putenv returns 0 normally, -1 on error (not enough core for malloc). 5921 * 5922 * Putenv may need to add a new name into the environment, or to 5923 * associate a value longer than the current value with a particular 5924 * name. So, to make life simpler, putenv() copies your entire 5925 * environment into the heap (i.e. malloc()) from the stack 5926 * (i.e. where it resides when your process is initiated) the first 5927 * time you call it. 5928 * 5929 * (history removed, not very interesting. See the "screen" sources.) 5930 */ 5931 5932 #if !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) 5933 5934 #define EXTRASIZE 5 /* increment to add to env. size */ 5935 5936 static int envsize = -1; /* current size of environment */ 5937 extern char **environ; /* the global which is your env. */ 5938 5939 static int findenv(char *name); /* look for a name in the env. */ 5940 static int newenv(void); /* copy env. from stack to heap */ 5941 static int moreenv(void); /* incr. size of env. */ 5942 5943 int 5944 putenv(const char *string) 5945 { 5946 int i; 5947 char *p; 5948 5949 if (envsize < 0) 5950 { /* first time putenv called */ 5951 if (newenv() < 0) /* copy env. to heap */ 5952 return -1; 5953 } 5954 5955 i = findenv((char *)string); /* look for name in environment */ 5956 5957 if (i < 0) 5958 { /* name must be added */ 5959 for (i = 0; environ[i]; i++); 5960 if (i >= (envsize - 1)) 5961 { /* need new slot */ 5962 if (moreenv() < 0) 5963 return -1; 5964 } 5965 p = (char *)alloc((unsigned)(strlen(string) + 1)); 5966 if (p == NULL) /* not enough core */ 5967 return -1; 5968 environ[i + 1] = 0; /* new end of env. */ 5969 } 5970 else 5971 { /* name already in env. */ 5972 p = vim_realloc(environ[i], strlen(string) + 1); 5973 if (p == NULL) 5974 return -1; 5975 } 5976 sprintf(p, "%s", string); /* copy into env. */ 5977 environ[i] = p; 5978 5979 return 0; 5980 } 5981 5982 static int 5983 findenv(char *name) 5984 { 5985 char *namechar, *envchar; 5986 int i, found; 5987 5988 found = 0; 5989 for (i = 0; environ[i] && !found; i++) 5990 { 5991 envchar = environ[i]; 5992 namechar = name; 5993 while (*namechar && *namechar != '=' && (*namechar == *envchar)) 5994 { 5995 namechar++; 5996 envchar++; 5997 } 5998 found = ((*namechar == '\0' || *namechar == '=') && *envchar == '='); 5999 } 6000 return found ? i - 1 : -1; 6001 } 6002 6003 static int 6004 newenv(void) 6005 { 6006 char **env, *elem; 6007 int i, esize; 6008 6009 for (i = 0; environ[i]; i++) 6010 ; 6011 6012 esize = i + EXTRASIZE + 1; 6013 env = (char **)alloc((unsigned)(esize * sizeof (elem))); 6014 if (env == NULL) 6015 return -1; 6016 6017 for (i = 0; environ[i]; i++) 6018 { 6019 elem = (char *)alloc((unsigned)(strlen(environ[i]) + 1)); 6020 if (elem == NULL) 6021 return -1; 6022 env[i] = elem; 6023 strcpy(elem, environ[i]); 6024 } 6025 6026 env[i] = 0; 6027 environ = env; 6028 envsize = esize; 6029 return 0; 6030 } 6031 6032 static int 6033 moreenv(void) 6034 { 6035 int esize; 6036 char **env; 6037 6038 esize = envsize + EXTRASIZE; 6039 env = (char **)vim_realloc((char *)environ, esize * sizeof (*env)); 6040 if (env == 0) 6041 return -1; 6042 environ = env; 6043 envsize = esize; 6044 return 0; 6045 } 6046 6047 # ifdef USE_VIMPTY_GETENV 6048 /* 6049 * Used for mch_getenv() for Mac. 6050 */ 6051 char_u * 6052 vimpty_getenv(const char_u *string) 6053 { 6054 int i; 6055 char_u *p; 6056 6057 if (envsize < 0) 6058 return NULL; 6059 6060 i = findenv((char *)string); 6061 6062 if (i < 0) 6063 return NULL; 6064 6065 p = vim_strchr((char_u *)environ[i], '='); 6066 return (p + 1); 6067 } 6068 # endif 6069 6070 #endif /* !defined(HAVE_SETENV) && !defined(HAVE_PUTENV) */ 6071 6072 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO) 6073 /* 6074 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have 6075 * rights to write into. 6076 */ 6077 int 6078 filewritable(char_u *fname) 6079 { 6080 int retval = 0; 6081 #if defined(UNIX) || defined(VMS) 6082 int perm = 0; 6083 #endif 6084 6085 #if defined(UNIX) || defined(VMS) 6086 perm = mch_getperm(fname); 6087 #endif 6088 if ( 6089 # ifdef WIN3264 6090 mch_writable(fname) && 6091 # else 6092 # if defined(UNIX) || defined(VMS) 6093 (perm & 0222) && 6094 # endif 6095 # endif 6096 mch_access((char *)fname, W_OK) == 0 6097 ) 6098 { 6099 ++retval; 6100 if (mch_isdir(fname)) 6101 ++retval; 6102 } 6103 return retval; 6104 } 6105 #endif 6106 6107 #if defined(FEAT_SPELL) || defined(FEAT_PERSISTENT_UNDO) || defined(PROTO) 6108 /* 6109 * Read 2 bytes from "fd" and turn them into an int, MSB first. 6110 */ 6111 int 6112 get2c(FILE *fd) 6113 { 6114 int n; 6115 6116 n = getc(fd); 6117 n = (n << 8) + getc(fd); 6118 return n; 6119 } 6120 6121 /* 6122 * Read 3 bytes from "fd" and turn them into an int, MSB first. 6123 */ 6124 int 6125 get3c(FILE *fd) 6126 { 6127 int n; 6128 6129 n = getc(fd); 6130 n = (n << 8) + getc(fd); 6131 n = (n << 8) + getc(fd); 6132 return n; 6133 } 6134 6135 /* 6136 * Read 4 bytes from "fd" and turn them into an int, MSB first. 6137 */ 6138 int 6139 get4c(FILE *fd) 6140 { 6141 /* Use unsigned rather than int otherwise result is undefined 6142 * when left-shift sets the MSB. */ 6143 unsigned n; 6144 6145 n = (unsigned)getc(fd); 6146 n = (n << 8) + (unsigned)getc(fd); 6147 n = (n << 8) + (unsigned)getc(fd); 6148 n = (n << 8) + (unsigned)getc(fd); 6149 return (int)n; 6150 } 6151 6152 /* 6153 * Read 8 bytes from "fd" and turn them into a time_T, MSB first. 6154 */ 6155 time_T 6156 get8ctime(FILE *fd) 6157 { 6158 time_T n = 0; 6159 int i; 6160 6161 for (i = 0; i < 8; ++i) 6162 n = (n << 8) + getc(fd); 6163 return n; 6164 } 6165 6166 /* 6167 * Read a string of length "cnt" from "fd" into allocated memory. 6168 * Returns NULL when out of memory or unable to read that many bytes. 6169 */ 6170 char_u * 6171 read_string(FILE *fd, int cnt) 6172 { 6173 char_u *str; 6174 int i; 6175 int c; 6176 6177 /* allocate memory */ 6178 str = alloc((unsigned)cnt + 1); 6179 if (str != NULL) 6180 { 6181 /* Read the string. Quit when running into the EOF. */ 6182 for (i = 0; i < cnt; ++i) 6183 { 6184 c = getc(fd); 6185 if (c == EOF) 6186 { 6187 vim_free(str); 6188 return NULL; 6189 } 6190 str[i] = c; 6191 } 6192 str[i] = NUL; 6193 } 6194 return str; 6195 } 6196 6197 /* 6198 * Write a number to file "fd", MSB first, in "len" bytes. 6199 */ 6200 int 6201 put_bytes(FILE *fd, long_u nr, int len) 6202 { 6203 int i; 6204 6205 for (i = len - 1; i >= 0; --i) 6206 if (putc((int)(nr >> (i * 8)), fd) == EOF) 6207 return FAIL; 6208 return OK; 6209 } 6210 6211 #ifdef _MSC_VER 6212 # if (_MSC_VER <= 1200) 6213 /* This line is required for VC6 without the service pack. Also see the 6214 * matching #pragma below. */ 6215 # pragma optimize("", off) 6216 # endif 6217 #endif 6218 6219 /* 6220 * Write time_T to file "fd" in 8 bytes. 6221 * Returns FAIL when the write failed. 6222 */ 6223 int 6224 put_time(FILE *fd, time_T the_time) 6225 { 6226 char_u buf[8]; 6227 6228 time_to_bytes(the_time, buf); 6229 return fwrite(buf, (size_t)8, (size_t)1, fd) == 1 ? OK : FAIL; 6230 } 6231 6232 /* 6233 * Write time_T to "buf[8]". 6234 */ 6235 void 6236 time_to_bytes(time_T the_time, char_u *buf) 6237 { 6238 int c; 6239 int i; 6240 int bi = 0; 6241 time_T wtime = the_time; 6242 6243 /* time_T can be up to 8 bytes in size, more than long_u, thus we 6244 * can't use put_bytes() here. 6245 * Another problem is that ">>" may do an arithmetic shift that keeps the 6246 * sign. This happens for large values of wtime. A cast to long_u may 6247 * truncate if time_T is 8 bytes. So only use a cast when it is 4 bytes, 6248 * it's safe to assume that long_u is 4 bytes or more and when using 8 6249 * bytes the top bit won't be set. */ 6250 for (i = 7; i >= 0; --i) 6251 { 6252 if (i + 1 > (int)sizeof(time_T)) 6253 /* ">>" doesn't work well when shifting more bits than avail */ 6254 buf[bi++] = 0; 6255 else 6256 { 6257 #if defined(SIZEOF_TIME_T) && SIZEOF_TIME_T > 4 6258 c = (int)(wtime >> (i * 8)); 6259 #else 6260 c = (int)((long_u)wtime >> (i * 8)); 6261 #endif 6262 buf[bi++] = c; 6263 } 6264 } 6265 } 6266 6267 #ifdef _MSC_VER 6268 # if (_MSC_VER <= 1200) 6269 # pragma optimize("", on) 6270 # endif 6271 #endif 6272 6273 #endif 6274 6275 #if (defined(FEAT_MBYTE) && defined(FEAT_QUICKFIX)) \ 6276 || defined(FEAT_SPELL) || defined(PROTO) 6277 /* 6278 * Return TRUE if string "s" contains a non-ASCII character (128 or higher). 6279 * When "s" is NULL FALSE is returned. 6280 */ 6281 int 6282 has_non_ascii(char_u *s) 6283 { 6284 char_u *p; 6285 6286 if (s != NULL) 6287 for (p = s; *p != NUL; ++p) 6288 if (*p >= 128) 6289 return TRUE; 6290 return FALSE; 6291 } 6292 #endif 6293 6294 #if defined(MESSAGE_QUEUE) || defined(PROTO) 6295 /* 6296 * Process messages that have been queued for netbeans or clientserver. 6297 * Also check if any jobs have ended. 6298 * These functions can call arbitrary vimscript and should only be called when 6299 * it is safe to do so. 6300 */ 6301 void 6302 parse_queued_messages(void) 6303 { 6304 win_T *old_curwin = curwin; 6305 6306 /* For Win32 mch_breakcheck() does not check for input, do it here. */ 6307 # if defined(WIN32) && defined(FEAT_JOB_CHANNEL) 6308 channel_handle_events(FALSE); 6309 # endif 6310 6311 # ifdef FEAT_NETBEANS_INTG 6312 /* Process the queued netbeans messages. */ 6313 netbeans_parse_messages(); 6314 # endif 6315 # ifdef FEAT_JOB_CHANNEL 6316 /* Write any buffer lines still to be written. */ 6317 channel_write_any_lines(); 6318 6319 /* Process the messages queued on channels. */ 6320 channel_parse_messages(); 6321 # endif 6322 # if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11) 6323 /* Process the queued clientserver messages. */ 6324 server_parse_messages(); 6325 # endif 6326 # ifdef FEAT_JOB_CHANNEL 6327 /* Check if any jobs have ended. */ 6328 job_check_ended(); 6329 # endif 6330 6331 /* If the current window changed we need to bail out of the waiting loop. 6332 * E.g. when a job exit callback closes the terminal window. */ 6333 if (curwin != old_curwin) 6334 ins_char_typebuf(K_IGNORE); 6335 } 6336 #endif 6337 6338 #ifndef PROTO /* proto is defined in vim.h */ 6339 # ifdef ELAPSED_TIMEVAL 6340 /* 6341 * Return time in msec since "start_tv". 6342 */ 6343 long 6344 elapsed(struct timeval *start_tv) 6345 { 6346 struct timeval now_tv; 6347 6348 gettimeofday(&now_tv, NULL); 6349 return (now_tv.tv_sec - start_tv->tv_sec) * 1000L 6350 + (now_tv.tv_usec - start_tv->tv_usec) / 1000L; 6351 } 6352 # endif 6353 6354 # ifdef ELAPSED_TICKCOUNT 6355 /* 6356 * Return time in msec since "start_tick". 6357 */ 6358 long 6359 elapsed(DWORD start_tick) 6360 { 6361 DWORD now = GetTickCount(); 6362 6363 return (long)now - (long)start_tick; 6364 } 6365 # endif 6366 #endif 6367