diff --git a/src/edit.c b/src/edit.c
index e5f6b33..87fd569 100644
--- a/src/edit.c
+++ b/src/edit.c
@@ -1476,7 +1476,7 @@
 		    ||
 # endif
 # ifdef FEAT_CONCEAL
-		    curwin->w_p_conceal
+		    curwin->w_p_conc > 0
 # endif
 		    )
 	    && !equalpos(last_cursormoved, curwin->w_cursor)
@@ -1498,7 +1498,7 @@
 		apply_autocmds(EVENT_CURSORMOVEDI, NULL, NULL, FALSE, curbuf);
 # endif
 # ifdef FEAT_CONCEAL
-	    if (curwin->w_p_conceal)
+	    if (curwin->w_p_conc > 0)
 	    {
 		conceal_old_cursor_line = last_cursormoved.lnum;
 		conceal_new_cursor_line = curwin->w_cursor.lnum;
diff --git a/src/gui.c b/src/gui.c
index 6899992..c899323 100644
--- a/src/gui.c
+++ b/src/gui.c
@@ -4922,7 +4922,7 @@
 		||
 # endif
 # ifdef FEAT_CONCEAL
-		curwin->w_p_conceal
+		curwin->w_p_conc > 0
 # endif
 		)
 		     && !equalpos(last_cursormoved, curwin->w_cursor))
@@ -4932,7 +4932,7 @@
 	    apply_autocmds(EVENT_CURSORMOVED, NULL, NULL, FALSE, curbuf);
 # endif
 # ifdef FEAT_CONCEAL
-	if (curwin->w_p_conceal)
+	if (curwin->w_p_conc > 0)
 	{
 	    conceal_old_cursor_line = last_cursormoved.lnum;
 	    conceal_new_cursor_line = curwin->w_cursor.lnum;
diff --git a/src/main.c b/src/main.c
index cce99cd..029b64c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1098,7 +1098,7 @@
 			||
 # endif
 # ifdef FEAT_CONCEAL
-			curwin->w_p_conceal
+			curwin->w_p_conc > 0
 # endif
 			)
 		 && !equalpos(last_cursormoved, curwin->w_cursor))
@@ -1109,7 +1109,7 @@
 							       FALSE, curbuf);
 # endif
 # ifdef FEAT_CONCEAL
-		if (curwin->w_p_conceal)
+		if (curwin->w_p_conc > 0)
 		{
 		    conceal_old_cursor_line = last_cursormoved.lnum;
 		    conceal_new_cursor_line = curwin->w_cursor.lnum;
diff --git a/src/normal.c b/src/normal.c
index 0559167..4d2f4c6 100644
--- a/src/normal.c
+++ b/src/normal.c
@@ -8296,7 +8296,7 @@
 		    0, 0))
 	{
 #ifdef FEAT_CONCEAL
-	    if (curwin->w_p_conceal && oldline != curwin->w_cursor.lnum)
+	    if (curwin->w_p_conc > 0 && oldline != curwin->w_cursor.lnum)
 		update_single_line(curwin, oldline);
 #endif
 	    /* When '#' is in 'cpoptions' ignore the count. */
diff --git a/src/option.c b/src/option.c
index 80eb942..27a82fd 100644
--- a/src/option.c
+++ b/src/option.c
@@ -7442,7 +7442,7 @@
 	redraw_titles();
 # endif
 # ifdef FEAT_CONCEAL
-	if (curwin->w_p_conceal)
+	if (curwin->w_p_conc > 0)
 	    update_single_line(curwin, curwin->w_cursor.lnum);
 # endif
     }
@@ -8232,17 +8232,17 @@
 	    ml_open_files();
     }
 #ifdef FEAT_CONCEAL
-    else if (pp == &curwin->w_p_conceal)
+    else if (pp == &curwin->w_p_conc)
     {
-	if (curwin->w_p_conceal < 0)
+	if (curwin->w_p_conc < 0)
 	{
 	    errmsg = e_positive;
-	    curwin->w_p_conceal = 0;
+	    curwin->w_p_conc = 0;
 	}
-	else if (curwin->w_p_conceal > 3)
+	else if (curwin->w_p_conc > 3)
 	{
 	    errmsg = e_invarg;
-	    curwin->w_p_conceal = 3;
+	    curwin->w_p_conc = 3;
 	}
     }
 #endif
@@ -9506,7 +9506,7 @@
 	case PV_CRBIND: return (char_u *)&(curwin->w_p_crb);
 #endif
 #ifdef FEAT_CONCEAL
-	case PV_CONCEAL:    return (char_u *)&(curwin->w_p_conceal);
+	case PV_CONCEAL:    return (char_u *)&(curwin->w_p_conc);
 #endif
 
 	case PV_AI:	return (char_u *)&(curbuf->b_p_ai);
diff --git a/src/screen.c b/src/screen.c
index 508e627..7d6985a 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -2776,7 +2776,7 @@
 #ifdef FEAT_CONCEAL
     int		syntax_flags	= 0;
     int		conceal_attr	= hl_attr(HLF_CONCEAL);
-    int		first_conceal	= (wp->w_p_conceal != 3);
+    int		first_conceal	= (wp->w_p_conc != 3);
     int		is_concealing	= FALSE;
     int		boguscols	= 0;	/* nonexistent columns added to force
 					   wrapping */
@@ -4377,7 +4377,7 @@
 	    }
 
 #ifdef FEAT_CONCEAL
-	    if (    wp->w_p_conceal
+	    if (    wp->w_p_conc > 0
 		    && !area_highlighting
 		    && (lnum != wp->w_cursor.lnum
 			|| curwin != wp || wp->w_buffer->b_p_ma == FALSE)
@@ -4386,7 +4386,7 @@
 	    {
 		char_attr = conceal_attr;
 		if (first_conceal
-			&& (syn_get_sub_char() != NUL || wp->w_p_conceal == 1))
+			&& (syn_get_sub_char() != NUL || wp->w_p_conc == 1))
 		{
 		    if (syn_get_sub_char() != NUL)
 			c = syn_get_sub_char();
@@ -4437,8 +4437,8 @@
 	    }
 	    else
 	    {
-		first_conceal	= (wp->w_p_conceal != 3);
-		is_concealing	= FALSE;
+		first_conceal = (wp->w_p_conc != 3);
+		is_concealing = FALSE;
 	    }
 #endif /* FEAT_CONCEAL */
 	}
@@ -4909,7 +4909,7 @@
 	    }
 	}
 #ifdef FEAT_CONCEAL
-	else if (wp->w_p_conceal > 0 && is_concealing)
+	else if (wp->w_p_conc > 0 && is_concealing)
 	{
 	    --n_skip;
 	    ++vcol_off;
diff --git a/src/structs.h b/src/structs.h
index e0f9f3b..ebcc3cf 100644
--- a/src/structs.h
+++ b/src/structs.h
@@ -216,8 +216,8 @@
     int		wo_wrap;
 #define w_p_wrap w_onebuf_opt.wo_wrap	/* 'wrap' */
 #ifdef FEAT_CONCEAL
-    long	wo_conceal;		/* 'conceal' */
-# define w_p_conceal w_onebuf_opt.wo_conceal
+    long	wo_conc;		/* 'conceal' */
+# define w_p_conc w_onebuf_opt.wo_conc
 #endif
 #ifdef FEAT_CURSORBIND
     int		wo_crb;
diff --git a/src/undo.c b/src/undo.c
index 7abd67b..5ebf0e7 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -2710,7 +2710,7 @@
 
 	FOR_ALL_WINDOWS(wp)
 	{
-	    if (wp->w_buffer == curbuf && wp->w_p_conceal)
+	    if (wp->w_buffer == curbuf && wp->w_p_conc > 0)
 		redraw_win_later(wp, NOT_VALID);
 	}
     }
