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