IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1108 from war1025/dev/for_all_tabs

Browse Source 
FOR_ALL_TAB_WINDOWS cleanup. Add FOR_ALL_TABS and FOR_ALL_WINDOWS_IN_TAB.
This commit is contained in:
Justin M. Keyes 2014-09-22 13:38:58 -04:00
commit 1c84a0e090
18 changed files with 253 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/nvim/api/tabpage.c
View File

@ -7,6 +7,7 @@
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/memory.h"
#include "nvim/window.h"
/// Gets the number of windows in a tabpage
///
@ -18,27 +19,18 @@ ArrayOf(Window) tabpage_get_windows(Tabpage tabpage, Error *err)
Array rv = ARRAY_DICT_INIT;
tabpage_T *tab = find_tab_by_handle(tabpage, err);
if (!tab) {
if (!tab || !valid_tabpage(tab)) {
return rv;
}
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (tp != tab) {
break;
}
FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
rv.size++;
}
rv.items = xmalloc(sizeof(Object) * rv.size);
size_t i = 0;
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (tp != tab) {
break;
}
FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
rv.items[i++] = WINDOW_OBJ(wp->handle);
}
@ -90,18 +82,15 @@ Window tabpage_get_window(Tabpage tabpage, Error *err)
Window rv = 0;
tabpage_T *tab = find_tab_by_handle(tabpage, err);
if (!tab) {
if (!tab || !valid_tabpage(tab)) {
return rv;
}
if (tab == curtab) {
return vim_get_current_window();
} else {
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (tp == tab && wp == tab->tp_curwin) {
FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
if (wp == tab->tp_curwin) {
return wp->handle;
}
}

2
src/nvim/api/vim.c
View File

@ -380,8 +380,6 @@ void vim_set_current_buffer(Buffer buffer, Error *err)
ArrayOf(Window) vim_get_windows(void)
{
Array rv = ARRAY_DICT_INIT;
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp) {
rv.size++;

16
src/nvim/buffer.c
View File

@ -514,12 +514,8 @@ void buf_freeall(buf_T *buf, int flags)
reset_synblock(curwin);
/* No folds in an empty buffer. */
{
win_T *win;
tabpage_T *tp;
FOR_ALL_TAB_WINDOWS(tp, win) {
if (win->w_buffer == buf)
if (win->w_buffer == buf) {
clearFolding(win);
}
}
@ -4206,8 +4202,6 @@ int read_viminfo_bufferlist(vir_T *virp, int writing)
void write_viminfo_bufferlist(FILE *fp)
{
win_T *win;
tabpage_T *tp;
char_u *line;
int max_buffers;
@ -4284,8 +4278,12 @@ char_u *buf_spname(buf_T *buf)
*/
bool find_win_for_buf(buf_T *buf, win_T **wp, tabpage_T **tp)
{
FOR_ALL_TAB_WINDOWS(*tp, *wp) {
if ((*wp)->w_buffer == buf) {
*wp = NULL;
*tp = NULL;
FOR_ALL_TAB_WINDOWS(tp2, wp2) {
if (wp2->w_buffer == buf) {
*tp = tp2;
*wp = wp2;
return true;
}
}

21
src/nvim/diff.c
View File

@ -62,8 +62,7 @@ static int diff_a_works = MAYBE;
/// @param buf
void diff_buf_delete(buf_T *buf)
{
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
int i = diff_buf_idx_tp(buf, tp);
if (i != DB_COUNT) {
@ -175,8 +174,7 @@ static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp)
/// @param buf
void diff_invalidate(buf_T *buf)
{
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
int i = diff_buf_idx_tp(buf, tp);
if (i != DB_COUNT) {
tp->tp_diff_invalid = TRUE;
@ -197,8 +195,7 @@ void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount,
long amount_after)
{
// Handle all tab pages that use the current buffer in a diff.
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
int idx = diff_buf_idx_tp(curbuf, tp);
if (idx != DB_COUNT) {
diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after);
@ -1819,8 +1816,7 @@ int diffopt_changed(void)
// If "icase" or "iwhite" was added or removed, need to update the diff.
if (diff_flags != diff_flags_new) {
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
tp->tp_diff_invalid = TRUE;
}
}
@ -2376,15 +2372,14 @@ static void diff_fold_update(diff_T *dp, int skip_idx)
/// @param buf The buffer to check.
///
/// @return TRUE if buffer "buf" is in diff-mode.
int diff_mode_buf(buf_T *buf)
bool diff_mode_buf(buf_T *buf)
{
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
if (diff_buf_idx_tp(buf, tp) != DB_COUNT) {
return TRUE;
return true;
}
}
return FALSE;
return false;
}
/// Move "count" times in direction "dir" to the next diff block.

36
src/nvim/eval.c
View File

@ -5403,11 +5403,9 @@ static int list_join(garray_T *gap, list_T *l, char_u *sep, int echo_style, int
int garbage_collect(void)
{
int copyID;
win_T *wp;
funccall_T *fc, **pfc;
int did_free;
int did_free_funccal = FALSE;
tabpage_T *tp;
/* Only do this once. */
want_garbage_collect = FALSE;
@ -5442,14 +5440,16 @@ int garbage_collect(void)
}
/* window-local variables */
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
set_ref_in_item(&wp->w_winvar.di_tv, copyID);
}
if (aucmd_win != NULL)
set_ref_in_item(&aucmd_win->w_winvar.di_tv, copyID);
/* tabpage-local variables */
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
FOR_ALL_TABS(tp) {
set_ref_in_item(&tp->tp_winvar.di_tv, copyID);
}
/* global variables */
set_ref_in_ht(&globvarht, copyID);
@ -9588,21 +9588,27 @@ find_win_by_nr (
tabpage_T *tp /* NULL for current tab page */
)
{
win_T *wp;
int nr;
int nr = get_tv_number_chk(vp, NULL);
nr = get_tv_number_chk(vp, NULL);
if (nr < 0)
if (nr < 0) {
return NULL;
if (nr == 0)
return curwin;
}
for (wp = (tp == NULL || tp == curtab) ? firstwin : tp->tp_firstwin;
wp != NULL; wp = wp->w_next)
if (--nr <= 0)
break;
if (nr == 0) {
return curwin;
}
// This method accepts NULL as an alias for curtab.
if (tp == NULL) {
tp = curtab;
}
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (--nr <= 0) {
return wp;
}
}
return NULL;
}
/*

9
src/nvim/ex_cmds.c
View File

@ -2962,14 +2962,11 @@ do_ecmd (
/* It's possible that all lines in the buffer changed. Need to update
* automatic folding for all windows where it's used. */
{
win_T *win;
tabpage_T *tp;
FOR_ALL_TAB_WINDOWS(tp, win)
if (win->w_buffer == curbuf)
FOR_ALL_TAB_WINDOWS(tp, win) {
if (win->w_buffer == curbuf) {
foldUpdateAll(win);
}
}
/* Change directories when the 'acd' option is set. */
do_autochdir();

15
src/nvim/ex_cmds2.c
View File

@ -1204,7 +1204,6 @@ check_changed_any (
int bufnum = 0;
int bufcount = 0;
int *bufnrs;
tabpage_T *tp;
FOR_ALL_BUFFERS(buf) {
++bufcount;
@ -1225,9 +1224,9 @@ check_changed_any (
}
/* buf in other tab */
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
if (tp != curtab) {
for (win_T *wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next) {
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
add_bufnum(bufnrs, &bufnum, wp->w_buffer->b_fnum);
}
}
@ -1282,7 +1281,6 @@ check_changed_any (
/* Try to find a window that contains the buffer. */
if (buf != curbuf) {
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_buffer == buf) {
goto_tabpage_win(tp, wp);
@ -1510,12 +1508,11 @@ do_arglist (
*/
static void alist_check_arg_idx(void)
{
win_T *win;
tabpage_T *tp;
FOR_ALL_TAB_WINDOWS(tp, win)
if (win->w_alist == curwin->w_alist)
FOR_ALL_TAB_WINDOWS(tp, win) {
if (win->w_alist == curwin->w_alist) {
check_arg_idx(win);
}
}
}
/*

53
src/nvim/ex_docmd.c
View File

@ -5267,9 +5267,6 @@ static void ex_tabclose(exarg_T *eap)
*/
static void ex_tabonly(exarg_T *eap)
{
tabpage_T *tp;
int done;
if (cmdwin_type != 0)
cmdwin_result = K_IGNORE;
else if (first_tabpage->tp_next == NULL)
@ -5277,8 +5274,8 @@ static void ex_tabonly(exarg_T *eap)
else {
/* Repeat this up to a 1000 times, because autocommands may mess
* up the lists. */
for (done = 0; done < 1000; ++done) {
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
for (int done = 0; done < 1000; ++done) {
FOR_ALL_TABS(tp) {
if (tp->tp_topframe != topframe) {
tabpage_close_other(tp, eap->forceit);
/* if we failed to close it quit */
@ -5287,10 +5284,12 @@ static void ex_tabonly(exarg_T *eap)
/* start over, "tp" is now invalid */
break;
}
if (first_tabpage->tp_next == NULL)
}
if (first_tabpage->tp_next == NULL) {
break;
}
}
}
}
/*
@ -5607,18 +5606,21 @@ alist_add (
*/
void alist_slash_adjust(void)
{
int i;
win_T *wp;
tabpage_T *tp;
for (i = 0; i < GARGCOUNT; ++i)
if (GARGLIST[i].ae_fname != NULL)
for (int i = 0; i < GARGCOUNT; ++i) {
if (GARGLIST[i].ae_fname != NULL) {
slash_adjust(GARGLIST[i].ae_fname);
FOR_ALL_TAB_WINDOWS(tp, wp)
if (wp->w_alist != &global_alist)
for (i = 0; i < WARGCOUNT(wp); ++i)
if (WARGLIST(wp)[i].ae_fname != NULL)
}
}
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_alist != &global_alist) {
for (int i = 0; i < WARGCOUNT(wp); ++i) {
if (WARGLIST(wp)[i].ae_fname != NULL) {
slash_adjust(WARGLIST(wp)[i].ae_fname);
}
}
}
}
}
#endif
@ -5808,24 +5810,27 @@ static void ex_tabmove(exarg_T *eap)
*/
static void ex_tabs(exarg_T *eap)
{
tabpage_T *tp;
win_T *wp;
int tabcount = 1;
msg_start();
msg_scroll = TRUE;
for (tp = first_tabpage; tp != NULL && !got_int; tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
if (got_int) {
break;
}
msg_putchar('\n');
vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
msg_outtrans_attr(IObuff, hl_attr(HLF_T));
out_flush(); /* output one line at a time */
ui_breakcheck();
if (tp == curtab)
wp = firstwin;
else
wp = tp->tp_firstwin;
for (; wp != NULL && !got_int; wp = wp->w_next) {
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (got_int) {
break;
}
msg_putchar('\n');
msg_putchar(wp == curwin ? '>' : ' ');
msg_putchar(' ');

18
src/nvim/fileio.c
View File

@ -5102,16 +5102,15 @@ void buf_reload(buf_T *buf, int orig_mode)
check_cursor();
update_topline();
keep_filetype = FALSE;
{
win_T *wp;
tabpage_T *tp;
/* Update folds unless they are defined manually. */
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_buffer == curwin->w_buffer
&& !foldmethodIsManual(wp))
&& !foldmethodIsManual(wp)) {
foldUpdateAll(wp);
}
}
/* If the mode didn't change and 'readonly' was set, keep the old
* value; the user probably used the ":view" command. But don't
* reset it, might have had a read error. */
@ -6269,14 +6268,11 @@ aucmd_restbuf (
* page. Do not trigger autocommands here. */
block_autocmds();
if (curwin != aucmd_win) {
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp)
{
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp == aucmd_win) {
if (tp != curtab)
if (tp != curtab) {
goto_tabpage_tp(tp, TRUE, TRUE);
}
win_goto(aucmd_win);
goto win_found;
}

15
src/nvim/globals.h
View File

@ -519,15 +519,19 @@ EXTERN win_T *firstwin; /* first window */
EXTERN win_T *lastwin; /* last window */
EXTERN win_T *prevwin INIT(= NULL); /* previous window */
# define W_NEXT(wp) ((wp)->w_next)
# define FOR_ALL_WINDOWS(wp) for (win_T *wp = firstwin; wp != NULL; wp = wp->w_next)
# define FOR_ALL_WINDOWS(wp) \
FOR_ALL_WINDOWS_IN_TAB(wp, curtab)
/*
* When using this macro "break" only breaks out of the inner loop. Use "goto"
* to break out of the tabpage loop.
*/
# define FOR_ALL_TAB_WINDOWS(tp, wp) \
for ((tp) = first_tabpage; (tp) != NULL; (tp) = (tp)->tp_next) \
for ((wp) = ((tp) == curtab) \
? firstwin : (tp)->tp_firstwin; (wp); (wp) = (wp)->w_next)
FOR_ALL_TABS(tp) \
FOR_ALL_WINDOWS_IN_TAB(wp, tp)
# define FOR_ALL_WINDOWS_IN_TAB(wp, tp) \
for (win_T *wp = ((tp) == curtab) \
? firstwin : (tp)->tp_firstwin; wp != NULL; wp = wp->w_next)
EXTERN win_T *curwin; /* currently active window */
@ -548,6 +552,9 @@ EXTERN tabpage_T *first_tabpage;
EXTERN tabpage_T *curtab;
EXTERN int redraw_tabline INIT(= FALSE); /* need to redraw tabline */
// Iterates over all tabs in the tab list
# define FOR_ALL_TABS(tp) for (tabpage_T *tp = first_tabpage; tp != NULL; tp = tp->tp_next)
/*
* All buffers are linked in a list. 'firstbuf' points to the first entry,
* 'lastbuf' to the last entry and 'curbuf' to the currently active buffer.

8
src/nvim/main.c
View File

@ -758,7 +758,6 @@ main_loop (
/* Exit properly */
void getout(int exitval)
{
win_T *wp;
tabpage_T *tp, *next_tp;
exiting = TRUE;
@ -780,11 +779,12 @@ void getout(int exitval)
/* Trigger BufWinLeave for all windows, but only once per buffer. */
for (tp = first_tabpage; tp != NULL; tp = next_tp) {
next_tp = tp->tp_next;
for (wp = (tp == curtab)
? firstwin : tp->tp_firstwin; wp != NULL; wp = wp->w_next) {
if (wp->w_buffer == NULL)
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (wp->w_buffer == NULL) {
/* Autocmd must have close the buffer already, skip. */
continue;
}
buf_T *buf = wp->w_buffer;
if (buf->b_changedtick != -1) {
apply_autocmds(EVENT_BUFWINLEAVE, buf->b_fname,

71
src/nvim/mark.c
View File

@ -898,8 +898,6 @@ void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
int i;
int fnum = curbuf->b_fnum;
linenr_T *lp;
win_T *win;
tabpage_T *tab;
static pos_T initpos = INIT_POS_T(1, 0, 0);
if (line2 < line1 && amount_after == 0L) /* nothing to do */
@ -939,8 +937,9 @@ void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
/* quickfix marks */
qf_mark_adjust(NULL, line1, line2, amount, amount_after);
/* location lists */
FOR_ALL_TAB_WINDOWS(tab, win)
FOR_ALL_TAB_WINDOWS(tab, win) {
qf_mark_adjust(win, line1, line2, amount, amount_after);
}
sign_mark_adjust(line1, line2, amount, amount_after);
}
@ -958,21 +957,26 @@ void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
/*
* Adjust items in all windows related to the current buffer.
*/
FOR_ALL_TAB_WINDOWS(tab, win)
{
if (!cmdmod.lockmarks)
FOR_ALL_TAB_WINDOWS(tab, win) {
if (!cmdmod.lockmarks) {
/* Marks in the jumplist. When deleting lines, this may create
* duplicate marks in the jumplist, they will be removed later. */
for (i = 0; i < win->w_jumplistlen; ++i)
if (win->w_jumplist[i].fmark.fnum == fnum)
for (i = 0; i < win->w_jumplistlen; ++i) {
if (win->w_jumplist[i].fmark.fnum == fnum) {
one_adjust_nodel(&(win->w_jumplist[i].fmark.mark.lnum));
}
}
}
if (win->w_buffer == curbuf) {
if (!cmdmod.lockmarks)
if (!cmdmod.lockmarks) {
/* marks in the tag stack */
for (i = 0; i < win->w_tagstacklen; i++)
if (win->w_tagstack[i].fmark.fnum == fnum)
for (i = 0; i < win->w_tagstacklen; i++) {
if (win->w_tagstack[i].fmark.fnum == fnum) {
one_adjust_nodel(&(win->w_tagstack[i].fmark.mark.lnum));
}
}
}
/* the displayed Visual area */
if (win->w_old_cursor_lnum != 0) {
@ -985,12 +989,14 @@ void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
if (win != curwin) {
if (win->w_topline >= line1 && win->w_topline <= line2) {
if (amount == MAXLNUM) { /* topline is deleted */
if (line1 <= 1)
if (line1 <= 1) {
win->w_topline = 1;
else
} else {
win->w_topline = line1 - 1;
} else /* keep topline on the same line */
}
} else { /* keep topline on the same line */
win->w_topline += amount;
}
win->w_topfill = 0;
} else if (amount_after && win->w_topline > line2) {
win->w_topline += amount_after;
@ -998,16 +1004,19 @@ void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
}
if (win->w_cursor.lnum >= line1 && win->w_cursor.lnum <= line2) {
if (amount == MAXLNUM) { /* line with cursor is deleted */
if (line1 <= 1)
if (line1 <= 1) {
win->w_cursor.lnum = 1;
else
} else {
win->w_cursor.lnum = line1 - 1;
}
win->w_cursor.col = 0;
} else /* keep cursor on the same line */
} else { /* keep cursor on the same line */
win->w_cursor.lnum += amount;
} else if (amount_after && win->w_cursor.lnum > line2)
}
} else if (amount_after && win->w_cursor.lnum > line2) {
win->w_cursor.lnum += amount_after;
}
}
/* adjust folds */
foldMarkAdjust(win, line1, line2, amount, amount_after);
@ -1338,12 +1347,6 @@ int removable(char_u *name)
*/
int write_viminfo_marks(FILE *fp_out)
{
int count;
int is_mark_set;
int i;
win_T *win;
tabpage_T *tp;
/*
* Set b_last_cursor for the all buffers that have a window.
*/
@ -1352,23 +1355,23 @@ int write_viminfo_marks(FILE *fp_out)
}
fputs(_("\n# History of marks within files (newest to oldest):\n"), fp_out);
count = 0;
int count = 0;
FOR_ALL_BUFFERS(buf) {
/*
* Only write something if buffer has been loaded and at least one
* mark is set.
*/
if (buf->b_marks_read) {
if (buf->b_last_cursor.lnum != 0)
is_mark_set = TRUE;
else {
is_mark_set = FALSE;
for (i = 0; i < NMARKS; i++)
bool is_mark_set = true;
if (buf->b_last_cursor.lnum == 0) {
is_mark_set = false;
for (int i = 0; i < NMARKS; i++) {
if (buf->b_namedm[i].lnum != 0) {
is_mark_set = TRUE;
is_mark_set = true;
break;
}
}
}
if (is_mark_set && buf->b_ffname != NULL
&& buf->b_ffname[0] != NUL && !removable(buf->b_ffname)) {
home_replace(NULL, buf->b_ffname, IObuff, IOSIZE, TRUE);
@ -1378,10 +1381,12 @@ int write_viminfo_marks(FILE *fp_out)
write_one_mark(fp_out, '^', &buf->b_last_insert);
write_one_mark(fp_out, '.', &buf->b_last_change);
/* changelist positions are stored oldest first */
for (i = 0; i < buf->b_changelistlen; ++i)
for (int i = 0; i < buf->b_changelistlen; ++i) {
write_one_mark(fp_out, '+', &buf->b_changelist[i]);
for (i = 0; i < NMARKS; i++)
}
for (int i = 0; i < NMARKS; i++) {
write_one_mark(fp_out, 'a' + i, &buf->b_namedm[i]);
}
count++;
}
}

6
src/nvim/memory.c
View File

@ -452,13 +452,9 @@ void free_all_mem(void)
p_hi = 0;
init_history();
{
win_T *win;
tabpage_T *tab;
qf_free_all(NULL);
/* Free all location lists */
FOR_ALL_TAB_WINDOWS(tab, win)
FOR_ALL_TAB_WINDOWS(tab, win) {
qf_free_all(win);
}

17
src/nvim/misc1.c
View File

@ -2027,8 +2027,6 @@ changed_lines_buf (
*/
static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, long xtra)
{
win_T *wp;
tabpage_T *tp;
int i;
int cols;
pos_T *p;
@ -2072,22 +2070,22 @@ static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, long xtra
curbuf->b_changelistlen = JUMPLISTSIZE - 1;
memmove(curbuf->b_changelist, curbuf->b_changelist + 1,
sizeof(pos_T) * (JUMPLISTSIZE - 1));
FOR_ALL_TAB_WINDOWS(tp, wp)
{
FOR_ALL_TAB_WINDOWS(tp, wp) {
/* Correct position in changelist for other windows on
* this buffer. */
if (wp->w_buffer == curbuf && wp->w_changelistidx > 0)
if (wp->w_buffer == curbuf && wp->w_changelistidx > 0) {
--wp->w_changelistidx;
}
}
FOR_ALL_TAB_WINDOWS(tp, wp)
{
}
FOR_ALL_TAB_WINDOWS(tp, wp) {
/* For other windows, if the position in the changelist is
* at the end it stays at the end. */
if (wp->w_buffer == curbuf
&& wp->w_changelistidx == curbuf->b_changelistlen)
&& wp->w_changelistidx == curbuf->b_changelistlen) {
++wp->w_changelistidx;
}
}
++curbuf->b_changelistlen;
}
}
@ -2098,8 +2096,7 @@ static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, long xtra
curwin->w_changelistidx = curbuf->b_changelistlen;
}
FOR_ALL_TAB_WINDOWS(tp, wp)
{
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_buffer == curbuf) {
/* Mark this window to be redrawn later. */
if (wp->w_redr_type < VALID)

19
src/nvim/option.c
View File

@ -2210,17 +2210,16 @@ set_options_default (
int opt_flags /* OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL */
)
{
int i;
win_T *wp;
tabpage_T *tp;
for (i = 0; !istermoption(&options[i]); i++)
if (!(options[i].flags & P_NODEFAULT))
for (int i = 0; !istermoption(&options[i]); i++) {
if (!(options[i].flags & P_NODEFAULT)) {
set_option_default(i, opt_flags, p_cp);
}
}
/* The 'scroll' option must be computed for all windows. */
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_comp_scroll(wp);
}
}
/// Set the Vi-default value of a string option.
@ -5532,13 +5531,11 @@ set_num_option (
errmsg = e_positive;
curbuf->b_p_tw = 0;
}
{
win_T *wp;
tabpage_T *tp;
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
check_colorcolumn(wp);
}
}
/*

15
src/nvim/quickfix.c
View File

@ -1466,11 +1466,7 @@ void qf_jump(qf_info_T *qi, int dir, int errornr, int forceit)
* then search in other tabs.
*/
if (!usable_win && (swb_flags & SWB_USETAB)) {
tabpage_T *tp;
win_T *wp;
FOR_ALL_TAB_WINDOWS(tp, wp)
{
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_buffer->b_fnum == qf_ptr->qf_fnum) {
goto_tabpage_win(tp, wp);
usable_win = true;
@ -2236,12 +2232,11 @@ static win_T *qf_find_win(qf_info_T *qi)
*/
static buf_T *qf_find_buf(qf_info_T *qi)
{
tabpage_T *tp;
win_T *win;
FOR_ALL_TAB_WINDOWS(tp, win)
if (is_qf_win(win, qi))
FOR_ALL_TAB_WINDOWS(tp, win) {
if (is_qf_win(win, qi)) {
return win->w_buffer;
}
}
return NULL;
}

20
src/nvim/screen.c
View File

@ -6263,7 +6263,6 @@ int screen_valid(int doclear)
void screenalloc(bool doclear)
{
int new_row, old_row;
win_T *wp;
int outofmem = FALSE;
int len;
schar_T *new_ScreenLines;
@ -6275,7 +6274,6 @@ void screenalloc(bool doclear)
unsigned *new_LineOffset;
char_u *new_LineWraps;
short *new_TabPageIdxs;
tabpage_T *tp;
static int entered = FALSE; /* avoid recursiveness */
static int done_outofmem_msg = FALSE; /* did outofmem message */
int retry_count = 0;
@ -6328,8 +6326,9 @@ retry:
* Continuing with the old ScreenLines may result in a crash, because the
* size is wrong.
*/
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_free_lsize(wp);
}
if (aucmd_win != NULL)
win_free_lsize(aucmd_win);
@ -6349,8 +6348,7 @@ retry:
new_LineWraps = xmalloc((size_t)(Rows * sizeof(char_u)));
new_TabPageIdxs = xmalloc((size_t)(Columns * sizeof(short)));
FOR_ALL_TAB_WINDOWS(tp, wp)
{
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_alloc_lines(wp);
}
if (aucmd_win != NULL && aucmd_win->w_lines == NULL) {
@ -7632,7 +7630,6 @@ void unshowmode(int force)
static void draw_tabline(void)
{
int tabcount = 0;
tabpage_T *tp;
int tabwidth;
int col = 0;
int scol = 0;
@ -7675,8 +7672,9 @@ static void draw_tabline(void)
(char_u *)"", OPT_FREE, SID_ERROR);
called_emsg |= save_called_emsg;
} else {
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
FOR_ALL_TABS(tp) {
++tabcount;
}
tabwidth = (Columns - 1 + tabcount / 2) / tabcount;
if (tabwidth < 6)
@ -7685,8 +7683,12 @@ static void draw_tabline(void)
attr = attr_nosel;
tabcount = 0;
scol = 0;
for (tp = first_tabpage; tp != NULL && col < Columns - 4;
tp = tp->tp_next) {
FOR_ALL_TABS(tp) {
if (col >= Columns - 4) {
break;
}
scol = col;
if (tp->tp_topframe == topframe)

109
src/nvim/window.c
View File

@ -1674,13 +1674,12 @@ close_windows (
int keep_curwin /* don't close "curwin" */
)
{
win_T *wp;
tabpage_T *tp, *nexttp;
int h = tabline_height();
++RedrawingDisabled;
for (wp = firstwin; wp != NULL && lastwin != firstwin; ) {
for (win_T *wp = firstwin; wp != NULL && lastwin != firstwin; ) {
if (wp->w_buffer == buf && (!keep_curwin || wp != curwin)
&& !(wp->w_closing || wp->w_buffer->b_closing)
) {
@ -1695,8 +1694,8 @@ close_windows (
/* Also check windows in other tab pages. */
for (tp = first_tabpage; tp != NULL; tp = nexttp) {
nexttp = tp->tp_next;
if (tp != curtab)
for (wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next)
if (tp != curtab) {
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (wp->w_buffer == buf
&& !(wp->w_closing || wp->w_buffer->b_closing)
) {
@ -1708,6 +1707,8 @@ close_windows (
break;
}
}
}
}
--RedrawingDisabled;
@ -1963,7 +1964,6 @@ int win_close(win_T *win, int free_buf)
*/
void win_close_othertab(win_T *win, int free_buf, tabpage_T *tp)
{
win_T *wp;
int dir;
tabpage_T *ptp = NULL;
int free_tp = FALSE;
@ -1982,10 +1982,18 @@ void win_close_othertab(win_T *win, int free_buf, tabpage_T *tp)
return;
/* Autocommands may have closed the window already. */
for (wp = tp->tp_firstwin; wp != NULL && wp != win; wp = wp->w_next)
;
if (wp == NULL)
{
bool found_window = false;
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (wp == win) {
found_window = true;
break;
}
}
if (!found_window) {
return;
}
}
/* When closing the last window in a tab page remove the tab page. */
if (tp->tp_firstwin == tp->tp_lastwin) {
@ -2986,14 +2994,14 @@ int make_tabpages(int maxcount)
/*
* Return TRUE when "tpc" points to a valid tab page.
*/
int valid_tabpage(tabpage_T *tpc)
bool valid_tabpage(tabpage_T *tpc)
{
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
if (tp == tpc)
return TRUE;
return FALSE;
FOR_ALL_TABS(tp) {
if (tp == tpc) {
return true;
}
}
return false;
}
/*
@ -3285,14 +3293,11 @@ void win_goto(win_T *wp)
*/
tabpage_T *win_find_tabpage(win_T *win)
{
win_T *wp;
tabpage_T *tp;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
for (wp = (tp == curtab ? firstwin : tp->tp_firstwin);
wp != NULL; wp = wp->w_next)
if (wp == win)
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp == win) {
return tp;
}
}
return NULL;
}
@ -3549,28 +3554,36 @@ win_T *buf_jump_open_win(buf_T *buf)
*/
win_T *buf_jump_open_tab(buf_T *buf)
{
win_T *wp;
tabpage_T *tp;
/* First try the current tab page. */
wp = buf_jump_open_win(buf);
// First try the current tab page.
{
win_T *wp = buf_jump_open_win(buf);
if (wp != NULL)
return wp;
}
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
FOR_ALL_TABS(tp) {
// Skip the current tab since we already checked it.
if (tp != curtab) {
for (wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next)
if (wp->w_buffer == buf)
break;
if (wp != NULL) {
FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
if (wp->w_buffer == buf) {
goto_tabpage_win(tp, wp);
if (curwin != wp)
wp = NULL; /* something went wrong */
break;
// If we the current window didn't switch,
// something went wrong.
if (curwin != wp) {
wp = NULL;
}
// Return the window we switched to.
return wp;
}
}
}
}
return wp;
// If we made it this far, we didn't find the buffer.
return NULL;
}
/*
@ -4963,19 +4976,16 @@ int tabline_height(void)
*/
int min_rows(void)
{
int total;
tabpage_T *tp;
int n;
if (firstwin == NULL) /* not initialized yet */
return MIN_LINES;
total = 0;
for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
n = frame_minheight(tp->tp_topframe, NULL);
if (total < n)
int total = 0;
FOR_ALL_TABS(tp) {
int n = frame_minheight(tp->tp_topframe, NULL);
if (total < n) {
total = n;
}
}
total += tabline_height();
total += 1; /* count the room for the command line */
return total;
@ -5014,17 +5024,16 @@ int only_one_window(void)
*/
void check_lnums(int do_curwin)
{
win_T *wp;
tabpage_T *tp;
FOR_ALL_TAB_WINDOWS(tp, wp)
FOR_ALL_TAB_WINDOWS(tp, wp) {
if ((do_curwin || wp != curwin) && wp->w_buffer == curbuf) {
if (wp->w_cursor.lnum > curbuf->b_ml.ml_line_count)
if (wp->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
wp->w_cursor.lnum = curbuf->b_ml.ml_line_count;
if (wp->w_topline > curbuf->b_ml.ml_line_count)
}
if (wp->w_topline > curbuf->b_ml.ml_line_count) {
wp->w_topline = curbuf->b_ml.ml_line_count;
}
}
}
}