<h2>Editing File: /usr/share/vim/vim80/autoload/vimball.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; vimball.vim : construct a file containing both paths and files
&quot; Author:	Charles E. Campbell
&quot; Date:		Apr 11, 2016
&quot; Version:	37
&quot; GetLatestVimScripts: 1502 1 :AutoInstall: vimball.vim
&quot; Copyright: (c) 2004-2011 by Charles E. Campbell
&quot;            The VIM LICENSE applies to Vimball.vim, and Vimball.txt
&quot;            (see |copyright|) except use &quot;Vimball&quot; instead of &quot;Vim&quot;.
&quot;            No warranty, express or implied.
&quot;  *** ***   Use At-Your-Own-Risk!   *** ***

&quot; ---------------------------------------------------------------------
&quot;  Load Once: {{{1
if &amp;cp || exists(&quot;g:loaded_vimball&quot;)
 finish
endif
let g:loaded_vimball = &quot;v37&quot;
if v:version &lt; 702
 echohl WarningMsg
 echo &quot;***warning*** this version of vimball needs vim 7.2&quot;
 echohl Normal
 finish
endif
let s:keepcpo= &amp;cpo
set cpo&amp;vim
&quot;DechoTabOn

&quot; =====================================================================
&quot; Constants: {{{1
if !exists(&quot;s:USAGE&quot;)
 let s:USAGE   = 0
 let s:WARNING = 1
 let s:ERROR   = 2

 &quot; determine if cygwin is in use or not
 if !exists(&quot;g:netrw_cygwin&quot;)
  if has(&quot;win32&quot;) || has(&quot;win95&quot;) || has(&quot;win64&quot;) || has(&quot;win16&quot;)
   if &amp;shell =~ '\%(\&lt;bash\&gt;\|\&lt;zsh\&gt;\)\%(\.exe\)\=$'
    let g:netrw_cygwin= 1
   else
    let g:netrw_cygwin= 0
   endif
  else
   let g:netrw_cygwin= 0
  endif
 endif

 &quot; set up g:vimball_mkdir if the mkdir() call isn't defined
 if !exists(&quot;*mkdir&quot;)
  if exists(&quot;g:netrw_local_mkdir&quot;)
   let g:vimball_mkdir= g:netrw_local_mkdir
  elseif executable(&quot;mkdir&quot;)
   let g:vimball_mkdir= &quot;mkdir&quot;
  elseif executable(&quot;makedir&quot;)
   let g:vimball_mkdir= &quot;makedir&quot;
  endif
  if !exists(g:vimball_mkdir)
   call vimball#ShowMesg(s:WARNING,&quot;(vimball) g:vimball_mkdir undefined&quot;)
  endif
 endif
endif

&quot; =====================================================================
&quot;  Functions: {{{1

&quot; ---------------------------------------------------------------------
&quot; vimball#MkVimball: creates a vimball given a list of paths to files {{{2
&quot; Input:
&quot;     line1,line2: a range of lines containing paths to files to be included in the vimball
&quot;     writelevel : if true, force a write to filename.vmb, even if it exists
&quot;                  (usually accomplished with :MkVimball! ...
&quot;     filename   : base name of file to be created (ie. filename.vmb)
&quot; Output: a filename.vmb using vimball format:
&quot;     path
&quot;     filesize
&quot;     [file]
&quot;     path
&quot;     filesize
&quot;     [file]
fun! vimball#MkVimball(line1,line2,writelevel,...) range
&quot;  call Dfunc(&quot;MkVimball(line1=&quot;.a:line1.&quot; line2=&quot;.a:line2.&quot; writelevel=&quot;.a:writelevel.&quot; vimballname&lt;&quot;.a:1.&quot;&gt;) a:0=&quot;.a:0)
  if a:1 =~ '\.vim$' || a:1 =~ '\.txt$'
   let vbname= substitute(a:1,'\.\a\{3}$','.vmb','')
  else
   let vbname= a:1
  endif
  if vbname !~ '\.vmb$'
   let vbname= vbname.'.vmb'
  endif
&quot;  call Decho(&quot;vbname&lt;&quot;.vbname.&quot;&gt;&quot;)
  if !a:writelevel &amp;&amp; a:1 =~ '[\/]'
   call vimball#ShowMesg(s:ERROR,&quot;(MkVimball) vimball name&lt;&quot;.a:1.&quot;&gt; should not include slashes; use ! to insist&quot;)
&quot;   call Dret(&quot;MkVimball : vimball name&lt;&quot;.a:1.&quot;&gt; should not include slashes&quot;)
   return
  endif
  if !a:writelevel &amp;&amp; filereadable(vbname)
   call vimball#ShowMesg(s:ERROR,&quot;(MkVimball) file&lt;&quot;.vbname.&quot;&gt; exists; use ! to insist&quot;)
&quot;   call Dret(&quot;MkVimball : file&lt;&quot;.vbname.&quot;&gt; already exists; use ! to insist&quot;)
   return
  endif

  &quot; user option bypass
  call vimball#SaveSettings()

  if a:0 &gt;= 2
   &quot; allow user to specify where to get the files
   let home= expand(a:2)
  else
   &quot; use first existing directory from rtp
   let home= vimball#VimballHome()
  endif

  &quot; save current directory
  let curdir = getcwd()
  call s:ChgDir(home)

  &quot; record current tab, initialize while loop index
  let curtabnr = tabpagenr()
  let linenr   = a:line1
&quot;  call Decho(&quot;curtabnr=&quot;.curtabnr)

  while linenr &lt;= a:line2
   let svfile  = getline(linenr)
&quot;   call Decho(&quot;svfile&lt;&quot;.svfile.&quot;&gt;&quot;)
 
   if !filereadable(svfile)
    call vimball#ShowMesg(s:ERROR,&quot;unable to read file&lt;&quot;.svfile.&quot;&gt;&quot;)
	call s:ChgDir(curdir)
	call vimball#RestoreSettings()
&quot;    call Dret(&quot;MkVimball&quot;)
    return
   endif
 
   &quot; create/switch to mkvimball tab
   if !exists(&quot;vbtabnr&quot;)
    tabnew
    sil! file Vimball
    let vbtabnr= tabpagenr()
   else
    exe &quot;tabn &quot;.vbtabnr
   endif
 
   let lastline= line(&quot;$&quot;) + 1
   if lastline == 2 &amp;&amp; getline(&quot;$&quot;) == &quot;&quot;
	call setline(1,'&quot; Vimball Archiver by Charles E. Campbell')
	call setline(2,'UseVimball')
	call setline(3,'finish')
	let lastline= line(&quot;$&quot;) + 1
   endif
   call setline(lastline  ,substitute(svfile,'$','	[[[1',''))
   call setline(lastline+1,0)

   &quot; write the file from the tab
&quot;   call Decho(&quot;exe $r &quot;.fnameescape(svfile))
   exe &quot;$r &quot;.fnameescape(svfile)

   call setline(lastline+1,line(&quot;$&quot;) - lastline - 1)
&quot;   call Decho(&quot;lastline=&quot;.lastline.&quot; line$=&quot;.line(&quot;$&quot;))

  &quot; restore to normal tab
   exe &quot;tabn &quot;.curtabnr
   let linenr= linenr + 1
  endwhile

  &quot; write the vimball
  exe &quot;tabn &quot;.vbtabnr
  call s:ChgDir(curdir)
  setlocal ff=unix
  if a:writelevel
&quot;   call Decho(&quot;exe w! &quot;.fnameescape(vbname))
   exe &quot;w! &quot;.fnameescape(vbname)
  else
&quot;   call Decho(&quot;exe w &quot;.fnameescape(vbname))
   exe &quot;w &quot;.fnameescape(vbname)
  endif
&quot;  call Decho(&quot;Vimball&lt;&quot;.vbname.&quot;&gt; created&quot;)
  echo &quot;Vimball&lt;&quot;.vbname.&quot;&gt; created&quot;

  &quot; remove the evidence
  setlocal nomod bh=wipe
  exe &quot;tabn &quot;.curtabnr
  exe &quot;tabc! &quot;.vbtabnr

  &quot; restore options
  call vimball#RestoreSettings()

&quot;  call Dret(&quot;MkVimball&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#Vimball: extract and distribute contents from a vimball {{{2
&quot;                  (invoked the the UseVimball command embedded in 
&quot;                  vimballs' prologue)
fun! vimball#Vimball(really,...)
&quot;  call Dfunc(&quot;vimball#Vimball(really=&quot;.a:really.&quot;) a:0=&quot;.a:0)

  if v:version &lt; 701 || (v:version == 701 &amp;&amp; !exists('*fnameescape'))
   echoerr &quot;your vim is missing the fnameescape() function (pls upgrade to vim 7.2 or later)&quot;
&quot;   call Dret(&quot;vimball#Vimball : needs 7.1 with patch 299 or later&quot;)
   return
  endif

  if getline(1) !~ '^&quot; Vimball Archiver'
   echoerr &quot;(Vimball) The current file does not appear to be a Vimball!&quot;
&quot;   call Dret(&quot;vimball#Vimball&quot;)
   return
  endif

  &quot; set up standard settings
  call vimball#SaveSettings()
  let curtabnr    = tabpagenr()
  let vimballfile = expand(&quot;%:tr&quot;)

  &quot; set up vimball tab
&quot;  call Decho(&quot;setting up vimball tab&quot;)
  tabnew
  sil! file Vimball
  let vbtabnr= tabpagenr()
  let didhelp= &quot;&quot;

  &quot; go to vim plugin home
  if a:0 &gt; 0
   &quot; let user specify the directory where the vimball is to be unpacked.
   &quot; If, however, the user did not specify a full path, set the home to be below the current directory
   let home= expand(a:1)
   if has(&quot;win32&quot;) || has(&quot;win95&quot;) || has(&quot;win64&quot;) || has(&quot;win16&quot;)
	if home !~ '^\a:[/\\]'
	 let home= getcwd().'/'.a:1
	endif
   elseif home !~ '^/'
	let home= getcwd().'/'.a:1
   endif
  else
   let home= vimball#VimballHome()
  endif
&quot;  call Decho(&quot;home&lt;&quot;.home.&quot;&gt;&quot;)

  &quot; save current directory and remove older same-named vimball, if any
  let curdir = getcwd()
&quot;  call Decho(&quot;home&lt;&quot;.home.&quot;&gt;&quot;)
&quot;  call Decho(&quot;curdir&lt;&quot;.curdir.&quot;&gt;&quot;)

  call s:ChgDir(home)
  let s:ok_unablefind= 1
  call vimball#RmVimball(vimballfile)
  unlet s:ok_unablefind

  let linenr  = 4
  let filecnt = 0

  &quot; give title to listing of (extracted) files from Vimball Archive
  if a:really
   echohl Title     | echomsg &quot;Vimball Archive&quot;         | echohl None
  else             
   echohl Title     | echomsg &quot;Vimball Archive Listing&quot; | echohl None
   echohl Statement | echomsg &quot;files would be placed under: &quot;.home | echohl None
  endif

  &quot; apportion vimball contents to various files
&quot;  call Decho(&quot;exe tabn &quot;.curtabnr)
  exe &quot;tabn &quot;.curtabnr
&quot;  call Decho(&quot;linenr=&quot;.linenr.&quot; line$=&quot;.line(&quot;$&quot;))
  while 1 &lt; linenr &amp;&amp; linenr &lt; line(&quot;$&quot;)
   let fname   = substitute(getline(linenr),'\t\[\[\[1$','','')
   let fname   = substitute(fname,'\\','/','g')
   let fsize   = substitute(getline(linenr+1),'^\(\d\+\).\{-}$','\1','')+0
   let fenc    = substitute(getline(linenr+1),'^\d\+\s*\(\S\{-}\)$','\1','')
   let filecnt = filecnt + 1
&quot;   call Decho(&quot;fname&lt;&quot;.fname.&quot;&gt; fsize=&quot;.fsize.&quot; filecnt=&quot;.filecnt. &quot; fenc=&quot;.fenc)

   if fname =~? '\%(^\|/\)\.VimballRecord$'
     echomsg &quot;(Vimball) Forbidding .VimballRecord filename, aborting...&quot;
     exe &quot;tabn &quot;.curtabnr
     call s:ChgDir(curdir)
     call vimball#RestoreSettings()
     return
   endif

   if a:really
    echomsg &quot;extracted &lt;&quot;.fname.&quot;&gt;: &quot;.fsize.&quot; lines&quot;
   else
    echomsg &quot;would extract &lt;&quot;.fname.&quot;&gt;: &quot;.fsize.&quot; lines&quot;
   endif
&quot;   call Decho(&quot;using L#&quot;.linenr.&quot;: will extract file&lt;&quot;.fname.&quot;&gt;&quot;)
&quot;   call Decho(&quot;using L#&quot;.(linenr+1).&quot;: fsize=&quot;.fsize)

   &quot; Allow AsNeeded/ directory to take place of plugin/ directory
   &quot; when AsNeeded/filename is filereadable or was present in VimballRecord
   if fname =~ '\&lt;plugin/'
   	let anfname= substitute(fname,'\&lt;plugin/','AsNeeded/','')
	if filereadable(anfname) || (exists(&quot;s:VBRstring&quot;) &amp;&amp; s:VBRstring =~# anfname)
&quot;	 call Decho(&quot;using anfname&lt;&quot;.anfname.&quot;&gt; instead of &lt;&quot;.fname.&quot;&gt;&quot;)
	 let fname= anfname
	endif
   endif

   &quot; make directories if they don't exist yet
   if a:really
&quot;    call Decho(&quot;making directories if they don't exist yet (fname&lt;&quot;.fname.&quot;&gt;)&quot;)
    let fnamebuf= substitute(fname,'\\','/','g')
	let dirpath = substitute(home,'\\','/','g')
&quot;	call Decho(&quot;init: fnamebuf&lt;&quot;.fnamebuf.&quot;&gt;&quot;)
&quot;	call Decho(&quot;init: dirpath &lt;&quot;.dirpath.&quot;&gt;&quot;)
    while fnamebuf =~ '/'
     let dirname  = dirpath.&quot;/&quot;.substitute(fnamebuf,'/.*$','','')
	 let dirpath  = dirname
     let fnamebuf = substitute(fnamebuf,'^.\{-}/\(.*\)$','\1','')
&quot;	 call Decho(&quot;dirname&lt;&quot;.dirname.&quot;&gt;&quot;)
&quot;	 call Decho(&quot;dirpath&lt;&quot;.dirpath.&quot;&gt;&quot;)
     if !isdirectory(dirname)
&quot;      call Decho(&quot;making &lt;&quot;.dirname.&quot;&gt;&quot;)
      if exists(&quot;g:vimball_mkdir&quot;)
	   call system(g:vimball_mkdir.&quot; &quot;.shellescape(dirname))
      else
       call mkdir(dirname)
      endif
	  call s:RecordDirInVar(dirname)
     endif
    endwhile
   endif
   call s:ChgDir(home)

   &quot; grab specified qty of lines and place into &quot;a&quot; buffer
   &quot; (skip over path/filename and qty-lines)
   let linenr   = linenr + 2
   let lastline = linenr + fsize - 1
&quot;   call Decho(&quot;exe &quot;.linenr.&quot;,&quot;.lastline.&quot;yank a&quot;)
   &quot; no point in handling a zero-length file
   if lastline &gt;= linenr
    exe &quot;silent &quot;.linenr.&quot;,&quot;.lastline.&quot;yank a&quot;

    &quot; copy &quot;a&quot; buffer into tab
&quot;   call Decho('copy &quot;a buffer into tab#'.vbtabnr)
    exe &quot;tabn &quot;.vbtabnr
    setlocal ma
    sil! %d
    silent put a
    1
    sil! d

    &quot; write tab to file
    if a:really
     let fnamepath= home.&quot;/&quot;.fname
&quot;    call Decho(&quot;exe w! &quot;.fnameescape(fnamepath))
	if fenc != &quot;&quot;
	 exe &quot;silent w! ++enc=&quot;.fnameescape(fenc).&quot; &quot;.fnameescape(fnamepath)
	else
	 exe &quot;silent w! &quot;.fnameescape(fnamepath)
	endif
	echo &quot;wrote &quot;.fnameescape(fnamepath)
	call s:RecordInVar(fnamepath)
    endif

    &quot; return to tab with vimball
&quot;   call Decho(&quot;exe tabn &quot;.curtabnr)
    exe &quot;tabn &quot;.curtabnr

    &quot; set up help if it's a doc/*.txt file
&quot;   call Decho(&quot;didhelp&lt;&quot;.didhelp.&quot;&gt; fname&lt;&quot;.fname.&quot;&gt;&quot;)
    if a:really &amp;&amp; didhelp == &quot;&quot; &amp;&amp; fname =~ 'doc/[^/]\+\.\(txt\|..x\)$'
    	let didhelp= substitute(fname,'^\(.*\&lt;doc\)[/\\][^.]*\.\(txt\|..x\)$','\1','')
&quot;	call Decho(&quot;didhelp&lt;&quot;.didhelp.&quot;&gt;&quot;)
    endif
   endif

   &quot; update for next file
&quot;   call Decho(&quot;update linenr= [linenr=&quot;.linenr.&quot;] + [fsize=&quot;.fsize.&quot;] = &quot;.(linenr+fsize))
   let linenr= linenr + fsize
  endwhile

  &quot; set up help
&quot;  call Decho(&quot;about to set up help: didhelp&lt;&quot;.didhelp.&quot;&gt;&quot;)
  if didhelp != &quot;&quot;
   let htpath= home.&quot;/&quot;.didhelp
&quot;   call Decho(&quot;exe helptags &quot;.htpath)
   exe &quot;helptags &quot;.fnameescape(htpath)
   echo &quot;did helptags&quot;
  endif

  &quot; make sure a &quot;Press ENTER...&quot; prompt appears to keep the messages showing!
  while filecnt &lt;= &amp;ch
   echomsg &quot; &quot;
   let filecnt= filecnt + 1
  endwhile

  &quot; record actions in &lt;.VimballRecord&gt;
  call s:RecordInFile(home)

  &quot; restore events, delete tab and buffer
  exe &quot;sil! tabn &quot;.vbtabnr
  setlocal nomod bh=wipe
  exe &quot;sil! tabn &quot;.curtabnr
  exe &quot;sil! tabc! &quot;.vbtabnr
  call vimball#RestoreSettings()
  call s:ChgDir(curdir)

&quot;  call Dret(&quot;vimball#Vimball&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#RmVimball: remove any files, remove any directories made by any {{{2
&quot;               previous vimball extraction based on a file of the current
&quot;               name.
&quot;  Usage:  RmVimball  (assume current file is a vimball; remove)
&quot;          RmVimball vimballname
fun! vimball#RmVimball(...)
&quot;  call Dfunc(&quot;vimball#RmVimball() a:0=&quot;.a:0)
  if exists(&quot;g:vimball_norecord&quot;)
&quot;   call Dret(&quot;vimball#RmVimball : (g:vimball_norecord)&quot;)
   return
  endif

  if a:0 == 0
   let curfile= expand(&quot;%:tr&quot;)
&quot;   call Decho(&quot;case a:0=0: curfile&lt;&quot;.curfile.&quot;&gt; (used expand(%:tr))&quot;)
  else
   if a:1 =~ '[\/]'
    call vimball#ShowMesg(s:USAGE,&quot;RmVimball vimballname [path]&quot;)
&quot;    call Dret(&quot;vimball#RmVimball : suspect a:1&lt;&quot;.a:1.&quot;&gt;&quot;)
    return
   endif
   let curfile= a:1
&quot;   call Decho(&quot;case a:0=&quot;.a:0.&quot;: curfile&lt;&quot;.curfile.&quot;&gt;&quot;)
  endif
  if curfile =~ '\.vmb$'
   let curfile= substitute(curfile,'\.vmb','','')
  elseif curfile =~ '\.vba$'
   let curfile= substitute(curfile,'\.vba','','')
  endif
  if a:0 &gt;= 2
   let home= expand(a:2)
  else
   let home= vimball#VimballHome()
  endif
  let curdir = getcwd()
&quot;  call Decho(&quot;home   &lt;&quot;.home.&quot;&gt;&quot;)
&quot;  call Decho(&quot;curfile&lt;&quot;.curfile.&quot;&gt;&quot;)
&quot;  call Decho(&quot;curdir &lt;&quot;.curdir.&quot;&gt;&quot;)

  call s:ChgDir(home)
  if filereadable(&quot;.VimballRecord&quot;)
&quot;   call Decho(&quot;.VimballRecord is readable&quot;)
&quot;   call Decho(&quot;curfile&lt;&quot;.curfile.&quot;&gt;&quot;)
   keepalt keepjumps 1split 
   sil! keepalt keepjumps e .VimballRecord
   let keepsrch= @/
&quot;   call Decho('search for ^\M'.curfile.'.\m: ')
&quot;   call Decho('search for ^\M'.curfile.'.\m{vba|vmb}: ')
&quot;   call Decho('search for ^\M'.curfile.'\m[-0-9.]*\.{vba|vmb}: ')
   if search('^\M'.curfile.&quot;\m: &quot;.'cw')
	let foundit= 1
   elseif search('^\M'.curfile.&quot;.\mvmb: &quot;,'cw')
	let foundit= 2
   elseif search('^\M'.curfile.'\m[-0-9.]*\.vmb: ','cw')
	let foundit= 2
   elseif search('^\M'.curfile.&quot;.\mvba: &quot;,'cw')
	let foundit= 1
   elseif search('^\M'.curfile.'\m[-0-9.]*\.vba: ','cw')
	let foundit= 1
   else
    let foundit = 0
   endif
   if foundit
	if foundit == 1
	 let exestring  = substitute(getline(&quot;.&quot;),'^\M'.curfile.'\m\S\{-}\.vba: ','','')
	else
	 let exestring  = substitute(getline(&quot;.&quot;),'^\M'.curfile.'\m\S\{-}\.vmb: ','','')
	endif
    let s:VBRstring= substitute(exestring,'call delete(','','g')
    let s:VBRstring= substitute(s:VBRstring,&quot;[')]&quot;,'','g')
	let nr_files= 0
	for line in split(exestring, '|')
	  if line !~ '^call delete(''[^'']\{-}''\(,&quot;d&quot;\)\?)$'
	    echomsg &quot;ignoring .VimballRecord entry: &quot; line
	  else
	    sil! keepalt keepjumps exe line
	    let nr_files+= 1
	  endif
	endfor
	sil! keepalt keepjumps d
	echomsg &quot;removed &quot;.nr_files.&quot; files&quot;
   else
    let s:VBRstring= ''
	let curfile    = substitute(curfile,'\.vmb','','')
&quot;    call Decho(&quot;unable to find &lt;&quot;.curfile.&quot;&gt; in .VimballRecord&quot;)
	if !exists(&quot;s:ok_unablefind&quot;)
     call vimball#ShowMesg(s:WARNING,&quot;(RmVimball) unable to find &lt;&quot;.curfile.&quot;&gt; in .VimballRecord&quot;)
	endif
   endif
   sil! keepalt keepjumps g/^\s*$/d
   sil! keepalt keepjumps wq!
   let @/= keepsrch
  endif
  call s:ChgDir(curdir)

&quot;  call Dret(&quot;vimball#RmVimball&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#Decompress: attempts to automatically decompress vimballs {{{2
fun! vimball#Decompress(fname,...)
&quot;  call Dfunc(&quot;Decompress(fname&lt;&quot;.a:fname.&quot;&gt;) a:0=&quot;.a:0)

  &quot; decompression:
  if     expand(&quot;%&quot;) =~ '.*\.gz'  &amp;&amp; executable(&quot;gunzip&quot;)
   &quot; handle *.gz with gunzip
   silent exe &quot;!gunzip &quot;.shellescape(a:fname)
   if v:shell_error != 0
	call vimball#ShowMesg(s:WARNING,&quot;(vimball#Decompress) gunzip may have failed with &lt;&quot;.a:fname.&quot;&gt;&quot;)
   endif
   let fname= substitute(a:fname,'\.gz$','','')
   exe &quot;e &quot;.escape(fname,' \')
   if a:0 == 0| call vimball#ShowMesg(s:USAGE,&quot;Source this file to extract it! (:so %)&quot;) | endif

  elseif expand(&quot;%&quot;) =~ '.*\.gz' &amp;&amp; executable(&quot;gzip&quot;)
   &quot; handle *.gz with gzip -d
   silent exe &quot;!gzip -d &quot;.shellescape(a:fname)
   if v:shell_error != 0
	call vimball#ShowMesg(s:WARNING,'(vimball#Decompress) &quot;gzip -d&quot; may have failed with &lt;'.a:fname.&quot;&gt;&quot;)
   endif
   let fname= substitute(a:fname,'\.gz$','','')
   exe &quot;e &quot;.escape(fname,' \')
   if a:0 == 0| call vimball#ShowMesg(s:USAGE,&quot;Source this file to extract it! (:so %)&quot;) | endif

  elseif expand(&quot;%&quot;) =~ '.*\.bz2' &amp;&amp; executable(&quot;bunzip2&quot;)
   &quot; handle *.bz2 with bunzip2
   silent exe &quot;!bunzip2 &quot;.shellescape(a:fname)
   if v:shell_error != 0
	call vimball#ShowMesg(s:WARNING,&quot;(vimball#Decompress) bunzip2 may have failed with &lt;&quot;.a:fname.&quot;&gt;&quot;)
   endif
   let fname= substitute(a:fname,'\.bz2$','','')
   exe &quot;e &quot;.escape(fname,' \')
   if a:0 == 0| call vimball#ShowMesg(s:USAGE,&quot;Source this file to extract it! (:so %)&quot;) | endif

  elseif expand(&quot;%&quot;) =~ '.*\.bz2' &amp;&amp; executable(&quot;bzip2&quot;)
   &quot; handle *.bz2 with bzip2 -d
   silent exe &quot;!bzip2 -d &quot;.shellescape(a:fname)
   if v:shell_error != 0
	call vimball#ShowMesg(s:WARNING,'(vimball#Decompress) &quot;bzip2 -d&quot; may have failed with &lt;'.a:fname.&quot;&gt;&quot;)
   endif
   let fname= substitute(a:fname,'\.bz2$','','')
   exe &quot;e &quot;.escape(fname,' \')
   if a:0 == 0| call vimball#ShowMesg(s:USAGE,&quot;Source this file to extract it! (:so %)&quot;) | endif

  elseif expand(&quot;%&quot;) =~ '.*\.zip' &amp;&amp; executable(&quot;unzip&quot;)
   &quot; handle *.zip with unzip
   silent exe &quot;!unzip &quot;.shellescape(a:fname)
   if v:shell_error != 0
	call vimball#ShowMesg(s:WARNING,&quot;(vimball#Decompress) unzip may have failed with &lt;&quot;.a:fname.&quot;&gt;&quot;)
   endif
   let fname= substitute(a:fname,'\.zip$','','')
   exe &quot;e &quot;.escape(fname,' \')
   if a:0 == 0| call vimball#ShowMesg(s:USAGE,&quot;Source this file to extract it! (:so %)&quot;) | endif
  endif

  if a:0 == 0| setlocal noma bt=nofile fmr=[[[,]]] fdm=marker | endif

&quot;  call Dret(&quot;Decompress&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#ShowMesg: {{{2
fun! vimball#ShowMesg(level,msg)
&quot;  call Dfunc(&quot;vimball#ShowMesg(level=&quot;.a:level.&quot; msg&lt;&quot;.a:msg.&quot;&gt;)&quot;)

  let rulerkeep   = &amp;ruler
  let showcmdkeep = &amp;showcmd
  set noruler noshowcmd
  redraw!

  if &amp;fo =~# '[ta]'
   echomsg &quot;***vimball*** &quot;.a:msg
  else
   if a:level == s:WARNING || a:level == s:USAGE
    echohl WarningMsg
   elseif a:level == s:ERROR
    echohl Error
   endif
   echomsg &quot;***vimball*** &quot;.a:msg
   echohl None
  endif

  if a:level != s:USAGE
   call inputsave()|let ok= input(&quot;Press &lt;cr&gt; to continue&quot;)|call inputrestore()
  endif

  let &amp;ruler   = rulerkeep
  let &amp;showcmd = showcmdkeep

&quot;  call Dret(&quot;vimball#ShowMesg&quot;)
endfun
&quot; =====================================================================
&quot; s:ChgDir: change directory (in spite of Windoze) {{{2
fun! s:ChgDir(newdir)
&quot;  call Dfunc(&quot;ChgDir(newdir&lt;&quot;.a:newdir.&quot;&gt;)&quot;)
  if (has(&quot;win32&quot;) || has(&quot;win95&quot;) || has(&quot;win64&quot;) || has(&quot;win16&quot;))
   try
    exe 'silent cd '.fnameescape(substitute(a:newdir,'/','\\','g'))
   catch  /^Vim\%((\a\+)\)\=:E/
    call mkdir(fnameescape(substitute(a:newdir,'/','\\','g')))
    exe 'silent cd '.fnameescape(substitute(a:newdir,'/','\\','g'))
   endtry
  else
   try
    exe 'silent cd '.fnameescape(a:newdir)
   catch  /^Vim\%((\a\+)\)\=:E/
    call mkdir(fnameescape(a:newdir))
    exe 'silent cd '.fnameescape(a:newdir)
   endtry
  endif
&quot;  call Dret(&quot;ChgDir : curdir&lt;&quot;.getcwd().&quot;&gt;&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; s:RecordInVar: record a un-vimball file deletion in the .VimballRecord file {{{2
fun! s:RecordInVar(file)
  if !exists(&quot;s:recordfile&quot;)
    let s:recordfile=[]
  endif
  call add(s:recordfile, 'call delete(' . string(a:file) . ')')
endfun

&quot; s:RecordDirInVar: record a un-vimball dir deletion in the .VimballRecord file {{{2
fun! s:RecordDirInVar(dir)
  if !exists(&quot;s:recorddir&quot;)
    let s:recorddir = []
  endif
  call add(s:recorddir, 'call delete(' . string(a:dir) . ',&quot;d&quot;)')
endfun

&quot; ---------------------------------------------------------------------
&quot; s:RecordInFile: {{{2
fun! s:RecordInFile(home)
&quot;  call Dfunc(&quot;s:RecordInFile()&quot;)
  if exists(&quot;g:vimball_norecord&quot;)
&quot;   call Dret(&quot;s:RecordInFile : g:vimball_norecord&quot;)
   return
  endif

  if exists(&quot;s:recordfile&quot;) || exists(&quot;s:recorddir&quot;)
   let curdir= getcwd()
   call s:ChgDir(a:home)
   keepalt keepjumps 1split 

   let cmd= expand(&quot;%:tr&quot;).&quot;: &quot;
&quot;   call Decho(&quot;cmd&lt;&quot;.cmd.&quot;&gt;&quot;)

   sil! keepalt keepjumps e .VimballRecord
   setlocal ma
   $
   if exists(&quot;s:recordfile&quot;) &amp;&amp; exists(&quot;s:recorddir&quot;)
   	let cmd= cmd.join(s:recordfile, '|').&quot;|&quot;.join(s:recorddir, '|')
   elseif exists(&quot;s:recorddir&quot;)
   	let cmd= cmd.join(s:recorddir, '|')
   elseif exists(&quot;s:recordfile&quot;)
   	let cmd= cmd.join(s:recordfile, '|')
   else
&quot;    call Dret(&quot;s:RecordInFile : neither recordfile nor recorddir exist&quot;)
	return
   endif
&quot;   call Decho(&quot;cmd&lt;&quot;.cmd.&quot;&gt;&quot;)

   &quot; put command into buffer, write .VimballRecord `file
   keepalt keepjumps put=cmd
   sil! keepalt keepjumps g/^\s*$/d
   sil! keepalt keepjumps wq!
   call s:ChgDir(curdir)

   if exists(&quot;s:recorddir&quot;)
&quot;	call Decho(&quot;unlet s:recorddir&lt;&quot;.s:recorddir.&quot;&gt;&quot;)
   	unlet s:recorddir
   endif
   if exists(&quot;s:recordfile&quot;)
&quot;	call Decho(&quot;unlet s:recordfile&lt;&quot;.s:recordfile.&quot;&gt;&quot;)
   	unlet s:recordfile
   endif
  else
&quot;   call Decho(&quot;s:record[file|dir] doesn't exist&quot;)
  endif

&quot;  call Dret(&quot;s:RecordInFile&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#VimballHome: determine/get home directory path (usually from rtp) {{{2
fun! vimball#VimballHome()
&quot;  call Dfunc(&quot;vimball#VimballHome()&quot;)
  if exists(&quot;g:vimball_home&quot;)
   let home= g:vimball_home
  else
   &quot; go to vim plugin home
   for home in split(&amp;rtp,',') + ['']
    if isdirectory(home) &amp;&amp; filewritable(home) | break | endif
	let basehome= substitute(home,'[/\\]\.vim$','','')
    if isdirectory(basehome) &amp;&amp; filewritable(basehome)
	 let home= basehome.&quot;/.vim&quot;
	 break
	endif
   endfor
   if home == &quot;&quot;
    &quot; just pick the first directory
    let home= substitute(&amp;rtp,',.*$','','')
   endif
   if (has(&quot;win32&quot;) || has(&quot;win95&quot;) || has(&quot;win64&quot;) || has(&quot;win16&quot;))
    let home= substitute(home,'/','\\','g')
   endif
  endif
  &quot; insure that the home directory exists
&quot;  call Decho(&quot;picked home&lt;&quot;.home.&quot;&gt;&quot;)
  if !isdirectory(home)
   if exists(&quot;g:vimball_mkdir&quot;)
&quot;	call Decho(&quot;home&lt;&quot;.home.&quot;&gt; isn't a directory -- making it now with g:vimball_mkdir&lt;&quot;.g:vimball_mkdir.&quot;&gt;&quot;)
&quot;    call Decho(&quot;system(&quot;.g:vimball_mkdir.&quot; &quot;.shellescape(home).&quot;)&quot;)
    call system(g:vimball_mkdir.&quot; &quot;.shellescape(home))
   else
&quot;	call Decho(&quot;home&lt;&quot;.home.&quot;&gt; isn't a directory -- making it now with mkdir()&quot;)
    call mkdir(home)
   endif
  endif
&quot;  call Dret(&quot;vimball#VimballHome &lt;&quot;.home.&quot;&gt;&quot;)
  return home
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#SaveSettings: {{{2
fun! vimball#SaveSettings()
&quot;  call Dfunc(&quot;SaveSettings()&quot;)
  let s:makeep  = getpos(&quot;'a&quot;)
  let s:regakeep= @a
  if exists(&quot;+acd&quot;)
   let s:acdkeep = &amp;acd
  endif
  let s:eikeep  = &amp;ei
  let s:fenkeep = &amp;l:fen
  let s:hidkeep = &amp;hidden
  let s:ickeep  = &amp;ic
  let s:lzkeep  = &amp;lz
  let s:pmkeep  = &amp;pm
  let s:repkeep = &amp;report
  let s:vekeep  = &amp;ve
  let s:ffkeep  = &amp;l:ff
  let s:swfkeep = &amp;l:swf
  if exists(&quot;+acd&quot;)
   setlocal ei=all ve=all noacd nofen noic report=999 nohid bt= ma lz pm= ff=unix noswf
  else
   setlocal ei=all ve=all       nofen noic report=999 nohid bt= ma lz pm= ff=unix noswf
  endif
  &quot; vimballs should be in unix format
  setlocal ff=unix
&quot;  call Dret(&quot;SaveSettings&quot;)
endfun

&quot; ---------------------------------------------------------------------
&quot; vimball#RestoreSettings: {{{2
fun! vimball#RestoreSettings()
&quot;  call Dfunc(&quot;RestoreSettings()&quot;)
  let @a      = s:regakeep
  if exists(&quot;+acd&quot;)
   let &amp;acd   = s:acdkeep
  endif
  let &amp;l:fen  = s:fenkeep
  let &amp;hidden = s:hidkeep
  let &amp;ic     = s:ickeep
  let &amp;lz     = s:lzkeep
  let &amp;pm     = s:pmkeep
  let &amp;report = s:repkeep
  let &amp;ve     = s:vekeep
  let &amp;ei     = s:eikeep
  let &amp;l:ff   = s:ffkeep
  if s:makeep[0] != 0
   &quot; restore mark a
&quot;   call Decho(&quot;restore mark-a: makeep=&quot;.string(makeep))
   call setpos(&quot;'a&quot;,s:makeep)
  endif
  if exists(&quot;+acd&quot;)
   unlet s:acdkeep
  endif
  unlet s:regakeep s:eikeep s:fenkeep s:hidkeep s:ickeep s:repkeep s:vekeep s:makeep s:lzkeep s:pmkeep s:ffkeep
&quot;  call Dret(&quot;RestoreSettings&quot;)
endfun

let &amp;cpo = s:keepcpo
unlet s:keepcpo

&quot; ---------------------------------------------------------------------
&quot; Modelines: {{{1
&quot; vim: fdm=marker
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload'>Back to Directory</a>