2 files changed, 157 insertions, 177 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 3fb19ad153..bfe9b2dbdd 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -10404,21 +10404,18 @@ static void f_gettabwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   getwinvar(argvars, rettv, 1);
 }
 
-/*
- * "gettagstack()" function
- */
-    static void
-f_gettagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+// "gettagstack()" function
+static void f_gettagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-    win_T	*wp = curwin;			// default is current window
+    win_T        *wp = curwin;                  // default is current window
 
     tv_dict_alloc_ret(rettv);
 
-    if (argvars[0].v_type != VAR_UNKNOWN)
-    {
-	wp = find_win_by_nr_or_id(&argvars[0]);
-	if (wp == NULL)
-	    return;
+    if (argvars[0].v_type != VAR_UNKNOWN) {
+        wp = find_win_by_nr_or_id(&argvars[0]);
+        if (wp == NULL) {
+          return;
+        }
     }
 
     get_tagstack(wp, rettv->vval.v_dict);
@@ -15216,62 +15213,58 @@ static void f_settabwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   setwinvar(argvars, rettv, 1);
 }
 
-/*
- * "settagstack()" function
- */
-    static void
-f_settagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+// "settagstack()" function
+static void f_settagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
     static char *e_invact2 = N_("E962: Invalid action: '%s'");
-    win_T	*wp;
-    dict_T	*d;
-    int		action = 'r';
+    win_T       *wp;
+    dict_T      *d;
+    int         action = 'r';
 
     rettv->vval.v_number = -1;
 
     // first argument: window number or id
     wp = find_win_by_nr_or_id(&argvars[0]);
-    if (wp == NULL)
-	return;
+    if (wp == NULL) {
+      return;
+    }
 
     // second argument: dict with items to set in the tag stack
-    if (argvars[1].v_type != VAR_DICT)
-    {
-	EMSG(_(e_dictreq));
-	return;
+    if (argvars[1].v_type != VAR_DICT) {
+        EMSG(_(e_dictreq));
+        return;
     }
     d = argvars[1].vval.v_dict;
-    if (d == NULL)
-	return;
+    if (d == NULL) {
+      return;
+    }
 
     // third argument: action - 'a' for append and 'r' for replace.
     // default is to replace the stack.
-    if (argvars[2].v_type == VAR_UNKNOWN)
-	action = 'r';
-    else if (argvars[2].v_type == VAR_STRING)
-    {
-	const char *actstr;
-	actstr = tv_get_string_chk(&argvars[2]);
-	if (actstr == NULL)
-	    return;
-	if ((*actstr == 'r' || *actstr == 'a') && actstr[1] == NUL)
-	    action = *actstr;
-	else
-	{
-	    EMSG2(_(e_invact2), actstr);
-	    return;
-	}
-    }
-    else
-    {
-	EMSG(_(e_stringreq));
-	return;
+    if (argvars[2].v_type == VAR_UNKNOWN) {
+      action = 'r';
+    } else if (argvars[2].v_type == VAR_STRING) {
+        const char *actstr;
+        actstr = tv_get_string_chk(&argvars[2]);
+        if (actstr == NULL) {
+          return;
+        }
+        if ((*actstr == 'r' || *actstr == 'a') && actstr[1] == NUL) {
+          action = *actstr;
+        } else {
+            EMSG2(_(e_invact2), actstr);
+            return;
+        }
+    } else {
+        EMSG(_(e_stringreq));
+        return;
     }
 
-    if (set_tagstack(wp, d, action) == OK)
-	rettv->vval.v_number = 0;
-    else
-	EMSG(_(e_listreq));
+    if (set_tagstack(wp, d, action) == OK) {
+      rettv->vval.v_number = 0;
+    } else {
+      EMSG(_(e_listreq));
+    }
 }
 
 /*
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index c046f71169..67ac16ea0e 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -2864,201 +2864,188 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
   return ret;
 }
 
-/*
- * Return information about 'tag' in dict 'retdict'.
- */
-    static void
-get_tag_details(taggy_T *tag, dict_T *retdict)
+// Return information about 'tag' in dict 'retdict'.
+static void get_tag_details(taggy_T *tag, dict_T *retdict)
 {
-    list_T	*pos;
-    fmark_T	*fmark;
+    list_T      *pos;
+    fmark_T     *fmark;
 
     tv_dict_add_str(retdict, S_LEN("tagname"), (const char *)tag->tagname);
     tv_dict_add_nr(retdict, S_LEN("matchnr"), tag->cur_match + 1);
     tv_dict_add_nr(retdict, S_LEN("bufnr"), tag->cur_fnum);
 
-    if ((pos = tv_list_alloc(4)) == NULL)
-	return;
+    if ((pos = tv_list_alloc(4)) == NULL) {
+      return;
+    }
     tv_dict_add_list(retdict, S_LEN("from"), pos);
 
     fmark = &tag->fmark;
     tv_list_append_number(pos,
-			(varnumber_T)(fmark->fnum != -1 ? fmark->fnum : 0));
+                          (varnumber_T)(fmark->fnum != -1 ? fmark->fnum : 0));
     tv_list_append_number(pos, (varnumber_T)fmark->mark.lnum);
     tv_list_append_number(pos, (varnumber_T)(fmark->mark.col == MAXCOL ?
-					MAXCOL : fmark->mark.col + 1));
+                                             MAXCOL : fmark->mark.col + 1));
     tv_list_append_number(pos, (varnumber_T)fmark->mark.coladd);
 }
 
-/*
- * Return the tag stack entries of the specified window 'wp' in dictionary
- * 'retdict'.
- */
-    void
-get_tagstack(win_T *wp, dict_T *retdict)
+// Return the tag stack entries of the specified window 'wp' in dictionary
+// 'retdict'.
+void get_tagstack(win_T *wp, dict_T *retdict)
 {
-    list_T	*l;
-    int		i;
-    dict_T	*d;
+    list_T      *l;
+    int         i;
+    dict_T      *d;
 
     tv_dict_add_nr(retdict, S_LEN("length"), wp->w_tagstacklen);
     tv_dict_add_nr(retdict, S_LEN("curidx"), wp->w_tagstackidx + 1);
     l = tv_list_alloc(2);
-    if (l == NULL)
-	return;
+    if (l == NULL) {
+      return;
+    }
     tv_dict_add_list(retdict, S_LEN("items"), l);
 
-    for (i = 0; i < wp->w_tagstacklen; i++)
-    {
-	if ((d = tv_dict_alloc()) == NULL)
-	    return;
-	tv_list_append_dict(l, d);
+    for (i = 0; i < wp->w_tagstacklen; i++) {
+        if ((d = tv_dict_alloc()) == NULL) {
+          return;
+        }
+        tv_list_append_dict(l, d);
 
-	get_tag_details(&wp->w_tagstack[i], d);
+        get_tag_details(&wp->w_tagstack[i], d);
     }
 }
 
-/*
- * Free all the entries in the tag stack of the specified window
- */
-    static void
-tagstack_clear(win_T *wp)
+// Free all the entries in the tag stack of the specified window
+static void tagstack_clear(win_T *wp)
 {
     int i;
 
     // Free the current tag stack
-    for (i = 0; i < wp->w_tagstacklen; ++i)
-	xfree(wp->w_tagstack[i].tagname);
+    for (i = 0; i < wp->w_tagstacklen; i++) {
+      xfree(wp->w_tagstack[i].tagname);
+    }
     wp->w_tagstacklen = 0;
     wp->w_tagstackidx = 0;
 }
 
-/*
- * Remove the oldest entry from the tag stack and shift the rest of
- * the entires to free up the top of the stack.
- */
-    static void
-tagstack_shift(win_T *wp)
+// Remove the oldest entry from the tag stack and shift the rest of
+// the entires to free up the top of the stack.
+static void tagstack_shift(win_T *wp)
 {
-    taggy_T	*tagstack = wp->w_tagstack;
-    int		i;
+    taggy_T     *tagstack = wp->w_tagstack;
+    int         i;
 
     xfree(tagstack[0].tagname);
-    for (i = 1; i < wp->w_tagstacklen; ++i)
-	tagstack[i - 1] = tagstack[i];
+    for (i = 1; i < wp->w_tagstacklen; i++) {
+      tagstack[i - 1] = tagstack[i];
+    }
     wp->w_tagstacklen--;
 }
 
-/*
- * Push a new item to the tag stack
- */
-    static void
-tagstack_push_item(
-	win_T	*wp,
-	char_u	*tagname,
-	int	cur_fnum,
-	int	cur_match,
-	pos_T	mark,
-	int	fnum)
+// Push a new item to the tag stack
+static void tagstack_push_item(
+    win_T   *wp,
+    char_u  *tagname,
+    int     cur_fnum,
+    int     cur_match,
+    pos_T   mark,
+    int     fnum)
 {
-    taggy_T	*tagstack = wp->w_tagstack;
-    int		idx = wp->w_tagstacklen;	// top of the stack
+    taggy_T     *tagstack = wp->w_tagstack;
+    int         idx = wp->w_tagstacklen;        // top of the stack
 
     // if the tagstack is full: remove the oldest entry
-    if (idx >= TAGSTACKSIZE)
-    {
-	tagstack_shift(wp);
-	idx = TAGSTACKSIZE - 1;
+    if (idx >= TAGSTACKSIZE) {
+        tagstack_shift(wp);
+        idx = TAGSTACKSIZE - 1;
     }
 
     wp->w_tagstacklen++;
     tagstack[idx].tagname = tagname;
     tagstack[idx].cur_fnum = cur_fnum;
     tagstack[idx].cur_match = cur_match;
-    if (tagstack[idx].cur_match < 0)
-	tagstack[idx].cur_match = 0;
+    if (tagstack[idx].cur_match < 0) {
+      tagstack[idx].cur_match = 0;
+    }
     tagstack[idx].fmark.mark = mark;
     tagstack[idx].fmark.fnum = fnum;
 }
 
-/*
- * Add a list of items to the tag stack in the specified window
- */
-    static void
-tagstack_push_items(win_T *wp, list_T *l)
+// Add a list of items to the tag stack in the specified window
+static void tagstack_push_items(win_T *wp, list_T *l)
 {
-    listitem_T	*li;
-    dictitem_T	*di;
-    dict_T	*itemdict;
-    char_u	*tagname;
-    pos_T	mark;
-    int		fnum;
+    listitem_T  *li;
+    dictitem_T  *di;
+    dict_T      *itemdict;
+    char_u      *tagname;
+    pos_T       mark;
+    int         fnum;
 
     // Add one entry at a time to the tag stack
-    for (li = l->lv_first; li != NULL; li = li->li_next)
-    {
-	if (li->li_tv.v_type != VAR_DICT || li->li_tv.vval.v_dict == NULL)
-	    continue;				// Skip non-dict items
-	itemdict = li->li_tv.vval.v_dict;
-
-	// parse 'from' for the cursor position before the tag jump
-	if ((di = tv_dict_find(itemdict, "from", -1)) == NULL)
-	    continue;
-	if (list2fpos(&di->di_tv, &mark, &fnum, NULL) != OK)
-	    continue;
-	if ((tagname = (char_u *)
-		tv_dict_get_string(itemdict, "tagname", TRUE)) == NULL)
-	    continue;
-
-	if (mark.col > 0)
-	    mark.col--;
-	tagstack_push_item(wp, tagname,
-		(int)tv_dict_get_number(itemdict, "bufnr"),
-		(int)tv_dict_get_number(itemdict, "matchnr") - 1,
-		mark, fnum);
+    for (li = tv_list_first(l); li != NULL; li = TV_LIST_ITEM_NEXT(l, li)) {
+        if (TV_LIST_ITEM_TV(li)->v_type != VAR_DICT
+            || TV_LIST_ITEM_TV(li)->vval.v_dict == NULL) {
+          continue;                           // Skip non-dict items
+        }
+        itemdict = TV_LIST_ITEM_TV(li)->vval.v_dict;
+
+        // parse 'from' for the cursor position before the tag jump
+        if ((di = tv_dict_find(itemdict, "from", -1)) == NULL) {
+          continue;
+        }
+        if (list2fpos(&di->di_tv, &mark, &fnum, NULL) != OK) {
+          continue;
+        }
+        if ((tagname = (char_u *)
+             tv_dict_get_string(itemdict, "tagname", true)) == NULL) {
+          continue;
+        }
+
+        if (mark.col > 0) {
+          mark.col--;
+        }
+        tagstack_push_item(wp, tagname,
+                           (int)tv_dict_get_number(itemdict, "bufnr"),
+                           (int)tv_dict_get_number(itemdict, "matchnr") - 1,
+                           mark, fnum);
     }
 }
 
-/*
- * Set the current index in the tag stack. Valid values are between 0
- * and the stack length (inclusive).
- */
-    static void
-tagstack_set_curidx(win_T *wp, int curidx)
+// Set the current index in the tag stack. Valid values are between 0
+// and the stack length (inclusive).
+static void tagstack_set_curidx(win_T *wp, int curidx)
 {
     wp->w_tagstackidx = curidx;
-    if (wp->w_tagstackidx < 0)			// sanity check
-	wp->w_tagstackidx = 0;
-    if (wp->w_tagstackidx > wp->w_tagstacklen)
-	wp->w_tagstackidx = wp->w_tagstacklen;
+    if (wp->w_tagstackidx < 0) {                // sanity check
+      wp->w_tagstackidx = 0;
+    }
+    if (wp->w_tagstackidx > wp->w_tagstacklen) {
+      wp->w_tagstackidx = wp->w_tagstacklen;
+    }
 }
 
-/*
- * Set the tag stack entries of the specified window.
- * 'action' is set to either 'a' for append or 'r' for replace.
- */
-    int
-set_tagstack(win_T *wp, dict_T *d, int action)
+// Set the tag stack entries of the specified window.
+// 'action' is set to either 'a' for append or 'r' for replace.
+int set_tagstack(win_T *wp, dict_T *d, int action)
 {
-    dictitem_T	*di;
-    list_T	*l;
+    dictitem_T  *di;
+    list_T      *l;
 
-    if ((di = tv_dict_find(d, "items", -1)) != NULL)
-    {
-	if (di->di_tv.v_type != VAR_LIST)
-	{
-	    return FAIL;
-	}
-	l = di->di_tv.vval.v_list;
+    if ((di = tv_dict_find(d, "items", -1)) != NULL) {
+        if (di->di_tv.v_type != VAR_LIST) {
+            return FAIL;
+        }
+        l = di->di_tv.vval.v_list;
 
-	if (action == 'r')
-	    tagstack_clear(wp);
+        if (action == 'r') {
+            tagstack_clear(wp);
+        }
 
-	tagstack_push_items(wp, l);
+        tagstack_push_items(wp, l);
     }
 
-    if ((di = tv_dict_find(d, "curidx", -1)) != NULL)
-	tagstack_set_curidx(wp, (int)tv_get_number(&di->di_tv) - 1);
+    if ((di = tv_dict_find(d, "curidx", -1)) != NULL) {
+        tagstack_set_curidx(wp, (int)tv_get_number(&di->di_tv) - 1);
+    }
 
     return OK;
 }