diff --git a/src/syntax.c b/src/syntax.c
index b4d3afc..da5dfa1 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -2750,7 +2750,7 @@
 {
     if (ga_grow(&current_state, 1) == FAIL)
 	return FAIL;
-    vim_memset(&CUR_STATE(current_state.ga_len), 0, sizeof(stateitem_T));
+    CLEAR_POINTER(&CUR_STATE(current_state.ga_len));
     CUR_STATE(current_state.ga_len).si_idx = idx;
     ++current_state.ga_len;
     return OK;
@@ -4908,7 +4908,7 @@
 
     // get the pattern.
     init_syn_patterns();
-    vim_memset(&item, 0, sizeof(item));
+    CLEAR_FIELD(item);
     rest = get_syn_pattern(rest, &item);
     if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL))
 	syn_opt_arg.flags |= HL_HAS_EOL;
@@ -5481,7 +5481,7 @@
 	return 0;
     }
 
-    vim_memset(&(SYN_CLSTR(curwin->w_s)[len]), 0, sizeof(syn_cluster_T));
+    CLEAR_POINTER(&(SYN_CLSTR(curwin->w_s)[len]));
     SYN_CLSTR(curwin->w_s)[len].scl_name = name;
     SYN_CLSTR(curwin->w_s)[len].scl_name_u = vim_strsave_up(name);
     SYN_CLSTR(curwin->w_s)[len].scl_list = NULL;
