Commits

equalsraf committed 18c574e

Import default 3872:1001f417a371

Comments (0)

Files changed (237)

 		src/Make_mvc.mak \
 		src/Make_w16.mak \
 		src/bigvim.bat \
+		src/bigvim64.bat \
 		src/msvcsetup.bat \
 		src/msvc2008.bat \
 		src/msvc2010.bat \
 		src/vim*.ico \
 		src/vim.tlb \
 		src/vimtbar.lib \
+		src/xpm/COPYRIGHT \
+		src/xpm/README.txt \
+		src/xpm/include/*.h \
+		src/xpm/x64/lib/libXpm.a \
+		src/xpm/x64/lib/libXpm.lib \
+		src/xpm/x86/lib/libXpm.a \
+		src/xpm/x86/lib/libXpm.lib \
 		src/vimtbar.dll \
 		nsis/icons/*.bmp \
 		nsis/icons/*.ico \
 		runtime/macros/hanoi/hanoi.vim \
 		runtime/macros/hanoi/poster \
 		runtime/macros/justify.vim \
+		runtime/macros/less.bat \
 		runtime/macros/less.sh \
 		runtime/macros/less.vim \
 		runtime/macros/life/click.me \
 
 # generic language files
 LANG_GEN = \
+		runtime/doc/*-de.1 \
+		runtime/doc/*-de.UTF-8.1 \
 		runtime/doc/*-fr.1 \
 		runtime/doc/*-fr.UTF-8.1 \
 		runtime/doc/*-it.1 \
 		runtime/tutor/Makefile \
 		runtime/tutor/tutor.utf-8 \
 		runtime/tutor/tutor.?? \
-		runtime/tutor/tutor.??.* \
+		runtime/tutor/tutor.??.utf-8 \
+		runtime/tutor/tutor.??.euc \
+		runtime/tutor/tutor.??.sjis \
+		runtime/tutor/tutor.??.iso9 \
+		runtime/tutor/tutor.??.big5 \
+		runtime/tutor/tutor.??.cp1250 \
+		runtime/tutor/tutor.??.cp1251 \
+		runtime/tutor/tutor.??.cp737 \
+		runtime/tutor/tutor.??_??.utf-8 \
 		runtime/tutor/tutor.bar \
-		runtime/tutor/tutor.bar.* \
+		runtime/tutor/tutor.bar.utf-8 \
 		runtime/spell/README.txt \
 		runtime/spell/??/*.diff \
 		runtime/spell/??/main.aap \

runtime/autoload/ccomplete.vim

 " Vim completion script
 " Language:	C
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
-" Last Change:	2011 Dec 30
+" Last Change:	2012 Jun 20
 
 let s:cpo_save = &cpo
 set cpo&vim
   endif
   if !cached
     while 1
-      exe 'silent! ' . n . 'vimgrep /\t' . typename . '\(\t\|$\)/j ' . fnames
+      exe 'silent! keepj noautocmd ' . n . 'vimgrep /\t' . typename . '\(\t\|$\)/j ' . fnames
 
       let qflist = getqflist()
       if len(qflist) > 0 || match(typename, "::") < 0

runtime/autoload/tohtml.vim

 " Vim autoload file for the tohtml plugin.
 " Maintainer: Ben Fritz <fritzophrenic@gmail.com>
-" Last Change: 2011 Apr 05
+" Last Change: 2012 Jun 30
 "
 " Additional contributors:
 "
 
 " this file uses line continuations
 let s:cpo_sav = &cpo
-set cpo-=C
+set cpo&vim
 
 " Automatically find charsets from all encodings supported natively by Vim. With
 " the 8bit- and 2byte- prefixes, Vim can actually support more encodings than
   call add(html, '<meta name="plugin-version" content="'.g:loaded_2html_plugin.'"'.tag_close)
   call add(html, '<meta name="settings" content="'.
 	\ join(filter(keys(s:settings),'s:settings[v:val]'),',').
+	\ ',prevent_copy='.s:settings.prevent_copy.
 	\ '"'.tag_close)
+  call add(html, '<meta name="colorscheme" content="'.
+	\ (exists('g:colors_name')
+	\ ? g:colors_name
+	\ : 'none'). '"'.tag_close)
 
   call add(html, '</head>')
   let body_line_num = len(html)
-  call add(html, '<body>')
-  call add(html, '<table border="1" width="100%">')
+  if !empty(s:settings.prevent_copy)
+    call add(html, "<body onload='FixCharWidth();'>")
+    call add(html, "<!-- hidden divs used by javascript to get the width of a char -->")
+    call add(html, "<div id='oneCharWidth'>0</div>")
+    call add(html, "<div id='oneInputWidth'><input size='1' value='0'".tag_close."</div>")
+    call add(html, "<div id='oneEmWidth' style='width: 1em;'></div>")
+  else
+    call add(html, '<body>')
+  endif
+  call add(html, "<table border='1' width='100%' id='vimCodeElement'>")
 
   call add(html, '<tr>')
   for buf in a:win_list
       let insert_index = diff_style_start
     endif
 
-    " Delete those parts that are not needed so
-    " we can include the rest into the resulting table
-    1,/^<body/d_
+    " Delete those parts that are not needed so we can include the rest into the
+    " resulting table.
+    1,/^<body.*\%(\n<!--.*-->\_s\+.*id='oneCharWidth'.*\_s\+.*id='oneInputWidth'.*\_s\+.*id='oneEmWidth'\)\?\zs/d_
     $
     ?</body>?,$d_
     let temp = getline(1,'$')
+    " clean out id on the main content container because we already set it on
+    " the table
+    let temp[0] = substitute(temp[0], " id='vimCodeElement'", "", "")
     " undo deletion of start and end part
     " so we can later save the file as valid html
     " TODO: restore using grabbed lines if undolevel is 1?
-    normal 2u
+    normal! 2u
     if s:settings.use_css
       call add(html, '<td valign="top"><div>')
     elseif s:settings.use_xhtml
     1
     let style_start = search('^</head>')-1
 
+    " add required javascript in reverse order so we can just call append again
+    " and again without adjusting {{{
+
+    " insert script closing tag if any javascript is needed
+    if s:settings.dynamic_folds || !empty(s:settings.prevent_copy)
+      call append(style_start, [
+	    \ '',
+	    \ s:settings.use_xhtml ? '//]]>' : '-->',
+	    \ "</script>"
+	    \ ])
+    endif
+
+    " insert script which corrects the size of small input elements in
+    " prevent_copy mode. See 2html.vim for details on why this is needed and how
+    " it works.
+    if !empty(s:settings.prevent_copy)
+      call append(style_start, [
+	    \ '',
+	    \ '/* simulate a "ch" unit by asking the browser how big a zero character is */',
+	    \ 'function FixCharWidth() {',
+	    \ '  /* get the hidden element which gives the width of a single character */',
+	    \ '  var goodWidth = document.getElementById("oneCharWidth").clientWidth;',
+	    \ '  /* get all input elements, we''ll filter on class later */',
+	    \ '  var inputTags = document.getElementsByTagName("input");',
+	    \ '  var ratio = 5;',
+	    \ '  var inputWidth = document.getElementById("oneInputWidth").clientWidth;',
+	    \ '  var emWidth = document.getElementById("oneEmWidth").clientWidth;',
+	    \ '  if (inputWidth > goodWidth) {',
+	    \ '    while (ratio < 100*goodWidth/emWidth && ratio < 100) {',
+	    \ '    ratio += 5;',
+	    \ '  }',
+	    \ '  document.getElementById("vimCodeElement").className = "em"+ratio;',
+	    \ '  }',
+	    \ '}'
+	    \ ])
+    endif
+
     " Insert javascript to toggle matching folds open and closed in all windows,
-    " if dynamic folding is active. {{{
+    " if dynamic folding is active.
     if s:settings.dynamic_folds
       call append(style_start, [
-	    \  "<script type='text/javascript'>",
-	    \  s:settings.use_xhtml ? '//<![CDATA[' : "  <!--",
 	    \  "  function toggleFold(objID)",
 	    \  "  {",
 	    \  "    for (win_num = 1; win_num <= ".len(a:buf_list)."; win_num++)",
 	    \  "      }",
 	    \  "    }",
 	    \  "  }",
-	    \  s:settings.use_xhtml ? '//]]>' : "  -->",
-	    \  "</script>"
 	    \ ])
+    endif
+
+    " insert script tag if any javascript is needed
+    if s:settings.dynamic_folds || s:settings.prevent_copy != ""
+      call append(style_start, [
+	    \ "<script type='text/javascript'>",
+	    \ s:settings.use_xhtml ? '//<![CDATA[' : "<!--"])
     endif "}}}
 
     " Insert styles from all the generated html documents and additional styles
     call tohtml#GetOption(user_settings, 'ignore_conceal', 0 )
     call tohtml#GetOption(user_settings, 'ignore_folding', 0 )
     call tohtml#GetOption(user_settings,  'dynamic_folds', 0 )
-    call tohtml#GetOption(user_settings,  'no_foldcolumn', 0 )
+    call tohtml#GetOption(user_settings,  'no_foldcolumn', user_settings.ignore_folding)
     call tohtml#GetOption(user_settings,   'hover_unfold', 0 )
     call tohtml#GetOption(user_settings,         'no_pre', 0 )
+    call tohtml#GetOption(user_settings,     'no_invalid', 0 )
     call tohtml#GetOption(user_settings,   'whole_filler', 0 )
     call tohtml#GetOption(user_settings,      'use_xhtml', 0 )
     " }}}
     " dynamic folding implies css
     if user_settings.dynamic_folds
       let user_settings.use_css = 1
+    else
+      let user_settings.no_foldcolumn = 1 " won't do anything but for consistency and for the test suite
     endif
 
     " if we're not using CSS we cannot use a pre section because <font> tags
     endif
     " }}}
 
+    " textual options
     if exists("g:html_use_encoding") "{{{
       " user specified the desired MIME charset, figure out proper
       " 'fileencoding' from it or warn the user if we cannot
       endif
     endif "}}}
 
+    " Default to making nothing uncopyable, because we default to
+    " not-standards way of doing things, and also because Microsoft Word and
+    " others paste the <input> elements anyway.
+    "
+    " html_prevent_copy only has an effect when using CSS.
+    "
+    " All options:
+    "	  f - fold column
+    "	  n - line numbers (also within fold text)
+    "	  t - fold text
+    "	  d - diff filler
+    "	  c - concealed text (reserved future)
+    "	  l - listchars (reserved possible future)
+    "	  s - signs (reserved possible future)
+    "
+    " Normal text is always selectable.
+    let user_settings.prevent_copy = ""
+    if user_settings.use_css
+      if exists("g:html_prevent_copy")
+	if user_settings.dynamic_folds && !user_settings.no_foldcolumn && g:html_prevent_copy =~# 'f'
+	  let user_settings.prevent_copy .= 'f'
+	endif
+	if user_settings.number_lines && g:html_prevent_copy =~# 'n'
+	  let user_settings.prevent_copy .= 'n'
+	endif
+	if &diff && g:html_prevent_copy =~# 'd'
+	  let user_settings.prevent_copy .= 'd'
+	endif
+	if !user_settings.ignore_folding && g:html_prevent_copy =~# 't'
+	  let user_settings.prevent_copy .= 't'
+	endif
+      else
+	let user_settings.prevent_copy = ""
+      endif
+    endif
+    if empty(user_settings.prevent_copy)
+      let user_settings.no_invalid = 0
+    endif
+
     " TODO: font
 
     return user_settings

runtime/compiler/mcs.vim

 " Vim compiler file
 " Compiler:    Mono C# Compiler
 " Maintainer:  Jarek Sobiecki <harijari@go2.pl>
-" Latest Revision: 2006-06-18
+" Last Updated By: Peter Collingbourne
+" Latest Revision: 2012 Jul 19
 
 if exists("current_compiler")
   finish
 set cpo-=C
 
 setlocal errorformat=
+         \%D%.%#Project\ \"%f/%[%^/\"]%#\"%.%#,
+         \%X%.%#Done\ building\ project\ \"%f/%[%^/\"]%#\"%.%#,
+         \%-G%\\s%.%#,
+         \%E%f(%l):\ error\ CS%n:%m,
+         \%W%f(%l):\ warning\ CS%n:%m,
          \%E%f(%l\\,%c):\ error\ CS%n:%m,
          \%W%f(%l\\,%c):\ warning\ CS%n:%m,
          \%E%>syntax\ error\\,%m,%Z%f(%l\\,%c):\ error\ CS%n:%m,
          \%D%*\\a[%*\\d]:\ Entering\ directory\ `%f',
          \%X%*\\a[%*\\d]:\ Leaving\ directory\ `%f',
          \%DMaking\ %*\\a\ in\ %f,
-         \%G-%.%#
+         \%-G%.%#
 
 let &cpo = s:cpo_save
 unlet s:cpo_save

runtime/doc/autocmd.txt

-*autocmd.txt*   For Vim version 7.3.  Last change: 2012 Feb 22
+*autocmd.txt*   For Vim version 7.3.  Last change: 2012 Sep 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 	Startup and exit
 |VimEnter|		after doing all the startup stuff
 |GUIEnter|		after starting the GUI successfully
+|GUIFailed|		after starting the GUI failed
 |TermResponse|		after the terminal response to |t_RV| is received
 
+|QuitPre|			when using `:quit`, before deciding whether to quit
 |VimLeavePre|		before exiting Vim, before writing the viminfo file
 |VimLeave|		before exiting Vim, after writing the viminfo file
 
 |SessionLoadPost|	after loading a session file
 
 |MenuPopup|		just before showing the popup menu
+|CompleteDone|		after Insert mode completion is done
 
 |User|			to be used in combination with ":doautocmd"
 
 				This does NOT work for ":r file".  Not used
 				when the file doesn't exist.  Also used after
 				successfully recovering a file.
+				Also triggered for the filetypedetect group
+				when executing ":filetype detect" and when
+				writing an unnamed buffer in a way that the
+				buffer gets a name.
 							*BufReadCmd*
 BufReadCmd			Before starting to edit a new buffer.  Should
 				read the file into the buffer. |Cmd-event|
 							*ColorScheme*
 ColorScheme			After loading a color scheme. |:colorscheme|
 
+							*CompleteDone*
+CompleteDone			After Insert mode completion is done.  Either
+				when something was completed or abandoning
+				completion. |ins-completion|
+
 							*CursorHold*
 CursorHold			When the user doesn't press a key for the time
 				specified with 'updatetime'.  Not re-triggered
 				it is run after error file is read and before
 				moving to the first error. 
 				See |QuickFixCmdPost-example|.
+							*QuitPre*
+QuitPre				When using `:quit`, before deciding whether it
+				closes the current window or quits Vim.  Can
+				be used to close any non-essential window if
+				the current window is the last ordinary
+				window.
 							*RemoteReply*
 RemoteReply			When a reply from a Vim that functions as
 				server was received |server2client()|.  The

runtime/doc/change.txt

-*change.txt*    For Vim version 7.3.  Last change: 2012 Apr 30
+*change.txt*    For Vim version 7.3.  Last change: 2012 Aug 08
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 [n]	Report the number of matches, do not actually substitute.  The [c]
 	flag is ignored.  The matches are reported as if 'report' is zero.
 	Useful to |count-items|.
+	If \= |sub-replace-expression| is used, the expression will be
+	evaluated in the |sandbox| at every match.
 
 [p]	Print the line containing the last substitute.
 
 			first line of a paragraph
 		second line of the same paragraph
 		third line.
+<	This also works inside comments, ignoring the comment leader.
 v	Vi-compatible auto-wrapping in insert mode: Only break a line at a
 	blank that you have entered during the current insert command.  (Note:
 	this is not 100% Vi compatible.  Vi has some "unexpected features" or

runtime/doc/cmdline.txt

-*cmdline.txt*   For Vim version 7.3.  Last change: 2012 Feb 05
+*cmdline.txt*   For Vim version 7.3.  Last change: 2012 Jun 20
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 		the home directory.  If the name is a directory a path
 		separator is added at the end.  For a file name that does not
 		exist and does not have an absolute path the result is
-		unpredictable.
+		unpredictable.  On MS-Windows an 8.3 filename is expanded to
+		the long name.
 	:8	Converts the path to 8.3 short format (currently only on
-		win32).  Will act on as much of a path that is an existing
-		path.
+		MS-Windows).  Will act on as much of a path that is an
+		existing path.
 	:~	Reduce file name to be relative to the home directory, if
 		possible.  File name is unmodified if it is not below the home
 		directory.

runtime/doc/diff.txt

-*diff.txt*      For Vim version 7.3.  Last change: 2012 May 18
+*diff.txt*      For Vim version 7.3.  Last change: 2012 Sep 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 While already in Vim you can start diff mode in three ways.
 
 							*E98*
-:diffsplit {filename}					*:diffs* *:diffsplit*
+:diffs[plit] {filename}					*:diffs* *:diffsplit*
 		Open a new window on the file {filename}.  The options are set
 		as for "vimdiff" for the current and the newly opened window.
 		Also see 'diffexpr'.
 
 							*:difft* *:diffthis*
-:diffthis	Make the current window part of the diff windows.  This sets
+:difft[his]	Make the current window part of the diff windows.  This sets
 		the options like for "vimdiff".
 
-:diffpatch {patchfile}				 *E816* *:diffp* *:diffpatch*
+:diffp[atch] {patchfile}				 *E816* *:diffp* *:diffpatch*
 		Use the current buffer, patch it with the diff found in
 		{patchfile} and open a buffer on the result.  The options are
 		set as for "vimdiff".
 file for a moment and come back to the same file and be in diff mode again.
 
 							*:diffo* *:diffoff*
-:diffoff	Switch off diff mode for the current window.
+:diffo[ff]	Switch off diff mode for the current window.
 
-:diffoff!	Switch off diff mode for the current window and in all windows
+:diffo[ff]!	Switch off diff mode for the current window and in all windows
 		in the current tab page where 'diff' is set.
 
 The ":diffoff" command resets the relevant options to their default value.
 
 The "1a2" item appends the line "bbb".
 The "4d4" item deletes the line "111".
-The '7c7" item replaces the line "GGG" with "ggg".
+The "7c7" item replaces the line "GGG" with "ggg".
 
 When 'diffexpr' is not empty, Vim evaluates it to obtain a diff file in the
 format mentioned.  These variables are set to the file names used:

runtime/doc/editing.txt

-*editing.txt*   For Vim version 7.3.  Last change: 2012 Apr 03
+*editing.txt*   For Vim version 7.3.  Last change: 2012 Aug 08
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 embedded spaces must be escaped with a backslash.
 
 						*wildcard* *wildcards*
-Wildcards in {file} are expanded.  Which wildcards are supported depends on
-the system.  These are the common ones:
+Wildcards in {file} are expanded, but as with file completion, 'wildignore'
+and 'suffixes' apply.  Which wildcards are supported depends on the system.
+These are the common ones:
 	?	matches one character
 	*	matches anything, including nothing
 	**	matches anything, including nothing, recurses into directories
 					*starstar-wildcard*
 Expanding "**" is possible on Unix, Win32, Mac OS/X and a few other systems.
 This allows searching a directory tree.  This goes up to 100 directories deep.
-Note there are some commands where this works slightly different, see
+Note there are some commands where this works slightly differently, see
 |file-searching|.
 Example: >
 	:n **/*.txt
 external command, by using the syntax `={expr}` e.g.: >
 	:e `=tempname()`
 The expression can contain just about anything, thus this can also be used to
-avoid the special meaning of '"', '|', '%' and '#'.  Names are to be separated
-with line breaks.  When the result is a |List| then each item is used as a
-name.  Line breaks also separate names.
+avoid the special meaning of '"', '|', '%' and '#'.  However, 'wildignore'
+does apply like to other wildcars.
+If the expression returns a string then names are to be separated with line
+breaks.  When the result is a |List| then each item is used as a name.  Line
+breaks also separate names.
 
 							*++opt* *[++opt]*
 The [++opt] argument can be used to force the value of 'fileformat',
 			If there are other tab pages and quitting the last
 			window in the current tab page the current tab page is
 			closed |tab-page|.
+			Triggers the |QuitPre| autocommand event.
 
 :conf[irm] q[uit]	Quit, but give prompt when changes have been made, or
 			the last file in the argument list has not been
 unmodified.
 
 							*browsefilter*
-For MS Windows, you can modify the filters that are used in the browse dialog.
-By setting the g:browsefilter or b:browsefilter variables, you can change the
-filters globally or locally to the buffer.  The variable is set to a string in
-the format "{filter label}\t{pattern};{pattern}\n" where {filter label} is the
-text that appears in the "Files of Type" comboBox, and {pattern} is the
-pattern which filters the filenames.  Several patterns can be given, separated
-by ';'.
+For MS Windows and GTK, you can modify the filters that are used in the browse
+dialog.  By setting the g:browsefilter or b:browsefilter variables, you can
+change the filters globally or locally to the buffer.  The variable is set to
+a string in the format "{filter label}\t{pattern};{pattern}\n" where {filter
+label} is the text that appears in the "Files of Type" comboBox, and {pattern}
+is the pattern which filters the filenames.  Several patterns can be given,
+separated by ';'.
 
 For Motif the same format is used, but only the very first pattern is actually
 used (Motif only offers one pattern, but you can edit it).
 For example, to have only Vim files in the dialog, you could use the following
 command: >
 
-     let g:browsefilter="Vim Scripts\t*.vim\nVim Startup Files\t*vimrc\n"
+     let g:browsefilter = "Vim Scripts\t*.vim\nVim Startup Files\t*vimrc\n"
 
 You can override the filter setting on a per-buffer basis by setting the
 b:browsefilter variable.  You would most likely set b:browsefilter in a
 may want to add "All Files\t*.*\n" as the final filter, so that the user can
 still access any desired file.
 
+To avoid setting browsefilter when Vim does not actually support it, you can
+use has("browsefilter"): >
+
+	if has("browsefilter")
+	   let g:browsefilter = "whatever"
+	endif
+
 ==============================================================================
 7. The current directory				*current-directory*
 

runtime/doc/eval.txt

-*eval.txt*	For Vim version 7.3.  Last change: 2012 May 18
+*eval.txt*	For Vim version 7.3.  Last change: 2012 Sep 05
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
 a |List| or a |Dictionary| it is equivalent to using "equal", using "isnot"
 equivalent to using "not equal".  Except that a different type means the
 values are different: "4 == '4'" is true, "4 is '4'" is false and "0 is []" is
-false and not a error. "is#"/"isnot#" and "is?"/"isnot?" can be used to match
+false and not an error. "is#"/"isnot#" and "is?"/"isnot?" can be used to match
 and ignore case.
 
 When comparing a String with a Number, the String is converted to a Number,
 prevnonblank( {lnum})		Number	line nr of non-blank line <= {lnum}
 printf( {fmt}, {expr1}...)	String	format text
 pumvisible()			Number	whether popup menu is visible
+pyeval( {expr})			any	evaluate |Python| expression
+py3eval( {expr})		any	evaluate |python3| expression
 range( {expr} [, {max} [, {stride}]])
 				List	items from {expr} to {max}
 readfile( {fname} [, {binary} [, {max}]])
 		"rwx" flags represent, in turn, the permissions of the owner
 		of the file, the group the file belongs to, and other users.
 		If a user does not have a given permission the flag for this
-		is replaced with the string "-".  Example: >
+		is replaced with the string "-".  Examples: >
 			:echo getfperm("/etc/passwd")
+			:echo getfperm(expand("~/.vimrc"))
 <		This will hopefully (from a security point of view) display
 		the string "rw-r--r--" or even "rw-------".
 
 			"search" or "/"   search pattern history
 			"expr"	 or "="   typed expression history
 			"input"  or "@"	  input line history
+			"debug"  or ">"   debug command history
+		The {history} string does not need to be the whole name, one
+		character is sufficient.
 		If {item} does already exist in the history, it will be
 		shifted to become the newest entry.
 		The result is a Number: 1 if the operation was successful,
 
 		The operation is done in-place.  If you want a |List| or
 		|Dictionary| to remain unmodified make a copy first: >
-			:let tlist = map(copy(mylist), ' & . "\t"')
+			:let tlist = map(copy(mylist), ' v:val . "\t"')
 
 <		Returns {expr}, the |List| or |Dictionary| that was filtered.
 		When an error is encountered while evaluating {string} no
 		This can be used to avoid some things that would remove the
 		popup menu.
 
+							*E860* *E861*
+py3eval({expr})						*py3eval()*
+		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 
+		'encoding').
+		Lists are represented as Vim |List| type.
+		Dictionaries are represented as Vim |Dictionary| type with 
+		keys converted to strings.
+		{only available when compiled with the |+python3| feature}
+
+							*E858* *E859*
+pyeval({expr})						*pyeval()*
+		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).
+		Lists are represented as Vim |List| type.
+		Dictionaries are represented as Vim |Dictionary| type, 
+		non-string keys result in error.
+		{only available when compiled with the |+python| feature}
+
 							*E726* *E727*
 range({expr} [, {max} [, {stride}]])				*range()*
 		Returns a |List| with Numbers:
 
 		If {options} contains no register settings, then the default
 		is to use character mode unless {value} ends in a <NL>.
-		Setting the '=' register is not possible.
-		Returns zero for success, non-zero for failure.
+		Setting the '=' register is not possible, but you can use >
+			:let @= = var_expr
+<		Returns zero for success, non-zero for failure.
 
 		Examples: >
 			:call setreg(v:register, @*)
 beos			BeOS version of Vim.
 browse			Compiled with |:browse| support, and browse() will
 			work.
+browsefilter		Compiled with support for |browsefilter|.
 builtin_terms		Compiled with some builtin terminals.
 byte_offset		Compiled with support for 'o' in 'statusline'
 cindent			Compiled with 'cindent' support.
 mouse_netterm		Compiled with support for netterm mouse.
 mouse_pterm		Compiled with support for qnx pterm mouse.
 mouse_sysmouse		Compiled with support for sysmouse (*BSD console mouse)
+mouse_sgr		Compiled with support for sgr mouse.
 mouse_urxvt		Compiled with support for urxvt mouse.
 mouse_xterm		Compiled with support for xterm mouse.
 mouseshape		Compiled with support for 'mouseshape'.

runtime/doc/gui_w32.txt

-*gui_w32.txt*   For Vim version 7.3.  Last change: 2011 Jul 23
+*gui_w32.txt*   For Vim version 7.3.  Last change: 2012 Aug 04
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 And add gvim to the list of applications.  This problem only appears to happen
 with the Intellimouse driver 2.2 and when "Universal Scrolling" is turned on.
 
+
+XPM support						*w32-xpm-support*
+
+Gvim can be build on MS-Windows with support for XPM files.  |+xpm_w32|
+See the Make_mvc.mak file for instructions, search for XPM.
+
+To try out if XPM support works do this: >
+	:help
+	:exe 'sign define vimxpm icon=' . $VIMRUNTIME . '\\vim16x16.xpm'
+	:exe 'sign place 1 line=1 name=vimxpm file=' . expand('%:p')
+<
+
  vim:tw=78:sw=4:ts=8:ft=help:norl:

runtime/doc/hebrew.txt

       This is also the keymap when 'keymap=hebrew' is set.  The advantage of
       'keymap' is that it works properly when using UTF8, e.g. it inserts the
       correct characters; 'hkmap' does not.  The 'keymap' keyboard can also
-      insert niqud and te`amim.  To see what those mappings are,look at the
+      insert niqud and te`amim.  To see what those mappings are, look at the
       keymap file 'hebrew.vim' etc.
 
 

runtime/doc/if_lua.txt

-*if_lua.txt*    For Vim version 7.3.  Last change: 2012 Jan 16
+*if_lua.txt*    For Vim version 7.3.  Last change: 2012 Jun 29
 
 
 		  VIM REFERENCE MANUAL    by Luis Carvalho
 <
 
 ==============================================================================
-7. The luaeval function					*lua-luaeval*
+7. The luaeval function					*lua-luaeval* *lua-eval*
 
 The (dual) equivalent of "vim.eval" for passing Lua values to Vim is
 "luaeval". "luaeval" takes an expression string and an optional argument and

runtime/doc/if_perl.txt

-*if_perl.txt*   For Vim version 7.3.  Last change: 2010 Jul 21
+*if_perl.txt*   For Vim version 7.3.  Last change: 2012 Aug 02
 
 
 		  VIM REFERENCE MANUAL    by Sven Verdoolaege
 	Sven Verdoolaege <skimo@breughel.ufsia.ac.be>
 	Matt Gerassimof
 
-Perl for MS-Windows can be found at:
-http://www.perl.com/CPAN/ports/nt/Standard/x86/
+Perl for MS-Windows can be found at: http://www.perl.com/
+The ActiveState one should work.
 
 ==============================================================================
 3. Using the Perl interface				*perl-using*
 
 							*:perl* *:pe*
 :pe[rl] {cmd}		Execute Perl command {cmd}.  The current package
-			is "main".
+			is "main".  Simple example to test if `:perl` is
+			working: >
+				:perl VIM::Msg("Hello")
 
 :pe[rl] << {endpattern}
 {script}

runtime/doc/if_pyth.txt

-*if_pyth.txt*   For Vim version 7.3.  Last change: 2012 Feb 04
+*if_pyth.txt*   For Vim version 7.3.  Last change: 2012 Sep 23
 
 
 		  VIM REFERENCE MANUAL    by Paul Moore
 
 The Python Interface to Vim				*python* *Python*
 
-1. Commands			|python-commands|
-2. The vim module		|python-vim|
-3. Buffer objects		|python-buffer|
-4. Range objects		|python-range|
-5. Window objects		|python-window|
-6. Dynamic loading		|python-dynamic|
-7. Python 3			|python3|
+1. Commands					|python-commands|
+2. The vim module				|python-vim|
+3. Buffer objects				|python-buffer|
+4. Range objects				|python-range|
+5. Window objects				|python-window|
+6. pyeval(), py3eval() Vim functions		|python-pyeval|
+7. Dynamic loading				|python-dynamic|
+8. Python 3					|python3|
 
 {Vi does not have any of these commands}
 
 
 					*:python* *:py* *E205* *E263* *E264*
 :[range]py[thon] {stmt}
-			Execute Python statement {stmt}.
+			Execute Python statement {stmt}.  A simple check if
+			the `:python` command is working: >
+				:python print "Hello"
 
 :[range]py[thon] << {endmarker}
 {script}
 	[{'cmd': '/^eval_expr(arg, nextcmd)$/', 'static': 0, 'name':
 	'eval_expr', 'kind': 'f', 'filename': './src/eval.c'}]
 
+vim.bindeval(str)					*python-bindeval*
+	Like |python-eval|, but
+	1. if expression evaluates to |List| or |Dictionary| it is returned as 
+	   vimlist or vimdictionary python type that are connected to original 
+	   list or dictionary. Thus modifications to these objects imply 
+	   modifications of the original.
+
+	   Additionally, vimlist and vimdictionary type have read-write 
+	   `.locked` attribute that returns
+	     Value           Meaning ~
+	     zero            Variable is not locked
+	     vim.VAR_LOCKED  Variable is locked, but can be unlocked
+	     vim.VAR_FIXED   Variable is locked and can't be unlocked
+	   integer constants. If variable is not fixed, you can do 
+	   `var.locked=True` to lock it and `var.locked=False` to unlock. 
+	   There is no recursive locking like |:lockvar|! does. There is also 
+	   no way to lock a specific key or check whether it is locked (in any 
+	   case these locks are ignored by anything except |:let|: |extend()| 
+	   does not care, neither does python interface).
+
+	   Vimdictionary type also supports `.scope` attribute which is one of
+	     Value              Meaning ~
+	     zero               Dictionary is not a scope one
+	     vim.VAR_DEF_SCOPE  Function-local or global scope dictionary
+	     vim.VAR_SCOPE      Other scope dictionary
+
+	2. if expression evaluates to a function reference, then it returns 
+	   callable vimfunction object. Use self keyword argument to assign 
+	   |self| object for dictionary functions.
+
+	Note: this function has the same behavior as |lua-eval| (except that 
+	      lua does not support running vim functions), |python-eval| is 
+	      kept for backwards compatibility in order not to make scripts 
+	      relying on outputs of vim.eval() being a copy of original or 
+	      vim.eval("1") returning a string.
+
 
 
 Error object of the "vim" module
 The width attribute is writable only if the screen is split vertically.
 
 ==============================================================================
-6. Dynamic loading					*python-dynamic*
+6. pyeval() and py3eval() Vim functions			*python-pyeval*
+
+To facilitate bi-directional interface, you can use |pyeval()| and |py3eval()| 
+functions to evaluate Python expressions and pass their values to VimL.
+
+==============================================================================
+7. Dynamic loading					*python-dynamic*
 
 On MS-Windows the Python library can be loaded dynamically.  The |:version|
 output then includes |+python/dyn|.
 sure edit "gvim.exe" and search for "python\d*.dll\c".
 
 ==============================================================================
-7. Python 3						*python3*
+8. Python 3						*python3*
 
 							*:py3* *:python3*
-The |:py3| and |:python3| commands work similar to |:python|.
-							*:py3file*
+The |:py3| and |:python3| commands work similar to |:python|.  A simple check
+if the `:py3` command is wrong: >
+	:py3 print("Hello")
+<							*:py3file*
 The |:py3file| command works similar to |:pyfile|.
 
+
 Vim can be built in four ways (:version output):
 1. No Python support	    (-python, -python3)
 2. Python 2 support only    (+python or +python/dyn, -python3)

runtime/doc/if_ruby.txt

-*if_ruby.txt*   For Vim version 7.3.  Last change: 2010 Oct 27
+*if_ruby.txt*   For Vim version 7.3.  Last change: 2012 Aug 02
 
 
 		  VIM REFERENCE MANUAL    by Shugo Maeda
 1. Commands						*ruby-commands*
 
 							*:ruby* *:rub*
-:rub[y] {cmd}		Execute Ruby command {cmd}.
+:rub[y] {cmd}		Execute Ruby command {cmd}.  A command to try it out: >
+				:ruby print "Hello"
 
 :rub[y] << {endpattern}
 {script}
 			wasn't compiled in.  To avoid errors, see
 			|script-here|.
 
-Command to try it out: >
-	:ruby print "Hello"   # this is a comment
-
 Example Vim script: >
 
 	function! RedGem()
 
 If you want to build Vim with Ruby 1.9.1, you need to edit the config.h file
 and comment-out the check for _MSC_VER.
+You may also need to rename the include directory name to match the version,
+strangely for Ruby 1.9.3 the directory is called 1.9.1.
 
 ==============================================================================
  vim:tw=78:ts=8:ft=help:norl:

runtime/doc/if_tcl.txt

-*if_tcl.txt*    For Vim version 7.3.  Last change: 2008 Aug 16
+*if_tcl.txt*    For Vim version 7.3.  Last change: 2012 Aug 02
 
 
 		  VIM REFERENCE MANUAL    by Ingo Wilken
 1. Commands				*tcl-ex-commands* *E571* *E572*
 
 							*:tcl* *:tc*
-:tc[l] {cmd}		Execute Tcl command {cmd}.
+:tc[l] {cmd}		Execute Tcl command {cmd}.  A simple check if `:tcl`
+			is working: >
+				:tcl puts "Hello"
 
 :[range]tc[l] << {endmarker}
 {script}

runtime/doc/indent.txt

-*indent.txt*    For Vim version 7.3.  Last change: 2011 Sep 02
+*indent.txt*    For Vim version 7.3.  Last change: 2012 Aug 30
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 								*cino-star*
 	*N    Vim searches for unclosed comments at most N lines away.  This
 	      limits the time needed to search for the start of a comment.
-	      If your /* */ comments stop indenting afer N lines this is the
+	      If your /* */ comments stop indenting after N lines this is the
 	      value you will want to change.
 	      (default 70 lines).
 

runtime/doc/index.txt

-*index.txt*     For Vim version 7.3.  Last change: 2011 Aug 06
+*index.txt*     For Vim version 7.3.  Last change: 2012 Jul 25
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 |gH|		gH		   start Select line mode
 |gI|		gI		2  like "I", but always start in column 1
 |gJ|		gJ		2  join lines without inserting space
+|gN|		gN	      1,2  find the previous match with the last used
+				   search pattern and Visually select it
 |gP|		["x]gP		2  put the text [from register x] before the
 				   cursor N times, leave the cursor after it
 |gQ|		gQ		    switch to "Ex" mode with Vim editing
 				   lines down
 |gk|		gk		1  like "k", but when 'wrap' on go N screen
 				   lines up
+|gn|		gn	      1,2  find the next match with the last used
+				   search pattern and Visually select it
 |gm|		gm		1  go to character at middle of the screenline
 |go|		go		1  cursor to byte N in the buffer
 |gp|		["x]gp		2  put the text [from register x] after the

runtime/doc/insert.txt

-*insert.txt*    For Vim version 7.3.  Last change: 2012 May 18
+*insert.txt*    For Vim version 7.3.  Last change: 2012 Jul 10
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 							*ins-smarttab*
 When the 'smarttab' option is on, a <Tab> inserts 'shiftwidth' positions at
 the beginning of a line and 'tabstop' positions in other places.  This means
-that often spaces instead of a <Tab> character are inserted.  When 'smarttab
+that often spaces instead of a <Tab> character are inserted.  When 'smarttab'
 is off, a <Tab> always inserts 'tabstop' positions, and 'shiftwidth' is only
 used for ">>" and the like.  {not in Vi}
 
 			leading text is changed.
 Other items are ignored.
 
+For acting upon end of completion, see the |CompleteDone| autocommand event.
+
 For example, the function can contain this: >
 	let matches = ... list of words ...
 	return {'words': matches, 'refresh': 'always'}

runtime/doc/intro.txt

-*intro.txt*     For Vim version 7.3.  Last change: 2011 May 15
+*intro.txt*     For Vim version 7.3.  Last change: 2012 Sep 05
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 							*quotecommandquote*
 "command"	A reference to a command that you can type is enclosed in
 		double quotes.
+`command`		New style command, this distinguishes it from other
+		quoted text and strings.
 
 					*key-notation* *key-codes* *keycodes*
 These names for keys are used in the documentation.  They can also be used

runtime/doc/map.txt

 	-complete=syntax	syntax file names |'syntax'|
 	-complete=tag		tags
 	-complete=tag_listfiles	tags, file names are shown when CTRL-D is hit
+	-complete=user		user names
 	-complete=var		user variables
 	-complete=custom,{func} custom completion, defined via {func}
 	-complete=customlist,{func} custom completion, defined via {func}

runtime/doc/mbyte.txt

-*mbyte.txt*     For Vim version 7.3.  Last change: 2012 Feb 29
+*mbyte.txt*     For Vim version 7.3.  Last change: 2012 Jun 06
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar et al.
 	|charset| converter.  Supported |charset|: ISO-2022-CN, ISO-2022-JP,
 	ISO-2022-KR, EUC-CN, EUC-JP, EUC-KR, EUC-TW, UTF-7, UTF-8, ISO-8859
 	series, Shift_JIS, Big5 and HZ.  Lv can be found at:
-	http://www.ff.iij4u.or.jp/~nrt/freeware/lv4495.tar.gz
+	http://www.ff.iij4u.or.jp/~nrt/lv/index.html
 
 
 							*mbyte-conversion*
 	    charsets, such as JIS X 0208, if this field is 0, code points has
 	    the same value as GL, and GR if 1.
 
-For example, in case of a 14 dots font corresponding to JIS X 0208, it is
+For example, in case of a 16 dots font corresponding to JIS X 0208, it is
 written like:
     -misc-fixed-medium-r-normal--16-110-100-100-c-160-jisx0208.1990-0
 

runtime/doc/motion.txt

-*motion.txt*    For Vim version 7.3.  Last change: 2011 Jul 19
+*motion.txt*    For Vim version 7.3.  Last change: 2012 Aug 04
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 	|>|	>	shift right
 	|<|	<	shift left
 	|zf|	zf	define a fold
-	|g@|    g@      call function set with the 'operatorfunc' option
+	|g@|	g@	call function set with the 'operatorfunc' option
 
 If the motion includes a count and the operator also had a count before it,
 the two counts are multiplied.  For example: "2d3w" deletes six words.
 			non-blank character |linewise|.  If 'startofline' not
 			set, keep the same column.
 
+							*:[range]*
 :[range]		Set the cursor on the last line number in [range].
 			[range] can also be just one line number, e.g., ":1"
 			or ":'m".
 These commands are {not in Vi}.
 These commands are not available when the |+textobjects| feature has been
 disabled at compile time.
+Also see `gn` and `gN`, operating on the last search pattern.
+
 							*v_aw* *aw*
 aw			"a word", select [count] words (see |word|).
 			Leading or trailing white space is included, but not
 	"daw"	delete a word				*daw*
 	"diW"	delete inner WORD (see |WORD|)		*diW*
 	"daW"	delete a WORD (see |WORD|)		*daW*
+	"dgn"   delete the next search pattern match    *dgn*
 	"dd"	delete one line				|dd|
 	"dis"	delete inner sentence			*dis*
 	"das"	delete a sentence			*das*
 			to be simulated by multiple commands.  (does not move
 			the cursor, this is not a motion command).
 
+						*m<* *m>*
+m<  or  m>		Set the |'<| or |'>| mark.  Useful to change what the
+			`gv` command selects.  (does not move the cursor, this
+			is not a motion command).
+			Note that the Visual mode cannot be set, only the
+			start and end position.
+
 						*:ma* *:mark* *E191*
 :[range]ma[rk] {a-zA-Z'}
 			Set mark {a-zA-Z'} at last line number in [range],

runtime/doc/options.txt

-*options.txt*	For Vim version 7.3.  Last change: 2012 May 16
+*options.txt*	For Vim version 7.3.  Last change: 2012 Aug 15
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
 	Vim does not try to send a message to an external debugger (Netbeans
 	or Sun Workshop).
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The expression will be evaluated in the |sandbox| when set from a
+	modeline, see |sandbox-option|.
 
 	It is not allowed to change text or jump to another window while
 	evaluating 'balloonexpr' |textlock|.
 	This option is a list of comma separated names.
 	These names are recognized:
 
+						*clipboard-unnamed*
 	unnamed		When included, Vim will use the clipboard register '*'
 			for all yank, delete, change and put operations which
 			would normally go to the unnamed register.  When a
 			explicitly accessed using the "* notation.  Also see
 			|gui-clipboard|.
 
+						*clipboard-unnamedplus*
 	unnamedplus	A variant of "unnamed" flag which uses the clipboard
 			register '+' (|quoteplus|) instead of register '*' for
 			all operations except yank.  Yank shall copy the text
 			Availability can be checked with: >
 				if has('unnamedplus')
 <
+						*clipboard-autoselect*
 	autoselect	Works like the 'a' flag in 'guioptions': If present,
 			then whenever Visual mode is started, or the Visual
 			area extended, Vim tries to become the owner of the
 			"autoselect" flag is used.
 			Also applies to the modeless selection.
 
+						*clipboard-autoselectplus*
+	autoselectplus  Like "autoselect" but using the + register instead of
+			the * register.  Compare to the 'P' flag in
+			'guioptions'.
+
+						*clipboard-autoselectml*
 	autoselectml	Like "autoselect", but for the modeless selection
 			only.  Compare to the 'A' flag in 'guioptions'.
 
+						*clipboard-html*
 	html		When the clipboard contains HTML, use this when
 			pasting.  When putting text on the clipboard, mark it
 			as HTML.  This works to copy rendered HTML from
 			Only supported for GTK version 2 and later.
 			Only available with the |+multi_byte| feature.
 
+						*clipboard-exclude*
 	exclude:{pattern}
 			Defines a pattern that is matched against the name of
 			the terminal 'term'.  If there is a match, no
 	The expression used for when 'foldmethod' is "expr".  It is evaluated
 	for each line to obtain its fold level.  See |fold-expr|.
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The expression will be evaluated in the |sandbox| if set from a
+	modeline, see |sandbox-option|.
 	This option can't be set from a |modeline| when the 'diff' option is
 	on.
 
 	An expression which is used to specify the text displayed for a closed
 	fold.  See |fold-foldtext|.
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The expression will be evaluated in the |sandbox| if set from a
+	modeline, see |sandbox-option|.
 
 	It is not allowed to change text or jump to another window while
 	evaluating 'foldtext' |textlock|.
 	format function will be used |C-indenting|.
 	Environment variables are expanded |:set_env|.  See |option-backslash|
 	about including spaces and backslashes.
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	This option cannot be set from a |modeline| or in the |sandbox|, for
+	security reasons.
 
 						*'formatexpr'* *'fex'*
 'formatexpr' 'fex'	string (default "")
 	When the expression evaluates to non-zero Vim will fall back to using
 	the internal format mechanism.
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.  That stops the option from working, since changing
-	the buffer text is not allowed.
+	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.
 
 						*'fsync'* *'fs'*
 'fsync' 'fs'		boolean	(default on)
 		windowing system's global selection unless explicitly told to
 		by a yank or delete operation for the "* register.
 		The same applies to the modeless selection.
+								*'go-P'*
+	  'P'	Like autoselect but using the "+ register instead of the "*
+	  	register.
 								*'go-A'*
 	  'A'	Autoselect for the modeless selection.  Like 'a', but only
 		applies to the modeless selection.
 	found.  Allows doing "gf" on the name after an 'include' statement.
 	Also used for |<cfile>|.
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The expression will be evaluated in the |sandbox| when set from a
+	modeline, see |sandbox-option|.
 
 	It is not allowed to change text or jump to another window while
 	evaluating 'includeexpr' |textlock|.
 	See |indent-expression|.
 	NOTE: This option is made empty when 'compatible' is set.
 
-	The expression may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The expression will be evaluated in the |sandbox| when set from a
+	modeline, see |sandbox-option|.
 
 	It is not allowed to change text or jump to another window while
 	evaluating 'indentexpr' |textlock|.
 			{not in Vi}
 	Strings to use in 'list' mode and for the |:list| command.  It is a
 	comma separated list of string settings.
+	  						*lcs-eol*
 	  eol:c		Character to show at the end of each line.  When
 			omitted, there is no extra character at the end of the
 			line.
+	  						*lcs-tab*
 	  tab:xy	Two characters to be used to show a tab.  The first
 			char is used once.  The second char is repeated to
 			fill the space that the tab normally occupies.
 			"tab:>-" will show a tab that takes four spaces as
 			">---".  When omitted, a tab is show as ^I.
+	  						*lcs-trail*
 	  trail:c	Character to show for trailing spaces.  When omitted,
 			trailing spaces are blank.
+	  						*lcs-extends*
 	  extends:c	Character to show in the last column, when 'wrap' is
 			off and the line continues beyond the right of the
 			screen.
+	  						*lcs-precedes*
 	  precedes:c	Character to show in the first column, when 'wrap'
 			is off and there is text preceding the character
 			visible in the first column.
+	  						*lcs-conceal*
 	  conceal:c	Character to show in place of concealed text, when
 			'conceallevel' is set to 1.
+	  						*lcs-nbsp*
 	  nbsp:c	Character to show for a non-breakable space (character
 			0xA0, 160).  Left blank when omitted.
 
 	invoked and what it should return.
 	This option is usually set by a filetype plugin:
 	|:filetype-plugin-on|
+	This option cannot be set from a |modeline| or in the |sandbox|, for
+	security reasons.
 
 
 			    *'opendevice'* *'odev'* *'noopendevice'* *'noodev'*
 			local to buffer
 	Number of spaces to use for each step of (auto)indent.  Used for
 	|'cindent'|, |>>|, |<<|, etc.
+	When zero the 'ts' value will be used.
 
 						*'shortmess'* *'shm'*
 'shortmess' 'shm'	string	(Vim default "filnxtToO", Vi default: "",
 	The variable "actual_curbuf" is set to the 'bufnr()' number of the
 	real current buffer.
 
-	The 'statusline' option may be evaluated in the |sandbox|, see
-	|sandbox-option|.
+	The 'statusline' option will be evaluated in the |sandbox| if set from
+	a modeline, see |sandbox-option|.
 
 	It is not allowed to change text or jump to another window while
 	evaluating 'statusline' |textlock|.
 	   pterm	QNX pterm mouse handling.
 							*urxvt-mouse*
 	   urxvt	Mouse handling for the urxvt (rxvt-unicode) terminal.
+							*sgr-mouse*
+	   sgr		Mouse handling for the terminal that emits SGR-styled
+			mouse reporting. Works with xterm version 277 or
+			later.
 
 	The mouse handling must be enabled at compile time |+mouse_xterm|
 	|+mouse_dec| |+mouse_netterm|.
 	or "xterm2" already.  The main use of this option is to set it to
 	"xterm", when the terminal name doesn't start with "xterm", but it can
 	handle xterm mouse codes.
+	The "sgr" value will be set if the xterm version is 277 or later.
 	The "xterm2" value will be set if the xterm version is reported to be
 	95 or higher.  This only works when compiled with the |+termresponse|
 	feature and if |t_RV| is set to the escape sequence to request the
 			{not available when compiled without the |+wildignore|
 			feature}
 	A list of file patterns.  A file that matches with one of these
-	patterns is ignored when completing file or directory names, and
-	influences the result of |expand()|, |glob()| and |globpath()| unless
-	a flag is passed to disable this.
+	patterns is ignored when expanding |wildcards|, completing file or
+	directory names, and influences the result of |expand()|, |glob()| and
+	|globpath()| unless a flag is passed to disable this.
 	The pattern is used like with |:autocmd|, see |autocmd-patterns|.
 	Also see 'suffixes'.
 	Example: >

runtime/doc/pi_gzip.txt

-*pi_gzip.txt*   For Vim version 7.3.  Last change: 2002 Oct 29
+*pi_gzip.txt*   For Vim version 7.3.  Last change: 2012 Jul 19
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 	*.Z		compress (Lempel-Ziv)
 	*.gz		gzip
 	*.bz2		bzip2
+	*.lzma		lzma
+	*.xz		xz
 
 That's actually the only thing you need to know.  There are no options.
 

runtime/doc/quickfix.txt

 					*:vim* *:vimgrep* *E682* *E683*
 :vim[grep][!] /{pattern}/[g][j] {file} ...
 			Search for {pattern} in the files {file} ... and set
-			the error list to the matches.
+			the error list to the matches.  Files matching
+			'wildignore' are ignored; files in 'suffixes' are
+			searched last.
 			Without the 'g' flag each line is added only once.
 			With 'g' every match is added.
 

runtime/doc/sign.txt

-*sign.txt*      For Vim version 7.3.  Last change: 2012 Jan 04
+*sign.txt*      For Vim version 7.3.  Last change: 2012 Jul 10
 
 
 		  VIM REFERENCE MANUAL    by Gordon Prieur
 		Remove the previously placed sign {id} from file {fname}.
 		See remark above about {fname} |:sign-fname|.
 
+:sign unplace * file={fname}
+		Remove all placed signs in file {fname}.
+
 :sign unplace {id} buffer={nr}
-		Same, but use buffer {nr}.
+		Remove the previously placed sign {id} from buffer {nr}.
+
+:sign unplace * buffer={nr}
+		Remove all placed signs in buffer {nr}.
 
 :sign unplace {id}
 		Remove the previously placed sign {id} from all files it

runtime/doc/syntax.txt

-*syntax.txt*	For Vim version 7.3.  Last change: 2012 Apr 06
+*syntax.txt*	For Vim version 7.3.  Last change: 2012 Jul 16
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
 This is not a syntax file itself, but a script that converts the current
 window into HTML.  Vim opens a new window in which it builds the HTML file.
 
+After you save the resulting file, you can view it with any browser.  The
+colors should be exactly the same as you see them in Vim.
+
 You are not supposed to set the 'filetype' or 'syntax' option to "2html"!
 Source the script to convert the current file: >
 
 	:runtime! syntax/2html.vim
 <
-							*:TOhtml*
-Or use the ":TOhtml" user command.  It is defined in a standard plugin.
-":TOhtml" also works with a range and in a Visual area: >
-
-	:10,40TOhtml
-
-Warning: This can be slow! The script must process every character of every
-line. Because it can take a long time, by default a progress bar is displayed
-in the statusline for each major step in the conversion process. If you don't
-like seeing this progress bar, you can disable it and get a very minor speed
-improvement with: >
-
-	let g:html_no_progress = 1
-
-":TOhtml" has another special feature: if the window is in diff mode, it will
-generate HTML that shows all the related windows.  This can be disabled by
-setting the g:html_diff_one_file variable: >
-
-	let g:html_diff_one_file = 1
+Many variables affect the output of 2html.vim; see below. Any of the on/off
+options listed below can be enabled or disabled by setting them explicitly to
+the desired value, or restored to their default by removing the variable using
+|:unlet|.
 
-After you save the resulting file, you can view it with any browser.  The
-colors should be exactly the same as you see them in Vim.
+Remarks:
+- Some truly ancient browsers may not show the background colors.
+- From most browsers you can also print the file (in color)!
+- The latest TOhtml may actually work with older versions of Vim, but some
+  features such as conceal support will not function, and the colors may be
+  incorrect for an old Vim without GUI support compiled in.
 
+Here is an example how to run the script over all .c and .h files from a
+Unix shell: >
+   for f in *.[ch]; do gvim -f +"syn on" +"run! syntax/2html.vim" +"wq" +"q" $f; done
+<
+					*g:html_start_line* *g:html_end_line*
 To restrict the conversion to a range of lines, use a range with the |:TOhtml|
-command, or set "g:html_start_line" and "g:html_end_line" to the first and
-last line to be converted.  Example, using the last set Visual area: >
+command below, or set "g:html_start_line" and "g:html_end_line" to the first
+and last line to be converted.  Example, using the last set Visual area: >
 
 	:let g:html_start_line = line("'<")
 	:let g:html_end_line = line("'>")
+	:runtime! syntax/2html.vim
+<
+							*:TOhtml*
+:[range]TOhtml		The ":TOhtml" command is defined in a standard plugin.
+			This command will source |2html.vim| for you. When a
+			range is given, set |g:html_start_line| and
+			|g:html_end_line| to the start and end of the range,
+			respectively. Default range is the entire buffer.
+
+			If the current window is part of a |diff|, unless
+			|g:html_diff_one_file| is set, :TOhtml will convert
+			all windows which are part of the diff in the current
+			tab and place them side-by-side in a <table> element
+			in the generated HTML.
+
+			Examples: >
+
+	:10,40TOhtml " convert lines 10-40 to html
+	:'<,'>TOhtml " convert current/last visual selection
+	:TOhtml      " convert entire buffer
+<
+							*g:html_diff_one_file*
+Default: 0.
+When 0, all windows involved in a |diff| in the current tab page are converted
+to HTML and placed side-by-side in a <table> element.
+When 1, only the current buffer is converted.
+Example: >
 
-The lines are numbered according to 'number' option and the Number
-highlighting.  You can force lines to be numbered in the HTML output by
-setting "html_number_lines" to non-zero value: >
+	let g:html_diff_one_file = 1
+<
+							 *g:html_whole_filler*
+Default: 0.
+When 0, if |g:html_diff_one_file| is 1, a sequence of more than 3 filler lines
+is displayed as three lines with the middle line mentioning the total number
+of inserted lines.
+When 1, always display all inserted lines as if |g:html_diff_one_file| were
+not set.
+>
+    :let g:html_whole_filler = 1
+<
+				     *TOhtml-performance* *g:html_no_progress*
+Default: 0.
+When 0, display a progress bar in the statusline for each major step in the
+2html.vim conversion process.
+When 1, do not display the progress bar. This offers a minor speed improvement
+but you won't have any idea how much longer the conversion might take; for big
+files it can take a long time!
+Example: >
+
+	let g:html_no_progress = 1
+<
+You can obtain better performance improvements by also instructing Vim to not
+run interactively, so that too much time is not taken to redraw as the script
+moves through the buffer, switches windows, and the like: >
+
+  vim -E -s -c "let g:html_no_progress=1" -c "syntax on" -c "set ft=c" -c "runtime syntax/2html.vim" -cwqa myfile.c
+<
+Note that the -s flag prevents loading your .vimrc and any plugins, so you
+need to explicitly source/enable anything that will affect the HTML
+conversion. See |-E| and |-s-ex| for details. It is probably best to create a
+script to replace all the -c commands and use it with the -u flag instead of
+specifying each command separately.
+
+							 *g:html_number_lines*
+Default: current 'number' setting.
+When 0, buffer text is displayed in the generated HTML without line numbering.
+When 1, a column of line numbers is added to the generated HTML with the same
+highlighting as the line number column in Vim (|hl-LineNr|).
+Force line numbers even if 'number' is not set: >
    :let g:html_number_lines = 1
-Force to omit the line numbers by using a zero value: >
+Force to omit the line numbers: >
    :let g:html_number_lines = 0
 Go back to the default to use 'number' by deleting the variable: >
    :unlet g:html_number_lines
-
-By default, valid HTML 4.01 using cascading style sheets (CSS1) is generated.
-If you need to generate markup for really old browsers or some other user
-agent that lacks basic CSS support, use: >
+<
+							      *g:html_use_css*
+Default: 1.
+When 1, generate valid HTML 4.01 markup with CSS1 styling, supported in all
+modern browsers and most old browsers.
+When 0, generate <font> tags and similar outdated markup. This is not
+recommended but it may work better in really old browsers, email clients,
+forum posts, and similar situations where basic CSS support is unavailable.
+Example: >
    :let g:html_use_css = 0
-
-Concealed text is removed from the HTML and replaced with the appropriate
-character from |:syn-cchar| or 'listchars' depending on the current value of
-'conceallevel'. If you always want to display all text in your document,
-either set 'conceallevel' to zero before invoking 2html, or use: >
+<
+						       *g:html_ignore_conceal*
+Default: 0.
+When 0, concealed text is removed from the HTML and replaced with a character
+from |:syn-cchar| or 'listchars' as appropriate, depending on the current
+value of 'conceallevel'.
+When 1, include all text from the buffer in the generated HTML, even if it is
+|conceal|ed.
+
+Either of the following commands will ensure that all text in the buffer is
+included in the generated HTML (unless it is folded): >
    :let g:html_ignore_conceal = 1
-
-Similarly, closed folds are put in the HTML as they are displayed.  If you
-don't want this, use the |zR| command before invoking 2html, or use: >
+   :setl conceallevel=0
+<
+						       *g:html_ignore_folding*
+Default: 0.
+When 0, text in a closed fold is replaced by the text shown for the fold in
+Vim (|fold-foldtext|). See |g:html_dynamic_folds| if you also want to allow
+the user to expand the fold as in Vim to see the text inside.
+When 1, include all text from the buffer in the generated HTML; whether the
+text is in a fold has no impact at all. |g:html_dynamic_folds| has no effect.
+
+Either of these commands will ensure that all text in the buffer is included
+in the generated HTML (unless it is concealed): >
+   zR
    :let g:html_ignore_folding = 1
+<
+							*g:html_dynamic_folds*
+Default: 0.
+When 0, text in a closed fold is not included at all in the generated HTML.
+When 1, generate javascript to open a fold and show the text within, just like
+in Vim.
 
-You may want to generate HTML that includes all the data within the folds, and
-allow the user to view the folded data similar to how they would in Vim. To
-generate this dynamic fold information, use: >
-   :let g:html_dynamic_folds = 1
-
-Using html_dynamic_folds will imply html_use_css, because it would be far too
-difficult to do it for old browsers. However, html_ignore_folding overrides
-html_dynamic_folds.
+Setting this variable to 1 causes 2html.vim to always use CSS for styling,
+regardless of what |g:html_use_css| is set to.
 
-Using html_dynamic_folds will default to generating a foldcolumn in the html
-similar to Vim's foldcolumn, that will use javascript to open and close the
-folds in the HTML document. The width of this foldcolumn starts at the current
-setting of |'foldcolumn'| but grows to fit the greatest foldlevel in your
-document. If you do not want to show a foldcolumn at all, use: >
+This variable is ignored when |g:html_ignore_folding| is set.
+>
+   :let g:html_dynamic_folds = 1
+<
+							*g:html_no_foldcolumn*
+Default: 0.
+When 0, if |g:html_dynamic_folds| is 1, generate a column of text similar to
+Vim's foldcolumn (|fold-foldcolumn|) the user can click on to toggle folds
+open or closed. The minimum width of the generated text column is the current
+'foldcolumn' setting.
+When 1, do not generate this column; instead, hovering the mouse cursor over
+folded text will open the fold as if |g:html_hover_unfold| were set.
+>
    :let g:html_no_foldcolumn = 1
-
-Using this option, there will be no foldcolumn available to open the folds in
-the HTML. For this reason, another option is provided: html_hover_unfold.
-Enabling this option will use CSS 2.0 to allow a user to open a fold by
-hovering the mouse pointer over it. Note that old browsers (notably Internet
-Explorer 6) will not support this feature.  Browser-specific markup for IE6 is
-included to fall back to the normal CSS1 code so that the folds show up
-correctly for this browser, but they will not be openable without a
-foldcolumn. Note that using html_hover_unfold will allow modern browsers with
-disabled javascript to view closed folds. To use this option, use: >
+<
+				*TOhtml-uncopyable-text* *g:html_prevent_copy*
+Default: empty string.
+This option prevents certain regions of the generated HTML from being copied,
+when you select all text in document rendered in a browser and copy it. Useful
+for allowing users to copy-paste only the source text even if a fold column or
+line numbers are shown in the generated content. Specify regions to be
+affected in this way as follows:
+	f:	fold column
+	n:	line numbers (also within fold text)
+	t:	fold text
+	d:	diff filler
+
+Example, to make the fold column and line numbers uncopyable: >
+	:let g:html_prevent_copy = "fn"
+<
+This feature is currently implemented by inserting read-only <input> elements
+into the markup to contain the uncopyable areas. This does not work well in
+all cases. When pasting to some applications which understand HTML, the
+<input> elements also get pasted. But plain-text paste destinations should
+always work.
+
+							   *g:html_no_invalid*
+Default: 0.
+When 0, if |g:html_prevent_copy| is non-empty, an invalid attribute is
+intentionally inserted into the <input> element for the uncopyable areas. This
+increases the number of applications you can paste to without also pasting the
+<input> elements. Specifically, Microsoft Word will not paste the <input>
+elements if they contain this invalid attribute.
+When 1, no invalid markup is ever intentionally inserted, and the generated
+page should validate. However, be careful pasting into Microsoft Word when
+|g:html_prevent_copy| is non-empty; it can be hard to get rid of the <input>
+elements which get pasted.
+
+							 *g:html_hover_unfold*
+Default: 0.
+When 0, the only way to open a fold generated by 2html.vim with
+|g:html_dynamic_folds| set, is to click on the generated fold column.
+When 1, use CSS 2.0 to allow the user to open a fold by moving the mouse
+cursor over the displayed fold text. This is useful to allow users with
+disabled javascript to view the folded text.
+
+Note that old browsers (notably Internet Explorer 6) will not support this
+feature.  Browser-specific markup for IE6 is included to fall back to the
+normal CSS1 styling so that the folds show up correctly for this browser, but
+they will not be openable without a foldcolumn.
+>
    :let g:html_hover_unfold = 1
-
-Setting html_no_foldcolumn with html_dynamic_folds will automatically set
-html_hover_unfold, because otherwise the folds wouldn't be dynamic.
-
-By default "<pre>" and "</pre>" are used around the text. When 'wrap' is set
-in the window being converted, the CSS 2.0 "white-space:pre-wrap" value is
-used to wrap the text. You can explicitly enable the wrapping with: >
+<
+					  *TOhtml-wrap-text* *g:html_pre_wrap*
+Default: current 'wrap' setting.
+When 0, if |g:html_no_pre| is 0 or unset, the text in the generated HTML does
+not wrap at the edge of the browser window.
+When 1, if |g:html_use_css| is 1, the CSS 2.0 "white-space:pre-wrap" value is
+used, causing the text to wrap at whitespace at the edge of the browser
+window.
+Explicitly enable text wrapping: >
    :let g:html_pre_wrap = 1
-or disable with >
+Explicitly disable wrapping: >
    :let g:html_pre_wrap = 0
-This generates HTML that looks very close to the Vim window, but unfortunately
-there can be minor differences such as the lack of a 'showbreak' option in in
-the HTML, or where line breaks can occur.
-
-Another way to obtain text wrapping in the HTML, at the risk of making some
-things look even more different, is to use: >
+Go back to default, determine wrapping from 'wrap' setting: >
+   :unlet g:html_pre_wrap
+<
+							       *g:html_no_pre*
+Default: 0.
+When 0, buffer text in the generated HTML is surrounded by <pre>...</pre>
+tags. Series of whitespace is shown as in Vim without special markup, and tab
+characters can be included literally (see |g:html_expand_tabs|).
+When 1 (not recommended), the <pre> tags are omitted, and a plain <div> is
+used instead. Whitespace is replaced by a series of &nbsp; character
+references, and <br> is used to end each line. This is another way to allow
+text in the generated HTML is wrap (see |g:html_pre_wrap|) which also works in
+old browsers, but may cause noticeable differences between Vim's display and
+the rendered page generated by 2html.vim.
+>
    :let g:html_no_pre = 1
-This will use <br> at the end of each line and use "&nbsp;" for repeated
-spaces. Doing it this way is more compatible with old browsers, but modern
-browsers support the "white-space" method.
-
-If you do stick with the default "<pre>" tags, <Tab> characters in the text
-are included in the generated output if they will have no effect on the
-appearance of the text and it looks like they are in the document
-intentionally. This allows for the HTML output to be copied and pasted from a
-browser without losing the actual whitespace used in the document.
-
-Specifically, <Tab> characters will be included if the 'tabstop' option is set
-to the default of 8, 'expandtab' is not set, and if neither the foldcolumn nor
-the line numbers are included in the HTML output (see options above). When any
-of these conditions are not met, any <Tab> characters in the text are expanded
-to the appropriate number of spaces in the HTML output.
-
-When "<pre>" is included, you can force |:TOhtml| to keep the tabs even if the
-other conditions are not met with: >
+<
+							  *g:html_expand_tabs*
+Default: 1 if 'tabstop' is 8, 'expandtab' is 0, and no fold column or line
+		numbers occur in the generated HTML;
+	 0 otherwise.
+When 0, <Tab> characters in the buffer text are replaced with an appropriate
+number of space characters, or &nbsp; references if |g:html_no_pre| is 1.
+When 1, if |g:html_no_pre| is 0 or unset, <Tab> characters in the buffer text
+are included as-is in the generated HTML. This is useful for when you want to
+allow copy and paste from a browser without losing the actual whitespace in
+the source document. Note that this can easily break text alignment and
+indentation in the HTML, unless set by default.
+
+Force |2html.vim| to keep <Tab> characters: >
    :let g:html_expand_tabs = 0
-Note that this can easily break text alignment and indentation in the HTML.
-
-Force tabs to be expanded even when they would be kept using: >
+<
+Force tabs to be expanded: >
    :let g:html_expand_tabs = 1
+<
+				    *TOhtml-encoding-detect* *TOhtml-encoding*
+It is highly recommended to set your desired encoding with
+|g:html_use_encoding| for any content which will be placed on a web server.
 
-For diff mode on a single file (with g:html_diff_one_file) a sequence of more
-than 3 filler lines is displayed as three lines with the middle line
-mentioning the total number of inserted lines.  If you prefer to see all the
-inserted lines as with the side-by-side diff, use: >
-    :let g:html_whole_filler = 1
-And to go back to displaying up to three lines again: >
-    :unlet g:html_whole_filler
+If you do not specify an encoding, |2html.vim| uses the preferred IANA name
+for the current value of 'fileencoding' if set, or 'encoding' if not.
+'encoding' is always used for certain 'buftype' values. 'fileencoding' will be
+set to match the chosen document encoding.
 
-For most buffers, TOhtml uses the current value of 'fileencoding' if set, or
-'encoding' if not, to determine the charset and 'fileencoding' of the HTML
-file. 'encoding' is always used for certain 'buftype' values. In general, this
-works for the encodings mentioned specifically by name in |encoding-names|,
-but TOhtml will only automatically use those encodings which are widely
-supported. However, you can override this to support specific encodings that
-may not be automatically detected by default.