Initialized vim

.vim/.gitignore

+.VimballRecord
+.netrwhist

.vim/.gitmodules

+[submodule "bundle/diffchar.vim"]
+	path = bundle/diffchar.vim
+	url = https://github.com/vim-scripts/diffchar.vim
+[submodule "bundle/eregex.vim"]
+	path = bundle/eregex.vim
+	url = https://github.com/othree/eregex.vim.git
+[submodule "bundle/nerdtree"]
+	path = bundle/nerdtree
+	url = https://github.com/scrooloose/nerdtree.git
+[submodule "bundle/supertab"]
+	path = bundle/supertab
+	url = git@github.com:ervandew/supertab.git
+[submodule "bundle/syntastic"]
+	path = bundle/syntastic
+	url = https://github.com/scrooloose/syntastic.git
+[submodule "bundle/vim2hs"]
+	path = bundle/vim2hs
+	url = https://github.com/dag/vim2hs
+[submodule "bundle/vim-surround"]
+	path = bundle/vim-surround
+	url = https://github.com/tpope/vim-surround.git

.vim/autoload/deb.vim

+" Vim autoload file for browsing debian package.
+" copyright (C) 2007-2008, arno renevier <arenevier@fdn.fr>
+" Distributed under the GNU General Public License (version 2 or above)
+" Last Change: 2008 april 1
+" 
+" Inspired by autoload/tar.vim by Charles E Campbell
+"
+" Latest version of that file can be found at
+" http://www.fdn.fr/~arenevier/vim/autoload/deb.vim
+" It should also be available at
+" http://www.vim.org/scripts/script.php?script_id=1970
+
+if &cp || exists("g:loaded_deb") || v:version < 700
+    finish
+endif
+let g:loaded_deb= "v1.4"
+
+fun! deb#read(debfile, member)
+
+    " checks if ar and tar are installed
+    if !s:hascmd("ar") || !s:hascmd("tar")
+        return
+    endif
+
+    let l:target = a:member
+
+    let l:archmember = s:dataFileName(a:debfile) " default archive member to extract
+    if l:archmember == ""
+        echohl WarningMsg | echo "***error*** (deb#read) no valid data file found in debian archive"
+        return
+    elseif l:archmember == "data.tar.gz"
+        let l:unpcmp = "tar zxfO "
+    elseif l:archmember == "data.tar.bz2"
+        let l:unpcmp = "tar jxfO "
+    elseif l:archmember == "data.tar.lzma"
+        if !s:hascmd("lzma")
+            return
+        endif
+        let l:unpcmp = "lzma -d | tar xfO "
+    elseif l:archmember == "data.tar"
+        let l:unpcmp = "tar xfO "
+    endif
+
+    if a:member =~ '^\* ' " information control file
+        let l:archmember = "control.tar.gz"
+        let l:target = substitute(l:target, "^\* ", "", "")
+        let l:unpcmp = "tar zxfO "
+    elseif a:member =~ ' -> ' " symbolic link
+        let l:target = split(a:member,' -> ')[0]
+        let l:linkname = split(a:member,' -> ')[1]
+
+        if l:linkname =~ "^\/" " direct symlink: path is already absolute
+            let l:target = ".".l:linkname
+
+        else 
+        " transform relative path to absolute path
+
+            " first, get basename for target
+            let l:target = substitute(l:target, "\/[^/]*$", "", "")
+
+            " while it begins with ../
+            while l:linkname =~ "^\.\.\/" 
+
+                " removes one level of ../ in linkname
+                let l:linkname = substitute(l:linkname, "^\.\.\/", "", "")
+
+                " go one directory up in target
+                let l:target = substitute(l:target, "\/[^/]*$", "", "")
+            endwhile
+
+            let l:target = l:target."/".l:linkname
+        endif
+    endif
+    
+    " we may preprocess some files (such as man pages, or changelogs)
+    let l:preproccmd = ""
+        
+    "
+    " unzip man pages
+    "
+    if l:target =~ "\.\/usr\/share\/man\/.*\.gz$"
+        
+        " try to fail gracefully if a command is not available
+        if !s:hascmd("gzip")
+            return
+        elseif !s:hascmd("nroff") 
+            let l:preproccmd = "| gzip -cd"
+        elseif !s:hascmd("col")
+            let l:preproccmd = "| gzip -cd | nroff -mandoc"
+        else
+            let l:preproccmd = "| gzip -cd | nroff -mandoc | col -b"
+        endif
+    
+    "
+    " unzip other .gz files
+    "
+    elseif l:target =~ '.*\.gz$'
+        if !s:hascmd("gzip")
+            return
+        endif
+        let l:preproccmd = "| gzip -cd"
+    endif
+
+    " read content
+    exe "silent r! ar p " . s:QuoteFile(a:debfile) . " " . s:QuoteFile(l:archmember) . " | " . l:unpcmp . " - " . s:QuoteFile(l:target) . l:preproccmd
+    " error will be treated in calling function
+    if v:shell_error != 0
+        return
+    endif
+
+    exe "file deb:".l:target
+
+    0d
+
+    setlocal nomodifiable nomodified readonly
+
+endfun
+
+fun! deb#browse(file)
+
+    " checks if necessary utils are installed
+    if !s:hascmd("dpkg") || !s:hascmd("ar") || !s:hascmd("tar")
+        return
+    endif
+
+    " checks if file is readable
+    if !filereadable(a:file)
+        return
+    endif
+    if a:file =~ "'"
+        echohl WarningMsg | echo "***error*** (deb#Browse) filename cannot contain quote character (" . a:file . ")"
+        return
+    endif
+
+    let keepmagic = &magic
+    set magic
+
+    " set filetype to "deb"
+    set ft=deb
+
+    setlocal modifiable noreadonly
+
+    " set header
+    exe "$put ='".'\"'." deb.vim version ".g:loaded_deb."'"
+    exe "$put ='".'\"'." Browsing debian package ".a:file."'"
+    $put=''
+
+    " package info
+    "exe "silent read! dpkg -I ".a:file
+    "$put=''
+
+    " display information control files
+    let l:infopos = line(".")
+    exe "silent read! ar p " . s:QuoteFile(a:file) . " control.tar.gz | tar zt"
+
+    $put=''
+
+    " display data files
+    let l:listpos = line(".")
+    exe "silent read! dpkg -c ". s:QuoteFile(a:file)
+
+    " format information control list
+    " removes '* ./' line
+    exe (l:infopos + 1). 'd'
+    " add a star before each line
+    exe "silent " . (l:infopos + 1). ',' . (l:listpos - 2) . 's/^/\* /'
+    
+    " format data list
+    exe "silent " . l:listpos . ',$s/^.*\s\(\.\/\(\S\|\).*\)$/\1/'
+    
+    if v:shell_error != 0
+        echohl WarningMsg | echo "***warning*** (deb#Browse) error when listing content of " . a:file
+        let &magic = keepmagic
+        return
+    endif
+
+    0d
+
+    setlocal nomodifiable readonly
+    noremap <silent> <buffer> <cr> :call <SID>DebBrowseSelect()<cr>
+    let &magic = keepmagic
+
+endfun
+
+fun! s:DebBrowseSelect()
+    let l:fname= getline(".")
+
+    " sanity check
+    if (l:fname !~ '^\.\/') && (l:fname !~ '^\* \.\/')
+        return
+    endif
+    if l:fname =~ "'"
+        echohl WarningMsg | echo "***error*** (DebBrowseSelect) filename cannot contain quote character (" . l:fname . ")"
+        return
+    endif
+
+    " do nothing on directories
+    " TODO: find a way to detect symlinks to directories, to be able not to
+    " open them
+    if (l:fname =~ '\/$')
+        return
+    endif
+
+    " need to get it now since a new window will open
+    let l:curfile= expand("%")
+   
+    " open new window
+    new
+    wincmd _
+
+    call deb#read(l:curfile, l:fname)
+
+    if v:shell_error != 0
+        echohl WarningMsg | echo "***warning*** (DebBrowseSelect) error when reading " . l:fname
+        return
+    endif
+
+    filetype detect
+
+    " zipped files, are unziped in deb#read, but filetype may not
+    " automatically work.
+    if l:fname =~ "\.\/usr\/share\/man\/.*\.gz$"
+        set filetype=man
+    elseif l:fname =~ "\.\/usr\/share\/doc\/.*\/changelog.Debian.gz$"
+        set filetype=debchangelog
+    endif
+
+endfun
+
+" return data file name for debian package. This can be either data.tar.gz,
+" data.tar.bz2 or data.tar.lzma
+fun s:dataFileName(deb)
+    for fn in ["data.tar.gz", "data.tar.bz2", "data.tar.lzma", "data.tar"]
+        " [0:-2] is to remove trailing null character from command output
+        if (system("ar t " . "'" . a:deb . "'" . " " . fn))[0:-2] == fn
+            return fn
+        endif
+    endfor
+    return "" " no debian data format in this archive
+endfun
+
+fun s:QuoteFile(file)
+    " we need to escape %, #, <, and >
+    " see :help cmdline-specialk
+    return "'" .  substitute(a:file, '\([%#<>]\)', '\\\1', 'g') . "'"
+endfun
+
+" return 1 if cmd exists
+" display error message and return 0 otherwise
+fun s:hascmd(cmd)
+    if executable(a:cmd)
+        return 1
+    else
+        echohl Error | echo "***error*** " . a:cmd . " not available on your system"
+        return 0
+    else
+endfu
+

.vim/autoload/haskellmode.vim

+"
+" utility functions for haskellmode plugins
+"
+" (Claus Reinke; last modified: 22/06/2010)
+" 
+" part of haskell plugins: http://projects.haskell.org/haskellmode-vim
+" please send patches to <claus.reinke@talk21.com>
+
+
+
+" find start/extent of name/symbol under cursor;
+" return start, symbolic flag, qualifier, unqualified id
+" (this is used in both haskell_doc.vim and in GHC.vim)
+function! haskellmode#GetNameSymbol(line,col,off)
+  let name    = "[a-zA-Z0-9_']"
+  let symbol  = "[-!#$%&\*\+/<=>\?@\\^|~:.]"
+  "let [line]  = getbufline(a:buf,a:lnum)
+  let line    = a:line
+
+  " find the beginning of unqualified id or qualified id component 
+  let start   = (a:col - 1) + a:off
+  if line[start] =~ name
+    let pattern = name
+  elseif line[start] =~ symbol
+    let pattern = symbol
+  else
+    return []
+  endif
+  while start > 0 && line[start - 1] =~ pattern
+    let start -= 1
+  endwhile
+  let id    = matchstr(line[start :],pattern.'*')
+  " call confirm(id)
+
+  " expand id to left and right, to get full id
+  let idPos = id[0] == '.' ? start+2 : start+1
+  let posA  = match(line,'\<\(\([A-Z]'.name.'*\.\)\+\)\%'.idPos.'c')
+  let start = posA>-1 ? posA+1 : idPos
+  let posB  = matchend(line,'\%'.idPos.'c\(\([A-Z]'.name.'*\.\)*\)\('.name.'\+\|'.symbol.'\+\)')
+  let end   = posB>-1 ? posB : idPos
+
+  " special case: symbolic ids starting with .
+  if id[0]=='.' && posA==-1 
+    let start = idPos-1
+    let end   = posB==-1 ? start : end
+  endif
+
+  " classify full id and split into qualifier and unqualified id
+  let fullid   = line[ (start>1 ? start-1 : 0) : (end-1) ]
+  let symbolic = fullid[-1:-1] =~ symbol  " might also be incomplete qualified id ending in .
+  let qualPos  = matchend(fullid, '\([A-Z]'.name.'*\.\)\+')
+  let qualifier = qualPos>-1 ? fullid[ 0 : (qualPos-2) ] : ''
+  let unqualId  = qualPos>-1 ? fullid[ qualPos : -1 ] : fullid
+  " call confirm(start.'/'.end.'['.symbolic.']:'.qualifier.' '.unqualId)
+
+  return [start,symbolic,qualifier,unqualId]
+endfunction
+
+function! haskellmode#GatherImports()
+  let imports={0:{},1:{}}
+  let i=1
+  while i<=line('$')
+    let res = haskellmode#GatherImport(i)
+    if !empty(res)
+      let [i,import] = res
+      let prefixPat = '^import\s*\%({-#\s*SOURCE\s*#-}\)\?\(qualified\)\?\s\+'
+      let modulePat = '\([A-Z][a-zA-Z0-9_''.]*\)'
+      let asPat     = '\(\s\+as\s\+'.modulePat.'\)\?'
+      let hidingPat = '\(\s\+hiding\s*\((.*)\)\)\?'
+      let listPat   = '\(\s*\((.*)\)\)\?'
+      let importPat = prefixPat.modulePat.asPat.hidingPat.listPat ".'\s*$'
+
+      let ml = matchlist(import,importPat)
+      if ml!=[]
+        let [_,qualified,module,_,as,_,hiding,_,explicit;x] = ml
+        let what = as=='' ? module : as
+        let hidings   = split(hiding[1:-2],',')
+        let explicits = split(explicit[1:-2],',')
+        let empty = {'lines':[],'hiding':hidings,'explicit':[],'modules':[]}
+        let entry = has_key(imports[1],what) ? imports[1][what] : deepcopy(empty)
+        let imports[1][what] = haskellmode#MergeImport(deepcopy(entry),i,hidings,explicits,module)
+        if !(qualified=='qualified')
+          let imports[0][what] = haskellmode#MergeImport(deepcopy(entry),i,hidings,explicits,module)
+        endif
+      else
+        echoerr "haskellmode#GatherImports doesn't understand: ".import
+      endif
+    endif
+    let i+=1
+  endwhile
+  if !has_key(imports[1],'Prelude') 
+    let imports[0]['Prelude'] = {'lines':[],'hiding':[],'explicit':[],'modules':[]}
+    let imports[1]['Prelude'] = {'lines':[],'hiding':[],'explicit':[],'modules':[]}
+  endif
+  return imports
+endfunction
+
+function! haskellmode#ListElem(list,elem)
+  for e in a:list | if e==a:elem | return 1 | endif | endfor
+  return 0
+endfunction
+
+function! haskellmode#ListIntersect(list1,list2)
+  let l = []
+  for e in a:list1 | if index(a:list2,e)!=-1 | let l += [e] | endif | endfor
+  return l
+endfunction
+
+function! haskellmode#ListUnion(list1,list2)
+  let l = []
+  for e in a:list2 | if index(a:list1,e)==-1 | let l += [e] | endif | endfor
+  return a:list1 + l
+endfunction
+
+function! haskellmode#ListWithout(list1,list2)
+  let l = []
+  for e in a:list1 | if index(a:list2,e)==-1 | let l += [e] | endif | endfor
+  return l
+endfunction
+
+function! haskellmode#MergeImport(entry,line,hiding,explicit,module)
+  let lines    = a:entry['lines'] + [ a:line ]
+  let hiding   = a:explicit==[] ? haskellmode#ListIntersect(a:entry['hiding'], a:hiding) 
+                              \ : haskellmode#ListWithout(a:entry['hiding'],a:explicit)
+  let explicit = haskellmode#ListUnion(a:entry['explicit'], a:explicit)
+  let modules  = haskellmode#ListUnion(a:entry['modules'], [ a:module ])
+  return {'lines':lines,'hiding':hiding,'explicit':explicit,'modules':modules}
+endfunction
+
+" collect lines belonging to a single import statement;
+" return number of last line and collected import statement
+" (assume opening parenthesis, if any, is on the first line)
+function! haskellmode#GatherImport(lineno)
+  let lineno = a:lineno
+  let import = getline(lineno)
+  if !(import=~'^import\s') | return [] | endif
+  let open  = strlen(substitute(import,'[^(]','','g'))
+  let close = strlen(substitute(import,'[^)]','','g'))
+  while open!=close
+    let lineno += 1
+    let linecont = getline(lineno)
+    let open  += strlen(substitute(linecont,'[^(]','','g'))
+    let close += strlen(substitute(linecont,'[^)]','','g'))
+    let import .= linecont
+  endwhile
+  return [lineno,import]
+endfunction
+
+function! haskellmode#UrlEncode(string)
+  let pat  = '\([^[:alnum:]]\)'
+  let code = '\=printf("%%%02X",char2nr(submatch(1)))'
+  let url  = substitute(a:string,pat,code,'g')
+  return url
+endfunction
+
+" TODO: we could have buffer-local settings, at the expense of
+"       reconfiguring for every new buffer.. do we want to?
+function! haskellmode#GHC()
+  if (!exists("g:ghc") || !executable(g:ghc)) 
+    if !executable('ghc') 
+      echoerr s:scriptname.": can't find ghc. please set g:ghc, or extend $PATH"
+      return 0
+    else
+      let g:ghc = 'ghc'
+    endif
+  endif    
+  return 1
+endfunction
+
+function! haskellmode#GHC_Version()
+  if !exists("g:ghc_version")
+    let g:ghc_version = substitute(system(g:ghc . ' --numeric-version'),'\n','','')
+  endif
+  return g:ghc_version
+endfunction
+
+function! haskellmode#GHC_VersionGE(target)
+  let current = split(haskellmode#GHC_Version(), '\.' )
+  let target  = a:target
+  for i in current
+    if ((target==[]) || (i>target[0]))
+      return 1
+    elseif (i==target[0])
+      let target = target[1:]
+    else
+      return 0
+    endif
+  endfor
+  return 1
+endfunction
+

.vim/autoload/pathogen.vim

+" pathogen.vim - path option manipulation
+" Maintainer:   Tim Pope <http://tpo.pe/>
+" Version:      2.2
+
+" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
+"
+" For management of individually installed plugins in ~/.vim/bundle (or
+" ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
+" .vimrc is the only other setup necessary.
+"
+" The API is documented inline below.  For maximum ease of reading,
+" :set foldmethod=marker
+
+if exists("g:loaded_pathogen") || &cp
+  finish
+endif
+let g:loaded_pathogen = 1
+
+function! s:warn(msg)
+  echohl WarningMsg
+  echomsg a:msg
+  echohl NONE
+endfunction
+
+" Point of entry for basic default usage.  Give a relative path to invoke
+" pathogen#incubate() (defaults to "bundle/{}"), or an absolute path to invoke
+" pathogen#surround().  For backwards compatibility purposes, a full path that
+" does not end in {} or * is given to pathogen#runtime_prepend_subdirectories()
+" instead.
+function! pathogen#infect(...) abort " {{{1
+  for path in a:0 ? reverse(copy(a:000)) : ['bundle/{}']
+    if path =~# '^[^\\/]\+$'
+      call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
+      call pathogen#incubate(path . '/{}')
+    elseif path =~# '^[^\\/]\+[\\/]\%({}\|\*\)$'
+      call pathogen#incubate(path)
+    elseif path =~# '[\\/]\%({}\|\*\)$'
+      call pathogen#surround(path)
+    else
+      call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
+      call pathogen#surround(path . '/{}')
+    endif
+  endfor
+  call pathogen#cycle_filetype()
+  return ''
+endfunction " }}}1
+
+" Split a path into a list.
+function! pathogen#split(path) abort " {{{1
+  if type(a:path) == type([]) | return a:path | endif
+  let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
+  return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
+endfunction " }}}1
+
+" Convert a list to a path.
+function! pathogen#join(...) abort " {{{1
+  if type(a:1) == type(1) && a:1
+    let i = 1
+    let space = ' '
+  else
+    let i = 0
+    let space = ''
+  endif
+  let path = ""
+  while i < a:0
+    if type(a:000[i]) == type([])
+      let list = a:000[i]
+      let j = 0
+      while j < len(list)
+        let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
+        let path .= ',' . escaped
+        let j += 1
+      endwhile
+    else
+      let path .= "," . a:000[i]
+    endif
+    let i += 1
+  endwhile
+  return substitute(path,'^,','','')
+endfunction " }}}1
+
+" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
+function! pathogen#legacyjoin(...) abort " {{{1
+  return call('pathogen#join',[1] + a:000)
+endfunction " }}}1
+
+" Remove duplicates from a list.
+function! pathogen#uniq(list) abort " {{{1
+  let i = 0
+  let seen = {}
+  while i < len(a:list)
+    if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
+      call remove(a:list,i)
+    elseif a:list[i] ==# ''
+      let i += 1
+      let empty = 1
+    else
+      let seen[a:list[i]] = 1
+      let i += 1
+    endif
+  endwhile
+  return a:list
+endfunction " }}}1
+
+" \ on Windows unless shellslash is set, / everywhere else.
+function! pathogen#separator() abort " {{{1
+  return !exists("+shellslash") || &shellslash ? '/' : '\'
+endfunction " }}}1
+
+" Convenience wrapper around glob() which returns a list.
+function! pathogen#glob(pattern) abort " {{{1
+  let files = split(glob(a:pattern),"\n")
+  return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")')
+endfunction "}}}1
+
+" Like pathogen#glob(), only limit the results to directories.
+function! pathogen#glob_directories(pattern) abort " {{{1
+  return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
+endfunction "}}}1
+
+" Turn filetype detection off and back on again if it was already enabled.
+function! pathogen#cycle_filetype() " {{{1
+  if exists('g:did_load_filetypes')
+    filetype off
+    filetype on
+  endif
+endfunction " }}}1
+
+" Check if a bundle is disabled.  A bundle is considered disabled if it ends
+" in a tilde or its basename or full name is included in the list
+" g:pathogen_disabled.
+function! pathogen#is_disabled(path) " {{{1
+  if a:path =~# '\~$'
+    return 1
+  elseif !exists("g:pathogen_disabled")
+    return 0
+  endif
+  let sep = pathogen#separator()
+  let blacklist = g:pathogen_disabled
+  return index(blacklist, strpart(a:path, strridx(a:path, sep)+1)) != -1 && index(blacklist, a:path) != 1
+endfunction "}}}1
+
+" Prepend the given directory to the runtime path and append its corresponding
+" after directory.  If the directory is already included, move it to the
+" outermost position.  Wildcards are added as is.  Ending a path in /{} causes
+" all subdirectories to be added (except those in g:pathogen_disabled).
+function! pathogen#surround(path) abort " {{{1
+  let sep = pathogen#separator()
+  let rtp = pathogen#split(&rtp)
+  if a:path =~# '[\\/]{}$'
+    let path = fnamemodify(a:path[0:-4], ':p:s?[\\/]\=$??')
+    let before = filter(pathogen#glob_directories(path.sep.'*'), '!pathogen#is_disabled(v:val)')
+    let after  = filter(reverse(pathogen#glob_directories(path.sep."*".sep."after")), '!pathogen#is_disabled(v:val[0:-7])')
+    call filter(rtp,'v:val[0:strlen(path)-1] !=# path')
+  else
+    let path = fnamemodify(a:path, ':p:s?[\\/]\=$??')
+    let before = [path]
+    let after = [path . sep . 'after']
+    call filter(rtp, 'index(before + after, v:val) == -1')
+  endif
+  let &rtp = pathogen#join(before, rtp, after)
+  return &rtp
+endfunction " }}}1
+
+" Prepend all subdirectories of path to the rtp, and append all 'after'
+" directories in those subdirectories.  Deprecated.
+function! pathogen#runtime_prepend_subdirectories(path) " {{{1
+  call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#surround('.string(a:path.'/{}').')')
+  return pathogen#surround(a:path . pathogen#separator() . '{}')
+endfunction " }}}1
+
+" For each directory in the runtime path, add a second entry with the given
+" argument appended.  If the argument ends in '/{}', add a separate entry for
+" each subdirectory.  The default argument is 'bundle/{}', which means that
+" .vim/bundle/*, $VIM/vimfiles/bundle/*, $VIMRUNTIME/bundle/*,
+" $VIM/vim/files/bundle/*/after, and .vim/bundle/*/after will be added (on
+" UNIX).
+function! pathogen#incubate(...) abort " {{{1
+  let sep = pathogen#separator()
+  let name = a:0 ? a:1 : 'bundle/{}'
+  if "\n".s:done_bundles =~# "\\M\n".name."\n"
+    return ""
+  endif
+  let s:done_bundles .= name . "\n"
+  let list = []
+  for dir in pathogen#split(&rtp)
+    if dir =~# '\<after$'
+      if name =~# '{}$'
+        let list +=  filter(pathogen#glob_directories(substitute(dir,'after$',name[0:-3],'').'*'.sep.'after'), '!pathogen#is_disabled(v:val[0:-7])') + [dir]
+      else
+        let list += [dir, substitute(dir, 'after$', '', '') . name . sep . 'after']
+      endif
+    else
+      if name =~# '{}$'
+        let list +=  [dir] + filter(pathogen#glob_directories(dir.sep.name[0:-3].'*'), '!pathogen#is_disabled(v:val)')
+      else
+        let list += [dir . sep . name, dir]
+      endif
+    endif
+  endfor
+  let &rtp = pathogen#join(pathogen#uniq(list))
+  return 1
+endfunction " }}}1
+
+" Deprecated alias for pathogen#incubate().
+function! pathogen#runtime_append_all_bundles(...) abort " {{{1
+  if a:0
+    call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#incubate('.string(a:1.'/{}').')')
+  else
+    call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#incubate()')
+  endif
+  return call('pathogen#incubate', map(copy(a:000),'v:val . "/{}"'))
+endfunction
+
+let s:done_bundles = ''
+" }}}1
+
+" Invoke :helptags on all non-$VIM doc directories in runtimepath.
+function! pathogen#helptags() abort " {{{1
+  let sep = pathogen#separator()
+  for glob in pathogen#split(&rtp)
+    for dir in split(glob(glob), "\n")
+      if (dir.sep)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir.sep.'doc') == 2 && !empty(filter(split(glob(dir.sep.'doc'.sep.'*'),"\n>"),'!isdirectory(v:val)')) && (!filereadable(dir.sep.'doc'.sep.'tags') || filewritable(dir.sep.'doc'.sep.'tags'))
+        silent! execute 'helptags' pathogen#fnameescape(dir.'/doc')
+      endif
+    endfor
+  endfor
+endfunction " }}}1
+
+command! -bar Helptags :call pathogen#helptags()
+
+" Execute the given command.  This is basically a backdoor for --remote-expr.
+function! pathogen#execute(...) abort " {{{1
+  for command in a:000
+    execute command
+  endfor
+  return ''
+endfunction " }}}1
+
+" Like findfile(), but hardcoded to use the runtimepath.
+function! pathogen#runtime_findfile(file,count) abort "{{{1
+  let rtp = pathogen#join(1,pathogen#split(&rtp))
+  let file = findfile(a:file,rtp,a:count)
+  if file ==# ''
+    return ''
+  else
+    return fnamemodify(file,':p')
+  endif
+endfunction " }}}1
+
+" Backport of fnameescape().