diff --git a/src/sign.c b/src/sign.c
index 6d54584..e997a77 100644
--- a/src/sign.c
+++ b/src/sign.c
@@ -45,17 +45,17 @@
 
 static char *cmds[] = { "define",
 # define SIGNCMD_DEFINE 0
-			"undefine",
+                        "undefine",
 # define SIGNCMD_UNDEFINE 1
-			"list",
+                        "list",
 # define SIGNCMD_LIST 2
-			"place",
+                        "place",
 # define SIGNCMD_PLACE 3
-			"unplace",
+                        "unplace",
 # define SIGNCMD_UNPLACE 4
-			"jump",
+                        "jump",
 # define SIGNCMD_JUMP 5
-			NULL
+                        NULL
 # define SIGNCMD_LAST 6
 };
 
@@ -87,21 +87,21 @@
 
     if (HASHITEM_EMPTY(hi))
     {
-	// new group
-	group = alloc(offsetof(signgroup_T, sg_name) + STRLEN(groupname) + 1);
-	if (group == NULL)
-	    return NULL;
+        // new group
+        group = alloc(offsetof(signgroup_T, sg_name) + STRLEN(groupname) + 1);
+        if (group == NULL)
+            return NULL;
 
-	STRCPY(group->sg_name, groupname);
-	group->sg_refcount = 1;
-	group->sg_next_sign_id = 1;
-	hash_add_item(&sg_table, hi, group->sg_name, hash);
+        STRCPY(group->sg_name, groupname);
+        group->sg_refcount = 1;
+        group->sg_next_sign_id = 1;
+        hash_add_item(&sg_table, hi, group->sg_name, hash);
     }
     else
     {
-	// existing group
-	group = HI2SG(hi);
-	group->sg_refcount++;
+        // existing group
+        group = HI2SG(hi);
+        group->sg_refcount++;
     }
 
     return group;
@@ -116,15 +116,15 @@
 {
     hashitem_T *hi = hash_find(&sg_table, groupname);
     if (HASHITEM_EMPTY(hi))
-	return;
+        return;
 
     signgroup_T *group = HI2SG(hi);
     group->sg_refcount--;
     if (group->sg_refcount == 0)
     {
-	// All the signs in this group are removed
-	hash_remove(&sg_table, hi, "sign remove");
-	vim_free(group);
+        // All the signs in this group are removed
+        hash_remove(&sg_table, hi, "sign remove");
+        vim_free(group);
     }
 }
 
@@ -137,9 +137,9 @@
 sign_in_group(sign_entry_T *sign, char_u *group)
 {
     return ((group != NULL && STRCMP(group, "*") == 0) ||
-	    (group == NULL && sign->se_group == NULL) ||
-	    (group != NULL && sign->se_group != NULL &&
-	     STRCMP(group, sign->se_group->sg_name) == 0));
+            (group == NULL && sign->se_group == NULL) ||
+            (group != NULL && sign->se_group != NULL &&
+             STRCMP(group, sign->se_group->sg_name) == 0));
 }
 
 /*
@@ -150,7 +150,7 @@
 sign_group_for_window(sign_entry_T *sign, win_T *wp)
 {
     int for_popup = sign->se_group != NULL &&
-		    STRNCMP("PopUp", sign->se_group->sg_name, 5) == 0;
+                    STRNCMP("PopUp", sign->se_group->sg_name, 5) == 0;
 
     return WIN_IS_POPUP(wp) ? for_popup : !for_popup;
 }
@@ -167,31 +167,31 @@
 
     if (groupname != NULL)
     {
-	hashitem_T *hi = hash_find(&sg_table, groupname);
-	if (HASHITEM_EMPTY(hi))
-	    return id;
-	group = HI2SG(hi);
+        hashitem_T *hi = hash_find(&sg_table, groupname);
+        if (HASHITEM_EMPTY(hi))
+            return id;
+        group = HI2SG(hi);
     }
 
     // Search for the next usable sign identifier
     int found = FALSE;
     while (!found)
     {
-	if (group == NULL)
-	    id = next_sign_id++; // global group
-	else
-	    id = group->sg_next_sign_id++;
+        if (group == NULL)
+            id = next_sign_id++; // global group
+        else
+            id = group->sg_next_sign_id++;
 
-	// Check whether this sign is already placed in the buffer
-	found = TRUE;
-	FOR_ALL_SIGNS_IN_BUF(buf, sign)
-	{
-	    if (id == sign->se_id && sign_in_group(sign, groupname))
-	    {
-		found = FALSE; // sign identifier is in use
-		break;
-	    }
-	}
+        // Check whether this sign is already placed in the buffer
+        found = TRUE;
+        FOR_ALL_SIGNS_IN_BUF(buf, sign)
+        {
+            if (id == sign->se_id && sign_in_group(sign, groupname))
+            {
+                found = FALSE; // sign identifier is in use
+                break;
+            }
+        }
     }
 
     return id;
@@ -203,18 +203,18 @@
  */
 static void
 insert_sign(buf_T *buf, // buffer to store sign in
-	    sign_entry_T *prev, // previous sign entry
-	    sign_entry_T *next, // next sign entry
-	    int id, // sign ID
-	    char_u *group, // sign group; NULL for global group
-	    int prio, // sign priority
-	    linenr_T lnum, // line number which gets the mark
-	    int typenr) // typenr of sign we are adding
+            sign_entry_T *prev, // previous sign entry
+            sign_entry_T *next, // next sign entry
+            int id, // sign ID
+            char_u *group, // sign group; NULL for global group
+            int prio, // sign priority
+            linenr_T lnum, // line number which gets the mark
+            int typenr) // typenr of sign we are adding
 {
     sign_entry_T *newsign =
-	lalloc_id(sizeof(sign_entry_T), FALSE, aid_insert_sign);
+        lalloc_id(sizeof(sign_entry_T), FALSE, aid_insert_sign);
     if (newsign == NULL)
-	return;
+        return;
 
     newsign->se_id = id;
     newsign->se_lnum = lnum;
@@ -222,44 +222,44 @@
 
     if (group != NULL)
     {
-	newsign->se_group = sign_group_ref(group);
-	if (newsign->se_group == NULL)
-	{
-	    vim_free(newsign);
-	    return;
-	}
+        newsign->se_group = sign_group_ref(group);
+        if (newsign->se_group == NULL)
+        {
+            vim_free(newsign);
+            return;
+        }
     }
     else
     {
-	newsign->se_group = NULL;
+        newsign->se_group = NULL;
     }
 
     newsign->se_priority = prio;
     newsign->se_next = next;
     newsign->se_prev = prev;
     if (next != NULL)
-	next->se_prev = newsign;
+        next->se_prev = newsign;
 
     if (prev == NULL)
     {
-	// When adding first sign need to redraw the windows to create the
-	// column for signs.
-	if (buf->b_signlist == NULL)
-	{
-	    redraw_buf_later(buf, UPD_NOT_VALID);
-	    changed_line_abv_curs();
-	}
+        // When adding first sign need to redraw the windows to create the
+        // column for signs.
+        if (buf->b_signlist == NULL)
+        {
+            redraw_buf_later(buf, UPD_NOT_VALID);
+            changed_line_abv_curs();
+        }
 
-	// first sign in signlist
-	buf->b_signlist = newsign;
+        // first sign in signlist
+        buf->b_signlist = newsign;
 # ifdef FEAT_NETBEANS_INTG
-	if (netbeans_active())
-	    buf->b_has_sign_column = TRUE;
+        if (netbeans_active())
+            buf->b_has_sign_column = TRUE;
 # endif
     }
     else
     {
-	prev->se_next = newsign;
+        prev->se_next = newsign;
     }
 }
 
@@ -268,17 +268,17 @@
  */
 static void
 insert_sign_by_lnum_prio(buf_T *buf, // buffer to store sign in
-			 sign_entry_T *prev, // previous sign entry
-			 int id, // sign ID
-			 char_u *group, // sign group; NULL for global group
-			 int prio, // sign priority
-			 linenr_T lnum, // line number which gets the mark
-			 int typenr) // typenr of sign we are adding
+                         sign_entry_T *prev, // previous sign entry
+                         int id, // sign ID
+                         char_u *group, // sign group; NULL for global group
+                         int prio, // sign priority
+                         linenr_T lnum, // line number which gets the mark
+                         int typenr) // typenr of sign we are adding
 {
     // keep signs sorted by lnum and by priority: insert new sign at
     // the proper position in the list for this lnum.
     while (prev != NULL && prev->se_lnum == lnum && prev->se_priority <= prio)
-	prev = prev->se_prev;
+        prev = prev->se_prev;
 
     sign_entry_T *sign = (prev == NULL) ? buf->b_signlist : prev->se_next;
 
@@ -293,8 +293,8 @@
 {
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
-	if (sp->sn_typenr == typenr)
-	    return sp;
+        if (sp->sn_typenr == typenr)
+            return sp;
     return NULL;
 }
 
@@ -306,8 +306,8 @@
 {
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
-	if (sp->sn_typenr == typenr)
-	    return sp->sn_name;
+        if (sp->sn_typenr == typenr)
+            return sp->sn_name;
     return (char_u *)_("[Deleted]");
 }
 
@@ -319,12 +319,12 @@
 {
     dict_T *d = dict_alloc_id(aid_sign_getinfo);
     if (d == NULL)
-	return NULL;
+        return NULL;
 
     dict_add_number(d, "id", sign->se_id);
     dict_add_string(d, "group",
-		    (sign->se_group == NULL) ? (char_u *)""
-					     : sign->se_group->sg_name);
+                    (sign->se_group == NULL) ? (char_u *)""
+                                             : sign->se_group->sg_name);
     dict_add_number(d, "lnum", sign->se_lnum);
     dict_add_string(d, "name", sign_typenr2name(sign->se_typenr));
     dict_add_number(d, "priority", sign->se_priority);
@@ -343,10 +343,10 @@
     // If there is only one sign in the buffer or only one sign on the line or
     // the sign is already sorted by priority, then return.
     if ((sign->se_prev == NULL || sign->se_prev->se_lnum != sign->se_lnum ||
-	 sign->se_prev->se_priority > sign->se_priority) &&
-	(sign->se_next == NULL || sign->se_next->se_lnum != sign->se_lnum ||
-	 sign->se_next->se_priority < sign->se_priority))
-	return;
+         sign->se_prev->se_priority > sign->se_priority) &&
+        (sign->se_next == NULL || sign->se_next->se_lnum != sign->se_lnum ||
+         sign->se_next->se_priority < sign->se_priority))
+        return;
 
     // One or more signs on the same line as 'sign'
     // Find a sign after which 'sign' should be inserted
@@ -354,28 +354,28 @@
     // First search backward for a sign with higher priority on the same line
     sign_entry_T *p = sign;
     while (p->se_prev != NULL && p->se_prev->se_lnum == sign->se_lnum &&
-	   p->se_prev->se_priority <= sign->se_priority)
-	p = p->se_prev;
+           p->se_prev->se_priority <= sign->se_priority)
+        p = p->se_prev;
 
     if (p == sign)
     {
-	// Sign not found. Search forward for a sign with priority just before
-	// 'sign'.
-	p = sign->se_next;
-	while (p->se_next != NULL && p->se_next->se_lnum == sign->se_lnum &&
-	       p->se_next->se_priority > sign->se_priority)
-	    p = p->se_next;
+        // Sign not found. Search forward for a sign with priority just before
+        // 'sign'.
+        p = sign->se_next;
+        while (p->se_next != NULL && p->se_next->se_lnum == sign->se_lnum &&
+               p->se_next->se_priority > sign->se_priority)
+            p = p->se_next;
     }
 
     // Remove 'sign' from the list
     if (buf->b_signlist == sign)
-	buf->b_signlist = sign->se_next;
+        buf->b_signlist = sign->se_next;
 
     if (sign->se_prev != NULL)
-	sign->se_prev->se_next = sign->se_next;
+        sign->se_prev->se_next = sign->se_next;
 
     if (sign->se_next != NULL)
-	sign->se_next->se_prev = sign->se_prev;
+        sign->se_next->se_prev = sign->se_prev;
 
     sign->se_prev = NULL;
     sign->se_next = NULL;
@@ -383,24 +383,24 @@
     // Re-insert 'sign' at the right place
     if (p->se_priority <= sign->se_priority)
     {
-	// 'sign' has a higher priority and should be inserted before 'p'
-	sign->se_prev = p->se_prev;
-	sign->se_next = p;
-	p->se_prev = sign;
-	if (sign->se_prev != NULL)
-	    sign->se_prev->se_next = sign;
+        // 'sign' has a higher priority and should be inserted before 'p'
+        sign->se_prev = p->se_prev;
+        sign->se_next = p;
+        p->se_prev = sign;
+        if (sign->se_prev != NULL)
+            sign->se_prev->se_next = sign;
 
-	if (buf->b_signlist == p)
-	    buf->b_signlist = sign;
+        if (buf->b_signlist == p)
+            buf->b_signlist = sign;
     }
     else
     {
-	// 'sign' has a lower priority and should be inserted after 'p'
-	sign->se_prev = p;
-	sign->se_next = p->se_next;
-	p->se_next = sign;
-	if (sign->se_next != NULL)
-	    sign->se_next->se_prev = sign;
+        // 'sign' has a lower priority and should be inserted after 'p'
+        sign->se_prev = p;
+        sign->se_next = p->se_next;
+        p->se_next = sign;
+        if (sign->se_next != NULL)
+            sign->se_next->se_prev = sign;
     }
 }
 
@@ -409,32 +409,32 @@
  */
 static void
 buf_addsign(buf_T *buf, // buffer to store sign in
-	    int id, // sign ID
-	    char_u *groupname, // sign group
-	    int prio, // sign priority
-	    linenr_T lnum, // line number which gets the mark
-	    int typenr) // typenr of sign we are adding
+            int id, // sign ID
+            char_u *groupname, // sign group
+            int prio, // sign priority
+            linenr_T lnum, // line number which gets the mark
+            int typenr) // typenr of sign we are adding
 {
     sign_entry_T *sign = NULL; // a sign in the signlist
     sign_entry_T *prev = NULL; // the previous sign
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	if (lnum == sign->se_lnum && id == sign->se_id &&
-	    sign_in_group(sign, groupname))
-	{
-	    // Update an existing sign
-	    sign->se_typenr = typenr;
-	    sign->se_priority = prio;
-	    sign_sort_by_prio_on_line(buf, sign);
-	    return;
-	}
-	else if (lnum < sign->se_lnum)
-	{
-	    insert_sign_by_lnum_prio(buf, prev, id, groupname, prio, lnum,
-				     typenr);
-	    return;
-	}
-	prev = sign;
+        if (lnum == sign->se_lnum && id == sign->se_id &&
+            sign_in_group(sign, groupname))
+        {
+            // Update an existing sign
+            sign->se_typenr = typenr;
+            sign->se_priority = prio;
+            sign_sort_by_prio_on_line(buf, sign);
+            return;
+        }
+        else if (lnum < sign->se_lnum)
+        {
+            insert_sign_by_lnum_prio(buf, prev, id, groupname, prio, lnum,
+                                     typenr);
+            return;
+        }
+        prev = sign;
     }
 
     insert_sign_by_lnum_prio(buf, prev, id, groupname, prio, lnum, typenr);
@@ -446,21 +446,21 @@
  */
 static linenr_T
 buf_change_sign_type(buf_T *buf, // buffer to store sign in
-		     int markId, // sign ID
-		     char_u *group, // sign group
-		     int typenr, // typenr of sign we are adding
-		     int prio) // sign priority
+                     int markId, // sign ID
+                     char_u *group, // sign group
+                     int typenr, // typenr of sign we are adding
+                     int prio) // sign priority
 {
     sign_entry_T *sign = NULL; // a sign in the signlist
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	if (sign->se_id == markId && sign_in_group(sign, group))
-	{
-	    sign->se_typenr = typenr;
-	    sign->se_priority = prio;
-	    sign_sort_by_prio_on_line(buf, sign);
-	    return sign->se_lnum;
-	}
+        if (sign->se_id == markId && sign_in_group(sign, group))
+        {
+            sign->se_typenr = typenr;
+            sign->se_priority = prio;
+            sign_sort_by_prio_on_line(buf, sign);
+            return sign->se_lnum;
+        }
     }
 
     return (linenr_T)0;
@@ -480,73 +480,73 @@
     sign_entry_T *sign = NULL;
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	// Signs are sorted by line number in the buffer. No need to check
-	// for signs after the specified line number 'lnum'.
-	if (sign->se_lnum > lnum)
-	    break;
+        // Signs are sorted by line number in the buffer. No need to check
+        // for signs after the specified line number 'lnum'.
+        if (sign->se_lnum > lnum)
+            break;
 
-	if (sign->se_lnum == lnum
+        if (sign->se_lnum == lnum
 # ifdef FEAT_PROP_POPUP
-	    && sign_group_for_window(sign, wp)
+            && sign_group_for_window(sign, wp)
 # endif
-	)
-	{
-	    sattr->sat_typenr = sign->se_typenr;
-	    sign_T *sp = find_sign_by_typenr(sign->se_typenr);
-	    if (sp == NULL)
-		return FALSE;
+        )
+        {
+            sattr->sat_typenr = sign->se_typenr;
+            sign_T *sp = find_sign_by_typenr(sign->se_typenr);
+            if (sp == NULL)
+                return FALSE;
 
 # ifdef FEAT_SIGN_ICONS
-	    sattr->sat_icon = sp->sn_image;
+            sattr->sat_icon = sp->sn_image;
 # endif
-	    sattr->sat_text = sp->sn_text;
+            sattr->sat_text = sp->sn_text;
 
-	    if (sattr->sat_text != NULL && sp->sn_text_hl > 0)
-		sattr->sat_texthl = syn_id2attr(sp->sn_text_hl);
+            if (sattr->sat_text != NULL && sp->sn_text_hl > 0)
+                sattr->sat_texthl = syn_id2attr(sp->sn_text_hl);
 
-	    if (sp->sn_line_hl > 0)
-		sattr->sat_linehl = syn_id2attr(sp->sn_line_hl);
+            if (sp->sn_line_hl > 0)
+                sattr->sat_linehl = syn_id2attr(sp->sn_line_hl);
 
-	    if (sp->sn_cul_hl > 0)
-		sattr->sat_culhl = syn_id2attr(sp->sn_cul_hl);
+            if (sp->sn_cul_hl > 0)
+                sattr->sat_culhl = syn_id2attr(sp->sn_cul_hl);
 
-	    if (sp->sn_num_hl > 0)
-		sattr->sat_numhl = syn_id2attr(sp->sn_num_hl);
+            if (sp->sn_num_hl > 0)
+                sattr->sat_numhl = syn_id2attr(sp->sn_num_hl);
 
-	    sattr->sat_priority = sign->se_priority;
+            sattr->sat_priority = sign->se_priority;
 
-	    // If there is another sign next with the same priority, may
-	    // combine the text and the line highlighting.
-	    if (sign->se_next != NULL &&
-		sign->se_next->se_priority == sign->se_priority &&
-		sign->se_next->se_lnum == sign->se_lnum)
-	    {
-		sign_T *next_sp = find_sign_by_typenr(sign->se_next->se_typenr);
-		if (next_sp == NULL)
-		    return FALSE;
+            // If there is another sign next with the same priority, may
+            // combine the text and the line highlighting.
+            if (sign->se_next != NULL &&
+                sign->se_next->se_priority == sign->se_priority &&
+                sign->se_next->se_lnum == sign->se_lnum)
+            {
+                sign_T *next_sp = find_sign_by_typenr(sign->se_next->se_typenr);
+                if (next_sp == NULL)
+                    return FALSE;
 
-		if (sattr->sat_icon == NULL && sattr->sat_text == NULL)
-		{
+                if (sattr->sat_icon == NULL && sattr->sat_text == NULL)
+                {
 # ifdef FEAT_SIGN_ICONS
-		    sattr->sat_icon = next_sp->sn_image;
+                    sattr->sat_icon = next_sp->sn_image;
 # endif
-		    sattr->sat_text = next_sp->sn_text;
-		}
+                    sattr->sat_text = next_sp->sn_text;
+                }
 
-		if (sp->sn_text_hl <= 0 && next_sp->sn_text_hl > 0)
-		    sattr->sat_texthl = syn_id2attr(next_sp->sn_text_hl);
+                if (sp->sn_text_hl <= 0 && next_sp->sn_text_hl > 0)
+                    sattr->sat_texthl = syn_id2attr(next_sp->sn_text_hl);
 
-		if (sp->sn_line_hl <= 0 && next_sp->sn_line_hl > 0)
-		    sattr->sat_linehl = syn_id2attr(next_sp->sn_line_hl);
+                if (sp->sn_line_hl <= 0 && next_sp->sn_line_hl > 0)
+                    sattr->sat_linehl = syn_id2attr(next_sp->sn_line_hl);
 
-		if (sp->sn_cul_hl <= 0 && next_sp->sn_cul_hl > 0)
-		    sattr->sat_culhl = syn_id2attr(next_sp->sn_cul_hl);
+                if (sp->sn_cul_hl <= 0 && next_sp->sn_cul_hl > 0)
+                    sattr->sat_culhl = syn_id2attr(next_sp->sn_cul_hl);
 
-		if (sp->sn_num_hl <= 0 && next_sp->sn_num_hl > 0)
-		    sattr->sat_numhl = syn_id2attr(next_sp->sn_num_hl);
-	    }
-	    return TRUE;
-	}
+                if (sp->sn_num_hl <= 0 && next_sp->sn_num_hl > 0)
+                    sattr->sat_numhl = syn_id2attr(next_sp->sn_num_hl);
+            }
+            return TRUE;
+        }
     }
     return FALSE;
 }
@@ -563,9 +563,9 @@
  */
 linenr_T
 buf_delsign(buf_T *buf, // buffer sign is stored in
-	    linenr_T atlnum, // sign at this line, 0 - at any line
-	    int id, // sign id
-	    char_u *group) // sign group
+            linenr_T atlnum, // sign at this line, 0 - at any line
+            int id, // sign id
+            char_u *group) // sign group
 {
     // pointer to pointer to current sign
     sign_entry_T **lastp = &buf->b_signlist;
@@ -574,44 +574,44 @@
 
     for (sign_entry_T *sign = buf->b_signlist; sign != NULL; sign = next)
     {
-	next = sign->se_next;
+        next = sign->se_next;
 
-	if ((id == 0 || sign->se_id == id) &&
-	    (atlnum == 0 || sign->se_lnum == atlnum) &&
-	    sign_in_group(sign, group))
-	{
-	    *lastp = next;
-	    if (next != NULL)
-		next->se_prev = sign->se_prev;
+        if ((id == 0 || sign->se_id == id) &&
+            (atlnum == 0 || sign->se_lnum == atlnum) &&
+            sign_in_group(sign, group))
+        {
+            *lastp = next;
+            if (next != NULL)
+                next->se_prev = sign->se_prev;
 
-	    lnum = sign->se_lnum;
+            lnum = sign->se_lnum;
 
-	    if (sign->se_group != NULL)
-		sign_group_unref(sign->se_group->sg_name);
+            if (sign->se_group != NULL)
+                sign_group_unref(sign->se_group->sg_name);
 
-	    vim_free(sign);
-	    redraw_buf_line_later(buf, lnum);
+            vim_free(sign);
+            redraw_buf_line_later(buf, lnum);
 
-	    // Check whether only one sign needs to be deleted
-	    // If deleting a sign with a specific identifier in a particular
-	    // group or deleting any sign at a particular line number, delete
-	    // only one sign.
-	    if (group == NULL || (*group != '*' && id != 0) ||
-		(*group == '*' && atlnum != 0))
-		break;
-	}
-	else
-	{
-	    lastp = &sign->se_next;
-	}
+            // Check whether only one sign needs to be deleted
+            // If deleting a sign with a specific identifier in a particular
+            // group or deleting any sign at a particular line number, delete
+            // only one sign.
+            if (group == NULL || (*group != '*' && id != 0) ||
+                (*group == '*' && atlnum != 0))
+                break;
+        }
+        else
+        {
+            lastp = &sign->se_next;
+        }
     }
 
     // When deleting the last sign the cursor position may change, because the
     // sign columns no longer shows.  And the 'signcolumn' may be hidden.
     if (buf->b_signlist == NULL)
     {
-	redraw_buf_later(buf, UPD_NOT_VALID);
-	changed_line_abv_curs();
+        redraw_buf_later(buf, UPD_NOT_VALID);
+        changed_line_abv_curs();
     }
 
     return lnum;
@@ -624,13 +624,13 @@
  */
 int
 buf_findsign(buf_T *buf, // buffer to store sign in
-	     int id, // sign ID
-	     char_u *group) // sign group
+             int id, // sign ID
+             char_u *group) // sign group
 {
     sign_entry_T *sign = NULL; // a sign in the signlist
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
-	if (sign->se_id == id && sign_in_group(sign, group))
-	    return sign->se_lnum;
+        if (sign->se_id == id && sign_in_group(sign, group))
+            return sign->se_lnum;
 
     return 0;
 }
@@ -641,19 +641,19 @@
  */
 static sign_entry_T *
 buf_getsign_at_line(buf_T *buf, // buffer whose sign we are searching for
-		    linenr_T lnum, // line number of sign
-		    char_u *groupname) // sign group name
+                    linenr_T lnum, // line number of sign
+                    char_u *groupname) // sign group name
 {
     sign_entry_T *sign = NULL; // a sign in the signlist
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	// Signs are sorted by line number in the buffer. No need to check
-	// for signs after the specified line number 'lnum'.
-	if (sign->se_lnum > lnum)
-	    break;
+        // Signs are sorted by line number in the buffer. No need to check
+        // for signs after the specified line number 'lnum'.
+        if (sign->se_lnum > lnum)
+            break;
 
-	if (sign->se_lnum == lnum && sign_in_group(sign, groupname))
-	    return sign;
+        if (sign->se_lnum == lnum && sign_in_group(sign, groupname))
+            return sign;
     }
 
     return NULL;
@@ -664,13 +664,13 @@
  */
 int
 buf_findsign_id(buf_T *buf, // buffer whose sign we are searching for
-		linenr_T lnum, // line number of sign
-		char_u *groupname) // sign group name
+                linenr_T lnum, // line number of sign
+                char_u *groupname) // sign group name
 {
     // a sign in the signlist
     sign_entry_T *sign = buf_getsign_at_line(buf, lnum, groupname);
     if (sign != NULL)
-	return sign->se_id;
+        return sign->se_id;
 
     return 0;
 }
@@ -681,19 +681,19 @@
  */
 int
 buf_findsigntype_id(buf_T *buf, // buffer whose sign we are searching for
-		    linenr_T lnum, // line number of sign
-		    int typenr) // sign type number
+                    linenr_T lnum, // line number of sign
+                    int typenr) // sign type number
 {
     sign_entry_T *sign = NULL; // a sign in the signlist
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	// Signs are sorted by line number in the buffer. No need to check
-	// for signs after the specified line number 'lnum'.
-	if (sign->se_lnum > lnum)
-	    break;
+        // Signs are sorted by line number in the buffer. No need to check
+        // for signs after the specified line number 'lnum'.
+        if (sign->se_lnum > lnum)
+            break;
 
-	if (sign->se_lnum == lnum && sign->se_typenr == typenr)
-	    return sign->se_id;
+        if (sign->se_lnum == lnum && sign->se_typenr == typenr)
+            return sign->se_id;
     }
 
     return 0;
@@ -710,13 +710,13 @@
     sign_entry_T *sign = NULL; // a sign in the signlist
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	// Signs are sorted by line number in the buffer. No need to check
-	// for signs after the specified line number 'lnum'.
-	if (sign->se_lnum > lnum)
-	    break;
+        // Signs are sorted by line number in the buffer. No need to check
+        // for signs after the specified line number 'lnum'.
+        if (sign->se_lnum > lnum)
+            break;
 
-	if (sign->se_lnum == lnum && sign_get_image(sign->se_typenr) != NULL)
-	    count++;
+        if (sign->se_lnum == lnum && sign_get_image(sign->se_typenr) != NULL)
+            count++;
     }
 
     return count;
@@ -735,8 +735,8 @@
     // sign column. Not when curwin is NULL (this means we're exiting).
     if (buf->b_signlist != NULL && curwin != NULL)
     {
-	redraw_buf_later(buf, UPD_NOT_VALID);
-	changed_line_abv_curs();
+        redraw_buf_later(buf, UPD_NOT_VALID);
+        changed_line_abv_curs();
     }
 
     // pointer to pointer to current sign
@@ -745,23 +745,23 @@
 
     for (sign_entry_T *sign = buf->b_signlist; sign != NULL; sign = next)
     {
-	next = sign->se_next;
-	if (sign_in_group(sign, group))
-	{
-	    *lastp = next;
+        next = sign->se_next;
+        if (sign_in_group(sign, group))
+        {
+            *lastp = next;
 
-	    if (next != NULL)
-		next->se_prev = sign->se_prev;
+            if (next != NULL)
+                next->se_prev = sign->se_prev;
 
-	    if (sign->se_group != NULL)
-		sign_group_unref(sign->se_group->sg_name);
+            if (sign->se_group != NULL)
+                sign_group_unref(sign->se_group->sg_name);
 
-	    vim_free(sign);
-	}
-	else
-	{
-	    lastp = &sign->se_next;
-	}
+            vim_free(sign);
+        }
+        else
+        {
+            lastp = &sign->se_next;
+        }
     }
 }
 
@@ -780,41 +780,41 @@
     buf_T *buf = (rbuf == NULL) ? firstbuf : rbuf;
     while (buf != NULL && !got_int)
     {
-	if (buf->b_signlist != NULL)
-	{
-	    vim_snprintf(lbuf, MSG_BUF_LEN, _("Signs for %s:"), buf->b_fname);
-	    msg_puts_attr(lbuf, HL_ATTR(HLF_D));
-	    msg_putchar('\n');
-	}
+        if (buf->b_signlist != NULL)
+        {
+            vim_snprintf(lbuf, MSG_BUF_LEN, _("Signs for %s:"), buf->b_fname);
+            msg_puts_attr(lbuf, HL_ATTR(HLF_D));
+            msg_putchar('\n');
+        }
 
-	sign_entry_T *sign = NULL;
-	FOR_ALL_SIGNS_IN_BUF(buf, sign)
-	{
-	    if (got_int)
-		break;
+        sign_entry_T *sign = NULL;
+        FOR_ALL_SIGNS_IN_BUF(buf, sign)
+        {
+            if (got_int)
+                break;
 
-	    if (!sign_in_group(sign, sign_group))
-		continue;
+            if (!sign_in_group(sign, sign_group))
+                continue;
 
-	    if (sign->se_group != NULL)
-		vim_snprintf(group, MSG_BUF_LEN, _("  group=%s"),
-			     sign->se_group->sg_name);
-	    else
-		group[0] = '\0';
+            if (sign->se_group != NULL)
+                vim_snprintf(group, MSG_BUF_LEN, _("  group=%s"),
+                             sign->se_group->sg_name);
+            else
+                group[0] = '\0';
 
-	    vim_snprintf(lbuf, MSG_BUF_LEN,
-			 _("    line=%ld  id=%d%s  name=%s  priority=%d"),
-			 (long)sign->se_lnum, sign->se_id, group,
-			 sign_typenr2name(sign->se_typenr), sign->se_priority);
+            vim_snprintf(lbuf, MSG_BUF_LEN,
+                         _("    line=%ld  id=%d%s  name=%s  priority=%d"),
+                         (long)sign->se_lnum, sign->se_id, group,
+                         sign_typenr2name(sign->se_typenr), sign->se_priority);
 
-	    msg_puts(lbuf);
-	    msg_putchar('\n');
-	}
+            msg_puts(lbuf);
+            msg_putchar('\n');
+        }
 
-	if (rbuf != NULL)
-	    break;
+        if (rbuf != NULL)
+            break;
 
-	buf = buf->b_next;
+        buf = buf->b_next;
     }
 }
 
@@ -827,28 +827,28 @@
     sign_entry_T *sign = NULL; // a sign in a b_signlist
     FOR_ALL_SIGNS_IN_BUF(curbuf, sign)
     {
-	// Ignore changes to lines after the sign
-	if (sign->se_lnum < line1)
-	    continue;
+        // Ignore changes to lines after the sign
+        if (sign->se_lnum < line1)
+            continue;
 
-	linenr_T new_lnum = sign->se_lnum;
+        linenr_T new_lnum = sign->se_lnum;
 
-	if (sign->se_lnum <= line2)
-	{
-	    if (amount != MAXLNUM)
-		new_lnum += amount;
-	}
-	else if (sign->se_lnum > line2)
-	{
-	    // Lines inserted or deleted before the sign
-	    new_lnum += amount_after;
-	}
+        if (sign->se_lnum <= line2)
+        {
+            if (amount != MAXLNUM)
+                new_lnum += amount;
+        }
+        else if (sign->se_lnum > line2)
+        {
+            // Lines inserted or deleted before the sign
+            new_lnum += amount_after;
+        }
 
-	// If the new sign line number is past the last line in the buffer,
-	// then don't adjust the line number. Otherwise, it will always be past
-	// the last line and will not be visible.
-	if (new_lnum <= curbuf->b_ml.ml_line_count)
-	    sign->se_lnum = new_lnum;
+        // If the new sign line number is past the last line in the buffer,
+        // then don't adjust the line number. Otherwise, it will always be past
+        // the last line and will not be visible.
+        if (new_lnum <= curbuf->b_ml.ml_line_count)
+            sign->se_lnum = new_lnum;
     }
 }
 
@@ -858,14 +858,14 @@
  */
 static int
 sign_cmd_idx(char_u *begin_cmd, // begin of sign subcmd
-	     char_u *end_cmd) // just after sign subcmd
+             char_u *end_cmd) // just after sign subcmd
 {
     int idx = 0;
     char save = *end_cmd;
     *end_cmd = NUL;
 
     while (cmds[idx] != NULL && STRCMP(begin_cmd, cmds[idx]) != 0)
-	++idx;
+        ++idx;
 
     *end_cmd = save;
     return idx;
@@ -878,16 +878,16 @@
 sign_find(char_u *name, sign_T **sp_prev)
 {
     if (sp_prev != NULL)
-	*sp_prev = NULL;
+        *sp_prev = NULL;
 
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
     {
-	if (STRCMP(sp->sn_name, name) == 0)
-	    break;
+        if (STRCMP(sp->sn_name, name) == 0)
+            break;
 
-	if (sp_prev != NULL)
-	    *sp_prev = sp;
+        if (sp_prev != NULL)
+            *sp_prev = sp;
     }
 
     return sp;
@@ -904,7 +904,7 @@
     // Allocate a new sign.
     sign_T *sp = alloc_clear_id(sizeof(sign_T), aid_sign_define_by_name);
     if (sp == NULL)
-	return NULL;
+        return NULL;
 
     // Check that next_sign_typenr is not already being used.
     // This only happens after wrapping around.  Hopefully
@@ -912,36 +912,36 @@
     sign_T *lp = first_sign;
     while (lp != NULL)
     {
-	if (lp->sn_typenr == next_sign_typenr)
-	{
-	    ++next_sign_typenr;
+        if (lp->sn_typenr == next_sign_typenr)
+        {
+            ++next_sign_typenr;
 
-	    if (next_sign_typenr == MAX_TYPENR)
-		next_sign_typenr = 1;
+            if (next_sign_typenr == MAX_TYPENR)
+                next_sign_typenr = 1;
 
-	    if (next_sign_typenr == start)
-	    {
-		vim_free(sp);
-		emsg(_(e_too_many_signs_defined));
-		return NULL;
-	    }
+            if (next_sign_typenr == start)
+            {
+                vim_free(sp);
+                emsg(_(e_too_many_signs_defined));
+                return NULL;
+            }
 
-	    lp = first_sign; // start all over
-	    continue;
-	}
-	lp = lp->sn_next;
+            lp = first_sign; // start all over
+            continue;
+        }
+        lp = lp->sn_next;
     }
 
     sp->sn_typenr = next_sign_typenr;
 
     if (++next_sign_typenr == MAX_TYPENR)
-	next_sign_typenr = 1; // wrap around
+        next_sign_typenr = 1; // wrap around
 
     sp->sn_name = vim_strsave(name);
     if (sp->sn_name == NULL) // out of memory
     {
-	vim_free(sp);
-	return NULL;
+        vim_free(sp);
+        return NULL;
     }
 
     return sp;
@@ -959,10 +959,10 @@
 # ifdef FEAT_SIGN_ICONS
     if (gui.in_use)
     {
-	out_flush();
-	if (sp->sn_image != NULL)
-	    gui_mch_destroy_sign(sp->sn_image);
-	sp->sn_image = gui_mch_register_sign(sp->sn_icon);
+        out_flush();
+        if (sp->sn_image != NULL)
+            gui_mch_destroy_sign(sp->sn_image);
+        sp->sn_image = gui_mch_register_sign(sp->sn_icon);
     }
 # endif
 }
@@ -980,39 +980,39 @@
     // Remove backslashes so that it is possible to use a space.
     for (s = text; s + 1 < endp; ++s)
     {
-	if (*s == '\\')
-	{
-	    STRMOVE(s, s + 1);
-	    --endp;
-	}
+        if (*s == '\\')
+        {
+            STRMOVE(s, s + 1);
+            --endp;
+        }
     }
 
     // Count cells and check for non-printable chars
     if (has_mbyte)
     {
-	for (s = text; s < endp; s += (*mb_ptr2len)(s))
-	{
-	    if (!vim_isprintc((*mb_ptr2char)(s)))
-		break;
+        for (s = text; s < endp; s += (*mb_ptr2len)(s))
+        {
+            if (!vim_isprintc((*mb_ptr2char)(s)))
+                break;
 
-	    cells += (*mb_ptr2cells)(s);
-	}
+            cells += (*mb_ptr2cells)(s);
+        }
     }
     else
     {
-	for (s = text; s < endp; ++s)
-	{
-	    if (!vim_isprintc(*s))
-		break;
-	}
-	cells = (int)(s - text);
+        for (s = text; s < endp; ++s)
+        {
+            if (!vim_isprintc(*s))
+                break;
+        }
+        cells = (int)(s - text);
     }
 
     // Currently sign text must be one or two display cells
     if (s != endp || cells < 1 || cells > 2)
     {
-	semsg(_(e_invalid_sign_text_str), text);
-	return FAIL;
+        semsg(_(e_invalid_sign_text_str), text);
+        return FAIL;
     }
 
     vim_free(sp->sn_text);
@@ -1023,7 +1023,7 @@
 
     // For single character sign text, pad with a space.
     if (sp->sn_text != NULL && cells == 1)
-	STRCPY(sp->sn_text + len - 1, " ");
+        STRCPY(sp->sn_text + len - 1, " ");
 
     return OK;
 }
@@ -1033,79 +1033,79 @@
  */
 int
 sign_define_by_name(char_u *name,
-		    char_u *icon,
-		    char_u *linehl,
-		    char_u *text,
-		    char_u *texthl,
-		    char_u *culhl,
-		    char_u *numhl,
-		    int prio)
+                    char_u *icon,
+                    char_u *linehl,
+                    char_u *text,
+                    char_u *texthl,
+                    char_u *culhl,
+                    char_u *numhl,
+                    int prio)
 {
     sign_T *sp_prev = NULL;
     sign_T *sp = sign_find(name, &sp_prev);
     if (sp == NULL)
     {
-	sp = alloc_new_sign(name);
-	if (sp == NULL)
-	    return FAIL;
+        sp = alloc_new_sign(name);
+        if (sp == NULL)
+            return FAIL;
 
-	// add the new sign to the list of signs
-	if (sp_prev == NULL)
-	    first_sign = sp;
-	else
-	    sp_prev->sn_next = sp;
+        // add the new sign to the list of signs
+        if (sp_prev == NULL)
+            first_sign = sp;
+        else
+            sp_prev->sn_next = sp;
     }
     else
     {
-	win_T *wp = NULL;
-	// Signs may already exist, a redraw is needed in windows with a
-	// non-empty sign list.
-	FOR_ALL_WINDOWS(wp)
-	{
-	    if (wp->w_buffer->b_signlist != NULL)
-		redraw_buf_later(wp->w_buffer, UPD_NOT_VALID);
-	}
+        win_T *wp = NULL;
+        // Signs may already exist, a redraw is needed in windows with a
+        // non-empty sign list.
+        FOR_ALL_WINDOWS(wp)
+        {
+            if (wp->w_buffer->b_signlist != NULL)
+                redraw_buf_later(wp->w_buffer, UPD_NOT_VALID);
+        }
     }
 
     // set values for a defined sign.
     if (icon != NULL)
-	sign_define_init_icon(sp, icon);
+        sign_define_init_icon(sp, icon);
 
     if (text != NULL && (sign_define_init_text(sp, text) == FAIL))
-	return FAIL;
+        return FAIL;
 
     sp->sn_priority = prio;
 
     if (linehl != NULL)
     {
-	if (*linehl == NUL)
-	    sp->sn_line_hl = 0;
-	else
-	    sp->sn_line_hl = syn_check_group(linehl, (int)STRLEN(linehl));
+        if (*linehl == NUL)
+            sp->sn_line_hl = 0;
+        else
+            sp->sn_line_hl = syn_check_group(linehl, (int)STRLEN(linehl));
     }
 
     if (texthl != NULL)
     {
-	if (*texthl == NUL)
-	    sp->sn_text_hl = 0;
-	else
-	    sp->sn_text_hl = syn_check_group(texthl, (int)STRLEN(texthl));
+        if (*texthl == NUL)
+            sp->sn_text_hl = 0;
+        else
+            sp->sn_text_hl = syn_check_group(texthl, (int)STRLEN(texthl));
     }
 
     if (culhl != NULL)
     {
-	if (*culhl == NUL)
-	    sp->sn_cul_hl = 0;
-	else
-	    sp->sn_cul_hl = syn_check_group(culhl, (int)STRLEN(culhl));
+        if (*culhl == NUL)
+            sp->sn_cul_hl = 0;
+        else
+            sp->sn_cul_hl = syn_check_group(culhl, (int)STRLEN(culhl));
     }
 
     if (numhl != NULL)
     {
-	if (*numhl == NUL)
-	    sp->sn_num_hl = 0;
-	else
-	    sp->sn_num_hl = syn_check_group(numhl, (int)STRLEN(numhl));
+        if (*numhl == NUL)
+            sp->sn_num_hl = 0;
+        else
+            sp->sn_num_hl = syn_check_group(numhl, (int)STRLEN(numhl));
     }
 
     return OK;
@@ -1130,9 +1130,9 @@
     sign_T *sp = sign_find(name, &sp_prev);
     if (sp == NULL)
     {
-	if (give_error)
-	    semsg(_(e_unknown_sign_str), name);
-	return FAIL;
+        if (give_error)
+            semsg(_(e_unknown_sign_str), name);
+        return FAIL;
     }
     sign_undefine(sp, sp_prev);
 
@@ -1147,9 +1147,9 @@
 {
     sign_T *sp = sign_find(name, NULL);
     if (sp != NULL)
-	sign_list_defined(sp);
+        sign_list_defined(sp);
     else
-	semsg(_(e_unknown_sign_str), name);
+        semsg(_(e_unknown_sign_str), name);
 }
 
 static void
@@ -1160,10 +1160,10 @@
 
     FOR_ALL_TAB_WINDOWS(tp, wp)
     {
-	if (wp->w_buffer == buf && (wp->w_p_nu || wp->w_p_rnu) &&
-	    (unplace || wp->w_nrwidth_width < 2) &&
-	    (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u'))
-	    wp->w_nrwidth_line_count = 0;
+        if (wp->w_buffer == buf && (wp->w_p_nu || wp->w_p_rnu) &&
+            (unplace || wp->w_nrwidth_width < 2) &&
+            (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u'))
+            wp->w_nrwidth_line_count = 0;
     }
 }
 
@@ -1172,61 +1172,61 @@
  */
 int
 sign_place(int *sign_id,
-	   char_u *sign_group,
-	   char_u *sign_name,
-	   buf_T *buf,
-	   linenr_T lnum,
-	   int prio)
+           char_u *sign_group,
+           char_u *sign_name,
+           buf_T *buf,
+           linenr_T lnum,
+           int prio)
 {
     // Check for reserved character '*' in group name
     if (sign_group != NULL && (*sign_group == '*' || *sign_group == '\0'))
-	return FAIL;
+        return FAIL;
 
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
     {
-	if (STRCMP(sp->sn_name, sign_name) == 0)
-	    break;
+        if (STRCMP(sp->sn_name, sign_name) == 0)
+            break;
     }
 
     if (sp == NULL)
     {
-	semsg(_(e_unknown_sign_str), sign_name);
-	return FAIL;
+        semsg(_(e_unknown_sign_str), sign_name);
+        return FAIL;
     }
 
     if (*sign_id == 0)
-	*sign_id = sign_group_get_next_signid(buf, sign_group);
+        *sign_id = sign_group_get_next_signid(buf, sign_group);
 
     // Use the default priority value for this sign.
     if (prio == -1)
-	prio = (sp->sn_priority != -1) ? sp->sn_priority : SIGN_DEF_PRIO;
+        prio = (sp->sn_priority != -1) ? sp->sn_priority : SIGN_DEF_PRIO;
 
     if (lnum > 0)
     {
-	// ":sign place {id} line={lnum} name={name} file={fname}":
-	// place a sign
-	buf_addsign(buf, *sign_id, sign_group, prio, lnum, sp->sn_typenr);
+        // ":sign place {id} line={lnum} name={name} file={fname}":
+        // place a sign
+        buf_addsign(buf, *sign_id, sign_group, prio, lnum, sp->sn_typenr);
     }
     else
     {
-	// ":sign place {id} file={fname}": change sign type and/or priority
-	lnum = buf_change_sign_type(buf, *sign_id, sign_group, sp->sn_typenr,
-				    prio);
+        // ":sign place {id} file={fname}": change sign type and/or priority
+        lnum = buf_change_sign_type(buf, *sign_id, sign_group, sp->sn_typenr,
+                                    prio);
     }
 
     if (lnum > 0)
     {
-	redraw_buf_line_later(buf, lnum);
+        redraw_buf_line_later(buf, lnum);
 
-	// When displaying signs in the 'number' column, if the width of the
-	// number column is less than 2, then force recomputing the width.
-	may_force_numberwidth_recompute(buf, FALSE);
+        // When displaying signs in the 'number' column, if the width of the
+        // number column is less than 2, then force recomputing the width.
+        may_force_numberwidth_recompute(buf, FALSE);
     }
     else
     {
-	semsg(_(e_not_possible_to_change_sign_str), sign_name);
-	return FAIL;
+        semsg(_(e_not_possible_to_change_sign_str), sign_name);
+        return FAIL;
     }
 
     return OK;
@@ -1239,27 +1239,27 @@
 sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T atlnum)
 {
     if (buf->b_signlist == NULL) // No signs in the buffer
-	return OK;
+        return OK;
 
     if (sign_id == 0)
     {
-	// Delete all the signs in the specified buffer
-	redraw_buf_later(buf, UPD_NOT_VALID);
-	buf_delete_signs(buf, sign_group);
+        // Delete all the signs in the specified buffer
+        redraw_buf_later(buf, UPD_NOT_VALID);
+        buf_delete_signs(buf, sign_group);
     }
     else
     {
-	// Delete only the specified signs
-	linenr_T lnum = buf_delsign(buf, atlnum, sign_id, sign_group);
-	if (lnum == 0)
-	    return FAIL;
+        // Delete only the specified signs
+        linenr_T lnum = buf_delsign(buf, atlnum, sign_id, sign_group);
+        if (lnum == 0)
+            return FAIL;
     }
 
     // When all the signs in a buffer are removed, force recomputing the
     // number column width (if enabled) in all the windows displaying the
     // buffer if 'signcolumn' is set to 'number' in that window.
     if (buf->b_signlist == NULL)
-	may_force_numberwidth_recompute(buf, TRUE);
+        may_force_numberwidth_recompute(buf, TRUE);
 
     return OK;
 }
@@ -1271,12 +1271,12 @@
 sign_unplace_at_cursor(char_u *groupname)
 {
     int id =
-	buf_findsign_id(curwin->w_buffer, curwin->w_cursor.lnum, groupname);
+        buf_findsign_id(curwin->w_buffer, curwin->w_cursor.lnum, groupname);
 
     if (id > 0)
-	sign_unplace(id, groupname, curwin->w_buffer, curwin->w_cursor.lnum);
+        sign_unplace(id, groupname, curwin->w_buffer, curwin->w_cursor.lnum);
     else
-	emsg(_(e_missing_sign_number));
+        emsg(_(e_missing_sign_number));
 }
 
 /*
@@ -1288,31 +1288,31 @@
     linenr_T lnum = buf_findsign(buf, sign_id, sign_group);
     if (lnum <= 0)
     {
-	semsg(_(e_invalid_sign_id_nr), sign_id);
-	return -1;
+        semsg(_(e_invalid_sign_id_nr), sign_id);
+        return -1;
     }
 
     // goto a sign ...
     if (buf_jump_open_win(buf) != NULL)
     { // ... in a current window
-	curwin->w_cursor.lnum = lnum;
-	check_cursor_lnum();
-	beginline(BL_WHITE);
+        curwin->w_cursor.lnum = lnum;
+        check_cursor_lnum();
+        beginline(BL_WHITE);
     }
     else
     { // ... not currently in a window
-	if (buf->b_fname == NULL)
-	{
-	    emsg(_(e_cannot_jump_to_buffer_that_does_not_have_name));
-	    return -1;
-	}
-	char_u *cmd = alloc(STRLEN(buf->b_fname) + 25);
-	if (cmd == NULL)
-	    return -1;
+        if (buf->b_fname == NULL)
+        {
+            emsg(_(e_cannot_jump_to_buffer_that_does_not_have_name));
+            return -1;
+        }
+        char_u *cmd = alloc(STRLEN(buf->b_fname) + 25);
+        if (cmd == NULL)
+            return -1;
 
-	sprintf((char *)cmd, "e +%ld %s", (long)lnum, buf->b_fname);
-	do_cmdline_cmd(cmd);
-	vim_free(cmd);
+        sprintf((char *)cmd, "e +%ld %s", (long)lnum, buf->b_fname);
+        do_cmdline_cmd(cmd);
+        vim_free(cmd);
     }
 # ifdef FEAT_FOLDING
     foldOpenCursor();
@@ -1341,57 +1341,57 @@
     // set values for a defined sign.
     while (TRUE)
     {
-	arg = skipwhite(p);
-	if (*arg == NUL)
-	    break;
+        arg = skipwhite(p);
+        if (*arg == NUL)
+            break;
 
-	p = skiptowhite_esc(arg);
-	if (STRNCMP(arg, "icon=", 5) == 0)
-	{
-	    arg += 5;
-	    icon = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "text=", 5) == 0)
-	{
-	    arg += 5;
-	    text = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "linehl=", 7) == 0)
-	{
-	    arg += 7;
-	    linehl = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "texthl=", 7) == 0)
-	{
-	    arg += 7;
-	    texthl = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "culhl=", 6) == 0)
-	{
-	    arg += 6;
-	    culhl = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "numhl=", 6) == 0)
-	{
-	    arg += 6;
-	    numhl = vim_strnsave(arg, p - arg);
-	}
-	else if (STRNCMP(arg, "priority=", 9) == 0)
-	{
-	    arg += 9;
-	    prio = atoi((char *)arg);
-	}
-	else
-	{
-	    semsg(_(e_invalid_argument_str), arg);
-	    failed = TRUE;
-	    break;
-	}
+        p = skiptowhite_esc(arg);
+        if (STRNCMP(arg, "icon=", 5) == 0)
+        {
+            arg += 5;
+            icon = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "text=", 5) == 0)
+        {
+            arg += 5;
+            text = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "linehl=", 7) == 0)
+        {
+            arg += 7;
+            linehl = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "texthl=", 7) == 0)
+        {
+            arg += 7;
+            texthl = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "culhl=", 6) == 0)
+        {
+            arg += 6;
+            culhl = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "numhl=", 6) == 0)
+        {
+            arg += 6;
+            numhl = vim_strnsave(arg, p - arg);
+        }
+        else if (STRNCMP(arg, "priority=", 9) == 0)
+        {
+            arg += 9;
+            prio = atoi((char *)arg);
+        }
+        else
+        {
+            semsg(_(e_invalid_argument_str), arg);
+            failed = TRUE;
+            break;
+        }
     }
 
     if (!failed)
-	sign_define_by_name(sign_name, icon, linehl, text, texthl, culhl, numhl,
-			    prio);
+        sign_define_by_name(sign_name, icon, linehl, text, texthl, culhl, numhl,
+                            prio);
 
     vim_free(icon);
     vim_free(text);
@@ -1406,40 +1406,40 @@
  */
 static void
 sign_place_cmd(buf_T *buf,
-	       linenr_T lnum,
-	       char_u *sign_name,
-	       int id,
-	       char_u *group,
-	       int prio)
+               linenr_T lnum,
+               char_u *sign_name,
+               int id,
+               char_u *group,
+               int prio)
 {
     if (id <= 0)
     {
-	// List signs placed in a file/buffer
-	//   :sign place file={fname}
-	//   :sign place group={group} file={fname}
-	//   :sign place group=* file={fname}
-	//   :sign place buffer={nr}
-	//   :sign place group={group} buffer={nr}
-	//   :sign place group=* buffer={nr}
-	//   :sign place
-	//   :sign place group={group}
-	//   :sign place group=*
-	if (lnum >= 0 || sign_name != NULL || (group != NULL && *group == '\0'))
-	    emsg(_(e_invalid_argument));
-	else
-	    sign_list_placed(buf, group);
+        // List signs placed in a file/buffer
+        //   :sign place file={fname}
+        //   :sign place group={group} file={fname}
+        //   :sign place group=* file={fname}
+        //   :sign place buffer={nr}
+        //   :sign place group={group} buffer={nr}
+        //   :sign place group=* buffer={nr}
+        //   :sign place
+        //   :sign place group={group}
+        //   :sign place group=*
+        if (lnum >= 0 || sign_name != NULL || (group != NULL && *group == '\0'))
+            emsg(_(e_invalid_argument));
+        else
+            sign_list_placed(buf, group);
     }
     else
     {
-	// Place a new sign
-	if (sign_name == NULL || buf == NULL ||
-	    (group != NULL && *group == '\0'))
-	{
-	    emsg(_(e_invalid_argument));
-	    return;
-	}
+        // Place a new sign
+        if (sign_name == NULL || buf == NULL ||
+            (group != NULL && *group == '\0'))
+        {
+            emsg(_(e_invalid_argument));
+            return;
+        }
 
-	sign_place(&id, group, sign_name, buf, lnum, prio);
+        sign_place(&id, group, sign_name, buf, lnum, prio);
     }
 }
 
@@ -1448,70 +1448,70 @@
  */
 static void
 sign_unplace_cmd(buf_T *buf,
-		 linenr_T lnum,
-		 char_u *sign_name,
-		 int id,
-		 char_u *group)
+                 linenr_T lnum,
+                 char_u *sign_name,
+                 int id,
+                 char_u *group)
 {
     if (lnum >= 0 || sign_name != NULL || (group != NULL && *group == '\0'))
     {
-	emsg(_(e_invalid_argument));
-	return;
+        emsg(_(e_invalid_argument));
+        return;
     }
 
     if (id == -2)
     {
-	if (buf != NULL)
-	{
-	    // :sign unplace * file={fname}
-	    // :sign unplace * group={group} file={fname}
-	    // :sign unplace * group=* file={fname}
-	    // :sign unplace * buffer={nr}
-	    // :sign unplace * group={group} buffer={nr}
-	    // :sign unplace * group=* buffer={nr}
-	    sign_unplace(0, group, buf, 0);
-	}
-	else
-	{
-	    // :sign unplace *
-	    // :sign unplace * group={group}
-	    // :sign unplace * group=*
-	    FOR_ALL_BUFFERS(buf)
-	    {
-		if (buf->b_signlist != NULL)
-		    buf_delete_signs(buf, group);
-	    }
-	}
+        if (buf != NULL)
+        {
+            // :sign unplace * file={fname}
+            // :sign unplace * group={group} file={fname}
+            // :sign unplace * group=* file={fname}
+            // :sign unplace * buffer={nr}
+            // :sign unplace * group={group} buffer={nr}
+            // :sign unplace * group=* buffer={nr}
+            sign_unplace(0, group, buf, 0);
+        }
+        else
+        {
+            // :sign unplace *
+            // :sign unplace * group={group}
+            // :sign unplace * group=*
+            FOR_ALL_BUFFERS(buf)
+            {
+                if (buf->b_signlist != NULL)
+                    buf_delete_signs(buf, group);
+            }
+        }
     }
     else
     {
-	if (buf != NULL)
-	{
-	    // :sign unplace {id} file={fname}
-	    // :sign unplace {id} group={group} file={fname}
-	    // :sign unplace {id} group=* file={fname}
-	    // :sign unplace {id} buffer={nr}
-	    // :sign unplace {id} group={group} buffer={nr}
-	    // :sign unplace {id} group=* buffer={nr}
-	    sign_unplace(id, group, buf, 0);
-	}
-	else
-	{
-	    if (id == -1)
-	    {
-		// :sign unplace group={group}
-		// :sign unplace group=*
-		sign_unplace_at_cursor(group);
-	    }
-	    else
-	    {
-		// :sign unplace {id}
-		// :sign unplace {id} group={group}
-		// :sign unplace {id} group=*
-		FOR_ALL_BUFFERS(buf)
-		    sign_unplace(id, group, buf, 0);
-	    }
-	}
+        if (buf != NULL)
+        {
+            // :sign unplace {id} file={fname}
+            // :sign unplace {id} group={group} file={fname}
+            // :sign unplace {id} group=* file={fname}
+            // :sign unplace {id} buffer={nr}
+            // :sign unplace {id} group={group} buffer={nr}
+            // :sign unplace {id} group=* buffer={nr}
+            sign_unplace(id, group, buf, 0);
+        }
+        else
+        {
+            if (id == -1)
+            {
+                // :sign unplace group={group}
+                // :sign unplace group=*
+                sign_unplace_at_cursor(group);
+            }
+            else
+            {
+                // :sign unplace {id}
+                // :sign unplace {id} group={group}
+                // :sign unplace {id} group=*
+                FOR_ALL_BUFFERS(buf)
+                    sign_unplace(id, group, buf, 0);
+            }
+        }
     }
 }
 
@@ -1524,24 +1524,24 @@
  */
 static void
 sign_jump_cmd(buf_T *buf,
-	      linenr_T lnum,
-	      char_u *sign_name,
-	      int id,
-	      char_u *group)
+              linenr_T lnum,
+              char_u *sign_name,
+              int id,
+              char_u *group)
 {
     if (sign_name == NULL && group == NULL && id == -1)
     {
-	emsg(_(e_argument_required));
-	return;
+        emsg(_(e_argument_required));
+        return;
     }
 
     if (buf == NULL || (group != NULL && *group == '\0') || lnum >= 0 ||
-	sign_name != NULL)
+        sign_name != NULL)
     {
-	// File or buffer is not specified or an empty group is used
-	// or a line number or a sign name is specified.
-	emsg(_(e_invalid_argument));
-	return;
+        // File or buffer is not specified or an empty group is used
+        // or a line number or a sign name is specified.
+        emsg(_(e_invalid_argument));
+        return;
     }
 
     (void)sign_jump(id, group, buf);
@@ -1555,13 +1555,13 @@
  */
 static int
 parse_sign_cmd_args(int cmd,
-		    char_u *arg,
-		    char_u **sign_name,
-		    int *signid,
-		    char_u **group,
-		    int *prio,
-		    buf_T **buf,
-		    linenr_T *lnum)
+                    char_u *arg,
+                    char_u **sign_name,
+                    int *signid,
+                    char_u **group,
+                    int *prio,
+                    buf_T **buf,
+                    linenr_T *lnum)
 {
     char_u *arg1 = arg;
     char_u *filename = NULL;
@@ -1570,102 +1570,102 @@
     // first arg could be placed sign id
     if (VIM_ISDIGIT(*arg))
     {
-	*signid = getdigits(&arg);
-	if (!VIM_ISWHITE(*arg) && *arg != NUL)
-	{
-	    *signid = -1;
-	    arg = arg1;
-	}
-	else
-	{
-	    arg = skipwhite(arg);
-	}
+        *signid = getdigits(&arg);
+        if (!VIM_ISWHITE(*arg) && *arg != NUL)
+        {
+            *signid = -1;
+            arg = arg1;
+        }
+        else
+        {
+            arg = skipwhite(arg);
+        }
     }
 
     while (*arg != NUL)
     {
-	if (STRNCMP(arg, "line=", 5) == 0)
-	{
-	    arg += 5;
-	    *lnum = atoi((char *)arg);
-	    arg = skiptowhite(arg);
-	    lnum_arg = TRUE;
-	}
-	else if (STRNCMP(arg, "*", 1) == 0 && cmd == SIGNCMD_UNPLACE)
-	{
-	    if (*signid != -1)
-	    {
-		emsg(_(e_invalid_argument));
-		return FAIL;
-	    }
-	    *signid = -2;
-	    arg = skiptowhite(arg + 1);
-	}
-	else if (STRNCMP(arg, "name=", 5) == 0)
-	{
-	    arg += 5;
-	    char_u *name = arg;
-	    arg = skiptowhite(arg);
-	    if (*arg != NUL)
-		*arg++ = NUL;
+        if (STRNCMP(arg, "line=", 5) == 0)
+        {
+            arg += 5;
+            *lnum = atoi((char *)arg);
+            arg = skiptowhite(arg);
+            lnum_arg = TRUE;
+        }
+        else if (STRNCMP(arg, "*", 1) == 0 && cmd == SIGNCMD_UNPLACE)
+        {
+            if (*signid != -1)
+            {
+                emsg(_(e_invalid_argument));
+                return FAIL;
+            }
+            *signid = -2;
+            arg = skiptowhite(arg + 1);
+        }
+        else if (STRNCMP(arg, "name=", 5) == 0)
+        {
+            arg += 5;
+            char_u *name = arg;
+            arg = skiptowhite(arg);
+            if (*arg != NUL)
+                *arg++ = NUL;
 
-	    while (name[0] == '0' && name[1] != NUL)
-		++name;
+            while (name[0] == '0' && name[1] != NUL)
+                ++name;
 
-	    *sign_name = name;
-	}
-	else if (STRNCMP(arg, "group=", 6) == 0)
-	{
-	    arg += 6;
-	    *group = arg;
-	    arg = skiptowhite(arg);
-	    if (*arg != NUL)
-		*arg++ = NUL;
-	}
-	else if (STRNCMP(arg, "priority=", 9) == 0)
-	{
-	    arg += 9;
-	    *prio = atoi((char *)arg);
-	    arg = skiptowhite(arg);
-	}
-	else if (STRNCMP(arg, "file=", 5) == 0)
-	{
-	    arg += 5;
-	    filename = arg;
-	    *buf = buflist_findname_exp(arg);
-	    break;
-	}
-	else if (STRNCMP(arg, "buffer=", 7) == 0)
-	{
-	    arg += 7;
-	    filename = arg;
-	    *buf = buflist_findnr((int)getdigits(&arg));
+            *sign_name = name;
+        }
+        else if (STRNCMP(arg, "group=", 6) == 0)
+        {
+            arg += 6;
+            *group = arg;
+            arg = skiptowhite(arg);
+            if (*arg != NUL)
+                *arg++ = NUL;
+        }
+        else if (STRNCMP(arg, "priority=", 9) == 0)
+        {
+            arg += 9;
+            *prio = atoi((char *)arg);
+            arg = skiptowhite(arg);
+        }
+        else if (STRNCMP(arg, "file=", 5) == 0)
+        {
+            arg += 5;
+            filename = arg;
+            *buf = buflist_findname_exp(arg);
+            break;
+        }
+        else if (STRNCMP(arg, "buffer=", 7) == 0)
+        {
+            arg += 7;
+            filename = arg;
+            *buf = buflist_findnr((int)getdigits(&arg));
 
-	    if (*skipwhite(arg) != NUL)
-		semsg(_(e_trailing_characters_str), arg);
+            if (*skipwhite(arg) != NUL)
+                semsg(_(e_trailing_characters_str), arg);
 
-	    break;
-	}
-	else
-	{
-	    emsg(_(e_invalid_argument));
-	    return FAIL;
-	}
+            break;
+        }
+        else
+        {
+            emsg(_(e_invalid_argument));
+            return FAIL;
+        }
 
-	arg = skipwhite(arg);
+        arg = skipwhite(arg);
     }
 
     if (filename != NULL && *buf == NULL)
     {
-	semsg(_(e_invalid_buffer_name_str), filename);
-	return FAIL;
+        semsg(_(e_invalid_buffer_name_str), filename);
+        return FAIL;
     }
 
     // If the filename is not supplied for the sign place or the sign jump
     // command, then use the current buffer.
     if (filename == NULL &&
-	((cmd == SIGNCMD_PLACE && lnum_arg) || cmd == SIGNCMD_JUMP))
-	*buf = curwin->w_buffer;
+        ((cmd == SIGNCMD_PLACE && lnum_arg) || cmd == SIGNCMD_JUMP))
+        *buf = curwin->w_buffer;
 
     return OK;
 }
@@ -1683,70 +1683,70 @@
     int idx = sign_cmd_idx(arg, p);
     if (idx == SIGNCMD_LAST)
     {
-	semsg(_(e_unknown_sign_command_str), arg);
-	return;
+        semsg(_(e_unknown_sign_command_str), arg);
+        return;
     }
     arg = skipwhite(p);
 
     if (idx > SIGNCMD_LIST)
     {
-	char_u *sign_name = NULL;
-	int id = -1;
-	char_u *group = NULL;
-	int prio = -1;
-	buf_T *buf = NULL;
-	linenr_T lnum = -1;
+        char_u *sign_name = NULL;
+        int id = -1;
+        char_u *group = NULL;
+        int prio = -1;
+        buf_T *buf = NULL;
+        linenr_T lnum = -1;
 
-	// Parse command line arguments
-	if (parse_sign_cmd_args(idx, arg, &sign_name, &id, &group, &prio, &buf,
-				&lnum) == FAIL)
-	    return;
+        // Parse command line arguments
+        if (parse_sign_cmd_args(idx, arg, &sign_name, &id, &group, &prio, &buf,
+                                &lnum) == FAIL)
+            return;
 
-	if (idx == SIGNCMD_PLACE)
-	    sign_place_cmd(buf, lnum, sign_name, id, group, prio);
-	else if (idx == SIGNCMD_UNPLACE)
-	    sign_unplace_cmd(buf, lnum, sign_name, id, group);
-	else if (idx == SIGNCMD_JUMP)
-	    sign_jump_cmd(buf, lnum, sign_name, id, group);
+        if (idx == SIGNCMD_PLACE)
+            sign_place_cmd(buf, lnum, sign_name, id, group, prio);
+        else if (idx == SIGNCMD_UNPLACE)
+            sign_unplace_cmd(buf, lnum, sign_name, id, group);
+        else if (idx == SIGNCMD_JUMP)
+            sign_jump_cmd(buf, lnum, sign_name, id, group);
 
-	return;
+        return;
     }
 
     // Define, undefine or list signs.
     if (idx == SIGNCMD_LIST && *arg == NUL)
     {
-	// ":sign list": list all defined signs
-	for (sign_T *sp = first_sign; sp != NULL && !got_int; sp = sp->sn_next)
-	    sign_list_defined(sp);
+        // ":sign list": list all defined signs
+        for (sign_T *sp = first_sign; sp != NULL && !got_int; sp = sp->sn_next)
+            sign_list_defined(sp);
     }
     else if (*arg == NUL)
     {
-	emsg(_(e_missing_sign_name));
+        emsg(_(e_missing_sign_name));
     }
     else
     {
 
-	// Isolate the sign name.  If it's a number skip leading zeroes,
-	// so that "099" and "99" are the same sign.  But keep "0".
-	p = skiptowhite(arg);
-	if (*p != NUL)
-	    *p++ = NUL;
+        // Isolate the sign name.  If it's a number skip leading zeroes,
+        // so that "099" and "99" are the same sign.  But keep "0".
+        p = skiptowhite(arg);
+        if (*p != NUL)
+            *p++ = NUL;
 
-	while (arg[0] == '0' && arg[1] != NUL)
-	    ++arg;
+        while (arg[0] == '0' && arg[1] != NUL)
+            ++arg;
 
-	char_u *name = vim_strsave(arg);
+        char_u *name = vim_strsave(arg);
 
-	if (idx == SIGNCMD_DEFINE)
-	    sign_define_cmd(name, p);
-	else if (idx == SIGNCMD_LIST)
-	    // ":sign list {name}"
-	    sign_list_by_name(name);
-	else
-	    // ":sign undefine {name}"
-	    sign_undefine_by_name(name, TRUE);
+        if (idx == SIGNCMD_DEFINE)
+            sign_define_cmd(name, p);
+        else if (idx == SIGNCMD_LIST)
+            // ":sign list {name}"
+            sign_list_by_name(name);
+        else
+            // ":sign undefine {name}"
+            sign_undefine_by_name(name, TRUE);
 
-	vim_free(name);
+        vim_free(name);
     }
 }
 
@@ -1759,44 +1759,44 @@
     dict_add_string(retdict, "name", sp->sn_name);
 
     if (sp->sn_icon != NULL)
-	dict_add_string(retdict, "icon", sp->sn_icon);
+        dict_add_string(retdict, "icon", sp->sn_icon);
 
     if (sp->sn_text != NULL)
-	dict_add_string(retdict, "text", sp->sn_text);
+        dict_add_string(retdict, "text", sp->sn_text);
 
     if (sp->sn_priority > 0)
-	dict_add_number(retdict, "priority", sp->sn_priority);
+        dict_add_number(retdict, "priority", sp->sn_priority);
 
     if (sp->sn_line_hl > 0)
     {
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, FALSE);
-	if (p == NULL)
-	    p = (char_u *)"NONE";
-	dict_add_string(retdict, "linehl", p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, FALSE);
+        if (p == NULL)
+            p = (char_u *)"NONE";
+        dict_add_string(retdict, "linehl", p);
     }
 
     if (sp->sn_text_hl > 0)
     {
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_text_hl - 1, FALSE);
-	if (p == NULL)
-	    p = (char_u *)"NONE";
-	dict_add_string(retdict, "texthl", p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_text_hl - 1, FALSE);
+        if (p == NULL)
+            p = (char_u *)"NONE";
+        dict_add_string(retdict, "texthl", p);
     }
 
     if (sp->sn_cul_hl > 0)
     {
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_cul_hl - 1, FALSE);
-	if (p == NULL)
-	    p = (char_u *)"NONE";
-	dict_add_string(retdict, "culhl", p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_cul_hl - 1, FALSE);
+        if (p == NULL)
+            p = (char_u *)"NONE";
+        dict_add_string(retdict, "culhl", p);
     }
 
     if (sp->sn_num_hl > 0)
     {
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_num_hl - 1, FALSE);
-	if (p == NULL)
-	    p = (char_u *)"NONE";
-	dict_add_string(retdict, "numhl", p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_num_hl - 1, FALSE);
+        if (p == NULL)
+            p = (char_u *)"NONE";
+        dict_add_string(retdict, "numhl", p);
     }
 }
 
@@ -1811,24 +1811,24 @@
 
     if (name != NULL)
     {
-	sp = sign_find(name, NULL);
-	if (sp == NULL)
-	    return;
+        sp = sign_find(name, NULL);
+        if (sp == NULL)
+            return;
     }
 
     for (; sp != NULL && !got_int; sp = sp->sn_next)
     {
-	dict_T *dict = dict_alloc_id(aid_sign_getlist);
-	if (dict == NULL)
-	    return;
+        dict_T *dict = dict_alloc_id(aid_sign_getlist);
+        if (dict == NULL)
+            return;
 
-	if (list_append_dict(retlist, dict) == FAIL)
-	    return;
+        if (list_append_dict(retlist, dict) == FAIL)
+            return;
 
-	sign_getinfo(sp, dict);
+        sign_getinfo(sp, dict);
 
-	if (name != NULL) // handle only the specified sign
-	    break;
+        if (name != NULL) // handle only the specified sign
+            break;
     }
 }
 
@@ -1841,9 +1841,9 @@
     sign_entry_T *sign = NULL;
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	dict_T *d = sign_get_info(sign);
-	if (d != NULL)
-	    list_append_dict(l, d);
+        dict_T *d = sign_get_info(sign);
+        if (d != NULL)
+            list_append_dict(l, d);
     }
 }
 
@@ -1852,14 +1852,14 @@
  */
 static void
 sign_get_placed_in_buf(buf_T *buf,
-		       linenr_T lnum,
-		       int sign_id,
-		       char_u *sign_group,
-		       list_T *retlist)
+                       linenr_T lnum,
+                       int sign_id,
+                       char_u *sign_group,
+                       list_T *retlist)
 {
     dict_T *d = dict_alloc_id(aid_sign_getplaced_dict);
     if (d == NULL)
-	return;
+        return;
 
     list_append_dict(retlist, d);
 
@@ -1867,25 +1867,25 @@
 
     list_T *l = list_alloc_id(aid_sign_getplaced_list);
     if (l == NULL)
-	return;
+        return;
 
     dict_add_list(d, "signs", l);
 
     sign_entry_T *sign = NULL;
     FOR_ALL_SIGNS_IN_BUF(buf, sign)
     {
-	if (!sign_in_group(sign, sign_group))
-	    continue;
+        if (!sign_in_group(sign, sign_group))
+            continue;
 
-	if ((lnum == 0 && sign_id == 0) ||
-	    (sign_id == 0 && lnum == sign->se_lnum) ||
-	    (lnum == 0 && sign_id == sign->se_id) ||
-	    (lnum == sign->se_lnum && sign_id == sign->se_id))
-	{
-	    dict_T *sdict = sign_get_info(sign);
-	    if (sdict != NULL)
-		list_append_dict(l, sdict);
-	}
+        if ((lnum == 0 && sign_id == 0) ||
+            (sign_id == 0 && lnum == sign->se_lnum) ||
+            (lnum == 0 && sign_id == sign->se_id) ||
+            (lnum == sign->se_lnum && sign_id == sign->se_id))
+        {
+            dict_T *sdict = sign_get_info(sign);
+            if (sdict != NULL)
+                list_append_dict(l, sdict);
+        }
     }
 }
 
@@ -1896,22 +1896,22 @@
  */
 static void
 sign_get_placed(buf_T *buf,
-		linenr_T lnum,
-		int sign_id,
-		char_u *sign_group,
-		list_T *retlist)
+                linenr_T lnum,
+                int sign_id,
+                char_u *sign_group,
+                list_T *retlist)
 {
     if (buf != NULL)
     {
-	sign_get_placed_in_buf(buf, lnum, sign_id, sign_group, retlist);
+        sign_get_placed_in_buf(buf, lnum, sign_id, sign_group, retlist);
     }
     else
     {
-	FOR_ALL_BUFFERS(buf)
-	{
-	    if (buf->b_signlist != NULL)
-		sign_get_placed_in_buf(buf, 0, sign_id, sign_group, retlist);
-	}
+        FOR_ALL_BUFFERS(buf)
+        {
+            if (buf->b_signlist != NULL)
+                sign_get_placed_in_buf(buf, 0, sign_id, sign_group, retlist);
+        }
     }
 }
 
@@ -1926,8 +1926,8 @@
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
     {
-	if (sp->sn_icon != NULL)
-	    sp->sn_image = gui_mch_register_sign(sp->sn_icon);
+        if (sp->sn_icon != NULL)
+            sp->sn_image = gui_mch_register_sign(sp->sn_icon);
     }
 }
 # endif
@@ -1944,70 +1944,70 @@
 
     if (sp->sn_icon != NULL)
     {
-	msg_puts(" icon=");
-	msg_outtrans(sp->sn_icon);
+        msg_puts(" icon=");
+        msg_outtrans(sp->sn_icon);
 # ifdef FEAT_SIGN_ICONS
-	if (sp->sn_image == NULL)
-	    msg_puts(_(" (NOT FOUND)"));
+        if (sp->sn_image == NULL)
+            msg_puts(_(" (NOT FOUND)"));
 # else
-	msg_puts(_(" (not supported)"));
+        msg_puts(_(" (not supported)"));
 # endif
     }
 
     if (sp->sn_text != NULL)
     {
-	msg_puts(" text=");
-	msg_outtrans(sp->sn_text);
+        msg_puts(" text=");
+        msg_outtrans(sp->sn_text);
     }
 
     if (sp->sn_priority > 0)
     {
-	vim_snprintf(lbuf, MSG_BUF_LEN, " priority=%d", sp->sn_priority);
-	msg_puts(lbuf);
+        vim_snprintf(lbuf, MSG_BUF_LEN, " priority=%d", sp->sn_priority);
+        msg_puts(lbuf);
     }
 
     if (sp->sn_line_hl > 0)
     {
-	msg_puts(" linehl=");
+        msg_puts(" linehl=");
 
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, FALSE);
-	if (p == NULL)
-	    msg_puts("NONE");
-	else
-	    msg_puts((char *)p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, FALSE);
+        if (p == NULL)
+            msg_puts("NONE");
+        else
+            msg_puts((char *)p);
     }
 
     if (sp->sn_text_hl > 0)
     {
-	msg_puts(" texthl=");
+        msg_puts(" texthl=");
 
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_text_hl - 1, FALSE);
-	if (p == NULL)
-	    msg_puts("NONE");
-	else
-	    msg_puts((char *)p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_text_hl - 1, FALSE);
+        if (p == NULL)
+            msg_puts("NONE");
+        else
+            msg_puts((char *)p);
     }
 
     if (sp->sn_cul_hl > 0)
     {
-	msg_puts(" culhl=");
+        msg_puts(" culhl=");
 
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_cul_hl - 1, FALSE);
-	if (p == NULL)
-	    msg_puts("NONE");
-	else
-	    msg_puts((char *)p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_cul_hl - 1, FALSE);
+        if (p == NULL)
+            msg_puts("NONE");
+        else
+            msg_puts((char *)p);
     }
 
     if (sp->sn_num_hl > 0)
     {
-	msg_puts(" numhl=");
+        msg_puts(" numhl=");
 
-	char_u *p = get_highlight_name_ext(NULL, sp->sn_num_hl - 1, FALSE);
-	if (p == NULL)
-	    msg_puts("NONE");
-	else
-	    msg_puts((char *)p);
+        char_u *p = get_highlight_name_ext(NULL, sp->sn_num_hl - 1, FALSE);
+        if (p == NULL)
+            msg_puts("NONE");
+        else
+            msg_puts((char *)p);
     }
 }
 
@@ -2022,16 +2022,16 @@
 # ifdef FEAT_SIGN_ICONS
     if (sp->sn_image != NULL)
     {
-	out_flush();
-	gui_mch_destroy_sign(sp->sn_image);
+        out_flush();
+        gui_mch_destroy_sign(sp->sn_image);
     }
 # endif
     vim_free(sp->sn_text);
 
     if (sp_prev == NULL)
-	first_sign = sp->sn_next;
+        first_sign = sp->sn_next;
     else
-	sp_prev->sn_next = sp->sn_next;
+        sp_prev->sn_next = sp->sn_next;
 
     vim_free(sp);
 }
@@ -2043,8 +2043,8 @@
     sign_T *sp = NULL;
     FOR_ALL_SIGNS(sp)
     {
-	if (sp->sn_typenr == typenr)
-	    return sp->sn_image;
+        if (sp->sn_typenr == typenr)
+            return sp->sn_image;
     }
     return NULL;
 }
@@ -2057,7 +2057,7 @@
 free_signs(void)
 {
     while (first_sign != NULL)
-	sign_undefine(first_sign, NULL);
+        sign_undefine(first_sign, NULL);
 }
 
 static enum
@@ -2083,8 +2083,8 @@
     // Complete with name of signs already defined
     FOR_ALL_SIGNS(sp)
     {
-	if (current_idx++ == idx)
-	    return sp->sn_name;
+        if (current_idx++ == idx)
+            return sp->sn_name;
     }
     return NULL;
 }
@@ -2102,15 +2102,15 @@
     // Complete with name of sign groups already defined
     FOR_ALL_HASHTAB_ITEMS(&sg_table, hi, todo)
     {
-	if (!HASHITEM_EMPTY(hi))
-	{
-	    --todo;
-	    if (current_idx++ == idx)
-	    {
-		signgroup_T *group = HI2SG(hi);
-		return group->sg_name;
-	    }
-	}
+        if (!HASHITEM_EMPTY(hi))
+        {
+            --todo;
+            if (current_idx++ == idx)
+            {
+                signgroup_T *group = HI2SG(hi);
+                return group->sg_name;
+            }
+        }
     }
     return NULL;
 }
@@ -2124,36 +2124,36 @@
 {
     switch (expand_what)
     {
-	case EXP_SUBCMD:
-	    return (char_u *)cmds[idx];
-	case EXP_DEFINE:
-	{
-	    char *define_arg[] = { "culhl=", "icon=",   "linehl=",   "numhl=",
-				   "text=",  "texthl=", "priority=", NULL };
-	    return (char_u *)define_arg[idx];
-	}
-	case EXP_PLACE:
-	{
-	    char *place_arg[] = { "line=", "name=",   "group=", "priority=",
-				  "file=", "buffer=", NULL };
-	    return (char_u *)place_arg[idx];
-	}
-	case EXP_LIST:
-	{
-	    char *list_arg[] = { "group=", "file=", "buffer=", NULL };
-	    return (char_u *)list_arg[idx];
-	}
-	case EXP_UNPLACE:
-	{
-	    char *unplace_arg[] = { "group=", "file=", "buffer=", NULL };
-	    return (char_u *)unplace_arg[idx];
-	}
-	case EXP_SIGN_NAMES:
-	    return get_nth_sign_name(idx);
-	case EXP_SIGN_GROUPS:
-	    return get_nth_sign_group_name(idx);
-	default:
-	    return NULL;
+        case EXP_SUBCMD:
+            return (char_u *)cmds[idx];
+        case EXP_DEFINE:
+        {
+            char *define_arg[] = { "culhl=", "icon=",   "linehl=",   "numhl=",
+                                   "text=",  "texthl=", "priority=", NULL };
+            return (char_u *)define_arg[idx];
+        }
+        case EXP_PLACE:
+        {
+            char *place_arg[] = { "line=", "name=",   "group=", "priority=",
+                                  "file=", "buffer=", NULL };
+            return (char_u *)place_arg[idx];
+        }
+        case EXP_LIST:
+        {
+            char *list_arg[] = { "group=", "file=", "buffer=", NULL };
+            return (char_u *)list_arg[idx];
+        }
+        case EXP_UNPLACE:
+        {
+            char *unplace_arg[] = { "group=", "file=", "buffer=", NULL };
+            return (char_u *)unplace_arg[idx];
+        }
+        case EXP_SIGN_NAMES:
+            return get_nth_sign_name(idx);
+        case EXP_SIGN_GROUPS:
+            return get_nth_sign_group_name(idx);
+        default:
+            return NULL;
     }
 }
 
@@ -2178,7 +2178,7 @@
     // expand subcmd name
     // :sign {subcmd}<CTRL-D>
     if (*end_subcmd == NUL)
-	return;
+        return;
 
     cmd_idx = sign_cmd_idx(arg, end_subcmd);
 
@@ -2197,9 +2197,9 @@
     p = begin_subcmd_args;
     do
     {
-	p = skipwhite(p);
-	last = p;
-	p = skiptowhite(p);
+        p = skipwhite(p);
+        last = p;
+        p = skiptowhite(p);
     }
     while (*p != NUL);
 
@@ -2210,75 +2210,75 @@
     //                            last     p
     if (p == NULL)
     {
-	// Expand last argument name (before equal sign).
-	xp->xp_pattern = last;
-	switch (cmd_idx)
-	{
-	    case SIGNCMD_DEFINE:
-		expand_what = EXP_DEFINE;
-		break;
-	    case SIGNCMD_PLACE:
-		// List placed signs
-		if (VIM_ISDIGIT(*begin_subcmd_args))
-		    //   :sign place {id} {args}...
-		    expand_what = EXP_PLACE;
-		else
-		    //   :sign place {args}...
-		    expand_what = EXP_LIST;
-		break;
-	    case SIGNCMD_LIST:
-	    case SIGNCMD_UNDEFINE:
-		// :sign list <CTRL-D>
-		// :sign undefine <CTRL-D>
-		expand_what = EXP_SIGN_NAMES;
-		break;
-	    case SIGNCMD_JUMP:
-	    case SIGNCMD_UNPLACE:
-		expand_what = EXP_UNPLACE;
-		break;
-	    default:
-		xp->xp_context = EXPAND_NOTHING;
-	}
+        // Expand last argument name (before equal sign).
+        xp->xp_pattern = last;
+        switch (cmd_idx)
+        {
+            case SIGNCMD_DEFINE:
+                expand_what = EXP_DEFINE;
+                break;
+            case SIGNCMD_PLACE:
+                // List placed signs
+                if (VIM_ISDIGIT(*begin_subcmd_args))
+                    //   :sign place {id} {args}...
+                    expand_what = EXP_PLACE;
+                else
+                    //   :sign place {args}...
+                    expand_what = EXP_LIST;
+                break;
+            case SIGNCMD_LIST:
+            case SIGNCMD_UNDEFINE:
+                // :sign list <CTRL-D>
+                // :sign undefine <CTRL-D>
+                expand_what = EXP_SIGN_NAMES;
+                break;
+            case SIGNCMD_JUMP:
+            case SIGNCMD_UNPLACE:
+                expand_what = EXP_UNPLACE;
+                break;
+            default:
+                xp->xp_context = EXPAND_NOTHING;
+        }
     }
     else
     {
-	// Expand last argument value (after equal sign).
-	xp->xp_pattern = p + 1;
-	switch (cmd_idx)
-	{
-	    case SIGNCMD_DEFINE:
-		if (STRNCMP(last, "texthl", 6) == 0 ||
-		    STRNCMP(last, "linehl", 6) == 0 ||
-		    STRNCMP(last, "culhl", 5) == 0 ||
-		    STRNCMP(last, "numhl", 5) == 0)
-		    xp->xp_context = EXPAND_HIGHLIGHT;
-		else if (STRNCMP(last, "icon", 4) == 0)
-		    xp->xp_context = EXPAND_FILES;
-		else
-		    xp->xp_context = EXPAND_NOTHING;
-		break;
-	    case SIGNCMD_PLACE:
-		if (STRNCMP(last, "name", 4) == 0)
-		    expand_what = EXP_SIGN_NAMES;
-		else if (STRNCMP(last, "group", 5) == 0)
-		    expand_what = EXP_SIGN_GROUPS;
-		else if (STRNCMP(last, "file", 4) == 0)
-		    xp->xp_context = EXPAND_BUFFERS;
-		else
-		    xp->xp_context = EXPAND_NOTHING;
-		break;
-	    case SIGNCMD_UNPLACE:
-	    case SIGNCMD_JUMP:
-		if (STRNCMP(last, "group", 5) == 0)
-		    expand_what = EXP_SIGN_GROUPS;
-		else if (STRNCMP(last, "file", 4) == 0)
-		    xp->xp_context = EXPAND_BUFFERS;
-		else
-		    xp->xp_context = EXPAND_NOTHING;
-		break;
-	    default:
-		xp->xp_context = EXPAND_NOTHING;
-	}
+        // Expand last argument value (after equal sign).
+        xp->xp_pattern = p + 1;
+        switch (cmd_idx)
+        {
+            case SIGNCMD_DEFINE:
+                if (STRNCMP(last, "texthl", 6) == 0 ||
+                    STRNCMP(last, "linehl", 6) == 0 ||
+                    STRNCMP(last, "culhl", 5) == 0 ||
+                    STRNCMP(last, "numhl", 5) == 0)
+                    xp->xp_context = EXPAND_HIGHLIGHT;
+                else if (STRNCMP(last, "icon", 4) == 0)
+                    xp->xp_context = EXPAND_FILES;
+                else
+                    xp->xp_context = EXPAND_NOTHING;
+                break;
+            case SIGNCMD_PLACE:
+                if (STRNCMP(last, "name", 4) == 0)
+                    expand_what = EXP_SIGN_NAMES;
+                else if (STRNCMP(last, "group", 5) == 0)
+                    expand_what = EXP_SIGN_GROUPS;
+                else if (STRNCMP(last, "file", 4) == 0)
+                    xp->xp_context = EXPAND_BUFFERS;
+                else
+                    xp->xp_context = EXPAND_NOTHING;
+                break;
+            case SIGNCMD_UNPLACE:
+            case SIGNCMD_JUMP:
+                if (STRNCMP(last, "group", 5) == 0)
+                    expand_what = EXP_SIGN_GROUPS;
+                else if (STRNCMP(last, "file", 4) == 0)
+                    xp->xp_context = EXPAND_BUFFERS;
+                else
+                    xp->xp_context = EXPAND_NOTHING;
+                break;
+            default:
+                xp->xp_context = EXPAND_NOTHING;
+        }
     }
 }
 
@@ -2300,30 +2300,30 @@
     int retval = -1;
 
     if (name_arg == NULL && dict == NULL)
-	return retval;
+        return retval;
 
     if (name_arg == NULL)
-	name = dict_get_string(dict, "name", TRUE);
+        name = dict_get_string(dict, "name", TRUE);
     else
-	name = vim_strsave(name_arg);
+        name = vim_strsave(name_arg);
 
     if (name == NULL || name[0] == NUL)
-	goto cleanup;
+        goto cleanup;
 
     if (dict != NULL)
     {
-	icon = dict_get_string(dict, "icon", TRUE);
-	linehl = dict_get_string(dict, "linehl", TRUE);
-	text = dict_get_string(dict, "text", TRUE);
-	texthl = dict_get_string(dict, "texthl", TRUE);
-	culhl = dict_get_string(dict, "culhl", TRUE);
-	numhl = dict_get_string(dict, "numhl", TRUE);
-	prio = dict_get_number_def(dict, "priority", -1);
+        icon = dict_get_string(dict, "icon", TRUE);
+        linehl = dict_get_string(dict, "linehl", TRUE);
+        text = dict_get_string(dict, "text", TRUE);
+        texthl = dict_get_string(dict, "texthl", TRUE);
+        culhl = dict_get_string(dict, "culhl", TRUE);
+        numhl = dict_get_string(dict, "numhl", TRUE);
+        prio = dict_get_number_def(dict, "priority", -1);
     }
 
     if (sign_define_by_name(name, icon, linehl, text, texthl, culhl, numhl,
-			    prio) == OK)
-	retval = 0;
+                            prio) == OK)
+        retval = 0;
 
 cleanup:
     vim_free(name);
@@ -2347,14 +2347,14 @@
     listitem_T *li = NULL;
     FOR_ALL_LIST_ITEMS(l, li)
     {
-	int retval = -1;
+        int retval = -1;
 
-	if (li->li_tv.v_type == VAR_DICT)
-	    retval = sign_define_from_dict(NULL, li->li_tv.vval.v_dict);
-	else
-	    emsg(_(e_dictionary_required));
+        if (li->li_tv.v_type == VAR_DICT)
+            retval = sign_define_from_dict(NULL, li->li_tv.vval.v_dict);
+        else
+            emsg(_(e_dictionary_required));
 
-	list_append_number(retlist, retval);
+        list_append_number(retlist, retval);
     }
 }
 
@@ -2365,17 +2365,17 @@
 f_sign_define(typval_T *argvars, typval_T *rettv)
 {
     if (in_vim9script() && (check_for_string_or_list_arg(argvars, 0) == FAIL ||
-			    check_for_opt_dict_arg(argvars, 1) == FAIL))
-	return;
+                            check_for_opt_dict_arg(argvars, 1) == FAIL))
+        return;
 
     if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_UNKNOWN)
     {
-	// Define multiple signs
-	if (rettv_list_alloc(rettv) == FAIL)
-	    return;
+        // Define multiple signs
+        if (rettv_list_alloc(rettv) == FAIL)
+            return;
 
-	sign_define_multiple(argvars[0].vval.v_list, rettv->vval.v_list);
-	return;
+        sign_define_multiple(argvars[0].vval.v_list, rettv->vval.v_list);
+        return;
     }
 
     // Define a single sign
@@ -2383,13 +2383,13 @@
 
     char_u *name = tv_get_string_chk(&argvars[0]);
     if (name == NULL)
-	return;
+        return;
 
     if (check_for_opt_dict_arg(argvars, 1) == FAIL)
-	return;
+        return;
 
     rettv->vval.v_number = sign_define_from_dict(
-	name, argvars[1].v_type == VAR_DICT ? argvars[1].vval.v_dict : NULL);
+        name, argvars[1].v_type == VAR_DICT ? argvars[1].vval.v_dict : NULL);
 }
 
 /*
@@ -2399,14 +2399,14 @@
 f_sign_getdefined(typval_T *argvars, typval_T *rettv)
 {
     if (rettv_list_alloc_id(rettv, aid_sign_getdefined) == FAIL)
-	return;
+        return;
 
     if (in_vim9script() && check_for_opt_string_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     char_u *name = NULL;
     if (argvars[0].v_type != VAR_UNKNOWN)
-	name = tv_get_string(&argvars[0]);
+        name = tv_get_string(&argvars[0]);
 
     sign_getlist(name, rettv->vval.v_list);
 }
@@ -2423,58 +2423,58 @@
     char_u *group = NULL;
 
     if (rettv_list_alloc_id(rettv, aid_sign_getplaced) == FAIL)
-	return;
+        return;
 
     if (in_vim9script() && (check_for_opt_buffer_arg(argvars, 0) == FAIL ||
-			    (argvars[0].v_type != VAR_UNKNOWN &&
-			     check_for_opt_dict_arg(argvars, 1) == FAIL)))
-	return;
+                            (argvars[0].v_type != VAR_UNKNOWN &&
+                             check_for_opt_dict_arg(argvars, 1) == FAIL)))
+        return;
 
     if (argvars[0].v_type != VAR_UNKNOWN)
     {
-	// get signs placed in the specified buffer
-	buf = get_buf_arg(&argvars[0]);
-	if (buf == NULL)
-	    return;
+        // get signs placed in the specified buffer
+        buf = get_buf_arg(&argvars[0]);
+        if (buf == NULL)
+            return;
 
-	if (argvars[1].v_type != VAR_UNKNOWN)
-	{
-	    if (check_for_nonnull_dict_arg(argvars, 1) == FAIL)
-		return;
+        if (argvars[1].v_type != VAR_UNKNOWN)
+        {
+            if (check_for_nonnull_dict_arg(argvars, 1) == FAIL)
+                return;
 
-	    dictitem_T *di = NULL;
-	    dict_T *dict = argvars[1].vval.v_dict;
+            dictitem_T *di = NULL;
+            dict_T *dict = argvars[1].vval.v_dict;
 
-	    if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
-	    {
-		// get signs placed at this line
-		int notanum = FALSE;
-		tv_get_number_chk(&di->di_tv, &notanum);
-		if (notanum)
-		    return;
+            if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
+            {
+                // get signs placed at this line
+                int notanum = FALSE;
+                tv_get_number_chk(&di->di_tv, &notanum);
+                if (notanum)
+                    return;
 
-		lnum = tv_get_lnum(&di->di_tv);
-	    }
+                lnum = tv_get_lnum(&di->di_tv);
+            }
 
-	    if ((di = dict_find(dict, (char_u *)"id", -1)) != NULL)
-	    {
-		// get sign placed with this identifier
-		int notanum = FALSE;
-		sign_id = (int)tv_get_number_chk(&di->di_tv, &notanum);
-		if (notanum)
-		    return;
-	    }
+            if ((di = dict_find(dict, (char_u *)"id", -1)) != NULL)
+            {
+                // get sign placed with this identifier
+                int notanum = FALSE;
+                sign_id = (int)tv_get_number_chk(&di->di_tv, &notanum);
+                if (notanum)
+                    return;
+            }
 
-	    if ((di = dict_find(dict, (char_u *)"group", -1)) != NULL)
-	    {
-		group = tv_get_string_chk(&di->di_tv);
-		if (group == NULL)
-		    return;
+            if ((di = dict_find(dict, (char_u *)"group", -1)) != NULL)
+            {
+                group = tv_get_string_chk(&di->di_tv);
+                if (group == NULL)
+                    return;
 
-		if (*group == '\0') // empty string means global group
-		    group = NULL;
-	    }
-	}
+                if (*group == '\0') // empty string means global group
+                    group = NULL;
+            }
+        }
     }
 
     sign_get_placed(buf, lnum, sign_id, group, rettv->vval.v_list);
@@ -2490,42 +2490,42 @@
     rettv->vval.v_number = -1;
 
     if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL ||
-			    check_for_string_arg(argvars, 1) == FAIL ||
-			    check_for_buffer_arg(argvars, 2) == FAIL))
-	return;
+                            check_for_string_arg(argvars, 1) == FAIL ||
+                            check_for_buffer_arg(argvars, 2) == FAIL))
+        return;
 
     int notanum = FALSE;
     // Sign identifier
     int sign_id = (int)tv_get_number_chk(&argvars[0], &notanum);
     if (notanum)
-	return;
+        return;
 
     if (sign_id <= 0)
     {
-	emsg(_(e_invalid_argument));
-	return;
+        emsg(_(e_invalid_argument));
+        return;
     }
 
     // Sign group
     sign_group = tv_get_string_chk(&argvars[1]);
     if (sign_group == NULL)
-	return;
+        return;
 
     if (sign_group[0] == '\0')
     {
-	sign_group = NULL; // global sign group
+        sign_group = NULL; // global sign group
     }
     else
     {
-	sign_group = vim_strsave(sign_group);
-	if (sign_group == NULL)
-	    return;
+        sign_group = vim_strsave(sign_group);
+        if (sign_group == NULL)
+            return;
     }
 
     // Buffer to place the sign
     buf_T *buf = get_buf_arg(&argvars[2]);
     if (buf == NULL)
-	goto cleanup;
+        goto cleanup;
 
     rettv->vval.v_number = sign_jump(sign_id, sign_group, buf);
 
@@ -2539,10 +2539,10 @@
  */
 static int
 sign_place_from_dict(typval_T *id_tv,
-		     typval_T *group_tv,
-		     typval_T *name_tv,
-		     typval_T *buf_tv,
-		     dict_T *dict)
+                     typval_T *group_tv,
+                     typval_T *name_tv,
+                     typval_T *buf_tv,
+                     dict_T *dict)
 {
     int sign_id = 0;
     char_u *group = NULL;
@@ -2556,114 +2556,114 @@
     // sign identifier
     if (id_tv == NULL)
     {
-	di = dict_find(dict, (char_u *)"id", -1);
-	if (di != NULL)
-	    id_tv = &di->di_tv;
+        di = dict_find(dict, (char_u *)"id", -1);
+        if (di != NULL)
+            id_tv = &di->di_tv;
     }
 
     if (id_tv == NULL)
     {
-	sign_id = 0;
+        sign_id = 0;
     }
     else
     {
-	int notanum = FALSE;
-	sign_id = tv_get_number_chk(id_tv, &notanum);
+        int notanum = FALSE;
+        sign_id = tv_get_number_chk(id_tv, &notanum);
 
-	if (notanum)
-	    return -1;
+        if (notanum)
+            return -1;
 
-	if (sign_id < 0)
-	{
-	    emsg(_(e_invalid_argument));
-	    return -1;
-	}
+        if (sign_id < 0)
+        {
+            emsg(_(e_invalid_argument));
+            return -1;
+        }
     }
 
     // sign group
     if (group_tv == NULL)
     {
-	di = dict_find(dict, (char_u *)"group", -1);
-	if (di != NULL)
-	    group_tv = &di->di_tv;
+        di = dict_find(dict, (char_u *)"group", -1);
+        if (di != NULL)
+            group_tv = &di->di_tv;
     }
 
     if (group_tv == NULL)
     {
-	group = NULL; // global group
+        group = NULL; // global group
     }
     else
     {
-	group = tv_get_string_chk(group_tv);
-	if (group == NULL)
-	    goto cleanup;
+        group = tv_get_string_chk(group_tv);
+        if (group == NULL)
+            goto cleanup;
 
-	if (group[0] == '\0') // global sign group
-	{
-	    group = NULL;
-	}
-	else
-	{
-	    group = vim_strsave(group);
-	    if (group == NULL)
-		return -1;
-	}
+        if (group[0] == '\0') // global sign group
+        {
+            group = NULL;
+        }
+        else
+        {
+            group = vim_strsave(group);
+            if (group == NULL)
+                return -1;
+        }
     }
 
     // sign name
     if (name_tv == NULL)
     {
-	di = dict_find(dict, (char_u *)"name", -1);
-	if (di != NULL)
-	    name_tv = &di->di_tv;
+        di = dict_find(dict, (char_u *)"name", -1);
+        if (di != NULL)
+            name_tv = &di->di_tv;
     }
 
     if (name_tv == NULL)
-	goto cleanup;
+        goto cleanup;
 
     sign_name = tv_get_string_chk(name_tv);
     if (sign_name == NULL)
-	goto cleanup;
+        goto cleanup;
 
     // buffer to place the sign
     if (buf_tv == NULL)
     {
-	di = dict_find(dict, (char_u *)"buffer", -1);
-	if (di != NULL)
-	    buf_tv = &di->di_tv;
+        di = dict_find(dict, (char_u *)"buffer", -1);
+        if (di != NULL)
+            buf_tv = &di->di_tv;
     }
 
     if (buf_tv == NULL)
-	goto cleanup;
+        goto cleanup;
 
     buf = get_buf_arg(buf_tv);
     if (buf == NULL)
-	goto cleanup;
+        goto cleanup;
 
     // line number of the sign
     di = dict_find(dict, (char_u *)"lnum", -1);
     if (di != NULL)
     {
-	lnum = tv_get_lnum(&di->di_tv);
-	if (lnum <= 0)
-	{
-	    emsg(_(e_invalid_argument));
-	    goto cleanup;
-	}
+        lnum = tv_get_lnum(&di->di_tv);
+        if (lnum <= 0)
+        {
+            emsg(_(e_invalid_argument));
+            goto cleanup;
+        }
     }
 
     // sign priority
     di = dict_find(dict, (char_u *)"priority", -1);
     if (di != NULL)
     {
-	int notanum = FALSE;
-	prio = (int)tv_get_number_chk(&di->di_tv, &notanum);
-	if (notanum)
-	    goto cleanup;
+        int notanum = FALSE;
+        prio = (int)tv_get_number_chk(&di->di_tv, &notanum);
+        if (notanum)
+            goto cleanup;
     }
 
     if (sign_place(&sign_id, group, sign_name, buf, lnum, prio) == OK)
-	ret_sign_id = sign_id;
+        ret_sign_id = sign_id;
 
 cleanup:
     vim_free(group);
@@ -2681,21 +2681,21 @@
     rettv->vval.v_number = -1;
 
     if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL ||
-			    check_for_string_arg(argvars, 1) == FAIL ||
-			    check_for_string_arg(argvars, 2) == FAIL ||
-			    check_for_buffer_arg(argvars, 3) == FAIL ||
-			    check_for_opt_dict_arg(argvars, 4) == FAIL))
-	return;
+                            check_for_string_arg(argvars, 1) == FAIL ||
+                            check_for_string_arg(argvars, 2) == FAIL ||
+                            check_for_buffer_arg(argvars, 3) == FAIL ||
+                            check_for_opt_dict_arg(argvars, 4) == FAIL))
+        return;
 
     if (argvars[4].v_type != VAR_UNKNOWN)
     {
-	if (check_for_nonnull_dict_arg(argvars, 4) == FAIL)
-	    return;
-	dict = argvars[4].vval.v_dict;
+        if (check_for_nonnull_dict_arg(argvars, 4) == FAIL)
+            return;
+        dict = argvars[4].vval.v_dict;
     }
 
     rettv->vval.v_number = sign_place_from_dict(&argvars[0], &argvars[1],
-						&argvars[2], &argvars[3], dict);
+                                                &argvars[2], &argvars[3], dict);
 }
 
 /*
@@ -2705,27 +2705,27 @@
 f_sign_placelist(typval_T *argvars, typval_T *rettv)
 {
     if (rettv_list_alloc(rettv) == FAIL)
-	return;
+        return;
 
     if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     if (check_for_list_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     // Process the List of sign attributes
     listitem_T *li = NULL;
     FOR_ALL_LIST_ITEMS(argvars[0].vval.v_list, li)
     {
-	int sign_id = -1;
+        int sign_id = -1;
 
-	if (li->li_tv.v_type == VAR_DICT)
-	    sign_id = sign_place_from_dict(NULL, NULL, NULL, NULL,
-					   li->li_tv.vval.v_dict);
-	else
-	    emsg(_(e_dictionary_required));
+        if (li->li_tv.v_type == VAR_DICT)
+            sign_id = sign_place_from_dict(NULL, NULL, NULL, NULL,
+                                           li->li_tv.vval.v_dict);
+        else
+            emsg(_(e_dictionary_required));
 
-	list_append_number(rettv->vval.v_list, sign_id);
+        list_append_number(rettv->vval.v_list, sign_id);
     }
 }
 
@@ -2738,12 +2738,12 @@
     listitem_T *li = NULL;
     FOR_ALL_LIST_ITEMS(l, li)
     {
-	int retval = -1;
-	char_u *name = tv_get_string_chk(&li->li_tv);
-	if (name != NULL && (sign_undefine_by_name(name, TRUE) == OK))
-	    retval = 0;
+        int retval = -1;
+        char_u *name = tv_get_string_chk(&li->li_tv);
+        if (name != NULL && (sign_undefine_by_name(name, TRUE) == OK))
+            retval = 0;
 
-	list_append_number(retlist, retval);
+        list_append_number(retlist, retval);
     }
 }
 
@@ -2755,35 +2755,35 @@
 {
 
     if (in_vim9script() && check_for_opt_string_or_list_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_UNKNOWN)
     {
-	// Undefine multiple signs
-	if (rettv_list_alloc(rettv) == FAIL)
-	    return;
+        // Undefine multiple signs
+        if (rettv_list_alloc(rettv) == FAIL)
+            return;
 
-	sign_undefine_multiple(argvars[0].vval.v_list, rettv->vval.v_list);
-	return;
+        sign_undefine_multiple(argvars[0].vval.v_list, rettv->vval.v_list);
+        return;
     }
 
     rettv->vval.v_number = -1;
 
     if (argvars[0].v_type == VAR_UNKNOWN)
     {
-	// Free all the signs
-	free_signs();
-	rettv->vval.v_number = 0;
+        // Free all the signs
+        free_signs();
+        rettv->vval.v_number = 0;
     }
     else
     {
-	// Free only the specified sign
-	char_u *name = tv_get_string_chk(&argvars[0]);
-	if (name == NULL)
-	    return;
+        // Free only the specified sign
+        char_u *name = tv_get_string_chk(&argvars[0]);
+        if (name == NULL)
+            return;
 
-	if (sign_undefine_by_name(name, TRUE) == OK)
-	    rettv->vval.v_number = 0;
+        if (sign_undefine_by_name(name, TRUE) == OK)
+            rettv->vval.v_number = 0;
     }
 }
 
@@ -2801,53 +2801,53 @@
 
     // sign group
     group = (group_tv != NULL) ? tv_get_string(group_tv)
-			       : dict_get_string(dict, "group", FALSE);
+                               : dict_get_string(dict, "group", FALSE);
 
     if (group != NULL)
     {
-	if (group[0] == '\0') // global sign group
-	{
-	    group = NULL;
-	}
-	else
-	{
-	    group = vim_strsave(group);
-	    if (group == NULL)
-		return retval;
-	}
+        if (group[0] == '\0') // global sign group
+        {
+            group = NULL;
+        }
+        else
+        {
+            group = vim_strsave(group);
+            if (group == NULL)
+                return retval;
+        }
     }
 
     if (dict != NULL)
     {
-	dictitem_T *di = dict_find(dict, (char_u *)"buffer", -1);
-	if (di != NULL)
-	{
-	    buf = get_buf_arg(&di->di_tv);
-	    if (buf == NULL)
-		goto cleanup;
-	}
+        dictitem_T *di = dict_find(dict, (char_u *)"buffer", -1);
+        if (di != NULL)
+        {
+            buf = get_buf_arg(&di->di_tv);
+            if (buf == NULL)
+                goto cleanup;
+        }
 
-	if (dict_has_key(dict, "id"))
-	{
-	    sign_id = dict_get_number(dict, "id");
-	    if (sign_id <= 0)
-	    {
-		emsg(_(e_invalid_argument));
-		goto cleanup;
-	    }
-	}
+        if (dict_has_key(dict, "id"))
+        {
+            sign_id = dict_get_number(dict, "id");
+            if (sign_id <= 0)
+            {
+                emsg(_(e_invalid_argument));
+                goto cleanup;
+            }
+        }
     }
 
     if (buf == NULL)
     {
-	// Delete the sign in all the buffers
-	retval = 0;
-	FOR_ALL_BUFFERS(buf)
-	    if (sign_unplace(sign_id, group, buf, 0) != OK)
-		retval = -1;
+        // Delete the sign in all the buffers
+        retval = 0;
+        FOR_ALL_BUFFERS(buf)
+            if (sign_unplace(sign_id, group, buf, 0) != OK)
+                retval = -1;
     }
     else if (sign_unplace(sign_id, group, buf, 0) == OK)
-	retval = 0;
+        retval = 0;
 
 cleanup:
     vim_free(group);
@@ -2862,7 +2862,7 @@
 
 # ifdef FEAT_PROP_POPUP
     while (sign != NULL && !sign_group_for_window(sign, wp))
-	sign = sign->se_next;
+        sign = sign->se_next;
 # endif
     return sign;
 }
@@ -2877,17 +2877,17 @@
     // column (if present). Otherwise signs are to be displayed in the sign
     // column.
     if (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u')
-	return get_first_valid_sign(wp) != NULL && !wp->w_p_nu && !wp->w_p_rnu;
+        return get_first_valid_sign(wp) != NULL && !wp->w_p_nu && !wp->w_p_rnu;
 
     if (*wp->w_p_scl == 'n')
-	return FALSE;
+        return FALSE;
 
     if (*wp->w_p_scl == 'y')
-	return TRUE;
+        return TRUE;
 
     return (get_first_valid_sign(wp) != NULL
 # ifdef FEAT_NETBEANS_INTG
-	    || wp->w_buffer->b_has_sign_column
+            || wp->w_buffer->b_has_sign_column
 # endif
     );
 }
@@ -2902,11 +2902,11 @@
     rettv->vval.v_number = -1;
 
     if ((check_for_string_arg(argvars, 0) == FAIL ||
-	 check_for_opt_dict_arg(argvars, 1) == FAIL))
-	return;
+         check_for_opt_dict_arg(argvars, 1) == FAIL))
+        return;
 
     if (argvars[1].v_type != VAR_UNKNOWN)
-	dict = argvars[1].vval.v_dict;
+        dict = argvars[1].vval.v_dict;
 
     rettv->vval.v_number = sign_unplace_from_dict(&argvars[0], dict);
 }
@@ -2918,25 +2918,25 @@
 f_sign_unplacelist(typval_T *argvars, typval_T *rettv)
 {
     if (rettv_list_alloc(rettv) == FAIL)
-	return;
+        return;
 
     if (in_vim9script() && check_for_list_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     if (check_for_list_arg(argvars, 0) == FAIL)
-	return;
+        return;
 
     listitem_T *li = NULL;
     FOR_ALL_LIST_ITEMS(argvars[0].vval.v_list, li)
     {
-	int retval = -1;
+        int retval = -1;
 
-	if (li->li_tv.v_type == VAR_DICT)
-	    retval = sign_unplace_from_dict(NULL, li->li_tv.vval.v_dict);
-	else
-	    emsg(_(e_dictionary_required));
+        if (li->li_tv.v_type == VAR_DICT)
+            retval = sign_unplace_from_dict(NULL, li->li_tv.vval.v_dict);
+        else
+            emsg(_(e_dictionary_required));
 
-	list_append_number(rettv->vval.v_list, retval);
+        list_append_number(rettv->vval.v_list, retval);
     }
 }