commit 2c2b3e40291be356865c2fadf7b9ad21cac8dfdb
parent 82fa4aaee199e9f71850c99aa39046ca99bd4e01
Author: Jake Bauer <jbauer@paritybit.ca>
Date: Sat, 20 May 2023 23:21:37 -0400
Remove gutentags
Diffstat:
17 files changed, 0 insertions(+), 3113 deletions(-)
diff --git a/.config/nvim/init.vim b/.config/nvim/init.vim
@@ -1,7 +1,6 @@
"Plugins Used:
" vim-commentary — (shortcuts for (un)commenting lines/blocks of code)
" vim-buftabline — (show a tab line for buffers)
-" vim-gutentags — (auto-generate tags)
" vim-monochrome — (custom colorscheme)
" vim-fastline — (custom status bar)
" neoscroll.nvim — (smooth scrolling)
@@ -14,9 +13,6 @@ filetype plugin indent on
" Plugin Settings
lua require('neoscroll').setup({easing_function = "quadratic"})
let g:buftabline_show = 1
-let g:gutentags_project_root = ['Makefile']
-let g:gutentags_add_default_project_roots = 1
-let g:gutentags_cache_dir = "~/.cache/nvim/"
" Syntax Highlighting and Colourscheme
syntax on
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/LICENSE b/.config/nvim/pack/bundle/start/vim-gutentags/LICENSE
@@ -1,23 +0,0 @@
-
-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.
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags.vim b/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags.vim
@@ -1,749 +0,0 @@
-" 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() ? ((haslocaldir() == 1) ? 'lcd' : 'tcd') : 'cd'
- endif
- execute chdir fnameescape(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
- if &shell == 'pwsh' || &shell == 'powershell'
- return '& ' . join(a:cmd, ' ')
- else
- return join(a:cmd, ' ')
- endif
- 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] == "'")
- " This was quoted, so there are probably things to escape.
- let l:escapedarg = cmdarg[1:-2] " substitute(cmdarg[1:-2], '\ ', '\\ ', 'g')
- call add(l:outcmd, l:escapedarg)
- 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
-
-" Set a variable on exit so that we don't complain when a job gets killed.
-function! gutentags#on_vim_leave_pre() abort
- let g:__gutentags_vim_is_leaving = 1
-endfunction
-
-function! gutentags#on_vim_leave() abort
- if has('win32') && !has('nvim')
- " Vim8 doesn't seem to be killing child processes soon enough for
- " us to clean things up inside this plugin, so do it ourselves.
- " TODO: test other platforms and other vims
- for module in g:gutentags_modules
- for upd_info in s:update_in_progress[module]
- let l:job = upd_info[1]
- call job_stop(l:job, "term")
- let l:status = job_status(l:job)
- if l:status == "run"
- call job_stop(l:job, "kill")
- endif
- endfor
- endfor
- endif
-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
-
-" Adds a started job to the list of ongoing updates.
-" Must pass the tags file being created/updated, and the job data as
-" returned by the gutentags#start_job function
-function! gutentags#add_job(module, tags_file, data) abort
- call add(s:update_in_progress[a:module], [a:tags_file, a:data])
-endfunction
-
-" Finds an ongoing job by tags file
-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
-
-" Finds an ongoing job by job data
-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
-
-" Gets the tags file of a given job
-function! gutentags#get_job_tags_file(module, job_idx) abort
- return s:update_in_progress[a:module][a:job_idx][0]
-endfunction
-
-" Gets the job data of the i-th job
-function! gutentags#get_job_data(module, job_idx) abort
- return s:update_in_progress[a:module][a:job_idx][1]
-endfunction
-
-" Removes the i-th job from the ongoing jobs
-function! gutentags#remove_job(module, job_idx) abort
- let [l:tags_file, l:job_data] = s:update_in_progress[a:module][a:job_idx]
- 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
-
- return [l:tags_file, l:job_data]
-endfunction
-
-" Removes the job from the ongoing jobs given its job data
-function! gutentags#remove_job_by_data(module, data) abort
- let l:idx = gutentags#find_job_index_by_data(a:module, a:data)
- return 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(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(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_stdout_cb(chan, msg) abort
- call gutentags#trace('[job stdout]: '.string(a:msg))
-endfunction
-
-function! gutentags#default_stderr_cb(chan, msg) abort
- call gutentags#trace('[job stderr]: '.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_stdout_cb']),
- \'on_stderr': function(
- \ '<SID>nvim_job_out_wrapper',
- \ ['gutentags#default_stderr_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_stdout_cb',
- \'err_cb': 'gutentags#default_stderr_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
-
-" }}}
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/cscope.vim b/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/cscope.vim
@@ -1,99 +0,0 @@
-" 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
- elseif !g:__gutentags_vim_is_leaving
- call gutentags#warning(
- \"cscope job failed, returned: ".
- \string(a:exit_val))
- endif
- if has('win32') && g:__gutentags_vim_is_leaving
- " The process got interrupted because Vim is quitting.
- " Remove the db file on Windows because there's no `trap`
- " statement in the update script.
- try | call delete(l:dbfile_path) | endtry
- endif
-endfunction
-
-" }}}
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/ctags.vim b/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/ctags.vim
@@ -1,343 +0,0 @@
-" 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
- if has('win32') || has('win64')
- execute 'setlocal tags^=' . fnameescape(b:gutentags_files['ctags'])
- else
- " spaces must be literally escaped in tags path
- let l:literal_space_escaped = substitute(fnameescape(b:gutentags_files['ctags']), '\ ', '\\\\ ', 'g')
- execute 'setlocal tags^=' . l:literal_space_escaped
- endif
- 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)
-
- " If the tags file exists, we may want to do a sanity check to prevent
- " weird errors that are hard to troubleshoot.
- 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
-
- " Get a tags file path relative to the current directory, which
- " happens to be the project root in this case.
- " Since the given tags file path is absolute, and since Vim won't
- " change the path if it is not inside the current directory, we
- " know that the tags file is "local" (i.e. inside the project)
- " if the path was shortened (an absolute path will always be
- " longer than a true relative path).
- let l:tags_file_relative = fnamemodify(a:tags_file, ':.')
- let l:tags_file_is_local = len(l:tags_file_relative) < len(a:tags_file)
- let l:use_tag_relative_opt = 0
-
- 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 will be the case, we're running
- " the jobs from the project root).
- let l:actual_proj_dir = '.'
- let l:actual_tags_file = l:tags_file_relative
-
- let l:tags_file_dir = fnamemodify(l:actual_tags_file, ':h')
- if l:tags_file_dir != '.'
- " Ok so now the tags file is stored in a subdirectory of the
- " project root, instead of at the root. This happens if, say,
- " someone set `gutentags_ctags_tagfile` to `.git/tags`, which
- " seems to be fairly popular.
- "
- " By default, `ctags` writes paths relative to the current
- " directory (the project root) but in this case we need it to
- " be relative to the tags file (e.g. adding `../` in front of
- " everything if the tags file is `.git/tags`).
- "
- " Thankfully most `ctags` implementations support an option
- " just for this.
- let l:use_tag_relative_opt = 1
- endif
- 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 l:use_tag_relative_opt
- let l:cmd += ['-O', shellescape("--tag-relative=yes")]
- endif
- for extra_arg in g:gutentags_ctags_extra_args
- let l:cmd += ['-O', shellescape(extra_arg)]
- endfor
- 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
- let [l:tags_file, l:job_data] = gutentags#remove_job_by_data('ctags', a:job)
-
- if a:exit_val != 0 && !g:__gutentags_vim_is_leaving
- call gutentags#warning("ctags job failed, returned: ".
- \string(a:exit_val))
- endif
- if has('win32') && g:__gutentags_vim_is_leaving
- " The process got interrupted because Vim is quitting.
- " Remove the tags and lock files on Windows because there's no `trap`
- " statement in update script.
- try | call delete(l:tags_file) | endtry
- try | call delete(l:tags_file.'.temp') | endtry
- try | call delete(l:tags_file.'.lock') | endtry
- 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,
- " but check if file still exist (could have been deleted if temp file)
- if filereadable(s:wildignores_options_path)
- call gutentags#trace("Wildignore options file is up to date.")
- return
- endif
- call gutentags#trace("Wildignore options file is not readable.")
- 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
-
-" }}}
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/gtags_cscope.vim b/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/gtags_cscope.vim
@@ -1,136 +0,0 @@
-" 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:runner_exe = gutentags#get_plat_file('update_gtags')
-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
- let l:cmd = [s:runner_exe]
- let l:cmd += ['-e', '"' . g:gutentags_gtags_executable . '"']
-
- 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
-
- let l:proj_options_file = a:proj_dir . '/' . g:gutentags_gtags_options_file
- if filereadable(l:proj_options_file)
- let l:proj_options = readfile(l:proj_options_file)
- let l:cmd += l:proj_options
- endif
-
- " 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: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 && !g:__gutentags_vim_is_leaving
- call gutentags#warning(
- \"gtags-cscope job failed, returned: ".
- \string(a:exit_val))
- endif
- if has('win32') && g:__gutentags_vim_is_leaving
- " The process got interrupted because Vim is quitting.
- " Remove the db file on Windows because there's no `trap`
- " statement in the update script.
- try | call delete(l:dbfile_path) | endtry
- endif
-endfunction
-
-" }}}
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/pycscope.vim b/.config/nvim/pack/bundle/start/vim-gutentags/autoload/gutentags/pycscope.vim
@@ -1,86 +0,0 @@
-" Pycscope module for Gutentags
-
-if !has('cscope')
- throw "Can't enable the pycscope module for Gutentags, this Vim has ".
- \"no support for cscope files."
-endif
-
-" Global Options {{{
-
-if !exists('g:gutentags_pycscope_executable')
- let g:gutentags_pycscope_executable = 'pycscope'
-endif
-
-if !exists('g:gutentags_pyscopefile')
- let g:gutentags_pyscopefile = 'pycscope.out'
-endif
-
-if !exists('g:gutentags_auto_add_pycscope')
- let g:gutentags_auto_add_pycscope = 1
-endif
-
-" }}}
-
-" Gutentags Module Interface {{{
-
-let s:runner_exe = gutentags#get_plat_file('update_pyscopedb')
-let s:unix_redir = (&shellredir =~# '%s') ? &shellredir : &shellredir . ' %s'
-let s:added_dbs = []
-
-function! gutentags#pycscope#init(project_root) abort
- let l:dbfile_path = gutentags#get_cachefile(
- \a:project_root, g:gutentags_pyscopefile)
- let b:gutentags_files['pycscope'] = l:dbfile_path
-
- if g:gutentags_auto_add_pycscope && 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#pycscope#generate(proj_dir, tags_file, gen_opts) abort
- let l:cmd = [s:runner_exe]
- let l:cmd += ['-e', g:gutentags_pycscope_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
- 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('pycscope')
- let l:job = gutentags#start_job(l:cmd, l:job_opts)
- call gutentags#add_job('pycscope', a:tags_file, l:job)
- else
- call gutentags#trace("(fake... not actually running)")
- endif
-endfunction
-
-function! gutentags#pycscope#on_job_exit(job, exit_val) abort
- let l:job_idx = gutentags#find_job_index_by_data('pycscope', a:job)
- let l:dbfile_path = gutentags#get_job_tags_file('pycscope', l:job_idx)
- call gutentags#remove_job('pycscope', 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(
- \"gutentags: pycscope job failed, returned: ".
- \string(a:exit_val))
- endif
-endfunction
-
-" }}}
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/doc/gutentags.txt b/.config/nvim/pack/bundle/start/vim-gutentags/doc/gutentags.txt
@@ -1,748 +0,0 @@
-*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`.
-
- - `pycscope`: generates a code database file using
- `pycscope`.
-
- - `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', '/opt/homebrew', '/home/linuxbrew/.linuxbrew']`,
- which are the folders where Homebrew is known to
- create a Git repository by default.
-
- *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 = 'ripper-tags'
-<
-
- *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 `pycscope` module.
-
- *gutentags_pycscope_executable*
-g:gutentags_pycscope_executable
- Specifies the name or path of the `pycscope` executable
- to use to generate the code database.
- Defaults to `"pycscope"`.
-
- *gutentags_auto_add_pycscope*
-g:gutentags_auto_add_pycscope
- If set to 1, Gutentags will automatically add the
- generated code database to Vim by running `:cs add`
- (see |:pycscope|).
- Defaults to 1.
-
-
-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`, `pycscope` 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:
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_gtags.sh b/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_gtags.sh
@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-PROG_NAME=$0
-GTAGS_EXE=gtags
-FILE_LIST_CMD=
-
-ShowUsage() {
- echo "Usage:"
- echo " $PROG_NAME <options>"
- echo ""
- echo " -e [exe=gtags]: The gtags executable to run."
- echo " -L [cmd=]: The file list command to run."
- echo ""
-}
-
-while [[ $# -ne 0 ]]; do
- case "$1" in
- -h)
- ShowUsage
- exit 0
- ;;
- -e)
- GTAGS_EXE=$2
- shift 2
- ;;
- -L)
- FILE_LIST_CMD=$2
- shift 2
- ;;
- *)
- GTAGS_ARGS="$GTAGS_ARGS $1"
- shift
- ;;
- esac
-done
-
-if [ -n "$FILE_LIST_CMD" ]; then
- CMD="$FILE_LIST_CMD | $GTAGS_EXE -f- $GTAGS_ARGS"
-else
- CMD="$GTAGS_EXE $GTAGS_ARGS"
-fi
-
-echo "Running gtags:"
-echo "$CMD"
-eval "$CMD"
-echo "Done."
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_pyscopedb.sh b/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_pyscopedb.sh
@@ -1,93 +0,0 @@
-#!/bin/sh
-
-set -e
-
-PROG_NAME=$0
-PYCSCOPE_EXE=pycscope
-PYCSCOPE_ARGS=
-DB_FILE=pycscope.out
-# Note that we keep the same name
-PROJECT_ROOT=
-FILE_LIST_CMD=
-
-ShowUsage() {
- echo "Usage:"
- echo " $PROG_NAME <options>"
- echo ""
- echo " -e [exe=pycscope]: The pycscope executable to run"
- echo " -f [file=pycscope.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 ""
-}
-
-
-while getopts "h?e:f:p:L:" opt; do
- case $opt in
- h|\?)
- ShowUsage
- exit 0
- ;;
- e)
- PYCSCOPE_EXE=$OPTARG
- ;;
- f)
- DB_FILE=$OPTARG
- ;;
- p)
- PROJECT_ROOT=$OPTARG
- ;;
- L)
- FILE_LIST_CMD=$OPTARG
- ;;
- esac
-done
-
-shift $((OPTIND - 1))
-
-if [ "$1" != "" ]; then
- echo "Invalid Argument: $1"
- exit 1
-fi
-
-echo "Locking pycscope DB file..."
-echo $$ > "$DB_FILE.lock"
-
-# Remove lock and temp file if script is stopped unexpectedly.
-trap 'rm -f "$DB_FILE.lock" "$DB_FILE.files" "$DB_FILE.temp"' 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" > "${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 > "${DB_FILE}.files"
-fi
-PYCSCOPE_ARGS="${PYCSCOPE_ARGS} -i ${DB_FILE}.files"
-
-echo "Running pycscope"
-echo "$PYCSCOPE_EXE -f \"$DB_FILE.temp\" "$PYCSCOPE_ARGS
-"$PYCSCOPE_EXE" -f "$DB_FILE.temp" $PYCSCOPE_ARGS
-
-if [ -d "$PROJECT_ROOT" ]; then
- cd "$PREVIOUS_DIR"
-fi
-
-echo "Replacing pycscope DB file"
-echo "mv -f \"$DB_FILE.temp\" \"$DB_FILE\""
-mv -f "$DB_FILE.temp" "$DB_FILE"
-
-echo "Unlocking pycscope DB file..."
-rm -f "$DB_FILE.lock"
-
-echo "Done."
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_scopedb.sh b/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_scopedb.sh
@@ -1,124 +0,0 @@
-#!/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."
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_tags.sh b/.config/nvim/pack/bundle/start/vim-gutentags/plat/unix/update_tags.sh
@@ -1,168 +0,0 @@
-#!/bin/sh
-
-set -e
-
-PROG_NAME=$0
-CTAGS_EXE=ctags
-CTAGS_ARGS=
-CTAGS_OPT_FILE=
-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_OPT_FILE="--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"
- CTAGS_ARG_LAST="${TAGS_FILE}.files"
- else
- CTAGS_ARG_LAST="${PROJECT_ROOT}"
- fi
-
- echo "Running ctags on whole project"
- if [ "$CTAGS_OPT_FILE" != "" ]; then
- echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" \"$CTAGS_OPT_FILE\" $CTAGS_ARGS \"$CTAGS_ARG_LAST\""
- "$CTAGS_EXE" -f "$TAGS_FILE.temp" "$CTAGS_OPT_FILE" $CTAGS_ARGS "$CTAGS_ARG_LAST"
- else
- echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" $CTAGS_ARGS \"$CTAGS_ARG_LAST\""
- "$CTAGS_EXE" -f "$TAGS_FILE.temp" $CTAGS_ARGS "$CTAGS_ARG_LAST"
- fi
-else
- echo "Running ctags on \"$UPDATED_SOURCE\""
- if [ "$CTAGS_OPT_FILE" != "" ]; then
- echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" \"$CTAGS_OPT_FILE\" $CTAGS_ARGS --append \"$UPDATED_SOURCE\""
- "$CTAGS_EXE" -f "$TAGS_FILE.temp" "$CTAGS_OPT_FILE" $CTAGS_ARGS --append "$UPDATED_SOURCE"
- else
- echo "$CTAGS_EXE -f \"$TAGS_FILE.temp\" $CTAGS_ARGS --append \"$UPDATED_SOURCE\""
- "$CTAGS_EXE" -f "$TAGS_FILE.temp" $CTAGS_ARGS --append "$UPDATED_SOURCE"
- fi
-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\""
-if [ -f "$TAGS_FILE.temp" ]; then
- mv -f "$TAGS_FILE.temp" "$TAGS_FILE"
-fi
-
-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
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_gtags.cmd b/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_gtags.cmd
@@ -1,56 +0,0 @@
-@echo off
-
-setlocal EnableExtensions EnableDelayedExpansion
-
-rem ==========================================
-rem PARSE ARGUMENTS
-rem ==========================================
-set "GTAGS_EXE=gtags"
-set "GTAGS_ARGS="
-set "FILE_LIST_CMD="
-
-if [%1]==[] goto :Usage
-
-:ParseArgs
-if [%1]==[] goto :DoneParseArgs
-if [%1]==[-e] (
- set GTAGS_EXE=%~2
- shift /1
- shift /1
- goto :ParseArgs
-)
-if [%1]==[-L] (
- set FILE_LIST_CMD=%~2
- shift /1
- shift /1
- goto :ParseArgs
-)
-set "GTAGS_ARGS=%GTAGS_ARGS% %1"
-shift /1
-goto :ParseArgs
-
-:DoneParseArgs
-rem ==========================================
-rem GENERATE GTAGS
-rem ==========================================
-set "GTAGS_CMD=%GTAGS_EXE% %GTAGS_ARGS%"
-if /i not "%FILE_LIST_CMD%"=="" (
- set "GTAGS_CMD=%FILE_LIST_CMD% | %GTAGS_EXE% -f- %GTAGS_ARGS%"
-)
-echo Running gtags:
-echo "%GTAGS_CMD%"
-call %GTAGS_CMD%
-echo Done.
-goto :EOF
-rem ==========================================
-rem USAGE
-rem ==========================================
-
-:Usage
-echo Usage:
-echo %~n0 ^<options^>
-echo.
-echo -e [exe=gtags]: The gtags executable to run.
-echo -L [cmd=]: The file list command to run
-echo.
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_scopedb.cmd b/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_scopedb.cmd
@@ -1,120 +0,0 @@
-@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.
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_tags.cmd b/.config/nvim/pack/bundle/start/vim-gutentags/plat/win32/update_tags.cmd
@@ -1,194 +0,0 @@
-@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 [log=]: The log file to output to
-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.
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/plugin/gutentags.vim b/.config/nvim/pack/bundle/start/vim-gutentags/plugin/gutentags.vim
@@ -1,120 +0,0 @@
-" 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_project_root = get(g:, 'gutentags_exclude_project_root',
- \['/usr/local', '/opt/homebrew', '/home/linuxbrew/.linuxbrew'])
-
-let g:gutentags_exclude_filetypes = get(g:, 'gutentags_exclude_filetypes', [])
-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
-
-let g:__gutentags_vim_is_leaving = 0
-
-" }}}
-
-" Gutentags Setup {{{
-
-augroup gutentags_detect
- autocmd!
- autocmd BufNewFile,BufReadPost * call gutentags#setup_gutentags()
- autocmd VimEnter * if expand('<amatch>')==''|call gutentags#setup_gutentags()|endif
- autocmd VimLeavePre * call gutentags#on_vim_leave_pre()
- autocmd VimLeave * call gutentags#on_vim_leave()
-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
-
-" }}}
-
diff --git a/.config/nvim/pack/bundle/start/vim-gutentags/res/ctags_recursive.options b/.config/nvim/pack/bundle/start/vim-gutentags/res/ctags_recursive.options
@@ -1,2 +0,0 @@
---recurse=yes
-
