diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index aba8c5f..93a2b4f 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*      For Vim version 7.0aa.  Last change: 2005 Jul 07
+*eval.txt*      For Vim version 7.0aa.  Last change: 2005 Jul 18
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -3979,8 +3979,10 @@
 		{lnum} and {col} in the current window.
 		The syntax ID can be used with |synIDattr()| and
 		|synIDtrans()| to obtain syntax information about text.
+
 		{col} is 1 for the leftmost column, {lnum} is 1 for the first
-		line.
+		line.  'synmaxcol' applies, in a longer line zero is returned.
+
 		When {trans} is non-zero, transparent items are reduced to the
 		item that they reveal.  This is useful when wanting to know
 		the effective color.  When {trans} is zero, the transparent
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index fe4a471..d491351 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 7.0aa.  Last change: 2005 Jul 11
+*options.txt*	For Vim version 7.0aa.  Last change: 2005 Jul 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -5700,11 +5700,14 @@
 	region by listing them: "en_us,en_ca" supports both US and Canadian
 	English, but not words specific for Australia, New Zealand or Great
 	Britain.
-	As a special case the name of a .spl file can be given as-is.  This is
-	mainly for testing purposes.  You must make sure the correct encoding
-	is used, Vim doesn't check it.
+	As a special case the name of a .spl file can be given as-is.  The
+	first "_xx" in the name is removed and used as the region name
+	(_xx is an underscore, two letters and followed by a non-letter).
+	This is mainly for testing purposes.  You must make sure the correct
+	encoding is used, Vim doesn't check it.
 	When 'encoding' is set the word lists are reloaded.  Thus it's a good
-	idea to set 'spelllang' after setting 'encoding'.
+	idea to set 'spelllang' after setting 'encoding' to avoid loading the
+	files twice.
 	How the related spell files are found is explained here: |spell-load|.
 
 						*'spellsuggest'* *'sps'*
@@ -6021,10 +6024,9 @@
 			{not in Vi}
 			{not available when compiled without the |+syntax|
 			feature}
-	Maximum column in which to search for syntax items.  With longer lines
-	some parts may not be highlighted and following text may not be
-	highlighted correctly (e.g., when the start or end of a region is not
-	recognized because it is beyond 'synmaxcol').
+	Maximum column in which to search for syntax items.  In long lines the
+	text after this column is not highlighted and following lines may not
+	be highlighted correctly, because the syntax state is cleared.
 	This helps to avoid very slow redrawing for an XML file that is one
 	long line.
 	Set to zero to remove the limit.
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index 8272543..130c9b3 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 7.0aa.  Last change: 2005 Jul 05
+*syntax.txt*	For Vim version 7.0aa.  Last change: 2005 Jul 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2516,17 +2516,17 @@
 
 Vim understands three types of syntax items:
 
-1. Keyword.
+1. Keyword
    It can only contain keyword characters, according to the 'iskeyword'
    option.  It cannot contain other syntax items.  It will only match with a
    complete word (there are no keyword characters before or after the match).
    The keyword "if" would match in "if(a=b)", but not in "ifdef x", because
    "(" is not a keyword character and "d" is.
 
-2. Match.
+2. Match
    This is a match with a single regexp pattern.
 
-3. Region.
+3. Region
    This starts at a match of the "start" regexp pattern and ends with a match
    with the "end" regexp pattern.  Any other text can appear in between.  A
    "skip" regexp pattern can be used to avoid matching the "end" pattern.
@@ -2565,13 +2565,30 @@
 
 DEFINING CASE						*:syn-case* *E390*
 
-:sy[ntax] case [match|ignore]
+:sy[ntax] case [match | ignore]
 	This defines if the following ":syntax" commands will work with
 	matching case, when using "match", or with ignoring case, when using
 	"ignore".  Note that any items before this are not affected, and all
 	items until the next ":syntax case" command are affected.
 
 
+SPELL CHECKING						*:syn-spell*
+
+:sy[ntax] spell [toplevel | notoplevel | default]
+	This defines where spell checking is to be done for text that is not
+	in a syntax item:
+
+	toplevel:	Text is spell checked.
+	notoplevel:	Text is not spell checked.
+	default:	When there is a @Spell cluster no spell checking.
+
+	For text in syntax items use the @Spell and @NoSpell clusters
+	|spell-syntax|.  When there is no @Spell and no @NoSpell cluster then
+	spell checking is done for "default" and "toplevel".
+
+	To activate spell checking the 'spell' option must be set.
+
+
 DEFINING KEYWORDS					*:syn-keyword*
 
 :sy[ntax] keyword {group-name} [{options}] {keyword} .. [{options}]
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index 989f7d5..7bd9904 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 7.0aa.  Last change: 2005 Jul 13
+*todo.txt*      For Vim version 7.0aa.  Last change: 2005 Jul 18
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -30,9 +30,11 @@
 							*known-bugs*
 -------------------- Known bugs and current work -----------------------
 
-Use vim_strncpy() in more places.
+"at" and "it" text objects: recognize HTML/SGML/XML tag pairs <b>asdf</b>
 
-When going over 'synmaxcol' don't highlight anything, stop regions.
+":e *.foo" completion with file name starting with "+" should be escaped.
+
+VMS patch for term.c also in Vim 6.3 (Zoltan Arpadffy)
 
 Add extra list of file locations.  Can be used with:
     :ltag	      list of matching tags, like :tselect
@@ -93,6 +95,7 @@
 -   Win32: tearoff menu window should have a scrollbar when it's taller than
     the screen.
 
+mblen(NULL, 0) also in Vim 6.3?
 
 
 PLANNED FOR VERSION 7.0:
@@ -1242,6 +1245,8 @@
 
 
 User Friendlier:
+8   Windows install with NSIS: make it possible to do a silent install, see
+    http://nsis.sourceforge.net/Docs/Chapter4.html#4.12
 8   Windows install with install.exe: Use .exe instead of .bat files for
     links, so that command line arguments are passed on unmodified? (Walter
     Briscoe)
@@ -2081,12 +2086,6 @@
 7   Support "-visual <type>" command line argument.
 
 
-VMS:
--   Improvement: rewrite term/TTY handling.
--   Improvement: create VMS GTK runtime libraries on OpenVMS 7.1-2 (today GTK
-    works just on 7.3).
-
-
 Autocommands:
 7   For autocommand events that trigger multiple times per buffer (e.g.,
     CursorHold), go through the list once and cache the result for a specific
diff --git a/runtime/doc/version7.txt b/runtime/doc/version7.txt
index 6a35fcd..4b7a09f 100644
--- a/runtime/doc/version7.txt
+++ b/runtime/doc/version7.txt
@@ -1,4 +1,4 @@
-*version7.txt*  For Vim version 7.0aa.  Last change: 2005 Jul 12
+*version7.txt*  For Vim version 7.0aa.  Last change: 2005 Jul 13
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -448,6 +448,8 @@
 
 Many filetype plugins and others from Nikolai Weibull.
 
+Xquery syntax file. (Jean-Marc Vanel)
+
 Moved all the indent settings from the filetype plugin to the indent file.
 Implemented b:undo_indent to undo indent settings when setting 'filetype' to a
 different value.
diff --git a/runtime/filetype.vim b/runtime/filetype.vim
index 44d8ce7..d8fd0af 100644
--- a/runtime/filetype.vim
+++ b/runtime/filetype.vim
@@ -1,7 +1,7 @@
 " Vim support file to detect file types
 "
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2005 Jul 04
+" Last Change:	2005 Jul 13
 
 " Listen very carefully, I will say this only once
 if exists("did_load_filetypes")
@@ -1812,6 +1812,9 @@
 " Xdg menus
 au BufNewFile,BufRead /etc/xdg/menus/*.menu	setf xml
 
+" Xquery
+au BufNewFile,BufRead *.xq,*.xql,*.xqm,*.xquery,*.xqy	setf xquery
+
 " XSD
 au BufNewFile,BufRead *.xsd			setf xsd
 
diff --git a/runtime/syntax/html.vim b/runtime/syntax/html.vim
index 61bc6c8..a2ffc18 100644
--- a/runtime/syntax/html.vim
+++ b/runtime/syntax/html.vim
@@ -2,7 +2,7 @@
 " Language:	HTML
 " Maintainer:	Claudio Fleiner <claudio@fleiner.com>
 " URL:		http://www.fleiner.com/vim/syntax/html.vim
-" Last Change:  2005 Jul 05
+" Last Change:  2005 Jul 18
 
 " Please check :help html.vim for some comments and a description of the options
 
@@ -27,6 +27,8 @@
 
 syn case ignore
 
+syn spell toplevel
+
 " mark illegal characters
 syn match htmlError "[<>&]"
 
@@ -35,8 +37,8 @@
 syn region  htmlString   contained start=+"+ end=+"+ contains=htmlSpecialChar,javaScriptExpression,@htmlPreproc
 syn region  htmlString   contained start=+'+ end=+'+ contains=htmlSpecialChar,javaScriptExpression,@htmlPreproc
 syn match   htmlValue    contained "=[\t ]*[^'" \t>][^ \t>]*"hs=s+1   contains=javaScriptExpression,@htmlPreproc
-syn region  htmlEndTag		   start=+</+	   end=+>+ contains=htmlTagN,htmlTagError,@NoSpell
-syn region  htmlTag		   start=+<[^/]+   end=+>+ contains=htmlTagN,htmlString,htmlArg,htmlValue,htmlTagError,htmlEvent,htmlCssDefinition,@htmlPreproc,@htmlArgCluster,@NoSpell
+syn region  htmlEndTag		   start=+</+	   end=+>+ contains=htmlTagN,htmlTagError
+syn region  htmlTag		   start=+<[^/]+   end=+>+ contains=htmlTagN,htmlString,htmlArg,htmlValue,htmlTagError,htmlEvent,htmlCssDefinition,@htmlPreproc,@htmlArgCluster
 syn match   htmlTagN     contained +<\s*[-a-zA-Z0-9]\++hs=s+1 contains=htmlTagName,htmlSpecialTagName,@htmlTagNameCluster
 syn match   htmlTagN     contained +</\s*[-a-zA-Z0-9]\++hs=s+2 contains=htmlTagName,htmlSpecialTagName,@htmlTagNameCluster
 syn match   htmlTagError contained "[^>]<"ms=s+1
@@ -116,7 +118,7 @@
 
 if !exists("html_no_rendering")
   " rendering
-  syn cluster htmlTop contains=htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,htmlLink,javaScript,@htmlPreproc
+  syn cluster htmlTop contains=@Spell,htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,htmlLink,javaScript,@htmlPreproc
 
   syn region htmlBold start="<b\>" end="</b>"me=e-4 contains=@htmlTop,htmlBoldUnderline,htmlBoldItalic
   syn region htmlBold start="<strong\>" end="</strong>"me=e-9 contains=@htmlTop,htmlBoldUnderline,htmlBoldItalic
@@ -146,7 +148,7 @@
   syn region htmlItalicUnderlineBold contained start="<b\>" end="</b>"me=e-4 contains=@htmlTop
   syn region htmlItalicUnderlineBold contained start="<strong\>" end="</strong>"me=e-9 contains=@htmlTop
 
-  syn region htmlLink start="<a\>\_[^>]*\<href\>" end="</a>"me=e-4 contains=htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,javaScript,@htmlPreproc
+  syn region htmlLink start="<a\>\_[^>]*\<href\>" end="</a>"me=e-4 contains=@Spell,htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,javaScript,@htmlPreproc
   syn region htmlH1 start="<h1\>" end="</h1>"me=e-5 contains=@htmlTop
   syn region htmlH2 start="<h2\>" end="</h2>"me=e-5 contains=@htmlTop
   syn region htmlH3 start="<h3\>" end="</h3>"me=e-5 contains=@htmlTop
@@ -154,7 +156,7 @@
   syn region htmlH5 start="<h5\>" end="</h5>"me=e-5 contains=@htmlTop
   syn region htmlH6 start="<h6\>" end="</h6>"me=e-5 contains=@htmlTop
   syn region htmlHead start="<head\>" end="</head>"me=e-7 end="<body\>"me=e-5 end="<h[1-6]\>"me=e-3 contains=htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,htmlLink,htmlTitle,javaScript,cssStyle,@htmlPreproc
-  syn region htmlTitle start="<title\>" end="</title>"me=e-8 contains=htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,javaScript,@htmlPreproc
+  syn region htmlTitle start="<title\>" end="</title>"me=e-8 contains=@Spell,htmlTag,htmlEndTag,htmlSpecialChar,htmlPreProc,htmlComment,javaScript,@htmlPreproc
 endif
 
 syn keyword htmlTagName		contained noscript
