source: patches/vim-7.1-fixes-3.patch@ c814e64

runtime/doc/change.txt

@@ -1571 +1571 @@
                         in their original order, right before the sorted
                         lines.
 
+                        If {pattern} is empty (e.g. // is specified), the
+                        last search pattern is used.  This allows trying out
+                        a pattern first.
+
 Note that using ":sort" with ":global" doesn't sort the matching lines, it's
 quite useless.
 

runtime/doc/eval.txt

@@ -1 @@
-*eval.txt*      For Vim version 7.1.  Last change: 2007 May 11
+*eval.txt*      For Vim version 7.1.  Last change: 2007 Jul 25
 
 
                   VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1557 +1557 @@
 changenr()                      Number  current change number
 char2nr( {expr})                Number  ASCII value of first char in {expr}
 cindent( {lnum})                Number  C indent for line {lnum}
+clearmatches()                  None    clear all matches
 col( {expr})                    Number  column nr of cursor or mark
 complete({startcol}, {matches}) String  set Insert mode completion
 complete_add( {expr})           Number  add completion match
@@ -1622 +1623 @@
 getline( {lnum})                String  line {lnum} of current buffer
 getline( {lnum}, {end})         List    lines {lnum} to {end} of current buffer
 getloclist({nr})                List    list of location list items
+getmatches()                    List    list of current matches
 getpos( {expr})                 List    position of cursor, mark, etc.
 getqflist()                     List    list of quickfix items
 getreg( [{regname} [, 1]])      String  contents of register
@@ -1676 +1678 @@
                                 String  check for mappings matching {name}
 match( {expr}, {pat}[, {start}[, {count}]])
                                 Number  position where {pat} matches in {expr}
+matchadd( {group}, {pattern}[, {priority}[, {id}]])
+                                Number  highlight {pattern} with {group}
 matcharg( {nr})                 List    arguments of |:match|
+matchdelete( {id})              Number  delete match identified by {id}
 matchend( {expr}, {pat}[, {start}[, {count}]])
                                 Number  position where {pat} ends in {expr}
 matchlist( {expr}, {pat}[, {start}[, {count}]])
@@ -1731 +1736 @@
 setline( {lnum}, {line})        Number  set line {lnum} to {line}
 setloclist( {nr}, {list}[, {action}])
                                 Number  modify location list using {list}
+setmatches( {list})             Number  restore a list of matches
 setpos( {expr}, {list})         none    set the {expr} position to {list}
 setqflist( {list}[, {action}])  Number  modify quickfix list using {list}
 setreg( {n}, {v}[, {opt}])      Number  set register to value and type
@@ -2012 +2018 @@
                 feature, -1 is returned.
                 See |C-indenting|.
 
+clearmatches()                                          *clearmatches()*
+                Clears all matches previously defined by |matchadd()| and the
+                |:match| commands.
+
                                                         *col()*
 col({expr})     The result is a Number, which is the byte index of the column
                 position given with {expr}.  The accepted positions are:
@@ -2020 +2030 @@
                             number of characters in the cursor line plus one)
                     'x      position of mark x (if the mark is not set, 0 is
                             returned)
+                Additionally {expr} can be [lnum, col]: a |List| with the line
+                and column number. Most useful when the column is "$", to get
+                the las column of a specific line.  When "lnum" or "col" is
+                out of range then col() returns zero.
                 To get the line number use |line()|.  To get both use
                 |getpos()|.
                 For the screen column position use |virtcol()|.
@@ -2824 +2838 @@
                 given file {fname}.
                 If {fname} is a directory, 0 is returned.
                 If the file {fname} can't be found, -1 is returned.
+                If the size of {fname} is too big to fit in a Number then -2
+                is returned.
 
 getfontname([{name}])                                   *getfontname()*
                 Without an argument returns the name of the normal font being
@@ -2912 +2928 @@
                 returned.  For an invalid window number {nr}, an empty list is
                 returned. Otherwise, same as getqflist().
 
+getmatches()                                            *getmatches()*
+                Returns a |List| with all matches previously defined by
+                |matchadd()| and the |:match| commands.  |getmatches()| is
+                useful in combination with |setmatches()|, as |setmatches()|
+                can restore a list of matches saved by |getmatches()|.
+                Example: >
+                        :echo getmatches()
+<                       [{'group': 'MyGroup1', 'pattern': 'TODO',
+                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
+                        'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
+                        :let m = getmatches()
+                        :call clearmatches()
+                        :echo getmatches()
+<                       [] >
+                        :call setmatches(m)
+                        :echo getmatches()
+<                       [{'group': 'MyGroup1', 'pattern': 'TODO',
+                        'priority': 10, 'id': 1}, {'group': 'MyGroup2',
+                        'pattern': 'FIXME', 'priority': 10, 'id': 2}] >
+                        :unlet m
+<
+
 getqflist()                                             *getqflist()*
                 Returns a list with all the current quickfix errors.  Each
                 list item is a dictionary with these entries:
@@ -3616 +3654 @@
                 the pattern.  'smartcase' is NOT used.  The matching is always
                 done like 'magic' is set and 'cpoptions' is empty.
 
+                                        *matchadd()* *E798* *E799* *E801*
+matchadd({group}, {pattern}[, {priority}[, {id}]])
+                Defines a pattern to be highlighted in the current window (a
+                "match").  It will be highlighted with {group}.  Returns an
+                identification number (ID), which can be used to delete the
+                match using |matchdelete()|.
+
+                The optional {priority} argument assigns a priority to the
+                match.  A match with a high priority will have its
+                highlighting overrule that of a match with a lower priority.
+                A priority is specified as an integer (negative numbers are no
+                exception).  If the {priority} argument is not specified, the
+                default priority is 10.  The priority of 'hlsearch' is zero,
+                hence all matches with a priority greater than zero will
+                overrule it.  Syntax highlighting (see 'syntax') is a separate
+                mechanism, and regardless of the chosen priority a match will
+                always overrule syntax highlighting.
+
+                The optional {id} argument allows the request for a specific
+                match ID.  If a specified ID is already taken, an error
+                message will appear and the match will not be added.  An ID
+                is specified as a positive integer (zero excluded).  IDs 1, 2
+                and 3 are reserved for |:match|, |:2match| and |:3match|,
+                respectively.  If the {id} argument is not specified,
+                |matchadd()| automatically chooses a free ID.
+
+                The number of matches is not limited, as it is the case with
+                the |:match| commands.
+
+                Example: >
+                        :highlight MyGroup ctermbg=green guibg=green
+                        :let m = matchadd("MyGroup", "TODO")
+<               Deletion of the pattern: >
+                        :call matchdelete(m)
+
+<               A list of matches defined by |matchadd()| and |:match| are
+                available from |getmatches()|.  All matches can be deleted in
+                one operation by |clearmatches()|.
 
 matcharg({nr})                                                  *matcharg()*
                 Selects the {nr} match item, as set with a |:match|,
@@ -3625 +3701 @@
                         The pattern used.
                 When {nr} is not 1, 2 or 3 returns an empty |List|.
                 When there is no match item set returns ['', ''].
-                This is usef to save and restore a |:match|.
-
+                This is useful to save and restore a |:match|.
+                Highlighting matches using the |:match| commands are limited
+                to three matches. |matchadd()| does not have this limitation.
+
+matchdelete({id})                              *matchdelete()* *E802* *E803*
+                Deletes a match with ID {id} previously defined by |matchadd()|
+                or one of the |:match| commands.  Returns 0 if succesfull,
+                otherwise -1.  See example for |matchadd()|.  All matches can
+                be deleted in one operation by |clearmatches()|.
 
 matchend({expr}, {pat}[, {start}[, {count}]])                   *matchend()*
                 Same as match(), but return the index of first character after
@@ -4379 +4462 @@
                 When {nr} is zero the current window is used. For a location
                 list window, the displayed location list is modified.  For an
                 invalid window number {nr}, -1 is returned.
-                Otherwise, same as setqflist().
+                Otherwise, same as |setqflist()|.
+                Also see |location-list|.
+
+setmatches({list})                                      *setmatches()*
+                Restores a list of matches saved by |getmatches()|.  Returns 0
+                if succesfull, otherwise -1.  All current matches are cleared
+                before the list is restored.  See example for |getmatches()|.
 
                                                         *setpos()*
 setpos({expr}, {list})
@@ -5022 +5111 @@
                 position, the returned Number will be the column at the end of
                 the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
                 set to 8, it returns 8.
-                For the use of {expr} see |col()|.  Additionally you can use
-                [lnum, col]: a |List| with the line and column number.  When
-                "lnum" or "col" is out of range then virtcol() returns zero.
-                When 'virtualedit' is used it can be [lnum, col, off], where
+                For the byte position use |col()|.
+                For the use of {expr} see |col()|.
+                When 'virtualedit' is used {expr} can be [lnum, col, off], where
                 "off" is the offset in screen columns from the start of the
                 character.  E.g., a position within a <Tab> or after the last
                 character.
-                For the byte position use |col()|.
                 When Virtual editing is active in the current mode, a position
                 beyond the end of the line can be returned. |'virtualedit'|
                 The accepted positions are:

runtime/doc/options.txt

@@ -1 @@
-*options.txt*   For Vim version 7.1.  Last change: 2007 May 11
+*options.txt*   For Vim version 7.1.  Last change: 2007 Aug 10
 
 
                   VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -2415 +2415 @@
         When mixing vertically and horizontally split windows, a minimal size
         is computed and some windows may be larger if there is room.  The
         'eadirection' option tells in which direction the size is affected.
-        Changing the height of a window can be avoided by setting
-        'winfixheight'.
+        Changing the height and width of a window can be avoided by setting
+        'winfixheight' and 'winfixwidth', respectively.
 
                                                 *'equalprg'* *'ep'*
 'equalprg' 'ep'         string  (default "")

runtime/doc/pattern.txt

@@ -1212 +1212 @@
                 {group} must exist at the moment this command is executed.
 
                 The {group} highlighting still applies when a character is
-                to be highlighted for 'hlsearch'.
+                to be highlighted for 'hlsearch', as the highlighting for
+                matches is given higher priority than that of 'hlsearch'.
+                Syntax highlighting (see 'syntax') is also overruled by
+                matches.
 
                 Note that highlighting the last used search pattern with
                 'hlsearch' is used in all windows, while the pattern defined
@@ -1226 +1229 @@
                 display you may get unexpected results.  That is because Vim
                 looks for a match in the line where redrawing starts.
 
-                Also see |matcharg()|, it returns the highlight group and
-                pattern of a previous :match command.
+                Also see |matcharg()|and |getmatches()|. The former returns
+                the highlight group and pattern of a previous |:match|
+                command.  The latter returns a list with highlight groups and
+                patterns defined by both |matchadd()| and |:match|.
+
+                Highlighting matches using |:match| are limited to three
+                matches (aside from |:match|, |:2match| and |:3match|are
+                available). |matchadd()| does not have this limitation and in
+                addition makes it possible to prioritize matches.
 
                 Another example, which highlights all characters in virtual
                 column 72 and more: >

runtime/doc/pi_paren.txt

@@ -12 +12 @@
 You can avoid loading this plugin by setting the "loaded_matchparen" variable: >
         :let loaded_matchparen = 1
 
-The plugin installs CursorMoved autocommands to redefine the match
-highlighting.
+The plugin installs CursorMoved, CursorMovedI and WinEnter autocommands to
+redefine the match highlighting.
 
 To disable the plugin after it was loaded use this command: >
 

runtime/doc/usr_41.txt

@@ -763 +763 @@
         foldtextresult()        get the text displayed for a closed fold
 
 Syntax and highlighting:
+        clearmatches()          clear all matches defined by |matchadd()| and
+                                the |:match| commands
+        getmatches()            get all matches defined by |matchadd()| and
+                                the |:match| commands
         hlexists()              check if a highlight group exists
         hlID()                  get ID of a highlight group
         synID()                 get syntax ID at a specific position
         synIDattr()             get a specific attribute of a syntax ID
         synIDtrans()            get translated syntax ID
         diff_hlID()             get highlight ID for diff mode at a position
+        matchadd()              define a pattern to highlight (a "match")
         matcharg()              get info about |:match| arguments
+        matchdelete()           delete a match defined by |matchadd()| or a
+                                |:match| command
+        setmatches()            restore a list of matches saved by
+                                |getmatches()|
 
 Spelling:
         spellbadword()          locate badly spelled word at or after cursor

runtime/doc/windows.txt

@@ -132 +132 @@
                 the same file.  Make new window N high (default is to use half
                 the height of the current window).  Reduces the current window
                 height to create room (and others, if the 'equalalways' option
-                is set and 'eadirection' isn't "hor").
+                is set, 'eadirection' isn't "hor", and one of them is higher
+                than the current or the new window).
                 Note: CTRL-S does not work on all terminals and might block
                 further input, use CTRL-Q to get going again.
                 Also see |++opt| and |+cmd|.
@@ -140 +141 @@
 CTRL-W CTRL-V                                           *CTRL-W_CTRL-V*
 CTRL-W v                                                *CTRL-W_v*
 :[N]vs[plit] [++opt] [+cmd] [file]                      *:vs* *:vsplit*
-                Like |:split|, but split vertically.  If 'equalalways' is set
-                and 'eadirection' isn't "ver" the windows will be spread out
-                horizontally, unless a width was specified.
+                Like |:split|, but split vertically.  The windows will be
+                spread out horizontally if
+                1. a width was not specified,
+                2. 'equalalways' is set,
+                3. 'eadirection' isn't "ver", and
+                4. one of the other windows are wider than the current or new
+                   window.
                 Note: In other places CTRL-Q does the same as CTRL-V, but here
                 it doesn't!
 

runtime/filetype.vim

@@ -1 +1 @@
 " Vim support file to detect file types
 "
 " Maintainer:   Bram Moolenaar <Bram@vim.org>
-" Last Change:  2007 May 10
+" Last Change:  2007 May 15
 
 " Listen very carefully, I will say this only once
 if exists("did_load_filetypes")
@@ -1286 +1286 @@
 au BufNewFile,BufRead *.it,*.ih                 setf ppwiz
 
 " Oracle Pro*C/C++
-au BufNewFile,BufRead .pc                       setf proc
+au BufNewFile,BufRead *.pc                      setf proc
 
 " Privoxy actions file
 au BufNewFile,BufRead *.action                  setf privoxy

runtime/plugin/matchparen.vim

@@ -1 +1 @@
 " Vim plugin for showing matching parens
 " Maintainer:  Bram Moolenaar <Bram@vim.org>
-" Last Change: 2006 Oct 12
+" Last Change: 2007 Aug 8
 
 " Exit quickly when:
 " - this plugin was already loaded (or disabled)
@@ -13 +13 @@
 
 augroup matchparen
   " Replace all matchparen autocommands
-  autocmd! CursorMoved,CursorMovedI * call s:Highlight_Matching_Pair()
+  autocmd! CursorMoved,CursorMovedI,WinEnter * call s:Highlight_Matching_Pair()
 augroup END
 
 " Skip the rest if it was already done.
@@ -62 +62 @@
   " Figure out the arguments for searchpairpos().
   " Restrict the search to visible lines with "stopline".
   " And avoid searching very far (e.g., for closed folds and long lines)
+  " The "viewable" variables give a range in which we can scroll while keeping
+  " the cursor at the same position
+  " adjustedScrolloff accounts for very large numbers of scrolloff
+  let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2])
+  let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2])
+  let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2])
+  " one of these stoplines will be adjusted below, but the current values are
+  " minimal boundaries within the current window
+  let stoplinebottom = line('w$')
+  let stoplinetop = line('w0')
   if i % 2 == 0
     let s_flags = 'nW'
     let c2 = plist[i + 1]
     if has("byte_offset") && has("syntax_items") && &smc > 0
       let stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2])
-      let stopline = min([line('w$'), byte2line(stopbyte)])
+      let stopline = min([bottom_viewable, byte2line(stopbyte)])
     else
-      let stopline = min([line('w$'), c_lnum + 100])
+      let stopline = min([bottom_viewable, c_lnum + 100])
     endif
+    let stoplinebottom = stopline
   else
     let s_flags = 'nbW'
     let c2 = c
     let c = plist[i - 1]
     if has("byte_offset") && has("syntax_items") && &smc > 0
       let stopbyte = max([1, line2byte(".") + col(".") - &smc * 2])
-      let stopline = max([line('w0'), byte2line(stopbyte)])
+      let stopline = max([top_viewable, byte2line(stopbyte)])
     else
-      let stopline = max([line('w0'), c_lnum - 100])
+      let stopline = max([top_viewable, c_lnum - 100])
     endif
+    let stoplinetop = stopline
   endif
   if c == '['
     let c = '\['
@@ -106 +118 @@
   endif
 
   " If a match is found setup match highlighting.
-  if m_lnum > 0 && m_lnum >= line('w0') && m_lnum <= line('w$')
+  if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom 
     exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) .
           \ 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/'
     let w:paren_hl_on = 1
@@ -114 +126 @@
 endfunction
 
 " Define commands that will disable and enable the plugin.
-command! NoMatchParen 3match none | unlet! g:loaded_matchparen | au! matchparen
-command! DoMatchParen runtime plugin/matchparen.vim | doau CursorMoved
+command! NoMatchParen windo 3match none | unlet! g:loaded_matchparen |
+          \ au! matchparen
+command! DoMatchParen runtime plugin/matchparen.vim | windo doau CursorMoved
 
 let &cpo = cpo_save

src/auto/configure

@@ -3843 +3843 @@
   fi
 
   if test "X$vi_cv_path_mzscheme_pfx" != "X"; then
-    if test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"; then
+    if test "x$MACOSX" = "xyes"; then
+      MZSCHEME_LIBS="-framework PLT_MzScheme"
+    elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"; then
       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libmzscheme.a ${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"
     else
       MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lmzscheme -lmzgc"

src/buffer.c

@@ -171 +171 @@
             /* Put the cursor on the first line. */
             curwin->w_cursor.lnum = 1;
             curwin->w_cursor.col = 0;
+
+            /* Set or reset 'modified' before executing autocommands, so that
+             * it can be changed there. */
+            if (!readonlymode && !bufempty())
+                changed();
+            else if (retval != FAIL)
+                unchanged(curbuf, FALSE);
 #ifdef FEAT_AUTOCMD
 # ifdef FEAT_EVAL
             apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE,
@@ -194 +201 @@
     /* When reading stdin, the buffer contents always needs writing, so set
      * the changed flag.  Unless in readonly mode: "ls | gview -".
      * When interrupted and 'cpoptions' contains 'i' set changed flag. */
-    if ((read_stdin && !readonlymode && !bufempty())
+    if ((got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL)
 #ifdef FEAT_AUTOCMD
                 || modified_was_set     /* ":set modified" used in autocmd */
 # ifdef FEAT_EVAL
                 || (aborting() && vim_strchr(p_cpo, CPO_INTMOD) != NULL)
 # endif
 #endif
-                || (got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL))
+       )
         changed();
-    else if (retval != FAIL)
+    else if (retval != FAIL && !read_stdin)
         unchanged(curbuf, FALSE);
     save_file_ff(curbuf);               /* keep this fileformat */
 
@@ -495 +502 @@
     buf->b_start_eol = TRUE;
 #ifdef FEAT_MBYTE
     buf->b_p_bomb = FALSE;
+    buf->b_start_bomb = FALSE;
 #endif
     buf->b_ml.ml_mfp = NULL;
     buf->b_ml.ml_flags = ML_EMPTY;              /* empty buffer */
@@ -4853 +4861 @@
              */
             for (e = s; *e != ':' && *e != NUL; ++e)
                 if (e[0] == '\\' && e[1] == ':')
-                    STRCPY(e, e + 1);
+                    mch_memmove(e, e + 1, STRLEN(e));
             if (*e == NUL)
                 end = TRUE;
 

src/charset.c

@@ -207 +207 @@
             }
             while (c <= c2)
             {
-                if (!do_isalpha || isalpha(c)
+                /* Use the MB_ functions here, because isalpha() doesn't
+                 * work properly when 'encoding' is "latin1" and the locale is
+                 * "C".  */
+                if (!do_isalpha || MB_ISLOWER(c) || MB_ISUPPER(c)
 #ifdef FEAT_FKMAP
                         || (p_altkeymap && (F_isalpha(c) || F_isdigit(c)))
 #endif
@@ -929 +932 @@
 }
 
 /*
+ * return TRUE if 'c' is a valid file-name character or a wildcard character
+ * Assume characters above 0x100 are valid (multi-byte).
+ * Explicitly interpret ']' as a wildcard character as mch_has_wildcard("]")
+ * returns false.
+ */
+    int
+vim_isfilec_or_wc(c)
+    int c;
+{
+    char_u buf[2];
+
+    buf[0] = (char_u)c;
+    buf[1] = NUL;
+    return vim_isfilec(c) || c == ']' || mch_has_wildcard(buf);
+}
+
+/*
  * return TRUE if 'c' is a printable character
  * Assume characters above 0x100 are printable (multi-byte), except for
  * Unicode.
@@ -1898 +1918 @@
 {
     for ( ; *p; ++p)
         if (rem_backslash(p))
-            STRCPY(p, p + 1);
+            mch_memmove(p, p + 1, STRLEN(p));
 }
 
 /*

src/configure.in

@@ -423 +423 @@
   fi
 
   if test "X$vi_cv_path_mzscheme_pfx" != "X"; then
-    if test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"; then
+    if test "x$MACOSX" = "xyes"; then
+      MZSCHEME_LIBS="-framework PLT_MzScheme"
+    elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"; then
       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libmzscheme.a ${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"
     else
       MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lmzscheme -lmzgc"

src/digraph.c

@@ -2349 +2349 @@
 
     if (*curbuf->b_p_keymap == NUL)
     {
-        /* Stop any active keymap and clear the table. */
+        /* Stop any active keymap and clear the table.  Also remove
+         * b:keymap_unload, as no keymap is active now. */
         keymap_unload();
+        do_cmdline_cmd((char_u *)"unlet! b:keymap_name");
     }
     else
     {
@@ -2500 +2502 @@
 
     ga_clear(&curbuf->b_kmap_ga);
     curbuf->b_kmap_state &= ~KEYMAP_LOADED;
-    do_cmdline_cmd((char_u *)"unlet! b:keymap_name");
 #ifdef FEAT_WINDOWS
     status_redraw_curbuf();
 #endif

src/edit.c

@@ -2057 +2057 @@
  * case of the originally typed text is used, and the case of the completed
  * text is inferred, ie this tries to work out what case you probably wanted
  * the rest of the word to be in -- webb
- * TODO: make this work for multi-byte characters.
  */
     int
 ins_compl_add_infercase(str, len, icase, fname, dir, flags)
@@ -2068 +2067 @@
     int         dir;
     int         flags;
 {
+    char_u      *p;
+    int         i, c;
+    int         actual_len;             /* Take multi-byte characters */
+    int         actual_compl_length;    /* into account. */
+    int         *wca;                   /* Wide character array. */
     int         has_lower = FALSE;
     int         was_letter = FALSE;
-    int         idx;
 
-    if (p_ic && curbuf->b_p_inf && len < IOSIZE)
+    if (p_ic && curbuf->b_p_inf)
     {
-        /* Infer case of completed part -- webb */
-        /* Use IObuff, str would change text in buffer! */
-        vim_strncpy(IObuff, str, len);
+        /* Infer case of completed part. */
 
-        /* Rule 1: Were any chars converted to lower? */
-        for (idx = 0; idx < compl_length; ++idx)
+        /* Find actual length of completion. */
+#ifdef FEAT_MBYTE
+        if (has_mbyte)
         {
-            if (islower(compl_orig_text[idx]))
+            p = str;
+            actual_len = 0;
+            while (*p != NUL)
             {
-                has_lower = TRUE;
-                if (isupper(IObuff[idx]))
-                {
-                    /* Rule 1 is satisfied */
-                    for (idx = compl_length; idx < len; ++idx)
-                        IObuff[idx] = TOLOWER_LOC(IObuff[idx]);
-                    break;
-                }
+                mb_ptr_adv(p);
+                ++actual_len;
             }
         }
+        else
+#endif
+            actual_len = len;
 
-        /*
-         * Rule 2: No lower case, 2nd consecutive letter converted to
-         * upper case.
-         */
-        if (!has_lower)
+        /* Find actual length of original text. */
+#ifdef FEAT_MBYTE
+        if (has_mbyte)
+        {
+            p = compl_orig_text;
+            actual_compl_length = 0;
+            while (*p != NUL)
+            {
+                mb_ptr_adv(p);
+                ++actual_compl_length;
+            }
+        }
+        else
+#endif
+            actual_compl_length = compl_length;
+
+        /* Allocate wide character array for the completion and fill it. */
+        wca = (int *)alloc(actual_len * sizeof(int));
+        if (wca != NULL)
         {
-            for (idx = 0; idx < compl_length; ++idx)
+            p = str;
+            for (i = 0; i < actual_len; ++i)
+#ifdef FEAT_MBYTE
+                if (has_mbyte)
+                    wca[i] = mb_ptr2char_adv(&p);
+                else
+#endif
+                    wca[i] = *(p++);
+
+            /* Rule 1: Were any chars converted to lower? */
+            p = compl_orig_text;
+            for (i = 0; i < actual_compl_length; ++i)
             {
-                if (was_letter && isupper(compl_orig_text[idx])
-                                                      && islower(IObuff[idx]))
+#ifdef FEAT_MBYTE
+                if (has_mbyte)
+                    c = mb_ptr2char_adv(&p);
+                else
+#endif
+                    c = *(p++);
+                if (MB_ISLOWER(c))
                 {
-                    /* Rule 2 is satisfied */
-                    for (idx = compl_length; idx < len; ++idx)
-                        IObuff[idx] = TOUPPER_LOC(IObuff[idx]);
-                    break;
+                    has_lower = TRUE;
+                    if (MB_ISUPPER(wca[i]))
+                    {
+                        /* Rule 1 is satisfied. */
+                        for (i = actual_compl_length; i < actual_len; ++i)
+                            wca[i] = MB_TOLOWER(wca[i]);
+                        break;
+                    }
                 }
-                was_letter = isalpha(compl_orig_text[idx]);
             }
-        }
 
-        /* Copy the original case of the part we typed */
-        STRNCPY(IObuff, compl_orig_text, compl_length);
+            /*
+             * Rule 2: No lower case, 2nd consecutive letter converted to
+             * upper case.
+             */
+            if (!has_lower)
+            {
+                p = compl_orig_text;
+                for (i = 0; i < actual_compl_length; ++i)
+                {
+#ifdef FEAT_MBYTE
+                    if (has_mbyte)
+                        c = mb_ptr2char_adv(&p);
+                    else
+#endif
+                        c = *(p++);
+                    if (was_letter && MB_ISUPPER(c) && MB_ISLOWER(wca[i]))
+                    {
+                        /* Rule 2 is satisfied. */
+                        for (i = actual_compl_length; i < actual_len; ++i)
+                            wca[i] = MB_TOUPPER(wca[i]);
+                        break;
+                    }
+                    was_letter = MB_ISLOWER(c) || MB_ISUPPER(c);
+                }
+            }
+
+            /* Copy the original case of the part we typed. */
+            p = compl_orig_text;
+            for (i = 0; i < actual_compl_length; ++i)
+            {
+#ifdef FEAT_MBYTE
+                if (has_mbyte)
+                    c = mb_ptr2char_adv(&p);
+                else
+#endif
+                    c = *(p++);
+                if (MB_ISLOWER(c))
+                    wca[i] = MB_TOLOWER(wca[i]);
+                else if (MB_ISUPPER(c))
+                    wca[i] = MB_TOUPPER(wca[i]);
+            }
+
+            /* 
+             * Generate encoding specific output from wide character array.
+             * Multi-byte characters can occupy up to five bytes more than
+             * ASCII characters, and we also need one byte for NUL, so stay
+             * six bytes away from the edge of IObuff.
+             */
+            p = IObuff;
+            i = 0;
+            while (i < actual_len && (p - IObuff + 6) < IOSIZE)
+#ifdef FEAT_MBYTE
+                if (has_mbyte)
+                    p += mb_char2bytes(wca[i++], p);
+                else
+#endif
+                    *(p++) = wca[i++];
+            *p = NUL;
+
+            vim_free(wca);
+        }
 
         return ins_compl_add(IObuff, len, icase, fname, NULL, dir,
                                                                 flags, FALSE);
@@ -2842 +2934 @@
                         /*
                          * Add the other matches on the line
                          */
+                        ptr = buf;
                         while (!got_int)
                         {
                             /* Find start of the next word.  Skip white
@@ -2851 +2944 @@
                                 break;
                             wstart = ptr;
 
-                            /* Find end of the word and add it. */
+                            /* Find end of the word. */
 #ifdef FEAT_MBYTE
                             if (has_mbyte)
                                 /* Japanese words may have characters in
@@ -2868 +2961 @@
                             else
 #endif
                                 ptr = find_word_end(ptr);
-                            add_r = ins_compl_add_infercase(wstart,
-                                    (int)(ptr - wstart),
-                                    p_ic, files[i], *dir, 0);
+
+                            /* Add the word. Skip the regexp match. */
+                            if (wstart != regmatch->startp[0])
+                                add_r = ins_compl_add_infercase(wstart,
+                                        (int)(ptr - wstart),
+                                        p_ic, files[i], *dir, 0);
                         }
                     }
                     if (add_r == OK)
@@ -7215 +7311 @@
                 p = ml_get_curline();
                 if (cin_iscase(p) || cin_isscopedecl(p) || cin_islabel(30))
                     return TRUE;
+                /* Need to get the line again after cin_islabel(). */
+                p = ml_get_curline();
                 if (curwin->w_cursor.col > 2
                         && p[curwin->w_cursor.col - 1] == ':'
                         && p[curwin->w_cursor.col - 2] == ':')
@@ -7998 +8096 @@
     /*
      * 0^D and ^^D: remove all indent.
      */
-    if ((lastc == '0' || lastc == '^') && curwin->w_cursor.col)
+    if (c == Ctrl_D && (lastc == '0' || lastc == '^')
+                                                  && curwin->w_cursor.col > 0)
     {
         --curwin->w_cursor.col;
         (void)del_char(FALSE);          /* delete the '^' or '0' */

src/eval.c

@@ -369 +369 @@
 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
 static char_u *skip_var_list __ARGS((char_u *arg, int *var_count, int *semicolon));
 static char_u *skip_var_one __ARGS((char_u *arg));
-static void list_hashtable_vars __ARGS((hashtab_T *ht, char_u *prefix, int empty));
-static void list_glob_vars __ARGS((void));
-static void list_buf_vars __ARGS((void));
-static void list_win_vars __ARGS((void));
+static void list_hashtable_vars __ARGS((hashtab_T *ht, char_u *prefix, int empty, int *first));
+static void list_glob_vars __ARGS((int *first));
+static void list_buf_vars __ARGS((int *first));
+static void list_win_vars __ARGS((int *first));
 #ifdef FEAT_WINDOWS
-static void list_tab_vars __ARGS((void));
+static void list_tab_vars __ARGS((int *first));
 #endif
-static void list_vim_vars __ARGS((void));
-static void list_script_vars __ARGS((void));
-static void list_func_vars __ARGS((void));
-static char_u *list_arg_vars __ARGS((exarg_T *eap, char_u *arg));
+static void list_vim_vars __ARGS((int *first));
+static void list_script_vars __ARGS((int *first));
+static void list_func_vars __ARGS((int *first));
+static char_u *list_arg_vars __ARGS((exarg_T *eap, char_u *arg, int *first));
 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
 static int check_changedtick __ARGS((char_u *arg));
 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
@@ -475 +475 @@
 static void f_changenr __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_char2nr __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_cindent __ARGS((typval_T *argvars, typval_T *rettv));
+static void f_clearmatches __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_col __ARGS((typval_T *argvars, typval_T *rettv));
 #if defined(FEAT_INS_EXPAND)
 static void f_complete __ARGS((typval_T *argvars, typval_T *rettv));
@@ -529 +530 @@
 static void f_getftime __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_getftype __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_getline __ARGS((typval_T *argvars, typval_T *rettv));
+static void f_getmatches __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_getpos __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_getqflist __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_getreg __ARGS((typval_T *argvars, typval_T *rettv));
@@ -577 +579 @@
 static void f_maparg __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_mapcheck __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_match __ARGS((typval_T *argvars, typval_T *rettv));
+static void f_matchadd __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_matcharg __ARGS((typval_T *argvars, typval_T *rettv));
+static void f_matchdelete __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_matchend __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_matchlist __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_matchstr __ARGS((typval_T *argvars, typval_T *rettv));
@@ -618 +622 @@
 static void f_setcmdpos __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_setline __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_setloclist __ARGS((typval_T *argvars, typval_T *rettv));
+static void f_setmatches __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_setpos __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_setqflist __ARGS((typval_T *argvars, typval_T *rettv));
 static void f_setreg __ARGS((typval_T *argvars, typval_T *rettv));
@@ -672 +677 @@
 static void f_writefile __ARGS((typval_T *argvars, typval_T *rettv));
 
 static int list2fpos __ARGS((typval_T *arg, pos_T *posp, int *fnump));
-static pos_T *var2fpos __ARGS((typval_T *varp, int lnum, int *fnum));
+static pos_T *var2fpos __ARGS((typval_T *varp, int dollar_lnum, int *fnum));
 static int get_env_len __ARGS((char_u **arg));
 static int get_id_len __ARGS((char_u **arg));
 static int get_name_len __ARGS((char_u **arg, char_u **alias, int evaluate, int verbose));
@@ -699 +704 @@
 static hashtab_T *find_var_ht __ARGS((char_u *name, char_u **varname));
 static void vars_clear_ext __ARGS((hashtab_T *ht, int free_val));
 static void delete_var __ARGS((hashtab_T *ht, hashitem_T *hi));
-static void list_one_var __ARGS((dictitem_T *v, char_u *prefix));
-static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string));
+static void list_one_var __ARGS((dictitem_T *v, char_u *prefix, int *first));
+static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
 static void set_var __ARGS((char_u *name, typval_T *varp, int copy));
 static int var_check_ro __ARGS((int flags, char_u *name));
 static int var_check_fixed __ARGS((int flags, char_u *name));
@@ -992 +997 @@
     char_u      *value;
     int         value_len;
 {
-    size_t      len;
+    int         len;
 
     if (redir_lval == NULL)
         return;
 
     if (value_len == -1)
-        len = STRLEN(value);    /* Append the entire string */
+        len = (int)STRLEN(value);       /* Append the entire string */
     else
-        len = value_len;        /* Append only "value_len" characters */
+        len = value_len;                /* Append only "value_len" characters */
 
-    if (ga_grow(&redir_ga, (int)len) == OK)
+    if (ga_grow(&redir_ga, len) == OK)
     {
         mch_memmove((char *)redir_ga.ga_data + redir_ga.ga_len, value, len);
-        redir_ga.ga_len += (int)len;
+        redir_ga.ga_len += len;
     }
     else
         var_redir_stop();
@@ -1411 +1416 @@
 }
 
 
-#if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
+#if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
+        || defined(FEAT_COMPL_FUNC) || defined(PROTO)
 /*
  * Call some vimL function and return the result in "*rettv".
  * Uses argv[argc] for the function arguments.
@@ -1484 +1490 @@
     return ret;
 }
 
+# if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
 /*
  * Call vimL function "func" and return the result as a string.
  * Returns NULL when calling the function fails.
@@ -1506 +1513 @@
     clear_tv(&rettv);
     return retval;
 }
+# endif
 
-#if defined(FEAT_COMPL_FUNC) || defined(PROTO)
+# if defined(FEAT_COMPL_FUNC) || defined(PROTO)
 /*
  * Call vimL function "func" and return the result as a number.
  * Returns -1 when calling the function fails.
@@ -1530 +1538 @@
     clear_tv(&rettv);
     return retval;
 }
-#endif
+# endif
 
 /*
  * Call vimL function "func" and return the result as a list
@@ -1556 +1564 @@
 
     return rettv.vval.v_list;
 }
-
 #endif
 
+
 /*
  * Save the current function call pointer, and set it to NULL.
  * Used when executing autocommands and for ":source".
@@ -1691 +1699 @@
     int         semicolon = 0;
     char_u      op[2];
     char_u      *argend;
+    int         first = TRUE;
 
     argend = skip_var_list(arg, &var_count, &semicolon);
     if (argend == NULL)
@@ -1707 +1716 @@
             EMSG(_(e_invarg));
         else if (!ends_excmd(*arg))
             /* ":let var1 var2" */
-            arg = list_arg_vars(eap, arg);
+            arg = list_arg_vars(eap, arg, &first);
         else if (!eap->skip)
         {
             /* ":let" */
-            list_glob_vars();
-            list_buf_vars();
-            list_win_vars();
+            list_glob_vars(&first);
+            list_buf_vars(&first);
+            list_win_vars(&first);
 #ifdef FEAT_WINDOWS
-            list_tab_vars();
+            list_tab_vars(&first);
 #endif
-            list_script_vars();
-            list_func_vars();
-            list_vim_vars();
+            list_script_vars(&first);
+            list_func_vars(&first);
+            list_vim_vars(&first);
         }
         eap->nextcmd = check_nextcmd(arg);
     }
@@ -1924 +1933 @@
  * If "empty" is TRUE also list NULL strings as empty strings.
  */
     static void
-list_hashtable_vars(ht, prefix, empty)
+list_hashtable_vars(ht, prefix, empty, first)
     hashtab_T   *ht;
     char_u      *prefix;
     int         empty;
+    int         *first;
 {
     hashitem_T  *hi;
     dictitem_T  *di;
@@ -1942 +1952 @@
             di = HI2DI(hi);
             if (empty || di->di_tv.v_type != VAR_STRING
                                            || di->di_tv.vval.v_string != NULL)
-                list_one_var(di, prefix);
+                list_one_var(di, prefix, first);
         }
     }
 }
@@ -1951 +1961 @@
  * List global variables.
  */
     static void
-list_glob_vars()
+list_glob_vars(first)
+    int *first;
 {
-    list_hashtable_vars(&globvarht, (char_u *)"", TRUE);
+    list_hashtable_vars(&globvarht, (char_u *)"", TRUE, first);
 }
 
 /*
  * List buffer variables.
  */
     static void
-list_buf_vars()
+list_buf_vars(first)
+    int *first;
 {
     char_u      numbuf[NUMBUFLEN];
 
-    list_hashtable_vars(&curbuf->b_vars.dv_hashtab, (char_u *)"b:", TRUE);
+    list_hashtable_vars(&curbuf->b_vars.dv_hashtab, (char_u *)"b:",
+                                                                 TRUE, first);
 
     sprintf((char *)numbuf, "%ld", (long)curbuf->b_changedtick);
-    list_one_var_a((char_u *)"b:", (char_u *)"changedtick", VAR_NUMBER, numbuf);
+    list_one_var_a((char_u *)"b:", (char_u *)"changedtick", VAR_NUMBER,
+                                                               numbuf, first);
 }
 
 /*
  * List window variables.
  */
     static void
-list_win_vars()
+list_win_vars(first)
+    int *first;
 {
-    list_hashtable_vars(&curwin->w_vars.dv_hashtab, (char_u *)"w:", TRUE);
+    list_hashtable_vars(&curwin->w_vars.dv_hashtab,
+                                                 (char_u *)"w:", TRUE, first);
 }
 
 #ifdef FEAT_WINDOWS
@@ -1984 +2000 @@
  * List tab page variables.
  */
     static void
-list_tab_vars()
+list_tab_vars(first)
+    int *first;
 {
-    list_hashtable_vars(&curtab->tp_vars.dv_hashtab, (char_u *)"t:", TRUE);
+    list_hashtable_vars(&curtab->tp_vars.dv_hashtab,
+                                                 (char_u *)"t:", TRUE, first);
 }
 #endif
 
@@ -1994 +2012 @@
  * List Vim variables.
  */
     static void
-list_vim_vars()
+list_vim_vars(first)
+    int *first;
 {
-    list_hashtable_vars(&vimvarht, (char_u *)"v:", FALSE);
+    list_hashtable_vars(&vimvarht, (char_u *)"v:", FALSE, first);
 }
 
 /*
  * List script-local variables, if there is a script.
  */
     static void
-list_script_vars()
+list_script_vars(first)
+    int *first;
 {
     if (current_SID > 0 && current_SID <= ga_scripts.ga_len)
-        list_hashtable_vars(&SCRIPT_VARS(current_SID), (char_u *)"s:", FALSE);
+        list_hashtable_vars(&SCRIPT_VARS(current_SID),
+                                                (char_u *)"s:", FALSE, first);
 }
 
 /*
  * List function variables, if there is a function.
  */
     static void
-list_func_vars()
+list_func_vars(first)
+    int *first;
 {
     if (current_funccal != NULL)
         list_hashtable_vars(&current_funccal->l_vars.dv_hashtab,
-                                                       (char_u *)"l:", FALSE);
+                                                (char_u *)"l:", FALSE, first);
 }
 
 /*
  * List variables in "arg".
  */
     static char_u *
-list_arg_vars(eap, arg)
+list_arg_vars(eap, arg, first)
     exarg_T     *eap;
     char_u      *arg;
+    int         *first;
 {
     int         error = FALSE;
     int         len;
@@ -2083 +2106 @@
                         {
                             switch (*name)
                             {
-                                case 'g': list_glob_vars(); break;
-                                case 'b': list_buf_vars(); break;
-                                case 'w': list_win_vars(); break;
+                                case 'g': list_glob_vars(first); break;
+                                case 'b': list_buf_vars(first); break;
+                                case 'w': list_win_vars(first); break;
 #ifdef FEAT_WINDOWS
-                                case 't': list_tab_vars(); break;
+                                case 't': list_tab_vars(first); break;
 #endif
-                                case 'v': list_vim_vars(); break;
-                                case 's': list_script_vars(); break;
-                                case 'l': list_func_vars(); break;
+                                case 'v': list_vim_vars(first); break;
+                                case 's': list_script_vars(first); break;
+                                case 'l': list_func_vars(first); break;
                                 default:
                                           EMSG2(_("E738: Can't list variables for %s"), name);
                             }
@@ -2108 +2131 @@
                             *arg = NUL;
                             list_one_var_a((char_u *)"",
                                     arg == arg_subsc ? name : name_start,
-                                    tv.v_type, s == NULL ? (char_u *)"" : s);
+                                    tv.v_type,
+                                    s == NULL ? (char_u *)"" : s,
+                                    first);
                             *arg = c;
                             vim_free(tf);
                         }
@@ -6794 +6819 @@
  * "numbuf" is used for a number.
  * Does not put quotes around strings, as ":echo" displays values.
  * When "copyID" is not NULL replace recursive lists and dicts with "...".
- * May return NULL;
+ * May return NULL.
  */
     static char_u *
 echo_string(tv, tofree, numbuf, copyID)
@@ -6879 +6904 @@
  * If the memory is allocated "tofree" is set to it, otherwise NULL.
  * "numbuf" is used for a number.
  * Puts quotes around strings, so that they can be parsed back by eval().
- * May return NULL;
+ * May return NULL.
  */
     static char_u *
 tv2string(tv, tofree, numbuf, copyID)
@@ -7043 +7068 @@
     {"changenr",        0, 0, f_changenr},
     {"char2nr",         1, 1, f_char2nr},
     {"cindent",         1, 1, f_cindent},
+    {"clearmatches",    0, 0, f_clearmatches},
     {"col",             1, 1, f_col},
 #if defined(FEAT_INS_EXPAND)
     {"complete",        2, 2, f_complete},
@@ -7099 +7125 @@
     {"getftype",        1, 1, f_getftype},
     {"getline",         1, 2, f_getline},
     {"getloclist",      1, 1, f_getqflist},
+    {"getmatches",      0, 0, f_getmatches},
     {"getpos",          1, 1, f_getpos},
     {"getqflist",       0, 0, f_getqflist},
     {"getreg",          0, 2, f_getreg},
@@ -7149 +7176 @@
     {"maparg",          1, 3, f_maparg},
     {"mapcheck",        1, 3, f_mapcheck},
     {"match",           2, 4, f_match},
+    {"matchadd",        2, 4, f_matchadd},
     {"matcharg",        1, 1, f_matcharg},
+    {"matchdelete",     1, 1, f_matchdelete},
     {"matchend",        2, 4, f_matchend},
     {"matchlist",       2, 4, f_matchlist},
     {"matchstr",        2, 4, f_matchstr},
@@ -7190 +7219 @@
     {"setcmdpos",       1, 1, f_setcmdpos},
     {"setline",         2, 2, f_setline},
     {"setloclist",      2, 3, f_setloclist},
+    {"setmatches",      1, 1, f_setmatches},
     {"setpos",          2, 2, f_setpos},
     {"setqflist",       1, 2, f_setqflist},
     {"setreg",          2, 3, f_setreg},
@@ -8240 +8270 @@
 }
 
 /*
+ * "clearmatches()" function
+ */
+/*ARGSUSED*/
+    static void
+f_clearmatches(argvars, rettv)
+    typval_T    *argvars;
+    typval_T    *rettv;
+{
+#ifdef FEAT_SEARCH_EXTRA
+    clear_matches(curwin);
+#endif
+}
+
+/*
  * "col(string)" function
  */
     static void
@@ -10136 +10180 @@
         if (mch_isdir(fname))
             rettv->vval.v_number = 0;
         else
+        {
             rettv->vval.v_number = (varnumber_T)st.st_size;
+
+            /* non-perfect check for overflow */
+            if ((off_t)rettv->vval.v_number != (off_t)st.st_size)
+                rettv->vval.v_number = -2;
+        }
     }
     else
           rettv->vval.v_number = -1;
@@ -10269 +10319 @@
 }
 
 /*
+ * "getmatches()" function
+ */
+/*ARGSUSED*/
+    static void
+f_getmatches(argvars, rettv)
+    typval_T    *argvars;
+    typval_T    *rettv;
+{
+#ifdef FEAT_SEARCH_EXTRA
+    dict_T      *dict;
+    matchitem_T *cur = curwin->w_match_head;
+
+    rettv->vval.v_number = 0;
+
+    if (rettv_list_alloc(rettv) == OK)
+    {
+        while (cur != NULL)
+        {
+            dict = dict_alloc();
+            if (dict == NULL)
+                return;
+            ++dict->dv_refcount;
+            dict_add_nr_str(dict, "group", 0L, syn_id2name(cur->hlg_id));
+            dict_add_nr_str(dict, "pattern", 0L, cur->pattern);
+            dict_add_nr_str(dict, "priority", (long)cur->priority, NULL);
+            dict_add_nr_str(dict, "id", (long)cur->id, NULL);
+            list_append_dict(rettv->vval.v_list, dict);
+            cur = cur->next;
+        }
+    }
+#endif
+}
+
+/*
  * "getpos(string)" function
  */
     static void
@@ -12439 +12523 @@
 }
 
 /*
+ * "matchadd()" function
+ */
+    static void
+f_matchadd(argvars, rettv)
+    typval_T    *argvars;
+    typval_T    *rettv;
+{
+#ifdef FEAT_SEARCH_EXTRA
+    char_u      buf[NUMBUFLEN];
+    char_u      *grp = get_tv_string_buf_chk(&argvars[0], buf); /* group */
+    char_u      *pat = get_tv_string_buf_chk(&argvars[1], buf); /* pattern */
+    int         prio = 10;      /* default priority */
+    int         id = -1;
+    int         error = FALSE;
+
+    rettv->vval.v_number = -1;
+
+    if (grp == NULL || pat == NULL)
+        return;
+    if (argvars[2].v_type != VAR_UNKNOWN)
+    {
+        prio = get_tv_number_chk(&argvars[2], &error);
+        if (argvars[3].v_type != VAR_UNKNOWN)
+            id = get_tv_number_chk(&argvars[3], &error);
+    }
+    if (error == TRUE)
+        return;
+    if (id >= 1 && id <= 3)
+    {
+        EMSGN("E798: ID is reserved for \":match\": %ld", id);
+        return;
+    }
+
+    rettv->vval.v_number = match_add(curwin, grp, pat, prio, id);
+#endif
+}
+
+/*
  * "matcharg()" function
  */
     static void
@@ -12449 +12571 @@
     if (rettv_list_alloc(rettv) == OK)
     {
 #ifdef FEAT_SEARCH_EXTRA
-        int     mi = get_tv_number(&argvars[0]);
+        int         id = get_tv_number(&argvars[0]);
+        matchitem_T *m;
 
-        if (mi >= 1 && mi <= 3)
+        if (id >= 1 && id <= 3)
         {
-            list_append_string(rettv->vval.v_list,
-                                 syn_id2name(curwin->w_match_id[mi - 1]), -1);
-            list_append_string(rettv->vval.v_list,
-                                             curwin->w_match_pat[mi - 1], -1);
+            if ((m = (matchitem_T *)get_match(curwin, id)) != NULL)
+            {
+                list_append_string(rettv->vval.v_list,
+                                                syn_id2name(m->hlg_id), -1);
+                list_append_string(rettv->vval.v_list, m->pattern, -1);
+            }
+            else
+            {
+                list_append_string(rettv->vval.v_list, NUL, -1);
+                list_append_string(rettv->vval.v_list, NUL, -1);
+            }
         }
 #endif
     }
 }
 
 /*
+ * "matchdelete()" function
+ */
+    static void
+f_matchdelete(argvars, rettv)
+    typval_T    *argvars;
+    typval_T    *rettv;
+{
+#ifdef FEAT_SEARCH_EXTRA
+    rettv->vval.v_number = match_delete(curwin,
+                                       (int)get_tv_number(&argvars[0]), TRUE);
+#endif
+}
+
+/*
  * "matchend()" function
  */
     static void
@@ -13680 +13824 @@
             }
             /* Shorten "remain". */
             if (*q != NUL)
-                STRCPY(remain, q - 1);
+                mch_memmove(remain, q - 1, STRLEN(q - 1) + 1);
             else
             {
                 vim_free(remain);
@@ -13919 +14063 @@
     /* If 'n' flag is used: restore cursor position. */
     if (flags & SP_NOMOVE)
         curwin->w_cursor = save_cursor;
+    else
+        curwin->w_set_curswant = TRUE;
 theend:
     p_ws = save_p_ws;
 
@@ -14498 +14644 @@
 }
 
 /*
+ * "setmatches()" function
+ */
+    static void
+f_setmatches(argvars, rettv)
+    typval_T    *argvars;
+    typval_T    *rettv;
+{
+#ifdef FEAT_SEARCH_EXTRA
+    list_T      *l;
+    listitem_T  *li;
+    dict_T      *d;
+
+    rettv->vval.v_number = -1;
+    if (argvars[0].v_type != VAR_LIST)
+    {
+        EMSG(_(e_listreq));
+        return;
+    }
+    if ((l = argvars[0].vval.v_list) != NULL)
+    {
+
+        /* To some extent make sure that we are dealing with a list from
+         * "getmatches()". */
+        li = l->lv_first;
+        while (li != NULL)
+        {
+            if (li->li_tv.v_type != VAR_DICT
+                    || (d = li->li_tv.vval.v_dict) == NULL)
+            {
+                EMSG(_(e_invarg));
+                return;
+            }
+            if (!(dict_find(d, (char_u *)"group", -1) != NULL
+                        && dict_find(d, (char_u *)"pattern", -1) != NULL
+                        && dict_find(d, (char_u *)"priority", -1) != NULL
+                        && dict_find(d, (char_u *)"id", -1) != NULL))
+            {
+                EMSG(_(e_invarg));
+                return;
+            }
+            li = li->li_next;
+        }
+
+        clear_matches(curwin);
+        li = l->lv_first;
+        while (li != NULL)
+        {
+            d = li->li_tv.vval.v_dict;
+            match_add(curwin, get_dict_string(d, (char_u *)"group", FALSE),
+                    get_dict_string(d, (char_u *)"pattern", FALSE),
+                    (int)get_dict_number(d, (char_u *)"priority"),
+                    (int)get_dict_number(d, (char_u *)"id"));
+            li = li->li_next;
+        }
+        rettv->vval.v_number = 0;
+    }
+#endif
+}
+
+/*
  * "setpos()" function
  */
 /*ARGSUSED*/
@@ -14785 +14991 @@
 
     p1 = tv2string(&(*(listitem_T **)s1)->li_tv, &tofree1, numbuf1, 0);
     p2 = tv2string(&(*(listitem_T **)s2)->li_tv, &tofree2, numbuf2, 0);
+    if (p1 == NULL)
+        p1 = (char_u *)"";
+    if (p2 == NULL)
+        p2 = (char_u *)"";
     if (item_compare_ic)
         res = STRICMP(p1, p2);
     else
@@ -15274 +15484 @@
 
     rettv->v_type = VAR_STRING;
     rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf, 0);
-    if (tofree == NULL)
+    /* Make a copy if we have a value but it's not in allocate memory. */
+    if (rettv->vval.v_string != NULL && tofree == NULL)
         rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
 }
 
@@ -16497 +16708 @@
  * Returns NULL when there is an error.
  */
     static pos_T *
-var2fpos(varp, lnum, fnum)
+var2fpos(varp, dollar_lnum, fnum)
     typval_T    *varp;
-    int         lnum;           /* TRUE when $ is last line */
+    int         dollar_lnum;    /* TRUE when $ is last line */
     int         *fnum;          /* set to fnum for '0, 'A, etc. */
 {
     char_u              *name;
@@ -16512 +16723 @@
         list_T          *l;
         int             len;
         int             error = FALSE;
+        listitem_T      *li;
 
         l = varp->vval.v_list;
         if (l == NULL)
@@ -16527 +16739 @@
         if (error)
             return NULL;
         len = (long)STRLEN(ml_get(pos.lnum));
+
+        /* We accept "$" for the column number: last column. */
+        li = list_find(l, 1L);
+        if (li != NULL && li->li_tv.v_type == VAR_STRING
+                && li->li_tv.vval.v_string != NULL
+                && STRCMP(li->li_tv.vval.v_string, "$") == 0)
+            pos.col = len + 1;
+
         /* Accept a position up to the NUL after the line. */
         if (pos.col == 0 || (int)pos.col > len + 1)
             return NULL;        /* invalid column number */
@@ -16559 +16779 @@
     pos.coladd = 0;
 #endif
 
-    if (name[0] == 'w' && lnum)
+    if (name[0] == 'w' && dollar_lnum)
     {
         pos.col = 0;
         if (name[1] == '0')             /* "w0": first visible line */
@@ -16577 +16797 @@
     }
     else if (name[0] == '$')            /* last column or line */
     {
-        if (lnum)
+        if (dollar_lnum)
         {
             pos.lnum = curbuf->b_ml.ml_line_count;
             pos.col = 0;
@@ -17798 +18018 @@
  * List the value of one internal variable.
  */
     static void
-list_one_var(v, prefix)
+list_one_var(v, prefix, first)
     dictitem_T  *v;
     char_u      *prefix;
+    int         *first;
 {
     char_u      *tofree;
     char_u      *s;
@@ -17808 +18029 @@
 
     s = echo_string(&v->di_tv, &tofree, numbuf, ++current_copyID);
     list_one_var_a(prefix, v->di_key, v->di_tv.v_type,
-                                                s == NULL ? (char_u *)"" : s);
+                                         s == NULL ? (char_u *)"" : s, first);
     vim_free(tofree);
 }
 
     static void
-list_one_var_a(prefix, name, type, string)
+list_one_var_a(prefix, name, type, string, first)
     char_u      *prefix;
     char_u      *name;
     int         type;
     char_u      *string;
+    int         *first;  /* when TRUE clear rest of screen and set to FALSE */
 {
-    msg_attr(prefix, 0);    /* don't use msg(), it overwrites "v:statusmsg" */
+    /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
+    msg_start();
+    msg_puts(prefix);
     if (name != NULL)   /* "a:" vars don't have a name stored */
         msg_puts(name);
     msg_putchar(' ');
@@ -17847 +18071 @@
 
     if (type == VAR_FUNC)
         msg_puts((char_u *)"()");
+    if (*first)
+    {
+        msg_clr_eos();
+        *first = FALSE;
+    }
 }
 
 /*
@@ -19969 +20198 @@
                 char_u  buf[MSG_BUF_LEN];
                 char_u  numbuf2[NUMBUFLEN];
                 char_u  *tofree;
+                char_u  *s;
 
                 msg_puts((char_u *)"(");
                 for (i = 0; i < argcount; ++i)
@@ -19979 +20209 @@
                         msg_outnum((long)argvars[i].vval.v_number);
                     else
                     {
-                        trunc_string(tv2string(&argvars[i], &tofree,
-                                              numbuf2, 0), buf, MSG_BUF_CLEN);
-                        msg_puts(buf);
-                        vim_free(tofree);
+                        s = tv2string(&argvars[i], &tofree, numbuf2, 0);
+                        if (s != NULL)
+                        {
+                            trunc_string(s, buf, MSG_BUF_CLEN);
+                            msg_puts(buf);
+                            vim_free(tofree);
+                        }
                     }
                 }
                 msg_puts((char_u *)")");
@@ -20060 +20293 @@
             char_u      buf[MSG_BUF_LEN];
             char_u      numbuf2[NUMBUFLEN];
             char_u      *tofree;
+            char_u      *s;
 
             /* The value may be very long.  Skip the middle part, so that we
              * have some idea how it starts and ends. smsg() would always
              * truncate it at the end. */
-            trunc_string(tv2string(fc.rettv, &tofree, numbuf2, 0),
-                                                           buf, MSG_BUF_CLEN);
-            smsg((char_u *)_("%s returning %s"), sourcing_name, buf);
-            vim_free(tofree);
+            s = tv2string(fc.rettv, &tofree, numbuf2, 0);
+            if (s != NULL)
+            {
+                trunc_string(s, buf, MSG_BUF_CLEN);
+                smsg((char_u *)_("%s returning %s"), sourcing_name, buf);
+                vim_free(tofree);
+            }
         }
         msg_puts((char_u *)"\n");   /* don't overwrite this either */
 

src/ex_cmds.c

@@ -408 +408 @@
                 goto sortend;
             }
             *s = NUL;
-            regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC);
+            /* Use last search pattern if sort pattern is empty. */
+            if (s == p + 1 && last_search_pat() != NULL)
+                regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC);
+            else
+                regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC);
             if (regmatch.regprog == NULL)
                 goto sortend;
             p = s;              /* continue after the regexp */
@@ -2912 +2916 @@
 }
 
 /*
- * Check if a buffer is read-only.  Ask for overruling in a dialog.
- * Return TRUE and give an error message when the buffer is readonly.
+ * Check if a buffer is read-only (either 'readonly' option is set or file is
+ * read-only). Ask for overruling in a dialog. Return TRUE and give an error
+ * message when the buffer is readonly.
  */
     static int
 check_readonly(forceit, buf)
     int         *forceit;
     buf_T       *buf;
 {
-    if (!*forceit && buf->b_p_ro)
+    struct stat st;
+
+    /* Handle a file being readonly when the 'readonly' option is set or when
+     * the file exists and permissions are read-only.
+     * We will send 0777 to check_file_readonly(), as the "perm" variable is
+     * important for device checks but not here. */
+    if (!*forceit && (buf->b_p_ro
+                || (mch_stat((char *)buf->b_ffname, &st) >= 0
+                    && check_file_readonly(buf->b_ffname, 0777))))
     {
 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
         if ((p_confirm || cmdmod.confirm) && buf->b_fname != NULL)
         {
             char_u      buff[IOSIZE];
 
-            dialog_msg(buff, _("'readonly' option is set for \"%s\".\nDo you wish to write anyway?"),
+            if (buf->b_p_ro)
+                dialog_msg(buff, _("'readonly' option is set for \"%s\".\nDo you wish to write anyway?"),
+                    buf->b_fname);
+            else
+                dialog_msg(buff, _("File permissions of \"%s\" are read-only.\nIt may still be possible to write it.\nDo you wish to try?"),
                     buf->b_fname);
 
             if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES)
@@ -2941 +2958 @@
         }
         else
 #endif
+        if (buf->b_p_ro)
             EMSG(_(e_readonly));
+        else
+            EMSG2(_("E505: \"%s\" is read-only (add ! to override)"),
+                    buf->b_fname);
         return TRUE;
     }
+
     return FALSE;
 }
 
@@ -2952 +2974 @@
  * 'fnum' is the number of the file, if zero use ffname/sfname.
  *
  * Return 1 for "normal" error, 2 for "not written" error, 0 for success
- * -1 for succesfully opening another file.
+ * -1 for successfully opening another file.
  * 'lnum' is the line number for the cursor in the new file (if non-zero).
  */
     int
@@ -3367 +3389 @@
                  * was in this window (or another window).  If not used
                  * before, reset the local window options to the global
                  * values.  Also restores old folding stuff. */
-                get_winopts(buf);
+                get_winopts(curbuf);
 #ifdef FEAT_SPELL
                 did_get_winopts = TRUE;
 #endif
@@ -3562 +3584 @@
         curwin_init();
 
 #ifdef FEAT_FOLDING
-        /* It's like all lines in the buffer changed.  Need to update
-         * automatic folding. */
+        /* It's possible that all lines in the buffer changed.  Need to update
+         * automatic folding for all windows where it's used. */
+# ifdef FEAT_WINDOWS
+        {
+            win_T           *win;
+            tabpage_T       *tp;
+
+            FOR_ALL_TAB_WINDOWS(tp, win)
+                if (win->w_buffer == curbuf)
+                    foldUpdateAll(win);
+        }
+# else
         foldUpdateAll(curwin);
+# endif
 #endif
 
         /* Change directories when the 'acd' option is set. */
@@ -3649 +3682 @@
 #ifdef FEAT_SPELL
     /* If the window options were changed may need to set the spell language.
      * Can only do this after the buffer has been properly setup. */
-    if (did_get_winopts && curwin->w_p_spell && *buf->b_p_spl != NUL)
-        did_set_spelllang(buf);
+    if (did_get_winopts && curwin->w_p_spell && *curbuf->b_p_spl != NUL)
+        did_set_spelllang(curbuf);
 #endif
 
     if (command == NULL)
@@ -3754 +3787 @@
             workshop_file_opened((char *)curbuf->b_ffname, curbuf->b_p_ro);
 # endif
 # ifdef FEAT_NETBEANS_INTG
-        if (usingNetbeans & ((flags & ECMD_SET_HELP) != ECMD_SET_HELP))
+        if (usingNetbeans && ((flags & ECMD_SET_HELP) != ECMD_SET_HELP))
             netbeans_file_opened(curbuf);
 # endif
     }
@@ -4294 +4327 @@
         do_error = TRUE;
         do_print = FALSE;
         do_count = FALSE;
+        do_number = FALSE;
         do_ic = 0;
     }
     while (*cmd)
@@ -6351 +6385 @@
         for (i = 0; i < ga.ga_len; ++i)
         {
             s = ((char_u **)ga.ga_data)[i];
-            if (STRNCMP(s, "help-tags", 9) == 0)
+            if (STRNCMP(s, "help-tags\t", 10) == 0)
                 /* help-tags entry was added in formatted form */
-                fprintf(fd_tags, (char *)s);
+                fputs((char *)s, fd_tags);
             else
             {
                 fprintf(fd_tags, "%s\t/*", s);

src/ex_docmd.c

@@ -133 +133 @@
 static void     get_flags __ARGS((exarg_T *eap));
 #if !defined(FEAT_PERL) || !defined(FEAT_PYTHON) || !defined(FEAT_TCL) \
         || !defined(FEAT_RUBY) || !defined(FEAT_MZSCHEME)
+# define HAVE_EX_SCRIPT_NI
 static void     ex_script_ni __ARGS((exarg_T *eap));
 #endif
 static char_u   *invalid_range __ARGS((exarg_T *eap));
@@ -2118 +2119 @@
 #ifdef FEAT_USR_CMDS
             !USER_CMDIDX(ea.cmdidx) &&
 #endif
-            cmdnames[ea.cmdidx].cmd_func == ex_ni);
+            (cmdnames[ea.cmdidx].cmd_func == ex_ni
+#ifdef HAVE_EX_SCRIPT_NI
+             || cmdnames[ea.cmdidx].cmd_func == ex_script_ni
+#endif
+             ));
 
 #ifndef FEAT_EVAL
     /*
@@ -3276 +3281 @@
 
     if (ea.argt & XFILE)
     {
-        int in_quote = FALSE;
-        char_u *bow = NULL;     /* Beginning of word */
+        int     c;
+        int     in_quote = FALSE;
+        char_u  *bow = NULL;    /* Beginning of word */
 
         /*
          * Allow spaces within back-quotes to count as part of the argument
          * being expanded.
          */
         xp->xp_pattern = skipwhite(arg);
-        for (p = xp->xp_pattern; *p; )
+        p = xp->xp_pattern;
+        while (*p != NUL)
         {
-            if (*p == '\\' && p[1] != NUL)
+#ifdef FEAT_MBYTE
+            if (has_mbyte)
+                c = mb_ptr2char(p);
+            else
+#endif
+                c = *p;
+            if (c == '\\' && p[1] != NUL)
                 ++p;
+            else if (c == '`')
+            {
+                if (!in_quote)
+                {
+                    xp->xp_pattern = p;
+                    bow = p + 1;
+                }
+                in_quote = !in_quote;
+            }
 #ifdef SPACE_IN_FILENAME
-            else if (vim_iswhite(*p) && (!(ea.argt & NOSPC) || usefilter))
+            else if (!vim_isfilec_or_wc(c)
+                                         && (!(ea.argt & NOSPC) || usefilter))
 #else
-            else if (vim_iswhite(*p))
+            else if (!vim_isfilec_or_wc(c))
 #endif
             {
-                p = skipwhite(p);
+                while (*p != NUL)
+                {
+#ifdef FEAT_MBYTE
+                    if (has_mbyte)
+                        c = mb_ptr2char(p);
+                    else
+#endif
+                        c = *p;
+                    if (c == '`' || vim_isfilec_or_wc(c))
+                        break;
+#ifdef FEAT_MBYTE
+                    if (has_mbyte)
+                        len = (*mb_ptr2len)(p);
+                    else
+#endif
+                        len = 1;
+                    mb_ptr_adv(p);
+                }
                 if (in_quote)
                     bow = p;
                 else
                     xp->xp_pattern = p;
-                --p;
-            }
-            else if (*p == '`')
-            {
-                if (!in_quote)
-                {
-                    xp->xp_pattern = p;
-                    bow = p + 1;
-                }
-                in_quote = !in_quote;
+                p -= len;
             }
             mb_ptr_adv(p);
         }
@@ -3401 +3432 @@
         case CMD_windo:
             return arg;
 
-#ifdef FEAT_SEARCH_EXTRA
+#ifdef FEAT_CMDL_COMPL
+# ifdef FEAT_SEARCH_EXTRA
         case CMD_match:
             if (*arg == NUL || !ends_excmd(*arg))
             {
-                /* Dummy call to clear variables. */
-                set_context_in_highlight_cmd(xp, (char_u *)"link n");
-                xp->xp_context = EXPAND_HIGHLIGHT;
-                xp->xp_pattern = arg;
+                /* also complete "None" */
+                set_context_in_echohl_cmd(xp, arg);
                 arg = skipwhite(skiptowhite(arg));
                 if (*arg != NUL)
                 {
@@ -3417 +3447 @@
                 }
             }
             return find_nextcmd(arg);
-#endif
+# endif
 
-#ifdef FEAT_CMDL_COMPL
 /*
  * All completion for the +cmdline_compl feature goes here.
  */
@@ -3617 +3646 @@
             break;
 
         case CMD_echohl:
-            xp->xp_context = EXPAND_HIGHLIGHT;
-            xp->xp_pattern = arg;
+            set_context_in_echohl_cmd(xp, arg);
             break;
 #endif
         case CMD_highlight:
@@ -3997 +4025 @@
         eap->errmsg = (char_u *)N_("E319: Sorry, the command is not available in this version");
 }
 
-#if !defined(FEAT_PERL) || !defined(FEAT_PYTHON) || !defined(FEAT_TCL) \
-        || !defined(FEAT_RUBY) || !defined(FEAT_MZSCHEME)
+#ifdef HAVE_EX_SCRIPT_NI
 /*
  * Function called for script command which is Not Implemented.  NI!
  * Skips over ":perl <<EOF" constructs.
@@ -4492 +4519 @@
             if (eap->argt & (USECTRLV | XFILE))
                 ++p;            /* skip CTRL-V and next char */
             else
-                STRCPY(p, p + 1);       /* remove CTRL-V and skip next char */
+                                /* remove CTRL-V and skip next char */
+                mch_memmove(p, p + 1, STRLEN(p));
             if (*p == NUL)              /* stop at NUL after CTRL-V */
                 break;
         }
@@ -10816 +10844 @@
     exarg_T     *eap;
 {
     char_u      *p;
+    char_u      *g = NULL;
     char_u      *end;
     int         c;
-    int         mi;
+    int         id;
 
     if (eap->line2 <= 3)
-        mi = eap->line2 - 1;
+        id = eap->line2;
     else
     {
         EMSG(e_invcmd);
@@ -10830 +10859 @@
 
     /* First clear any old pattern. */
     if (!eap->skip)
-    {
-        vim_free(curwin->w_match[mi].regprog);
-        curwin->w_match[mi].regprog = NULL;
-        vim_free(curwin->w_match_pat[mi]);
-        curwin->w_match_pat[mi] = NULL;
-        redraw_later(SOME_VALID);       /* always need a redraw */
-    }
+        match_delete(curwin, id, FALSE);
 
     if (ends_excmd(*eap->arg))
         end = eap->arg;
@@ -10847 +10870 @@
     {
         p = skiptowhite(eap->arg);
         if (!eap->skip)
-        {
-            curwin->w_match_id[mi] = syn_namen2id(eap->arg,
-                                                         (int)(p - eap->arg));
-            if (curwin->w_match_id[mi] == 0)
-            {
-                EMSG2(_(e_nogroup), eap->arg);
-                return;
-            }
-        }
+            g = vim_strnsave(eap->arg, (int)(p - eap->arg));
         p = skipwhite(p);
         if (*p == NUL)
         {
@@ -10879 +10894 @@
 
             c = *end;
             *end = NUL;
-            curwin->w_match[mi].regprog = vim_regcomp(p + 1, RE_MAGIC);
-            if (curwin->w_match[mi].regprog == NULL)
-            {
-                EMSG2(_(e_invarg2), p);
-                *end = c;
-                return;
-            }
-            curwin->w_match_pat[mi] = vim_strsave(p + 1);
+            match_add(curwin, g, p + 1, 10, id);
+            vim_free(g);
             *end = c;
         }
     }

src/ex_eval.c

@@ -1551 +1551 @@
                 }
                 save_cpo  = p_cpo;
                 p_cpo = (char_u *)"";
-                regmatch.regprog = vim_regcomp(pat, TRUE);
+                regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
                 regmatch.rm_ic = FALSE;
                 if (end != NULL)
                     *end = save_char;

src/ex_getln.c

@@ -268 +268 @@
     {
         xpc.xp_context = ccline.xp_context;
         xpc.xp_pattern = ccline.cmdbuff;
+# if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
         xpc.xp_arg = ccline.xp_arg;
+# endif
     }
 #endif
 
@@ -484 +486 @@
         if (xpc.xp_context == EXPAND_MENUNAMES && p_wmnu)
         {
             /* Hitting <Down> after "emenu Name.": complete submenu */
-            if (ccline.cmdbuff[ccline.cmdpos - 1] == '.' && c == K_DOWN)
+            if (c == K_DOWN && ccline.cmdpos > 0
+                                  && ccline.cmdbuff[ccline.cmdpos - 1] == '.')
                 c = p_wc;
             else if (c == K_UP)
             {
@@ -533 +536 @@
             upseg[3] = PATHSEP;
             upseg[4] = NUL;
 
-            if (ccline.cmdbuff[ccline.cmdpos - 1] == PATHSEP
-                    && c == K_DOWN
-                    && (ccline.cmdbuff[ccline.cmdpos - 2] != '.'
+            if (c == K_DOWN
+                    && ccline.cmdpos > 0
+                    && ccline.cmdbuff[ccline.cmdpos - 1] == PATHSEP
+                    && (ccline.cmdpos < 3
+                        || ccline.cmdbuff[ccline.cmdpos - 2] != '.'
                         || ccline.cmdbuff[ccline.cmdpos - 3] != '.'))
             {
                 /* go down a directory */
@@ -730 +735 @@
             /* In Ex mode a backslash escapes a newline. */
             if (exmode_active
                     && c != ESC
-                    && ccline.cmdpos > 0
                     && ccline.cmdpos == ccline.cmdlen
+                    && ccline.cmdpos > 0
                     && ccline.cmdbuff[ccline.cmdpos - 1] == '\\')
             {
                 if (c == K_KENTER)
@@ -2090 +2095 @@
     garray_T    line_ga;
     char_u      *pend;
     int         startcol = 0;
-    int         c1;
+    int         c1 = 0;
     int         escaped = FALSE;        /* CTRL-V typed */
     int         vcol = 0;
     char_u      *p;
-    int         prev_char = 0;
+    int         prev_char;
 
     /* Switch cursor on now.  This avoids that it happens after the "\n", which
      * confuses the system function that computes tabstops. */
@@ -2147 +2152 @@
 
         /* Get one character at a time.  Don't use inchar(), it can't handle
          * special characters. */
+        prev_char = c1;
         c1 = vgetc();
 
         /*
@@ -2204 +2210 @@
 redraw:
                 /* redraw the line */
                 msg_col = startcol;
-                windgoto(msg_row, msg_col);
                 vcol = 0;
                 for (p = (char_u *)line_ga.ga_data;
                           p < (char_u *)line_ga.ga_data + line_ga.ga_len; ++p)
@@ -2223 +2228 @@
                     }
                 }
                 msg_clr_eos();
+                windgoto(msg_row, msg_col);
                 continue;
             }
 
@@ -2268 +2274 @@
         if (IS_SPECIAL(c1))
             c1 = '?';
         ((char_u *)line_ga.ga_data)[line_ga.ga_len] = c1;
-        prev_char = c1;
         if (c1 == '\n')
             msg_putchar('\n');
         else if (c1 == TAB)
@@ -4148 +4153 @@
 
 #ifdef FEAT_EVAL
     if (ccline.cmdfirstc == '=')
+    {
+# ifdef FEAT_CMDL_COMPL
         /* pass CMD_SIZE because there is no real command */
         set_context_for_expression(xp, str, CMD_SIZE);
+# endif
+    }
     else if (ccline.input_fn)
     {
         xp->xp_context = ccline.xp_context;
         xp->xp_pattern = ccline.cmdbuff;
+# if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
         xp->xp_arg = ccline.xp_arg;
+# endif
     }
     else
 #endif
@@ -4295 +4306 @@
                             && pat[i + 1] == '\\'
                             && pat[i + 2] == '\\'
                             && pat[i + 3] == ' ')
-                        STRCPY(pat + i, pat + i + 3);
+                        mch_memmove(pat + i, pat + i + 3,
+                                                     STRLEN(pat + i + 3) + 1);
                     if (xp->xp_backslash == XP_BS_ONE
                             && pat[i + 1] == ' ')
-                        STRCPY(pat + i, pat + i + 1);
+                        mch_memmove(pat + i, pat + i + 1, STRLEN(pat + i));
                 }
         }
 
@@ -4502 +4514 @@
     if (xp->xp_context != EXPAND_MENUNAMES && xp->xp_context != EXPAND_MENUS)
         sort_strings(*file, *num_file);
 
+#ifdef FEAT_CMDL_COMPL
+    /* Reset the variables used for special highlight names expansion, so that
+     * they don't show up when getting normal highlight names by ID. */
+    reset_expand_highlight();
+#endif
+
     return OK;
 }
 
@@ -4535 +4553 @@
     pat = vim_strsave(filepat);
     for (i = 0; pat[i]; ++i)
         if (pat[i] == '\\' && pat[i + 1] == ' ')
-            STRCPY(pat + i, pat + i + 1);
+            mch_memmove(pat + i, pat + i + 1, STRLEN(pat + i));
 
     flags |= EW_FILE | EW_EXEC;
 

src/feature.h

@@ -673 +673 @@
 # define ESC_CHG_TO_ENG_MODE            /* if defined, when ESC pressed,
                                          * turn to english mode
                                          */
-# if !defined(FEAT_XFONTSET) && defined(HAVE_X11)
+# if !defined(FEAT_XFONTSET) && defined(HAVE_X11) && !defined(HAVE_GTK2)
 #  define FEAT_XFONTSET                 /* Hangul input requires xfontset */
 # endif
 # if defined(FEAT_XIM) && !defined(LINT)

src/fileio.c

@@ -44 +44 @@
 /* Is there any system that doesn't have access()? */
 #define USE_MCH_ACCESS
 
+#if defined(sun) && defined(S_ISCHR)
+# define OPEN_CHR_FILES
+static int is_dev_fd_file(char_u *fname);
+#endif
 #ifdef FEAT_MBYTE
 static char_u *next_fenc __ARGS((char_u **pp));
 # ifdef FEAT_EVAL
@@ -406 +410 @@
 # ifdef S_ISSOCK
                       && !S_ISSOCK(perm)            /* ... or socket */
 # endif
+# ifdef OPEN_CHR_FILES
+                      && !(S_ISCHR(perm) && is_dev_fd_file(fname))
+                        /* ... or a character special file named /dev/fd/<n> */
+# endif
                                                 )
         {
             if (S_ISDIR(perm))
@@ -424 +432 @@
          */
         if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)
         {
-            filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option"), 0);
+            filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option)"), 0);
             msg_end();
             msg_scroll = msg_save;
             return FAIL;
@@ -646 +654 @@
         curbuf->b_start_eol = TRUE;
 #ifdef FEAT_MBYTE
         curbuf->b_p_bomb = FALSE;
+        curbuf->b_start_bomb = FALSE;
 #endif
     }
 
@@ -904 +913 @@
         file_rewind = FALSE;
 #ifdef FEAT_MBYTE
         if (set_options)
+        {
             curbuf->b_p_bomb = FALSE;
+            curbuf->b_start_bomb = FALSE;
+        }
         conv_error = 0;
 #endif
     }
@@ -1353 +1365 @@
                     size -= blen;
                     mch_memmove(ptr, ptr + blen, (size_t)size);
                     if (set_options)
+                    {
                         curbuf->b_p_bomb = TRUE;
+                        curbuf->b_start_bomb = TRUE;
+                    }
                 }
 
                 if (fio_flags == FIO_UCSBOM)
@@ -2265 +2280 @@
             }
 #  endif
 # endif
+# ifdef OPEN_CHR_FILES
+            if (S_ISCHR(perm))                      /* or character special */
+            {
+                STRCAT(IObuff, _("[character special]"));
+                c = TRUE;
+            }
+# endif
 #endif
             if (curbuf->b_p_ro)
             {
@@ -2464 +2486 @@
     return OK;
 }
 
+#ifdef OPEN_CHR_FILES
+/*
+ * Returns TRUE if the file name argument is of the form "/dev/fd/\d\+",
+ * which is the name of files used for process substitution output by
+ * some shells on some operating systems, e.g., bash on SunOS.
+ * Do not accept "/dev/fd/[012]", opening these may hang Vim.
+ */
+    static int
+is_dev_fd_file(fname)
+    char_u      *fname;
+{
+    return (STRNCMP(fname, "/dev/fd/", 8) == 0
+            && VIM_ISDIGIT(fname[8])
+            && *skipdigits(fname + 9) == NUL
+            && (fname[9] != NUL
+                || (fname[8] != '0' && fname[8] != '1' && fname[8] != '2')));
+}
+#endif
+
 #ifdef FEAT_MBYTE
 
 /*
@@ -2734 +2775 @@
 #endif
 
 /*
+ * Return TRUE if a file appears to be read-only from the file permissions.
+ */
+    int
+check_file_readonly(fname, perm)
+    char_u      *fname;         /* full path to file */
+    int         perm;           /* known permissions on file */
+{
+#ifndef USE_MCH_ACCESS
+    int     fd = 0;
+#endif
+
+    return (
+#ifdef USE_MCH_ACCESS
+# ifdef UNIX
+        (perm & 0222) == 0 ||
+# endif
+        mch_access((char *)fname, W_OK)
+#else
+        (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0
+                                        ? TRUE : (close(fd), FALSE)
+#endif
+        );
+}
+
+
+/*
  * buf_write() - write to file "fname" lines "start" through "end"
  *
  * We do our own buffering here because fwrite() is so slow.
@@ -3219 +3286 @@
          * Check if the file is really writable (when renaming the file to
          * make a backup we won't discover it later).
          */
-        file_readonly = (
-# ifdef USE_MCH_ACCESS
-#  ifdef UNIX
-                    (perm & 0222) == 0 ||
-#  endif
-                    mch_access((char *)fname, W_OK)
-# else
-                    (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0
-                                                   ? TRUE : (close(fd), FALSE)
-# endif
-                    );
+        file_readonly = check_file_readonly(fname, (int)perm);
+
         if (!forceit && file_readonly)
         {
             if (vim_strchr(p_cpo, CPO_FWRITE) != NULL)

src/globals.h

@@ -801 +801 @@
 EXTERN int (*mb_char2bytes) __ARGS((int c, char_u *buf)) INIT(= latin_char2bytes);
 EXTERN int (*mb_ptr2cells) __ARGS((char_u *p)) INIT(= latin_ptr2cells);
 EXTERN int (*mb_char2cells) __ARGS((int c)) INIT(= latin_char2cells);
-EXTERN int (*mb_off2cells) __ARGS((unsigned off)) INIT(= latin_off2cells);
+EXTERN int (*mb_off2cells) __ARGS((unsigned off, unsigned max_off)) INIT(= latin_off2cells);
 EXTERN int (*mb_ptr2char) __ARGS((char_u *p)) INIT(= latin_ptr2char);
 EXTERN int (*mb_head_off) __ARGS((char_u *base, char_u *p)) INIT(= latin_head_off);
 

src/gui.c

@@ -1080 +1080 @@
                 cur_width = gui.char_width;
             }
 #ifdef FEAT_MBYTE
-            if (has_mbyte && (*mb_off2cells)(LineOffset[gui.row] + gui.col) > 1)
+            if (has_mbyte && (*mb_off2cells)(LineOffset[gui.row] + gui.col,
+                                    LineOffset[gui.row] + screen_Columns) > 1)
             {
                 /* Double wide character. */
                 if (shape_table[idx].shape != SHAPE_VER)
@@ -1159 +1160 @@
 #endif
 
 # if defined(FEAT_GUI_TABLINE) && (defined(FEAT_GUI_MSWIN) \
-        || defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_MAC))
+        || defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_MAC))
     if (gui_has_tabline())
         text_area_y += gui.tabline_height;
 #endif
@@ -5117 +5118 @@
                 p = vim_strsave_escaped(fnames[i], (char_u *)"\\ \t\"|");
 # endif
                 if (p != NULL)
-                    add_to_input_buf(p, (int)STRLEN(p));
+                    add_to_input_buf_csi(p, (int)STRLEN(p));
                 vim_free(p);
                 vim_free(fnames[i]);
             }

src/gui_gtk.c

@@ -53 +53 @@
 # ifdef bindtextdomain
 #  undef bindtextdomain
 # endif
-# ifdef bindtextdomain_codeset
-#  undef bindtextdomain_codeset
+# ifdef bind_textdomain_codeset
+#  undef bind_textdomain_codeset
 # endif
 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
 #  define ENABLE_NLS    /* so the texts in the dialog boxes are translated */
@@ -1630 +1630 @@
  */
 /*ARGSUSED*/
     static int
-dlg_key_press_event(GtkWidget * widget, GdkEventKey * event, CancelData *data)
+dlg_key_press_event(GtkWidget *widget, GdkEventKey *event, CancelData *data)
 {
-    /* Ignore hitting Enter when there is no default button. */
-    if (data->ignore_enter && event->keyval == GDK_Return)
+    /* Ignore hitting Enter (or Space) when there is no default button. */
+    if (data->ignore_enter && (event->keyval == GDK_Return
+                                                     || event->keyval == ' '))
         return TRUE;
+    else    /* A different key was pressed, return to normal behavior */
+        data->ignore_enter = FALSE;
 
     if (event->keyval != GDK_Escape && event->keyval != GDK_Return)
         return FALSE;
@@ -2224 +2227 @@
 {
     DialogInfo *di = (DialogInfo *)data;
 
+    /* Ignore hitting Enter (or Space) when there is no default button. */
+    if (di->ignore_enter && (event->keyval == GDK_Return
+                                                     || event->keyval == ' '))
+        return TRUE;
+    else    /* A different key was pressed, return to normal behavior */
+        di->ignore_enter = FALSE;
+
     /* Close the dialog when hitting "Esc". */
     if (event->keyval == GDK_Escape)
     {

src/gui_gtk_x11.c

@@ -36 +36 @@
 # ifdef bindtextdomain
 #  undef bindtextdomain
 # endif
-# ifdef bindtextdomain_codeset
-#  undef bindtextdomain_codeset
+# ifdef bind_textdomain_codeset
+#  undef bind_textdomain_codeset
 # endif
 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
 #  define ENABLE_NLS    /* so the texts in the dialog boxes are translated */
@@ -2188 +2188 @@
     escaped_filename = vim_strsave_escaped(filename, escape_chars);
     if (escaped_filename == NULL)
         return FALSE;
-    mksession_cmdline = g_strconcat("mksession ", (char *)escaped_filename, NULL);
+    mksession_cmdline = g_strconcat("mksession ", (char *)escaped_filename,
+                                                                        NULL);
     vim_free(escaped_filename);
+
     /*
      * Use a reasonable hardcoded set of 'sessionoptions' flags to avoid
      * unpredictable effects when the session is saved automatically.  Also,
@@ -2199 +2201 @@
      */
     save_ssop_flags = ssop_flags;
     ssop_flags = (SSOP_BLANK|SSOP_CURDIR|SSOP_FOLDS|SSOP_GLOBALS
-                  |SSOP_HELP|SSOP_OPTIONS|SSOP_WINSIZE);
+                  |SSOP_HELP|SSOP_OPTIONS|SSOP_WINSIZE|SSOP_TABPAGES);
 
     do_cmdline_cmd((char_u *)"let Save_VV_this_session = v:this_session");
     failed = (do_cmdline_cmd((char_u *)mksession_cmdline) == FAIL);

src/if_cscope.c

@@ -73 +73 @@
 
 
 static csinfo_T     csinfo[CSCOPE_MAX_CONNECTIONS];
+static int          eap_arg_len;    /* length of eap->arg, set in
+                                       cs_lookup_cmd() */
 static cscmd_T      cs_cmds[] =
 {
     { "add",    cs_add,
@@ -260 +262 @@
 
     if ((p = cs_manage_matches(NULL, NULL, -1, Get)) == NULL)
         return TRUE;
-
-    if ((int)strlen(p) > size)
-    {
-        strncpy((char *)buf, p, size - 1);
-        buf[size] = '\0';
-    }
-    else
-        (void)strcpy((char *)buf, p);
+    vim_strncpy(buf, (char_u *)p, size - 1);
 
     return FALSE;
 } /* cs_fgets */
@@ -386 +381 @@
  * PRIVATE: cs_add
  *
  * add cscope database or a directory name (to look for cscope.out)
- * the the cscope connection list
+ * to the cscope connection list
  *
  * MAXPATHL 256
  */
@@ -966 +961 @@
     }
 
     pat = opt + strlen(opt) + 1;
-    if (pat == NULL || (pat != NULL && pat[0] == '\0'))
+    if (pat >= (char *)eap->arg + eap_arg_len)
     {
         cs_usage_msg(Find);
         return FALSE;
@@ -1317 +1312 @@
 #else
             /* compare pathnames first */
             && ((fullpathcmp(csinfo[j].fname, fname, FALSE) & FPC_SAME)
-                /* if not Windows 9x, test index file atributes too */
+                /* if not Windows 9x, test index file attributes too */
                 || (!mch_windows95()
                     && csinfo[j].nVolume == bhfi.dwVolumeSerialNumber
                     && csinfo[j].nIndexHigh == bhfi.nFileIndexHigh
@@ -1401 +1396 @@
     if (eap->arg == NULL)
         return NULL;
 
+    /* Store length of eap->arg before it gets modified by strtok(). */
+    eap_arg_len = STRLEN(eap->arg);
+
     if ((stok = strtok((char *)(eap->arg), (const char *)" ")) == NULL)
         return NULL;
 
@@ -2195 +2193 @@
             cs_add_common(dblist[i], pplist[i], fllist[i]);
             if (p_csverbose)
             {
-                /* dont' use smsg_attr because want to display
+                /* don't use smsg_attr() because we want to display the
                  * connection number in the same line as
                  * "Added cscope database..."
                  */

src/if_mzsch.c

@@ -308 +308 @@
 static Scheme_Config *(*dll_scheme_current_config)(void);
 static Scheme_Object *(*dll_scheme_char_string_to_byte_string)
     (Scheme_Object *s);
+static Scheme_Object *(*dll_scheme_char_string_to_path)
+    (Scheme_Object *s);
 # endif
 
 /* arrays are imported directly */
@@ -398 +400 @@
 #  define scheme_current_config dll_scheme_current_config
 #  define scheme_char_string_to_byte_string \
     dll_scheme_char_string_to_byte_string
+#  define scheme_char_string_to_path \
+    dll_scheme_char_string_to_path
 # endif
 
 typedef struct
@@ -498 +502 @@
     {"scheme_current_config", (void **)&dll_scheme_current_config},
     {"scheme_char_string_to_byte_string",
         (void **)&dll_scheme_char_string_to_byte_string},
+    {"scheme_char_string_to_path",
+        (void **)&dll_scheme_char_string_to_path},
 # endif
     {NULL, NULL}};
 
@@ -773 +779 @@
 #ifdef MZSCHEME_COLLECTS
     /* setup 'current-library-collection-paths' parameter */
     scheme_set_param(scheme_config, MZCONFIG_COLLECTION_PATHS,
-            scheme_make_pair(scheme_make_string(MZSCHEME_COLLECTS),
+            scheme_make_pair(
+# if MZSCHEME_VERSION_MAJOR >= 299
+                scheme_char_string_to_path(
+                    scheme_byte_string_to_char_string(
+                        scheme_make_byte_string(MZSCHEME_COLLECTS))),
+# else
+                scheme_make_string(MZSCHEME_COLLECTS),
+# endif
                 scheme_null));
 #endif
 #ifdef HAVE_SANDBOX

src/macros.h

@@ -54 +54 @@
 
 /*
  * toupper() and tolower() that use the current locale.
- * On some systems toupper()/tolower() only work on lower/uppercase characters
+ * On some systems toupper()/tolower() only work on lower/uppercase
+ * characters, first use islower() or isupper() then.
  * Careful: Only call TOUPPER_LOC() and TOLOWER_LOC() with a character in the
  * range 0 - 255.  toupper()/tolower() on some systems can't handle others.
- * Note: for UTF-8 use utf_toupper() and utf_tolower().
+ * Note: It is often better to use MB_TOLOWER() and MB_TOUPPER(), because many
+ * toupper() and tolower() implementations only work for ASCII.
  */
 #ifdef MSWIN
 #  define TOUPPER_LOC(c)        toupper_tab[(c) & 255]

src/main.c

@@ -954 +954 @@
     int         cmdwin;     /* TRUE when working in the command-line window */
     int         noexmode;   /* TRUE when return on entering Ex mode */
 {
-    oparg_T     oa;     /* operator arguments */
+    oparg_T     oa;                             /* operator arguments */
+    int         previous_got_int = FALSE;       /* "got_int" was TRUE */
 
 #if defined(FEAT_X11) && defined(FEAT_XCLIPBOARD)
     /* Setup to catch a terminating error from the X server.  Just ignore
@@ -1015 +1016 @@
                 need_fileinfo = FALSE;
             }
         }
-        if (got_int && !global_busy)
+
+        /* Reset "got_int" now that we got back to the main loop.  Except when
+         * inside a ":g/pat/cmd" command, then the "got_int" needs to abort
+         * the ":g" command.
+         * For ":g/pat/vi" we reset "got_int" when used once.  When used
+         * a second time we go back to Ex mode and abort the ":g" command. */
+        if (got_int)
         {
-            if (!quit_more)
-                (void)vgetc();          /* flush all buffers */
-            got_int = FALSE;
+            if (noexmode && global_busy && !exmode_active && previous_got_int)
+            {
+                /* Typed two CTRL-C in a row: go back to ex mode as if "Q" was
+                 * used and keep "got_int" set, so that it aborts ":g". */
+                exmode_active = EXMODE_NORMAL;
+                State = NORMAL;
+            }
+            else if (!global_busy || !exmode_active)
+            {
+                if (!quit_more)
+                    (void)vgetc();              /* flush all buffers */
+                got_int = FALSE;
+            }
+            previous_got_int = TRUE;
         }
+        else
+            previous_got_int = FALSE;
+
         if (!exmode_active)
             msg_scroll = FALSE;
         quit_more = FALSE;
@@ -1360 +1381 @@
         p = vim_getenv((char_u *)"VIMRUNTIME", &mustfree);
         if (p != NULL && *p != NUL)
         {
-            STRCPY(NameBuff, p);
-            STRCAT(NameBuff, "/lang");
+            vim_snprintf((char *)NameBuff, MAXPATHL, "%s/lang", p);
             bindtextdomain(VIMPACKAGE, (char *)NameBuff);
         }
         if (mustfree)

src/mbyte.c

@@ -1310 +1310 @@
 /*
  * mb_off2cells() function pointer.
  * Return number of display cells for char at ScreenLines[off].
- * Caller must make sure "off" and "off + 1" are valid!
+ * We make sure that the offset used is less than "max_off".
  */
 /*ARGSUSED*/
     int
-latin_off2cells(off)
+latin_off2cells(off, max_off)
     unsigned    off;
+    unsigned    max_off;
 {
     return 1;
 }
 
     int
-dbcs_off2cells(off)
+dbcs_off2cells(off, max_off)
     unsigned    off;
+    unsigned    max_off;
 {
+    /* never check beyond end of the line */
+    if (off >= max_off)
+        return 1;
+
     /* Number of cells is equal to number of bytes, except for euc-jp when
      * the first byte is 0x8e. */
     if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
@@ -1332 +1338 @@
 }
 
     int
-utf_off2cells(off)
+utf_off2cells(off, max_off)
     unsigned    off;
+    unsigned    max_off;
 {
-    return ScreenLines[off + 1] == 0 ? 2 : 1;
+    return (off + 1 < max_off && ScreenLines[off + 1] == 0) ? 2 : 1;
 }
 
 /*
@@ -2320 +2327 @@
                 /* Single byte: first check normally, then with ignore case. */
                 if (s1[i] != s2[i])
                 {
-                    cdiff = TOLOWER_LOC(s1[i]) - TOLOWER_LOC(s2[i]);
+                    cdiff = MB_TOLOWER(s1[i]) - MB_TOLOWER(s2[i]);
                     if (cdiff != 0)
                         return cdiff;
                 }
@@ -2899 +2906 @@
     if (composing_hangul)
         return TRUE;
 #endif
-    if (enc_dbcs != 0)
-        return dbcs_off2cells(LineOffset[row] + col) > 1;
-    if (enc_utf8)
-        return (col + 1 < Columns
-                && ScreenLines[LineOffset[row] + col + 1] == 0);
-    return FALSE;
+    return (*mb_off2cells)(LineOffset[row] + col,
+                                        LineOffset[row] + screen_Columns) > 1;
 }
 
 # if defined(FEAT_CLIPBOARD) || defined(FEAT_GUI) || defined(FEAT_RIGHTLEFT) \

src/message.c

@@ -1842 +1842 @@
     int         wrap;
 
     did_wait_return = FALSE;
-    while (*s != NUL && (maxlen < 0 || (int)(s - str) < maxlen))
+    while ((maxlen < 0 || (int)(s - str) < maxlen) && *s != NUL)
     {
         /*
          * We are at the end of the screen line when:
@@ -1878 +1878 @@
                 /* output postponed text */
                 t_puts(&t_col, t_s, s, attr);
 
-            /* When no more prompt an no more room, truncate here */
+            /* When no more prompt and no more room, truncate here */
             if (msg_no_more && lines_left == 0)
                 break;
 
@@ -1927 +1927 @@
              * If screen is completely filled and 'more' is set then wait
              * for a character.
              */
-            --lines_left;
+            if (lines_left > 0)
+                --lines_left;
             if (p_more && lines_left == 0 && State != HITRETURN
                                             && !msg_no_more && !exmode_active)
             {
@@ -2234 +2235 @@
 {
     msgchunk_T  *mp;
 
-    /* Only show somethign if there is more than one line, otherwise it looks
+    /* Only show something if there is more than one line, otherwise it looks
      * weird, typing a command without output results in one line. */
     mp = msg_sb_start(last_msgchunk);
     if (mp == NULL || mp->sb_prev == NULL)
@@ -2622 +2623 @@
                 }
             }
 
-            if (scroll < 0 || (scroll == 0 && mp_last != NULL))
+            if (scroll <= 0)
             {
                 /* displayed the requested text, more prompt again */
                 screen_fill((int)Rows - 1, (int)Rows, 0,
@@ -3456 +3457 @@
                     /* advance to next hotkey and set default hotkey */
 #ifdef FEAT_MBYTE
                     if (has_mbyte)
-                        hotkp += (*mb_ptr2len)(hotkp);
+                        hotkp += STRLEN(hotkp);
                     else
 #endif
                         ++hotkp;
-                    (void)copy_char(r + 1, hotkp, TRUE);
+                    hotkp[copy_char(r + 1, hotkp, TRUE)] = NUL;
                     if (dfltbutton)
                         --dfltbutton;
 
@@ -3493 +3494 @@
                         *msgp++ = (dfltbutton == 1) ? ']' : ')';
 
                         /* redefine hotkey */
-                        (void)copy_char(r, hotkp, TRUE);
+                        hotkp[copy_char(r, hotkp, TRUE)] = NUL;
                     }
                 }
                 else
@@ -3519 +3520 @@
             *msgp++ = ':';
             *msgp++ = ' ';
             *msgp = NUL;
-            mb_ptr_adv(hotkp);
-            *hotkp = NUL;
         }
         else
         {
@@ -3555 +3554 @@
             msgp = confirm_msg + 1 + STRLEN(message);
             hotkp = hotk;
 
-            /* define first default hotkey */
-            (void)copy_char(buttons, hotkp, TRUE);
+            /* Define first default hotkey.  Keep the hotkey string NUL
+             * terminated to avoid reading past the end. */
+            hotkp[copy_char(buttons, hotkp, TRUE)] = NUL;
 
             /* Remember where the choices start, displaying starts here when
              * "hotkp" typed at the more prompt. */

src/misc1.c

@@ -90 +90 @@
  */
     int
 set_indent(size, flags)
-    int         size;
+    int         size;               /* measured in spaces */
     int         flags;
 {
     char_u      *p;
@@ -98 +98 @@
     char_u      *oldline;
     char_u      *s;
     int         todo;
-    int         ind_len;
+    int         ind_len;            /* measured in characters */
     int         line_len;
     int         doit = FALSE;
-    int         ind_done;
+    int         ind_done = 0;       /* measured in spaces */
     int         tab_pad;
     int         retval = FALSE;
+    int         orig_char_len = -1; /* number of initial whitespace chars when
+                                       'et' and 'pi' are both set */
 
     /*
      * First check if there is anything to do and compute the number of
@@ -116 +118 @@
     /* Calculate the buffer size for the new indent, and check to see if it
      * isn't already set */
 
-    /* if 'expandtab' isn't set: use TABs */
-    if (!curbuf->b_p_et)
+    /* if 'expandtab' isn't set: use TABs; if both 'expandtab' and
+     * 'preserveindent' are set count the number of characters at the
+     * beginning of the line to be copied */
+    if (!curbuf->b_p_et || (!(flags & SIN_INSERT) && curbuf->b_p_pi))
     {
         /* If 'preserveindent' is set then reuse as much as possible of
          * the existing indent structure for the new indent */
@@ -148 +152 @@
                 ++p;
             }
 
+            /* Set initial number of whitespace chars to copy if we are
+             * preserving indent but expandtab is set */
+            if (curbuf->b_p_et)
+                orig_char_len = ind_len;
+
             /* Fill to next tabstop with a tab, if possible */
             tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
-            if (todo >= tab_pad)
+            if (todo >= tab_pad && orig_char_len == -1)
             {
                 doit = TRUE;
                 todo -= tab_pad;
@@ -193 +202 @@
     else
         p = skipwhite(p);
     line_len = (int)STRLEN(p) + 1;
-    newline = alloc(ind_len + line_len);
-    if (newline == NULL)
-        return FALSE;
+
+    /* If 'preserveindent' and 'expandtab' are both set keep the original
+     * characters and allocate accordingly.  We will fill the rest with spaces
+     * after the if (!curbuf->b_p_et) below. */
+    if (orig_char_len != -1)
+    {
+        newline = alloc(orig_char_len + size - ind_done + line_len);
+        if (newline == NULL)
+            return FALSE;
+        todo = size - ind_done;
+        ind_len = orig_char_len + todo;    /* Set total length of indent in
+                                            * characters, which may have been
+                                            * undercounted until now  */
+        p = oldline;
+        s = newline;
+        while (orig_char_len > 0)
+        {
+            *s++ = *p++;
+            orig_char_len--;
+        }
+        /* Skip over any additional white space (useful when newindent is less
+         * than old) */
+        while (vim_iswhite(*p))
+            (void)*p++;
+
+    }
+    else
+    {
+        todo = size;
+        newline = alloc(ind_len + line_len);
+        if (newline == NULL)
+            return FALSE;
+        s = newline;
+    }
 
     /* Put the characters in the new line. */
-    s = newline;
-    todo = size;
     /* if 'expandtab' isn't set: use TABs */
     if (!curbuf->b_p_et)
     {
@@ -1320 +1358 @@
             newindent += (int)curbuf->b_p_sw;
         }
 #endif
-        /* Copy the indent only if expand tab is disabled */
-        if (curbuf->b_p_ci && !curbuf->b_p_et)
+        /* Copy the indent */
+        if (curbuf->b_p_ci)
         {
             (void)copy_indent(newindent, saved_line);
 
@@ -4786 +4824 @@
 static int      cin_iswhileofdo __ARGS((char_u *, linenr_T, int));
 static int      cin_iswhileofdo_end __ARGS((int terminated, int ind_maxparen, int ind_maxcomment));
 static int      cin_isbreak __ARGS((char_u *));
-static int      cin_is_cpp_baseclass __ARGS((char_u *line, colnr_T *col));
+static int      cin_is_cpp_baseclass __ARGS((colnr_T *col));
 static int      get_baseclass_amount __ARGS((int col, int ind_maxparen, int ind_maxcomment, int ind_cpp_baseclass));
 static int      cin_ends_in __ARGS((char_u *, char_u *, char_u *));
 static int      cin_skip2pos __ARGS((pos_T *trypos));
@@ -5551 +5589 @@
  * This is a lot of guessing.  Watch out for "cond ? func() : foo".
  */
     static int
-cin_is_cpp_baseclass(line, col)
-    char_u      *line;
+cin_is_cpp_baseclass(col)
     colnr_T     *col;       /* return: column to align with */
 {
     char_u      *s;
     int         class_or_struct, lookfor_ctor_init, cpp_base_class;
     linenr_T    lnum = curwin->w_cursor.lnum;
+    char_u      *line = ml_get_curline();
 
     *col = 0;
 
@@ -5585 +5623 @@
      */
     while (lnum > 1)
     {
-        s = skipwhite(ml_get(lnum - 1));
+        line = ml_get(lnum - 1);
+        s = skipwhite(line);
         if (*s == '#' || *s == NUL)
             break;
         while (*s != NUL)
@@ -5602 +5641 @@
         --lnum;
     }
 
-    s = cin_skipcomment(ml_get(lnum));
+    line = ml_get(lnum);
+    s = cin_skipcomment(line);
     for (;;)
     {
         if (*s == NUL)
@@ -5610 +5650 @@
             if (lnum == curwin->w_cursor.lnum)
                 break;
             /* Continue in the cursor line. */
-            s = cin_skipcomment(ml_get(++lnum));
+            line = ml_get(++lnum);
+            s = cin_skipcomment(line);
+            if (*s == NUL)
+                continue;
         }
 
         if (s[0] == ':')
@@ -7079 +7122 @@
                 n = FALSE;
                 if (lookfor != LOOKFOR_TERM && ind_cpp_baseclass > 0)
                 {
-                    n = cin_is_cpp_baseclass(l, &col);
+                    n = cin_is_cpp_baseclass(&col);
                     l = ml_get_curline();
                 }
                 if (n)
@@ -7670 +7713 @@
                 n = FALSE;
                 if (ind_cpp_baseclass != 0 && theline[0] != '{')
                 {
-                    n = cin_is_cpp_baseclass(l, &col);
+                    n = cin_is_cpp_baseclass(&col);
                     l = ml_get_curline();
                 }
                 if (n)
@@ -8596 +8639 @@
     for (p = buf + wildoff; p < s; ++p)
         if (rem_backslash(p))
         {
-            STRCPY(p, p + 1);
+            mch_memmove(p, p + 1, STRLEN(p));
             --e;
             --s;
         }
@@ -8897 +8940 @@
     for (p = buf + wildoff; p < s; ++p)
         if (rem_backslash(p))
         {
-            STRCPY(p, p + 1);
+            mch_memmove(p, p + 1, STRLEN(p));
             --e;
             --s;
         }

src/normal.c

@@ -889 +889 @@
 
         ++no_mapping;
         ++allow_keys;           /* no mapping for nchar, but allow key codes */
+#ifdef FEAT_AUTOCMD
+        /* Don't generate a CursorHold event here, most commands can't handle
+         * it, e.g., nv_replace(), nv_csearch(). */
+        did_cursorhold = TRUE;
+#endif
         if (ca.cmdchar == 'g')
         {
             /*
@@ -3755 +3760 @@
     extra_len = (int)STRLEN(p);
     overflow = old_len + extra_len - SHOWCMD_COLS;
     if (overflow > 0)
-        STRCPY(showcmd_buf, showcmd_buf + overflow);
+        mch_memmove(showcmd_buf, showcmd_buf + overflow,
+                                                      old_len - overflow + 1);
     STRCAT(showcmd_buf, p);
 
     if (char_avail())
@@ -6379 +6385 @@
      */
     else if (cap->nchar == 'p' || cap->nchar == 'P')
     {
-        if (!checkclearopq(cap->oap))
+        if (!checkclearop(cap->oap))
         {
             prep_redo_cmd(cap);
             do_put(cap->oap->regname,
@@ -6662 +6668 @@
     else
         had_ctrl_v = NUL;
 
+    /* Abort if the character is a special key. */
+    if (IS_SPECIAL(cap->nchar))
+    {
+        clearopbeep(cap->oap);
+        return;
+    }
+
 #ifdef FEAT_VISUAL
     /* Visual mode "r" */
     if (VIsual_active)
@@ -6688 +6701 @@
     }
 #endif
 
-    /*
-     * Check for a special key or not enough characters to replace.
-     */
+    /* Abort if not enough characters to replace. */
     ptr = ml_get_cursor();
-    if (IS_SPECIAL(cap->nchar) || STRLEN(ptr) < (unsigned)cap->count1
+    if (STRLEN(ptr) < (unsigned)cap->count1
 #ifdef FEAT_MBYTE
             || (has_mbyte && mb_charlen(ptr) < cap->count1)
 #endif

src/ops.c

@@ -3404 +3404 @@
 
 #ifdef FEAT_VIRTUALEDIT
         col += curwin->w_cursor.coladd;
-        if (ve_flags == VE_ALL && curwin->w_cursor.coladd > 0)
+        if (ve_flags == VE_ALL
+                && (curwin->w_cursor.coladd > 0
+                    || endcol2 == curwin->w_cursor.col))
         {
             if (dir == FORWARD && c == NUL)
                 ++col;

src/option.c

@@ -4628 +4628 @@
                                     if ((!(flags & P_COMMA) || *s != ',')
                                             && vim_strchr(s + 1, *s) != NULL)
                                     {
-                                        STRCPY(s, s + 1);
+                                        mch_memmove(s, s + 1, STRLEN(s));
                                         --s;
                                     }
                             }
@@ -7118 +7118 @@
     /* when 'endofline' is changed, redraw the window title */
     else if ((int *)varp == &curbuf->b_p_eol)
         need_maketitle = TRUE;
+#ifdef FEAT_MBYTE
+    /* when 'bomb' is changed, redraw the window title */
+    else if ((int *)varp == &curbuf->b_p_bomb)
+        need_maketitle = TRUE;
+#endif
 #endif
 
     /* when 'bin' is set also set some other options */
@@ -8219 +8224 @@
             varp = get_varp(&options[opt_idx]);
             if (varp != NULL)   /* hidden option is not changed */
             {
+                if (number == 0 && string != NULL)
+                {
+                    int index;
+
+                    /* Either we are given a string or we are setting option
+                     * to zero. */
+                    for (index = 0; string[index] == '0'; ++index)
+                        ;
+                    if (string[index] != NUL || index == 0)
+                    {
+                        /* There's another character after zeros or the string
+                         * is empty.  In both cases, we are trying to set a
+                         * num option using a string. */
+                        EMSG3(_("E521: Number required: &%s = '%s'"),
+                                                                name, string);
+                        return;     /* do nothing as we hit an error */
+
+                    }
+                }
                 if (flags & P_NUM)
                     (void)set_num_option(opt_idx, varp, number,
                                                           NULL, 0, opt_flags);
@@ -10585 +10609 @@
     buf->b_start_ffc = *buf->b_p_ff;
     buf->b_start_eol = buf->b_p_eol;
 #ifdef FEAT_MBYTE
+    buf->b_start_bomb = buf->b_p_bomb;
+
     /* Only use free/alloc when necessary, they take time. */
     if (buf->b_start_fenc == NULL
                              || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0)
@@ -10598 +10624 @@
 /*
  * Return TRUE if 'fileformat' and/or 'fileencoding' has a different value
  * from when editing started (save_file_ff() called).
- * Also when 'endofline' was changed and 'binary' is set.
+ * Also when 'endofline' was changed and 'binary' is set, or when 'bomb' was
+ * changed and 'binary' is not set.
  * Don't consider a new, empty buffer to be changed.
  */
     int
 file_ff_differs(buf)
     buf_T       *buf;
 {
+    /* In a buffer that was never loaded the options are not valid. */
+    if (buf->b_flags & BF_NEVERLOADED)
+        return FALSE;
     if ((buf->b_flags & BF_NEW)
             && buf->b_ml.ml_line_count == 1
             && *ml_get_buf(buf, (linenr_T)1, FALSE) == NUL)
@@ -10614 +10644 @@
     if (buf->b_p_bin && buf->b_start_eol != buf->b_p_eol)
         return TRUE;
 #ifdef FEAT_MBYTE
+    if (!buf->b_p_bin && buf->b_start_bomb != buf->b_p_bomb)
+        return TRUE;
     if (buf->b_start_fenc == NULL)
         return (*buf->b_p_fenc != NUL);
     return (STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0);

src/os_unix.c

@@ -753 +753 @@
     if (signal_stack != NULL)
     {
 # ifdef HAVE_SIGALTSTACK
-#  ifdef __APPLE__
+#  if defined(__APPLE__) && (!defined(MAC_OS_X_VERSION_MAX_ALLOWED) \
+                || MAC_OS_X_VERSION_MAX_ALLOWED <= 1040)
         /* missing prototype.  Adding it to osdef?.h.in doesn't work, because
          * "struct sigaltstack" needs to be declared. */
         extern int sigaltstack __ARGS((const struct sigaltstack *ss, struct sigaltstack *oss));
@@ -2499 +2500 @@
     if (stat((char *)name, &statb))
 #endif
         return -1;
+#ifdef __INTERIX
+    /* The top bit makes the value negative, which means the file doesn't
+     * exist.  Remove the bit, we don't use it. */
+    return statb.st_mode & ~S_ADDACE;
+#else
     return statb.st_mode;
+#endif
 }
 
 /*
@@ -5682 +5689 @@
 
 /*
  * Closes connection to gpm
- * returns non-zero if connection succesfully closed
+ * returns non-zero if connection successfully closed
  */
     static void
 gpm_close()

src/os_unix.h

@@ -508 +508 @@
 #if !defined(S_ISFIFO) && defined(S_IFIFO)
 # define        S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
 #endif
+#if !defined(S_ISCHR) && defined(S_IFCHR)
+# define        S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
+#endif
 
 /* Note: Some systems need both string.h and strings.h (Savage).  However,
  * some systems can't handle both, only use string.h in that case. */

src/popupmnu.c

@@ -75 +75 @@
 
     row = curwin->w_cline_row + W_WINROW(curwin);
     height = curwin->w_cline_height;
-    col = curwin->w_wcol + W_WINCOL(curwin) - curwin->w_leftcol;
 
     if (firstwin->w_p_pvw)
         top_clear = firstwin->w_height;
@@ -167 +166 @@
     pum_base_width = max_width;
     pum_kind_width = kind_width;
 
+    /* Calculate column */
+#ifdef FEAT_RIGHTLEFT
+    if (curwin->w_p_rl)
+        col = W_WINCOL(curwin) + W_WIDTH(curwin) - curwin->w_wcol -
+                                                        curwin->w_leftcol - 1;
+    else
+#endif
+        col = W_WINCOL(curwin) + curwin->w_wcol - curwin->w_leftcol;
+
     /* if there are more items than room we need a scrollbar */
     if (pum_height < size)
     {
@@ -179 +187 @@
     if (def_width < max_width)
         def_width = max_width;
 
-    if (col < Columns - PUM_DEF_WIDTH || col < Columns - max_width)
+    if (((col < Columns - PUM_DEF_WIDTH || col < Columns - max_width)
+#ifdef FEAT_RIGHTLEFT
+                && !curwin->w_p_rl)
+            || (curwin->w_p_rl && (col > PUM_DEF_WIDTH || col > max_width)
+#endif
+       ))
     {
         /* align pum column with "col" */
         pum_col = col;
-        pum_width = Columns - pum_col - pum_scrollbar;
+
+#ifdef FEAT_RIGHTLEFT
+        if (curwin->w_p_rl)
+            pum_width = pum_col - pum_scrollbar + 1;
+        else
+#endif
+            pum_width = Columns - pum_col - pum_scrollbar;
+
         if (pum_width > max_width + kind_width + extra_width + 1
                                                  && pum_width > PUM_DEF_WIDTH)
         {
@@ -195 +215 @@
     else if (Columns < def_width)
     {
         /* not enough room, will use what we have */
-        pum_col = 0;
+#ifdef FEAT_RIGHTLEFT
+        if (curwin->w_p_rl)
+            pum_col = Columns - 1;
+        else
+#endif
+            pum_col = 0;
         pum_width = Columns - 1;
     }
     else
     {
         if (max_width > PUM_DEF_WIDTH)
             max_width = PUM_DEF_WIDTH;  /* truncate */
-        pum_col = Columns - max_width;
+#ifdef FEAT_RIGHTLEFT
+        if (curwin->w_p_rl)
+            pum_col = max_width - 1;
+        else
+#endif
+            pum_col = Columns - max_width;
         pum_width = max_width - pum_scrollbar;
     }
 
@@ -255 +285 @@
         attr = (idx == pum_selected) ? attr_select : attr_norm;
 
         /* prepend a space if there is room */
-        if (pum_col > 0)
-            screen_putchar(' ', row, pum_col - 1, attr);
+#ifdef FEAT_RIGHTLEFT
+        if (curwin->w_p_rl)
+        {
+            if (pum_col < W_WINCOL(curwin) + W_WIDTH(curwin) - 1)
+                screen_putchar(' ', row, pum_col + 1, attr);
+        }
+        else
+#endif
+            if (pum_col > 0)
+                screen_putchar(' ', row, pum_col - 1, attr);
 
         /* Display each entry, use two spaces for a Tab.
          * Do this 3 times: For the main text, kind and extra info */
@@ -282 +320 @@
                     {
                         /* Display the text that fits or comes before a Tab.
                          * First convert it to printable characters. */
-                        char_u *st;
-                        int  saved = *p;
+                        char_u  *st;
+                        int     saved = *p;
 
                         *p = NUL;
                         st = transstr(s);
                         *p = saved;
-                        if (st != NULL)
+#ifdef FEAT_RIGHTLEFT
+                        if (curwin->w_p_rl)
                         {
-                            screen_puts_len(st, (int)STRLEN(st), row, col,
+                            if (st != NULL)
+                            {
+                                char_u  *rt = reverse_text(st);
+                                char_u  *rt_saved = rt;
+                                int     len, j;
+
+                                if (rt != NULL)
+                                {
+                                    len = STRLEN(rt);
+                                    if (len > pum_width)
+                                    {
+                                        for (j = pum_width; j < len; ++j)
+                                            mb_ptr_adv(rt);
+                                        len = pum_width;
+                                    }
+                                    screen_puts_len(rt, len, row,
+                                                        col - len + 1, attr);
+                                    vim_free(rt_saved);
+                                }
+                                vim_free(st);
+                            }
+                            col -= width;
+                        }
+                        else
+#endif
+                        {
+                            if (st != NULL)
+                            {
+                                screen_puts_len(st, (int)STRLEN(st), row, col,
                                                                         attr);
-                            vim_free(st);
+                                vim_free(st);
+                            }
+                            col += width;
                         }
-                        col += width;
 
                         if (*p != TAB)
                             break;
 
                         /* Display two spaces for a Tab. */
-                        screen_puts_len((char_u *)"  ", 2, row, col, attr);
-                        col += 2;
+#ifdef FEAT_RIGHTLEFT
+                        if (curwin->w_p_rl)
+                        {
+                            screen_puts_len((char_u *)"  ", 2, row, col - 1,
+                                                                        attr);
+                            col -= 2;
+                        }
+                        else
+#endif
+                        {
+                            screen_puts_len((char_u *)"  ", 2, row, col, attr);
+                            col += 2;
+                        }
                         totwidth += 2;
                         s = NULL;           /* start text at next char */
                         width = 0;
@@ -322 +401 @@
                                           && pum_array[idx].pum_extra == NULL)
                     || pum_base_width + n >= pum_width)
                 break;
-            screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
+#ifdef FEAT_RIGHTLEFT
+            if (curwin->w_p_rl)
+            {
+                screen_fill(row, row + 1, pum_col - pum_base_width - n + 1,
+                                                    col + 1, ' ', ' ', attr);
+                col = pum_col - pum_base_width - n + 1;
+            }
+            else
+#endif
+            {
+                screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
                                                               ' ', ' ', attr);
-            col = pum_col + pum_base_width + n;
+                col = pum_col + pum_base_width + n;
+            }
             totwidth = pum_base_width + n;
         }
 
-        screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ', attr);
+#ifdef FEAT_RIGHTLEFT
+        if (curwin->w_p_rl)
+            screen_fill(row, row + 1, pum_col - pum_width + 1, col + 1, ' ',
+                                                                    ' ', attr);
+        else
+#endif
+            screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ',
+                                                                        attr);
         if (pum_scrollbar > 0)
-            screen_putchar(' ', row, pum_col + pum_width,
-                    i >= thumb_pos && i < thumb_pos + thumb_heigth
+        {
+#ifdef FEAT_RIGHTLEFT
+            if (curwin->w_p_rl)
+                screen_putchar(' ', row, pum_col - pum_width,
+                        i >= thumb_pos && i < thumb_pos + thumb_heigth
                                                   ? attr_thumb : attr_scroll);
+            else
+#endif
+                screen_putchar(' ', row, pum_col + pum_width,
+                        i >= thumb_pos && i < thumb_pos + thumb_heigth
+                                                  ? attr_thumb : attr_scroll);
+        }
 
         ++row;
     }
@@ -466 +572 @@
                         set_option_value((char_u *)"bh", 0L,
                                                  (char_u *)"wipe", OPT_LOCAL);
                         set_option_value((char_u *)"diff", 0L,
-                                                     (char_u *)"", OPT_LOCAL);
+                                                             NULL, OPT_LOCAL);
                     }
                 }
                 if (res == OK)

src/proto/charset.pro

@@ -21 +21 @@
 int vim_iswordp __ARGS((char_u *p));
 int vim_iswordc_buf __ARGS((char_u *p, buf_T *buf));
 int vim_isfilec __ARGS((int c));
+int vim_isfilec_or_wc __ARGS((int c));
 int vim_isprintc __ARGS((int c));
 int vim_isprintc_strict __ARGS((int c));
 int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col));

src/proto/fileio.pro

@@ -2 +2 @@
 void filemess __ARGS((buf_T *buf, char_u *name, char_u *s, int attr));
 int readfile __ARGS((char_u *fname, char_u *sfname, linenr_T from, linenr_T lines_to_skip, linenr_T lines_to_read, exarg_T *eap, int flags));
 int prep_exarg __ARGS((exarg_T *eap, buf_T *buf));
+int check_file_readonly __ARGS((char_u *fname, int perm));
 int buf_write __ARGS((buf_T *buf, char_u *fname, char_u *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, int filtering));
 void msg_add_fname __ARGS((buf_T *buf, char_u *fname));
 void msg_add_lines __ARGS((int insert_space, long lnum, long nchars));

src/proto/mbyte.pro

@@ -12 +12 @@
 int utf_ptr2cells __ARGS((char_u *p));
 int dbcs_ptr2cells __ARGS((char_u *p));
 int latin_char2cells __ARGS((int c));
-int latin_off2cells __ARGS((unsigned off));
-int dbcs_off2cells __ARGS((unsigned off));
-int utf_off2cells __ARGS((unsigned off));
+int latin_off2cells __ARGS((unsigned off, unsigned max_off));
+int dbcs_off2cells __ARGS((unsigned off, unsigned max_off));
+int utf_off2cells __ARGS((unsigned off, unsigned max_off));
 int latin_ptr2char __ARGS((char_u *p));
 int utf_ptr2char __ARGS((char_u *p));
 int mb_ptr2char_adv __ARGS((char_u **pp));

src/proto/search.pro

@@ -1 +1 @@
 /* search.c */
 int search_regcomp __ARGS((char_u *pat, int pat_save, int pat_use, int options, regmmatch_T *regmatch));
 char_u *get_search_pat __ARGS((void));
+char_u *reverse_text __ARGS((char_u *s));
 void save_search_patterns __ARGS((void));
 void restore_search_patterns __ARGS((void));
 void free_search_patterns __ARGS((void));

src/proto/syntax.pro

@@ -8 +8 @@
 void syntax_clear __ARGS((buf_T *buf));
 void ex_syntax __ARGS((exarg_T *eap));
 int syntax_present __ARGS((buf_T *buf));
+void reset_expand_highlight __ARGS((void));
+void set_context_in_echohl_cmd __ARGS((expand_T *xp, char_u *arg));
 void set_context_in_syntax_cmd __ARGS((expand_T *xp, char_u *arg));
 char_u *get_syntax_name __ARGS((expand_T *xp, int idx));
 int syn_get_id __ARGS((win_T *wp, long lnum, colnr_T col, int trans, int *spellp));

src/proto/window.pro

@@ -59 +59 @@
 int only_one_window __ARGS((void));
 void check_lnums __ARGS((int do_curwin));
 int win_hasvertsplit __ARGS((void));
+int match_add __ARGS((win_T *wp, char_u *grp, char_u *pat, int prio, int id));
+int match_delete __ARGS((win_T *wp, int id, int perr));
+void clear_matches __ARGS((win_T *wp));
+matchitem_T *get_match __ARGS((win_T *wp, int id));
 /* vim: set ft=c : */

src/quickfix.c

@@ -2331 +2331 @@
             set_option_value((char_u *)"bt", 0L, (char_u *)"quickfix",
                                                                    OPT_LOCAL);
             set_option_value((char_u *)"bh", 0L, (char_u *)"wipe", OPT_LOCAL);
-            set_option_value((char_u *)"diff", 0L, (char_u *)"", OPT_LOCAL);
+            set_option_value((char_u *)"diff", 0L, NULL, OPT_LOCAL);
         }
 
         /* Only set the height when still in the same tab page and there is no

src/regexp.c

@@ -2220 +2220 @@
                                 break;
                             case CLASS_LOWER:
                                 for (cu = 1; cu <= 255; cu++)
-                                    if (islower(cu))
+                                    if (MB_ISLOWER(cu))
                                         regc(cu);
                                 break;
                             case CLASS_PRINT:
@@ -2240 +2240 @@
                                 break;
                             case CLASS_UPPER:
                                 for (cu = 1; cu <= 255; cu++)
-                                    if (isupper(cu))
+                                    if (MB_ISUPPER(cu))
                                         regc(cu);
                                 break;
                             case CLASS_XDIGIT:
@@ -3465 +3465 @@
                         (enc_utf8 && utf_fold(prog->regstart) == utf_fold(c)))
                         || (c < 255 && prog->regstart < 255 &&
 #endif
-                            TOLOWER_LOC(prog->regstart) == TOLOWER_LOC(c)))))
+                            MB_TOLOWER(prog->regstart) == MB_TOLOWER(c)))))
             retval = regtry(prog, col);
         else
             retval = 0;
@@ -4200 +4200 @@
 #ifdef FEAT_MBYTE
                             !enc_utf8 &&
 #endif
-                            TOLOWER_LOC(*opnd) != TOLOWER_LOC(*reginput))))
+                            MB_TOLOWER(*opnd) != MB_TOLOWER(*reginput))))
                     status = RA_NOMATCH;
                 else if (*opnd == NUL)
                 {
@@ -4733 +4733 @@
                     rst.nextb = *OPERAND(next);
                     if (ireg_ic)
                     {
-                        if (isupper(rst.nextb))
-                            rst.nextb_ic = TOLOWER_LOC(rst.nextb);
+                        if (MB_ISUPPER(rst.nextb))
+                            rst.nextb_ic = MB_TOLOWER(rst.nextb);
                         else
-                            rst.nextb_ic = TOUPPER_LOC(rst.nextb);
+                            rst.nextb_ic = MB_TOUPPER(rst.nextb);
                     }
                     else
                         rst.nextb_ic = rst.nextb;
@@ -5558 +5558 @@
             int     cu, cl;
 
             /* This doesn't do a multi-byte character, because a MULTIBYTECODE
-             * would have been used for it. */
+             * would have been used for it.  It does handle single-byte
+             * characters, such as latin1. */
             if (ireg_ic)
             {
-                cu = TOUPPER_LOC(*opnd);
-                cl = TOLOWER_LOC(*opnd);
+                cu = MB_TOUPPER(*opnd);
+                cl = MB_TOLOWER(*opnd);
                 while (count < maxcount && (*scan == cu || *scan == cl))
                 {
                     count++;
@@ -6490 +6491 @@
         cc = utf_fold(c);
     else
 #endif
-         if (isupper(c))
-        cc = TOLOWER_LOC(c);
-    else if (islower(c))
-        cc = TOUPPER_LOC(c);
+         if (MB_ISUPPER(c))
+        cc = MB_TOLOWER(c);
+    else if (MB_ISLOWER(c))
+        cc = MB_TOUPPER(c);
     else
         return vim_strchr(s, c);
 
@@ -6637 +6638 @@
                 }
             }
             else if (magic)
-                STRCPY(p, p + 1);               /* remove '~' */
+                mch_memmove(p, p + 1, STRLEN(p));       /* remove '~' */
             else
-                STRCPY(p, p + 2);               /* remove '\~' */
+                mch_memmove(p, p + 2, STRLEN(p) - 1);   /* remove '\~' */
             --p;
         }
         else
@@ -7014 +7015 @@
 #ifdef FEAT_MBYTE
                             if (has_mbyte)
                             {
-                                int l = mb_ptr2len(s) - 1;
+                                int l;
+
+                                /* Copy composing characters separately, one
+                                 * at a time. */
+                                if (enc_utf8)
+                                    l = utf_ptr2len(s) - 1;
+                                else
+                                    l = mb_ptr2len(s) - 1;
 
                                 s += l;
                                 len -= l;

src/screen.c

@@ -100 +100 @@
 static int      screen_cur_row, screen_cur_col; /* last known cursor position */
 
 #ifdef FEAT_SEARCH_EXTRA
-/*
- * Struct used for highlighting 'hlsearch' matches for the last use search
- * pattern or a ":match" item.
- * For 'hlsearch' there is one pattern for all windows.  For ":match" there is
- * a different pattern for each window.
- */
-typedef struct
-{
-    regmmatch_T rm;     /* points to the regexp program; contains last found
-                           match (may continue in next line) */
-    buf_T       *buf;   /* the buffer to search for a match */
-    linenr_T    lnum;   /* the line to search for a match */
-    int         attr;   /* attributes to be used for a match */
-    int         attr_cur; /* attributes currently active in win_line() */
-    linenr_T    first_lnum;     /* first lnum to search for multi-line pat */
-    colnr_T     startcol; /* in win_line() points to char where HL starts */
-    colnr_T     endcol;  /* in win_line() points to char where HL ends */
-} match_T;
-
 static match_T search_hl;       /* used for 'hlsearch' highlight matching */
-static match_T match_hl[3];     /* used for ":match" highlight matching */
 #endif
 
 #ifdef FEAT_FOLDING
@@ -155 +135 @@
 static void redraw_custum_statusline __ARGS((win_T *wp));
 #endif
 #ifdef FEAT_SEARCH_EXTRA
+#define SEARCH_HL_PRIORITY 0
 static void start_search_hl __ARGS((void));
 static void end_search_hl __ARGS((void));
 static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum));
@@ -350 +331 @@
     {
         if (type < must_redraw)     /* use maximal type */
             type = must_redraw;
+
+        /* must_redraw is reset here, so that when we run into some weird
+         * reason to redraw while busy redrawing (e.g., asynchronous
+         * scrolling), or update_topline() in win_update() will cause a
+         * scroll, the screen will be redrawn later or in win_update(). */
         must_redraw = 0;
     }
 
@@ -787 +773 @@
                                            w_topline got smaller a bit */
 #endif
 #ifdef FEAT_SEARCH_EXTRA
+    matchitem_T *cur;           /* points to the match list */
     int         top_to_mod = FALSE;    /* redraw above mod_top */
 #endif
 
@@ -848 +835 @@
 #endif
 
 #ifdef FEAT_SEARCH_EXTRA
-    /* Setup for ":match" and 'hlsearch' highlighting.  Disable any previous
+    /* Setup for match and 'hlsearch' highlighting.  Disable any previous
      * match */
-    for (i = 0; i < 3; ++i)
+    cur = wp->w_match_head;
+    while (cur != NULL)
     {
-        match_hl[i].rm = wp->w_match[i];
-        if (wp->w_match_id[i] == 0)
-            match_hl[i].attr = 0;
-        else
-            match_hl[i].attr = syn_id2attr(wp->w_match_id[i]);
-        match_hl[i].buf = buf;
-        match_hl[i].lnum = 0;
-        match_hl[i].first_lnum = 0;
+        cur->hl.rm = cur->match;
+        if (cur->hlg_id == 0)
+            cur->hl.attr = 0;
+        else
+            cur->hl.attr = syn_id2attr(cur->hlg_id);
+        cur->hl.buf = buf;
+        cur->hl.lnum = 0;
+        cur->hl.first_lnum = 0;
+        cur = cur->next;
     }
     search_hl.buf = buf;
     search_hl.lnum = 0;
@@ -923 +912 @@
              * change in one line may make the Search highlighting in a
              * previous line invalid.  Simple solution: redraw all visible
              * lines above the change.
-             * Same for a ":match" pattern.
+             * Same for a match pattern.
              */
             if (search_hl.rm.regprog != NULL
                                         && re_multiline(search_hl.rm.regprog))
                 top_to_mod = TRUE;
             else
-                for (i = 0; i < 3; ++i)
-                    if (match_hl[i].rm.regprog != NULL
-                                      && re_multiline(match_hl[i].rm.regprog))
+            {
+                cur = wp->w_match_head;
+                while (cur != NULL)
+                {
+                    if (cur->match.regprog != NULL
+                                           && re_multiline(cur->match.regprog))
                     {
                         top_to_mod = TRUE;
                         break;
                     }
+                    cur = cur->next;
+                }
+            }
 #endif
         }
 #ifdef FEAT_FOLDING
@@ -1029 +1024 @@
             type = VALID;
     }
 
+    /* Trick: we want to avoid clearing the screen twice.  screenclear() will
+     * set "screen_cleared" to TRUE.  The special value MAYBE (which is still
+     * non-zero and thus not FALSE) will indicate that screenclear() was not
+     * called. */
+    if (screen_cleared)
+        screen_cleared = MAYBE;
+
     /*
      * If there are no changes on the screen that require a complete redraw,
      * handle three cases:
@@ -1230 +1232 @@
             mid_end = wp->w_height;
             if (lastwin == firstwin)
             {
-                screenclear();
+                /* Clear the screen when it was not done by win_del_lines() or
+                 * win_ins_lines() above, "screen_cleared" is FALSE or MAYBE
+                 * then. */
+                if (screen_cleared != TRUE)
+                    screenclear();
 #ifdef FEAT_WINDOWS
                 /* The screen was cleared, redraw the tab pages line. */
                 if (redraw_tabline)
@@ -1238 +1244 @@
 #endif
             }
         }
+
+        /* When win_del_lines() or win_ins_lines() caused the screen to be
+         * cleared (only happens for the first window) or when screenclear()
+         * was called directly above, "must_redraw" will have been set to
+         * NOT_VALID, need to reset it here to avoid redrawing twice. */
+        if (screen_cleared == TRUE)
+            must_redraw = 0;
     }
     else
     {
@@ -2542 +2555 @@
 
     char_u      extra[18];              /* "%ld" and 'fdc' must fit in here */
     int         n_extra = 0;            /* number of extra chars */
-    char_u      *p_extra = NULL;        /* string of extra chars */
+    char_u      *p_extra = NULL;        /* string of extra chars, plus NUL */
     int         c_extra = NUL;          /* extra chars, all the same */
     int         extra_attr = 0;         /* attributes when n_extra != 0 */
     static char_u *at_end_str = (char_u *)""; /* used for p_extra when
@@ -2626 +2639 @@
     int         line_attr = 0;          /* atrribute for the whole line */
 #endif
 #ifdef FEAT_SEARCH_EXTRA
-    match_T     *shl;                   /* points to search_hl or match_hl */
-#endif
-#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_MBYTE)
-    int         i;
+    matchitem_T *cur;                   /* points to the match list */
+    match_T     *shl;                   /* points to search_hl or a match */
+    int         shl_flag;               /* flag to indicate whether search_hl
+                                           has been processed or not */
+    int         prevcol_hl_flag;        /* flag to indicate whether prevcol
+                                           equals startcol of search_hl or one
+                                           of the matches */
 #endif
 #ifdef FEAT_ARABIC
     int         prev_c = 0;             /* previous Arabic character */
@@ -3074 +3090 @@
 
 #ifdef FEAT_SEARCH_EXTRA
     /*
-     * Handle highlighting the last used search pattern and ":match".
-     * Do this for both search_hl and match_hl[3].
+     * Handle highlighting the last used search pattern and matches.
+     * Do this for both search_hl and the match list.
      */
-    for (i = 3; i >= 0; --i)
+    cur = wp->w_match_head;
+    shl_flag = FALSE;
+    while (cur != NULL || shl_flag == FALSE)
     {
-        shl = (i == 3) ? &search_hl : &match_hl[i];
+        if (shl_flag == FALSE)
+        {
+            shl = &search_hl;
+            shl_flag = TRUE;
+        }
+        else
+            shl = &cur->hl;
         shl->startcol = MAXCOL;
         shl->endcol = MAXCOL;
         shl->attr_cur = 0;
@@ -3122 +3146 @@
                 area_highlighting = TRUE;
             }
         }
+        if (shl != &search_hl && cur != NULL)
+            cur = cur->next;
     }
 #endif
 
@@ -3163 +3189 @@
                 if (cmdwin_type != 0 && wp == curwin)
                 {
                     /* Draw the cmdline character. */
-                    *extra = cmdwin_type;
                     n_extra = 1;
-                    p_extra = extra;
-                    c_extra = NUL;
+                    c_extra = cmdwin_type;
                     char_attr = hl_attr(HLF_AT);
                 }
             }
@@ -3182 +3206 @@
                     fill_foldcolumn(extra, wp, FALSE, lnum);
                     n_extra = wp->w_p_fdc;
                     p_extra = extra;
+                    p_extra[n_extra] = NUL;
                     c_extra = NUL;
                     char_attr = hl_attr(HLF_FC);
                 }
@@ -3388 +3413 @@
                  * After end, check for start/end of next match.
                  * When another match, have to check for start again.
                  * Watch out for matching an empty string!
-                 * Do this first for search_hl, then for match_hl, so that
-                 * ":match" overrules 'hlsearch'.
+                 * Do this for 'search_hl' and the match list (ordered by
+                 * priority).
                  */
                 v = (long)(ptr - line);
-                for (i = 3; i >= 0; --i)
-                {
-                    shl = (i == 3) ? &search_hl : &match_hl[i];
+                cur = wp->w_match_head;
+                shl_flag = FALSE;
+                while (cur != NULL || shl_flag == FALSE)
+                {
+                    if (shl_flag == FALSE
+                            && ((cur != NULL
+                                    && cur->priority > SEARCH_HL_PRIORITY)
+                                || cur == NULL))
+                    {
+                        shl = &search_hl;
+                        shl_flag = TRUE;
+                    }
+                    else
+                        shl = &cur->hl;
                     while (shl->rm.regprog != NULL)
                     {
                         if (shl->startcol != MAXCOL
@@ -3442 +3478 @@
                         }
                         break;
                     }
+                    if (shl != &search_hl && cur != NULL)
+                        cur = cur->next;
                 }
 
-                /* ":match" highlighting overrules 'hlsearch' */
-                for (i = 0; i <= 3; ++i)
-                    if (i == 3)
-                        search_attr = search_hl.attr_cur;
-                    else if (match_hl[i].attr_cur != 0)
+                /* Use attributes from match with highest priority among
+                 * 'search_hl' and the match list. */
+                search_attr = search_hl.attr_cur;
+                cur = wp->w_match_head;
+                shl_flag = FALSE;
+                while (cur != NULL || shl_flag == FALSE)
+                {
+                    if (shl_flag == FALSE
+                            && ((cur != NULL
+                                    && cur->priority > SEARCH_HL_PRIORITY)
+                                || cur == NULL))
                     {
-                        search_attr = match_hl[i].attr_cur;
-                        break;
+                        shl = &search_hl;
+                        shl_flag = TRUE;
                     }
+                    else
+                        shl = &cur->hl;
+                    if (shl->attr_cur != 0)
+                        search_attr = shl->attr_cur;
+                    if (shl != &search_hl && cur != NULL)
+                        cur = cur->next;
+                }
             }
 #endif
 
 #ifdef FEAT_DIFF
             if (diff_hlf != (hlf_T)0)
             {
-                if (diff_hlf == HLF_CHD && ptr - line >= change_start)
+                if (diff_hlf == HLF_CHD && ptr - line >= change_start
+                                                              && n_extra == 0)
                     diff_hlf = HLF_TXD;         /* changed text */
-                if (diff_hlf == HLF_TXD && ptr - line > change_end)
+                if (diff_hlf == HLF_TXD && ptr - line > change_end
+                                                              && n_extra == 0)
                     diff_hlf = HLF_CHD;         /* changed line */
                 line_attr = hl_attr(diff_hlf);
             }
@@ -3496 +3549 @@
          * Get the next character to put on the screen.
          */
         /*
-         * The 'extra' array contains the extra stuff that is inserted to
-         * represent special characters (non-printable stuff).  When all
-         * characters are the same, c_extra is used.
+         * The "p_extra" points to the extra stuff that is inserted to
+         * represent special characters (non-printable stuff) and other
+         * things.  When all characters are the same, c_extra is used.
+         * "p_extra" must end in a NUL to avoid mb_ptr2len() reads past
+         * "p_extra[n_extra]".
          * For the '$' of the 'list' option, n_extra == 1, p_extra == "".
          */
         if (n_extra > 0)
@@ -3611 +3666 @@
                          * Draw it as a space with a composing char. */
                         if (utf_iscomposing(mb_c))
                         {
+                            int i;
+
                             for (i = Screen_mco - 1; i > 0; --i)
                                 u8cc[i] = u8cc[i - 1];
                             u8cc[0] = mb_c;
@@ -3752 +3809 @@
                  * a '<' in the first column. */
                 if (n_skip > 0 && mb_l > 1)
                 {
-                    extra[0] = '<';
-                    p_extra = extra;
                     n_extra = 1;
-                    c_extra = NUL;
+                    c_extra = '<';
                     c = ' ';
                     if (area_attr == 0 && search_attr == 0)
                     {
@@ -4254 +4309 @@
              * highlight match at end of line. If it's beyond the last
              * char on the screen, just overwrite that one (tricky!)  Not
              * needed when a '$' was displayed for 'list'. */
+#ifdef FEAT_SEARCH_EXTRA
+            prevcol_hl_flag = FALSE;
+            if (prevcol == (long)search_hl.startcol)
+                prevcol_hl_flag = TRUE;
+            else
+            {
+                cur = wp->w_match_head;
+                while (cur != NULL)
+                {
+                    if (prevcol == (long)cur->hl.startcol)
+                    {
+                        prevcol_hl_flag = TRUE;
+                        break;
+                    }
+                    cur = cur->next;
+                }
+            }
+#endif
             if (lcs_eol == lcs_eol_one
                     && ((area_attr != 0 && vcol == fromcol && c == NUL)
 #ifdef FEAT_SEARCH_EXTRA
                         /* highlight 'hlsearch' match at end of line */
-                        || ((prevcol == (long)search_hl.startcol
-                                || prevcol == (long)match_hl[0].startcol
-                                || prevcol == (long)match_hl[1].startcol
-                                || prevcol == (long)match_hl[2].startcol)
+                        || (prevcol_hl_flag == TRUE
 # if defined(LINE_ATTR)
                             && did_line_attr <= 1
 # endif
@@ -4302 +4372 @@
 #ifdef FEAT_SEARCH_EXTRA
                 if (area_attr == 0)
                 {
-                    for (i = 0; i <= 3; ++i)
-                    {
-                        if (i == 3)
-                            char_attr = search_hl.attr;
-                        else if ((ptr - line) - 1 == (long)match_hl[i].startcol)
+                    /* Use attributes from match with highest priority among
+                     * 'search_hl' and the match list. */
+                    char_attr = search_hl.attr;
+                    cur = wp->w_match_head;
+                    shl_flag = FALSE;
+                    while (cur != NULL || shl_flag == FALSE)
+                    {
+                        if (shl_flag == FALSE
+                                && ((cur != NULL
+                                        && cur->priority > SEARCH_HL_PRIORITY)
+                                    || cur == NULL))
                         {
-                            char_attr = match_hl[i].attr;
-                            break;
+                            shl = &search_hl;
+                            shl_flag = TRUE;
                         }
+                        else
+                            shl = &cur->hl;
+                        if ((ptr - line) - 1 == (long)shl->startcol)
+                            char_attr = shl->attr;
+                        if (shl != &search_hl && cur != NULL)
+                            cur = cur->next;
                     }
                 }
 #endif
@@ -4460 +4542 @@
             {
                 if (mb_utf8)
                 {
+                    int i;
+
                     ScreenLinesUC[off] = mb_c;
                     if ((c & 0xff) == 0)
                         ScreenLines[off] = 0x80;   /* avoid storing zero */
@@ -4548 +4632 @@
 
         /*
          * At end of screen line and there is more to come: Display the line
-         * so far.  If there is no more to display it is catched above.
+         * so far.  If there is no more to display it is caught above.
          */
         if ((
 #ifdef FEAT_RIGHTLEFT
@@ -4625 +4709 @@
 #endif
 #ifdef FEAT_MBYTE
                          && !(has_mbyte
-                             && ((*mb_off2cells)(LineOffset[screen_row]) == 2
+                             && ((*mb_off2cells)(LineOffset[screen_row],
+                                     LineOffset[screen_row] + screen_Columns)
+                                                                          == 2
                                  || (*mb_off2cells)(LineOffset[screen_row - 1]
-                                                        + (int)Columns - 2) == 2))
+                                                        + (int)Columns - 2,
+                                     LineOffset[screen_row] + screen_Columns)
+                                                                        == 2))
 #endif
                    )
                 {
@@ -4787 +4875 @@
 {
     unsigned        off_from;
     unsigned        off_to;
+#ifdef FEAT_MBYTE
+    unsigned        max_off_from;
+    unsigned        max_off_to;
+#endif
     int             col = 0;
 #if defined(FEAT_GUI) || defined(UNIX) || defined(FEAT_VERTSPLIT)
     int             hl;
@@ -4813 +4905 @@
 
     off_from = (unsigned)(current_ScreenLine - ScreenLines);
     off_to = LineOffset[row] + coloff;
+#ifdef FEAT_MBYTE
+    max_off_from = off_from + screen_Columns;
+    max_off_to = LineOffset[row] + screen_Columns;
+#endif
 
 #ifdef FEAT_RIGHTLEFT
     if (rlflag)
@@ -4847 +4943 @@
     {
 #ifdef FEAT_MBYTE
         if (has_mbyte && (col + 1 < endcol))
-            char_cells = (*mb_off2cells)(off_from);
+            char_cells = (*mb_off2cells)(off_from, max_off_from);
         else
             char_cells = 1;
 #endif
@@ -4924 +5020 @@
                  * ScreenLinesUC[] is sufficient. */
                 if (char_cells == 1
                         && col + 1 < endcol
-                        && (*mb_off2cells)(off_to) > 1)
+                        && (*mb_off2cells)(off_to, max_off_to) > 1)
                 {
                     /* Writing a single-cell character over a double-cell
                      * character: need to redraw the next cell. */
@@ -4933 +5029 @@
                 }
                 else if (char_cells == 2
                         && col + 2 < endcol
-                        && (*mb_off2cells)(off_to) == 1
-                        && (*mb_off2cells)(off_to + 1) > 1)
+                        && (*mb_off2cells)(off_to, max_off_to) == 1
+                        && (*mb_off2cells)(off_to + 1, max_off_to) > 1)
                 {
                     /* Writing the second half of a double-cell character over
                      * a double-cell character: need to redraw the second
@@ -4953 +5049 @@
              * char over the left halve of an existing one. */
             if (has_mbyte && col + char_cells == endcol
                     && ((char_cells == 1
-                            && (*mb_off2cells)(off_to) > 1)
+                            && (*mb_off2cells)(off_to, max_off_to) > 1)
                         || (char_cells == 2
-                            && (*mb_off2cells)(off_to) == 1
-                            && (*mb_off2cells)(off_to + 1) > 1)))
+                            && (*mb_off2cells)(off_to, max_off_to) == 1
+                            && (*mb_off2cells)(off_to + 1, max_off_to) > 1)))
                 clear_next = TRUE;
 #endif
 
@@ -5096 +5192 @@
                         /* find previous character by counting from first
                          * column and get its width. */
                         unsigned off = LineOffset[row];
+                        unsigned max_off = LineOffset[row] + screen_Columns;
 
                         while (off < off_to)
                         {
-                            prev_cells = (*mb_off2cells)(off);
+                            prev_cells = (*mb_off2cells)(off, max_off);
                             off += prev_cells;
                         }
                     }
@@ -5285 +5382 @@
 static int skip_status_match_char __ARGS((expand_T *xp, char_u *s));
 
 /*
- * Get the lenght of an item as it will be shown in the status line.
+ * Get the length of an item as it will be shown in the status line.
  */
     static int
 status_match_len(xp, s)
@@ -5351 +5448 @@
     int         row;
     char_u      *buf;
     int         len;
-    int         clen;           /* lenght in screen cells */
+    int         clen;           /* length in screen cells */
     int         fillchar;
     int         attr;
     int         i;
@@ -6103 +6200 @@
     char_u      *ptr = text;
     int         c;
 #ifdef FEAT_MBYTE
+    unsigned    max_off;
     int         mbyte_blen = 1;
     int         mbyte_cells = 1;
     int         u8c = 0;
@@ -6119 +6217 @@
         return;
 
     off = LineOffset[row] + col;
-    while (*ptr != NUL && col < screen_Columns
-                                      && (len < 0 || (int)(ptr - text) < len))
+#ifdef FEAT_MBYTE
+    max_off = LineOffset[row] + screen_Columns;
+#endif
+    while (col < screen_Columns
+            && (len < 0 || (int)(ptr - text) < len)
+            && *ptr != NUL)
     {
         c = *ptr;
 #ifdef FEAT_MBYTE
@@ -6241 +6343 @@
             else if (has_mbyte
                     && (len < 0 ? ptr[mbyte_blen] == NUL
                                              : ptr + mbyte_blen >= text + len)
-                    && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1)
+                    && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1)
                         || (mbyte_cells == 2
-                            && (*mb_off2cells)(off) == 1
-                            && (*mb_off2cells)(off + 1) > 1)))
+                            && (*mb_off2cells)(off, max_off) == 1
+                            && (*mb_off2cells)(off + 1, max_off) > 1)))
                 clear_next_cell = TRUE;
 
             /* Make sure we never leave a second byte of a double-byte behind,
              * it confuses mb_off2cells(). */
             if (enc_dbcs
-                    && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1)
+                    && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1)
                         || (mbyte_cells == 2
-                            && (*mb_off2cells)(off) == 1
-                            && (*mb_off2cells)(off + 1) > 1)))
+                            && (*mb_off2cells)(off, max_off) == 1
+                            && (*mb_off2cells)(off + 1, max_off) > 1)))
                 ScreenLines[off + mbyte_blen] = 0;
 #endif
             ScreenLines[off] = c;
@@ -6318 +6420 @@
 
 #ifdef FEAT_SEARCH_EXTRA
 /*
- * Prepare for 'searchhl' highlighting.
+ * Prepare for 'hlsearch' highlighting.
  */
     static void
 start_search_hl()
@@ -6331 +6433 @@
 }
 
 /*
- * Clean up for 'searchhl' highlighting.
+ * Clean up for 'hlsearch' highlighting.
  */
     static void
 end_search_hl()
@@ -6351 +6453 @@
     win_T       *wp;
     linenr_T    lnum;
 {
-    match_T     *shl;           /* points to search_hl or match_hl */
+    matchitem_T *cur;           /* points to the match list */
+    match_T     *shl;           /* points to search_hl or a match */
+    int         shl_flag;       /* flag to indicate whether search_hl
+                                   has been processed or not */
     int         n;
-    int         i;
 
     /*
      * When using a multi-line pattern, start searching at the top
      * of the window or just after a closed fold.
-     * Do this both for search_hl and match_hl[3].
+     * Do this both for search_hl and the match list.
      */
-    for (i = 3; i >= 0; --i)
+    cur = wp->w_match_head;
+    shl_flag = FALSE;
+    while (cur != NULL || shl_flag == FALSE)
     {
-        shl = (i == 3) ? &search_hl : &match_hl[i];
+        if (shl_flag == FALSE)
+        {
+            shl = &search_hl;
+            shl_flag = TRUE;
+        }
+        else
+            shl = &cur->hl;
         if (shl->rm.regprog != NULL
                 && shl->lnum == 0
                 && re_multiline(shl->rm.regprog))
@@ -6397 +6509 @@
                 }
             }
         }
+        if (shl != &search_hl && cur != NULL)
+            cur = cur->next;
     }
 }
 
 /*
- * Search for a next 'searchl' or ":match" match.
+ * Search for a next 'hlsearch' or match.
  * Uses shl->buf.
  * Sets shl->lnum and shl->rm contents.
  * Note: Assumes a previous match is always before "lnum", unless
@@ -6411 +6525 @@
     static void
 next_search_hl(win, shl, lnum, mincol)
     win_T       *win;
-    match_T     *shl;           /* points to search_hl or match_hl */
+    match_T     *shl;           /* points to search_hl or a match */
     linenr_T    lnum;
     colnr_T     mincol;         /* minimal column for a match */
 {
@@ -6479 +6593 @@
             /* Error while handling regexp: stop using this regexp. */
             if (shl == &search_hl)
             {
-                /* don't free the regprog in match_hl[], it's a copy */
+                /* don't free regprog in the match list, it's a copy */
                 vim_free(shl->rm.regprog);
                 no_hlsearch = TRUE;
             }
@@ -6827 +6941 @@
 {
     int         r, c;
     int         off;
+#ifdef FEAT_MBYTE
+    int         max_off;
+#endif
 
     /* Can't use ScreenLines unless initialized */
     if (ScreenLines == NULL)
@@ -6837 +6954 @@
     for (r = row; r < row + height; ++r)
     {
         off = LineOffset[r];
+#ifdef FEAT_MBYTE
+        max_off = off + screen_Columns;
+#endif
         for (c = col; c < col + width; ++c)
         {
 #ifdef FEAT_MBYTE
-            if (enc_dbcs != 0 && dbcs_off2cells(off + c) > 1)
+            if (enc_dbcs != 0 && dbcs_off2cells(off + c, max_off) > 1)
             {
                 screen_char_2(off + c, r, c);
                 ++c;
@@ -6850 +6970 @@
             {
                 screen_char(off + c, r, c);
 #ifdef FEAT_MBYTE
-                if (utf_off2cells(off + c) > 1)
+                if (utf_off2cells(off + c, max_off) > 1)
                     ++c;
 #endif
             }

src/search.c

@@ -101 +101 @@
 static char_u       *mr_pattern = NULL; /* pattern used by search_regcomp() */
 #ifdef FEAT_RIGHTLEFT
 static int          mr_pattern_alloced = FALSE; /* mr_pattern was allocated */
-static char_u       *reverse_text __ARGS((char_u *s));
 #endif
 
 #ifdef FEAT_FIND_ID
@@ -228 +227 @@
     return mr_pattern;
 }
 
-#ifdef FEAT_RIGHTLEFT
+#if defined(FEAT_RIGHTLEFT) || defined(PROTO)
 /*
  * Reverse text into allocated memory.
  * Returns the allocated string, NULL when out of memory.
  */
-    static char_u *
+    char_u *
 reverse_text(s)
     char_u *s;
 {
@@ -573 +572 @@
         /*
          * Start searching in current line, unless searching backwards and
          * we're in column 0.
+         * If we are searching backwards, in column 0, and not including the
+         * current position, gain some efficiency by skipping back a line.
+         * Otherwise begin the search in the current line.
          */
-        if (dir == BACKWARD && start_pos.col == 0)
+        if (dir == BACKWARD && start_pos.col == 0
+                                             && (options & SEARCH_START) == 0)
         {
             lnum = pos->lnum - 1;
             at_first_line = FALSE;
@@ -1894 +1897 @@
     }
 
 #ifdef FEAT_RIGHTLEFT
-    /* This is just guessing: when 'rightleft' is set, search for a maching
+    /* This is just guessing: when 'rightleft' is set, search for a matching
      * paren/brace in the other direction. */
     if (curwin->w_p_rl && vim_strchr((char_u *)"()[]{}<>", initc) != NULL)
         backwards = !backwards;
@@ -2124 +2127 @@
                         else if (!backwards)
                             inquote = TRUE;
                     }
+
+                    /* ml_get() only keeps one line, need to get linep again */
+                    linep = ml_get(pos.lnum);
                 }
             }
         }
@@ -2795 +2801 @@
         i = inc_cursor();
         if (i == -1 || (i >= 1 && last_line)) /* started at last char in file */
             return FAIL;
-        if (i == 1 && eol && count == 0)      /* started at last char in line */
+        if (i >= 1 && eol && count == 0)      /* started at last char in line */
             return OK;
 
         /*
@@ -3600 +3606 @@
     {
         oap->start = start_pos;
         oap->motion_type = MCHAR;
+        oap->inclusive = FALSE;
         if (sol)
-        {
             incl(&curwin->w_cursor);
-            oap->inclusive = FALSE;
-        }
-        else
+        else if (lt(start_pos, curwin->w_cursor))
+            /* Include the character under the cursor. */
             oap->inclusive = TRUE;
+        else
+            /* End is before the start (no text in between <>, [], etc.): don't
+             * operate on any text. */
+            curwin->w_cursor = start_pos;
     }
 
     return OK;
@@ -3734 +3743 @@
 
         if (in_html_tag(FALSE))
         {
-            /* cursor on start tag, move to just after it */
+            /* cursor on start tag, move to its '>' */
             while (*ml_get_cursor() != '>')
                 if (inc_cursor() < 0)
                     break;
@@ -3838 +3847 @@
         /* Exclude the start tag. */
         curwin->w_cursor = start_pos;
         while (inc_cursor() >= 0)
-            if (*ml_get_cursor() == '>' && lt(curwin->w_cursor, end_pos))
+            if (*ml_get_cursor() == '>')
             {
                 inc_cursor();
                 start_pos = curwin->w_cursor;
@@ -3860 +3869 @@
 #ifdef FEAT_VISUAL
     if (VIsual_active)
     {
-        if (*p_sel == 'e')
+        /* If the end is before the start there is no text between tags, select
+         * the char under the cursor. */
+        if (lt(end_pos, start_pos))
+            curwin->w_cursor = start_pos;
+        else if (*p_sel == 'e')
             ++curwin->w_cursor.col;
         VIsual = start_pos;
         VIsual_mode = 'v';
@@ -3872 +3885 @@
     {
         oap->start = start_pos;
         oap->motion_type = MCHAR;
-        oap->inclusive = TRUE;
+        if (lt(end_pos, start_pos))
+        {
+            /* End is before the start: there is no text between tags; operate
+             * on an empty area. */
+            curwin->w_cursor = start_pos;
+            oap->inclusive = FALSE;
+        }
+        else
+            oap->inclusive = TRUE;
     }
     retval = OK;
 

src/spell.c

@@ -7829 +7829 @@
 # if (_MSC_VER <= 1200)
 /* This line is required for VC6 without the service pack.  Also see the
  * matching #pragma below. */
-/* # pragma optimize("", off) */
+ #  pragma optimize("", off)
 # endif
 #endif
 
@@ -7859 +7859 @@
 
 #ifdef _MSC_VER
 # if (_MSC_VER <= 1200)
-/* # pragma optimize("", on) */
+ #  pragma optimize("", on)
 # endif
 #endif
 
@@ -12182 +12182 @@
             {
                 n = mb_cptr2len(p);
                 c = mb_ptr2char(p);
-                if (!soundfold && !spell_iswordp(p + n, curbuf))
+                if (p[n] == NUL)
+                    c2 = NUL;
+                else if (!soundfold && !spell_iswordp(p + n, curbuf))
                     c2 = c; /* don't swap non-word char */
                 else
                     c2 = mb_ptr2char(p + n);
@@ -12190 +12192 @@
             else
 #endif
             {
-                if (!soundfold && !spell_iswordp(p + 1, curbuf))
+                if (p[1] == NUL)
+                    c2 = NUL;
+                else if (!soundfold && !spell_iswordp(p + 1, curbuf))
                     c2 = c; /* don't swap non-word char */
                 else
                     c2 = p[1];
             }
 
+            /* When the second character is NUL we can't swap. */
+            if (c2 == NUL)
+            {
+                sp->ts_state = STATE_REP_INI;
+                break;
+            }
+
             /* When characters are identical, swap won't do anything.
              * Also get here if the second char is not a word character. */
             if (c == c2)

src/structs.h

@@ -1453 +1453 @@
 #ifdef FEAT_MBYTE
     char_u      *b_start_fenc;  /* 'fileencoding' when edit started or NULL */
     int         b_bad_char;     /* "++bad=" argument when edit started or 0 */
+    int         b_start_bomb;   /* 'bomb' when it was read */
 #endif
 
 #ifdef FEAT_EVAL
@@ -1694 +1695 @@
 #define FR_COL  2       /* frame with a column of windows */
 
 /*
+ * Struct used for highlighting 'hlsearch' matches, matches defined by
+ * ":match" and matches defined by match functions.
+ * For 'hlsearch' there is one pattern for all windows.  For ":match" and the
+ * match functions there is a different pattern for each window.
+ */
+typedef struct
+{
+    regmmatch_T rm;     /* points to the regexp program; contains last found
+                           match (may continue in next line) */
+    buf_T       *buf;   /* the buffer to search for a match */
+    linenr_T    lnum;   /* the line to search for a match */
+    int         attr;   /* attributes to be used for a match */
+    int         attr_cur; /* attributes currently active in win_line() */
+    linenr_T    first_lnum;     /* first lnum to search for multi-line pat */
+    colnr_T     startcol; /* in win_line() points to char where HL starts */
+    colnr_T     endcol;  /* in win_line() points to char where HL ends */
+} match_T;
+
+/*
+ * matchitem_T provides a linked list for storing match items for ":match" and
+ * the match functions.
+ */
+typedef struct matchitem matchitem_T;
+struct matchitem
+{
+    matchitem_T *next;
+    int         id;         /* match ID */
+    int         priority;   /* match priority */
+    char_u      *pattern;   /* pattern to highlight */
+    int         hlg_id;     /* highlight group ID */
+    regmmatch_T match;      /* regexp program for pattern */
+    match_T     hl;         /* struct for doing the actual highlighting */
+};
+
+/*
  * Structure which contains all information that belongs to a window
  *
  * All row numbers are relative to the start of the window, except w_winrow.
@@ -1934 +1970 @@
 #endif
 
 #ifdef FEAT_SEARCH_EXTRA
-    regmmatch_T w_match[3];         /* regexp programs for ":match" */
-    char_u      *(w_match_pat[3]);  /* patterns for ":match" */
-    int         w_match_id[3];      /* highlight IDs for ":match" */
+    matchitem_T *w_match_head;          /* head of match list */
+    int         w_next_match_id;        /* next match ID */
 #endif
 
     /*

src/syntax.c

@@ -66 +66 @@
 #define HL_TABLE() ((struct hl_group *)((highlight_ga.ga_data)))
 
 #ifdef FEAT_CMDL_COMPL
-static int include_default = FALSE;     /* include "default" for expansion */
-static int include_link = FALSE;        /* include "link" for expansion */
+/* Flags to indicate an additional string for highlight name completion. */
+static int include_none = 0;    /* when 1 include "None" */
+static int include_default = 0; /* when 1 include "default" */
+static int include_link = 0;    /* when 2 include "link" and "clear" */
 #endif
 
 /*
@@ -277 +279 @@
  */
 typedef struct state_item
 {
-    int         si_idx;                 /* index of syntax pattern */
+    int         si_idx;                 /* index of syntax pattern or
+                                           KEYWORD_IDX */
     int         si_id;                  /* highlight group ID for keywords */
     int         si_trans_id;            /* idem, transparancy removed */
     int         si_m_lnum;              /* lnum of the match */
@@ -835 +838 @@
                             current_lnum = end_lnum;
                             break;
                         }
-                        spp = &(SYN_ITEMS(syn_buf)[cur_si->si_idx]);
-                        found_flags = spp->sp_flags;
-                        found_match_idx = spp->sp_sync_idx;
+                        if (cur_si->si_idx < 0)
+                        {
+                            /* Cannot happen? */
+                            found_flags = 0;
+                            found_match_idx = KEYWORD_IDX;
+                        }
+                        else
+                        {
+                            spp = &(SYN_ITEMS(syn_buf)[cur_si->si_idx]);
+                            found_flags = spp->sp_flags;
+                            found_match_idx = spp->sp_sync_idx;
+                        }
                         found_current_lnum = current_lnum;
                         found_current_col = current_col;
                         found_m_endpos = cur_si->si_m_endpos;
@@ -1725 +1737 @@
 {
     int     attr = 0;
 
+    if (can_spell != NULL)
+        /* Default: Only do spelling when there is no @Spell cluster or when
+         * ":syn spell toplevel" was used. */
+        *can_spell = syn_buf->b_syn_spell == SYNSPL_DEFAULT
+                    ? (syn_buf->b_spell_cluster_id == 0)
+                    : (syn_buf->b_syn_spell == SYNSPL_TOP);
+
     /* check for out of memory situation */
     if (syn_buf->b_sst_array == NULL)
         return 0;
@@ -2524 +2543 @@
     stateitem_T *sip = &CUR_STATE(idx);
     synpat_T    *spp;
 
+    /* This should not happen... */
+    if (sip->si_idx < 0)
+        return;
+
     spp = &(SYN_ITEMS(syn_buf)[sip->si_idx]);
     if (sip->si_flags & HL_MATCH)
         sip->si_id = spp->sp_syn_match_id;
@@ -2639 +2662 @@
     lpos_T      end_endpos;
     int         end_idx;
 
+    /* return quickly for a keyword */
+    if (sip->si_idx < 0)
+        return;
+
     /* Don't update when it's already done.  Can be a match of an end pattern
      * that started in a previous line.  Watch out: can also be a "keepend"
      * from a containing item. */
@@ -2751 +2778 @@
     char_u      *line;
     int         had_match = FALSE;
 
+    /* just in case we are invoked for a keyword */
+    if (idx < 0)
+        return;
+
     /*
      * Check for being called with a START pattern.
      * Can happen with a match that continues to the next line, because it
@@ -4460 +4491 @@
     current_syn_inc_tag = ++running_syn_inc_tag;
     prev_toplvl_grp = curbuf->b_syn_topgrp;
     curbuf->b_syn_topgrp = sgl_id;
-    if (source ? do_source(eap->arg, FALSE, FALSE) == FAIL
-                                : source_runtime(eap->arg, DOSO_NONE) == FAIL)
+    if (source ? do_source(eap->arg, FALSE, DOSO_NONE) == FAIL
+                                : source_runtime(eap->arg, TRUE) == FAIL)
         EMSG2(_(e_notopen), eap->arg);
     curbuf->b_syn_topgrp = prev_toplvl_grp;
     current_syn_inc_tag = prev_syn_inc_tag;
@@ -5956 +5987 @@
 {
     return (buf->b_syn_patterns.ga_len != 0
             || buf->b_syn_clusters.ga_len != 0
-            || curbuf->b_keywtab.ht_used > 0
-            || curbuf->b_keywtab_ic.ht_used > 0);
+            || buf->b_keywtab.ht_used > 0
+            || buf->b_keywtab_ic.ht_used > 0);
 }
 
 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
@@ -5968 +5999 @@
     EXP_CASE        /* expand ":syn case" arguments */
 } expand_what;
 
+/*
+ * Reset include_link, include_default, include_none to 0.
+ * Called when we are done expanding.
+ */
+    void
+reset_expand_highlight()
+{
+    include_link = include_default = include_none = 0;
+}
+
+/*
+ * Handle command line completion for :match and :echohl command: Add "None"
+ * as highlight group.
+ */
+    void
+set_context_in_echohl_cmd(xp, arg)
+    expand_T    *xp;
+    char_u      *arg;
+{
+    xp->xp_context = EXPAND_HIGHLIGHT;
+    xp->xp_pattern = arg;
+    include_none = 1;
+}
 
 /*
  * Handle command line completion for :syntax command.
@@ -5983 +6037 @@
     xp->xp_context = EXPAND_SYNTAX;
     expand_what = EXP_SUBCMD;
     xp->xp_pattern = arg;
-    include_link = FALSE;
-    include_default = FALSE;
+    include_link = 0;
+    include_default = 0;
 
     /* (part of) subcommand already typed */
     if (*arg != NUL)
@@ -8479 +8533 @@
 syn_id2name(id)
     int         id;
 {
-    if (id <= 0 || id >= highlight_ga.ga_len)
+    if (id <= 0 || id > highlight_ga.ga_len)
         return (char_u *)"";
     return HL_TABLE()[id - 1].sg_name;
 }
@@ -8949 +9003 @@
     return OK;
 }
 
-#ifdef FEAT_CMDL_COMPL
+#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
 
 static void highlight_list __ARGS((void));
 static void highlight_list_two __ARGS((int cnt, int attr));
@@ -8967 +9021 @@
     /* Default: expand group names */
     xp->xp_context = EXPAND_HIGHLIGHT;
     xp->xp_pattern = arg;
-    include_link = TRUE;
-    include_default = TRUE;
+    include_link = 2;
+    include_default = 1;
 
     /* (part of) subcommand already typed */
     if (*arg != NUL)
@@ -8976 +9030 @@
         p = skiptowhite(arg);
         if (*p != NUL)                  /* past "default" or group name */
         {
-            include_default = FALSE;
+            include_default = 0;
             if (STRNCMP("default", arg, p - arg) == 0)
             {
                 arg = skipwhite(p);
@@ -8985 +9039 @@
             }
             if (*p != NUL)                      /* past group name */
             {
-                include_link = FALSE;
+                include_link = 0;
                 if (arg[1] == 'i' && arg[0] == 'N')
                     highlight_list();
                 if (STRNCMP("link", arg, p - arg) == 0
@@ -9045 +9099 @@
     expand_T    *xp;
     int         idx;
 {
-    if (idx == highlight_ga.ga_len
 #ifdef FEAT_CMDL_COMPL
-            && include_link
-#endif
-            )
+    if (idx == highlight_ga.ga_len && include_none != 0)
+        return (char_u *)"none";
+    if (idx == highlight_ga.ga_len + include_none && include_default != 0)
+        return (char_u *)"default";
+    if (idx == highlight_ga.ga_len + include_none + include_default
+                                                         && include_link != 0)
         return (char_u *)"link";
-    if (idx == highlight_ga.ga_len + 1
-#ifdef FEAT_CMDL_COMPL
-            && include_link
-#endif
-            )
+    if (idx == highlight_ga.ga_len + include_none + include_default + 1
+                                                         && include_link != 0)
         return (char_u *)"clear";
-    if (idx == highlight_ga.ga_len + 2
-#ifdef FEAT_CMDL_COMPL
-            && include_default
 #endif
-            )
-        return (char_u *)"default";
     if (idx < 0 || idx >= highlight_ga.ga_len)
         return NULL;
     return HL_TABLE()[idx].sg_name;
 }
 #endif
 
-#ifdef FEAT_GUI
+#if defined(FEAT_GUI) || defined(PROTO)
 /*
  * Free all the highlight group fonts.
  * Used when quitting for systems which need it.

src/termlib.c

@@ -191 +191 @@
             lbuf[0] == '\t' &&
             lbuf[1] == ':')
         {
-            strcpy(lbuf, lbuf+2);
+            mch_memmove(lbuf, lbuf + 2, strlen(lbuf + 2) + 1);
             llen -= 2;
         }
         if (lbuf[llen-2] == '\\')               /* and continuations */

src/testdir/Makefile

@@ -1 +1 @@
 #
-# Makefile to run al tests for Vim
+# Makefile to run all tests for Vim
 #
 
 VIMPROG = ../vim
 
+# Uncomment this line for using valgrind.
+# The output goes into a file "valgrind.$PID" (sorry, no test number).
+# VALGRIND = valgrind --tool=memcheck --num-callers=15 --logfile=valgrind
+
 SCRIPTS = test1.out test2.out test3.out test4.out test5.out test6.out \
                 test7.out test8.out test9.out test10.out test11.out \
                 test12.out  test13.out test14.out test15.out test17.out \
@@ -15 +19 @@
                 test43.out test44.out test45.out test46.out test47.out \
                 test48.out test49.out test51.out test52.out test53.out \
                 test54.out test55.out test56.out test57.out test58.out \
-                test59.out test60.out test61.out test62.out
+                test59.out test60.out test61.out test62.out test63.out \
+                test64.out
 
 SCRIPTS_GUI = test16.out
 
@@ -38 +43 @@
 
 test1.out: test1.in
         -rm -f $*.failed tiny.vim small.vim mbyte.vim test.ok X* viminfo
-        $(VIMPROG) -u unix.vim -U NONE --noplugin -s dotest.in $*.in
+        $(VALGRIND) $(VIMPROG) -u unix.vim -U NONE --noplugin -s dotest.in $*.in
         @/bin/sh -c "if diff test.out $*.ok; \
                 then mv -f test.out $*.out; \
                 else echo; \
@@ -51 +56 @@
         cp $*.ok test.ok
         # Sleep a moment to avoid that the xterm title is messed up
         @-sleep .2
-        -$(VIMPROG) -u unix.vim -U NONE --noplugin -s dotest.in $*.in
+        -$(VALGRIND) $(VIMPROG) -u unix.vim -U NONE --noplugin -s dotest.in $*.in
         @/bin/sh -c "if test -f test.out; then\
                   if diff test.out $*.ok; \
                   then mv -f test.out $*.out; \

src/testdir/test63.in

@@ +1 @@
+Test for ":match", ":2match", ":3match", "clearmatches()", "getmatches()",
+"matchadd()", "matcharg()", "matchdelete()", and "setmatches()".
+
+STARTTEST
+:so small.vim
+:" --- Check that "matcharg()" returns the correct group and pattern if a match
+:" --- is defined.
+:let @r = "*** Test 1: "
+:highlight MyGroup1 ctermbg=red
+:highlight MyGroup2 ctermbg=green
+:highlight MyGroup3 ctermbg=blue
+:match MyGroup1 /TODO/
+:2match MyGroup2 /FIXME/
+:3match MyGroup3 /XXX/
+:if matcharg(1) == ['MyGroup1', 'TODO'] && matcharg(2) == ['MyGroup2', 'FIXME'] && matcharg(3) == ['MyGroup3', 'XXX']
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:" --- Check that "matcharg()" returns an empty list if the argument is not 1,
+:" --- 2 or 3 (only 0 and 4 are tested).
+:let @r .= "*** Test 2: "
+:if matcharg(0) == [] && matcharg(4) == []
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:" --- Check that "matcharg()" returns ['', ''] if a match is not defined.
+:let @r .= "*** Test 3: "
+:match
+:2match
+:3match
+:if matcharg(1) == ['', ''] && matcharg(2) == ['', ''] && matcharg(3) == ['', '']
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:" --- Check that "matchadd()" and "getmatches()" agree on added matches and
+:" --- that default values apply.
+:let @r .= "*** Test 4: "
+:let m1 = matchadd("MyGroup1", "TODO")
+:let m2 = matchadd("MyGroup2", "FIXME", 42)
+:let m3 = matchadd("MyGroup3", "XXX", 60, 17)
+:if getmatches() == [{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 4}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 42, 'id': 5}, {'group': 'MyGroup3', 'pattern': 'XXX', 'priority': 60, 'id': 17}]
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:" --- Check that "matchdelete()" deletes the matches defined in the previous
+:" --- test correctly.
+:let @r .= "*** Test 5: "
+:call matchdelete(m1)
+:call matchdelete(m2)
+:call matchdelete(m3)
+:unlet m1
+:unlet m2
+:unlet m3
+:if getmatches() == []
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:" --- Check that "matchdelete()" returns 0 if succesfull and otherwise -1.
+:let @r .= "*** Test 6: "
+:let m = matchadd("MyGroup1", "TODO")
+:let r1 = matchdelete(m)
+:let r2 = matchdelete(42)
+:if r1 == 0 && r2 == -1
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:unlet m
+:unlet r1
+:unlet r2
+:" --- Check that "clearmatches()" clears all matches defined by ":match" and
+:" --- "matchadd()".
+:let @r .= "*** Test 7: "
+:let m1 = matchadd("MyGroup1", "TODO")
+:let m2 = matchadd("MyGroup2", "FIXME", 42)
+:let m3 = matchadd("MyGroup3", "XXX", 60, 17)
+:match MyGroup1 /COFFEE/
+:2match MyGroup2 /HUMPPA/
+:3match MyGroup3 /VIM/
+:call clearmatches()
+:if getmatches() == []
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:unlet m1
+:unlet m2
+:unlet m3
+:" --- Check that "setmatches()" restores a list of matches saved by
+:" --- "getmatches()" without changes. (Matches with equal priority must also
+:" --- remain in the same order.)
+:let @r .= "*** Test 8: "
+:let m1 = matchadd("MyGroup1", "TODO")
+:let m2 = matchadd("MyGroup2", "FIXME", 42)
+:let m3 = matchadd("MyGroup3", "XXX", 60, 17)
+:match MyGroup1 /COFFEE/
+:2match MyGroup2 /HUMPPA/
+:3match MyGroup3 /VIM/
+:let ml = getmatches()
+:call clearmatches()
+:call setmatches(ml)
+:if getmatches() == ml
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:call clearmatches()
+:unlet m1
+:unlet m2
+:unlet m3
+:unlet ml
+:" --- Check that "setmatches()" will not add two matches with the same ID. The
+:" --- expected behaviour (for now) is to add the first match but not the
+:" --- second and to return 0 (even though it is a matter of debate whether
+:" --- this can be considered succesfull behaviour).
+:let @r .= "*** Test 9: "
+:let r1 = setmatches([{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 10, 'id': 1}])
+:if getmatches() == [{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}] && r1 == 0
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:call clearmatches()
+:unlet r1
+:" --- Check that "setmatches()" returns 0 if succesfull and otherwise -1.
+:" --- (A range of valid and invalid input values are tried out to generate the
+:" --- return values.)
+:let @r .= "*** Test 10: "
+:let rs1 = setmatches([])
+:let rs2 = setmatches([{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}])
+:call clearmatches()
+:let rf1 = setmatches(0)
+:let rf2 = setmatches([0])
+:let rf3 = setmatches([{'wrong key': 'wrong value'}])
+:if rs1 == 0 && rs2 == 0 && rf1 == -1 && rf2 == -1 && rf3 == -1
+:  let @r .= "OK\n"
+:else
+:  let @r .= "FAILED\n"
+:endif
+:unlet rs1
+:unlet rs2
+:unlet rf1
+:unlet rf2
+:unlet rf3
+:highlight clear MyGroup1
+:highlight clear MyGroup2
+:highlight clear MyGroup3
+G"rp
+:/^Results/,$wq! test.out
+ENDTEST
+
+Results of test63:

src/testdir/test63.ok

@@ +1 @@
+Results of test63:
+*** Test 1: OK
+*** Test 2: OK
+*** Test 3: OK
+*** Test 4: OK
+*** Test 5: OK
+*** Test 6: OK
+*** Test 7: OK
+*** Test 8: OK
+*** Test 9: OK
+*** Test 10: OK

src/testdir/test64.in

@@ +1 @@
+Test for regexp patterns.
+
+A pattern that gives the expected result produces OK, so that we know it was
+actually tried.
+
+STARTTEST
+:so small.vim
+:" tl is a List of Lists with:
+:"    regexp pattern
+:"    text to test the pattern on
+:"    expected match (optional)
+:"    expected submatch 1 (optional)
+:"    expected submatch 2 (optional)
+:"    etc.
+:"  When there is no match use only the first two items.
+:let tl = []
+:call add(tl, ['b', 'abcdef', 'b'])
+:call add(tl, ['bc*', 'abccccdef', 'bcccc'])
+:call add(tl, ['bc\{-}', 'abccccdef', 'b'])
+:call add(tl, ['bc\{-}\(d\)', 'abccccdef', 'bccccd', 'd'])
+:call add(tl, ['x', 'abcdef'])
+:"
+:for t in tl
+:  let l = matchlist(t[1], t[0])
+:" check the match itself
+:  if len(l) == 0 && len(t) > 2
+:    $put ='ERROR: pat: \"' . t[0] . '\", text: \"' . t[1] . '\", did not match, expected: \"' . t[2] . '\"'
+:  elseif len(l) > 0 && len(t) == 2
+:    $put ='ERROR: pat: \"' . t[0] . '\", text: \"' . t[1] . '\", match: \"' . l[0] . '\", expected no match'
+:  elseif len(t) > 2 && l[0] != t[2]
+:    $put ='ERROR: pat: \"' . t[0] . '\", text: \"' . t[1] . '\", match: \"' . l[0] . '\", expected: \"' . t[2] . '\"'
+:  else
+:    $put ='OK'
+:  endif
+:  if len(l) > 0
+:"   check all the nine submatches
+:    for i in range(1, 9)
+:      if len(t) <= i + 2
+:        let e = ''
+:      else
+:        let e = t[i + 2]
+:      endif
+:      if l[i] != e
+:        $put ='ERROR: pat: \"' . t[0] . '\", text: \"' . t[1] . '\", submatch ' . i . ': \"' . l[i] . '\", expected: \"' . e . '\"'
+:      endif
+:    endfor
+:  endif
+:endfor
+:/^Results/,$wq! test.out
+ENDTEST
+
+Results of test64:

src/testdir/test64.ok

@@ +1 @@
+Results of test64:
+OK
+OK
+OK
+OK
+OK

src/ui.c

@@ -1603 +1603 @@
 #if defined(FEAT_GUI) || defined(FEAT_MOUSE_GPM) \
         || defined(FEAT_XCLIPBOARD) || defined(VMS) \
         || defined(FEAT_SNIFF) || defined(FEAT_CLIENTSERVER) \
-        || (defined(FEAT_GUI) && (!defined(USE_ON_FLY_SCROLL) \
-                || defined(FEAT_MENU))) \
         || defined(PROTO)
 /*
  * Add the given bytes to the input buffer
@@ -1630 +1628 @@
 }
 #endif
 
-#if (defined(FEAT_XIM) && defined(FEAT_GUI_GTK)) \
+#if ((defined(FEAT_XIM) || defined(FEAT_DND)) && defined(FEAT_GUI_GTK)) \
+        || defined(FEAT_GUI_MSWIN) \
+        || defined(FEAT_GUI_MAC) \
         || (defined(FEAT_MBYTE) && defined(FEAT_MBYTE_IME)) \
         || (defined(FEAT_GUI) && (!defined(USE_ON_FLY_SCROLL) \
                 || defined(FEAT_MENU))) \

src/version.c

@@ -667 +667 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    94,
+/**/
+    93,
+/**/
+    90,
+/**/
+    89,
+/**/
+    87,
+/**/
+    86,
+/**/
+    85,
+/**/
+    84,
+/**/
+    83,
+/**/
+    82,
+/**/
+    81,
+/**/
+    79,
+/**/
+    78,
+/**/
+    77,
+/**/
+    76,
+/**/
+    75,
+/**/
+    74,
+/**/
+    73,
+/**/
+    71,
+/**/
+    69,
+/**/
+    68,
+/**/
+    67,
+/**/
+    66,
+/**/
+    64,
+/**/
+    63,
+/**/
+    62,
+/**/
+    61,
+/**/
+    60,
+/**/
+    59,
+/**/
+    58,
+/**/
+    57,
+/**/
+    56,
+/**/
+    55,
+/**/
+    54,
+/**/
+    53,
+/**/
+    52,
+/**/
+    51,
+/**/
+    50,
+/**/
+    49,
+/**/
+    48,
+/**/
+    47,
+/**/
+    46,
+/**/
+    45,
+/**/
+    44,
+/**/
+    43,
+/**/
+    42,
+/**/
+    40,
+/**/
+    39,
+/**/
+    38,
+/**/
+    37,
+/**/
+    36,
+/**/
+    35,
+/**/
+    34,
+/**/
+    33,
+/**/
+    32,
+/**/
+    31,
+/**/
+    30,
+/**/
+    29,
+/**/
+    28,
+/**/
+    27,
+/**/
+    26,
+/**/
+    25,
+/**/
+    24,
+/**/
+    23,
+/**/
+    22,
+/**/
+    21,
+/**/
+    20,
+/**/
+    19,
+/**/
+    18,
+/**/
+    17,
+/**/
+    16,
+/**/
+    15,
+/**/
+    14,
+/**/
+    13,
+/**/
+    12,
+/**/
+    11,
+/**/
+    10,
+/**/
+    9,
+/**/
+    8,
+/**/
+    6,
+/**/
+    5,
+/**/
+    4,
+/**/
+    2,
+/**/
+    1,
+/**/
     0
 };
 

src/vim.h

@@ -1380 +1380 @@
 #endif
 
 #ifdef FEAT_MBYTE
-# define MB_STRICMP(d, s)       (has_mbyte ? mb_strnicmp((char_u *)(d), (char_u *)(s), (int)MAXCOL) : STRICMP((d), (s)))
-# define MB_STRNICMP(d, s, n)   (has_mbyte ? mb_strnicmp((char_u *)(d), (char_u *)(s), (int)(n)) : STRNICMP((d), (s), (n)))
+/* We need to call mb_stricmp() even when we aren't dealing with a multi-byte
+ * encoding because mb_stricmp() takes care of all ascii and non-ascii
+ * encodings, including characters with umluats in latin1, etc., while
+ * STRICMP() only handles the system locale version, which often does not
+ * handle non-ascii properly. */
+
+# define MB_STRICMP(d, s)       mb_strnicmp((char_u *)(d), (char_u *)(s), (int)MAXCOL)
+# define MB_STRNICMP(d, s, n)   mb_strnicmp((char_u *)(d), (char_u *)(s), (int)(n))
 #else
 # define MB_STRICMP(d, s)       STRICMP((d), (s))
 # define MB_STRNICMP(d, s, n)   STRNICMP((d), (s), (n))

src/vimtutor

@@ -39 +39 @@
 # remove the copy of the tutor on exit
 trap "rm -rf $TODELETE" 0 1 2 3 9 11 13 15
 
-# Vim could be called "vim" or "vi".  Also check for "vim6", for people who
-# have Vim 5.x installed as "vim" and Vim 6.0 as "vim6".
-testvim=`which vim6 2>/dev/null`
-if test -f "$testvim"; then
-        VIM=vim6
-else
-        testvim=`which vim`
+# Vim could be called "vim" or "vi".  Also check for "vimN", for people who
+# have Vim installed with its version number.
+# We anticipate up to a future Vim 8 version :-).
+seq="vim vim8 vim75 vim74 vim73 vim72 vim71 vim70 vim7 vim6 vi"
+for i in $seq; do
+        testvim=`which $i 2>/dev/null`
         if test -f "$testvim"; then
-                VIM=vim
-        else
-                VIM=vi
+                VIM=$i
+                break
         fi
+done
+
+# When no Vim version was found fall back to "vim", you'll get an error message
+# below.
+if test -z "$VIM"; then
+        VIM=vim
 fi
 
 # Use Vim to copy the tutor, it knows the value of $VIMRUNTIME

src/window.c

@@ -75 +75 @@
 static win_T *restore_snapshot_rec __ARGS((frame_T *sn, frame_T *fr));
 
 #endif /* FEAT_WINDOWS */
+
 static win_T *win_alloc __ARGS((win_T *after));
 static void win_new_height __ARGS((win_T *, int));
 
@@ -732 +733 @@
     if (flags & WSP_VERT)
     {
         layout = FR_ROW;
-        do_equal = (p_ea && new_size == 0 && *p_ead != 'v');
 
         /*
          * Check if we are able to split the current window and compute its
@@ -769 +769 @@
          * instead, if possible. */
         if (oldwin->w_p_wfw)
             win_setwidth_win(oldwin->w_width + new_size, oldwin);
+
+        /* Only make all windows the same width if one of them (except oldwin)
+         * is wider than one of the split windows. */
+        if (!do_equal && p_ea && size == 0 && *p_ead != 'v'
+           && oldwin->w_frame->fr_parent != NULL)
+        {
+            frp = oldwin->w_frame->fr_parent->fr_child;
+            while (frp != NULL)
+            {
+                if (frp->fr_win != oldwin && frp->fr_win != NULL
+                        && (frp->fr_win->w_width > new_size
+                            || frp->fr_win->w_width > oldwin->w_width
+                                                   - new_size - STATUS_HEIGHT))
+                {
+                    do_equal = TRUE;
+                    break;
+                }
+                frp = frp->fr_next;
+            }
+        }
     }
     else
 #endif
     {
         layout = FR_COL;
-        do_equal = (p_ea && new_size == 0
-#ifdef FEAT_VERTSPLIT
-                && *p_ead != 'h'
-#endif
-                );
 
         /*
          * Check if we are able to split the current window and compute its
@@ -831 +846 @@
             if (need_status)
                 oldwin_height -= STATUS_HEIGHT;
         }
+
+        /* Only make all windows the same height if one of them (except oldwin)
+         * is higher than one of the split windows. */
+        if (!do_equal && p_ea && size == 0
+#ifdef FEAT_VERTSPLIT
+                && *p_ead != 'h'
+#endif
+           && oldwin->w_frame->fr_parent != NULL)
+        {
+            frp = oldwin->w_frame->fr_parent->fr_child;
+            while (frp != NULL)
+            {
+                if (frp->fr_win != oldwin && frp->fr_win != NULL
+                        && (frp->fr_win->w_height > new_size
+                            || frp->fr_win->w_height > oldwin_height - new_size
+                                                              - STATUS_HEIGHT))
+                {
+                    do_equal = TRUE;
+                    break;
+                }
+                frp = frp->fr_next;
+            }
+        }
     }
 
     /*
@@ -2120 +2158 @@
         if (wp->w_p_pvw || bt_quickfix(wp->w_buffer))
         {
             /*
-             * The cursor goes to the preview or the quickfix window, try
+             * If the cursor goes to the preview or the quickfix window, try
              * finding another window to go to.
              */
             for (;;)
@@ -2307 +2345 @@
     frame_T     *frp, *frp2, *frp3;
     frame_T     *frp_close = win->w_frame;
     win_T       *wp;
-    int         old_size = 0;
 
     /*
      * If there is only one window there is nothing to remove.
@@ -2328 +2365 @@
     if (frp_close->fr_parent->fr_layout == FR_COL)
     {
 #endif
-        /* When 'winfixheight' is set, remember its old size and restore
-         * it later (it's a simplistic solution...).  Don't do this if the
-         * window will occupy the full height of the screen. */
-        if (frp2->fr_win != NULL
-                && (frp2->fr_next != NULL || frp2->fr_prev != NULL)
-                && frp2->fr_win->w_p_wfh)
-            old_size = frp2->fr_win->w_height;
+        /* When 'winfixheight' is set, try to find another frame in the column
+         * (as close to the closed frame as possible) to distribute the height
+         * to. */
+        if (frp2->fr_win != NULL && frp2->fr_win->w_p_wfh)
+        {
+            frp = frp_close->fr_prev;
+            frp3 = frp_close->fr_next;
+            while (frp != NULL || frp3 != NULL)
+            {
+                if (frp != NULL)
+                {
+                    if (frp->fr_win != NULL && !frp->fr_win->w_p_wfh)
+                    {
+                        frp2 = frp;
+                        wp = frp->fr_win;
+                        break;
+                    }
+                    frp = frp->fr_prev;
+                }
+                if (frp3 != NULL)
+                {
+                    if (frp3->fr_win != NULL && !frp3->fr_win->w_p_wfh)
+                    {
+                        frp2 = frp3;
+                        wp = frp3->fr_win;
+                        break;
+                    }
+                    frp3 = frp3->fr_next;
+                }
+            }
+        }
         frame_new_height(frp2, frp2->fr_height + frp_close->fr_height,
                             frp2 == frp_close->fr_next ? TRUE : FALSE, FALSE);
-        if (old_size != 0)
-            win_setheight_win(old_size, frp2->fr_win);
 #ifdef FEAT_VERTSPLIT
         *dirp = 'v';
     }
     else
     {
-        /* When 'winfixwidth' is set, remember its old size and restore
-         * it later (it's a simplistic solution...).  Don't do this if the
-         * window will occupy the full width of the screen. */
-        if (frp2->fr_win != NULL
-                && (frp2->fr_next != NULL || frp2->fr_prev != NULL)
-                && frp2->fr_win->w_p_wfw)
-            old_size = frp2->fr_win->w_width;
+        /* When 'winfixwidth' is set, try to find another frame in the column
+         * (as close to the closed frame as possible) to distribute the width
+         * to. */
+        if (frp2->fr_win != NULL && frp2->fr_win->w_p_wfw)
+        {
+            frp = frp_close->fr_prev;
+            frp3 = frp_close->fr_next;
+            while (frp != NULL || frp3 != NULL)
+            {
+                if (frp != NULL)
+                {
+                    if (frp->fr_win != NULL && !frp->fr_win->w_p_wfw)
+                    {
+                        frp2 = frp;
+                        wp = frp->fr_win;
+                        break;
+                    }
+                    frp = frp->fr_prev;
+                }
+                if (frp3 != NULL)
+                {
+                    if (frp3->fr_win != NULL && !frp3->fr_win->w_p_wfw)
+                    {
+                        frp2 = frp3;
+                        wp = frp3->fr_win;
+                        break;
+                    }
+                    frp3 = frp3->fr_next;
+                }
+            }
+        }
         frame_new_width(frp2, frp2->fr_width + frp_close->fr_width,
                             frp2 == frp_close->fr_next ? TRUE : FALSE, FALSE);
-        if (old_size != 0)
-            win_setwidth_win(old_size, frp2->fr_win);
         *dirp = 'h';
     }
 #endif
@@ -4128 +4209 @@
 #ifdef FEAT_AUTOCMD
         --autocmd_block;
 #endif
+#ifdef FEAT_SEARCH_EXTRA
+        newwin->w_match_head = NULL;
+        newwin->w_next_match_id = 4;
+#endif
     }
     return newwin;
 }
@@ -4185 +4270 @@
         vim_free(wp->w_tagstack[i].tagname);
 
     vim_free(wp->w_localdir);
+
 #ifdef FEAT_SEARCH_EXTRA
-    vim_free(wp->w_match[0].regprog);
-    vim_free(wp->w_match[1].regprog);
-    vim_free(wp->w_match[2].regprog);
+    clear_matches(wp);
 #endif
+
 #ifdef FEAT_JUMPLIST
     free_jumplist(wp);
 #endif
@@ -6174 +6259 @@
     return FALSE;
 }
 #endif
+
+#if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
+/*
+ * Add match to the match list of window 'wp'.  The pattern 'pat' will be
+ * highligted with the group 'grp' with priority 'prio'.
+ * Optionally, a desired ID 'id' can be specified (greater than or equal to 1).
+ * If no particular ID is desired, -1 must be specified for 'id'.
+ * Return ID of added match, -1 on failure.
+ */
+    int
+match_add(wp, grp, pat, prio, id)
+    win_T       *wp;
+    char_u      *grp;
+    char_u      *pat;
+    int         prio;
+    int         id;
+{
+    matchitem_T *cur;
+    matchitem_T *prev;
+    matchitem_T *m;
+    int         hlg_id;
+    regprog_T   *regprog;
+
+    if (*grp == NUL || *pat == NUL)
+        return -1;
+    if (id < -1 || id == 0)
+    {
+        EMSGN("E799: Invalid ID: %ld (must be greater than or equal to 1)", id);
+        return -1;
+    }
+    if (id != -1)
+    {
+        cur = wp->w_match_head;
+        while (cur != NULL)
+        {
+            if (cur->id == id)
+            {
+                EMSGN("E801: ID already taken: %ld", id);
+                return -1;
+            }
+            cur = cur->next;
+        }
+    }
+    if ((hlg_id = syn_namen2id(grp, STRLEN(grp))) == 0)
+    {
+        EMSG2(_(e_nogroup), grp);
+        return -1;
+    }
+    if ((regprog = vim_regcomp(pat, RE_MAGIC)) == NULL)
+    {
+        EMSG2(_(e_invarg2), pat);
+        return -1;
+    }
+
+    /* Find available match ID. */
+    while (id == -1)
+    {
+        cur = wp->w_match_head;
+        while (cur != NULL && cur->id != wp->w_next_match_id)
+            cur = cur->next;
+        if (cur == NULL)
+            id = wp->w_next_match_id;
+        wp->w_next_match_id++;
+    }
+
+    /* Build new match. */
+    m = (matchitem_T *)alloc(sizeof(matchitem_T));
+    m->id = id;
+    m->priority = prio;
+    m->pattern = vim_strsave(pat);
+    m->hlg_id = hlg_id;
+    m->match.regprog = regprog;
+    m->match.rmm_ic = FALSE;
+    m->match.rmm_maxcol = 0;
+
+    /* Insert new match.  The match list is in ascending order with regard to
+     * the match priorities. */
+    cur = wp->w_match_head;
+    prev = cur;
+    while (cur != NULL && prio >= cur->priority)
+    {
+        prev = cur;
+        cur = cur->next;
+    }
+    if (cur == prev)
+        wp->w_match_head = m;
+    else
+        prev->next = m;
+    m->next = cur;
+
+    redraw_later(SOME_VALID);
+    return id;
+}
+
+/*
+ * Delete match with ID 'id' in the match list of window 'wp'.
+ * Print error messages if 'perr' is TRUE.
+ */
+    int
+match_delete(wp, id, perr)
+    win_T       *wp;
+    int         id;
+    int         perr;
+{
+    matchitem_T *cur = wp->w_match_head;
+    matchitem_T *prev = cur;
+
+    if (id < 1)
+    {
+        if (perr == TRUE)
+            EMSGN("E802: Invalid ID: %ld (must be greater than or equal to 1)",
+                                                                          id);
+        return -1;
+    }
+    while (cur != NULL && cur->id != id)
+    {
+        prev = cur;
+        cur = cur->next;
+    }
+    if (cur == NULL)
+    {
+        if (perr == TRUE)
+            EMSGN("E803: ID not found: %ld", id);
+        return -1;
+    }
+    if (cur == prev)
+        wp->w_match_head = cur->next;
+    else
+        prev->next = cur->next;
+    vim_free(cur->match.regprog);
+    vim_free(cur->pattern);
+    vim_free(cur);
+    redraw_later(SOME_VALID);
+    return 0;
+}
+
+/*
+ * Delete all matches in the match list of window 'wp'.
+ */
+    void
+clear_matches(wp)
+    win_T       *wp;
+{
+    matchitem_T *m;
+
+    while (wp->w_match_head != NULL)
+    {
+        m = wp->w_match_head->next;
+        vim_free(wp->w_match_head->match.regprog);
+        vim_free(wp->w_match_head->pattern);
+        vim_free(wp->w_match_head);
+        wp->w_match_head = m;
+    }
+    redraw_later(SOME_VALID);
+}
+
+/*
+ * Get match from ID 'id' in window 'wp'.
+ * Return NULL if match not found.
+ */
+    matchitem_T *
+get_match(wp, id)
+    win_T       *wp;
+    int         id;
+{
+    matchitem_T *cur = wp->w_match_head;
+
+    while (cur != NULL && cur->id != id)
+        cur = cur->next;
+    return cur;
+}
+#endif