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 * scriptfile.c: functions for dealing with the runtime directories/files 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_EVAL) || defined(PROTO) 17 // The names of packages that once were loaded are remembered. 18 static garray_T ga_loaded = {0, 0, sizeof(char_u *), 4, NULL}; 19 #endif 20 21 /* 22 * Initialize the execution stack. 23 */ 24 void 25 estack_init(void) 26 { 27 estack_T *entry; 28 29 if (ga_grow(&exestack, 10) == FAIL) 30 mch_exit(0); 31 entry = ((estack_T *)exestack.ga_data) + exestack.ga_len; 32 entry->es_type = ETYPE_TOP; 33 entry->es_name = NULL; 34 entry->es_lnum = 0; 35 #ifdef FEAT_EVAL 36 entry->es_info.ufunc = NULL; 37 #endif 38 ++exestack.ga_len; 39 } 40 41 /* 42 * Add an item to the execution stack. 43 * Returns the new entry or NULL when out of memory. 44 */ 45 estack_T * 46 estack_push(etype_T type, char_u *name, long lnum) 47 { 48 estack_T *entry; 49 50 // If memory allocation fails then we'll pop more than we push, eventually 51 // at the top level it will be OK again. 52 if (ga_grow(&exestack, 1) == OK) 53 { 54 entry = ((estack_T *)exestack.ga_data) + exestack.ga_len; 55 entry->es_type = type; 56 entry->es_name = name; 57 entry->es_lnum = lnum; 58 #ifdef FEAT_EVAL 59 entry->es_info.ufunc = NULL; 60 #endif 61 ++exestack.ga_len; 62 return entry; 63 } 64 return NULL; 65 } 66 67 #if defined(FEAT_EVAL) || defined(PROTO) 68 /* 69 * Add a user function to the execution stack. 70 */ 71 void 72 estack_push_ufunc(etype_T type, ufunc_T *ufunc, long lnum) 73 { 74 estack_T *entry = estack_push(type, 75 ufunc->uf_name_exp != NULL 76 ? ufunc->uf_name_exp : ufunc->uf_name, lnum); 77 if (entry != NULL) 78 entry->es_info.ufunc = ufunc; 79 } 80 #endif 81 82 /* 83 * Take an item off of the execution stack. 84 */ 85 void 86 estack_pop(void) 87 { 88 if (exestack.ga_len > 1) 89 --exestack.ga_len; 90 } 91 92 /* 93 * Get the current value for <sfile> in allocated memory. 94 */ 95 char_u * 96 estack_sfile(void) 97 { 98 estack_T *entry; 99 #ifdef FEAT_EVAL 100 size_t len; 101 int idx; 102 char *res; 103 size_t done; 104 #endif 105 106 entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1; 107 if (entry->es_name == NULL) 108 return NULL; 109 #ifdef FEAT_EVAL 110 if (entry->es_info.ufunc == NULL) 111 #endif 112 return vim_strsave(entry->es_name); 113 114 #ifdef FEAT_EVAL 115 // For a function we compose the call stack, as it was done in the past: 116 // "function One[123]..Two[456]..Three" 117 len = STRLEN(entry->es_name) + 10; 118 for (idx = exestack.ga_len - 2; idx >= 0; --idx) 119 { 120 entry = ((estack_T *)exestack.ga_data) + idx; 121 if (entry->es_name == NULL || entry->es_info.ufunc == NULL) 122 { 123 ++idx; 124 break; 125 } 126 len += STRLEN(entry->es_name) + 15; 127 } 128 129 res = (char *)alloc((int)len); 130 if (res != NULL) 131 { 132 STRCPY(res, "function "); 133 while (idx < exestack.ga_len - 1) 134 { 135 done = STRLEN(res); 136 entry = ((estack_T *)exestack.ga_data) + idx; 137 vim_snprintf(res + done, len - done, "%s[%ld]..", 138 entry->es_name, entry->es_lnum); 139 ++idx; 140 } 141 done = STRLEN(res); 142 entry = ((estack_T *)exestack.ga_data) + idx; 143 vim_snprintf(res + done, len - done, "%s", entry->es_name); 144 } 145 return (char_u *)res; 146 #endif 147 } 148 149 /* 150 * ":runtime [what] {name}" 151 */ 152 void 153 ex_runtime(exarg_T *eap) 154 { 155 char_u *arg = eap->arg; 156 char_u *p = skiptowhite(arg); 157 int len = (int)(p - arg); 158 int flags = eap->forceit ? DIP_ALL : 0; 159 160 if (STRNCMP(arg, "START", len) == 0) 161 { 162 flags += DIP_START + DIP_NORTP; 163 arg = skipwhite(arg + len); 164 } 165 else if (STRNCMP(arg, "OPT", len) == 0) 166 { 167 flags += DIP_OPT + DIP_NORTP; 168 arg = skipwhite(arg + len); 169 } 170 else if (STRNCMP(arg, "PACK", len) == 0) 171 { 172 flags += DIP_START + DIP_OPT + DIP_NORTP; 173 arg = skipwhite(arg + len); 174 } 175 else if (STRNCMP(arg, "ALL", len) == 0) 176 { 177 flags += DIP_START + DIP_OPT; 178 arg = skipwhite(arg + len); 179 } 180 181 source_runtime(arg, flags); 182 } 183 184 static void 185 source_callback(char_u *fname, void *cookie) 186 { 187 (void)do_source(fname, FALSE, DOSO_NONE, cookie); 188 } 189 190 /* 191 * Find the file "name" in all directories in "path" and invoke 192 * "callback(fname, cookie)". 193 * "name" can contain wildcards. 194 * When "flags" has DIP_ALL: source all files, otherwise only the first one. 195 * When "flags" has DIP_DIR: find directories instead of files. 196 * When "flags" has DIP_ERR: give an error message if there is no match. 197 * 198 * return FAIL when no file could be sourced, OK otherwise. 199 */ 200 int 201 do_in_path( 202 char_u *path, 203 char_u *name, 204 int flags, 205 void (*callback)(char_u *fname, void *ck), 206 void *cookie) 207 { 208 char_u *rtp; 209 char_u *np; 210 char_u *buf; 211 char_u *rtp_copy; 212 char_u *tail; 213 int num_files; 214 char_u **files; 215 int i; 216 int did_one = FALSE; 217 #ifdef AMIGA 218 struct Process *proc = (struct Process *)FindTask(0L); 219 APTR save_winptr = proc->pr_WindowPtr; 220 221 // Avoid a requester here for a volume that doesn't exist. 222 proc->pr_WindowPtr = (APTR)-1L; 223 #endif 224 225 // Make a copy of 'runtimepath'. Invoking the callback may change the 226 // value. 227 rtp_copy = vim_strsave(path); 228 buf = alloc(MAXPATHL); 229 if (buf != NULL && rtp_copy != NULL) 230 { 231 if (p_verbose > 10 && name != NULL) 232 { 233 verbose_enter(); 234 smsg(_("Searching for \"%s\" in \"%s\""), 235 (char *)name, (char *)path); 236 verbose_leave(); 237 } 238 239 // Loop over all entries in 'runtimepath'. 240 rtp = rtp_copy; 241 while (*rtp != NUL && ((flags & DIP_ALL) || !did_one)) 242 { 243 size_t buflen; 244 245 // Copy the path from 'runtimepath' to buf[]. 246 copy_option_part(&rtp, buf, MAXPATHL, ","); 247 buflen = STRLEN(buf); 248 249 // Skip after or non-after directories. 250 if (flags & (DIP_NOAFTER | DIP_AFTER)) 251 { 252 int is_after = buflen >= 5 253 && STRCMP(buf + buflen - 5, "after") == 0; 254 255 if ((is_after && (flags & DIP_NOAFTER)) 256 || (!is_after && (flags & DIP_AFTER))) 257 continue; 258 } 259 260 if (name == NULL) 261 { 262 (*callback)(buf, (void *) &cookie); 263 if (!did_one) 264 did_one = (cookie == NULL); 265 } 266 else if (buflen + STRLEN(name) + 2 < MAXPATHL) 267 { 268 add_pathsep(buf); 269 tail = buf + STRLEN(buf); 270 271 // Loop over all patterns in "name" 272 np = name; 273 while (*np != NUL && ((flags & DIP_ALL) || !did_one)) 274 { 275 // Append the pattern from "name" to buf[]. 276 copy_option_part(&np, tail, (int)(MAXPATHL - (tail - buf)), 277 "\t "); 278 279 if (p_verbose > 10) 280 { 281 verbose_enter(); 282 smsg(_("Searching for \"%s\""), buf); 283 verbose_leave(); 284 } 285 286 // Expand wildcards, invoke the callback for each match. 287 if (gen_expand_wildcards(1, &buf, &num_files, &files, 288 (flags & DIP_DIR) ? EW_DIR : EW_FILE) == OK) 289 { 290 for (i = 0; i < num_files; ++i) 291 { 292 (*callback)(files[i], cookie); 293 did_one = TRUE; 294 if (!(flags & DIP_ALL)) 295 break; 296 } 297 FreeWild(num_files, files); 298 } 299 } 300 } 301 } 302 } 303 vim_free(buf); 304 vim_free(rtp_copy); 305 if (!did_one && name != NULL) 306 { 307 char *basepath = path == p_rtp ? "runtimepath" : "packpath"; 308 309 if (flags & DIP_ERR) 310 semsg(_(e_dirnotf), basepath, name); 311 else if (p_verbose > 0) 312 { 313 verbose_enter(); 314 smsg(_("not found in '%s': \"%s\""), basepath, name); 315 verbose_leave(); 316 } 317 } 318 319 #ifdef AMIGA 320 proc->pr_WindowPtr = save_winptr; 321 #endif 322 323 return did_one ? OK : FAIL; 324 } 325 326 /* 327 * Find "name" in "path". When found, invoke the callback function for 328 * it: callback(fname, "cookie") 329 * When "flags" has DIP_ALL repeat for all matches, otherwise only the first 330 * one is used. 331 * Returns OK when at least one match found, FAIL otherwise. 332 * 333 * If "name" is NULL calls callback for each entry in "path". Cookie is 334 * passed by reference in this case, setting it to NULL indicates that callback 335 * has done its job. 336 */ 337 static int 338 do_in_path_and_pp( 339 char_u *path, 340 char_u *name, 341 int flags, 342 void (*callback)(char_u *fname, void *ck), 343 void *cookie) 344 { 345 int done = FAIL; 346 char_u *s; 347 int len; 348 char *start_dir = "pack/*/start/*/%s"; 349 char *opt_dir = "pack/*/opt/*/%s"; 350 351 if ((flags & DIP_NORTP) == 0) 352 done = do_in_path(path, name, flags, callback, cookie); 353 354 if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_START)) 355 { 356 len = (int)(STRLEN(start_dir) + STRLEN(name)); 357 s = alloc(len); 358 if (s == NULL) 359 return FAIL; 360 vim_snprintf((char *)s, len, start_dir, name); 361 done = do_in_path(p_pp, s, flags, callback, cookie); 362 vim_free(s); 363 } 364 365 if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_OPT)) 366 { 367 len = (int)(STRLEN(opt_dir) + STRLEN(name)); 368 s = alloc(len); 369 if (s == NULL) 370 return FAIL; 371 vim_snprintf((char *)s, len, opt_dir, name); 372 done = do_in_path(p_pp, s, flags, callback, cookie); 373 vim_free(s); 374 } 375 376 return done; 377 } 378 379 /* 380 * Just like do_in_path_and_pp(), using 'runtimepath' for "path". 381 */ 382 int 383 do_in_runtimepath( 384 char_u *name, 385 int flags, 386 void (*callback)(char_u *fname, void *ck), 387 void *cookie) 388 { 389 return do_in_path_and_pp(p_rtp, name, flags, callback, cookie); 390 } 391 392 /* 393 * Source the file "name" from all directories in 'runtimepath'. 394 * "name" can contain wildcards. 395 * When "flags" has DIP_ALL: source all files, otherwise only the first one. 396 * 397 * return FAIL when no file could be sourced, OK otherwise. 398 */ 399 int 400 source_runtime(char_u *name, int flags) 401 { 402 return source_in_path(p_rtp, name, flags, NULL); 403 } 404 405 /* 406 * Just like source_runtime(), but use "path" instead of 'runtimepath'. 407 */ 408 int 409 source_in_path(char_u *path, char_u *name, int flags, int *ret_sid) 410 { 411 return do_in_path_and_pp(path, name, flags, source_callback, ret_sid); 412 } 413 414 415 #if defined(FEAT_EVAL) || defined(PROTO) 416 417 /* 418 * Expand wildcards in "pat" and invoke do_source() for each match. 419 */ 420 static void 421 source_all_matches(char_u *pat) 422 { 423 int num_files; 424 char_u **files; 425 int i; 426 427 if (gen_expand_wildcards(1, &pat, &num_files, &files, EW_FILE) == OK) 428 { 429 for (i = 0; i < num_files; ++i) 430 (void)do_source(files[i], FALSE, DOSO_NONE, NULL); 431 FreeWild(num_files, files); 432 } 433 } 434 435 /* 436 * Add the package directory to 'runtimepath'. 437 */ 438 static int 439 add_pack_dir_to_rtp(char_u *fname) 440 { 441 char_u *p4, *p3, *p2, *p1, *p; 442 char_u *entry; 443 char_u *insp = NULL; 444 int c; 445 char_u *new_rtp; 446 int keep; 447 size_t oldlen; 448 size_t addlen; 449 size_t new_rtp_len; 450 char_u *afterdir = NULL; 451 size_t afterlen = 0; 452 char_u *after_insp = NULL; 453 char_u *ffname = NULL; 454 size_t fname_len; 455 char_u *buf = NULL; 456 char_u *rtp_ffname; 457 int match; 458 int retval = FAIL; 459 460 p4 = p3 = p2 = p1 = get_past_head(fname); 461 for (p = p1; *p; MB_PTR_ADV(p)) 462 if (vim_ispathsep_nocolon(*p)) 463 { 464 p4 = p3; p3 = p2; p2 = p1; p1 = p; 465 } 466 467 // now we have: 468 // rtp/pack/name/start/name 469 // p4 p3 p2 p1 470 // 471 // find the part up to "pack" in 'runtimepath' 472 c = *++p4; // append pathsep in order to expand symlink 473 *p4 = NUL; 474 ffname = fix_fname(fname); 475 *p4 = c; 476 if (ffname == NULL) 477 return FAIL; 478 479 // Find "ffname" in "p_rtp", ignoring '/' vs '\' differences. 480 // Also stop at the first "after" directory. 481 fname_len = STRLEN(ffname); 482 buf = alloc(MAXPATHL); 483 if (buf == NULL) 484 goto theend; 485 for (entry = p_rtp; *entry != NUL; ) 486 { 487 char_u *cur_entry = entry; 488 489 copy_option_part(&entry, buf, MAXPATHL, ","); 490 if (insp == NULL) 491 { 492 add_pathsep(buf); 493 rtp_ffname = fix_fname(buf); 494 if (rtp_ffname == NULL) 495 goto theend; 496 match = vim_fnamencmp(rtp_ffname, ffname, fname_len) == 0; 497 vim_free(rtp_ffname); 498 if (match) 499 // Insert "ffname" after this entry (and comma). 500 insp = entry; 501 } 502 503 if ((p = (char_u *)strstr((char *)buf, "after")) != NULL 504 && p > buf 505 && vim_ispathsep(p[-1]) 506 && (vim_ispathsep(p[5]) || p[5] == NUL || p[5] == ',')) 507 { 508 if (insp == NULL) 509 // Did not find "ffname" before the first "after" directory, 510 // insert it before this entry. 511 insp = cur_entry; 512 after_insp = cur_entry; 513 break; 514 } 515 } 516 517 if (insp == NULL) 518 // Both "fname" and "after" not found, append at the end. 519 insp = p_rtp + STRLEN(p_rtp); 520 521 // check if rtp/pack/name/start/name/after exists 522 afterdir = concat_fnames(fname, (char_u *)"after", TRUE); 523 if (afterdir != NULL && mch_isdir(afterdir)) 524 afterlen = STRLEN(afterdir) + 1; // add one for comma 525 526 oldlen = STRLEN(p_rtp); 527 addlen = STRLEN(fname) + 1; // add one for comma 528 new_rtp = alloc(oldlen + addlen + afterlen + 1); // add one for NUL 529 if (new_rtp == NULL) 530 goto theend; 531 532 // We now have 'rtp' parts: {keep}{keep_after}{rest}. 533 // Create new_rtp, first: {keep},{fname} 534 keep = (int)(insp - p_rtp); 535 mch_memmove(new_rtp, p_rtp, keep); 536 new_rtp_len = keep; 537 if (*insp == NUL) 538 new_rtp[new_rtp_len++] = ','; // add comma before 539 mch_memmove(new_rtp + new_rtp_len, fname, addlen - 1); 540 new_rtp_len += addlen - 1; 541 if (*insp != NUL) 542 new_rtp[new_rtp_len++] = ','; // add comma after 543 544 if (afterlen > 0 && after_insp != NULL) 545 { 546 int keep_after = (int)(after_insp - p_rtp); 547 548 // Add to new_rtp: {keep},{fname}{keep_after},{afterdir} 549 mch_memmove(new_rtp + new_rtp_len, p_rtp + keep, 550 keep_after - keep); 551 new_rtp_len += keep_after - keep; 552 mch_memmove(new_rtp + new_rtp_len, afterdir, afterlen - 1); 553 new_rtp_len += afterlen - 1; 554 new_rtp[new_rtp_len++] = ','; 555 keep = keep_after; 556 } 557 558 if (p_rtp[keep] != NUL) 559 // Append rest: {keep},{fname}{keep_after},{afterdir}{rest} 560 mch_memmove(new_rtp + new_rtp_len, p_rtp + keep, oldlen - keep + 1); 561 else 562 new_rtp[new_rtp_len] = NUL; 563 564 if (afterlen > 0 && after_insp == NULL) 565 { 566 // Append afterdir when "after" was not found: 567 // {keep},{fname}{rest},{afterdir} 568 STRCAT(new_rtp, ","); 569 STRCAT(new_rtp, afterdir); 570 } 571 572 set_option_value((char_u *)"rtp", 0L, new_rtp, 0); 573 vim_free(new_rtp); 574 retval = OK; 575 576 theend: 577 vim_free(buf); 578 vim_free(ffname); 579 vim_free(afterdir); 580 return retval; 581 } 582 583 /* 584 * Load scripts in "plugin" and "ftdetect" directories of the package. 585 */ 586 static int 587 load_pack_plugin(char_u *fname) 588 { 589 static char *plugpat = "%s/plugin/**/*.vim"; 590 static char *ftpat = "%s/ftdetect/*.vim"; 591 int len; 592 char_u *ffname = fix_fname(fname); 593 char_u *pat = NULL; 594 int retval = FAIL; 595 596 if (ffname == NULL) 597 return FAIL; 598 len = (int)STRLEN(ffname) + (int)STRLEN(ftpat); 599 pat = alloc(len); 600 if (pat == NULL) 601 goto theend; 602 vim_snprintf((char *)pat, len, plugpat, ffname); 603 source_all_matches(pat); 604 605 { 606 char_u *cmd = vim_strsave((char_u *)"g:did_load_filetypes"); 607 608 // If runtime/filetype.vim wasn't loaded yet, the scripts will be 609 // found when it loads. 610 if (cmd != NULL && eval_to_number(cmd) > 0) 611 { 612 do_cmdline_cmd((char_u *)"augroup filetypedetect"); 613 vim_snprintf((char *)pat, len, ftpat, ffname); 614 source_all_matches(pat); 615 do_cmdline_cmd((char_u *)"augroup END"); 616 } 617 vim_free(cmd); 618 } 619 vim_free(pat); 620 retval = OK; 621 622 theend: 623 vim_free(ffname); 624 return retval; 625 } 626 627 // used for "cookie" of add_pack_plugin() 628 static int APP_ADD_DIR; 629 static int APP_LOAD; 630 static int APP_BOTH; 631 632 static void 633 add_pack_plugin(char_u *fname, void *cookie) 634 { 635 if (cookie != &APP_LOAD) 636 { 637 char_u *buf = alloc(MAXPATHL); 638 char_u *p; 639 int found = FALSE; 640 641 if (buf == NULL) 642 return; 643 p = p_rtp; 644 while (*p != NUL) 645 { 646 copy_option_part(&p, buf, MAXPATHL, ","); 647 if (pathcmp((char *)buf, (char *)fname, -1) == 0) 648 { 649 found = TRUE; 650 break; 651 } 652 } 653 vim_free(buf); 654 if (!found) 655 // directory is not yet in 'runtimepath', add it 656 if (add_pack_dir_to_rtp(fname) == FAIL) 657 return; 658 } 659 660 if (cookie != &APP_ADD_DIR) 661 load_pack_plugin(fname); 662 } 663 664 /* 665 * Add all packages in the "start" directory to 'runtimepath'. 666 */ 667 void 668 add_pack_start_dirs(void) 669 { 670 do_in_path(p_pp, (char_u *)"pack/*/start/*", DIP_ALL + DIP_DIR, 671 add_pack_plugin, &APP_ADD_DIR); 672 } 673 674 /* 675 * Load plugins from all packages in the "start" directory. 676 */ 677 void 678 load_start_packages(void) 679 { 680 did_source_packages = TRUE; 681 do_in_path(p_pp, (char_u *)"pack/*/start/*", DIP_ALL + DIP_DIR, 682 add_pack_plugin, &APP_LOAD); 683 } 684 685 /* 686 * ":packloadall" 687 * Find plugins in the package directories and source them. 688 */ 689 void 690 ex_packloadall(exarg_T *eap) 691 { 692 if (!did_source_packages || eap->forceit) 693 { 694 // First do a round to add all directories to 'runtimepath', then load 695 // the plugins. This allows for plugins to use an autoload directory 696 // of another plugin. 697 add_pack_start_dirs(); 698 load_start_packages(); 699 } 700 } 701 702 /* 703 * ":packadd[!] {name}" 704 */ 705 void 706 ex_packadd(exarg_T *eap) 707 { 708 static char *plugpat = "pack/*/%s/%s"; 709 int len; 710 char *pat; 711 int round; 712 int res = OK; 713 714 // Round 1: use "start", round 2: use "opt". 715 for (round = 1; round <= 2; ++round) 716 { 717 // Only look under "start" when loading packages wasn't done yet. 718 if (round == 1 && did_source_packages) 719 continue; 720 721 len = (int)STRLEN(plugpat) + (int)STRLEN(eap->arg) + 5; 722 pat = alloc(len); 723 if (pat == NULL) 724 return; 725 vim_snprintf(pat, len, plugpat, round == 1 ? "start" : "opt", eap->arg); 726 // The first round don't give a "not found" error, in the second round 727 // only when nothing was found in the first round. 728 res = do_in_path(p_pp, (char_u *)pat, 729 DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0), 730 add_pack_plugin, eap->forceit ? &APP_ADD_DIR : &APP_BOTH); 731 vim_free(pat); 732 } 733 } 734 #endif 735 736 /* 737 * Sort "gap" and remove duplicate entries. "gap" is expected to contain a 738 * list of file names in allocated memory. 739 */ 740 void 741 remove_duplicates(garray_T *gap) 742 { 743 int i; 744 int j; 745 char_u **fnames = (char_u **)gap->ga_data; 746 747 sort_strings(fnames, gap->ga_len); 748 for (i = gap->ga_len - 1; i > 0; --i) 749 if (fnamecmp(fnames[i - 1], fnames[i]) == 0) 750 { 751 vim_free(fnames[i]); 752 for (j = i + 1; j < gap->ga_len; ++j) 753 fnames[j - 1] = fnames[j]; 754 --gap->ga_len; 755 } 756 } 757 758 /* 759 * Expand color scheme, compiler or filetype names. 760 * Search from 'runtimepath': 761 * 'runtimepath'/{dirnames}/{pat}.vim 762 * When "flags" has DIP_START: search also from 'start' of 'packpath': 763 * 'packpath'/pack/ * /start/ * /{dirnames}/{pat}.vim 764 * When "flags" has DIP_OPT: search also from 'opt' of 'packpath': 765 * 'packpath'/pack/ * /opt/ * /{dirnames}/{pat}.vim 766 * "dirnames" is an array with one or more directory names. 767 */ 768 int 769 ExpandRTDir( 770 char_u *pat, 771 int flags, 772 int *num_file, 773 char_u ***file, 774 char *dirnames[]) 775 { 776 char_u *s; 777 char_u *e; 778 char_u *match; 779 garray_T ga; 780 int i; 781 int pat_len; 782 783 *num_file = 0; 784 *file = NULL; 785 pat_len = (int)STRLEN(pat); 786 ga_init2(&ga, (int)sizeof(char *), 10); 787 788 for (i = 0; dirnames[i] != NULL; ++i) 789 { 790 s = alloc(STRLEN(dirnames[i]) + pat_len + 7); 791 if (s == NULL) 792 { 793 ga_clear_strings(&ga); 794 return FAIL; 795 } 796 sprintf((char *)s, "%s/%s*.vim", dirnames[i], pat); 797 globpath(p_rtp, s, &ga, 0); 798 vim_free(s); 799 } 800 801 if (flags & DIP_START) { 802 for (i = 0; dirnames[i] != NULL; ++i) 803 { 804 s = alloc(STRLEN(dirnames[i]) + pat_len + 22); 805 if (s == NULL) 806 { 807 ga_clear_strings(&ga); 808 return FAIL; 809 } 810 sprintf((char *)s, "pack/*/start/*/%s/%s*.vim", dirnames[i], pat); 811 globpath(p_pp, s, &ga, 0); 812 vim_free(s); 813 } 814 } 815 816 if (flags & DIP_OPT) { 817 for (i = 0; dirnames[i] != NULL; ++i) 818 { 819 s = alloc(STRLEN(dirnames[i]) + pat_len + 20); 820 if (s == NULL) 821 { 822 ga_clear_strings(&ga); 823 return FAIL; 824 } 825 sprintf((char *)s, "pack/*/opt/*/%s/%s*.vim", dirnames[i], pat); 826 globpath(p_pp, s, &ga, 0); 827 vim_free(s); 828 } 829 } 830 831 for (i = 0; i < ga.ga_len; ++i) 832 { 833 match = ((char_u **)ga.ga_data)[i]; 834 s = match; 835 e = s + STRLEN(s); 836 if (e - 4 > s && STRNICMP(e - 4, ".vim", 4) == 0) 837 { 838 e -= 4; 839 for (s = e; s > match; MB_PTR_BACK(match, s)) 840 if (s < match || vim_ispathsep(*s)) 841 break; 842 ++s; 843 *e = NUL; 844 mch_memmove(match, s, e - s + 1); 845 } 846 } 847 848 if (ga.ga_len == 0) 849 return FAIL; 850 851 // Sort and remove duplicates which can happen when specifying multiple 852 // directories in dirnames. 853 remove_duplicates(&ga); 854 855 *file = ga.ga_data; 856 *num_file = ga.ga_len; 857 return OK; 858 } 859 860 /* 861 * Expand loadplugin names: 862 * 'packpath'/pack/ * /opt/{pat} 863 */ 864 int 865 ExpandPackAddDir( 866 char_u *pat, 867 int *num_file, 868 char_u ***file) 869 { 870 char_u *s; 871 char_u *e; 872 char_u *match; 873 garray_T ga; 874 int i; 875 int pat_len; 876 877 *num_file = 0; 878 *file = NULL; 879 pat_len = (int)STRLEN(pat); 880 ga_init2(&ga, (int)sizeof(char *), 10); 881 882 s = alloc(pat_len + 26); 883 if (s == NULL) 884 { 885 ga_clear_strings(&ga); 886 return FAIL; 887 } 888 sprintf((char *)s, "pack/*/opt/%s*", pat); 889 globpath(p_pp, s, &ga, 0); 890 vim_free(s); 891 892 for (i = 0; i < ga.ga_len; ++i) 893 { 894 match = ((char_u **)ga.ga_data)[i]; 895 s = gettail(match); 896 e = s + STRLEN(s); 897 mch_memmove(match, s, e - s + 1); 898 } 899 900 if (ga.ga_len == 0) 901 return FAIL; 902 903 // Sort and remove duplicates which can happen when specifying multiple 904 // directories in dirnames. 905 remove_duplicates(&ga); 906 907 *file = ga.ga_data; 908 *num_file = ga.ga_len; 909 return OK; 910 } 911 912 static void 913 cmd_source(char_u *fname, exarg_T *eap) 914 { 915 if (*fname == NUL) 916 emsg(_(e_argreq)); 917 918 else if (eap != NULL && eap->forceit) 919 // ":source!": read Normal mode commands 920 // Need to execute the commands directly. This is required at least 921 // for: 922 // - ":g" command busy 923 // - after ":argdo", ":windo" or ":bufdo" 924 // - another command follows 925 // - inside a loop 926 openscript(fname, global_busy || listcmd_busy || eap->nextcmd != NULL 927 #ifdef FEAT_EVAL 928 || eap->cstack->cs_idx >= 0 929 #endif 930 ); 931 932 // ":source" read ex commands 933 else if (do_source(fname, FALSE, DOSO_NONE, NULL) == FAIL) 934 semsg(_(e_notopen), fname); 935 } 936 937 /* 938 * ":source {fname}" 939 */ 940 void 941 ex_source(exarg_T *eap) 942 { 943 #ifdef FEAT_BROWSE 944 if (cmdmod.browse) 945 { 946 char_u *fname = NULL; 947 948 fname = do_browse(0, (char_u *)_("Source Vim script"), eap->arg, 949 NULL, NULL, 950 (char_u *)_(BROWSE_FILTER_MACROS), NULL); 951 if (fname != NULL) 952 { 953 cmd_source(fname, eap); 954 vim_free(fname); 955 } 956 } 957 else 958 #endif 959 cmd_source(eap->arg, eap); 960 } 961 962 #if defined(FEAT_EVAL) || defined(PROTO) 963 /* 964 * ":options" 965 */ 966 void 967 ex_options( 968 exarg_T *eap UNUSED) 969 { 970 char_u buf[500]; 971 int multi_mods = 0; 972 973 buf[0] = NUL; 974 (void)add_win_cmd_modifers(buf, &multi_mods); 975 976 vim_setenv((char_u *)"OPTWIN_CMD", buf); 977 cmd_source((char_u *)SYS_OPTWIN_FILE, NULL); 978 } 979 #endif 980 981 /* 982 * ":source" and associated commands. 983 */ 984 /* 985 * Structure used to store info for each sourced file. 986 * It is shared between do_source() and getsourceline(). 987 * This is required, because it needs to be handed to do_cmdline() and 988 * sourcing can be done recursively. 989 */ 990 struct source_cookie 991 { 992 FILE *fp; // opened file for sourcing 993 char_u *nextline; // if not NULL: line that was read ahead 994 linenr_T sourcing_lnum; // line number of the source file 995 int finished; // ":finish" used 996 #ifdef USE_CRNL 997 int fileformat; // EOL_UNKNOWN, EOL_UNIX or EOL_DOS 998 int error; // TRUE if LF found after CR-LF 999 #endif 1000 #ifdef FEAT_EVAL 1001 garray_T lines_ga; // lines read in previous pass 1002 int use_lines_ga; // next line to get from "lines_ga" 1003 linenr_T breakpoint; // next line with breakpoint or zero 1004 char_u *fname; // name of sourced file 1005 int dbg_tick; // debug_tick when breakpoint was set 1006 int level; // top nesting level of sourced file 1007 #endif 1008 vimconv_T conv; // type of conversion 1009 }; 1010 1011 #ifdef FEAT_EVAL 1012 /* 1013 * Return the address holding the next breakpoint line for a source cookie. 1014 */ 1015 linenr_T * 1016 source_breakpoint(void *cookie) 1017 { 1018 return &((struct source_cookie *)cookie)->breakpoint; 1019 } 1020 1021 /* 1022 * Get the grow array to store script lines in. 1023 */ 1024 garray_T * 1025 source_get_line_ga(void *cookie) 1026 { 1027 return &((struct source_cookie *)cookie)->lines_ga; 1028 } 1029 1030 /* 1031 * Set the index to start reading from the grow array with script lines. 1032 */ 1033 void 1034 source_use_line_ga(void *cookie) 1035 { 1036 ((struct source_cookie *)cookie)->use_lines_ga = 0; 1037 } 1038 1039 /* 1040 * Return the address holding the debug tick for a source cookie. 1041 */ 1042 int * 1043 source_dbg_tick(void *cookie) 1044 { 1045 return &((struct source_cookie *)cookie)->dbg_tick; 1046 } 1047 1048 /* 1049 * Return the nesting level for a source cookie. 1050 */ 1051 int 1052 source_level(void *cookie) 1053 { 1054 return ((struct source_cookie *)cookie)->level; 1055 } 1056 #endif 1057 1058 #if (defined(MSWIN) && defined(FEAT_CSCOPE)) || defined(HAVE_FD_CLOEXEC) 1059 # define USE_FOPEN_NOINH 1060 /* 1061 * Special function to open a file without handle inheritance. 1062 * When possible the handle is closed on exec(). 1063 */ 1064 static FILE * 1065 fopen_noinh_readbin(char *filename) 1066 { 1067 # ifdef MSWIN 1068 int fd_tmp = mch_open(filename, O_RDONLY | O_BINARY | O_NOINHERIT, 0); 1069 # else 1070 int fd_tmp = mch_open(filename, O_RDONLY, 0); 1071 # endif 1072 1073 if (fd_tmp == -1) 1074 return NULL; 1075 1076 # ifdef HAVE_FD_CLOEXEC 1077 { 1078 int fdflags = fcntl(fd_tmp, F_GETFD); 1079 if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0) 1080 (void)fcntl(fd_tmp, F_SETFD, fdflags | FD_CLOEXEC); 1081 } 1082 # endif 1083 1084 return fdopen(fd_tmp, READBIN); 1085 } 1086 #endif 1087 1088 /* 1089 * do_source: Read the file "fname" and execute its lines as EX commands. 1090 * When "ret_sid" is not NULL and we loaded the script before, don't load it 1091 * again. 1092 * 1093 * This function may be called recursively! 1094 * 1095 * Return FAIL if file could not be opened, OK otherwise. 1096 * If a scriptitem_T was found or created "*ret_sid" is set to the SID. 1097 */ 1098 int 1099 do_source( 1100 char_u *fname, 1101 int check_other, // check for .vimrc and _vimrc 1102 int is_vimrc, // DOSO_ value 1103 int *ret_sid UNUSED) 1104 { 1105 struct source_cookie cookie; 1106 char_u *p; 1107 char_u *fname_exp; 1108 char_u *firstline = NULL; 1109 int retval = FAIL; 1110 #ifdef FEAT_EVAL 1111 sctx_T save_current_sctx; 1112 static scid_T last_current_SID = 0; 1113 static int last_current_SID_seq = 0; 1114 funccal_entry_T funccalp_entry; 1115 int save_debug_break_level = debug_break_level; 1116 int sid; 1117 scriptitem_T *si = NULL; 1118 #endif 1119 #ifdef STARTUPTIME 1120 struct timeval tv_rel; 1121 struct timeval tv_start; 1122 #endif 1123 #ifdef FEAT_PROFILE 1124 proftime_T wait_start; 1125 #endif 1126 int trigger_source_post = FALSE; 1127 ESTACK_CHECK_DECLARATION 1128 1129 p = expand_env_save(fname); 1130 if (p == NULL) 1131 return retval; 1132 fname_exp = fix_fname(p); 1133 vim_free(p); 1134 if (fname_exp == NULL) 1135 return retval; 1136 if (mch_isdir(fname_exp)) 1137 { 1138 smsg(_("Cannot source a directory: \"%s\""), fname); 1139 goto theend; 1140 } 1141 1142 #ifdef FEAT_EVAL 1143 // See if we loaded this script before. 1144 for (sid = script_items.ga_len; sid > 0; --sid) 1145 { 1146 // We used to check inode here, but that doesn't work: 1147 // - If a script is edited and written, it may get a different 1148 // inode number, even though to the user it is the same script. 1149 // - If a script is deleted and another script is written, with a 1150 // different name, the inode may be re-used. 1151 si = SCRIPT_ITEM(sid); 1152 if (si->sn_name != NULL && fnamecmp(si->sn_name, fname_exp) == 0) 1153 // Found it! 1154 break; 1155 } 1156 if (sid > 0 && ret_sid != NULL) 1157 { 1158 // Already loaded and no need to load again, return here. 1159 *ret_sid = sid; 1160 retval = OK; 1161 goto theend; 1162 } 1163 #endif 1164 1165 // Apply SourceCmd autocommands, they should get the file and source it. 1166 if (has_autocmd(EVENT_SOURCECMD, fname_exp, NULL) 1167 && apply_autocmds(EVENT_SOURCECMD, fname_exp, fname_exp, 1168 FALSE, curbuf)) 1169 { 1170 #ifdef FEAT_EVAL 1171 retval = aborting() ? FAIL : OK; 1172 #else 1173 retval = OK; 1174 #endif 1175 if (retval == OK) 1176 // Apply SourcePost autocommands. 1177 apply_autocmds(EVENT_SOURCEPOST, fname_exp, fname_exp, 1178 FALSE, curbuf); 1179 goto theend; 1180 } 1181 1182 // Apply SourcePre autocommands, they may get the file. 1183 apply_autocmds(EVENT_SOURCEPRE, fname_exp, fname_exp, FALSE, curbuf); 1184 1185 #ifdef USE_FOPEN_NOINH 1186 cookie.fp = fopen_noinh_readbin((char *)fname_exp); 1187 #else 1188 cookie.fp = mch_fopen((char *)fname_exp, READBIN); 1189 #endif 1190 if (cookie.fp == NULL && check_other) 1191 { 1192 // Try again, replacing file name ".vimrc" by "_vimrc" or vice versa, 1193 // and ".exrc" by "_exrc" or vice versa. 1194 p = gettail(fname_exp); 1195 if ((*p == '.' || *p == '_') 1196 && (STRICMP(p + 1, "vimrc") == 0 1197 || STRICMP(p + 1, "gvimrc") == 0 1198 || STRICMP(p + 1, "exrc") == 0)) 1199 { 1200 if (*p == '_') 1201 *p = '.'; 1202 else 1203 *p = '_'; 1204 #ifdef USE_FOPEN_NOINH 1205 cookie.fp = fopen_noinh_readbin((char *)fname_exp); 1206 #else 1207 cookie.fp = mch_fopen((char *)fname_exp, READBIN); 1208 #endif 1209 } 1210 } 1211 1212 if (cookie.fp == NULL) 1213 { 1214 if (p_verbose > 0) 1215 { 1216 verbose_enter(); 1217 if (SOURCING_NAME == NULL) 1218 smsg(_("could not source \"%s\""), fname); 1219 else 1220 smsg(_("line %ld: could not source \"%s\""), 1221 SOURCING_LNUM, fname); 1222 verbose_leave(); 1223 } 1224 goto theend; 1225 } 1226 1227 // The file exists. 1228 // - In verbose mode, give a message. 1229 // - For a vimrc file, may want to set 'compatible', call vimrc_found(). 1230 if (p_verbose > 1) 1231 { 1232 verbose_enter(); 1233 if (SOURCING_NAME == NULL) 1234 smsg(_("sourcing \"%s\""), fname); 1235 else 1236 smsg(_("line %ld: sourcing \"%s\""), SOURCING_LNUM, fname); 1237 verbose_leave(); 1238 } 1239 if (is_vimrc == DOSO_VIMRC) 1240 vimrc_found(fname_exp, (char_u *)"MYVIMRC"); 1241 else if (is_vimrc == DOSO_GVIMRC) 1242 vimrc_found(fname_exp, (char_u *)"MYGVIMRC"); 1243 1244 #ifdef USE_CRNL 1245 // If no automatic file format: Set default to CR-NL. 1246 if (*p_ffs == NUL) 1247 cookie.fileformat = EOL_DOS; 1248 else 1249 cookie.fileformat = EOL_UNKNOWN; 1250 cookie.error = FALSE; 1251 #endif 1252 1253 cookie.nextline = NULL; 1254 cookie.sourcing_lnum = 0; 1255 cookie.finished = FALSE; 1256 1257 #ifdef FEAT_EVAL 1258 ga_init2(&cookie.lines_ga, sizeof(char_u *), 200); 1259 cookie.use_lines_ga = -1; 1260 1261 // Check if this script has a breakpoint. 1262 cookie.breakpoint = dbg_find_breakpoint(TRUE, fname_exp, (linenr_T)0); 1263 cookie.fname = fname_exp; 1264 cookie.dbg_tick = debug_tick; 1265 1266 cookie.level = ex_nesting_level; 1267 #endif 1268 1269 // Keep the sourcing name/lnum, for recursive calls. 1270 estack_push(ETYPE_SCRIPT, fname_exp, 0); 1271 ESTACK_CHECK_SETUP 1272 1273 #ifdef STARTUPTIME 1274 if (time_fd != NULL) 1275 time_push(&tv_rel, &tv_start); 1276 #endif 1277 1278 #ifdef FEAT_EVAL 1279 # ifdef FEAT_PROFILE 1280 if (do_profiling == PROF_YES) 1281 prof_child_enter(&wait_start); // entering a child now 1282 # endif 1283 1284 // Don't use local function variables, if called from a function. 1285 // Also starts profiling timer for nested script. 1286 save_funccal(&funccalp_entry); 1287 1288 save_current_sctx = current_sctx; 1289 current_sctx.sc_lnum = 0; 1290 current_sctx.sc_version = 1; // default script version 1291 1292 // Check if this script was sourced before to finds its SID. 1293 // Always use a new sequence number. 1294 current_sctx.sc_seq = ++last_current_SID_seq; 1295 if (sid > 0) 1296 { 1297 hashtab_T *ht; 1298 int is_vim9 = si->sn_version == SCRIPT_VERSION_VIM9; 1299 1300 // loading the same script again 1301 si->sn_had_command = FALSE; 1302 si->sn_version = 1; 1303 current_sctx.sc_sid = sid; 1304 1305 ht = &SCRIPT_VARS(sid); 1306 if (is_vim9) 1307 hashtab_free_contents(ht); 1308 else 1309 { 1310 int todo = (int)ht->ht_used; 1311 hashitem_T *hi; 1312 dictitem_T *di; 1313 1314 for (hi = ht->ht_array; todo > 0; ++hi) 1315 if (!HASHITEM_EMPTY(hi)) 1316 { 1317 --todo; 1318 di = HI2DI(hi); 1319 di->di_flags |= DI_FLAGS_RELOAD; 1320 } 1321 } 1322 1323 // old imports are no longer valid 1324 free_imports(sid); 1325 1326 // in Vim9 script functions are marked deleted 1327 if (is_vim9) 1328 delete_script_functions(sid); 1329 } 1330 else 1331 { 1332 // It's new, generate a new SID. 1333 current_sctx.sc_sid = ++last_current_SID; 1334 if (ga_grow(&script_items, 1335 (int)(current_sctx.sc_sid - script_items.ga_len)) == FAIL) 1336 goto almosttheend; 1337 while (script_items.ga_len < current_sctx.sc_sid) 1338 { 1339 si = ALLOC_CLEAR_ONE(scriptitem_T); 1340 if (si == NULL) 1341 goto almosttheend; 1342 ++script_items.ga_len; 1343 SCRIPT_ITEM(script_items.ga_len) = si; 1344 si->sn_name = NULL; 1345 si->sn_version = 1; 1346 1347 // Allocate the local script variables to use for this script. 1348 new_script_vars(script_items.ga_len); 1349 ga_init2(&si->sn_var_vals, sizeof(typval_T), 10); 1350 ga_init2(&si->sn_imports, sizeof(imported_T), 10); 1351 ga_init2(&si->sn_type_list, sizeof(type_T), 10); 1352 # ifdef FEAT_PROFILE 1353 si->sn_prof_on = FALSE; 1354 # endif 1355 } 1356 si = SCRIPT_ITEM(current_sctx.sc_sid); 1357 si->sn_name = fname_exp; 1358 fname_exp = vim_strsave(si->sn_name); // used for autocmd 1359 if (ret_sid != NULL) 1360 *ret_sid = current_sctx.sc_sid; 1361 } 1362 1363 # ifdef FEAT_PROFILE 1364 if (do_profiling == PROF_YES) 1365 { 1366 int forceit; 1367 1368 // Check if we do profiling for this script. 1369 if (!si->sn_prof_on && has_profiling(TRUE, si->sn_name, &forceit)) 1370 { 1371 script_do_profile(si); 1372 si->sn_pr_force = forceit; 1373 } 1374 if (si->sn_prof_on) 1375 { 1376 ++si->sn_pr_count; 1377 profile_start(&si->sn_pr_start); 1378 profile_zero(&si->sn_pr_children); 1379 } 1380 } 1381 # endif 1382 #endif 1383 1384 cookie.conv.vc_type = CONV_NONE; // no conversion 1385 1386 // Read the first line so we can check for a UTF-8 BOM. 1387 firstline = getsourceline(0, (void *)&cookie, 0, TRUE); 1388 if (firstline != NULL && STRLEN(firstline) >= 3 && firstline[0] == 0xef 1389 && firstline[1] == 0xbb && firstline[2] == 0xbf) 1390 { 1391 // Found BOM; setup conversion, skip over BOM and recode the line. 1392 convert_setup(&cookie.conv, (char_u *)"utf-8", p_enc); 1393 p = string_convert(&cookie.conv, firstline + 3, NULL); 1394 if (p == NULL) 1395 p = vim_strsave(firstline + 3); 1396 if (p != NULL) 1397 { 1398 vim_free(firstline); 1399 firstline = p; 1400 } 1401 } 1402 1403 // Call do_cmdline, which will call getsourceline() to get the lines. 1404 do_cmdline(firstline, getsourceline, (void *)&cookie, 1405 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_REPEAT); 1406 retval = OK; 1407 1408 #ifdef FEAT_PROFILE 1409 if (do_profiling == PROF_YES) 1410 { 1411 // Get "si" again, "script_items" may have been reallocated. 1412 si = SCRIPT_ITEM(current_sctx.sc_sid); 1413 if (si->sn_prof_on) 1414 { 1415 profile_end(&si->sn_pr_start); 1416 profile_sub_wait(&wait_start, &si->sn_pr_start); 1417 profile_add(&si->sn_pr_total, &si->sn_pr_start); 1418 profile_self(&si->sn_pr_self, &si->sn_pr_start, 1419 &si->sn_pr_children); 1420 } 1421 } 1422 #endif 1423 1424 if (got_int) 1425 emsg(_(e_interr)); 1426 ESTACK_CHECK_NOW 1427 estack_pop(); 1428 if (p_verbose > 1) 1429 { 1430 verbose_enter(); 1431 smsg(_("finished sourcing %s"), fname); 1432 if (SOURCING_NAME != NULL) 1433 smsg(_("continuing in %s"), SOURCING_NAME); 1434 verbose_leave(); 1435 } 1436 #ifdef STARTUPTIME 1437 if (time_fd != NULL) 1438 { 1439 vim_snprintf((char *)IObuff, IOSIZE, "sourcing %s", fname); 1440 time_msg((char *)IObuff, &tv_start); 1441 time_pop(&tv_rel); 1442 } 1443 #endif 1444 1445 if (!got_int) 1446 trigger_source_post = TRUE; 1447 1448 #ifdef FEAT_EVAL 1449 // After a "finish" in debug mode, need to break at first command of next 1450 // sourced file. 1451 if (save_debug_break_level > ex_nesting_level 1452 && debug_break_level == ex_nesting_level) 1453 ++debug_break_level; 1454 #endif 1455 1456 #ifdef FEAT_EVAL 1457 almosttheend: 1458 // Get "si" again, "script_items" may have been reallocated. 1459 si = SCRIPT_ITEM(current_sctx.sc_sid); 1460 if (si->sn_save_cpo != NULL) 1461 { 1462 free_string_option(p_cpo); 1463 p_cpo = si->sn_save_cpo; 1464 si->sn_save_cpo = NULL; 1465 } 1466 1467 current_sctx = save_current_sctx; 1468 restore_funccal(); 1469 # ifdef FEAT_PROFILE 1470 if (do_profiling == PROF_YES) 1471 prof_child_exit(&wait_start); // leaving a child now 1472 # endif 1473 #endif 1474 fclose(cookie.fp); 1475 vim_free(cookie.nextline); 1476 vim_free(firstline); 1477 convert_setup(&cookie.conv, NULL, NULL); 1478 #ifdef FEAT_EVAL 1479 ga_clear_strings(&cookie.lines_ga); 1480 #endif 1481 1482 if (trigger_source_post) 1483 apply_autocmds(EVENT_SOURCEPOST, fname_exp, fname_exp, FALSE, curbuf); 1484 1485 theend: 1486 vim_free(fname_exp); 1487 return retval; 1488 } 1489 1490 #if defined(FEAT_EVAL) || defined(PROTO) 1491 1492 /* 1493 * ":scriptnames" 1494 */ 1495 void 1496 ex_scriptnames(exarg_T *eap) 1497 { 1498 int i; 1499 1500 if (eap->addr_count > 0) 1501 { 1502 // :script {scriptId}: edit the script 1503 if (eap->line2 < 1 || eap->line2 > script_items.ga_len) 1504 emsg(_(e_invarg)); 1505 else 1506 { 1507 eap->arg = SCRIPT_ITEM(eap->line2)->sn_name; 1508 do_exedit(eap, NULL); 1509 } 1510 return; 1511 } 1512 1513 for (i = 1; i <= script_items.ga_len && !got_int; ++i) 1514 if (SCRIPT_ITEM(i)->sn_name != NULL) 1515 { 1516 home_replace(NULL, SCRIPT_ITEM(i)->sn_name, 1517 NameBuff, MAXPATHL, TRUE); 1518 smsg("%3d: %s", i, NameBuff); 1519 } 1520 } 1521 1522 # if defined(BACKSLASH_IN_FILENAME) || defined(PROTO) 1523 /* 1524 * Fix slashes in the list of script names for 'shellslash'. 1525 */ 1526 void 1527 scriptnames_slash_adjust(void) 1528 { 1529 int i; 1530 1531 for (i = 1; i <= script_items.ga_len; ++i) 1532 if (SCRIPT_ITEM(i)->sn_name != NULL) 1533 slash_adjust(SCRIPT_ITEM(i)->sn_name); 1534 } 1535 # endif 1536 1537 /* 1538 * Get a pointer to a script name. Used for ":verbose set". 1539 */ 1540 char_u * 1541 get_scriptname(scid_T id) 1542 { 1543 if (id == SID_MODELINE) 1544 return (char_u *)_("modeline"); 1545 if (id == SID_CMDARG) 1546 return (char_u *)_("--cmd argument"); 1547 if (id == SID_CARG) 1548 return (char_u *)_("-c argument"); 1549 if (id == SID_ENV) 1550 return (char_u *)_("environment variable"); 1551 if (id == SID_ERROR) 1552 return (char_u *)_("error handler"); 1553 return SCRIPT_ITEM(id)->sn_name; 1554 } 1555 1556 # if defined(EXITFREE) || defined(PROTO) 1557 void 1558 free_scriptnames(void) 1559 { 1560 int i; 1561 1562 for (i = script_items.ga_len; i > 0; --i) 1563 { 1564 scriptitem_T *si = SCRIPT_ITEM(i); 1565 1566 // the variables themselves are cleared in evalvars_clear() 1567 vim_free(si->sn_vars); 1568 1569 vim_free(si->sn_name); 1570 free_imports(i); 1571 free_string_option(si->sn_save_cpo); 1572 # ifdef FEAT_PROFILE 1573 ga_clear(&si->sn_prl_ga); 1574 # endif 1575 vim_free(si); 1576 } 1577 ga_clear(&script_items); 1578 } 1579 1580 void 1581 free_autoload_scriptnames(void) 1582 { 1583 ga_clear_strings(&ga_loaded); 1584 } 1585 # endif 1586 1587 #endif 1588 1589 linenr_T 1590 get_sourced_lnum(char_u *(*fgetline)(int, void *, int, int), void *cookie) 1591 { 1592 return fgetline == getsourceline 1593 ? ((struct source_cookie *)cookie)->sourcing_lnum 1594 : SOURCING_LNUM; 1595 } 1596 1597 static char_u * 1598 get_one_sourceline(struct source_cookie *sp) 1599 { 1600 garray_T ga; 1601 int len; 1602 int c; 1603 char_u *buf; 1604 #ifdef USE_CRNL 1605 int has_cr; // CR-LF found 1606 #endif 1607 int have_read = FALSE; 1608 1609 // use a growarray to store the sourced line 1610 ga_init2(&ga, 1, 250); 1611 1612 // Loop until there is a finished line (or end-of-file). 1613 ++sp->sourcing_lnum; 1614 for (;;) 1615 { 1616 // make room to read at least 120 (more) characters 1617 if (ga_grow(&ga, 120) == FAIL) 1618 break; 1619 buf = (char_u *)ga.ga_data; 1620 1621 if (fgets((char *)buf + ga.ga_len, ga.ga_maxlen - ga.ga_len, 1622 sp->fp) == NULL) 1623 break; 1624 len = ga.ga_len + (int)STRLEN(buf + ga.ga_len); 1625 #ifdef USE_CRNL 1626 // Ignore a trailing CTRL-Z, when in Dos mode. Only recognize the 1627 // CTRL-Z by its own, or after a NL. 1628 if ( (len == 1 || (len >= 2 && buf[len - 2] == '\n')) 1629 && sp->fileformat == EOL_DOS 1630 && buf[len - 1] == Ctrl_Z) 1631 { 1632 buf[len - 1] = NUL; 1633 break; 1634 } 1635 #endif 1636 1637 have_read = TRUE; 1638 ga.ga_len = len; 1639 1640 // If the line was longer than the buffer, read more. 1641 if (ga.ga_maxlen - ga.ga_len == 1 && buf[len - 1] != '\n') 1642 continue; 1643 1644 if (len >= 1 && buf[len - 1] == '\n') // remove trailing NL 1645 { 1646 #ifdef USE_CRNL 1647 has_cr = (len >= 2 && buf[len - 2] == '\r'); 1648 if (sp->fileformat == EOL_UNKNOWN) 1649 { 1650 if (has_cr) 1651 sp->fileformat = EOL_DOS; 1652 else 1653 sp->fileformat = EOL_UNIX; 1654 } 1655 1656 if (sp->fileformat == EOL_DOS) 1657 { 1658 if (has_cr) // replace trailing CR 1659 { 1660 buf[len - 2] = '\n'; 1661 --len; 1662 --ga.ga_len; 1663 } 1664 else // lines like ":map xx yy^M" will have failed 1665 { 1666 if (!sp->error) 1667 { 1668 msg_source(HL_ATTR(HLF_W)); 1669 emsg(_("W15: Warning: Wrong line separator, ^M may be missing")); 1670 } 1671 sp->error = TRUE; 1672 sp->fileformat = EOL_UNIX; 1673 } 1674 } 1675 #endif 1676 // The '\n' is escaped if there is an odd number of ^V's just 1677 // before it, first set "c" just before the 'V's and then check 1678 // len&c parities (is faster than ((len-c)%2 == 0)) -- Acevedo 1679 for (c = len - 2; c >= 0 && buf[c] == Ctrl_V; c--) 1680 ; 1681 if ((len & 1) != (c & 1)) // escaped NL, read more 1682 { 1683 ++sp->sourcing_lnum; 1684 continue; 1685 } 1686 1687 buf[len - 1] = NUL; // remove the NL 1688 } 1689 1690 // Check for ^C here now and then, so recursive :so can be broken. 1691 line_breakcheck(); 1692 break; 1693 } 1694 1695 if (have_read) 1696 return (char_u *)ga.ga_data; 1697 1698 vim_free(ga.ga_data); 1699 return NULL; 1700 } 1701 1702 /* 1703 * Get one full line from a sourced file. 1704 * Called by do_cmdline() when it's called from do_source(). 1705 * 1706 * Return a pointer to the line in allocated memory. 1707 * Return NULL for end-of-file or some error. 1708 */ 1709 char_u * 1710 getsourceline(int c UNUSED, void *cookie, int indent UNUSED, int do_concat) 1711 { 1712 struct source_cookie *sp = (struct source_cookie *)cookie; 1713 char_u *line; 1714 char_u *p; 1715 1716 #ifdef FEAT_EVAL 1717 // If breakpoints have been added/deleted need to check for it. 1718 if (sp->dbg_tick < debug_tick) 1719 { 1720 sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, SOURCING_LNUM); 1721 sp->dbg_tick = debug_tick; 1722 } 1723 # ifdef FEAT_PROFILE 1724 if (do_profiling == PROF_YES) 1725 script_line_end(); 1726 # endif 1727 #endif 1728 1729 // Set the current sourcing line number. 1730 SOURCING_LNUM = sp->sourcing_lnum + 1; 1731 1732 // Get current line. If there is a read-ahead line, use it, otherwise get 1733 // one now. 1734 if (sp->finished) 1735 line = NULL; 1736 #ifdef FEAT_EVAL 1737 else if (sp->use_lines_ga >= 0) 1738 { 1739 // Get a line that was read in ex_vim9script(). 1740 for (;;) 1741 { 1742 if (sp->use_lines_ga >= sp->lines_ga.ga_len) 1743 { 1744 line = NULL; 1745 break; 1746 } 1747 else 1748 { 1749 line = ((char_u **)(sp->lines_ga.ga_data))[sp->use_lines_ga]; 1750 ((char_u **)(sp->lines_ga.ga_data))[sp->use_lines_ga] = NULL; 1751 ++sp->use_lines_ga; 1752 if (line != NULL) 1753 break; 1754 // Skip NULL lines, they are equivalent to blank lines. 1755 ++sp->sourcing_lnum; 1756 } 1757 } 1758 SOURCING_LNUM = sp->sourcing_lnum + 1; 1759 } 1760 #endif 1761 else if (sp->nextline == NULL) 1762 line = get_one_sourceline(sp); 1763 else 1764 { 1765 line = sp->nextline; 1766 sp->nextline = NULL; 1767 ++sp->sourcing_lnum; 1768 } 1769 #ifdef FEAT_PROFILE 1770 if (line != NULL && do_profiling == PROF_YES) 1771 script_line_start(); 1772 #endif 1773 1774 // Only concatenate lines starting with a \ when 'cpoptions' doesn't 1775 // contain the 'C' flag. 1776 if (line != NULL && do_concat && vim_strchr(p_cpo, CPO_CONCAT) == NULL 1777 #ifdef FEAT_EVAL 1778 && sp->use_lines_ga < 0 1779 #endif 1780 ) 1781 { 1782 // compensate for the one line read-ahead 1783 --sp->sourcing_lnum; 1784 1785 // Get the next line and concatenate it when it starts with a 1786 // backslash. We always need to read the next line, keep it in 1787 // sp->nextline. 1788 /* Also check for a comment in between continuation lines: "\ */ 1789 sp->nextline = get_one_sourceline(sp); 1790 if (sp->nextline != NULL 1791 && (*(p = skipwhite(sp->nextline)) == '\\' 1792 || (p[0] == '"' && p[1] == '\\' && p[2] == ' '))) 1793 { 1794 garray_T ga; 1795 1796 ga_init2(&ga, (int)sizeof(char_u), 400); 1797 ga_concat(&ga, line); 1798 if (*p == '\\') 1799 ga_concat(&ga, p + 1); 1800 for (;;) 1801 { 1802 vim_free(sp->nextline); 1803 sp->nextline = get_one_sourceline(sp); 1804 if (sp->nextline == NULL) 1805 break; 1806 p = skipwhite(sp->nextline); 1807 if (*p == '\\') 1808 { 1809 // Adjust the growsize to the current length to speed up 1810 // concatenating many lines. 1811 if (ga.ga_len > 400) 1812 { 1813 if (ga.ga_len > 8000) 1814 ga.ga_growsize = 8000; 1815 else 1816 ga.ga_growsize = ga.ga_len; 1817 } 1818 ga_concat(&ga, p + 1); 1819 } 1820 else if (p[0] != '"' || p[1] != '\\' || p[2] != ' ') 1821 break; 1822 } 1823 ga_append(&ga, NUL); 1824 vim_free(line); 1825 line = ga.ga_data; 1826 } 1827 } 1828 1829 if (line != NULL && sp->conv.vc_type != CONV_NONE) 1830 { 1831 char_u *s; 1832 1833 // Convert the encoding of the script line. 1834 s = string_convert(&sp->conv, line, NULL); 1835 if (s != NULL) 1836 { 1837 vim_free(line); 1838 line = s; 1839 } 1840 } 1841 1842 #ifdef FEAT_EVAL 1843 // Did we encounter a breakpoint? 1844 if (sp->breakpoint != 0 && sp->breakpoint <= SOURCING_LNUM) 1845 { 1846 dbg_breakpoint(sp->fname, SOURCING_LNUM); 1847 // Find next breakpoint. 1848 sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, SOURCING_LNUM); 1849 sp->dbg_tick = debug_tick; 1850 } 1851 #endif 1852 1853 return line; 1854 } 1855 1856 /* 1857 * ":scriptencoding": Set encoding conversion for a sourced script. 1858 */ 1859 void 1860 ex_scriptencoding(exarg_T *eap) 1861 { 1862 struct source_cookie *sp; 1863 char_u *name; 1864 1865 if (!getline_equal(eap->getline, eap->cookie, getsourceline)) 1866 { 1867 emsg(_("E167: :scriptencoding used outside of a sourced file")); 1868 return; 1869 } 1870 1871 if (*eap->arg != NUL) 1872 { 1873 name = enc_canonize(eap->arg); 1874 if (name == NULL) // out of memory 1875 return; 1876 } 1877 else 1878 name = eap->arg; 1879 1880 // Setup for conversion from the specified encoding to 'encoding'. 1881 sp = (struct source_cookie *)getline_cookie(eap->getline, eap->cookie); 1882 convert_setup(&sp->conv, name, p_enc); 1883 1884 if (name != eap->arg) 1885 vim_free(name); 1886 } 1887 1888 /* 1889 * ":scriptversion": Set Vim script version for a sourced script. 1890 */ 1891 void 1892 ex_scriptversion(exarg_T *eap UNUSED) 1893 { 1894 #ifdef FEAT_EVAL 1895 int nr; 1896 1897 if (!getline_equal(eap->getline, eap->cookie, getsourceline)) 1898 { 1899 emsg(_("E984: :scriptversion used outside of a sourced file")); 1900 return; 1901 } 1902 if (current_sctx.sc_version == SCRIPT_VERSION_VIM9) 1903 { 1904 emsg(_("E1040: Cannot use :scriptversion after :vim9script")); 1905 return; 1906 } 1907 1908 nr = getdigits(&eap->arg); 1909 if (nr == 0 || *eap->arg != NUL) 1910 emsg(_(e_invarg)); 1911 else if (nr > 4) 1912 semsg(_("E999: scriptversion not supported: %d"), nr); 1913 else 1914 { 1915 current_sctx.sc_version = nr; 1916 SCRIPT_ITEM(current_sctx.sc_sid)->sn_version = nr; 1917 } 1918 #endif 1919 } 1920 1921 #if defined(FEAT_EVAL) || defined(PROTO) 1922 /* 1923 * ":finish": Mark a sourced file as finished. 1924 */ 1925 void 1926 ex_finish(exarg_T *eap) 1927 { 1928 if (getline_equal(eap->getline, eap->cookie, getsourceline)) 1929 do_finish(eap, FALSE); 1930 else 1931 emsg(_("E168: :finish used outside of a sourced file")); 1932 } 1933 1934 /* 1935 * Mark a sourced file as finished. Possibly makes the ":finish" pending. 1936 * Also called for a pending finish at the ":endtry" or after returning from 1937 * an extra do_cmdline(). "reanimate" is used in the latter case. 1938 */ 1939 void 1940 do_finish(exarg_T *eap, int reanimate) 1941 { 1942 int idx; 1943 1944 if (reanimate) 1945 ((struct source_cookie *)getline_cookie(eap->getline, 1946 eap->cookie))->finished = FALSE; 1947 1948 // Cleanup (and inactivate) conditionals, but stop when a try conditional 1949 // not in its finally clause (which then is to be executed next) is found. 1950 // In this case, make the ":finish" pending for execution at the ":endtry". 1951 // Otherwise, finish normally. 1952 idx = cleanup_conditionals(eap->cstack, 0, TRUE); 1953 if (idx >= 0) 1954 { 1955 eap->cstack->cs_pending[idx] = CSTP_FINISH; 1956 report_make_pending(CSTP_FINISH, NULL); 1957 } 1958 else 1959 ((struct source_cookie *)getline_cookie(eap->getline, 1960 eap->cookie))->finished = TRUE; 1961 } 1962 1963 1964 /* 1965 * Return TRUE when a sourced file had the ":finish" command: Don't give error 1966 * message for missing ":endif". 1967 * Return FALSE when not sourcing a file. 1968 */ 1969 int 1970 source_finished( 1971 char_u *(*fgetline)(int, void *, int, int), 1972 void *cookie) 1973 { 1974 return (getline_equal(fgetline, cookie, getsourceline) 1975 && ((struct source_cookie *)getline_cookie( 1976 fgetline, cookie))->finished); 1977 } 1978 1979 /* 1980 * Return the autoload script name for a function or variable name. 1981 * Returns NULL when out of memory. 1982 * Caller must make sure that "name" contains AUTOLOAD_CHAR. 1983 */ 1984 char_u * 1985 autoload_name(char_u *name) 1986 { 1987 char_u *p, *q = NULL; 1988 char_u *scriptname; 1989 1990 // Get the script file name: replace '#' with '/', append ".vim". 1991 scriptname = alloc(STRLEN(name) + 14); 1992 if (scriptname == NULL) 1993 return NULL; 1994 STRCPY(scriptname, "autoload/"); 1995 STRCAT(scriptname, name); 1996 for (p = scriptname + 9; (p = vim_strchr(p, AUTOLOAD_CHAR)) != NULL; 1997 q = p, ++p) 1998 *p = '/'; 1999 STRCPY(q, ".vim"); 2000 return scriptname; 2001 } 2002 2003 /* 2004 * If "name" has a package name try autoloading the script for it. 2005 * Return TRUE if a package was loaded. 2006 */ 2007 int 2008 script_autoload( 2009 char_u *name, 2010 int reload) // load script again when already loaded 2011 { 2012 char_u *p; 2013 char_u *scriptname, *tofree; 2014 int ret = FALSE; 2015 int i; 2016 2017 // If there is no '#' after name[0] there is no package name. 2018 p = vim_strchr(name, AUTOLOAD_CHAR); 2019 if (p == NULL || p == name) 2020 return FALSE; 2021 2022 tofree = scriptname = autoload_name(name); 2023 if (scriptname == NULL) 2024 return FALSE; 2025 2026 // Find the name in the list of previously loaded package names. Skip 2027 // "autoload/", it's always the same. 2028 for (i = 0; i < ga_loaded.ga_len; ++i) 2029 if (STRCMP(((char_u **)ga_loaded.ga_data)[i] + 9, scriptname + 9) == 0) 2030 break; 2031 if (!reload && i < ga_loaded.ga_len) 2032 ret = FALSE; // was loaded already 2033 else 2034 { 2035 // Remember the name if it wasn't loaded already. 2036 if (i == ga_loaded.ga_len && ga_grow(&ga_loaded, 1) == OK) 2037 { 2038 ((char_u **)ga_loaded.ga_data)[ga_loaded.ga_len++] = scriptname; 2039 tofree = NULL; 2040 } 2041 2042 // Try loading the package from $VIMRUNTIME/autoload/<name>.vim 2043 if (source_runtime(scriptname, 0) == OK) 2044 ret = TRUE; 2045 } 2046 2047 vim_free(tofree); 2048 return ret; 2049 } 2050 #endif 2051