/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

/*

* buffer.c: functions for dealing with the buffer structure

*/

/*

* The buffer list is a double linked list of all buffers.

* Each buffer can be in one of these states:

* never loaded: BF_NEVERLOADED is set, only the file name is valid

* not loaded: b_ml.ml_mfp == NULL, no memfile allocated

* hidden: b_nwindows == 0, loaded but not displayed in a window

* normal: loaded and displayed in a window

*

* Instead of storing file names all over the place, each file name is

* stored in the buffer list. It can be referenced by a number.

*

* The current implementation remembers all file names ever used.

*/

#include "vim.h"

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);

static void buflist_setfpos(buf_T *buf, win_T *win, linenr_T lnum, colnr_T col, int copy_options);

#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);

#else

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

#endif

#ifdef FEAT_TITLE

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

#endif

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

static void free_buffer(buf_T *);

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

static void clear_wininfo(buf_T *buf);

#ifdef UNIX

# define dev_T dev_t

#else

# define dev_T unsigned

#endif

#if defined(FEAT_QUICKFIX)

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

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

#endif

static char *e_auabort = N_("E855: Autocommands caused command to abort");

/* Number of times free_buffer() was called. */

static int buf_free_count = 0;

/* Read data from buffer for retrying. */

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,

(linenr_T)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, FALSE);

}

else

{

/* Delete the converted lines. */

while (curbuf->b_ml.ml_line_count > line_count)

ml_delete(line_count, FALSE);

}

/* 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);

if (retval == OK)

{

#ifdef FEAT_EVAL

apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE,

curbuf, &retval);

#else

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

#endif

}

}

return retval;

}

/*

* Open current buffer, that is: open the memfile and read the file into

* memory.

* Return FAIL for failure, OK otherwise.

*/

int

open_buffer(

int read_stdin, /* read file from stdin */

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

int flags) /* extra flags for readfile() */

{

int retval = OK;

bufref_T old_curbuf;

#ifdef FEAT_SYN_HL

long old_tw = curbuf->b_p_tw;

#endif

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);

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(_("E82: Cannot allocate any buffer, exiting..."));

getout(2);

}

emsg(_("E83: Cannot allocate buffer, using other one..."));

enter_buffer(curbuf);

#ifdef FEAT_SYN_HL

if (old_tw != curbuf->b_p_tw)

check_colorcolumn(curwin);

#endif

return FAIL;

}

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

* reading the file. */

set_bufref(&old_curbuf, curbuf);

modified_was_set = FALSE;

/* mark cursor position as being invalid */

curwin->w_valid = 0;

if (curbuf->b_ffname != NULL

#ifdef FEAT_NETBEANS_INTG

&& netbeansReadFile

#endif

)

{

int old_msg_silent = msg_silent;

#ifdef UNIX

int save_bin = curbuf->b_p_bin;

int perm;

#endif

#ifdef FEAT_NETBEANS_INTG

int oldFire = netbeansFireChanges;

netbeansFireChanges = 0;

#endif

#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))

# endif

))

read_fifo = TRUE;

if (read_fifo)

curbuf->b_p_bin = TRUE;

#endif

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)

retval = read_buffer(FALSE, eap, flags);

}

#endif

msg_silent = old_msg_silent;

#ifdef FEAT_NETBEANS_INTG

netbeansFireChanges = oldFire;

#endif

/* 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);

}

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

if (curbuf->b_flags & BF_NEVERLOADED)

{

(void)buf_init_chartab(curbuf, FALSE);

#ifdef FEAT_CINDENT

parse_cino(curbuf);

#endif

}

/*

* 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)

|| modified_was_set /* ":set modified" used in autocmd */

#ifdef FEAT_EVAL

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

#endif

)

changed();

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

unchanged(curbuf, FALSE);

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);

#ifdef FEAT_INS_EXPAND

curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf);

#endif

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

#ifdef FEAT_EVAL

if (aborting())

#else

if (got_int)

#endif

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);

#endif

/* 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;

#endif

}

#ifdef FEAT_EVAL

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

#else

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

#endif

if (retval == OK)

{

/*

* 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. */

aucmd_prepbuf(&aco, old_curbuf.br_buf);

do_modelines(0);

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

#ifdef FEAT_EVAL

apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf,

&retval);

#else

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

#endif

/* restore curwin/curbuf and a few other things */

aucmd_restbuf(&aco);

}

}

return retval;

}

/*

* Store "buf" in "bufref" and set the free count.

*/

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;

}

/*

* Return TRUE if "bufref->br_buf" points to the same buffer as when

* set_bufref() was called and it is a valid buffer.

* Only goes through the buffer list if buf_free_count changed.

* Also checks if b_fnum is still the same, a :bwipe followed by :new might get

* the same allocated memory, but it's a different buffer.

*/

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;

}

/*

* Return TRUE if "buf" points to a valid buffer (in the buffer list).

* This can be slow if there are many buffers, prefer using bufref_valid().

*/

int

buf_valid(buf_T *buf)

{

buf_T *bp;

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

* one. */

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

if (bp == buf)

return TRUE;

return FALSE;

}

/*

* A hash table used to quickly lookup a buffer by its number.

*/

static hashtab_T buf_hashtab;

static void

buf_hashtab_add(buf_T *buf)

{

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

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

emsg(_("E931: 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);

}

/*

* Return TRUE when buffer "buf" can be unloaded.

* Give an error message and return FALSE when the buffer is locked or the

* screen is being redrawn and the buffer is in a window.

*/

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)

emsg(_("E937: Attempt to delete a buffer that is in use"));

return can_unload;

}

/*

* Close the link to a buffer.

* "action" is used when there is no longer a window for the buffer.

* It can be:

* 0 buffer becomes hidden

* DOBUF_UNLOAD buffer is unloaded

* DOBUF_DELETE buffer is unloaded and removed from buffer list

* DOBUF_WIPE buffer is unloaded and really deleted

* When doing all but the first one on the current buffer, the caller should

* get a new buffer very soon!

*

* The 'bufhidden' option can force freeing and deleting.

*

* When "abort_if_last" is TRUE then do not close the buffer if autocommands

* cause there to be only one window with this buffer. e.g. when ":quit" is

* supposed to close the window but autocommands close all other windows.

*/

void

close_buffer(

win_T *win, /* if not NULL, set b_last_cursor */

buf_T *buf,

int action,

int abort_if_last UNUSED)

{

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 del_buf = (action == DOBUF_DEL || action == DOBUF_WIPE);

int wipe_buf = (action == DOBUF_WIPE);

/*

* 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

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

{

if (term_job_running(buf->b_term))

{

if (wipe_buf || unload_buf)

{

if (!can_unload_buffer(buf))

return;

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

free_terminal(buf);

}

else

{

/* The job keeps running, hide the buffer. */

del_buf = FALSE;

unload_buf = FALSE;

}

}

else

{

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

del_buf = TRUE;

unload_buf = TRUE;

wipe_buf = TRUE;

}

}

#endif

/* 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;

/* 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;

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

FALSE, buf)

&& !bufref_valid(&bufref))

{

/* Autocommands deleted the buffer. */

aucmd_abort:

emsg(_(e_auabort));

return;

}

--buf->b_locked;

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;

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;

if (abort_if_last && one_window())

/* Autocommands made this the only window. */

goto aucmd_abort;

}

#ifdef FEAT_EVAL

if (aborting()) /* autocmds may abort script processing */

return;

#endif

}

/* 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. */

#endif

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

* unloaded. */

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

return;

/* 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

#endif

)

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));

/* Autocommands may have deleted the buffer. */

if (!bufref_valid(&bufref))

return;

#ifdef FEAT_EVAL

if (aborting()) /* autocmds may abort script processing */

return;

#endif

/*

* 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;

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;

#ifdef FEAT_ODB_EDITOR

odb_buffer_close(buf);

#endif

/*

* Remove the buffer from the list.

*/

if (wipe_buf)

{

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;

}

}

/*

* Make buffer not contain a file.

*/

void

buf_clear_file(buf_T *buf)

{

buf->b_ml.ml_line_count = 1;

unchanged(buf, TRUE);

buf->b_shortname = 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);

#endif

}

/*

* buf_freeall() - free all things allocated for a buffer that are related to

* the file. Careful: get here with "curwin" NULL when exiting.

* flags:

* BFA_DEL buffer is going to be deleted

* BFA_WIPE buffer is going to be wiped out

* BFA_KEEP_UNDO do not free undo information

*/

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;

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;

/* 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

if (aborting()) /* autocmds may abort script processing */

return;

#endif

/*

* 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. */

#endif

#ifdef FEAT_SYN_HL

/* Remove any ownsyntax, unless exiting. */

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

reset_synblock(curwin);

#endif

#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);

}

#endif

#ifdef FEAT_TCL

tcl_buffer_free(buf);

#endif

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)

{

u_blockfree(buf); /* free the memory allocated for undo */

u_clearall(buf); /* reset all undo information */

}

#ifdef FEAT_SYN_HL

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

#endif

#ifdef FEAT_TEXT_PROP

clear_buf_prop_types(buf);

#endif

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

}

/*

* Free a buffer structure and the things it contains related to the buffer

* itself (not the file, that must have been done already).

*/

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);

unref_var_dict(buf->b_vars);

#endif

#ifdef FEAT_LUA

lua_buffer_free(buf);

#endif

#ifdef FEAT_MZSCHEME

mzscheme_buffer_free(buf);

#endif

#ifdef FEAT_PERL

perl_buf_free(buf);

#endif

#ifdef FEAT_PYTHON

python_buffer_free(buf);

#endif

#ifdef FEAT_PYTHON3

python3_buffer_free(buf);

#endif

#ifdef FEAT_RUBY

ruby_buffer_free(buf);

#endif

#ifdef FEAT_JOB_CHANNEL

channel_buffer_free(buf);

#endif

#ifdef FEAT_TERMINAL

free_terminal(buf);

#endif

#ifdef FEAT_JOB_CHANNEL

vim_free(buf->b_prompt_text);

free_callback(buf->b_prompt_callback, buf->b_prompt_partial);

#endif

buf_hashtab_remove(buf);

aubuflocal_remove(buf);

if (autocmd_busy)

{

/* Do not free the buffer structure while autocommands are executing,

* it's still needed. Free it when autocmd_busy is reset. */

buf->b_next = au_pending_free_buf;

au_pending_free_buf = buf;

}

else

vim_free(buf);

}

/*

* Initializes b:changedtick.

*/

static void

init_changedtick(buf_T *buf)

{

dictitem_T *di = (dictitem_T *)&buf->b_ct_di;

di->di_flags = DI_FLAGS_FIX | DI_FLAGS_RO;

di->di_tv.v_type = VAR_NUMBER;

di->di_tv.v_lock = VAR_FIXED;

di->di_tv.vval.v_number = 0;

#ifdef FEAT_EVAL

STRCPY(buf->b_ct_di.di_key, "changedtick");

(void)dict_add(buf->b_vars, di);

#endif

}

/*

* Free stuff in the buffer for ":bdel" and when wiping out the buffer.

*/

static void

free_buffer_stuff(

buf_T *buf,

int free_options) /* free options as well */

{

if (free_options)

{

clear_wininfo(buf); /* including window-local options */

free_buf_options(buf, TRUE);

#ifdef FEAT_SPELL

ga_clear(&buf->b_s.b_langp);

#endif

}

#ifdef FEAT_EVAL

{

varnumber_T tick = CHANGEDTICK(buf);

vars_clear(&buf->b_vars->dv_hashtab); /* free all buffer variables */

hash_init(&buf->b_vars->dv_hashtab);

init_changedtick(buf);

CHANGEDTICK(buf) = tick;

}

#endif

uc_clear(&buf->b_ucmds); // clear local user commands

#ifdef FEAT_SIGNS

buf_delete_signs(buf, (char_u *)"*"); // delete any signs

#endif

#ifdef FEAT_NETBEANS_INTG

netbeans_file_killed(buf);

#endif

#ifdef FEAT_LOCALMAP

map_clear_int(buf, MAP_ALL_MODES, TRUE, FALSE); /* clear local mappings */

map_clear_int(buf, MAP_ALL_MODES, TRUE, TRUE); /* clear local abbrevs */

#endif

VIM_CLEAR(buf->b_start_fenc);

}

/*

* Free the b_wininfo list for buffer "buf".

*/

static void

clear_wininfo(buf_T *buf)

{

wininfo_T *wip;

while (buf->b_wininfo != NULL)

{

wip = buf->b_wininfo;

buf->b_wininfo = wip->wi_next;

if (wip->wi_optset)

{

clear_winopt(&wip->wi_opt);

#ifdef FEAT_FOLDING

deleteFoldRecurse(&wip->wi_folds);

#endif

}

vim_free(wip);

}

}

/*

* Go to another buffer. Handles the result of the ATTENTION dialog.

*/

void

goto_buffer(

exarg_T *eap,

int start,

int dir,

int count)

{

bufref_T old_curbuf;

set_bufref(&old_curbuf, curbuf);

swap_exists_action = SEA_DIALOG;

(void)do_buffer(*eap->cmd == 's' ? DOBUF_SPLIT : DOBUF_GOTO,

start, dir, count, eap->forceit);

if (swap_exists_action == SEA_QUIT && *eap->cmd == 's')

{

#if defined(FEAT_EVAL)

cleanup_T cs;

/* Reset the error/interrupt/exception state here so that

* aborting() returns FALSE when closing a window. */

enter_cleanup(&cs);

#endif

/* Quitting means closing the split window, nothing else. */

win_close(curwin, TRUE);

swap_exists_action = SEA_NONE;

swap_exists_did_quit = TRUE;