Merge pull request #1108 from war1025/dev/for_all_tabs

FOR_ALL_TAB_WINDOWS cleanup. Add FOR_ALL_TABS and FOR_ALL_WINDOWS_IN_TAB.

src/nvim/api/tabpage.c

@@ -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;
+  FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
-  win_T *wp;
-
-  FOR_ALL_TAB_WINDOWS(tp, wp) {
-    if (tp != tab) {
-      break;
-    }
     rv.size++;
   }
 
   rv.items = xmalloc(sizeof(Object) * rv.size);
   size_t i = 0;
 
-  FOR_ALL_TAB_WINDOWS(tp, wp) {
+  FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
-    if (tp != tab) {
-      break;
-    }
     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;
+    FOR_ALL_WINDOWS_IN_TAB(wp, tab) {
-    win_T *wp;
+      if (wp == tab->tp_curwin) {
-
-    FOR_ALL_TAB_WINDOWS(tp, wp) {
-      if (tp == tab && wp == tab->tp_curwin) {
         return wp->handle;
       }
     }

src/nvim/api/vim.c

@@ -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++;

src/nvim/buffer.c

@@ -514,13 +514,9 @@ void buf_freeall(buf_T *buf, int flags)
     reset_synblock(curwin);
 
   /* No folds in an empty buffer. */
-  {
+  FOR_ALL_TAB_WINDOWS(tp, win) {
-    win_T           *win;
+    if (win->w_buffer == buf) {
-    tabpage_T       *tp;
+      clearFolding(win);
-
-    FOR_ALL_TAB_WINDOWS(tp, win) {
-      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) {
+  *wp = NULL;
-    if ((*wp)->w_buffer == buf) {
+  *tp = NULL;
+  FOR_ALL_TAB_WINDOWS(tp2, wp2) {
+    if (wp2->w_buffer == buf) {
+      *tp = tp2;
+      *wp = wp2;
       return true;
     }
   }

src/nvim/diff.c

@@ -62,8 +62,7 @@ static int diff_a_works = MAYBE;
 /// @param buf
 void diff_buf_delete(buf_T *buf)
 {
-  tabpage_T *tp;
+  FOR_ALL_TABS(tp) {
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
     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_ALL_TABS(tp) {
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
     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_ALL_TABS(tp) {
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
     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_ALL_TABS(tp) {
-    for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
       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_ALL_TABS(tp) {
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
     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.

src/nvim/eval.c

@@ -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);
+    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 = get_tv_number_chk(vp, NULL);
-  int nr;
 
-  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;
+  if (nr == 0) {
-       wp != NULL; wp = wp->w_next)
+    return curwin;
-    if (--nr <= 0)
+  }
-      break;
+
-  return wp;
+  // 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;
 }
 
 /*

src/nvim/ex_cmds.c

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

src/nvim/ex_cmds2.c

@@ -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;
+  FOR_ALL_TAB_WINDOWS(tp, win) {
-  tabpage_T   *tp;
+    if (win->w_alist == curwin->w_alist) {
-
+      check_arg_idx(win);
-  FOR_ALL_TAB_WINDOWS(tp, win)
+    }
-  if (win->w_alist == curwin->w_alist)
+  }
-    check_arg_idx(win);
 }
 
 /*

src/nvim/ex_docmd.c

@@ -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 (int done = 0; done < 1000; ++done) {
-      for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
+      FOR_ALL_TABS(tp) {
         if (tp->tp_topframe != topframe) {
           tabpage_close_other(tp, eap->forceit);
           /* if we failed to close it quit */
@@ -5287,8 +5284,10 @@ 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;
+  for (int i = 0; i < GARGCOUNT; ++i) {
-  win_T       *wp;
+    if (GARGLIST[i].ae_fname != NULL) {
-  tabpage_T   *tp;
-
-  for (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) {
-        slash_adjust(WARGLIST(wp)[i].ae_fname);
+    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)
+    FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
-      wp = firstwin;
+      if (got_int) {
-    else
+        break;
-      wp = tp->tp_firstwin;
+      }
-    for (; wp != NULL && !got_int; wp = wp->w_next) {
+
       msg_putchar('\n');
       msg_putchar(wp == curwin ? '>' : ' ');
       msg_putchar(' ');

src/nvim/fileio.c

@@ -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. */
+  /* 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;
+      FOR_ALL_TAB_WINDOWS(tp, wp) {
-      win_T       *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;
         }

src/nvim/globals.h

@@ -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_ALL_TABS(tp) \
-    for ((wp) = ((tp) == curtab) \
+    FOR_ALL_WINDOWS_IN_TAB(wp, tp)
-                ? firstwin : (tp)->tp_firstwin; (wp); (wp) = (wp)->w_next)
+
+# 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.

src/nvim/main.c

@@ -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)
+      FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
-          ? firstwin : tp->tp_firstwin; wp != NULL; wp = wp->w_next) {
+        if (wp->w_buffer == NULL) {
-        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,

src/nvim/mark.c

@@ -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);
+      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)
+  FOR_ALL_TAB_WINDOWS(tab, win) {
-  {
+    if (!cmdmod.lockmarks) {
-    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)
+      for (i = 0; i < win->w_jumplistlen; ++i) {
-        if (win->w_jumplist[i].fmark.fnum == fnum)
+        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++)
+        for (i = 0; i < win->w_tagstacklen; i++) {
-          if (win->w_tagstack[i].fmark.fnum == fnum)
+          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,15 +1004,18 @@ 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 */
@@ -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,22 +1355,22 @@ 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)
+      bool is_mark_set = true;
-        is_mark_set = TRUE;
+      if (buf->b_last_cursor.lnum == 0) {
-      else {
+        is_mark_set = false;
-        is_mark_set = FALSE;
+        for (int i = 0; i < NMARKS; i++) {
-        for (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)) {
@@ -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++;
       }
     }

src/nvim/memory.c

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

src/nvim/misc1.c

@@ -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,21 +2070,21 @@ 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)

src/nvim/option.c

@@ -2210,17 +2210,16 @@ set_options_default (
     int opt_flags                  /* OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL */
 )
 {
-  int i;
+  for (int i = 0; !istermoption(&options[i]); i++) {
-  win_T       *wp;
+    if (!(options[i].flags & P_NODEFAULT)) {
-  tabpage_T   *tp;
-
-  for (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);
+    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);
     }
+
   }
 
   /*

src/nvim/quickfix.c

@@ -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;
+      FOR_ALL_TAB_WINDOWS(tp, wp) {
-      win_T       *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;
+  FOR_ALL_TAB_WINDOWS(tp, win) {
-  win_T       *win;
+    if (is_qf_win(win, qi)) {
-
+      return win->w_buffer;
-  FOR_ALL_TAB_WINDOWS(tp, win)
+    }
-  if (is_qf_win(win, qi))
+  }
-    return win->w_buffer;
 
   return NULL;
 }

src/nvim/screen.c

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

src/nvim/window.c

@@ -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)
+    if (tp != curtab) {
-      for (wp = tp->tp_firstwin; wp != NULL; wp = wp->w_next)
+      FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
         if (wp->w_buffer == buf
             && !(wp->w_closing || wp->w_buffer->b_closing)
             ) {
@@ -1707,6 +1706,8 @@ close_windows (
           nexttp = first_tabpage;
           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)
+  {
-    ;
+    bool found_window = false;
-  if (wp == NULL)
+    FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
-    return;
+      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_ALL_TABS(tp) {
-
+    if (tp == tpc) {
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
+      return true;
-    if (tp == tpc)
+    }
-      return TRUE;
+  }
-  return FALSE;
+  return false;
 }
 
 /*
@@ -3285,14 +3293,11 @@ void win_goto(win_T *wp)
  */
 tabpage_T *win_find_tabpage(win_T *win)
 {
-  win_T       *wp;
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
-  tabpage_T   *tp;
+    if (wp == win) {
-
+      return 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)
-        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. */
+  // First try the current tab page.
-  wp = buf_jump_open_win(buf);
+  {
-  if (wp != NULL)
+    win_T *wp = buf_jump_open_win(buf);
-    return wp;
+    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)
+      FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
-        if (wp->w_buffer == buf)
+        if (wp->w_buffer == buf) {
-          break;
+          goto_tabpage_win(tp, wp);
-      if (wp != NULL) {
+
-        goto_tabpage_win(tp, wp);
+          // If we the current window didn't switch,
-        if (curwin != wp)
+          // something went wrong.
-          wp = NULL;            /* something went wrong */
+          if (curwin != wp) {
-        break;
+            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,18 +4976,15 @@ 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;
+  int total = 0;
-  for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
+  FOR_ALL_TABS(tp) {
-    n = frame_minheight(tp->tp_topframe, NULL);
+    int n = frame_minheight(tp->tp_topframe, NULL);
-    if (total < n)
+    if (total < n) {
       total = n;
+    }
   }
   total += tabline_height();
   total += 1;           /* count the room for the command line */
@@ -5014,16 +5024,15 @@ int only_one_window(void)
  */
 void check_lnums(int do_curwin)
 {
-  win_T       *wp;
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
-
+    if ((do_curwin || wp != curwin) && wp->w_buffer == curbuf) {
-  tabpage_T   *tp;
+      if (wp->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
-
+        wp->w_cursor.lnum = curbuf->b_ml.ml_line_count;
-  FOR_ALL_TAB_WINDOWS(tp, wp)
+      }
-  if ((do_curwin || wp != curwin) && wp->w_buffer == curbuf) {
+      if (wp->w_topline > curbuf->b_ml.ml_line_count) {
-    if (wp->w_cursor.lnum > curbuf->b_ml.ml_line_count)
+        wp->w_topline = 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)
+    }
-      wp->w_topline = curbuf->b_ml.ml_line_count;
   }
 }