diff --git a/runtime/doc/change.txt b/runtime/doc/change.txt
index 4ed7200..77347fb 100644
--- a/runtime/doc/change.txt
+++ b/runtime/doc/change.txt
@@ -1,4 +1,4 @@
-*change.txt*    For Vim version 7.0aa.  Last change: 2004 Dec 24
+*change.txt*    For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -985,10 +985,11 @@
 or copied with the yank "y" command, regardless of whether or not a specific
 register was used (e.g.  "xdd).  This is like the unnamed register is pointing
 to the last used register.  An exception is the '_' register: "_dd does not
-store the deleted text in any register.  Vim uses the contents of this
-register for any put command (p or P) which does not specify a register.
-Additionally you can access it with the name '"'.  This means you have to type
-two double quotes.  Writing to the "" register writes to register "0.
+store the deleted text in any register.
+Vim uses the contents of the unnamed register for any put command (p or P)
+which does not specify a register.  Additionally you can access it with the
+name '"'.  This means you have to type two double quotes.  Writing to the ""
+register writes to register "0.
 {Vi: register contents are lost when changing files, no '"'}
 
 2. Numbered registers "0 to "9		*quote_number* *quote0*	*quote1*
@@ -999,9 +1000,9 @@
    Numbered register 1 contains the text deleted by the most recent delete or
 change command, unless the command specified another register or the text is
 less than one line (the small delete register is used then).  An exception is
-made for these commands: |%|, |(|, |)|, |`|, |/|, |?|, |n|, |N|, |{| and |}|.
-Register "1 is always used then (this is Vi compatible).  The "- register is
-used as well if the delete is within a line.
+made for the delete operator with these movement commands: |%|, |(|, |)|, |`|,
+|/|, |?|, |n|, |N|, |{| and |}|.  Register "1 is always used then (this is Vi
+compatible).  The "- register is used as well if the delete is within a line.
    With each successive deletion or change, Vim shifts the previous contents
 of register 1 into register 2, 2 into 3, and so forth, losing the previous
 contents of register 9.
diff --git a/runtime/doc/editing.txt b/runtime/doc/editing.txt
index 753e2ac..1921fbc 100644
--- a/runtime/doc/editing.txt
+++ b/runtime/doc/editing.txt
@@ -1,4 +1,4 @@
-*editing.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 16
+*editing.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -46,7 +46,7 @@
 			name.  {not in Vi}
 
 All file names are remembered in the buffer list.  When you enter a file name,
-for editing (e.g., with ":e filename") or writing (e.g., with (:w file name"),
+for editing (e.g., with ":e filename") or writing (e.g., with ":w file name"),
 the file name is added to the list.  You can use the buffer list to remember
 which files you edited and to quickly switch from one file to another (e.g.,
 to copy text) with the |CTRL-^| command.  First type the number of the file
@@ -57,7 +57,7 @@
 :f[ile]			Prints the current file name (as typed), the
 			cursor position (unless the 'ruler' option is set),
 			and the file status (readonly, modified, read errors,
-			new file)).  See the 'shortmess' option about how tho
+			new file).  See the 'shortmess' option about how tho
 			make this message shorter.  {Vi does not include
 			column number}
 
@@ -111,7 +111,7 @@
 keep file names short.  When reading or writing files the full name is still
 used, the "~" is only used when displaying file names.  When replacing the
 file name would result in just "~", "~/" is used instead (to avoid confusion
-with 'backupext' set to "~").
+between options set to $HOME with 'backupext' set to "~").
 
 When writing the buffer, the default is to use the current file name.  Thus
 when you give the "ZZ" or ":wq" command, the original file will be
@@ -260,12 +260,12 @@
 
 							*:vi* *:visual*
 :vi[sual][!] [++opt] [+cmd] [file]
-			When entered 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|.
 
 							*:vie* *:view*
 :vie[w] [++opt] [+cmd] file
-			When entered 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}
 
@@ -666,7 +666,7 @@
 			in Vi}
 
 :[count]wN[ext][!] [++opt] [+cmd] [file]		*:wN* *:wNext*
-:[count]wp[revous][!] [++opt] [+cmd] [file]		*:wp* *:wprevious*
+:[count]wp[revious][!] [++opt] [+cmd] [file]		*:wp* *:wprevious*
 			Same as :wnext, but go to previous file instead of
 			next.  {not in Vi}
 
@@ -1402,7 +1402,7 @@
 
    '**' is more sophisticated:
       - It ONLY matches directories.
-      - It matches up to 30  directories deep, so you can use it to search an
+      - It matches up to 30 directories deep, so you can use it to search an
 	entire directory tree
       - The maximum number of levels matched can be given by appending a number
 	to '**'.
diff --git a/runtime/doc/fold.txt b/runtime/doc/fold.txt
index 6644439..2aadd76 100644
--- a/runtime/doc/fold.txt
+++ b/runtime/doc/fold.txt
@@ -1,4 +1,4 @@
-*fold.txt*      For Vim version 7.0aa.  Last change: 2004 Oct 15
+*fold.txt*      For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -279,7 +279,7 @@
 		Create a fold for the lines in {range}.  Works like "zf".
 
 							*zd* *E351*
-zd		Delete one fold at the cursor.  When the cursor is on folded
+zd		Delete one fold at the cursor.  When the cursor is on a folded
 		line, that fold is deleted.  Nested folds are moved one level
 		up.  In Visual mode all folds (partially) in the selected area
 		are deleted.  Careful: This easily deletes more folds than you
@@ -457,7 +457,7 @@
 
 'foldlevel' is a number option: The higher the more folded regions are open.
 When 'foldlevel' is 0, all folds are closed.
-When 'foldlevel' is positive, some folds closed.
+When 'foldlevel' is positive, some folds are closed.
 When 'foldlevel' is very high, all folds are open.
 'foldlevel' is applied when it is changed.  After that manually folds can be
 opened and closed.
diff --git a/runtime/doc/gui.txt b/runtime/doc/gui.txt
index b83acd6..a7da5e0 100644
--- a/runtime/doc/gui.txt
+++ b/runtime/doc/gui.txt
@@ -1,4 +1,4 @@
-*gui.txt*       For Vim version 7.0aa.  Last change: 2004 Jun 15
+*gui.txt*       For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -52,7 +52,8 @@
 	:let bmenu_max_pathlen = 50
 - If the "-U {gvimrc}" command-line option has been used when starting Vim,
   the {gvimrc} file will be read for initializations.  The following
-  initializations are skipped.
+  initializations are skipped.  When {gvimrc} is "NONE" no file will be read
+  for initializations.
 - For Unix and MS-Windows, if the system gvimrc exists, it is sourced.  The
   name of this file is normally "$VIM/gvimrc".  You can check this with
   ":version".  Also see |$VIM|.
diff --git a/runtime/doc/gui_x11.txt b/runtime/doc/gui_x11.txt
index 8dee2a2..2cbc4c9 100644
--- a/runtime/doc/gui_x11.txt
+++ b/runtime/doc/gui_x11.txt
@@ -1,4 +1,4 @@
-*gui_x11.txt*   For Vim version 7.0aa.  Last change: 2004 Jul 02
+*gui_x11.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -437,6 +437,9 @@
 ==============================================================================
 7. KDE version					*gui-kde* *kde* *KDE* *KVim*
 
+NOTE: The KDE version is still under development.  It is not recommended for
+daily work.
+
 The KDE version of Vim works with KDE 2.x and KDE 3.x.
 KVim (name code for gui-kde) does not use traditional X settings for its
 configuration.
diff --git a/runtime/doc/index.txt b/runtime/doc/index.txt
index a0bc07b..a973c59 100644
--- a/runtime/doc/index.txt
+++ b/runtime/doc/index.txt
@@ -1,4 +1,4 @@
-*index.txt*     For Vim version 7.0aa.  Last change: 2004 Dec 24
+*index.txt*     For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -807,6 +807,7 @@
 ------------------------------------------------------------------------------
 |v_CTRL-\_CTRL-N| CTRL-\ CTRL-N	   stop Visual mode
 |v_CTRL-\_CTRL-G| CTRL-\ CTRL-G	   go to mode specified with 'insertmode'
+|v_CTRL-C|	CTRL-C		   stop Visual mode
 |v_CTRL-G|	CTRL-G		   toggle between Visual mode and Select mode
 |v_<BS>|	<BS>		2  Select mode: delete highlighted area
 |v_CTRL-H|	CTRL-H		2  same as <BS>
@@ -814,6 +815,7 @@
 				   command
 |v_CTRL-V|	CTRL-V		   make Visual mode blockwise or stop Visual
 				   mode
+|v_<Esc>|	<Esc>		   stop Visual mode
 |v_CTRL-]|	CTRL-]		   jump to highlighted tag
 |v_!|		!{filter}	2  filter the highlighted lines through the
 				   external command {filter}
diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt
index 8cd8854..4921f1a 100644
--- a/runtime/doc/map.txt
+++ b/runtime/doc/map.txt
@@ -1,4 +1,4 @@
-*map.txt*       For Vim version 7.0aa.  Last change: 2004 Dec 09
+*map.txt*       For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -613,7 +613,7 @@
 <		"#i{CURSOR}"	  is expanded to "#include"
 		">#i{CURSOR}"	  is not expanded
 >
-   :ab ;; <endofline>"
+   :ab ;; <endofline>
 <		"test;;"	  is not expanded
 		"test ;;"	  is expanded to "test <endofline>"
 
@@ -735,7 +735,7 @@
 	how it should appear in your .exrc file, if you choose to go that
 	route.  The first ^V is there to quote the second ^V; the :ab
 	command uses ^V as its own quote character, so you can include quoted
-	whitespace or the | character in the abbreviation.   The :ab command
+	whitespace or the | character in the abbreviation.  The :ab command
 	doesn't do anything special with the ^[ character, so it doesn't need
 	to be quoted.  (Although quoting isn't harmful; that's why typing 7
 	[but not 8!] ^Vs works.)
@@ -750,7 +750,7 @@
 	Later, when the abbreviation is expanded because the user typed in
 	the word "esc", the long form is subjected to the same type of
 	^V interpretation as keyboard input.  So the ^V protects the ^[
-	character from being interpreted as the "exit input-mode" character.
+	character from being interpreted as the "exit Insert mode" character.
 	Instead, the ^[ is inserted into the text.
 
 Expands to: ^[
@@ -778,7 +778,7 @@
 the script, it doesn't know in which script the function was defined.  To
 avoid this problem, use "<SID>" instead of "s:".  The same translation is done
 as for mappings.  This makes it possible to define a call to the function in
-mapping.
+a mapping.
 
 When a local function is executed, it runs in the context of the script it was
 defined in.  This means that new functions and mappings it defines can also
@@ -1054,7 +1054,7 @@
 	 Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d
 
    " Count the number of lines in the range
-   :com! -range -nargs=0 Lines :echo <line2> - <line1> + 1 "lines"
+   :com! -range -nargs=0 Lines  echo <line2> - <line1> + 1 "lines"
 
    " Call a user function (example of <f-args>)
    :com -nargs=* Mycmd call Myfunc(<f-args>)
diff --git a/runtime/doc/motion.txt b/runtime/doc/motion.txt
index 4f9405f..d7f6cbc 100644
--- a/runtime/doc/motion.txt
+++ b/runtime/doc/motion.txt
@@ -1,4 +1,4 @@
-*motion.txt*    For Vim version 7.0aa.  Last change: 2004 Nov 23
+*motion.txt*    For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -831,8 +831,8 @@
 
 							*'^* *`^*
 '^  `^			To the position where the cursor was the last time
-			when Insert mode was stopped  This is used by the |gi|
-			command.  Not set when the |:keepjumps| command
+			when Insert mode was stopped.  This is used by the
+			|gi| command.  Not set when the |:keepjumps| command
 			modifier was used.  {not in Vi}
 
 							*'.* *`.*
diff --git a/runtime/doc/pi_expl.txt b/runtime/doc/pi_expl.txt
index 4c962ff..62ee2c3 100644
--- a/runtime/doc/pi_expl.txt
+++ b/runtime/doc/pi_expl.txt
@@ -1,4 +1,4 @@
-*pi_expl.txt*   For Vim version 7.0aa.  Last change: 2002 Nov 08
+*pi_expl.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by M A Aziz Ahmed
@@ -65,7 +65,7 @@
 The default for this is the setting of splitbelow at the time the plugin is
 loaded.
 
-To control where the windows goes relative to the explorer window when
+To control where the window goes relative to the explorer window when
 splitting vertically, use the variable: >
   let g:explSplitRight=1    " Put new window to the right of the explorer
   let g:explSplitRight=0    " Put new window to the left of the explorer
@@ -77,14 +77,14 @@
 			    " current window
   let g:explStartRight=0    " Put new explorer window to the left of the
 			    " current window
-The default for this set to g:explSplitRight at the time the plugin is loaded.
+The default is the value of g:explSplitRight at the time the plugin is loaded.
 
 To use a different split method for the explorer window, use: >
   let g:explStartBelow=1    " Put new explorer window below the
 			    " current window
   let g:explStartBelow=0    " Put new explorer window above the
 			    " current window
-The default for this set to g:explSplitBelow at the time the plugin is loaded.
+The default is the value of g:explSplitBelow at the time the plugin is loaded.
 
 The start splits allow for the explorer window to be placed in a file browser
 type arrangement, where the directories are shown on the left and the contents
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 51755a1..1f6cefb 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -2520,6 +2520,10 @@
 :vi	editing.txt	/*:vi*
 :vie	editing.txt	/*:vie*
 :view	editing.txt	/*:view*
+:vim	quickfix.txt	/*:vim*
+:vimgrep	quickfix.txt	/*:vimgrep*
+:vimgrepa	quickfix.txt	/*:vimgrepa*
+:vimgrepadd	quickfix.txt	/*:vimgrepadd*
 :visual	editing.txt	/*:visual*
 :visual_example	visual.txt	/*:visual_example*
 :viu	various.txt	/*:viu*
@@ -4951,7 +4955,6 @@
 hebrew.txt	hebrew.txt	/*hebrew.txt*
 help	various.txt	/*help*
 help-context	help.txt	/*help-context*
-help-tags	tags	1
 help-translated	various.txt	/*help-translated*
 help-xterm-window	various.txt	/*help-xterm-window*
 help.txt	help.txt	/*help.txt*
@@ -5601,6 +5604,7 @@
 new-utf-8	version6.txt	/*new-utf-8*
 new-vertsplit	version6.txt	/*new-vertsplit*
 new-vim-server	version6.txt	/*new-vim-server*
+new-vimgrep	version7.txt	/*new-vimgrep*
 new-virtedit	version6.txt	/*new-virtedit*
 news	intro.txt	/*news*
 nextnonblank()	eval.txt	/*nextnonblank()*
diff --git a/runtime/doc/usr_40.txt b/runtime/doc/usr_40.txt
index 9066416..afc3696 100644
--- a/runtime/doc/usr_40.txt
+++ b/runtime/doc/usr_40.txt
@@ -1,4 +1,4 @@
-*usr_40.txt*	For Vim version 7.0aa.  Last change: 2004 Feb 13
+*usr_40.txt*	For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -60,7 +60,8 @@
 different.  The <F2> mapping for Normal mode is still there.  Thus you can map
 the same key differently for each mode.
    Notice that, although this mapping starts in Insert mode, it ends in Normal
-mode.  If you want it to continue in Insert mode, append a "a" to the mapping.
+mode.  If you want it to continue in Insert mode, append an "a" to the
+mapping.
 
 Here is an overview of map commands and in which mode they work:
 
diff --git a/runtime/doc/visual.txt b/runtime/doc/visual.txt
index 4100578..0ff9dfe 100644
--- a/runtime/doc/visual.txt
+++ b/runtime/doc/visual.txt
@@ -1,4 +1,4 @@
-*visual.txt*    For Vim version 7.0aa.  Last change: 2004 Jun 08
+*visual.txt*    For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -46,7 +46,7 @@
 after the Visual area, the character under the cursor is not included.
 
 With "v" the text before the start position and after the end position will
-not be highlighted.  However, All uppercase and non-alpha operators, except
+not be highlighted.  However, all uppercase and non-alpha operators, except
 "~" and "U", will work on whole lines anyway.  See the list of operators
 below.
 
@@ -139,6 +139,9 @@
 If you want to highlight exactly the same area as the last time, you can use
 "gv" |gv| |v_gv|.
 
+							*v_<Esc>*
+<Esc>			In Visual mode: Stop Visual mode.
+
 							*v_CTRL-C*
 CTRL-C			In Visual mode: Stop Visual mode.  When insert mode is
 			pending (the mode message shows
@@ -176,7 +179,7 @@
 that window is adjusted, so that the same Visual area is still selected.  This
 is especially useful to view the start of the Visual area in one window, and
 the end in another.  You can then use <RightMouse> (or <S-LeftMouse> when
-'mousemodel' is "popup") to move either end of the Visual area.
+'mousemodel' is "popup") to drag either end of the Visual area.
 
 ==============================================================================
 4. Operating on the Visual area				*visual-operators*
@@ -362,7 +365,7 @@
 Visual-block Examples					*blockwise-examples*
 With the following text, I will indicate the commands to produce the block and
 the results below. In all cases, the cursor begins on the 'a' in the first
-line if the test text.
+line of the test text.
 The following modeline settings are assumed ":ts=8:sw=4:".
 
 It will be helpful to
diff --git a/runtime/doc/windows.txt b/runtime/doc/windows.txt
index 130b0f5..4ba6d4a 100644
--- a/runtime/doc/windows.txt
+++ b/runtime/doc/windows.txt
@@ -1,4 +1,4 @@
-*windows.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 21
+*windows.txt*   For Vim version 7.0aa.  Last change: 2004 Dec 29
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -877,7 +877,7 @@
 
 			1 #h  "/test/text"		line 1 ~
 			2u    "asdf"			line 0 ~
-			3 %l+ "version.c"		line 1 ~
+			3 %a+ "version.c"		line 1 ~
 
 		When the [!] is included the list will show unlisted buffers
 		(the term "unlisted" is a bit confusing then...).
