" Vimball Archiver by Charles E. Campbell, Ph.D.
UseVimball
finish
plugin/HiMtchBrkt.vim	[[[1
518
" HiMtchBrkt : highlights matching brackets and, optionally, containing brackets
"  Author:  Charles E. Campbell  <NcampObell@SdrPchip.AorgM-NOSPAM>
"  Date:    Feb 22, 2011 - Jan 07, 2020
"  Version: 23
"
" A Vim v6.0/7.0 plugin with menus for gvim
"
" Usage: {{{1
"   \[i : initialize highlighting of matching bracket
"   \[s : stop       highlighting of matching bracket
"
"   Actually, <Leader> is used, so you may set mapleader to change
"   the leading backslash to whatever you want in your <.vimrc>
"   See :help mapleader.
"
" GetLatestVimScripts: 1435 1 :AutoInstall: HiMtchBrkt.vim
" GetLatestVimScripts: 1066 1 cecutil.vim
" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_HiMtchBrkt")
 finish
endif
let g:loaded_HiMtchBrkt = "v23"
let s:keepcpo           = &cpo
set cpo&vim
if exists("g:hicurline_ut") && !exists("g:HiMtchBrkt_ut")
 let g:HiMtchBrkt_ut= g:hicurline_ut
endif
if v:version >= 700 && exists("##CursorMoved")
 let g:loaded_matchparen= 1
endif

" ---------------------------------------------------------------------
" Public Interface: {{{1
if !hasmapto('<Plug>HMBStart')
 map <unique> <Leader>[i	<Plug>HMBStart
endif
if !hasmapto('<Plug>HMBStop')
 map <unique> <Leader>[s	<Plug>HMBStop
endif
com! -bang HMBstart    :set lz|call s:HMBStart(<bang>0)|set nolz
com! -bang HMBstop     :set lz|call s:HMBStop(<bang>0)|set nolz
com! -bang HMBsurround :set lz|call s:HMBSurround(<bang>1)|set nolz
com! -bang HiMtchBrkt  call s:HiMtchBrktToggle(<bang>1)

" ---------------------------------------------------------------------
" Global Maps: {{{1
nmap <silent> <unique> <script> <Plug>HMBStart :set lz<CR>:call <SID>HMBStart(0)<CR>:set nolz<CR>
nmap <silent> <unique> <script> <Plug>HMBStop  :set lz<CR>:call <SID>HMBStop(0)<CR>:set nolz<CR>

" ---------------------------------------------------------------------
" DrChip Menu Support: {{{1
if has("menu") && has("gui_running") && &go =~# 'm'
 if !exists("g:DrChipTopLvlMenu")
  let g:DrChipTopLvlMenu= "DrChip."
 endif
 exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Start<tab><Leader>[i	<Leader>[i'
 exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On<tab>:HMBsurround	:HMBsurround'
endif
"DechoTabOn

" =====================================================================
" HMBStart: {{{1
fun! s:HMBStart(mode)
"  call Dfunc("HMBStart(mode=".a:mode.")")

  " indicate that HiMtchBrkt mode is on
  let s:HiMtchBrkt= 1

  " set whichwrap
  let s:wwkeep= &ww
  set ww=b,s,<,>,[,]

  if exists("g:dohimtchbrkt") && g:dohimtchbrkt == 1
   " already in HiMtchBrkt mode
   if &cmdheight >= 2 && a:mode == 0
    echo "[HiMtchBrkt]"
   endif
"   call Dret("HMBStart : already in HiMtchBrkt mode")
   return
  endif
  let g:dohimtchbrkt= 1
 
  " indicate in HiMtchBrkt mode
  if &cmdheight >= 2 && a:mode == 0
   echo "[HiMtchBrkt]"
  endif
 
  if v:version >= 700 && exists("##CursorMoved")
   " assuming snapshot#195 or later
   augroup HMBEvent
   	au!
    au CursorMoved * silent call s:HiMatchBracket()
   augroup END
  else
   " Save Maps (if any)
"   call Decho("saving user maps")
   call SaveUserMaps("n","",":F(","HiMtchBrkt")
   call SaveUserMaps("n","",":F)","HiMtchBrkt")
   call SaveUserMaps("n","",":F[","HiMtchBrkt")
   call SaveUserMaps("n","",":F]","HiMtchBrkt")
   call SaveUserMaps("n","",":F{","HiMtchBrkt")
   call SaveUserMaps("n","",":F}","HiMtchBrkt")
   call SaveUserMaps("n","",":f(","HiMtchBrkt")
   call SaveUserMaps("n","",":f)","HiMtchBrkt")
   call SaveUserMaps("n","",":f[","HiMtchBrkt")
   call SaveUserMaps("n","",":f]","HiMtchBrkt")
   call SaveUserMaps("n","",":f{","HiMtchBrkt")
   call SaveUserMaps("n","",":f}","HiMtchBrkt")
   call SaveUserMaps("n","","<c-b>","HiMtchBrkt")
   call SaveUserMaps("n","","<c-d>","HiMtchBrkt")
   call SaveUserMaps("n","","<c-f>","HiMtchBrkt")
   call SaveUserMaps("n","","<c-u>","HiMtchBrkt")
   call SaveUserMaps("n","","<down>","HiMtchBrkt")
   call SaveUserMaps("n","","<PageDown>","HiMtchBrkt")
   call SaveUserMaps("n","","<end>","HiMtchBrkt")
   call SaveUserMaps("n","","<home>","HiMtchBrkt")
   call SaveUserMaps("n","","<left>","HiMtchBrkt")
   call SaveUserMaps("n","","<right>","HiMtchBrkt")
   call SaveUserMaps("n","","<space>","HiMtchBrkt")
   call SaveUserMaps("n","","<up>","HiMtchBrkt")
   call SaveUserMaps("n","","<PageUp>","HiMtchBrkt")
   call SaveUserMaps("n","","webWEBjklh$0%;,nN","HiMtchBrkt")
   call SaveUserMaps("o","","<down>","HiMtchBrkt")
   call SaveUserMaps("o","","<end>","HiMtchBrkt")
   call SaveUserMaps("o","","<home>","HiMtchBrkt")
   call SaveUserMaps("o","","<left>","HiMtchBrkt")
   call SaveUserMaps("o","","<right>","HiMtchBrkt")
   call SaveUserMaps("o","","<up>","HiMtchBrkt")
   if has("gui_running") && has("mouse")
    call SaveUserMaps("n","","<leftmouse>","HiMtchBrkt")
    call SaveUserMaps("o","","<leftmouse>","HiMtchBrkt")
   endif
   if v:version > 602 || v:version == 602 && has("patch405")
    call SaveUserMaps("n","","0","HiMtchBrkt")
   endif
  
   " Install HiMtchBrkt maps
   if has("gui_running")
    call s:HMBMapper("<down>"    , "<down>"    , "<down>")
    call s:HMBMapper("<up>"      , "<up>"      , "<up>")
    call s:HMBMapper("<right>"   , "<right>"   , "<right>")
    call s:HMBMapper("<left>"    , "<left>"    , "<left>")
    call s:HMBMapper("<home>"    , "<home>"    , "<home>")
    call s:HMBMapper("<end>"     , "<end>"     , "<end>")
    call s:HMBMapper("<space>"   , "<space>"   , "")
    call s:HMBMapper("<PageUp>"  , "<PageUp>"  , "<PageUp>")
    call s:HMBMapper("<PageDown>", "<PageDown>", "<PageDown>")
   else
    call s:HMBMapper("<down>"    , "j"    , "<c-o>j"    )
    call s:HMBMapper("<up>"      , "k"    , "<c-o>k"    )
    call s:HMBMapper("<right>"   , "l"    , "<c-o>l"    )
    call s:HMBMapper("<left>"    , "h"    , "<c-o>h"    )
    call s:HMBMapper("<home>"    , "0"    , "<c-o>0"    )
    call s:HMBMapper("<end>"     , "$"    , "<c-o>$"    )
    call s:HMBMapper("<space>"   , "l"    , ""          )
    call s:HMBMapper("<PageUp>"  , "<c-b>", "<c-o><c-b>")
    call s:HMBMapper("<PageDown>", "<c-f>", "<c-o><c-f>")
   endif
   if has("gui_running") && has ("mouse")
    call s:HMBMapper("<leftmouse>","<leftmouse>","<leftmouse>")
   endif
   if v:version > 602 || v:version == 602 && has("patch405")
    call s:HMBMapper('0'    , '0'    , '')
   endif
   call s:HMBMapper('b'    , 'b'    , '')
   call s:HMBMapper('B'    , 'B'    , '')
   call s:HMBMapper('e'    , 'e'    , '')
   call s:HMBMapper('E'    , 'E'    , '')
   call s:HMBMapper('h'    , 'h'    , '')
   call s:HMBMapper('j'    , 'j'    , '')
   call s:HMBMapper('k'    , 'k'    , '')
   call s:HMBMapper('l'    , 'l'    , '')
   call s:HMBMapper('n'    , 'n'    , '')
   call s:HMBMapper('N'    , 'N'    , '')
   call s:HMBMapper('$'    , '$'    , '')
   call s:HMBMapper('%'    , '%'    , '')
   call s:HMBMapper('w'    , 'w'    , '')
   call s:HMBMapper('W'    , 'W'    , '')
   call s:HMBMapper("<c-f>", "<c-f>", "")
   call s:HMBMapper("<c-b>", "<c-b>", "")
   call s:HMBMapper("<c-d>", "<c-d>", "")
   call s:HMBMapper("<c-u>", "<c-u>", "")
   call s:HMBMapper('f('   , 'f('   , '')
   call s:HMBMapper('f)'   , 'f)'   , '')
   call s:HMBMapper('f{'   , 'f{'   , '')
   call s:HMBMapper('f}'   , 'f}'   , '')
   call s:HMBMapper('f['   , 'f['   , '')
   call s:HMBMapper('f]'   , 'f]'   , '')
   call s:HMBMapper('F('   , 'F('   , '')
   call s:HMBMapper('F)'   , 'F)'   , '')
   call s:HMBMapper('F{'   , 'F{'   , '')
   call s:HMBMapper('F}'   , 'F}'   , '')
   call s:HMBMapper('F['   , 'F['   , '')
   call s:HMBMapper('F]'   , 'F]'   , '')
   if exists("mapleader")
    if mapleader != ';'
     call s:HMBMapper(';',';','')
    endif
    if mapleader != ','
     call s:HMBMapper(',',',','')
    endif
   else
    call s:HMBMapper(';',';','')
    call s:HMBMapper(',',',','')
   endif
 
   " use CursorHold event to do a belated highlighing of matching bracket
   " to handle motions not directly handled above
   if !exists("g:HiMtchBrkt_nocursorhold") && (!exists("g:HiMtchBrkt_ut") || g:HiMtchBrkt_ut != 0)
    " keep and set options
    let g:HiMtchBrkt_utkeep= &ut
    if exists("g:HiMtchBrkt_ut")
     let &ut= g:HiMtchBrkt_ut
    else
     " I'd like to set ut even faster, but unfortunately that clears
     " status-line messages before people have a chance to read them
     set ut=2000
    endif
"	call Decho("setting up CursorHold call to s:HiMtchBracket()")
    augroup HMBEvent
     au!
     au CursorHold * if getline(line(".")) != "" | silent call s:HiMatchBracket() | endif
    augroup END
   endif
  endif
 
  " Insert stop  HiMtchBrkt into menu
  " Delete start HiMtchBrkt from menu
  if has("gui_running") && has("menu")
"   call Decho("setting up menu")
   exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Stop<tab><Leader>[s	:HMBstop'."\<cr>"
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Start'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On'
   if exists("g:HiMtchBrkt_surround") && g:HiMtchBrkt_surround
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off<tab>:HMBsurround!	:HMBsurround!'."\<cr>"
   else
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On<tab>:HMBsurround	:HMBsurround'."\<cr>"
   endif
  endif
 
"  call Dret("HMBStart")
endfun

" ---------------------------------------------------------------------
" HMBStop: turn  HiMtchBrkt mode off: restore motion key maps to prior {{{1
" settings (if any), restore visual beeps, restore CursorHold update timer.
fun! <SID>HMBStop(mode)
"  call Dfunc("HMBStop(mode=".a:mode.")")
  " indicate that HiMtchBrkt is off
  let s:HiMtchBrkt= 0

  if !exists("g:dohimtchbrkt")
   if &cmdheight >= 2 && a:mode == 0
    echo "[HiMtchBrkt off]"
   endif
"   call Dret("HMBStop")
   return
  endif
  unlet g:dohimtchbrkt
  match none
 
  " remove cursorhold event for highlighting matching bracket
  if (v:version >= 700 && exists("##CursorMoved")) || !exists("g:HiMtchBrkt_nocursorhold")
   augroup HMBEvent
    au!
   augroup END
  endif
 
  if &cmdheight >= 2
   echo "[HiMtchBrkt off]"
  endif
 
  " restore user map(s), if any
  if v:version < 700
   call RestoreUserMaps("HiMtchBrkt")
  endif
  let &ww= s:wwkeep
 
  " Insert start HiMtchBrkt into menu
  " Delete stop  HiMtchBrkt from menu
  if has("gui_running") && has("menu")
   exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Start<tab><Leader>[i	:HMBstart'."\<cr>"
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Stop'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On'
   if exists("g:HiMtchBrkt_surround") && g:HiMtchBrkt_surround
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off<tab>:HMBsurround!	:HMBsurround!'."\<cr>"
   else
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On<tab>:HMBsurround	:HMBsurround'."\<cr>"
   endif
  endif
"  call Dret("HMBStop")
endfun

" ---------------------------------------------------------------------
" s:HiMatchBracket: this routine actually performs the highlighting of {{{1
" the matching bracket.
fun! s:HiMatchBracket()
"  call Dfunc("s:HiMatchBracket()")
"  call Decho(((exists("g:HiMtchBrkt_surround") && g:HiMtchBrkt_surround)? "surround" : "normal")." mode")

  if mode() =~# '['."\<c-v>".'vVsS]'
   " don't try to highlight matching/surrounding brackets while in
   " visual-block mode
"   call Dret("s:HiMatchBracket -- avoiding visual block/char/line mode<".mode().">")
   return
  endif

  " save
  let magickeep        = &l:magic
  let sokeep           = &so
  let sskeep           = &ss
  let sisokeep         = &siso
  let solkeep          = &sol
  let t_vbkeep         = &t_vb
  let vbkeep           = &vb
  silent! let regpaste = @*

  " turn beep/visual flash off
  set nosol vb t_vb= so=0 siso=0 ss=0 magic

  " remove every other character from the mps option set
  let mps= substitute(&mps,'\(.\).','\1','g')

  " grab a copy of the character under the cursor into curchr
  let curchr= getline(".")[col(".")-1]

  " if the character grabbed in curchr is in the mps option set, then highlight
  " the matching character
"  call Decho("HiMatchBracket: stridx(mps<".mps.">,curchr<".curchr.">)=".stridx(mps,curchr))
  if stridx(mps,curchr) != -1
   if v:version >= 700 && exists("##CursorMoved")
	" determine match line, column.
	" Restrict search to currently visible portion of window.
   	if &mps =~# curchr.':'
	 let stopline           = line("w$")
	 let chrmatch           = substitute(&mps,'^.*'.curchr.':\(.\).*$','\1','')
	 let [mtchline,mtchcol] = searchpairpos('\V'.curchr,'','\V'.chrmatch,'n','',stopline)
	else
	 let stopline           = line("w0")
	 let chrmatch           = substitute(&mps,'^.*\(.\):'.curchr.'.*$','\1','')
	 let [mtchline,mtchcol] = searchpairpos('\V'.chrmatch,'','\V'.curchr,'bn','',stopline)
	endif
"    call Decho("curchr<".curchr."> chrmatch<".chrmatch.">  searchpairpos[".mtchline.','.mtchcol.'] stopline='.stopline)
	if mtchline != 0 && mtchcol != 0
"     call Decho('exe match Search /\%'.mtchline.'l\%'.mtchcol.'c/')
	 exe 'match Search /\%'.mtchline.'l\%'.mtchcol.'c/'
    else
	 match none
    endif
   else
   	" vim 6.4 and earlier support
    let swp     = SaveWinPosn(0)
    let curline = line('.')
    let curcol  = virtcol('.')
	keepj norm! H
	let hline   = line('.')
	if hline != curline
	 call RestoreWinPosn(swp)
	endif
	keepj norm! %
	let mtchline = line('.')
	let mtchcol  = virtcol('.')
	call RestoreWinPosn(swp)
"    call Decho('exe match Search /\%'.mtchline.'l\%'.mtchcol.'v/')
	exe 'match Search /\%'.mtchline.'l\%'.mtchcol.'v/'
   endif

  " if g:HiMtchBrkt_surround exists and is true, then highlight the surrounding brackets
  elseif exists("g:HiMtchBrkt_surround") && g:HiMtchBrkt_surround
   let swp        = SaveWinPosn(0)
   let openers    = '['.escape(substitute(&mps,':.,\=',"","g"),']').']'
   let closers    = '['.escape(substitute(&mps,',\=.:',"","g"),']').']'
"   call Decho("openers".openers." closers".closers)
   if v:version >= 700 && exists("##CursorMoved")
   	" HMBsurround mode for vim v7.x
    let [mtchline1,mtchcol1]= searchpairpos(openers,"",closers,'bn','',line("w0"))
	if mtchline1 != 0 && mtchcol1 != 0
	 let mtchchr1             = getline(mtchline1)[mtchcol1-1]
	 let mtchchr2             = substitute(&mps,'^.*'.mtchchr1.':\(.\).*$','\1','')
	 let [mtchline2,mtchcol2] = searchpairpos('\V'.mtchchr1,"",'\V'.mtchchr2,'n','',line("w$"))
"	 call Decho("[".mtchline1.','.mtchcol1.']<'.mtchchr1.'>')
"	 call Decho("[".mtchline2.','.mtchcol2.']<'.mtchchr2.'>')
	 if mtchline2 != 0 && mtchcol2 != 0
      exe 'match Search /\%'.mtchline1.'l\%'.mtchcol1.'v\|\%'.mtchline2.'l\%'.mtchcol2.'v/'
	 else
      exe 'match Search /\%'.mtchline1.'l\%'.mtchcol1.'v/'
	 endif
	else
     let [mtchline2,mtchcol2]= searchpairpos(openers,"",closers,'n','',line("w$"))
	 if mtchline2 != 0 && mtchcol2 != 0
      exe 'match Search /\%'.mtchline2.'l\%'.mtchcol2.'v/'
	 else
	  match none
	 endif
	endif
"    let [mtchline2,mtchcol2]= searchpairpos(openers,"",closers,'n','',line("w$"))
"	 let [mtchline,mtchcol] = searchpairpos(escape(chrmatch,'[]'),'',escape(curchr,'[]'),'bn','',stopline)
   else
   	" HMBsurround mode for vim v6.x
    if searchpair(openers,"",closers) <= 0
	 match none
	else
     let curchr= getline(".")[col(".")-1]
"     call Decho("surround: stridx(mps<".mps.">,curchr<".curchr.">)=".stridx(mps,curchr))
     if stridx(mps,curchr) != -1
      let mtchline1 = line('.')
      let mtchcol1  = virtcol('.')
      keepj norm! %
      let mtchline2 = line('.')
      let mtchcol2  = virtcol('.')
      call RestoreWinPosn(swp)
      exe 'match Search /\%'.mtchline1.'l\%'.mtchcol1.'v\|\%'.mtchline2.'l\%'.mtchcol2.'v/'
"      call Decho('match Search /\%'.mtchline1.'l\%'.mtchcol1.'v\|\%'.mtchline2.'l\%'.mtchcol2.'v/')
     endif
	endif
   endif

  else
   match none
  endif
 
  " restore
  let &l:magic   = magickeep
  let &sol       = solkeep
  let &so        = sokeep
  let &siso      = sisokeep
  let &ss        = sskeep
  let &t_vb      = t_vbkeep
  let &vb        = vbkeep
  silent! let @* = regpaste

"  call Dret("s:HiMatchBracket")
endfun

" ---------------------------------------------------------------------
" HMBSurround: turns on HiMtchBrkt surround mode (brackets containing
" current cursor are highlighted).  If HiMtchBrkt is not enabled, then
" enabling with HMBsurround will also start HiMtchBrkt.  It doesn't
" stop HiMtchBrkt mode, though.  Instead, HiMtchBrkt will go to matching
" bracket highlighting mode.
fun! s:HMBSurround(mode)
"  call Dfunc("HMBsurround()")
  let g:HiMtchBrkt_surround= a:mode
  if g:HiMtchBrkt_surround
   if !exists("g:dohimtchbrkt")
    call s:HMBStart(0)
   endif
  endif
  call s:HiMatchBracket()
  if has("menu") && has("gui_running") && &go =~# 'm'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off'
   exe 'silent! unmenu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On'
   if g:HiMtchBrkt_surround
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ Off<tab>:HMBsurround!	:HMBsurround!'."\<cr>"
   else
    exe 'menu '.g:DrChipTopLvlMenu.'HiMtchBrkt.Surround\ On<tab>:HMBsurround	:HMBsurround'."\<cr>"
   endif
  endif
"  call Dret("HMBsurround")
endfun

" ---------------------------------------------------------------------
" HMBMapper: {{{1
fun! s:HMBMapper(lhs,nrhs,irhs)
"  call Dfunc("HMBMapper(.lhs<".a:lhs."> nrhs<".a:nrhs."> irhs<".a:irhs.">)")

  " overload normal mode mapping
  let rhs= maparg(a:lhs,"n")
"  call Decho("rhs<".rhs.">")
  if rhs == "" | let rhs= a:nrhs | endif
  exe "nno <silent> ".a:lhs." ".rhs.":silent call <SID>HiMatchBracket()<CR>"
"  call Decho("exe nno <silent> ".a:lhs." ".rhs.":silent call <SID>HiMatchBracket()<CR>")

  if a:irhs != ""
  " overload insert mode mapping
   let rhs= maparg(a:lhs,"i")
"   call Decho("rhs<".rhs.">")
   if rhs == "" | let rhs= a:irhs | endif
   exe "ino <silent> ".a:lhs." ".rhs."<c-o>:silent call <SID>HiMatchBracket()<CR>"
"   call Decho("exe ino <silent> ".a:lhs." ".rhs."<c-o>:silent call <SID>HiMatchBracket()<CR>")
  endif
"  call Dret("HMBMapper")
endfun

" ---------------------------------------------------------------------
" s:HiMtchBrktToggle: {{{1
fun! s:HiMtchBrktToggle(surround)
"  call Dfunc("s:HiMtchBrktToggle(surround=".a:surround.")")
  if !exists("s:HiMtchBrkt") || s:HiMtchBrkt == 0
   call s:HMBStart(1)
   if a:surround
	call s:HMBSurround(1)
   endif
  else
   call s:HMBStop(0)
  endif
"  call Dret("s:HiMtchBrktToggle")
endfun

" ---------------------------------------------------------------------
"  Auto Startup With HiMtchBrktOn: {{{1
if exists("g:HiMtchBrktOn") && g:HiMtchBrktOn != 0
 if !exists("*SaveUserMaps")
  " due to loading order, <plugin/cecutil.vim> may not have loaded yet.
  " attempt to force a load now.  Ditto for matchit!
  silent! runtime plugin/cecutil.vim
 endif
 silent! runtime plugin/matchit.vim
 silent HMBstart
endif

let &cpo= s:keepcpo
unlet s:keepcpo
" ---------------------------------------------------------------------
"  vim: ts=4 fdm=marker
plugin/cecutil.vim	[[[1
601
" cecutil.vim : save/restore window position
"               save/restore mark position
"               save/restore selected user maps
"  Author:	Charles E. Campbell
"  Version:	18k	ASTRO-ONLY
"  Date:	Nov 22, 2017
"
"  Saving Restoring Destroying Marks: {{{1
"       call SaveMark(markname)       let savemark= SaveMark(markname)
"       call RestoreMark(markname)    call RestoreMark(savemark)
"       call DestroyMark(markname)
"       commands: SM RM DM
"
"  Saving Restoring Destroying Window Position: {{{1
"       call SaveWinPosn()        let winposn= SaveWinPosn()
"       call RestoreWinPosn()     call RestoreWinPosn(winposn)
"		\swp : save current window/buffer's position
"		\rwp : restore current window/buffer's previous position
"       commands: SWP RWP
"
"  Saving And Restoring User Maps: {{{1
"       call SaveUserMaps(mapmode,maplead,mapchx,suffix)
"       call RestoreUserMaps(suffix)
"
" GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim
"
" You believe that God is one. You do well. The demons also {{{1
" believe, and shudder. But do you want to know, vain man, that
" faith apart from works is dead?  (James 2:19,20 WEB)
"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore()

" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_cecutil")
 finish
endif
let g:loaded_cecutil = "v18k"
let s:keepcpo        = &cpo
set cpo&vim
"if exists("g:loaded_Decho")  " Decho
" DechoRemOn
"endif  " Decho

" =======================
"  Public Interface: {{{1
" =======================

" ---------------------------------------------------------------------
"  Map Interface: {{{2
if !hasmapto('<Plug>SaveWinPosn')
 map <unique> <Leader>swp <Plug>SaveWinPosn
endif
if !hasmapto('<Plug>RestoreWinPosn')
 map <unique> <Leader>rwp <Plug>RestoreWinPosn
endif
nmap <silent> <Plug>SaveWinPosn		:call SaveWinPosn()<CR>
nmap <silent> <Plug>RestoreWinPosn	:call RestoreWinPosn()<CR>

" ---------------------------------------------------------------------
" Command Interface: {{{2
com! -bar -nargs=0 SWP	call SaveWinPosn()
com! -bar -nargs=? RWP	call RestoreWinPosn(<args>)
com! -bar -nargs=1 SM	call SaveMark(<q-args>)
com! -bar -nargs=1 RM	call RestoreMark(<q-args>)
com! -bar -nargs=1 DM	call DestroyMark(<q-args>)

com! -bar -nargs=1 WLR	call s:WinLineRestore(<q-args>)

if v:version < 630
 let s:modifier= "sil! "
else
 let s:modifier= "sil! keepj "
endif

" ===============
" Functions: {{{1
" ===============

" ---------------------------------------------------------------------
" SaveWinPosn: {{{2
"    let winposn= SaveWinPosn()  will save window position in winposn variable
"    call SaveWinPosn()          will save window position in b:cecutil_winposn{b:cecutil_iwinposn}
"    let winposn= SaveWinPosn(0) will *only* save window position in winposn variable (no stacking done)
fun! SaveWinPosn(...)
"  echomsg "Decho: SaveWinPosn() a:0=".a:0
  let savedposn= winsaveview()
  if a:0 == 0
   if !exists("b:cecutil_iwinposn")
    let b:cecutil_iwinposn= 1
   else
    let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
   endif
"   echomsg "Decho: saving posn to SWP stack"
   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
  endif
  return savedposn
""  echomsg "Decho: SaveWinPosn() a:0=".a:0
"  if line("$") == 1 && getline(1) == ""
""   echomsg "Decho: SaveWinPosn : empty buffer"
"   return ""
"  endif
"  let so_keep   = &l:so
"  let siso_keep = &siso
"  let ss_keep   = &l:ss
"  setlocal so=0 siso=0 ss=0

"  let swline = line(".")                           " save-window line in file
"  let swcol  = col(".")                            " save-window column in file
"  if swcol >= col("$")
"   let swcol= swcol + virtcol(".") - virtcol("$")  " adjust for virtual edit (cursor past end-of-line)
"  endif
"  let swwline   = winline() - 1                    " save-window window line
"  let swwcol    = virtcol(".") - wincol()          " save-window window column
"  let savedposn = ""
""  echomsg "Decho: sw[".swline.",".swcol."] sww[".swwline.",".swwcol."]"
"  let savedposn = "call GoWinbufnr(".winbufnr(0).")"
"  let savedposn = savedposn."|".s:modifier.swline
"  let savedposn = savedposn."|".s:modifier."norm! 0z\<cr>"
"  if swwline > 0
"   let savedposn= savedposn.":".s:modifier."call s:WinLineRestore(".(swwline+1).")\<cr>"
"  endif
"  if swwcol > 0
"   let savedposn= savedposn.":".s:modifier."norm! 0".swwcol."zl\<cr>"
"  endif
"  let savedposn = savedposn.":".s:modifier."call cursor(".swline.",".swcol.")\<cr>"

"  " save window position in
"  " b:cecutil_winposn_{iwinposn} (stack)
"  " only when SaveWinPosn() is used
"  if a:0 == 0
"   if !exists("b:cecutil_iwinposn")
"    let b:cecutil_iwinposn= 1
"   else
"    let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
"   endif
""   echomsg "Decho: saving posn to SWP stack"
"   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
"  endif

"  let &l:so = so_keep
"  let &siso = siso_keep
"  let &l:ss = ss_keep

""  if exists("b:cecutil_iwinposn")                                                                  " Decho
""   echomsg "Decho: b:cecutil_winpos{".b:cecutil_iwinposn."}[".b:cecutil_winposn{b:cecutil_iwinposn}."]"
""  else                                                                                             " Decho
""   echomsg "Decho: b:cecutil_iwinposn doesn't exist"
""  endif                                                                                            " Decho
""  echomsg "Decho: SaveWinPosn [".savedposn."]"
"  return savedposn
endfun

" ---------------------------------------------------------------------
" RestoreWinPosn: {{{2
"      call RestoreWinPosn()
"      call RestoreWinPosn(winposn)
fun! RestoreWinPosn(...)
  if line("$") == 1 && getline(1) == ""
   return ""
  endif
  if a:0 == 0 || type(a:1) != 4
   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
    try
	 call winrestview(b:cecutil_winposn{b:cecutil_iwinposn})
    catch /^Vim\%((\a\+)\)\=:E749/
     " ignore empty buffer error messages
    endtry
    " normally drop top-of-stack by one
    " but while new top-of-stack doesn't exist
    " drop top-of-stack index by one again
    if b:cecutil_iwinposn >= 1
     unlet b:cecutil_winposn{b:cecutil_iwinposn}
     let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
     while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
      let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
     endwhile
     if b:cecutil_iwinposn < 1
      unlet b:cecutil_iwinposn
     endif
    endif
   else
    echohl WarningMsg
    echomsg "***warning*** need to SaveWinPosn first!"
    echohl None
   endif

  else	 " handle input argument
"   echomsg "Decho: using input a:1<".a:1.">"
   " use window position passed to this function
   call winrestview(a:1)
   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
   if exists("b:cecutil_iwinposn")
    let jwinposn= b:cecutil_iwinposn
    while jwinposn >= 1                     " search for a:1 in iwinposn..1
     if exists("b:cecutil_winposn{jwinposn}")    " if it exists
      if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
       unlet b:cecutil_winposn{jwinposn}            " unlet it
       if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
        let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
       endif
      endif
     endif
     let jwinposn= jwinposn - 1
    endwhile
   endif
  endif

""  echomsg "Decho: RestoreWinPosn() a:0=".a:0
""  echomsg "Decho: getline(1)<".getline(1).">"
""  echomsg "Decho: line(.)=".line(".")
"  if line("$") == 1 && getline(1) == ""
""   echomsg "Decho: RestoreWinPosn : empty buffer"
"   return ""
"  endif
"  let so_keep   = &l:so
"  let siso_keep = &l:siso
"  let ss_keep   = &l:ss
"  setlocal so=0 siso=0 ss=0

"  if a:0 == 0 || a:1 == ""
"   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
"   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
""    echomsg "Decho: using stack b:cecutil_winposn{".b:cecutil_iwinposn."}<".b:cecutil_winposn{b:cecutil_iwinposn}.">"
"    try
"     exe s:modifier.b:cecutil_winposn{b:cecutil_iwinposn}
"    catch /^Vim\%((\a\+)\)\=:E749/
"     " ignore empty buffer error messages
"    endtry
"    " normally drop top-of-stack by one
"    " but while new top-of-stack doesn't exist
"    " drop top-of-stack index by one again
"    if b:cecutil_iwinposn >= 1
"     unlet b:cecutil_winposn{b:cecutil_iwinposn}
"     let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
"     while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
"      let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
"     endwhile
"     if b:cecutil_iwinposn < 1
"      unlet b:cecutil_iwinposn
"     endif
"    endif
"   else
"    echohl WarningMsg
"    echomsg "***warning*** need to SaveWinPosn first!"
"    echohl None
"   endif

"  else	 " handle input argument
""   echomsg "Decho: using input a:1<".a:1.">"
"   " use window position passed to this function
"   exe a:1
"   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
"   if exists("b:cecutil_iwinposn")
"    let jwinposn= b:cecutil_iwinposn
"    while jwinposn >= 1                     " search for a:1 in iwinposn..1
"     if exists("b:cecutil_winposn{jwinposn}")    " if it exists
"      if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
"       unlet b:cecutil_winposn{jwinposn}            " unlet it
"       if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
"        let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
"       endif
"      endif
"     endif
"     let jwinposn= jwinposn - 1
"    endwhile
"   endif
"  endif

"  " Seems to be something odd: vertical motions after RWP
"  " cause jump to first column.  The following fixes that.
"  " Note: was using wincol()>1, but with signs, a cursor
"  " at column 1 yields wincol()==3.  Beeping ensued.
"  let vekeep= &ve
"  set ve=all
"  if virtcol('.') > 1
"   exe s:modifier."norm! hl"
"  elseif virtcol(".") < virtcol("$")
"   exe s:modifier."norm! lh"
"  endif
"  let &ve= vekeep

"  let &l:so   = so_keep
"  let &l:siso = siso_keep
"  let &l:ss   = ss_keep

""  echomsg "Decho: RestoreWinPosn"
endfun

" ---------------------------------------------------------------------
" s:WinLineRestore: {{{2
fun! s:WinLineRestore(swwline)
"  echomsg "Decho: s:WinLineRestore(swwline=".a:swwline.")"
  while winline() < a:swwline
   let curwinline= winline()
   exe s:modifier."norm! \<c-y>"
   if curwinline == winline()
	break
   endif
  endwhile
"  echomsg "Decho: s:WinLineRestore"
endfun

" ---------------------------------------------------------------------
" GoWinbufnr: go to window holding given buffer (by number) {{{2
"   Prefers current window; if its buffer number doesn't match,
"   then will try from topleft to bottom right
fun! GoWinbufnr(bufnum)
"  call Dfunc("GoWinbufnr(".a:bufnum.")")
  if winbufnr(0) == a:bufnum
"   call Dret("GoWinbufnr : winbufnr(0)==a:bufnum")
   return
  endif
  winc t
  let first=1
  while winbufnr(0) != a:bufnum && (first || winnr() != 1)
  	winc w
	let first= 0
   endwhile
"  call Dret("GoWinbufnr")
endfun

" ---------------------------------------------------------------------
" SaveMark: sets up a string saving a mark position. {{{2
"           For example, SaveMark("a")
"           Also sets up a global variable, g:savemark_{markname}
fun! SaveMark(markname)
"  call Dfunc("SaveMark(markname<".string(a:markname).">)")
  let markname= a:markname
  if strpart(markname,0,1) !~ '\a'
   let markname= strpart(markname,1,1)
  endif
"  call Decho("markname=".string(markname))

  let lzkeep  = &lz
  set lz

  if 1 <= line("'".markname) && line("'".markname) <= line("$")
   let winposn               = SaveWinPosn(0)
   exe s:modifier."norm! `".markname
   let savemark              = SaveWinPosn(0)
   let g:savemark_{markname} = savemark
   let savemark              = markname.string(savemark)
   call RestoreWinPosn(winposn)
  else
   let g:savemark_{markname} = ""
   let savemark              = ""
  endif

  let &lz= lzkeep

"  call Dret("SaveMark : savemark<".savemark.">")
  return savemark
endfun

" ---------------------------------------------------------------------
" RestoreMark: {{{2
"   call RestoreMark("a")  -or- call RestoreMark(savemark)
fun! RestoreMark(markname)
"  call Dfunc("RestoreMark(markname<".a:markname.">)")

  if strlen(a:markname) <= 0
"   call Dret("RestoreMark : no such mark")
   return
  endif
  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname." strlen(a:markname)=".strlen(a:markname))

  let lzkeep  = &lz
  set lz
  let winposn = SaveWinPosn(0)

  if strlen(a:markname) <= 2
   if exists("g:savemark_{markname}")
	" use global variable g:savemark_{markname}
"	call Decho("use savemark list")
	call RestoreWinPosn(g:savemark_{markname})
	exe "norm! m".markname
   endif
  else
   " markname is a savemark command (string)
"	call Decho("use savemark command")
   let markcmd= strpart(a:markname,1)
  call RestoreWinPosn(winposn)
   exe "norm! m".markname
  endif

  call RestoreWinPosn(winposn)
  let &lz       = lzkeep

"  call Dret("RestoreMark")
endfun

" ---------------------------------------------------------------------
" DestroyMark: {{{2
"   call DestroyMark("a")  -- destroys mark
fun! DestroyMark(markname)
"  call Dfunc("DestroyMark(markname<".a:markname.">)")

  " save options and set to standard values
  let reportkeep= &report
  let lzkeep    = &lz
  set lz report=10000

  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname)

  let curmod  = &mod
  let winposn = SaveWinPosn(0)
  1
  let lineone = getline(".")
  exe "k".markname
  d
  put! =lineone
  let &mod    = curmod
  call RestoreWinPosn(winposn)

  " restore options to user settings
  let &report = reportkeep
  let &lz     = lzkeep

"  call Dret("DestroyMark")
endfun

" ---------------------------------------------------------------------
" QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{2
" However, <q-args> doesn't split at all, so this one returns a list
" with splits at all whitespace (only!), plus a leading length-of-list.
" The resulting list:  qarglist[0] corresponds to a:0
"                      qarglist[i] corresponds to a:{i}
fun! QArgSplitter(qarg)
"  call Dfunc("QArgSplitter(qarg<".a:qarg.">)")
  let qarglist    = split(a:qarg)
  let qarglistlen = len(qarglist)
  let qarglist    = insert(qarglist,qarglistlen)
"  call Dret("QArgSplitter ".string(qarglist))
  return qarglist
endfun

" ---------------------------------------------------------------------
" ListWinPosn: {{{2
"fun! ListWinPosn()                                                        " Decho 
"  if !exists("b:cecutil_iwinposn") || b:cecutil_iwinposn == 0             " Decho 
"   call Decho("nothing on SWP stack")                                     " Decho
"  else                                                                    " Decho
"   let jwinposn= b:cecutil_iwinposn                                       " Decho 
"   while jwinposn >= 1                                                    " Decho 
"    if exists("b:cecutil_winposn{jwinposn}")                              " Decho 
"     call Decho("winposn{".jwinposn."}<".b:cecutil_winposn{jwinposn}.">") " Decho 
"    else                                                                  " Decho 
"     call Decho("winposn{".jwinposn."} -- doesn't exist")                 " Decho 
"    endif                                                                 " Decho 
"    let jwinposn= jwinposn - 1                                            " Decho 
"   endwhile                                                               " Decho 
"  endif                                                                   " Decho
"endfun                                                                    " Decho 
"com! -nargs=0 LWP	call ListWinPosn()                                    " Decho 

" ---------------------------------------------------------------------
" SaveUserMaps: this function sets up a script-variable (s:restoremap) {{{2
"          which can be used to restore user maps later with
"          call RestoreUserMaps()
"
"          mapmode - see :help maparg for details (n v o i c l "")
"                    ex. "n" = Normal
"                    The letters "b" and "u" are optional prefixes;
"                    The "u" means that the map will also be unmapped
"                    The "b" means that the map has a <buffer> qualifier
"                    ex. "un"  = Normal + unmapping
"                    ex. "bn"  = Normal + <buffer>
"                    ex. "bun" = Normal + <buffer> + unmapping
"                    ex. "ubn" = Normal + <buffer> + unmapping
"          maplead - see mapchx
"          mapchx  - "<something>" handled as a single map item.
"                    ex. "<left>"
"                  - "string" a string of single letters which are actually
"                    multiple two-letter maps (using the maplead:
"                    maplead . each_character_in_string)
"                    ex. maplead="\" and mapchx="abc" saves user mappings for
"                        \a, \b, and \c
"                    Of course, if maplead is "", then for mapchx="abc",
"                    mappings for a, b, and c are saved.
"                  - :something  handled as a single map item, w/o the ":"
"                    ex.  mapchx= ":abc" will save a mapping for "abc"
"          suffix  - a string unique to your plugin
"                    ex.  suffix= "DrawIt"
fun! SaveUserMaps(mapmode,maplead,mapchx,suffix)
"  call Dfunc("SaveUserMaps(mapmode<".a:mapmode."> maplead<".a:maplead."> mapchx<".a:mapchx."> suffix<".a:suffix.">)")

  if !exists("s:restoremap_{a:suffix}")
   " initialize restoremap_suffix to null string
   let s:restoremap_{a:suffix}= ""
  endif

  " set up dounmap: if 1, then save and unmap  (a:mapmode leads with a "u")
  "                 if 0, save only
  let mapmode  = a:mapmode
  let dounmap  = 0
  let dobuffer = ""
  while mapmode =~# '^[bu]'
   if     mapmode =~# '^u'
    let dounmap = 1
    let mapmode = strpart(a:mapmode,1)
   elseif mapmode =~# '^b'
    let dobuffer = "<buffer> "
    let mapmode  = strpart(a:mapmode,1)
   endif
  endwhile
"  call Decho("dounmap=".dounmap."  dobuffer<".dobuffer.">")
 
  " save single map :...something...
  if strpart(a:mapchx,0,1) == ':'
"   call Decho("save single map :...something...")
   let amap= strpart(a:mapchx,1)
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
   endif
   let amap                    = a:maplead.amap
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:sil! ".mapmode."unmap ".dobuffer.amap
   if maparg(amap,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "sil! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save single map <something>
  elseif strpart(a:mapchx,0,1) == '<'
"   call Decho("save single map <something>")
   let amap       = a:mapchx
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
"	call Decho("amap[[".amap."]]")
   endif
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
   if maparg(a:mapchx,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "sil! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save multiple maps
  else
"   call Decho("save multiple maps")
   let i= 1
   while i <= strlen(a:mapchx)
    let amap= a:maplead.strpart(a:mapchx,i-1,1)
	if amap == "|" || amap == "\<c-v>"
	 let amap= "\<c-v>".amap
	endif
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
    if maparg(amap,mapmode) != ""
     let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	 let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
    endif
	if dounmap
	 exe "sil! ".mapmode."unmap ".dobuffer.amap
	endif
    let i= i + 1
   endwhile
  endif
"  call Dret("SaveUserMaps : s:restoremap_".a:suffix.": ".s:restoremap_{a:suffix})
endfun

" ---------------------------------------------------------------------
" RestoreUserMaps: {{{2
"   Used to restore user maps saved by SaveUserMaps()
fun! RestoreUserMaps(suffix)
"  call Dfunc("RestoreUserMaps(suffix<".a:suffix.">)")
  if exists("s:restoremap_{a:suffix}")
   let s:restoremap_{a:suffix}= substitute(s:restoremap_{a:suffix},'|\s*$','','e')
   if s:restoremap_{a:suffix} != ""
"   	call Decho("exe ".s:restoremap_{a:suffix})
    exe "sil! ".s:restoremap_{a:suffix}
   endif
   unlet s:restoremap_{a:suffix}
  endif
"  call Dret("RestoreUserMaps")
endfun

" ==============
"  Restore: {{{1
" ==============
let &cpo= s:keepcpo
unlet s:keepcpo

" ================
"  Modelines: {{{1
" ================
" vim: ts=4 fdm=marker
doc/HiMtchBrkt.txt	[[[1
301
*himtchbrkt.txt*	The HiMtchBrkt Tool		Feb 22, 2011

Author:  Charles E. Campbell  <NdrOchip@ScampbellPfamily.AbizM>
	  (remove NOSPAM from Campbell's email first)
Copyright: (c) 2004-2011 by Charles E. Campbell	*himtchbrkt-copyright*
           The VIM LICENSE applies to HiMtchBrkt.vim and HiMtchBrkt.txt
           (see |copyright|) except use "HiMtchBrkt" instead of "Vim"
	   No warranty, express or implied.  Use At-Your-Own-Risk.

==============================================================================
1. Contents						*himtchbrkt-contents*

	1. Contents......................: |himtchbrkt-contents|
	2. Installing HiMtchBrkt.........: |himtchbrkt-install|
	3. HiMtchBrkt Manual.............: |himtchbrkt|
	4. HiMtchBrkt Usage..............: |himtchbrkt-usage|
	     Starting....................: |himtchbrkt-start|
	     Options.....................: |himtchbrkt-options|
	     Stopping....................: |himtchbrkt-stopping|
	     User Map Protection.........: |himtchbrkt-protect|
	     HiMtchBrkt Options..........: |himtchbrkt-option|
	5. History.......................: |himtchbrkt-history|


==============================================================================
2. Installing HiMtchBrkt				*himtchbrkt-install*

    1. Move/copy HiMtchBrkt.tar.gz to
         unix/linux: ~/.vim
	 Windows   : ...\vimfiles
    2. gunzip HiMtchBrkt.tar.gz
    3. tar -oxvf HiMtchBrkt.tar
    4. vim
       :helptags doc
       :q
    5. This step is only for those who wish to have HiMtchBrkt start up
       automatically:

       a) if you want HiMtchBrkt to start up for all files:
          Put the following line in your <.vimrc> (or vimfiles, for Windows): >

	  let g:HiMtchBrktOn= 1
<
       b) if you want HiMtchBrkt to start up automatically but only for
          specific filetypes.  For example, assume such a filetype is
	  for the C language: >

          mkdir ftplugin  (if ftplugin/ doesn't already exist)
	  cd ftplugin
	  mkdir c         (if ftplugin/c doesn't already exist)
	  cd c
	  echo "HMBstart" >> c.vim
<

==============================================================================
3. HiMtchBrkt Manual					*himtchbrkt*
							*himtchbrkt-manual*
	To Enable:

 /================+============================================================\
 || Starting &    |                                                           ||
 || Stopping      | Explanation                                               ||
 ++---------------+-----------------------------------------------------------++
 || <Leader>[i    | start HiMtchBrkt   (via a map)                            ||
 || <Leader>[s    | stop  HiMtchBrkt   (via a map)                            ||
 ++---------------+-----------------------------------------------------------++
 || :HMBstart     | start HiMtchBrkt   (via a command)                        ||
 || :HMBstop      | stop  HiMtchBrkt   (via a command)                        ||
 || :HMBsurround  | enable HiMtchBrkt surrounding bracket mode                ||
 || :HMBsurround! | enable HiMtchBrkt matching-bracket mode                   ||
 ++===============+===========================================================++

 You may also choose from the DrChip.HiMtchBrkt menu items if you're running
 gvim.  Check on vim's help for mapleader |mapleader| to learn how to set
 <Leader>; by default its the backslash - ie. by default \[i will start and
 \[s will stop HiMtchBrkt.

==============================================================================
4. HiMtchBrkt Usage					*himtchbrkt-usage*

    See |himtchbrkt-start| and |himtchbrkt-stop| for how to start and
    stop HiMtchBrkt.

    The HiMtchBrkt plugin highlights the matching bracket or the surrounding
    brackets

   	e.g. (){}[]  (actually the |'matchpairs'| option is used)

    when the cursor is moved on top of the bracket.

    For version 7.0 of vim (you'll need snapshot#195 or later), HiMtchBrkt
    uses the CursorMoved and CursorMovedI events to trigger the highlightinhg
    of matching/surrounding brackets.

    For version 6.0 of vim it does so by making a fair number of maps that
    intercept the requested motion, perform the requested motion, then also
    call the HiMatchBracket() function which does the work to highlight any
    matching bracket.  Basically it does a "%" to find the matching bracket
    (if any) and then constructs and executes an appropriate ":match" command.

    As of version 10 of HiMtchBrkt, such overloaded motions include:

    	,  E   F)  k      <down>
    	;  f(  F[  l      <end>
    	$  f)  F]  w      <home>
    	%  f[  F{  <c-b>  <left>
    	0  f]  F}  <c-d>  <leftmouse>
    	b  f{  h   <c-f>  <right>
    	B  f}  j   <c-u>  <up>
    	e  F(

    Version 12 of HiMtchBrkt supports overloading of 0, too (if you have
    vim6.2 and patch 405 or later).

    (for vim version 6.0) Because vim is rich with commands that can move the
    cursor, the script also uses the CursorHold event (see |CursorHold| and
    |'updatetime'|) to highlight matching brackets after the cursor is left
    still for awhile.

STARTING					*himtchbrkt-start* *HMBstart*
    <Leader>[i
    :HMBstart
    :HMBsurround
    let g:HiMtchBrktOn= 1   (in your .vimrc or vimfiles)

    Typically one puts <himtchbrkt.vim> into the .vim/plugin directory
    (vimfiles\plugin for MS) where it becomes always available.  It uses a
    either of the following two commands to start:

	<Leader>[i: initialize highlighting of matching brackets
	            (by default its \[i)
    or
	:HMBstart

    A message, "[HiMtchBrkt]", will appear on the message line.

    If you want to have HiMtchBrkt on by default, you may find
    tip #411 (http://vim.sourceforge.net/tips/tip.php?tip_id=411) on
    "How To Initialize a Plugin" helpful.

OPTIONS							*himtchbrkt-options*

    g:HiMtchBrktOn					*himtchbrkt-on*

	If this option exists and is not zero (ie. set it in your
	.vimrc file), then HiMtchBrkt will both load and start on.
	
    g:HiMtchBrkt_nocursorhold			*himtchbrkt-nocursorhold*

    	If g:himtchbrkt_nocursorhold exists, then the CursorHold event will
	not be used to check on matching brackets:

    	Although a large number of ways to move the cursor have been
	overloaded with a call to HiMatchBracket() (plus the move), it is
	quite possible that some have been overlooked or are performed by some
	other function that HiMtchBrkt.vim doesn't know about.  These
	situations are normally handled by CursorHold events -- after a period
	of time of inactivity, a CursorHold event occurs and a HiMtchBrkt
	check is made.

    	Unfortunately, when a CursorHold event occurs, any command-line
	messages disappear.

    g:HiMtchBrkt_surround		*himtchbrkt-surround* *HMBsurround*
	When this variable exists and is true (ie. non-zero), then
	HiMtchBrkt will highlight both brackets surrounding the cursor
	position.  This variable is turned on and off by :HMBsurround
	and :HMBsurround!, respectively.

    g:HiMtchBrkt_ut					*himtchbrkt-ut*

	This optional variable controls how long the period of activity
	will be, in milliseconds (see |'ut'|).  By default HiMtchBrkt
	will set it to 20ms.  Thus HiMtchBrkt responds rapidly to both
	known motion commands and to "new" ones.  Again, the disadvantage
	is that messages disappear when the CursorEvent takes effect.


STOPPING		*himtchbrkt-stop* *himtchbrkt-stopping* *HMBstop*
    <Leader>[s

    When you are done with HiMtchBrkt, use

	    <Leader>[s: stop highlighting of matching brackets
	            	(by default its \[s)
    or
	    :HMBstop

    to terminate HiMtchBrkt mode.  Either of these will restore your usual
    options and remove the maps HiMtchBrkt set up.

    A message, "[HiMtchBrkt off]", will appear on the message line.

USER MAP PROTECTION					*himtchbrkt-protect*

    Starting HiMtchBrkt causes it to set up a number of maps which enables
    the highlighting of matching brackets in normal mode.  A few keypad
    entries in insert mode are also supported (up, down, right, left, home,
    and end).

HIGHLIGHTING MATCHING BRACKET OPTIONS			*himtchbrkt-option*

    g:DrChipTopLvlMenu

	By default its "DrChip"; however, you may set this to whatever you
	like in your <.vimrc>.  This variable controls where HiMtchBrkt's menu
	items are placed.  Of course, you must be using gvim and have menu
	support.

==============================================================================
5. HiMtchBrkt History					*himtchbrkt-history*

    (began this history rather late I'm afraid)
    v23  03/01/06: * SaveWinPosn()/RestoreWinPosn() are no longer needed for
                     vim 7.0aa (uses searchpairpos() only)
                   * bugfix: visual-block yank-put wasn't working properly
	 05/20/09  * cecutil bugfix
	 10/28/09  * (Christophe Royer) menu entries use :HMBstart and :HMBstop
		     instead of maps (<Leader>[i and<Leader>[s)
		   * (Christophe Royer) avoids highlighting of brackets while
		     in either visual-map or select modes.
	 10/28/09  * added :HiMtchBrkt[!] command to toggle HiMtchBrkt on/off
		     (the ! also turns HMBsurround mode on).
	 02/22/11  * for menus, &go =~# used to insure correct case
    v22  02/13/06: * bugfix: :HMBstop now also removes the CursorMove events
         02/15/06  * bugfix: CursorMovedI event prevented inserting normal
                     characters from proceeding properly.  Currently its been
                     removed.
         02/21/06  * HiMtchBrkt now uses searchpairpos() to speed up
                     determination of matching/surrounding brackets; this
                     is used for version 7 (or later) of vim only.
         02/28/06  * uses line("w0") and line("w$") and the new stopline
                     parameter for searchpair*() to speed up setting up
                     the match (vim v7 only)
    v21  02/10/06: * :HMBsurround will start HiMtchBrkt mode if it needs to.
                   * Menus are adjusted to show Surround On/Off choices
         02/13/06  * HiMtchBrkt now takes advantage of the new CursorMoved
                     and CursorMovedI events
    v20  01/19/06: * HMBMapper() now made script-local (s:HMBMapper())
         01/20/06  * g:HiMtchBrktOn == 1 will auto-start HiMtchBrkt
         01/20/06  * g:HiMtchBrktOn variable for auto-startup installed
         01/23/06  * "norm! yl" used instead of "norm! vy" to grab a copy
                     of the character under the cursor without clearing
                     messages (with vim7.0aa snapshot#185)
         02/09/06  * HMBsurround implemented (surrounding brackets highlighted)
    v19  01/12/06: * will now append its maps to any pre-existing maps.  If
                     HMBstarted _after_ other plugins with maps have loaded,
                     then HiMtchBrkt will work with them (in particular, if
                     HiMtchBrkt is started _after_ matchit.vim, then both
                     will work together).
                   * bugfix with gvim+keys while in normal mode
                   * CursorHold on an empty buffer no longer calls
                     HiMtchBracket() (tnx to Gary Johnson)
        01/17/06   * Worked around the scrolloffset option
    v18  01/03/06: * unwanted blinking and other unfortunate behavior; setting
                     sol (temporarily) to see if its fixed
                   * g:himtchbrkt_ut option included
    v15  12/22/05: * SaveMap() was issuing an error message, which had
                     already been protected against with a maparg() check.
                     Applied silent!.
         12/28/05  * now uses cecutil to save/restore user maps
    v14  03/07/05: * At Armin Sander's suggestion, I moved the anti-beep
                     code from start/stop to every HiMtchBrkt invocation.
                     That way HiMtchBrkt will only stop itself from beeping
                   * Added g:himtchbrkt_nocursorhold option when there are
                     unmatched brackets.
         08/26/05  * HiMtchBrkt, upon initialization, will set whichwrap option
                     (to b,s,<,>,[,]) and will restore the user's original
                     whichwrap option setting upon termination
         08/31/05  * Added commands: :HMBstart and :HMBstop
                   * Internal maps used to overload arrow-key motions
                     now use jklh style motions for the sake of celerity
         12/22/05  * if g:HiMtchBrktOn is true, then HiMtchBrkt will begin
                     in bracket matching mode
    v13  08/17/04: * global variables now prefixed with himtchbrkt_
                   * now set CursorHold/FocusGained update time to 200ms
         10/29/04  * marker-based folding installed
                   * Now uses Search (instead of Special) highlighting
    v12  03/26/04: if vim6.2 and has patch405, then the 0 command is
                   also handled
    v11  11/24/03: the "b" motion inadvertently got disabled, now fixed
    v10  11/24/03: incorporated Benji Fisher's suggestions for
                   improvements to document, incorporating CursorHold
                   event, globalize dohimtchbrkt, using matchpairs
                   option instead of hardcoded [](){}.
                   Includes M Geddes' fix for \%#v instead of \%#c
    v9   03/10/03: fixed bug (col() -> virtcol() )
    v7   02/11/03: retains position, even with widely separated {}
                   some optimization
                   restores @0
    v6   05/28/02: has("menu") included with menu tests
    v4   05/23/02: eliminated a console-vim bug with g:DrChipTopLvlMenu
    v3   04/11/02: Added e,B,E and <leftmouse> to movements supported
                   (Thanks to Nidhir Kumar for suggesting e and <leftmouse>)
                   Start/Stop menu items now toggle
    v2   03/14/02: Thanks to Dan Sharp for suggesting <home>, <end>,
                   and g:DrChipTopLvlMenu
    v1   epoch

=====================================================================
vim:tw=78:ts=8:ft=help:sts=4