diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt
index 0a5bc94..c5f4cb4 100644
--- a/runtime/doc/change.txt
+++ b/runtime/doc/change.txt
@@ -1,4 +1,4 @@
-*change.txt*    For Vim version 7.4.  Last change: 2015 Jan 27
+*change.txt*    For Vim version 7.4.  Last change: 2015 Feb 10
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1192,12 +1192,14 @@
 7. Expression register "=			*quote_=* *quote=* *@=*
 This is not really a register that stores text, but is a way to use an
 expression in commands which use a register.  The expression register is
-read-only; you cannot put text into it.  After the '=', the cursor moves to
-the command-line, where you can enter any expression (see |expression|).  All
-normal command-line editing commands are available, including a special
-history for expressions.  When you end the command-line by typing <CR>, Vim
-computes the result of the expression.  If you end it with <Esc>, Vim abandons
-the expression.  If you do not enter an expression, Vim uses the previous
+read-write.
+
+When typing the '=' after " or CTRL-R the cursor moves to the command-line,
+where you can enter any expression (see |expression|).  All normal
+command-line editing commands are available, including a special history for
+expressions.  When you end the command-line by typing <CR>, Vim computes the
+result of the expression.  If you end it with <Esc>, Vim abandons the
+expression.  If you do not enter an expression, Vim uses the previous
 expression (like with the "/" command).
 
 The expression must evaluate to a String.  A Number is always automatically
@@ -1242,7 +1244,7 @@
 It is writable with `:let`, you can change it to have 'hlsearch' highlight
 other matches without actually searching.  You can't yank or delete into this
 register.  The search direction is available in |v:searchforward|.
-Note that the valued is restored when returning from a function
+Note that the value is restored when returning from a function
 |function-search-undo|.
 {not in Vi}
 
@@ -1457,10 +1459,10 @@
 for the new line: " * ".  To close this comment you just have to type "/"
 before typing anything else on the new line.  This will replace the
 middle-comment leader with the end-comment leader and apply any specified
-alignment, leaving just " */".  There is no need to hit BackSpace first.
+alignment, leaving just " */".  There is no need to hit Backspace first.
 
-When there is a match with a middle part, but there also is a maching end part
-which is longer, the end part is used.  This makes a C style comment work
+When there is a match with a middle part, but there also is a matching end
+part which is longer, the end part is used.  This makes a C style comment work
 without requiring the middle part to end with a space.
 
 Here is an example of alignment flags at work to make a comment stand out
diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt
index 4b8e536..816d45f 100644
--- a/runtime/doc/editing.txt
+++ b/runtime/doc/editing.txt
@@ -1,4 +1,4 @@
-*editing.txt*   For Vim version 7.4.  Last change: 2015 Jan 04
+*editing.txt*   For Vim version 7.4.  Last change: 2015 Feb 27
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -304,7 +304,8 @@
 			Mnemonic: "goto file".
 			Uses the 'isfname' option to find out which characters
 			are supposed to be in a file name.  Trailing
-			punctuation characters ".,:;!" are ignored.
+			punctuation characters ".,:;!" are ignored. Escaped
+			spaces "\ " are reduced to a single space.
 			Uses the 'path' option as a list of directory names to
 			look for the file.  See the 'path' option for details
 			about relative directories and wildcards.
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 2c39532..e9a5dc9 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 7.4.  Last change: 2015 Jan 29
+*eval.txt*	For Vim version 7.4.  Last change: 2015 Feb 10
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -3314,7 +3314,7 @@
 			:  endwhile
 			:endfunction
 <
-		You may also receive syntetic characters, such as
+		You may also receive synthetic characters, such as
 		|<CursorHold>|. Often you will want to ignore this and get
 		another character: >
 			:function GetKey()
@@ -4828,7 +4828,7 @@
 		Evaluate Python expression {expr} and return its result
 		converted to Vim data structures.
 		Numbers and strings are returned as they are (strings are 
-		copied though, unicode strings are additionally converted to 
+		copied though, Unicode strings are additionally converted to 
 		'encoding').
 		Lists are represented as Vim |List| type.
 		Dictionaries are represented as Vim |Dictionary| type with 
@@ -5567,7 +5567,7 @@
 			:call setwinvar(2, "myvar", "foobar")
 
 sha256({string})						*sha256()*
-		Returns a String with 64 hex charactes, which is the SHA256
+		Returns a String with 64 hex characters, which is the SHA256
 		checksum of {string}.
 		{only available when compiled with the |+cryptv| feature}
 
@@ -8280,7 +8280,7 @@
 							*catch-text*
 NOTE: You should never catch the error message text itself: >
 	:catch /No such variable/
-only works in the english locale, but not when the user has selected
+only works in the English locale, but not when the user has selected
 a different language by the |:language| command.  It is however helpful to
 cite the message text in a comment: >
 	:catch /^Vim(\a\+):E108:/   " No such variable
diff --git a/runtime/doc/if_ruby.txt b/runtime/doc/if_ruby.txt
index 0a32d87..4084181 100644
--- a/runtime/doc/if_ruby.txt
+++ b/runtime/doc/if_ruby.txt
@@ -1,4 +1,4 @@
-*if_ruby.txt*   For Vim version 7.4.  Last change: 2012 Aug 02
+*if_ruby.txt*   For Vim version 7.4.  Last change: 2015 Feb 22
 
 
 		  VIM REFERENCE MANUAL    by Shugo Maeda
@@ -120,9 +120,13 @@
 							*ruby-evaluate*
 VIM::evaluate({expr})
 	Evaluates {expr} using the vim internal expression evaluator (see
-	|expression|).  Returns the expression result as a string.
-	A |List| is turned into a string by joining the items and inserting
-	line breaks.
+	|expression|).  Returns the expression result as:
+	- a Integer if the Vim expression evaluates to a number
+	- a Float if the Vim expression evaluates to a float
+	- a String if the Vim expression evaluates to a string
+	- a Array if the Vim expression evaluates to a Vim list
+	- a Hash if the Vim expression evaluates to a Vim dictionary
+	Dictionaries and lists are recursively expanded.
 
 ==============================================================================
 3. VIM::Buffer objects					*ruby-buffer*
diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index 1e0134d..e8171a9 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1,4 +1,4 @@
-*index.txt*     For Vim version 7.4.  Last change: 2015 Jan 07
+*index.txt*     For Vim version 7.4.  Last change: 2015 Feb 12
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -702,12 +702,16 @@
 |g'|		g'{mark}	1  like |'| but without changing the jumplist
 |g`|		g`{mark}	1  like |`| but without changing the jumplist
 |gstar|		g*		1  like "*", but without using "\<" and "\>"
+|g+|		g+		   go to newer text state N times
+|g,|		g,		1  go to N newer position in change list
+|g-|		g-		   go to older text state N times
 |g0|		g0		1  when 'wrap' off go to leftmost character of
 				   the current line that is on the screen;
 				   when 'wrap' on go to the leftmost character
 				   of the current screen line
 |g8|		g8		   print hex value of bytes used in UTF-8
 				   character under the cursor
+|g;|		g;		1  go to N older position in change list
 |g<|		g<		   display previous command output
 |g?|		g?		2  Rot13 encoding operator
 |g?g?|		g??		2  Rot13 encode current line
@@ -736,6 +740,7 @@
 				   the screen; when 'wrap' on go to the
 				   leftmost non-white character of the current
 				   screen line
+|g_|		g_		1  cursor to the last CHAR N - 1 lines lower
 |ga|		ga		   print ascii value of character under the
 				   cursor
 |gd|		gd		1  go to definition of word under the cursor
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 193e323..39c3270 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 7.4.  Last change: 2015 Jan 27
+*options.txt*	For Vim version 7.4.  Last change: 2015 Feb 17
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -536,11 +536,11 @@
 	vim<{vers}:	version before {vers}
 	vim={vers}:	version {vers}
 	vim>{vers}:	version after {vers}
-{vers} is 600 for Vim 6.0 (hundred times the major version plus minor).
-For example, to use a modeline only for Vim 6.0 and later:
-	/* vim600: set foldmethod=marker: */ ~
-To use a modeline for Vim before version 5.7:
-	/* vim<570: set sw=4: */ ~
+{vers} is 700 for Vim 7.0 (hundred times the major version plus minor).
+For example, to use a modeline only for Vim 7.0:
+	/* vim700: set foldmethod=marker */ ~
+To use a modeline for Vim after version 7.2:
+	/* vim>702: set cole=2: */ ~
 There can be no blanks between "vim" and the ":".
 
 
@@ -1316,8 +1316,9 @@
 	nofile only:	The buffer name is fixed, it is not handled like a
 			file name.  It is not modified in response to a |:cd|
 			command.
-	nofile only:	When using ":e bufname" and already editing "bufname"
-			nothing changes, since there is no file to edit.
+	both:		When using ":e bufname" and already editing "bufname"
+			the buffer is made empty and autocommands are
+			triggered as usual for |:edit|.
 							*E676*
 	"acwrite" implies that the buffer name is not related to a file, like
 	"nofile", but it will be written.  Thus, in contrast to "nofile" and
@@ -2950,8 +2951,8 @@
 	  2. If a <NL> is found and 'fileformats' includes "unix", 'fileformat'
 	     is set to "unix".  Note that when a <NL> is found without a
 	     preceding <CR>, "unix" is preferred over "dos".
-	  3. If 'fileformat' has not yet been set, and if 'fileformats'
-	     includes "mac", 'fileformat' is set to "mac".
+	  3. If 'fileformat' has not yet been set, and if a <CR> is found, and
+	     if 'fileformats' includes "mac", 'fileformat' is set to "mac".
 	     This means that "mac" is only chosen when:
 	      "unix" is not present or no <NL> is found in the file, and
 	      "dos" is not present or no <CR><NL> is found in the file.
diff --git a/runtime/doc/pattern.txt b/runtime/doc/pattern.txt
index 322811b..323f167 100644
--- a/runtime/doc/pattern.txt
+++ b/runtime/doc/pattern.txt
@@ -1,4 +1,4 @@
-*pattern.txt*   For Vim version 7.4.  Last change: 2014 Sep 06
+*pattern.txt*   For Vim version 7.4.  Last change: 2015 Feb 17
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -59,6 +59,8 @@
 
 							*n*
 n			Repeat the latest "/" or "?" [count] times.
+			If the cursor doesn't move the search is repeated with
+			count + 1.
 			|last-pattern| {Vi: no count}
 
 							*N*
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index fdafb67..5587edc 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 7.4.  Last change: 2015 Feb 03
+*syntax.txt*	For Vim version 7.4.  Last change: 2015 Feb 22
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -211,7 +211,8 @@
 A syntax group name doesn't specify any color or attributes itself.
 
 The name for a highlight or syntax group must consist of ASCII letters, digits
-and the underscore.  As a regexp: "[a-zA-Z0-9_]*"
+and the underscore.  As a regexp: "[a-zA-Z0-9_]*".  However, Vim does not give
+an error when using other characters.
 
 To be able to allow each user to pick his favorite set of colors, there must
 be preferred names for highlight groups that are common for many languages.
@@ -4253,7 +4254,7 @@
 for a comment or syncing pattern is restricted to N lines backwards (after
 adding "minlines").  This is useful if you have few things to sync on and a
 slow machine.  Example: >
-   :syntax sync ccomment maxlines=500
+   :syntax sync maxlines=500 ccomment
 <
 						*:syn-sync-linebreaks*
 When using a pattern that matches multiple lines, a change in one line may
diff --git a/runtime/doc/tags b/runtime/doc/tags
index c4c4c8c..c08344d 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -995,6 +995,7 @@
 't_ve'	term.txt	/*'t_ve'*
 't_vi'	term.txt	/*'t_vi'*
 't_vs'	term.txt	/*'t_vs'*
+'t_xn'	term.txt	/*'t_xn'*
 't_xs'	term.txt	/*'t_xs'*
 'ta'	options.txt	/*'ta'*
 'tabline'	options.txt	/*'tabline'*
@@ -8203,6 +8204,7 @@
 t_ve	term.txt	/*t_ve*
 t_vi	term.txt	/*t_vi*
 t_vs	term.txt	/*t_vs*
+t_xn	term.txt	/*t_xn*
 t_xs	term.txt	/*t_xs*
 tab	intro.txt	/*tab*
 tab-page	tabpage.txt	/*tab-page*
diff --git a/runtime/doc/term.txt b/runtime/doc/term.txt
index 842f69b..2ad4f67 100644
--- a/runtime/doc/term.txt
+++ b/runtime/doc/term.txt
@@ -1,4 +1,4 @@
-*term.txt*      For Vim version 7.4.  Last change: 2014 May 13
+*term.txt*      For Vim version 7.4.  Last change: 2015 Feb 23
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -283,8 +283,8 @@
 								*t_xs* *'t_xs'*
 	t_xs	if non-empty, standout not erased by overwriting (hpterm)
 								*t_xn* *'t_xn'*
-	t_xn	if non-empty, character writing at the last cell of screen
-		didn't causes scrolling
+	t_xn	if non-empty, writing a character at the last screen cell
+		does not cause scrolling
 	t_ZH	italics mode					*t_ZH* *'t_ZH'*
 	t_ZR	italics end					*t_ZR* *'t_ZR'*
 
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 00e7034..0da2222 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 7.4.  Last change: 2015 Feb 03
+*todo.txt*      For Vim version 7.4.  Last change: 2015 Feb 27
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -35,6 +35,8 @@
 -------------------- Known bugs and current work -----------------------
 
 Regexp problems:
+- The old engine does not find a match for "/\%#=1\(\)\{80}", the new engine
+  matches everywhere.
 - Using win_linetabsize() can still be slow. Cache the result, store col and
   vcol. Reset them when moving to another line.
 - Very slow with a long line and Ruby highlighting. (John Whitley, 2014 Dec 4)
@@ -51,9 +53,13 @@
 - Does not work with NFA regexp engine:
   \%u, \%x, \%o, \%d followed by a composing character
 - Bug relating to back references. (Ingo Karkat, 2014 Jul 24)
+- New RE does not give an error for empty group: "\(\)\{2}" (Dominique Pelle,
+  2015 Feb 7)
 - Using back reference before the capturing group sometimes works with the old
   engine, can we do this with the new engine?  E.g. with
   "/\%(<\1>\)\@<=.*\%(<\/\(\w\+\)>\)\@=" matching text inside HTML tags.
+- Strange matching with "\(Hello\n\)\@<=A". (Anas Syed, 2015 Feb 12)
+- Problem with \v(A)@<=b+\1c. (Issue 334)
 - Diff highlighting can be very slow. (Issue 309)
 - Using %> for a virtual column has a check based on 'tabsize'.  Better would
   be to cache the result of win_linetabsize(col), storing both col and vcol,
@@ -62,12 +68,18 @@
 - this doesn't work: "syntax match ErrorMsg /.\%9l\%>20c\&\%<28c/".  Leaving
   out the \& works.  Seems any column check after \& fails.
 
+Check out neovim bug reports that apply to Vim:
+https://github.com/neovim/neovim/issues?q=label%3Abug-vim
+Specifically:
+https://github.com/neovim/neovim/commit/cf8e175cf54281bcad5e704308e92ebb3e6381d3
+https://github.com/neovim/neovim/commit/d7038127ca6b356ad33fdec08aa3b23ac6a817af
+https://github.com/neovim/neovim/commit/77ace65bdce379f2d9b13ee81ab3fc01951f92dc
+
 Still using freed memory after using setloclist(). (lcd, 2014 Jul 23)
 More info Jul 24.  Not clear why.
 
-Docs: "= register is writable. (Christian Brabandt, 2015 Jan 28)
-
-New syntax file for pfmain. (Anton Shestakov, 2015 Feb 2)
+Better .ico file for Windows. (Pat Suwalski, 2015 Feb 13)
+Waiting for response on remark from Edward Fox.
 
 Patch to make getregtype() return the right size for non-linux systems.
 (Yasuhiro Matsumoto, 2014 Jul 8)
@@ -88,22 +100,24 @@
 MS-Windows: When editing a file with a leading space, writing it uses the
 wrong name. (Aram, 2014 Nov 7)  Vim 7.4.
 
+Can't recognize the $ProgramFiles(x86) environment variable.  Recognize it
+specifically?  First try with the parens, then without.
+
 Value returned by virtcol() changes depending on how lines wrap.  This is
 inconsistent with the documentation.
 
 Better greek spell checking.  Issue 299.
 
-On MS-Windows running tests with Mercurial has problems when the fileformat of
-the input files are changed. (Ken Takata, Taro Muraoka, 2014 Sep 25)
-Update Nov 5.
+When complete() first argument is before where insert started and 'backspace'
+is Vi compatible, the completion fails. (Hirohito Higashi, 2015 Feb 19)
+
+Weird encryption problems on Windows. (Ben Fritz, 2015 Feb 13)
+Goes away when disabling the swap file. (might1, Feb 16)
 
 MS-Windows: Crash opening very long file name starting with "\\".
 (Christian Brock, 2012 Jun 29)
 
-Patch to add "tn" termcap feature, whether Vim can write in the last screen
-cell. (Hayaki Saito, 2015 Jan 28)
-
-Patch to fix getting buffer number for autocommand. (Lech Lorens, 2015 Jan 27)
+Syntax files for Innovation Data processing. (Rob Owens, 2015 Feb 4)
 
 Add a few features to xxd. (Vadim Vygonets, 2013 Nov 11)
 Patches: 2013 Nov 19
@@ -111,21 +125,34 @@
 2: Add -o: add offset to displayed position
 3: Change displayed file position width to 8 chars
 
-Undo messes up text.  Issue 324.
-Patch from Christian on the issue.
-
 Using CTRL-L while popup menu is visible behaves like CTRL-P, which is wrong.
 Patch by Yasuhiro Matsumoto, 2015 Jan 5.
 Is this right?  Comment from Amadeus Demarzi.
 Another patch from Christian, Jan 6.
-Comment from Hirohito Higashi, Jan 6.
+Comment from Hirohito Higashi, Jan 6, update Feb 8, update Feb 17.
+
+HTML indenting: adjustments for html5. (Michaelpg, 2015 Feb 23)
+
+glob() omits symbolic links to non-existing files.
+(Charles Campbell, 2015 Feb 19)
+Patch by James McCoy, 2015 Feb 20.
+Docs change suggestion by Roland Eggner, 2015 Feb 21.
+Probably "to a not existing file" should be "to a non-existing file".
 
 Cursorline background color not mixed with character highlight.
 Patch by Yasuhiro Matsumoto, 2014 Dec 3.
 
+Patch to fix temp directories for Windows, so that it works without tweaking.
+Issue 28.
+Also see http://superuser.com/questions/364879/how-to-open-a-new-file-in-gvim-e303-unable-to-open-swap-file
+
 Problem using diff syntax with cp932 encoding.  Idea from Yasuhiro Matsumoto,
 patch from Ken Takata (2014 Nov 6)
 
+text deleted by "dit" depends on indent of closing tag.
+(Jan Parthey, 2015 Feb 8)
+Patch by Christian, Feb 9.  Update Feb 13.
+
 ml_updatechunk() is slow when retrying for another encoding. (John Little,
 2014 Sep 11)
 
@@ -146,7 +173,7 @@
 
 Crash when using R syntax. (Jakson Alves de Aquino, 2015 Jan 30)
 Memory freed by ":syn clear" but still referenced, syntax items referenced
-from two windows?
+from two windows?  Stopped happening (Feb 5).
 
 Window height computed incorrectly when Vim is minimized.
 Patch to fix this. (Ingo Karkat, 2014 Dec 19)
@@ -157,18 +184,20 @@
 Patch to allow values greater than 255 for ctermfg/ctermbg on Windows.
 (Yasuhiro Matsumoto, 2014 Dec 5)
 
+Patch for an extra argument to matchadd() for conceal. (Christian Brabandt,
+2015 Feb 17, update Feb 19)
+
 Mixup of highlighting when there is a match and SpellBad. (ZyX, 2015 Jan 1)
 
 Problem caused by patch 7.3.638: window->open does not update window
 correctly. Issue 91.  With patch.
 
 Patch to add 'belloff' option. (Christian Brabandt, 2015 Jan 31)
+Update Feb 6.
 
 Patch for drag&drop reordering of GUI tab pages reordering.
 (Ken Takata, 2013 Nov 22, second one, also by Masamichi Abe)
 
-'ff' is wrong for one-line file without EOL. (Patch on Issue 77)
-
 Patch on Issue 72: 'autochdir' causes problems for :vimgrep.
 
 When 'balloonexpr' returns a list the result has a trailing newline.
@@ -192,6 +221,9 @@
 
 Adding "~" to 'cdpath' doesn't work for completion?  (Davido, 2013 Aug 19)
 
+Should be easy to highlight all matches with 'incsearch'.  Idea by Itchyny,
+2015 Feb 6.
+
 Plugins need to make a lot of effort, lots of mappings, to know what happened
 before pressing the key that triggers a plugin action.  How about keeping the
 last N pressed keys, so that they do not need to be mapped?
@@ -379,9 +411,6 @@
 Several syntax file match "^\s*" which may get underlined if that's in the
 highlight group.  Add a "\zs" after it?
 
-Patch to fix temp directories for Windows, so that it works without tweaking.
-Issue 28.
-
 Go through more coverity reports.
 
 Patch to add ":undorecover", get as much text out of the undo file as
@@ -2108,8 +2137,6 @@
 			Search in 'runtimepath'?
 			More docs needed about how to use this.
 			How to get the messages into the .po files?
-    strchars()		Like strlen() and strwidth() but counting characters
-			instead of bytes.
     confirm()		add "flags" argument, with 'v' for vertical
 			    layout and 'c' for console dialog. (Haegg)
 			    Flemming Madsen has a patch for the 'c' flag
@@ -4659,7 +4686,6 @@
     should be ignored (like "*/" or "#endif" inside /* */).
     Also: use "%" to jump from start to end of syntax region and back.
     Alternative: use matchit.vim
-8   "/:/e+1" gets stuck on a match at the end of the line.  Do we care?
 8   A pattern like "\([^a]\+\)\+" takes an awful long time.  Recognize that
     the recursive "\+" is meaningless and optimize for it.
     This one is also very slow on "/* some comment */": "^\/\*\(.*[^/]\)*$".
diff --git a/runtime/ftplugin/spec.vim b/runtime/ftplugin/spec.vim
index c3af8a9..d457659 100644
--- a/runtime/ftplugin/spec.vim
+++ b/runtime/ftplugin/spec.vim
@@ -2,7 +2,7 @@
 " Filename: spec.vim
 " Maintainer: Igor Gnatenko i.gnatenko.brain@gmail.com
 " Former Maintainer: Gustavo Niemeyer <niemeyer@conectiva.com> (until March 2014)
-" Last Change: Sun Mar 2 11:24 MSK 2014 Igor Gnatenko
+" Last Change: Fri Feb 20 16:01 MSK 2014 Igor Gnatenko
 
 if exists("b:did_ftplugin")
 	finish
@@ -18,7 +18,9 @@
 	endif
 endif
 
-noremap <buffer> <unique> <script> <Plug>SpecChangelog :call <SID>SpecChangelog("")<CR>
+if !hasmapto("call <SID>SpecChangelog(\"\")<CR>")
+       noremap <buffer> <unique> <script> <Plug>SpecChangelog :call <SID>SpecChangelog("")<CR>
+endif
 
 if !exists("*s:SpecChangelog")
 	function s:SpecChangelog(format)
diff --git a/runtime/syntax/asterisk.vim b/runtime/syntax/asterisk.vim
index 58e867d..fd4ec39 100644
--- a/runtime/syntax/asterisk.vim
+++ b/runtime/syntax/asterisk.vim
@@ -1,8 +1,9 @@
 " Vim syntax file
 " Language:	Asterisk config file
-" Maintainer:	brc007 
+" Maintainer: 	Jean Aunis <jean.aunis@yahoo.fr>
+" Previous Maintainer:	brc007
 " Updated for 1.2 by Tilghman Lesher (Corydon76)
-" Last Change:	2006 Mar 20 
+" Last Change:	2015 Feb 27
 " version 0.4
 "
 if version < 600
@@ -17,18 +18,19 @@
 syn keyword     asteriskTodo    TODO contained
 syn match       asteriskComment         ";.*" contains=asteriskTodo
 syn match       asteriskContext         "\[.\{-}\]"
-syn match       asteriskExten           "^\s*exten\s*=>\?\s*[^,]\+" contains=asteriskPattern
+syn match       asteriskExten           "^\s*\zsexten\s*=>\?\s*[^,]\+\ze," contains=asteriskPattern nextgroup=asteriskPriority
+syn match       asteriskExten           "^\s*\zssame\s*=>\?\s*\ze" nextgroup=asteriskPriority
 syn match       asteriskExten           "^\s*\(register\|channel\|ignorepat\|include\|\(no\)\?load\)\s*=>\?"
 syn match       asteriskPattern         "_\(\[[[:alnum:]#*\-]\+\]\|[[:alnum:]#*]\)*\.\?" contained
 syn match       asteriskPattern         "[^A-Za-z0-9,]\zs[[:alnum:]#*]\+\ze" contained
 syn match       asteriskApp             ",\zs[a-zA-Z]\+\ze$"
 syn match       asteriskApp             ",\zs[a-zA-Z]\+\ze("
 " Digits plus oldlabel (newlabel)
-syn match       asteriskPriority        ",\zs[[:digit:]]\+\(+[[:alpha:]][[:alnum:]_]*\)\?\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
+syn match       asteriskPriority        "\zs[[:digit:]]\+\(+[[:alpha:]][[:alnum:]_]*\)\?\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
 " oldlabel plus digits (newlabel)
-syn match       asteriskPriority        ",\zs[[:alpha:]][[:alnum:]_]*+[[:digit:]]\+\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
+syn match       asteriskPriority        "\zs[[:alpha:]][[:alnum:]_]*+[[:digit:]]\+\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
 " s or n plus digits (newlabel)
-syn match       asteriskPriority        ",\zs[sn]\(+[[:digit:]]\+\)\?\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
+syn match       asteriskPriority        "\zs[sn]\(+[[:digit:]]\+\)\?\(([[:alpha:]][[:alnum:]_]*)\)\?\ze," contains=asteriskLabel
 syn match       asteriskLabel           "(\zs[[:alpha:]][[:alnum:]]*\ze)" contained
 syn match       asteriskError           "^\s*#\s*[[:alnum:]]*"
 syn match       asteriskInclude         "^\s*#\s*\(include\|exec\)\s.*"
diff --git a/runtime/syntax/c.vim b/runtime/syntax/c.vim
index 128e1a2..a520e63 100644
--- a/runtime/syntax/c.vim
+++ b/runtime/syntax/c.vim
@@ -1,7 +1,7 @@
 " Vim syntax file
 " Language:	C
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2014 Nov 13
+" Last Change:	2015 Feb 27
 
 " Quit when a (custom) syntax file was already loaded
 if exists("b:current_syntax")
@@ -330,6 +330,8 @@
   " POSIX 2001
   syn keyword cConstant SIGBUS SIGPOLL SIGPROF SIGSYS SIGURG
   syn keyword cConstant SIGVTALRM SIGXCPU SIGXFSZ
+  " non-POSIX signals
+  syn keyword cConstant SIGWINCH SIGINFO
   " Add POSIX errors as well
   syn keyword cConstant E2BIG EACCES EAGAIN EBADF EBADMSG EBUSY
   syn keyword cConstant ECANCELED ECHILD EDEADLK EDOM EEXIST EFAULT
diff --git a/runtime/syntax/cobol.vim b/runtime/syntax/cobol.vim
index 5315e75..51ca3d8 100644
--- a/runtime/syntax/cobol.vim
+++ b/runtime/syntax/cobol.vim
@@ -1,10 +1,10 @@
 " Vim syntax file
-" Language:   COBOL
-" Maintainer: Tim Pope <vimNOSPAM@tpope.info>
+" Language:     COBOL
+" Maintainer:   Tim Pope <vimNOSPAM@tpope.org>
 "     (formerly Davyd Ondrejko <vondraco@columbus.rr.com>)
 "     (formerly Sitaram Chamarty <sitaram@diac.com> and
-"		    James Mitchell <james_mitchell@acm.org>)
-" $Id: cobol.vim,v 1.2 2007/05/05 18:23:43 vimboss Exp $
+"               James Mitchell <james_mitchell@acm.org>)
+" Last Change:  2015 Feb 13
 
 " For version 5.x: Clear all syntax items
 " For version 6.x: Quit when a syntax file was already loaded
@@ -145,7 +145,7 @@
 syn match   cobolIndicator   "\%7c[D-]" contained
 
 if exists("cobol_legacy_code")
-  syn region  cobolCondFlow     contains=ALLBUT,cobolLine start="\<\(IF\|INVALID\|END\|EOP\)\>" skip=/\('\|"\)[^"]\{-}\("\|'\|$\)/ end="\." keepend
+  syn region  cobolCondFlow     contains=ALLBUT,cobolLine,cobolBadLine start="\<\(IF\|INVALID\|END\|EOP\)\>" skip=/\('\|"\)[^"]\{-}\("\|'\|$\)/ end="\." keepend
 endif
 
 " many legacy sources have junk in columns 1-6: must be before others
diff --git a/runtime/syntax/make.vim b/runtime/syntax/make.vim
index 6fd46aa..35b0934 100644
--- a/runtime/syntax/make.vim
+++ b/runtime/syntax/make.vim
@@ -2,7 +2,7 @@
 " Language:	Makefile
 " Maintainer:	Claudio Fleiner <claudio@fleiner.com>
 " URL:		http://www.fleiner.com/vim/syntax/make.vim
-" Last Change:	2012 Oct 05
+" Last Change:	2015 Feb 28
 
 " For version 5.x: Clear all syntax items
 " For version 6.x: Quit when a syntax file was already loaded
@@ -43,8 +43,8 @@
 syn region makeIdent	start="\${" skip="\\}\|\\\\" end="}" contains=makeStatement,makeIdent,makeSString,makeDString
 syn match makeIdent	"\$\$\w*"
 syn match makeIdent	"\$[^({]"
-syn match makeIdent	"^ *\a\w*\s*[:+?!*]="me=e-2
-syn match makeIdent	"^ *\a\w*\s*="me=e-1
+syn match makeIdent	"^ *[^:#= \t]*\s*[:+?!*]="me=e-2
+syn match makeIdent	"^ *[^:#= \t]*\s*="me=e-1
 syn match makeIdent	"%"
 
 " Makefile.in variables
@@ -55,11 +55,11 @@
 syn match makeImplicit		"^\.[A-Za-z0-9_./\t -]\+\s*:$"me=e-1 nextgroup=makeSource
 syn match makeImplicit		"^\.[A-Za-z0-9_./\t -]\+\s*:[^=]"me=e-2 nextgroup=makeSource
 
-syn region makeTarget	transparent matchgroup=makeTarget start="^[A-Za-z0-9_./$()%-][A-Za-z0-9_./\t $()%-]*:\{1,2}[^:=]"rs=e-1 end=";"re=e-1,me=e-1 end="[^\\]$" keepend contains=makeIdent,makeSpecTarget,makeNextLine skipnl nextGroup=makeCommands
-syn match makeTarget		"^[A-Za-z0-9_./$()%*@-][A-Za-z0-9_./\t $()%*@-]*::\=\s*$" contains=makeIdent,makeSpecTarget skipnl nextgroup=makeCommands,makeCommandError
+syn region makeTarget   transparent matchgroup=makeTarget start="^[~A-Za-z0-9_./$()%-][A-Za-z0-9_./\t $()%-]*:\{1,2}[^:=]"rs=e-1 end=";"re=e-1,me=e-1 end="[^\\]$" keepend contains=makeIdent,makeSpecTarget,makeNextLine,makeComment skipnl nextGroup=makeCommands
+syn match makeTarget		"^[~A-Za-z0-9_./$()%*@-][A-Za-z0-9_./\t $()%*@-]*::\=\s*$" contains=makeIdent,makeSpecTarget,makeComment skipnl nextgroup=makeCommands,makeCommandError
 
-syn region makeSpecTarget	transparent matchgroup=makeSpecTarget start="^\.\(SUFFIXES\|PHONY\|DEFAULT\|PRECIOUS\|IGNORE\|SILENT\|EXPORT_ALL_VARIABLES\|KEEP_STATE\|LIBPATTERNS\|NOTPARALLEL\|DELETE_ON_ERROR\|INTERMEDIATE\|POSIX\|SECONDARY\)\>\s*:\{1,2}[^:=]"rs=e-1 end="[^\\]$" keepend contains=makeIdent,makeSpecTarget,makeNextLine skipnl nextGroup=makeCommands
-syn match makeSpecTarget		"^\.\(SUFFIXES\|PHONY\|DEFAULT\|PRECIOUS\|IGNORE\|SILENT\|EXPORT_ALL_VARIABLES\|KEEP_STATE\|LIBPATTERNS\|NOTPARALLEL\|DELETE_ON_ERROR\|INTERMEDIATE\|POSIX\|SECONDARY\)\>\s*::\=\s*$" contains=makeIdent skipnl nextgroup=makeCommands,makeCommandError
+syn region makeSpecTarget	transparent matchgroup=makeSpecTarget start="^\.\(SUFFIXES\|PHONY\|DEFAULT\|PRECIOUS\|IGNORE\|SILENT\|EXPORT_ALL_VARIABLES\|KEEP_STATE\|LIBPATTERNS\|NOTPARALLEL\|DELETE_ON_ERROR\|INTERMEDIATE\|POSIX\|SECONDARY\)\>\s*:\{1,2}[^:=]"rs=e-1 end="[^\\]$" keepend contains=makeIdent,makeSpecTarget,makeNextLine,makeComment skipnl nextGroup=makeCommands
+syn match makeSpecTarget		"^\.\(SUFFIXES\|PHONY\|DEFAULT\|PRECIOUS\|IGNORE\|SILENT\|EXPORT_ALL_VARIABLES\|KEEP_STATE\|LIBPATTERNS\|NOTPARALLEL\|DELETE_ON_ERROR\|INTERMEDIATE\|POSIX\|SECONDARY\)\>\s*::\=\s*$" contains=makeIdent,makeComment skipnl nextgroup=makeCommands,makeCommandError
 
 syn match makeCommandError "^\s\+\S.*" contained
 syn region makeCommands start=";"hs=s+1 start="^\t" end="^[^\t#]"me=e-1,re=e-1 end="^$" contained contains=makeCmdNextLine,makeSpecial,makeComment,makeIdent,makePreCondit,makeDefine,makeDString,makeSString nextgroup=makeCommandError
diff --git a/runtime/syntax/pfmain.vim b/runtime/syntax/pfmain.vim
index a090445..32ed697 100644
--- a/runtime/syntax/pfmain.vim
+++ b/runtime/syntax/pfmain.vim
@@ -1,11 +1,11 @@
 " Vim syntax file
 " Language:	Postfix main.cf configuration
 " Maintainer:	KELEMEN Peter <Peter dot Kelemen at cern dot ch>
-" Last Update:  Hong Xu
-" Last Change:	2011 May 14
+" Last Updates:	Anton Shestakov, Hong Xu
+" Last Change:	2015 Feb 10
 " Version:	0.40
 " URL:		http://cern.ch/fuji/vim/syntax/pfmain.vim
-" Comment:	Based on Postfix 2.9 defaults.
+" Comment:	Based on Postfix 2.12/3.0 postconf.5.html.
 
 if version < 600
 	syntax clear
@@ -41,6 +41,7 @@
 syntax keyword pfmainConf address_verify_sender
 syntax keyword pfmainConf address_verify_sender_dependent_default_transport_maps
 syntax keyword pfmainConf address_verify_sender_dependent_relayhost_maps
+syntax keyword pfmainConf address_verify_sender_ttl
 syntax keyword pfmainConf address_verify_service_name
 syntax keyword pfmainConf address_verify_transport_maps
 syntax keyword pfmainConf address_verify_virtual_transport
@@ -52,6 +53,7 @@
 syntax keyword pfmainConf allow_percent_hack
 syntax keyword pfmainConf allow_untrusted_routing
 syntax keyword pfmainConf alternate_config_directories
+syntax keyword pfmainConf always_add_missing_headers
 syntax keyword pfmainConf always_bcc
 syntax keyword pfmainConf anvil_rate_time_unit
 syntax keyword pfmainConf anvil_status_update_time
@@ -61,6 +63,7 @@
 syntax keyword pfmainConf authorized_flush_users
 syntax keyword pfmainConf authorized_mailq_users
 syntax keyword pfmainConf authorized_submit_users
+syntax keyword pfmainConf authorized_verp_clients
 syntax keyword pfmainConf backwards_bounce_logfile_compatibility
 syntax keyword pfmainConf berkeley_db_create_buffer_size
 syntax keyword pfmainConf berkeley_db_read_buffer_size
@@ -81,7 +84,9 @@
 syntax keyword pfmainConf command_execution_directory
 syntax keyword pfmainConf command_expansion_filter
 syntax keyword pfmainConf command_time_limit
+syntax keyword pfmainConf compatibility_level
 syntax keyword pfmainConf config_directory
+syntax keyword pfmainConf confirm_delay_cleared
 syntax keyword pfmainConf connection_cache_protocol_timeout
 syntax keyword pfmainConf connection_cache_service_name
 syntax keyword pfmainConf connection_cache_status_update_time
@@ -89,14 +94,17 @@
 syntax keyword pfmainConf content_filter
 syntax keyword pfmainConf cyrus_sasl_config_path
 syntax keyword pfmainConf daemon_directory
+syntax keyword pfmainConf daemon_table_open_error_is_fatal
 syntax keyword pfmainConf daemon_timeout
 syntax keyword pfmainConf data_directory
 syntax keyword pfmainConf debug_peer_level
 syntax keyword pfmainConf debug_peer_list
+syntax keyword pfmainConf debugger_command
 syntax keyword pfmainConf default_database_type
 syntax keyword pfmainConf default_delivery_slot_cost
 syntax keyword pfmainConf default_delivery_slot_discount
 syntax keyword pfmainConf default_delivery_slot_loan
+syntax keyword pfmainConf default_delivery_status_filter
 syntax keyword pfmainConf default_destination_concurrency_failed_cohort_limit
 syntax keyword pfmainConf default_destination_concurrency_limit
 syntax keyword pfmainConf default_destination_concurrency_negative_feedback
@@ -137,6 +145,7 @@
 syntax keyword pfmainConf empty_address_default_transport_maps_lookup_key
 syntax keyword pfmainConf empty_address_recipient
 syntax keyword pfmainConf empty_address_relayhost_maps_lookup_key
+syntax keyword pfmainConf enable_errors_to
 syntax keyword pfmainConf enable_long_queue_ids
 syntax keyword pfmainConf enable_original_recipient
 syntax keyword pfmainConf error_notice_recipient
@@ -144,6 +153,8 @@
 syntax keyword pfmainConf execution_directory_expansion_filter
 syntax keyword pfmainConf expand_owner_alias
 syntax keyword pfmainConf export_environment
+syntax keyword pfmainConf extract_recipient_limit
+syntax keyword pfmainConf fallback_relay
 syntax keyword pfmainConf fallback_transport
 syntax keyword pfmainConf fallback_transport_maps
 syntax keyword pfmainConf fast_flush_domains
@@ -177,25 +188,33 @@
 syntax keyword pfmainConf ipc_timeout
 syntax keyword pfmainConf ipc_ttl
 syntax keyword pfmainConf line_length_limit
+syntax keyword pfmainConf lmdb_map_size
 syntax keyword pfmainConf lmtp_address_preference
+syntax keyword pfmainConf lmtp_address_verify_target
+syntax keyword pfmainConf lmtp_assume_final
 syntax keyword pfmainConf lmtp_bind_address
 syntax keyword pfmainConf lmtp_bind_address6
 syntax keyword pfmainConf lmtp_body_checks
+syntax keyword pfmainConf lmtp_cache_connection
 syntax keyword pfmainConf lmtp_cname_overrides_servername
 syntax keyword pfmainConf lmtp_connect_timeout
 syntax keyword pfmainConf lmtp_connection_cache_destinations
 syntax keyword pfmainConf lmtp_connection_cache_on_demand
 syntax keyword pfmainConf lmtp_connection_cache_time_limit
+syntax keyword pfmainConf lmtp_connection_reuse_count_limit
 syntax keyword pfmainConf lmtp_connection_reuse_time_limit
 syntax keyword pfmainConf lmtp_data_done_timeout
 syntax keyword pfmainConf lmtp_data_init_timeout
 syntax keyword pfmainConf lmtp_data_xfer_timeout
 syntax keyword pfmainConf lmtp_defer_if_no_mx_address_found
+syntax keyword pfmainConf lmtp_delivery_status_filter
 syntax keyword pfmainConf lmtp_destination_concurrency_limit
 syntax keyword pfmainConf lmtp_destination_recipient_limit
 syntax keyword pfmainConf lmtp_discard_lhlo_keyword_address_maps
 syntax keyword pfmainConf lmtp_discard_lhlo_keywords
+syntax keyword pfmainConf lmtp_dns_reply_filter
 syntax keyword pfmainConf lmtp_dns_resolver_options
+syntax keyword pfmainConf lmtp_dns_support_level
 syntax keyword pfmainConf lmtp_enforce_tls
 syntax keyword pfmainConf lmtp_generic_maps
 syntax keyword pfmainConf lmtp_header_checks
@@ -230,9 +249,11 @@
 syntax keyword pfmainConf lmtp_sasl_tls_security_options
 syntax keyword pfmainConf lmtp_sasl_tls_verified_security_options
 syntax keyword pfmainConf lmtp_sasl_type
+syntax keyword pfmainConf lmtp_send_dummy_mail_auth
 syntax keyword pfmainConf lmtp_send_xforward_command
 syntax keyword pfmainConf lmtp_sender_dependent_authentication
 syntax keyword pfmainConf lmtp_skip_5xx_greeting
+syntax keyword pfmainConf lmtp_skip_quit_response
 syntax keyword pfmainConf lmtp_starttls_timeout
 syntax keyword pfmainConf lmtp_tcp_port
 syntax keyword pfmainConf lmtp_tls_CAfile
@@ -248,6 +269,7 @@
 syntax keyword pfmainConf lmtp_tls_exclude_ciphers
 syntax keyword pfmainConf lmtp_tls_fingerprint_cert_match
 syntax keyword pfmainConf lmtp_tls_fingerprint_digest
+syntax keyword pfmainConf lmtp_tls_force_insecure_host_tlsa_lookup
 syntax keyword pfmainConf lmtp_tls_key_file
 syntax keyword pfmainConf lmtp_tls_loglevel
 syntax keyword pfmainConf lmtp_tls_mandatory_ciphers
@@ -262,10 +284,12 @@
 syntax keyword pfmainConf lmtp_tls_security_level
 syntax keyword pfmainConf lmtp_tls_session_cache_database
 syntax keyword pfmainConf lmtp_tls_session_cache_timeout
+syntax keyword pfmainConf lmtp_tls_trust_anchor_file
 syntax keyword pfmainConf lmtp_tls_verify_cert_match
 syntax keyword pfmainConf lmtp_use_tls
 syntax keyword pfmainConf lmtp_xforward_timeout
 syntax keyword pfmainConf local_command_shell
+syntax keyword pfmainConf local_delivery_status_filter
 syntax keyword pfmainConf local_destination_concurrency_limit
 syntax keyword pfmainConf local_destination_recipient_limit
 syntax keyword pfmainConf local_header_rewrite_clients
@@ -287,17 +311,19 @@
 syntax keyword pfmainConf manpage_directory
 syntax keyword pfmainConf maps_rbl_domains
 syntax keyword pfmainConf maps_rbl_reject_code
-syntax keyword pfmainConf master_service_disable
 syntax keyword pfmainConf masquerade_classes
 syntax keyword pfmainConf masquerade_domains
 syntax keyword pfmainConf masquerade_exceptions
+syntax keyword pfmainConf master_service_disable
 syntax keyword pfmainConf max_idle
 syntax keyword pfmainConf max_use
 syntax keyword pfmainConf maximal_backoff_time
 syntax keyword pfmainConf maximal_queue_lifetime
+syntax keyword pfmainConf message_drop_headers
 syntax keyword pfmainConf message_reject_characters
 syntax keyword pfmainConf message_size_limit
 syntax keyword pfmainConf message_strip_characters
+syntax keyword pfmainConf meta_directory
 syntax keyword pfmainConf milter_command_timeout
 syntax keyword pfmainConf milter_connect_macros
 syntax keyword pfmainConf milter_connect_timeout
@@ -335,10 +361,12 @@
 syntax keyword pfmainConf non_fqdn_reject_code
 syntax keyword pfmainConf non_smtpd_milters
 syntax keyword pfmainConf notify_classes
+syntax keyword pfmainConf nullmx_reject_code
 syntax keyword pfmainConf owner_request_special
 syntax keyword pfmainConf parent_domain_matches_subdomains
 syntax keyword pfmainConf permit_mx_backup_networks
 syntax keyword pfmainConf pickup_service_name
+syntax keyword pfmainConf pipe_delivery_status_filter
 syntax keyword pfmainConf plaintext_reject_code
 syntax keyword pfmainConf postmulti_control_commands
 syntax keyword pfmainConf postmulti_start_commands
@@ -362,7 +390,9 @@
 syntax keyword pfmainConf postscreen_dnsbl_reply_map
 syntax keyword pfmainConf postscreen_dnsbl_sites
 syntax keyword pfmainConf postscreen_dnsbl_threshold
+syntax keyword pfmainConf postscreen_dnsbl_timeout
 syntax keyword pfmainConf postscreen_dnsbl_ttl
+syntax keyword pfmainConf postscreen_dnsbl_whitelist_threshold
 syntax keyword pfmainConf postscreen_enforce_tls
 syntax keyword pfmainConf postscreen_expansion_filter
 syntax keyword pfmainConf postscreen_forbidden_commands
@@ -381,6 +411,8 @@
 syntax keyword pfmainConf postscreen_pre_queue_limit
 syntax keyword pfmainConf postscreen_reject_footer
 syntax keyword pfmainConf postscreen_tls_security_level
+syntax keyword pfmainConf postscreen_upstream_proxy_protocol
+syntax keyword pfmainConf postscreen_upstream_proxy_timeout
 syntax keyword pfmainConf postscreen_use_tls
 syntax keyword pfmainConf postscreen_watchdog_timeout
 syntax keyword pfmainConf postscreen_whitelist_interfaces
@@ -395,7 +427,9 @@
 syntax keyword pfmainConf proxymap_service_name
 syntax keyword pfmainConf proxywrite_service_name
 syntax keyword pfmainConf qmgr_clog_warn_time
+syntax keyword pfmainConf qmgr_daemon_timeout
 syntax keyword pfmainConf qmgr_fudge_factor
+syntax keyword pfmainConf qmgr_ipc_timeout
 syntax keyword pfmainConf qmgr_message_active_limit
 syntax keyword pfmainConf qmgr_message_recipient_limit
 syntax keyword pfmainConf qmgr_message_recipient_minimum
@@ -435,17 +469,21 @@
 syntax keyword pfmainConf rewrite_service_name
 syntax keyword pfmainConf sample_directory
 syntax keyword pfmainConf send_cyrus_sasl_authzid
+syntax keyword pfmainConf sender_based_routing
 syntax keyword pfmainConf sender_bcc_maps
 syntax keyword pfmainConf sender_canonical_classes
 syntax keyword pfmainConf sender_canonical_maps
 syntax keyword pfmainConf sender_dependent_default_transport_maps
 syntax keyword pfmainConf sender_dependent_relayhost_maps
+syntax keyword pfmainConf sendmail_fix_line_endings
 syntax keyword pfmainConf sendmail_path
 syntax keyword pfmainConf service_throttle_time
 syntax keyword pfmainConf setgid_group
+syntax keyword pfmainConf shlib_directory
 syntax keyword pfmainConf show_user_unknown_table_name
 syntax keyword pfmainConf showq_service_name
 syntax keyword pfmainConf smtp_address_preference
+syntax keyword pfmainConf smtp_address_verify_target
 syntax keyword pfmainConf smtp_always_send_ehlo
 syntax keyword pfmainConf smtp_bind_address
 syntax keyword pfmainConf smtp_bind_address6
@@ -455,16 +493,20 @@
 syntax keyword pfmainConf smtp_connection_cache_destinations
 syntax keyword pfmainConf smtp_connection_cache_on_demand
 syntax keyword pfmainConf smtp_connection_cache_time_limit
+syntax keyword pfmainConf smtp_connection_reuse_count_limit
 syntax keyword pfmainConf smtp_connection_reuse_time_limit
 syntax keyword pfmainConf smtp_data_done_timeout
 syntax keyword pfmainConf smtp_data_init_timeout
 syntax keyword pfmainConf smtp_data_xfer_timeout
 syntax keyword pfmainConf smtp_defer_if_no_mx_address_found
+syntax keyword pfmainConf smtp_delivery_status_filter
 syntax keyword pfmainConf smtp_destination_concurrency_limit
 syntax keyword pfmainConf smtp_destination_recipient_limit
 syntax keyword pfmainConf smtp_discard_ehlo_keyword_address_maps
 syntax keyword pfmainConf smtp_discard_ehlo_keywords
+syntax keyword pfmainConf smtp_dns_reply_filter
 syntax keyword pfmainConf smtp_dns_resolver_options
+syntax keyword pfmainConf smtp_dns_support_level
 syntax keyword pfmainConf smtp_enforce_tls
 syntax keyword pfmainConf smtp_fallback_relay
 syntax keyword pfmainConf smtp_generic_maps
@@ -479,6 +521,7 @@
 syntax keyword pfmainConf smtp_mx_session_limit
 syntax keyword pfmainConf smtp_nested_header_checks
 syntax keyword pfmainConf smtp_never_send_ehlo
+syntax keyword pfmainConf smtp_per_record_deadline
 syntax keyword pfmainConf smtp_pix_workaround_delay_time
 syntax keyword pfmainConf smtp_pix_workaround_maps
 syntax keyword pfmainConf smtp_pix_workaround_threshold_time
@@ -500,8 +543,10 @@
 syntax keyword pfmainConf smtp_sasl_tls_security_options
 syntax keyword pfmainConf smtp_sasl_tls_verified_security_options
 syntax keyword pfmainConf smtp_sasl_type
+syntax keyword pfmainConf smtp_send_dummy_mail_auth
 syntax keyword pfmainConf smtp_send_xforward_command
 syntax keyword pfmainConf smtp_sender_dependent_authentication
+syntax keyword pfmainConf smtp_skip_4xx_greeting
 syntax keyword pfmainConf smtp_skip_5xx_greeting
 syntax keyword pfmainConf smtp_skip_quit_response
 syntax keyword pfmainConf smtp_starttls_timeout
@@ -519,6 +564,7 @@
 syntax keyword pfmainConf smtp_tls_exclude_ciphers
 syntax keyword pfmainConf smtp_tls_fingerprint_cert_match
 syntax keyword pfmainConf smtp_tls_fingerprint_digest
+syntax keyword pfmainConf smtp_tls_force_insecure_host_tlsa_lookup
 syntax keyword pfmainConf smtp_tls_key_file
 syntax keyword pfmainConf smtp_tls_loglevel
 syntax keyword pfmainConf smtp_tls_mandatory_ciphers
@@ -533,7 +579,9 @@
 syntax keyword pfmainConf smtp_tls_security_level
 syntax keyword pfmainConf smtp_tls_session_cache_database
 syntax keyword pfmainConf smtp_tls_session_cache_timeout
+syntax keyword pfmainConf smtp_tls_trust_anchor_file
 syntax keyword pfmainConf smtp_tls_verify_cert_match
+syntax keyword pfmainConf smtp_tls_wrappermode
 syntax keyword pfmainConf smtp_use_tls
 syntax keyword pfmainConf smtp_xforward_timeout
 syntax keyword pfmainConf smtpd_authorized_verp_clients
@@ -554,6 +602,7 @@
 syntax keyword pfmainConf smtpd_delay_reject
 syntax keyword pfmainConf smtpd_discard_ehlo_keyword_address_maps
 syntax keyword pfmainConf smtpd_discard_ehlo_keywords
+syntax keyword pfmainConf smtpd_dns_reply_filter
 syntax keyword pfmainConf smtpd_end_of_data_restrictions
 syntax keyword pfmainConf smtpd_enforce_tls
 syntax keyword pfmainConf smtpd_error_sleep_time
@@ -565,14 +614,19 @@
 syntax keyword pfmainConf smtpd_helo_restrictions
 syntax keyword pfmainConf smtpd_history_flush_threshold
 syntax keyword pfmainConf smtpd_junk_command_limit
+syntax keyword pfmainConf smtpd_log_access_permit_actions
 syntax keyword pfmainConf smtpd_milters
 syntax keyword pfmainConf smtpd_noop_commands
 syntax keyword pfmainConf smtpd_null_access_lookup_key
 syntax keyword pfmainConf smtpd_peername_lookup
 syntax keyword pfmainConf smtpd_per_record_deadline
+syntax keyword pfmainConf smtpd_policy_service_default_action
 syntax keyword pfmainConf smtpd_policy_service_max_idle
 syntax keyword pfmainConf smtpd_policy_service_max_ttl
+syntax keyword pfmainConf smtpd_policy_service_request_limit
+syntax keyword pfmainConf smtpd_policy_service_retry_delay
 syntax keyword pfmainConf smtpd_policy_service_timeout
+syntax keyword pfmainConf smtpd_policy_service_try_limit
 syntax keyword pfmainConf smtpd_proxy_ehlo
 syntax keyword pfmainConf smtpd_proxy_filter
 syntax keyword pfmainConf smtpd_proxy_options
@@ -583,13 +637,16 @@
 syntax keyword pfmainConf smtpd_reject_footer
 syntax keyword pfmainConf smtpd_reject_unlisted_recipient
 syntax keyword pfmainConf smtpd_reject_unlisted_sender
+syntax keyword pfmainConf smtpd_relay_restrictions
 syntax keyword pfmainConf smtpd_restriction_classes
+syntax keyword pfmainConf smtpd_sasl_application_name
 syntax keyword pfmainConf smtpd_sasl_auth_enable
 syntax keyword pfmainConf smtpd_sasl_authenticated_header
 syntax keyword pfmainConf smtpd_sasl_exceptions_networks
 syntax keyword pfmainConf smtpd_sasl_local_domain
 syntax keyword pfmainConf smtpd_sasl_path
 syntax keyword pfmainConf smtpd_sasl_security_options
+syntax keyword pfmainConf smtpd_sasl_service
 syntax keyword pfmainConf smtpd_sasl_tls_security_options
 syntax keyword pfmainConf smtpd_sasl_type
 syntax keyword pfmainConf smtpd_sender_login_maps
@@ -628,21 +685,21 @@
 syntax keyword pfmainConf smtpd_tls_session_cache_database
 syntax keyword pfmainConf smtpd_tls_session_cache_timeout
 syntax keyword pfmainConf smtpd_tls_wrappermode
+syntax keyword pfmainConf smtpd_upstream_proxy_protocol
+syntax keyword pfmainConf smtpd_upstream_proxy_timeout
 syntax keyword pfmainConf smtpd_use_tls
+syntax keyword pfmainConf smtputf8_autodetect_classes
+syntax keyword pfmainConf smtputf8_enable
 syntax keyword pfmainConf soft_bounce
 syntax keyword pfmainConf stale_lock_time
 syntax keyword pfmainConf stress
 syntax keyword pfmainConf strict_7bit_headers
 syntax keyword pfmainConf strict_8bitmime
 syntax keyword pfmainConf strict_8bitmime_body
-syntax keyword pfmainConf strict_mime_encoding_domain
-syntax keyword pfmainConf strict_rfc821_envelopes
-syntax keyword pfmainConf strict_7bit_headers
-syntax keyword pfmainConf strict_8bitmime
-syntax keyword pfmainConf strict_8bitmime_body
 syntax keyword pfmainConf strict_mailbox_ownership
 syntax keyword pfmainConf strict_mime_encoding_domain
 syntax keyword pfmainConf strict_rfc821_envelopes
+syntax keyword pfmainConf strict_smtputf8
 syntax keyword pfmainConf sun_mailtool_compatibility
 syntax keyword pfmainConf swap_bangpath
 syntax keyword pfmainConf syslog_facility
@@ -650,11 +707,15 @@
 syntax keyword pfmainConf tcp_windowsize
 syntax keyword pfmainConf tls_append_default_CA
 syntax keyword pfmainConf tls_daemon_random_bytes
+syntax keyword pfmainConf tls_dane_digest_agility
+syntax keyword pfmainConf tls_dane_digests
+syntax keyword pfmainConf tls_dane_trust_anchor_digest_enable
 syntax keyword pfmainConf tls_disable_workarounds
 syntax keyword pfmainConf tls_eecdh_strong_curve
 syntax keyword pfmainConf tls_eecdh_ultra_curve
 syntax keyword pfmainConf tls_export_cipherlist
 syntax keyword pfmainConf tls_high_cipherlist
+syntax keyword pfmainConf tls_legacy_public_key_fingerprints
 syntax keyword pfmainConf tls_low_cipherlist
 syntax keyword pfmainConf tls_medium_cipherlist
 syntax keyword pfmainConf tls_null_cipherlist
@@ -664,6 +725,10 @@
 syntax keyword pfmainConf tls_random_prng_update_period
 syntax keyword pfmainConf tls_random_reseed_period
 syntax keyword pfmainConf tls_random_source
+syntax keyword pfmainConf tls_session_ticket_cipher
+syntax keyword pfmainConf tls_ssl_options
+syntax keyword pfmainConf tls_wildcard_matches_multiple_labels
+syntax keyword pfmainConf tlsmgr_service_name
 syntax keyword pfmainConf tlsproxy_enforce_tls
 syntax keyword pfmainConf tlsproxy_service_name
 syntax keyword pfmainConf tlsproxy_tls_CAfile
@@ -711,6 +776,7 @@
 syntax keyword pfmainConf transport_recipient_refill_delay
 syntax keyword pfmainConf transport_recipient_refill_limit
 syntax keyword pfmainConf transport_retry_time
+syntax keyword pfmainConf transport_time_limit
 syntax keyword pfmainConf trigger_timeout
 syntax keyword pfmainConf undisclosed_recipients_header
 syntax keyword pfmainConf unknown_address_reject_code
@@ -731,10 +797,12 @@
 syntax keyword pfmainConf unverified_sender_reject_reason
 syntax keyword pfmainConf unverified_sender_tempfail_action
 syntax keyword pfmainConf verp_delimiter_filter
+syntax keyword pfmainConf virtual_alias_address_length_limit
 syntax keyword pfmainConf virtual_alias_domains
 syntax keyword pfmainConf virtual_alias_expansion_limit
 syntax keyword pfmainConf virtual_alias_maps
 syntax keyword pfmainConf virtual_alias_recursion_limit
+syntax keyword pfmainConf virtual_delivery_status_filter
 syntax keyword pfmainConf virtual_destination_concurrency_limit
 syntax keyword pfmainConf virtual_destination_recipient_limit
 syntax keyword pfmainConf virtual_gid_maps
@@ -743,6 +811,7 @@
 syntax keyword pfmainConf virtual_mailbox_limit
 syntax keyword pfmainConf virtual_mailbox_lock
 syntax keyword pfmainConf virtual_mailbox_maps
+syntax keyword pfmainConf virtual_maps
 syntax keyword pfmainConf virtual_minimum_uid
 syntax keyword pfmainConf virtual_transport
 syntax keyword pfmainConf virtual_uid_maps
@@ -765,6 +834,7 @@
 syntax match pfmainRef "$\<address_verify_sender\>"
 syntax match pfmainRef "$\<address_verify_sender_dependent_default_transport_maps\>"
 syntax match pfmainRef "$\<address_verify_sender_dependent_relayhost_maps\>"
+syntax match pfmainRef "$\<address_verify_sender_ttl\>"
 syntax match pfmainRef "$\<address_verify_service_name\>"
 syntax match pfmainRef "$\<address_verify_transport_maps\>"
 syntax match pfmainRef "$\<address_verify_virtual_transport\>"
@@ -776,6 +846,7 @@
 syntax match pfmainRef "$\<allow_percent_hack\>"
 syntax match pfmainRef "$\<allow_untrusted_routing\>"
 syntax match pfmainRef "$\<alternate_config_directories\>"
+syntax match pfmainRef "$\<always_add_missing_headers\>"
 syntax match pfmainRef "$\<always_bcc\>"
 syntax match pfmainRef "$\<anvil_rate_time_unit\>"
 syntax match pfmainRef "$\<anvil_status_update_time\>"
@@ -785,6 +856,7 @@
 syntax match pfmainRef "$\<authorized_flush_users\>"
 syntax match pfmainRef "$\<authorized_mailq_users\>"
 syntax match pfmainRef "$\<authorized_submit_users\>"
+syntax match pfmainRef "$\<authorized_verp_clients\>"
 syntax match pfmainRef "$\<backwards_bounce_logfile_compatibility\>"
 syntax match pfmainRef "$\<berkeley_db_create_buffer_size\>"
 syntax match pfmainRef "$\<berkeley_db_read_buffer_size\>"
@@ -805,7 +877,9 @@
 syntax match pfmainRef "$\<command_execution_directory\>"
 syntax match pfmainRef "$\<command_expansion_filter\>"
 syntax match pfmainRef "$\<command_time_limit\>"
+syntax match pfmainRef "$\<compatibility_level\>"
 syntax match pfmainRef "$\<config_directory\>"
+syntax match pfmainRef "$\<confirm_delay_cleared\>"
 syntax match pfmainRef "$\<connection_cache_protocol_timeout\>"
 syntax match pfmainRef "$\<connection_cache_service_name\>"
 syntax match pfmainRef "$\<connection_cache_status_update_time\>"
@@ -813,14 +887,17 @@
 syntax match pfmainRef "$\<content_filter\>"
 syntax match pfmainRef "$\<cyrus_sasl_config_path\>"
 syntax match pfmainRef "$\<daemon_directory\>"
+syntax match pfmainRef "$\<daemon_table_open_error_is_fatal\>"
 syntax match pfmainRef "$\<daemon_timeout\>"
 syntax match pfmainRef "$\<data_directory\>"
 syntax match pfmainRef "$\<debug_peer_level\>"
 syntax match pfmainRef "$\<debug_peer_list\>"
+syntax match pfmainRef "$\<debugger_command\>"
 syntax match pfmainRef "$\<default_database_type\>"
 syntax match pfmainRef "$\<default_delivery_slot_cost\>"
 syntax match pfmainRef "$\<default_delivery_slot_discount\>"
 syntax match pfmainRef "$\<default_delivery_slot_loan\>"
+syntax match pfmainRef "$\<default_delivery_status_filter\>"
 syntax match pfmainRef "$\<default_destination_concurrency_failed_cohort_limit\>"
 syntax match pfmainRef "$\<default_destination_concurrency_limit\>"
 syntax match pfmainRef "$\<default_destination_concurrency_negative_feedback\>"
@@ -861,6 +938,7 @@
 syntax match pfmainRef "$\<empty_address_default_transport_maps_lookup_key\>"
 syntax match pfmainRef "$\<empty_address_recipient\>"
 syntax match pfmainRef "$\<empty_address_relayhost_maps_lookup_key\>"
+syntax match pfmainRef "$\<enable_errors_to\>"
 syntax match pfmainRef "$\<enable_long_queue_ids\>"
 syntax match pfmainRef "$\<enable_original_recipient\>"
 syntax match pfmainRef "$\<error_notice_recipient\>"
@@ -868,6 +946,8 @@
 syntax match pfmainRef "$\<execution_directory_expansion_filter\>"
 syntax match pfmainRef "$\<expand_owner_alias\>"
 syntax match pfmainRef "$\<export_environment\>"
+syntax match pfmainRef "$\<extract_recipient_limit\>"
+syntax match pfmainRef "$\<fallback_relay\>"
 syntax match pfmainRef "$\<fallback_transport\>"
 syntax match pfmainRef "$\<fallback_transport_maps\>"
 syntax match pfmainRef "$\<fast_flush_domains\>"
@@ -901,25 +981,33 @@
 syntax match pfmainRef "$\<ipc_timeout\>"
 syntax match pfmainRef "$\<ipc_ttl\>"
 syntax match pfmainRef "$\<line_length_limit\>"
+syntax match pfmainRef "$\<lmdb_map_size\>"
 syntax match pfmainRef "$\<lmtp_address_preference\>"
+syntax match pfmainRef "$\<lmtp_address_verify_target\>"
+syntax match pfmainRef "$\<lmtp_assume_final\>"
 syntax match pfmainRef "$\<lmtp_bind_address\>"
 syntax match pfmainRef "$\<lmtp_bind_address6\>"
 syntax match pfmainRef "$\<lmtp_body_checks\>"
+syntax match pfmainRef "$\<lmtp_cache_connection\>"
 syntax match pfmainRef "$\<lmtp_cname_overrides_servername\>"
 syntax match pfmainRef "$\<lmtp_connect_timeout\>"
 syntax match pfmainRef "$\<lmtp_connection_cache_destinations\>"
 syntax match pfmainRef "$\<lmtp_connection_cache_on_demand\>"
 syntax match pfmainRef "$\<lmtp_connection_cache_time_limit\>"
+syntax match pfmainRef "$\<lmtp_connection_reuse_count_limit\>"
 syntax match pfmainRef "$\<lmtp_connection_reuse_time_limit\>"
 syntax match pfmainRef "$\<lmtp_data_done_timeout\>"
 syntax match pfmainRef "$\<lmtp_data_init_timeout\>"
 syntax match pfmainRef "$\<lmtp_data_xfer_timeout\>"
 syntax match pfmainRef "$\<lmtp_defer_if_no_mx_address_found\>"
+syntax match pfmainRef "$\<lmtp_delivery_status_filter\>"
 syntax match pfmainRef "$\<lmtp_destination_concurrency_limit\>"
 syntax match pfmainRef "$\<lmtp_destination_recipient_limit\>"
 syntax match pfmainRef "$\<lmtp_discard_lhlo_keyword_address_maps\>"
 syntax match pfmainRef "$\<lmtp_discard_lhlo_keywords\>"
+syntax match pfmainRef "$\<lmtp_dns_reply_filter\>"
 syntax match pfmainRef "$\<lmtp_dns_resolver_options\>"
+syntax match pfmainRef "$\<lmtp_dns_support_level\>"
 syntax match pfmainRef "$\<lmtp_enforce_tls\>"
 syntax match pfmainRef "$\<lmtp_generic_maps\>"
 syntax match pfmainRef "$\<lmtp_header_checks\>"
@@ -954,9 +1042,11 @@
 syntax match pfmainRef "$\<lmtp_sasl_tls_security_options\>"
 syntax match pfmainRef "$\<lmtp_sasl_tls_verified_security_options\>"
 syntax match pfmainRef "$\<lmtp_sasl_type\>"
+syntax match pfmainRef "$\<lmtp_send_dummy_mail_auth\>"
 syntax match pfmainRef "$\<lmtp_send_xforward_command\>"
 syntax match pfmainRef "$\<lmtp_sender_dependent_authentication\>"
 syntax match pfmainRef "$\<lmtp_skip_5xx_greeting\>"
+syntax match pfmainRef "$\<lmtp_skip_quit_response\>"
 syntax match pfmainRef "$\<lmtp_starttls_timeout\>"
 syntax match pfmainRef "$\<lmtp_tcp_port\>"
 syntax match pfmainRef "$\<lmtp_tls_CAfile\>"
@@ -972,6 +1062,7 @@
 syntax match pfmainRef "$\<lmtp_tls_exclude_ciphers\>"
 syntax match pfmainRef "$\<lmtp_tls_fingerprint_cert_match\>"
 syntax match pfmainRef "$\<lmtp_tls_fingerprint_digest\>"
+syntax match pfmainRef "$\<lmtp_tls_force_insecure_host_tlsa_lookup\>"
 syntax match pfmainRef "$\<lmtp_tls_key_file\>"
 syntax match pfmainRef "$\<lmtp_tls_loglevel\>"
 syntax match pfmainRef "$\<lmtp_tls_mandatory_ciphers\>"
@@ -982,11 +1073,16 @@
 syntax match pfmainRef "$\<lmtp_tls_policy_maps\>"
 syntax match pfmainRef "$\<lmtp_tls_protocols\>"
 syntax match pfmainRef "$\<lmtp_tls_scert_verifydepth\>"
+syntax match pfmainRef "$\<lmtp_tls_secure_cert_match\>"
+syntax match pfmainRef "$\<lmtp_tls_security_level\>"
+syntax match pfmainRef "$\<lmtp_tls_session_cache_database\>"
 syntax match pfmainRef "$\<lmtp_tls_session_cache_timeout\>"
+syntax match pfmainRef "$\<lmtp_tls_trust_anchor_file\>"
 syntax match pfmainRef "$\<lmtp_tls_verify_cert_match\>"
 syntax match pfmainRef "$\<lmtp_use_tls\>"
 syntax match pfmainRef "$\<lmtp_xforward_timeout\>"
 syntax match pfmainRef "$\<local_command_shell\>"
+syntax match pfmainRef "$\<local_delivery_status_filter\>"
 syntax match pfmainRef "$\<local_destination_concurrency_limit\>"
 syntax match pfmainRef "$\<local_destination_recipient_limit\>"
 syntax match pfmainRef "$\<local_header_rewrite_clients\>"
@@ -1008,17 +1104,19 @@
 syntax match pfmainRef "$\<manpage_directory\>"
 syntax match pfmainRef "$\<maps_rbl_domains\>"
 syntax match pfmainRef "$\<maps_rbl_reject_code\>"
-syntax match pfmainRef "$\<master_service_disable\>"
 syntax match pfmainRef "$\<masquerade_classes\>"
 syntax match pfmainRef "$\<masquerade_domains\>"
 syntax match pfmainRef "$\<masquerade_exceptions\>"
+syntax match pfmainRef "$\<master_service_disable\>"
 syntax match pfmainRef "$\<max_idle\>"
 syntax match pfmainRef "$\<max_use\>"
 syntax match pfmainRef "$\<maximal_backoff_time\>"
 syntax match pfmainRef "$\<maximal_queue_lifetime\>"
+syntax match pfmainRef "$\<message_drop_headers\>"
 syntax match pfmainRef "$\<message_reject_characters\>"
 syntax match pfmainRef "$\<message_size_limit\>"
 syntax match pfmainRef "$\<message_strip_characters\>"
+syntax match pfmainRef "$\<meta_directory\>"
 syntax match pfmainRef "$\<milter_command_timeout\>"
 syntax match pfmainRef "$\<milter_connect_macros\>"
 syntax match pfmainRef "$\<milter_connect_timeout\>"
@@ -1056,10 +1154,12 @@
 syntax match pfmainRef "$\<non_fqdn_reject_code\>"
 syntax match pfmainRef "$\<non_smtpd_milters\>"
 syntax match pfmainRef "$\<notify_classes\>"
+syntax match pfmainRef "$\<nullmx_reject_code\>"
 syntax match pfmainRef "$\<owner_request_special\>"
 syntax match pfmainRef "$\<parent_domain_matches_subdomains\>"
 syntax match pfmainRef "$\<permit_mx_backup_networks\>"
 syntax match pfmainRef "$\<pickup_service_name\>"
+syntax match pfmainRef "$\<pipe_delivery_status_filter\>"
 syntax match pfmainRef "$\<plaintext_reject_code\>"
 syntax match pfmainRef "$\<postmulti_control_commands\>"
 syntax match pfmainRef "$\<postmulti_start_commands\>"
@@ -1083,7 +1183,9 @@
 syntax match pfmainRef "$\<postscreen_dnsbl_reply_map\>"
 syntax match pfmainRef "$\<postscreen_dnsbl_sites\>"
 syntax match pfmainRef "$\<postscreen_dnsbl_threshold\>"
+syntax match pfmainRef "$\<postscreen_dnsbl_timeout\>"
 syntax match pfmainRef "$\<postscreen_dnsbl_ttl\>"
+syntax match pfmainRef "$\<postscreen_dnsbl_whitelist_threshold\>"
 syntax match pfmainRef "$\<postscreen_enforce_tls\>"
 syntax match pfmainRef "$\<postscreen_expansion_filter\>"
 syntax match pfmainRef "$\<postscreen_forbidden_commands\>"
@@ -1102,9 +1204,8 @@
 syntax match pfmainRef "$\<postscreen_pre_queue_limit\>"
 syntax match pfmainRef "$\<postscreen_reject_footer\>"
 syntax match pfmainRef "$\<postscreen_tls_security_level\>"
-syntax match pfmainRef "$\<lmtp_tls_secure_cert_match\>"
-syntax match pfmainRef "$\<lmtp_tls_security_level\>"
-syntax match pfmainRef "$\<lmtp_tls_session_cache_database\>"
+syntax match pfmainRef "$\<postscreen_upstream_proxy_protocol\>"
+syntax match pfmainRef "$\<postscreen_upstream_proxy_timeout\>"
 syntax match pfmainRef "$\<postscreen_use_tls\>"
 syntax match pfmainRef "$\<postscreen_watchdog_timeout\>"
 syntax match pfmainRef "$\<postscreen_whitelist_interfaces\>"
@@ -1119,7 +1220,9 @@
 syntax match pfmainRef "$\<proxymap_service_name\>"
 syntax match pfmainRef "$\<proxywrite_service_name\>"
 syntax match pfmainRef "$\<qmgr_clog_warn_time\>"
+syntax match pfmainRef "$\<qmgr_daemon_timeout\>"
 syntax match pfmainRef "$\<qmgr_fudge_factor\>"
+syntax match pfmainRef "$\<qmgr_ipc_timeout\>"
 syntax match pfmainRef "$\<qmgr_message_active_limit\>"
 syntax match pfmainRef "$\<qmgr_message_recipient_limit\>"
 syntax match pfmainRef "$\<qmgr_message_recipient_minimum\>"
@@ -1159,17 +1262,21 @@
 syntax match pfmainRef "$\<rewrite_service_name\>"
 syntax match pfmainRef "$\<sample_directory\>"
 syntax match pfmainRef "$\<send_cyrus_sasl_authzid\>"
+syntax match pfmainRef "$\<sender_based_routing\>"
 syntax match pfmainRef "$\<sender_bcc_maps\>"
 syntax match pfmainRef "$\<sender_canonical_classes\>"
 syntax match pfmainRef "$\<sender_canonical_maps\>"
 syntax match pfmainRef "$\<sender_dependent_default_transport_maps\>"
 syntax match pfmainRef "$\<sender_dependent_relayhost_maps\>"
+syntax match pfmainRef "$\<sendmail_fix_line_endings\>"
 syntax match pfmainRef "$\<sendmail_path\>"
 syntax match pfmainRef "$\<service_throttle_time\>"
 syntax match pfmainRef "$\<setgid_group\>"
+syntax match pfmainRef "$\<shlib_directory\>"
 syntax match pfmainRef "$\<show_user_unknown_table_name\>"
 syntax match pfmainRef "$\<showq_service_name\>"
 syntax match pfmainRef "$\<smtp_address_preference\>"
+syntax match pfmainRef "$\<smtp_address_verify_target\>"
 syntax match pfmainRef "$\<smtp_always_send_ehlo\>"
 syntax match pfmainRef "$\<smtp_bind_address\>"
 syntax match pfmainRef "$\<smtp_bind_address6\>"
@@ -1179,16 +1286,20 @@
 syntax match pfmainRef "$\<smtp_connection_cache_destinations\>"
 syntax match pfmainRef "$\<smtp_connection_cache_on_demand\>"
 syntax match pfmainRef "$\<smtp_connection_cache_time_limit\>"
+syntax match pfmainRef "$\<smtp_connection_reuse_count_limit\>"
 syntax match pfmainRef "$\<smtp_connection_reuse_time_limit\>"
 syntax match pfmainRef "$\<smtp_data_done_timeout\>"
 syntax match pfmainRef "$\<smtp_data_init_timeout\>"
 syntax match pfmainRef "$\<smtp_data_xfer_timeout\>"
 syntax match pfmainRef "$\<smtp_defer_if_no_mx_address_found\>"
+syntax match pfmainRef "$\<smtp_delivery_status_filter\>"
 syntax match pfmainRef "$\<smtp_destination_concurrency_limit\>"
 syntax match pfmainRef "$\<smtp_destination_recipient_limit\>"
 syntax match pfmainRef "$\<smtp_discard_ehlo_keyword_address_maps\>"
 syntax match pfmainRef "$\<smtp_discard_ehlo_keywords\>"
+syntax match pfmainRef "$\<smtp_dns_reply_filter\>"
 syntax match pfmainRef "$\<smtp_dns_resolver_options\>"
+syntax match pfmainRef "$\<smtp_dns_support_level\>"
 syntax match pfmainRef "$\<smtp_enforce_tls\>"
 syntax match pfmainRef "$\<smtp_fallback_relay\>"
 syntax match pfmainRef "$\<smtp_generic_maps\>"
@@ -1203,6 +1314,7 @@
 syntax match pfmainRef "$\<smtp_mx_session_limit\>"
 syntax match pfmainRef "$\<smtp_nested_header_checks\>"
 syntax match pfmainRef "$\<smtp_never_send_ehlo\>"
+syntax match pfmainRef "$\<smtp_per_record_deadline\>"
 syntax match pfmainRef "$\<smtp_pix_workaround_delay_time\>"
 syntax match pfmainRef "$\<smtp_pix_workaround_maps\>"
 syntax match pfmainRef "$\<smtp_pix_workaround_threshold_time\>"
@@ -1224,8 +1336,10 @@
 syntax match pfmainRef "$\<smtp_sasl_tls_security_options\>"
 syntax match pfmainRef "$\<smtp_sasl_tls_verified_security_options\>"
 syntax match pfmainRef "$\<smtp_sasl_type\>"
+syntax match pfmainRef "$\<smtp_send_dummy_mail_auth\>"
 syntax match pfmainRef "$\<smtp_send_xforward_command\>"
 syntax match pfmainRef "$\<smtp_sender_dependent_authentication\>"
+syntax match pfmainRef "$\<smtp_skip_4xx_greeting\>"
 syntax match pfmainRef "$\<smtp_skip_5xx_greeting\>"
 syntax match pfmainRef "$\<smtp_skip_quit_response\>"
 syntax match pfmainRef "$\<smtp_starttls_timeout\>"
@@ -1243,6 +1357,7 @@
 syntax match pfmainRef "$\<smtp_tls_exclude_ciphers\>"
 syntax match pfmainRef "$\<smtp_tls_fingerprint_cert_match\>"
 syntax match pfmainRef "$\<smtp_tls_fingerprint_digest\>"
+syntax match pfmainRef "$\<smtp_tls_force_insecure_host_tlsa_lookup\>"
 syntax match pfmainRef "$\<smtp_tls_key_file\>"
 syntax match pfmainRef "$\<smtp_tls_loglevel\>"
 syntax match pfmainRef "$\<smtp_tls_mandatory_ciphers\>"
@@ -1257,7 +1372,9 @@
 syntax match pfmainRef "$\<smtp_tls_security_level\>"
 syntax match pfmainRef "$\<smtp_tls_session_cache_database\>"
 syntax match pfmainRef "$\<smtp_tls_session_cache_timeout\>"
+syntax match pfmainRef "$\<smtp_tls_trust_anchor_file\>"
 syntax match pfmainRef "$\<smtp_tls_verify_cert_match\>"
+syntax match pfmainRef "$\<smtp_tls_wrappermode\>"
 syntax match pfmainRef "$\<smtp_use_tls\>"
 syntax match pfmainRef "$\<smtp_xforward_timeout\>"
 syntax match pfmainRef "$\<smtpd_authorized_verp_clients\>"
@@ -1278,6 +1395,7 @@
 syntax match pfmainRef "$\<smtpd_delay_reject\>"
 syntax match pfmainRef "$\<smtpd_discard_ehlo_keyword_address_maps\>"
 syntax match pfmainRef "$\<smtpd_discard_ehlo_keywords\>"
+syntax match pfmainRef "$\<smtpd_dns_reply_filter\>"
 syntax match pfmainRef "$\<smtpd_end_of_data_restrictions\>"
 syntax match pfmainRef "$\<smtpd_enforce_tls\>"
 syntax match pfmainRef "$\<smtpd_error_sleep_time\>"
@@ -1289,14 +1407,19 @@
 syntax match pfmainRef "$\<smtpd_helo_restrictions\>"
 syntax match pfmainRef "$\<smtpd_history_flush_threshold\>"
 syntax match pfmainRef "$\<smtpd_junk_command_limit\>"
+syntax match pfmainRef "$\<smtpd_log_access_permit_actions\>"
 syntax match pfmainRef "$\<smtpd_milters\>"
 syntax match pfmainRef "$\<smtpd_noop_commands\>"
 syntax match pfmainRef "$\<smtpd_null_access_lookup_key\>"
 syntax match pfmainRef "$\<smtpd_peername_lookup\>"
 syntax match pfmainRef "$\<smtpd_per_record_deadline\>"
+syntax match pfmainRef "$\<smtpd_policy_service_default_action\>"
 syntax match pfmainRef "$\<smtpd_policy_service_max_idle\>"
 syntax match pfmainRef "$\<smtpd_policy_service_max_ttl\>"
+syntax match pfmainRef "$\<smtpd_policy_service_request_limit\>"
+syntax match pfmainRef "$\<smtpd_policy_service_retry_delay\>"
 syntax match pfmainRef "$\<smtpd_policy_service_timeout\>"
+syntax match pfmainRef "$\<smtpd_policy_service_try_limit\>"
 syntax match pfmainRef "$\<smtpd_proxy_ehlo\>"
 syntax match pfmainRef "$\<smtpd_proxy_filter\>"
 syntax match pfmainRef "$\<smtpd_proxy_options\>"
@@ -1307,13 +1430,16 @@
 syntax match pfmainRef "$\<smtpd_reject_footer\>"
 syntax match pfmainRef "$\<smtpd_reject_unlisted_recipient\>"
 syntax match pfmainRef "$\<smtpd_reject_unlisted_sender\>"
+syntax match pfmainRef "$\<smtpd_relay_restrictions\>"
 syntax match pfmainRef "$\<smtpd_restriction_classes\>"
+syntax match pfmainRef "$\<smtpd_sasl_application_name\>"
 syntax match pfmainRef "$\<smtpd_sasl_auth_enable\>"
 syntax match pfmainRef "$\<smtpd_sasl_authenticated_header\>"
 syntax match pfmainRef "$\<smtpd_sasl_exceptions_networks\>"
 syntax match pfmainRef "$\<smtpd_sasl_local_domain\>"
 syntax match pfmainRef "$\<smtpd_sasl_path\>"
 syntax match pfmainRef "$\<smtpd_sasl_security_options\>"
+syntax match pfmainRef "$\<smtpd_sasl_service\>"
 syntax match pfmainRef "$\<smtpd_sasl_tls_security_options\>"
 syntax match pfmainRef "$\<smtpd_sasl_type\>"
 syntax match pfmainRef "$\<smtpd_sender_login_maps\>"
@@ -1352,21 +1478,21 @@
 syntax match pfmainRef "$\<smtpd_tls_session_cache_database\>"
 syntax match pfmainRef "$\<smtpd_tls_session_cache_timeout\>"
 syntax match pfmainRef "$\<smtpd_tls_wrappermode\>"
+syntax match pfmainRef "$\<smtpd_upstream_proxy_protocol\>"
+syntax match pfmainRef "$\<smtpd_upstream_proxy_timeout\>"
 syntax match pfmainRef "$\<smtpd_use_tls\>"
+syntax match pfmainRef "$\<smtputf8_autodetect_classes\>"
+syntax match pfmainRef "$\<smtputf8_enable\>"
 syntax match pfmainRef "$\<soft_bounce\>"
 syntax match pfmainRef "$\<stale_lock_time\>"
 syntax match pfmainRef "$\<stress\>"
 syntax match pfmainRef "$\<strict_7bit_headers\>"
 syntax match pfmainRef "$\<strict_8bitmime\>"
 syntax match pfmainRef "$\<strict_8bitmime_body\>"
-syntax match pfmainRef "$\<strict_mime_encoding_domain\>"
-syntax match pfmainRef "$\<strict_rfc821_envelopes\>"
-syntax match pfmainRef "$\<strict_7bit_headers\>"
-syntax match pfmainRef "$\<strict_8bitmime\>"
-syntax match pfmainRef "$\<strict_8bitmime_body\>"
 syntax match pfmainRef "$\<strict_mailbox_ownership\>"
 syntax match pfmainRef "$\<strict_mime_encoding_domain\>"
 syntax match pfmainRef "$\<strict_rfc821_envelopes\>"
+syntax match pfmainRef "$\<strict_smtputf8\>"
 syntax match pfmainRef "$\<sun_mailtool_compatibility\>"
 syntax match pfmainRef "$\<swap_bangpath\>"
 syntax match pfmainRef "$\<syslog_facility\>"
@@ -1374,11 +1500,15 @@
 syntax match pfmainRef "$\<tcp_windowsize\>"
 syntax match pfmainRef "$\<tls_append_default_CA\>"
 syntax match pfmainRef "$\<tls_daemon_random_bytes\>"
+syntax match pfmainRef "$\<tls_dane_digest_agility\>"
+syntax match pfmainRef "$\<tls_dane_digests\>"
+syntax match pfmainRef "$\<tls_dane_trust_anchor_digest_enable\>"
 syntax match pfmainRef "$\<tls_disable_workarounds\>"
 syntax match pfmainRef "$\<tls_eecdh_strong_curve\>"
 syntax match pfmainRef "$\<tls_eecdh_ultra_curve\>"
 syntax match pfmainRef "$\<tls_export_cipherlist\>"
 syntax match pfmainRef "$\<tls_high_cipherlist\>"
+syntax match pfmainRef "$\<tls_legacy_public_key_fingerprints\>"
 syntax match pfmainRef "$\<tls_low_cipherlist\>"
 syntax match pfmainRef "$\<tls_medium_cipherlist\>"
 syntax match pfmainRef "$\<tls_null_cipherlist\>"
@@ -1388,6 +1518,10 @@
 syntax match pfmainRef "$\<tls_random_prng_update_period\>"
 syntax match pfmainRef "$\<tls_random_reseed_period\>"
 syntax match pfmainRef "$\<tls_random_source\>"
+syntax match pfmainRef "$\<tls_session_ticket_cipher\>"
+syntax match pfmainRef "$\<tls_ssl_options\>"
+syntax match pfmainRef "$\<tls_wildcard_matches_multiple_labels\>"
+syntax match pfmainRef "$\<tlsmgr_service_name\>"
 syntax match pfmainRef "$\<tlsproxy_enforce_tls\>"
 syntax match pfmainRef "$\<tlsproxy_service_name\>"
 syntax match pfmainRef "$\<tlsproxy_tls_CAfile\>"
@@ -1435,6 +1569,7 @@
 syntax match pfmainRef "$\<transport_recipient_refill_delay\>"
 syntax match pfmainRef "$\<transport_recipient_refill_limit\>"
 syntax match pfmainRef "$\<transport_retry_time\>"
+syntax match pfmainRef "$\<transport_time_limit\>"
 syntax match pfmainRef "$\<trigger_timeout\>"
 syntax match pfmainRef "$\<undisclosed_recipients_header\>"
 syntax match pfmainRef "$\<unknown_address_reject_code\>"
@@ -1455,10 +1590,12 @@
 syntax match pfmainRef "$\<unverified_sender_reject_reason\>"
 syntax match pfmainRef "$\<unverified_sender_tempfail_action\>"
 syntax match pfmainRef "$\<verp_delimiter_filter\>"
+syntax match pfmainRef "$\<virtual_alias_address_length_limit\>"
 syntax match pfmainRef "$\<virtual_alias_domains\>"
 syntax match pfmainRef "$\<virtual_alias_expansion_limit\>"
 syntax match pfmainRef "$\<virtual_alias_maps\>"
 syntax match pfmainRef "$\<virtual_alias_recursion_limit\>"
+syntax match pfmainRef "$\<virtual_delivery_status_filter\>"
 syntax match pfmainRef "$\<virtual_destination_concurrency_limit\>"
 syntax match pfmainRef "$\<virtual_destination_recipient_limit\>"
 syntax match pfmainRef "$\<virtual_gid_maps\>"
@@ -1467,39 +1604,62 @@
 syntax match pfmainRef "$\<virtual_mailbox_limit\>"
 syntax match pfmainRef "$\<virtual_mailbox_lock\>"
 syntax match pfmainRef "$\<virtual_mailbox_maps\>"
+syntax match pfmainRef "$\<virtual_maps\>"
 syntax match pfmainRef "$\<virtual_minimum_uid\>"
 syntax match pfmainRef "$\<virtual_transport\>"
 syntax match pfmainRef "$\<virtual_uid_maps\>"
 
+syntax keyword pfmainWord accept
 syntax keyword pfmainWord all
+syntax keyword pfmainWord always
 syntax keyword pfmainWord check_address_map
 syntax keyword pfmainWord check_ccert_access
+syntax keyword pfmainWord check_client_a_access
 syntax keyword pfmainWord check_client_access
+syntax keyword pfmainWord check_client_mx_access
+syntax keyword pfmainWord check_client_ns_access
 syntax keyword pfmainWord check_etrn_access
+syntax keyword pfmainWord check_helo_a_access
 syntax keyword pfmainWord check_helo_access
 syntax keyword pfmainWord check_helo_mx_access
 syntax keyword pfmainWord check_helo_ns_access
 syntax keyword pfmainWord check_policy_service
+syntax keyword pfmainWord check_recipient_a_access
 syntax keyword pfmainWord check_recipient_access
 syntax keyword pfmainWord check_recipient_maps
 syntax keyword pfmainWord check_recipient_mx_access
 syntax keyword pfmainWord check_recipient_ns_access
 syntax keyword pfmainWord check_relay_domains
+syntax keyword pfmainWord check_reverse_client_hostname_a_access
+syntax keyword pfmainWord check_reverse_client_hostname_access
+syntax keyword pfmainWord check_reverse_client_hostname_mx_access
+syntax keyword pfmainWord check_reverse_client_hostname_ns_access
+syntax keyword pfmainWord check_sasl_access
+syntax keyword pfmainWord check_sender_a_access
 syntax keyword pfmainWord check_sender_access
 syntax keyword pfmainWord check_sender_mx_access
 syntax keyword pfmainWord check_sender_ns_access
 syntax keyword pfmainWord class
 syntax keyword pfmainWord client_address
 syntax keyword pfmainWord client_port
+syntax keyword pfmainWord dane
+syntax keyword pfmainWord dane-only
+syntax keyword pfmainWord defer
 syntax keyword pfmainWord defer_if_permit
 syntax keyword pfmainWord defer_if_reject
+syntax keyword pfmainWord defer_unauth_destination
+syntax keyword pfmainWord disabled
 syntax keyword pfmainWord dns
+syntax keyword pfmainWord dnssec
 syntax keyword pfmainWord drop
 syntax keyword pfmainWord dunno
+syntax keyword pfmainWord enabled
+syntax keyword pfmainWord encrypt
 syntax keyword pfmainWord enforce
 syntax keyword pfmainWord envelope_recipient
 syntax keyword pfmainWord envelope_sender
 syntax keyword pfmainWord export
+syntax keyword pfmainWord fingerprint
 syntax keyword pfmainWord header_recipient
 syntax keyword pfmainWord header_sender
 syntax keyword pfmainWord high
@@ -1509,22 +1669,37 @@
 syntax keyword pfmainWord ipv6
 syntax keyword pfmainWord localtime
 syntax keyword pfmainWord low
+syntax keyword pfmainWord may
+syntax keyword pfmainWord maybe
 syntax keyword pfmainWord medium
 syntax keyword pfmainWord native
+syntax keyword pfmainWord never
+syntax keyword pfmainWord no_address_mappings
+syntax keyword pfmainWord no_header_body_checks
+syntax keyword pfmainWord no_header_reply
+syntax keyword pfmainWord no_milters
+syntax keyword pfmainWord no_unknown_recipient_checks
+syntax keyword pfmainWord none
 syntax keyword pfmainWord null
+syntax keyword pfmainWord off
+syntax keyword pfmainWord on
 syntax keyword pfmainWord permit
 syntax keyword pfmainWord permit_auth_destination
+syntax keyword pfmainWord permit_dnswl_client
 syntax keyword pfmainWord permit_inet_interfaces
 syntax keyword pfmainWord permit_mx_backup
 syntax keyword pfmainWord permit_mynetworks
 syntax keyword pfmainWord permit_naked_ip_address
+syntax keyword pfmainWord permit_rhswl_client
 syntax keyword pfmainWord permit_sasl_authenticated
 syntax keyword pfmainWord permit_tls_all_clientcerts
 syntax keyword pfmainWord permit_tls_clientcerts
+syntax keyword pfmainWord quarantine
 syntax keyword pfmainWord reject
 syntax keyword pfmainWord reject_authenticated_sender_login_mismatch
 syntax keyword pfmainWord reject_invalid_helo_hostname
 syntax keyword pfmainWord reject_invalid_hostname
+syntax keyword pfmainWord reject_known_sender_login_mismatch
 syntax keyword pfmainWord reject_maps_rbl
 syntax keyword pfmainWord reject_multi_recipient_bounce
 syntax keyword pfmainWord reject_non_fqdn_helo_hostname
@@ -1537,10 +1712,12 @@
 syntax keyword pfmainWord reject_rhsbl_client
 syntax keyword pfmainWord reject_rhsbl_helo
 syntax keyword pfmainWord reject_rhsbl_recipient
+syntax keyword pfmainWord reject_rhsbl_reverse_client
 syntax keyword pfmainWord reject_rhsbl_sender
 syntax keyword pfmainWord reject_sender_login_mismatch
 syntax keyword pfmainWord reject_unauth_destination
 syntax keyword pfmainWord reject_unauth_pipelining
+syntax keyword pfmainWord reject_unauthenticated_sender_login_mismatch
 syntax keyword pfmainWord reject_unknown_address
 syntax keyword pfmainWord reject_unknown_client
 syntax keyword pfmainWord reject_unknown_client_hostname
@@ -1554,11 +1731,15 @@
 syntax keyword pfmainWord reject_unlisted_sender
 syntax keyword pfmainWord reject_unverified_recipient
 syntax keyword pfmainWord reject_unverified_sender
+syntax keyword pfmainWord secure
+syntax keyword pfmainWord server_name
 syntax keyword pfmainWord sleep
 syntax keyword pfmainWord smtpd_access_maps
-syntax keyword pfmainWord server_name
 syntax keyword pfmainWord speed_adjust
+syntax keyword pfmainWord strong
 syntax keyword pfmainWord subnet
+syntax keyword pfmainWord tempfail
+syntax keyword pfmainWord ultra
 syntax keyword pfmainWord warn_if_reject
 syntax keyword pfmainWord CRYPTOPRO_TLSEXT_BUG
 syntax keyword pfmainWord DONT_INSERT_EMPTY_FRAGMENTS
@@ -1574,7 +1755,7 @@
 syntax keyword pfmainWord TLS_D5_BUG
 syntax keyword pfmainWord TLS_ROLLBACK_BUG
 
-syntax keyword pfmainDict	btree cidr environ hash nis pcre proxy regexp sdbm sdbm static tcp unix
+syntax keyword pfmainDict	btree cidr environ hash nis pcre proxy regexp sdbm static tcp unix
 syntax keyword pfmainQueueDir	incoming active deferred corrupt hold
 syntax keyword pfmainTransport	smtp lmtp unix local relay uucp virtual
 syntax keyword pfmainLock	fcntl flock dotlock
@@ -1588,26 +1769,50 @@
 
 syntax match pfmainSpecial	"\<alias\>"
 syntax match pfmainSpecial	"\<canonical\>"
+syntax match pfmainSpecial	"\<forward\>"
+syntax match pfmainSpecial	"\<generic\>"
+syntax match pfmainSpecial	"\<include\>"
+syntax match pfmainSpecial	"\<virtual\>"
+
+syntax match pfmainSpecial	"\<delay_dotcrlf\>"
+syntax match pfmainSpecial	"\<disable_esmtp\>"
+
+syntax match pfmainSpecial	"\<res_defnames\>"
+syntax match pfmainSpecial	"\<res_dnsrch\>"
+
 syntax match pfmainSpecial	"\<command\>"
 syntax match pfmainSpecial	"\<file\>"
-syntax match pfmainSpecial	"\<forward\>"
+
+syntax match pfmainSpecial	"\<forward_secrecy\>"
+syntax match pfmainSpecial	"\<mutual_auth\>"
+syntax match pfmainSpecial	"\<noactive\>"
 syntax match pfmainSpecial	"\<noanonymous\>"
+syntax match pfmainSpecial	"\<nodictionary\>"
 syntax match pfmainSpecial	"\<noplaintext\>"
+
+syntax match pfmainSpecial	"\<bounce\>"
+syntax match pfmainSpecial	"\<2bounce\>"
+syntax match pfmainSpecial	"\<data\>"
+syntax match pfmainSpecial	"\<delay\>"
+syntax match pfmainSpecial	"\<policy\>"
+syntax match pfmainSpecial	"\<protocol\>"
 syntax match pfmainSpecial	"\<resource\>"
 syntax match pfmainSpecial	"\<software\>"
 
-syntax match pfmainSpecial	"\<bounce\>"
 syntax match pfmainSpecial	"\<cleanup\>"
 syntax match pfmainSpecial	"\<cyrus\>"
-syntax match pfmainSpecial	"\<defer\>"
 syntax match pfmainSpecial	"\<error\>"
 syntax match pfmainSpecial	"\<flush\>"
+syntax match pfmainSpecial	"\<notify\>"
 syntax match pfmainSpecial	"\<pickup\>"
 syntax match pfmainSpecial	"\<postdrop\>"
 syntax match pfmainSpecial	"\<qmgr\>"
+syntax match pfmainSpecial	"\<qmqpd\>"
 syntax match pfmainSpecial	"\<rewrite\>"
 syntax match pfmainSpecial	"\<scache\>"
+syntax match pfmainSpecial	"\<sendmail\>"
 syntax match pfmainSpecial	"\<showq\>"
+syntax match pfmainSpecial	"\<smtpd\>"
 syntax match pfmainSpecial	"\<trace\>"
 syntax match pfmainSpecial	"\<verify\>"
 
