diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt
index 17d8a52..62bc062 100644
--- a/runtime/doc/editing.txt
+++ b/runtime/doc/editing.txt
@@ -276,7 +276,7 @@
 
 							*:vie* *:view*
 :vie[w][!] [++opt] [+cmd] file
-			When used in Ex mode: Leave |Ex mode|, go back to
+			When used in Ex mode: Leave |Ex-mode|, go back to
 			Normal mode.  Otherwise same as |:edit|, but set
 			'readonly' option for this buffer.  {not in Vi}
 
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index f731fba..efa5b9d 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 8.0.  Last change: 2017 Mar 04
+*eval.txt*	For Vim version 8.0.  Last change: 2017 Mar 09
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -1904,6 +1904,8 @@
 
 					*v:testing* *testing-variable*
 v:testing	Must be set before using `test_garbagecollect_now()`.
+		Also, when set certain error messages won't be shown for 2
+		seconds. (e.g. "'dictionary' option is empty") 
 
 				*v:this_session* *this_session-variable*
 v:this_session	Full filename of the last loaded or saved session file.  See
@@ -7797,14 +7799,6 @@
 		Set a flag to enable the effect of 'autochdir' before Vim
 		startup has finished.
 
-						*test_disable_char_avail()*
-test_disable_char_avail({expr})
-		When {expr} is 1 the internal char_avail() function will
-		return |FALSE|.  When {expr} is 0 the char_avail() function will
-		function normally.
-		Only use this for a test where typeahead causes the test not
-		to work.  E.g., to trigger the CursorMovedI autocommand event.
-
 test_garbagecollect_now()			 *test_garbagecollect_now()*
 		Like garbagecollect(), but executed right away.  This must
 		only be called directly to avoid any structure to exist
@@ -7840,6 +7834,18 @@
 test_null_string()					*test_null_string()*
 		Return a String that is null. Only useful for testing.
 
+test_override({name}, {val})				*test_override()*
+		Overrides certain parts of Vims internal processing to be able
+		to run tests. Only to be used for testing Vim!
+		The override is enabled when {val} is non-zero and removed
+		when {val} is zero.
+		Current supported values for name are: 
+
+		name	     effect when {val} is non-zero ~
+		redraw       disable the redrawing() function
+		char_avail   disable the char_avail() function
+		ALL	     clear all overrides ({val} is not used)
+
 test_settime({expr})					*test_settime()*
 		Set the time Vim uses internally.  Currently only used for
 		timestamps in the history, as they are used in viminfo, and
diff --git a/runtime/doc/if_pyth.txt b/runtime/doc/if_pyth.txt
index 0be8a31..6f1c202 100644
--- a/runtime/doc/if_pyth.txt
+++ b/runtime/doc/if_pyth.txt
@@ -1,4 +1,4 @@
-*if_pyth.txt*   For Vim version 8.0.  Last change: 2017 Feb 18
+*if_pyth.txt*   For Vim version 8.0.  Last change: 2017 Mar 09
 
 
 		  VIM REFERENCE MANUAL    by Paul Moore
@@ -17,6 +17,7 @@
 9. Dynamic loading				|python-dynamic|
 10. Python 3					|python3|
 11. Python X					|python_x|
+12. Building with Python support		|python-building|
 
 {Vi does not have any of these commands}
 
@@ -880,4 +881,26 @@
 	endif
 
 ==============================================================================
+12. Building with Python support			*python-building*
+
+A few hints for building with Python 2 or 3 support.
+
+UNIX
+
+See src/Makefile for how to enable including the Python interface.
+
+On Ubuntu you will want to install these packages for Python 2:
+	python
+	python-dev
+For Python 3:
+	python3
+	pytyon3-dev
+For Python 3.6:
+	python3.6
+	pytyon3.6-dev
+
+If you have more than one version of Python 3, you need to link python3 to the
+one you prefer, before running configure.
+
+==============================================================================
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt
index e644f83..7d723ce 100644
--- a/runtime/doc/map.txt
+++ b/runtime/doc/map.txt
@@ -1,4 +1,4 @@
-*map.txt*       For Vim version 8.0.  Last change: 2016 Oct 15
+*map.txt*       For Vim version 8.0.  Last change: 2017 Mar 10
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -584,7 +584,8 @@
 
 							*map-comments*
 It is not possible to put a comment after these commands, because the '"'
-character is considered to be part of the {lhs} or {rhs}.
+character is considered to be part of the {lhs} or {rhs}. However, one can
+use |", since this starts a new, empty command with a comment.
 
 							*map_bar* *map-bar*
 Since the '|' character is used to separate a map command from the next
diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt
index ba37c87..673d1c5 100644
--- a/runtime/doc/motion.txt
+++ b/runtime/doc/motion.txt
@@ -1,4 +1,4 @@
-*motion.txt*    For Vim version 8.0.  Last change: 2016 Nov 24
+*motion.txt*    For Vim version 8.0.  Last change: 2017 Mar 12
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -193,7 +193,7 @@
 
 							*$* *<End>* *<kEnd>*
 $  or <End>		To the end of the line.  When a count is given also go
-			[count - 1] lines downward |inclusive|.
+			[count - 1] lines downward. |inclusive| motion.
 			In Visual mode the cursor goes to just after the last
 			character in the line.
 			When 'virtualedit' is active, "$" may move the cursor
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 4db9781..9a88edb 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 8.0.  Last change: 2017 Mar 05
+*options.txt*	For Vim version 8.0.  Last change: 2017 Mar 09
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -727,6 +727,7 @@
 	which can be easier to read at certain sizes on certain displays.
 	Setting this option can sometimes cause problems if 'guifont' is set
 	to its default (empty string).
+	NOTE: This option is reset when 'compatible' is set.
 
 			*'autochdir'* *'acd'* *'noautochdir'* *'noacd'*
 'autochdir' 'acd'	boolean (default off)
@@ -760,6 +761,7 @@
 	- Disable the use of 'keymap' (without changing its value).
 	Note that 'arabicshape' and 'delcombine' are not reset (it is a global
 	option).
+	NOTE: This option is reset when 'compatible' is set.
 	Also see |arabic.txt|.
 
 					*'arabicshape'* *'arshape'*
@@ -781,6 +783,7 @@
 	form.
 	Arabic is a complex language which requires other settings, for
 	further details see |arabic.txt|.
+	NOTE: This option is set when 'compatible' is set.
 
 			*'autoindent'* *'ai'* *'noautoindent'* *'noai'*
 'autoindent' 'ai'	boolean	(default off)
@@ -993,6 +996,9 @@
 	the system may refuse to do this.  In that case the "auto" value will
 	again not rename the file.
 
+	NOTE: This option is set to the Vi default value when 'compatible' is
+	set and to the Vim default value when 'compatible' is reset.
+
 						*'backupdir'* *'bdir'*
 'backupdir' 'bdir'	string	(default for Amiga: ".,t:",
 				 for MS-DOS and Win32: ".,$TEMP,c:/tmp,c:/temp"
@@ -1139,6 +1145,7 @@
 <	When they are supported "\n" characters will start a new line.  If the
 	expression evaluates to a |List| this is equal to using each List item
 	as a string and putting "\n" in between them.
+	NOTE: This option is set to "" when 'compatible' is set.
 
 						*'belloff'* *'bo'*
 'belloff' 'bo'		string	(default "")
@@ -1176,8 +1183,8 @@
 	wildmode    More matches in |cmdline-completion| available
 		    (depends on the 'wildmode' setting).
 
-	This is most useful, to fine tune when in insert mode the bell should
-	be rung. For normal mode and ex commands, the bell is often rung to
+	This is most useful to fine tune when in Insert mode the bell should
+	be rung. For Normal mode and Ex commands, the bell is often rung to
 	indicate that an error occurred. It can be silenced by adding the
 	"error" keyword.
 
@@ -1259,6 +1266,7 @@
 	Every wrapped line will continue visually indented (same amount of
 	space as the beginning of that line), thus preserving horizontal blocks
 	of text.
+	NOTE: This option is reset when 'compatible' is set.
 
 						*'breakindentopt'* *'briopt'*
 'breakindentopt' 'briopt' string (default empty)
@@ -1435,6 +1443,8 @@
 		:exe "set cedit=\<Esc>"
 <	|Nvi| also has this option, but it only uses the first character.
 	See |cmdwin|.
+	NOTE: This option is set to the Vim default value when 'compatible'
+	is reset.
 
 				*'charconvert'* *'ccv'* *E202* *E214* *E513*
 'charconvert' 'ccv'	string (default "")
@@ -1743,7 +1753,7 @@
 	   set to its Vim default when 'compatible' is unset.
 	The {effect} column summarises the change when 'compatible' is set.
 
-	option		? set value	effect
+	option		? set value	effect ~
 
 	'allowrevins'	+ off		no CTRL-_ command
 	'antialias'	+ off		don't use antialiased fonts
@@ -1763,7 +1773,7 @@
 	'cscopepathcomp'+ 0		don't show directories in tags list
 	'cscoperelative'+ off		
 	'cscopetag'	+ off		don't use cscope for ":tag"
-	'cscopetagorder'  0		see |cscopetagorder|
+	'cscopetagorder'+ 0		see |cscopetagorder|
 	'cscopeverbose'	+ off		see |cscopeverbose|
 	'delcombine'	+ off		unicode: delete whole char combination
 	'digraph'	+ off		no digraphs
@@ -1813,7 +1823,7 @@
 	'tildeop'	+ off		tilde is not an operator
 	'ttimeout'	+ off		no terminal timeout
 	'undofile'	+ off		don't use an undo file
-	'viminfo'       - {unchanged}	{set vim default only on resetting 'cp'}
+	'viminfo'       - {unchanged}	{set Vim default only on resetting 'cp'}
 	'virtualedit'	+ ""		cursor can only be placed on characters
 	'whichwrap'	& ""		left-right movements don't wrap
 	'wildchar'	& CTRL-E	only when the current value is <Tab>
@@ -1993,7 +2003,7 @@
 	existing line.  'expandtab' has no effect on these characters, a Tab
 	remains a Tab.  If the new indent is greater than on the existing
 	line, the remaining space is filled in the normal manner.
-	NOTE: 'copyindent' is reset when 'compatible' is set.
+	NOTE: This option is reset when 'compatible' is set.
 	Also see 'preserveindent'.
 
 						*'cpoptions'* *'cpo'* *cpo*
@@ -2354,6 +2364,7 @@
 			{not in Vi}
 	Determines how many components of the path to show in a list of tags.
 	See |cscopepathcomp|.
+	NOTE: This option is set to 0 when 'compatible' is set.
 
 						*'cscopeprg'* *'csprg'*
 'cscopeprg' 'csprg'	string	(default "cscope")
@@ -2383,6 +2394,7 @@
 	In the absence of a prefix (-P) for cscope. setting this option enables
 	to use the basename of cscope.out path as the prefix.
 	See |cscoperelative|.
+	NOTE: This option is reset when 'compatible' is set.
 
 				*'cscopetag'* *'cst'* *'nocscopetag'* *'nocst'*
 'cscopetag' 'cst'	boolean (default off)
@@ -2502,6 +2514,7 @@
 	This is useful for Arabic, Hebrew and many other languages where one
 	may have combining characters overtop of base characters, and want
 	to remove only the combining ones.
+	NOTE: This option is reset when 'compatible' is set.
 
 						*'dictionary'* *'dict'*
 'dictionary' 'dict'	string	(default "")
@@ -3422,6 +3435,7 @@
 	The expression will be evaluated in the |sandbox| when set from a
 	modeline, see |sandbox-option|.  That stops the option from working,
 	since changing the buffer text is not allowed.
+	NOTE: This option is set to "" when 'compatible' is set.
 
 					*'formatoptions'* *'fo'*
 'formatoptions' 'fo'	string (Vim default: "tcq", Vi default: "vt")
@@ -4081,31 +4095,6 @@
 	define one.  The default uses a different group for each occasion.
 	See |highlight-default| for the default highlight groups.
 
-				 *'hlsearch'* *'hls'* *'nohlsearch'* *'nohls'*
-'hlsearch' 'hls'	boolean	(default off)
-			global
-			{not in Vi}
-			{not available when compiled without the
-			|+extra_search| feature}
-	When there is a previous search pattern, highlight all its matches.
-	The type of highlighting used can be set with the 'l' occasion in the
-	'highlight' option.  This uses the "Search" highlight group by
-	default.  Note that only the matching text is highlighted, any offsets
-	are not applied.
-	See also: 'incsearch' and |:match|.
-	When you get bored looking at the highlighted matches, you can turn it
-	off with |:nohlsearch|.  This does not change the option value, as
-	soon as you use a search command, the highlighting comes back.
-	'redrawtime' specifies the maximum time spent on finding matches.
-	When the search pattern can match an end-of-line, Vim will try to
-	highlight all of the matched text.  However, this depends on where the
-	search starts.  This will be the first line in the window or the first
-	line below a closed fold.  A match in a previous line which is not
-	drawn may not continue in a newly drawn line.
-	You can specify whether the highlight status is restored on startup
-	with the 'h' flag in 'viminfo' |viminfo-h|.
-	NOTE: This option is reset when 'compatible' is set.
-
 						*'history'* *'hi'*
 'history' 'hi'		number	(Vim default: 50, Vi default: 0,
 						 set to 200 in |defaults.vim|)
@@ -4140,6 +4129,31 @@
 	See |rileft.txt|.
 	NOTE: This option is reset when 'compatible' is set.
 
+				 *'hlsearch'* *'hls'* *'nohlsearch'* *'nohls'*
+'hlsearch' 'hls'	boolean	(default off)
+			global
+			{not in Vi}
+			{not available when compiled without the
+			|+extra_search| feature}
+	When there is a previous search pattern, highlight all its matches.
+	The type of highlighting used can be set with the 'l' occasion in the
+	'highlight' option.  This uses the "Search" highlight group by
+	default.  Note that only the matching text is highlighted, any offsets
+	are not applied.
+	See also: 'incsearch' and |:match|.
+	When you get bored looking at the highlighted matches, you can turn it
+	off with |:nohlsearch|.  This does not change the option value, as
+	soon as you use a search command, the highlighting comes back.
+	'redrawtime' specifies the maximum time spent on finding matches.
+	When the search pattern can match an end-of-line, Vim will try to
+	highlight all of the matched text.  However, this depends on where the
+	search starts.  This will be the first line in the window or the first
+	line below a closed fold.  A match in a previous line which is not
+	drawn may not continue in a newly drawn line.
+	You can specify whether the highlight status is restored on startup
+	with the 'h' flag in 'viminfo' |viminfo-h|.
+	NOTE: This option is reset when 'compatible' is set.
+
 						*'icon'* *'noicon'*
 'icon'			boolean	(default off, on when title can be restored)
 			global
@@ -4419,7 +4433,7 @@
 <	Error messages will be suppressed, unless the 'debug' option contains
 	"msg".
 	See |indent-expression|.
-	NOTE: This option is made empty when 'compatible' is set.
+	NOTE: This option is set to "" when 'compatible' is set.
 
 	The expression will be evaluated in the |sandbox| when set from a
 	modeline, see |sandbox-option|.
@@ -5410,6 +5424,8 @@
 			feature}
 	The number of milliseconds between polls for MzScheme threads.
 	Negative or zero value means no thread scheduling.
+	NOTE: This option is set to the Vim default value when 'compatible'
+	is reset.
 
 							*'nrformats'* *'nf'*
 'nrformats' 'nf'	string	(default "bin,octal,hex",
@@ -5475,7 +5491,8 @@
 	is set. Thus with the Vim default of 4 there is room for a line number
 	up to 999. When the buffer has 1000 lines five columns will be used.
 	The minimum value is 1, the maximum value is 10.
-	NOTE: 'numberwidth' is reset to 8 when 'compatible' is set.
+	NOTE: This option is set to the Vi default value when 'compatible' is
+	set and to the Vim default value when 'compatible' is reset.
 
 						*'omnifunc'* *'ofu'*
 'omnifunc' 'ofu'	string	(default: empty)
@@ -5715,7 +5732,7 @@
 	a Tab.
 	NOTE: When using ">>" multiple times the resulting indent is a mix of
 	tabs and spaces.  You might not like this.
-	NOTE: 'preserveindent' is reset when 'compatible' is set.
+	NOTE: This option is reset when 'compatible' is set.
 	Also see 'copyindent'.
 	Use |:retab| to clean up white space.
 
@@ -6453,9 +6470,6 @@
 	"-f" is not inside the quotes, because it is not part of the command
 	name.  And Vim automagically recognizes the backslashes that are path
 	separators.
-	For Dos 32 bits (DJGPP), you can set the $DJSYSFLAGS environment
-	variable to change the way external commands are executed.  See the
-	libc.inf file of DJGPP.
 	Under MS-Windows, when the executable ends in ".com" it must be
 	included.  Thus setting the shell to "command.com" or "4dos.com"
 	works, but "command" and "4dos" do not work for all commands (e.g.,
@@ -6595,6 +6609,8 @@
 	'shelltemp' is off.
 	The `system()` function does not respect this option and always uses
 	temp files.
+	NOTE: This option is set to the Vim default value when 'compatible'
+	is reset.
 
 						*'shelltype'* *'st'*
 'shelltype' 'st'	number	(default 0)
@@ -6911,7 +6927,7 @@
 	mapping: ":inoremap # X^H#", where ^H is entered with CTRL-V CTRL-H.
 	When using the ">>" command, lines starting with '#' are not shifted
 	right.
-	NOTE: 'smartindent' is reset when 'compatible' is set.
+	NOTE: This option is reset when 'compatible' is set.
 	This option is reset when 'paste' is set and restored when 'paste' is
 	reset.
 
@@ -7566,6 +7582,8 @@
 	   ignore	Ignore case
 	   match	Match case
 	   smart	Ignore case unless an upper case letter is used
+	NOTE: This option is set to the Vi default value when 'compatible' is
+	set and to the Vim default value when 'compatible' is reset.
 
 						*'taglength'* *'tl'*
 'taglength' 'tl'	number	(default 0)
@@ -7712,6 +7730,7 @@
 	compatible terminal.
 	If setting this option does not work (produces a colorless UI)
 	reading |xterm-true-color| might help.
+	NOTE: This option is reset when 'compatible' is set.
 
 						*'terse'* *'noterse'*
 'terse'			boolean	(default off)
@@ -8122,6 +8141,7 @@
 	The undo file is not read when 'undoreload' causes the buffer from
 	before a reload to be saved for undo.
 	When 'undofile' is turned off the undo file is NOT deleted.
+	NOTE: This option is reset when 'compatible' is set.
 
 						*'undolevels'* *'ul'*
 'undolevels' 'ul'	number	(default 100, 1000 for Unix, VMS,
@@ -8377,6 +8397,8 @@
 
 	This option cannot be set from a |modeline| or in the |sandbox|, for
 	security reasons.
+	NOTE: This option is set to the Vim default value when 'compatible'
+	is reset.
 
 					    *'virtualedit'* *'ve'*
 'virtualedit' 've'	string	(default "")
@@ -8405,6 +8427,7 @@
 	The `g$` command will move to the end of the screen line.
 	It doesn't make sense to combine "all" with "onemore", but you will
 	not get a warning for it.
+	NOTE: This option is set to "" when 'compatible' is set.
 
 			*'visualbell'* *'vb'* *'novisualbell'* *'novb'* *beep*
 'visualbell' 'vb'	boolean	(default off)
diff --git a/runtime/doc/pattern.txt b/runtime/doc/pattern.txt
index 027f47b..1496604 100644
--- a/runtime/doc/pattern.txt
+++ b/runtime/doc/pattern.txt
@@ -872,8 +872,8 @@
 	inside the Visual area put it at the start and just before the end of
 	the pattern, e.g.: >
 		/\%Vfoo.*ba\%Vr
-<	This works if "foo bar" (or more) was Visually selected. This: >
-		/\%Vfoo.*ba\%Vr
+<	This also works if only "foo bar" was Visually selected. This: >
+		/\%Vfoo.*bar\%V
 <	would match "foo bar" if the Visual selection continues after the "r".
 	Only works for the current buffer.
 
diff --git a/runtime/doc/quickfix.txt b/runtime/doc/quickfix.txt
index 2430cff..0ee2466 100644
--- a/runtime/doc/quickfix.txt
+++ b/runtime/doc/quickfix.txt
@@ -1,4 +1,4 @@
-*quickfix.txt*  For Vim version 8.0.  Last change: 2016 Nov 04
+*quickfix.txt*  For Vim version 8.0.  Last change: 2017 Mar 06
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -45,10 +45,13 @@
 compiler (see |errorformat| below).
 
 						*location-list* *E776*
-A location list is similar to a quickfix list and contains a list of positions
-in files.  A location list is associated with a window and each window can
-have a separate location list.  A location list can be associated with only
-one window.  The location list is independent of the quickfix list.
+A location list is a window-local quickfix list. You get one after commands
+like `:lvimgrep`, `:lgrep`, `:lhelpgrep`, `:lmake`, etc., which create a
+location list instead of a quickfix list as the corresponding `:vimgrep`,
+`:grep`, `:helpgrep`, `:make` do.
+A location list is associated with a window and each window can have a
+separate location list.  A location list can be associated with only one
+window.  The location list is independent of the quickfix list.
 
 When a window with a location list is split, the new window gets a copy of the
 location list.  When there are no longer any references to a location list,
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 5dc3ac6..68c611b 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -427,6 +427,7 @@
 'macatsui'	options.txt	/*'macatsui'*
 'magic'	options.txt	/*'magic'*
 'makeef'	options.txt	/*'makeef'*
+'makeencoding'	options.txt	/*'makeencoding'*
 'makeprg'	options.txt	/*'makeprg'*
 'mat'	options.txt	/*'mat'*
 'matchpairs'	options.txt	/*'matchpairs'*
@@ -439,6 +440,7 @@
 'maxmemtot'	options.txt	/*'maxmemtot'*
 'mco'	options.txt	/*'mco'*
 'mef'	options.txt	/*'mef'*
+'menc'	options.txt	/*'menc'*
 'menuitems'	options.txt	/*'menuitems'*
 'mesg'	vi_diff.txt	/*'mesg'*
 'mfd'	options.txt	/*'mfd'*
@@ -5348,6 +5350,7 @@
 cino-=	indent.txt	/*cino-=*
 cino->	indent.txt	/*cino->*
 cino-C	indent.txt	/*cino-C*
+cino-E	indent.txt	/*cino-E*
 cino-J	indent.txt	/*cino-J*
 cino-L	indent.txt	/*cino-L*
 cino-M	indent.txt	/*cino-M*
@@ -7887,6 +7890,7 @@
 python-bindeval-objects	if_pyth.txt	/*python-bindeval-objects*
 python-buffer	if_pyth.txt	/*python-buffer*
 python-buffers	if_pyth.txt	/*python-buffers*
+python-building	if_pyth.txt	/*python-building*
 python-chdir	if_pyth.txt	/*python-chdir*
 python-command	if_pyth.txt	/*python-command*
 python-commands	if_pyth.txt	/*python-commands*
@@ -8744,7 +8748,6 @@
 test-functions	usr_41.txt	/*test-functions*
 test_alloc_fail()	eval.txt	/*test_alloc_fail()*
 test_autochdir()	eval.txt	/*test_autochdir()*
-test_disable_char_avail()	eval.txt	/*test_disable_char_avail()*
 test_garbagecollect_now()	eval.txt	/*test_garbagecollect_now()*
 test_ignore_error()	eval.txt	/*test_ignore_error()*
 test_null_channel()	eval.txt	/*test_null_channel()*
@@ -8753,6 +8756,7 @@
 test_null_list()	eval.txt	/*test_null_list()*
 test_null_partial()	eval.txt	/*test_null_partial()*
 test_null_string()	eval.txt	/*test_null_string()*
+test_override()	eval.txt	/*test_override()*
 test_settime()	eval.txt	/*test_settime()*
 testing	eval.txt	/*testing*
 testing-variable	eval.txt	/*testing-variable*
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 95a5dde..67a00be 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 8.0.  Last change: 2017 Mar 05
+*todo.txt*      For Vim version 8.0.  Last change: 2017 Mar 16
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -35,6 +35,12 @@
 							*known-bugs*
 -------------------- Known bugs and current work -----------------------
 
+Using "g<" after ":for x in [1,2,3]|echom x|endfor" looks wrong. (Marcin
+Szamotulski, 2017 Mar 12)
+Also, using Ctrl-C clears the last part.
+
+Test 45 fails on MS-Windows only before resetting 'sw'. Why?
+
 +channel:
 - Try out background make plugin: 
   https://github.com/AndrewVos/vim-make-background
@@ -110,6 +116,14 @@
 
 Memory leak in test97?  The string is actually freed.  Weird.
 
+Include rust files.  Got all permissions?
+
+dict_add_list and dict_add_dict may free item when failing. (2017 Mar 12,
+Nikolai Pavlov, #1555)
+
+Patch to add buffer name argument to taglist().
+Ordering of tags in result of taglist call. (Duncan McDougall, #1194)
+
 Add a toolbar in the terminal.  Can be global, above all windows, or specific
 for one window.
 Use tb_set(winid, [{'text': 'stop', 'cb': callback, 'hi': 'Green'}])
@@ -121,18 +135,23 @@
 
 Json string with trailing \u should be an error. (Lcd)
 
+On MS-Windows with 'clipboard' set to "unnamed" this doesn't work to double
+lines: :g/^/normal yyp   On Unix it works OK.  (Bryce Orgill, 2016 Nov 5)
+Another example 2017 Mar 10.
+
 Multi-byte bug: dv} splits char. (Urtica Dioica, 2017 Jan 9)
 
 When session file has name in argument list but the buffer was deleted, the
 buffer is not deleted when using the session file. (#1393)
 Should add the buffer in hidden state.
 
-When "gf" excludes following ":99", jump to line 99.
-Also when editing a file foo.txt:99 ?
-
 When an item in the quickfix list has a file name that does not exist, behave
 like the item was not a match for :cnext.
 
+Patch to test regexp classes. (Dominique, 2017 Mar 13, #1560)
+Do we need to adjust the implementation?
+Make different classes that depend on the system and that don't.
+
 Wrong diff highlighting with three files. (2016 Oct 20, #1186)
 Also get E749 on exit.
 Another example in #1309
@@ -146,19 +165,11 @@
 When deleting a mark or register, leave a tombstone, so that it's also deleted
 when writing viminfo (and the delete was the most recent action). #1339
 
-Patch to add 'makeencoding', useful when the system encoding differs from
-Vim's 'encoding' setting. (Ken Takata, 2017 Jan 31)
-
-Patch to adjust marks when adding a new line to the end of buffer in diff
-mode. (James McCoy, 2016 Dec 14, #1329)
-
 Suggestion to improve pt-br spell checking. (Marcelo D Montu, 2016 Dec 15,
 #1330)
 
 Error in test_startup_utf8 on Solaris. (Danek Duvall, 2016 Aug 17)
 
-Patch to fix that test87 fails on Arch Linux. (Jesin, 2017 Feb 10)
-
 Completion for :!cmd shows each match twice. #1435
 
 GTK: When adding a timer from 'balloonexpr' it won't fire, because
@@ -176,14 +187,18 @@
 Using CTRL-G_U in InsertCharPre causes trouble for redo. (Israel Chauca
 Fuentes, 2017 Feb 12, #1470)
 
+Check for errors E704 and E705 only does VAR_FUNC, should also do VAR_PARTIAL.
+(Nikolai Pavlov, 2017 Mar 13, #1557)
+Make a function to check for function-like type?
+
 Screen updated delayed when using CTRL-O u in Insert mode.
 (Barlik, #1191)  Perhaps because status message?
 
-Patch to add buffer name argument to taglist().
-Ordering of tags in result of taglist call. (Duncan McDougall, #1194)
-
-Patch to fix that b_ind_has_comment is not correctly reset. (Christian
-Brabandt, 2017 Feb 14, closes #1475)
+Implement optional arguments for functions.
+    func Foo(start, count = 1 all = 1)
+    call Foo(12)
+    call Foo(12, all = 0)
+    call Foo(12, 15, 0)
 
 writefile() does not abort as soon as an error is found. (Nikolai Pavlov,
 2017 Feb 14, #1476)
@@ -237,9 +252,6 @@
 "ci[" does not look for next [ like ci" does look for next ".
 (J.F. 2017 Jan 7)
 
-On MS-Windows with 'clipboard' set to "unnamed" this doesn't work to double
-lines: :g/^/normal yyp   On Unix it works OK.  (Bryce Orgill, 2016 Nov 5)
-
 Patch for wrong cursor position on wrapped line, involving breakindent.
 (Ozaki Kiichi, 2016 Nov 25)
 Does this also fix #1408 ?
@@ -261,9 +273,6 @@
 
 Patch to add Zstandard compressed file support. (Nick Terrell, 2016 Oct 24)
 
-Patch to add new regexp classes :ident:, :keyword:, :fname:.
-(ichizok, 2016 Jan 12, #1373)
-
 Patch to add trim() function. (Bukn, 2016 Nov 25, #1280)
 
 Patch to add MODIFIED_BY to MSVC build file. (Chen Lei, 2016 Nov 24, #1275)
@@ -1061,6 +1070,9 @@
 Patch to improve equivalence classes in regexp patterns.
 (Christian Brabandt, 2013 Jan 16, update Jan 17)
 
+Patch to add new regexp classes :ident:, :keyword:, :fname:.
+(ichizok, 2016 Jan 12, #1373)
+
 Patch with suggestions for starting.txt. (Tony Mechelynck, 2012 Oct 24)
 But use Gnome instead of GTK?
 
diff --git a/runtime/doc/usr_02.txt b/runtime/doc/usr_02.txt
index 566a197..2ccde79 100644
--- a/runtime/doc/usr_02.txt
+++ b/runtime/doc/usr_02.txt
@@ -1,4 +1,4 @@
-*usr_02.txt*	For Vim version 8.0.  Last change: 2016 Jan 16
+*usr_02.txt*	For Vim version 8.0.  Last change: 2017 Mar 14
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -554,7 +554,7 @@
 8) Ex-commands always start with ":", so to go to the :s command help: >
 	:help :s
 
-9) Commands specifically for debugging start with ">".  To go to to the help
+9) Commands specifically for debugging start with ">".  To go to the help
    for the "cont" debug command: >
 	:help >cont
 
diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index 32a8f6d..4bffb47 100644
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -1,4 +1,4 @@
-*usr_41.txt*	For Vim version 8.0.  Last change: 2017 Mar 01
+*usr_41.txt*	For Vim version 8.0.  Last change: 2017 Mar 09
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -922,8 +922,8 @@
 	assert_fails()		assert that a function call fails
 	test_alloc_fail()	make memory allocation fail
 	test_autochdir()	enable 'autochdir' during startup
-	test_disable_char_avail()	test without typeahead
-	test_garbagecollect_now()	free memory right now
+	test_override()		test with Vim internal overrides
+	test_garbagecollect_now()   free memory right now
 	test_ignore_error()	ignore a specific error message
 	test_null_channel()	return a null Channel
 	test_null_dict()	return a null Dict
diff --git a/runtime/doc/version8.txt b/runtime/doc/version8.txt
index 5afe385..c091536 100644
--- a/runtime/doc/version8.txt
+++ b/runtime/doc/version8.txt
@@ -1,4 +1,4 @@
-*version8.txt*  For Vim version 8.0.  Last change: 2017 Feb 24
+*version8.txt*  For Vim version 8.0.  Last change: 2017 Mar 16
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -296,7 +296,7 @@
 |systemlist()|		get the result of a shell command as a list
 |test_alloc_fail()|	make memory allocation fail
 |test_autochdir()|	test 'autochdir' functionality
-|test_disable_char_avail()| test without typeahead
+test_disable_char_avail() test without typeahead (removed later)
 |test_garbagecollect_now()| free memory right now
 |test_null_channel()|	return a null Channel
 |test_null_dict()|	return a null Dict
@@ -426,7 +426,7 @@
 useful default values for new users.  That includes setting 'nocompatible'.
 Thus Vim no longer starts up in Vi compatible mode.  If you do want that,
 either create a .vimrc file that does "set compatible" or start Vim with
-"Vim -C".
+"vim -C".
 
 
 Support removed ~
@@ -1866,7 +1866,7 @@
 	    src/testdir/test60.ok
 
 Patch 7.4.237 (after 7.4.236)
-Problem:    When some patches was not included has("patch-7.4.123") may return
+Problem:    When some patches were not included has("patch-7.4.123") may return
 	    true falsely.
 Solution:   Check for the specific patch number.
 Files:	    runtime/doc/eval.txt, src/eval.c
