From 38241721c45339e9fdf8f82967e10a8bf3eb784c Mon Sep 17 00:00:00 2001 From: Jannik ZANDER Date: Fri, 2 Sep 2022 08:19:20 +0200 Subject: [PATCH] Add nobackup --- plugin/fzf.vim | 831 ---------------------------------------- plugin/gtags-cscope.vim | 273 ------------- undo/.gitignore | 1 - vimrc | 1 + 4 files changed, 1 insertion(+), 1105 deletions(-) delete mode 100644 plugin/fzf.vim delete mode 100644 plugin/gtags-cscope.vim delete mode 100644 undo/.gitignore diff --git a/plugin/fzf.vim b/plugin/fzf.vim deleted file mode 100644 index 0bbeaff..0000000 --- a/plugin/fzf.vim +++ /dev/null @@ -1,831 +0,0 @@ -" Copyright (c) 2017 Junegunn Choi -" -" MIT License -" -" 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. - -if exists('g:loaded_fzf') - finish -endif -let g:loaded_fzf = 1 - -let s:is_win = has('win32') || has('win64') -if s:is_win && &shellslash - set noshellslash - let s:base_dir = expand(':h:h') - set shellslash -else - let s:base_dir = expand(':h:h') -endif -if s:is_win - let s:term_marker = '&::FZF' - - function! s:fzf_call(fn, ...) - let shellslash = &shellslash - try - set noshellslash - return call(a:fn, a:000) - finally - let &shellslash = shellslash - endtry - endfunction - - " Use utf-8 for fzf.vim commands - " Return array of shell commands for cmd.exe - let s:codepage = libcallnr('kernel32.dll', 'GetACP', 0) - function! s:enc_to_cp(str) - return iconv(a:str, &encoding, 'cp'.s:codepage) - endfunction - function! s:wrap_cmds(cmds) - return map([ - \ '@echo off', - \ 'setlocal enabledelayedexpansion'] - \ + (has('gui_running') ? ['set TERM= > nul'] : []) - \ + (type(a:cmds) == type([]) ? a:cmds : [a:cmds]) - \ + ['endlocal'], - \ 'enc_to_cp(v:val."\r")') - endfunction -else - let s:term_marker = ";#FZF" - - function! s:fzf_call(fn, ...) - return call(a:fn, a:000) - endfunction - - function! s:wrap_cmds(cmds) - return a:cmds - endfunction - - function! s:enc_to_cp(str) - return a:str - endfunction -endif - -function! s:shellesc_cmd(arg) - let escaped = substitute(a:arg, '[&|<>()@^]', '^&', 'g') - let escaped = substitute(escaped, '%', '%%', 'g') - let escaped = substitute(escaped, '"', '\\^&', 'g') - let escaped = substitute(escaped, '\(\\\+\)\(\\^\)', '\1\1\2', 'g') - return '^"'.substitute(escaped, '\(\\\+\)$', '\1\1', '').'^"' -endfunction - -function! fzf#shellescape(arg, ...) - let shell = get(a:000, 0, s:is_win ? 'cmd.exe' : 'sh') - if shell =~# 'cmd.exe$' - return s:shellesc_cmd(a:arg) - endif - return s:fzf_call('shellescape', a:arg) -endfunction - -function! s:fzf_getcwd() - return s:fzf_call('getcwd') -endfunction - -function! s:fzf_fnamemodify(fname, mods) - return s:fzf_call('fnamemodify', a:fname, a:mods) -endfunction - -function! s:fzf_expand(fmt) - return s:fzf_call('expand', a:fmt, 1) -endfunction - -function! s:fzf_tempname() - return s:fzf_call('tempname') -endfunction - -let s:default_layout = { 'down': '~40%' } -let s:layout_keys = ['window', 'up', 'down', 'left', 'right'] -let s:fzf_go = s:base_dir.'/bin/fzf' -let s:fzf_tmux = s:base_dir.'/bin/fzf-tmux' -let s:install = s:base_dir.'/install' -let s:installed = 0 - -let s:cpo_save = &cpo -set cpo&vim - -function! s:fzf_exec() - if !exists('s:exec') - if executable(s:fzf_go) - let s:exec = s:fzf_go - elseif executable('fzf') - let s:exec = 'fzf' - elseif s:is_win && !has('win32unix') - call s:warn('fzf executable not found.') - call s:warn('Download fzf binary for Windows from https://github.com/junegunn/fzf-bin/releases/') - call s:warn('and place it as '.s:base_dir.'\bin\fzf.exe') - throw 'fzf executable not found' - elseif !s:installed && executable(s:install) && - \ input('fzf executable not found. Download binary? (y/n) ') =~? '^y' - redraw - echo - call s:warn('Downloading fzf binary. Please wait ...') - let s:installed = 1 - call system(s:install.' --bin') - return s:fzf_exec() - else - redraw - throw 'fzf executable not found' - endif - endif - return fzf#shellescape(s:exec) -endfunction - -function! s:tmux_enabled() - if has('gui_running') - return 0 - endif - - if exists('s:tmux') - return s:tmux - endif - - let s:tmux = 0 - if exists('$TMUX') && executable(s:fzf_tmux) - let output = system('tmux -V') - let s:tmux = !v:shell_error && output >= 'tmux 1.7' - endif - return s:tmux -endfunction - -function! s:escape(path) - let path = fnameescape(a:path) - return s:is_win ? escape(path, '$') : path -endfunction - -" Upgrade legacy options -function! s:upgrade(dict) - let copy = copy(a:dict) - if has_key(copy, 'tmux') - let copy.down = remove(copy, 'tmux') - endif - if has_key(copy, 'tmux_height') - let copy.down = remove(copy, 'tmux_height') - endif - if has_key(copy, 'tmux_width') - let copy.right = remove(copy, 'tmux_width') - endif - return copy -endfunction - -function! s:error(msg) - echohl ErrorMsg - echom a:msg - echohl None -endfunction - -function! s:warn(msg) - echohl WarningMsg - echom a:msg - echohl None -endfunction - -function! s:has_any(dict, keys) - for key in a:keys - if has_key(a:dict, key) - return 1 - endif - endfor - return 0 -endfunction - -function! s:open(cmd, target) - if stridx('edit', a:cmd) == 0 && s:fzf_fnamemodify(a:target, ':p') ==# s:fzf_expand('%:p') - return - endif - execute a:cmd s:escape(a:target) -endfunction - -function! s:common_sink(action, lines) abort - if len(a:lines) < 2 - return - endif - let key = remove(a:lines, 0) - let Cmd = get(a:action, key, 'e') - if type(Cmd) == type(function('call')) - return Cmd(a:lines) - endif - if len(a:lines) > 1 - augroup fzf_swap - autocmd SwapExists * let v:swapchoice='o' - \| call s:warn('fzf: E325: swap file exists: '.s:fzf_expand('')) - augroup END - endif - try - let empty = empty(s:fzf_expand('%')) && line('$') == 1 && empty(getline(1)) && !&modified - let autochdir = &autochdir - set noautochdir - for item in a:lines - if empty - execute 'e' s:escape(item) - let empty = 0 - else - call s:open(Cmd, item) - endif - if !has('patch-8.0.0177') && !has('nvim-0.2') && exists('#BufEnter') - \ && isdirectory(item) - doautocmd BufEnter - endif - endfor - catch /^Vim:Interrupt$/ - finally - let &autochdir = autochdir - silent! autocmd! fzf_swap - endtry -endfunction - -function! s:get_color(attr, ...) - let gui = !s:is_win && !has('win32unix') && has('termguicolors') && &termguicolors - let fam = gui ? 'gui' : 'cterm' - let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$' - for group in a:000 - let code = synIDattr(synIDtrans(hlID(group)), a:attr, fam) - if code =~? pat - return code - endif - endfor - return '' -endfunction - -function! s:defaults() - let rules = copy(get(g:, 'fzf_colors', {})) - let colors = join(map(items(filter(map(rules, 'call("s:get_color", v:val)'), '!empty(v:val)')), 'join(v:val, ":")'), ',') - return empty(colors) ? '' : fzf#shellescape('--color='.colors) -endfunction - -function! s:validate_layout(layout) - for key in keys(a:layout) - if index(s:layout_keys, key) < 0 - throw printf('Invalid entry in g:fzf_layout: %s (allowed: %s)%s', - \ key, join(s:layout_keys, ', '), key == 'options' ? '. Use $FZF_DEFAULT_OPTS.' : '') - endif - endfor - return a:layout -endfunction - -function! s:evaluate_opts(options) - return type(a:options) == type([]) ? - \ join(map(copy(a:options), 'fzf#shellescape(v:val)')) : a:options -endfunction - -" [name string,] [opts dict,] [fullscreen boolean] -function! fzf#wrap(...) - let args = ['', {}, 0] - let expects = map(copy(args), 'type(v:val)') - let tidx = 0 - for arg in copy(a:000) - let tidx = index(expects, type(arg), tidx) - if tidx < 0 - throw 'Invalid arguments (expected: [name string] [opts dict] [fullscreen boolean])' - endif - let args[tidx] = arg - let tidx += 1 - unlet arg - endfor - let [name, opts, bang] = args - - if len(name) - let opts.name = name - end - - " Layout: g:fzf_layout (and deprecated g:fzf_height) - if bang - for key in s:layout_keys - if has_key(opts, key) - call remove(opts, key) - endif - endfor - elseif !s:has_any(opts, s:layout_keys) - if !exists('g:fzf_layout') && exists('g:fzf_height') - let opts.down = g:fzf_height - else - let opts = extend(opts, s:validate_layout(get(g:, 'fzf_layout', s:default_layout))) - endif - endif - - " Colors: g:fzf_colors - let opts.options = s:defaults() .' '. s:evaluate_opts(get(opts, 'options', '')) - - " History: g:fzf_history_dir - if len(name) && len(get(g:, 'fzf_history_dir', '')) - let dir = s:fzf_expand(g:fzf_history_dir) - if !isdirectory(dir) - call mkdir(dir, 'p') - endif - let history = fzf#shellescape(dir.'/'.name) - let opts.options = join(['--history', history, opts.options]) - endif - - " Action: g:fzf_action - if !s:has_any(opts, ['sink', 'sink*']) - let opts._action = get(g:, 'fzf_action', s:default_action) - let opts.options .= ' --expect='.join(keys(opts._action), ',') - function! opts.sink(lines) abort - return s:common_sink(self._action, a:lines) - endfunction - let opts['sink*'] = remove(opts, 'sink') - endif - - return opts -endfunction - -function! s:use_sh() - let [shell, shellslash, shellcmdflag, shellxquote] = [&shell, &shellslash, &shellcmdflag, &shellxquote] - if s:is_win - set shell=cmd.exe - set noshellslash - let &shellcmdflag = has('nvim') ? '/s /c' : '/c' - let &shellxquote = has('nvim') ? '"' : '(' - else - set shell=sh - endif - return [shell, shellslash, shellcmdflag, shellxquote] -endfunction - -function! fzf#run(...) abort -try - let [shell, shellslash, shellcmdflag, shellxquote] = s:use_sh() - - let dict = exists('a:1') ? s:upgrade(a:1) : {} - let temps = { 'result': s:fzf_tempname() } - let optstr = s:evaluate_opts(get(dict, 'options', '')) - try - let fzf_exec = s:fzf_exec() - catch - throw v:exception - endtry - - if !has_key(dict, 'dir') - let dict.dir = s:fzf_getcwd() - endif - if has('win32unix') && has_key(dict, 'dir') - let dict.dir = fnamemodify(dict.dir, ':p') - endif - - if !has_key(dict, 'source') && !empty($FZF_DEFAULT_COMMAND) && !s:is_win - let temps.source = s:fzf_tempname() - call writefile(s:wrap_cmds(split($FZF_DEFAULT_COMMAND, "\n")), temps.source) - let dict.source = (empty($SHELL) ? &shell : $SHELL).' '.fzf#shellescape(temps.source) - endif - - if has_key(dict, 'source') - let source = dict.source - let type = type(source) - if type == 1 - let prefix = '( '.source.' )|' - elseif type == 3 - let temps.input = s:fzf_tempname() - call writefile(map(source, 'enc_to_cp(v:val)'), temps.input) - let prefix = (s:is_win ? 'type ' : 'cat ').fzf#shellescape(temps.input).'|' - else - throw 'Invalid source type' - endif - else - let prefix = '' - endif - - let prefer_tmux = get(g:, 'fzf_prefer_tmux', 0) - let use_height = has_key(dict, 'down') && !has('gui_running') && - \ !(has('nvim') || s:is_win || has('win32unix') || s:present(dict, 'up', 'left', 'right', 'window')) && - \ executable('tput') && filereadable('/dev/tty') - let has_vim8_term = has('terminal') && has('patch-8.0.995') - let has_nvim_term = has('nvim-0.2.1') || has('nvim') && !s:is_win - let use_term = has_nvim_term || - \ has_vim8_term && !has('win32unix') && (has('gui_running') || s:is_win || !use_height && s:present(dict, 'down', 'up', 'left', 'right', 'window')) - let use_tmux = (!use_height && !use_term || prefer_tmux) && !has('win32unix') && s:tmux_enabled() && s:splittable(dict) - if prefer_tmux && use_tmux - let use_height = 0 - let use_term = 0 - endif - if use_height - let height = s:calc_size(&lines, dict.down, dict) - let optstr .= ' --height='.height - elseif use_term - let optstr .= ' --no-height' - endif - let command = prefix.(use_tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result - - if use_term - return s:execute_term(dict, command, temps) - endif - - let lines = use_tmux ? s:execute_tmux(dict, command, temps) - \ : s:execute(dict, command, use_height, temps) - call s:callback(dict, lines) - return lines -finally - let [&shell, &shellslash, &shellcmdflag, &shellxquote] = [shell, shellslash, shellcmdflag, shellxquote] -endtry -endfunction - -function! s:present(dict, ...) - for key in a:000 - if !empty(get(a:dict, key, '')) - return 1 - endif - endfor - return 0 -endfunction - -function! s:fzf_tmux(dict) - let size = '' - for o in ['up', 'down', 'left', 'right'] - if s:present(a:dict, o) - let spec = a:dict[o] - if (o == 'up' || o == 'down') && spec[0] == '~' - let size = '-'.o[0].s:calc_size(&lines, spec, a:dict) - else - " Legacy boolean option - let size = '-'.o[0].(spec == 1 ? '' : substitute(spec, '^\~', '', '')) - endif - break - endif - endfor - return printf('LINES=%d COLUMNS=%d %s %s %s --', - \ &lines, &columns, fzf#shellescape(s:fzf_tmux), size, (has_key(a:dict, 'source') ? '' : '-')) -endfunction - -function! s:splittable(dict) - return s:present(a:dict, 'up', 'down') && &lines > 15 || - \ s:present(a:dict, 'left', 'right') && &columns > 40 -endfunction - -function! s:pushd(dict) - if s:present(a:dict, 'dir') - let cwd = s:fzf_getcwd() - let w:fzf_pushd = { - \ 'command': haslocaldir() ? 'lcd' : (exists(':tcd') && haslocaldir(-1) ? 'tcd' : 'cd'), - \ 'origin': cwd, - \ 'bufname': bufname('') - \ } - execute 'lcd' s:escape(a:dict.dir) - let cwd = s:fzf_getcwd() - let w:fzf_pushd.dir = cwd - let a:dict.pushd = w:fzf_pushd - return cwd - endif - return '' -endfunction - -augroup fzf_popd - autocmd! - autocmd WinEnter * call s:dopopd() -augroup END - -function! s:dopopd() - if !exists('w:fzf_pushd') - return - endif - - " FIXME: We temporarily change the working directory to 'dir' entry - " of options dictionary (set to the current working directory if not given) - " before running fzf. - " - " e.g. call fzf#run({'dir': '/tmp', 'source': 'ls', 'sink': 'e'}) - " - " After processing the sink function, we have to restore the current working - " directory. But doing so may not be desirable if the function changed the - " working directory on purpose. - " - " So how can we tell if we should do it or not? A simple heuristic we use - " here is that we change directory only if the current working directory - " matches 'dir' entry. However, it is possible that the sink function did - " change the directory to 'dir'. In that case, the user will have an - " unexpected result. - if s:fzf_getcwd() ==# w:fzf_pushd.dir && (!&autochdir || w:fzf_pushd.bufname ==# bufname('')) - execute w:fzf_pushd.command s:escape(w:fzf_pushd.origin) - endif - unlet w:fzf_pushd -endfunction - -function! s:xterm_launcher() - let fmt = 'xterm -T "[fzf]" -bg "%s" -fg "%s" -geometry %dx%d+%d+%d -e bash -ic %%s' - if has('gui_macvim') - let fmt .= '&& osascript -e "tell application \"MacVim\" to activate"' - endif - return printf(fmt, - \ escape(synIDattr(hlID("Normal"), "bg"), '#'), escape(synIDattr(hlID("Normal"), "fg"), '#'), - \ &columns, &lines/2, getwinposx(), getwinposy()) -endfunction -unlet! s:launcher -if s:is_win || has('win32unix') - let s:launcher = '%s' -else - let s:launcher = function('s:xterm_launcher') -endif - -function! s:exit_handler(code, command, ...) - if a:code == 130 - return 0 - elseif has('nvim') && a:code == 129 - " When deleting the terminal buffer while fzf is still running, - " Nvim sends SIGHUP. - return 0 - elseif a:code > 1 - call s:error('Error running ' . a:command) - if !empty(a:000) - sleep - endif - return 0 - endif - return 1 -endfunction - -function! s:execute(dict, command, use_height, temps) abort - call s:pushd(a:dict) - if has('unix') && !a:use_height - silent! !clear 2> /dev/null - endif - let escaped = (a:use_height || s:is_win) ? a:command : escape(substitute(a:command, '\n', '\\n', 'g'), '%#!') - if has('gui_running') - let Launcher = get(a:dict, 'launcher', get(g:, 'Fzf_launcher', get(g:, 'fzf_launcher', s:launcher))) - let fmt = type(Launcher) == 2 ? call(Launcher, []) : Launcher - if has('unix') - let escaped = "'".substitute(escaped, "'", "'\"'\"'", 'g')."'" - endif - let command = printf(fmt, escaped) - else - let command = escaped - endif - if s:is_win - let batchfile = s:fzf_tempname().'.bat' - call writefile(s:wrap_cmds(command), batchfile) - let command = batchfile - let a:temps.batchfile = batchfile - if has('nvim') - let fzf = {} - let fzf.dict = a:dict - let fzf.temps = a:temps - function! fzf.on_exit(job_id, exit_status, event) dict - call s:pushd(self.dict) - let lines = s:collect(self.temps) - call s:callback(self.dict, lines) - endfunction - let cmd = 'start /wait cmd /c '.command - call jobstart(cmd, fzf) - return [] - endif - elseif has('win32unix') && $TERM !=# 'cygwin' - let shellscript = s:fzf_tempname() - call writefile([command], shellscript) - let command = 'cmd.exe /C '.fzf#shellescape('set "TERM=" & start /WAIT sh -c '.shellscript) - let a:temps.shellscript = shellscript - endif - if a:use_height - let stdin = has_key(a:dict, 'source') ? '' : '< /dev/tty' - call system(printf('tput cup %d > /dev/tty; tput cnorm > /dev/tty; %s %s 2> /dev/tty', &lines, command, stdin)) - else - execute 'silent !'.command - endif - let exit_status = v:shell_error - redraw! - return s:exit_handler(exit_status, command) ? s:collect(a:temps) : [] -endfunction - -function! s:execute_tmux(dict, command, temps) abort - let command = a:command - let cwd = s:pushd(a:dict) - if len(cwd) - " -c '#{pane_current_path}' is only available on tmux 1.9 or above - let command = join(['cd', fzf#shellescape(cwd), '&&', command]) - endif - - call system(command) - let exit_status = v:shell_error - redraw! - return s:exit_handler(exit_status, command) ? s:collect(a:temps) : [] -endfunction - -function! s:calc_size(max, val, dict) - let val = substitute(a:val, '^\~', '', '') - if val =~ '%$' - let size = a:max * str2nr(val[:-2]) / 100 - else - let size = min([a:max, str2nr(val)]) - endif - - let srcsz = -1 - if type(get(a:dict, 'source', 0)) == type([]) - let srcsz = len(a:dict.source) - endif - - let opts = $FZF_DEFAULT_OPTS.' '.s:evaluate_opts(get(a:dict, 'options', '')) - let margin = stridx(opts, '--inline-info') > stridx(opts, '--no-inline-info') ? 1 : 2 - let margin += stridx(opts, '--border') > stridx(opts, '--no-border') ? 2 : 0 - let margin += stridx(opts, '--header') > stridx(opts, '--no-header') - return srcsz >= 0 ? min([srcsz + margin, size]) : size -endfunction - -function! s:getpos() - return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')} -endfunction - -function! s:split(dict) - let directions = { - \ 'up': ['topleft', 'resize', &lines], - \ 'down': ['botright', 'resize', &lines], - \ 'left': ['vertical topleft', 'vertical resize', &columns], - \ 'right': ['vertical botright', 'vertical resize', &columns] } - let ppos = s:getpos() - try - if s:present(a:dict, 'window') - execute 'keepalt' a:dict.window - elseif !s:splittable(a:dict) - execute (tabpagenr()-1).'tabnew' - else - for [dir, triple] in items(directions) - let val = get(a:dict, dir, '') - if !empty(val) - let [cmd, resz, max] = triple - if (dir == 'up' || dir == 'down') && val[0] == '~' - let sz = s:calc_size(max, val, a:dict) - else - let sz = s:calc_size(max, val, {}) - endif - execute cmd sz.'new' - execute resz sz - return [ppos, {}] - endif - endfor - endif - return [ppos, { '&l:wfw': &l:wfw, '&l:wfh': &l:wfh }] - finally - setlocal winfixwidth winfixheight - endtry -endfunction - -function! s:execute_term(dict, command, temps) abort - let winrest = winrestcmd() - let pbuf = bufnr('') - let [ppos, winopts] = s:split(a:dict) - call s:use_sh() - let b:fzf = a:dict - let fzf = { 'buf': bufnr(''), 'pbuf': pbuf, 'ppos': ppos, 'dict': a:dict, 'temps': a:temps, - \ 'winopts': winopts, 'winrest': winrest, 'lines': &lines, - \ 'columns': &columns, 'command': a:command } - function! fzf.switch_back(inplace) - if a:inplace && bufnr('') == self.buf - if bufexists(self.pbuf) - execute 'keepalt b' self.pbuf - endif - " No other listed buffer - if bufnr('') == self.buf - enew - endif - endif - endfunction - function! fzf.on_exit(id, code, ...) - if s:getpos() == self.ppos " {'window': 'enew'} - for [opt, val] in items(self.winopts) - execute 'let' opt '=' val - endfor - call self.switch_back(1) - else - if bufnr('') == self.buf - " We use close instead of bd! since Vim does not close the split when - " there's no other listed buffer (nvim +'set nobuflisted') - close - endif - execute 'tabnext' self.ppos.tab - execute self.ppos.win.'wincmd w' - endif - - if bufexists(self.buf) - execute 'bd!' self.buf - endif - - if &lines == self.lines && &columns == self.columns && s:getpos() == self.ppos - execute self.winrest - endif - - if !s:exit_handler(a:code, self.command, 1) - return - endif - - call s:pushd(self.dict) - let lines = s:collect(self.temps) - call s:callback(self.dict, lines) - call self.switch_back(s:getpos() == self.ppos) - endfunction - - try - call s:pushd(a:dict) - if s:is_win - let fzf.temps.batchfile = s:fzf_tempname().'.bat' - call writefile(s:wrap_cmds(a:command), fzf.temps.batchfile) - let command = fzf.temps.batchfile - else - let command = a:command - endif - let command .= s:term_marker - if has('nvim') - call termopen(command, fzf) - else - let fzf.buf = term_start([&shell, &shellcmdflag, command], {'curwin': 1, 'exit_cb': function(fzf.on_exit)}) - if !has('patch-8.0.1261') && !has('nvim') && !s:is_win - call term_wait(fzf.buf, 20) - endif - endif - finally - call s:dopopd() - endtry - setlocal nospell bufhidden=wipe nobuflisted nonumber - setf fzf - startinsert - return [] -endfunction - -function! s:collect(temps) abort - try - return filereadable(a:temps.result) ? readfile(a:temps.result) : [] - finally - for tf in values(a:temps) - silent! call delete(tf) - endfor - endtry -endfunction - -function! s:callback(dict, lines) abort - let popd = has_key(a:dict, 'pushd') - if popd - let w:fzf_pushd = a:dict.pushd - endif - - try - if has_key(a:dict, 'sink') - for line in a:lines - if type(a:dict.sink) == 2 - call a:dict.sink(line) - else - execute a:dict.sink s:escape(line) - endif - endfor - endif - if has_key(a:dict, 'sink*') - call a:dict['sink*'](a:lines) - endif - catch - if stridx(v:exception, ':E325:') < 0 - echoerr v:exception - endif - endtry - - " We may have opened a new window or tab - if popd - let w:fzf_pushd = a:dict.pushd - call s:dopopd() - endif -endfunction - -let s:default_action = { - \ 'ctrl-t': 'tab split', - \ 'ctrl-x': 'split', - \ 'ctrl-v': 'vsplit' } - -function! s:shortpath() - let short = fnamemodify(getcwd(), ':~:.') - if !has('win32unix') - let short = pathshorten(short) - endif - let slash = (s:is_win && !&shellslash) ? '\' : '/' - return empty(short) ? '~'.slash : short . (short =~ escape(slash, '\').'$' ? '' : slash) -endfunction - -function! s:cmd(bang, ...) abort - let args = copy(a:000) - let opts = { 'options': ['--multi'] } - if len(args) && isdirectory(expand(args[-1])) - let opts.dir = substitute(substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g'), '[/\\]*$', '/', '') - if s:is_win && !&shellslash - let opts.dir = substitute(opts.dir, '/', '\\', 'g') - endif - let prompt = opts.dir - else - let prompt = s:shortpath() - endif - let prompt = strwidth(prompt) < &columns - 20 ? prompt : '> ' - call extend(opts.options, ['--prompt', prompt]) - call extend(opts.options, args) - call fzf#run(fzf#wrap('FZF', opts, a:bang)) -endfunction - -command! -nargs=* -complete=dir -bang FZF call s:cmd(0, ) - -let &cpo = s:cpo_save -unlet s:cpo_save diff --git a/plugin/gtags-cscope.vim b/plugin/gtags-cscope.vim deleted file mode 100644 index 3b6ab11..0000000 --- a/plugin/gtags-cscope.vim +++ /dev/null @@ -1,273 +0,0 @@ -" File: gtags-cscope.vim -" Author: Tama Communications Corporation -" Version: 0.4.1 -" Last Modified: September 10, 2014 -" -" Copyright and license -" --------------------- -" Copyright (c) 2010, 2011 Tama Communications Corporation -" -" This file is part of GNU GLOBAL. -" -" This program is free software: you can redistribute it and/or modify -" it under the terms of the GNU General Public License as published by -" the Free Software Foundation, either version 3 of the License, or -" (at your option) any later version. -" -" This program is distributed in the hope that it will be useful, -" but WITHOUT ANY WARRANTY; without even the implied warranty of -" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -" GNU General Public License for more details. -" -" You should have received a copy of the GNU General Public License -" along with this program. If not, see . -" -" Overview -" -------- -" The gtags-cscope.vim plugin script integrates the GNU GLOBAL source code tagging system -" with Vim using cscope interface. -" -" Installation -" ------------ -" Drop the file in your plugin directory or source it from your vimrc. -" To use this script, you need the GNU GLOBAL-5.8 or later installed -" in your machine. -" -" Usage -" ----- -" First of all, you must execute gtags(1) at the root of source directory -" to make tag files. Assuming that your source directory is '/var/src', -" it is neccessary to execute the following commands. -" -" [Load vim] -" $ cd /var/src -" $ gtags -" $ vim -" [Load gtags-cscope] -" :GtagsCscope (in vim command line) -" -" Basic command -" ------------- -" Then you can use cs commands except for the 'd'(2) command. -" Profitable commands are assigned to keys like follows: -" -" explanation command -" ---------------------------------------------------------- -" Find symbol :cs find 0 or s -" Find definition :cs find 1 or g -" Find functions called by this function (not implemented) -" Find reference :cs find 3 or c -" Find text string :cs find 4 or t -" Find egrep pattern :cs find 6 or e -" Find path :cs find 7 or f -" Find include file :cs find 8 or i -" -" You can move tag list using: -" Go to the next tag :tn -" Go to the previous tag :tp -" Pop tag stack :pop -" -" About the other tag command, you can see the help like this: -" -" :h tagsrch -" -" Enhancing command -" ----------------- -" You can use the context jump function. To use this function, put the cursor -" on a word and type . -" If you can use mouse then please double click on the left button. -" To pop tag, please type 'g' and click on the right button. -" -" Configure -" --------- -" You can use the following variables in $HOME/.vimrc. -" -" To use the default key/mouse mapping: -" let GtagsCscope_Auto_Map = 1 -" To ignore letter case when searching: -" let GtagsCscope_Ignore_Case = 1 -" To use absolute path name: -" let GtagsCscope_Absolute_Path = 1 -" To deterring interruption: -" let GtagsCscope_Keep_Alive = 1 -" If you hope auto loading: -" let GtagsCscope_Auto_Load = 1 -" To use 'vim -t ', ':tag' and '' -" set cscopetag -" -if exists("loaded_gtags_cscope") - finish -endif -if !has("cscope") - echohl WarningMsg | - \ echomsg 'Gtags-cscope: ' . 'This vim does not include cscope support.' | - \ echohl None - finish -endif -" -" global command name -" -let s:global_command = $GTAGSGLOBAL -if s:global_command == '' - let s:global_command = "global" -endif -if !exists("GtagsCscope_Auto_Load") - let GtagsCscope_Auto_Load = 0 -endif -if !exists("GtagsCscope_Auto_Map") - let GtagsCscope_Auto_Map = 0 -endif -if !exists("GtagsCscope_Use_Old_Key_Map") - let GtagsCscope_Use_Old_Key_Map = 0 -endif -if !exists("GtagsCscope_Quiet") - let GtagsCscope_Quiet = 0 -endif -if !exists("GtagsCscope_Ignore_Case") - let GtagsCscope_Ignore_Case = 0 -endif -if !exists("GtagsCscope_Absolute_Path") - let GtagsCscope_Absolute_Path = 0 -endif -if !exists("GtagsCscope_Keep_Alive") - let GtagsCscope_Keep_Alive = 0 -endif - -" -" Display error message. -" -function! s:Error(msg) - if (g:GtagsCscope_Quiet == 0) - echohl WarningMsg | - \ echomsg 'Gtags-cscope: ' . a:msg | - \ echohl None - endif -endfunction - -function! s:GtagsCscope_GtagsRoot() - let cmd = s:global_command . " -pq" - let cmd_output = system(cmd) - if v:shell_error != 0 - if v:shell_error == 3 - call s:Error('GTAGS not found.') - else - call s:Error('global command failed. command line: ' . cmd) - endif - return '' - endif - return strpart(cmd_output, 0, strlen(cmd_output) - 1) -endfunction - -function! s:GtagsCscope() - " - " Get gtagsroot directory. - " - let gtagsroot = s:GtagsCscope_GtagsRoot() - if gtagsroot == '' - return - endif - " - " Load gtags-cscope. - " - set csprg=gtags-cscope - let s:command = "cs add " . gtagsroot . "/GTAGS" - let s:option = '' - if g:GtagsCscope_Ignore_Case == 1 - let s:option = s:option . 'C' - endif - if g:GtagsCscope_Absolute_Path == 1 - let s:option = s:option . 'a' - endif - if g:GtagsCscope_Keep_Alive == 1 - let s:option = s:option . 'i' - endif - if s:option != '' - let s:command = s:command . ' . -' . s:option - endif - set nocscopeverbose - exe s:command - set cscopeverbose - " - " Key mapping - " - if g:GtagsCscope_Auto_Map == 1 - if g:GtagsCscope_Use_Old_Key_Map == 1 - " normal command - :nmap s :cs find s =expand("") - :nmap t :cs find g =expand("") - :nmap r :cs find c =expand("") - :nmap g :cs find e =expand("") - :nmap P :cs find f - " Using 'CTRL-spacebar', the result is displayed in new horizontal window. - :nmap s :scs find s =expand("") - :nmap t :scs find g =expand("") - :nmap r :scs find c =expand("") - :nmap g :scs find e =expand("") - :nmap P :scs find f - " Hitting CTRL-space *twice*, the result is displayed in new vertical window. - :nmap s :vert scs find s =expand("") - :nmap t :vert scs find g =expand("") - :nmap r :vert scs find c =expand("") - :nmap g :vert scs find e =expand("") - :nmap P :vert scs find f - else - " - " The following key mappings are derived from 'cscope_maps.vim'. - " (The 'd' command is not implemented in gtags-cscope.) - " - " normal command - :nmap s :cs find s =expand("") - :nmap g :cs find g =expand("") - :nmap c :cs find c =expand("") - :nmap t :cs find t =expand("") - :nmap e :cs find e =expand("") - :nmap f :cs find f =expand("") - :nmap i :cs find i =expand("") - ":nmap d :cs find d =expand("") - " Using 'CTRL-spacebar', the result is displayed in new horizontal window. - :nmap s :scs find s =expand("") - :nmap g :scs find g =expand("") - :nmap c :scs find c =expand("") - :nmap t :scs find t =expand("") - :nmap e :scs find e =expand("") - :nmap f :scs find f =expand("") - :nmap i :scs find i =expand("") - ":nmap d :scs find d =expand("") - " Hitting CTRL-space *twice*, the result is displayed in new vertical window. - :nmap s :vert scs find s =expand("") - :nmap g :vert scs find g =expand("") - :nmap c :vert scs find c =expand("") - :nmap t :vert scs find t =expand("") - :nmap e :vert scs find e =expand("") - :nmap f :vert scs find f =expand("") - :nmap i :vert scs find i =expand("") - ":nmap d :vert scs find d =expand("") - endif - " tag command - :nmap :tn - :nmap :tp - :nmap :cn - :nmap :cp - " Context search. See the --from-here option of global(1). - :nmap :cs find d =expand(""):=line('.'):% - :nmap <2-LeftMouse> :cs find d =expand(""):=line('.'):% - :nmap g :cs find d =expand(""):=line('.'):% - :nmap :cs find d =expand(""):=line('.'):% - " The following mappings are unnecessary, because you can use the default mapping. - ":nmap g - ":nmap - " Short cut key - :nmap :cs find - :nmap :scs find - :nmap :vert scs find - :nmap :copen - :nmap :cs find d =expand(""):=line('.'):% - :nmap :cclose - endif -endfunction - -if g:GtagsCscope_Auto_Load == 1 - call s:GtagsCscope() -endif -command! -nargs=0 GtagsCscope call s:GtagsCscope() -let loaded_gtags_cscope = 1 diff --git a/undo/.gitignore b/undo/.gitignore deleted file mode 100644 index 5e4debc..0000000 --- a/undo/.gitignore +++ /dev/null @@ -1 +0,0 @@ -* diff --git a/vimrc b/vimrc index c55449b..110a905 100644 --- a/vimrc +++ b/vimrc @@ -1,3 +1,4 @@ source $VIMRUNTIME/defaults.vim set tabstop=2 expandtab autoindent set hidden +set nobackup -- 2.43.0