#include "vim.h"

#ifdef FEAT_EVAL

# define MAX_STL_EVAL_DEPTH 100

static void enter_buffer(buf_T *buf);

static void buflist_getfpos(void);

static char_u *buflist_match(regmatch_T *rmp, buf_T *buf, int ignore_case);

static char_u *fname_match(regmatch_T *rmp, char_u *name, int ignore_case);

#ifdef UNIX

static buf_T *buflist_findname_stat(char_u *ffname, stat_T *st);

static int otherfile_buf(buf_T *buf, char_u *ffname, stat_T *stp);

static int buf_same_ino(buf_T *buf, stat_T *stp);

static int otherfile_buf(buf_T *buf, char_u *ffname);

static int value_changed(char_u *str, char_u **last);

static int append_arg_number(win_T *wp, char_u *buf, size_t buflen, int add_file);

static void free_buffer(buf_T *);

static void free_buffer_stuff(buf_T *buf, int free_options);

static int bt_nofileread(buf_T *buf);

static void no_write_message_buf(buf_T *buf);

static int do_buffer_ext(int action, int start, int dir, int count, int flags);

#ifdef UNIX

# define dev_T dev_t

# define dev_T unsigned

#define FOR_ALL_BUFS_FROM_LAST(buf) \

for ((buf) = lastbuf; (buf) != NULL; (buf) = (buf)->b_prev)

#if defined(FEAT_QUICKFIX)

static char *msg_loclist = N_("[Location List]");

static char *msg_qflist = N_("[Quickfix List]");

static int buf_free_count = 0;

static int top_file_num = 1; // highest file number

static garray_T buf_reuse = GA_EMPTY; // file numbers to recycle

static void

trigger_undo_ftplugin(buf_T *buf, win_T *win)

{

window_layout_lock();

buf->b_locked++;

win->w_locked = TRUE;

// b:undo_ftplugin may be set, undo it

do_cmdline_cmd((char_u*)"if exists('b:undo_ftplugin') | :legacy :exe \

b:undo_ftplugin | endif");

buf->b_locked--;

win->w_locked = FALSE;

window_layout_unlock();

}

static int

calc_percentage(long part, long whole)

{

// With 32 bit longs and more than 21,474,836 lines multiplying by 100

// causes an overflow, thus for large numbers divide instead.

return (part > 1000000L)

? (int)(part / (whole / 100L))

: (int)((part * 100L) / whole);

}

int

get_highest_fnum(void)

{

return top_file_num - 1;

}

static int

read_buffer(

int read_stdin, // read file from stdin, otherwise fifo

exarg_T *eap, // for forced 'ff' and 'fenc' or NULL

int flags) // extra flags for readfile()

{

int retval = OK;

linenr_T line_count;

// Read from the buffer which the text is already filled in and append at

// the end. This makes it possible to retry when 'fileformat' or

// 'fileencoding' was guessed wrong.

line_count = curbuf->b_ml.ml_line_count;

retval = readfile(

read_stdin ? NULL : curbuf->b_ffname,

read_stdin ? NULL : curbuf->b_fname,

line_count, (linenr_T)0, (linenr_T)MAXLNUM, eap,

flags | READ_BUFFER);

if (retval == OK)

{

// Delete the binary lines.

while (--line_count >= 0)

ml_delete((linenr_T)1);

}

else

{

// Delete the converted lines.

while (curbuf->b_ml.ml_line_count > line_count)

ml_delete(line_count);

}

// Put the cursor on the first line.

curwin->w_cursor.lnum = 1;

curwin->w_cursor.col = 0;

if (read_stdin)

{

// Set or reset 'modified' before executing autocommands, so that

// it can be changed there.

if (!readonlymode && !BUFEMPTY())

changed();

else if (retval == OK)

unchanged(curbuf, FALSE, TRUE);

if (retval == OK)

{

#ifdef FEAT_EVAL

apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE,

curbuf, &retval);

apply_autocmds(EVENT_STDINREADPOST, NULL, NULL, FALSE, curbuf);

}

}

return retval;

}

#if defined(FEAT_EVAL) || defined(PROTO)

void

buffer_ensure_loaded(buf_T *buf)

{

if (buf->b_ml.ml_mfp != NULL)

return;

aco_save_T aco;

// Make sure the buffer is in a window. If not then skip it.

aucmd_prepbuf(&aco, buf);

if (curbuf == buf)

{

if (swap_exists_action != SEA_READONLY)

swap_exists_action = SEA_NONE;

open_buffer(FALSE, NULL, 0);

aucmd_restbuf(&aco);

}

}

int

open_buffer(

int read_stdin, // read file from stdin

exarg_T *eap, // for forced 'ff' and 'fenc' or NULL

int flags_arg) // extra flags for readfile()

{

int flags = flags_arg;

int retval = OK;

bufref_T old_curbuf;

#ifdef FEAT_SYN_HL

long old_tw = curbuf->b_p_tw;

int read_fifo = FALSE;

// The 'readonly' flag is only set when BF_NEVERLOADED is being reset.

// When re-entering the same buffer, it should not change, because the

// user may have reset the flag by hand.

if (readonlymode && curbuf->b_ffname != NULL

&& (curbuf->b_flags & BF_NEVERLOADED))

curbuf->b_p_ro = TRUE;

if (ml_open(curbuf) == FAIL)

{

// There MUST be a memfile, otherwise we can't do anything

// If we can't create one for the current buffer, take another buffer

close_buffer(NULL, curbuf, 0, FALSE, FALSE);

FOR_ALL_BUFFERS(curbuf)

if (curbuf->b_ml.ml_mfp != NULL)

break;

// If there is no memfile at all, exit.

// This is OK, since there are no changes to lose.

if (curbuf == NULL)

{

emsg(_(e_cannot_allocate_any_buffer_exiting));

// Don't try to do any saving, with "curbuf" NULL almost nothing

// will work.

v_dying = 2;

getout(2);

}

emsg(_(e_cannot_allocate_buffer_using_other_one));

enter_buffer(curbuf);

#ifdef FEAT_SYN_HL

if (old_tw != curbuf->b_p_tw)

check_colorcolumn(NULL, curwin);

return FAIL;

}

// Do not sync this buffer yet, may first want to read the file.

if (curbuf->b_ml.ml_mfp != NULL)

curbuf->b_ml.ml_mfp->mf_dirty = MF_DIRTY_YES_NOSYNC;

// The autocommands in readfile() may change the buffer, but only AFTER

// reading the file.

set_bufref(&old_curbuf, curbuf);

curbuf->b_modified_was_set = FALSE;

// mark cursor position as being invalid

curwin->w_valid = 0;

// A buffer without an actual file should not use the buffer name to read a

// file.

if (bt_nofileread(curbuf))

flags |= READ_NOFILE;

// Read the file if there is one.

if (curbuf->b_ffname != NULL

#ifdef FEAT_NETBEANS_INTG

&& netbeansReadFile

)

{

int old_msg_silent = msg_silent;

#ifdef UNIX

int save_bin = curbuf->b_p_bin;

int perm;

#ifdef FEAT_NETBEANS_INTG

int oldFire = netbeansFireChanges;

netbeansFireChanges = 0;

#ifdef UNIX

perm = mch_getperm(curbuf->b_ffname);

if (perm >= 0 && (S_ISFIFO(perm)

|| S_ISSOCK(perm)

# ifdef OPEN_CHR_FILES

|| (S_ISCHR(perm) && is_dev_fd_file(curbuf->b_ffname))

))

read_fifo = TRUE;

if (read_fifo)

curbuf->b_p_bin = TRUE;

if (shortmess(SHM_FILEINFO))

msg_silent = 1;

retval = readfile(curbuf->b_ffname, curbuf->b_fname,

(linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, eap,

flags | READ_NEW | (read_fifo ? READ_FIFO : 0));

#ifdef UNIX

if (read_fifo)

{

curbuf->b_p_bin = save_bin;

if (retval == OK)

// don't add READ_FIFO here, otherwise we won't be able to

// detect the encoding

retval = read_buffer(FALSE, eap, flags);

}

msg_silent = old_msg_silent;

#ifdef FEAT_NETBEANS_INTG

netbeansFireChanges = oldFire;

// Help buffer is filtered.

if (bt_help(curbuf))

fix_help_buffer();

}

else if (read_stdin)

{

int save_bin = curbuf->b_p_bin;

// First read the text in binary mode into the buffer.

// Then read from that same buffer and append at the end. This makes

// it possible to retry when 'fileformat' or 'fileencoding' was

// guessed wrong.

curbuf->b_p_bin = TRUE;

retval = readfile(NULL, NULL, (linenr_T)0,

(linenr_T)0, (linenr_T)MAXLNUM, NULL,

flags | (READ_NEW + READ_STDIN));

curbuf->b_p_bin = save_bin;

if (retval == OK)

retval = read_buffer(TRUE, eap, flags);

}

// Can now sync this buffer in ml_sync_all().

if (curbuf->b_ml.ml_mfp != NULL

&& curbuf->b_ml.ml_mfp->mf_dirty == MF_DIRTY_YES_NOSYNC)

curbuf->b_ml.ml_mfp->mf_dirty = MF_DIRTY_YES;

// if first time loading this buffer, init b_chartab[]

if (curbuf->b_flags & BF_NEVERLOADED)

{

(void)buf_init_chartab(curbuf, FALSE);

parse_cino(curbuf);

}

// Set/reset the Changed flag first, autocmds may change the buffer.

// Apply the automatic commands, before processing the modelines.

// So the modelines have priority over autocommands.

//

// When reading stdin, the buffer contents always needs writing, so set

// the changed flag. Unless in readonly mode: "ls | gview -".

// When interrupted and 'cpoptions' contains 'i' set changed flag.

if ((got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL)

|| curbuf->b_modified_was_set // autocmd did ":set modified"

#ifdef FEAT_EVAL

|| (aborting() && vim_strchr(p_cpo, CPO_INTMOD) != NULL)

)

changed();

else if (retval == OK && !read_stdin && !read_fifo)

unchanged(curbuf, FALSE, TRUE);

save_file_ff(curbuf); // keep this fileformat

// Set last_changedtick to avoid triggering a TextChanged autocommand right

// after it was added.

curbuf->b_last_changedtick = CHANGEDTICK(curbuf);

curbuf->b_last_changedtick_i = CHANGEDTICK(curbuf);

curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf);

// require "!" to overwrite the file, because it wasn't read completely

#ifdef FEAT_EVAL

if (aborting())

if (got_int)

curbuf->b_flags |= BF_READERR;

#ifdef FEAT_FOLDING

// Need to update automatic folding. Do this before the autocommands,

// they may use the fold info.

foldUpdateAll(curwin);

// need to set w_topline, unless some autocommand already did that.

if (!(curwin->w_valid & VALID_TOPLINE))

{

curwin->w_topline = 1;

#ifdef FEAT_DIFF

curwin->w_topfill = 0;

}

#ifdef FEAT_EVAL

apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf, &retval);

apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);

if (retval != OK)

return retval;

// The autocommands may have changed the current buffer. Apply the

// modelines to the correct buffer, if it still exists and is loaded.

if (bufref_valid(&old_curbuf) && old_curbuf.br_buf->b_ml.ml_mfp != NULL)

{

aco_save_T aco;

// Go to the buffer that was opened, make sure it is in a window.

// If not then skip it.

aucmd_prepbuf(&aco, old_curbuf.br_buf);

if (curbuf == old_curbuf.br_buf)

{

do_modelines(0);

curbuf->b_flags &= ~(BF_CHECK_RO | BF_NEVERLOADED);

if ((flags & READ_NOWINENTER) == 0)

#ifdef FEAT_EVAL

apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL,

FALSE, curbuf, &retval);

apply_autocmds(EVENT_BUFWINENTER, NULL, NULL,

FALSE, curbuf);

// restore curwin/curbuf and a few other things

aucmd_restbuf(&aco);

}

}

return retval;

}

void

set_bufref(bufref_T *bufref, buf_T *buf)

{

bufref->br_buf = buf;

bufref->br_fnum = buf == NULL ? 0 : buf->b_fnum;

bufref->br_buf_free_count = buf_free_count;

}

int

bufref_valid(bufref_T *bufref)

{

return bufref->br_buf_free_count == buf_free_count

? TRUE : buf_valid(bufref->br_buf)

&& bufref->br_fnum == bufref->br_buf->b_fnum;

}

int

buf_valid(buf_T *buf)

{

buf_T *bp;

// Assume that we more often have a recent buffer, start with the last

// one.

FOR_ALL_BUFS_FROM_LAST(bp)

if (bp == buf)

return TRUE;

return FALSE;

}

static hashtab_T buf_hashtab;

static void

buf_hashtab_add(buf_T *buf)

{

vim_snprintf((char *)buf->b_key, sizeof(buf->b_key), "%x", buf->b_fnum);

if (hash_add(&buf_hashtab, buf->b_key, "create buffer") == FAIL)

emsg(_(e_buffer_cannot_be_registered));

}

static void

buf_hashtab_remove(buf_T *buf)

{

hashitem_T *hi = hash_find(&buf_hashtab, buf->b_key);

if (!HASHITEM_EMPTY(hi))

hash_remove(&buf_hashtab, hi, "close buffer");

}

static int

can_unload_buffer(buf_T *buf)

{

int can_unload = !buf->b_locked;

if (can_unload && updating_screen)

{

win_T *wp;

FOR_ALL_WINDOWS(wp)

if (wp->w_buffer == buf)

{

can_unload = FALSE;

break;

}

}

if (!can_unload)

{

char_u *fname = buf->b_fname != NULL ? buf->b_fname : buf->b_ffname;

semsg(_(e_attempt_to_delete_buffer_that_is_in_use_str),

fname != NULL ? fname : (char_u *)"[No Name]");

}

return can_unload;

}

int

close_buffer(

int ignore_abort)

{

int is_curbuf;

int nwindows;

bufref_T bufref;

int is_curwin = (curwin != NULL && curwin->w_buffer == buf);

win_T *the_curwin = curwin;

tabpage_T *the_curtab = curtab;

int unload_buf = (action != 0);

int wipe_buf = (action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE);

int del_buf = (action == DOBUF_DEL || wipe_buf);

CHECK_CURBUF;

// Force unloading or deleting when 'bufhidden' says so.

// The caller must take care of NOT deleting/freeing when 'bufhidden' is

// "hide" (otherwise we could never free or delete a buffer).

if (buf->b_p_bh[0] == 'd') // 'bufhidden' == "delete"

{

del_buf = TRUE;

unload_buf = TRUE;

}

else if (buf->b_p_bh[0] == 'w') // 'bufhidden' == "wipe"

{

del_buf = TRUE;

unload_buf = TRUE;

wipe_buf = TRUE;

}

else if (buf->b_p_bh[0] == 'u') // 'bufhidden' == "unload"

unload_buf = TRUE;

#ifdef FEAT_TERMINAL

// depending on how we get here b_nwindows may already be zero

if (bt_terminal(buf) && (buf->b_nwindows <= 1 || del_buf))

{

CHECK_CURBUF;

if (term_job_running(buf->b_term))

{

if (wipe_buf || unload_buf)

{

if (!can_unload_buffer(buf))

return FALSE;

// Wiping out or unloading a terminal buffer kills the job.

free_terminal(buf);

// A terminal buffer is wiped out when job has finished.

del_buf = TRUE;

unload_buf = TRUE;

wipe_buf = TRUE;

}

else

{

// The job keeps running, hide the buffer.

del_buf = FALSE;

unload_buf = FALSE;

}

}

else if (buf->b_p_bh[0] == 'h' && !del_buf)

{

// Hide a terminal buffer.

unload_buf = FALSE;

}

else

{

if (del_buf || unload_buf)

{

// A terminal buffer is wiped out if the job has finished.

// We only do this when there's an intention to unload the

// buffer. This way, :hide and other similar commands won't

// wipe the buffer.

del_buf = TRUE;

unload_buf = TRUE;

wipe_buf = TRUE;

}

}

CHECK_CURBUF;

}

// Disallow deleting the buffer when it is locked (already being closed or

// halfway a command that relies on it). Unloading is allowed.

if ((del_buf || wipe_buf) && !can_unload_buffer(buf))

return FALSE;

// check no autocommands closed the window

if (win != NULL && win_valid_any_tab(win))

{

// Set b_last_cursor when closing the last window for the buffer.

// Remember the last cursor position and window options of the buffer.

// This used to be only for the current window, but then options like

// 'foldmethod' may be lost with a ":only" command.

if (buf->b_nwindows == 1)

set_last_cursor(win);

buflist_setfpos(buf, win,

win->w_cursor.lnum == 1 ? 0 : win->w_cursor.lnum,

win->w_cursor.col, TRUE);

}

set_bufref(&bufref, buf);

// When the buffer is no longer in a window, trigger BufWinLeave

if (buf->b_nwindows == 1)

{

++buf->b_locked;

++buf->b_locked_split;

if (apply_autocmds(EVENT_BUFWINLEAVE, buf->b_fname, buf->b_fname,

FALSE, buf)

&& !bufref_valid(&bufref))

{

// Autocommands deleted the buffer.

aucmd_abort:

emsg(_(e_autocommands_caused_command_to_abort));

return FALSE;

}

--buf->b_locked;

--buf->b_locked_split;

if (abort_if_last && one_window())

// Autocommands made this the only window.

goto aucmd_abort;

// When the buffer becomes hidden, but is not unloaded, trigger

// BufHidden

if (!unload_buf)

{

++buf->b_locked;

++buf->b_locked_split;

if (apply_autocmds(EVENT_BUFHIDDEN, buf->b_fname, buf->b_fname,

FALSE, buf)

&& !bufref_valid(&bufref))

// Autocommands deleted the buffer.

goto aucmd_abort;

--buf->b_locked;

--buf->b_locked_split;

if (abort_if_last && one_window())

// Autocommands made this the only window.

goto aucmd_abort;

}

#ifdef FEAT_EVAL

// autocmds may abort script processing

if (!ignore_abort && aborting())

return FALSE;

}

// If the buffer was in curwin and the window has changed, go back to that

// window, if it still exists. This avoids that ":edit x" triggering a

// "tabnext" BufUnload autocmd leaves a window behind without a buffer.

if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin))

{

block_autocmds();

goto_tabpage_win(the_curtab, the_curwin);

unblock_autocmds();

}

nwindows = buf->b_nwindows;

// decrease the link count from windows (unless not in any window)

if (buf->b_nwindows > 0)

--buf->b_nwindows;

#ifdef FEAT_DIFF

if (diffopt_hiddenoff() && !unload_buf && buf->b_nwindows == 0)

diff_buf_delete(buf); // Clear 'diff' for hidden buffer.

// Return when a window is displaying the buffer or when it's not

// unloaded.

if (buf->b_nwindows > 0 || !unload_buf)

return FALSE;

// Always remove the buffer when there is no file name.

if (buf->b_ffname == NULL)

del_buf = TRUE;

// When closing the current buffer stop Visual mode before freeing

// anything.

if (buf == curbuf && VIsual_active

#if defined(EXITFREE)

&& !entered_free_all_mem

)

end_visual_mode();

// Free all things allocated for this buffer.

// Also calls the "BufDelete" autocommands when del_buf is TRUE.

//

// Remember if we are closing the current buffer. Restore the number of

// windows, so that autocommands in buf_freeall() don't get confused.

is_curbuf = (buf == curbuf);

buf->b_nwindows = nwindows;

buf_freeall(buf, (del_buf ? BFA_DEL : 0)

+ (wipe_buf ? BFA_WIPE : 0)

+ (ignore_abort ? BFA_IGNORE_ABORT : 0));

// Autocommands may have deleted the buffer.

if (!bufref_valid(&bufref))

return FALSE;

#ifdef FEAT_EVAL

// autocmds may abort script processing

if (!ignore_abort && aborting())

return FALSE;

// It's possible that autocommands change curbuf to the one being deleted.

// This might cause the previous curbuf to be deleted unexpectedly. But

// in some cases it's OK to delete the curbuf, because a new one is

// obtained anyway. Therefore only return if curbuf changed to the

// deleted buffer.

if (buf == curbuf && !is_curbuf)

return FALSE;

if (win_valid_any_tab(win) && win->w_buffer == buf)

win->w_buffer = NULL; // make sure we don't use the buffer now

// Autocommands may have opened or closed windows for this buffer.

// Decrement the count for the close we do here.

if (buf->b_nwindows > 0)

--buf->b_nwindows;

/*

if (wipe_buf)

{

tabpage_T *tp;

win_T *wp;

// Do not wipe out the buffer if it is used in a window.

if (buf->b_nwindows > 0)

return FALSE;

FOR_ALL_TAB_WINDOWS(tp, wp)

mark_forget_file(wp, buf->b_fnum);

if (action == DOBUF_WIPE_REUSE)

{

// we can re-use this buffer number, store it

if (buf_reuse.ga_itemsize == 0)

ga_init2(&buf_reuse, sizeof(int), 50);

if (ga_grow(&buf_reuse, 1) == OK)

((int *)buf_reuse.ga_data)[buf_reuse.ga_len++] = buf->b_fnum;

}

if (buf->b_sfname != buf->b_ffname)

VIM_CLEAR(buf->b_sfname);

else

buf->b_sfname = NULL;

VIM_CLEAR(buf->b_ffname);

if (buf->b_prev == NULL)

firstbuf = buf->b_next;

else

buf->b_prev->b_next = buf->b_next;

if (buf->b_next == NULL)

lastbuf = buf->b_prev;

else

buf->b_next->b_prev = buf->b_prev;

free_buffer(buf);

}

else

{

if (del_buf)

{

// Free all internal variables and reset option values, to make

// ":bdel" compatible with Vim 5.7.

free_buffer_stuff(buf, TRUE);

// Make it look like a new buffer.

buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED;

// Init the options when loaded again.

buf->b_p_initialized = FALSE;

}

buf_clear_file(buf);

if (del_buf)

buf->b_p_bl = FALSE;

}

// NOTE: at this point "curbuf" may be invalid!

return TRUE;

}

void

buf_clear_file(buf_T *buf)

{

buf->b_ml.ml_line_count = 1;

unchanged(buf, TRUE, TRUE);

buf->b_shortname = FALSE;

buf->b_p_eof = FALSE;

buf->b_start_eof = FALSE;

buf->b_p_eol = TRUE;

buf->b_start_eol = TRUE;

buf->b_p_bomb = FALSE;

buf->b_start_bomb = FALSE;

buf->b_ml.ml_mfp = NULL;

buf->b_ml.ml_flags = ML_EMPTY; // empty buffer

#ifdef FEAT_NETBEANS_INTG

netbeans_deleted_all_lines(buf);

}

void

buf_freeall(buf_T *buf, int flags)

{

int is_curbuf = (buf == curbuf);

bufref_T bufref;

int is_curwin = (curwin != NULL && curwin->w_buffer == buf);

win_T *the_curwin = curwin;

tabpage_T *the_curtab = curtab;

// Make sure the buffer isn't closed by autocommands.

++buf->b_locked;

++buf->b_locked_split;

set_bufref(&bufref, buf);

if (buf->b_ml.ml_mfp != NULL)

{

if (apply_autocmds(EVENT_BUFUNLOAD, buf->b_fname, buf->b_fname,

FALSE, buf)

&& !bufref_valid(&bufref))

// autocommands deleted the buffer

return;

}

if ((flags & BFA_DEL) && buf->b_p_bl)

{

if (apply_autocmds(EVENT_BUFDELETE, buf->b_fname, buf->b_fname,

FALSE, buf)

&& !bufref_valid(&bufref))

// autocommands deleted the buffer

return;

}

if (flags & BFA_WIPE)

{

if (apply_autocmds(EVENT_BUFWIPEOUT, buf->b_fname, buf->b_fname,

FALSE, buf)

&& !bufref_valid(&bufref))

// autocommands deleted the buffer

return;

}

--buf->b_locked;

--buf->b_locked_split;

// If the buffer was in curwin and the window has changed, go back to that

// window, if it still exists. This avoids that ":edit x" triggering a

// "tabnext" BufUnload autocmd leaves a window behind without a buffer.

if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin))

{

block_autocmds();

goto_tabpage_win(the_curtab, the_curwin);

unblock_autocmds();

}

#ifdef FEAT_EVAL

// autocmds may abort script processing

if ((flags & BFA_IGNORE_ABORT) == 0 && aborting())

return;

// It's possible that autocommands change curbuf to the one being deleted.

// This might cause curbuf to be deleted unexpectedly. But in some cases

// it's OK to delete the curbuf, because a new one is obtained anyway.

// Therefore only return if curbuf changed to the deleted buffer.

if (buf == curbuf && !is_curbuf)

return;

#ifdef FEAT_DIFF

diff_buf_delete(buf); // Can't use 'diff' for unloaded buffer.

#ifdef FEAT_SYN_HL

// Remove any ownsyntax, unless exiting.

if (curwin != NULL && curwin->w_buffer == buf)

reset_synblock(curwin);

#ifdef FEAT_FOLDING

// No folds in an empty buffer.

{

win_T *win;

tabpage_T *tp;

FOR_ALL_TAB_WINDOWS(tp, win)

if (win->w_buffer == buf)

clearFolding(win);

}

#ifdef FEAT_TCL

tcl_buffer_free(buf);

ml_close(buf, TRUE); // close and delete the memline/memfile

buf->b_ml.ml_line_count = 0; // no lines in buffer

if ((flags & BFA_KEEP_UNDO) == 0)

// free the memory allocated for undo

// and reset all undo information

u_clearallandblockfree(buf);

#ifdef FEAT_SYN_HL

syntax_clear(&buf->b_s); // reset syntax info

#ifdef FEAT_PROP_POPUP

clear_buf_prop_types(buf);

buf->b_flags &= ~BF_READERR; // a read error is no longer relevant

}

static void

free_buffer(buf_T *buf)

{

++buf_free_count;

free_buffer_stuff(buf, TRUE);

#ifdef FEAT_EVAL

// b:changedtick uses an item in buf_T, remove it now

dictitem_remove(buf->b_vars, (dictitem_T *)&buf->b_ct_di, "free buffer");

unref_var_dict(buf->b_vars);

remove_listeners(buf);

#ifdef FEAT_LUA

lua_buffer_free(buf);

#ifdef FEAT_MZSCHEME

mzscheme_buffer_free(buf);

#ifdef FEAT_PERL

perl_buf_free(buf);

#ifdef FEAT_PYTHON

python_buffer_free(buf);

#ifdef FEAT_PYTHON3

python3_buffer_free(buf);

#ifdef FEAT_RUBY