blob: 587aa29a0dfc0b05ceb8218b496b0eb789e917ce [file] [log] [blame]
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001/* 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
Bram Moolenaarda6c0332019-09-01 16:01:30 +020016#if defined(FEAT_EVAL) || defined(PROTO)
17// The names of packages that once were loaded are remembered.
18static garray_T ga_loaded = {0, 0, sizeof(char_u *), 4, NULL};
19#endif
20
Bram Moolenaar307c5a52019-08-25 15:41:00 +020021/*
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010022 * Initialize the execution stack.
23 */
24 void
25estack_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;
Bram Moolenaar09d46402019-12-29 23:53:01 +010035#ifdef FEAT_EVAL
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010036 entry->es_info.ufunc = NULL;
Bram Moolenaar09d46402019-12-29 23:53:01 +010037#endif
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010038 ++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 *
46estack_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;
Bram Moolenaar09d46402019-12-29 23:53:01 +010058#ifdef FEAT_EVAL
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010059 entry->es_info.ufunc = NULL;
Bram Moolenaar09d46402019-12-29 23:53:01 +010060#endif
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010061 ++exestack.ga_len;
62 return entry;
63 }
64 return NULL;
65}
66
Bram Moolenaar09d46402019-12-29 23:53:01 +010067#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010068/*
69 * Add a user function to the execution stack.
70 */
Bram Moolenaarc620c052020-07-08 15:16:19 +020071 estack_T *
Bram Moolenaar25e0f582020-05-25 22:36:50 +020072estack_push_ufunc(ufunc_T *ufunc, long lnum)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010073{
Bram Moolenaar25e0f582020-05-25 22:36:50 +020074 estack_T *entry = estack_push(ETYPE_UFUNC,
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010075 ufunc->uf_name_exp != NULL
76 ? ufunc->uf_name_exp : ufunc->uf_name, lnum);
77 if (entry != NULL)
78 entry->es_info.ufunc = ufunc;
Bram Moolenaarc620c052020-07-08 15:16:19 +020079 return entry;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010080}
Bram Moolenaar25e0f582020-05-25 22:36:50 +020081
82/*
83 * Return TRUE if "ufunc" with "lnum" is already at the top of the exe stack.
84 */
85 int
86estack_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}
Bram Moolenaar09d46402019-12-29 23:53:01 +010098#endif
Bram Moolenaar1a47ae32019-12-29 23:04:25 +010099
100/*
Bram Moolenaarc620c052020-07-08 15:16:19 +0200101 * Take an item off of the execution stack and return it.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100102 */
Bram Moolenaarc620c052020-07-08 15:16:19 +0200103 estack_T *
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100104estack_pop(void)
105{
Bram Moolenaarc620c052020-07-08 15:16:19 +0200106 if (exestack.ga_len == 0)
107 return NULL;
108 --exestack.ga_len;
109 return ((estack_T *)exestack.ga_data) + exestack.ga_len;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100110}
111
112/*
113 * Get the current value for <sfile> in allocated memory.
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200114 * "which" is ESTACK_SFILE for <sfile> and ESTACK_STACK for <stack>.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100115 */
116 char_u *
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200117estack_sfile(estack_arg_T which UNUSED)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100118{
Bram Moolenaar85b09572019-12-30 10:57:00 +0100119 estack_T *entry;
120#ifdef FEAT_EVAL
Bram Moolenaara5d04232020-07-26 15:37:02 +0200121 garray_T ga;
Bram Moolenaar4d7a2482020-01-06 19:53:43 +0100122 size_t len;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100123 int idx;
Bram Moolenaara5d04232020-07-26 15:37:02 +0200124 etype_T last_type = ETYPE_SCRIPT;
125 char *type_name;
Bram Moolenaar85b09572019-12-30 10:57:00 +0100126#endif
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100127
128 entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1;
Bram Moolenaar09d46402019-12-29 23:53:01 +0100129#ifdef FEAT_EVAL
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200130 if (which == ESTACK_SFILE && entry->es_type != ETYPE_UFUNC)
Bram Moolenaar09d46402019-12-29 23:53:01 +0100131#endif
Bram Moolenaara5d04232020-07-26 15:37:02 +0200132 {
133 if (entry->es_name == NULL)
134 return NULL;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100135 return vim_strsave(entry->es_name);
Bram Moolenaara5d04232020-07-26 15:37:02 +0200136 }
Bram Moolenaar09d46402019-12-29 23:53:01 +0100137#ifdef FEAT_EVAL
Bram Moolenaara5d04232020-07-26 15:37:02 +0200138 // Give information about each stack entry up to the root.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100139 // For a function we compose the call stack, as it was done in the past:
140 // "function One[123]..Two[456]..Three"
Bram Moolenaara5d04232020-07-26 15:37:02 +0200141 ga_init2(&ga, sizeof(char), 100);
142 for (idx = 0; idx < exestack.ga_len; ++idx)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100143 {
144 entry = ((estack_T *)exestack.ga_data) + idx;
Bram Moolenaara5d04232020-07-26 15:37:02 +0200145 if (entry->es_name != NULL)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100146 {
Bram Moolenaara810db32020-09-11 17:59:23 +0200147 long lnum = 0;
148 char *dots;
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200149
Bram Moolenaara5d04232020-07-26 15:37:02 +0200150 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);
Bram Moolenaard3bb6a82020-07-26 15:55:25 +0200163 if (ga_grow(&ga, (int)len) == FAIL)
Bram Moolenaara5d04232020-07-26 15:37:02 +0200164 break;
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200165 if (idx == exestack.ga_len - 1)
166 lnum = which == ESTACK_STACK ? SOURCING_LNUM : 0;
167 else
168 lnum = entry->es_lnum;
Bram Moolenaara810db32020-09-11 17:59:23 +0200169 dots = idx == exestack.ga_len - 1 ? "" : "..";
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200170 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.
Bram Moolenaard3bb6a82020-07-26 15:55:25 +0200174 vim_snprintf((char *)ga.ga_data + ga.ga_len, len, "%s%s%s",
Bram Moolenaara810db32020-09-11 17:59:23 +0200175 type_name, entry->es_name, dots);
Bram Moolenaara5d04232020-07-26 15:37:02 +0200176 else
Bram Moolenaara810db32020-09-11 17:59:23 +0200177 vim_snprintf((char *)ga.ga_data + ga.ga_len, len, "%s%s[%ld]%s",
178 type_name, entry->es_name, lnum, dots);
Bram Moolenaard3bb6a82020-07-26 15:55:25 +0200179 ga.ga_len += (int)STRLEN((char *)ga.ga_data + ga.ga_len);
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100180 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100181 }
182
Bram Moolenaara5d04232020-07-26 15:37:02 +0200183 return (char_u *)ga.ga_data;
Bram Moolenaar09d46402019-12-29 23:53:01 +0100184#endif
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100185}
186
187/*
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200188 * ":runtime [what] {name}"
189 */
190 void
191ex_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
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100223source_callback(char_u *fname, void *cookie)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200224{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100225 (void)do_source(fname, FALSE, DOSO_NONE, cookie);
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200226}
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
239do_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 {
Bram Moolenaar647a5302020-05-03 17:01:24 +0200269 if (p_verbose > 10 && name != NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200270 {
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
Bram Moolenaar647a5302020-05-03 17:01:24 +0200317 if (p_verbose > 10)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200318 {
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
376do_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
421do_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
438source_runtime(char_u *name, int flags)
439{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100440 return source_in_path(p_rtp, name, flags, NULL);
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200441}
442
443/*
444 * Just like source_runtime(), but use "path" instead of 'runtimepath'.
445 */
446 int
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100447source_in_path(char_u *path, char_u *name, int flags, int *ret_sid)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200448{
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100449 return do_in_path_and_pp(path, name, flags, source_callback, ret_sid);
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200450}
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
459source_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)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100468 (void)do_source(files[i], FALSE, DOSO_NONE, NULL);
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200469 FreeWild(num_files, files);
470 }
471}
472
473/*
474 * Add the package directory to 'runtimepath'.
475 */
476 static int
477add_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
614theend:
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
625load_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
660theend:
661 vim_free(ffname);
662 return retval;
663}
664
665// used for "cookie" of add_pack_plugin()
666static int APP_ADD_DIR;
667static int APP_LOAD;
668static int APP_BOTH;
669
670 static void
671add_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
706add_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
716load_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
728ex_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
744ex_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/*
Bram Moolenaar26262f82019-09-04 20:59:15 +0200775 * Sort "gap" and remove duplicate entries. "gap" is expected to contain a
776 * list of file names in allocated memory.
777 */
778 void
779remove_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/*
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200797 * 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
807ExpandRTDir(
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
903ExpandPackAddDir(
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
951cmd_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
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100971 else if (do_source(fname, FALSE, DOSO_NONE, NULL) == FAIL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200972 semsg(_(e_notopen), fname);
973}
974
975/*
976 * ":source {fname}"
977 */
978 void
979ex_source(exarg_T *eap)
980{
981#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +0200982 if (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar307c5a52019-08-25 15:41:00 +0200983 {
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
1005ex_options(
1006 exarg_T *eap UNUSED)
1007{
Bram Moolenaar7a1637f2020-04-13 21:16:21 +02001008 char_u buf[500];
1009 int multi_mods = 0;
1010
1011 buf[0] = NUL;
Bram Moolenaar02194d22020-10-24 23:08:38 +02001012 (void)add_win_cmd_modifers(buf, &cmdmod, &multi_mods);
Bram Moolenaar7a1637f2020-04-13 21:16:21 +02001013
1014 vim_setenv((char_u *)"OPTWIN_CMD", buf);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001015 cmd_source((char_u *)SYS_OPTWIN_FILE, NULL);
1016}
1017#endif
1018
1019/*
1020 * ":source" and associated commands.
1021 */
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001022
1023#ifdef FEAT_EVAL
1024/*
1025 * Return the address holding the next breakpoint line for a source cookie.
1026 */
1027 linenr_T *
1028source_breakpoint(void *cookie)
1029{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001030 return &((source_cookie_T *)cookie)->breakpoint;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001031}
1032
1033/*
1034 * Return the address holding the debug tick for a source cookie.
1035 */
1036 int *
1037source_dbg_tick(void *cookie)
1038{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001039 return &((source_cookie_T *)cookie)->dbg_tick;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001040}
1041
1042/*
1043 * Return the nesting level for a source cookie.
1044 */
1045 int
1046source_level(void *cookie)
1047{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001048 return ((source_cookie_T *)cookie)->level;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001049}
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001050
1051/*
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02001052 * 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.
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001054 */
1055 char_u *
1056source_nextline(void *cookie)
1057{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001058 return ((source_cookie_T *)cookie)->nextline;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001059}
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001060#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 *
1069fopen_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.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001094 * When "ret_sid" is not NULL and we loaded the script before, don't load it
1095 * again.
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001096 *
1097 * This function may be called recursively!
1098 *
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001099 * 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.
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001101 */
1102 int
1103do_source(
1104 char_u *fname,
1105 int check_other, // check for .vimrc and _vimrc
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001106 int is_vimrc, // DOSO_ value
1107 int *ret_sid UNUSED)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001108{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001109 source_cookie_T cookie;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001110 char_u *p;
1111 char_u *fname_exp;
1112 char_u *firstline = NULL;
1113 int retval = FAIL;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001114 sctx_T save_current_sctx;
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01001115#ifdef FEAT_EVAL
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001116 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;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001120 int sid;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001121 scriptitem_T *si = NULL;
Bram Moolenaar8de901e2021-06-11 22:21:24 +02001122 int save_estack_compiling = estack_compiling;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001123#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;
Bram Moolenaare31ee862020-01-07 20:59:34 +01001132 ESTACK_CHECK_DECLARATION
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001133
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 }
Bram Moolenaar8de901e2021-06-11 22:21:24 +02001146#ifdef FEAT_EVAL
Bram Moolenaarf0a40692021-06-11 22:05:47 +02001147 estack_compiling = FALSE;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001148
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001149 // See if we loaded this script before.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001150 for (sid = script_items.ga_len; sid > 0; --sid)
1151 {
Bram Moolenaar978d1702020-01-26 17:38:12 +01001152 // 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.
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001157 si = SCRIPT_ITEM(sid);
Bram Moolenaar978d1702020-01-26 17:38:12 +01001158 if (si->sn_name != NULL && fnamecmp(si->sn_name, fname_exp) == 0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001159 // Found it!
1160 break;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001161 }
1162 if (sid > 0 && ret_sid != NULL)
1163 {
1164 // Already loaded and no need to load again, return here.
1165 *ret_sid = sid;
Bram Moolenaar292b90d2020-03-18 15:23:16 +01001166 retval = OK;
1167 goto theend;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001168 }
1169#endif
1170
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001171 // 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();
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001223 if (SOURCING_NAME == NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001224 smsg(_("could not source \"%s\""), fname);
1225 else
1226 smsg(_("line %ld: could not source \"%s\""),
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001227 SOURCING_LNUM, fname);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001228 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();
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001239 if (SOURCING_NAME == NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001240 smsg(_("sourcing \"%s\""), fname);
1241 else
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001242 smsg(_("line %ld: sourcing \"%s\""), SOURCING_LNUM, fname);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001243 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.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001273 estack_push(ETYPE_SCRIPT, fname_exp, 0);
Bram Moolenaare31ee862020-01-07 20:59:34 +01001274 ESTACK_CHECK_SETUP
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001275
1276#ifdef STARTUPTIME
1277 if (time_fd != NULL)
1278 time_push(&tv_rel, &tv_start);
1279#endif
1280
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01001281 save_current_sctx = current_sctx;
1282 current_sctx.sc_version = 1; // default script version
1283
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001284#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
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001294 current_sctx.sc_lnum = 0;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001295
1296 // Check if this script was sourced before to finds its SID.
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001297 // Always use a new sequence number.
1298 current_sctx.sc_seq = ++last_current_SID_seq;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001299 if (sid > 0)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001300 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001301 hashtab_T *ht;
Bram Moolenaar2b327002020-12-26 15:39:31 +01001302 int todo;
1303 hashitem_T *hi;
1304 dictitem_T *di;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001305
1306 // loading the same script again
Bram Moolenaar2b327002020-12-26 15:39:31 +01001307 si->sn_state = SN_STATE_RELOAD;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001308 current_sctx.sc_sid = sid;
1309
Bram Moolenaar2b327002020-12-26 15:39:31 +01001310 // 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.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001313 ht = &SCRIPT_VARS(sid);
Bram Moolenaar2b327002020-12-26 15:39:31 +01001314 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 }
Bram Moolenaar7e3ee782020-12-27 14:02:27 +01001322 // imports can be redefined once
1323 mark_imports_for_reload(sid);
Bram Moolenaar0123cc12021-02-07 17:17:58 +01001324
1325 // reset version, "vim9script" may have been added or removed.
1326 si->sn_version = 1;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001327 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001328 else
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001329 {
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001330 // It's new, generate a new SID.
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001331 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 {
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001337 si = ALLOC_CLEAR_ONE(scriptitem_T);
1338 if (si == NULL)
1339 goto almosttheend;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001340 ++script_items.ga_len;
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001341 SCRIPT_ITEM(script_items.ga_len) = si;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001342 si->sn_name = NULL;
1343 si->sn_version = 1;
Bram Moolenaar7ebcba62020-01-12 17:42:55 +01001344
1345 // Allocate the local script variables to use for this script.
1346 new_script_vars(script_items.ga_len);
Bram Moolenaar3b74b6b2020-06-19 19:01:43 +02001347 ga_init2(&si->sn_var_vals, sizeof(svar_T), 10);
Bram Moolenaar8d739de2020-10-14 19:39:19 +02001348 hash_init(&si->sn_all_vars.dv_hashtab);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001349 ga_init2(&si->sn_imports, sizeof(imported_T), 10);
1350 ga_init2(&si->sn_type_list, sizeof(type_T), 10);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001351# ifdef FEAT_PROFILE
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001352 si->sn_prof_on = FALSE;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001353# endif
1354 }
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001355 si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001356 si->sn_name = fname_exp;
1357 fname_exp = vim_strsave(si->sn_name); // used for autocmd
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001358 if (ret_sid != NULL)
1359 *ret_sid = current_sctx.sc_sid;
Bram Moolenaar2b327002020-12-26 15:39:31 +01001360
1361 // Used to check script variable index is still valid.
1362 si->sn_script_seq = current_sctx.sc_seq;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001363 }
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.
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001414 si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001415 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));
Bram Moolenaare31ee862020-01-07 20:59:34 +01001428 ESTACK_CHECK_NOW
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001429 estack_pop();
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001430 if (p_verbose > 1)
1431 {
1432 verbose_enter();
1433 smsg(_("finished sourcing %s"), fname);
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001434 if (SOURCING_NAME != NULL)
1435 smsg(_("continuing in %s"), SOURCING_NAME);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001436 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
1459almosttheend:
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001460 // Get "si" again, "script_items" may have been reallocated.
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001461 si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001462 if (si->sn_save_cpo != NULL)
1463 {
Bram Moolenaar3e191692021-03-17 17:46:00 +01001464 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 }
Bram Moolenaar37294bd2021-03-10 13:40:08 +01001491 set_option_value((char_u *)"cpo", 0L, si->sn_save_cpo, OPT_NO_REDRAW);
Bram Moolenaar0123cc12021-02-07 17:17:58 +01001492 VIM_CLEAR(si->sn_save_cpo);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001493 }
1494
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001495 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
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01001501 current_sctx = save_current_sctx;
1502
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001503 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
1511theend:
1512 vim_free(fname_exp);
Bram Moolenaar8de901e2021-06-11 22:21:24 +02001513#ifdef FEAT_EVAL
Bram Moolenaarf0a40692021-06-11 22:05:47 +02001514 estack_compiling = save_estack_compiling;
Bram Moolenaar8de901e2021-06-11 22:21:24 +02001515#endif
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001516 return retval;
1517}
1518
1519#if defined(FEAT_EVAL) || defined(PROTO)
1520
1521/*
1522 * ":scriptnames"
1523 */
1524 void
1525ex_scriptnames(exarg_T *eap)
1526{
1527 int i;
1528
1529 if (eap->addr_count > 0)
1530 {
1531 // :script {scriptId}: edit the script
Bram Moolenaare3d46852020-08-29 13:39:17 +02001532 if (!SCRIPT_ID_VALID(eap->line2))
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001533 emsg(_(e_invarg));
1534 else
1535 {
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001536 eap->arg = SCRIPT_ITEM(eap->line2)->sn_name;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001537 do_exedit(eap, NULL);
1538 }
1539 return;
1540 }
1541
1542 for (i = 1; i <= script_items.ga_len && !got_int; ++i)
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001543 if (SCRIPT_ITEM(i)->sn_name != NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001544 {
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001545 home_replace(NULL, SCRIPT_ITEM(i)->sn_name,
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001546 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
1556scriptnames_slash_adjust(void)
1557{
1558 int i;
1559
1560 for (i = 1; i <= script_items.ga_len; ++i)
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001561 if (SCRIPT_ITEM(i)->sn_name != NULL)
1562 slash_adjust(SCRIPT_ITEM(i)->sn_name);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001563}
1564# endif
1565
1566/*
1567 * Get a pointer to a script name. Used for ":verbose set".
Bram Moolenaar74667062020-12-28 15:41:41 +01001568 * Message appended to "Last set from "
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001569 */
1570 char_u *
1571get_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");
Bram Moolenaar74667062020-12-28 15:41:41 +01001583 if (id == SID_WINLAYOUT)
1584 return (char_u *)_("changed window size");
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001585 return SCRIPT_ITEM(id)->sn_name;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001586}
1587
1588# if defined(EXITFREE) || defined(PROTO)
1589 void
1590free_scriptnames(void)
1591{
1592 int i;
1593
1594 for (i = script_items.ga_len; i > 0; --i)
Bram Moolenaar86173482019-10-01 17:02:16 +02001595 {
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001596 scriptitem_T *si = SCRIPT_ITEM(i);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001597
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001598 // the variables themselves are cleared in evalvars_clear()
1599 vim_free(si->sn_vars);
1600
1601 vim_free(si->sn_name);
Bram Moolenaar8d739de2020-10-14 19:39:19 +02001602 free_imports_and_script_vars(i);
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001603 free_string_option(si->sn_save_cpo);
Bram Moolenaara720be72019-10-22 21:45:19 +02001604# ifdef FEAT_PROFILE
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001605 ga_clear(&si->sn_prl_ga);
Bram Moolenaara720be72019-10-22 21:45:19 +02001606# endif
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001607 vim_free(si);
Bram Moolenaar86173482019-10-01 17:02:16 +02001608 }
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001609 ga_clear(&script_items);
1610}
Bram Moolenaarda6c0332019-09-01 16:01:30 +02001611
1612 void
1613free_autoload_scriptnames(void)
1614{
1615 ga_clear_strings(&ga_loaded);
1616}
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001617# endif
1618
1619#endif
1620
1621 linenr_T
Bram Moolenaar66250c92020-08-20 15:02:42 +02001622get_sourced_lnum(
1623 char_u *(*fgetline)(int, void *, int, getline_opt_T),
1624 void *cookie)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001625{
1626 return fgetline == getsourceline
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001627 ? ((source_cookie_T *)cookie)->sourcing_lnum
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001628 : SOURCING_LNUM;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001629}
1630
1631 static char_u *
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001632get_one_sourceline(source_cookie_T *sp)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001633{
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 *
Bram Moolenaar66250c92020-08-20 15:02:42 +02001744getsourceline(
1745 int c UNUSED,
1746 void *cookie,
1747 int indent UNUSED,
1748 getline_opt_T options)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001749{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001750 source_cookie_T *sp = (source_cookie_T *)cookie;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001751 char_u *line;
1752 char_u *p;
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001753 int do_vim9_all = in_vim9script()
1754 && options == GETLINE_CONCAT_ALL;
Bram Moolenaar8242ebb2020-12-29 11:15:01 +01001755 int do_bar_cont = do_vim9_all
1756 || options == GETLINE_CONCAT_CONTBAR;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001757
1758#ifdef FEAT_EVAL
1759 // If breakpoints have been added/deleted need to check for it.
1760 if (sp->dbg_tick < debug_tick)
1761 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001762 sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, SOURCING_LNUM);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001763 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.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001772 SOURCING_LNUM = sp->sourcing_lnum + 1;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001773
1774 // Get current line. If there is a read-ahead line, use it, otherwise get
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001775 // one now. "fp" is NULL if actually using a string.
1776 if (sp->finished || sp->fp == NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001777 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.
Bram Moolenaar66250c92020-08-20 15:02:42 +02001793 if (line != NULL && options != GETLINE_NONE
1794 && vim_strchr(p_cpo, CPO_CONCAT) == NULL)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001795 {
Bram Moolenaar5072b472021-06-03 21:56:10 +02001796 int comment_char = in_vim9script() ? '#' : '"';
1797
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001798 // 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: "\ */
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001805 // Also check for a Vim9 comment, empty line, line starting with '|',
1806 // but not "||".
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001807 sp->nextline = get_one_sourceline(sp);
1808 if (sp->nextline != NULL
1809 && (*(p = skipwhite(sp->nextline)) == '\\'
Bram Moolenaar5072b472021-06-03 21:56:10 +02001810 || (p[0] == comment_char
1811 && p[1] == '\\' && p[2] == ' ')
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001812 || (do_vim9_all && (*p == NUL
1813 || vim9_comment_start(p)))
Bram Moolenaar8242ebb2020-12-29 11:15:01 +01001814 || (do_bar_cont && p[0] == '|' && p[1] != '|')))
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001815 {
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);
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001822 else if (*p == '|')
1823 {
1824 ga_concat(&ga, (char_u *)" ");
1825 ga_concat(&ga, p);
1826 }
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001827 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);
Bram Moolenaar8242ebb2020-12-29 11:15:01 +01001834 if (*p == '\\' || (do_bar_cont && p[0] == '|' && p[1] != '|'))
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001835 {
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 }
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001845 if (*p == '\\')
1846 ga_concat(&ga, p + 1);
1847 else
1848 {
1849 ga_concat(&ga, (char_u *)" ");
1850 ga_concat(&ga, p);
1851 }
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001852 }
Bram Moolenaar5072b472021-06-03 21:56:10 +02001853 else if (!(p[0] == (comment_char)
Bram Moolenaar0f37e352021-06-02 15:28:15 +02001854 && p[1] == '\\' && p[2] == ' ')
Bram Moolenaardcc58e02020-12-28 20:53:21 +01001855 && !(do_vim9_all && (*p == NUL || vim9_comment_start(p))))
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001856 break;
Bram Moolenaar75783bd2020-07-19 14:41:58 +02001857 /* drop a # comment or "\ comment line */
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001858 }
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?
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001880 if (sp->breakpoint != 0 && sp->breakpoint <= SOURCING_LNUM)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001881 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001882 dbg_breakpoint(sp->fname, SOURCING_LNUM);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001883 // Find next breakpoint.
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001884 sp->breakpoint = dbg_find_breakpoint(TRUE, sp->fname, SOURCING_LNUM);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001885 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
1896ex_scriptencoding(exarg_T *eap)
1897{
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001898 source_cookie_T *sp;
1899 char_u *name;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001900
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'.
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001917 sp = (source_cookie_T *)getline_cookie(eap->getline, eap->cookie);
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001918 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
1928ex_scriptversion(exarg_T *eap UNUSED)
1929{
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001930 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 }
Bram Moolenaareb6880b2020-07-12 17:07:05 +02001937 if (in_vim9script())
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001938 {
Bram Moolenaar451c2e32020-08-15 16:33:28 +02001939 emsg(_(e_cannot_use_scriptversion_after_vim9script));
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001940 return;
1941 }
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001942
1943 nr = getdigits(&eap->arg);
1944 if (nr == 0 || *eap->arg != NUL)
1945 emsg(_(e_invarg));
Bram Moolenaar67979662020-06-20 22:50:47 +02001946 else if (nr > SCRIPT_VERSION_MAX)
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001947 semsg(_("E999: scriptversion not supported: %d"), nr);
1948 else
Bram Moolenaar7ebcba62020-01-12 17:42:55 +01001949 {
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001950 current_sctx.sc_version = nr;
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01001951#ifdef FEAT_EVAL
Bram Moolenaar21b9e972020-01-26 19:26:46 +01001952 SCRIPT_ITEM(current_sctx.sc_sid)->sn_version = nr;
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001953#endif
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01001954 }
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001955}
1956
1957#if defined(FEAT_EVAL) || defined(PROTO)
1958/*
1959 * ":finish": Mark a sourced file as finished.
1960 */
1961 void
1962ex_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
1976do_finish(exarg_T *eap, int reanimate)
1977{
1978 int idx;
1979
1980 if (reanimate)
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001981 ((source_cookie_T *)getline_cookie(eap->getline,
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001982 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
Bram Moolenaar9567efa2021-01-11 22:16:30 +01001995 ((source_cookie_T *)getline_cookie(eap->getline,
Bram Moolenaar307c5a52019-08-25 15:41:00 +02001996 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
2006source_finished(
Bram Moolenaar66250c92020-08-20 15:02:42 +02002007 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaar307c5a52019-08-25 15:41:00 +02002008 void *cookie)
2009{
2010 return (getline_equal(fgetline, cookie, getsourceline)
Bram Moolenaar9567efa2021-01-11 22:16:30 +01002011 && ((source_cookie_T *)getline_cookie(
Bram Moolenaar307c5a52019-08-25 15:41:00 +02002012 fgetline, cookie))->finished);
2013}
Bram Moolenaarda6c0332019-09-01 16:01:30 +02002014
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 *
2021autoload_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/");
Bram Moolenaara1773442020-08-12 15:21:22 +02002031 STRCAT(scriptname, name[0] == 'g' && name[1] == ':' ? name + 2: name);
Bram Moolenaarda6c0332019-09-01 16:01:30 +02002032 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
2044script_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;
Bram Moolenaardaa2f362020-08-08 21:33:21 +02002052 int ret_sid;
Bram Moolenaarda6c0332019-09-01 16:01:30 +02002053
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
Bram Moolenaardaa2f362020-08-08 21:33:21 +02002080 // Use "ret_sid" to avoid loading the same script again.
2081 if (source_in_path(p_rtp, scriptname, 0, &ret_sid) == OK)
Bram Moolenaarda6c0332019-09-01 16:01:30 +02002082 ret = TRUE;
2083 }
2084
2085 vim_free(tofree);
2086 return ret;
2087}
Bram Moolenaar307c5a52019-08-25 15:41:00 +02002088#endif