Install vim-gutentags

.gitmodules

@@ -43,3 +43,6 @@
 [submodule "dotfiles/vim/bundle/vim-airline-themes"]
 	path = dotfiles/vim/bundle/vim-airline-themes
 	url = https://github.com/vim-airline/vim-airline-themes
+[submodule "dotfiles/vim/bundle/vim-gutentags"]
+	path = dotfiles/vim/bundle/vim-gutentags
+	url = https://github.com/ludovicchabant/vim-gutentags.git

dotfiles/vim/bundle/vim-gutentags/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Something's wrong?
+
+---
+
+**Describe the bug**
+Describe what the bug is about, and what you expected. Don't forget to format things nicely with Markdown. If applicable, post screenshots.
+
+**Steps to reproduce**
+1. Do this '...'
+2. Do that '...'
+3. Etc.
+
+**Share your setup**
+- What OS and version of Vim are you using?
+- What version of `ctags`, `gtags`, or whatever do you have installed?
+- Are you using `g:gutentags_cache_dir`?
+
+**Post the logs**
+- Run `:let g:gutentags_trace = 1`.
+- Reproduce the bug.
+- Run `:messages` and show the messages that Gutentags posted.
+- Look for the `tags.log` file that Gutentags' script left behind, and post its contents.
+
+**Additional context**
+Add any other context about the problem here.

dotfiles/vim/bundle/vim-gutentags/.gitignore

@@ -0,0 +1 @@
+doc/tags

dotfiles/vim/bundle/vim-gutentags/.hgignore

@@ -0,0 +1,3 @@
+syntax:regexp
+(^|/)tags$
+

dotfiles/vim/bundle/vim-gutentags/.hgtags

@@ -0,0 +1 @@
+06c496e010b403703643284b12893c1f92b3e756 v1.0.0

dotfiles/vim/bundle/vim-gutentags/CONTRIBUTING.md

@@ -0,0 +1,60 @@
+
+# Contributing
+
+You're thinking of contributing something to one of my projects? Oh my, I'm
+quite honoured! Here's what you need to know.
+
+
+## Writing
+
+Clone the repository from either [BitBucket][] (if you're into Mercurial) or
+[GitHub][] (if you're into Git).
+
+Next, create a branch for your work -- don't work directly on the `defaut` or
+`master` branch. Instead, in Mercurial:
+
+  $ hg bookmark my-fix
+
+Or, in Git:
+
+  $ git checkout -b my-fix master
+
+Make your changes. Don't write anything that's not related to the fix you're
+trying to contribute to the project.
+
+Write a simple, concise commit message. Gutentags isn't a big piece of code so
+no need for strict message formats, so don't get fancy.
+
+
+## Testing
+
+If you can, try and test your changes on multiple platforms -- Ubuntu, MacOS,
+and Windows are supposed to be supported.
+
+Also try to test your changes with:
+
+1. `g:gutentags_cache_dir` enabled and disabled.
+2. A repository with spaces in its root path.
+3. A repository with files and folders that have spaces in them.
+
+If you're on NeoVim, try and test on a "normal" Vim.
+
+
+## Pushing
+
+Once everything's fine, go on BitBucket or GitHub (again, depending on your
+favorite source control tool) and create a fork if you haven't done so yet. Push
+your changes to your fork, and create a pull request. Check the documentation of
+either code portal for more information.
+
+Don't worry if you don't see any reply from me for a while. My turn around time
+is measured in weeks, sometimes in months. This is normal -- I've got a job,
+a family, and open-source hacking is only one of many awesome hobbies I spend my
+limited free time on.
+
+That's it for now! And thanks a lot for contributing!
+
+
+[bitbucket]: https://bitbucket.org/ludovicchabant/vim-gutentags
+[github]: https://github.com/ludovicchabant/vim-gutentags
+

dotfiles/vim/bundle/vim-gutentags/LICENSE

@@ -0,0 +1,23 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Ludovic Chabant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

dotfiles/vim/bundle/vim-gutentags/README.md

@@ -0,0 +1,81 @@
+
+# Gutentags
+
+Gutentags is a plugin that takes care of the much needed management of tags
+files in Vim. It will (re)generate tag files as you work while staying
+completely out of your way. It will even do its best to keep those tag files
+out of your way too. It has no dependencies and just works.
+
+
+## How?
+
+Install Gutentags like any other Vim plugin. I recommend something like
+[Pathogen][], so you can go:
+
+    cd ~/.vim/bundle
+    hg clone https://bitbucket.org/ludovicchabant/vim-gutentags
+
+If you're more into Git than Mercurial:
+
+    git clone https://github.com/ludovicchabant/vim-gutentags.git
+
+Then you only need to do a `:call pathogen#helptags()` to generate the
+documentation tags (how ironic, eh?) and you can access Gutentags' help pages
+with `help gutentags`.
+
+
+## What?
+
+In order to generate tag files, Gutentags will have to figure out what's in
+your project. To do this, it will locate well-known project root markers like
+SCM folders (`.git`, `.hg`, etc.), any custom tags you define (with
+`gutentags_project_root`), and even things you may have defined already with
+other plugins, like [CtrlP][].
+
+If the current file you're editing is found to be in such a project, Gutentags
+will make sure the tag file for that project is up to date. Then, as you work
+in files in that project, it will partially re-generate the tag file. Every
+time you save, it will silently, in the background, update the tags for that
+file.
+
+Usually, ctags can only append tags to an existing tag file, so Gutentags
+removes the tags for the current file first, to make sure the tag file is
+always consistent with the source code.
+
+Also, Gutentags is clever enough to not stumble upon itself by triggering
+multiple ctags processes if you save files too fast, or your project is really
+big.
+
+
+## Why?
+
+There are some similar Vim plugins out there ("vim-tags", "vim-autotag",
+"vim-automatic-ctags", etc.). They all fail on one or more of the requirements
+I set for myself with Gutentags:
+
+* No other dependency than running Vim: no Python, Ruby, or whatever.
+* Cross-platform: should work on at least Ubuntu, Mac, and Windows.
+* Incremental tags generation: don't re-generate the whole project all the time.
+  This may be fine for small projects, but it doesn't scale.
+* External process management: if the ctags process is taking a long time, don't
+  run another one because I saved a file again.
+* Keep the tag file consistent: don't just append the current file's tags to the
+  tag file, otherwise you will still "see" tags for deleted or renamed classes
+  and functions.
+* Automatically create the tag file: you open something from a freshly forked
+  project, it should start indexing it automatically, just like in Sublime Text
+  or Visual Studio or any other IDE.
+
+I hope Gutentags will bring you as much closure as me regarding tag files. I know
+I don't want to have to think about it, and probably neither do you.
+
+
+# Related Projects
+
+* [gutentags_plus](https://github.com/skywind3000/gutentags_plus): handles
+  switching between `cscope` databases automatically before performing a search
+  query.
+
+[Pathogen]: https://github.com/tpope/vim-pathogen
+[ctrlp]: https://github.com/kien/ctrlp.vim
+

dotfiles/vim/bundle/vim-gutentags/autoload/gutentags.vim

@@ -0,0 +1,705 @@
+" gutentags.vim - Automatic ctags management for Vim
+
+" Utilities {{{
+
+function! gutentags#chdir(path)
+    if has('nvim')
+        let chdir = haslocaldir() ? 'lcd' : haslocaldir(-1, 0) ? 'tcd' : 'cd'
+    else
+        let chdir = haslocaldir() ? 'lcd' : 'cd'
+    endif
+    execute chdir a:path
+endfunction
+
+" Throw an exception message.
+function! gutentags#throw(message)
+    throw "gutentags: " . a:message
+endfunction
+
+" Show an error message.
+function! gutentags#error(message)
+    let v:errmsg = "gutentags: " . a:message
+    echoerr v:errmsg
+endfunction
+
+" Show a warning message.
+function! gutentags#warning(message)
+    echohl WarningMsg
+    echom "gutentags: " . a:message
+    echohl None
+endfunction
+
+" Prints a message if debug tracing is enabled.
+function! gutentags#trace(message, ...)
+    if g:gutentags_trace || (a:0 && a:1)
+        let l:message = "gutentags: " . a:message
+        echom l:message
+    endif
+endfunction
+
+" Strips the ending slash in a path.
+function! gutentags#stripslash(path)
+    return fnamemodify(a:path, ':s?[/\\]$??')
+endfunction
+
+" Normalizes the slashes in a path.
+function! gutentags#normalizepath(path)
+    if exists('+shellslash') && &shellslash
+        return substitute(a:path, '\v/', '\\', 'g')
+    elseif has('win32')
+        return substitute(a:path, '\v/', '\\', 'g')
+    else
+        return a:path
+    endif
+endfunction
+
+" Shell-slashes the path (opposite of `normalizepath`).
+function! gutentags#shellslash(path)
+    if exists('+shellslash') && !&shellslash
+        return substitute(a:path, '\v\\', '/', 'g')
+    else
+        return a:path
+    endif
+endfunction
+
+" Gets a file path in the correct `plat` folder.
+function! gutentags#get_plat_file(filename) abort
+    return g:gutentags_plat_dir . a:filename . g:gutentags_script_ext
+endfunction
+
+" Gets a file path in the resource folder.
+function! gutentags#get_res_file(filename) abort
+    return g:gutentags_res_dir . a:filename
+endfunction
+
+" Generate a path for a given filename in the cache directory.
+function! gutentags#get_cachefile(root_dir, filename) abort
+    if gutentags#is_path_rooted(a:filename)
+        return a:filename
+    endif
+    let l:tag_path = gutentags#stripslash(a:root_dir) . '/' . a:filename
+    if g:gutentags_cache_dir != ""
+        " Put the tag file in the cache dir instead of inside the
+        " project root.
+        let l:tag_path = g:gutentags_cache_dir . '/' .
+                    \tr(l:tag_path, '\/: ', '---_')
+        let l:tag_path = substitute(l:tag_path, '/\-', '/', '')
+        let l:tag_path = substitute(l:tag_path, '[\-_]*$', '', '')
+    endif
+    let l:tag_path = gutentags#normalizepath(l:tag_path)
+    return l:tag_path
+endfunction
+
+" Makes sure a given command starts with an executable that's in the PATH.
+function! gutentags#validate_cmd(cmd) abort
+    if !empty(a:cmd) && executable(split(a:cmd)[0])
+        return a:cmd
+    endif
+    return ""
+endfunction
+
+" Makes an appropriate command line for use with `job_start` by converting
+" a list of possibly quoted arguments into a single string on Windows, or
+" into a list of unquoted arguments on Unix/Mac.
+if has('win32') || has('win64')
+    function! gutentags#make_args(cmd) abort
+        return join(a:cmd, ' ')
+    endfunction
+else
+    function! gutentags#make_args(cmd) abort
+        let l:outcmd = []
+        for cmdarg in a:cmd
+            " Thanks Vimscript... you can use negative integers for strings
+            " in the slice notation, but not for indexing characters :(
+            let l:arglen = strlen(cmdarg)
+            if (cmdarg[0] == '"' && cmdarg[l:arglen - 1] == '"') || 
+                        \(cmdarg[0] == "'" && cmdarg[l:arglen - 1] == "'")
+                call add(l:outcmd, cmdarg[1:-2])
+            else
+                call add(l:outcmd, cmdarg)
+            endif
+        endfor
+        return l:outcmd
+    endfunction
+endif
+
+" Returns whether a path is rooted.
+if has('win32') || has('win64')
+    function! gutentags#is_path_rooted(path) abort
+        return len(a:path) >= 2 && (
+                    \a:path[0] == '/' || a:path[0] == '\' || a:path[1] == ':')
+    endfunction
+else
+    function! gutentags#is_path_rooted(path) abort
+        return !empty(a:path) && a:path[0] == '/'
+    endfunction
+endif
+
+" }}}
+
+" Gutentags Setup {{{
+
+let s:known_files = []
+let s:known_projects = {}
+
+function! s:cache_project_root(path) abort
+    let l:result = {}
+
+    for proj_info in g:gutentags_project_info
+        let l:filematch = get(proj_info, 'file', '')
+        if l:filematch != '' && filereadable(a:path . '/'. l:filematch)
+            let l:result = copy(proj_info)
+            break
+        endif
+
+        let l:globmatch = get(proj_info, 'glob', '')
+        if l:globmatch != '' && glob(a:path . '/' . l:globmatch) != ''
+            let l:result = copy(proj_info)
+            break
+        endif
+    endfor
+
+    let s:known_projects[a:path] = l:result
+endfunction
+
+function! gutentags#get_project_file_list_cmd(path) abort
+    if type(g:gutentags_file_list_command) == type("")
+        return gutentags#validate_cmd(g:gutentags_file_list_command)
+    elseif type(g:gutentags_file_list_command) == type({})
+        let l:markers = get(g:gutentags_file_list_command, 'markers', [])
+        if type(l:markers) == type({})
+            for [marker, file_list_cmd] in items(l:markers)
+                if !empty(globpath(a:path, marker, 1))
+                    return gutentags#validate_cmd(file_list_cmd)
+                endif
+            endfor
+        endif
+        return get(g:gutentags_file_list_command, 'default', "")
+    endif
+    return ""
+endfunction
+
+" Finds the first directory with a project marker by walking up from the given
+" file path.
+function! gutentags#get_project_root(path) abort
+    if g:gutentags_project_root_finder != ''
+        return call(g:gutentags_project_root_finder, [a:path])
+    endif
+    return gutentags#default_get_project_root(a:path)
+endfunction
+
+" Default implementation for finding project markers... useful when a custom
+" finder (`g:gutentags_project_root_finder`) wants to fallback to the default
+" behaviour.
+function! gutentags#default_get_project_root(path) abort
+    let l:path = gutentags#stripslash(a:path)
+    let l:previous_path = ""
+    let l:markers = g:gutentags_project_root[:]
+    if g:gutentags_add_ctrlp_root_markers && exists('g:ctrlp_root_markers')
+        for crm in g:ctrlp_root_markers
+            if index(l:markers, crm) < 0
+                call add(l:markers, crm)
+            endif
+        endfor
+    endif
+    while l:path != l:previous_path
+        for root in l:markers
+            if !empty(globpath(l:path, root, 1))
+                let l:proj_dir = simplify(fnamemodify(l:path, ':p'))
+                let l:proj_dir = gutentags#stripslash(l:proj_dir)
+                if l:proj_dir == ''
+                    call gutentags#trace("Found project marker '" . root .
+                                \"' at the root of your file-system! " .
+                                \" That's probably wrong, disabling " .
+                                \"gutentags for this file...",
+                                \1)
+                    call gutentags#throw("Marker found at root, aborting.")
+                endif
+                for ign in g:gutentags_exclude_project_root
+                    if l:proj_dir == ign
+                        call gutentags#trace(
+                                    \"Ignoring project root '" . l:proj_dir .
+                                    \"' because it is in the list of ignored" .
+                                    \" projects.")
+                        call gutentags#throw("Ignore project: " . l:proj_dir)
+                    endif
+                endfor
+                return l:proj_dir
+            endif
+        endfor
+        let l:previous_path = l:path
+        let l:path = fnamemodify(l:path, ':h')
+    endwhile
+    call gutentags#throw("Can't figure out what tag file to use for: " . a:path)
+endfunction
+
+" Get info on the project we're inside of.
+function! gutentags#get_project_info(path) abort
+    return get(s:known_projects, a:path, {})
+endfunction
+
+" Setup gutentags for the current buffer.
+function! gutentags#setup_gutentags() abort
+    if exists('b:gutentags_files') && !g:gutentags_debug
+        " This buffer already has gutentags support.
+        return
+    endif
+
+    " Don't setup gutentags for anything that's not a normal buffer
+    " (so don't do anything for help buffers and quickfix windows and
+    "  other such things)
+    " Also don't do anything for the default `[No Name]` buffer you get
+    " after starting Vim.
+    if &buftype != '' || 
+          \(bufname('%') == '' && !g:gutentags_generate_on_empty_buffer)
+        return
+    endif
+
+    " Don't setup gutentags for things that don't need it, or that could
+    " cause problems.
+    if index(g:gutentags_exclude_filetypes, &filetype) >= 0
+        return
+    endif
+
+    " Let the user specify custom ways to disable Gutentags.
+    if g:gutentags_init_user_func != '' &&
+                \!call(g:gutentags_init_user_func, [expand('%:p')])
+        call gutentags#trace("Ignoring '" . bufname('%') . "' because of " .
+                    \"custom user function.")
+        return
+    endif
+
+    " Try and find what tags file we should manage.
+    call gutentags#trace("Scanning buffer '" . bufname('%') . "' for gutentags setup...")
+    try
+        let l:buf_dir = expand('%:p:h', 1)
+        if g:gutentags_resolve_symlinks
+            let l:buf_dir = fnamemodify(resolve(expand('%:p', 1)), ':p:h')
+        endif
+        if !exists('b:gutentags_root')
+            let b:gutentags_root = gutentags#get_project_root(l:buf_dir)
+        endif
+        if !len(b:gutentags_root)
+            call gutentags#trace("no valid project root.. no gutentags support.")
+            return
+        endif
+        if filereadable(b:gutentags_root . '/.notags')
+            call gutentags#trace("'.notags' file found... no gutentags support.")
+            return
+        endif
+
+        if !has_key(s:known_projects, b:gutentags_root)
+            call s:cache_project_root(b:gutentags_root)
+        endif
+        if g:gutentags_trace
+            let l:projnfo = gutentags#get_project_info(b:gutentags_root)
+            if l:projnfo != {}
+                call gutentags#trace("Setting project type to ".l:projnfo['type'])
+            else
+                call gutentags#trace("No specific project type.")
+            endif
+        endif
+
+        let b:gutentags_files = {}
+        for module in g:gutentags_modules
+            call call("gutentags#".module."#init", [b:gutentags_root])
+        endfor
+    catch /^gutentags\:/
+        call gutentags#trace("No gutentags support for this buffer.")
+        return
+    endtry
+
+    " We know what tags file to manage! Now set things up.
+    call gutentags#trace("Setting gutentags for buffer '".bufname('%')."'")
+
+    " Autocommands for updating the tags on save.
+    " We need to pass the buffer number to the callback function in the rare
+    " case that the current buffer is changed by another `BufWritePost`
+    " callback. This will let us get that buffer's variables without causing
+    " errors.
+    let l:bn = bufnr('%')
+    execute 'augroup gutentags_buffer_' . l:bn
+    execute '  autocmd!'
+    execute '  autocmd BufWritePost <buffer=' . l:bn . '> call s:write_triggered_update_tags(' . l:bn . ')'
+    execute 'augroup end'
+
+    " Miscellaneous commands.
+    command! -buffer -bang GutentagsUpdate :call s:manual_update_tags(<bang>0)
+
+    " Add these tags files to the known tags files.
+    for module in keys(b:gutentags_files)
+        let l:tagfile = b:gutentags_files[module]
+        let l:found = index(s:known_files, l:tagfile)
+        if l:found < 0
+            call add(s:known_files, l:tagfile)
+
+            " Generate this new file depending on settings and stuff.
+            if g:gutentags_enabled
+                if g:gutentags_generate_on_missing && !filereadable(l:tagfile)
+                    call gutentags#trace("Generating missing tags file: " . l:tagfile)
+                    call s:update_tags(l:bn, module, 1, 1)
+                elseif g:gutentags_generate_on_new
+                    call gutentags#trace("Generating tags file: " . l:tagfile)
+                    call s:update_tags(l:bn, module, 1, 1)
+                endif
+            endif
+        endif
+    endfor
+endfunction
+
+" }}}
+
+"  Job Management {{{
+
+" List of queued-up jobs, and in-progress jobs, per module.
+let s:update_queue = {}
+let s:update_in_progress = {}
+for module in g:gutentags_modules
+    let s:update_queue[module] = []
+    let s:update_in_progress[module] = []
+endfor
+
+function! gutentags#add_job(module, tags_file, data) abort
+    call add(s:update_in_progress[a:module], [a:tags_file, a:data])
+endfunction
+
+function! gutentags#find_job_index_by_tags_file(module, tags_file) abort
+    let l:idx = -1
+    for upd_info in s:update_in_progress[a:module]
+        let l:idx += 1
+        if upd_info[0] == a:tags_file
+            return l:idx
+        endif
+    endfor
+    return -1
+endfunction
+
+function! gutentags#find_job_index_by_data(module, data) abort
+    let l:idx = -1
+    for upd_info in s:update_in_progress[a:module]
+        let l:idx += 1
+        if upd_info[1] == a:data
+            return l:idx
+        endif
+    endfor
+    return -1
+endfunction
+
+function! gutentags#get_job_tags_file(module, job_idx) abort
+    return s:update_in_progress[a:module][a:job_idx][0]
+endfunction
+
+function! gutentags#get_job_data(module, job_idx) abort
+    return s:update_in_progress[a:module][a:job_idx][1]
+endfunction
+
+function! gutentags#remove_job(module, job_idx) abort
+    let l:tags_file = s:update_in_progress[a:module][a:job_idx][0]
+    call remove(s:update_in_progress[a:module], a:job_idx)
+
+    " Run the user callback for finished jobs.
+    silent doautocmd User GutentagsUpdated
+
+    " See if we had any more updates queued up for this.
+    let l:qu_idx = -1
+    for qu_info in s:update_queue[a:module]
+        let l:qu_idx += 1
+        if qu_info[0] == l:tags_file
+            break
+        endif
+    endfor
+    if l:qu_idx >= 0
+        let l:qu_info = s:update_queue[a:module][l:qu_idx]
+        call remove(s:update_queue[a:module], l:qu_idx)
+
+        if bufexists(l:qu_info[1])
+            call gutentags#trace("Finished ".a:module." job, ".
+                        \"running queued update for '".l:tags_file."'.")
+            call s:update_tags(l:qu_info[1], a:module, l:qu_info[2], 2)
+        else
+            call gutentags#trace("Finished ".a:module." job, ".
+                        \"but skipping queued update for '".l:tags_file."' ".
+                        \"because originating buffer doesn't exist anymore.")
+        endif
+    else
+        call gutentags#trace("Finished ".a:module." job.")
+    endif
+endfunction
+
+function! gutentags#remove_job_by_data(module, data) abort
+    let l:idx = gutentags#find_job_index_by_data(a:module, a:data)
+    call gutentags#remove_job(a:module, l:idx)
+endfunction
+
+" }}}
+
+"  Tags File Management {{{
+
+" (Re)Generate the tags file for the current buffer's file.
+function! s:manual_update_tags(bang) abort
+    let l:restore_prev_trace = 0
+    let l:prev_trace = g:gutentags_trace
+    if &verbose > 0
+        let g:gutentags_trace = 1
+        let l:restore_prev_trace = 1
+    endif
+
+    try
+        let l:bn = bufnr('%')
+        for module in g:gutentags_modules
+            call s:update_tags(l:bn, module, a:bang, 0)
+        endfor
+        silent doautocmd User GutentagsUpdating
+    finally
+        if l:restore_prev_trace
+            let g:gutentags_trace = l:prev_trace
+        endif
+    endtry
+endfunction
+
+" (Re)Generate the tags file for a buffer that just go saved.
+function! s:write_triggered_update_tags(bufno) abort
+    if g:gutentags_enabled && g:gutentags_generate_on_write
+        for module in g:gutentags_modules
+            call s:update_tags(a:bufno, module, 0, 2)
+        endfor
+    endif
+    silent doautocmd User GutentagsUpdating
+endfunction
+
+" Update the tags file for the current buffer's file.
+" write_mode:
+"   0: update the tags file if it exists, generate it otherwise.
+"   1: always generate (overwrite) the tags file.
+"
+" queue_mode:
+"   0: if an update is already in progress, report it and abort.
+"   1: if an update is already in progress, abort silently.
+"   2: if an update is already in progress, queue another one.
+function! s:update_tags(bufno, module, write_mode, queue_mode) abort
+    " Figure out where to save.
+    let l:buf_gutentags_files = getbufvar(a:bufno, 'gutentags_files')
+    let l:tags_file = l:buf_gutentags_files[a:module]
+    let l:proj_dir = getbufvar(a:bufno, 'gutentags_root')
+
+    " Check that there's not already an update in progress.
+    let l:in_progress_idx = gutentags#find_job_index_by_tags_file(
+                \a:module, l:tags_file)
+    if l:in_progress_idx >= 0
+        if a:queue_mode == 2
+            let l:needs_queuing = 1
+            for qu_info in s:update_queue[a:module]
+                if qu_info[0] == l:tags_file
+                    let l:needs_queuing = 0
+                    break
+                endif
+            endfor
+            if l:needs_queuing
+                call add(s:update_queue[a:module], 
+                            \[l:tags_file, a:bufno, a:write_mode])
+            endif
+            call gutentags#trace("Tag file '" . l:tags_file . 
+                        \"' is already being updated. Queuing it up...")
+        elseif a:queue_mode == 1
+            call gutentags#trace("Tag file '" . l:tags_file .
+                        \"' is already being updated. Skipping...")
+        elseif a:queue_mode == 0
+            echom "gutentags: The tags file is already being updated, " .
+                        \"please try again later."
+        else
+            call gutentags#throw("Unknown queue mode: " . a:queue_mode)
+        endif
+
+        " Don't update the tags right now.
+        return
+    endif
+
+    " Switch to the project root to make the command line smaller, and make
+    " it possible to get the relative path of the filename to parse if we're
+    " doing an incremental update.
+    let l:prev_cwd = getcwd()
+    call gutentags#chdir(fnameescape(l:proj_dir))
+    try
+        call call("gutentags#".a:module."#generate",
+                    \[l:proj_dir, l:tags_file,
+                    \ {
+                    \   'write_mode': a:write_mode,
+                    \ }])
+    catch /^gutentags\:/
+        echom "Error while generating ".a:module." file:"
+        echom v:exception
+    finally
+        " Restore the current directory...
+        call gutentags#chdir(fnameescape(l:prev_cwd))
+    endtry
+endfunction
+
+" }}}
+
+" Utility Functions {{{
+
+function! gutentags#rescan(...)
+    if exists('b:gutentags_files')
+        unlet b:gutentags_files
+    endif
+    if a:0 && a:1
+        let l:trace_backup = g:gutentags_trace
+        let l:gutentags_trace = 1
+    endif
+    call gutentags#setup_gutentags()
+    if a:0 && a:1
+        let g:gutentags_trace = l:trace_backup
+    endif
+endfunction
+
+function! gutentags#toggletrace(...)
+    let g:gutentags_trace = !g:gutentags_trace
+    if a:0 > 0
+        let g:gutentags_trace = a:1
+    endif
+    if g:gutentags_trace
+        echom "gutentags: Tracing is enabled."
+    else
+        echom "gutentags: Tracing is disabled."
+    endif
+    echom ""
+endfunction
+
+function! gutentags#fake(...)
+    let g:gutentags_fake = !g:gutentags_fake
+    if a:0 > 0
+        let g:gutentags_fake = a:1
+    endif
+    if g:gutentags_fake
+        echom "gutentags: Now faking gutentags."
+    else
+        echom "gutentags: Now running gutentags for real."
+    endif
+    echom ""
+endfunction
+
+function! gutentags#default_io_cb(chan, msg) abort
+    call gutentags#trace('[job output]: '.string(a:msg))
+endfunction
+
+if has('nvim')
+    " Neovim job API.
+    function! s:nvim_job_exit_wrapper(real_cb, job, exit_code, event_type) abort
+        call call(a:real_cb, [a:job, a:exit_code])
+    endfunction
+
+    function! s:nvim_job_out_wrapper(real_cb, job, lines, event_type) abort
+        call call(a:real_cb, [a:job, a:lines])
+    endfunction
+
+    function! gutentags#build_default_job_options(module) abort
+       " Neovim kills jobs on exit, which is what we want.
+       let l:job_opts = {
+                \'on_exit': function(
+                \    '<SID>nvim_job_exit_wrapper',
+                \    ['gutentags#'.a:module.'#on_job_exit']),
+                \'on_stdout': function(
+                \    '<SID>nvim_job_out_wrapper',
+                \    ['gutentags#default_io_cb']),
+                \'on_stderr': function(
+                \    '<SID>nvim_job_out_wrapper',
+                \    ['gutentags#default_io_cb'])
+                \}
+       return l:job_opts
+    endfunction
+
+    function! gutentags#start_job(cmd, opts) abort
+        return jobstart(a:cmd, a:opts)
+    endfunction
+else
+    " Vim8 job API.
+    function! gutentags#build_default_job_options(module) abort
+        let l:job_opts = {
+                 \'exit_cb': 'gutentags#'.a:module.'#on_job_exit',
+                 \'out_cb': 'gutentags#default_io_cb',
+                 \'err_cb': 'gutentags#default_io_cb',
+                 \'stoponexit': 'term'
+                 \}
+        return l:job_opts
+    endfunction
+
+    function! gutentags#start_job(cmd, opts) abort
+        return job_start(a:cmd, a:opts)
+    endfunction
+endif
+
+" Returns which modules are currently generating something for the
+" current buffer.
+function! gutentags#inprogress()
+    " Does this buffer have gutentags enabled?
+    if !exists('b:gutentags_files')
+        return []
+    endif
+
+    " Find any module that has a job in progress for any of this buffer's
+    " tags files.
+    let l:modules_in_progress = []
+    for [module, tags_file] in items(b:gutentags_files)
+        let l:jobidx = gutentags#find_job_index_by_tags_file(module, tags_file)
+        if l:jobidx >= 0
+            call add(l:modules_in_progress, module)
+        endif
+    endfor
+    return l:modules_in_progress
+endfunction
+
+" }}}
+
+" Statusline Functions {{{
+
+" Prints whether a tag file is being generated right now for the current
+" buffer in the status line.
+"
+" Arguments can be passed:
+" - args 1 and 2 are the prefix and suffix, respectively, of whatever output,
+"   if any, is going to be produced.
+"   (defaults to empty strings)
+" - arg 3 is the text to be shown if tags are currently being generated.
+"   (defaults to the name(s) of the modules currently generating).
+
+function! gutentags#statusline(...) abort
+    let l:modules_in_progress = gutentags#inprogress()
+    if empty(l:modules_in_progress)
+       return ''
+    endif
+
+    let l:prefix = ''
+    let l:suffix = ''
+    if a:0 > 0
+       let l:prefix = a:1
+    endif
+    if a:0 > 1
+       let l:suffix = a:2
+    endif
+
+    if a:0 > 2
+       let l:genmsg = a:3
+    else
+       let l:genmsg = join(l:modules_in_progress, ',')
+    endif
+
+    return l:prefix.l:genmsg.l:suffix
+endfunction
+
+" Same as `gutentags#statusline`, but the only parameter is a `Funcref` or
+" function name that will get passed the list of modules currently generating
+" something. This formatter function should return the string to display in
+" the status line.
+
+function! gutentags#statusline_cb(fmt_cb, ...) abort
+    let l:modules_in_progress = gutentags#inprogress()
+
+    if (a:0 == 0 || !a:1) && empty(l:modules_in_progress)
+       return ''
+    endif
+
+    return call(a:fmt_cb, [l:modules_in_progress])
+endfunction
+
+" }}}
+

dotfiles/vim/bundle/vim-gutentags/autoload/gutentags/cscope.vim

@@ -0,0 +1,93 @@
+" Cscope module for Gutentags
+
+if !has('cscope')
+    throw "Can't enable the cscope module for Gutentags, this Vim has ".
+                \"no support for cscope files."
+endif
+
+" Global Options {{{
+
+if !exists('g:gutentags_cscope_executable')
+    let g:gutentags_cscope_executable = 'cscope'
+endif
+
+if !exists('g:gutentags_scopefile')
+    let g:gutentags_scopefile = 'cscope.out'
+endif
+
+if !exists('g:gutentags_auto_add_cscope')
+    let g:gutentags_auto_add_cscope = 1
+endif
+
+if !exists('g:gutentags_cscope_build_inverted_index')
+    let g:gutentags_cscope_build_inverted_index = 0
+endif
+
+" }}}
+
+" Gutentags Module Interface {{{
+
+let s:runner_exe = gutentags#get_plat_file('update_scopedb')
+let s:unix_redir = (&shellredir =~# '%s') ? &shellredir : &shellredir . ' %s'
+let s:added_dbs = []
+
+function! gutentags#cscope#init(project_root) abort
+    let l:dbfile_path = gutentags#get_cachefile(
+                \a:project_root, g:gutentags_scopefile)
+    let b:gutentags_files['cscope'] = l:dbfile_path
+
+    if g:gutentags_auto_add_cscope && filereadable(l:dbfile_path)
+        if index(s:added_dbs, l:dbfile_path) < 0
+            call add(s:added_dbs, l:dbfile_path)
+            silent! execute 'cs add ' . fnameescape(l:dbfile_path)
+        endif
+    endif
+endfunction
+
+function! gutentags#cscope#generate(proj_dir, tags_file, gen_opts) abort
+    let l:cmd = [s:runner_exe]
+    let l:cmd += ['-e', g:gutentags_cscope_executable]
+    let l:cmd += ['-p', a:proj_dir]
+    let l:cmd += ['-f', a:tags_file]
+    let l:file_list_cmd =
+        \ gutentags#get_project_file_list_cmd(a:proj_dir)
+    if !empty(l:file_list_cmd)
+        let l:cmd += ['-L', '"' . l:file_list_cmd . '"']
+    endif
+    if g:gutentags_cscope_build_inverted_index
+        let l:cmd += ['-I']
+    endif
+    let l:cmd = gutentags#make_args(l:cmd)
+
+    call gutentags#trace("Running: " . string(l:cmd))
+    call gutentags#trace("In:      " . getcwd())
+    if !g:gutentags_fake
+		let l:job_opts = gutentags#build_default_job_options('cscope')
+        let l:job = gutentags#start_job(l:cmd, l:job_opts)
+        call gutentags#add_job('cscope', a:tags_file, l:job)
+    else
+        call gutentags#trace("(fake... not actually running)")
+    endif
+endfunction
+
+function! gutentags#cscope#on_job_exit(job, exit_val) abort
+    let l:job_idx = gutentags#find_job_index_by_data('cscope', a:job)
+    let l:dbfile_path = gutentags#get_job_tags_file('cscope', l:job_idx)
+    call gutentags#remove_job('cscope', l:job_idx)
+
+    if a:exit_val == 0
+        if index(s:added_dbs, l:dbfile_path) < 0
+            call add(s:added_dbs, l:dbfile_path)
+            silent! execute 'cs add ' . fnameescape(l:dbfile_path)
+        else
+            silent! execute 'cs reset'
+        endif
+    else
+        call gutentags#warning(
+                    \"cscope job failed, returned: ".
+                    \string(a:exit_val))
+    endif
+endfunction
+
+" }}}
+

dotfiles/vim/bundle/vim-gutentags/autoload/gutentags/ctags.vim

@@ -0,0 +1,294 @@
+" Ctags module for Gutentags
+
+" Global Options {{{
+
+let g:gutentags_ctags_executable = get(g:, 'gutentags_ctags_executable', 'ctags')
+let g:gutentags_ctags_tagfile = get(g:, 'gutentags_ctags_tagfile', 'tags')
+let g:gutentags_ctags_auto_set_tags = get(g:, 'gutentags_ctags_auto_set_tags', 1)
+
+let g:gutentags_ctags_options_file = get(g:, 'gutentags_ctags_options_file', '.gutctags')
+let g:gutentags_ctags_check_tagfile = get(g:, 'gutentags_ctags_check_tagfile', 0)
+let g:gutentags_ctags_extra_args = get(g:, 'gutentags_ctags_extra_args', [])
+let g:gutentags_ctags_post_process_cmd = get(g:, 'gutentags_ctags_post_process_cmd', '')
+
+let g:gutentags_ctags_exclude = get(g:, 'gutentags_ctags_exclude', [])
+let g:gutentags_ctags_exclude_wildignore = get(g:, 'gutentags_ctags_exclude_wildignore', 1)
+
+" Backwards compatibility.
+function! s:_handleOldOptions() abort
+    let l:renamed_options = {
+                \'gutentags_exclude': 'gutentags_ctags_exclude',
+                \'gutentags_tagfile': 'gutentags_ctags_tagfile',
+                \'gutentags_auto_set_tags': 'gutentags_ctags_auto_set_tags'
+                \}
+    for key in keys(l:renamed_options)
+        if exists('g:'.key)
+            let newname = l:renamed_options[key]
+            echom "gutentags: Option 'g:'".key." has been renamed to ".
+                        \"'g:'".newname." Please update your vimrc."
+            let g:[newname] = g:[key]
+        endif
+    endfor
+endfunction
+call s:_handleOldOptions()
+" }}}
+
+" Gutentags Module Interface {{{
+
+let s:did_check_exe = 0
+let s:runner_exe = gutentags#get_plat_file('update_tags')
+let s:unix_redir = (&shellredir =~# '%s') ? &shellredir : &shellredir . ' %s'
+let s:wildignores_options_path = ''
+let s:last_wildignores = ''
+
+function! gutentags#ctags#init(project_root) abort
+    " Figure out the path to the tags file.
+    " Check the old name for this option, too, before falling back to the
+    " globally defined name.
+    let l:tagfile = getbufvar("", 'gutentags_ctags_tagfile',
+                \getbufvar("", 'gutentags_tagfile', 
+                \g:gutentags_ctags_tagfile))
+    let b:gutentags_files['ctags'] = gutentags#get_cachefile(
+                \a:project_root, l:tagfile)
+
+    " Set the tags file for Vim to use.
+    if g:gutentags_ctags_auto_set_tags
+        execute 'setlocal tags^=' . fnameescape(b:gutentags_files['ctags'])
+    endif
+
+    " Check if the ctags executable exists.
+    if s:did_check_exe == 0
+        if g:gutentags_enabled && executable(expand(g:gutentags_ctags_executable, 1)) == 0
+            let g:gutentags_enabled = 0
+            echoerr "Executable '".g:gutentags_ctags_executable."' can't be found. "
+                        \."Gutentags will be disabled. You can re-enable it by "
+                        \."setting g:gutentags_enabled back to 1."
+        endif
+        let s:did_check_exe = 1
+    endif
+endfunction
+
+function! gutentags#ctags#generate(proj_dir, tags_file, gen_opts) abort
+    let l:write_mode = a:gen_opts['write_mode']
+
+    let l:tags_file_exists = filereadable(a:tags_file)
+    let l:tags_file_relative = fnamemodify(a:tags_file, ':.')
+    let l:tags_file_is_local = len(l:tags_file_relative) < len(a:tags_file)
+
+    if l:tags_file_exists && g:gutentags_ctags_check_tagfile
+        let l:first_lines = readfile(a:tags_file, '', 1)
+        if len(l:first_lines) == 0 || stridx(l:first_lines[0], '!_TAG_') != 0
+            call gutentags#throw(
+                        \"File ".a:tags_file." doesn't appear to be ".
+                        \"a ctags file. Please delete it and run ".
+                        \":GutentagsUpdate!.")
+            return
+        endif
+    endif
+
+    if empty(g:gutentags_cache_dir) && l:tags_file_is_local
+        " If we don't use the cache directory, we can pass relative paths
+        " around.
+        "
+        " Note that if we don't do this and pass a full path for the project
+        " root, some `ctags` implementations like Exhuberant Ctags can get
+        " confused if the paths have spaces -- but not if you're *in* the root 
+        " directory, for some reason... (which we are, our caller in
+        " `autoload/gutentags.vim` changed it).
+        let l:actual_proj_dir = '.'
+        let l:actual_tags_file = l:tags_file_relative
+    else
+        " else: the tags file goes in a cache directory, so we need to specify
+        " all the paths absolutely for `ctags` to do its job correctly.
+        let l:actual_proj_dir = a:proj_dir
+        let l:actual_tags_file = a:tags_file
+    endif
+
+    " Build the command line.
+    let l:cmd = [s:runner_exe]
+    let l:cmd += ['-e', '"' . s:get_ctags_executable(a:proj_dir) . '"']
+    let l:cmd += ['-t', '"' . l:actual_tags_file . '"']
+    let l:cmd += ['-p', '"' . l:actual_proj_dir . '"']
+    if l:write_mode == 0 && l:tags_file_exists
+        let l:cur_file_path = expand('%:p')
+        if empty(g:gutentags_cache_dir) && l:tags_file_is_local
+            let l:cur_file_path = fnamemodify(l:cur_file_path, ':.')
+        endif
+        let l:cmd += ['-s', '"' . l:cur_file_path . '"']
+    else
+        let l:file_list_cmd = gutentags#get_project_file_list_cmd(l:actual_proj_dir)
+        if !empty(l:file_list_cmd)
+            if match(l:file_list_cmd, '///') > 0
+                let l:suffopts = split(l:file_list_cmd, '///')
+                let l:suffoptstr = l:suffopts[1]
+                let l:file_list_cmd = l:suffopts[0]
+                if l:suffoptstr == 'absolute'
+                    let l:cmd += ['-A']
+                endif
+            endif
+            let l:cmd += ['-L', '"' . l:file_list_cmd. '"']
+        endif
+    endif
+    if empty(get(l:, 'file_list_cmd', ''))
+        " Pass the Gutentags recursive options file before the project
+        " options file, so that users can override --recursive.
+        " Omit --recursive if this project uses a file list command.
+        let l:cmd += ['-o', '"' . gutentags#get_res_file('ctags_recursive.options') . '"']
+    endif
+    if !empty(g:gutentags_ctags_extra_args)
+        let l:cmd += ['-O', shellescape(join(g:gutentags_ctags_extra_args))]
+    endif
+    if !empty(g:gutentags_ctags_post_process_cmd)
+        let l:cmd += ['-P', shellescape(g:gutentags_ctags_post_process_cmd)]
+    endif
+    let l:proj_options_file = a:proj_dir . '/' .
+                \g:gutentags_ctags_options_file
+    if filereadable(l:proj_options_file)
+        let l:proj_options_file = s:process_options_file(
+                    \a:proj_dir, l:proj_options_file)
+        let l:cmd += ['-o', '"' . l:proj_options_file . '"']
+    endif
+    if g:gutentags_ctags_exclude_wildignore
+        call s:generate_wildignore_options()
+        if !empty(s:wildignores_options_path)
+            let l:cmd += ['-x', shellescape('@'.s:wildignores_options_path, 1)]
+        endif
+    endif
+    for exc in g:gutentags_ctags_exclude
+        let l:cmd += ['-x', '"' . exc . '"']
+    endfor
+    if g:gutentags_pause_after_update
+        let l:cmd += ['-c']
+    endif
+    if g:gutentags_trace
+        let l:cmd += ['-l', '"' . l:actual_tags_file . '.log"']
+    endif
+    let l:cmd = gutentags#make_args(l:cmd)
+
+    call gutentags#trace("Running: " . string(l:cmd))
+    call gutentags#trace("In:      " . getcwd())
+    if !g:gutentags_fake
+        let l:job_opts = gutentags#build_default_job_options('ctags')
+        let l:job = gutentags#start_job(l:cmd, l:job_opts)
+        call gutentags#add_job('ctags', a:tags_file, l:job)
+    else
+        call gutentags#trace("(fake... not actually running)")
+    endif
+endfunction
+
+function! gutentags#ctags#on_job_exit(job, exit_val) abort
+    call gutentags#remove_job_by_data('ctags', a:job)
+
+    if a:exit_val != 0
+        call gutentags#warning("ctags job failed, returned: ".
+                    \string(a:exit_val))
+    endif
+endfunction
+
+" }}}
+
+" Utilities {{{
+
+" Get final ctags executable depending whether a filetype one is defined
+function! s:get_ctags_executable(proj_dir) abort
+    "Only consider the main filetype in cases like 'python.django'
+    let l:ftype = get(split(&filetype, '\.'), 0, '')
+    let l:proj_info = gutentags#get_project_info(a:proj_dir)
+    let l:type = get(l:proj_info, 'type', l:ftype)
+    let exepath = exists('g:gutentags_ctags_executable_{l:type}')
+        \ ? g:gutentags_ctags_executable_{l:type} : g:gutentags_ctags_executable
+    return expand(exepath, 1)
+endfunction
+
+function! s:generate_wildignore_options() abort
+    if s:last_wildignores == &wildignore
+        " The 'wildignore' setting didn't change since last time we did this.
+        call gutentags#trace("Wildignore options file is up to date.")
+        return
+    endif
+
+    if s:wildignores_options_path == ''
+        if empty(g:gutentags_cache_dir)
+            let s:wildignores_options_path = tempname()
+        else
+            let s:wildignores_options_path = 
+                        \gutentags#stripslash(g:gutentags_cache_dir).
+                        \'/_wildignore.options'
+        endif
+    endif
+
+    call gutentags#trace("Generating wildignore options: ".s:wildignores_options_path)
+    let l:opt_lines = []
+    for ign in split(&wildignore, ',')
+        call add(l:opt_lines, ign)
+    endfor
+    call writefile(l:opt_lines, s:wildignores_options_path)
+    let s:last_wildignores = &wildignore
+endfunction
+
+function! s:process_options_file(proj_dir, path) abort
+    if empty(g:gutentags_cache_dir)
+        " If we're not using a cache directory to store tag files, we can
+        " use the options file straight away.
+        return a:path
+    endif
+
+    " See if we need to process the options file.
+    let l:do_process = 0
+    let l:proj_dir = gutentags#stripslash(a:proj_dir)
+    let l:out_path = gutentags#get_cachefile(l:proj_dir, 'options')
+    if !filereadable(l:out_path)
+        call gutentags#trace("Processing options file '".a:path."' because ".
+                    \"it hasn't been processed yet.")
+        let l:do_process = 1
+    elseif getftime(a:path) > getftime(l:out_path)
+        call gutentags#trace("Processing options file '".a:path."' because ".
+                    \"it has changed.")
+        let l:do_process = 1
+    endif
+    if l:do_process == 0
+        " Nothing's changed, return the existing processed version of the
+        " options file.
+        return l:out_path
+    endif
+
+    " We have to process the options file. Right now this only means capturing
+    " all the 'exclude' rules, and rewrite them to make them absolute.
+    "
+    " This is because since `ctags` is run with absolute paths (because we
+    " want the tag file to be in a cache directory), it will do its path
+    " matching with absolute paths too, so the exclude rules need to be
+    " absolute.
+    let l:lines = readfile(a:path)
+    let l:outlines = []
+    for line in l:lines
+        let l:exarg_idx = matchend(line, '\v^\-\-exclude=')
+        if l:exarg_idx < 0
+            call add(l:outlines, line)
+            continue
+        endif
+
+        " Don't convert things that don't look like paths.
+        let l:exarg = strpart(line, l:exarg_idx + 1)
+        let l:do_convert = 1
+        if l:exarg[0] == '@'   " Manifest file path
+            let l:do_convert = 0
+        endif
+        if stridx(l:exarg, '/') < 0 && stridx(l:exarg, '\\') < 0   " Filename
+            let l:do_convert = 0
+        endif
+        if l:do_convert == 0
+            call add(l:outlines, line)
+            continue
+        endif
+
+        let l:fullp = l:proj_dir . gutentags#normalizepath('/'.l:exarg)
+        let l:ol = '--exclude='.l:fullp
+        call add(l:outlines, l:ol)
+    endfor
+
+    call writefile(l:outlines, l:out_path)
+    return l:out_path
+endfunction
+
+" }}}

dotfiles/vim/bundle/vim-gutentags/autoload/gutentags/gtags_cscope.vim

@@ -0,0 +1,122 @@
+" gtags_cscope module for Gutentags
+
+if !has('cscope')
+    throw "Can't enable the gtags-cscope module for Gutentags, "
+                \"this Vim has no support for cscope files."
+endif
+
+" Global Options {{{
+
+if !exists('g:gutentags_gtags_executable')
+    let g:gutentags_gtags_executable = 'gtags'
+endif
+
+if !exists('g:gutentags_gtags_dbpath')
+    let g:gutentags_gtags_dbpath = ''
+endif
+
+if !exists('g:gutentags_gtags_options_file')
+    let g:gutentags_gtags_options_file = '.gutgtags'
+endif
+
+if !exists('g:gutentags_gtags_cscope_executable')
+    let g:gutentags_gtags_cscope_executable = 'gtags-cscope'
+endif
+
+if !exists('g:gutentags_auto_add_gtags_cscope')
+    let g:gutentags_auto_add_gtags_cscope = 1
+endif
+
+" }}}
+
+" Gutentags Module Interface {{{
+
+let s:added_db_files = {}
+
+function! s:add_db(db_file) abort
+    if filereadable(a:db_file)
+        call gutentags#trace(
+                    \"Adding cscope DB file: " . a:db_file)
+        set nocscopeverbose
+        execute 'cs add ' . fnameescape(a:db_file)
+        set cscopeverbose
+        let s:added_db_files[a:db_file] = 1
+    else
+        call gutentags#trace(
+                    \"Not adding cscope DB file because it doesn't " .
+                    \"exist yet: " . a:db_file)
+    endif
+endfunction
+
+function! gutentags#gtags_cscope#init(project_root) abort
+    let l:db_path = gutentags#get_cachefile(
+                \a:project_root, g:gutentags_gtags_dbpath)
+    let l:db_path = gutentags#stripslash(l:db_path)
+    let l:db_file = l:db_path . '/GTAGS'
+    let l:db_file = gutentags#normalizepath(l:db_file)
+
+    if !isdirectory(l:db_path)
+        call mkdir(l:db_path, 'p')
+    endif
+
+    let b:gutentags_files['gtags_cscope'] = l:db_file
+
+    execute 'set cscopeprg=' . fnameescape(g:gutentags_gtags_cscope_executable)
+
+    " The combination of gtags-cscope, vim's cscope and global files is
+    " a bit flaky. Environment variables are safer than vim passing
+    " paths around and interpreting input correctly.
+    let $GTAGSDBPATH = l:db_path
+    let $GTAGSROOT = a:project_root
+
+    if g:gutentags_auto_add_gtags_cscope && 
+                \!has_key(s:added_db_files, l:db_file)
+        let s:added_db_files[l:db_file] = 0
+        call s:add_db(l:db_file)
+    endif
+endfunction
+
+function! gutentags#gtags_cscope#generate(proj_dir, tags_file, gen_opts) abort
+    " gtags doesn't honour GTAGSDBPATH and GTAGSROOT, so PWD and dbpath
+    " have to be set
+    let l:db_path = fnamemodify(a:tags_file, ':p:h')
+
+    let l:proj_options_file = a:proj_dir . '/' . g:gutentags_gtags_options_file
+
+    let l:cmd = ['"'.g:gutentags_gtags_executable.'"']
+    if filereadable(l:proj_options_file)
+        let l:proj_options = readfile(l:proj_options_file)
+        let l:cmd += l:proj_options
+    endif
+    let l:cmd += ['--incremental', '"'.l:db_path.'"']
+    let l:cmd = gutentags#make_args(l:cmd)
+
+    call gutentags#trace("Running: " . string(l:cmd))
+    call gutentags#trace("In:      " . getcwd())
+    if !g:gutentags_fake
+        let l:job_opts = gutentags#build_default_job_options('gtags_cscope')
+        let l:job = gutentags#start_job(l:cmd, l:job_opts)
+        call gutentags#add_job('gtags_cscope', a:tags_file, l:job)
+    else
+        call gutentags#trace("(fake... not actually running)")
+    endif
+    call gutentags#trace("")
+endfunction
+
+function! gutentags#gtags_cscope#on_job_exit(job, exit_val) abort
+    let l:job_idx = gutentags#find_job_index_by_data('gtags_cscope', a:job)
+    let l:dbfile_path = gutentags#get_job_tags_file('gtags_cscope', l:job_idx)
+    call gutentags#remove_job('gtags_cscope', l:job_idx)
+
+    if g:gutentags_auto_add_gtags_cscope
+        call s:add_db(l:dbfile_path)
+    endif
+
+    if a:exit_val != 0
+        call gutentags#warning(
+                    \"gtags-cscope job failed, returned: ".
+                    \string(a:exit_val))
+    endif
+endfunction
+
+" }}}

dotfiles/vim/bundle/vim-gutentags/doc/gutentags.txt

@@ -0,0 +1,728 @@
+*gutentags.txt*  Automatic ctags management for VIM
+      ___           ___           ___           ___           ___     
+     /\__\         /\  \         /\__\         /\__\         /\  \    
+    /:/ _/_        \:\  \       /:/  /        /:/ _/_        \:\  \   
+   /:/ /\  \        \:\  \     /:/__/        /:/ /\__\        \:\  \  
+  /:/ /::\  \   ___  \:\  \   /::\  \       /:/ /:/ _/_   _____\:\  \ 
+ /:/__\/\:\__\ /\  \  \:\__\ /:/\:\  \     /:/_/:/ /\__\ /::::::::\__\
+ \:\  \ /:/  / \:\  \ /:/  / \/__\:\  \    \:\/:/ /:/  / \:\~~\~~\/__/
+  \:\  /:/  /   \:\  /:/  /       \:\__\    \::/_/:/  /   \:\  \      
+   \:\/:/  /     \:\/:/  /         \/__/     \:\/:/  /     \:\  \     
+    \::/  /       \::/  /                     \::/  /       \:\__\    
+     \/__/         \/__/                       \/__/         \/__/    
+        ___           ___           ___           ___     
+       /\__\         /\  \         /\__\         /\__\    
+      /:/  /        /::\  \       /:/ _/_       /:/ _/_   
+     /:/__/        /:/\:\  \     /:/ /\  \     /:/ /\  \  
+    /::\  \       /:/ /::\  \   /:/ /::\  \   /:/ /::\  \ 
+   /:/\:\  \     /:/_/:/\:\__\ /:/__\/\:\__\ /:/_/:/\:\__\
+   \/__\:\  \    \:\/:/  \/__/ \:\  \ /:/  / \:\/:/ /:/  /
+        \:\__\    \::/__/       \:\  /:/  /   \::/ /:/  / 
+         \/__/     \:\  \        \:\/:/  /     \/_/:/  /  
+                    \:\__\        \::/  /        /:/  /   
+                     \/__/         \/__/         \/__/    
+
+
+                GUTENTAGS REFERENCE MANUAL
+                    by Ludovic Chabant
+
+                                                *gutentags*
+
+1. Introduction             |gutentags-intro|
+2. Commands                 |gutentags-commands|
+3. Status Line              |gutentags-status-line|
+4. Global Settings          |gutentags-settings|
+5. Project Settings         |gutentags-project-settings|
+
+=============================================================================
+1. Introduction                                 *gutentags-intro*
+
+Gutentags is a plugin that takes care of the much needed management of tags
+files in Vim. It will (re)generate tag files as you work while staying
+completely out of your way. It will even do its best to keep those tag files
+out of your way too. It has no dependencies and just works.
+
+In order to generate tag files, Gutentags will have to figure out what's in
+your project. To do this, it will locate well-known project root markers like
+SCM folders (.git, .hg, etc.), any custom tags you define (with
+|gutentags_project_root|), and even things you may have defined already with
+other plugins, like CtrlP.
+
+If the current file you're editing is found to be in such a project, Gutentags
+will make sure the tag file for that project is up to date. Then, as you work
+in files in that project, it will partially re-generate the tag file. Every
+time you save, it will silently, in the background, update the tags for that
+file.
+
+Usually, `ctags` can only append tags to an existing tag file, so Gutentags
+removes the tags for the current file first, to make sure the tag file is
+always consistent with the source code.
+
+Also, Gutentags is clever enough to not stumble upon itself by triggering
+multiple ctags processes if you save files too fast, or if your project is
+really big.
+
+
+1.1 Requirements
+                                                *gutentags-ctags-requirements*
+
+If you're using the `ctags` modules (which is the default and only working one
+at this point, really), you will need a `tags` generator that supports the
+following arguments:
+
+* `-f` (to specify the output file)
+* `--append` (to append to an existing file while keeping it sorted)
+* `--exclude` (to exclude file patterns)
+* `--options` (to specify an options file)
+
+This means you probably want Exuberant Ctags or Universal Ctags. The basic
+old BSD Ctags WON'T WORK. Other language-specific versions may or may not
+work. Check with their help or man page.
+
+
+1.2 Similar Plugins
+                                                *gutentags-similar-plugins*
+
+There are some similar Vim plugins out there ("vim-tags", "vim-autotag",
+"vim-automatic-ctags", etc.). They all fail on one or more of the requirements
+I set for myself with Gutentags:
+
+* No other dependency than running Vim: no Python, Ruby, or whatever.
+* Cross-platform: should work on at least Mac and Windows.
+* Incremental tags generation: don't re-generate the whole project all the
+  time. This may be fine for small projects, but it doesn't scale.
+* External process management: if the ctags process is taking a long time,
+  don't run another one because I saved the file again.
+* Keep the tag file consistent: don't just append the current file's tags to
+  the tag file, otherwise you will still "see" tags for deleted or renamed
+  classes and functions.
+* Automatically create the tag file: you open something from a freshly forked
+  project, it should start indexing it automatically, just like in Sublime Text 
+  or Visual Studio or any other IDE.
+
+
+=============================================================================
+2. Commands                                     *gutentags-commands*
+
+                                                *gutentags-project-commands*
+The following commands are only available in buffers that have been found to
+belong to a project that should be managed by Gutentags. See
+|gutentags_project_root| for how Gutentags figures out the project a file
+belongs to. When no project is found (i.e. the file is not under any of the
+known project markers), Gutentags is disabled for that buffer, and the
+following commands and remarks don't apply.
+
+If you want to force-disable Gutentags for a given project even though it does
+match one of the items in |gutentags_project_root|, create a file named
+"`.notags`" at the root of the project.
+
+The tag file that Gutentags creates and manages will be named after
+|gutentags_ctags_tagfile|, relative to the project's root directory. When
+Gutentags finds a valid project root, it will prepend the tag file's path to
+'tags', unless |gutentags_ctags_auto_set_tags| is set to 0. This is to make
+sure Vim will use that file first.
+
+If a file managed by Gutentags is opened and no tag file already exists,
+Gutentags will start generating it right away in the background, unless 
+|gutentags_generate_on_missing| is set to 0. If you have a large project, you
+may want to know when Gutentags is generating tags: see
+|gutentags-status-line| to display an indicator in your status line.
+
+When a file managed by Gutentags is saved, the tag file will be incrementally
+updated, i.e. references to the recently saved file are removed, and that file
+is re-parsed for tags, with the result being merged into the tag file. This
+makes the tag file 100% consistent with the latest changes. This doesn't
+happen however if |gutentags_generate_on_write| is set to 0, in which case you
+have to run |GutentagsUpdate| manually.
+
+
+                                                *:GutentagsUpdate*
+:GutentagsUpdate
+                        Forces an update of the current tag file with the
+                        current buffer. If tags are already being generated,
+                        you will be notified and the command will abort.
+
+:GutentagsUpdate!
+                        Like |GutentagsUpdate|, but updates the current tags
+                        file with the whole project instead of just the
+                        current buffer.
+
+
+Some debugging/troubleshooting commands are also available if the
+|gutentags_define_advanced_commands| global setting is set to 1.
+
+                                                *:GutentagsToggleEnabled*
+:GutentagsToggleEnabled
+                        Disables and re-enables Gutentags.
+                        When Gutentags is disabled, it won't update your tag
+                        file when you save a buffer. It will however still
+                        look for project markers as you open new buffers so
+                        that they can start working again when you re-enable
+                        Gutentags.
+
+                        {only available when
+                        |gutentags_define_advanced_commands| is set}
+
+                                                *GutentagsToggleTrace*
+:GutentagsToggleTrace
+                        If you want to keep an eye on what Gutentags is doing,
+                        you can enable tracing. This will show messages every
+                        time Gutentags does something. It can get annoying
+                        quickly, since it will require you to press a key to
+                        dismiss those messages, but it can be useful to
+                        troubleshoot a problem.
+                        In addition to messages in Vim, it will also make
+                        Gutentags redirect the output of the tag generation
+                        script to a `.log` file in the project root.
+
+                        {only available when
+                        |gutentags_define_advanced_commands| is set}
+
+
+Gutentags also has some user auto-commands (see |User| and |:doautocmd|):
+
+                                                *GutentagsUpdating*
+GutentagsUpdating
+                        This auto-command is triggered when a background
+                        update job has started.
+
+                                                *GutentagsUpdated*
+GutentagsUpdated
+                        This auto-command is triggered when a background
+                        update job has finished.
+
+
+=============================================================================
+3.  Status Line                                 *gutentags-status-line*
+
+Tag file generation can take a while if you're working on a project big
+enough. In that case, you may want to know when `ctags` is running, so you
+have a heads up if some of the tags aren't recognized yet.
+
+                                                *gutentags#statusline()*
+You can display an indicator of tag generation progress in your |status-line|
+with the following function: >
+        :set statusline+=%{gutentags#statusline()}
+
+The function will, by default, print a list of modules in the status line. So
+if the `ctags` module (see |g:gutentags_modules|) is currently generating
+a tags file, you will see "ctags" printed in the status line. If nothing is
+happening, nothing will be printed in the status line.
+
+You can pass some parameters to customize this:
+
+1. A prefix string (defaults to `""`).
+2. A suffix string (defaults to `""`).
+3. The text to print (defaults to the names of modules currently generating
+   something).
+
+So using `gutentags#statusline('[', ']')` would print `"[ctags]"` instead of
+`"ctags"`.
+
+Because Gutentags runs the tag generation in the background, the statusline
+indicator might stay there even after the background process has ended. It
+would only go away when Vim decides to refresh the statusline. You can force
+refresh it in a callback on |GutentagsUpdating| and |GutentagsUpdated|.
+
+For instance, with the `lightline` plugin:
+
+        augroup MyGutentagsStatusLineRefresher
+            autocmd!
+            autocmd User GutentagsUpdating call lightline#update()
+            autocmd User GutentagsUpdated call lightline#update()
+        augroup END
+
+                                                *gutentags#statusline_cb*
+As an alternative to the previous function, `gutentags#statusline_cb` takes
+a single parameter which should be a |Funcref| or a function name. This
+function should take a list of active module names, and return a string. This
+lets you completely control what the status line will print.
+
+For instance:
+        function! s:get_gutentags_status(mods) abort
+            let l:msg = ''
+            if index(a:mods, 'ctags') >= 0
+               let l:msg .= '♨'
+             endif
+             if index(a:mods, 'cscope') >= 0
+               let l:msg .= '♺'
+             endif
+             return l:msg
+        endfunction
+
+        :set statusline+=%{gutentags#statusline_cb(
+                    \function('<SID>get_gutentags_status'))}
+
+By default, the callback function doesn't get called if no tags generation is
+currently happening. You can pass `1` as a second argument so that the
+callback function is always called.
+
+
+=============================================================================
+4. Global Settings                              *gutentags-settings*
+
+The following settings can be defined in your |vimrc| to change the default
+behaviour of Gutentags.
+
+                                                *gutentags_enabled*
+g:gutentags_enabled
+                        Defines whether Gutentags should be enabled. When
+                        disabled, Gutentags will still scan for project root
+                        markers when opening buffers. This is so that when you
+                        re-enable Gutentags, you won't have some buffers
+                        mysteriously working while others (those open last)
+                        don't.
+                        Defaults to `1`.
+
+                                                *gutentags_trace*
+g:gutentags_trace
+                        When true, Gutentags will spit out debugging
+                        information as Vim messages (which you can later read
+                        with |:messages|). It also runs its background scripts
+                        with extra parameters to log activity to a `tags.log`
+                        file that you can also inspect for more information.
+
+                        Note: you can run `:verbose GutentagsUpdate` to
+                        temporarily set |g:gutentags_trace| to `1` for that
+                        update only.
+
+                        Defaults to `0`.
+
+                                                *gutentags_dont_load*
+g:gutentags_dont_load
+                        Prevents Gutentags from loading at all on Vim startup.
+
+                        The difference between this and |gutentags_enabled| is
+                        that |gutentags_enabled| can be turned on and off in
+                        the same Vim session -- Gutentags as a plugin stays
+                        loaded and will keep track of what happened while it
+                        was disabled. However, |gutentags_dont_load| only
+                        works on Vim startup and will prevent Gutentags from
+                        loading at all, as if it wasn't there.
+
+                                                *gutentags_modules*
+g:gutentags_modules
+                        A list of modules to load with Gutentags. Each module
+                        is responsible for generating a specific type of tags
+                        file.
+                        Valid values are:
+
+                        - `ctags`: generates a `tags` file using
+                          a `ctags`-compatible program like Exhuberant Ctags
+                          or Universal Ctags.
+
+                        - `cscope`: generates a code database file using
+                          `cscope`.
+
+                        - `gtags_cscope`: same as `cscope` but uses GNU's
+                          `gtags` executable and database.
+
+                        Defaults to `[ctags]`.
+
+                                                *gutentags_project_root*
+g:gutentags_project_root
+                        When a buffer is loaded, Gutentags will figure out if
+                        it's part of a project that should have tags managed
+                        automatically. To do this, it looks for "root markers"
+                        in the current file's directory and its parent
+                        directories. If it finds any of those markers,
+                        Gutentags will be enabled for the project, and a tags
+                        file named after |gutentags_ctags_tagfile| will be 
+                        created at the project root.
+                        Defaults to `[]` (an empty |List|).
+                        A list of default markers will be appended to the
+                        user-defined ones unless
+                        |gutentags_add_default_project_roots| is set to 0.
+
+                                            *gutentags_add_default_project_roots*
+g:gutentags_add_default_project_roots
+                        Defines whether Gutentags should always define some
+                        default project roots (see |gutentags_project_root|).
+                        This can be useful to prevent unnecessary disk access
+                        when Gutentags searches for a project root.
+                        The default markers are:
+                        `['.git', '.hg', '.svn', '.bzr', '_darcs', '_darcs', '_FOSSIL_', '.fslckout']`
+
+                                            *gutentags_add_ctrlp_root_markers*
+g:gutentags_add_ctrlp_root_markers
+                        If Gutentags finds `g:ctrlp_root_markers` (used by the
+                        CtrlP plugin), it will append those root markers to
+                        the existing ones (see |g:gutentags_project_root|).
+                        Set this to 0 to stop it from happening.
+                        Defaults to 1.
+
+                                                *gutentags_exclude_filetypes*
+g:gutentags_exclude_filetypes
+                        A |List| of file types (see |'filetype'|) that Gutentags
+                        should ignore. When a buffer is opened, if its
+                        'filetype' is found in this list, Gutentags features
+                        won't be available for this buffer.
+                        Defaults to an empty list (`[]`).
+
+                                                *gutentags_exclude_project_root*
+g:gutentags_exclude_project_root
+                        A list of project roots to generally ignore. If a file
+                        is opened inside one of those projects, Gutentags
+                        won't be activated. This is similar to placing
+                        a `.notags` file in the root of those projects, but
+                        can be useful when you don't want to, or can't, place
+                        such a file there.
+                        Defaults to `['/usr/local']`, which is the folder where
+                        Homebrew is known to create a Git directory by default
+                        on MacOS.
+
+                                                *gutentags_project_root_finder*
+g:gutentags_project_root_finder
+                        When a buffer is loaded, Gutentags uses a default
+                        (internal) implementation to find that file's
+                        project's root directory, using settings like
+                        |g:gutentags_project_root|. When you specify
+                        |g:gutentags_project_root_finder|, you can tell
+                        Gutentags to use a custom implementation, such as
+                        `vim-projectroot`. The value of this setting must be
+                        the name of a function that takes a single string
+                        argument (the path to the current buffer's file) and
+                        returns a string value (the project's root directory).
+                        Defaults to `''`.
+                        Note: when set, the called implementation will
+                        possibly ignore |g:gutentags_project_root|.
+                        Note: an implementation can fallback to the default
+                        behaviour by calling
+                        `gutentags#default_get_project_root`.
+
+                                                *gutentags_generate_on_missing*
+g:gutentags_generate_on_missing
+                        If set to 1, Gutentags will start generating an initial
+                        tag file if a file is open in a project where no tags
+                        file is found. See |gutentags_project_root| for how
+                        Gutentags locates the project.
+                        When set to 0, Gutentags will only generate the first
+                        time the file is saved (if
+                        |gutentags_generate_on_write| is set to 1), or when
+                        |GutentagsUpdate| or |GutentagsGenerate| is run.
+                        Defaults to 1.
+
+                                                *gutentags_generate_on_new*
+g:gutentags_generate_on_new
+                        If set to 1, Gutentags will start generating the tag
+                        file when a new project is open. A new project is
+                        considered open when a buffer is created for a file
+                        whose corresponding tag file has not been "seen" yet
+                        in the current Vim session -- which pretty much means
+                        when you open the first file in a given source control
+                        repository.
+                        When set to 0, Gutentags won't do anything special.
+                        See also |gutentags_generate_on_missing| and
+                        |gutentags_generate_on_write|.
+                        Defaults to 1.
+
+                                                *gutentags_generate_on_write*
+g:gutentags_generate_on_write
+                        If set to 1, Gutentags will update the current
+                        project's tag file when a file inside that project is
+                        saved. See |gutentags_project_root| for how Gutentags
+                        locates the project.
+                        When set to 0, Gutentags won't do anything on save.
+                        This means that the project's tag file won't reflect
+                        the latest changes, and you will have to run
+                        |GutentagsUpdate| manually.
+                        Defaults to 1.
+
+                                            *gutentags_generate_on_empty_buffer*
+g:gutentags_generate_on_empty_buffer
+                        If set to 1, Gutentags will start generating the tag
+                        file even if there's no buffer currently open, as long
+                        as the current working directory (as returned by
+                        |:cd|) is inside a known project.
+                        This is useful if you want Gutentags to generate the
+                        tag file right after opening Vim.
+                        Defaults to 0.
+
+                                                *gutentags_background_update*
+g:gutentags_background_update
+                        Specifies whether the process that updates the tags
+                        file should be run in the background or in the
+                        foreground. If run in the foreground, Vim will block
+                        until the process is complete.
+                        Defaults to 1.
+
+                                                *gutentags_cache_dir*
+g:gutentags_cache_dir
+                        Specifies a directory in which to create all the tags
+                        files, instead of writing them at the root of each
+                        project. This is handy to keep tags files from
+                        polluting many directories all across your computer.
+
+                                            *gutentags_resolve_symlinks*
+g:gutentags_resolve_symlinks
+                        When set to 1, Gutentags will resolve any symlinks in
+                        the current buffer's path in order to find the project
+                        it belongs to. This is what you want if you're editing
+                        a symlink located outside of the project, and it
+                        points to a file inside the project. However, this is
+                        maybe not what you want if the symlink itself is
+                        part of the project.
+                        Defaults to 0.
+                        
+                                            *gutentags_init_user_func*
+g:gutentags_init_user_func
+                        When set to a non-empty string, it is expected to be
+                        the name of a function that will be called when a file
+                        is opened in a project. The function gets passed the
+                        path of the file and if it returns 0, Gutentags won't
+                        be enabled for that file.
+
+                        You can use this to manually set buffer-local
+                        settings:
+                        
+                        * `b:gutentags_ctags_tagfile` (see |gutentags_ctags_tagfile|).
+
+                        This setting was previously called 
+                        `gutentags_enabled_user_func`. The old setting is
+                        still used as a fallback.
+
+                        Defaults to "".
+
+                                            *gutentags_define_advanced_commands*
+g:gutentags_define_advanced_commands
+                        Defines some advanced commands like
+                        |GutentagsToggleEnabled| and |GutentagsUnlock|.
+
+                                            *gutentags_project_info*
+g:gutentags_project_info
+                        Defines ways for Gutentags to figure out what kind of
+                        project any given file belongs to. This should be
+                        a list of dictionaries:
+
+                        let g:gutentags_project_info = []
+                        call add(g:gutentags_project_info, {...})
+
+                        Each dictionary item must contain at least a `type`
+                        key, indicating the type of project:
+
+                        {"type": "python"}
+
+                        Other items will be used to figure out if a project is
+                        of the given type.
+
+                        "file": any existing file with this path (relative to
+                        the project root) will make the current project match
+                        the given info.
+
+                        "glob": any result found with this glob pattern
+                        (relative to the project root) will make the current
+                        project match the given info. See |glob()| for more
+                        information.
+
+                        Gutentags adds by default the following definitions:
+
+                        call add(g:gutentags_project_info, {'type': 'python', 'file': 'setup.py'})
+                        call add(g:gutentags_project_info, {'type': 'ruby', 'file': 'Gemfile'})
+
+                        This means, for example, that you can use
+                        `g:gutentags_ctags_executable_ruby` out of the box.
+                        See |gutentags_ctags_executable_{filetype}| for more
+                        information.
+
+                                            *gutentags_file_list_command*
+g:gutentags_file_list_command
+                        Specifies command(s) to use to list files for which
+                        tags should be generated, instead of recursively
+                        examining all files within the project root. When
+                        invoked, file list commands will execute in the
+                        project root directory.
+
+                        This setting is useful in projects using source
+                        control to restrict tag generation to only files
+                        tracked in the repository.
+
+                        This variable may be set in one of two ways. If
+                        set as a |String|, the specified command will be used to
+                        list files for all projects. For example: >
+
+                         let g:gutentags_file_list_command = 'find . -type f'
+<
+                        If set as a |Dictionary|, this variable should be set
+                        as a mapping of project root markers to the desired
+                        file list command for that root marker. (See
+                        |gutentags_project_root| for how Gutentags uses root
+                        markers to locate the project.) For example: >
+
+                         let g:gutentags_file_list_command = {
+                             \ 'markers': {
+                                 \ '.git': 'git ls-files',
+                                 \ '.hg': 'hg files',
+                                 \ },
+                             \ }
+<
+                        Note: If a custom ctags executable is specified, it
+                        must support the '-L' command line option in order to
+                        read the list of files to be examined.
+
+
+The following settings are valid for the `ctags` module.
+
+                                                *gutentags_ctags_executable*
+g:gutentags_ctags_executable
+                        Specifies the ctags executable to launch.
+                        Defaults to `ctags`.
+
+                                     *gutentags_ctags_executable_{filetype}*
+g:gutentags_ctags_executable_{type}
+                        Specifies the ctags executable to launch for a project
+                        of type {type}. See |gutentags_project_info| for more
+                        information.
+                        IMPORTANT: please see |gutentags-ctags-requirements|.
+                        Example: >
+                         let g:gutentags_ctags_executable_ruby = 'foobar'
+<
+
+                                                *gutentags_ctags_tagfile*
+g:gutentags_ctags_tagfile
+                        Specifies the name of the tag file to create. This
+                        will be appended to the project's root. See
+                        |gutentags_project_root| for how Gutentags locates the
+                        project.
+                        Defaults to `tags`.
+
+                                                *gutentags_ctags_exclude*
+g:gutentags_ctags_exclude
+                        A list of file patterns to pass to the
+                        |gutentags_ctags_executable| so that they will be
+                        excluded from parsing for the tags generation.
+                        See also |gutentags_ctags_exclude_wildignore|.
+                        Defaults to `[]` (an empty |List|).
+
+                                                *gutentags_ctags_exclude_wildignore*
+g:gutentags_ctags_exclude_wildignore
+                        When 1, Gutentags will automatically pass your
+                        'wildignore' file patterns to the 
+                        |gutentags_ctags_executable| so that they are ignored.
+                        Set also |gutentags_ctags_exclude| to pass custom
+                        patterns.
+                        Defaults to 1.
+
+                                                *gutentags_ctags_auto_set_tags*
+g:gutentags_ctags_auto_set_tags
+                        If set to 1, Gutentags will automatically prepend
+                        'tags' with the exact path to the tag file for the
+                        current project. See |gutentags_project_root| for how
+                        Gutentags locates the project.
+                        When set to 0, Gutentags doesn't change 'tags', and
+                        this means that whatever tag file it generates may
+                        not be picked up by Vim. See |tagfiles()| to know what
+                        tag files Vim knows about.
+                        Defaults to 1.
+
+                                                *gutentags_ctags_extra_args*
+g:gutentags_ctags_extra_args
+                        A list of arguments to pass to `ctags`.
+                        Defaults to `[]`.
+
+                                                *gutentags_ctags_post_process_cmd*
+g:gutentags_ctags_post_process_cmd
+                        If defined, the tags generation script will run the
+                        command with an argument that points to a temporary
+                        copy of the tags file. If the post-process step is
+                        modifying the tags file, it needs to do so in-place.
+                        This is useful for cleaning up a tags file that may
+                        contain tags with non-ASCII names that somehow upsets
+                        Vim.
+                        Defaults to `""` (an empty |String|).
+
+
+The following settings are valid for the `cscope` module.
+
+                                                *gutentags_cscope_executable*
+g:gutentags_cscope_executable
+                        Specifies the name or path of the `cscope` executable
+                        to use to generate the code database.
+                        Defaults to `"cscope"`.
+
+                                                *gutentags_scopefile*
+g:gutentags_scopefile
+                        Specifies the name of the scope file to create. This
+                        will be appended to the project's root. See
+                        |gutentags_project_root| for how Gutentags locates the
+                        project.
+                        Defaults to `"cscope.out"`.
+
+                                                *gutentags_auto_add_cscope*
+g:gutentags_auto_add_cscope
+                        If set to 1, Gutentags will automatically add the
+                        generated code database to Vim by running `:cs add`
+                        (see |:cscope|).
+                        Defaults to 1.
+
+                                                *gutentags_cscope_build_inverted_index*
+g:gutentags_cscope_build_inverted_index
+                        If set to 1, Gutentags will make `cscope` build an
+                        inverted index.
+                        Defaults to 0.
+
+
+The following settings are valid for the `gtags_cscope` module.
+
+                                                *gutentags_gtags_executable*
+g:gutentags_gtags_executable
+                        Specifies the name or path of the `gtags` executable
+                        to use to generate the code database.
+                        Defaults to `"gtags"`.
+
+                                                *gutentags_gtags_cscope_executable*
+g:gutentags_gtags_cscope_executable
+                        Specifies the name or path of the `gtags-cscope`
+                        executable to use to generate the code database.
+                        Defaults to `"gtags-cscope"`.
+
+                                                *gutentags_gtags_dbpath*
+g:gutentags_gtags_dbpath
+                        Path from the cache directory (|gutentags_cache_dir|
+                        or project root) to the folder containing the
+                        definition database file (usually called `GTAGS`).
+                        Defaults to `""`.
+
+                                                *gutentags_gtags_options_file*
+g:gutentags_gtags_options_file
+                        The name of a file that will be looked for in
+                        a project root directory. The file is expected to
+                        contain `gtags` options (one per line).
+                        Defaults to `".gutgtags"`.
+
+                                                *gutentags_auto_add_gtags_cscope*
+g:gutentags_auto_add_gtags_cscope
+                        If set to 1, Gutentags will automatically add the
+                        generated code database to Vim by running `:cs add`
+                        (see |:cscope|).
+                        Defaults to 1.
+
+People using `cscope` or `gtags_cscope` across multiple projects in the same
+Vim instance might be interested in the `gutentags_plus` plugin, which handles
+switching databases automatically before performing a query.
+See https://github.com/skywind3000/gutentags_plus.
+
+=============================================================================
+5. Project Settings                             *gutentags-project-settings*
+
+Gutentags can be customized to some extent on a per-project basis with the
+following files present in the project root directory:
+
+                                                *gutentags-.gutctags*
+`.gutctags`: if this file exists, Ctags will be told to load additional
+command-line parameters by reading it line by line (see the Ctags
+documentation for more information).
+
+Note that for complex reasons, Gutentags can't run `ctags` from the project
+root if you're using |gutentags_cache_dir|, so if the `.gutctags` file exists,
+it will be pre-processed in order to make all `--exclude=` clauses into
+absolute paths (by prepending the project root). The resulting file will be
+saved into the cache directory, and passed to `ctags` via the `--options=`
+parameter. If you're _not_ using |gutentags_cache_dir|, the `.gutctags` file
+is _not_ pre-processed, and is passed as-is via the `--options=` parameter.
+
+                                                *gutentags-.notags*
+`.notags`: if this file exists, Gutentags will be disabled completely for that
+project.
+
+
+ vim:tw=78:et:ft=help:norl:

dotfiles/vim/bundle/vim-gutentags/plat/unix/update_scopedb.sh

@@ -0,0 +1,124 @@
+#!/bin/sh
+
+set -e
+
+PROG_NAME=$0
+CSCOPE_EXE=cscope
+CSCOPE_ARGS=
+DB_FILE=cscope.out
+PROJECT_ROOT=
+FILE_LIST_CMD=
+BUILD_INVERTED_INDEX=0
+
+ShowUsage() {
+    echo "Usage:"
+    echo "    $PROG_NAME <options>"
+    echo ""
+    echo "    -e [exe=cscope]:      The cscope executable to run"
+    echo "    -f [file=cscope.out]: The path to the ctags file to update"
+    echo "    -p [dir=]:            The path to the project root"
+    echo "    -L [cmd=]:            The file list command to run"
+    echo "    -I:                   Builds an inverted index"
+    echo ""
+}
+
+
+while getopts "h?e:f:p:L:I" opt; do
+    case $opt in
+        h|\?)
+            ShowUsage
+            exit 0
+            ;;
+        e)
+            CSCOPE_EXE=$OPTARG
+            ;;
+        f)
+            DB_FILE=$OPTARG
+            ;;
+        p)
+            PROJECT_ROOT=$OPTARG
+            ;;
+        L)
+            FILE_LIST_CMD=$OPTARG
+            ;;
+        I)
+            BUILD_INVERTED_INDEX=1
+            ;;
+    esac
+done
+
+shift $((OPTIND - 1))
+
+if [ "$1" != "" ]; then
+    echo "Invalid Argument: $1"
+    exit 1
+fi
+
+echo "Locking cscope DB file..."
+echo $$ > "$DB_FILE.lock"
+
+# Remove lock and temp file if script is stopped unexpectedly.
+CleanUp() {
+    rm -f "$DB_FILE.lock" "$DB_FILE.files" "$DB_FILE.temp"
+    if [ "$BUILD_INVERTED_INDEX" -eq 1 ]; then
+        rm -f "$DB_FILE.temp.in" "$DB_FILE.temp.po"
+    fi
+}
+
+trap CleanUp INT QUIT TERM EXIT
+
+PREVIOUS_DIR=$(pwd)
+if [ -d "$PROJECT_ROOT" ]; then
+    cd "$PROJECT_ROOT"
+fi
+
+if [ -n "${FILE_LIST_CMD}" ]; then
+    if [ "${PROJECT_ROOT}" = "." ]; then
+        eval "$FILE_LIST_CMD" | while read -r l; do
+            echo "\"${l}\""
+        done > "${DB_FILE}.files"
+    else
+        # If using a tags cache directory, use absolute paths
+        eval "$FILE_LIST_CMD" | while read -r l; do
+            echo "\"${PROJECT_ROOT%/}/${l}\""
+        done > "${DB_FILE}.files"
+    fi
+else
+    find . -type f ! -name ${DB_FILE} | while read -r l; do
+        echo "\"${l}\""
+    done > "${DB_FILE}.files"
+fi
+
+if [ ! -s "${DB_FILE}.files" ]; then
+    echo "There is no files to generate cscope DB"
+    exit
+fi
+
+CSCOPE_ARGS="${CSCOPE_ARGS} -i ${DB_FILE}.files"
+
+if [ "$BUILD_INVERTED_INDEX" -eq 1 ]; then
+    CSCOPE_ARGS="$CSCOPE_ARGS -q"
+fi
+
+echo "Running cscope"
+echo "$CSCOPE_EXE $CSCOPE_ARGS -b -k -f \"$DB_FILE.temp\""
+"$CSCOPE_EXE" $CSCOPE_ARGS -v -b -k -f "$DB_FILE.temp"
+
+if [ -d "$PROJECT_ROOT" ]; then
+    cd "$PREVIOUS_DIR"
+fi
+
+echo "Replacing cscope DB file"
+if [ "$BUILD_INVERTED_INDEX" -eq 1 ]; then
+    echo "mv -f \"$DB_FILE.temp.in\" \"$DB_FILE.in\""
+    mv -f "$DB_FILE.temp.in" "$DB_FILE.in"
+    echo "mv -f \"$DB_FILE.temp.po\" \"$DB_FILE.po\""
+    mv -f "$DB_FILE.temp.po" "$DB_FILE.po"
+fi
+echo "mv -f \"$DB_FILE.temp\" \"$DB_FILE\""
+mv -f "$DB_FILE.temp" "$DB_FILE"
+
+echo "Unlocking cscope DB file..."
+rm -f "$DB_FILE.lock"
+
+echo "Done."

dotfiles/vim/bundle/vim-gutentags/plat/unix/update_tags.sh

@@ -0,0 +1,155 @@
+#!/bin/sh
+
+set -e
+
+PROG_NAME=$0
+CTAGS_EXE=ctags
+CTAGS_ARGS=
+TAGS_FILE=tags
+PROJECT_ROOT=
+LOG_FILE=
+FILE_LIST_CMD=
+FILE_LIST_CMD_IS_ABSOLUTE=0
+UPDATED_SOURCE=
+POST_PROCESS_CMD=
+PAUSE_BEFORE_EXIT=0
+
+
+ShowUsage() {
+    echo "Usage:"
+    echo "    $PROG_NAME <options>"
+    echo ""
+    echo "    -e [exe=ctags]: The ctags executable to run"
+    echo "    -t [file=tags]: The path to the ctags file to update"
+    echo "    -p [dir=]:      The path to the project root"
+    echo "    -l [file=]:     The path to a log file"
+    echo "    -L [cmd=]:      The file list command to run"
+    echo "    -A:             Specifies that the file list command returns "
+    echo "                    absolute paths"
+    echo "    -s [file=]:     The path to the source file that needs updating"
+    echo "    -x [pattern=]:  A pattern of files to exclude"
+    echo "    -o [options=]:  An options file to read additional options from"
+    echo "    -O [params=]:   Parameters to pass to ctags"
+    echo "    -P [cmd=]:      Post process command to run on the tags file"
+    echo "    -c:             Ask for confirmation before exiting"
+    echo ""
+}
+
+
+while getopts "h?e:x:t:p:l:L:s:o:O:P:cA" opt; do
+    case $opt in
+        h|\?)
+            ShowUsage
+            exit 0
+            ;;
+        e)
+            CTAGS_EXE=$OPTARG
+            ;;
+        x)
+            CTAGS_ARGS="$CTAGS_ARGS --exclude=$OPTARG"
+            ;;
+        t)
+            TAGS_FILE=$OPTARG
+            ;;
+        p)
+            PROJECT_ROOT=$OPTARG
+            ;;
+        l)
+            LOG_FILE=$OPTARG
+            ;;
+        L)
+            FILE_LIST_CMD=$OPTARG
+            ;;
+        A)
+            FILE_LIST_CMD_IS_ABSOLUTE=1
+            ;;
+        s)
+            UPDATED_SOURCE=$OPTARG
+            ;;
+        c)
+            PAUSE_BEFORE_EXIT=1
+            ;;
+        o)
+            CTAGS_ARGS="$CTAGS_ARGS --options=$OPTARG"
+            ;;
+        O)
+            CTAGS_ARGS="$CTAGS_ARGS $OPTARG"
+            ;;
+        P)
+            POST_PROCESS_CMD=$OPTARG
+            ;;
+    esac
+done
+
+shift $((OPTIND - 1))
+
+if [ "$1" != "" ]; then
+    echo "Invalid Argument: $1"
+    exit 1
+fi
+
+echo "Locking tags file..."
+echo $$ > "$TAGS_FILE.lock"
+
+# Remove lock and temp file if script is stopped unexpectedly.
+trap 'errorcode=$?; rm -f "$TAGS_FILE.lock" "$TAGS_FILE.files" "$TAGS_FILE.temp"; exit $errorcode' INT QUIT TERM EXIT
+
+INDEX_WHOLE_PROJECT=1
+if [ -f "$TAGS_FILE" ]; then
+    if [ "$UPDATED_SOURCE" != "" ]; then
+        echo "Removing references to: $UPDATED_SOURCE"
+        tab="	"
+        cmd="grep --text -Ev '^[^$tab]+$tab$UPDATED_SOURCE$tab' '$TAGS_FILE' > '$TAGS_FILE.temp'"
+        echo "$cmd"
+        eval "$cmd" || true
+        INDEX_WHOLE_PROJECT=0
+    fi
+fi
+
+if [ $INDEX_WHOLE_PROJECT -eq 1 ]; then
+    if [ -n "${FILE_LIST_CMD}" ]; then
+        if [ "${PROJECT_ROOT}" = "." ] || [ $FILE_LIST_CMD_IS_ABSOLUTE -eq 1 ]; then
+            echo "Running file list command"
+            echo "eval $FILE_LIST_CMD > \"${TAGS_FILE}.files\""
+            eval $FILE_LIST_CMD > "${TAGS_FILE}.files"
+        else
+            # If using a tags cache directory, use absolute paths
+            echo "Running file list command, patching for absolute paths"
+            echo "eval $FILE_LIST_CMD"
+            eval $FILE_LIST_CMD | while read -r l; do
+                echo "${PROJECT_ROOT%/}/${l}"
+            done > "${TAGS_FILE}.files"
+        fi
+        CTAGS_ARGS="${CTAGS_ARGS} -L "${TAGS_FILE}.files""
+    else
+        CTAGS_ARGS="${CTAGS_ARGS} "${PROJECT_ROOT}""
+    fi
+
+    echo "Running ctags on whole project"
+    echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" $CTAGS_ARGS"
+    $CTAGS_EXE -f "$TAGS_FILE.temp" $CTAGS_ARGS
+else
+    echo "Running ctags on \"$UPDATED_SOURCE\""
+    echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" $CTAGS_ARGS --append \"$UPDATED_SOURCE\""
+    $CTAGS_EXE -f "$TAGS_FILE.temp" $CTAGS_ARGS --append "$UPDATED_SOURCE"
+fi
+
+if [ "$POST_PROCESS_CMD" != "" ]; then
+    echo "Running post process"
+    echo "$POST_PROCESS_CMD \"$TAGS_FILE.temp\""
+    $POST_PROCESS_CMD "$TAGS_FILE.temp"
+fi
+
+echo "Replacing tags file"
+echo "mv -f \"$TAGS_FILE.temp\" \"$TAGS_FILE\""
+mv -f "$TAGS_FILE.temp" "$TAGS_FILE"
+
+echo "Unlocking tags file..."
+rm -f "$TAGS_FILE.lock"
+
+echo "Done."
+
+if [ $PAUSE_BEFORE_EXIT -eq 1 ]; then
+    printf "Press ENTER to exit..."
+    read -r
+fi

dotfiles/vim/bundle/vim-gutentags/plat/win32/update_scopedb.cmd

@@ -0,0 +1,120 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+rem ==========================================
+rem            PARSE ARGUMENTS
+rem ==========================================
+
+set CSCOPE_EXE=cscope
+set CSCOPE_ARGS=
+set DB_FILE=cscope.out
+set FILE_LIST_CMD=
+set LOG_FILE=
+set BUILD_INVERTED_INDEX=0
+
+:ParseArgs
+if [%1]==[] goto :DoneParseArgs
+if [%1]==[-e] (
+    set CSCOPE_EXE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-f] (
+    set DB_FILE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-p] (
+    set PROJ_ROOT=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-L] (
+    set FILE_LIST_CMD=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-l] (
+    set LOG_FILE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-I] (
+    set BUILD_INVERTED_INDEX=1
+    goto :LoopParseArgs
+)
+echo Invalid Argument: %1
+goto :Usage
+
+:LoopParseArgs
+shift
+goto :ParseArgs
+
+:DoneParseArgs
+
+
+rem ==========================================
+rem             GENERATE DATABASE
+rem ==========================================
+
+if [%LOG_FILE%]==[] set LOG_FILE=CON
+
+echo Locking db file > %LOG_FILE%
+echo locked > "%DB_FILE%.lock"
+
+echo Running cscope >> %LOG_FILE%
+if NOT ["%FILE_LIST_CMD%"]==[""] (
+    if ["%PROJECT_ROOT%"]==["."] (
+        for /F "usebackq delims=" %%F in (`%FILE_LIST_CMD%`) do @echo "%%F">%DB_FILE%.files
+    ) else (
+        rem Potentially useful:
+        rem http://stackoverflow.com/questions/9749071/cmd-iterate-stdin-piped-from-another-command
+        for /F "usebackq delims=" %%F in (`%FILE_LIST_CMD%`) do @echo "%PROJECT_ROOT%\%%F">%DB_FILE%.files
+    )
+) ELSE (
+    for /F "usebackq delims=" %%F in (`dir /S /B /A-D .`) do @echo "%%F">%DB_FILE%.files
+)
+
+set FILESIZE=0
+for /F %%F in ("%DB_FILE%.files") do set FILESIZE=%%~zF
+if %FILESIZE% EQU 0 (
+    echo There is no files to generate cscope DB
+    goto :EOF
+)
+
+set CSCOPE_ARGS=%CSCOPE_ARGS% -i %DB_FILE%.files
+if ["%BUILD_INVERTED_INDEX%"]==["1"] (
+    set CSCOPE_ARGS=%CSCOPE_ARGS% -q
+)
+"%CSCOPE_EXE%" %CSCOPE_ARGS% -b -k -f "%DB_FILE%"
+if ERRORLEVEL 1 (
+    echo ERROR: Cscope executable returned non-zero code. >> %LOG_FILE%
+)
+
+echo Unlocking db file >> %LOG_FILE%
+del /F "%DB_FILE%.files" "%DB_FILE%.lock"
+if ERRORLEVEL 1 (
+    echo ERROR: Unable to remove file lock. >> %LOG_FILE%
+)
+
+echo Done. >> %LOG_FILE%
+
+goto :EOF
+
+
+rem ==========================================
+rem                 USAGE
+rem ==========================================
+
+:Usage
+echo Usage:
+echo    %~n0 ^<options^>
+echo.
+echo    -e [exe=cscope]:             The cscope executable to run
+echo    -f [file=cscope.out]:        The path to the database file to create
+echo    -p [dir=]:                   The path to the project root
+echo    -L [cmd=]:                   The file list command to run
+echo    -l [log=]:                   The log file to output to
+echo    -I:                          Builds an inverted index
+echo.
+

dotfiles/vim/bundle/vim-gutentags/plat/win32/update_tags.cmd

@@ -0,0 +1,191 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+rem ==========================================
+rem            PARSE ARGUMENTS
+rem ==========================================
+
+set CTAGS_EXE=ctags
+set CTAGS_ARGS=
+set TAGS_FILE=tags
+set PROJECT_ROOT=
+set FILE_LIST_CMD=
+set FILE_LIST_CMD_IS_ABSOLUTE=0
+set UPDATED_SOURCE=
+set POST_PROCESS_CMD=
+set PAUSE_BEFORE_EXIT=0
+set LOG_FILE=
+
+:ParseArgs
+if [%1]==[] goto :DoneParseArgs
+if [%1]==[-e] (
+    set CTAGS_EXE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-x] (
+    set CTAGS_ARGS=%CTAGS_ARGS% --exclude=%2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-t] (
+    set TAGS_FILE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-p] (
+    set PROJECT_ROOT=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-L] (
+    set FILE_LIST_CMD=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-A] (
+    set FILE_LIST_CMD_IS_ABSOLUTE=1
+    goto :LoopParseArgs
+)
+if [%1]==[-s] (
+    set UPDATED_SOURCE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-c] (
+    set PAUSE_BEFORE_EXIT=1
+    goto :LoopParseArgs
+)
+if [%1]==[-l] (
+    set LOG_FILE=%~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-o] (
+    set CTAGS_ARGS=%CTAGS_ARGS% --options=%2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-O] (
+    set CTAGS_ARGS=%CTAGS_ARGS% %~2
+    shift
+    goto :LoopParseArgs
+)
+if [%1]==[-P] (
+    set POST_PROCESS_CMD=%~2
+    shift
+    goto :LoopParseArgs
+)
+echo Invalid Argument: %1
+goto :Usage
+
+:LoopParseArgs
+shift
+goto :ParseArgs
+
+:DoneParseArgs
+
+
+rem ==========================================
+rem               GENERATE TAGS
+rem ==========================================
+
+if [%LOG_FILE%]==[] set LOG_FILE=CON
+
+echo Locking tags file... > %LOG_FILE%
+echo locked > "%TAGS_FILE%.lock"
+
+set INDEX_WHOLE_PROJECT=1
+if exist "%TAGS_FILE%" (
+    if not ["%UPDATED_SOURCE%"]==[""] (
+        echo Removing references to: %UPDATED_SOURCE% >> %LOG_FILE%
+        echo findstr /V /C:"%UPDATED_SOURCE%" "%TAGS_FILE%" ^> "%TAGS_FILE%.temp" >> %LOG_FILE%
+        findstr /V /C:"%UPDATED_SOURCE%" "%TAGS_FILE%" > "%TAGS_FILE%.temp"
+        set CTAGS_ARGS=%CTAGS_ARGS% --append "%UPDATED_SOURCE%"
+        set INDEX_WHOLE_PROJECT=0
+    )
+)
+if ["%INDEX_WHOLE_PROJECT%"]==["1"] (
+    if not ["%FILE_LIST_CMD%"]==[""] (
+        echo Running file list command >> %LOG_FILE%
+        set use_raw_list=0
+        if ["%PROJECT_ROOT%"]==["."] set use_raw_list=1
+        if ["%FILE_LIST_CMD_IS_ABSOLUTE%"]==["1"] set use_raw_list=1
+        rem No idea why we need to use delayed expansion here to make it work :(
+        if ["!use_raw_list!"]==["1"] (
+            echo call %FILE_LIST_CMD% ^> %TAGS_FILE%.files >> %LOG_FILE%
+            call %FILE_LIST_CMD% > %TAGS_FILE%.files
+        ) else (
+            rem Potentially useful:
+            rem http://stackoverflow.com/questions/9749071/cmd-iterate-stdin-piped-from-another-command
+            echo call %FILE_LIST_CMD% -- with loop for prepending project root >> %LOG_FILE%
+            type NUL > %TAGS_FILE%.files
+            for /F "usebackq delims=" %%F in (`%FILE_LIST_CMD%`) do @echo %PROJECT_ROOT%\%%F >> %TAGS_FILE%.files
+        )
+        set CTAGS_ARGS=%CTAGS_ARGS% -L %TAGS_FILE%.files
+    ) else (
+        set CTAGS_ARGS=%CTAGS_ARGS% "%PROJECT_ROOT%"
+    )
+)
+
+echo Running ctags >> %LOG_FILE%
+echo call "%CTAGS_EXE%" -f "%TAGS_FILE%.temp" %CTAGS_ARGS% >> %LOG_FILE%
+call "%CTAGS_EXE%" -f "%TAGS_FILE%.temp" %CTAGS_ARGS% >> %LOG_FILE% 2>&1
+if ERRORLEVEL 1 (
+    echo ERROR: Ctags executable returned non-zero code. >> %LOG_FILE%
+    goto :Unlock
+)
+
+if not ["%POST_PROCESS_CMD%"]==[""] (
+    echo Running post process >> %LOG_FILE%
+    echo call %POST_PROCESS_CMD% %TAGS_FILE%.temp >> %LOG_FILE%
+    call %POST_PROCESS_CMD% %TAGS_FILE%.temp >> %LOG_FILE% 2>&1
+    if ERRORLEVEL 1 (
+        echo ERROR: Post process returned non-zero code. >> %LOG_FILE%
+        goto :Unlock
+    )
+)
+
+echo Replacing tags file >> %LOG_FILE%
+echo move /Y "%TAGS_FILE%.temp" "%TAGS_FILE%" >> %LOG_FILE%
+move /Y "%TAGS_FILE%.temp" "%TAGS_FILE%" >> %LOG_FILE% 2>&1
+if ERRORLEVEL 1 (
+    echo ERROR: Unable to rename temp tags file into actual tags file. >> %LOG_FILE%
+    goto :Unlock
+)
+
+:Unlock
+echo Unlocking tags file... >> %LOG_FILE%
+del /F "%TAGS_FILE%.files" "%TAGS_FILE%.lock"
+if ERRORLEVEL 1 (
+    echo ERROR: Unable to remove file lock. >> %LOG_FILE%
+)
+
+echo Done. >> %LOG_FILE%
+if [%PAUSE_BEFORE_EXIT%]==[1] (
+    pause
+)
+
+goto :EOF
+
+
+rem ==========================================
+rem                 USAGE
+rem ==========================================
+
+:Usage
+echo Usage:
+echo    %~n0 ^<options^>
+echo.
+echo    -e [exe=ctags]: The ctags executable to run
+echo    -t [file=tags]: The path to the ctags file to update
+echo    -p [dir=]:      The path to the project root
+echo    -L [cmd=]:      The file list command to run
+echo    -A:             Specifies that the file list command returns
+echo                    absolute paths
+echo    -s [file=]:     The path to the source file that needs updating
+echo    -l [log=]:      The log file to output to
+echo    -o [options=]:  An options file to read additional options from
+echo    -c:             Ask for confirmation before exiting
+echo.
+

dotfiles/vim/bundle/vim-gutentags/plugin/gutentags.vim

@@ -0,0 +1,114 @@
+" gutentags.vim - Automatic ctags management for Vim
+" Maintainer:   Ludovic Chabant <http://ludovic.chabant.com>
+" Version:      2.0.0
+
+" Globals {{{
+
+if (&cp || get(g:, 'gutentags_dont_load', 0))
+    finish
+endif
+
+if v:version < 704
+    echoerr "gutentags: this plugin requires vim >= 7.4."
+    finish
+endif
+
+if !(has('job') || (has('nvim') && exists('*jobwait')))
+    echoerr "gutentags: this plugin requires the job API from Vim8 or Neovim."
+    finish
+endif
+
+let g:gutentags_debug = get(g:, 'gutentags_debug', 0)
+
+if (exists('g:loaded_gutentags') && !g:gutentags_debug)
+    finish
+endif
+if (exists('g:loaded_gutentags') && g:gutentags_debug)
+    echom "Reloaded gutentags."
+endif
+let g:loaded_gutentags = 1
+
+let g:gutentags_trace = get(g:, 'gutentags_trace', 0)
+let g:gutentags_fake = get(g:, 'gutentags_fake', 0)
+let g:gutentags_background_update = get(g:, 'gutentags_background_update', 1)
+let g:gutentags_pause_after_update = get(g:, 'gutentags_pause_after_update', 0)
+let g:gutentags_enabled = get(g:, 'gutentags_enabled', 1)
+let g:gutentags_modules = get(g:, 'gutentags_modules', ['ctags'])
+
+let g:gutentags_init_user_func = get(g:, 'gutentags_init_user_func', 
+            \get(g:, 'gutentags_enabled_user_func', ''))
+
+let g:gutentags_add_ctrlp_root_markers = get(g:, 'gutentags_add_ctrlp_root_markers', 1)
+let g:gutentags_add_default_project_roots = get(g:, 'gutentags_add_default_project_roots', 1)
+let g:gutentags_project_root = get(g:, 'gutentags_project_root', [])
+if g:gutentags_add_default_project_roots
+    let g:gutentags_project_root += ['.git', '.hg', '.svn', '.bzr', '_darcs', '_FOSSIL_', '.fslckout']
+endif
+
+let g:gutentags_project_root_finder = get(g:, 'gutentags_project_root_finder', '')
+
+let g:gutentags_project_info = get(g:, 'gutentags_project_info', [])
+call add(g:gutentags_project_info, {'type': 'python', 'file': 'setup.py'})
+call add(g:gutentags_project_info, {'type': 'ruby', 'file': 'Gemfile'})
+
+let g:gutentags_exclude_filetypes = get(g:, 'gutentags_exclude_filetypes', [])
+let g:gutentags_exclude_project_root = get(g:, 'gutentags_exclude_project_root', ['/usr/local'])
+let g:gutentags_resolve_symlinks = get(g:, 'gutentags_resolve_symlinks', 0)
+let g:gutentags_generate_on_new = get(g:, 'gutentags_generate_on_new', 1)
+let g:gutentags_generate_on_missing = get(g:, 'gutentags_generate_on_missing', 1)
+let g:gutentags_generate_on_write = get(g:, 'gutentags_generate_on_write', 1)
+let g:gutentags_generate_on_empty_buffer = get(g:, 'gutentags_generate_on_empty_buffer', 0)
+let g:gutentags_file_list_command = get(g:, 'gutentags_file_list_command', '')
+
+let g:gutentags_use_jobs = get(g:, 'gutentags_use_jobs', has('job'))
+
+if !exists('g:gutentags_cache_dir')
+    let g:gutentags_cache_dir = ''
+elseif !empty(g:gutentags_cache_dir)
+    " Make sure we get an absolute/resolved path (e.g. expanding `~/`), and
+    " strip any trailing slash.
+    let g:gutentags_cache_dir = fnamemodify(g:gutentags_cache_dir, ':p')
+    let g:gutentags_cache_dir = fnamemodify(g:gutentags_cache_dir, ':s?[/\\]$??')
+endif
+
+let g:gutentags_define_advanced_commands = get(g:, 'gutentags_define_advanced_commands', 0)
+
+if g:gutentags_cache_dir != '' && !isdirectory(g:gutentags_cache_dir)
+    call mkdir(g:gutentags_cache_dir, 'p')
+endif
+
+if has('win32')
+    let g:gutentags_plat_dir = expand('<sfile>:h:h:p') . "\\plat\\win32\\"
+    let g:gutentags_res_dir = expand('<sfile>:h:h:p') . "\\res\\"
+    let g:gutentags_script_ext = '.cmd'
+else
+    let g:gutentags_plat_dir = expand('<sfile>:h:h:p') . '/plat/unix/'
+    let g:gutentags_res_dir = expand('<sfile>:h:h:p') . '/res/'
+    let g:gutentags_script_ext = '.sh'
+endif
+
+" }}}
+
+" Gutentags Setup {{{
+
+augroup gutentags_detect
+    autocmd!
+    autocmd BufNewFile,BufReadPost *  call gutentags#setup_gutentags()
+    autocmd VimEnter               *  if expand('<amatch>')==''|call gutentags#setup_gutentags()|endif
+augroup end
+
+" }}}
+
+" Toggles and Miscellaneous Commands {{{
+
+if g:gutentags_define_advanced_commands
+    command! GutentagsToggleEnabled :let g:gutentags_enabled=!g:gutentags_enabled
+    command! GutentagsToggleTrace   :call gutentags#toggletrace()
+endif
+
+if g:gutentags_debug
+    command! GutentagsToggleFake    :call gutentags#fake()
+endif
+
+" }}}
+

dotfiles/vim/bundle/vim-gutentags/res/ctags_recursive.options

@@ -0,0 +1,2 @@
+--recurse=yes
+