Created
January 31, 2016 05:56
-
-
Save nhooyr/72512de7ef5efc89562d to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
sourcing "init.vim" | |
line 1: set updatetime=1 | |
line 2: nnoremap <silent> <a-v> :vsplit term://$SHELL<CR> | |
line 3: nnoremap <silent> <c-g> :vs term://./neogo<CR> | |
finished sourcing init.vim | |
Searching for "plugin/**/*.vim" in "/usr/local/etc/dotfiles/nvim,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/HEAD/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/after,/usr/local/etc/dotfiles/nvim/after" | |
Searching for "/usr/local/etc/dotfiles/nvim/plugin/**/*.vim" | |
Searching for "/etc/xdg/nvim/plugin/**/*.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/plugin/**/*.vim" | |
Searching for "/usr/local/share/nvim/site/plugin/**/*.vim" | |
Searching for "/usr/share/nvim/site/plugin/**/*.vim" | |
Searching for "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/**/*.vim" | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/gzip.vim" | |
line 1: " Vim plugin for editing compressed files. | |
line 2: " Maintainer: Bram Moolenaar <[email protected]> | |
line 3: " Last Change: 2010 Mar 10 | |
line 4: | |
line 5: " Exit quickly when: | |
line 6: " - this plugin was already loaded | |
line 7: " - when 'compatible' is set | |
line 8: " - some autocommands are already taking care of compressed files | |
line 9: if exists("loaded_gzip") || &cp || exists("#BufReadPre#*.gz") | |
line 10: finish | |
line 11: endif | |
line 12: let loaded_gzip = 1 | |
line 13: | |
line 14: augroup gzip | |
line 15: " Remove all gzip autocommands | |
line 16: au! | |
line 17: | |
line 18: " Enable editing of gzipped files. | |
line 19: " The functions are defined in autoload/gzip.vim. | |
line 20: " | |
line 21: " Set binary mode before reading the file. | |
line 22: " Use "gzip -d", gunzip isn't always available. | |
line 23: autocmd BufReadPre,FileReadPre^I*.gz,*.bz2,*.Z,*.lzma,*.xz setlocal bin | |
line 24: autocmd BufReadPost,FileReadPost^I*.gz call gzip#read("gzip -dn") | |
line 25: autocmd BufReadPost,FileReadPost^I*.bz2 call gzip#read("bzip2 -d") | |
line 26: autocmd BufReadPost,FileReadPost^I*.Z call gzip#read("uncompress") | |
line 27: autocmd BufReadPost,FileReadPost^I*.lzma call gzip#read("lzma -d") | |
line 28: autocmd BufReadPost,FileReadPost^I*.xz call gzip#read("xz -d") | |
line 29: autocmd BufWritePost,FileWritePost^I*.gz call gzip#write("gzip") | |
line 30: autocmd BufWritePost,FileWritePost^I*.bz2 call gzip#write("bzip2") | |
line 31: autocmd BufWritePost,FileWritePost^I*.Z call gzip#write("compress -f") | |
line 32: autocmd BufWritePost,FileWritePost^I*.lzma call gzip#write("lzma -z") | |
line 33: autocmd BufWritePost,FileWritePost^I*.xz call gzip#write("xz -z") | |
line 34: autocmd FileAppendPre^I^I^I*.gz call gzip#appre("gzip -dn") | |
line 35: autocmd FileAppendPre^I^I^I*.bz2 call gzip#appre("bzip2 -d") | |
line 36: autocmd FileAppendPre^I^I^I*.Z call gzip#appre("uncompress") | |
line 37: autocmd FileAppendPre^I^I^I*.lzma call gzip#appre("lzma -d") | |
line 38: autocmd FileAppendPre^I^I^I*.xz call gzip#appre("xz -d") | |
line 39: autocmd FileAppendPost^I^I*.gz call gzip#write("gzip") | |
line 40: autocmd FileAppendPost^I^I*.bz2 call gzip#write("bzip2") | |
line 41: autocmd FileAppendPost^I^I*.Z call gzip#write("compress -f") | |
line 42: autocmd FileAppendPost^I^I*.lzma call gzip#write("lzma -z") | |
line 43: autocmd FileAppendPost^I^I*.xz call gzip#write("xz -z") | |
line 44: augroup END | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/gzip.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/man.vim" | |
line 1: if get(g:, 'loaded_man', 0) | |
line 2: finish | |
line 3: endif | |
line 4: let g:loaded_man = 1 | |
line 5: | |
line 6: command! -count=0 -nargs=+ Man call man#get_page(<count>, <f-args>) | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/man.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/matchit.vim" | |
line 1: " matchit.vim: (global plugin) Extended "%" matching | |
line 2: " Last Change: Fri Jan 25 10:00 AM 2008 EST | |
line 3: " Maintainer: Benji Fisher PhD <[email protected]> | |
line 4: " Version: 1.13.2, for Vim 6.3+ | |
line 5: " URL:^I^Ihttp://www.vim.org/script.php?script_id=39 | |
line 6: | |
line 7: " Documentation: | |
line 8: " The documentation is in a separate file, matchit.txt . | |
line 9: | |
line 10: " Credits: | |
line 11: " Vim editor by Bram Moolenaar (Thanks, Bram!) | |
line 12: " Original script and design by Raul Segura Acevedo | |
line 13: " Support for comments by Douglas Potts | |
line 14: " Support for back references and other improvements by Benji Fisher | |
line 15: " Support for many languages by Johannes Zellner | |
line 16: " Suggestions for improvement, bug reports, and support for additional | |
line 17: " languages by Jordi-Albert Batalla, Neil Bird, Servatius Brandt, Mark | |
line 18: " Collett, Stephen Wall, Dany St-Amant, Yuheng Xie, and Johannes Zellner. | |
line 19: | |
line 20: " Debugging: | |
line 21: " If you'd like to try the built-in debugging commands... | |
line 22: " :MatchDebug to activate debugging for the current buffer | |
line 23: " This saves the values of several key script variables as buffer-local | |
line 24: " variables. See the MatchDebug() function, below, for details. | |
line 25: | |
line 26: " TODO: I should think about multi-line patterns for b:match_words. | |
line 27: " This would require an option: how many lines to scan (default 1). | |
line 28: " This would be useful for Python, maybe also for *ML. | |
line 29: " TODO: Maybe I should add a menu so that people will actually use some of | |
line 30: " the features that I have implemented. | |
line 31: " TODO: Eliminate the MultiMatch function. Add yet another argument to | |
line 32: " Match_wrapper() instead. | |
line 33: " TODO: Allow :let b:match_words = '\(\(foo\)\(bar\)\):\3\2:end\1' | |
line 34: " TODO: Make backrefs safer by using '\V' (very no-magic). | |
line 35: " TODO: Add a level of indirection, so that custom % scripts can use my | |
line 36: " work but extend it. | |
line 37: | |
line 38: " allow user to prevent loading | |
line 39: " and prevent duplicate loading | |
line 40: if exists("loaded_matchit") || &cp | |
line 41: finish | |
line 42: endif | |
line 43: let loaded_matchit = 1 | |
line 44: let s:last_mps = "" | |
line 45: let s:last_words = ":" | |
line 46: | |
line 47: let s:save_cpo = &cpo | |
line 48: set cpo&vim | |
line 49: | |
line 50: nnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'n') <CR> | |
line 51: nnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'n') <CR> | |
line 52: vnoremap <silent> % :<C-U>call <SID>Match_wrapper('',1,'v') <CR>m'gv`` | |
line 53: vnoremap <silent> g% :<C-U>call <SID>Match_wrapper('',0,'v') <CR>m'gv`` | |
line 54: onoremap <silent> % v:<C-U>call <SID>Match_wrapper('',1,'o') <CR> | |
line 55: onoremap <silent> g% v:<C-U>call <SID>Match_wrapper('',0,'o') <CR> | |
line 56: | |
line 57: " Analogues of [{ and ]} using matching patterns: | |
line 58: nnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "n") <CR> | |
line 59: nnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "n") <CR> | |
line 60: vmap [% <Esc>[%m'gv`` | |
line 61: vmap ]% <Esc>]%m'gv`` | |
line 62: " vnoremap <silent> [% :<C-U>call <SID>MultiMatch("bW", "v") <CR>m'gv`` | |
line 63: " vnoremap <silent> ]% :<C-U>call <SID>MultiMatch("W", "v") <CR>m'gv`` | |
line 64: onoremap <silent> [% v:<C-U>call <SID>MultiMatch("bW", "o") <CR> | |
line 65: onoremap <silent> ]% v:<C-U>call <SID>MultiMatch("W", "o") <CR> | |
line 66: | |
line 67: " text object: | |
line 68: vmap a% <Esc>[%v]% | |
line 69: | |
line 70: " Auto-complete mappings: (not yet "ready for prime time") | |
line 71: " TODO Read :help write-plugin for the "right" way to let the user | |
line 72: " specify a key binding. | |
line 73: " let g:match_auto = '<C-]>' | |
line 74: " let g:match_autoCR = '<C-CR>' | |
line 75: " if exists("g:match_auto") | |
line 76: " execute "inoremap " . g:match_auto . ' x<Esc>"=<SID>Autocomplete()<CR>Pls' | |
line 77: " endif | |
line 78: " if exists("g:match_autoCR") | |
line 79: " execute "inoremap " . g:match_autoCR . ' <CR><C-R>=<SID>Autocomplete()<CR>' | |
line 80: " endif | |
line 81: " if exists("g:match_gthhoh") | |
line 82: " execute "inoremap " . g:match_gthhoh . ' <C-O>:call <SID>Gthhoh()<CR>' | |
line 83: " endif " gthhoh = "Get the heck out of here!" | |
line 84: | |
line 85: let s:notslash = '\\\@<!\%(\\\\\)*' | |
line 86: | |
line 87: function! s:Match_wrapper(word, forward, mode) range | |
line 283: | |
line 284: " Restore options and do some special handling for Operator-pending mode. | |
line 285: " The optional argument is the tail of the matching group. | |
line 286: fun! s:CleanUp(options, mode, startline, startcol, ...) | |
line 312: | |
line 313: " Example (simplified HTML patterns): if | |
line 314: " a:groupBR^I= '<\(\k\+\)>:</\1>' | |
line 315: " a:prefix^I= '^.\{3}\(' | |
line 316: " a:group^I= '<\(\k\+\)>:</\(\k\+\)>' | |
line 317: " a:suffix^I= '\).\{2}$' | |
line 318: " a:matchline^I= "123<tag>12" or "123</tag>12" | |
line 319: " then extract "tag" from a:matchline and return "<tag>:</tag>" . | |
line 320: fun! s:InsertRefs(groupBR, prefix, group, suffix, matchline) | |
line 375: | |
line 376: " Input a comma-separated list of groups with backrefs, such as | |
line 377: " a:groups = '\(foo\):end\1,\(bar\):end\1' | |
line 378: " and return a comma-separated list of groups with backrefs replaced: | |
line 379: " return '\(foo\):end\(foo\),\(bar\):end\(bar\)' | |
line 380: fun! s:ParseWords(groups) | |
line 404: | |
line 405: " TODO I think this can be simplified and/or made more efficient. | |
line 406: " TODO What should I do if a:start is out of range? | |
line 407: " Return a regexp that matches all of a:string, such that | |
line 408: " matchstr(a:string, regexp) represents the match for a:pat that starts | |
line 409: " as close to a:start as possible, before being preferred to after, and | |
line 410: " ends after a:start . | |
line 411: " Usage: | |
line 412: " let regexp = s:Wholematch(getline("."), 'foo\|bar', col(".")-1) | |
line 413: " let i = match(getline("."), regexp) | |
line 414: " let j = matchend(getline("."), regexp) | |
line 415: " let match = matchstr(getline("."), regexp) | |
line 416: fun! s:Wholematch(string, pat, start) | |
line 426: | |
line 427: " No extra arguments: s:Ref(string, d) will | |
line 428: " find the d'th occurrence of '\(' and return it, along with everything up | |
line 429: " to and including the matching '\)'. | |
line 430: " One argument: s:Ref(string, d, "start") returns the index of the start | |
line 431: " of the d'th '\(' and any other argument returns the length of the group. | |
line 432: " Two arguments: s:Ref(string, d, "foo", "bar") returns a string to be | |
line 433: " executed, having the effect of | |
line 434: " :let foo = s:Ref(string, d, "start") | |
line 435: " :let bar = s:Ref(string, d, "len") | |
line 436: fun! s:Ref(string, d, ...) | |
line 477: | |
line 478: " Count the number of disjoint copies of pattern in string. | |
line 479: " If the pattern is a literal string and contains no '0' or '1' characters | |
line 480: " then s:Count(string, pattern, '0', '1') should be faster than | |
line 481: " s:Count(string, pattern). | |
line 482: fun! s:Count(string, pattern, ...) | |
line 500: | |
line 501: " s:Resolve('\(a\)\(b\)', '\(c\)\2\1\1\2') should return table.word, where | |
line 502: " word = '\(c\)\(b\)\(a\)\3\2' and table = '-32-------'. That is, the first | |
line 503: " '\1' in target is replaced by '\(a\)' in word, table[1] = 3, and this | |
line 504: " indicates that all other instances of '\1' in target are to be replaced | |
line 505: " by '\3'. The hard part is dealing with nesting... | |
line 506: " Note that ":" is an illegal character for source and target, | |
line 507: " unless it is preceded by "\". | |
line 508: fun! s:Resolve(source, target, output) | |
line 555: | |
line 556: " Assume a:comma = ",". Then the format for a:patterns and a:1 is | |
line 557: " a:patterns = "<pat1>,<pat2>,..." | |
line 558: " a:1 = "<alt1>,<alt2>,..." | |
line 559: " If <patn> is the first pattern that matches a:string then return <patn> | |
line 560: " if no optional arguments are given; return <patn>,<altn> if a:1 is given. | |
line 561: fun! s:Choose(patterns, string, comma, branch, prefix, suffix, ...) | |
line 596: | |
line 597: " Call this function to turn on debugging information. Every time the main | |
line 598: " script is run, buffer variables will be saved. These can be used directly | |
line 599: " or viewed using the menu items below. | |
line 600: if !exists(":MatchDebug") | |
line 601: command! -nargs=0 MatchDebug call s:Match_debug() | |
line 602: endif | |
line 603: | |
line 604: fun! s:Match_debug() | |
line 625: | |
line 626: " Jump to the nearest unmatched "(" or "if" or "<tag>" if a:spflag == "bW" | |
line 627: " or the nearest unmatched "</tag>" or "endif" or ")" if a:spflag == "W". | |
line 628: " Return a "mark" for the original position, so that | |
line 629: " let m = MultiMatch("bW", "n") ... execute m | |
line 630: " will return to the original position. If there is a problem, do not | |
line 631: " move the cursor and return "", unless a count is given, in which case | |
line 632: " go up or down as many levels as possible and again return "". | |
line 633: " TODO This relies on the same patterns as % matching. It might be a good | |
line 634: " idea to give it its own matching patterns. | |
line 635: fun! s:MultiMatch(spflag, mode) | |
line 732: | |
line 733: " Search backwards for "if" or "while" or "<tag>" or ... | |
line 734: " and return "endif" or "endwhile" or "</tag>" or ... . | |
line 735: " For now, this uses b:match_words and the same script variables | |
line 736: " as s:Match_wrapper() . Later, it may get its own patterns, | |
line 737: " either from a buffer variable or passed as arguments. | |
line 738: " fun! s:Autocomplete() | |
line 739: " echo "autocomplete not yet implemented :-(" | |
line 740: " if !exists("b:match_words") || b:match_words == "" | |
line 741: " return "" | |
line 742: " end | |
line 743: " let startpos = s:MultiMatch("bW") | |
line 744: " | |
line 745: " if startpos == "" | |
line 746: " return "" | |
line 747: " endif | |
line 748: " " - TODO: figure out whether 'if' or '<tag>' matched, and construct | |
line 749: " " - the appropriate closing. | |
line 750: " let matchline = getline(".") | |
line 751: " let curcol = col(".") - 1 | |
line 752: " " - TODO: Change the s:all argument if there is a new set of match pats. | |
line 753: " let regexp = s:Wholematch(matchline, s:all, curcol) | |
line 754: " let suf = strlen(matchline) - matchend(matchline, regexp) | |
line 755: " let prefix = (curcol ? '^.\{' . curcol . '}\%(' : '^\%(') | |
line 756: " let suffix = (suf ? '\).\{' . suf . '}$' : '\)$') | |
line 757: " " Reconstruct the version with unresolved backrefs. | |
line 758: " let patBR = substitute(b:match_words.',', '[,:]*,[,:]*', ',', 'g') | |
line 759: " let patBR = substitute(patBR, ':\{2,}', ':', "g") | |
line 760: " " Now, set group and groupBR to the matching group: 'if:endif' or | |
line 761: " " 'while:endwhile' or whatever. | |
line 762: " let group = s:Choose(s:pat, matchline, ",", ":", prefix, suffix, patBR) | |
line 763: " let i = matchend(group, s:notslash . ",") | |
line 764: " let groupBR = strpart(group, i) | |
line 765: " let group = strpart(group, 0, i-1) | |
line 766: " " Now, matchline =~ prefix . substitute(group,':','\|','g') . suffix | |
line 767: " if s:do_BR | |
line 768: " let group = s:InsertRefs(groupBR, prefix, group, suffix, matchline) | |
line 769: " endif | |
line 770: " " let g:group = group | |
line 771: " | |
line 772: " " - TODO: Construct the closing from group. | |
line 773: " let fake = "end" . expand("<cword>") | |
line 774: " execute startpos | |
line 775: " return fake | |
line 776: " endfun | |
line 777: | |
line 778: " Close all open structures. "Get the heck out of here!" | |
line 779: " fun! s:Gthhoh() | |
line 780: " let close = s:Autocomplete() | |
line 781: " while strlen(close) | |
line 782: " put=close | |
line 783: " let close = s:Autocomplete() | |
line 784: " endwhile | |
line 785: " endfun | |
line 786: | |
line 787: " Parse special strings as typical skip arguments for searchpair(): | |
line 788: " s:foo becomes (current syntax item) =~ foo | |
line 789: " S:foo becomes (current syntax item) !~ foo | |
line 790: " r:foo becomes (line before cursor) =~ foo | |
line 791: " R:foo becomes (line before cursor) !~ foo | |
line 792: fun! s:ParseSkip(str) | |
line 809: | |
line 810: let &cpo = s:save_cpo | |
line 811: unlet s:save_cpo | |
line 812: | |
line 813: " vim:sts=2:sw=2: | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/matchit.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/matchparen.vim" | |
line 1: " Vim plugin for showing matching parens | |
line 2: " Maintainer: Bram Moolenaar <[email protected]> | |
line 3: " Last Change: 2014 Jul 19 | |
line 4: | |
line 5: " Exit quickly when: | |
line 6: " - this plugin was already loaded (or disabled) | |
line 7: " - when 'compatible' is set | |
line 8: " - the "CursorMoved" autocmd event is not available. | |
line 9: if exists("g:loaded_matchparen") || &cp || !exists("##CursorMoved") | |
line 10: finish | |
line 11: endif | |
line 12: let g:loaded_matchparen = 1 | |
line 13: | |
line 14: if !exists("g:matchparen_timeout") | |
line 15: let g:matchparen_timeout = 300 | |
line 16: endif | |
line 17: if !exists("g:matchparen_insert_timeout") | |
line 18: let g:matchparen_insert_timeout = 60 | |
line 19: endif | |
line 20: | |
line 21: augroup matchparen | |
line 22: " Replace all matchparen autocommands | |
line 23: autocmd! CursorMoved,CursorMovedI,WinEnter * call s:Highlight_Matching_Pair() | |
line 24: if exists('##TextChanged') | |
line 25: autocmd! TextChanged,TextChangedI * call s:Highlight_Matching_Pair() | |
line 26: endif | |
line 27: augroup END | |
line 28: | |
line 29: " Skip the rest if it was already done. | |
line 30: if exists("*s:Highlight_Matching_Pair") | |
line 31: finish | |
line 32: endif | |
line 33: | |
line 34: let s:cpo_save = &cpo | |
line 35: set cpo-=C | |
line 36: | |
line 37: " The function that is invoked (very often) to define a ":match" highlighting | |
line 38: " for any matching paren. | |
line 39: function! s:Highlight_Matching_Pair() | |
line 182: | |
line 183: " Define commands that will disable and enable the plugin. | |
line 185: command! NoMatchParen windo silent! call matchdelete(3) | unlet! g:loaded_matchparen | au! matchparen | |
line 186: command! DoMatchParen runtime plugin/matchparen.vim | windo doau CursorMoved | |
line 187: | |
line 188: let &cpo = s:cpo_save | |
line 189: unlet s:cpo_save | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/matchparen.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/netrwPlugin.vim" | |
line 1: " netrwPlugin.vim: Handles file transfer and remote directory listing across a network | |
line 2: " PLUGIN SECTION | |
line 3: " Date:^I^INov 07, 2014 | |
line 4: " Maintainer:^ICharles E Campbell <[email protected]> | |
line 5: " GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim | |
line 6: " Copyright: Copyright (C) 1999-2013 Charles E. Campbell {{{1 | |
line 7: " Permission is hereby granted to use and distribute this code, | |
line 8: " with or without modifications, provided that this copyright | |
line 9: " notice is copied with it. Like anything else that's free, | |
line 10: " netrw.vim, netrwPlugin.vim, and netrwSettings.vim are provided | |
line 11: " *as is* and comes with no warranty of any kind, either | |
line 12: " expressed or implied. By using this plugin, you agree that | |
line 13: " in no event will the copyright holder be liable for any damages | |
line 14: " resulting from the use of this software. | |
line 15: " | |
line 16: " But be doers of the Word, and not only hearers, deluding your own selves {{{1 | |
line 17: " (James 1:22 RSV) | |
line 18: " =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- | |
line 19: " Load Once: {{{1 | |
line 20: if &cp || exists("g:loaded_netrwPlugin") | |
line 21: finish | |
line 22: endif | |
line 23: let g:loaded_netrwPlugin = "v153" | |
line 24: if v:version < 702 | |
line 25: echohl WarningMsg | |
line 26: echo "***warning*** you need vim version 7.2 for this version of netrw" | |
line 27: echohl None | |
line 28: finish | |
line 29: endif | |
line 30: if v:version < 703 || (v:version == 703 && !has("patch465")) | |
line 31: echohl WarningMsg | |
line 32: echo "***warning*** this version of netrw needs vim 7.3.465 or later" | |
line 33: echohl Normal | |
line 34: finish | |
line 35: endif | |
line 36: let s:keepcpo = &cpo | |
line 37: set cpo&vim | |
line 38: "DechoRemOn | |
line 39: | |
line 40: " --------------------------------------------------------------------- | |
line 41: " Public Interface: {{{1 | |
line 42: | |
line 43: " Local Browsing Autocmds: {{{2 | |
line 44: augroup FileExplorer | |
line 45: au! | |
line 46: au BufLeave * if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 47: au BufEnter *^Isil call s:LocalBrowse(expand("<amatch>")) | |
line 48: au VimEnter *^Isil call s:VimEnter(expand("<amatch>")) | |
line 49: if has("win32") || has("win95") || has("win64") || has("win16") | |
line 50: au BufEnter .* sil call s:LocalBrowse(expand("<amatch>")) | |
line 51: endif | |
line 52: augroup END | |
line 53: | |
line 54: " Network Browsing Reading Writing: {{{2 | |
line 55: augroup Network | |
line 56: au! | |
line 57: au BufReadCmd file://*^I^I^I^I^I^I^I^I^I^I^Icall netrw#FileUrlRead(expand("<amatch>")) | |
line 58: au BufReadCmd ftp://*,rcp://*,scp://*,http://*,file://*,https://*,dav://*,davs://*,rsync://*,sftp://*^Iexe "sil doau BufReadPre ".fnameescape(expand("<amatch>"))|call netrw#Nread(2,expand("<amatch>"))|exe "sil doau BufReadPost ".fnameescape(expand("<amatch>")) | |
line 59: au FileReadCmd ftp://*,rcp://*,scp://*,http://*,file://*,https://*,dav://*,davs://*,rsync://*,sftp://*^Iexe "sil doau FileReadPre ".fnameescape(expand("<amatch>"))|call netrw#Nread(1,expand("<amatch>"))|exe "sil doau FileReadPost ".fnameescape(expand("<amatch>")) | |
line 60: au BufWriteCmd ftp://*,rcp://*,scp://*,http://*,file://*,dav://*,davs://*,rsync://*,sftp://*^I^I^Iexe "sil doau BufWritePre ".fnameescape(expand("<amatch>"))|exe 'Nwrite '.fnameescape(expand("<amatch>"))|exe "sil doau BufWritePost ".fnameescape(expand("<amatch>")) | |
line 61: au FileWriteCmd ftp://*,rcp://*,scp://*,http://*,file://*,dav://*,davs://*,rsync://*,sftp://*^I^I^Iexe "sil doau FileWritePre ".fnameescape(expand("<amatch>"))|exe "'[,']".'Nwrite '.fnameescape(expand("<amatch>"))|exe "sil doau FileWritePost ".fnameescape(expand("<amatch>")) | |
line 62: try | |
line 63: au SourceCmd ftp://*,rcp://*,scp://*,http://*,file://*,https://*,dav://*,davs://*,rsync://*,sftp://*^Iexe 'Nsource '.fnameescape(expand("<amatch>")) | |
line 64: catch /^Vim\%((\a\+)\)\=:E216/ | |
line 65: au SourcePre ftp://*,rcp://*,scp://*,http://*,file://*,https://*,dav://*,davs://*,rsync://*,sftp://*^Iexe 'Nsource '.fnameescape(expand("<amatch>")) | |
line 66: endtry | |
line 67: augroup END | |
line 68: | |
line 69: " Commands: :Nread, :Nwrite, :NetUserPass {{{2 | |
line 70: com! -count=1 -nargs=*^INread^I^Icall netrw#SavePosn()<bar>call netrw#NetRead(<count>,<f-args>)<bar>call netrw#RestorePosn() | |
line 71: com! -range=% -nargs=*^INwrite^I^Icall netrw#SavePosn()<bar><line1>,<line2>call netrw#NetWrite(<f-args>)<bar>call netrw#RestorePosn() | |
line 72: com! -nargs=*^I^INetUserPass^Icall NetUserPass(<f-args>) | |
line 73: com! -nargs=*^I Nsource^I^Icall netrw#SavePosn()<bar>call netrw#NetSource(<f-args>)<bar>call netrw#RestorePosn() | |
line 74: com! -nargs=?^I^INtree^I^Icall netrw#SetTreetop(<q-args>) | |
line 75: | |
line 76: " Commands: :Explore, :Sexplore, Hexplore, Vexplore, Lexplore {{{2 | |
line 77: com! -nargs=* -bar -bang -count=0 -complete=dir^IExplore^I^Icall netrw#Explore(<count>,0,0+<bang>0,<q-args>) | |
line 78: com! -nargs=* -bar -bang -count=0 -complete=dir^ISexplore^Icall netrw#Explore(<count>,1,0+<bang>0,<q-args>) | |
line 79: com! -nargs=* -bar -bang -count=0 -complete=dir^IHexplore^Icall netrw#Explore(<count>,1,2+<bang>0,<q-args>) | |
line 80: com! -nargs=* -bar -bang -count=0 -complete=dir^IVexplore^Icall netrw#Explore(<count>,1,4+<bang>0,<q-args>) | |
line 81: com! -nargs=* -bar -count=0 -complete=dir^ITexplore^Icall netrw#Explore(<count>,0,6 ,<q-args>) | |
line 82: com! -nargs=* -bar -bang^I^I^INexplore^Icall netrw#Explore(-1,0,0,<q-args>) | |
line 83: com! -nargs=* -bar -bang^I^I^IPexplore^Icall netrw#Explore(-2,0,0,<q-args>) | |
line 84: com! -nargs=* -bar -bang -count=0 -complete=dir Lexplore^Icall netrw#Lexplore(<count>,<bang>0,<q-args>) | |
line 85: | |
line 86: " Commands: NetrwSettings {{{2 | |
line 87: com! -nargs=0^INetrwSettings^Icall netrwSettings#NetrwSettings() | |
line 88: com! -bang^INetrwClean^Icall netrw#Clean(<bang>0) | |
line 89: | |
line 90: " Maps: | |
line 91: if !exists("g:netrw_nogx") | |
line 92: if maparg('gx','n') == "" | |
line 93: if !hasmapto('<Plug>NetrwBrowseX') | |
line 94: nmap <unique> gx <Plug>NetrwBrowseX | |
line 95: endif | |
line 96: nno <silent> <Plug>NetrwBrowseX :call netrw#BrowseX(expand((exists("g:netrw_gx")? g:netrw_gx : '<cfile>')),netrw#CheckIfRemote())<cr> | |
line 97: endif | |
line 98: if maparg('gx','v') == "" | |
line 99: if !hasmapto('<Plug>NetrwBrowseXVis') | |
line 100: vmap <unique> gx <Plug>NetrwBrowseXVis | |
line 101: endif | |
line 102: vno <silent> <Plug>NetrwBrowseXVis :<c-u>call netrw#BrowseXVis()<cr> | |
line 103: endif | |
line 104: endif | |
line 105: | |
line 106: " --------------------------------------------------------------------- | |
line 107: " LocalBrowse: invokes netrw#LocalBrowseCheck() on directory buffers {{{2 | |
line 108: fun! s:LocalBrowse(dirname) | |
line 150: | |
line 151: " --------------------------------------------------------------------- | |
line 152: " s:VimEnter: after all vim startup stuff is done, this function is called. {{{2 | |
line 153: " Its purpose: to look over all windows and run s:LocalBrowse() on | |
line 154: " them, which checks if they're directories and will create a directory | |
line 155: " listing when appropriate. | |
line 156: " It also sets s:vimentered, letting s:LocalBrowse() know that s:VimEnter() | |
line 157: " has already been called. | |
line 158: fun! s:VimEnter(dirname) | |
line 166: | |
line 167: " --------------------------------------------------------------------- | |
line 168: " NetrwStatusLine: {{{1 | |
line 169: fun! NetrwStatusLine() | |
line 180: | |
line 181: " ------------------------------------------------------------------------ | |
line 182: " NetUserPass: set username and password for subsequent ftp transfer {{{1 | |
line 183: " Usage: :call NetUserPass()^I^I^I-- will prompt for userid and password | |
line 184: "^I :call NetUserPass("uid")^I^I-- will prompt for password | |
line 185: "^I :call NetUserPass("uid","password") -- sets global userid and password | |
line 186: fun! NetUserPass(...) | |
line 210: | |
line 211: " ------------------------------------------------------------------------ | |
line 212: " Modelines And Restoration: {{{1 | |
line 213: let &cpo= s:keepcpo | |
line 214: unlet s:keepcpo | |
line 215: " vim:ts=8 fdm=marker | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/netrwPlugin.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rplugin.vim" | |
line 1: if exists('loaded_remote_plugins') || &cp | |
line 2: finish | |
line 3: endif | |
line 4: let loaded_remote_plugins = 1 | |
line 5: call remote#host#LoadRemotePlugins() | |
Searching for "autoload/remote/host.vim" in "/usr/local/etc/dotfiles/nvim,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/HEAD/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/after,/usr/local/etc/dotfiles/nvim/after" | |
Searching for "/usr/local/etc/dotfiles/nvim/autoload/remote/host.vim" | |
Searching for "/etc/xdg/nvim/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/remote/host.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/remote/host.vim" | |
Searching for "/usr/share/nvim/site/autoload/remote/host.vim" | |
Searching for "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/host.vim" | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote) | |
chdir(/Users/nhooyr/scratch) | |
line 5: sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/host.vim" | |
line 1: let s:hosts = {} | |
line 2: let s:plugin_patterns = {} | |
line 4: let s:remote_plugins_manifest = fnamemodify(expand($MYVIMRC, 1), ':h').'/.'.fnamemodify($MYVIMRC, ':t').'-rplugin~' | |
line 5: | |
line 6: | |
line 7: " Register a host by associating it with a factory(funcref) | |
line 8: function! remote#host#Register(name, pattern, factory) | |
line 16: | |
line 17: | |
line 18: " Register a clone to an existing host. The new host will use the same factory | |
line 19: " as `source`, but it will run as a different process. This can be used by | |
line 20: " plugins that should run isolated from other plugins created for the same host | |
line 21: " type | |
line 22: function! remote#host#RegisterClone(name, orig_name) | |
line 34: | |
line 35: | |
line 36: " Get a host channel, bootstrapping it if necessary | |
line 37: function! remote#host#Require(name) | |
line 52: | |
line 53: | |
line 54: function! remote#host#IsRunning(name) | |
line 60: | |
line 61: | |
line 62: " Example of registering a Python plugin with two commands (one async), one | |
line 63: " autocmd (async) and one function (sync): | |
line 64: " | |
line 65: " let s:plugin_path = expand('<sfile>:p:h').'/nvim_plugin.py' | |
line 66: " call remote#host#RegisterPlugin('python', s:plugin_path, [ | |
line 67: " \ {'type': 'command', 'name': 'PyCmd', 'sync': 1, 'opts': {}}, | |
line 68: " \ {'type': 'command', 'name': 'PyAsyncCmd', 'sync': 0, 'opts': {'eval': 'cursor()'}}, | |
line 69: " \ {'type': 'autocmd', 'name': 'BufEnter', 'sync': 0, 'opts': {'eval': 'expand("<afile>")'}}, | |
line 70: " \ {'type': 'function', 'name': 'PyFunc', 'sync': 1, 'opts': {}} | |
line 71: " \ ]) | |
line 72: " | |
line 73: " The third item in a declaration is a boolean: non zero means the command, | |
line 74: " autocommand or function will be executed synchronously with rpcrequest. | |
line 75: function! remote#host#RegisterPlugin(host, path, specs) | |
line 117: | |
line 118: | |
line 119: function! remote#host#LoadRemotePlugins() | |
line 124: | |
line 125: | |
line 126: function! s:RegistrationCommands(host) | |
line 164: | |
line 165: | |
line 166: function! s:UpdateRemotePlugins() | |
line 184: | |
line 185: | |
line 186: command! UpdateRemotePlugins call s:UpdateRemotePlugins() | |
line 187: | |
line 188: | |
line 189: let s:plugins_for_host = {} | |
line 190: function! remote#host#PluginsForHost(host) | |
line 196: | |
line 197: | |
line 198: " Registration of standard hosts | |
line 199: | |
line 200: " Python/Python3 {{{ | |
line 201: function! s:RequirePythonHost(host) | |
line 231: | |
line 232: call remote#host#Register('python', '*.py', function('s:RequirePythonHost')) | |
calling function remote#host#Register('python', '*.py', function('<SNR>8_RequirePythonHost')) | |
line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
line 2: let s:plugin_patterns[a:name] = a:pattern | |
line 3: if type(a:factory) == type(1) && a:factory | |
line 4: " Passed a channel directly | |
line 5: let s:hosts[a:name].channel = a:factory | |
line 6: endif | |
function remote#host#Register returning #0 | |
continuing in /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/host.vim | |
line 233: call remote#host#Register('python3', '*.py', function('s:RequirePythonHost')) | |
calling function remote#host#Register('python3', '*.py', function('<SNR>8_RequirePythonHost')) | |
line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
line 2: let s:plugin_patterns[a:name] = a:pattern | |
line 3: if type(a:factory) == type(1) && a:factory | |
line 4: " Passed a channel directly | |
line 5: let s:hosts[a:name].channel = a:factory | |
line 6: endif | |
function remote#host#Register returning #0 | |
continuing in /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/host.vim | |
line 234: " }}} | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/host.vim | |
continuing in /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rplugin.vim | |
calling function remote#host#LoadRemotePlugins() | |
line 1: if filereadable(s:remote_plugins_manifest) | |
line 2: exe 'source '.s:remote_plugins_manifest | |
line 2: source ./.-rplugin~ | |
chdir(/Users/nhooyr/scratch) | |
chdir(.) | |
chdir(/Users/nhooyr/scratch) | |
line 2: sourcing "./.-rplugin~" | |
line 1: " python3 plugins | |
line 4: call remote#host#RegisterPlugin('python3', '/Users/nhooyr/scratch/deoplete.nvim/rplugin/python3/deoplete.py', [ {'sync': 1, 'name': 'DeopleteInitializePython', 'type': 'command', 'opts': {}}, ]) | |
calling function remote#host#RegisterPlugin('python3', '/Users/nhooyr/scratch/deoplete.nvim/rplugin/python3/deoplete.py', [{'sync': 1, 'name': 'DeopleteInitializePython', 'type': 'command', 'opts': {}}]) | |
line 1: let plugins = remote#host#PluginsForHost(a:host) | |
calling function remote#host#RegisterPlugin..remote#host#PluginsForHost('python3') | |
line 1: if !has_key(s:plugins_for_host, a:host) | |
line 2: let s:plugins_for_host[a:host] = [] | |
line 3: end | |
line 4: return s:plugins_for_host[a:host] | |
function remote#host#RegisterPlugin..remote#host#PluginsForHost returning [] | |
continuing in function remote#host#RegisterPlugin | |
line 2: | |
line 3: for plugin in plugins | |
line 4: if plugin.path == a:path | |
line 5: throw 'Plugin "'.a:path.'" is already registered' | |
line 6: endif | |
line 7: endfor | |
line 8: | |
line 9: if has_key(s:hosts, a:host) && remote#host#IsRunning(a:host) | |
calling function remote#host#RegisterPlugin..remote#host#IsRunning('python3') | |
line 1: if !has_key(s:hosts, a:name) | |
line 2: throw 'No host named "'.a:name.'" is registered' | |
line 3: endif | |
line 4: return s:hosts[a:name].channel != 0 | |
function remote#host#RegisterPlugin..remote#host#IsRunning returning #0 | |
continuing in function remote#host#RegisterPlugin | |
line 10: " For now we won't allow registration of plugins when the host is already | |
line 11: " running. | |
line 12: throw 'Host "'.a:host.'" is already running' | |
line 13: endif | |
line 14: | |
line 15: for spec in a:specs | |
line 16: let type = spec.type | |
line 17: let name = spec.name | |
line 18: let sync = spec.sync | |
line 19: let opts = spec.opts | |
line 20: let rpc_method = a:path | |
line 21: if type == 'command' | |
line 22: let rpc_method .= ':command:'.name | |
line 23: call remote#define#CommandOnHost(a:host, rpc_method, sync, name, opts) | |
Searching for "autoload/remote/define.vim" in "/usr/local/etc/dotfiles/nvim,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/HEAD/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/after,/usr/local/etc/dotfiles/nvim/after" | |
Searching for "/usr/local/etc/dotfiles/nvim/autoload/remote/define.vim" | |
Searching for "/etc/xdg/nvim/autoload/remote/define.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/remote/define.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/remote/define.vim" | |
Searching for "/usr/share/nvim/site/autoload/remote/define.vim" | |
Searching for "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/define.vim" | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote) | |
chdir(/Users/nhooyr/scratch) | |
line 23: sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/define.vim" | |
line 1: function! remote#define#CommandOnHost(host, method, sync, name, opts) | |
line 39: | |
line 40: | |
line 41: function! remote#define#CommandBootstrap(host, method, sync, name, opts, forward) | |
line 52: | |
line 53: | |
line 54: function! remote#define#CommandOnChannel(channel, method, sync, name, opts) | |
line 88: | |
line 89: | |
line 90: function! remote#define#AutocmdOnHost(host, method, sync, name, opts) | |
line 104: | |
line 105: | |
line 106: function! remote#define#AutocmdBootstrap(host, method, sync, name, opts, forward) | |
line 119: | |
line 120: | |
line 121: function! remote#define#AutocmdOnChannel(channel, method, sync, name, opts) | |
line 129: | |
line 130: | |
line 131: function! remote#define#FunctionOnHost(host, method, sync, name, opts) | |
line 142: | |
line 143: | |
line 144: function! remote#define#FunctionBootstrap(host, method, sync, name, opts, group) | |
line 156: | |
line 157: | |
line 158: function! remote#define#FunctionOnChannel(channel, method, sync, name, opts) | |
line 167: | |
line 168: | |
line 169: function! s:GetRpcFunction(sync) | |
line 175: | |
line 176: | |
line 177: function! s:GetCommandPrefix(name, opts) | |
line 181: | |
line 182: | |
line 183: " Each msgpack-rpc autocommand has it's own unique group, which is derived | |
line 184: " from an autoincrementing gid(group id). This is required for replacing the | |
line 185: " autocmd implementation with the lazy-load mechanism | |
line 186: let s:next_gid = 1 | |
line 187: function! s:GetNextAutocmdGroup() | |
line 196: | |
line 197: | |
line 198: function! s:GetAutocmdPrefix(name, opts) | |
line 218: | |
line 219: | |
line 220: function! s:GetFunctionPrefix(name, opts) | |
line 223: | |
line 224: | |
line 225: function! s:StringifyOpts(opts, keys) | |
line 238: | |
line 239: | |
line 240: function! s:AddEval(rpcargs, opts) | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/autoload/remote/define.vim | |
continuing in function remote#host#RegisterPlugin | |
calling function remote#host#RegisterPlugin..remote#define#CommandOnHost('python3', '/Users/nhooyr/scratch/deoplete.nvim/...ete.py:command:DeopleteInitializePython', 1, 'DeopleteInitializePython', {}) | |
line 1: let prefix = '' | |
line 2: | |
line 3: if has_key(a:opts, 'range') | |
line 4: if a:opts.range == '' || a:opts.range == '%' | |
line 5: " -range or -range=%, pass the line range in a list | |
line 6: let prefix = '<line1>,<line2>' | |
line 7: elseif matchstr(a:opts.range, '\d') != '' | |
line 8: " -range=N, pass the count | |
line 9: let prefix = '<count>' | |
line 10: endif | |
line 11: elseif has_key(a:opts, 'count') | |
line 12: let prefix = '<count>' | |
line 13: endif | |
line 14: | |
line 15: let forward_args = [prefix.a:name] | |
line 16: | |
line 17: if has_key(a:opts, 'bang') | |
line 18: call add(forward_args, '<bang>') | |
line 19: endif | |
line 20: | |
line 21: if has_key(a:opts, 'register') | |
line 22: call add(forward_args, ' <register>') | |
line 23: endif | |
line 24: | |
line 25: if has_key(a:opts, 'nargs') | |
line 26: call add(forward_args, ' <args>') | |
line 27: endif | |
line 28: | |
line 29: exe s:GetCommandPrefix(a:name, a:opts) .' call remote#define#CommandBootstrap("'.a:host.'"' . ', "'.a:method.'"' . ', "'.a:sync.'"' . ', "'.a:name.'"' . ', '.string(a:opts).'' . ', "'.join(forward_args, '').'"' . ')' | |
calling function remote#host#RegisterPlugin..remote#define#CommandOnHost..<SNR>10_GetCommandPrefix('DeopleteInitializePython', {}) | |
line 1: return 'command!'.s:StringifyOpts(a:opts, ['nargs', 'complete', 'range', 'count', 'bang', 'bar', 'register']).' '.a:name | |
calling function remote#host#RegisterPlugin..remote#define#CommandOnHost..<SNR>10_GetCommandPrefix..<SNR>10_StringifyOpts({}, ['nargs', 'complete', 'range', 'count', 'bang', 'bar', 'register']) | |
line 1: let rv = [] | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 2: for key in a:keys | |
line 3: if has_key(a:opts, key) | |
line 4: call add(rv, ' -'.key) | |
line 5: let val = a:opts[key] | |
line 6: if type(val) != type('') || val != '' | |
line 7: call add(rv, '='.val) | |
line 8: endif | |
line 9: endif | |
line 10: endfor | |
line 11: return join(rv, '') | |
function remote#host#RegisterPlugin..remote#define#CommandOnHost..<SNR>10_GetCommandPrefix..<SNR>10_StringifyOpts returning '' | |
continuing in function remote#host#RegisterPlugin..remote#define#CommandOnHost..<SNR>10_GetCommandPrefix | |
function remote#host#RegisterPlugin..remote#define#CommandOnHost..<SNR>10_GetCommandPrefix returning 'command! DeopleteInitializePython' | |
continuing in function remote#host#RegisterPlugin..remote#define#CommandOnHost | |
line 29: command! DeopleteInitializePython call remote#define#CommandBootstrap("python3", "/Users/nhooyr/scratch/deoplete.nvim/rplugin/python3/deoplete.py:command:DeopleteInitializePython", "1", "DeopleteInitializePython", {}, "DeopleteInitializePython") | |
function remote#host#RegisterPlugin..remote#define#CommandOnHost returning #0 | |
continuing in function remote#host#RegisterPlugin | |
line 24: elseif type == 'autocmd' | |
line 25: " Since multiple handlers can be attached to the same autocmd event by a | |
line 26: " single plugin, we need a way to uniquely identify the rpc method to | |
line 27: " call. The solution is to append the autocmd pattern to the method | |
line 28: " name(This still has a limit: one handler per event/pattern combo, but | |
line 29: " there's no need to allow plugins define multiple handlers in that case) | |
line 30: let rpc_method .= ':autocmd:'.name.':'.get(opts, 'pattern', '*') | |
line 31: call remote#define#AutocmdOnHost(a:host, rpc_method, sync, name, opts) | |
line 32: elseif type == 'function' | |
line 33: let rpc_method .= ':function:'.name | |
line 34: call remote#define#FunctionOnHost(a:host, rpc_method, sync, name, opts) | |
line 35: else | |
line 36: echoerr 'Invalid declaration type: '.type | |
line 37: endif | |
line 38: endfor | |
line 15: for spec in a:specs | |
line 16: let type = spec.type | |
line 17: let name = spec.name | |
line 18: let sync = spec.sync | |
line 19: let opts = spec.opts | |
line 20: let rpc_method = a:path | |
line 21: if type == 'command' | |
line 22: let rpc_method .= ':command:'.name | |
line 23: call remote#define#CommandOnHost(a:host, rpc_method, sync, name, opts) | |
line 24: elseif type == 'autocmd' | |
line 25: " Since multiple handlers can be attached to the same autocmd event by a | |
line 26: " single plugin, we need a way to uniquely identify the rpc method to | |
line 27: " call. The solution is to append the autocmd pattern to the method | |
line 28: " name(This still has a limit: one handler per event/pattern combo, but | |
line 29: " there's no need to allow plugins define multiple handlers in that case) | |
line 30: let rpc_method .= ':autocmd:'.name.':'.get(opts, 'pattern', '*') | |
line 31: call remote#define#AutocmdOnHost(a:host, rpc_method, sync, name, opts) | |
line 32: elseif type == 'function' | |
line 33: let rpc_method .= ':function:'.name | |
line 34: call remote#define#FunctionOnHost(a:host, rpc_method, sync, name, opts) | |
line 35: else | |
line 36: echoerr 'Invalid declaration type: '.type | |
line 37: endif | |
line 38: endfor | |
line 39: | |
line 40: call add(plugins, {'path': a:path, 'specs': a:specs}) | |
function remote#host#RegisterPlugin returning #0 | |
continuing in /Users/nhooyr/scratch/.-rplugin~ | |
line 5: | |
line 6: | |
line 7: " python plugins | |
line 8: | |
line 9: | |
finished sourcing ./.-rplugin~ | |
continuing in function remote#host#LoadRemotePlugins | |
line 3: endif | |
function remote#host#LoadRemotePlugins returning #0 | |
continuing in /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rplugin.vim | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rplugin.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rrhelper.vim" | |
line 1: " Vim plugin with helper function(s) for --remote-wait | |
line 2: " Maintainer: Flemming Madsen <[email protected]> | |
line 3: " Last Change: 2008 May 29 | |
line 4: | |
line 5: " Has this already been loaded? | |
line 6: if exists("loaded_rrhelper") || !has("clientserver") | |
line 7: finish | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/rrhelper.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/shada.vim" | |
line 1: if exists('g:loaded_shada_plugin') | |
line 2: finish | |
line 3: endif | |
line 4: let g:loaded_shada_plugin = 1 | |
line 5: | |
line 6: augroup ShaDaCommands | |
line 7: autocmd! | |
line 11: autocmd BufReadCmd *.shada,*.shada.tmp.[a-z] :if !empty(v:cmdarg)|throw '++opt not supported'|endif |call setline('.', shada#get_strings(readfile(expand('<afile>'),'b'))) |setlocal filetype=shada | |
line 14: autocmd FileReadCmd *.shada,*.shada.tmp.[a-z] :if !empty(v:cmdarg)|throw '++opt not supported'|endif |call append("'[", shada#get_strings(readfile(expand('<afile>'), 'b'))) | |
line 22: autocmd BufWriteCmd *.shada,*.shada.tmp.[a-z] :if !empty(v:cmdarg)|throw '++opt not supported'|endif |if writefile(shada#get_binstrings(getline(1, '$')),expand('<afile>'), 'b') == 0 | let &l:modified = (expand('<afile>') is# bufname(+expand('<abuf>'))? 0: stridx(&cpoptions, '+') != -1) |endif | |
line 29: autocmd FileWriteCmd *.shada,*.shada.tmp.[a-z] :if !empty(v:cmdarg)|throw '++opt not supported'|endif |call writefile(shada#get_binstrings(getline(min([line("'["), line("']")]),max([line("'["), line("']")]))),expand('<afile>'),'b') | |
line 36: autocmd FileAppendCmd *.shada,*.shada.tmp.[a-z] :if !empty(v:cmdarg)|throw '++opt not supported'|endif |call writefile(shada#get_binstrings(getline(min([line("'["), line("']")]),max([line("'["), line("']")]))),expand('<afile>'),'ab') | |
line 38: autocmd SourceCmd *.shada,*.shada.tmp.[a-z] :execute 'rshada' fnameescape(expand('<afile>')) | |
line 39: augroup END | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/shada.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/spellfile.vim" | |
line 1: " Vim plugin for downloading spell files | |
line 2: " Maintainer: Bram Moolenaar <[email protected]> | |
line 3: " Last Change: 2006 Feb 01 | |
line 4: | |
line 5: " Exit quickly when: | |
line 6: " - this plugin was already loaded | |
line 7: " - when 'compatible' is set | |
line 8: " - some autocommands are already taking care of spell files | |
line 9: if exists("loaded_spellfile_plugin") || &cp || exists("#SpellFileMissing") | |
line 10: finish | |
line 11: endif | |
line 12: let loaded_spellfile_plugin = 1 | |
line 13: | |
line 14: " The function is in the autoload directory. | |
line 15: autocmd SpellFileMissing * call spellfile#LoadFile(expand('<amatch>')) | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/spellfile.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tarPlugin.vim" | |
line 1: " tarPlugin.vim -- a Vim plugin for browsing tarfiles | |
line 2: " Original was copyright (c) 2002, Michael C. Toren <[email protected]> | |
line 3: " Modified by Charles E. Campbell | |
line 4: " Distributed under the GNU General Public License. | |
line 5: " | |
line 6: " Updates are available from <http://michael.toren.net/code/>. If you | |
line 7: " find this script useful, or have suggestions for improvements, please | |
line 8: " let me know. | |
line 9: " Also look there for further comments and documentation. | |
line 10: " | |
line 11: " This part only sets the autocommands. The functions are in autoload/tar.vim. | |
line 12: " --------------------------------------------------------------------- | |
line 13: " Load Once: {{{1 | |
line 14: if &cp || exists("g:loaded_tarPlugin") | |
line 15: finish | |
line 16: endif | |
line 17: let g:loaded_tarPlugin = "v29" | |
line 18: let s:keepcpo = &cpo | |
line 19: set cpo&vim | |
line 20: | |
line 21: " --------------------------------------------------------------------- | |
line 22: " Public Interface: {{{1 | |
line 23: augroup tar | |
line 24: au! | |
line 25: au BufReadCmd tarfile::*^Icall tar#Read(expand("<amatch>"), 1) | |
line 26: au FileReadCmd tarfile::*^Icall tar#Read(expand("<amatch>"), 0) | |
line 27: au BufWriteCmd tarfile::*^Icall tar#Write(expand("<amatch>")) | |
line 28: au FileWriteCmd tarfile::*^Icall tar#Write(expand("<amatch>")) | |
line 29: | |
line 30: if has("unix") | |
line 31: au BufReadCmd tarfile::*/*^Icall tar#Read(expand("<amatch>"), 1) | |
line 32: au FileReadCmd tarfile::*/*^Icall tar#Read(expand("<amatch>"), 0) | |
line 33: au BufWriteCmd tarfile::*/*^Icall tar#Write(expand("<amatch>")) | |
line 34: au FileWriteCmd tarfile::*/*^Icall tar#Write(expand("<amatch>")) | |
line 35: endif | |
line 36: | |
line 37: au BufReadCmd *.tar.gz^I^Icall tar#Browse(expand("<amatch>")) | |
line 38: au BufReadCmd *.tar^I^I^Icall tar#Browse(expand("<amatch>")) | |
line 39: au BufReadCmd *.lrp^I^I^Icall tar#Browse(expand("<amatch>")) | |
line 40: au BufReadCmd *.tar.bz2^I^Icall tar#Browse(expand("<amatch>")) | |
line 41: au BufReadCmd *.tar.Z^I^Icall tar#Browse(expand("<amatch>")) | |
line 42: au BufReadCmd *.tgz^I^I^Icall tar#Browse(expand("<amatch>")) | |
line 43: au BufReadCmd *.tar.lzma^Icall tar#Browse(expand("<amatch>")) | |
line 44: au BufReadCmd *.tar.xz^I^Icall tar#Browse(expand("<amatch>")) | |
line 45: au BufReadCmd *.txz^I^I^Icall tar#Browse(expand("<amatch>")) | |
line 46: augroup END | |
line 47: com! -nargs=? -complete=file Vimuntar call tar#Vimuntar(<q-args>) | |
line 48: | |
line 49: " --------------------------------------------------------------------- | |
line 50: " Restoration And Modelines: {{{1 | |
line 51: " vim: fdm=marker | |
line 52: let &cpo= s:keepcpo | |
line 53: unlet s:keepcpo | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tarPlugin.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tohtml.vim" | |
line 1: " Vim plugin for converting a syntax highlighted file to HTML. | |
line 2: " Maintainer: Ben Fritz <[email protected]> | |
line 3: " Last Change: 2013 Jul 08 | |
line 4: " | |
line 5: " The core of the code is in $VIMRUNTIME/autoload/tohtml.vim and | |
line 6: " $VIMRUNTIME/syntax/2html.vim | |
line 7: " | |
line 8: " TODO: {{{ | |
line 9: " * Options for generating the CSS in external style sheets. New :TOcss | |
line 10: " command to convert the current color scheme into a (mostly) generic CSS | |
line 11: " stylesheet which can be re-used. Alternate stylesheet support? Good start | |
line 12: " by Erik Falor | |
line 13: " ( https://groups.google.com/d/topic/vim_use/7XTmC4D22dU/discussion ). | |
line 14: " * Add optional argument to :TOhtml command to specify mode (gui, cterm, | |
line 15: " term) to use for the styling. Suggestion by "nacitar". | |
line 16: " * Add way to override or specify which RGB colors map to the color numbers | |
line 17: " in cterm. Get better defaults than just guessing? Suggestion by "nacitar". | |
line 18: " * Disable filetype detection until after all processing is done. | |
line 19: " * Add option for not generating the hyperlink on stuff that looks like a | |
line 20: " URL? Or just color the link to fit with the colorscheme (and only special | |
line 21: " when hovering)? | |
line 22: " * Bug: Opera does not allow printing more than one page if uncopyable | |
line 23: " regions is turned on. Possible solution: Add normal text line numbers with | |
line 24: " display:none, set to display:inline for print style sheets, and hide | |
line 25: " <input> elements for print, to allow Opera printing multiple pages (and | |
line 26: " other uncopyable areas?). May need to make the new text invisible to IE | |
line 27: " with conditional comments to prevent copying it, IE for some reason likes | |
line 28: " to copy hidden text. Other browsers too? | |
line 29: " * Bug: still a 1px gap throughout the fold column when html_prevent_copy is | |
line 30: " "fn" in some browsers. Specifically, in Chromium on Ubuntu (but not Chrome | |
line 31: " on Windows). Perhaps it is font related? | |
line 32: " * Bug: still some gaps in the fold column when html_prevent_copy contains | |
line 33: " 'd' and showing the whole diff (observed in multiple browsers). Only gaps | |
line 34: " on diff lines though. | |
line 35: " * Undercurl support via CSS3, with fallback to dotted or something: | |
line 36: "^Ihttps://groups.google.com/d/topic/vim_use/BzXA6He1pHg/discussion | |
line 37: " * Redo updates for modified default foldtext (v11) when/if the patch is | |
line 38: " accepted to modify it. | |
line 39: " * Test case +diff_one_file-dynamic_folds+expand_tabs-hover_unfold | |
line 40: "^I^I+ignore_conceal-ignore_folding+no_foldcolumn+no_pre+no_progress | |
line 41: "^I^I+number_lines-pre_wrap-use_css+use_xhtml+whole_filler.xhtml | |
line 42: " does not show the whole diff filler as it is supposed to? | |
line 43: " * Bug: when 'isprint' is wrong for the current encoding, will generate | |
line 44: " invalid content. Can/should anything be done about this? Maybe a separate | |
line 45: " plugin to correct 'isprint' based on encoding? | |
line 46: " * Check to see if the windows-125\d encodings actually work in Unix without | |
line 47: " the 8bit- prefix. Add prefix to autoload dictionaries for Unix if not. | |
line 48: " * Font auto-detection similar to | |
line 49: " http://www.vim.org/scripts/script.php?script_id=2384 but for a variety of | |
line 50: " platforms. | |
line 51: " * Error thrown when sourcing 2html.vim directly when plugins are not loaded. | |
line 52: " * Pull in code from http://www.vim.org/scripts/script.php?script_id=3113 : | |
line 53: "^I- listchars support | |
line 54: "^I- full-line background highlight | |
line 55: "^I- other? | |
line 56: " * Make it so deleted lines in a diff don't create side-scrolling (get it | |
line 57: " free with full-line background highlight above). | |
line 58: " * Restore open/closed folds and cursor position after processing each file | |
line 59: " with option not to restore for speed increase. | |
line 60: " * Add extra meta info (generation time, etc.)? | |
line 61: " * Tidy up so we can use strict doctype in even more situations | |
line 62: " * Implementation detail: add threshold for writing the lines to the html | |
line 63: " buffer before we're done (5000 or so lines should do it) | |
line 64: " * TODO comments for code cleanup scattered throughout | |
line 65: "}}} | |
line 66: | |
line 67: if exists('g:loaded_2html_plugin') | |
line 68: finish | |
line 69: endif | |
line 70: let g:loaded_2html_plugin = 'vim7.4_v1' | |
line 71: | |
line 72: " | |
line 73: " Changelog: {{{ | |
line 74: " 7.4_v1 (this version): Fix modeline mangling for new "Vim:" format, and | |
line 75: "^I^I^I also for version-specific modelines like "vim>703:". | |
line 76: " | |
line 77: " 7.3 updates: {{{ | |
line 78: " 7.3_v14 (ad6996a23e3e): Allow suppressing line number anchors using | |
line 79: "^I^I^I g:html_line_ids=0. Allow customizing | |
line 80: "^I^I^I important IDs (like line IDs and fold IDs) using | |
line 81: "^I^I^I g:html_id_expr evalutated when the buffer conversion | |
line 82: "^I^I^I is started. | |
line 83: " 7.3_v13 (2eb30f341e8d): Keep foldmethod at manual in the generated file and | |
line 84: "^I^I^I insert modeline to set it to manual. | |
line 85: "^I^I^I Fix bug: diff mode with 2 unsaved buffers creates a | |
line 86: "^I^I^I duplicate of one buffer instead of including both. | |
line 87: "^I^I^I Add anchors to each line so you can put '#L123' | |
line 88: "^I^I^I or '#123' at the end of the URL to jump to line 123 | |
line 89: "^I^I^I (idea by Andy Spencer). Add javascript to open folds | |
line 90: "^I^I^I to show the anchor being jumped to if it is hidden. | |
line 91: "^I^I^I Fix XML validation error: &nsbp; not part of XML. | |
line 92: "^I^I^I Allow TOhtml to chain together with other commands | |
line 93: "^I^I^I using |. | |
line 94: " 7.3_v12 (9910cbff5f16): Fix modeline mangling to also work for when multiple | |
line 95: "^I^I^I highlight groups make up the start-of-modeline text. | |
line 96: "^I^I^I Improve render time of page with uncopyable regions | |
line 97: "^I^I^I by not using one-input-per-char. Change name of | |
line 98: "^I^I^I uncopyable option from html_unselectable to | |
line 99: "^I^I^I html_prevent_copy. Added html_no_invalid option and | |
line 100: "^I^I^I default to inserting invalid markup for uncopyable | |
line 101: "^I^I^I regions to prevent MS Word from pasting undeletable | |
line 102: "^I^I^I <input> elements. Fix 'cpo' handling (Thilo Six). | |
line 103: "^I^I 7.3_v12b1: Add html_unselectable option. Rework logic to | |
line 104: "^I^I^I eliminate post-processing substitute commands in | |
line 105: "^I^I^I favor of doing the work up front. Remove unnecessary | |
line 106: "^I^I^I special treatment of 'LineNr' highlight group. Minor | |
line 107: "^I^I^I speed improvements. Fix modeline mangling in | |
line 108: "^I^I^I generated output so it works for text in the first | |
line 109: "^I^I^I column. Fix missing line number and fold column in | |
line 110: "^I^I^I diff filler lines. Fix that some fonts have a 1px | |
line 111: "^I^I^I gap (using a dirty hack, improvements welcome). Add | |
line 112: "^I^I^I "colorscheme" meta tag. Does NOT include support for | |
line 113: "^I^I^I the new default foldtext added in v11, as the patch | |
line 114: "^I^I^I adding it has not yet been included in Vim. | |
line 115: " 7.3_v11 ( unreleased ): Support new default foldtext from patch by Christian | |
line 116: "^I^I^I Brabandt in | |
line 117: "^I^I^I http://groups.google.com/d/topic/vim_dev/B6FSGfq9VoI/discussion. | |
line 118: "^I^I^I This patch has not yet been included in Vim, thus | |
line 119: "^I^I^I these changes are removed in the next version. | |
line 120: " 7.3_v10 (fd09a9c8468e): Fix error E684 when converting a range wholly inside | |
line 121: "^I^I^I multiple nested folds with dynamic folding on. | |
line 122: "^I^I^I Also fix problem with foldtext in this situation. | |
line 123: " 7.3_v9 (0877b8d6370e): Add html_pre_wrap option active with html_use_css | |
line 124: "^I^I^I and without html_no_pre, default value same as | |
line 125: "^I^I^I 'wrap' option, (Andy Spencer). Don't use | |
line 126: "^I^I^I 'fileencoding' for converted document encoding if | |
line 127: "^I^I^I 'buftype' indicates a special buffer which isn't | |
line 128: "^I^I^I written. | |
line 129: " 7.3_v8 (85c5a72551e2): Add html_expand_tabs option to allow leaving tab | |
line 130: "^I^I^I characters in generated output (Andy Spencer). | |
line 131: "^I^I^I Escape text that looks like a modeline so Vim | |
line 132: "^I^I^I doesn't use anything in the converted HTML as a | |
line 133: "^I^I^I modeline. Bugfixes: Fix folding when a fold starts | |
line 134: "^I^I^I before the conversion range. Remove fold column when | |
line 135: "^I^I^I there are no folds. | |
line 136: " 7.3_v7 (840c3cadb842): see betas released on vim_dev below: | |
line 137: "^I^I 7.3_v7b3: Fixed bug, convert Unicode to UTF-8 all the way. | |
line 138: "^I^I 7.3_v7b2: Remove automatic detection of encodings that are not | |
line 139: "^I^I^I supported by all major browsers according to | |
line 140: "^I^I^I http://wiki.whatwg.org/wiki/Web_Encodings and | |
line 141: "^I^I^I convert to UTF-8 for all Unicode encodings. Make | |
line 142: "^I^I^I HTML encoding to Vim encoding detection be | |
line 143: "^I^I^I case-insensitive for built-in pairs. | |
line 144: "^I^I 7.3_v7b1: Remove use of setwinvar() function which cannot be | |
line 145: "^I^I^I called in restricted mode (Andy Spencer). Use | |
line 146: "^I^I^I 'fencoding' instead of 'encoding' to determine by | |
line 147: "^I^I^I charset, and make sure the 'fenc' of the generated | |
line 148: "^I^I^I file matches its indicated charset. Add charsets for | |
line 149: "^I^I^I all of Vim's natively supported encodings. | |
line 150: " 7.3_v6 (0d3f0e3d289b): Really fix bug with 'nowrapscan', 'magic' and other | |
line 151: "^I^I^I user settings interfering with diff mode generation, | |
line 152: "^I^I^I trailing whitespace (e.g. line number column) when | |
line 153: "^I^I^I using html_no_pre, and bugs when using | |
line 154: "^I^I^I html_hover_unfold. | |
line 155: " 7.3_v5 ( unreleased ): Fix bug with 'nowrapscan' and also with out-of-sync | |
line 156: "^I^I^I folds in diff mode when first line was folded. | |
line 157: " 7.3_v4 (7e008c174cc3): Bugfixes, especially for xhtml markup, and diff mode | |
line 158: " 7.3_v3 (a29075150aee): Refactor option handling and make html_use_css | |
line 159: "^I^I^I default to true when not set to anything. Use strict | |
line 160: "^I^I^I doctypes where possible. Rename use_xhtml option to | |
line 161: "^I^I^I html_use_xhtml for consistency. Use .xhtml extension | |
line 162: "^I^I^I when using this option. Add meta tag for settings. | |
line 163: " 7.3_v2 (80229a724a11): Fix syntax highlighting in diff mode to use both the | |
line 164: "^I^I^I diff colors and the normal syntax colors | |
line 165: " 7.3_v1 (e7751177126b): Add conceal support and meta tags in output | |
line 166: " Pre-v1 baseline: Mercurial changeset 3c9324c0800e | |
line 167: "}}} | |
line 168: "}}} | |
line 169: | |
line 170: " Define the :TOhtml command when: | |
line 171: " - 'compatible' is not set | |
line 172: " - this plugin was not already loaded | |
line 173: " - user commands are available. {{{ | |
line 174: if !&cp && !exists(":TOhtml") && has("user_commands") | |
line 175: command -range=% -bar TOhtml :call tohtml#Convert2HTML(<line1>, <line2>) | |
line 176: endif "}}} | |
line 177: | |
line 178: " Make sure any patches will probably use consistent indent | |
line 179: " vim: ts=8 sw=2 sts=2 noet fdm=marker | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tohtml.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tutor.vim" | |
line 1: if exists('g:loaded_tutor_mode_plugin') || &compatible | |
line 2: finish | |
line 3: endif | |
line 4: let g:loaded_tutor_mode_plugin = 1 | |
line 5: | |
line 6: command! -nargs=? -complete=custom,tutor#TutorCmdComplete Tutor call tutor#TutorCmd(<q-args>) | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/tutor.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/vimballPlugin.vim" | |
line 1: " vimballPlugin : construct a file containing both paths and files | |
line 2: " Author: Charles E. Campbell, Jr. | |
line 3: " Copyright: (c) 2004-2010 by Charles E. Campbell, Jr. | |
line 4: " The VIM LICENSE applies to Vimball.vim, and Vimball.txt | |
line 5: " (see |copyright|) except use "Vimball" instead of "Vim". | |
line 6: " No warranty, express or implied. | |
line 7: " *** *** Use At-Your-Own-Risk! *** *** | |
line 8: " | |
line 9: " (Rom 2:1 WEB) Therefore you are without excuse, O man, whoever you are who | |
line 10: " judge. For in that which you judge another, you condemn yourself. For | |
line 11: " you who judge practice the same things. | |
line 12: " GetLatestVimScripts: 1502 1 :AutoInstall: vimball.vim | |
line 13: | |
line 14: " --------------------------------------------------------------------- | |
line 15: " Load Once: {{{1 | |
line 16: if &cp || exists("g:loaded_vimballPlugin") | |
line 17: finish | |
line 18: endif | |
line 19: let g:loaded_vimballPlugin = "v35" | |
line 20: let s:keepcpo = &cpo | |
line 21: set cpo&vim | |
line 22: | |
line 23: " ------------------------------------------------------------------------------ | |
line 24: " Public Interface: {{{1 | |
line 25: com! -ra -complete=file -na=+ -bang MkVimball^I^I^I^Icall vimball#MkVimball(<line1>,<line2>,<bang>0,<f-args>) | |
line 26: com! -na=? -complete=dir UseVimball^I^I^I^I^I^Icall vimball#Vimball(1,<f-args>) | |
line 27: com! -na=0 VimballList^I^I^I^I^I^Icall vimball#Vimball(0) | |
line 28: com! -na=* -complete=dir RmVimball^I^I^I^I^I^I^Icall vimball#SaveSettings()|call vimball#RmVimball(<f-args>)|call vimball#RestoreSettings() | |
line 29: au BufEnter *.vba,*.vba.gz,*.vba.bz2,*.vba.zip,*.vba.xz^Isetlocal bt=nofile fmr=[[[,]]] fdm=marker|if &ff != 'unix'|setlocal ma ff=unix noma|endif|call vimball#ShowMesg(0,"Source this file to extract it! (:so %)") | |
line 30: au SourceCmd *.vba.gz,*.vba.bz2,*.vba.zip,*.vba.xz^I^I^Iif expand("%")!=expand("<afile>") | exe "1sp" fnameescape(expand("<afile>"))|endif|call vimball#Decompress(expand("<amatch>"))|so %|if expand("%")!=expand("<afile>")|close|endif | |
line 31: au SourceCmd *.vba^I^I^I^I^I^I^I^I^I^I^Iif expand("%")!=expand("<afile>") | exe "1sp" fnameescape(expand("<afile>"))|call vimball#Vimball(1)|close|else|call vimball#Vimball(1)|endif | |
line 32: au BufEnter *.vmb,*.vmb.gz,*.vmb.bz2,*.vmb.zip,*.vmb.xz^Isetlocal bt=nofile fmr=[[[,]]] fdm=marker|if &ff != 'unix'|setlocal ma ff=unix noma|endif|call vimball#ShowMesg(0,"Source this file to extract it! (:so %)") | |
line 33: au SourceCmd *.vmb.gz,*.vmb.bz2,*.vmb.zip,*.vmb.xz^I^I^Iif expand("%")!=expand("<afile>") | exe "1sp" fnameescape(expand("<afile>"))|endif|call vimball#Decompress(expand("<amatch>"))|so %|if expand("%")!=expand("<afile>")|close|endif | |
line 34: au SourceCmd *.vmb^I^I^I^I^I^I^I^I^I^I^Iif expand("%")!=expand("<afile>") | exe "1sp" fnameescape(expand("<afile>"))|call vimball#Vimball(1)|close|else|call vimball#Vimball(1)|endif | |
line 35: | |
line 36: " ===================================================================== | |
line 37: " Restoration And Modelines: {{{1 | |
line 38: " vim: fdm=marker | |
line 39: let &cpo= s:keepcpo | |
line 40: unlet s:keepcpo | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/vimballPlugin.vim | |
chdir(/Users/nhooyr/scratch) | |
chdir(/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/scratch) | |
sourcing "/usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/zipPlugin.vim" | |
line 1: " zipPlugin.vim: Handles browsing zipfiles | |
line 2: " PLUGIN PORTION | |
line 3: " Date:^I^I^IJun 07, 2013 | |
line 4: " Maintainer:^ICharles E Campbell <[email protected]> | |
line 5: " License:^I^IVim License (see vim's :help license) | |
line 6: " Copyright: Copyright (C) 2005-2013 Charles E. Campbell {{{1 | |
line 7: " Permission is hereby granted to use and distribute this code, | |
line 8: " with or without modifications, provided that this copyright | |
line 9: " notice is copied with it. Like anything else that's free, | |
line 10: " zipPlugin.vim is provided *as is* and comes with no warranty | |
line 11: " of any kind, either expressed or implied. By using this | |
line 12: " plugin, you agree that in no event will the copyright | |
line 13: " holder be liable for any damages resulting from the use | |
line 14: " of this software. | |
line 15: " | |
line 16: " (James 4:8 WEB) Draw near to God, and he will draw near to you. | |
line 17: " Cleanse your hands, you sinners; and purify your hearts, you double-minded. | |
line 18: " --------------------------------------------------------------------- | |
line 19: " Load Once: {{{1 | |
line 20: if &cp || exists("g:loaded_zipPlugin") | |
line 21: finish | |
line 22: endif | |
line 23: let g:loaded_zipPlugin = "v27" | |
line 24: let s:keepcpo = &cpo | |
line 25: set cpo&vim | |
line 26: | |
line 27: " --------------------------------------------------------------------- | |
line 28: " Options: {{{1 | |
line 29: if !exists("g:zipPlugin_ext") | |
line 30: let g:zipPlugin_ext= '*.zip,*.jar,*.xpi,*.ja,*.war,*.ear,*.celzip,*.oxt,*.kmz,*.wsz,*.xap,*.docx,*.docm,*.dotx,*.dotm,*.potx,*.potm,*.ppsx,*.ppsm,*.pptx,*.pptm,*.ppam,*.sldx,*.thmx,*.xlam,*.xlsx,*.xlsm,*.xlsb,*.xltx,*.xltm,*.xlam,*.crtx,*.vdw,*.glox,*.gcsx,*.gqsx' | |
line 31: endif | |
line 32: | |
line 33: " --------------------------------------------------------------------- | |
line 34: " Public Interface: {{{1 | |
line 35: augroup zip | |
line 36: au! | |
line 37: au BufReadCmd zipfile:*^Icall zip#Read(expand("<amatch>"), 1) | |
line 38: au FileReadCmd zipfile:*^Icall zip#Read(expand("<amatch>"), 0) | |
line 39: au BufWriteCmd zipfile:*^Icall zip#Write(expand("<amatch>")) | |
line 40: au FileWriteCmd zipfile:*^Icall zip#Write(expand("<amatch>")) | |
line 41: | |
line 42: if has("unix") | |
line 43: au BufReadCmd zipfile:*/*^Icall zip#Read(expand("<amatch>"), 1) | |
line 44: au FileReadCmd zipfile:*/*^Icall zip#Read(expand("<amatch>"), 0) | |
line 45: au BufWriteCmd zipfile:*/*^Icall zip#Write(expand("<amatch>")) | |
line 46: au FileWriteCmd zipfile:*/*^Icall zip#Write(expand("<amatch>")) | |
line 47: endif | |
line 48: | |
line 49: exe "au BufReadCmd ".g:zipPlugin_ext.' call zip#Browse(expand("<amatch>"))' | |
line 49: au BufReadCmd *.zip,*.jar,*.xpi,*.ja,*.war,*.ear,*.celzip,*.oxt,*.kmz,*.wsz,*.xap,*.docx,*.docm,*.dotx,*.dotm,*.potx,*.potm,*.ppsx,*.ppsm,*.pptx,*.pptm,*.ppam,*.sldx,*.thmx,*.xlam,*.xlsx,*.xlsm,*.xlsb,*.xltx,*.xltm,*.xlam,*.crtx,*.vdw,*.glox,*.gcsx,*.gqsx call zip#Browse(expand("<amatch>")) | |
line 50: augroup END | |
line 51: | |
line 52: " --------------------------------------------------------------------- | |
line 53: " Restoration And Modelines: {{{1 | |
line 54: " vim: fdm=marker | |
line 55: let &cpo= s:keepcpo | |
line 56: unlet s:keepcpo | |
finished sourcing /usr/local/Cellar/neovim/HEAD/share/nvim/runtime/plugin/zipPlugin.vim | |
Searching for "/usr/share/nvim/site/after/plugin/**/*.vim" | |
Searching for "/usr/local/share/nvim/site/after/plugin/**/*.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/plugin/**/*.vim" | |
Searching for "/etc/xdg/nvim/after/plugin/**/*.vim" | |
Searching for "/usr/local/etc/dotfiles/nvim/after/plugin/**/*.vim" | |
Reading ShaDa file "/Users/nhooyr/.local/share/nvim/shada/main.shada" info marks oldfiles | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing VimEnter Auto commands for "*" | |
autocommand sil call s:VimEnter(expand("<amatch>")) | |
line 0: sil call s:VimEnter(expand("<amatch>")) | |
calling function <SNR>6_VimEnter('') | |
line 1: " call Dfunc("s:VimEnter(dirname<".a:dirname.">) expand(%)<".expand("%").">") | |
line 2: let curwin = winnr() | |
line 3: let s:vimentered = 1 | |
line 4: windo call s:LocalBrowse(expand("%:p")) | |
line 4: call s:LocalBrowse(expand("%:p")) | |
calling function <SNR>6_VimEnter..<SNR>6_LocalBrowse('') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_VimEnter..<SNR>6_LocalBrowse returning #0 | |
continuing in function <SNR>6_VimEnter | |
line 5: exe curwin."wincmd w" | |
line 5: 1wincmd w | |
line 6: " call Dret("s:VimEnter") | |
function <SNR>6_VimEnter returning #0 | |
continuing in VimEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing BufReadCmd Auto commands for "term://*" | |
autocommand :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
line 0: :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60634:./neogo') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing BufReadCmd Auto commands for "term://*" | |
autocommand :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
line 0: :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60635:./neogo') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
-- VISUAL -- | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing BufReadCmd Auto commands for "term://*" | |
autocommand :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
line 0: :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60636:/usr/local/bin/zsh') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing BufReadCmd Auto commands for "term://*" | |
autocommand :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
line 0: :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60654:/usr/local/bin/zsh') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing BufReadCmd Auto commands for "term://*" | |
autocommand :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
line 0: :call termopen( matchstr(expand("<amatch>"), '\c\mterm://\%(.\{-}//\%(\d\+:\)\?\)\?\zs.*'), {'cwd': get(matchlist(expand("<amatch>"), '\c\mterm://\(.\{-}\)//'), 1, '')}) | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60672:/usr/local/bin/zsh') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: " Figure out the arguments for searchpairpos(). | |
line 36: if i % 2 == 0 | |
line 37: let s_flags = 'nW' | |
line 38: let c2 = plist[i + 1] | |
line 39: else | |
line 40: let s_flags = 'nbW' | |
line 41: let c2 = c | |
line 42: let c = plist[i - 1] | |
line 43: endif | |
line 44: if c == '[' | |
line 45: let c = '\[' | |
line 46: let c2 = '\]' | |
line 47: endif | |
line 48: | |
line 49: " Find the match. When it was just before the cursor move it there for a | |
line 50: " moment. | |
line 51: if before > 0 | |
line 52: let has_getcurpos = exists("*getcurpos") | |
line 53: if has_getcurpos | |
line 54: " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
line 55: let save_cursor = getcurpos() | |
line 56: else | |
line 57: let save_cursor = winsaveview() | |
line 58: endif | |
line 59: call cursor(c_lnum, c_col - before) | |
line 60: endif | |
line 61: | |
line 62: " Build an expression that detects whether the current cursor position is in | |
line 63: " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
line 64: " skip argument. | |
line 65: " We match "escape" for special items, such as lispEscapeSpecial. | |
line 66: let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
line 68: " If executing the expression determines that the cursor is currently in | |
line 69: " one of the syntax types, then we want searchpairpos() to find the pair | |
line 70: " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
line 71: " outside of the syntax types and s_skip should keep its value so we skip any | |
line 72: " matching pair inside the syntax types. | |
line 73: execute 'if' s_skip '| let s_skip = 0 | endif' | |
line 73: if !empty(filter(map(synstack(line("."), col(".")), 'synIDattr(v:val, "name")'), 'v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"')) | let s_skip = 0 | endif | |
line 73: let s_skip = 0 | endif | |
line 73: endif | |
line 74: | |
line 75: " Limit the search to lines visible in the window. | |
line 76: let stoplinebottom = line('w$') | |
line 77: let stoplinetop = line('w0') | |
line 78: if i % 2 == 0 | |
line 79: let stopline = stoplinebottom | |
line 80: else | |
line 81: let stopline = stoplinetop | |
line 82: endif | |
line 83: | |
line 84: " Limit the search time to 300 msec to avoid a hang on very long lines. | |
line 85: " This fails when a timeout is not supported. | |
line 86: if mode() == 'i' || mode() == 'R' | |
line 87: let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
line 88: else | |
line 89: let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
line 90: endif | |
line 91: try | |
line 92: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
line 93: catch /E118/ | |
line 94: " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
line 95: " a long time on closed folds and long lines. | |
line 96: " The "viewable" variables give a range in which we can scroll while | |
line 97: " keeping the cursor at the same position. | |
line 98: " adjustedScrolloff accounts for very large numbers of scrolloff. | |
line 99: let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
line 100: let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
line 101: let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
line 102: " one of these stoplines will be adjusted below, but the current values are | |
line 103: " minimal boundaries within the current window | |
line 104: if i % 2 == 0 | |
line 105: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 106: ^Ilet stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
line 107: ^Ilet stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
line 108: else | |
line 109: ^Ilet stopline = min([bottom_viewable, c_lnum + 100]) | |
line 110: endif | |
line 111: let stoplinebottom = stopline | |
line 112: else | |
line 113: if has("byte_offset") && has("syntax_items") && &smc > 0 | |
line 114: ^Ilet stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
line 115: ^Ilet stopline = max([top_viewable, byte2line(stopbyte)]) | |
line 116: else | |
line 117: ^Ilet stopline = max([top_viewable, c_lnum - 100]) | |
line 118: endif | |
line 119: let stoplinetop = stopline | |
line 120: endif | |
line 121: let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
line 122: endtry | |
line 123: | |
line 124: if before > 0 | |
line 125: if has_getcurpos | |
line 126: call setpos('.', save_cursor) | |
line 127: else | |
line 128: call winrestview(save_cursor) | |
line 129: endif | |
line 130: endif | |
line 131: | |
line 132: " If a match is found setup match highlighting. | |
line 133: if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
line 134: if exists('*matchaddpos') | |
line 135: call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
line 136: else | |
line 137: exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
line 139: endif | |
line 140: let w:paren_hl_on = 1 | |
line 141: endif | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
-- TERMINAL -- | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60654:/usr/local/bin/zsh') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
-- TERMINAL -- | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60636:/usr/local/bin/zsh') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing TextChanged Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChanged Auto commands for "*" | |
-- TERMINAL -- | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60635:./neogo') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
-- TERMINAL -- | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('term://.//60634:./neogo') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
-- TERMINAL -- | |
Executing BufLeave Auto commands for "*" | |
autocommand if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: if &ft != "netrw"|let w:netrw_prvfile= expand("%:p")|endif | |
line 0: let w:netrw_prvfile= expand("%:p")|endif | |
line 0: endif | |
Executing WinEnter Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in WinEnter Auto commands for "*" | |
Executing BufEnter Auto commands for "*" | |
autocommand sil call s:LocalBrowse(expand("<amatch>")) | |
line 0: sil call s:LocalBrowse(expand("<amatch>")) | |
calling function <SNR>6_LocalBrowse('') | |
line 1: " Unfortunate interaction -- only DechoMsg debugging calls can be safely used here. | |
line 2: " Otherwise, the BufEnter event gets triggered when attempts to write to | |
line 3: " the DBG buffer are made. | |
line 4: | |
line 5: if !exists("s:vimentered") | |
line 6: " If s:vimentered doesn't exist, then the VimEnter event hasn't fired. It will, | |
line 7: " and so s:VimEnter() will then be calling this routine, but this time with s:vimentered defined. | |
line 8: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered doesn't exist)") | |
line 9: " call Dret("s:LocalBrowse") | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " call Dfunc("s:LocalBrowse(dirname<".a:dirname.">) (s:vimentered=".s:vimentered.")") | |
line 14: | |
line 15: if has("amiga") | |
line 16: " The check against '' is made for the Amiga, where the empty | |
line 17: " string is the current directory and not checking would break | |
line 18: " things such as the help command. | |
line 19: " call Decho("(LocalBrowse) dirname<".a:dirname."> (isdirectory, amiga)") | |
line 20: if a:dirname != '' && isdirectory(a:dirname) | |
line 21: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 22: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 23: exe w:netrw_bannercnt | |
line 24: endif | |
line 25: endif | |
line 26: | |
line 27: elseif isdirectory(a:dirname) | |
line 28: " call Decho("(LocalBrowse) dirname<".a:dirname."> ft=".&ft." (isdirectory, not amiga)") | |
line 29: " call Dredir("LocalBrowse ft last set: ","verbose set ft") | |
line 30: sil! call netrw#LocalBrowseCheck(a:dirname) | |
line 31: if exists("w:netrw_bannercnt") && line('.') < w:netrw_bannercnt | |
line 32: exe w:netrw_bannercnt | |
line 33: endif | |
line 34: | |
line 35: else | |
line 36: " not a directory, ignore it | |
line 37: " call Decho("(LocalBrowse) dirname<".a:dirname."> not a directory, ignoring...") | |
line 38: endif | |
line 39: | |
line 40: " call Dret("s:LocalBrowse") | |
function <SNR>6_LocalBrowse returning #0 | |
continuing in BufEnter Auto commands for "*" | |
Executing CursorMoved Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMoved Auto commands for "*" | |
-- INSERT -- | |
Executing CursorMovedI Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in CursorMovedI Auto commands for "*" | |
Executing TextChangedI Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exists('w:paren_hl_on') && w:paren_hl_on | |
line 3: silent! call matchdelete(3) | |
line 4: let w:paren_hl_on = 0 | |
line 5: endif | |
line 6: | |
line 7: " Avoid that we remove the popup menu. | |
line 8: " Return when there are no colors (looks like the cursor jumps). | |
line 9: if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
line 10: return | |
line 11: endif | |
line 12: | |
line 13: " Get the character under the cursor and check if it's in 'matchpairs'. | |
line 14: let c_lnum = line('.') | |
line 15: let c_col = col('.') | |
line 16: let before = 0 | |
line 17: | |
line 18: let text = getline(c_lnum) | |
line 19: let c = text[c_col - 1] | |
line 20: let plist = split(&matchpairs, '.\zs[:,]') | |
line 21: let i = index(plist, c) | |
line 22: if i < 0 | |
line 23: " not found, in Insert mode try character before the cursor | |
line 24: if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
line 25: let before = 1 | |
line 26: let c = text[c_col - 2] | |
line 27: let i = index(plist, c) | |
line 28: endif | |
line 29: if i < 0 | |
line 30: " not found, nothing to do | |
line 31: return | |
function <SNR>5_Highlight_Matching_Pair returning #0 | |
continuing in TextChangedI Auto commands for "*" | |
Executing CursorMovedI Auto commands for "*" | |
autocommand call s:Highlight_Matching_Pair() | |
line 0: call s:Highlight_Matching_Pair() | |
calling function <SNR>5_Highlight_Matching_Pair() | |
line 1: " Remove any previous match. | |
line 2: if exi |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment