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 * evalbuffer.c: Buffer related builtin functions
12 */
13
14 #include "vim.h"
15
16 #if defined(FEAT_EVAL) || defined(PROTO)
17 /*
18 * Mark references in functions of buffers.
19 */
20 int
set_ref_in_buffers(int copyID)21 set_ref_in_buffers(int copyID)
22 {
23 int abort = FALSE;
24 buf_T *bp;
25
26 FOR_ALL_BUFFERS(bp)
27 {
28 listener_T *lnr;
29 typval_T tv;
30
31 for (lnr = bp->b_listener; !abort && lnr != NULL; lnr = lnr->lr_next)
32 {
33 if (lnr->lr_callback.cb_partial != NULL)
34 {
35 tv.v_type = VAR_PARTIAL;
36 tv.vval.v_partial = lnr->lr_callback.cb_partial;
37 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
38 }
39 }
40 # ifdef FEAT_JOB_CHANNEL
41 if (!abort && bp->b_prompt_callback.cb_partial != NULL)
42 {
43 tv.v_type = VAR_PARTIAL;
44 tv.vval.v_partial = bp->b_prompt_callback.cb_partial;
45 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
46 }
47 if (!abort && bp->b_prompt_interrupt.cb_partial != NULL)
48 {
49 tv.v_type = VAR_PARTIAL;
50 tv.vval.v_partial = bp->b_prompt_interrupt.cb_partial;
51 abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL);
52 }
53 # endif
54 if (abort)
55 break;
56 }
57 return abort;
58 }
59
60 buf_T *
buflist_find_by_name(char_u * name,int curtab_only)61 buflist_find_by_name(char_u *name, int curtab_only)
62 {
63 int save_magic;
64 char_u *save_cpo;
65 buf_T *buf;
66
67 // Ignore 'magic' and 'cpoptions' here to make scripts portable
68 save_magic = p_magic;
69 p_magic = TRUE;
70 save_cpo = p_cpo;
71 p_cpo = empty_option;
72
73 buf = buflist_findnr(buflist_findpat(name, name + STRLEN(name),
74 TRUE, FALSE, curtab_only));
75
76 p_magic = save_magic;
77 p_cpo = save_cpo;
78 return buf;
79 }
80
81 /*
82 * Find a buffer by number or exact name.
83 */
84 buf_T *
find_buffer(typval_T * avar)85 find_buffer(typval_T *avar)
86 {
87 buf_T *buf = NULL;
88
89 if (avar->v_type == VAR_NUMBER)
90 buf = buflist_findnr((int)avar->vval.v_number);
91 else if (in_vim9script() && check_for_string_arg(avar, 0) == FAIL)
92 return NULL;
93 else if (avar->v_type == VAR_STRING && avar->vval.v_string != NULL)
94 {
95 buf = buflist_findname_exp(avar->vval.v_string);
96 if (buf == NULL)
97 {
98 // No full path name match, try a match with a URL or a "nofile"
99 // buffer, these don't use the full path.
100 FOR_ALL_BUFFERS(buf)
101 if (buf->b_fname != NULL
102 && (path_with_url(buf->b_fname)
103 #ifdef FEAT_QUICKFIX
104 || bt_nofilename(buf)
105 #endif
106 )
107 && STRCMP(buf->b_fname, avar->vval.v_string) == 0)
108 break;
109 }
110 }
111 return buf;
112 }
113
114 /*
115 * If there is a window for "curbuf", make it the current window.
116 */
117 static void
find_win_for_curbuf(void)118 find_win_for_curbuf(void)
119 {
120 wininfo_T *wip;
121
122 FOR_ALL_BUF_WININFO(curbuf, wip)
123 {
124 if (wip->wi_win != NULL)
125 {
126 curwin = wip->wi_win;
127 break;
128 }
129 }
130 }
131
132 /*
133 * Set line or list of lines in buffer "buf" to "lines".
134 * Any type is allowed and converted to a string.
135 */
136 static void
set_buffer_lines(buf_T * buf,linenr_T lnum_arg,int append,typval_T * lines,typval_T * rettv)137 set_buffer_lines(
138 buf_T *buf,
139 linenr_T lnum_arg,
140 int append,
141 typval_T *lines,
142 typval_T *rettv)
143 {
144 linenr_T lnum = lnum_arg + (append ? 1 : 0);
145 char_u *line = NULL;
146 list_T *l = NULL;
147 listitem_T *li = NULL;
148 long added = 0;
149 linenr_T append_lnum;
150 buf_T *curbuf_save = NULL;
151 win_T *curwin_save = NULL;
152 int is_curbuf = buf == curbuf;
153
154 // When using the current buffer ml_mfp will be set if needed. Useful when
155 // setline() is used on startup. For other buffers the buffer must be
156 // loaded.
157 if (buf == NULL || (!is_curbuf && buf->b_ml.ml_mfp == NULL) || lnum < 1)
158 {
159 rettv->vval.v_number = 1; // FAIL
160 return;
161 }
162
163 if (!is_curbuf)
164 {
165 curbuf_save = curbuf;
166 curwin_save = curwin;
167 curbuf = buf;
168 find_win_for_curbuf();
169 }
170
171 if (append)
172 // appendbufline() uses the line number below which we insert
173 append_lnum = lnum - 1;
174 else
175 // setbufline() uses the line number above which we insert, we only
176 // append if it's below the last line
177 append_lnum = curbuf->b_ml.ml_line_count;
178
179 if (lines->v_type == VAR_LIST)
180 {
181 l = lines->vval.v_list;
182 if (l == NULL || list_len(l) == 0)
183 {
184 // set proper return code
185 if (lnum > curbuf->b_ml.ml_line_count)
186 rettv->vval.v_number = 1; // FAIL
187 goto done;
188 }
189 CHECK_LIST_MATERIALIZE(l);
190 li = l->lv_first;
191 }
192 else
193 line = typval_tostring(lines, FALSE);
194
195 // default result is zero == OK
196 for (;;)
197 {
198 if (l != NULL)
199 {
200 // list argument, get next string
201 if (li == NULL)
202 break;
203 vim_free(line);
204 line = typval_tostring(&li->li_tv, FALSE);
205 li = li->li_next;
206 }
207
208 rettv->vval.v_number = 1; // FAIL
209 if (line == NULL || lnum > curbuf->b_ml.ml_line_count + 1)
210 break;
211
212 // When coming here from Insert mode, sync undo, so that this can be
213 // undone separately from what was previously inserted.
214 if (u_sync_once == 2)
215 {
216 u_sync_once = 1; // notify that u_sync() was called
217 u_sync(TRUE);
218 }
219
220 if (!append && lnum <= curbuf->b_ml.ml_line_count)
221 {
222 // Existing line, replace it.
223 // Removes any existing text properties.
224 if (u_savesub(lnum) == OK && ml_replace_len(
225 lnum, line, (colnr_T)STRLEN(line) + 1, TRUE, TRUE) == OK)
226 {
227 changed_bytes(lnum, 0);
228 if (is_curbuf && lnum == curwin->w_cursor.lnum)
229 check_cursor_col();
230 rettv->vval.v_number = 0; // OK
231 }
232 }
233 else if (added > 0 || u_save(lnum - 1, lnum) == OK)
234 {
235 // append the line
236 ++added;
237 if (ml_append(lnum - 1, line, (colnr_T)0, FALSE) == OK)
238 rettv->vval.v_number = 0; // OK
239 }
240
241 if (l == NULL) // only one string argument
242 break;
243 ++lnum;
244 }
245 vim_free(line);
246
247 if (added > 0)
248 {
249 win_T *wp;
250 tabpage_T *tp;
251
252 appended_lines_mark(append_lnum, added);
253
254 // Only adjust the cursor for buffers other than the current, unless it
255 // is the current window. For curbuf and other windows it has been
256 // done in mark_adjust_internal().
257 FOR_ALL_TAB_WINDOWS(tp, wp)
258 if (wp->w_buffer == buf
259 && (wp->w_buffer != curbuf || wp == curwin)
260 && wp->w_cursor.lnum > append_lnum)
261 wp->w_cursor.lnum += added;
262 check_cursor_col();
263 update_topline();
264 }
265
266 done:
267 if (!is_curbuf)
268 {
269 curbuf = curbuf_save;
270 curwin = curwin_save;
271 }
272 }
273
274 /*
275 * "append(lnum, string/list)" function
276 */
277 void
f_append(typval_T * argvars,typval_T * rettv)278 f_append(typval_T *argvars, typval_T *rettv)
279 {
280 linenr_T lnum;
281
282 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
283 return;
284
285 lnum = tv_get_lnum(&argvars[0]);
286 set_buffer_lines(curbuf, lnum, TRUE, &argvars[1], rettv);
287 }
288
289 /*
290 * Set or append lines to a buffer.
291 */
292 static void
buf_set_append_line(typval_T * argvars,typval_T * rettv,int append)293 buf_set_append_line(typval_T *argvars, typval_T *rettv, int append)
294 {
295 linenr_T lnum;
296 buf_T *buf;
297
298 if (in_vim9script()
299 && (check_for_buffer_arg(argvars, 0) == FAIL
300 || check_for_lnum_arg(argvars, 1) == FAIL
301 || check_for_string_or_number_or_list_arg(argvars, 2) == FAIL))
302 return;
303
304 buf = tv_get_buf(&argvars[0], FALSE);
305 if (buf == NULL)
306 rettv->vval.v_number = 1; // FAIL
307 else
308 {
309 lnum = tv_get_lnum_buf(&argvars[1], buf);
310 set_buffer_lines(buf, lnum, append, &argvars[2], rettv);
311 }
312 }
313
314 /*
315 * "appendbufline(buf, lnum, string/list)" function
316 */
317 void
f_appendbufline(typval_T * argvars,typval_T * rettv)318 f_appendbufline(typval_T *argvars, typval_T *rettv)
319 {
320 buf_set_append_line(argvars, rettv, TRUE);
321 }
322
323 /*
324 * "bufadd(expr)" function
325 */
326 void
f_bufadd(typval_T * argvars,typval_T * rettv)327 f_bufadd(typval_T *argvars, typval_T *rettv)
328 {
329 char_u *name;
330
331 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
332 return;
333
334 name = tv_get_string(&argvars[0]);
335 rettv->vval.v_number = buflist_add(*name == NUL ? NULL : name, 0);
336 }
337
338 /*
339 * "bufexists(expr)" function
340 */
341 void
f_bufexists(typval_T * argvars,typval_T * rettv)342 f_bufexists(typval_T *argvars, typval_T *rettv)
343 {
344 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
345 return;
346
347 rettv->vval.v_number = (find_buffer(&argvars[0]) != NULL);
348 }
349
350 /*
351 * "buflisted(expr)" function
352 */
353 void
f_buflisted(typval_T * argvars,typval_T * rettv)354 f_buflisted(typval_T *argvars, typval_T *rettv)
355 {
356 buf_T *buf;
357
358 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
359 return;
360
361 buf = find_buffer(&argvars[0]);
362 rettv->vval.v_number = (buf != NULL && buf->b_p_bl);
363 }
364
365 /*
366 * "bufload(expr)" function
367 */
368 void
f_bufload(typval_T * argvars,typval_T * rettv UNUSED)369 f_bufload(typval_T *argvars, typval_T *rettv UNUSED)
370 {
371 buf_T *buf;
372
373 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
374 return;
375
376 buf = get_buf_arg(&argvars[0]);
377 if (buf != NULL)
378 buffer_ensure_loaded(buf);
379 }
380
381 /*
382 * "bufloaded(expr)" function
383 */
384 void
f_bufloaded(typval_T * argvars,typval_T * rettv)385 f_bufloaded(typval_T *argvars, typval_T *rettv)
386 {
387 buf_T *buf;
388
389 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
390 return;
391
392 buf = find_buffer(&argvars[0]);
393 rettv->vval.v_number = (buf != NULL && buf->b_ml.ml_mfp != NULL);
394 }
395
396 /*
397 * "bufname(expr)" function
398 */
399 void
f_bufname(typval_T * argvars,typval_T * rettv)400 f_bufname(typval_T *argvars, typval_T *rettv)
401 {
402 buf_T *buf;
403 typval_T *tv = &argvars[0];
404
405 if (in_vim9script() && check_for_opt_buffer_arg(argvars, 0) == FAIL)
406 return;
407
408 if (tv->v_type == VAR_UNKNOWN)
409 buf = curbuf;
410 else
411 buf = tv_get_buf_from_arg(tv);
412 rettv->v_type = VAR_STRING;
413 if (buf != NULL && buf->b_fname != NULL)
414 rettv->vval.v_string = vim_strsave(buf->b_fname);
415 else
416 rettv->vval.v_string = NULL;
417 }
418
419 /*
420 * "bufnr(expr)" function
421 */
422 void
f_bufnr(typval_T * argvars,typval_T * rettv)423 f_bufnr(typval_T *argvars, typval_T *rettv)
424 {
425 buf_T *buf;
426 int error = FALSE;
427 char_u *name;
428
429 if (in_vim9script()
430 && (check_for_opt_buffer_arg(argvars, 0) == FAIL
431 || (argvars[0].v_type != VAR_UNKNOWN
432 && check_for_opt_bool_arg(argvars, 1) == FAIL)))
433 return;
434
435 if (argvars[0].v_type == VAR_UNKNOWN)
436 buf = curbuf;
437 else
438 buf = tv_get_buf_from_arg(&argvars[0]);
439
440 // If the buffer isn't found and the second argument is not zero create a
441 // new buffer.
442 if (buf == NULL
443 && argvars[1].v_type != VAR_UNKNOWN
444 && tv_get_bool_chk(&argvars[1], &error) != 0
445 && !error
446 && (name = tv_get_string_chk(&argvars[0])) != NULL
447 && !error)
448 buf = buflist_new(name, NULL, (linenr_T)1, 0);
449
450 if (buf != NULL)
451 rettv->vval.v_number = buf->b_fnum;
452 else
453 rettv->vval.v_number = -1;
454 }
455
456 static void
buf_win_common(typval_T * argvars,typval_T * rettv,int get_nr)457 buf_win_common(typval_T *argvars, typval_T *rettv, int get_nr)
458 {
459 win_T *wp;
460 int winnr = 0;
461 buf_T *buf;
462
463 if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL)
464 return;
465
466 buf = tv_get_buf_from_arg(&argvars[0]);
467 FOR_ALL_WINDOWS(wp)
468 {
469 ++winnr;
470 if (wp->w_buffer == buf)
471 break;
472 }
473 rettv->vval.v_number = (wp != NULL ? (get_nr ? winnr : wp->w_id) : -1);
474 }
475
476 /*
477 * "bufwinid(nr)" function
478 */
479 void
f_bufwinid(typval_T * argvars,typval_T * rettv)480 f_bufwinid(typval_T *argvars, typval_T *rettv)
481 {
482 buf_win_common(argvars, rettv, FALSE);
483 }
484
485 /*
486 * "bufwinnr(nr)" function
487 */
488 void
f_bufwinnr(typval_T * argvars,typval_T * rettv)489 f_bufwinnr(typval_T *argvars, typval_T *rettv)
490 {
491 buf_win_common(argvars, rettv, TRUE);
492 }
493
494 /*
495 * "deletebufline()" function
496 */
497 void
f_deletebufline(typval_T * argvars,typval_T * rettv)498 f_deletebufline(typval_T *argvars, typval_T *rettv)
499 {
500 buf_T *buf;
501 linenr_T first, last;
502 linenr_T lnum;
503 long count;
504 int is_curbuf;
505 buf_T *curbuf_save = NULL;
506 win_T *curwin_save = NULL;
507 tabpage_T *tp;
508 win_T *wp;
509
510 if (in_vim9script()
511 && (check_for_buffer_arg(argvars, 0) == FAIL
512 || check_for_lnum_arg(argvars, 1) == FAIL
513 || check_for_opt_lnum_arg(argvars, 2) == FAIL))
514 return;
515
516 buf = tv_get_buf(&argvars[0], FALSE);
517 if (buf == NULL)
518 {
519 rettv->vval.v_number = 1; // FAIL
520 return;
521 }
522 is_curbuf = buf == curbuf;
523
524 first = tv_get_lnum_buf(&argvars[1], buf);
525 if (argvars[2].v_type != VAR_UNKNOWN)
526 last = tv_get_lnum_buf(&argvars[2], buf);
527 else
528 last = first;
529
530 if (buf->b_ml.ml_mfp == NULL || first < 1
531 || first > buf->b_ml.ml_line_count || last < first)
532 {
533 rettv->vval.v_number = 1; // FAIL
534 return;
535 }
536
537 if (!is_curbuf)
538 {
539 curbuf_save = curbuf;
540 curwin_save = curwin;
541 curbuf = buf;
542 find_win_for_curbuf();
543 }
544 if (last > curbuf->b_ml.ml_line_count)
545 last = curbuf->b_ml.ml_line_count;
546 count = last - first + 1;
547
548 // When coming here from Insert mode, sync undo, so that this can be
549 // undone separately from what was previously inserted.
550 if (u_sync_once == 2)
551 {
552 u_sync_once = 1; // notify that u_sync() was called
553 u_sync(TRUE);
554 }
555
556 if (u_save(first - 1, last + 1) == FAIL)
557 {
558 rettv->vval.v_number = 1; // FAIL
559 }
560 else
561 {
562 for (lnum = first; lnum <= last; ++lnum)
563 ml_delete_flags(first, ML_DEL_MESSAGE);
564
565 FOR_ALL_TAB_WINDOWS(tp, wp)
566 if (wp->w_buffer == buf)
567 {
568 if (wp->w_cursor.lnum > last)
569 wp->w_cursor.lnum -= count;
570 else if (wp->w_cursor.lnum> first)
571 wp->w_cursor.lnum = first;
572 if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count)
573 wp->w_cursor.lnum = wp->w_buffer->b_ml.ml_line_count;
574 }
575 check_cursor_col();
576 deleted_lines_mark(first, count);
577 }
578
579 if (!is_curbuf)
580 {
581 curbuf = curbuf_save;
582 curwin = curwin_save;
583 }
584 }
585
586 /*
587 * Returns buffer options, variables and other attributes in a dictionary.
588 */
589 static dict_T *
get_buffer_info(buf_T * buf)590 get_buffer_info(buf_T *buf)
591 {
592 dict_T *dict;
593 tabpage_T *tp;
594 win_T *wp;
595 list_T *windows;
596
597 dict = dict_alloc();
598 if (dict == NULL)
599 return NULL;
600
601 dict_add_number(dict, "bufnr", buf->b_fnum);
602 dict_add_string(dict, "name", buf->b_ffname);
603 dict_add_number(dict, "lnum", buf == curbuf ? curwin->w_cursor.lnum
604 : buflist_findlnum(buf));
605 dict_add_number(dict, "linecount", buf->b_ml.ml_line_count);
606 dict_add_number(dict, "loaded", buf->b_ml.ml_mfp != NULL);
607 dict_add_number(dict, "listed", buf->b_p_bl);
608 dict_add_number(dict, "changed", bufIsChanged(buf));
609 dict_add_number(dict, "changedtick", CHANGEDTICK(buf));
610 dict_add_number(dict, "hidden",
611 buf->b_ml.ml_mfp != NULL && buf->b_nwindows == 0);
612
613 // Get a reference to buffer variables
614 dict_add_dict(dict, "variables", buf->b_vars);
615
616 // List of windows displaying this buffer
617 windows = list_alloc();
618 if (windows != NULL)
619 {
620 FOR_ALL_TAB_WINDOWS(tp, wp)
621 if (wp->w_buffer == buf)
622 list_append_number(windows, (varnumber_T)wp->w_id);
623 dict_add_list(dict, "windows", windows);
624 }
625
626 #ifdef FEAT_PROP_POPUP
627 // List of popup windows displaying this buffer
628 windows = list_alloc();
629 if (windows != NULL)
630 {
631 FOR_ALL_POPUPWINS(wp)
632 if (wp->w_buffer == buf)
633 list_append_number(windows, (varnumber_T)wp->w_id);
634 FOR_ALL_TABPAGES(tp)
635 FOR_ALL_POPUPWINS_IN_TAB(tp, wp)
636 if (wp->w_buffer == buf)
637 list_append_number(windows, (varnumber_T)wp->w_id);
638
639 dict_add_list(dict, "popups", windows);
640 }
641 #endif
642
643 #ifdef FEAT_SIGNS
644 if (buf->b_signlist != NULL)
645 {
646 // List of signs placed in this buffer
647 list_T *signs = list_alloc();
648 if (signs != NULL)
649 {
650 get_buffer_signs(buf, signs);
651 dict_add_list(dict, "signs", signs);
652 }
653 }
654 #endif
655
656 #ifdef FEAT_VIMINFO
657 dict_add_number(dict, "lastused", buf->b_last_used);
658 #endif
659
660 return dict;
661 }
662
663 /*
664 * "getbufinfo()" function
665 */
666 void
f_getbufinfo(typval_T * argvars,typval_T * rettv)667 f_getbufinfo(typval_T *argvars, typval_T *rettv)
668 {
669 buf_T *buf = NULL;
670 buf_T *argbuf = NULL;
671 dict_T *d;
672 int filtered = FALSE;
673 int sel_buflisted = FALSE;
674 int sel_bufloaded = FALSE;
675 int sel_bufmodified = FALSE;
676
677 if (rettv_list_alloc(rettv) != OK)
678 return;
679
680 if (in_vim9script()
681 && check_for_opt_buffer_or_dict_arg(argvars, 0) == FAIL)
682 return;
683
684 // List of all the buffers or selected buffers
685 if (argvars[0].v_type == VAR_DICT)
686 {
687 dict_T *sel_d = argvars[0].vval.v_dict;
688
689 if (sel_d != NULL)
690 {
691 filtered = TRUE;
692 sel_buflisted = dict_get_bool(sel_d, (char_u *)"buflisted", FALSE);
693 sel_bufloaded = dict_get_bool(sel_d, (char_u *)"bufloaded", FALSE);
694 sel_bufmodified = dict_get_bool(sel_d, (char_u *)"bufmodified",
695 FALSE);
696 }
697 }
698 else if (argvars[0].v_type != VAR_UNKNOWN)
699 {
700 // Information about one buffer. Argument specifies the buffer
701 argbuf = tv_get_buf_from_arg(&argvars[0]);
702 if (argbuf == NULL)
703 return;
704 }
705
706 // Return information about all the buffers or a specified buffer
707 FOR_ALL_BUFFERS(buf)
708 {
709 if (argbuf != NULL && argbuf != buf)
710 continue;
711 if (filtered && ((sel_bufloaded && buf->b_ml.ml_mfp == NULL)
712 || (sel_buflisted && !buf->b_p_bl)
713 || (sel_bufmodified && !buf->b_changed)))
714 continue;
715
716 d = get_buffer_info(buf);
717 if (d != NULL)
718 list_append_dict(rettv->vval.v_list, d);
719 if (argbuf != NULL)
720 return;
721 }
722 }
723
724 /*
725 * Get line or list of lines from buffer "buf" into "rettv".
726 * Return a range (from start to end) of lines in rettv from the specified
727 * buffer.
728 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
729 */
730 static void
get_buffer_lines(buf_T * buf,linenr_T start,linenr_T end,int retlist,typval_T * rettv)731 get_buffer_lines(
732 buf_T *buf,
733 linenr_T start,
734 linenr_T end,
735 int retlist,
736 typval_T *rettv)
737 {
738 char_u *p;
739
740 if (retlist)
741 {
742 if (rettv_list_alloc(rettv) == FAIL)
743 return;
744 }
745 else
746 {
747 rettv->v_type = VAR_STRING;
748 rettv->vval.v_string = NULL;
749 }
750
751 if (buf == NULL || buf->b_ml.ml_mfp == NULL || start < 0)
752 return;
753
754 if (!retlist)
755 {
756 if (start >= 1 && start <= buf->b_ml.ml_line_count)
757 p = ml_get_buf(buf, start, FALSE);
758 else
759 p = (char_u *)"";
760 rettv->vval.v_string = vim_strsave(p);
761 }
762 else
763 {
764 if (end < start)
765 return;
766
767 if (start < 1)
768 start = 1;
769 if (end > buf->b_ml.ml_line_count)
770 end = buf->b_ml.ml_line_count;
771 while (start <= end)
772 if (list_append_string(rettv->vval.v_list,
773 ml_get_buf(buf, start++, FALSE), -1) == FAIL)
774 break;
775 }
776 }
777
778 /*
779 * "getbufline()" function
780 */
781 void
f_getbufline(typval_T * argvars,typval_T * rettv)782 f_getbufline(typval_T *argvars, typval_T *rettv)
783 {
784 linenr_T lnum = 1;
785 linenr_T end = 1;
786 buf_T *buf;
787
788 if (in_vim9script()
789 && (check_for_buffer_arg(argvars, 0) == FAIL
790 || check_for_lnum_arg(argvars, 1) == FAIL
791 || check_for_opt_lnum_arg(argvars, 2) == FAIL))
792 return;
793
794 buf = tv_get_buf_from_arg(&argvars[0]);
795 if (buf != NULL)
796 {
797 lnum = tv_get_lnum_buf(&argvars[1], buf);
798 if (argvars[2].v_type == VAR_UNKNOWN)
799 end = lnum;
800 else
801 end = tv_get_lnum_buf(&argvars[2], buf);
802 }
803
804 get_buffer_lines(buf, lnum, end, TRUE, rettv);
805 }
806
807 type_T *
ret_f_getline(int argcount,type_T ** argtypes UNUSED)808 ret_f_getline(int argcount, type_T **argtypes UNUSED)
809 {
810 return argcount == 1 ? &t_string : &t_list_string;
811 }
812
813 /*
814 * "getline(lnum, [end])" function
815 */
816 void
f_getline(typval_T * argvars,typval_T * rettv)817 f_getline(typval_T *argvars, typval_T *rettv)
818 {
819 linenr_T lnum;
820 linenr_T end;
821 int retlist;
822
823 if (in_vim9script()
824 && (check_for_lnum_arg(argvars, 0) == FAIL
825 || check_for_opt_lnum_arg(argvars, 1) == FAIL))
826 return;
827
828 lnum = tv_get_lnum(argvars);
829 if (argvars[1].v_type == VAR_UNKNOWN)
830 {
831 end = 0;
832 retlist = FALSE;
833 }
834 else
835 {
836 end = tv_get_lnum(&argvars[1]);
837 retlist = TRUE;
838 }
839
840 get_buffer_lines(curbuf, lnum, end, retlist, rettv);
841 }
842
843 /*
844 * "setbufline()" function
845 */
846 void
f_setbufline(typval_T * argvars,typval_T * rettv)847 f_setbufline(typval_T *argvars, typval_T *rettv)
848 {
849 buf_set_append_line(argvars, rettv, FALSE);
850 }
851
852 /*
853 * "setline()" function
854 */
855 void
f_setline(typval_T * argvars,typval_T * rettv)856 f_setline(typval_T *argvars, typval_T *rettv)
857 {
858 linenr_T lnum;
859
860 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL)
861 return;
862
863 lnum = tv_get_lnum(&argvars[0]);
864 set_buffer_lines(curbuf, lnum, FALSE, &argvars[1], rettv);
865 }
866 #endif // FEAT_EVAL
867
868 #if defined(FEAT_JOB_CHANNEL) \
869 || defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) \
870 || defined(PROTO)
871 /*
872 * Make "buf" the current buffer. restore_buffer() MUST be called to undo.
873 * No autocommands will be executed. Use aucmd_prepbuf() if there are any.
874 */
875 void
switch_buffer(bufref_T * save_curbuf,buf_T * buf)876 switch_buffer(bufref_T *save_curbuf, buf_T *buf)
877 {
878 block_autocmds();
879 #ifdef FEAT_FOLDING
880 ++disable_fold_update;
881 #endif
882 set_bufref(save_curbuf, curbuf);
883 --curbuf->b_nwindows;
884 curbuf = buf;
885 curwin->w_buffer = buf;
886 ++curbuf->b_nwindows;
887 }
888
889 /*
890 * Restore the current buffer after using switch_buffer().
891 */
892 void
restore_buffer(bufref_T * save_curbuf)893 restore_buffer(bufref_T *save_curbuf)
894 {
895 unblock_autocmds();
896 #ifdef FEAT_FOLDING
897 --disable_fold_update;
898 #endif
899 // Check for valid buffer, just in case.
900 if (bufref_valid(save_curbuf))
901 {
902 --curbuf->b_nwindows;
903 curwin->w_buffer = save_curbuf->br_buf;
904 curbuf = save_curbuf->br_buf;
905 ++curbuf->b_nwindows;
906 }
907 }
908
909 /*
910 * Find a window for buffer "buf".
911 * If found OK is returned and "wp" and "tp" are set to the window and tabpage.
912 * If not found FAIL is returned.
913 */
914 static int
find_win_for_buf(buf_T * buf,win_T ** wp,tabpage_T ** tp)915 find_win_for_buf(
916 buf_T *buf,
917 win_T **wp,
918 tabpage_T **tp)
919 {
920 FOR_ALL_TAB_WINDOWS(*tp, *wp)
921 if ((*wp)->w_buffer == buf)
922 return OK;
923 return FAIL;
924 }
925
926 /*
927 * Find a window that contains "buf" and switch to it.
928 * If there is no such window, use the current window and change "curbuf".
929 * Caller must initialize save_curbuf to NULL.
930 * restore_win_for_buf() MUST be called later!
931 */
932 void
switch_to_win_for_buf(buf_T * buf,win_T ** save_curwinp,tabpage_T ** save_curtabp,bufref_T * save_curbuf)933 switch_to_win_for_buf(
934 buf_T *buf,
935 win_T **save_curwinp,
936 tabpage_T **save_curtabp,
937 bufref_T *save_curbuf)
938 {
939 win_T *wp;
940 tabpage_T *tp;
941
942 if (find_win_for_buf(buf, &wp, &tp) == FAIL)
943 switch_buffer(save_curbuf, buf);
944 else if (switch_win(save_curwinp, save_curtabp, wp, tp, TRUE) == FAIL)
945 {
946 restore_win(*save_curwinp, *save_curtabp, TRUE);
947 switch_buffer(save_curbuf, buf);
948 }
949 }
950
951 void
restore_win_for_buf(win_T * save_curwin,tabpage_T * save_curtab,bufref_T * save_curbuf)952 restore_win_for_buf(
953 win_T *save_curwin,
954 tabpage_T *save_curtab,
955 bufref_T *save_curbuf)
956 {
957 if (save_curbuf->br_buf == NULL)
958 restore_win(save_curwin, save_curtab, TRUE);
959 else
960 restore_buffer(save_curbuf);
961 }
962 #endif
963