Created
November 3, 2015 06:17
-
-
Save nhooyr/02c0e82d72517cd8c127 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
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
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
could not source "$VIM/sysinit.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/dotfiles/nvim/init.vim" | |
line 1: call plug#begin('~/.nvim/plugged') | |
Searching for "autoload/plug.vim" in "/Users/nhooyr/dotfiles/nvim,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dotfiles/nvim/after" | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/plug.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/dotfiles/nvim/autoload) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 1: sourcing "/Users/nhooyr/dotfiles/nvim/autoload/plug.vim" | |
line 1: " vim-plug: Vim plugin manager | |
line 2: " ============================ | |
line 3: " | |
line 4: " Download plug.vim and put it in ~/.vim/autoload | |
line 5: " | |
line 6: " curl -fLo ~/.vim/autoload/plug.vim --create-dirs \ | |
line 7: " https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim | |
line 8: " | |
line 9: " Edit your .vimrc | |
line 10: " | |
line 11: " call plug#begin('~/.vim/plugged') | |
line 12: " | |
line 13: " " Make sure you use single quotes | |
line 14: " Plug 'junegunn/seoul256.vim' | |
line 15: " Plug 'junegunn/vim-easy-align' | |
line 16: " | |
line 17: " " Group dependencies, vim-snippets depends on ultisnips | |
line 18: " Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets' | |
line 19: " | |
line 20: " " On-demand loading | |
line 21: " Plug 'scrooloose/nerdtree', { 'on': 'NERDTreeToggle' } | |
line 22: " Plug 'tpope/vim-fireplace', { 'for': 'clojure' } | |
line 23: " | |
line 24: " " Using git URL | |
line 25: " Plug 'https://github.com/junegunn/vim-github-dashboard.git' | |
line 26: " | |
line 27: " " Plugin options | |
line 28: " Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' } | |
line 29: " | |
line 30: " " Plugin outside ~/.vim/plugged with post-update hook | |
line 31: " Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' } | |
line 32: " | |
line 33: " " Unmanaged plugin (manually installed and updated) | |
line 34: " Plug '~/my-prototype-plugin' | |
line 35: " | |
line 36: " call plug#end() | |
line 37: " | |
line 38: " Then reload .vimrc and :PlugInstall to install plugins. | |
line 39: " Visit https://github.com/junegunn/vim-plug for more information. | |
line 40: " | |
line 41: " | |
line 42: " Copyright (c) 2015 Junegunn Choi | |
line 43: " | |
line 44: " MIT License | |
line 45: " | |
line 46: " Permission is hereby granted, free of charge, to any person obtaining | |
line 47: " a copy of this software and associated documentation files (the | |
line 48: " "Software"), to deal in the Software without restriction, including | |
line 49: " without limitation the rights to use, copy, modify, merge, publish, | |
line 50: " distribute, sublicense, and/or sell copies of the Software, and to | |
line 51: " permit persons to whom the Software is furnished to do so, subject to | |
line 52: " the following conditions: | |
line 53: " | |
line 54: " The above copyright notice and this permission notice shall be | |
line 55: " included in all copies or substantial portions of the Software. | |
line 56: " | |
line 57: " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
line 58: " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
line 59: " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
line 60: " NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
line 61: " LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
line 62: " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
line 63: " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
line 64: | |
line 65: if exists('g:loaded_plug') | |
line 66: finish | |
line 67: endif | |
line 68: let g:loaded_plug = 1 | |
line 69: | |
line 70: let s:cpo_save = &cpo | |
line 71: set cpo&vim | |
line 72: | |
line 73: let s:plug_src = 'https://github.com/junegunn/vim-plug.git' | |
line 74: let s:plug_tab = get(s:, 'plug_tab', -1) | |
line 75: let s:plug_buf = get(s:, 'plug_buf', -1) | |
line 76: let s:mac_gui = has('gui_macvim') && has('gui_running') | |
line 77: let s:is_win = has('win32') || has('win64') | |
line 78: let s:nvim = has('nvim') && exists('*jobwait') && !s:is_win | |
line 79: let s:me = resolve(expand('<sfile>:p')) | |
line 80: let s:base_spec = { 'branch': 'master', 'frozen': 0 } | |
line 86: let s:TYPE = { 'string': type(''), 'list': type([]), 'dict': type({}), 'funcref': type(function('call')) } | |
line 87: let s:loaded = get(s:, 'loaded', {}) | |
line 88: let s:triggers = get(s:, 'triggers', {}) | |
line 89: | |
line 90: function! plug#begin(...) | |
line 110: | |
line 111: function! s:define_commands() | |
line 124: | |
line 125: function! s:to_a(v) | |
line 128: | |
line 129: function! s:to_s(v) | |
line 132: | |
line 133: function! s:source(from, ...) | |
line 140: | |
line 141: function! s:assoc(dict, key, val) | |
line 144: | |
line 145: function! plug#end() | |
line 224: | |
line 225: function! s:loaded_names() | |
line 228: | |
line 229: function! s:reload() | |
line 234: | |
line 235: function! s:trim(str) | |
line 238: | |
line 239: function! s:version_requirement(val, min) | |
line 248: | |
line 249: function! s:git_version_requirement(...) | |
line 254: | |
line 255: function! s:progress_opt(base) | |
line 259: | |
line 260: if s:is_win | |
line 261: function! s:rtp(spec) | |
line 264: | |
line 265: function! s:path(path) | |
line 268: | |
line 269: function! s:dirpath(path) | |
line 272: | |
line 273: function! s:is_local_plug(repo) | |
line 276: else | |
line 277: function! s:rtp(spec) | |
line 280: | |
line 281: function! s:path(path) | |
line 284: | |
line 285: function! s:dirpath(path) | |
line 288: | |
line 289: function! s:is_local_plug(repo) | |
line 292: endif | |
line 293: | |
line 294: function! s:err(msg) | |
line 300: | |
line 301: function! s:esc(path) | |
line 304: | |
line 305: function! s:escrtp(path) | |
line 308: | |
line 309: function! s:remove_rtp() | |
line 319: | |
line 320: function! s:reorg_rtp() | |
line 346: | |
line 347: function! plug#load(...) | |
line 367: | |
line 368: function! s:remove_triggers(name) | |
line 381: | |
line 382: function! s:lod(names, types) | |
line 399: | |
line 400: function! s:lod_ft(pat, names) | |
line 410: | |
line 411: function! s:lod_cmd(cmd, bang, l1, l2, args, names) | |
line 415: | |
line 416: function! s:lod_map(map, names, prefix) | |
line 428: | |
line 429: function! s:add(repo, ...) | |
line 448: | |
line 449: function! s:parse_options(arg) | |
line 464: | |
line 465: function! s:infer_properties(name, repo) | |
line 483: | |
line 484: function! s:install(force, names) | |
line 487: | |
line 488: function! s:update(force, names) | |
line 491: | |
line 492: function! plug#helptags() | |
line 504: | |
line 505: function! s:syntax() | |
line 546: | |
line 547: function! s:lpad(str, len) | |
line 550: | |
line 551: function! s:lines(msg) | |
line 554: | |
line 555: function! s:lastline(msg) | |
line 558: | |
line 559: function! s:new_window() | |
line 562: | |
line 563: function! s:plug_window_exists() | |
line 567: | |
line 568: function! s:switch_in() | |
line 586: | |
line 587: function! s:switch_out(...) | |
line 600: | |
line 601: function! s:prepare() | |
line 628: | |
line 629: function! s:assign_name() | |
line 640: | |
line 641: function! s:do(pull, force, todo) | |
line 679: | |
line 680: function! s:finish(pull) | |
line 702: | |
line 703: function! s:retry() | |
line 710: | |
line 711: function! s:is_managed(name) | |
line 714: | |
line 715: function! s:names(...) | |
line 718: | |
line 719: function! s:update_impl(pull, force, args) abort | |
line 828: | |
line 829: function! s:update_finish() | |
line 840: | |
line 841: function! s:job_abort() | |
line 854: | |
line 855: " When a:event == 'stdout', data = list of strings | |
line 856: " When a:event == 'exit', data = returncode | |
line 857: function! s:job_handler(job_id, data, event) abort | |
line 878: | |
line 879: function! s:spawn(name, cmd, opts) | |
line 906: | |
line 907: function! s:reap(name) | |
line 921: | |
line 922: function! s:bar() | |
line 931: | |
line 932: function! s:logpos(name) | |
line 940: | |
line 941: function! s:log(bullet, name, lines) | |
line 956: | |
line 957: function! s:update_vim() | |
line 963: | |
line 964: function! s:tick() | |
line 1019: | |
line 1020: function! s:update_python() | |
line 1397: | |
line 1398: function! s:update_ruby() | |
line 1611: | |
line 1612: function! s:shellesc(arg) | |
line 1615: | |
line 1616: function! s:glob_dir(path) | |
line 1619: | |
line 1620: function! s:progress_bar(line, bar, total) | |
line 1623: | |
line 1624: function! s:compare_git_uri(a, b) | |
line 1629: | |
line 1630: function! s:format_message(bullet, name, message) | |
line 1638: | |
line 1639: function! s:with_cd(cmd, dir) | |
line 1642: | |
line 1643: function! s:system(cmd, ...) | |
line 1655: | |
line 1656: function! s:system_chomp(...) | |
line 1660: | |
line 1661: function! s:git_valid(spec, check_branch) | |
line 1698: | |
line 1699: function! s:rm_rf(dir) | |
line 1704: | |
line 1705: function! s:clean(force) | |
line 1762: | |
line 1763: function! s:upgrade() | |
line 1789: | |
line 1790: function! s:upgrade_specs() | |
line 1795: | |
line 1796: function! s:status() | |
line 1839: | |
line 1840: function! s:extract_name(str, prefix, suffix) | |
line 1843: | |
line 1844: function! s:status_load(lnum) | |
line 1854: | |
line 1855: function! s:status_update() range | |
line 1863: | |
line 1864: function! s:is_preview_window_open() | |
line 1872: | |
line 1873: function! s:find_name(lnum) | |
line 1886: | |
line 1887: function! s:preview_commit() | |
line 1911: | |
line 1912: function! s:section(flags) | |
line 1915: | |
line 1916: function! s:diff() | |
line 1949: | |
line 1950: function! s:revert() | |
line 1963: | |
line 1964: function! s:snapshot(...) abort | |
line 2002: | |
line 2003: function! s:split_rtp() | |
line 2006: | |
line 2007: let s:first_rtp = s:escrtp(get(s:split_rtp(), 0, '')) | |
calling function <SNR>2_split_rtp() | |
line 1: return split(&rtp, '\\\@<!,') | |
function <SNR>2_split_rtp returning ['/Users/nhooyr/dotfiles/nvim', '/etc...r', '/Users/nhooyr/dotfiles/nvim/after'] | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/plug.vim | |
calling function <SNR>2_escrtp('/Users/nhooyr/dotfiles/nvim') | |
line 1: return escape(a:path, ' ,') | |
function <SNR>2_escrtp returning '/Users/nhooyr/dotfiles/nvim' | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/plug.vim | |
line 2008: let s:last_rtp = s:escrtp(get(s:split_rtp(), -1, '')) | |
calling function <SNR>2_split_rtp() | |
line 1: return split(&rtp, '\\\@<!,') | |
function <SNR>2_split_rtp returning ['/Users/nhooyr/dotfiles/nvim', '/etc...r', '/Users/nhooyr/dotfiles/nvim/after'] | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/plug.vim | |
calling function <SNR>2_escrtp('/Users/nhooyr/dotfiles/nvim/after') | |
line 1: return escape(a:path, ' ,') | |
function <SNR>2_escrtp returning '/Users/nhooyr/dotfiles/nvim/after' | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/plug.vim | |
line 2009: | |
line 2010: if exists('g:plugs') | |
line 2011: let g:plugs_order = get(g:, 'plugs_order', keys(g:plugs)) | |
line 2012: call s:upgrade_specs() | |
line 2013: call s:define_commands() | |
line 2014: endif | |
line 2015: | |
line 2016: let &cpo = s:cpo_save | |
line 2017: unlet s:cpo_save | |
line 2018: | |
finished sourcing /Users/nhooyr/dotfiles/nvim/autoload/plug.vim | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
calling function plug#begin('~/.nvim/plugged') | |
line 1: if a:0 > 0 | |
line 2: let s:plug_home_org = a:1 | |
line 3: let home = s:path(fnamemodify(expand(a:1), ':p')) | |
calling function plug#begin..<SNR>2_path('/Users/nhooyr/.nvim/plugged/') | |
line 1: return s:trim(a:path) | |
calling function plug#begin..<SNR>2_path..<SNR>2_trim('/Users/nhooyr/.nvim/plugged/') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function plug#begin..<SNR>2_path..<SNR>2_trim returning '/Users/nhooyr/.nvim/plugged' | |
continuing in function plug#begin..<SNR>2_path | |
function plug#begin..<SNR>2_path returning '/Users/nhooyr/.nvim/plugged' | |
continuing in function plug#begin | |
line 4: elseif exists('g:plug_home') | |
line 5: let home = s:path(g:plug_home) | |
line 6: elseif !empty(&rtp) | |
line 7: let home = s:path(split(&rtp, ',')[0]) . '/plugged' | |
line 8: else | |
line 9: return s:err('Unable to determine plug home. Try calling plug#begin() with a path argument.') | |
line 10: endif | |
line 11: | |
line 12: let g:plug_home = home | |
line 13: let g:plugs = {} | |
line 14: let g:plugs_order = [] | |
line 15: let s:triggers = {} | |
line 16: | |
line 17: call s:define_commands() | |
calling function plug#begin..<SNR>2_define_commands() | |
line 1: command! -nargs=+ -bar Plug call s:add(<args>) | |
line 2: if !executable('git') | |
line 3: return s:err('`git` executable not found. vim-plug requires git.') | |
line 4: endif | |
line 5: command! -nargs=* -bar -bang -complete=customlist,s:names PlugInstall call s:install('<bang>' == '!', [<f-args>]) | |
line 6: command! -nargs=* -bar -bang -complete=customlist,s:names PlugUpdate call s:update('<bang>' == '!', [<f-args>]) | |
line 7: command! -nargs=0 -bar -bang PlugClean call s:clean('<bang>' == '!') | |
line 8: command! -nargs=0 -bar PlugUpgrade if s:upgrade() | execute 'source' s:esc(s:me) | endif | |
line 9: command! -nargs=0 -bar PlugStatus call s:status() | |
line 10: command! -nargs=0 -bar PlugDiff call s:diff() | |
line 11: command! -nargs=? -bar PlugSnapshot call s:snapshot(<f-args>) | |
function plug#begin..<SNR>2_define_commands returning #0 | |
continuing in function plug#begin | |
line 18: return 1 | |
function plug#begin returning #1 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 2: | |
line 3: Plug 'fatih/vim-go', { 'for': 'go' } | |
line 3: call s:add('fatih/vim-go', { 'for': 'go' }) | |
calling function <SNR>2_add('fatih/vim-go', {'for': 'go'}) | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('fatih/vim-go') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'fatih/vim-go' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-go', 'fatih/vim-go') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('fatih/vim-go') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-go/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-go/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/fat...: '/Users/nhooyr/.nvim/plugged/vim-go/'} | |
continuing in function <SNR>2_add | |
calling function <SNR>2_add..<SNR>2_parse_options({'for': 'go'}) | |
line 1: let opts = copy(s:base_spec) | |
line 2: let type = type(a:arg) | |
line 3: if type == s:TYPE.string | |
line 4: let opts.tag = a:arg | |
line 5: elseif type == s:TYPE.dict | |
line 6: call extend(opts, a:arg) | |
line 7: if has_key(opts, 'dir') | |
line 8: let opts.dir = s:dirpath(expand(opts.dir)) | |
line 9: endif | |
line 10: else | |
line 11: throw 'Invalid argument type (expected: string or dictionary)' | |
line 12: endif | |
line 13: return opts | |
function <SNR>2_add..<SNR>2_parse_options returning {'for': 'go', 'frozen': 0, 'branch': 'master'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 4: "Plug 'scrooloose/syntastic' | |
line 5: Plug 'benekastah/neomake' | |
line 5: call s:add('benekastah/neomake') | |
calling function <SNR>2_add('benekastah/neomake') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('benekastah/neomake') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'benekastah/neomake' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('neomake', 'benekastah/neomake') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('benekastah/neomake') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/neomake/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/neomake/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/ben... '/Users/nhooyr/.nvim/plugged/neomake/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 6: Plug 'majutsushi/tagbar' | |
line 6: call s:add('majutsushi/tagbar') | |
calling function <SNR>2_add('majutsushi/tagbar') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('majutsushi/tagbar') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'majutsushi/tagbar' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('tagbar', 'majutsushi/tagbar') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('majutsushi/tagbar') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/tagbar/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/tagbar/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/maj...: '/Users/nhooyr/.nvim/plugged/tagbar/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 7: Plug 'tpope/vim-fugitive' | |
line 7: call s:add('tpope/vim-fugitive') | |
calling function <SNR>2_add('tpope/vim-fugitive') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('tpope/vim-fugitive') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'tpope/vim-fugitive' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-fugitive', 'tpope/vim-fugitive') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('tpope/vim-fugitive') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-fugitive/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-fugitive/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/tpo...ers/nhooyr/.nvim/plugged/vim-fugitive/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 8: "Plug 'SirVer/ultisnips' | |
line 9: Plug 'Valloric/YouCompleteMe', { 'do': 'python2 install.py --gocode-completer' } | |
line 9: call s:add('Valloric/YouCompleteMe', { 'do': 'python2 install.py --gocode-completer' }) | |
calling function <SNR>2_add('Valloric/YouCompleteMe', {'do': 'python2 install.py --gocode-completer'}) | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('Valloric/YouCompleteMe') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'Valloric/YouCompleteMe' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('YouCompleteMe', 'Valloric/YouCompleteMe') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('Valloric/YouCompleteMe') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/YouCompleteMe/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/YouCompleteMe/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/Val...rs/nhooyr/.nvim/plugged/YouCompleteMe/'} | |
continuing in function <SNR>2_add | |
calling function <SNR>2_add..<SNR>2_parse_options({'do': 'python2 install.py --gocode-completer'}) | |
line 1: let opts = copy(s:base_spec) | |
line 2: let type = type(a:arg) | |
line 3: if type == s:TYPE.string | |
line 4: let opts.tag = a:arg | |
line 5: elseif type == s:TYPE.dict | |
line 6: call extend(opts, a:arg) | |
line 7: if has_key(opts, 'dir') | |
line 8: let opts.dir = s:dirpath(expand(opts.dir)) | |
line 9: endif | |
line 10: else | |
line 11: throw 'Invalid argument type (expected: string or dictionary)' | |
line 12: endif | |
line 13: return opts | |
function <SNR>2_add..<SNR>2_parse_options returning {'do': 'python2 install.py --gocode-completer', 'frozen': 0, 'branch': 'master'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 10: Plug 'bling/vim-airline' | |
line 10: call s:add('bling/vim-airline') | |
calling function <SNR>2_add('bling/vim-airline') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('bling/vim-airline') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'bling/vim-airline' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-airline', 'bling/vim-airline') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('bling/vim-airline') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-airline/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-airline/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/bli...sers/nhooyr/.nvim/plugged/vim-airline/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 11: Plug 'Raimondi/delimitMate' | |
line 11: call s:add('Raimondi/delimitMate') | |
calling function <SNR>2_add('Raimondi/delimitMate') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('Raimondi/delimitMate') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'Raimondi/delimitMate' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('delimitMate', 'Raimondi/delimitMate') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('Raimondi/delimitMate') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/delimitMate/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/delimitMate/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/Rai...sers/nhooyr/.nvim/plugged/delimitMate/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 12: "Plug 'ervandew/supertab' | |
line 13: Plug 'christoomey/vim-tmux-navigator' | |
line 13: call s:add('christoomey/vim-tmux-navigator') | |
calling function <SNR>2_add('christoomey/vim-tmux-navigator') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('christoomey/vim-tmux-navigator') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'christoomey/vim-tmux-navigator' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-tmux-navigator', 'christoomey/vim-tmux-navigator') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('christoomey/vim-tmux-navigator') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/chr...ooyr/.nvim/plugged/vim-tmux-navigator/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 14: Plug 'mhinz/vim-startify' | |
line 14: call s:add('mhinz/vim-startify') | |
calling function <SNR>2_add('mhinz/vim-startify') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('mhinz/vim-startify') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'mhinz/vim-startify' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-startify', 'mhinz/vim-startify') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('mhinz/vim-startify') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-startify/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-startify/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/mhi...ers/nhooyr/.nvim/plugged/vim-startify/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 15: Plug 'mattn/emmet-vim' | |
line 15: call s:add('mattn/emmet-vim') | |
calling function <SNR>2_add('mattn/emmet-vim') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('mattn/emmet-vim') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'mattn/emmet-vim' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('emmet-vim', 'mattn/emmet-vim') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('mattn/emmet-vim') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/emmet-vim/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/emmet-vim/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/mat.../Users/nhooyr/.nvim/plugged/emmet-vim/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 16: Plug 'tpope/vim-surround' | |
line 16: call s:add('tpope/vim-surround') | |
calling function <SNR>2_add('tpope/vim-surround') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('tpope/vim-surround') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'tpope/vim-surround' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-surround', 'tpope/vim-surround') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('tpope/vim-surround') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-surround/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-surround/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/tpo...ers/nhooyr/.nvim/plugged/vim-surround/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 17: Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' } | |
line 17: call s:add('junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes | ./install' }) | |
calling function <SNR>2_add('junegunn/fzf', {'dir': '~/.fzf', 'do': 'yes | ./install'}) | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('junegunn/fzf') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'junegunn/fzf' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('fzf', 'junegunn/fzf') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('junegunn/fzf') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/fzf') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/fzf/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/jun...ir': '/Users/nhooyr/.nvim/plugged/fzf/'} | |
continuing in function <SNR>2_add | |
calling function <SNR>2_add..<SNR>2_parse_options({'dir': '~/.fzf', 'do': 'yes | ./install'}) | |
line 1: let opts = copy(s:base_spec) | |
line 2: let type = type(a:arg) | |
line 3: if type == s:TYPE.string | |
line 4: let opts.tag = a:arg | |
line 5: elseif type == s:TYPE.dict | |
line 6: call extend(opts, a:arg) | |
line 7: if has_key(opts, 'dir') | |
line 8: let opts.dir = s:dirpath(expand(opts.dir)) | |
calling function <SNR>2_add..<SNR>2_parse_options..<SNR>2_dirpath('/Users/nhooyr/.fzf') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_parse_options..<SNR>2_dirpath returning '/Users/nhooyr/.fzf/' | |
continuing in function <SNR>2_add..<SNR>2_parse_options | |
line 9: endif | |
line 10: else | |
line 11: throw 'Invalid argument type (expected: string or dictionary)' | |
line 12: endif | |
line 13: return opts | |
function <SNR>2_add..<SNR>2_parse_options returning {'dir': '/Users/nhooyr/.fzf/', 'froze...nch': 'master', 'do': 'yes | ./install'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 18: Plug 'tpope/vim-repeat' | |
line 18: call s:add('tpope/vim-repeat') | |
calling function <SNR>2_add('tpope/vim-repeat') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('tpope/vim-repeat') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'tpope/vim-repeat' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-repeat', 'tpope/vim-repeat') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('tpope/vim-repeat') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-repeat/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-repeat/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/tpo...Users/nhooyr/.nvim/plugged/vim-repeat/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 19: Plug 'romainl/Apprentice' | |
line 19: call s:add('romainl/Apprentice') | |
calling function <SNR>2_add('romainl/Apprentice') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('romainl/Apprentice') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'romainl/Apprentice' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('Apprentice', 'romainl/Apprentice') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('romainl/Apprentice') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/Apprentice/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/Apprentice/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/rom...Users/nhooyr/.nvim/plugged/Apprentice/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 20: Plug 'unblevable/quick-scope' | |
line 20: call s:add('unblevable/quick-scope') | |
calling function <SNR>2_add('unblevable/quick-scope') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('unblevable/quick-scope') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'unblevable/quick-scope' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('quick-scope', 'unblevable/quick-scope') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('unblevable/quick-scope') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/quick-scope/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/quick-scope/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/unb...sers/nhooyr/.nvim/plugged/quick-scope/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 21: Plug 'jez/vim-superman' | |
line 21: call s:add('jez/vim-superman') | |
calling function <SNR>2_add('jez/vim-superman') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('jez/vim-superman') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'jez/vim-superman' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-superman', 'jez/vim-superman') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('jez/vim-superman') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-superman/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-superman/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/jez...ers/nhooyr/.nvim/plugged/vim-superman/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 22: Plug 'vim-scripts/LanguageTool' | |
line 22: call s:add('vim-scripts/LanguageTool') | |
calling function <SNR>2_add('vim-scripts/LanguageTool') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('vim-scripts/LanguageTool') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'vim-scripts/LanguageTool' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('LanguageTool', 'vim-scripts/LanguageTool') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('vim-scripts/LanguageTool') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/LanguageTool/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/LanguageTool/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/vim...ers/nhooyr/.nvim/plugged/LanguageTool/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 23: Plug 'osyo-manga/vim-over' | |
line 23: call s:add('osyo-manga/vim-over') | |
calling function <SNR>2_add('osyo-manga/vim-over') | |
line 1: if a:0 > 1 | |
line 2: return s:err('Invalid number of arguments (1..2)') | |
line 3: endif | |
line 4: | |
line 5: try | |
line 6: let repo = s:trim(a:repo) | |
calling function <SNR>2_add..<SNR>2_trim('osyo-manga/vim-over') | |
line 1: return substitute(a:str, '[\/]\+$', '', '') | |
function <SNR>2_add..<SNR>2_trim returning 'osyo-manga/vim-over' | |
continuing in function <SNR>2_add | |
line 7: let name = fnamemodify(repo, ':t:s?\.git$??') | |
line 8: let spec = extend(s:infer_properties(name, repo), a:0 == 1 ? s:parse_options(a:1) : s:base_spec) | |
calling function <SNR>2_add..<SNR>2_infer_properties('vim-over', 'osyo-manga/vim-over') | |
line 1: let repo = a:repo | |
line 2: if s:is_local_plug(repo) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug('osyo-manga/vim-over') | |
line 1: return a:repo[0] =~ '[/$~]' | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_is_local_plug returning #0 | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 3: return { 'dir': s:dirpath(expand(repo)) } | |
line 4: else | |
line 5: if repo =~ ':' | |
line 6: let uri = repo | |
line 7: else | |
line 8: if repo !~ '/' | |
line 9: let repo = 'vim-scripts/'. repo | |
line 10: endif | |
line 11: let fmt = get(g:, 'plug_url_format', 'https://git::@github.com/%s.git') | |
line 12: let uri = printf(fmt, repo) | |
line 13: endif | |
line 14: let dir = s:dirpath( fnamemodify(join([g:plug_home, a:name], '/'), ':p') ) | |
calling function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-over/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function <SNR>2_add..<SNR>2_infer_properties..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-over/' | |
continuing in function <SNR>2_add..<SNR>2_infer_properties | |
line 15: return { 'dir': dir, 'uri': uri } | |
function <SNR>2_add..<SNR>2_infer_properties returning {'uri': 'https://git::@github.com/osy...'/Users/nhooyr/.nvim/plugged/vim-over/'} | |
continuing in function <SNR>2_add | |
line 10: if !has_key(g:plugs, name) | |
line 11: call add(g:plugs_order, name) | |
line 12: endif | |
line 13: let g:plugs[name] = spec | |
line 14: let s:loaded[name] = get(s:loaded, name, 0) | |
line 15: catch | |
line 16: return s:err(v:exception) | |
line 17: endtry | |
function <SNR>2_add returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 24: "Plug 'vim-utils/vim-troll-stopper' | |
line 25: | |
line 26: call plug#end() | |
calling function plug#end() | |
line 1: if !exists('g:plugs') | |
line 2: return s:err('Call plug#begin() first') | |
line 3: endif | |
line 4: | |
line 5: if exists('#PlugLOD') | |
line 6: augroup PlugLOD | |
line 7: autocmd! | |
line 8: augroup END | |
line 9: augroup! PlugLOD | |
line 10: endif | |
line 11: let lod = { 'ft': {}, 'map': {}, 'cmd': {} } | |
line 12: | |
line 13: filetype off | |
Searching for "ftoff.vim" in "/Users/nhooyr/dotfiles/nvim,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dotfiles/nvim/after" | |
Searching for "/Users/nhooyr/dotfiles/nvim/ftoff.vim" | |
Searching for "/etc/xdg/nvim/ftoff.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/ftoff.vim" | |
Searching for "/usr/local/share/nvim/site/ftoff.vim" | |
Searching for "/usr/share/nvim/site/ftoff.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftoff.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 13: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftoff.vim" | |
line 1: " Vim support file to switch off detection of file types | |
line 2: " | |
line 3: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 4: " Last change:^I2001 Jun 11 | |
line 5: | |
line 6: if exists("did_load_filetypes") | |
line 7: unlet did_load_filetypes | |
line 8: endif | |
line 9: | |
line 10: " Remove all autocommands in the filetypedetect group | |
line 11: silent! au! filetypedetect * | |
Error detected while processing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftoff.vim: | |
line 11: | |
E216: No such group or event: filetypedetect * | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftoff.vim | |
continuing in function plug#end | |
Searching for "/usr/share/nvim/site/after/ftoff.vim" | |
Searching for "/usr/local/share/nvim/site/after/ftoff.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/ftoff.vim" | |
Searching for "/etc/xdg/nvim/after/ftoff.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/ftoff.vim" | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 19: endif | |
line 20: | |
line 21: if has_key(plug, 'on') | |
line 22: let s:triggers[name] = { 'map': [], 'cmd': [] } | |
line 23: for cmd in s:to_a(plug.on) | |
line 24: if cmd =~? '^<Plug>.\+' | |
line 25: if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i')) | |
line 26: call s:assoc(lod.map, cmd, name) | |
line 27: endif | |
line 28: call add(s:triggers[name].map, cmd) | |
line 29: elseif cmd =~ '^[A-Z]' | |
line 30: if exists(':'.cmd) != 2 | |
line 31: call s:assoc(lod.cmd, cmd, name) | |
line 32: endif | |
line 33: call add(s:triggers[name].cmd, cmd) | |
line 34: endif | |
line 35: endfor | |
line 36: endif | |
line 37: | |
line 38: if has_key(plug, 'for') | |
line 39: let types = s:to_a(plug.for) | |
calling function plug#end..<SNR>2_to_a('go') | |
line 1: return type(a:v) == s:TYPE.list ? a:v : [a:v] | |
function plug#end..<SNR>2_to_a returning ['go'] | |
continuing in function plug#end | |
line 40: if !empty(types) | |
line 41: call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim') | |
calling function plug#end..<SNR>2_rtp({'uri': 'https://git::@github.com/fat...en': 0, 'for': 'go', 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-go/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-go/' | |
continuing in function plug#end..<SNR>2_rtp | |
function plug#end..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-go/' | |
continuing in function plug#end | |
calling function plug#end..<SNR>2_source('/Users/nhooyr/.nvim/plugged/vim-go/', 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim') | |
line 1: for pattern in a:000 | |
line 2: for vim in s:lines(globpath(a:from, pattern)) | |
calling function plug#end..<SNR>2_source..<SNR>2_lines('/Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim') | |
line 1: return split(a:msg, "[\r\n]") | |
function plug#end..<SNR>2_source..<SNR>2_lines returning ['/Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim'] | |
continuing in function plug#end..<SNR>2_source | |
line 3: execute 'source' s:esc(vim) | |
calling function plug#end..<SNR>2_source..<SNR>2_esc('/Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim') | |
line 1: return escape(a:path, ' ') | |
function plug#end..<SNR>2_source..<SNR>2_esc returning '/Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim' | |
continuing in function plug#end..<SNR>2_source | |
line 3: source /Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-go/ftdetect) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 3: sourcing "/Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim" | |
line 1: " We take care to preserve the user's fileencodings and fileformats, | |
line 2: " because those settings are global (not buffer local), yet we want | |
line 3: " to override them for loading Go files, which are defined to be UTF-8. | |
line 4: let s:current_fileformats = '' | |
line 5: let s:current_fileencodings = '' | |
line 6: | |
line 7: " define fileencodings to open as utf-8 encoding even if it's ascii. | |
line 8: function! s:gofiletype_pre() | |
line 14: | |
line 15: " restore fileencodings as others | |
line 16: function! s:gofiletype_post() | |
line 20: | |
line 21: au BufNewFile *.go setfiletype go | setlocal fileencoding=utf-8 fileformat=unix | |
line 22: au BufRead *.go call s:gofiletype_pre() | |
line 23: au BufReadPost *.go call s:gofiletype_post() | |
line 24: | |
line 25: au BufRead,BufNewFile *.tmpl set filetype=gohtmltmpl | |
line 26: | |
line 27: " vim:ts=4:sw=4:et | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-go/ftdetect/gofiletype.vim | |
continuing in function plug#end..<SNR>2_source | |
line 4: endfor | |
line 2: for vim in s:lines(globpath(a:from, pattern)) | |
line 3: execute 'source' s:esc(vim) | |
line 4: endfor | |
line 5: endfor | |
line 1: for pattern in a:000 | |
line 2: for vim in s:lines(globpath(a:from, pattern)) | |
calling function plug#end..<SNR>2_source..<SNR>2_lines('') | |
line 1: return split(a:msg, "[\r\n]") | |
function plug#end..<SNR>2_source..<SNR>2_lines returning [] | |
continuing in function plug#end..<SNR>2_source | |
line 3: execute 'source' s:esc(vim) | |
line 4: endfor | |
line 5: endfor | |
line 1: for pattern in a:000 | |
line 2: for vim in s:lines(globpath(a:from, pattern)) | |
line 3: execute 'source' s:esc(vim) | |
line 4: endfor | |
line 5: endfor | |
function plug#end..<SNR>2_source returning #0 | |
continuing in function plug#end | |
line 42: endif | |
line 43: for type in types | |
line 44: call s:assoc(lod.ft, type, name) | |
calling function plug#end..<SNR>2_assoc({}, 'go', 'vim-go') | |
line 1: let a:dict[a:key] = add(get(a:dict, a:key, []), a:val) | |
function plug#end..<SNR>2_assoc returning #0 | |
continuing in function plug#end | |
line 45: endfor | |
line 43: for type in types | |
line 44: call s:assoc(lod.ft, type, name) | |
line 45: endfor | |
line 46: endif | |
line 47: endfor | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 14: for name in g:plugs_order | |
line 15: let plug = g:plugs[name] | |
line 16: if get(s:loaded, name, 0) || !has_key(plug, 'on') && !has_key(plug, 'for') | |
line 17: let s:loaded[name] = 1 | |
line 18: continue | |
line 19: endif | |
line 20: | |
line 21: if has_key(plug, 'on') | |
line 22: let s:triggers[name] = { 'map': [], 'cmd': [] } | |
line 23: for cmd in s:to_a(plug.on) | |
line 24: if cmd =~? '^<Plug>.\+' | |
line 25: if empty(mapcheck(cmd)) && empty(mapcheck(cmd, 'i')) | |
line 26: call s:assoc(lod.map, cmd, name) | |
line 27: endif | |
line 28: call add(s:triggers[name].map, cmd) | |
line 29: elseif cmd =~ '^[A-Z]' | |
line 30: if exists(':'.cmd) != 2 | |
line 31: call s:assoc(lod.cmd, cmd, name) | |
line 32: endif | |
line 33: call add(s:triggers[name].cmd, cmd) | |
line 34: endif | |
line 35: endfor | |
line 36: endif | |
line 37: | |
line 38: if has_key(plug, 'for') | |
line 39: let types = s:to_a(plug.for) | |
line 40: if !empty(types) | |
line 41: call s:source(s:rtp(plug), 'ftdetect/**/*.vim', 'after/ftdetect/**/*.vim') | |
line 42: endif | |
line 43: for type in types | |
line 44: call s:assoc(lod.ft, type, name) | |
line 45: endfor | |
line 46: endif | |
line 47: endfor | |
line 48: | |
line 49: for [cmd, names] in items(lod.cmd) | |
line 50: execute printf( 'command! -nargs=* -range -bang %s call s:lod_cmd(%s, "<bang>", <line1>, <line2>, <q-args>, %s)', cmd, string(cmd), string(names)) | |
line 53: endfor | |
line 54: | |
line 55: for [map, names] in items(lod.map) | |
line 56: for [mode, map_prefix, key_prefix] in [['i', '<C-O>', ''], ['n', '', ''], ['v', '', 'gv'], ['o', '', '']] | |
line 58: execute printf( '%snoremap <silent> %s %s:<C-U>call <SID>lod_map(%s, %s, "%s")<CR>', mode, map, map_prefix, string(map), string(names), key_prefix) | |
line 61: endfor | |
line 62: endfor | |
line 63: | |
line 64: for [ft, names] in items(lod.ft) | |
line 65: augroup PlugLOD | |
line 66: execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)', ft, string(ft), string(names)) | |
line 66: autocmd FileType go call <SID>lod_ft('go', ['vim-go']) | |
line 68: augroup END | |
line 69: endfor | |
line 64: for [ft, names] in items(lod.ft) | |
line 65: augroup PlugLOD | |
line 66: execute printf('autocmd FileType %s call <SID>lod_ft(%s, %s)', ft, string(ft), string(names)) | |
line 68: augroup END | |
line 69: endfor | |
line 70: | |
line 71: call s:reorg_rtp() | |
calling function plug#end..<SNR>2_reorg_rtp() | |
line 1: if !empty(s:first_rtp) | |
line 2: execute 'set rtp-='.s:first_rtp | |
line 2: set rtp-=/Users/nhooyr/dotfiles/nvim | |
line 3: execute 'set rtp-='.s:last_rtp | |
line 3: set rtp-=/Users/nhooyr/dotfiles/nvim/after | |
line 4: endif | |
line 5: | |
line 6: " &rtp is modified from outside | |
line 7: if exists('s:prtp') && s:prtp !=# &rtp | |
line 8: call s:remove_rtp() | |
line 9: unlet! s:middle | |
line 10: endif | |
line 11: | |
line 12: let s:middle = get(s:, 'middle', &rtp) | |
line 13: let rtps = map(s:loaded_names(), 's:rtp(g:plugs[v:val])') | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_loaded_names() | |
line 1: return filter(copy(g:plugs_order), 'get(s:loaded, v:val, 0)') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_loaded_names returning ['neomake', 'tagbar', 'vim-fugitive',...m-superman', 'LanguageTool', 'vim-over'] | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/ben...make/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/neomake/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/neomake/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/neomake/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/maj...gbar/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/tagbar/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/tagbar/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/tagbar/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/tpo...tive/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-fugitive/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-fugitive/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-fugitive/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/Val...'python2 install.py --gocode-completer'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/YouCompleteMe/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/YouCompleteMe/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/YouCompleteMe/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/bli...line/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-airline/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-airline/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-airline/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/Rai...Mate/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/delimitMate/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/delimitMate/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/delimitMate/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/chr...ator/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/mhi...tify/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-startify/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-startify/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-startify/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/mat...-vim/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/emmet-vim/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/emmet-vim/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/emmet-vim/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/tpo...ound/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-surround/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-surround/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-surround/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/jun...nch': 'master', 'do': 'yes | ./install'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.fzf/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.fzf/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.fzf/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/tpo...peat/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-repeat/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-repeat/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-repeat/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/rom...tice/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/Apprentice/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/Apprentice/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/Apprentice/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/unb...cope/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/quick-scope/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/quick-scope/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/quick-scope/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/jez...rman/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-superman/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-superman/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-superman/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/vim...Tool/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/LanguageTool/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/LanguageTool/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/LanguageTool/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp({'uri': 'https://git::@github.com/osy...over/', 'frozen': 0, 'branch': 'master'}) | |
line 1: return s:dirpath(a:spec.dir . get(a:spec, 'rtp', '')) | |
calling function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath('/Users/nhooyr/.nvim/plugged/vim-over/') | |
line 1: return substitute(a:path, '[/\\]*$', '/', '') | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp..<SNR>2_dirpath returning '/Users/nhooyr/.nvim/plugged/vim-over/' | |
continuing in function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp | |
function plug#end..<SNR>2_reorg_rtp..<SNR>2_rtp returning '/Users/nhooyr/.nvim/plugged/vim-over/' | |
continuing in function plug#end..<SNR>2_reorg_rtp | |
line 14: let afters = filter(map(copy(rtps), 'globpath(v:val, "after")'), 'isdirectory(v:val)') | |
line 15: let rtp = join(map(rtps, 'escape(v:val, ",")'), ',') . ','.s:middle.',' . join(map(afters, 'escape(v:val, ",")'), ',') | |
line 18: let &rtp = substitute(substitute(rtp, ',,*', ',', 'g'), '^,\|,$', '', 'g') | |
line 19: let s:prtp = &rtp | |
line 20: | |
line 21: if !empty(s:first_rtp) | |
line 22: execute 'set rtp^='.s:first_rtp | |
line 22: set rtp^=/Users/nhooyr/dotfiles/nvim | |
line 23: execute 'set rtp+='.s:last_rtp | |
line 23: set rtp+=/Users/nhooyr/dotfiles/nvim/after | |
line 24: endif | |
function plug#end..<SNR>2_reorg_rtp returning #0 | |
continuing in function plug#end | |
line 72: filetype plugin indent on | |
Searching for "filetype.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dot | |
Searching for "/Users/nhooyr/dotfiles/nvim/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/filetype.vim" | |
Searching for "/Users/nhooyr/.fzf/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/filetype.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/filetype.vim" | |
Searching for "/etc/xdg/nvim/filetype.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/filetype.vim" | |
Searching for "/usr/local/share/nvim/site/filetype.vim" | |
Searching for "/usr/share/nvim/site/filetype.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/filetype.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 72: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/filetype.vim" | |
line 1: " Vim support file to detect file types | |
line 2: " | |
line 3: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 4: " Last Change:^I2015 Jan 07 | |
line 5: | |
line 6: " Listen very carefully, I will say this only once | |
line 7: if exists("did_load_filetypes") | |
line 8: finish | |
line 9: endif | |
line 10: let did_load_filetypes = 1 | |
line 11: | |
line 12: " Line continuation is used here, remove 'C' from 'cpoptions' | |
line 13: let s:cpo_save = &cpo | |
line 14: set cpo&vim | |
line 15: | |
line 16: augroup filetypedetect | |
line 17: | |
line 18: " Ignored extensions | |
line 19: if exists("*fnameescape") | |
line 21: au BufNewFile,BufRead ?\+.orig,?\+.bak,?\+.old,?\+.new,?\+.dpkg-dist,?\+.dpkg-old,?\+.dpkg-new,?\+.dpkg-bak,?\+.rpmsave,?\+.rpmnew,?\+.pacsave,?\+.pacnew exe "doau filetypedetect BufRead " . fnameescape(expand("<afile>:r")) | |
line 28: au BufNewFile,BufRead *~ let s:name = expand("<afile>") | let s:short = substitute(s:name, '\~$', '', '') | if s:name != s:short && s:short != "" | exe "doau filetypedetect BufRead " . fnameescape(s:short) | endif | unlet! s:name s:short | |
line 32: au BufNewFile,BufRead ?\+.in if expand("<afile>:t") != "configure.in" | exe "doau filetypedetect BufRead " . fnameescape(expand("<afile>:r")) | endif | |
line 33: elseif &verbose > 0 | |
line 34: echomsg "Warning: some filetypes will not be recognized because this version of Vim does not have fnameescape()" | |
line 35: endif | |
line 36: | |
line 37: " Pattern used to match file names which should not be inspected. | |
line 38: " Currently finds compressed files. | |
line 39: if !exists("g:ft_ignore_pat") | |
line 40: let g:ft_ignore_pat = '\.\(Z\|gz\|bz2\|zip\|tgz\)$' | |
line 41: endif | |
line 42: | |
line 43: " Function used for patterns that end in a star: don't set the filetype if the | |
line 44: " file name matches ft_ignore_pat. | |
line 45: func! s:StarSetf(ft) | |
line 50: | |
line 51: " Abaqus or Trasys | |
line 52: au BufNewFile,BufRead *.inp^I^I^Icall s:Check_inp() | |
line 53: | |
line 54: func! s:Check_inp() | |
line 73: | |
line 74: " A-A-P recipe | |
line 75: au BufNewFile,BufRead *.aap^I^I^Isetf aap | |
line 76: | |
line 77: " A2ps printing utility | |
line 78: au BufNewFile,BufRead */etc/a2ps.cfg,*/etc/a2ps/*.cfg,a2psrc,.a2psrc setf a2ps | |
line 79: | |
line 80: " ABAB/4 | |
line 81: au BufNewFile,BufRead *.abap^I^I^Isetf abap | |
line 82: | |
line 83: " ABC music notation | |
line 84: au BufNewFile,BufRead *.abc^I^I^Isetf abc | |
line 85: | |
line 86: " ABEL | |
line 87: au BufNewFile,BufRead *.abl^I^I^Isetf abel | |
line 88: | |
line 89: " AceDB | |
line 90: au BufNewFile,BufRead *.wrm^I^I^Isetf acedb | |
line 91: | |
line 92: " Ada (83, 9X, 95) | |
line 93: au BufNewFile,BufRead *.adb,*.ads,*.ada^I^Isetf ada | |
line 94: au BufNewFile,BufRead *.gpr^I^I^Isetf ada | |
line 95: | |
line 96: " AHDL | |
line 97: au BufNewFile,BufRead *.tdf^I^I^Isetf ahdl | |
line 98: | |
line 99: " AMPL | |
line 100: au BufNewFile,BufRead *.run^I^I^Isetf ampl | |
line 101: | |
line 102: " Ant | |
line 103: au BufNewFile,BufRead build.xml^I^I^Isetf ant | |
line 104: | |
line 105: " Arduino | |
line 106: au BufNewFile,BufRead *.ino,*.pde^I^Isetf arduino | |
line 107: | |
line 108: " Apache style config file | |
line 109: au BufNewFile,BufRead proftpd.conf*^I^Icall s:StarSetf('apachestyle') | |
line 110: | |
line 111: " Apache config file | |
line 112: au BufNewFile,BufRead .htaccess,*/etc/httpd/*.conf^I^Isetf apache | |
line 113: | |
line 114: " XA65 MOS6510 cross assembler | |
line 115: au BufNewFile,BufRead *.a65^I^I^Isetf a65 | |
line 116: | |
line 117: " Applescript | |
line 118: au BufNewFile,BufRead *.scpt^I^I^Isetf applescript | |
line 119: | |
line 120: " Applix ELF | |
line 122: au BufNewFile,BufRead *.am if expand("<afile>") !~? 'Makefile.am\>' | setf elf | endif | |
line 123: | |
line 124: " ALSA configuration | |
line 125: au BufNewFile,BufRead .asoundrc,*/usr/share/alsa/alsa.conf,*/etc/asound.conf setf alsaconf | |
line 126: | |
line 127: " Arc Macro Language | |
line 128: au BufNewFile,BufRead *.aml^I^I^Isetf aml | |
line 129: | |
line 130: " APT config file | |
line 131: au BufNewFile,BufRead apt.conf^I^I setf aptconf | |
line 132: au BufNewFile,BufRead */.aptitude/config setf aptconf | |
line 133: au BufNewFile,BufRead */etc/apt/apt.conf.d/{[-_[:alnum:]]\+,[-_.[:alnum:]]\+.conf} setf aptconf | |
line 134: | |
line 135: " Arch Inventory file | |
line 136: au BufNewFile,BufRead .arch-inventory,=tagging-method^Isetf arch | |
line 137: | |
line 138: " ART*Enterprise (formerly ART-IM) | |
line 139: au BufNewFile,BufRead *.art^I^I^Isetf art | |
line 140: | |
line 141: " AsciiDoc | |
line 142: au BufNewFile,BufRead *.asciidoc^I^Isetf asciidoc | |
line 143: | |
line 144: " ASN.1 | |
line 145: au BufNewFile,BufRead *.asn,*.asn1^I^Isetf asn | |
line 146: | |
line 147: " Active Server Pages (with Visual Basic Script) | |
line 153: au BufNewFile,BufRead *.asa if exists("g:filetype_asa") | exe "setf " . g:filetype_asa | else | setf aspvbs | endif | |
line 154: | |
line 155: " Active Server Pages (with Perl or Visual Basic Script) | |
line 163: au BufNewFile,BufRead *.asp if exists("g:filetype_asp") | exe "setf " . g:filetype_asp | elseif getline(1) . getline(2) . getline(3) =~? "perlscript" | setf aspperl | else | setf aspvbs | endif | |
line 164: | |
line 165: " Grub (must be before catch *.lst) | |
line 166: au BufNewFile,BufRead */boot/grub/menu.lst,*/boot/grub/grub.conf,*/etc/grub.conf setf grub | |
line 167: | |
line 168: " Assembly (all kinds) | |
line 169: " *.lst is not pure assembly, it has two extra columns (address, byte codes) | |
line 170: au BufNewFile,BufRead *.asm,*.[sS],*.[aA],*.mac,*.lst^Icall s:FTasm() | |
line 171: | |
line 172: " This function checks for the kind of assembly that is wanted by the user, or | |
line 173: " can be detected from the first five lines of the file. | |
line 174: func! s:FTasm() | |
line 195: | |
line 196: func! s:FTasmsyntax() | |
line 208: | |
line 209: " Macro (VAX) | |
line 210: au BufNewFile,BufRead *.mar^I^I^Isetf vmasm | |
line 211: | |
line 212: " Atlas | |
line 213: au BufNewFile,BufRead *.atl,*.as^I^Isetf atlas | |
line 214: | |
line 215: " Autoit v3 | |
line 216: au BufNewFile,BufRead *.au3^I^I^Isetf autoit | |
line 217: | |
line 218: " Autohotkey | |
line 219: au BufNewFile,BufRead *.ahk^I^I^Isetf autohotkey | |
line 220: | |
line 221: " Automake | |
line 222: au BufNewFile,BufRead [mM]akefile.am,GNUmakefile.am^Isetf automake | |
line 223: | |
line 224: " Autotest .at files are actually m4 | |
line 225: au BufNewFile,BufRead *.at^I^I^Isetf m4 | |
line 226: | |
line 227: " Avenue | |
line 228: au BufNewFile,BufRead *.ave^I^I^Isetf ave | |
line 229: | |
line 230: " Awk | |
line 231: au BufNewFile,BufRead *.awk^I^I^Isetf awk | |
line 232: | |
line 233: " B | |
line 234: au BufNewFile,BufRead *.mch,*.ref,*.imp^I^Isetf b | |
line 235: | |
line 236: " BASIC or Visual Basic | |
line 237: au BufNewFile,BufRead *.bas^I^I^Icall s:FTVB("basic") | |
line 238: | |
line 239: " Check if one of the first five lines contains "VB_Name". In that case it is | |
line 240: " probably a Visual Basic file. Otherwise it's assumed to be "alt" filetype. | |
line 241: func! s:FTVB(alt) | |
line 248: | |
line 249: " Visual Basic Script (close to Visual Basic) or Visual Basic .NET | |
line 250: au BufNewFile,BufRead *.vb,*.vbs,*.dsm,*.ctl^Isetf vb | |
line 251: | |
line 252: " IBasic file (similar to QBasic) | |
line 253: au BufNewFile,BufRead *.iba,*.ibi^I^Isetf ibasic | |
line 254: | |
line 255: " FreeBasic file (similar to QBasic) | |
line 256: au BufNewFile,BufRead *.fb,*.bi^I^I^Isetf freebasic | |
line 257: | |
line 258: " Batch file for MSDOS. | |
line 259: au BufNewFile,BufRead *.bat,*.sys^I^Isetf dosbatch | |
line 260: " *.cmd is close to a Batch file, but on OS/2 Rexx files also use *.cmd. | |
line 262: au BufNewFile,BufRead *.cmd if getline(1) =~ '^/\*' | setf rexx | else | setf dosbatch | endif | |
line 263: | |
line 264: " Batch file for 4DOS | |
line 265: au BufNewFile,BufRead *.btm^I^I^Icall s:FTbtm() | |
line 266: func! s:FTbtm() | |
line 273: | |
line 274: " BC calculator | |
line 275: au BufNewFile,BufRead *.bc^I^I^Isetf bc | |
line 276: | |
line 277: " BDF font | |
line 278: au BufNewFile,BufRead *.bdf^I^I^Isetf bdf | |
line 279: | |
line 280: " BibTeX bibliography database file | |
line 281: au BufNewFile,BufRead *.bib^I^I^Isetf bib | |
line 282: | |
line 283: " BibTeX Bibliography Style | |
line 284: au BufNewFile,BufRead *.bst^I^I^Isetf bst | |
line 285: | |
line 286: " BIND configuration | |
line 287: au BufNewFile,BufRead named.conf,rndc.conf^Isetf named | |
line 288: | |
line 289: " BIND zone | |
line 290: au BufNewFile,BufRead named.root^I^Isetf bindzone | |
line 291: au BufNewFile,BufRead *.db^I^I^Icall s:BindzoneCheck('') | |
line 292: | |
line 293: func! s:BindzoneCheck(default) | |
line 300: | |
line 301: " Blank | |
line 302: au BufNewFile,BufRead *.bl^I^I^Isetf blank | |
line 303: | |
line 304: " Blkid cache file | |
line 305: au BufNewFile,BufRead */etc/blkid.tab,*/etc/blkid.tab.old setf xml | |
line 306: | |
line 307: " C or lpc | |
line 308: au BufNewFile,BufRead *.c^I^I^Icall s:FTlpc() | |
line 309: | |
line 310: func! s:FTlpc() | |
line 323: | |
line 324: " Calendar | |
line 325: au BufNewFile,BufRead calendar^I^I^Isetf calendar | |
line 326: | |
line 327: " C# | |
line 328: au BufNewFile,BufRead *.cs^I^I^Isetf cs | |
line 329: | |
line 330: " CSDL | |
line 331: au BufNewFile,BufRead *.csdl^I^I^Isetf csdl | |
line 332: | |
line 333: " Cabal | |
line 334: au BufNewFile,BufRead *.cabal^I^I^Isetf cabal | |
line 335: | |
line 336: " Cdrdao TOC | |
line 337: au BufNewFile,BufRead *.toc^I^I^Isetf cdrtoc | |
line 338: | |
line 339: " Cdrdao config | |
line 340: au BufNewFile,BufRead */etc/cdrdao.conf,*/etc/defaults/cdrdao,*/etc/default/cdrdao,.cdrdao^Isetf cdrdaoconf | |
line 341: | |
line 342: " Cfengine | |
line 343: au BufNewFile,BufRead cfengine.conf^I^Isetf cfengine | |
line 344: | |
line 345: " ChaiScript | |
line 346: au BufRead,BufNewFile *.chai^I^I^Isetf chaiscript | |
line 347: | |
line 348: " Comshare Dimension Definition Language | |
line 349: au BufNewFile,BufRead *.cdl^I^I^Isetf cdl | |
line 350: | |
line 351: " Conary Recipe | |
line 352: au BufNewFile,BufRead *.recipe^I^I^Isetf conaryrecipe | |
line 353: | |
line 354: " Controllable Regex Mutilator | |
line 355: au BufNewFile,BufRead *.crm^I^I^Isetf crm | |
line 356: | |
line 357: " Cyn++ | |
line 358: au BufNewFile,BufRead *.cyn^I^I^Isetf cynpp | |
line 359: | |
line 360: " Cynlib | |
line 361: " .cc and .cpp files can be C++ or Cynlib. | |
line 363: au BufNewFile,BufRead *.cc if exists("cynlib_syntax_for_cc")|setf cynlib|else|setf cpp|endif | |
line 365: au BufNewFile,BufRead *.cpp if exists("cynlib_syntax_for_cpp")|setf cynlib|else|setf cpp|endif | |
line 366: | |
line 367: " C++ | |
line 368: au BufNewFile,BufRead *.cxx,*.c++,*.hh,*.hxx,*.hpp,*.ipp,*.moc,*.tcc,*.inl setf cpp | |
line 369: if has("fname_case") | |
line 370: au BufNewFile,BufRead *.C,*.H setf cpp | |
line 371: endif | |
line 372: | |
line 373: " .h files can be C, Ch C++, ObjC or ObjC++. | |
line 374: " Set c_syntax_for_h if you want C, ch_syntax_for_h if you want Ch. ObjC is | |
line 375: " detected automatically. | |
line 376: au BufNewFile,BufRead *.h^I^I^Icall s:FTheader() | |
line 377: | |
line 378: func! s:FTheader() | |
line 393: | |
line 394: " Ch (CHscript) | |
line 395: au BufNewFile,BufRead *.chf^I^I^Isetf ch | |
line 396: | |
line 397: " TLH files are C++ headers generated by Visual C++'s #import from typelibs | |
line 398: au BufNewFile,BufRead *.tlh^I^I^Isetf cpp | |
line 399: | |
line 400: " Cascading Style Sheets | |
line 401: au BufNewFile,BufRead *.css^I^I^Isetf css | |
line 402: | |
line 403: " Century Term Command Scripts (*.cmd too) | |
line 404: au BufNewFile,BufRead *.con^I^I^Isetf cterm | |
line 405: | |
line 406: " Changelog | |
line 408: au BufNewFile,BufRead changelog.Debian,changelog.dch,NEWS.Debian,NEWS.dch^Isetf debchangelog | |
line 409: | |
line 415: au BufNewFile,BufRead [cC]hange[lL]og if getline(1) =~ '; urgency='| setf debchangelog| else| setf changelog| endif | |
line 416: | |
line 420: au BufNewFile,BufRead NEWS if getline(1) =~ '; urgency='| setf debchangelog| endif | |
line 421: | |
line 422: " CHILL | |
line 423: au BufNewFile,BufRead *..ch^I^I^Isetf chill | |
line 424: | |
line 425: " Changes for WEB and CWEB or CHILL | |
line 426: au BufNewFile,BufRead *.ch^I^I^Icall s:FTchange() | |
line 427: | |
line 428: " This function checks if one of the first ten lines start with a '@'. In | |
line 429: " that case it is probably a change file. | |
line 430: " If the first line starts with # or ! it's probably a ch file. | |
line 431: " If a line has "main", "include", "//" ir "/*" it's probably ch. | |
line 432: " Otherwise CHILL is assumed. | |
line 433: func! s:FTchange() | |
line 456: | |
line 457: " ChordPro | |
line 458: au BufNewFile,BufRead *.chopro,*.crd,*.cho,*.crdpro,*.chordpro^Isetf chordpro | |
line 459: | |
line 460: " Clean | |
line 461: au BufNewFile,BufRead *.dcl,*.icl^I^Isetf clean | |
line 462: | |
line 463: " Clever | |
line 464: au BufNewFile,BufRead *.eni^I^I^Isetf cl | |
line 465: | |
line 466: " Clever or dtd | |
line 467: au BufNewFile,BufRead *.ent^I^I^Icall s:FTent() | |
line 468: | |
line 469: func! s:FTent() | |
line 488: | |
line 489: " Clipper (or FoxPro; could also be eviews) | |
line 495: au BufNewFile,BufRead *.prg if exists("g:filetype_prg") | exe "setf " . g:filetype_prg | else | setf clipper | endif | |
line 496: | |
line 497: " Clojure | |
line 498: au BufNewFile,BufRead *.clj,*.cljs^I^Isetf clojure | |
line 499: | |
line 500: " Cmake | |
line 501: au BufNewFile,BufRead CMakeLists.txt,*.cmake,*.cmake.in^I^Isetf cmake | |
line 502: | |
line 503: " Cmusrc | |
line 504: au BufNewFile,BufRead */.cmus/{autosave,rc,command-history,*.theme} setf cmusrc | |
line 505: au BufNewFile,BufRead */cmus/{rc,*.theme}^I^I^Isetf cmusrc | |
line 506: | |
line 507: " Cobol | |
line 508: au BufNewFile,BufRead *.cbl,*.cob,*.lib^Isetf cobol | |
line 509: " cobol or zope form controller python script? (heuristic) | |
line 515: au BufNewFile,BufRead *.cpy if getline(1) =~ '^##' | setf python | else | setf cobol | endif | |
line 516: | |
line 517: " Coco/R | |
line 518: au BufNewFile,BufRead *.atg^I^I^Isetf coco | |
line 519: | |
line 520: " Cold Fusion | |
line 521: au BufNewFile,BufRead *.cfm,*.cfi,*.cfc^I^Isetf cf | |
line 522: | |
line 523: " Configure scripts | |
line 524: au BufNewFile,BufRead configure.in,configure.ac setf config | |
line 525: | |
line 526: " CUDA Cumpute Unified Device Architecture | |
line 527: au BufNewFile,BufRead *.cu^I^I^Isetf cuda | |
line 528: | |
line 529: " Dockerfile | |
line 530: au BufNewFile,BufRead Dockerfile^I^Isetf dockerfile | |
line 531: | |
line 532: " WildPackets EtherPeek Decoder | |
line 533: au BufNewFile,BufRead *.dcd^I^I^Isetf dcd | |
line 534: | |
line 535: " Enlightenment configuration files | |
line 536: au BufNewFile,BufRead *enlightenment/*.cfg^Isetf c | |
line 537: | |
line 538: " Eterm | |
line 539: au BufNewFile,BufRead *Eterm/*.cfg^I^Isetf eterm | |
line 540: | |
line 541: " Euphoria 3 or 4 | |
line 542: au BufNewFile,BufRead *.eu,*.ew,*.ex,*.exu,*.exw call s:EuphoriaCheck() | |
line 543: if has("fname_case") | |
line 544: au BufNewFile,BufRead *.EU,*.EW,*.EX,*.EXU,*.EXW call s:EuphoriaCheck() | |
line 545: endif | |
line 546: | |
line 547: func! s:EuphoriaCheck() | |
line 554: | |
line 555: " Lynx config files | |
line 556: au BufNewFile,BufRead lynx.cfg^I^I^Isetf lynx | |
line 557: | |
line 558: " Quake | |
line 559: au BufNewFile,BufRead *baseq[2-3]/*.cfg,*id1/*.cfg^Isetf quake | |
line 560: au BufNewFile,BufRead *quake[1-3]/*.cfg^I^I^Isetf quake | |
line 561: | |
line 562: " Quake C | |
line 563: au BufNewFile,BufRead *.qc^I^I^Isetf c | |
line 564: | |
line 565: " Configure files | |
line 566: au BufNewFile,BufRead *.cfg^I^I^Isetf cfg | |
line 567: | |
line 568: " Cucumber | |
line 569: au BufNewFile,BufRead *.feature^I^I^Isetf cucumber | |
line 570: | |
line 571: " Communicating Sequential Processes | |
line 572: au BufNewFile,BufRead *.csp,*.fdr^I^Isetf csp | |
line 573: | |
line 574: " CUPL logic description and simulation | |
line 575: au BufNewFile,BufRead *.pld^I^I^Isetf cupl | |
line 576: au BufNewFile,BufRead *.si^I^I^Isetf cuplsim | |
line 577: | |
line 578: " Debian Control | |
line 579: au BufNewFile,BufRead */debian/control^I^Isetf debcontrol | |
line 583: au BufNewFile,BufRead control if getline(1) =~ '^Source:'| setf debcontrol| endif | |
line 584: | |
line 585: " Debian Sources.list | |
line 586: au BufNewFile,BufRead */etc/apt/sources.list^I^Isetf debsources | |
line 587: au BufNewFile,BufRead */etc/apt/sources.list.d/*.list^Isetf debsources | |
line 588: | |
line 589: " Deny hosts | |
line 590: au BufNewFile,BufRead denyhosts.conf^I^Isetf denyhosts | |
line 591: | |
line 592: " dnsmasq(8) configuration files | |
line 593: au BufNewFile,BufRead */etc/dnsmasq.conf^Isetf dnsmasq | |
line 594: | |
line 595: " ROCKLinux package description | |
line 596: au BufNewFile,BufRead *.desc^I^I^Isetf desc | |
line 597: | |
line 598: " the D language or dtrace | |
line 599: au BufNewFile,BufRead *.d^I^I^Icall s:DtraceCheck() | |
line 600: | |
line 601: func! s:DtraceCheck() | |
line 612: | |
line 613: " Desktop files | |
line 614: au BufNewFile,BufRead *.desktop,.directory^Isetf desktop | |
line 615: | |
line 616: " Dict config | |
line 617: au BufNewFile,BufRead dict.conf,.dictrc^I^Isetf dictconf | |
line 618: | |
line 619: " Dictd config | |
line 620: au BufNewFile,BufRead dictd.conf^I^Isetf dictdconf | |
line 621: | |
line 622: " Diff files | |
line 623: au BufNewFile,BufRead *.diff,*.rej,*.patch^Isetf diff | |
line 624: | |
line 625: " Dircolors | |
line 626: au BufNewFile,BufRead .dir_colors,.dircolors,*/etc/DIR_COLORS^Isetf dircolors | |
line 627: | |
line 628: " Diva (with Skill) or InstallShield | |
line 634: au BufNewFile,BufRead *.rul if getline(1).getline(2).getline(3).getline(4).getline(5).getline(6) =~? 'InstallShield' | setf ishd | else | setf diva | endif | |
line 635: | |
line 636: " DCL (Digital Command Language - vms) or DNS zone file | |
line 637: au BufNewFile,BufRead *.com^I^I^Icall s:BindzoneCheck('dcl') | |
line 638: | |
line 639: " DOT | |
line 640: au BufNewFile,BufRead *.dot^I^I^Isetf dot | |
line 641: | |
line 642: " Dylan - lid files | |
line 643: au BufNewFile,BufRead *.lid^I^I^Isetf dylanlid | |
line 644: | |
line 645: " Dylan - intr files (melange) | |
line 646: au BufNewFile,BufRead *.intr^I^I^Isetf dylanintr | |
line 647: | |
line 648: " Dylan | |
line 649: au BufNewFile,BufRead *.dylan^I^I^Isetf dylan | |
line 650: | |
line 651: " Microsoft Module Definition | |
line 652: au BufNewFile,BufRead *.def^I^I^Isetf def | |
line 653: | |
line 654: " Dracula | |
line 655: au BufNewFile,BufRead *.drac,*.drc,*lvs,*lpe^Isetf dracula | |
line 656: | |
line 657: " Datascript | |
line 658: au BufNewFile,BufRead *.ds^I^I^Isetf datascript | |
line 659: | |
line 660: " dsl | |
line 661: au BufNewFile,BufRead *.dsl^I^I^Isetf dsl | |
line 662: | |
line 663: " DTD (Document Type Definition for XML) | |
line 664: au BufNewFile,BufRead *.dtd^I^I^Isetf dtd | |
line 665: | |
line 666: " DTS/DSTI (device tree files) | |
line 667: au BufNewFile,BufRead *.dts,*.dtsi^I^Isetf dts | |
line 668: | |
line 669: " EDIF (*.edf,*.edif,*.edn,*.edo) | |
line 670: au BufNewFile,BufRead *.ed\(f\|if\|n\|o\)^Isetf edif | |
line 671: | |
line 672: " Embedix Component Description | |
line 673: au BufNewFile,BufRead *.ecd^I^I^Isetf ecd | |
line 674: | |
line 675: " Eiffel or Specman or Euphoria | |
line 676: au BufNewFile,BufRead *.e,*.E^I^I^Icall s:FTe() | |
line 677: | |
line 678: " Elinks configuration | |
line 679: au BufNewFile,BufRead */etc/elinks.conf,*/.elinks/elinks.conf^Isetf elinks | |
line 680: | |
line 681: func! s:FTe() | |
line 696: | |
line 697: " ERicsson LANGuage; Yaws is erlang too | |
line 698: au BufNewFile,BufRead *.erl,*.hrl,*.yaws^Isetf erlang | |
line 699: | |
line 700: " Elm Filter Rules file | |
line 701: au BufNewFile,BufRead filter-rules^I^Isetf elmfilt | |
line 702: | |
line 703: " ESMTP rc file | |
line 704: au BufNewFile,BufRead *esmtprc^I^I^Isetf esmtprc | |
line 705: | |
line 706: " ESQL-C | |
line 707: au BufNewFile,BufRead *.ec,*.EC^I^I^Isetf esqlc | |
line 708: | |
line 709: " Esterel | |
line 710: au BufNewFile,BufRead *.strl^I^I^Isetf esterel | |
line 711: | |
line 712: " Essbase script | |
line 713: au BufNewFile,BufRead *.csc^I^I^Isetf csc | |
line 714: | |
line 715: " Exim | |
line 716: au BufNewFile,BufRead exim.conf^I^I^Isetf exim | |
line 717: | |
line 718: " Expect | |
line 719: au BufNewFile,BufRead *.exp^I^I^Isetf expect | |
line 720: | |
line 721: " Exports | |
line 722: au BufNewFile,BufRead exports^I^I^Isetf exports | |
line 723: | |
line 724: " Falcon | |
line 725: au BufNewFile,BufRead *.fal^I^I^Isetf falcon | |
line 726: | |
line 727: " Fantom | |
line 728: au BufNewFile,BufRead *.fan,*.fwt^I^Isetf fan | |
line 729: | |
line 730: " Factor | |
line 731: au BufNewFile,BufRead *.factor^I^I^Isetf factor | |
line 732: | |
line 733: " Fetchmail RC file | |
line 734: au BufNewFile,BufRead .fetchmailrc^I^Isetf fetchmail | |
line 735: | |
line 736: " FlexWiki - disabled, because it has side effects when a .wiki file | |
line 737: " is not actually FlexWiki | |
line 738: "au BufNewFile,BufRead *.wiki^I^I^Isetf flexwiki | |
line 739: | |
line 740: " Focus Executable | |
line 741: au BufNewFile,BufRead *.fex,*.focexec^I^Isetf focexec | |
line 742: | |
line 743: " Focus Master file (but not for auto.master) | |
line 744: au BufNewFile,BufRead auto.master^I^Isetf conf | |
line 745: au BufNewFile,BufRead *.mas,*.master^I^Isetf master | |
line 746: | |
line 747: " Forth | |
line 748: au BufNewFile,BufRead *.fs,*.ft^I^I^Isetf forth | |
line 749: | |
line 750: " Reva Forth | |
line 751: au BufNewFile,BufRead *.frt^I^I^Isetf reva | |
line 752: | |
line 753: " Fortran | |
line 754: if has("fname_case") | |
line 755: au BufNewFile,BufRead *.F,*.FOR,*.FPP,*.FTN,*.F77,*.F90,*.F95,*.F03,*.F08^I setf fortran | |
line 756: endif | |
line 757: au BufNewFile,BufRead *.f,*.for,*.fortran,*.fpp,*.ftn,*.f77,*.f90,*.f95,*.f03,*.f08 setf fortran | |
line 758: | |
line 759: " Framescript | |
line 760: au BufNewFile,BufRead *.fsl^I^I^Isetf framescript | |
line 761: | |
line 762: " FStab | |
line 763: au BufNewFile,BufRead fstab,mtab^I^Isetf fstab | |
line 764: | |
line 765: " GDB command files | |
line 766: au BufNewFile,BufRead .gdbinit^I^I^Isetf gdb | |
line 767: | |
line 768: " GDMO | |
line 769: au BufNewFile,BufRead *.mo,*.gdmo^I^Isetf gdmo | |
line 770: | |
line 771: " Gedcom | |
line 772: au BufNewFile,BufRead *.ged,lltxxxxx.txt^Isetf gedcom | |
line 773: | |
line 774: " Git | |
line 775: au BufNewFile,BufRead *.git/COMMIT_EDITMSG^Isetf gitcommit | |
line 776: au BufNewFile,BufRead *.git/MERGE_MSG^I^Isetf gitcommit | |
line 777: au BufNewFile,BufRead *.git/config,.gitconfig,.gitmodules setf gitconfig | |
line 778: au BufNewFile,BufRead *.git/modules/*/COMMIT_EDITMSG setf gitcommit | |
line 779: au BufNewFile,BufRead *.git/modules/*/config^Isetf gitconfig | |
line 780: au BufNewFile,BufRead */.config/git/config^Isetf gitconfig | |
line 781: if !empty($XDG_CONFIG_HOME) | |
line 782: au BufNewFile,BufRead $XDG_CONFIG_HOME/git/config^Isetf gitconfig | |
line 783: endif | |
line 784: au BufNewFile,BufRead git-rebase-todo^I^Isetf gitrebase | |
line 788: au BufNewFile,BufRead .msg.[0-9]* if getline(1) =~ '^From.*# This line is ignored.$' | setf gitsendemail | endif | |
line 792: au BufNewFile,BufRead *.git/* if getline(1) =~ '^\x\{40\}\>\|^ref: ' | setf git | endif | |
line 793: | |
line 794: " Gkrellmrc | |
line 795: au BufNewFile,BufRead gkrellmrc,gkrellmrc_?^Isetf gkrellmrc | |
line 796: | |
line 797: " GP scripts (2.0 and onward) | |
line 798: au BufNewFile,BufRead *.gp,.gprc^I^Isetf gp | |
line 799: | |
line 800: " GPG | |
line 801: au BufNewFile,BufRead */.gnupg/options^I^Isetf gpg | |
line 802: au BufNewFile,BufRead */.gnupg/gpg.conf^I^Isetf gpg | |
line 803: au BufNewFile,BufRead */usr/*/gnupg/options.skel setf gpg | |
line 804: | |
line 805: " gnash(1) configuration files | |
line 806: au BufNewFile,BufRead gnashrc,.gnashrc,gnashpluginrc,.gnashpluginrc setf gnash | |
line 807: | |
line 808: " Gitolite | |
line 809: au BufNewFile,BufRead gitolite.conf^I^Isetf gitolite | |
line 810: au BufNewFile,BufRead */gitolite-admin/conf/*^Icall s:StarSetf('gitolite') | |
line 811: au BufNewFile,BufRead {,.}gitolite.rc,example.gitolite.rc^Isetf perl | |
line 812: | |
line 813: " Gnuplot scripts | |
line 814: au BufNewFile,BufRead *.gpi^I^I^Isetf gnuplot | |
line 815: | |
line 816: " Go (Google) | |
line 817: au BufNewFile,BufRead *.go^I^I^Isetf go | |
line 818: | |
line 819: " GrADS scripts | |
line 820: au BufNewFile,BufRead *.gs^I^I^Isetf grads | |
line 821: | |
line 822: " Gretl | |
line 823: au BufNewFile,BufRead *.gretl^I^I^Isetf gretl | |
line 824: | |
line 825: " Groovy | |
line 826: au BufNewFile,BufRead *.groovy^I^I^Isetf groovy | |
line 827: | |
line 828: " GNU Server Pages | |
line 829: au BufNewFile,BufRead *.gsp^I^I^Isetf gsp | |
line 830: | |
line 831: " Group file | |
line 832: au BufNewFile,BufRead */etc/group,*/etc/group-,*/etc/group.edit,*/etc/gshadow,*/etc/gshadow-,*/etc/gshadow.edit,*/var/backups/group.bak,*/var/backups/gshadow.bak setf group | |
line 833: | |
line 834: " GTK RC | |
line 835: au BufNewFile,BufRead .gtkrc,gtkrc^I^Isetf gtkrc | |
line 836: | |
line 837: " Haml | |
line 838: au BufNewFile,BufRead *.haml^I^I^Isetf haml | |
line 839: | |
line 840: " Hamster Classic | Playground files | |
line 841: au BufNewFile,BufRead *.hsc,*.hsm^I^Isetf hamster | |
line 842: | |
line 843: " Haskell | |
line 844: au BufNewFile,BufRead *.hs,*.hs-boot^I^Isetf haskell | |
line 845: au BufNewFile,BufRead *.lhs^I^I^Isetf lhaskell | |
line 846: au BufNewFile,BufRead *.chs^I^I^Isetf chaskell | |
line 847: | |
line 848: " Haste | |
line 849: au BufNewFile,BufRead *.ht^I^I^Isetf haste | |
line 850: au BufNewFile,BufRead *.htpp^I^I^Isetf hastepreproc | |
line 851: | |
line 852: " Hercules | |
line 853: au BufNewFile,BufRead *.vc,*.ev,*.rs,*.sum,*.errsum^Isetf hercules | |
line 854: | |
line 855: " HEX (Intel) | |
line 856: au BufNewFile,BufRead *.hex,*.h32^I^Isetf hex | |
line 857: | |
line 858: " Tilde (must be before HTML) | |
line 859: au BufNewFile,BufRead *.t.html^I^I^Isetf tilde | |
line 860: | |
line 861: " HTML (.shtml and .stm for server side) | |
line 862: au BufNewFile,BufRead *.html,*.htm,*.shtml,*.stm call s:FThtml() | |
line 863: | |
line 864: " Distinguish between HTML, XHTML and Django | |
line 865: func! s:FThtml() | |
line 880: | |
line 881: " HTML with Ruby - eRuby | |
line 882: au BufNewFile,BufRead *.erb,*.rhtml^I^Isetf eruby | |
line 883: | |
line 884: " HTML with M4 | |
line 885: au BufNewFile,BufRead *.html.m4^I^I^Isetf htmlm4 | |
line 886: | |
line 887: " HTML Cheetah template | |
line 888: au BufNewFile,BufRead *.tmpl^I^I^Isetf htmlcheetah | |
line 889: | |
line 890: " Host config | |
line 891: au BufNewFile,BufRead */etc/host.conf^I^Isetf hostconf | |
line 892: | |
line 893: " Hosts access | |
line 894: au BufNewFile,BufRead */etc/hosts.allow,*/etc/hosts.deny setf hostsaccess | |
line 895: | |
line 896: " Hyper Builder | |
line 897: au BufNewFile,BufRead *.hb^I^I^Isetf hb | |
line 898: | |
line 899: " Httest | |
line 900: au BufNewFile,BufRead *.htt,*.htb^I^Isetf httest | |
line 901: | |
line 902: " Icon | |
line 903: au BufNewFile,BufRead *.icn^I^I^Isetf icon | |
line 904: | |
line 905: " IDL (Interface Description Language) | |
line 906: au BufNewFile,BufRead *.idl^I^I^Icall s:FTidl() | |
line 907: | |
line 908: " Distinguish between standard IDL and MS-IDL | |
line 909: func! s:FTidl() | |
line 920: | |
line 921: " Microsoft IDL (Interface Description Language) Also *.idl | |
line 922: " MOF = WMI (Windows Management Instrumentation) Managed Object Format | |
line 923: au BufNewFile,BufRead *.odl,*.mof^I^Isetf msidl | |
line 924: | |
line 925: " Icewm menu | |
line 926: au BufNewFile,BufRead */.icewm/menu^I^Isetf icemenu | |
line 927: | |
line 928: " Indent profile (must come before IDL *.pro!) | |
line 929: au BufNewFile,BufRead .indent.pro^I^Isetf indent | |
line 930: au BufNewFile,BufRead indent.pro^I^Icall s:ProtoCheck('indent') | |
line 931: | |
line 932: " IDL (Interactive Data Language) | |
line 933: au BufNewFile,BufRead *.pro^I^I^Icall s:ProtoCheck('idlang') | |
line 934: | |
line 935: " Distinguish between "default" and Cproto prototype file. */ | |
line 936: func! s:ProtoCheck(default) | |
line 948: | |
line 949: | |
line 950: " Indent RC | |
line 951: au BufNewFile,BufRead indentrc^I^I^Isetf indent | |
line 952: | |
line 953: " Inform | |
line 954: au BufNewFile,BufRead *.inf,*.INF^I^Isetf inform | |
line 955: | |
line 956: " Initng | |
line 957: au BufNewFile,BufRead */etc/initng/*/*.i,*.ii^Isetf initng | |
line 958: | |
line 959: " Innovation Data Processing | |
line 960: au BufRead,BufNewFile upstream.dat\c,upstream.*.dat\c,*.upstream.dat\c ^Isetf upstreamdat | |
line 961: au BufRead,BufNewFile upstream.log\c,upstream.*.log\c,*.upstream.log\c ^Isetf upstreamlog | |
line 962: au BufRead,BufNewFile upstreaminstall.log\c,upstreaminstall.*.log\c,*.upstreaminstall.log\c setf upstreaminstalllog | |
line 963: au BufRead,BufNewFile usserver.log\c,usserver.*.log\c,*.usserver.log\c ^Isetf usserverlog | |
line 964: au BufRead,BufNewFile usw2kagt.log\c,usw2kagt.*.log\c,*.usw2kagt.log\c ^Isetf usw2kagtlog | |
line 965: | |
line 966: " Ipfilter | |
line 967: au BufNewFile,BufRead ipf.conf,ipf6.conf,ipf.rules^Isetf ipfilter | |
line 968: | |
line 969: " Informix 4GL (source - canonical, include file, I4GL+M4 preproc.) | |
line 970: au BufNewFile,BufRead *.4gl,*.4gh,*.m4gl^Isetf fgl | |
line 971: | |
line 972: " .INI file for MSDOS | |
line 973: au BufNewFile,BufRead *.ini^I^I^Isetf dosini | |
line 974: | |
line 975: " SysV Inittab | |
line 976: au BufNewFile,BufRead inittab^I^I^Isetf inittab | |
line 977: | |
line 978: " Inno Setup | |
line 979: au BufNewFile,BufRead *.iss^I^I^Isetf iss | |
line 980: | |
line 981: " J | |
line 982: au BufNewFile,BufRead *.ijs^I^I^Isetf j | |
line 983: | |
line 984: " JAL | |
line 985: au BufNewFile,BufRead *.jal,*.JAL^I^Isetf jal | |
line 986: | |
line 987: " Jam | |
line 988: au BufNewFile,BufRead *.jpl,*.jpr^I^Isetf jam | |
line 989: | |
line 990: " Java | |
line 991: au BufNewFile,BufRead *.java,*.jav^I^Isetf java | |
line 992: | |
line 993: " JavaCC | |
line 994: au BufNewFile,BufRead *.jj,*.jjt^I^Isetf javacc | |
line 995: | |
line 996: " JavaScript, ECMAScript | |
line 997: au BufNewFile,BufRead *.js,*.javascript,*.es,*.jsx setf javascript | |
line 998: | |
line 999: " Java Server Pages | |
line 1000: au BufNewFile,BufRead *.jsp^I^I^Isetf jsp | |
line 1001: | |
line 1002: " Java Properties resource file (note: doesn't catch font.properties.pl) | |
line 1003: au BufNewFile,BufRead *.properties,*.properties_??,*.properties_??_??^Isetf jproperties | |
line 1004: au BufNewFile,BufRead *.properties_??_??_*^Icall s:StarSetf('jproperties') | |
line 1005: | |
line 1006: " Jess | |
line 1007: au BufNewFile,BufRead *.clp^I^I^Isetf jess | |
line 1008: | |
line 1009: " Jgraph | |
line 1010: au BufNewFile,BufRead *.jgr^I^I^Isetf jgraph | |
line 1011: | |
line 1012: " Jovial | |
line 1013: au BufNewFile,BufRead *.jov,*.j73,*.jovial^Isetf jovial | |
line 1014: | |
line 1015: " JSON | |
line 1016: au BufNewFile,BufRead *.json,*.jsonp^I^Isetf json | |
line 1017: | |
line 1018: " Kixtart | |
line 1019: au BufNewFile,BufRead *.kix^I^I^Isetf kix | |
line 1020: | |
line 1021: " Kimwitu[++] | |
line 1022: au BufNewFile,BufRead *.k^I^I^Isetf kwt | |
line 1023: | |
line 1024: " Kivy | |
line 1025: au BufNewFile,BufRead *.kv^I^I^Isetf kivy | |
line 1026: | |
line 1027: " KDE script | |
line 1028: au BufNewFile,BufRead *.ks^I^I^Isetf kscript | |
line 1029: | |
line 1030: " Kconfig | |
line 1031: au BufNewFile,BufRead Kconfig,Kconfig.debug^Isetf kconfig | |
line 1032: | |
line 1033: " Lace (ISE) | |
line 1034: au BufNewFile,BufRead *.ace,*.ACE^I^Isetf lace | |
line 1035: | |
line 1036: " Latte | |
line 1037: au BufNewFile,BufRead *.latte,*.lte^I^Isetf latte | |
line 1038: | |
line 1039: " Limits | |
line 1040: au BufNewFile,BufRead */etc/limits,*/etc/*limits.conf,*/etc/*limits.d/*.conf^Isetf limits | |
line 1041: | |
line 1042: " LambdaProlog (*.mod too, see Modsim) | |
line 1043: au BufNewFile,BufRead *.sig^I^I^Isetf lprolog | |
line 1044: | |
line 1045: " LDAP LDIF | |
line 1046: au BufNewFile,BufRead *.ldif^I^I^Isetf ldif | |
line 1047: | |
line 1048: " Ld loader | |
line 1049: au BufNewFile,BufRead *.ld^I^I^Isetf ld | |
line 1050: | |
line 1051: " Less | |
line 1052: au BufNewFile,BufRead *.less^I^I^Isetf less | |
line 1053: | |
line 1054: " Lex | |
line 1055: au BufNewFile,BufRead *.lex,*.l,*.lxx,*.l++^Isetf lex | |
line 1056: | |
line 1057: " Libao | |
line 1058: au BufNewFile,BufRead */etc/libao.conf,*/.libao^Isetf libao | |
line 1059: | |
line 1060: " Libsensors | |
line 1061: au BufNewFile,BufRead */etc/sensors.conf,*/etc/sensors3.conf^Isetf sensors | |
line 1062: | |
line 1063: " LFTP | |
line 1064: au BufNewFile,BufRead lftp.conf,.lftprc,*lftp/rc^Isetf lftp | |
line 1065: | |
line 1066: " Lifelines (or Lex for C++!) | |
line 1067: au BufNewFile,BufRead *.ll^I^I^Isetf lifelines | |
line 1068: | |
line 1069: " Lilo: Linux loader | |
line 1070: au BufNewFile,BufRead lilo.conf^I^I^Isetf lilo | |
line 1071: | |
line 1072: " Lisp (*.el = ELisp, *.cl = Common Lisp, *.jl = librep Lisp) | |
line 1073: if has("fname_case") | |
line 1074: au BufNewFile,BufRead *.lsp,*.lisp,*.el,*.cl,*.jl,*.L,.emacs,.sawfishrc setf lisp | |
line 1075: else | |
line 1076: au BufNewFile,BufRead *.lsp,*.lisp,*.el,*.cl,*.jl,.emacs,.sawfishrc setf lisp | |
line 1077: endif | |
line 1078: | |
line 1079: " SBCL implementation of Common Lisp | |
line 1080: au BufNewFile,BufRead sbclrc,.sbclrc^I^Isetf lisp | |
line 1081: | |
line 1082: " Liquid | |
line 1083: au BufNewFile,BufRead *.liquid^I^I^Isetf liquid | |
line 1084: | |
line 1085: " Lite | |
line 1086: au BufNewFile,BufRead *.lite,*.lt^I^Isetf lite | |
line 1087: | |
line 1088: " LiteStep RC files | |
line 1089: au BufNewFile,BufRead */LiteStep/*/*.rc^I^Isetf litestep | |
line 1090: | |
line 1091: " Login access | |
line 1092: au BufNewFile,BufRead */etc/login.access^Isetf loginaccess | |
line 1093: | |
line 1094: " Login defs | |
line 1095: au BufNewFile,BufRead */etc/login.defs^I^Isetf logindefs | |
line 1096: | |
line 1097: " Logtalk | |
line 1098: au BufNewFile,BufRead *.lgt^I^I^Isetf logtalk | |
line 1099: | |
line 1100: " LOTOS | |
line 1101: au BufNewFile,BufRead *.lot,*.lotos^I^Isetf lotos | |
line 1102: | |
line 1103: " Lout (also: *.lt) | |
line 1104: au BufNewFile,BufRead *.lou,*.lout^I^Isetf lout | |
line 1105: | |
line 1106: " Lua | |
line 1107: au BufNewFile,BufRead *.lua^I^I^Isetf lua | |
line 1108: | |
line 1109: " Luarocks | |
line 1110: au BufNewFile,BufRead *.rockspec^I^Isetf lua | |
line 1111: | |
line 1112: " Linden Scripting Language (Second Life) | |
line 1113: au BufNewFile,BufRead *.lsl^I^I^Isetf lsl | |
line 1114: | |
line 1115: " Lynx style file (or LotusScript!) | |
line 1116: au BufNewFile,BufRead *.lss^I^I^Isetf lss | |
line 1117: | |
line 1118: " M4 | |
line 1120: au BufNewFile,BufRead *.m4 if expand("<afile>") !~? 'html.m4$\|fvwm2rc' | setf m4 | endif | |
line 1121: | |
line 1122: " MaGic Point | |
line 1123: au BufNewFile,BufRead *.mgp^I^I^Isetf mgp | |
line 1124: | |
line 1125: " Mail (for Elm, trn, mutt, muttng, rn, slrn) | |
line 1126: au BufNewFile,BufRead snd.\d\+,.letter,.letter.\d\+,.followup,.article,.article.\d\+,pico.\d\+,mutt{ng,}-*-\w\+,mutt[[:alnum:]_-]\\\{6\},ae\d\+.txt,/tmp/SLRN[0-9A-Z.]\+,*.eml setf mail | |
line 1127: | |
line 1128: " Mail aliases | |
line 1129: au BufNewFile,BufRead */etc/mail/aliases,*/etc/aliases^Isetf mailaliases | |
line 1130: | |
line 1131: " Mailcap configuration file | |
line 1132: au BufNewFile,BufRead .mailcap,mailcap^I^Isetf mailcap | |
line 1133: | |
line 1134: " Makefile | |
line 1135: au BufNewFile,BufRead *[mM]akefile,*.mk,*.mak,*.dsp setf make | |
line 1136: | |
line 1137: " MakeIndex | |
line 1138: au BufNewFile,BufRead *.ist,*.mst^I^Isetf ist | |
line 1139: | |
line 1140: " Mallard | |
line 1141: au BufNewFile,BufRead *.page^I^I^Isetf mallard | |
line 1142: | |
line 1143: " Manpage | |
line 1144: au BufNewFile,BufRead *.man^I^I^Isetf man | |
line 1145: | |
line 1146: " Man config | |
line 1147: au BufNewFile,BufRead */etc/man.conf,man.config^Isetf manconf | |
line 1148: | |
line 1149: " Maple V | |
line 1150: au BufNewFile,BufRead *.mv,*.mpl,*.mws^I^Isetf maple | |
line 1151: | |
line 1152: " Map (UMN mapserver config file) | |
line 1153: au BufNewFile,BufRead *.map^I^I^Isetf map | |
line 1154: | |
line 1155: " Markdown | |
line 1156: au BufNewFile,BufRead *.markdown,*.mdown,*.mkd,*.mkdn,*.mdwn,*.md setf markdown | |
line 1157: | |
line 1158: " Mason | |
line 1159: au BufNewFile,BufRead *.mason,*.mhtml,*.comp^Isetf mason | |
line 1160: | |
line 1161: " Matlab or Objective C | |
line 1162: au BufNewFile,BufRead *.m^I^I^Icall s:FTm() | |
line 1163: | |
line 1164: func! s:FTm() | |
line 1188: | |
line 1189: " Mathematica notebook | |
line 1190: au BufNewFile,BufRead *.nb^I^I^Isetf mma | |
line 1191: | |
line 1192: " Maya Extension Language | |
line 1193: au BufNewFile,BufRead *.mel^I^I^Isetf mel | |
line 1194: | |
line 1195: " Mercurial (hg) commit file | |
line 1196: au BufNewFile,BufRead hg-editor-*.txt^I^Isetf hgcommit | |
line 1197: | |
line 1198: " Mercurial config (looks like generic config file) | |
line 1199: au BufNewFile,BufRead *.hgrc,*hgrc^I^Isetf cfg | |
line 1200: | |
line 1201: " Messages (logs mostly) | |
line 1202: au BufNewFile,BufRead */log/{auth,cron,daemon,debug,kern,lpr,mail,messages,news/news,syslog,user}{,.log,.err,.info,.warn,.crit,.notice}{,.[0-9]*,-[0-9]*} setf messages | |
line 1203: | |
line 1204: " Metafont | |
line 1205: au BufNewFile,BufRead *.mf^I^I^Isetf mf | |
line 1206: | |
line 1207: " MetaPost | |
line 1208: au BufNewFile,BufRead *.mp^I^I^Isetf mp | |
line 1209: | |
line 1210: " MGL | |
line 1211: au BufNewFile,BufRead *.mgl^I^I^Isetf mgl | |
line 1212: | |
line 1213: " MIX - Knuth assembly | |
line 1214: au BufNewFile,BufRead *.mix,*.mixal^I^Isetf mix | |
line 1215: | |
line 1216: " MMIX or VMS makefile | |
line 1217: au BufNewFile,BufRead *.mms^I^I^Icall s:FTmms() | |
line 1218: | |
line 1219: " Symbian meta-makefile definition (MMP) | |
line 1220: au BufNewFile,BufRead *.mmp^I^I^Isetf mmp | |
line 1221: | |
line 1222: func! s:FTmms() | |
line 1238: | |
line 1239: | |
line 1240: " Modsim III (or LambdaProlog) | |
line 1246: au BufNewFile,BufRead *.mod if getline(1) =~ '\<module\>' | setf lprolog | else | setf modsim3 | endif | |
line 1247: | |
line 1248: " Modula 2 (.md removed in favor of Markdown) | |
line 1249: au BufNewFile,BufRead *.m2,*.DEF,*.MOD,*.mi^Isetf modula2 | |
line 1250: | |
line 1251: " Modula 3 (.m3, .i3, .mg, .ig) | |
line 1252: au BufNewFile,BufRead *.[mi][3g]^I^Isetf modula3 | |
line 1253: | |
line 1254: " Monk | |
line 1255: au BufNewFile,BufRead *.isc,*.monk,*.ssc,*.tsc^Isetf monk | |
line 1256: | |
line 1257: " MOO | |
line 1258: au BufNewFile,BufRead *.moo^I^I^Isetf moo | |
line 1259: | |
line 1260: " Modconf | |
line 1261: au BufNewFile,BufRead */etc/modules.conf,*/etc/modules,*/etc/conf.modules setf modconf | |
line 1262: | |
line 1263: " Mplayer config | |
line 1264: au BufNewFile,BufRead mplayer.conf,*/.mplayer/config^Isetf mplayerconf | |
line 1265: | |
line 1266: " Moterola S record | |
line 1267: au BufNewFile,BufRead *.s19,*.s28,*.s37^I^Isetf srec | |
line 1268: | |
line 1269: " Mrxvtrc | |
line 1270: au BufNewFile,BufRead mrxvtrc,.mrxvtrc^I^Isetf mrxvtrc | |
line 1271: | |
line 1272: " Msql | |
line 1273: au BufNewFile,BufRead *.msql^I^I^Isetf msql | |
line 1274: | |
line 1275: " Mysql | |
line 1276: au BufNewFile,BufRead *.mysql^I^I^Isetf mysql | |
line 1277: | |
line 1278: " Mutt setup files (must be before catch *.rc) | |
line 1279: au BufNewFile,BufRead */etc/Muttrc.d/*^I^Icall s:StarSetf('muttrc') | |
line 1280: | |
line 1281: " M$ Resource files | |
line 1282: au BufNewFile,BufRead *.rc,*.rch^I^Isetf rc | |
line 1283: | |
line 1284: " MuPAD source | |
line 1285: au BufRead,BufNewFile *.mu^I^I^Isetf mupad | |
line 1286: | |
line 1287: " Mush | |
line 1288: au BufNewFile,BufRead *.mush^I^I^Isetf mush | |
line 1289: | |
line 1290: " Mutt setup file (also for Muttng) | |
line 1291: au BufNewFile,BufRead Mutt{ng,}rc^I^Isetf muttrc | |
line 1292: | |
line 1293: " Nano | |
line 1294: au BufNewFile,BufRead */etc/nanorc,.nanorc^Isetf nanorc | |
line 1295: | |
line 1296: " Nastran input/DMAP | |
line 1297: "au BufNewFile,BufRead *.dat^I^I^Isetf nastran | |
line 1298: | |
line 1299: " Natural | |
line 1300: au BufNewFile,BufRead *.NS[ACGLMNPS]^I^Isetf natural | |
line 1301: | |
line 1302: " Netrc | |
line 1303: au BufNewFile,BufRead .netrc^I^I^Isetf netrc | |
line 1304: | |
line 1305: " Ninja file | |
line 1306: au BufNewFile,BufRead *.ninja^I^I^Isetf ninja | |
line 1307: | |
line 1308: " Novell netware batch files | |
line 1309: au BufNewFile,BufRead *.ncf^I^I^Isetf ncf | |
line 1310: | |
line 1311: " Nroff/Troff (*.ms and *.t are checked below) | |
line 1315: au BufNewFile,BufRead *.me if expand("<afile>") != "read.me" && expand("<afile>") != "click.me" | setf nroff | endif | |
line 1316: au BufNewFile,BufRead *.tr,*.nr,*.roff,*.tmac,*.mom^Isetf nroff | |
line 1317: au BufNewFile,BufRead *.[1-9]^I^I^Icall s:FTnroff() | |
line 1318: | |
line 1319: " This function checks if one of the first five lines start with a dot. In | |
line 1320: " that case it is probably an nroff file: 'filetype' is set and 1 is returned. | |
line 1321: func! s:FTnroff() | |
line 1328: | |
line 1329: " Nroff or Objective C++ | |
line 1330: au BufNewFile,BufRead *.mm^I^I^Icall s:FTmm() | |
line 1331: | |
line 1332: func! s:FTmm() | |
line 1344: | |
line 1345: " Not Quite C | |
line 1346: au BufNewFile,BufRead *.nqc^I^I^Isetf nqc | |
line 1347: | |
line 1348: " NSIS | |
line 1349: au BufNewFile,BufRead *.nsi,*.nsh^I^Isetf nsis | |
line 1350: | |
line 1351: " OCAML | |
line 1352: au BufNewFile,BufRead *.ml,*.mli,*.mll,*.mly,.ocamlinit^Isetf ocaml | |
line 1353: | |
line 1354: " Occam | |
line 1355: au BufNewFile,BufRead *.occ^I^I^Isetf occam | |
line 1356: | |
line 1357: " Omnimark | |
line 1358: au BufNewFile,BufRead *.xom,*.xin^I^Isetf omnimark | |
line 1359: | |
line 1360: " OpenROAD | |
line 1361: au BufNewFile,BufRead *.or^I^I^Isetf openroad | |
line 1362: | |
line 1363: " OPL | |
line 1364: au BufNewFile,BufRead *.[Oo][Pp][Ll]^I^Isetf opl | |
line 1365: | |
line 1366: " Oracle config file | |
line 1367: au BufNewFile,BufRead *.ora^I^I^Isetf ora | |
line 1368: | |
line 1369: " Packet filter conf | |
line 1370: au BufNewFile,BufRead pf.conf^I^I^Isetf pf | |
line 1371: | |
line 1372: " Pam conf | |
line 1373: au BufNewFile,BufRead */etc/pam.conf^I^Isetf pamconf | |
line 1374: | |
line 1375: " PApp | |
line 1376: au BufNewFile,BufRead *.papp,*.pxml,*.pxsl^Isetf papp | |
line 1377: | |
line 1378: " Password file | |
line 1379: au BufNewFile,BufRead */etc/passwd,*/etc/passwd-,*/etc/passwd.edit,*/etc/shadow,*/etc/shadow-,*/etc/shadow.edit,*/var/backups/passwd.bak,*/var/backups/shadow.bak setf passwd | |
line 1380: | |
line 1381: " Pascal (also *.p) | |
line 1382: au BufNewFile,BufRead *.pas^I^I^Isetf pascal | |
line 1383: | |
line 1384: " Delphi project file | |
line 1385: au BufNewFile,BufRead *.dpr^I^I^Isetf pascal | |
line 1386: | |
line 1387: " PDF | |
line 1388: au BufNewFile,BufRead *.pdf^I^I^Isetf pdf | |
line 1389: | |
line 1390: " Perl | |
line 1391: if has("fname_case") | |
line 1392: au BufNewFile,BufRead *.pl,*.PL^I^Icall s:FTpl() | |
line 1393: else | |
line 1394: au BufNewFile,BufRead *.pl^I^I^Icall s:FTpl() | |
line 1395: endif | |
line 1396: au BufNewFile,BufRead *.plx,*.al^I^Isetf perl | |
line 1397: au BufNewFile,BufRead *.p6,*.pm6^I^Isetf perl6 | |
line 1398: | |
line 1399: func! s:FTpl() | |
line 1413: | |
line 1414: " Perl, XPM or XPM2 | |
line 1422: au BufNewFile,BufRead *.pm if getline(1) =~ "XPM2" | setf xpm2 | elseif getline(1) =~ "XPM" | setf xpm | else | setf perl | endif | |
line 1423: | |
line 1424: " Perl POD | |
line 1425: au BufNewFile,BufRead *.pod^I^I^Isetf pod | |
line 1426: | |
line 1427: " Php, php3, php4, etc. | |
line 1428: " Also Phtml (was used for PHP 2 in the past) | |
line 1429: " Also .ctp for Cake template file | |
line 1430: au BufNewFile,BufRead *.php,*.php\d,*.phtml,*.ctp^Isetf php | |
line 1431: | |
line 1432: " Pike | |
line 1433: au BufNewFile,BufRead *.pike,*.lpc,*.ulpc,*.pmod setf pike | |
line 1434: | |
line 1435: " Pinfo config | |
line 1436: au BufNewFile,BufRead */etc/pinforc,*/.pinforc^Isetf pinfo | |
line 1437: | |
line 1438: " Palm Resource compiler | |
line 1439: au BufNewFile,BufRead *.rcp^I^I^Isetf pilrc | |
line 1440: | |
line 1441: " Pine config | |
line 1442: au BufNewFile,BufRead .pinerc,pinerc,.pinercex,pinercex^I^Isetf pine | |
line 1443: | |
line 1444: " PL/1, PL/I | |
line 1445: au BufNewFile,BufRead *.pli,*.pl1^I^Isetf pli | |
line 1446: | |
line 1447: " PL/M (also: *.inp) | |
line 1448: au BufNewFile,BufRead *.plm,*.p36,*.pac^I^Isetf plm | |
line 1449: | |
line 1450: " PL/SQL | |
line 1451: au BufNewFile,BufRead *.pls,*.plsql^I^Isetf plsql | |
line 1452: | |
line 1453: " PLP | |
line 1454: au BufNewFile,BufRead *.plp^I^I^Isetf plp | |
line 1455: | |
line 1456: " PO and PO template (GNU gettext) | |
line 1457: au BufNewFile,BufRead *.po,*.pot^I^Isetf po | |
line 1458: | |
line 1459: " Postfix main config | |
line 1460: au BufNewFile,BufRead main.cf^I^I^Isetf pfmain | |
line 1461: | |
line 1462: " PostScript (+ font files, encapsulated PostScript, Adobe Illustrator) | |
line 1463: au BufNewFile,BufRead *.ps,*.pfa,*.afm,*.eps,*.epsf,*.epsi,*.ai^I setf postscr | |
line 1464: | |
line 1465: " PostScript Printer Description | |
line 1466: au BufNewFile,BufRead *.ppd^I^I^Isetf ppd | |
line 1467: | |
line 1468: " Povray | |
line 1469: au BufNewFile,BufRead *.pov^I^I^Isetf pov | |
line 1470: | |
line 1471: " Povray configuration | |
line 1472: au BufNewFile,BufRead .povrayrc^I^I^Isetf povini | |
line 1473: | |
line 1474: " Povray, PHP or assembly | |
line 1475: au BufNewFile,BufRead *.inc^I^I^Icall s:FTinc() | |
line 1476: | |
line 1477: func! s:FTinc() | |
line 1498: | |
line 1499: " Printcap and Termcap | |
line 1501: au BufNewFile,BufRead *printcap let b:ptcap_type = "print" | setf ptcap | |
line 1503: au BufNewFile,BufRead *termcap let b:ptcap_type = "term" | setf ptcap | |
line 1504: | |
line 1505: " PCCTS / ANTRL | |
line 1506: "au BufNewFile,BufRead *.g^I^I^Isetf antrl | |
line 1507: au BufNewFile,BufRead *.g^I^I^Isetf pccts | |
line 1508: | |
line 1509: " PPWizard | |
line 1510: au BufNewFile,BufRead *.it,*.ih^I^I^Isetf ppwiz | |
line 1511: | |
line 1512: " Obj 3D file format | |
line 1513: " TODO: is there a way to avoid MS-Windows Object files? | |
line 1514: au BufNewFile,BufRead *.obj^I^I^Isetf obj | |
line 1515: | |
line 1516: " Oracle Pro*C/C++ | |
line 1517: au BufNewFile,BufRead *.pc^I^I^Isetf proc | |
line 1518: | |
line 1519: " Privoxy actions file | |
line 1520: au BufNewFile,BufRead *.action^I^I^Isetf privoxy | |
line 1521: | |
line 1522: " Procmail | |
line 1523: au BufNewFile,BufRead .procmail,.procmailrc^Isetf procmail | |
line 1524: | |
line 1525: " Progress or CWEB | |
line 1526: au BufNewFile,BufRead *.w^I^I^Icall s:FTprogress_cweb() | |
line 1527: | |
line 1528: func! s:FTprogress_cweb() | |
line 1539: | |
line 1540: " Progress or assembly | |
line 1541: au BufNewFile,BufRead *.i^I^I^Icall s:FTprogress_asm() | |
line 1542: | |
line 1543: func! s:FTprogress_asm() | |
line 1565: | |
line 1566: " Progress or Pascal | |
line 1567: au BufNewFile,BufRead *.p^I^I^Icall s:FTprogress_pascal() | |
line 1568: | |
line 1569: func! s:FTprogress_pascal() | |
line 1593: | |
line 1594: | |
line 1595: " Software Distributor Product Specification File (POSIX 1387.2-1995) | |
line 1596: au BufNewFile,BufRead *.psf^I^I^Isetf psf | |
line 1600: au BufNewFile,BufRead INDEX,INFO if getline(1) =~ '^\s*\(distribution\|installed_software\|root\|bundle\|product\)\s*$' | setf psf | endif | |
line 1601: | |
line 1602: " Prolog | |
line 1603: au BufNewFile,BufRead *.pdb^I^I^Isetf prolog | |
line 1604: | |
line 1605: " Promela | |
line 1606: au BufNewFile,BufRead *.pml^I^I^Isetf promela | |
line 1607: | |
line 1608: " Google protocol buffers | |
line 1609: au BufNewFile,BufRead *.proto^I^I^Isetf proto | |
line 1610: | |
line 1611: " Protocols | |
line 1612: au BufNewFile,BufRead */etc/protocols^I^Isetf protocols | |
line 1613: | |
line 1614: " Pyrex | |
line 1615: au BufNewFile,BufRead *.pyx,*.pxd^I^Isetf pyrex | |
line 1616: | |
line 1617: " Python | |
line 1618: au BufNewFile,BufRead *.py,*.pyw^I^Isetf python | |
line 1619: | |
line 1620: " Quixote (Python-based web framework) | |
line 1621: au BufNewFile,BufRead *.ptl^I^I^Isetf python | |
line 1622: | |
line 1623: " Radiance | |
line 1624: au BufNewFile,BufRead *.rad,*.mat^I^Isetf radiance | |
line 1625: | |
line 1626: " Ratpoison config/command files | |
line 1627: au BufNewFile,BufRead .ratpoisonrc,ratpoisonrc^Isetf ratpoison | |
line 1628: | |
line 1629: " RCS file | |
line 1630: au BufNewFile,BufRead *\,v^I^I^Isetf rcs | |
line 1631: | |
line 1632: " Readline | |
line 1633: au BufNewFile,BufRead .inputrc,inputrc^I^Isetf readline | |
line 1634: | |
line 1635: " Registry for MS-Windows | |
line 1637: au BufNewFile,BufRead *.reg if getline(1) =~? '^REGEDIT[0-9]*\s*$\|^Windows Registry Editor Version \d*\.\d*\s*$' | setf registry | endif | |
line 1638: | |
line 1639: " Renderman Interface Bytestream | |
line 1640: au BufNewFile,BufRead *.rib^I^I^Isetf rib | |
line 1641: | |
line 1642: " Rexx | |
line 1643: au BufNewFile,BufRead *.rex,*.orx,*.rxo,*.rxj,*.jrexx,*.rexxj,*.rexx,*.testGroup,*.testUnit^Isetf rexx | |
line 1644: | |
line 1645: " R (Splus) | |
line 1646: if has("fname_case") | |
line 1647: au BufNewFile,BufRead *.s,*.S^I^I^Isetf r | |
line 1648: else | |
line 1649: au BufNewFile,BufRead *.s^I^I^Isetf r | |
line 1650: endif | |
line 1651: | |
line 1652: " R Help file | |
line 1653: if has("fname_case") | |
line 1654: au BufNewFile,BufRead *.rd,*.Rd^I^Isetf rhelp | |
line 1655: else | |
line 1656: au BufNewFile,BufRead *.rd^I^I^Isetf rhelp | |
line 1657: endif | |
line 1658: | |
line 1659: " R noweb file | |
line 1660: if has("fname_case") | |
line 1661: au BufNewFile,BufRead *.Rnw,*.rnw,*.Snw,*.snw^I^Isetf rnoweb | |
line 1662: else | |
line 1663: au BufNewFile,BufRead *.rnw,*.snw^I^I^Isetf rnoweb | |
line 1664: endif | |
line 1665: | |
line 1666: " R Markdown file | |
line 1667: if has("fname_case") | |
line 1668: au BufNewFile,BufRead *.Rmd,*.rmd,*.Smd,*.smd^I^Isetf rmd | |
line 1669: else | |
line 1670: au BufNewFile,BufRead *.rmd,*.smd^I^I^Isetf rmd | |
line 1671: endif | |
line 1672: | |
line 1673: " R reStructuredText file | |
line 1674: if has("fname_case") | |
line 1675: au BufNewFile,BufRead *.Rrst,*.rrst,*.Srst,*.srst^Isetf rrst | |
line 1676: else | |
line 1677: au BufNewFile,BufRead *.rrst,*.srst^I^I^Isetf rrst | |
line 1678: endif | |
line 1679: | |
line 1680: " Rexx, Rebol or R | |
line 1681: au BufNewFile,BufRead *.r,*.R^I^I^Icall s:FTr() | |
line 1682: | |
line 1683: func! s:FTr() | |
line 1715: | |
line 1716: " Remind | |
line 1717: au BufNewFile,BufRead .reminders,*.remind,*.rem^I^Isetf remind | |
line 1718: | |
line 1719: " Resolv.conf | |
line 1720: au BufNewFile,BufRead resolv.conf^I^Isetf resolv | |
line 1721: | |
line 1722: " Relax NG Compact | |
line 1723: au BufNewFile,BufRead *.rnc^I^I^Isetf rnc | |
line 1724: | |
line 1725: " Relax NG XML | |
line 1726: au BufNewFile,BufRead *.rng^I^I^Isetf rng | |
line 1727: | |
line 1728: " RPL/2 | |
line 1729: au BufNewFile,BufRead *.rpl^I^I^Isetf rpl | |
line 1730: | |
line 1731: " Robots.txt | |
line 1732: au BufNewFile,BufRead robots.txt^I^Isetf robots | |
line 1733: | |
line 1734: " Rpcgen | |
line 1735: au BufNewFile,BufRead *.x^I^I^Isetf rpcgen | |
line 1736: | |
line 1737: " reStructuredText Documentation Format | |
line 1738: au BufNewFile,BufRead *.rst^I^I^Isetf rst | |
line 1739: | |
line 1740: " RTF | |
line 1741: au BufNewFile,BufRead *.rtf^I^I^Isetf rtf | |
line 1742: | |
line 1743: " Interactive Ruby shell | |
line 1744: au BufNewFile,BufRead .irbrc,irbrc^I^Isetf ruby | |
line 1745: | |
line 1746: " Ruby | |
line 1747: au BufNewFile,BufRead *.rb,*.rbw^I^Isetf ruby | |
line 1748: | |
line 1749: " RubyGems | |
line 1750: au BufNewFile,BufRead *.gemspec^I^I^Isetf ruby | |
line 1751: | |
line 1752: " Rackup | |
line 1753: au BufNewFile,BufRead *.ru^I^I^Isetf ruby | |
line 1754: | |
line 1755: " Bundler | |
line 1756: au BufNewFile,BufRead Gemfile^I^I^Isetf ruby | |
line 1757: | |
line 1758: " Ruby on Rails | |
line 1759: au BufNewFile,BufRead *.builder,*.rxml,*.rjs^Isetf ruby | |
line 1760: | |
line 1761: " Rantfile and Rakefile is like Ruby | |
line 1762: au BufNewFile,BufRead [rR]antfile,*.rant,[rR]akefile,*.rake^Isetf ruby | |
line 1763: | |
line 1764: " S-lang (or shader language, or SmallLisp) | |
line 1765: au BufNewFile,BufRead *.sl^I^I^Isetf slang | |
line 1766: | |
line 1767: " Samba config | |
line 1768: au BufNewFile,BufRead smb.conf^I^I^Isetf samba | |
line 1769: | |
line 1770: " SAS script | |
line 1771: au BufNewFile,BufRead *.sas^I^I^Isetf sas | |
line 1772: | |
line 1773: " Sass | |
line 1774: au BufNewFile,BufRead *.sass^I^I^Isetf sass | |
line 1775: | |
line 1776: " Sather | |
line 1777: au BufNewFile,BufRead *.sa^I^I^Isetf sather | |
line 1778: | |
line 1779: " Scilab | |
line 1780: au BufNewFile,BufRead *.sci,*.sce^I^Isetf scilab | |
line 1781: | |
line 1782: " SCSS | |
line 1783: au BufNewFile,BufRead *.scss^I^I^Isetf scss | |
line 1784: | |
line 1785: " SD: Streaming Descriptors | |
line 1786: au BufNewFile,BufRead *.sd^I^I^Isetf sd | |
line 1787: | |
line 1788: " SDL | |
line 1789: au BufNewFile,BufRead *.sdl,*.pr^I^Isetf sdl | |
line 1790: | |
line 1791: " sed | |
line 1792: au BufNewFile,BufRead *.sed^I^I^Isetf sed | |
line 1793: | |
line 1794: " Sieve (RFC 3028) | |
line 1795: au BufNewFile,BufRead *.siv^I^I^Isetf sieve | |
line 1796: | |
line 1797: " Sendmail | |
line 1798: au BufNewFile,BufRead sendmail.cf^I^Isetf sm | |
line 1799: | |
line 1800: " Sendmail .mc files are actually m4. Could also be MS Message text file. | |
line 1801: au BufNewFile,BufRead *.mc^I^I^Icall s:McSetf() | |
line 1802: | |
line 1803: func! s:McSetf() | |
line 1818: | |
line 1819: " Services | |
line 1820: au BufNewFile,BufRead */etc/services^I^Isetf services | |
line 1821: | |
line 1822: " Service Location config | |
line 1823: au BufNewFile,BufRead */etc/slp.conf^I^Isetf slpconf | |
line 1824: | |
line 1825: " Service Location registration | |
line 1826: au BufNewFile,BufRead */etc/slp.reg^I^Isetf slpreg | |
line 1827: | |
line 1828: " Service Location SPI | |
line 1829: au BufNewFile,BufRead */etc/slp.spi^I^Isetf slpspi | |
line 1830: | |
line 1831: " Setserial config | |
line 1832: au BufNewFile,BufRead */etc/serial.conf^I^Isetf setserial | |
line 1833: | |
line 1834: " SGML | |
line 1844: au BufNewFile,BufRead *.sgm,*.sgml if getline(1).getline(2).getline(3).getline(4).getline(5) =~? 'linuxdoc' | setf sgmllnx | elseif getline(1) =~ '<!DOCTYPE.*DocBook' || getline(2) =~ '<!DOCTYPE.*DocBook' | let b:docbk_type = "sgml" | let b:docbk_ver = 4 | setf docbk | else | setf sgml | endif | |
line 1845: | |
line 1846: " SGMLDECL | |
line 1850: au BufNewFile,BufRead *.decl,*.dcl,*.dec if getline(1).getline(2).getline(3) =~? '^<!SGML' | setf sgmldecl | endif | |
line 1851: | |
line 1852: " SGML catalog file | |
line 1853: au BufNewFile,BufRead catalog^I^I^Isetf catalog | |
line 1854: au BufNewFile,BufRead sgml.catalog*^I^Icall s:StarSetf('catalog') | |
line 1855: | |
line 1856: " Shell scripts (sh, ksh, bash, bash2, csh); Allow .profile_foo etc. | |
line 1857: " Gentoo ebuilds and Arch Linux PKGBUILDs are actually bash scripts | |
line 1858: au BufNewFile,BufRead .bashrc*,bashrc,bash.bashrc,.bash_profile*,.bash_logout*,.bash_aliases*,*.bash,*.ebuild,PKGBUILD* call SetFileTypeSH("bash") | |
line 1859: au BufNewFile,BufRead .kshrc*,*.ksh call SetFileTypeSH("ksh") | |
line 1860: au BufNewFile,BufRead */etc/profile,.profile*,*.sh,*.env call SetFileTypeSH(getline(1)) | |
line 1861: | |
line 1862: " Shell script (Arch Linux) or PHP file (Drupal) | |
line 1868: au BufNewFile,BufRead *.install if getline(1) =~ '<?php' | setf php | else | call SetFileTypeSH("bash") | endif | |
line 1869: | |
line 1870: " Also called from scripts.vim. | |
line 1871: func! SetFileTypeSH(name) | |
line 1914: | |
line 1915: " For shell-like file types, check for an "exec" command hidden in a comment, | |
line 1916: " as used for Tcl. | |
line 1917: " Also called from scripts.vim, thus can't be local to this script. | |
line 1918: func! SetFileTypeShell(name) | |
line 1937: | |
line 1938: " tcsh scripts | |
line 1939: au BufNewFile,BufRead .tcshrc*,*.tcsh,tcsh.tcshrc,tcsh.login^Icall SetFileTypeShell("tcsh") | |
line 1940: | |
line 1941: " csh scripts, but might also be tcsh scripts (on some systems csh is tcsh) | |
line 1942: au BufNewFile,BufRead .login*,.cshrc*,csh.cshrc,csh.login,csh.logout,*.csh,.alias call s:CSH() | |
line 1943: | |
line 1944: func! s:CSH() | |
line 1953: | |
line 1954: " Z-Shell script | |
line 1955: au BufNewFile,BufRead .zprofile,*/etc/zprofile,.zfbfmarks setf zsh | |
line 1956: au BufNewFile,BufRead .zsh*,.zlog*,.zcompdump* call s:StarSetf('zsh') | |
line 1957: au BufNewFile,BufRead *.zsh^I^I^Isetf zsh | |
line 1958: | |
line 1959: " Scheme | |
line 1960: au BufNewFile,BufRead *.scm,*.ss,*.rkt^I^Isetf scheme | |
line 1961: | |
line 1962: " Screen RC | |
line 1963: au BufNewFile,BufRead .screenrc,screenrc^Isetf screen | |
line 1964: | |
line 1965: " Simula | |
line 1966: au BufNewFile,BufRead *.sim^I^I^Isetf simula | |
line 1967: | |
line 1968: " SINDA | |
line 1969: au BufNewFile,BufRead *.sin,*.s85^I^Isetf sinda | |
line 1970: | |
line 1971: " SiSU | |
line 1972: au BufNewFile,BufRead *.sst,*.ssm,*.ssi,*.-sst,*._sst setf sisu | |
line 1973: au BufNewFile,BufRead *.sst.meta,*.-sst.meta,*._sst.meta setf sisu | |
line 1974: | |
line 1975: " SKILL | |
line 1976: au BufNewFile,BufRead *.il,*.ils,*.cdf^I^Isetf skill | |
line 1977: | |
line 1978: " SLRN | |
line 1979: au BufNewFile,BufRead .slrnrc^I^I^Isetf slrnrc | |
line 1980: au BufNewFile,BufRead *.score^I^I^Isetf slrnsc | |
line 1981: | |
line 1982: " Smalltalk (and TeX) | |
line 1983: au BufNewFile,BufRead *.st^I^I^Isetf st | |
line 1991: au BufNewFile,BufRead *.cls if getline(1) =~ '^%' | setf tex | elseif getline(1)[0] == '#' && getline(1) =~ 'rexx' | setf rexx | else | setf st | endif | |
line 1992: | |
line 1993: " Smarty templates | |
line 1994: au BufNewFile,BufRead *.tpl^I^I^Isetf smarty | |
line 1995: | |
line 1996: " SMIL or XML | |
line 2002: au BufNewFile,BufRead *.smil if getline(1) =~ '<?\s*xml.*?>' | setf xml | else | setf smil | endif | |
line 2003: | |
line 2004: " SMIL or SNMP MIB file | |
line 2010: au BufNewFile,BufRead *.smi if getline(1) =~ '\<smil\>' | setf smil | else | setf mib | endif | |
line 2011: | |
line 2012: " SMITH | |
line 2013: au BufNewFile,BufRead *.smt,*.smith^I^Isetf smith | |
line 2014: | |
line 2015: " Snobol4 and spitbol | |
line 2016: au BufNewFile,BufRead *.sno,*.spt^I^Isetf snobol4 | |
line 2017: | |
line 2018: " SNMP MIB files | |
line 2019: au BufNewFile,BufRead *.mib,*.my^I^Isetf mib | |
line 2020: | |
line 2021: " Snort Configuration | |
line 2022: au BufNewFile,BufRead *.hog,snort.conf,vision.conf^Isetf hog | |
line 2023: au BufNewFile,BufRead *.rules^I^I^Icall s:FTRules() | |
line 2024: | |
line 2025: let s:ft_rules_udev_rules_pattern = '^\s*\cudev_rules\s*=\s*"\([^"]\{-1,}\)/*".*' | |
line 2026: func! s:FTRules() | |
line 2054: | |
line 2055: | |
line 2056: " Spec (Linux RPM) | |
line 2057: au BufNewFile,BufRead *.spec^I^I^Isetf spec | |
line 2058: | |
line 2059: " Speedup (AspenTech plant simulator) | |
line 2060: au BufNewFile,BufRead *.speedup,*.spdata,*.spd^Isetf spup | |
line 2061: | |
line 2062: " Slice | |
line 2063: au BufNewFile,BufRead *.ice^I^I^Isetf slice | |
line 2064: | |
line 2065: " Spice | |
line 2066: au BufNewFile,BufRead *.sp,*.spice^I^Isetf spice | |
line 2067: | |
line 2068: " Spyce | |
line 2069: au BufNewFile,BufRead *.spy,*.spi^I^Isetf spyce | |
line 2070: | |
line 2071: " Squid | |
line 2072: au BufNewFile,BufRead squid.conf^I^Isetf squid | |
line 2073: | |
line 2074: " SQL for Oracle Designer | |
line 2075: au BufNewFile,BufRead *.tyb,*.typ,*.tyc,*.pkb,*.pks^Isetf sql | |
line 2076: | |
line 2077: " SQL | |
line 2078: au BufNewFile,BufRead *.sql^I^I^Icall s:SQL() | |
line 2079: | |
line 2080: func! s:SQL() | |
line 2087: | |
line 2088: " SQLJ | |
line 2089: au BufNewFile,BufRead *.sqlj^I^I^Isetf sqlj | |
line 2090: | |
line 2091: " SQR | |
line 2092: au BufNewFile,BufRead *.sqr,*.sqi^I^Isetf sqr | |
line 2093: | |
line 2094: " OpenSSH configuration | |
line 2095: au BufNewFile,BufRead ssh_config,*/.ssh/config^Isetf sshconfig | |
line 2096: | |
line 2097: " OpenSSH server configuration | |
line 2098: au BufNewFile,BufRead sshd_config^I^Isetf sshdconfig | |
line 2099: | |
line 2100: " Stata | |
line 2101: au BufNewFile,BufRead *.ado,*.class,*.do,*.imata,*.mata setf stata | |
line 2102: | |
line 2103: " SMCL | |
line 2104: au BufNewFile,BufRead *.hlp,*.ihlp,*.smcl^Isetf smcl | |
line 2105: | |
line 2106: " Stored Procedures | |
line 2107: au BufNewFile,BufRead *.stp^I^I^Isetf stp | |
line 2108: | |
line 2109: " Standard ML | |
line 2110: au BufNewFile,BufRead *.sml^I^I^Isetf sml | |
line 2111: | |
line 2112: " Sratus VOS command macro | |
line 2113: au BufNewFile,BufRead *.cm^I^I^Isetf voscm | |
line 2114: | |
line 2115: " Sysctl | |
line 2116: au BufNewFile,BufRead */etc/sysctl.conf,*/etc/sysctl.d/*.conf^Isetf sysctl | |
line 2117: | |
line 2118: " Synopsys Design Constraints | |
line 2119: au BufNewFile,BufRead *.sdc^I^I^Isetf sdc | |
line 2120: | |
line 2121: " Sudoers | |
line 2122: au BufNewFile,BufRead */etc/sudoers,sudoers.tmp^Isetf sudoers | |
line 2123: | |
line 2124: " SVG (Scalable Vector Graphics) | |
line 2125: au BufNewFile,BufRead *.svg^I^I^Isetf svg | |
line 2126: | |
line 2127: " If the file has an extension of 't' and is in a directory 't' or 'xt' then | |
line 2128: " it is almost certainly a Perl test file. | |
line 2129: " If the first line starts with '#' and contains 'perl' it's probably a Perl | |
line 2130: " file. | |
line 2131: " (Slow test) If a file contains a 'use' statement then it is almost certainly | |
line 2132: " a Perl file. | |
line 2133: func! s:FTperl() | |
line 2149: | |
line 2150: " Tads (or Nroff or Perl test file) | |
line 2152: au BufNewFile,BufRead *.t if !s:FTnroff() && !s:FTperl() | setf tads | endif | |
line 2153: | |
line 2154: " Tags | |
line 2155: au BufNewFile,BufRead tags^I^I^Isetf tags | |
line 2156: | |
line 2157: " TAK | |
line 2158: au BufNewFile,BufRead *.tak^I^I^Isetf tak | |
line 2159: | |
line 2160: " Task | |
line 2161: au BufRead,BufNewFile {pending,completed,undo}.data setf taskdata | |
line 2162: au BufRead,BufNewFile *.task^I^I^Isetf taskedit | |
line 2163: | |
line 2164: " Tcl (JACL too) | |
line 2165: au BufNewFile,BufRead *.tcl,*.tk,*.itcl,*.itk,*.jacl^Isetf tcl | |
line 2166: | |
line 2167: " TealInfo | |
line 2168: au BufNewFile,BufRead *.tli^I^I^Isetf tli | |
line 2169: | |
line 2170: " Telix Salt | |
line 2171: au BufNewFile,BufRead *.slt^I^I^Isetf tsalt | |
line 2172: | |
line 2173: " Terminfo | |
line 2174: au BufNewFile,BufRead *.ti^I^I^Isetf terminfo | |
line 2175: | |
line 2176: " TeX | |
line 2177: au BufNewFile,BufRead *.latex,*.sty,*.dtx,*.ltx,*.bbl^Isetf tex | |
line 2178: au BufNewFile,BufRead *.tex^I^I^Icall s:FTtex() | |
line 2179: | |
line 2180: " Choose context, plaintex, or tex (LaTeX) based on these rules: | |
line 2181: " 1. Check the first line of the file for "%&<format>". | |
line 2182: " 2. Check the first 1000 non-comment lines for LaTeX or ConTeXt keywords. | |
line 2183: " 3. Default to "latex" or to g:tex_flavor, can be set in user's vimrc. | |
line 2184: func! s:FTtex() | |
line 2231: | |
line 2232: " ConTeXt | |
line 2233: au BufNewFile,BufRead tex/context/*/*.tex,*.mkii,*.mkiv setf context | |
line 2234: | |
line 2235: " Texinfo | |
line 2236: au BufNewFile,BufRead *.texinfo,*.texi,*.txi^Isetf texinfo | |
line 2237: | |
line 2238: " TeX configuration | |
line 2239: au BufNewFile,BufRead texmf.cnf^I^I^Isetf texmf | |
line 2240: | |
line 2241: " Tidy config | |
line 2242: au BufNewFile,BufRead .tidyrc,tidyrc^I^Isetf tidy | |
line 2243: | |
line 2244: " TF mud client | |
line 2245: au BufNewFile,BufRead *.tf,.tfrc,tfrc^I^Isetf tf | |
line 2246: | |
line 2247: " TPP - Text Presentation Program | |
line 2248: au BufNewFile,BufReadPost *.tpp^I^I^Isetf tpp | |
line 2249: | |
line 2250: " Treetop | |
line 2251: au BufRead,BufNewFile *.treetop^I^I^Isetf treetop | |
line 2252: | |
line 2253: " Trustees | |
line 2254: au BufNewFile,BufRead trustees.conf^I^Isetf trustees | |
line 2255: | |
line 2256: " TSS - Geometry | |
line 2257: au BufNewFile,BufReadPost *.tssgm^I^Isetf tssgm | |
line 2258: | |
line 2259: " TSS - Optics | |
line 2260: au BufNewFile,BufReadPost *.tssop^I^Isetf tssop | |
line 2261: | |
line 2262: " TSS - Command Line (temporary) | |
line 2263: au BufNewFile,BufReadPost *.tsscl^I^Isetf tsscl | |
line 2264: | |
line 2265: " Tutor mode | |
line 2266: au BufNewFile,BufReadPost *.tutor^I^Isetf tutor | |
line 2267: | |
line 2268: " TWIG files | |
line 2269: au BufNewFile,BufReadPost *.twig^I^Isetf twig | |
line 2270: | |
line 2271: " Motif UIT/UIL files | |
line 2272: au BufNewFile,BufRead *.uit,*.uil^I^Isetf uil | |
line 2273: | |
line 2274: " Udev conf | |
line 2275: au BufNewFile,BufRead */etc/udev/udev.conf^Isetf udevconf | |
line 2276: | |
line 2277: " Udev permissions | |
line 2278: au BufNewFile,BufRead */etc/udev/permissions.d/*.permissions setf udevperm | |
line 2279: " | |
line 2280: " Udev symlinks config | |
line 2281: au BufNewFile,BufRead */etc/udev/cdsymlinks.conf^Isetf sh | |
line 2282: | |
line 2283: " UnrealScript | |
line 2284: au BufNewFile,BufRead *.uc^I^I^Isetf uc | |
line 2285: | |
line 2286: " Updatedb | |
line 2287: au BufNewFile,BufRead */etc/updatedb.conf^Isetf updatedb | |
line 2288: | |
line 2289: " Upstart (init(8)) config files | |
line 2290: au BufNewFile,BufRead */usr/share/upstart/*.conf^I setf upstart | |
line 2291: au BufNewFile,BufRead */usr/share/upstart/*.override^I setf upstart | |
line 2292: au BufNewFile,BufRead */etc/init/*.conf,*/etc/init/*.override setf upstart | |
line 2293: au BufNewFile,BufRead */.init/*.conf,*/.init/*.override setf upstart | |
line 2294: au BufNewFile,BufRead */.config/upstart/*.conf^I^I setf upstart | |
line 2295: au BufNewFile,BufRead */.config/upstart/*.override^I setf upstart | |
line 2296: | |
line 2297: " Vera | |
line 2298: au BufNewFile,BufRead *.vr,*.vri,*.vrh^I^Isetf vera | |
line 2299: | |
line 2300: " Verilog HDL | |
line 2301: au BufNewFile,BufRead *.v^I^I^Isetf verilog | |
line 2302: | |
line 2303: " Verilog-AMS HDL | |
line 2304: au BufNewFile,BufRead *.va,*.vams^I^Isetf verilogams | |
line 2305: | |
line 2306: " SystemVerilog | |
line 2307: au BufNewFile,BufRead *.sv,*.svh^I^Isetf systemverilog | |
line 2308: | |
line 2309: " VHDL | |
line 2310: au BufNewFile,BufRead *.hdl,*.vhd,*.vhdl,*.vbe,*.vst setf vhdl | |
line 2311: au BufNewFile,BufRead *.vhdl_[0-9]*^I^Icall s:StarSetf('vhdl') | |
line 2312: | |
line 2313: " Vim script | |
line 2314: au BufNewFile,BufRead *.vim,*.vba,.exrc,_exrc^Isetf vim | |
line 2315: | |
line 2316: " Viminfo file | |
line 2317: au BufNewFile,BufRead .viminfo,_viminfo^I^Isetf viminfo | |
line 2318: | |
line 2319: " Virata Config Script File or Drupal module | |
line 2325: au BufRead,BufNewFile *.hw,*.module,*.pkg if getline(1) =~ '<?php' | setf php | else | setf virata | endif | |
line 2326: | |
line 2327: " Visual Basic (also uses *.bas) or FORM | |
line 2328: au BufNewFile,BufRead *.frm^I^I^Icall s:FTVB("form") | |
line 2329: | |
line 2330: " SaxBasic is close to Visual Basic | |
line 2331: au BufNewFile,BufRead *.sba^I^I^Isetf vb | |
line 2332: | |
line 2333: " Vgrindefs file | |
line 2334: au BufNewFile,BufRead vgrindefs^I^I^Isetf vgrindefs | |
line 2335: | |
line 2336: " VRML V1.0c | |
line 2337: au BufNewFile,BufRead *.wrl^I^I^Isetf vrml | |
line 2338: | |
line 2339: " Vroom (vim testing and executable documentation) | |
line 2340: au BufNewFile,BufRead *.vroom^I^I^Isetf vroom | |
line 2341: | |
line 2342: " Webmacro | |
line 2343: au BufNewFile,BufRead *.wm^I^I^Isetf webmacro | |
line 2344: | |
line 2345: " Wget config | |
line 2346: au BufNewFile,BufRead .wgetrc,wgetrc^I^Isetf wget | |
line 2347: | |
line 2348: " Website MetaLanguage | |
line 2349: au BufNewFile,BufRead *.wml^I^I^Isetf wml | |
line 2350: | |
line 2351: " Winbatch | |
line 2352: au BufNewFile,BufRead *.wbt^I^I^Isetf winbatch | |
line 2353: | |
line 2354: " WSML | |
line 2355: au BufNewFile,BufRead *.wsml^I^I^Isetf wsml | |
line 2356: | |
line 2357: " WvDial | |
line 2358: au BufNewFile,BufRead wvdial.conf,.wvdialrc^Isetf wvdial | |
line 2359: | |
line 2360: " CVS RC file | |
line 2361: au BufNewFile,BufRead .cvsrc^I^I^Isetf cvsrc | |
line 2362: | |
line 2363: " CVS commit file | |
line 2364: au BufNewFile,BufRead cvs\d\+^I^I^Isetf cvs | |
line 2365: | |
line 2366: " WEB (*.web is also used for Winbatch: Guess, based on expecting "%" comment | |
line 2367: " lines in a WEB file). | |
line 2373: au BufNewFile,BufRead *.web if getline(1)[0].getline(2)[0].getline(3)[0].getline(4)[0].getline(5)[0] =~ "%" | setf web | else | setf winbatch | endif | |
line 2374: | |
line 2375: " Windows Scripting Host and Windows Script Component | |
line 2376: au BufNewFile,BufRead *.ws[fc]^I^I^Isetf wsh | |
line 2377: | |
line 2378: " XHTML | |
line 2379: au BufNewFile,BufRead *.xhtml,*.xht^I^Isetf xhtml | |
line 2380: | |
line 2381: " X Pixmap (dynamically sets colors, use BufEnter to make it work better) | |
line 2387: au BufEnter *.xpm if getline(1) =~ "XPM2" | setf xpm2 | else | setf xpm | endif | |
line 2388: au BufEnter *.xpm2^I^I^I^Isetf xpm2 | |
line 2389: | |
line 2390: " XFree86 config | |
line 2395: au BufNewFile,BufRead XF86Config if getline(1) =~ '\<XConfigurator\>' | let b:xf86conf_xfree86_version = 3 | endif | setf xf86conf | |
line 2398: au BufNewFile,BufRead */xorg.conf.d/*.conf let b:xf86conf_xfree86_version = 4 | setf xf86conf | |
line 2399: | |
line 2400: " Xorg config | |
line 2401: au BufNewFile,BufRead xorg.conf,xorg.conf-4^Ilet b:xf86conf_xfree86_version = 4 | setf xf86conf | |
line 2402: | |
line 2403: " Xinetd conf | |
line 2404: au BufNewFile,BufRead */etc/xinetd.conf^I^Isetf xinetd | |
line 2405: | |
line 2406: " XS Perl extension interface language | |
line 2407: au BufNewFile,BufRead *.xs^I^I^Isetf xs | |
line 2408: | |
line 2409: " X resources file | |
line 2410: au BufNewFile,BufRead .Xdefaults,.Xpdefaults,.Xresources,xdm-config,*.ad setf xdefaults | |
line 2411: | |
line 2412: " Xmath | |
line 2413: au BufNewFile,BufRead *.msc,*.msf^I^Isetf xmath | |
line 2415: au BufNewFile,BufRead *.ms if !s:FTnroff() | setf xmath | endif | |
line 2416: | |
line 2417: " XML specific variants: docbk and xbl | |
line 2418: au BufNewFile,BufRead *.xml^I^I^Icall s:FTxml() | |
line 2419: | |
line 2420: func! s:FTxml() | |
line 2445: | |
line 2446: " XMI (holding UML models) is also XML | |
line 2447: au BufNewFile,BufRead *.xmi^I^I^Isetf xml | |
line 2448: | |
line 2449: " CSPROJ files are Visual Studio.NET's XML-based project config files | |
line 2450: au BufNewFile,BufRead *.csproj,*.csproj.user^Isetf xml | |
line 2451: | |
line 2452: " Qt Linguist translation source and Qt User Interface Files are XML | |
line 2453: au BufNewFile,BufRead *.ts,*.ui^I^I^Isetf xml | |
line 2454: | |
line 2455: " TPM's are RDF-based descriptions of TeX packages (Nikolai Weibull) | |
line 2456: au BufNewFile,BufRead *.tpm^I^I^Isetf xml | |
line 2457: | |
line 2458: " Xdg menus | |
line 2459: au BufNewFile,BufRead */etc/xdg/menus/*.menu^Isetf xml | |
line 2460: | |
line 2461: " ATI graphics driver configuration | |
line 2462: au BufNewFile,BufRead fglrxrc^I^I^Isetf xml | |
line 2463: | |
line 2464: " XLIFF (XML Localisation Interchange File Format) is also XML | |
line 2465: au BufNewFile,BufRead *.xlf^I^I^Isetf xml | |
line 2466: au BufNewFile,BufRead *.xliff^I^I^Isetf xml | |
line 2467: | |
line 2468: " XML User Interface Language | |
line 2469: au BufNewFile,BufRead *.xul^I^I^Isetf xml | |
line 2470: | |
line 2471: " X11 xmodmap (also see below) | |
line 2472: au BufNewFile,BufRead *Xmodmap^I^I^Isetf xmodmap | |
line 2473: | |
line 2474: " Xquery | |
line 2475: au BufNewFile,BufRead *.xq,*.xql,*.xqm,*.xquery,*.xqy^Isetf xquery | |
line 2476: | |
line 2477: " XSD | |
line 2478: au BufNewFile,BufRead *.xsd^I^I^Isetf xsd | |
line 2479: | |
line 2480: " Xslt | |
line 2481: au BufNewFile,BufRead *.xsl,*.xslt^I^Isetf xslt | |
line 2482: | |
line 2483: " Yacc | |
line 2484: au BufNewFile,BufRead *.yy,*.yxx,*.y++^I^Isetf yacc | |
line 2485: | |
line 2486: " Yacc or racc | |
line 2487: au BufNewFile,BufRead *.y^I^I^Icall s:FTy() | |
line 2488: | |
line 2489: func! s:FTy() | |
line 2505: | |
line 2506: | |
line 2507: " Yaml | |
line 2508: au BufNewFile,BufRead *.yaml,*.yml^I^Isetf yaml | |
line 2509: | |
line 2510: " yum conf (close enough to dosini) | |
line 2511: au BufNewFile,BufRead */etc/yum.conf^I^Isetf dosini | |
line 2512: | |
line 2513: " Zimbu | |
line 2514: au BufNewFile,BufRead *.zu^I^I^Isetf zimbu | |
line 2515: " Zimbu Templates | |
line 2516: au BufNewFile,BufRead *.zut^I^I^Isetf zimbutempl | |
line 2517: | |
line 2518: " Zope | |
line 2519: " dtml (zope dynamic template markup language), pt (zope page template), | |
line 2520: " cpt (zope form controller page template) | |
line 2521: au BufNewFile,BufRead *.dtml,*.pt,*.cpt^I^Icall s:FThtml() | |
line 2522: " zsql (zope sql method) | |
line 2523: au BufNewFile,BufRead *.zsql^I^I^Icall s:SQL() | |
line 2524: | |
line 2525: " Z80 assembler asz80 | |
line 2526: au BufNewFile,BufRead *.z8a^I^I^Isetf z8a | |
line 2527: | |
line 2528: augroup END | |
line 2529: | |
line 2530: | |
line 2531: " Source the user-specified filetype file, for backwards compatibility with | |
line 2532: " Vim 5.x. | |
line 2533: if exists("myfiletypefile") && filereadable(expand(myfiletypefile)) | |
line 2534: execute "source " . myfiletypefile | |
line 2535: endif | |
line 2536: | |
line 2537: | |
line 2538: " Check for "*" after loading myfiletypefile, so that scripts.vim is only used | |
line 2539: " when there are no matching file name extensions. | |
line 2540: " Don't do this for compressed files. | |
line 2541: augroup filetypedetect | |
line 2544: au BufNewFile,BufRead * if !did_filetype() && expand("<amatch>") !~ g:ft_ignore_pat | runtime! scripts.vim | endif | |
line 2545: au StdinReadPost * if !did_filetype() | runtime! scripts.vim | endif | |
line 2546: | |
line 2547: | |
line 2548: " Extra checks for when no filetype has been detected now. Mostly used for | |
line 2549: " patterns that end in "*". E.g., "zsh*" matches "zsh.vim", but that's a Vim | |
line 2550: " script file. | |
line 2551: " Most of these should call s:StarSetf() to avoid names ending in .gz and the | |
line 2552: " like are used. | |
line 2553: | |
line 2554: " More Apache config files | |
line 2555: au BufNewFile,BufRead access.conf*,apache.conf*,apache2.conf*,httpd.conf*,srm.conf*^Icall s:StarSetf('apache') | |
line 2556: au BufNewFile,BufRead */etc/apache2/*.conf*,*/etc/apache2/conf.*/*,*/etc/apache2/mods-*/*,*/etc/apache2/sites-*/*,*/etc/httpd/conf.d/*.conf*^I^Icall s:StarSetf('apache') | |
line 2557: | |
line 2558: " Asterisk config file | |
line 2559: au BufNewFile,BufRead *asterisk/*.conf*^I^Icall s:StarSetf('asterisk') | |
line 2560: au BufNewFile,BufRead *asterisk*/*voicemail.conf* call s:StarSetf('asteriskvm') | |
line 2561: | |
line 2562: " Bazaar version control | |
line 2563: au BufNewFile,BufRead bzr_log.*^I^I^Isetf bzr | |
line 2564: | |
line 2565: " BIND zone | |
line 2566: au BufNewFile,BufRead */named/db.*,*/bind/db.*^Icall s:StarSetf('bindzone') | |
line 2567: | |
line 2568: " Calendar | |
line 2571: au BufNewFile,BufRead */.calendar/*,*/share/calendar/*/calendar.*,*/share/calendar/calendar.*^I^I^I^I^Icall s:StarSetf('calendar') | |
line 2572: | |
line 2573: " Changelog | |
line 2579: au BufNewFile,BufRead [cC]hange[lL]og* if getline(1) =~ '; urgency='| call s:StarSetf('debchangelog')|else| call s:StarSetf('changelog')|endif | |
line 2580: | |
line 2581: " Crontab | |
line 2582: au BufNewFile,BufRead crontab,crontab.*,*/etc/cron.d/*^I^Icall s:StarSetf('crontab') | |
line 2583: | |
line 2584: " dnsmasq(8) configuration | |
line 2585: au BufNewFile,BufRead */etc/dnsmasq.d/*^I^Icall s:StarSetf('dnsmasq') | |
line 2586: | |
line 2587: " Dracula | |
line 2588: au BufNewFile,BufRead drac.*^I^I^Icall s:StarSetf('dracula') | |
line 2589: | |
line 2590: " Fvwm | |
line 2591: au BufNewFile,BufRead */.fvwm/*^I^I^Icall s:StarSetf('fvwm') | |
line 2593: au BufNewFile,BufRead *fvwmrc*,*fvwm95*.hook let b:fvwm_version = 1 | call s:StarSetf('fvwm') | |
line 2599: au BufNewFile,BufRead *fvwm2rc* if expand("<afile>:e") == "m4"| call s:StarSetf('fvwm2m4')|else| let b:fvwm_version = 2 | call s:StarSetf('fvwm')|endif | |
line 2600: | |
line 2601: " Gedcom | |
line 2602: au BufNewFile,BufRead */tmp/lltmp*^I^Icall s:StarSetf('gedcom') | |
line 2603: | |
line 2604: " GTK RC | |
line 2605: au BufNewFile,BufRead .gtkrc*,gtkrc*^I^Icall s:StarSetf('gtkrc') | |
line 2606: | |
line 2607: " Jam | |
line 2608: au BufNewFile,BufRead Prl*.*,JAM*.*^I^Icall s:StarSetf('jam') | |
line 2609: | |
line 2610: " Jargon | |
line 2614: au! BufNewFile,BufRead *jarg* if getline(1).getline(2).getline(3).getline(4).getline(5) =~? 'THIS IS THE JARGON FILE'| call s:StarSetf('jargon')|endif | |
line 2615: | |
line 2616: " Kconfig | |
line 2617: au BufNewFile,BufRead Kconfig.*^I^I^Icall s:StarSetf('kconfig') | |
line 2618: | |
line 2619: " Lilo: Linux loader | |
line 2620: au BufNewFile,BufRead lilo.conf*^I^Icall s:StarSetf('lilo') | |
line 2621: | |
line 2622: " Logcheck | |
line 2623: au BufNewFile,BufRead */etc/logcheck/*.d*/*^Icall s:StarSetf('logcheck') | |
line 2624: | |
line 2625: " Makefile | |
line 2626: au BufNewFile,BufRead [mM]akefile*^I^Icall s:StarSetf('make') | |
line 2627: | |
line 2628: " Ruby Makefile | |
line 2629: au BufNewFile,BufRead [rR]akefile*^I^Icall s:StarSetf('ruby') | |
line 2630: | |
line 2631: " Mail (also matches muttrc.vim, so this is below the other checks) | |
line 2632: au BufNewFile,BufRead mutt[[:alnum:]._-]\\\{6\}^Isetf mail | |
line 2633: | |
line 2634: " Modconf | |
line 2638: au BufNewFile,BufRead */etc/modutils/* if executable(expand("<afile>")) != 1| call s:StarSetf('modconf')|endif | |
line 2639: au BufNewFile,BufRead */etc/modprobe.*^I^Icall s:StarSetf('modconf') | |
line 2640: | |
line 2641: " Mutt setup file | |
line 2642: au BufNewFile,BufRead .mutt{ng,}rc*,*/.mutt{ng,}/mutt{ng,}rc*^Icall s:StarSetf('muttrc') | |
line 2643: au BufNewFile,BufRead mutt{ng,}rc*,Mutt{ng,}rc*^I^Icall s:StarSetf('muttrc') | |
line 2644: | |
line 2645: " Nroff macros | |
line 2646: au BufNewFile,BufRead tmac.*^I^I^Icall s:StarSetf('nroff') | |
line 2647: | |
line 2648: " Pam conf | |
line 2649: au BufNewFile,BufRead */etc/pam.d/*^I^Icall s:StarSetf('pamconf') | |
line 2650: | |
line 2651: " Printcap and Termcap | |
line 2655: au BufNewFile,BufRead *printcap* if !did_filetype()| let b:ptcap_type = "print" | call s:StarSetf('ptcap')|endif | |
line 2659: au BufNewFile,BufRead *termcap* if !did_filetype()| let b:ptcap_type = "term" | call s:StarSetf('ptcap')|endif | |
line 2660: | |
line 2661: " ReDIF | |
line 2662: " Only used when the .rdf file was not detected to be XML. | |
line 2663: au BufRead,BufNewFile *.rdf^I^I^Icall s:Redif() | |
line 2664: func! s:Redif() | |
line 2674: | |
line 2675: " Remind | |
line 2676: au BufNewFile,BufRead .reminders*^I^Icall s:StarSetf('remind') | |
line 2677: | |
line 2678: " Vim script | |
line 2679: au BufNewFile,BufRead *vimrc*^I^I^Icall s:StarSetf('vim') | |
line 2680: | |
line 2681: " Subversion commit file | |
line 2682: au BufNewFile,BufRead svn-commit*.tmp^I^Isetf svn | |
line 2683: | |
line 2684: " X resources file | |
line 2685: au BufNewFile,BufRead Xresources*,*/app-defaults/*,*/Xresources/* call s:StarSetf('xdefaults') | |
line 2686: | |
line 2687: " XFree86 config | |
line 2689: au BufNewFile,BufRead XF86Config-4* let b:xf86conf_xfree86_version = 4 | call s:StarSetf('xf86conf') | |
line 2694: au BufNewFile,BufRead XF86Config* if getline(1) =~ '\<XConfigurator\>'| let b:xf86conf_xfree86_version = 3|endif|call s:StarSetf('xf86conf') | |
line 2695: | |
line 2696: " X11 xmodmap | |
line 2697: au BufNewFile,BufRead *xmodmap*^I^I^Icall s:StarSetf('xmodmap') | |
line 2698: | |
line 2699: " Xinetd conf | |
line 2700: au BufNewFile,BufRead */etc/xinetd.d/*^I^Icall s:StarSetf('xinetd') | |
line 2701: | |
line 2702: " yum conf (close enough to dosini) | |
line 2703: au BufNewFile,BufRead */etc/yum.repos.d/*^Icall s:StarSetf('dosini') | |
line 2704: | |
line 2705: " Z-Shell script | |
line 2706: au BufNewFile,BufRead zsh*,zlog*^I^Icall s:StarSetf('zsh') | |
line 2707: | |
line 2708: | |
line 2709: " Plain text files, needs to be far down to not override others. This avoids | |
line 2710: " the "conf" type being used if there is a line starting with '#'. | |
line 2711: au BufNewFile,BufRead *.txt,*.text,README^Isetf text | |
line 2712: | |
line 2713: | |
line 2714: " Use the filetype detect plugins. They may overrule any of the previously | |
line 2715: " detected filetypes. | |
line 2716: runtime! ftdetect/*.vim | |
Searching for "ftdetect/*.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/d | |
Searching for "/Users/nhooyr/dotfiles/nvim/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.fzf/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/ftdetect/*.vim" | |
Searching for "/etc/xdg/nvim/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/ftdetect/*.vim" | |
Searching for "/usr/local/share/nvim/site/ftdetect/*.vim" | |
Searching for "/usr/share/nvim/site/ftdetect/*.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftdetect/*.vim" | |
Searching for "/usr/share/nvim/site/after/ftdetect/*.vim" | |
Searching for "/usr/local/share/nvim/site/after/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/ftdetect/*.vim" | |
Searching for "/etc/xdg/nvim/after/ftdetect/*.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/ftdetect/*.vim" | |
not found in 'runtimepath': "ftdetect/*.vim" | |
line 2717: | |
line 2718: " NOTE: The above command could have ended the filetypedetect autocmd group | |
line 2719: " and started another one. Let's make sure it has ended to get to a consistent | |
line 2720: " state. | |
line 2721: augroup END | |
line 2722: | |
line 2723: " Generic configuration file (check this last, it's just guessing!) | |
line 2729: au filetypedetect BufNewFile,BufRead,StdinReadPost * if !did_filetype() && expand("<amatch>") !~ g:ft_ignore_pat && (getline(1) =~ '^#' || getline(2) =~ '^#' || getline(3) =~ '^#'^I|| getline(4) =~ '^#' || getline(5) =~ '^#') | setf conf | endif | |
line 2730: | |
line 2731: | |
line 2732: " If the GUI is already running, may still need to install the Syntax menu. | |
line 2733: " Don't do it when the 'M' flag is included in 'guioptions'. | |
line 2735: if has("menu") && has("gui_running") && !exists("did_install_syntax_menu") && &guioptions !~# "M" | |
line 2736: source <sfile>:p:h/menu.vim | |
line 2737: endif | |
line 2738: | |
line 2739: " Function called for testing all functions defined here. These are | |
line 2740: " script-local, thus need to be executed here. | |
line 2741: " Returns a string with error messages (hopefully empty). | |
line 2742: func! TestFiletypeFuncs(testlist) | |
line 2753: | |
line 2754: " Restore 'cpoptions' | |
line 2755: let &cpo = s:cpo_save | |
line 2756: unlet s:cpo_save | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/filetype.vim | |
continuing in function plug#end | |
Searching for "/usr/share/nvim/site/after/filetype.vim" | |
Searching for "/usr/local/share/nvim/site/after/filetype.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/filetype.vim" | |
Searching for "/etc/xdg/nvim/after/filetype.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/filetype.vim" | |
Searching for "ftplugin.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dot | |
Searching for "/Users/nhooyr/dotfiles/nvim/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/ftplugin.vim" | |
Searching for "/Users/nhooyr/.fzf/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/ftplugin.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/ftplugin.vim" | |
Searching for "/etc/xdg/nvim/ftplugin.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/ftplugin.vim" | |
Searching for "/usr/local/share/nvim/site/ftplugin.vim" | |
Searching for "/usr/share/nvim/site/ftplugin.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftplugin.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 72: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftplugin.vim" | |
line 1: " Vim support file to switch on loading plugins for file types | |
line 2: " | |
line 3: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 4: " Last change:^I2006 Apr 30 | |
line 5: | |
line 6: if exists("did_load_ftplugin") | |
line 7: finish | |
line 8: endif | |
line 9: let did_load_ftplugin = 1 | |
line 10: | |
line 11: augroup filetypeplugin | |
line 12: au FileType * call s:LoadFTPlugin() | |
line 13: | |
line 14: func! s:LoadFTPlugin() | |
line 35: augroup END | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/ftplugin.vim | |
continuing in function plug#end | |
Searching for "/usr/share/nvim/site/after/ftplugin.vim" | |
Searching for "/usr/local/share/nvim/site/after/ftplugin.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/ftplugin.vim" | |
Searching for "/etc/xdg/nvim/after/ftplugin.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/ftplugin.vim" | |
Searching for "indent.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dotfi | |
Searching for "/Users/nhooyr/dotfiles/nvim/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/indent.vim" | |
Searching for "/Users/nhooyr/.fzf/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/indent.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/indent.vim" | |
Searching for "/etc/xdg/nvim/indent.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/indent.vim" | |
Searching for "/usr/local/share/nvim/site/indent.vim" | |
Searching for "/usr/share/nvim/site/indent.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/indent.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 72: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/indent.vim" | |
line 1: " Vim support file to switch on loading indent files for file types | |
line 2: " | |
line 3: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 4: " Last Change:^I2008 Feb 22 | |
line 5: | |
line 6: if exists("did_indent_on") | |
line 7: finish | |
line 8: endif | |
line 9: let did_indent_on = 1 | |
line 10: | |
line 11: augroup filetypeindent | |
line 12: au FileType * call s:LoadIndent() | |
line 13: func! s:LoadIndent() | |
line 31: augroup END | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/indent.vim | |
continuing in function plug#end | |
Searching for "/usr/share/nvim/site/after/indent.vim" | |
Searching for "/usr/local/share/nvim/site/after/indent.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/indent.vim" | |
Searching for "/etc/xdg/nvim/after/indent.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/indent.vim" | |
line 73: if has('vim_starting') | |
line 74: syntax enable | |
line 74: so $VIMRUNTIME/syntax/syntax.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 74: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 04 | |
line 4: | |
line 5: " This file is used for ":syntax on". | |
line 6: " It installs the autocommands and starts highlighting for all buffers. | |
line 7: | |
line 8: if !has("syntax") | |
line 9: finish | |
line 10: endif | |
line 11: | |
line 12: " If Syntax highlighting appears to be on already, turn it off first, so that | |
line 13: " any leftovers are cleared. | |
line 14: if exists("syntax_on") || exists("syntax_manual") | |
line 15: so <sfile>:p:h/nosyntax.vim | |
line 16: endif | |
line 17: | |
line 18: " Load the Syntax autocommands and set the default methods for highlighting. | |
line 19: runtime syntax/synload.vim | |
Searching for "syntax/synload.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhoo | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/synload.vim" | |
Searching for "/etc/xdg/nvim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 19: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2012 Sep 25 | |
line 4: | |
line 5: " This file sets up for syntax highlighting. | |
line 6: " It is loaded from "syntax.vim" and "manual.vim". | |
line 7: " 1. Set the default highlight groups. | |
line 8: " 2. Install Syntax autocommands for all the available syntax files. | |
line 9: | |
line 10: if !has("syntax") | |
line 11: finish | |
line 12: endif | |
line 13: | |
line 14: " let others know that syntax has been switched on | |
line 15: let syntax_on = 1 | |
line 16: | |
line 17: " Set the default highlighting colors. Use a color scheme if specified. | |
line 18: if exists("colors_name") | |
line 19: exe "colors " . colors_name | |
line 20: else | |
line 21: runtime! syntax/syncolor.vim | |
Searching for "syntax/syncolor.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nho | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 21: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 12 | |
line 4: | |
line 5: " This file sets up the default methods for highlighting. | |
line 6: " It is loaded from "synload.vim" and from Vim for ":syntax reset". | |
line 7: " Also used from init_highlight(). | |
line 8: | |
line 9: if !exists("syntax_cmd") || syntax_cmd == "on" | |
line 10: " ":syntax on" works like in Vim 5.7: set colors but keep links | |
line 11: command -nargs=* SynColor hi <args> | |
line 12: command -nargs=* SynLink hi link <args> | |
line 13: else | |
line 14: if syntax_cmd == "enable" | |
line 15: " ":syntax enable" keeps any existing colors | |
line 16: command -nargs=* SynColor hi def <args> | |
line 17: command -nargs=* SynLink hi def link <args> | |
line 18: elseif syntax_cmd == "reset" | |
line 19: " ":syntax reset" resets all colors to the default | |
line 20: command -nargs=* SynColor hi <args> | |
line 21: command -nargs=* SynLink hi! link <args> | |
line 22: else | |
line 23: " User defined syncolor file has already set the colors. | |
line 24: finish | |
line 25: endif | |
line 26: endif | |
line 27: | |
line 28: " Many terminals can only use six different colors (plus black and white). | |
line 29: " Therefore the number of colors used is kept low. It doesn't look nice with | |
line 30: " too many colors anyway. | |
line 31: " Careful with "cterm=bold", it changes the color to bright for some terminals. | |
line 32: " There are two sets of defaults: for a dark and a light background. | |
line 33: if &background == "dark" | |
line 34: SynColor Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 35: SynColor Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 36: SynColor Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 37: SynColor Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 38: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 39: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 40: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 41: SynColor Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 42: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 43: else | |
line 44: SynColor Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 44: hi Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 45: SynColor Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 45: hi Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 46: SynColor Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 46: hi Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 47: SynColor Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 47: hi Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 48: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 48: hi Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 49: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 49: hi PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 50: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 50: hi Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 51: SynColor Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 51: hi Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 52: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 52: hi Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 53: endif | |
line 54: SynColor Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 54: hi Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 55: SynColor Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 55: hi Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 56: | |
line 57: " Common groups that link to default highlighting. | |
line 58: " You can specify other highlighting easily. | |
line 59: SynLink String^I^IConstant | |
line 59: hi link String^I^IConstant | |
line 60: SynLink Character^IConstant | |
line 60: hi link Character^IConstant | |
line 61: SynLink Number^I^IConstant | |
line 61: hi link Number^I^IConstant | |
line 62: SynLink Boolean^I^IConstant | |
line 62: hi link Boolean^I^IConstant | |
line 63: SynLink Float^I^INumber | |
line 63: hi link Float^I^INumber | |
line 64: SynLink Function^IIdentifier | |
line 64: hi link Function^IIdentifier | |
line 65: SynLink Conditional^IStatement | |
line 65: hi link Conditional^IStatement | |
line 66: SynLink Repeat^I^IStatement | |
line 66: hi link Repeat^I^IStatement | |
line 67: SynLink Label^I^IStatement | |
line 67: hi link Label^I^IStatement | |
line 68: SynLink Operator^IStatement | |
line 68: hi link Operator^IStatement | |
line 69: SynLink Keyword^I^IStatement | |
line 69: hi link Keyword^I^IStatement | |
line 70: SynLink Exception^IStatement | |
line 70: hi link Exception^IStatement | |
line 71: SynLink Include^I^IPreProc | |
line 71: hi link Include^I^IPreProc | |
line 72: SynLink Define^I^IPreProc | |
line 72: hi link Define^I^IPreProc | |
line 73: SynLink Macro^I^IPreProc | |
line 73: hi link Macro^I^IPreProc | |
line 74: SynLink PreCondit^IPreProc | |
line 74: hi link PreCondit^IPreProc | |
line 75: SynLink StorageClass^IType | |
line 75: hi link StorageClass^IType | |
line 76: SynLink Structure^IType | |
line 76: hi link Structure^IType | |
line 77: SynLink Typedef^I^IType | |
line 77: hi link Typedef^I^IType | |
line 78: SynLink Tag^I^ISpecial | |
line 78: hi link Tag^I^ISpecial | |
line 79: SynLink SpecialChar^ISpecial | |
line 79: hi link SpecialChar^ISpecial | |
line 80: SynLink Delimiter^ISpecial | |
line 80: hi link Delimiter^ISpecial | |
line 81: SynLink SpecialComment^ISpecial | |
line 81: hi link SpecialComment^ISpecial | |
line 82: SynLink Debug^I^ISpecial | |
line 82: hi link Debug^I^ISpecial | |
line 83: | |
line 84: delcommand SynColor | |
line 85: delcommand SynLink | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim | |
Searching for "/usr/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/syntax/syncolor.vim" | |
line 22: endif | |
line 23: | |
line 24: " Line continuation is used here, remove 'C' from 'cpoptions' | |
line 25: let s:cpo_save = &cpo | |
line 26: set cpo&vim | |
line 27: | |
line 28: " First remove all old syntax autocommands. | |
line 29: au! Syntax | |
line 30: | |
line 31: au Syntax *^I^Icall s:SynSet() | |
line 32: | |
line 33: fun! s:SynSet() | |
line 61: | |
line 62: | |
line 63: " Handle adding doxygen to other languages (C, C++, C#, IDL) | |
line 68: au Syntax c,cpp,cs,idl,php if (exists('b:load_doxygen_syntax') && b:load_doxygen_syntax)^I|| (exists('g:load_doxygen_syntax') && g:load_doxygen_syntax) | runtime! syntax/doxygen.vim | endif | |
line 69: | |
line 70: | |
line 71: " Source the user-specified syntax highlighting file | |
line 72: if exists("mysyntaxfile") && filereadable(expand(mysyntaxfile)) | |
line 73: execute "source " . mysyntaxfile | |
line 74: endif | |
line 75: | |
line 76: " Restore 'cpoptions' | |
line 77: let &cpo = s:cpo_save | |
line 78: unlet s:cpo_save | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim | |
line 20: | |
line 21: " Load the FileType autocommands if not done yet. | |
line 22: if exists("did_load_filetypes") | |
line 23: let s:did_ft = 1 | |
line 24: else | |
line 25: filetype on | |
line 26: let s:did_ft = 0 | |
line 27: endif | |
line 28: | |
line 29: " Set up the connection between FileType and Syntax autocommands. | |
line 30: " This makes the syntax automatically set when the file type is detected. | |
line 31: augroup syntaxset | |
line 32: au! FileType *^Iexe "set syntax=" . expand("<amatch>") | |
line 33: augroup END | |
line 34: | |
line 35: | |
line 36: " Execute the syntax autocommands for the each buffer. | |
line 37: " If the filetype wasn't detected yet, do that now. | |
line 38: " Always do the syntaxset autocommands, for buffers where the 'filetype' | |
line 39: " already was set manually (e.g., help buffers). | |
line 40: doautoall syntaxset FileType | |
line 41: if !s:did_ft | |
line 42: doautoall filetypedetect BufRead | |
line 43: endif | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim | |
continuing in function plug#end | |
line 75: else | |
line 76: call s:reload() | |
line 77: endif | |
function plug#end returning #0 | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 27: | |
line 28: syntax on | |
line 28: so $VIMRUNTIME/syntax/syntax.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 28: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 04 | |
line 4: | |
line 5: " This file is used for ":syntax on". | |
line 6: " It installs the autocommands and starts highlighting for all buffers. | |
line 7: | |
line 8: if !has("syntax") | |
line 9: finish | |
line 10: endif | |
line 11: | |
line 12: " If Syntax highlighting appears to be on already, turn it off first, so that | |
line 13: " any leftovers are cleared. | |
line 14: if exists("syntax_on") || exists("syntax_manual") | |
line 15: so <sfile>:p:h/nosyntax.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 15: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/nosyntax.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2006 Apr 16 | |
line 4: | |
line 5: " This file is used for ":syntax off". | |
line 6: " It removes the autocommands and stops highlighting for all buffers. | |
line 7: | |
line 8: if !has("syntax") | |
line 9: finish | |
line 10: endif | |
line 11: | |
line 12: " Remove all autocommands for the Syntax event. This also avoids that | |
line 13: " "syntax=foo" in a modeline triggers the SynSet() function of synload.vim. | |
line 14: au! Syntax | |
line 15: | |
line 16: " remove all syntax autocommands and remove the syntax for each buffer | |
line 17: augroup syntaxset | |
line 18: au! | |
line 19: au BufEnter * syn clear | |
line 20: au BufEnter * if exists("b:current_syntax") | unlet b:current_syntax | endif | |
line 21: doautoall syntaxset BufEnter * | |
line 22: au! | |
line 23: augroup END | |
line 24: | |
line 25: if exists("syntax_on") | |
line 26: unlet syntax_on | |
line 27: endif | |
line 28: if exists("syntax_manual") | |
line 29: unlet syntax_manual | |
line 30: endif | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/nosyntax.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim | |
line 16: endif | |
line 17: | |
line 18: " Load the Syntax autocommands and set the default methods for highlighting. | |
line 19: runtime syntax/synload.vim | |
Searching for "syntax/synload.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhoo | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/synload.vim" | |
Searching for "/etc/xdg/nvim/syntax/synload.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/share/nvim/site/syntax/synload.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 19: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2012 Sep 25 | |
line 4: | |
line 5: " This file sets up for syntax highlighting. | |
line 6: " It is loaded from "syntax.vim" and "manual.vim". | |
line 7: " 1. Set the default highlight groups. | |
line 8: " 2. Install Syntax autocommands for all the available syntax files. | |
line 9: | |
line 10: if !has("syntax") | |
line 11: finish | |
line 12: endif | |
line 13: | |
line 14: " let others know that syntax has been switched on | |
line 15: let syntax_on = 1 | |
line 16: | |
line 17: " Set the default highlighting colors. Use a color scheme if specified. | |
line 18: if exists("colors_name") | |
line 19: exe "colors " . colors_name | |
line 20: else | |
line 21: runtime! syntax/syncolor.vim | |
Searching for "syntax/syncolor.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nho | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 21: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 12 | |
line 4: | |
line 5: " This file sets up the default methods for highlighting. | |
line 6: " It is loaded from "synload.vim" and from Vim for ":syntax reset". | |
line 7: " Also used from init_highlight(). | |
line 8: | |
line 9: if !exists("syntax_cmd") || syntax_cmd == "on" | |
line 10: " ":syntax on" works like in Vim 5.7: set colors but keep links | |
line 11: command -nargs=* SynColor hi <args> | |
line 12: command -nargs=* SynLink hi link <args> | |
line 13: else | |
line 14: if syntax_cmd == "enable" | |
line 15: " ":syntax enable" keeps any existing colors | |
line 16: command -nargs=* SynColor hi def <args> | |
line 17: command -nargs=* SynLink hi def link <args> | |
line 18: elseif syntax_cmd == "reset" | |
line 19: " ":syntax reset" resets all colors to the default | |
line 20: command -nargs=* SynColor hi <args> | |
line 21: command -nargs=* SynLink hi! link <args> | |
line 22: else | |
line 23: " User defined syncolor file has already set the colors. | |
line 24: finish | |
line 25: endif | |
line 26: endif | |
line 27: | |
line 28: " Many terminals can only use six different colors (plus black and white). | |
line 29: " Therefore the number of colors used is kept low. It doesn't look nice with | |
line 30: " too many colors anyway. | |
line 31: " Careful with "cterm=bold", it changes the color to bright for some terminals. | |
line 32: " There are two sets of defaults: for a dark and a light background. | |
line 33: if &background == "dark" | |
line 34: SynColor Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 35: SynColor Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 36: SynColor Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 37: SynColor Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 38: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 39: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 40: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 41: SynColor Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 42: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 43: else | |
line 44: SynColor Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 44: hi Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 45: SynColor Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 45: hi Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 46: SynColor Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 46: hi Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 47: SynColor Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 47: hi Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 48: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 48: hi Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 49: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 49: hi PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 50: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 50: hi Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 51: SynColor Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 51: hi Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 52: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 52: hi Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 53: endif | |
line 54: SynColor Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 54: hi Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 55: SynColor Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 55: hi Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 56: | |
line 57: " Common groups that link to default highlighting. | |
line 58: " You can specify other highlighting easily. | |
line 59: SynLink String^I^IConstant | |
line 59: hi link String^I^IConstant | |
line 60: SynLink Character^IConstant | |
line 60: hi link Character^IConstant | |
line 61: SynLink Number^I^IConstant | |
line 61: hi link Number^I^IConstant | |
line 62: SynLink Boolean^I^IConstant | |
line 62: hi link Boolean^I^IConstant | |
line 63: SynLink Float^I^INumber | |
line 63: hi link Float^I^INumber | |
line 64: SynLink Function^IIdentifier | |
line 64: hi link Function^IIdentifier | |
line 65: SynLink Conditional^IStatement | |
line 65: hi link Conditional^IStatement | |
line 66: SynLink Repeat^I^IStatement | |
line 66: hi link Repeat^I^IStatement | |
line 67: SynLink Label^I^IStatement | |
line 67: hi link Label^I^IStatement | |
line 68: SynLink Operator^IStatement | |
line 68: hi link Operator^IStatement | |
line 69: SynLink Keyword^I^IStatement | |
line 69: hi link Keyword^I^IStatement | |
line 70: SynLink Exception^IStatement | |
line 70: hi link Exception^IStatement | |
line 71: SynLink Include^I^IPreProc | |
line 71: hi link Include^I^IPreProc | |
line 72: SynLink Define^I^IPreProc | |
line 72: hi link Define^I^IPreProc | |
line 73: SynLink Macro^I^IPreProc | |
line 73: hi link Macro^I^IPreProc | |
line 74: SynLink PreCondit^IPreProc | |
line 74: hi link PreCondit^IPreProc | |
line 75: SynLink StorageClass^IType | |
line 75: hi link StorageClass^IType | |
line 76: SynLink Structure^IType | |
line 76: hi link Structure^IType | |
line 77: SynLink Typedef^I^IType | |
line 77: hi link Typedef^I^IType | |
line 78: SynLink Tag^I^ISpecial | |
line 78: hi link Tag^I^ISpecial | |
line 79: SynLink SpecialChar^ISpecial | |
line 79: hi link SpecialChar^ISpecial | |
line 80: SynLink Delimiter^ISpecial | |
line 80: hi link Delimiter^ISpecial | |
line 81: SynLink SpecialComment^ISpecial | |
line 81: hi link SpecialComment^ISpecial | |
line 82: SynLink Debug^I^ISpecial | |
line 82: hi link Debug^I^ISpecial | |
line 83: | |
line 84: delcommand SynColor | |
line 85: delcommand SynLink | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim | |
Searching for "/usr/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/syntax/syncolor.vim" | |
line 22: endif | |
line 23: | |
line 24: " Line continuation is used here, remove 'C' from 'cpoptions' | |
line 25: let s:cpo_save = &cpo | |
line 26: set cpo&vim | |
line 27: | |
line 28: " First remove all old syntax autocommands. | |
line 29: au! Syntax | |
line 30: | |
line 31: au Syntax *^I^Icall s:SynSet() | |
line 32: | |
line 33: fun! s:SynSet() | |
line 61: | |
line 62: | |
line 63: " Handle adding doxygen to other languages (C, C++, C#, IDL) | |
line 68: au Syntax c,cpp,cs,idl,php if (exists('b:load_doxygen_syntax') && b:load_doxygen_syntax)^I|| (exists('g:load_doxygen_syntax') && g:load_doxygen_syntax) | runtime! syntax/doxygen.vim | endif | |
line 69: | |
line 70: | |
line 71: " Source the user-specified syntax highlighting file | |
line 72: if exists("mysyntaxfile") && filereadable(expand(mysyntaxfile)) | |
line 73: execute "source " . mysyntaxfile | |
line 74: endif | |
line 75: | |
line 76: " Restore 'cpoptions' | |
line 77: let &cpo = s:cpo_save | |
line 78: unlet s:cpo_save | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/synload.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim | |
line 20: | |
line 21: " Load the FileType autocommands if not done yet. | |
line 22: if exists("did_load_filetypes") | |
line 23: let s:did_ft = 1 | |
line 24: else | |
line 25: filetype on | |
line 26: let s:did_ft = 0 | |
line 27: endif | |
line 28: | |
line 29: " Set up the connection between FileType and Syntax autocommands. | |
line 30: " This makes the syntax automatically set when the file type is detected. | |
line 31: augroup syntaxset | |
line 32: au! FileType *^Iexe "set syntax=" . expand("<amatch>") | |
line 33: augroup END | |
line 34: | |
line 35: | |
line 36: " Execute the syntax autocommands for the each buffer. | |
line 37: " If the filetype wasn't detected yet, do that now. | |
line 38: " Always do the syntaxset autocommands, for buffers where the 'filetype' | |
line 39: " already was set manually (e.g., help buffers). | |
line 40: doautoall syntaxset FileType | |
line 41: if !s:did_ft | |
line 42: doautoall filetypedetect BufRead | |
line 43: endif | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syntax.vim | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 29: set mouse = | |
line 30: set visualbell | |
line 31: set fillchars=vert:\| | |
line 32: set linebreak | |
line 33: nnoremap <expr> j v:count ? 'j' : 'gj' | |
line 34: nnoremap <expr> k v:count ? 'k' : 'gk' | |
line 35: nnoremap <C-e> 5<C-e> | |
line 36: nnoremap <C-y> 5<C-y> | |
line 37: "highlight last inserted text | |
line 38: nnoremap gV `[v`] | |
line 39: nnoremap m ; | |
line 40: set scrolljump=10 | |
line 41: set shiftwidth=5 | |
line 42: set tabstop=5 | |
line 43: set formatoptions+=w | |
line 44: "set textwidth=130 | |
line 45: set t_Co=256 | |
line 46: set background=dark | |
Searching for "syntax/syncolor.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nho | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 46: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 12 | |
line 4: | |
line 5: " This file sets up the default methods for highlighting. | |
line 6: " It is loaded from "synload.vim" and from Vim for ":syntax reset". | |
line 7: " Also used from init_highlight(). | |
line 8: | |
line 9: if !exists("syntax_cmd") || syntax_cmd == "on" | |
line 10: " ":syntax on" works like in Vim 5.7: set colors but keep links | |
line 11: command -nargs=* SynColor hi <args> | |
line 12: command -nargs=* SynLink hi link <args> | |
line 13: else | |
line 14: if syntax_cmd == "enable" | |
line 15: " ":syntax enable" keeps any existing colors | |
line 16: command -nargs=* SynColor hi def <args> | |
line 17: command -nargs=* SynLink hi def link <args> | |
line 18: elseif syntax_cmd == "reset" | |
line 19: " ":syntax reset" resets all colors to the default | |
line 20: command -nargs=* SynColor hi <args> | |
line 21: command -nargs=* SynLink hi! link <args> | |
line 22: else | |
line 23: " User defined syncolor file has already set the colors. | |
line 24: finish | |
line 25: endif | |
line 26: endif | |
line 27: | |
line 28: " Many terminals can only use six different colors (plus black and white). | |
line 29: " Therefore the number of colors used is kept low. It doesn't look nice with | |
line 30: " too many colors anyway. | |
line 31: " Careful with "cterm=bold", it changes the color to bright for some terminals. | |
line 32: " There are two sets of defaults: for a dark and a light background. | |
line 33: if &background == "dark" | |
line 34: SynColor Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 34: hi Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 35: SynColor Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 35: hi Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 36: SynColor Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 36: hi Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 37: SynColor Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 37: hi Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 38: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 38: hi Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 39: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 39: hi PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 40: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 40: hi Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 41: SynColor Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 41: hi Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 42: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 42: hi Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 43: else | |
line 44: SynColor Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 45: SynColor Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 46: SynColor Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 47: SynColor Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 48: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 49: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 50: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 51: SynColor Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 52: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 53: endif | |
line 54: SynColor Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 54: hi Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 55: SynColor Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 55: hi Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 56: | |
line 57: " Common groups that link to default highlighting. | |
line 58: " You can specify other highlighting easily. | |
line 59: SynLink String^I^IConstant | |
line 59: hi link String^I^IConstant | |
line 60: SynLink Character^IConstant | |
line 60: hi link Character^IConstant | |
line 61: SynLink Number^I^IConstant | |
line 61: hi link Number^I^IConstant | |
line 62: SynLink Boolean^I^IConstant | |
line 62: hi link Boolean^I^IConstant | |
line 63: SynLink Float^I^INumber | |
line 63: hi link Float^I^INumber | |
line 64: SynLink Function^IIdentifier | |
line 64: hi link Function^IIdentifier | |
line 65: SynLink Conditional^IStatement | |
line 65: hi link Conditional^IStatement | |
line 66: SynLink Repeat^I^IStatement | |
line 66: hi link Repeat^I^IStatement | |
line 67: SynLink Label^I^IStatement | |
line 67: hi link Label^I^IStatement | |
line 68: SynLink Operator^IStatement | |
line 68: hi link Operator^IStatement | |
line 69: SynLink Keyword^I^IStatement | |
line 69: hi link Keyword^I^IStatement | |
line 70: SynLink Exception^IStatement | |
line 70: hi link Exception^IStatement | |
line 71: SynLink Include^I^IPreProc | |
line 71: hi link Include^I^IPreProc | |
line 72: SynLink Define^I^IPreProc | |
line 72: hi link Define^I^IPreProc | |
line 73: SynLink Macro^I^IPreProc | |
line 73: hi link Macro^I^IPreProc | |
line 74: SynLink PreCondit^IPreProc | |
line 74: hi link PreCondit^IPreProc | |
line 75: SynLink StorageClass^IType | |
line 75: hi link StorageClass^IType | |
line 76: SynLink Structure^IType | |
line 76: hi link Structure^IType | |
line 77: SynLink Typedef^I^IType | |
line 77: hi link Typedef^I^IType | |
line 78: SynLink Tag^I^ISpecial | |
line 78: hi link Tag^I^ISpecial | |
line 79: SynLink SpecialChar^ISpecial | |
line 79: hi link SpecialChar^ISpecial | |
line 80: SynLink Delimiter^ISpecial | |
line 80: hi link Delimiter^ISpecial | |
line 81: SynLink SpecialComment^ISpecial | |
line 81: hi link SpecialComment^ISpecial | |
line 82: SynLink Debug^I^ISpecial | |
line 82: hi link Debug^I^ISpecial | |
line 83: | |
line 84: delcommand SynColor | |
line 85: delcommand SynLink | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
Searching for "/usr/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/syntax/syncolor.vim" | |
line 47: colorscheme apprentice | |
Searching for "colors/apprentice.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/n | |
Searching for "/Users/nhooyr/dotfiles/nvim/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.fzf/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/colors/apprentice.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/colors/apprentice.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/Apprentice/colors) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 47: sourcing "/Users/nhooyr/.nvim/plugged/Apprentice/colors/apprentice.vim" | |
line 1: " 'apprentice.vim' -- Vim color scheme. | |
line 2: " Author: Romain Lafourcade ([email protected]) | |
line 3: " Description: Essentially a streamlining and conversion to xterm colors of | |
line 4: " 'sorcerer' by Jeet Sukumaran (jeetsukumaran@gmailcom) | |
line 5: | |
line 6: " MADE-UP NAME HEX RGB XTERM ANSI | |
line 7: " ======================================================================== | |
line 8: " almost black #1c1c1c rgb(28, 28, 28) 234 0 | |
line 9: " darker grey #262626 rgb(38, 38, 38) 235 background color | |
line 10: " dark grey #303030 rgb(48, 48, 48) 236 8 | |
line 11: " grey #444444 rgb(68, 68, 68) 238 8 | |
line 12: " medium grey #585858 rgb(88, 88, 88) 240 8 | |
line 13: " light grey #6c6c6c rgb(108, 108, 108) 242 7 | |
line 14: " lighter grey #bcbcbc rgb(188, 188, 188) 250 foreground color | |
line 15: " white #ffffff rgb(255, 255, 255) 231 15 | |
line 16: " purple #5f5f87 rgb(95, 95, 135) 60 5 | |
line 17: " light purple #8787af rgb(135, 135, 175) 103 13 | |
line 18: " green #5f875f rgb(95, 135, 95) 65 2 | |
line 19: " light green #87af87 rgb(135, 175, 135) 108 10 | |
line 20: " aqua #5f8787 rgb(95, 135, 135) 66 6 | |
line 21: " light aqua #5fafaf rgb(95, 175, 175) 73 14 | |
line 22: " blue #5f87af rgb(95, 135, 175) 67 4 | |
line 23: " light blue #8fafd7 rgb(143, 175, 215) 110 12 | |
line 24: " red #af5f5f rgb(175, 95, 95) 131 1 | |
line 25: " orange #ff8700 rgb(255, 135, 0) 208 9 | |
line 26: " ocre #87875f rgb(135, 135, 95) 101 3 | |
line 27: " yellow #ffffaf rgb(255, 255, 175) 229 11 | |
line 28: | |
line 29: hi clear | |
Searching for "syntax/syncolor.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nho | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 29: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 12 | |
line 4: | |
line 5: " This file sets up the default methods for highlighting. | |
line 6: " It is loaded from "synload.vim" and from Vim for ":syntax reset". | |
line 7: " Also used from init_highlight(). | |
line 8: | |
line 9: if !exists("syntax_cmd") || syntax_cmd == "on" | |
line 10: " ":syntax on" works like in Vim 5.7: set colors but keep links | |
line 11: command -nargs=* SynColor hi <args> | |
line 12: command -nargs=* SynLink hi link <args> | |
line 13: else | |
line 14: if syntax_cmd == "enable" | |
line 15: " ":syntax enable" keeps any existing colors | |
line 16: command -nargs=* SynColor hi def <args> | |
line 17: command -nargs=* SynLink hi def link <args> | |
line 18: elseif syntax_cmd == "reset" | |
line 19: " ":syntax reset" resets all colors to the default | |
line 20: command -nargs=* SynColor hi <args> | |
line 21: command -nargs=* SynLink hi! link <args> | |
line 22: else | |
line 23: " User defined syncolor file has already set the colors. | |
line 24: finish | |
line 25: endif | |
line 26: endif | |
line 27: | |
line 28: " Many terminals can only use six different colors (plus black and white). | |
line 29: " Therefore the number of colors used is kept low. It doesn't look nice with | |
line 30: " too many colors anyway. | |
line 31: " Careful with "cterm=bold", it changes the color to bright for some terminals. | |
line 32: " There are two sets of defaults: for a dark and a light background. | |
line 33: if &background == "dark" | |
line 34: SynColor Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 34: hi Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 35: SynColor Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 35: hi Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 36: SynColor Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 36: hi Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 37: SynColor Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 37: hi Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 38: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 38: hi Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 39: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 39: hi PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 40: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 40: hi Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 41: SynColor Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 41: hi Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 42: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 42: hi Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 43: else | |
line 44: SynColor Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 45: SynColor Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 46: SynColor Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 47: SynColor Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 48: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 49: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 50: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 51: SynColor Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 52: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 53: endif | |
line 54: SynColor Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 54: hi Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 55: SynColor Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 55: hi Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 56: | |
line 57: " Common groups that link to default highlighting. | |
line 58: " You can specify other highlighting easily. | |
line 59: SynLink String^I^IConstant | |
line 59: hi link String^I^IConstant | |
line 60: SynLink Character^IConstant | |
line 60: hi link Character^IConstant | |
line 61: SynLink Number^I^IConstant | |
line 61: hi link Number^I^IConstant | |
line 62: SynLink Boolean^I^IConstant | |
line 62: hi link Boolean^I^IConstant | |
line 63: SynLink Float^I^INumber | |
line 63: hi link Float^I^INumber | |
line 64: SynLink Function^IIdentifier | |
line 64: hi link Function^IIdentifier | |
line 65: SynLink Conditional^IStatement | |
line 65: hi link Conditional^IStatement | |
line 66: SynLink Repeat^I^IStatement | |
line 66: hi link Repeat^I^IStatement | |
line 67: SynLink Label^I^IStatement | |
line 67: hi link Label^I^IStatement | |
line 68: SynLink Operator^IStatement | |
line 68: hi link Operator^IStatement | |
line 69: SynLink Keyword^I^IStatement | |
line 69: hi link Keyword^I^IStatement | |
line 70: SynLink Exception^IStatement | |
line 70: hi link Exception^IStatement | |
line 71: SynLink Include^I^IPreProc | |
line 71: hi link Include^I^IPreProc | |
line 72: SynLink Define^I^IPreProc | |
line 72: hi link Define^I^IPreProc | |
line 73: SynLink Macro^I^IPreProc | |
line 73: hi link Macro^I^IPreProc | |
line 74: SynLink PreCondit^IPreProc | |
line 74: hi link PreCondit^IPreProc | |
line 75: SynLink StorageClass^IType | |
line 75: hi link StorageClass^IType | |
line 76: SynLink Structure^IType | |
line 76: hi link Structure^IType | |
line 77: SynLink Typedef^I^IType | |
line 77: hi link Typedef^I^IType | |
line 78: SynLink Tag^I^ISpecial | |
line 78: hi link Tag^I^ISpecial | |
line 79: SynLink SpecialChar^ISpecial | |
line 79: hi link SpecialChar^ISpecial | |
line 80: SynLink Delimiter^ISpecial | |
line 80: hi link Delimiter^ISpecial | |
line 81: SynLink SpecialComment^ISpecial | |
line 81: hi link SpecialComment^ISpecial | |
line 82: SynLink Debug^I^ISpecial | |
line 82: hi link Debug^I^ISpecial | |
line 83: | |
line 84: delcommand SynColor | |
line 85: delcommand SynLink | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim | |
continuing in /Users/nhooyr/.nvim/plugged/Apprentice/colors/apprentice.vim | |
Searching for "/usr/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/syntax/syncolor.vim" | |
line 30: | |
line 31: if exists("syntax_on") | |
line 32: syntax reset | |
line 32: runtime! syntax/syncolor.vim | |
Searching for "syntax/syncolor.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nho | |
Searching for "/Users/nhooyr/dotfiles/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.fzf/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/share/nvim/site/syntax/syncolor.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 32: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim" | |
line 1: " Vim syntax support file | |
line 2: " Maintainer:^IBram Moolenaar <[email protected]> | |
line 3: " Last Change:^I2001 Sep 12 | |
line 4: | |
line 5: " This file sets up the default methods for highlighting. | |
line 6: " It is loaded from "synload.vim" and from Vim for ":syntax reset". | |
line 7: " Also used from init_highlight(). | |
line 8: | |
line 9: if !exists("syntax_cmd") || syntax_cmd == "on" | |
line 10: " ":syntax on" works like in Vim 5.7: set colors but keep links | |
line 11: command -nargs=* SynColor hi <args> | |
line 12: command -nargs=* SynLink hi link <args> | |
line 13: else | |
line 14: if syntax_cmd == "enable" | |
line 15: " ":syntax enable" keeps any existing colors | |
line 16: command -nargs=* SynColor hi def <args> | |
line 17: command -nargs=* SynLink hi def link <args> | |
line 18: elseif syntax_cmd == "reset" | |
line 19: " ":syntax reset" resets all colors to the default | |
line 20: command -nargs=* SynColor hi <args> | |
line 21: command -nargs=* SynLink hi! link <args> | |
line 22: else | |
line 23: " User defined syncolor file has already set the colors. | |
line 24: finish | |
line 25: endif | |
line 26: endif | |
line 27: | |
line 28: " Many terminals can only use six different colors (plus black and white). | |
line 29: " Therefore the number of colors used is kept low. It doesn't look nice with | |
line 30: " too many colors anyway. | |
line 31: " Careful with "cterm=bold", it changes the color to bright for some terminals. | |
line 32: " There are two sets of defaults: for a dark and a light background. | |
line 33: if &background == "dark" | |
line 34: SynColor Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 34: hi Comment^Iterm=bold cterm=NONE ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#80a0ff guibg=NONE | |
line 35: SynColor Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 35: hi Constant^Iterm=underline cterm=NONE ctermfg=Magenta ctermbg=NONE gui=NONE guifg=#ffa0a0 guibg=NONE | |
line 36: SynColor Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 36: hi Special^Iterm=bold cterm=NONE ctermfg=LightRed ctermbg=NONE gui=NONE guifg=Orange guibg=NONE | |
line 37: SynColor Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 37: hi Identifier^Iterm=underline cterm=bold ctermfg=Cyan ctermbg=NONE gui=NONE guifg=#40ffff guibg=NONE | |
line 38: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 38: hi Statement^Iterm=bold cterm=NONE ctermfg=Yellow ctermbg=NONE gui=bold guifg=#ffff60 guibg=NONE | |
line 39: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 39: hi PreProc^Iterm=underline cterm=NONE ctermfg=LightBlue ctermbg=NONE gui=NONE guifg=#ff80ff guibg=NONE | |
line 40: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 40: hi Type^I^Iterm=underline cterm=NONE ctermfg=LightGreen ctermbg=NONE gui=bold guifg=#60ff60 guibg=NONE | |
line 41: SynColor Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 41: hi Underlined^Iterm=underline cterm=underline ctermfg=LightBlue gui=underline guifg=#80a0ff | |
line 42: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 42: hi Ignore^Iterm=NONE cterm=NONE ctermfg=black ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 43: else | |
line 44: SynColor Comment^Iterm=bold cterm=NONE ctermfg=DarkBlue ctermbg=NONE gui=NONE guifg=Blue guibg=NONE | |
line 45: SynColor Constant^Iterm=underline cterm=NONE ctermfg=DarkRed ctermbg=NONE gui=NONE guifg=Magenta guibg=NONE | |
line 46: SynColor Special^Iterm=bold cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=SlateBlue guibg=NONE | |
line 47: SynColor Identifier^Iterm=underline cterm=NONE ctermfg=DarkCyan ctermbg=NONE gui=NONE guifg=DarkCyan guibg=NONE | |
line 48: SynColor Statement^Iterm=bold cterm=NONE ctermfg=Brown ctermbg=NONE gui=bold guifg=Brown guibg=NONE | |
line 49: SynColor PreProc^Iterm=underline cterm=NONE ctermfg=DarkMagenta ctermbg=NONE gui=NONE guifg=Purple guibg=NONE | |
line 50: SynColor Type^I^Iterm=underline cterm=NONE ctermfg=DarkGreen ctermbg=NONE gui=bold guifg=SeaGreen guibg=NONE | |
line 51: SynColor Underlined^Iterm=underline cterm=underline ctermfg=DarkMagenta gui=underline guifg=SlateBlue | |
line 52: SynColor Ignore^Iterm=NONE cterm=NONE ctermfg=white ctermbg=NONE gui=NONE guifg=bg guibg=NONE | |
line 53: endif | |
line 54: SynColor Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 54: hi Error^I^Iterm=reverse cterm=NONE ctermfg=White ctermbg=Red gui=NONE guifg=White guibg=Red | |
line 55: SynColor Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 55: hi Todo^I^Iterm=standout cterm=NONE ctermfg=Black ctermbg=Yellow gui=NONE guifg=Blue guibg=Yellow | |
line 56: | |
line 57: " Common groups that link to default highlighting. | |
line 58: " You can specify other highlighting easily. | |
line 59: SynLink String^I^IConstant | |
line 59: hi! link String^I^IConstant | |
line 60: SynLink Character^IConstant | |
line 60: hi! link Character^IConstant | |
line 61: SynLink Number^I^IConstant | |
line 61: hi! link Number^I^IConstant | |
line 62: SynLink Boolean^I^IConstant | |
line 62: hi! link Boolean^I^IConstant | |
line 63: SynLink Float^I^INumber | |
line 63: hi! link Float^I^INumber | |
line 64: SynLink Function^IIdentifier | |
line 64: hi! link Function^IIdentifier | |
line 65: SynLink Conditional^IStatement | |
line 65: hi! link Conditional^IStatement | |
line 66: SynLink Repeat^I^IStatement | |
line 66: hi! link Repeat^I^IStatement | |
line 67: SynLink Label^I^IStatement | |
line 67: hi! link Label^I^IStatement | |
line 68: SynLink Operator^IStatement | |
line 68: hi! link Operator^IStatement | |
line 69: SynLink Keyword^I^IStatement | |
line 69: hi! link Keyword^I^IStatement | |
line 70: SynLink Exception^IStatement | |
line 70: hi! link Exception^IStatement | |
line 71: SynLink Include^I^IPreProc | |
line 71: hi! link Include^I^IPreProc | |
line 72: SynLink Define^I^IPreProc | |
line 72: hi! link Define^I^IPreProc | |
line 73: SynLink Macro^I^IPreProc | |
line 73: hi! link Macro^I^IPreProc | |
line 74: SynLink PreCondit^IPreProc | |
line 74: hi! link PreCondit^IPreProc | |
line 75: SynLink StorageClass^IType | |
line 75: hi! link StorageClass^IType | |
line 76: SynLink Structure^IType | |
line 76: hi! link Structure^IType | |
line 77: SynLink Typedef^I^IType | |
line 77: hi! link Typedef^I^IType | |
line 78: SynLink Tag^I^ISpecial | |
line 78: hi! link Tag^I^ISpecial | |
line 79: SynLink SpecialChar^ISpecial | |
line 79: hi! link SpecialChar^ISpecial | |
line 80: SynLink Delimiter^ISpecial | |
line 80: hi! link Delimiter^ISpecial | |
line 81: SynLink SpecialComment^ISpecial | |
line 81: hi! link SpecialComment^ISpecial | |
line 82: SynLink Debug^I^ISpecial | |
line 82: hi! link Debug^I^ISpecial | |
line 83: | |
line 84: delcommand SynColor | |
line 85: delcommand SynLink | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/syntax/syncolor.vim | |
continuing in /Users/nhooyr/.nvim/plugged/Apprentice/colors/apprentice.vim | |
Searching for "/usr/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/usr/local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/syntax/syncolor.vim" | |
Searching for "/etc/xdg/nvim/after/syntax/syncolor.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/syntax/syncolor.vim" | |
line 33: endif | |
line 34: | |
line 35: let colors_name = "apprentice" | |
line 36: | |
line 37: if ($TERM =~ '256' && &t_Co >= 256) || has("gui_running") | |
line 38: hi Normal ctermbg=235 ctermfg=250 guibg=#262626 guifg=#bcbcbc cterm=NONE gui=NONE | |
line 39: | |
line 40: set background=dark | |
line 41: | |
line 42: hi Comment ctermbg=NONE ctermfg=240 guibg=NONE guifg=#585858 cterm=NONE gui=NONE | |
line 43: hi Conceal ctermbg=NONE ctermfg=250 guibg=NONE guifg=#bcbcbc cterm=NONE gui=NONE | |
line 44: hi Constant ctermbg=NONE ctermfg=208 guibg=NONE guifg=#ff8700 cterm=NONE gui=NONE | |
line 45: hi Error ctermbg=NONE ctermfg=131 guibg=NONE guifg=#af5f5f cterm=reverse gui=reverse | |
line 46: hi Identifier ctermbg=NONE ctermfg=67 guibg=NONE guifg=#5f87af cterm=NONE gui=NONE | |
line 47: hi Ignore ctermbg=NONE ctermfg=NONE guibg=NONE guifg=NONE cterm=NONE gui=NONE | |
line 48: hi PreProc ctermbg=NONE ctermfg=66 guibg=NONE guifg=#5f8787 cterm=NONE gui=NONE | |
line 49: hi Special ctermbg=NONE ctermfg=65 guibg=NONE guifg=#5f875f cterm=NONE gui=NONE | |
line 50: hi Statement ctermbg=NONE ctermfg=110 guibg=NONE guifg=#8fafd7 cterm=NONE gui=NONE | |
line 51: hi String ctermbg=NONE ctermfg=108 guibg=NONE guifg=#87af87 cterm=NONE gui=NONE | |
line 52: hi Todo ctermbg=NONE ctermfg=NONE guibg=NONE guifg=NONE cterm=reverse gui=reverse | |
line 53: hi Type ctermbg=NONE ctermfg=103 guibg=NONE guifg=#8787af cterm=NONE gui=NONE | |
line 54: hi Underlined ctermbg=NONE ctermfg=66 guibg=NONE guifg=#5f8787 cterm=underline gui=underline | |
line 55: | |
line 56: hi LineNr ctermbg=234 ctermfg=242 guibg=#1c1c1c guifg=#6c6c6c cterm=NONE gui=NONE | |
line 57: hi NonText ctermbg=NONE ctermfg=240 guibg=NONE guifg=#585858 cterm=NONE gui=NONE | |
line 58: | |
line 59: hi Pmenu ctermbg=238 ctermfg=250 guibg=#444444 guifg=#bcbcbc cterm=NONE gui=NONE | |
line 60: hi PmenuSbar ctermbg=240 ctermfg=NONE guibg=#585858 guifg=NONE cterm=NONE gui=NONE | |
line 61: hi PmenuSel ctermbg=66 ctermfg=235 guibg=#5f8787 guifg=#262626 cterm=NONE gui=NONE | |
line 62: hi PmenuThumb ctermbg=66 ctermfg=66 guibg=#5f8787 guifg=#5f8787 cterm=NONE gui=NONE | |
line 63: | |
line 64: hi ErrorMsg ctermbg=131 ctermfg=235 guibg=#af5f5f guifg=#262626 cterm=NONE gui=NONE | |
line 65: hi ModeMsg ctermbg=108 ctermfg=235 guibg=#87af87 guifg=#262626 cterm=NONE gui=NONE | |
line 66: hi MoreMsg ctermbg=NONE ctermfg=66 guibg=NONE guifg=#5f8787 cterm=NONE gui=NONE | |
line 67: hi Question ctermbg=NONE ctermfg=108 guibg=NONE guifg=#87af87 cterm=NONE gui=NONE | |
line 68: hi WarningMsg ctermbg=NONE ctermfg=131 guibg=NONE guifg=#af5f5f cterm=NONE gui=NONE | |
line 69: | |
line 70: hi TabLine ctermbg=238 ctermfg=101 guibg=#444444 guifg=#87875f cterm=NONE gui=NONE | |
line 71: hi TabLineFill ctermbg=238 ctermfg=238 guibg=#444444 guifg=#444444 cterm=NONE gui=NONE | |
line 72: hi TabLineSel ctermbg=101 ctermfg=235 guibg=#87875f guifg=#262626 cterm=NONE gui=NONE | |
line 73: | |
line 74: hi Cursor ctermbg=242 ctermfg=NONE guibg=#6c6c6c guifg=NONE cterm=NONE gui=NONE | |
line 75: hi CursorColumn ctermbg=236 ctermfg=NONE guibg=#303030 guifg=NONE cterm=NONE gui=NONE | |
line 76: hi CursorLine ctermbg=236 ctermfg=NONE guibg=#303030 guifg=NONE cterm=NONE gui=NONE | |
line 77: hi CursorLineNr ctermbg=236 ctermfg=73 guibg=#303030 guifg=#5fafaf cterm=NONE gui=NONE | |
line 78: | |
line 79: hi helpLeadBlank ctermbg=NONE ctermfg=NONE guibg=NONE guifg=NONE cterm=NONE gui=NONE | |
line 80: hi helpNormal ctermbg=NONE ctermfg=NONE guibg=NONE guifg=NONE cterm=NONE gui=NONE | |
line 81: | |
line 82: hi StatusLine ctermbg=101 ctermfg=235 guibg=#87875f guifg=#262626 cterm=NONE gui=NONE | |
line 83: hi StatusLineNC ctermbg=238 ctermfg=101 guibg=#444444 guifg=#87875f cterm=NONE gui=italic | |
line 84: | |
line 85: hi Visual ctermbg=110 ctermfg=235 guibg=#8fafd7 guifg=#262626 cterm=NONE gui=NONE | |
line 86: hi VisualNOS ctermbg=NONE ctermfg=NONE guibg=NONE guifg=NONE cterm=underline gui=underline | |
line 87: | |
line 88: hi FoldColumn ctermbg=234 ctermfg=242 guibg=#1c1c1c guifg=#6c6c6c cterm=NONE gui=NONE | |
line 89: hi Folded ctermbg=234 ctermfg=242 guibg=#1c1c1c guifg=#6c6c6c cterm=NONE gui=NONE | |
line 90: | |
line 91: hi VertSplit ctermbg=238 ctermfg=238 guibg=#444444 guifg=#444444 cterm=NONE gui=NONE | |
line 92: hi WildMenu ctermbg=110 ctermfg=235 guibg=#8fafd7 guifg=#262626 cterm=NONE gui=NONE | |
line 93: | |
line 94: hi Function ctermbg=NONE ctermfg=229 guibg=NONE guifg=#ffffaf cterm=NONE gui=NONE | |
line 95: hi SpecialKey ctermbg=NONE ctermfg=240 guibg=NONE guifg=#585858 cterm=NONE gui=NONE | |
line 96: hi Title ctermbg=NONE ctermfg=231 guibg=NONE guifg=#ffffff cterm=NONE gui=NONE | |
line 97: | |
line 98: hi DiffAdd ctermbg=108 ctermfg=235 guibg=#87af87 guifg=#262626 cterm=NONE gui=NONE | |
line 99: hi DiffChange ctermbg=60 ctermfg=235 guibg=#5f5f87 guifg=#262626 cterm=NONE gui=NONE | |
line 100: hi DiffDelete ctermbg=131 ctermfg=235 guibg=#af5f5f guifg=#262626 cterm=NONE gui=NONE | |
line 101: hi DiffText ctermbg=103 ctermfg=235 guibg=#8787af guifg=#262626 cterm=NONE gui=NONE | |
line 102: | |
line 103: hi IncSearch ctermbg=131 ctermfg=235 guibg=#af5f5f guifg=#262626 cterm=NONE gui=NONE | |
line 104: hi Search ctermbg=229 ctermfg=235 guibg=#ffffaf guifg=#262626 cterm=NONE gui=NONE | |
line 105: | |
line 106: hi Directory ctermbg=NONE ctermfg=73 guibg=NONE guifg=#5fafaf cterm=NONE gui=NONE | |
line 107: hi MatchParen ctermbg=234 ctermfg=229 guibg=#1c1c1c guifg=#ffffaf cterm=NONE gui=NONE | |
line 108: | |
line 109: hi SpellBad ctermbg=NONE ctermfg=131 guibg=NONE guifg=NONE cterm=undercurl gui=undercurl guisp=#af5f5f | |
line 110: hi SpellCap ctermbg=NONE ctermfg=73 guibg=NONE guifg=NONE cterm=undercurl gui=undercurl guisp=#5fafaf | |
line 111: hi SpellLocal ctermbg=NONE ctermfg=65 guibg=NONE guifg=NONE cterm=undercurl gui=undercurl guisp=#5f875f | |
line 112: hi SpellRare ctermbg=NONE ctermfg=208 guibg=NONE guifg=NONE cterm=undercurl gui=undercurl guisp=#ff8700 | |
line 113: | |
line 114: hi ColorColumn ctermbg=131 ctermfg=NONE guibg=#af5f5f guifg=NONE cterm=NONE gui=NONE | |
line 115: hi signColumn ctermbg=234 ctermfg=242 guibg=#1c1c1c guifg=#6c6c6c cterm=NONE gui=NONE | |
line 116: elseif &t_Co == 8 || $TERM !~# '^linux' || &t_Co == 16 | |
line 117: set t_Co=16 | |
line 118: | |
line 119: hi Normal ctermbg=NONE ctermfg=white cterm=NONE | |
line 120: | |
line 121: set background=dark | |
line 122: | |
line 123: hi Comment ctermbg=NONE ctermfg=gray cterm=NONE | |
line 124: hi Conceal ctermbg=NONE ctermfg=white cterm=NONE | |
line 125: hi Constant ctermbg=NONE ctermfg=red cterm=NONE | |
line 126: hi Function ctermbg=NONE ctermfg=yellow cterm=NONE | |
line 127: hi Identifier ctermbg=NONE ctermfg=darkblue cterm=NONE | |
line 128: hi PreProc ctermbg=NONE ctermfg=darkcyan cterm=NONE | |
line 129: hi Special ctermbg=NONE ctermfg=darkgreen cterm=NONE | |
line 130: hi Statement ctermbg=NONE ctermfg=blue cterm=NONE | |
line 131: hi String ctermbg=NONE ctermfg=green cterm=NONE | |
line 132: hi Todo ctermbg=NONE ctermfg=NONE cterm=reverse | |
line 133: hi Type ctermbg=NONE ctermfg=magenta cterm=NONE | |
line 134: | |
line 135: hi Error ctermbg=NONE ctermfg=darkred cterm=reverse | |
line 136: hi Ignore ctermbg=NONE ctermfg=NONE cterm=NONE | |
line 137: hi Underlined ctermbg=NONE ctermfg=NONE cterm=reverse | |
line 138: | |
line 139: hi LineNr ctermbg=black ctermfg=gray cterm=NONE | |
line 140: hi NonText ctermbg=NONE ctermfg=darkgray cterm=NONE | |
line 141: | |
line 142: hi Pmenu ctermbg=darkgray ctermfg=white cterm=NONE | |
line 143: hi PmenuSbar ctermbg=gray ctermfg=NONE cterm=NONE | |
line 144: hi PmenuSel ctermbg=darkcyan ctermfg=black cterm=NONE | |
line 145: hi PmenuThumb ctermbg=darkcyan ctermfg=NONE cterm=NONE | |
line 146: | |
line 147: hi ErrorMsg ctermbg=darkred ctermfg=black cterm=NONE | |
line 148: hi ModeMsg ctermbg=darkgreen ctermfg=black cterm=NONE | |
line 149: hi MoreMsg ctermbg=NONE ctermfg=darkcyan cterm=NONE | |
line 150: hi Question ctermbg=NONE ctermfg=green cterm=NONE | |
line 151: hi WarningMsg ctermbg=NONE ctermfg=darkred cterm=NONE | |
line 152: | |
line 153: hi TabLine ctermbg=darkgray ctermfg=darkyellow cterm=NONE | |
line 154: hi TabLineFill ctermbg=darkgray ctermfg=black cterm=NONE | |
line 155: hi TabLineSel ctermbg=darkyellow ctermfg=black cterm=NONE | |
line 156: | |
line 157: hi Cursor ctermbg=NONE ctermfg=NONE cterm=NONE | |
line 158: hi CursorColumn ctermbg=darkgray ctermfg=NONE cterm=NONE | |
line 159: hi CursorLine ctermbg=darkgray ctermfg=NONE cterm=NONE | |
line 160: hi CursorLineNr ctermbg=black ctermfg=cyan cterm=NONE | |
line 161: | |
line 162: hi helpLeadBlank ctermbg=NONE ctermfg=NONE cterm=NONE | |
line 163: hi helpNormal ctermbg=NONE ctermfg=NONE cterm=NONE | |
line 164: | |
line 165: hi StatusLine ctermbg=darkyellow ctermfg=black cterm=NONE | |
line 166: hi StatusLineNC ctermbg=darkgray ctermfg=black cterm=NONE | |
line 167: | |
line 168: hi Visual ctermbg=blue ctermfg=black cterm=NONE | |
line 169: hi VisualNOS ctermbg=white ctermfg=black cterm=NONE | |
line 170: | |
line 171: hi FoldColumn ctermbg=black ctermfg=darkgray cterm=NONE | |
line 172: hi Folded ctermbg=black ctermfg=darkgray cterm=NONE | |
line 173: | |
line 174: hi VertSplit ctermbg=darkgray ctermfg=darkgray cterm=NONE | |
line 175: hi WildMenu ctermbg=blue ctermfg=black cterm=NONE | |
line 176: | |
line 177: hi SpecialKey ctermbg=NONE ctermfg=darkgray cterm=NONE | |
line 178: hi Title ctermbg=NONE ctermfg=white cterm=NONE | |
line 179: | |
line 180: hi DiffAdd ctermbg=darkgreen ctermfg=black cterm=NONE | |
line 181: hi DiffChange ctermbg=darkcyan ctermfg=black cterm=NONE | |
line 182: hi DiffDelete ctermbg=darkred ctermfg=black cterm=NONE | |
line 183: hi DiffText ctermbg=yellow ctermfg=black cterm=NONE | |
line 184: | |
line 185: hi IncSearch ctermbg=darkred ctermfg=black cterm=NONE | |
line 186: hi Search ctermbg=yellow ctermfg=black cterm=NONE | |
line 187: | |
line 188: hi Directory ctermbg=NONE ctermfg=cyan cterm=NONE | |
line 189: hi MatchParen ctermbg=black ctermfg=yellow cterm=NONE | |
line 190: | |
line 191: hi SpellBad ctermbg=NONE ctermfg=darkred cterm=undercurl | |
line 192: hi SpellCap ctermbg=NONE ctermfg=darkyellow cterm=undercurl | |
line 193: hi SpellLocal ctermbg=NONE ctermfg=darkgreen cterm=undercurl | |
line 194: hi SpellRare ctermbg=NONE ctermfg=darkmagenta cterm=undercurl | |
line 195: | |
line 196: hi ColorColumn ctermbg=darkred ctermfg=NONE cterm=NONE | |
line 197: hi SignColumn ctermbg=black ctermfg=darkgray cterm=NONE | |
line 198: endif | |
line 199: | |
line 200: hi link Boolean Constant | |
line 201: hi link Character Constant | |
line 202: hi link Conditional Statement | |
line 203: hi link Debug Special | |
line 204: hi link Define PreProc | |
line 205: hi link Delimiter Special | |
line 206: hi link Exception Statement | |
line 207: hi link Float Number | |
line 208: hi link HelpCommand Statement | |
line 209: hi link HelpExample Statement | |
line 210: hi link Include PreProc | |
line 211: hi link Keyword Statement | |
line 212: hi link Label Statement | |
line 213: hi link Macro PreProc | |
line 214: hi link Number Constant | |
line 215: hi link Operator Statement | |
line 216: hi link PreCondit PreProc | |
line 217: hi link Repeat Statement | |
line 218: hi link SpecialChar Special | |
line 219: hi link SpecialComment Special | |
line 220: hi link StorageClass Type | |
line 221: hi link Structure Type | |
line 222: hi link Tag Special | |
line 223: hi link Typedef Type | |
line 224: | |
line 225: hi link htmlEndTag htmlTagName | |
line 226: hi link htmlLink Function | |
line 227: hi link htmlSpecialTagName htmlTagName | |
line 228: hi link htmlTag htmlTagName | |
line 229: hi link htmlBold Normal | |
line 230: hi link htmlItalic Normal | |
line 231: hi link xmlTag Statement | |
line 232: hi link xmlTagName Statement | |
line 233: hi link xmlEndTag Statement | |
line 234: | |
line 235: hi link markdownItalic Preproc | |
line 236: hi link asciidocQuotedEmphasized Preproc | |
line 237: | |
line 238: hi link diffBDiffer WarningMsg | |
line 239: hi link diffCommon WarningMsg | |
line 240: hi link diffDiffer WarningMsg | |
line 241: hi link diffIdentical WarningMsg | |
line 242: hi link diffIsA WarningMsg | |
line 243: hi link diffNoEOL WarningMsg | |
line 244: hi link diffOnly WarningMsg | |
line 245: hi link diffRemoved WarningMsg | |
line 246: hi link diffAdded String | |
line 247: | |
line 248: if $NVIM_TUI_ENABLE_TRUE_COLOR == 1 | |
line 249: let g:terminal_foreground = "#BCBCBC" | |
line 250: let g:terminal_background = "#262626" | |
line 251: let g:terminal_color_0 = "#1C1C1C" | |
line 252: let g:terminal_color_8 = "#444444" | |
line 253: let g:terminal_color_1 = "#AF5F5F" | |
line 254: let g:terminal_color_9 = "#FF8700" | |
line 255: let g:terminal_color_2 = "#5F875F" | |
line 256: let g:terminal_color_10 = "#87AF87" | |
line 257: let g:terminal_color_3 = "#87875F" | |
line 258: let g:terminal_color_11 = "#FFFFAF" | |
line 259: let g:terminal_color_4 = "#5F87AF" | |
line 260: let g:terminal_color_12 = "#8FAFD7" | |
line 261: let g:terminal_color_5 = "#5F5F87" | |
line 262: let g:terminal_color_13 = "#8787AF" | |
line 263: let g:terminal_color_6 = "#5F8787" | |
line 264: let g:terminal_color_14 = "#5FAFAF" | |
line 265: let g:terminal_color_7 = "#6C6C6C" | |
line 266: let g:terminal_color_15 = "#FFFFFF" | |
line 267: endif | |
finished sourcing /Users/nhooyr/.nvim/plugged/Apprentice/colors/apprentice.vim | |
continuing in /Users/nhooyr/dotfiles/nvim/init.vim | |
line 48: hi Normal ctermbg=black | |
line 49: hi Search ctermfg=0 ctermbg=110 | |
line 50: hi Cursor ctermfg=0 ctermbg=fg | |
line 51: hi IncSearch ctermfg=0 ctermbg=2 | |
line 52: hi Directory ctermfg=7 | |
line 53: hi StatusLine ctermbg=0 ctermfg=7 | |
line 54: hi WildMenu ctermbg=253 ctermfg=0 | |
line 55: hi TODO ctermbg=0 ctermfg=6 cterm=bold | |
line 56: hi VertSplit ctermbg=0 ctermfg=238 | |
line 57: hi DiffChange cterm=none ctermfg=235 ctermbg=103 | |
line 58: hi DiffText cterm=none ctermfg=235 ctermbg=13 | |
line 59: hi TrollStopper ctermbg=5 ctermfg=8 | |
line 60: set wildignorecase | |
line 61: set backspace=indent,eol,start | |
line 62: set title | |
line 63: set re=1 | |
line 64: set number | |
line 65: set relativenumber | |
line 66: hi CursorLine ctermbg=234 | |
line 67: hi CursorLineNR ctermbg=234 | |
line 68: set noruler | |
line 69: set laststatus=2 | |
line 70: set updatetime=0 | |
line 71: set noshowmode | |
line 72: set showcmd | |
line 73: set ignorecase | |
line 74: set smartcase | |
line 75: set incsearch | |
line 76: set autochdir | |
line 77: let g:netrw_winsize = 15 | |
line 78: let g:netrw_banner = 0 | |
line 79: let g:netrw_liststyle = 3 | |
line 80: let g:netrw_browse_split = 0 | |
line 81: let g:netrw_altv=1 | |
line 82: set scrolloff=5 | |
line 83: | |
line 84: let g:user_emmet_install_global = 0 | |
line 85: autocmd FileType html,css EmmetInstall | |
line 86: let g:user_emmet_leader_key='<C-Z>' | |
line 87: | |
line 88: nnoremap <silent><expr> <leader>h (&hls && v:hlsearch ? ':nohls' : ':set hls')."\n" | |
line 89: nnoremap <Esc><Esc> :<C-u>nohlsearch<CR> | |
line 90: nnoremap Q <nop> | |
line 91: au BufRead,BufNewFile .z* setfiletype zsh | |
line 92: | |
line 93: " make YCM compatible with UltiSnips (using supertab) | |
line 94: "let g:ycm_key_list_select_completion = ['<C-n>', '<Down>'] | |
line 95: "let g:ycm_key_list_previous_completion = ['<C-p>', '<Up>'] | |
line 96: "let g:SuperTabDefaultCompletionType = '<C-n>' | |
line 97: | |
line 98: " better key bindings for UltiSnipsExpandTrigger | |
line 99: "let g:UltiSnipsExpandTrigger = "<tab>" | |
line 100: "let g:UltiSnipsJumpForwardTrigger = "<tab>" | |
line 101: "let g:UltiSnipsJumpBackwardTrigger = "<s-tab>" | |
line 102: | |
line 103: let g:airline#extensions#tabline#enabled = 1 | |
line 104: let g:airline_powerline_fonts = 1 | |
line 105: let g:airline_theme = "nhooyr" | |
line 106: let g:airline_left_sep='' | |
line 107: let g:airline_right_sep='' | |
line 108: | |
line 109: " Go keyboard mappings | |
line 110: au FileType go nmap <leader>i :GoImport | |
line 111: au FileType go nmap <leader>di :GoDrop | |
line 112: au FileType go nmap <Leader>gd <Plug>(go-doc) | |
line 113: au FileType go nmap <Leader>gv <Plug>(go-doc-vertical) | |
line 114: au FileType go nmap <Leader>gi <Plug>(go-implements) | |
line 115: au FileType go nmap <leader>f :GoFmt<CR> | |
line 116: au FileType go nmap <leader>gr :GoRename | |
line 117: au FileType go nmap <leader>dd <Plug>(go-def) | |
line 118: au FileType go nmap <leader>b <Plug>(go-build) | |
line 119: au FileType go nmap <leader>n <Plug>(go-info) | |
line 120: nmap <leader>l :TagbarToggle<CR> | |
line 121: "nmap <leader>c :SyntasticCheck<CR> | |
line 122: nmap <leader>r :so $MYVIMRC<CR> | |
line 123: nmap <leader>m :make<CR> | |
line 124: nmap <leader>w :ToggleWhitespace<CR> | |
line 125: nmap <leader>ws :w !sudo tee %<CR> | |
line 126: nmap <leader>0 :vs ~/.homework<CR> | |
line 127: nmap <leader>to :vs ~/.todo<CR> | |
line 128: nmap <leader>z :FZF<CR> | |
line 129: nmap <leader>s :OverCommandLine<CR> | |
line 130: | |
line 132: let g:startify_custom_header = map(split(system('fortune -s | cowsay'), '\n'), '" ". v:val') + ['',''] | |
line 133: | |
line 134: let g:go_highlight_functions = 1 | |
line 135: let g:go_highlight_methods = 1 | |
line 136: let g:go_highlight_structs = 1 | |
line 137: let g:go_highlight_operators = 1 | |
line 138: let g:go_highlight_build_constraints = 1 | |
line 139: let g:go_fmt_command = "goimports" | |
line 140: let g:go_fmt_autosave = 0 | |
line 141: let g:go_jump_to_error = 0 | |
line 142: let g:go_auto_type_info = 0 | |
line 143: | |
line 144: let g:tagbar_autofocus = 1 | |
line 145: let g:tagbar_autoclose = 1 | |
line 146: | |
line 147: " Show syntax highlighting groups for word under cursor ctrl+p | |
line 148: nmap <C-P> :call <SID>SynStack()<CR> | |
line 149: function! <SID>SynStack() | |
line 155: | |
line 159: "let g:syntastic_mode_map = { "mode": "passive", "active_filetypes": [],"passive_filetypes": [] } | |
line 160: "let g:syntastic_always_populate_loc_list = 1 | |
line 161: "let g:syntastic_auto_loc_list = 1 | |
line 162: "let g:syntastic_go_go_build_args = "-o /dev/null" | |
line 163: "let g:syntastic_auto_jump = 1 | |
line 164: hi ErrorMsg ctermbg=234 ctermfg=73 | |
line 165: | |
line 166: let g:delimitMate_expand_cr = 1 | |
line 167: | |
line 168: let g:qs_highlight_on_keys = ['f', 'F', 't', 'T'] | |
line 169: let g:qs_first_occurrence_highlight_color = 2 | |
line 170: let g:qs_second_occurrence_highlight_color = 1 | |
line 171: | |
line 172: let g:languagetool_jar = '/usr/local/Cellar/languagetool/3.0/libexec/languagetool-commandline."jar' | |
line 173: | |
line 174: ino <C-h> <ESC>:TmuxNavigateLeft<cr> | |
line 175: ino <C-j> <ESC>:TmuxNavigateDown<cr> | |
line 176: ino <C-k> <ESC>:TmuxNavigateUp<cr> | |
line 177: ino <C-l> <ESC>:TmuxNavigateRight<cr> | |
line 178: ino <C-\> <ESC>:TmuxNavigatePrevious<cr> | |
line 179: nnoremap * *`` | |
line 180: set spell spelllang=en_ca | |
Searching for "spell/en.utf-8.spl" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhoo | |
Searching for "/Users/nhooyr/dotfiles/nvim/spell/en.utf-8.spl" | |
Reading spell file "/Users/nhooyr/dotfiles/nvim/spell/en.utf-8.spl" | |
Searching for "spell/en.utf-8.add.spl" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/spell/en.utf-8.add.spl" | |
Reading spell file "/Users/nhooyr/dotfiles/nvim/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.fzf/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/spell/en.utf-8.add.spl" | |
Searching for "/etc/xdg/nvim/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/spell/en.utf-8.add.spl" | |
Searching for "/usr/local/share/nvim/site/spell/en.utf-8.add.spl" | |
Searching for "/usr/share/nvim/site/spell/en.utf-8.add.spl" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/spell/en.utf-8.add.spl" | |
Searching for "/usr/share/nvim/site/after/spell/en.utf-8.add.spl" | |
Searching for "/usr/local/share/nvim/site/after/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/spell/en.utf-8.add.spl" | |
Searching for "/etc/xdg/nvim/after/spell/en.utf-8.add.spl" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/spell/en.utf-8.add.spl" | |
Searching for "spell/en.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/dot | |
Searching for "/Users/nhooyr/dotfiles/nvim/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/spell/en.vim" | |
Searching for "/Users/nhooyr/.fzf/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/spell/en.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/spell/en.vim" | |
Searching for "/etc/xdg/nvim/spell/en.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/spell/en.vim" | |
Searching for "/usr/local/share/nvim/site/spell/en.vim" | |
Searching for "/usr/share/nvim/site/spell/en.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/spell/en.vim" | |
Searching for "/usr/share/nvim/site/after/spell/en.vim" | |
Searching for "/usr/local/share/nvim/site/after/spell/en.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/spell/en.vim" | |
Searching for "/etc/xdg/nvim/after/spell/en.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/spell/en.vim" | |
not found in 'runtimepath': "spell/en.vim" | |
line 181: autocmd FileType startify setlocal nospell | |
line 182: autocmd FileType help setlocal nospell | |
line 183: autocmd FileType vim-plug setlocal nospell | |
line 184: au TermOpen * setlocal nospell | |
line 185: nnoremap <A-a> <C-a> | |
line 186: nnoremap <A-x> <C-x> | |
line 187: let g:html_indent_inctags = "body,head,tbody" | |
line 188: let g:ycm_key_detailed_diagnostics = '' | |
line 189: let g:ycm_key_invoke_completion = '<C-x>' | |
line 190: set backup | |
line 191: set backupdir=~/.nvim/backup | |
line 192: set backupskip=/tmp/*,/private/tmp/* | |
line 193: set directory=~/.nvim/swap | |
line 194: set undofile | |
line 195: set undodir=~/.nvim/undodir | |
line 196: set writebackup | |
line 197: set splitbelow | |
line 198: set splitright | |
line 199: autocmd! BufWritePost * Neomake | |
line 200: let g:neomake_open_list = 1 | |
line 204: let g:neomake_error_sign = { 'text': '>', 'texthl': 'ErrorMsg', } | |
line 205: | |
finished sourcing /Users/nhooyr/dotfiles/nvim/init.vim | |
Searching for "plugin/**/*.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/plugin/**/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/neomake/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/neomake/plugin/neomake.vim" | |
line 1: " vim: ts=4 sw=4 et | |
line 2: | |
line 3: function! s:NeomakeCommand(file_mode, enabled_makers) | |
line 20: | |
line 21: function! s:NeomakeSh(sh_command) | |
line 28: | |
line 29: command! -nargs=* -bang -bar -complete=customlist,neomake#CompleteMakers Neomake call s:NeomakeCommand(<bang>1, [<f-args>]) | |
line 30: " These commands are available for clarity | |
line 31: command! -nargs=* -bar -complete=customlist,neomake#CompleteMakers NeomakeProject Neomake! <args> | |
line 32: command! -nargs=* -bar -complete=customlist,neomake#CompleteMakers NeomakeFile Neomake <args> | |
line 33: | |
line 34: command! -nargs=+ -complete=shellcmd NeomakeSh call s:NeomakeSh(<q-args>) | |
line 35: | |
line 36: command! NeomakeListJobs call neomake#ListJobs() | |
line 37: | |
line 38: augroup neomake | |
line 39: autocmd! | |
line 40: autocmd BufWinEnter,CursorHold * call neomake#ProcessCurrentBuffer() | |
line 41: autocmd CursorMoved * call neomake#CursorMoved() | |
line 42: augroup END | |
finished sourcing /Users/nhooyr/.nvim/plugged/neomake/plugin/neomake.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/tagbar/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/tagbar/plugin/tagbar.vim" | |
line 1: " ============================================================================ | |
line 2: " File: tagbar.vim | |
line 3: " Description: List the current file's tags in a sidebar, ordered by class etc | |
line 4: " Author: Jan Larres <[email protected]> | |
line 5: " Licence: Vim licence | |
line 6: " Website: http://majutsushi.github.com/tagbar/ | |
line 7: " Version: 2.6.1 | |
line 8: " Note: This plugin was heavily inspired by the 'Taglist' plugin by | |
line 9: " Yegappan Lakshmanan and uses a small amount of code from it. | |
line 10: " | |
line 11: " Original taglist copyright notice: | |
line 12: " Permission is hereby granted to use and distribute this code, | |
line 13: " with or without modifications, provided that this copyright | |
line 14: " notice is copied with it. Like anything else that's free, | |
line 15: " taglist.vim is provided *as is* and comes with no warranty of | |
line 16: " any kind, either expressed or implied. In no event will the | |
line 17: " copyright holder be liable for any damamges resulting from the | |
line 18: " use of this software. | |
line 19: " ============================================================================ | |
line 20: | |
line 21: scriptencoding utf-8 | |
line 22: | |
line 23: if &cp || exists('g:loaded_tagbar') | |
line 24: finish | |
line 25: endif | |
line 26: | |
line 27: " Basic init {{{1 | |
line 28: | |
line 29: if v:version < 700 | |
line 30: echohl WarningMsg | |
line 31: echomsg 'Tagbar: Vim version is too old, Tagbar requires at least 7.0' | |
line 32: echohl None | |
line 33: finish | |
line 34: endif | |
line 35: | |
line 36: if v:version == 700 && !has('patch167') | |
line 37: echohl WarningMsg | |
line 40: echomsg 'Tagbar: Vim versions lower than 7.0.167 have a bug' 'that prevents this version of Tagbar from working.' 'Please use the alternate version posted on the website.' | |
line 41: echohl None | |
line 42: finish | |
line 43: endif | |
line 44: | |
line 45: function! s:init_var(var, value) abort | |
line 50: | |
line 51: function! s:setup_options() abort | |
line 83: call s:setup_options() | |
calling function <SNR>14_setup_options() | |
line 1: if !exists('g:tagbar_vertical') || g:tagbar_vertical == 0 | |
line 2: let previewwin_pos = 'topleft' | |
line 3: else | |
line 4: let previewwin_pos = 'rightbelow vertical' | |
line 5: endif | |
line 6: let options = [ ['autoclose', 0], ['autofocus', 0], ['autopreview', 0], ['autoshowtag', 0], ['compact', 0], ['expand', 0], ['foldlevel', 99], ['hide_nonpublic', 0], ['indent', 2], ['left', 0], ['previewwin_pos', previewwin_pos], ['show_visibility', 1], ['show_linenumbers', 0], ['singleclick', 0], ['sort', 1], ['systemenc', &encoding], ['vertical', 0], ['width', 40], ['zoomwidth', 1], ] | |
line 27: | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('autoclose', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('autofocus', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('autopreview', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_autopreview = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('autoshowtag', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_autoshowtag = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('compact', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_compact = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('expand', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_expand = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('foldlevel', 99) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_foldlevel = 99 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('hide_nonpublic', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_hide_nonpublic = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('indent', 2) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_indent = 2 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('left', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_left = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('previewwin_pos', 'topleft') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_previewwin_pos = 'topleft' | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('show_visibility', 1) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_show_visibility = 1 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('show_linenumbers', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_show_linenumbers = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('singleclick', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_singleclick = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('sort', 1) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_sort = 1 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('systemenc', 'utf-8') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_systemenc = 'utf-8' | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('vertical', 0) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_vertical = 0 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('width', 40) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_width = 40 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
calling function <SNR>14_setup_options..<SNR>14_init_var('zoomwidth', 1) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_zoomwidth = 1 | |
line 3: endif | |
function <SNR>14_setup_options..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_options | |
line 30: endfor | |
line 28: for [opt, val] in options | |
line 29: call s:init_var(opt, val) | |
line 30: endfor | |
function <SNR>14_setup_options returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/tagbar/plugin/tagbar.vim | |
line 84: | |
line 85: if !exists('g:tagbar_iconchars') | |
line 87: if has('multi_byte') && has('unix') && &encoding == 'utf-8' && (empty(&termencoding) || &termencoding == 'utf-8') | |
line 88: let g:tagbar_iconchars = ['▶', '▼'] | |
line 89: else | |
line 90: let g:tagbar_iconchars = ['+', '-'] | |
line 91: endif | |
line 92: endif | |
line 93: | |
line 94: function! s:setup_keymaps() abort | |
line 124: call s:setup_keymaps() | |
calling function <SNR>14_setup_keymaps() | |
line 1: let keymaps = [ ['jump', '<CR>'], ['preview', 'p'], ['previewwin', 'P'], ['nexttag', '<C-N>'], ['prevtag', '<C-P>'], ['showproto', '<Space>'], ['hidenonpublic', 'v'], ['openfold', ['+', '<kPlus>', 'zo']], ['closefold', ['-', '<kMinus>', 'zc']], ['togglefold', ['o', 'za']], ['openallfolds', ['*', '<kMultiply>', 'zR']], ['closeallfolds', ['=', 'zM']], ['nextfold', 'zj'], ['prevfold', 'zk'], ['togglesort', 's'], ['toggleautoclose', 'c'], ['zoomwin', 'x'], ['close', 'q'], ['help', ['<F1>', '?']], ] | |
line 24: | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_jump', '<CR>') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_jump = '<CR>' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_preview', 'p') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_preview = 'p' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_previewwin', 'P') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_previewwin = 'P' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_nexttag', '<C-N>') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_nexttag = '<C-N>' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_prevtag', '<C-P>') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_prevtag = '<C-P>' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_showproto', '<Space>') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_showproto = '<Space>' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_hidenonpublic', 'v') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_hidenonpublic = 'v' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_openfold', ['+', '<kPlus>', 'zo']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_openfold = ['+', '<kPlus>', 'zo'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_closefold', ['-', '<kMinus>', 'zc']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_closefold = ['-', '<kMinus>', 'zc'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_togglefold', ['o', 'za']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_togglefold = ['o', 'za'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_openallfolds', ['*', '<kMultiply>', 'zR']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_openallfolds = ['*', '<kMultiply>', 'zR'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_closeallfolds', ['=', 'zM']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_closeallfolds = ['=', 'zM'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_nextfold', 'zj') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_nextfold = 'zj' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_prevfold', 'zk') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_prevfold = 'zk' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_togglesort', 's') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_togglesort = 's' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_toggleautoclose', 'c') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_toggleautoclose = 'c' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_zoomwin', 'x') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_zoomwin = 'x' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_close', 'q') | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_close = 'q' | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
calling function <SNR>14_setup_keymaps..<SNR>14_init_var('map_help', ['<F1>', '?']) | |
line 1: if !exists('g:tagbar_' . a:var) | |
line 2: execute 'let g:tagbar_' . a:var . ' = ' . string(a:value) | |
line 2: let g:tagbar_map_help = ['<F1>', '?'] | |
line 3: endif | |
function <SNR>14_setup_keymaps..<SNR>14_init_var returning #0 | |
continuing in function <SNR>14_setup_keymaps | |
line 27: unlet key | |
line 28: endfor | |
line 25: for [map, key] in keymaps | |
line 26: call s:init_var('map_' . map, key) | |
line 27: unlet key | |
line 28: endfor | |
function <SNR>14_setup_keymaps returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/tagbar/plugin/tagbar.vim | |
line 125: | |
line 126: augroup TagbarSession | |
line 127: autocmd! | |
line 128: autocmd SessionLoadPost * nested call tagbar#RestoreSession() | |
line 129: augroup END | |
line 130: | |
line 131: " Commands {{{1 | |
line 132: command! -nargs=0 Tagbar call tagbar#ToggleWindow() | |
line 133: command! -nargs=0 TagbarToggle call tagbar#ToggleWindow() | |
line 134: command! -nargs=? TagbarOpen call tagbar#OpenWindow(<f-args>) | |
line 135: command! -nargs=0 TagbarOpenAutoClose call tagbar#OpenWindow('fcj') | |
line 136: command! -nargs=0 TagbarClose call tagbar#CloseWindow() | |
line 137: command! -nargs=1 -bang TagbarSetFoldlevel call tagbar#SetFoldLevel(<args>, <bang>0) | |
line 138: command! -nargs=0 TagbarShowTag call tagbar#highlighttag(1, 1) | |
line 139: command! -nargs=? TagbarCurrentTag echo tagbar#currenttag('%s', 'No current tag', <f-args>) | |
line 140: command! -nargs=1 TagbarGetTypeConfig call tagbar#gettypeconfig(<f-args>) | |
line 141: command! -nargs=? TagbarDebug call tagbar#StartDebug(<f-args>) | |
line 142: command! -nargs=0 TagbarDebugEnd call tagbar#StopDebug() | |
line 143: command! -nargs=0 TagbarTogglePause call tagbar#toggle_pause() | |
line 144: | |
line 145: " Modeline {{{1 | |
line 146: " vim: ts=8 sw=4 sts=4 et foldenable foldmethod=marker foldcolumn=1 | |
finished sourcing /Users/nhooyr/.nvim/plugged/tagbar/plugin/tagbar.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-fugitive/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim" | |
line 1: " fugitive.vim - A Git wrapper so awesome, it should be illegal | |
line 2: " Maintainer: Tim Pope <http://tpo.pe/> | |
line 3: " Version: 2.2 | |
line 4: " GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim | |
line 5: | |
line 6: if exists('g:loaded_fugitive') || &cp | |
line 7: finish | |
line 8: endif | |
line 9: let g:loaded_fugitive = 1 | |
line 10: | |
line 11: if !exists('g:fugitive_git_executable') | |
line 12: let g:fugitive_git_executable = 'git' | |
line 13: endif | |
line 14: | |
line 15: " Section: Utility | |
line 16: | |
line 17: function! s:function(name) abort | |
line 20: | |
line 21: function! s:sub(str,pat,rep) abort | |
line 24: | |
line 25: function! s:gsub(str,pat,rep) abort | |
line 28: | |
line 29: function! s:winshell() abort | |
line 32: | |
line 33: function! s:shellesc(arg) abort | |
line 42: | |
line 43: function! s:fnameescape(file) abort | |
line 50: | |
line 51: function! s:throw(string) abort | |
line 55: | |
line 56: function! s:warn(str) abort | |
line 62: | |
line 63: function! s:shellslash(path) abort | |
line 70: | |
line 71: let s:git_versions = {} | |
line 72: | |
line 73: function! fugitive#git_version(...) abort | |
Searching for "autoload/fugitive.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/n | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/autoload/fugitive.vim" | |
Searching for "/etc/xdg/nvim/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/fugitive.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/fugitive.vim" | |
Searching for "/usr/share/nvim/site/autoload/fugitive.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/fugitive.vim" | |
Searching for "/usr/share/nvim/site/after/autoload/fugitive.vim" | |
Searching for "/usr/local/share/nvim/site/after/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/autoload/fugitive.vim" | |
Searching for "/etc/xdg/nvim/after/autoload/fugitive.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/autoload/fugitive.vim" | |
not found in 'runtimepath': "autoload/fugitive.vim" | |
line 79: | |
line 80: function! s:recall() abort | |
line 97: | |
line 98: function! s:add_methods(namespace, method_names) abort | |
line 103: | |
line 104: let s:commands = [] | |
line 105: function! s:command(definition) abort | |
line 108: | |
line 109: function! s:define_commands() abort | |
line 114: | |
line 115: augroup fugitive_utility | |
line 116: autocmd! | |
line 117: autocmd User Fugitive call s:define_commands() | |
line 118: augroup END | |
line 119: | |
line 120: let s:abstract_prototype = {} | |
line 121: | |
line 122: " Section: Initialization | |
line 123: | |
line 124: function! fugitive#is_git_dir(path) abort | |
line 128: | |
line 129: function! fugitive#extract_git_dir(path) abort | |
line 176: | |
line 177: function! fugitive#detect(path) abort | |
line 220: | |
line 221: augroup fugitive | |
line 222: autocmd! | |
line 223: autocmd BufNewFile,BufReadPost * call fugitive#detect(expand('%:p')) | |
line 224: autocmd FileType netrw call fugitive#detect(expand('%:p')) | |
line 225: autocmd User NERDTreeInit,NERDTreeNewRoot call fugitive#detect(b:NERDTreeRoot.path.str()) | |
line 226: autocmd VimEnter * if expand('<amatch>')==''|call fugitive#detect(getcwd())|endif | |
line 227: autocmd CmdWinEnter * call fugitive#detect(expand('#:p')) | |
line 228: autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave') | |
line 229: augroup END | |
line 230: | |
line 231: " Section: Repository | |
line 232: | |
line 233: let s:repo_prototype = {} | |
line 234: let s:repos = {} | |
line 235: let s:worktree_for_dir = {} | |
line 236: let s:dir_for_worktree = {} | |
line 237: | |
line 238: function! s:repo(...) abort | |
line 251: | |
line 252: function! fugitive#repo(...) abort | |
line 255: | |
line 256: function! s:repo_dir(...) dict abort | |
line 259: | |
line 260: function! s:configured_tree(git_dir) abort | |
line 279: | |
line 280: function! s:repo_tree(...) dict abort | |
line 292: | |
line 293: function! s:repo_bare() dict abort | |
line 300: | |
line 301: function! s:repo_translate(spec) dict abort | |
line 345: | |
line 346: function! s:repo_head(...) dict abort | |
line 361: | |
line 362: call s:add_methods('repo',['dir','tree','bare','translate','head']) | |
calling function <SNR>15_add_methods('repo', ['dir', 'tree', 'bare', 'translate', 'head']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_dir') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_dir') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_tree') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_tree') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_bare') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_bare') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_translate') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_translate') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_head') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_head') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 363: | |
line 364: function! s:repo_git_command(...) dict abort | |
line 368: | |
line 369: function! s:repo_git_chomp(...) dict abort | |
line 372: | |
line 373: function! s:repo_git_chomp_in_tree(...) dict abort | |
line 383: | |
line 384: function! s:repo_rev_parse(rev) dict abort | |
line 391: | |
line 392: call s:add_methods('repo',['git_command','git_chomp','git_chomp_in_tree','rev_parse']) | |
calling function <SNR>15_add_methods('repo', ['git_command', 'git_chomp', 'git_chomp_in_tree', 'rev_parse']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_git_command') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_git_command') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_git_chomp') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_git_chomp') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_git_chomp_in_tree') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_git_chomp_in_tree') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_rev_parse') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_rev_parse') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 393: | |
line 394: function! s:repo_dirglob(base) dict abort | |
line 400: | |
line 401: function! s:repo_superglob(base) dict abort | |
line 443: | |
line 444: call s:add_methods('repo',['dirglob','superglob']) | |
calling function <SNR>15_add_methods('repo', ['dirglob', 'superglob']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_dirglob') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_dirglob') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_superglob') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_superglob') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 445: | |
line 446: function! s:repo_config(conf) dict abort | |
line 449: | |
line 450: function! s:repo_user() dict abort | |
line 455: | |
line 456: function! s:repo_aliases() dict abort | |
line 465: | |
line 466: call s:add_methods('repo',['config', 'user', 'aliases']) | |
calling function <SNR>15_add_methods('repo', ['config', 'user', 'aliases']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_config') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_config') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_user') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_user') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_aliases') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_aliases') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 467: | |
line 468: function! s:repo_keywordprg() dict abort | |
line 476: | |
line 477: call s:add_methods('repo',['keywordprg']) | |
calling function <SNR>15_add_methods('repo', ['keywordprg']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_keywordprg') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_keywordprg') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 478: | |
line 479: " Section: Buffer | |
line 480: | |
line 481: let s:buffer_prototype = {} | |
line 482: | |
line 483: function! s:buffer(...) abort | |
line 491: | |
line 492: function! fugitive#buffer(...) abort | |
line 495: | |
line 496: function! s:buffer_getvar(var) dict abort | |
line 499: | |
line 500: function! s:buffer_setvar(var,value) dict abort | |
line 503: | |
line 504: function! s:buffer_getline(lnum) dict abort | |
line 507: | |
line 508: function! s:buffer_repo() dict abort | |
line 511: | |
line 512: function! s:buffer_type(...) dict abort | |
line 536: | |
line 537: if has('win32') | |
line 538: | |
line 539: function! s:buffer_spec() dict abort | |
line 547: | |
line 548: else | |
line 549: | |
line 550: function! s:buffer_spec() dict abort | |
line 554: | |
line 555: endif | |
line 556: | |
line 557: function! s:buffer_name() dict abort | |
line 560: | |
line 561: function! s:buffer_commit() dict abort | |
line 564: | |
line 565: function! s:cpath(path) abort | |
line 572: | |
line 573: function! s:buffer_path(...) dict abort | |
line 587: | |
line 588: function! s:buffer_rev() dict abort | |
line 602: | |
line 603: function! s:buffer_sha1() dict abort | |
line 610: | |
line 611: function! s:buffer_expand(rev) dict abort | |
line 628: | |
line 629: function! s:buffer_containing_commit() dict abort | |
line 638: | |
line 639: function! s:buffer_up(...) dict abort | |
line 662: | |
line 663: call s:add_methods('buffer',['getvar','setvar','getline','repo','type','spec','name','commit','path','rev','sha1','expand','containing_commit','up']) | |
calling function <SNR>15_add_methods('buffer', ['getvar', 'setvar', 'getline', 'repo...1', 'expand', 'containing_commit', 'up']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_getvar') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_getvar') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_setvar') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_setvar') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_getline') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_getline') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_repo') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_repo') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_type') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_type') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_spec') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_spec') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_name') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_name') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_commit') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_commit') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_path') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_path') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_rev') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_rev') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_sha1') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_sha1') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_expand') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_expand') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_containing_commit') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_containing_commit') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_up') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_up') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 664: | |
line 665: " Section: Git | |
line 666: | |
line 667: call s:command("-bang -nargs=? -complete=customlist,s:GitComplete Git :execute s:Git(<bang>0,<q-args>)") | |
calling function <SNR>15_command('-bang -nargs=? -complete=customlist,...te Git :execute s:Git(<bang>0,<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 668: | |
line 669: function! s:ExecuteInTree(cmd) abort | |
line 679: | |
line 680: function! s:Git(bang, args) abort | |
line 702: | |
line 703: function! fugitive#git_commands() abort | |
line 709: | |
line 710: function! s:GitComplete(A, L, P) abort | |
line 718: | |
line 719: " Section: Gcd, Glcd | |
line 720: | |
line 721: function! s:DirComplete(A,L,P) abort | |
line 725: | |
line 726: call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Gcd :cd<bang> `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`") | |
calling function <SNR>15_command('-bar -bang -nargs=? -complete=custom...ir(<q-args>) : s:repo().tree(<q-args>)`') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 727: call s:command("-bar -bang -nargs=? -complete=customlist,s:DirComplete Glcd :lcd<bang> `=s:repo().bare() ? s:repo().dir(<q-args>) : s:repo().tree(<q-args>)`") | |
calling function <SNR>15_command('-bar -bang -nargs=? -complete=custom...ir(<q-args>) : s:repo().tree(<q-args>)`') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 728: | |
line 729: " Section: Gstatus | |
line 730: | |
line 731: call s:command("-bar Gstatus :execute s:Status()") | |
calling function <SNR>15_command('-bar Gstatus :execute s:Status()') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 732: augroup fugitive_status | |
line 733: autocmd! | |
line 734: if !has('win32') | |
line 735: autocmd FocusGained,ShellCmdPost * call fugitive#reload_status() | |
line 736: autocmd BufDelete term://* call fugitive#reload_status() | |
line 737: endif | |
line 738: augroup END | |
line 739: | |
line 740: function! s:Status() abort | |
line 751: | |
line 752: function! fugitive#reload_status() abort | |
line 784: | |
line 785: function! s:stage_info(lnum) abort | |
line 810: | |
line 811: function! s:StageNext(count) abort | |
line 817: | |
line 818: function! s:StagePrevious(count) abort | |
line 828: | |
line 829: function! s:StageReloadSeek(target,lnum1,lnum2) abort | |
line 840: | |
line 841: function! s:StageUndo() abort | |
line 862: | |
line 863: function! s:StageDiff(diff) abort | |
line 881: | |
line 882: function! s:StageDiffEdit() abort | |
line 904: | |
line 905: function! s:StageToggle(lnum1,lnum2) abort | |
line 969: | |
line 970: function! s:StagePatch(lnum1,lnum2) abort | |
line 1015: | |
line 1016: " Section: Gcommit | |
line 1017: | |
line 1018: call s:command("-nargs=? -complete=customlist,s:CommitComplete Gcommit :execute s:Commit(<q-args>)") | |
calling function <SNR>15_command('-nargs=? -complete=customlist,s:Comm...ete Gcommit :execute s:Commit(<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1019: | |
line 1020: function! s:Commit(args, ...) abort | |
line 1102: | |
line 1103: function! s:CommitComplete(A,L,P) abort | |
line 1111: | |
line 1112: function! s:FinishCommit() abort | |
line 1120: | |
line 1121: " Section: Gmerge, Gpull | |
line 1122: | |
line 1124: call s:command("-nargs=? -bang -complete=custom,s:RevisionComplete Gmerge " . "execute s:Merge('merge', <bang>0, <q-args>)") | |
calling function <SNR>15_command('-nargs=? -bang -complete=custom,s:Re...e s:Merge(''merge'', <bang>0, <q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1126: call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpull " . "execute s:Merge('pull --progress', <bang>0, <q-args>)") | |
calling function <SNR>15_command('-nargs=? -bang -complete=custom,s:Re...''pull --progress'', <bang>0, <q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1127: | |
line 1128: function! s:RevisionComplete(A, L, P) abort | |
line 1132: | |
line 1133: function! s:RemoteComplete(A, L, P) abort | |
line 1144: | |
line 1145: function! fugitive#cwindow() abort | |
line 1155: | |
line 1162: let s:common_efm = '' . '%+Egit:%.%#,' . '%+Eusage:%.%#,' . '%+Eerror:%.%#,' . '%+Efatal:%.%#,' . '%-G%.%#%\e[K%.%#,' . '%-G%.%#%\r%.%\+' | |
line 1163: | |
line 1164: function! s:Merge(cmd, bang, args) abort | |
line 1241: | |
line 1242: " Section: Ggrep, Glog | |
line 1243: | |
line 1244: if !exists('g:fugitive_summary_format') | |
line 1245: let g:fugitive_summary_format = '%s' | |
line 1246: endif | |
line 1247: | |
line 1248: call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Ggrep :execute s:Grep('grep',<bang>0,<q-args>)") | |
calling function <SNR>15_command('-bang -nargs=? -complete=customlist,...ecute s:Grep(''grep'',<bang>0,<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1249: call s:command("-bang -nargs=? -complete=customlist,s:EditComplete Glgrep :execute s:Grep('lgrep',<bang>0,<q-args>)") | |
calling function <SNR>15_command('-bang -nargs=? -complete=customlist,...cute s:Grep(''lgrep'',<bang>0,<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1250: call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Glog :call s:Log('grep<bang>',<line1>,<count>,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -range=0 -comple...'grep<bang>'',<line1>,<count>,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1251: call s:command("-bar -bang -nargs=* -range=0 -complete=customlist,s:EditComplete Gllog :call s:Log('lgrep<bang>',<line1>,<count>,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -range=0 -comple...lgrep<bang>'',<line1>,<count>,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1252: | |
line 1253: function! s:Grep(cmd,bang,arg) abort | |
line 1291: | |
line 1292: function! s:Log(cmd, line1, line2, ...) abort | |
line 1329: | |
line 1330: " Section: Gedit, Gpedit, Gsplit, Gvsplit, Gtabedit, Gread | |
line 1331: | |
line 1332: function! s:Edit(cmd,bang,...) abort | |
line 1415: | |
line 1416: function! s:EditComplete(A,L,P) abort | |
line 1419: | |
line 1420: function! s:EditRunComplete(A,L,P) abort | |
line 1427: | |
line 1428: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Ge :execute s:Edit('edit<bang>',0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...ecute s:Edit(''edit<bang>'',0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1429: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gedit :execute s:Edit('edit<bang>',0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...ecute s:Edit(''edit<bang>'',0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1430: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gpedit :execute s:Edit('pedit',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...cute s:Edit(''pedit'',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1431: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gsplit :execute s:Edit('split',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...cute s:Edit(''split'',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1432: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gvsplit :execute s:Edit('vsplit',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...ute s:Edit(''vsplit'',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1433: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditRunComplete Gtabedit :execute s:Edit('tabedit',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...te s:Edit(''tabedit'',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1434: call s:command("-bar -bang -nargs=* -count -complete=customlist,s:EditRunComplete Gread :execute s:Edit((!<count> && <line1> ? '' : <count>).'read',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -count -complete...' : <count>).''read'',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1435: | |
line 1436: " Section: Gwrite, Gwq | |
line 1437: | |
line 1438: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwrite :execute s:Write(<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...rite :execute s:Write(<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1439: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gw :execute s:Write(<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...e Gw :execute s:Write(<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1440: call s:command("-bar -bang -nargs=* -complete=customlist,s:EditComplete Gwq :execute s:Wq(<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -nargs=* -complete=custom...ete Gwq :execute s:Wq(<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1441: | |
line 1442: function! s:Write(force,...) abort | |
line 1581: | |
line 1582: function! s:Wq(force,...) abort | |
line 1594: | |
line 1595: augroup fugitive_commit | |
line 1596: autocmd! | |
line 1597: autocmd VimLeavePre,BufDelete COMMIT_EDITMSG execute s:sub(s:FinishCommit(), '^echoerr (.*)', 'echohl ErrorMsg|echo \1|echohl NONE') | |
line 1598: augroup END | |
line 1599: | |
line 1600: " Section: Gpush, Gfetch | |
line 1601: | |
line 1602: call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gpush execute s:Dispatch('<bang>', 'push '.<q-args>)") | |
calling function <SNR>15_command('-nargs=? -bang -complete=custom,s:Re...ispatch(''<bang>'', ''push ''.<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1603: call s:command("-nargs=? -bang -complete=custom,s:RemoteComplete Gfetch execute s:Dispatch('<bang>', 'fetch '.<q-args>)") | |
calling function <SNR>15_command('-nargs=? -bang -complete=custom,s:Re...spatch(''<bang>'', ''fetch ''.<q-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1604: | |
line 1605: function! s:Dispatch(bang, args) | |
line 1628: | |
line 1629: " Section: Gdiff | |
line 1630: | |
line 1631: call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gdiff :execute s:Diff('',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bang -bar -nargs=* -complete=custom... :execute s:Diff('''',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1632: call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gvdiff :execute s:Diff('keepalt vert ',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bang -bar -nargs=* -complete=custom...iff(''keepalt vert '',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1633: call s:command("-bang -bar -nargs=* -complete=customlist,s:EditComplete Gsdiff :execute s:Diff('keepalt ',<bang>0,<f-args>)") | |
calling function <SNR>15_command('-bang -bar -nargs=* -complete=custom...e s:Diff(''keepalt '',<bang>0,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1634: | |
line 1635: augroup fugitive_diff | |
line 1636: autocmd! | |
line 1640: autocmd BufWinLeave * if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 2 | call s:diffoff_all(getbufvar(+expand('<abuf>'), 'git_dir')) | endif | |
line 1644: autocmd BufWinEnter * if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 | call s:diffoff() | endif | |
line 1645: augroup END | |
line 1646: | |
line 1647: function! s:can_diffoff(buf) abort | |
line 1652: | |
line 1653: function! fugitive#can_diffoff(buf) abort | |
line 1656: | |
line 1657: function! s:diff_modifier(count) abort | |
line 1669: | |
line 1670: function! s:diff_window_count() abort | |
line 1677: | |
line 1678: function! s:diff_restore() abort | |
line 1692: | |
line 1693: function! s:diffthis() abort | |
line 1699: | |
line 1700: function! s:diffoff() abort | |
line 1708: | |
line 1709: function! s:diffoff_all(dir) abort | |
line 1724: | |
line 1725: function! s:buffer_compare_age(commit) dict abort | |
line 1744: | |
line 1745: call s:add_methods('buffer',['compare_age']) | |
calling function <SNR>15_add_methods('buffer', ['compare_age']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:buffer_compare_age') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_buffer_compare_age') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 1746: | |
line 1747: function! s:Diff(vert,keepfocus,...) abort | |
line 1820: | |
line 1821: " Section: Gmove, Gremove | |
line 1822: | |
line 1823: function! s:Move(force,destination) abort | |
line 1856: | |
line 1857: function! s:MoveComplete(A,L,P) abort | |
line 1866: | |
line 1867: function! s:Remove(force) abort | |
line 1888: | |
line 1889: augroup fugitive_remove | |
line 1890: autocmd! | |
line 1894: autocmd User Fugitive if s:buffer().commit() =~# '^0\=$' | exe "command! -buffer -bar -bang -nargs=1 -complete=customlist,s:MoveComplete Gmove :execute s:Move(<bang>0,<q-args>)" | exe "command! -buffer -bar -bang Gremove :execute s:Remove(<bang>0)" | endif | |
line 1895: augroup END | |
line 1896: | |
line 1897: " Section: Gblame | |
line 1898: | |
line 1899: augroup fugitive_blame | |
line 1900: autocmd! | |
line 1901: autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame | |
line 1902: autocmd FileType fugitiveblame setlocal nomodeline | if exists('b:git_dir') | let &l:keywordprg = s:repo().keywordprg() | endif | |
line 1903: autocmd Syntax fugitiveblame call s:BlameSyntax() | |
line 1904: autocmd User Fugitive if s:buffer().type('file', 'blob') | exe "command! -buffer -bar -bang -range=0 -nargs=* Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,[<f-args>])" | endif | |
line 1905: autocmd ColorScheme,GUIEnter * call s:RehighlightBlame() | |
line 1906: augroup END | |
line 1907: | |
line 1908: function! s:linechars(pattern) abort | |
line 1917: | |
line 1918: function! s:Blame(bang,line1,line2,count,args) abort | |
line 2033: | |
line 2034: function! s:BlameCommit(cmd) abort | |
line 2074: | |
line 2075: function! s:BlameJump(suffix) abort | |
line 2110: | |
line 2111: let s:hash_colors = {} | |
line 2112: | |
line 2113: function! s:BlameSyntax() abort | |
line 2161: | |
line 2162: function! s:RehighlightBlame() abort | |
line 2171: | |
line 2172: " Section: Gbrowse | |
line 2173: | |
line 2174: call s:command("-bar -bang -range -nargs=* -complete=customlist,s:EditComplete Gbrowse :execute s:Browse(<bang>0,<line1>,<count>,<f-args>)") | |
calling function <SNR>15_command('-bar -bang -range -nargs=* -complete...rowse(<bang>0,<line1>,<count>,<f-args>)') | |
line 1: let s:commands += [a:definition] | |
function <SNR>15_command returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 2175: | |
line 2176: function! s:Browse(bang,line1,count,...) abort | |
line 2294: | |
line 2295: function! s:github_url(opts, ...) abort | |
line 2356: | |
line 2357: function! s:instaweb_url(opts) abort | |
line 2397: | |
line 2398: if !exists('g:fugitive_browse_handlers') | |
line 2399: let g:fugitive_browse_handlers = [] | |
line 2400: endif | |
line 2401: | |
line 2403: call extend(g:fugitive_browse_handlers, [s:function('s:github_url'), s:function('s:instaweb_url')]) | |
calling function <SNR>15_function('s:github_url') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_function returning function('<SNR>15_github_url') | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
calling function <SNR>15_function('s:instaweb_url') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_function returning function('<SNR>15_instaweb_url') | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 2404: | |
line 2405: " Section: File access | |
line 2406: | |
line 2407: function! s:ReplaceCmd(cmd,...) abort | |
line 2450: | |
line 2451: function! s:BufReadIndex() abort | |
line 2529: | |
line 2530: function! s:FileRead() abort | |
line 2546: | |
line 2547: function! s:BufReadIndexFile() abort | |
line 2567: | |
line 2568: function! s:BufWriteIndexFile() abort | |
line 2600: | |
line 2601: function! s:BufReadObject() abort | |
line 2682: | |
line 2683: augroup fugitive_files | |
line 2684: autocmd! | |
line 2691: autocmd BufReadCmd index{,.lock} if fugitive#is_git_dir(expand('<amatch>:p:h')) | exe s:BufReadIndex() | elseif filereadable(expand('<amatch>')) | read <amatch> | 1delete | endif | |
line 2692: autocmd FileReadCmd fugitive://**//[0-3]/** exe s:FileRead() | |
line 2693: autocmd BufReadCmd fugitive://**//[0-3]/** exe s:BufReadIndexFile() | |
line 2694: autocmd BufWriteCmd fugitive://**//[0-3]/** exe s:BufWriteIndexFile() | |
line 2695: autocmd BufReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:BufReadObject() | |
line 2696: autocmd FileReadCmd fugitive://**//[0-9a-f][0-9a-f]* exe s:FileRead() | |
line 2700: autocmd FileType git if exists('b:git_dir') | call s:JumpInit() | endif | |
line 2704: autocmd FileType git,gitcommit,gitrebase if exists('b:git_dir') | call s:GFInit() | endif | |
line 2705: augroup END | |
line 2706: | |
line 2707: " Section: Temp files | |
line 2708: | |
line 2709: if !exists('s:temp_files') | |
line 2710: let s:temp_files = {} | |
line 2711: endif | |
line 2712: | |
line 2713: augroup fugitive_temp | |
line 2714: autocmd! | |
line 2723: autocmd BufNewFile,BufReadPost * if has_key(s:temp_files,s:cpath(expand('<afile>:p'))) | let b:git_dir = s:temp_files[s:cpath(expand('<afile>:p'))].dir | let b:git_type = 'temp' | let b:git_args = s:temp_files[s:cpath(expand('<afile>:p'))].args | call fugitive#detect(expand('<afile>:p')) | setlocal bufhidden=delete nobuflisted | nnoremap <buffer> <silent> q :<C-U>bdelete<CR>| endif | |
line 2724: augroup END | |
line 2725: | |
line 2726: " Section: Go to file | |
line 2727: | |
line 2728: nnoremap <SID>: :<C-U><C-R>=v:count ? v:count : ''<CR> | |
line 2729: function! s:GFInit(...) abort | |
line 2738: | |
line 2739: function! s:JumpInit(...) abort | |
line 2757: | |
line 2758: function! s:cfile() abort | |
line 2934: | |
line 2935: function! s:GF(mode) abort | |
line 2947: | |
line 2948: function! fugitive#cfile() abort | |
line 2958: | |
line 2959: " Section: Statusline | |
line 2960: | |
line 2961: function! s:repo_head_ref() dict abort | |
line 2967: | |
line 2968: call s:add_methods('repo',['head_ref']) | |
calling function <SNR>15_add_methods('repo', ['head_ref']) | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
calling function <SNR>15_add_methods..<SNR>15_function('s:repo_head_ref') | |
line 1: return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '<SNR>\d\+_'),'')) | |
function <SNR>15_add_methods..<SNR>15_function returning function('<SNR>15_repo_head_ref') | |
continuing in function <SNR>15_add_methods | |
line 3: endfor | |
line 1: for name in a:method_names | |
line 2: let s:{a:namespace}_prototype[name] = s:function('s:'.a:namespace.'_'.name) | |
line 3: endfor | |
function <SNR>15_add_methods returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
line 2969: | |
line 2970: function! fugitive#statusline(...) abort | |
line 2985: | |
line 2986: function! fugitive#head(...) abort | |
line 2993: | |
line 2994: augroup fugitive_statusline | |
line 2995: autocmd! | |
line 2996: autocmd User Flags call Hoist('buffer', function('fugitive#statusline')) | |
line 2997: augroup END | |
line 2998: | |
line 2999: " Section: Folding | |
line 3000: | |
line 3001: function! fugitive#foldtext() abort | |
line 3039: | |
line 3040: augroup fugitive_foldtext | |
line 3041: autocmd! | |
line 3045: autocmd User Fugitive if &filetype =~# '^git\%(commit\)\=$' && &foldtext ==# 'foldtext()' | set foldtext=fugitive#foldtext() | endif | |
line 3046: augroup END | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-fugitive/plugin/fugitive.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim" | |
line 1: " Copyright (C) 2011, 2012 Google Inc. | |
line 2: " | |
line 3: " This file is part of YouCompleteMe. | |
line 4: " | |
line 5: " YouCompleteMe is free software: you can redistribute it and/or modify | |
line 6: " it under the terms of the GNU General Public License as published by | |
line 7: " the Free Software Foundation, either version 3 of the License, or | |
line 8: " (at your option) any later version. | |
line 9: " | |
line 10: " YouCompleteMe is distributed in the hope that it will be useful, | |
line 11: " but WITHOUT ANY WARRANTY; without even the implied warranty of | |
line 12: " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
line 13: " GNU General Public License for more details. | |
line 14: " | |
line 15: " You should have received a copy of the GNU General Public License | |
line 16: " along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>. | |
line 17: | |
line 18: " This is basic vim plugin boilerplate | |
line 19: let s:save_cpo = &cpo | |
line 20: set cpo&vim | |
line 21: | |
line 22: function! s:restore_cpo() | |
line 26: | |
line 27: if exists( "g:loaded_youcompleteme" ) | |
line 28: call s:restore_cpo() | |
line 29: finish | |
line 30: elseif v:version < 703 || (v:version == 703 && !has('patch598')) | |
line 33: echohl WarningMsg | echomsg "YouCompleteMe unavailable: requires Vim 7.3.598+" | echohl None | |
line 33: echomsg "YouCompleteMe unavailable: requires Vim 7.3.598+" | echohl None | |
line 33: echohl None | |
line 34: call s:restore_cpo() | |
line 35: finish | |
line 36: elseif !has( 'python' ) | |
Searching for "autoload/provider/python.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/autoload/provider/python.vim" | |
Searching for "/etc/xdg/nvim/autoload/provider/python.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/provider/python.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/provider/python.vim" | |
Searching for "/usr/share/nvim/site/autoload/provider/python.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 36: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim" | |
line 1: " The Python provider uses a Python host to emulate an environment for running | |
line 2: " python-vim plugins. See ":help nvim-provider" for more information. | |
line 3: " | |
line 4: " Associating the plugin with the Python host is the first step because plugins | |
line 5: " will be passed as command-line arguments | |
line 6: | |
line 7: if exists('g:loaded_python_provider') | |
line 8: finish | |
line 9: endif | |
line 10: let g:loaded_python_provider = 1 | |
line 11: | |
line 12: let [s:prog, s:err] = provider#pythonx#Detect(2) | |
Searching for "autoload/provider/pythonx.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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, | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/autoload/provider/pythonx.vim" | |
Searching for "/etc/xdg/nvim/autoload/provider/pythonx.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/provider/pythonx.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/provider/pythonx.vim" | |
Searching for "/usr/share/nvim/site/autoload/provider/pythonx.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/pythonx.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 12: sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/pythonx.vim" | |
line 1: " The Python provider helper | |
line 2: if exists('s:loaded_pythonx_provider') | |
line 3: finish | |
line 4: endif | |
line 5: | |
line 6: let s:loaded_pythonx_provider = 1 | |
line 7: | |
line 8: function! provider#pythonx#Detect(major_ver) abort | |
line 44: | |
line 45: function! s:check_interpreter(prog, major_ver, skip) abort | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/pythonx.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
calling function provider#pythonx#Detect(2) | |
line 1: let host_var = (a:major_ver == 2) ? 'g:python_host_prog' : 'g:python3_host_prog' | |
line 3: let skip_var = (a:major_ver == 2) ? 'g:python_host_skip_check' : 'g:python3_host_skip_check' | |
line 5: let skip = exists(skip_var) ? {skip_var} : 0 | |
line 6: if exists(host_var) | |
line 7: " Disable auto detection. | |
line 8: let [result, err] = s:check_interpreter({host_var}, a:major_ver, skip) | |
line 9: if result | |
line 10: return [{host_var}, err] | |
line 11: endif | |
line 12: return ['', 'provider/pythonx: Could not load Python ' . a:major_ver . ' from ' . host_var . ': ' . err] | |
line 14: endif | |
line 15: | |
line 16: let prog_suffixes = (a:major_ver == 2) ? ['2', '2.7', '2.6', ''] : ['3', '3.5', '3.4', '3.3', ''] | |
line 19: | |
line 20: let errors = [] | |
line 21: for prog in map(prog_suffixes, "'python' . v:val") | |
line 22: let [result, err] = s:check_interpreter(prog, a:major_ver, skip) | |
calling function provider#pythonx#Detect..<SNR>18_check_interpreter('python2', 2, 0) | |
line 1: let prog_path = exepath(a:prog) | |
line 2: if prog_path == '' | |
line 3: return [0, a:prog . ' not found in search path or not executable.'] | |
line 4: endif | |
line 5: | |
line 6: if a:skip | |
line 7: return [1, ''] | |
line 8: endif | |
line 9: | |
line 10: let min_version = (a:major_ver == 2) ? '2.6' : '3.3' | |
line 11: | |
line 12: " Try to load neovim module, and output Python version. | |
line 13: " Return codes: | |
line 14: " 0 Neovim module can be loaded. | |
line 15: " 1 Something else went wrong. | |
line 16: " 2 Neovim module cannot be loaded. | |
line 17: let prog_ver = system([ a:prog , '-c' , 'import sys; ' . 'sys.path.remove(""); ' . 'sys.stdout.write(str(sys.version_info[0]) + "." + str(sys.version_info[1])); ' . 'import pkgutil; ' . 'exit(2*int(pkgutil.get_loader("neovim") is None))' ]) | |
line 24: | |
line 25: if prog_ver | |
line 26: if prog_ver !~ '^' . a:major_ver | |
line 27: return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python ' . a:major_ver . '.'] | |
line 29: elseif prog_ver =~ '^' . a:major_ver && prog_ver < min_version | |
line 30: return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python >= ' . min_version . '.'] | |
line 32: endif | |
line 33: endif | |
line 34: | |
line 35: if v:shell_error == 1 | |
line 36: return [0, 'Checking ' . prog_path . ' caused an unknown error. ' . 'Please report this at github.com/neovim/neovim.'] | |
line 38: elseif v:shell_error == 2 | |
line 39: return [0, prog_path . ' does have not have the neovim module installed. ' . 'See ":help nvim-python".'] | |
line 41: endif | |
line 42: | |
line 43: return [1, ''] | |
function provider#pythonx#Detect..<SNR>18_check_interpreter returning [1, ''] | |
continuing in function provider#pythonx#Detect | |
line 23: if result | |
line 24: return [prog, err] | |
function provider#pythonx#Detect returning ['python2', ''] | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
line 13: | |
line 14: function! provider#python#Prog() | |
line 17: | |
line 18: function! provider#python#Error() | |
line 21: | |
line 22: if s:prog == '' | |
line 23: " Detection failed | |
line 24: finish | |
line 25: endif | |
line 26: | |
line 27: let s:plugin_path = expand('<sfile>:p:h').'/script_host.py' | |
line 28: | |
line 29: " The Python provider plugin will run in a separate instance of the Python | |
line 30: " host. | |
line 31: call remote#host#RegisterClone('legacy-python-provider', 'python') | |
Searching for "autoload/remote/host.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/User | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/remote/host.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/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/0.1.0/share/nvim/runtime/autoload/remote/host.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/remote) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 31: sourcing "/usr/local/Cellar/neovim/0.1.0/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 179: | |
line 180: | |
line 181: command! UpdateRemotePlugins call s:UpdateRemotePlugins() | |
line 182: | |
line 183: | |
line 184: let s:plugins_for_host = {} | |
line 185: function! remote#host#PluginsForHost(host) | |
line 191: | |
line 192: | |
line 193: " Registration of standard hosts | |
line 194: | |
line 195: " Python/Python3 {{{ | |
line 196: function! s:RequirePythonHost(host) | |
line 224: | |
line 225: call remote#host#Register('python', '*.py', function('s:RequirePythonHost')) | |
calling function remote#host#Register('python', '*.py', function('<SNR>19_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/0.1.0/share/nvim/runtime/autoload/remote/host.vim | |
line 226: call remote#host#Register('python3', '*.py', function('s:RequirePythonHost')) | |
calling function remote#host#Register('python3', '*.py', function('<SNR>19_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/0.1.0/share/nvim/runtime/autoload/remote/host.vim | |
line 227: " }}} | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/remote/host.vim | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
calling function remote#host#RegisterClone('legacy-python-provider', 'python') | |
line 1: if !has_key(s:hosts, a:orig_name) | |
line 2: throw 'No host named "'.a:orig_name.'" is registered' | |
line 3: endif | |
line 4: let Factory = s:hosts[a:orig_name].factory | |
line 5: let s:hosts[a:name] = { 'factory': Factory, 'channel': 0, 'initialized': 0, 'orig_name': a:orig_name } | |
function remote#host#RegisterClone returning #0 | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
line 32: call remote#host#RegisterPlugin('legacy-python-provider', s:plugin_path, []) | |
calling function remote#host#RegisterPlugin('legacy-python-provider', '/usr/local/Cellar/neovim/0.1.0/share...untime/autoload/provider/script_host.py', []) | |
line 1: let plugins = remote#host#PluginsForHost(a:host) | |
calling function remote#host#RegisterPlugin..remote#host#PluginsForHost('legacy-python-provider') | |
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('legacy-python-provider') | |
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) | |
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 /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
line 33: | |
line 34: function! provider#python#Call(method, args) | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/provider/python.vim | |
continuing in /Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim | |
line 40: echohl WarningMsg | echomsg "YouCompleteMe unavailable: requires Vim compiled with " . "Python 2.x support" | echohl None | |
line 40: echomsg "YouCompleteMe unavailable: requires Vim compiled with " . "Python 2.x support" | echohl None | |
line 40: echohl None | |
line 41: call s:restore_cpo() | |
line 42: finish | |
line 43: endif | |
line 44: | |
line 45: let s:script_folder_path = escape( expand( '<sfile>:p:h' ), '\' ) | |
line 46: let s:python_folder_path = s:script_folder_path . '/../python/' | |
line 47: let s:ycmd_folder_path = s:script_folder_path . '/../third_party/ycmd/' | |
line 48: | |
line 49: function! s:YcmLibsPresentIn( path_prefix ) | |
line 62: | |
line 63: if s:YcmLibsPresentIn( s:python_folder_path ) | |
calling function <SNR>16_YcmLibsPresentIn('/Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/../python/') | |
line 1: if filereadable(a:path_prefix . 'ycm_client_support.so') && filereadable(a:path_prefix . 'ycm_core.so') | |
line 3: return 1 | |
line 4: elseif filereadable(a:path_prefix . 'ycm_client_support.pyd') && filereadable(a:path_prefix . 'ycm_core.pyd') | |
line 6: return 1 | |
line 7: elseif filereadable(a:path_prefix . 'ycm_client_support.dll') && filereadable(a:path_prefix . 'ycm_core.dll') | |
line 9: return 1 | |
line 10: endif | |
line 11: return 0 | |
function <SNR>16_YcmLibsPresentIn returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim | |
line 67: echohl WarningMsg | echomsg "YCM libraries found in old YouCompleteMe/python location; " . "please RECOMPILE YCM." | echohl None | |
line 67: echomsg "YCM libraries found in old YouCompleteMe/python location; " . "please RECOMPILE YCM." | echohl None | |
line 67: echohl None | |
line 68: call s:restore_cpo() | |
line 69: finish | |
line 70: endif | |
line 71: | |
line 73: let g:ycm_check_if_ycm_core_present = get( g:, 'ycm_check_if_ycm_core_present', 1 ) | |
line 74: | |
line 76: if g:ycm_check_if_ycm_core_present && !s:YcmLibsPresentIn( s:ycmd_folder_path ) | |
calling function <SNR>16_YcmLibsPresentIn('/Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/../third_party/ycmd/') | |
line 1: if filereadable(a:path_prefix . 'ycm_client_support.so') && filereadable(a:path_prefix . 'ycm_core.so') | |
line 3: return 1 | |
function <SNR>16_YcmLibsPresentIn returning #1 | |
continuing in /Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim | |
line 81: echohl WarningMsg | echomsg "ycm_client_support.[so|pyd|dll] and " . "ycm_core.[so|pyd|dll] not detected; you need to compile " . "YCM before using it. Read the docs!" | echohl None | |
line 81: echomsg "ycm_client_support.[so|pyd|dll] and " . "ycm_core.[so|pyd|dll] not detected; you need to compile " . "YCM before using it. Read the docs!" | echohl None | |
line 81: echohl None | |
line 82: call s:restore_cpo() | |
line 83: finish | |
line 84: endif | |
line 85: | |
line 86: let g:loaded_youcompleteme = 1 | |
line 87: | |
line 88: " NOTE: Most defaults are in default_settings.json. They are loaded into Vim | |
line 89: " global with the 'ycm_' prefix if such a key does not already exist; thus, the | |
line 90: " user can override the defaults. | |
line 91: " The only defaults that are here are the ones that are only relevant to the YCM | |
line 92: " Vim client and not the server. | |
line 93: | |
line 95: let g:ycm_allow_changing_updatetime = get( g:, 'ycm_allow_changing_updatetime', 1 ) | |
line 96: | |
line 98: let g:ycm_open_loclist_on_ycm_diags = get( g:, 'ycm_open_loclist_on_ycm_diags', 1 ) | |
line 99: | |
line 101: let g:ycm_add_preview_to_completeopt = get( g:, 'ycm_add_preview_to_completeopt', 0 ) | |
line 102: | |
line 104: let g:ycm_autoclose_preview_window_after_completion = get( g:, 'ycm_autoclose_preview_window_after_completion', 0 ) | |
line 105: | |
line 107: let g:ycm_autoclose_preview_window_after_insertion = get( g:, 'ycm_autoclose_preview_window_after_insertion', 0 ) | |
line 108: | |
line 110: let g:ycm_key_list_select_completion = get( g:, 'ycm_key_list_select_completion', ['<TAB>', '<Down>'] ) | |
line 111: | |
line 113: let g:ycm_key_list_previous_completion = get( g:, 'ycm_key_list_previous_completion', ['<S-TAB>', '<Up>'] ) | |
line 114: | |
line 116: let g:ycm_key_invoke_completion = get( g:, 'ycm_key_invoke_completion', '<C-Space>' ) | |
line 117: | |
line 119: let g:ycm_key_detailed_diagnostics = get( g:, 'ycm_key_detailed_diagnostics', '<leader>d' ) | |
line 120: | |
line 122: let g:ycm_cache_omnifunc = get( g:, 'ycm_cache_omnifunc', 1 ) | |
line 123: | |
line 125: let g:ycm_server_log_level = get( g:, 'ycm_server_log_level', 'info' ) | |
line 126: | |
line 128: let g:ycm_server_keep_logfiles = get( g:, 'ycm_server_keep_logfiles', 0 ) | |
line 129: | |
line 131: let g:ycm_extra_conf_vim_data = get( g:, 'ycm_extra_conf_vim_data', [] ) | |
line 132: | |
line 134: let g:ycm_path_to_python_interpreter = get( g:, 'ycm_path_to_python_interpreter', '' ) | |
line 135: | |
line 138: let g:ycm_show_diagnostics_ui = get( g:, 'ycm_show_diagnostics_ui', get( g:, 'ycm_register_as_syntastic_checker', 1 ) ) | |
line 139: | |
line 142: let g:ycm_enable_diagnostic_signs = get( g:, 'ycm_enable_diagnostic_signs', get( g:, 'syntastic_enable_signs', 1 ) ) | |
line 143: | |
line 146: let g:ycm_enable_diagnostic_highlighting = get( g:, 'ycm_enable_diagnostic_highlighting', get( g:, 'syntastic_enable_highlighting', 1 ) ) | |
line 147: | |
line 150: let g:ycm_echo_current_diagnostic = get( g:, 'ycm_echo_current_diagnostic', get( g:, 'syntastic_echo_current_error', 1 ) ) | |
line 151: | |
line 154: let g:ycm_always_populate_location_list = get( g:, 'ycm_always_populate_location_list', get( g:, 'syntastic_always_populate_loc_list', 0 ) ) | |
line 155: | |
line 158: let g:ycm_error_symbol = get( g:, 'ycm_error_symbol', get( g:, 'syntastic_error_symbol', '>>' ) ) | |
line 159: | |
line 162: let g:ycm_warning_symbol = get( g:, 'ycm_warning_symbol', get( g:, 'syntastic_warning_symbol', '>>' ) ) | |
line 163: | |
line 165: let g:ycm_goto_buffer_command = get( g:, 'ycm_goto_buffer_command', 'same-buffer' ) | |
line 166: | |
line 168: let g:ycm_disable_for_files_larger_than_kb = get( g:, 'ycm_disable_for_files_larger_than_kb', 1000 ) | |
line 169: | |
line 170: " On-demand loading. Let's use the autoload folder and not slow down vim's | |
line 171: " startup procedure. | |
line 172: augroup youcompletemeStart | |
line 173: autocmd! | |
line 174: autocmd VimEnter * call youcompleteme#Enable() | |
line 175: augroup END | |
line 176: | |
line 177: " This is basic vim plugin boilerplate | |
line 178: call s:restore_cpo() | |
calling function <SNR>16_restore_cpo() | |
line 1: let &cpo = s:save_cpo | |
line 2: unlet s:save_cpo | |
function <SNR>16_restore_cpo returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim | |
finished sourcing /Users/nhooyr/.nvim/plugged/YouCompleteMe/plugin/youcompleteme.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: if &cp || v:version < 702 || (exists('g:loaded_airline') && g:loaded_airline) | |
line 5: finish | |
line 6: endif | |
line 7: let g:loaded_airline = 1 | |
line 8: | |
line 9: let s:airline_initialized = 0 | |
line 10: let s:airline_theme_defined = 0 | |
line 11: function! s:init() | |
line 28: | |
line 29: function! s:on_window_changed() | |
line 36: | |
line 37: function! s:on_colorscheme_changed() | |
line 48: | |
line 49: function airline#cmdwinenter(...) | |
Searching for "autoload/airline.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nh | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 49: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let g:airline_statusline_funcrefs = get(g:, 'airline_statusline_funcrefs', []) | |
line 5: | |
line 6: let s:sections = ['a','b','c','gutter','x','y','z','warning'] | |
line 7: let s:inactive_funcrefs = [] | |
line 8: | |
line 9: function! airline#add_statusline_func(name) | |
line 12: | |
line 13: function! airline#add_statusline_funcref(function) | |
line 22: | |
line 23: function! airline#remove_statusline_func(name) | |
line 29: | |
line 30: function! airline#add_inactive_statusline_func(name) | |
line 33: | |
line 34: function! airline#load_theme() | |
line 51: | |
line 52: function! airline#switch_theme(name) | |
line 71: | |
line 72: function! airline#switch_matching_theme() | |
line 89: | |
line 90: function! airline#update_statusline() | |
line 113: | |
line 114: let s:contexts = {} | |
line 117: let s:core_funcrefs = [ function('airline#extensions#apply'), function('airline#extensions#default#apply') ] | |
line 118: function! s:invoke_funcrefs(context, funcrefs) | |
line 127: | |
line 128: function! airline#statusline(winnr) | |
line 136: | |
line 137: function! airline#check_mode(winnr) | |
line 184: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline.vim | |
continuing in /Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim | |
line 52: | |
line 53: function! s:airline_toggle() | |
line 91: | |
line 92: function! s:get_airline_themes(a, l, p) | |
line 96: | |
line 97: function! s:airline_theme(...) | |
line 104: | |
line 105: command! -bar -nargs=? -complete=customlist,<sid>get_airline_themes AirlineTheme call <sid>airline_theme(<f-args>) | |
line 106: command! -bar AirlineToggleWhitespace call airline#extensions#whitespace#toggle() | |
line 107: command! -bar AirlineToggle call s:airline_toggle() | |
line 108: command! -bar AirlineRefresh call airline#load_theme() | call airline#update_statusline() | |
line 109: | |
line 110: call airline#init#bootstrap() | |
Searching for "autoload/airline/init.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Use | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/init.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/init.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/init.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/init.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/init.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/init.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 110: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/init.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: function! s:check_defined(variable, default) | |
line 9: | |
line 10: let s:loaded = 0 | |
line 11: function! airline#init#bootstrap() | |
line 89: | |
line 90: function! airline#init#sections() | |
line 117: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/init.vim | |
continuing in /Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim | |
calling function airline#init#bootstrap() | |
line 1: if s:loaded | |
line 2: return | |
line 3: endif | |
line 4: let s:loaded = 1 | |
line 5: | |
line 6: let g:airline#init#bootstrapping = 1 | |
line 7: call s:check_defined('g:airline_left_sep', get(g:, 'airline_powerline_fonts', 0)?"\ue0b0":">") | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_left_sep', '') | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 8: call s:check_defined('g:airline_left_alt_sep', get(g:, 'airline_powerline_fonts', 0)?"\ue0b1":">") | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_left_alt_sep', '') | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 9: call s:check_defined('g:airline_right_sep', get(g:, 'airline_powerline_fonts', 0)?"\ue0b2":"<") | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_right_sep', '') | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 10: call s:check_defined('g:airline_right_alt_sep', get(g:, 'airline_powerline_fonts', 0)?"\ue0b3":"<") | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_right_alt_sep', '') | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 11: call s:check_defined('g:airline_detect_modified', 1) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_detect_modified', 1) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 12: call s:check_defined('g:airline_detect_paste', 1) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_detect_paste', 1) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 13: call s:check_defined('g:airline_detect_crypt', 1) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_detect_crypt', 1) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 14: call s:check_defined('g:airline_detect_iminsert', 0) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_detect_iminsert', 0) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 15: call s:check_defined('g:airline_inactive_collapse', 1) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_inactive_collapse', 1) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 16: call s:check_defined('g:airline_exclude_filenames', ['DebuggerWatch','DebuggerStack','DebuggerStatus']) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_exclude_filenames', ['DebuggerWatch', 'DebuggerStack', 'DebuggerStatus']) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 17: call s:check_defined('g:airline_exclude_filetypes', []) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_exclude_filetypes', []) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 18: call s:check_defined('g:airline_exclude_preview', 0) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_exclude_preview', 0) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 19: | |
line 20: call s:check_defined('g:airline_mode_map', {}) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_mode_map', {}) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 21: call extend(g:airline_mode_map, { '__' : '------', 'n' : 'NORMAL', 'i' : 'INSERT', 'R' : 'REPLACE', 'v' : 'VISUAL', 'V' : 'V-LINE', 'c' : 'COMMAND', '^V' : 'V-BLOCK', 's' : 'SELECT', 'S' : 'S-LINE', '^S' : 'S-BLOCK', 't' : 'TERMINAL', }, 'keep') | |
line 35: | |
line 36: call s:check_defined('g:airline_theme_map', {}) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_theme_map', {}) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 37: call extend(g:airline_theme_map, { 'Tomorrow.*': 'tomorrow', 'base16.*': 'base16', 'mo[l|n]okai': 'molokai', 'wombat.*': 'wombat', '.*zenburn.*': 'zenburn', '.*solarized.*': 'solarized', }, 'keep') | |
line 45: | |
line 46: call s:check_defined('g:airline_symbols', {}) | |
calling function airline#init#bootstrap..<SNR>22_check_defined('g:airline_symbols', {}) | |
line 1: if !exists(a:variable) | |
line 2: let {a:variable} = a:default | |
line 3: endif | |
function airline#init#bootstrap..<SNR>22_check_defined returning #0 | |
continuing in function airline#init#bootstrap | |
line 47: call extend(g:airline_symbols, { 'paste': get(g:, 'airline_paste_symbol', 'PASTE'), 'readonly': get(g:, 'airline_readonly_symbol', get(g:, 'airline_powerline_fonts', 0) ? "\ue0a2" : 'RO'), 'whitespace': get(g:, 'airline_powerline_fonts', 0) ? "\u2739" : '!', 'linenr': get(g:, 'airline_linecolumn_prefix', get(g:, 'airline_powerline_fonts', 0) ? "\ue0a1" : ':' ), 'branch': get(g:, 'airline_branch_prefix', get(g:, 'airline_powerline_fonts', 0) ? "\ue0a0" : ''), 'modified': '+', 'space': ' ', 'crypt': get(g:, 'airline_crypt_symbol', nr2char(0x1F512)), }, 'keep') | |
line 57: | |
line 58: call airline#parts#define('mode', { 'function': 'airline#parts#mode', 'accent': 'bold', }) | |
Searching for "autoload/airline/parts.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Us | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/parts.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/parts.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/parts.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/parts.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/parts.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/parts.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 58: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/parts.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:parts = {} | |
line 5: | |
line 6: " PUBLIC API {{{ | |
line 7: | |
line 8: function! airline#parts#define(key, config) | |
line 16: | |
line 17: function! airline#parts#define_function(key, name) | |
line 20: | |
line 21: function! airline#parts#define_text(key, text) | |
line 24: | |
line 25: function! airline#parts#define_raw(key, raw) | |
line 28: | |
line 29: function! airline#parts#define_minwidth(key, width) | |
line 32: | |
line 33: function! airline#parts#define_condition(key, predicate) | |
line 36: | |
line 37: function! airline#parts#define_accent(key, accent) | |
line 40: | |
line 41: function! airline#parts#define_empty(keys) | |
line 46: | |
line 47: function! airline#parts#get(key) | |
line 50: | |
line 51: " }}} | |
line 52: | |
line 53: function! airline#parts#mode() | |
line 56: | |
line 57: function! airline#parts#crypt() | |
line 60: | |
line 61: function! airline#parts#paste() | |
line 64: | |
line 65: function! airline#parts#iminsert() | |
line 71: | |
line 72: function! airline#parts#readonly() | |
line 75: | |
line 76: function! airline#parts#filetype() | |
line 79: | |
line 80: function! airline#parts#ffenc() | |
line 83: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/parts.vim | |
continuing in function airline#init#bootstrap | |
calling function airline#init#bootstrap..airline#parts#define('mode', {'function': 'airline#parts#mode', 'accent': 'bold'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap | |
line 62: call airline#parts#define_function('iminsert', 'airline#parts#iminsert') | |
calling function airline#init#bootstrap..airline#parts#define_function('iminsert', 'airline#parts#iminsert') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function airline#init#bootstrap..airline#parts#define_function..airline#parts#define('iminsert', {'function': 'airline#parts#iminsert'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_function | |
function airline#init#bootstrap..airline#parts#define_function returning #0 | |
continuing in function airline#init#bootstrap | |
line 63: call airline#parts#define_function('paste', 'airline#parts#paste') | |
calling function airline#init#bootstrap..airline#parts#define_function('paste', 'airline#parts#paste') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function airline#init#bootstrap..airline#parts#define_function..airline#parts#define('paste', {'function': 'airline#parts#paste'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_function | |
function airline#init#bootstrap..airline#parts#define_function returning #0 | |
continuing in function airline#init#bootstrap | |
line 64: call airline#parts#define_function('crypt', 'airline#parts#crypt') | |
calling function airline#init#bootstrap..airline#parts#define_function('crypt', 'airline#parts#crypt') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function airline#init#bootstrap..airline#parts#define_function..airline#parts#define('crypt', {'function': 'airline#parts#crypt'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_function | |
function airline#init#bootstrap..airline#parts#define_function returning #0 | |
continuing in function airline#init#bootstrap | |
line 65: call airline#parts#define_function('filetype', 'airline#parts#filetype') | |
calling function airline#init#bootstrap..airline#parts#define_function('filetype', 'airline#parts#filetype') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function airline#init#bootstrap..airline#parts#define_function..airline#parts#define('filetype', {'function': 'airline#parts#filetype'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_function | |
function airline#init#bootstrap..airline#parts#define_function returning #0 | |
continuing in function airline#init#bootstrap | |
line 66: call airline#parts#define('readonly', { 'function': 'airline#parts#readonly', 'accent': 'red', }) | |
calling function airline#init#bootstrap..airline#parts#define('readonly', {'function': 'airline#parts#readonly', 'accent': 'red'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap | |
line 70: call airline#parts#define_raw('file', '%f%m') | |
calling function airline#init#bootstrap..airline#parts#define_raw('file', '%f%m') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_raw..airline#parts#define('file', {'raw': '%f%m'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap | |
line 71: call airline#parts#define_raw('linenr', '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#') | |
calling function airline#init#bootstrap..airline#parts#define_raw('linenr', '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_raw..airline#parts#define('linenr', {'raw': '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap | |
line 72: call airline#parts#define_function('ffenc', 'airline#parts#ffenc') | |
calling function airline#init#bootstrap..airline#parts#define_function('ffenc', 'airline#parts#ffenc') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function airline#init#bootstrap..airline#parts#define_function..airline#parts#define('ffenc', {'function': 'airline#parts#ffenc'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_function | |
function airline#init#bootstrap..airline#parts#define_function returning #0 | |
continuing in function airline#init#bootstrap | |
line 73: call airline#parts#define_empty(['hunks', 'branch', 'tagbar', 'syntastic', 'eclim', 'whitespace','windowswap']) | |
calling function airline#init#bootstrap..airline#parts#define_empty(['hunks', 'branch', 'tagbar', 'syntastic', 'eclim', 'whitespace', 'windowswap']) | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('hunks', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('hunks', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('branch', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('branch', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('tagbar', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('tagbar', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('syntastic', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('syntastic', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('eclim', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('eclim', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('whitespace', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('whitespace', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw('windowswap', '') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define('windowswap', {'raw': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw | |
function airline#init#bootstrap..airline#parts#define_empty..airline#parts#define_raw returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_empty | |
line 3: endfor | |
line 1: for key in a:keys | |
line 2: call airline#parts#define_raw(key, '') | |
line 3: endfor | |
function airline#init#bootstrap..airline#parts#define_empty returning #0 | |
continuing in function airline#init#bootstrap | |
line 74: call airline#parts#define_text('capslock', '') | |
calling function airline#init#bootstrap..airline#parts#define_text('capslock', '') | |
line 1: call airline#parts#define(a:key, { 'text': a:text }) | |
calling function airline#init#bootstrap..airline#parts#define_text..airline#parts#define('capslock', {'text': ''}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function airline#init#bootstrap..airline#parts#define_text..airline#parts#define returning #0 | |
continuing in function airline#init#bootstrap..airline#parts#define_text | |
function airline#init#bootstrap..airline#parts#define_text returning #0 | |
continuing in function airline#init#bootstrap | |
line 75: | |
line 76: unlet g:airline#init#bootstrapping | |
function airline#init#bootstrap returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim | |
line 111: call s:airline_toggle() | |
calling function <SNR>20_airline_toggle() | |
line 1: if exists("#airline") | |
line 2: augroup airline | |
line 3: au! | |
line 4: augroup END | |
line 5: augroup! airline | |
line 6: | |
line 7: if exists("s:stl") | |
line 8: let &stl = s:stl | |
line 9: endif | |
line 10: | |
line 11: silent doautocmd User AirlineToggledOff | |
line 12: else | |
line 13: let s:stl = &statusline | |
line 14: augroup airline | |
line 15: autocmd! | |
line 16: | |
line 17: autocmd CmdwinEnter * call airline#add_statusline_func('airline#cmdwinenter') | call <sid>on_window_changed() | |
line 20: autocmd CmdwinLeave * call airline#remove_statusline_func('airline#cmdwinenter') | |
line 21: | |
line 22: autocmd ColorScheme * call <sid>on_colorscheme_changed() | |
line 23: autocmd VimEnter,WinEnter,BufWinEnter,FileType,BufUnload,VimResized * call <sid>on_window_changed() | |
line 25: | |
line 26: autocmd BufWritePost */autoload/airline/themes/*.vim exec 'source '.split(globpath(&rtp, 'autoload/airline/themes/'.g:airline_theme.'.vim', 1), "\n")[0] | call airline#load_theme() | |
line 29: augroup END | |
line 30: | |
line 31: if s:airline_initialized | |
line 32: call s:on_window_changed() | |
line 33: endif | |
line 34: | |
line 35: silent doautocmd User AirlineToggledOn | |
No matching autocommands | |
line 36: endif | |
function <SNR>20_airline_toggle returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim | |
line 112: | |
line 113: autocmd VimEnter * call airline#deprecation#check() | |
line 114: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/plugin/airline.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/delimitMate/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/delimitMate/plugin/delimitMate.vim" | |
line 1: " File: plugin/delimitMate.vim | |
line 2: " Version: 2.7 | |
line 3: " Modified: 2013-07-15 | |
line 4: " Description: This plugin provides auto-completion for quotes, parens, etc. | |
line 5: " Maintainer: Israel Chauca F. <[email protected]> | |
line 6: " Manual: Read ":help delimitMate". | |
line 7: " ============================================================================ | |
line 8: | |
line 9: " Initialization: {{{ | |
line 10: | |
line 11: if exists("g:loaded_delimitMate") || &cp | |
line 12: " User doesn't want this plugin or compatible is set, let's get out! | |
line 13: finish | |
line 14: endif | |
line 15: let g:loaded_delimitMate = 1 | |
line 16: let save_cpo = &cpo | |
line 17: set cpo&vim | |
line 18: | |
line 19: if v:version < 700 | |
line 20: echoerr "delimitMate: this plugin requires vim >= 7!" | |
line 21: finish | |
line 22: endif | |
line 23: | |
line 24: let s:loaded_delimitMate = 1 | |
line 25: let delimitMate_version = "2.8" | |
line 26: | |
line 27: "}}} | |
line 28: | |
line 29: " Functions: {{{ | |
line 30: | |
line 31: function! s:option_init(name, default) "{{{ | |
line 44: | |
line 45: function! s:init() "{{{ | |
line 148: | |
line 149: function! s:get(...) " {{{ | |
line 152: | |
line 153: function! s:set(...) " {{{ | |
line 156: | |
line 157: function! s:Map() "{{{ | |
line 182: | |
line 183: function! s:Unmap() " {{{ | |
line 205: | |
line 206: function! s:test() "{{{ | |
line 218: | |
line 219: function! s:setup(...) "{{{ | |
line 261: | |
line 262: function! s:TriggerAbb() "{{{ | |
line 270: | |
line 271: function! s:NoAutoClose() "{{{ | |
line 281: | |
line 282: function! s:AutoClose() "{{{ | |
line 324: | |
line 325: function! s:ExtraMappings() "{{{ | |
line 362: | |
line 363: "}}} | |
line 364: | |
line 365: " Commands: {{{ | |
line 366: | |
line 367: " Let me refresh without re-loading the buffer: | |
line 368: command! -bar DelimitMateReload call s:setup(1) | |
line 369: " Quick test: | |
line 370: command! -bar DelimitMateTest call s:test() | |
line 371: " Switch On/Off: | |
line 372: command! -bar DelimitMateSwitch call s:setup(2) | |
line 373: " Enable mappings: | |
line 374: command! -bar DelimitMateOn call s:setup(1) | |
line 375: " Disable mappings: | |
line 376: command! -bar DelimitMateOff call s:setup(0) | |
line 377: | |
line 378: "}}} | |
line 379: | |
line 380: " Autocommands: {{{ | |
line 381: | |
line 382: augroup delimitMate | |
line 383: au! | |
line 384: " Run on file type change. | |
line 385: au FileType * call <SID>setup() | |
line 386: | |
line 387: " Run on new buffers. | |
line 392: au BufNewFile,BufRead,BufEnter * if !exists('b:delimitMate_was_here') | call <SID>setup() | let b:delimitMate_was_here = 1 | endif | |
line 393: augroup END | |
line 394: | |
line 395: "}}} | |
line 396: | |
line 397: " This is for the default buffer when it does not have a filetype. | |
line 398: call s:setup() | |
calling function <SNR>24_setup() | |
line 1: let swap = a:0 && a:1 == 2 | |
line 2: let enable = a:0 && a:1 | |
line 3: let disable = a:0 && !a:1 | |
line 4: " First, remove all magic, if needed: | |
line 5: if get(b:, 'delimitMate_enabled', 0) | |
line 6: call s:Unmap() | |
line 7: " Switch | |
line 8: if swap | |
line 9: echo "delimitMate is disabled." | |
line 10: return | |
line 11: endif | |
line 12: endif | |
line 13: if disable | |
line 14: " Just disable the mappings. | |
line 15: return | |
line 16: endif | |
line 17: if !a:0 | |
line 18: " Check if this file type is excluded: | |
line 19: if exists("g:delimitMate_excluded_ft") && index(split(g:delimitMate_excluded_ft, ','), &filetype, 0, 1) >= 0 | |
line 21: " Finish here: | |
line 22: return 1 | |
line 23: endif | |
line 24: " Check if user tried to disable using b:loaded_delimitMate | |
line 25: if exists("b:loaded_delimitMate") | |
line 26: return 1 | |
line 27: endif | |
line 28: endif | |
line 29: " Initialize settings: | |
line 30: if ! s:init() | |
calling function <SNR>24_setup..<SNR>24_init() | |
line 1: " Initialize variables: | |
line 2: " autoclose | |
line 3: call s:option_init("autoclose", 1) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('autoclose', 1) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('autoclose', 1) | |
line 1: return call('delimitMate#Set', a:000) | |
Searching for "autoload/delimitMate.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/User | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/delimitMate.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/delimitMate.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/delimitMate/autoload) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 1: sourcing "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/delimitMate.vim" | |
line 1: " File: autoload/delimitMate.vim | |
line 2: " Version: 2.7 | |
line 3: " Modified: 2013-07-15 | |
line 4: " Description: This plugin provides auto-completion for quotes, parens, etc. | |
line 5: " Maintainer: Israel Chauca F. <[email protected]> | |
line 6: " Manual: Read ":help delimitMate". | |
line 7: " ============================================================================ | |
line 8: | |
line 9: "let delimitMate_loaded = 1 | |
line 10: | |
line 11: if !exists('s:options') | |
line 12: let s:options = {} | |
line 13: endif | |
line 14: | |
line 15: function! s:set(name, value, ...) "{{{ | |
line 31: | |
line 32: function! s:get(name, ...) "{{{ | |
line 42: | |
line 43: function! s:exists(name, ...) "{{{ | |
line 53: | |
line 54: function! s:is_jump(...) "{{{ | |
line 90: | |
line 91: function! s:rquote(char) "{{{ | |
line 99: | |
line 100: function! s:lquote(char) "{{{ | |
line 107: | |
line 108: function! s:get_char(...) "{{{ | |
line 121: | |
line 122: function! s:is_cr_expansion(...) " {{{ | |
line 140: | |
line 141: function! s:is_space_expansion() " {{{ | |
line 164: | |
line 165: function! s:is_empty_matchpair() "{{{ | |
line 175: | |
line 176: function! s:is_empty_quotes() "{{{ | |
line 185: | |
line 186: function! s:cursor_idx() "{{{ | |
line 190: | |
line 191: function! s:get_syn_name() "{{{ | |
line 198: | |
line 199: function! s:is_excluded_ft(ft) "{{{ | |
line 205: | |
line 206: function! s:is_forbidden(char) "{{{ | |
line 216: | |
line 217: function! s:balance_matchpairs(char) "{{{ | |
line 253: | |
line 254: function! s:is_smart_quote(char) "{{{ | |
line 269: | |
line 270: function! delimitMate#Set(...) "{{{ | |
line 273: | |
line 274: function! delimitMate#Get(...) "{{{ | |
line 277: | |
line 278: function! delimitMate#ShouldJump(...) "{{{ | |
line 281: | |
line 282: function! delimitMate#IsEmptyPair(str) "{{{ | |
line 298: | |
line 299: function! delimitMate#WithinEmptyPair() "{{{ | |
line 310: | |
line 311: function! delimitMate#SkipDelim(char) "{{{ | |
line 338: | |
line 339: function! delimitMate#ParenDelim(right) " {{{ | |
line 365: | |
line 366: function! delimitMate#QuoteDelim(char) "{{{ | |
line 407: | |
line 408: function! delimitMate#JumpOut(char) "{{{ | |
line 426: | |
line 427: function! delimitMate#JumpAny(...) " {{{ | |
line 446: | |
line 447: function! delimitMate#JumpMany() " {{{ | |
line 468: | |
line 469: function! delimitMate#ExpandReturn() "{{{ | |
line 511: | |
line 512: function! delimitMate#ExpandSpace() "{{{ | |
line 528: | |
line 529: function! delimitMate#BS() " {{{ | |
line 546: | |
line 547: function! delimitMate#Test() "{{{ | |
line 628: | |
line 629: function! s:test_mappings(list, is_matchpair) "{{{ | |
line 658: | |
line 659: function! s:joinUndo() "{{{ | |
line 666: | |
line 667: " vim:foldmethod=marker:foldcolumn=4:ts=2:sw=2 | |
finished sourcing /Users/nhooyr/.nvim/plugged/delimitMate/autoload/delimitMate.vim | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('autoclose', 1) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('autoclose', 1) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.autoclose = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 4: " matchpairs | |
line 5: call s:option_init("matchpairs", string(&matchpairs)[1:-2]) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('matchpairs', '(:),{:},[:]') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('matchpairs', '(:),{:},[:]') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('matchpairs', '(:),{:},[:]') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('matchpairs', '(:),{:},[:]') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.matchpairs = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 6: call s:option_init("matchpairs_list", map(split(s:get('matchpairs'), '.:.\zs,\ze.:.'), 'split(v:val, ''^.\zs:\ze.$'')')) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('matchpairs') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('matchpairs') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning '(:),{:},[:]' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning '(:),{:},[:]' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning '(:),{:},[:]' | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('matchpairs_list', [['(', ')'], ['{', '}'], ['[', ']']]) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('matchpairs_list', [['(', ')'], ['{', '}'], ['[', ']']]) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('matchpairs_list', [['(', ')'], ['{', '}'], ['[', ']']]) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('matchpairs_list', [['(', ')'], ['{', '}'], ['[', ']']]) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.matchpairs_list = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 7: let pairs = s:get('matchpairs_list') | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 8: if len(filter(pairs, 'v:val[0] ==# v:val[1]')) | |
line 9: echohl ErrorMsg | |
line 10: echom 'delimitMate: each member of a pair in delimitMate_matchpairs must be different from each other.' | |
line 11: echom 'delimitMate: invalid pairs: ' . join(map(pairs, 'join(v:val, ":")'), ', ') | |
line 12: echohl Normal | |
line 13: return 0 | |
line 14: endif | |
line 15: call s:option_init("left_delims", map(copy(s:get('matchpairs_list')), 'v:val[0]')) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('left_delims', ['(', '{', '[']) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('left_delims', ['(', '{', '[']) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('left_delims', ['(', '{', '[']) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('left_delims', ['(', '{', '[']) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.left_delims = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 16: call s:option_init("right_delims", map(copy(s:get('matchpairs_list')), 'v:val[1]')) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('right_delims', [')', '}', ']']) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('right_delims', [')', '}', ']']) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('right_delims', [')', '}', ']']) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('right_delims', [')', '}', ']']) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.right_delims = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 17: " quotes | |
line 18: call s:option_init("quotes", "\" ' `") | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('quotes', '" '' `') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('quotes', '" '' `') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('quotes', '" '' `') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('quotes', '" '' `') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.quotes = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 19: call s:option_init("quotes_list",split(s:get('quotes'), '\s\+')) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('quotes') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('quotes') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('quotes') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning '" '' `' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning '" '' `' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning '" '' `' | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('quotes_list', ['"', '''', '`']) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('quotes_list', ['"', '''', '`']) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('quotes_list', ['"', '''', '`']) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('quotes_list', ['"', '''', '`']) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.quotes_list = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 20: " nesting_quotes | |
line 21: call s:option_init("nesting_quotes", []) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('nesting_quotes', []) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('nesting_quotes', []) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('nesting_quotes', []) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('nesting_quotes', []) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.nesting_quotes = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 22: " excluded_regions | |
line 23: call s:option_init("excluded_regions", "Comment") | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('excluded_regions', 'Comment') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('excluded_regions', 'Comment') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('excluded_regions', 'Comment') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('excluded_regions', 'Comment') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.excluded_regions = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 24: call s:option_init("excluded_regions_list", split(s:get('excluded_regions'), ',\s*')) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('excluded_regions') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('excluded_regions') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('excluded_regions') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning 'Comment' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning 'Comment' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning 'Comment' | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('excluded_regions_list', ['Comment']) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('excluded_regions_list', ['Comment']) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('excluded_regions_list', ['Comment']) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('excluded_regions_list', ['Comment']) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.excluded_regions_list = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 25: let enabled = len(s:get('excluded_regions_list')) > 0 | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('excluded_regions_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('excluded_regions_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('excluded_regions_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['Comment'] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning ['Comment'] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning ['Comment'] | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 26: call s:option_init("excluded_regions_enabled", enabled) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('excluded_regions_enabled', 1) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('excluded_regions_enabled', 1) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('excluded_regions_enabled', 1) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('excluded_regions_enabled', 1) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.excluded_regions_enabled = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 27: " expand_space | |
line 28: if exists("b:delimitMate_expand_space") && type(b:delimitMate_expand_space) == type("") | |
line 29: echom "b:delimitMate_expand_space is '".b:delimitMate_expand_space."' but it must be either 1 or 0!" | |
line 30: echom "Read :help 'delimitMate_expand_space' for more details." | |
line 31: unlet b:delimitMate_expand_space | |
line 32: let b:delimitMate_expand_space = 1 | |
line 33: endif | |
line 34: if exists("g:delimitMate_expand_space") && type(g:delimitMate_expand_space) == type("") | |
line 35: echom "delimitMate_expand_space is '".g:delimitMate_expand_space."' but it must be either 1 or 0!" | |
line 36: echom "Read :help 'delimitMate_expand_space' for more details." | |
line 37: unlet g:delimitMate_expand_space | |
line 38: let g:delimitMate_expand_space = 1 | |
line 39: endif | |
line 40: call s:option_init("expand_space", 0) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('expand_space', 0) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('expand_space', 0) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('expand_space', 0) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('expand_space', 0) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.expand_space = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 41: " expand_cr | |
line 42: if exists("b:delimitMate_expand_cr") && type(b:delimitMate_expand_cr) == type("") | |
line 43: echom "b:delimitMate_expand_cr is '".b:delimitMate_expand_cr."' but it must be either 1 or 0!" | |
line 44: echom "Read :help 'delimitMate_expand_cr' for more details." | |
line 45: unlet b:delimitMate_expand_cr | |
line 46: let b:delimitMate_expand_cr = 1 | |
line 47: endif | |
line 48: if exists("g:delimitMate_expand_cr") && type(g:delimitMate_expand_cr) == type("") | |
line 49: echom "delimitMate_expand_cr is '".g:delimitMate_expand_cr."' but it must be either 1 or 0!" | |
line 50: echom "Read :help 'delimitMate_expand_cr' for more details." | |
line 51: unlet g:delimitMate_expand_cr | |
line 52: let g:delimitMate_expand_cr = 1 | |
line 53: endif | |
line 54: if ((&backspace !~ 'eol' || &backspace !~ 'start') && &backspace != 2) && ((exists('b:delimitMate_expand_cr') && b:delimitMate_expand_cr == 1) || (exists('g:delimitMate_expand_cr') && g:delimitMate_expand_cr == 1)) | |
line 57: echom "delimitMate: There seems to be some incompatibility with your settings that may interfer with the expansion of <CR>. See :help 'delimitMate_expand_cr' for details." | |
line 58: endif | |
line 59: call s:option_init("expand_cr", 0) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('expand_cr', 0) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 9: let value = g:delimitMate_expand_cr | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('expand_cr', 1) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('expand_cr', 1) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('expand_cr', 1) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.expand_cr = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 60: " expand_in_quotes | |
line 61: call s:option_init('expand_inside_quotes', 0) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('expand_inside_quotes', 0) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('expand_inside_quotes', 0) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('expand_inside_quotes', 0) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('expand_inside_quotes', 0) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.expand_inside_quotes = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 62: " jump_expansion | |
line 63: call s:option_init("jump_expansion", 0) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('jump_expansion', 0) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('jump_expansion', 0) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('jump_expansion', 0) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('jump_expansion', 0) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.jump_expansion = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 64: " smart_matchpairs | |
line 65: call s:option_init("smart_matchpairs", '^\%(\w\|\!\|[£$]\|[^[:punct:][:space:]]\)') | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('smart_matchpairs', '^\%(\w\|\!\|[£$]\|[^[:punct:][:space:]]\)') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('smart_matchpairs', '^\%(\w\|\!\|[£$]\|[^[:punct:][:space:]]\)') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('smart_matchpairs', '^\%(\w\|\!\|[£$]\|[^[:punct:][:space:]]\)') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('smart_matchpairs', '^\%(\w\|\!\|[£$]\|[^[:punct:][:space:]]\)') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.smart_matchpairs = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 66: " smart_quotes | |
line 67: " XXX: backward compatibility. Ugly, should go the way of the dodo soon. | |
line 68: let quotes = escape(join(s:get('quotes_list'), ''), '\-^[]') | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('quotes_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('quotes_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('quotes_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 69: let default_smart_quotes = '\%(\w\|[^[:punct:][:space:]' . quotes . ']\|\%(\\\\\)*\\\)\%#\|\%#\%(\w\|[^[:space:][:punct:]' . quotes . ']\)' | |
line 70: if exists('g:delimitMate_smart_quotes') && type(g:delimitMate_smart_quotes) == type(0) | |
line 71: if g:delimitMate_smart_quotes | |
line 72: unlet g:delimitMate_smart_quotes | |
line 73: else | |
line 74: unlet g:delimitMate_smart_quotes | |
line 75: let g:delimitMate_smart_quotes = '' | |
line 76: endif | |
line 77: endif | |
line 78: if exists('b:delimitMate_smart_quotes') && type(b:delimitMate_smart_quotes) == type(0) | |
line 79: if b:delimitMate_smart_quotes | |
line 80: unlet b:delimitMate_smart_quotes | |
line 81: if exists('g:delimitMate_smart_quotes') && type(g:delimitMate_smart_quotes) && g:delimitMate_smart_quotes | |
line 82: let b:delimitMate_smart_quotes = default_smart_quotes | |
line 83: endif | |
line 84: else | |
line 85: unlet b:delimitMate_smart_quotes | |
line 86: let b:delimitMate_smart_quotes = '' | |
line 87: endif | |
line 88: endif | |
line 89: call s:option_init("smart_quotes", default_smart_quotes) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('smart_quotes', '\%(\w\|[^[:punct:][:space:]"''`]\|\%...\|\%#\%(\w\|[^[:space:][:punct:]"''`]\)') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('smart_quotes', '\%(\w\|[^[:punct:][:space:]"''`]\|\%...\|\%#\%(\w\|[^[:space:][:punct:]"''`]\)') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('smart_quotes', '\%(\w\|[^[:punct:][:space:]"''`]\|\%...\|\%#\%(\w\|[^[:space:][:punct:]"''`]\)') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('smart_quotes', '\%(\w\|[^[:punct:][:space:]"''`]\|\%...\|\%#\%(\w\|[^[:space:][:punct:]"''`]\)') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.smart_quotes = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 90: " apostrophes | |
line 91: call s:option_init("apostrophes", "") | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('apostrophes', '') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('apostrophes', '') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('apostrophes', '') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('apostrophes', '') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.apostrophes = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 92: call s:option_init("apostrophes_list", split(s:get('apostrophes'), ":\s*")) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get('apostrophes') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get('apostrophes') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get('apostrophes') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get..<SNR>25_get returning '' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get..delimitMate#Get returning '' | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_get returning '' | |
continuing in function <SNR>24_setup..<SNR>24_init | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('apostrophes_list', []) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('apostrophes_list', []) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('apostrophes_list', []) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('apostrophes_list', []) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.apostrophes_list = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 93: " tab2exit | |
line 94: call s:option_init("tab2exit", 1) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('tab2exit', 1) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('tab2exit', 1) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('tab2exit', 1) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('tab2exit', 1) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.tab2exit = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 95: " balance_matchpairs | |
line 96: call s:option_init("balance_matchpairs", 0) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('balance_matchpairs', 0) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('balance_matchpairs', 0) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('balance_matchpairs', 0) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('balance_matchpairs', 0) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.balance_matchpairs = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 97: " eol marker | |
line 98: call s:option_init("insert_eol_marker", 1) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('insert_eol_marker', 1) | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('insert_eol_marker', 1) | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('insert_eol_marker', 1) | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('insert_eol_marker', 1) | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.insert_eol_marker = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 99: call s:option_init("eol_marker", "") | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init('eol_marker', '') | |
line 1: let b = exists("b:delimitMate_" . a:name) | |
line 2: let g = exists("g:delimitMate_" . a:name) | |
line 3: " Find value to use. | |
line 4: if !b && !g | |
line 5: let value = a:default | |
line 6: elseif b | |
line 7: exec "let value = b:delimitMate_" . a:name | |
line 8: else | |
line 9: exec "let value = g:delimitMate_" . a:name | |
line 10: endif | |
line 11: call s:set(a:name, value) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set('eol_marker', '') | |
line 1: return call('delimitMate#Set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set('eol_marker', '') | |
line 1: return call('s:set', a:000) | |
calling function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set('eol_marker', '') | |
line 1: let scope = a:0 ? a:1 : 's' | |
line 2: let bufnr = bufnr('%') | |
line 3: if !exists('s:options[bufnr]') | |
line 4: let s:options[bufnr] = {} | |
line 5: endif | |
line 6: if scope == 's' | |
line 7: let name = 's:options.' . bufnr . '.' . a:name | |
line 8: else | |
line 9: let name = scope . ':delimitMate_' . a:name | |
line 10: if exists('name') | |
line 11: exec 'unlet! ' . name | |
line 12: endif | |
line 13: endif | |
line 14: exec 'let ' . name . ' = a:value' | |
line 14: let s:options.1.eol_marker = a:value | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set..<SNR>25_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set..delimitMate#Set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init..<SNR>24_set returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init | |
function <SNR>24_setup..<SNR>24_init..<SNR>24_option_init returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_init | |
line 100: " Everything is fine. | |
line 101: return 1 | |
function <SNR>24_setup..<SNR>24_init returning #1 | |
continuing in function <SNR>24_setup | |
line 31: " Something went wrong. | |
line 32: return | |
line 33: endif | |
line 34: if enable || swap || !get(g:, 'delimitMate_offByDefault', 0) | |
line 35: " Now, add magic: | |
line 36: call s:Map() | |
calling function <SNR>24_setup..<SNR>24_Map() | |
line 1: " Set mappings: | |
line 2: try | |
line 3: let save_keymap = &keymap | |
line 4: let save_iminsert = &iminsert | |
line 5: let save_imsearch = &imsearch | |
line 6: let save_cpo = &cpo | |
line 7: set keymap= | |
line 7: unlet! b:keymap_name | |
line 8: set cpo&vim | |
line 9: silent! doautocmd <nomodeline> User delimitMate_map | |
No matching autocommands | |
line 10: if s:get('autoclose') | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_get('autoclose') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_get..delimitMate#Get('autoclose') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_get..delimitMate#Get..<SNR>25_get('autoclose') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_get..delimitMate#Get..<SNR>25_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_get..delimitMate#Get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map | |
line 11: call s:AutoClose() | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose() | |
line 1: " Add matching pair and jump to the midle: | |
line 2: " inoremap <silent> <buffer> ( ()<Left> | |
line 3: let i = 0 | |
line 4: while i < len(s:get('matchpairs_list')) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 5: let ld = s:get('left_delims')[i] == '|' ? '<bar>' : s:get('left_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 6: let rd = s:get('right_delims')[i] == '|' ? '<bar>' : s:get('right_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 7: exec 'inoremap <expr><silent> <Plug>delimitMate' . ld. ' <SID>TriggerAbb().delimitMate#ParenDelim("' . escape(rd, '|') . '")' | |
line 7: inoremap <expr><silent> <Plug>delimitMate( <SID>TriggerAbb().delimitMate#ParenDelim(")") | |
line 9: exec 'silent! imap <unique> <buffer> '.ld.' <Plug>delimitMate'.ld | |
line 9: silent! imap <unique> <buffer> ( <Plug>delimitMate( | |
line 11: let i += 1 | |
line 12: endwhile | |
line 4: while i < len(s:get('matchpairs_list')) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 5: let ld = s:get('left_delims')[i] == '|' ? '<bar>' : s:get('left_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 6: let rd = s:get('right_delims')[i] == '|' ? '<bar>' : s:get('right_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 7: exec 'inoremap <expr><silent> <Plug>delimitMate' . ld. ' <SID>TriggerAbb().delimitMate#ParenDelim("' . escape(rd, '|') . '")' | |
line 7: inoremap <expr><silent> <Plug>delimitMate{ <SID>TriggerAbb().delimitMate#ParenDelim("}") | |
line 9: exec 'silent! imap <unique> <buffer> '.ld.' <Plug>delimitMate'.ld | |
line 9: silent! imap <unique> <buffer> { <Plug>delimitMate{ | |
line 11: let i += 1 | |
line 12: endwhile | |
line 4: while i < len(s:get('matchpairs_list')) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 5: let ld = s:get('left_delims')[i] == '|' ? '<bar>' : s:get('left_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('left_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('left_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('left_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['(', '{', '['] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 6: let rd = s:get('right_delims')[i] == '|' ? '<bar>' : s:get('right_delims')[i] | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 7: exec 'inoremap <expr><silent> <Plug>delimitMate' . ld. ' <SID>TriggerAbb().delimitMate#ParenDelim("' . escape(rd, '|') . '")' | |
line 7: inoremap <expr><silent> <Plug>delimitMate[ <SID>TriggerAbb().delimitMate#ParenDelim("]") | |
line 9: exec 'silent! imap <unique> <buffer> '.ld.' <Plug>delimitMate'.ld | |
line 9: silent! imap <unique> <buffer> [ <Plug>delimitMate[ | |
line 11: let i += 1 | |
line 12: endwhile | |
line 4: while i < len(s:get('matchpairs_list')) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('matchpairs_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('matchpairs_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('matchpairs_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [['(', ')'], ['{', '}'], ['[', ']']] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 5: let ld = s:get('left_delims')[i] == '|' ? '<bar>' : s:get('left_delims')[i] | |
line 6: let rd = s:get('right_delims')[i] == '|' ? '<bar>' : s:get('right_delims')[i] | |
line 7: exec 'inoremap <expr><silent> <Plug>delimitMate' . ld. ' <SID>TriggerAbb().delimitMate#ParenDelim("' . escape(rd, '|') . '")' | |
line 9: exec 'silent! imap <unique> <buffer> '.ld.' <Plug>delimitMate'.ld | |
line 11: let i += 1 | |
line 12: endwhile | |
line 13: | |
line 14: " Exit from inside the matching pair: | |
line 15: for delim in s:get('right_delims') | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('right_delims') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('right_delims') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('right_delims') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [')', '}', ']'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 16: let delim = delim == '|' ? '<bar>' : delim | |
line 17: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb().delimitMate#JumpOut("\' . delim . '")' | |
line 17: inoremap <expr><silent> <Plug>delimitMate) <SID>TriggerAbb().delimitMate#JumpOut("\)") | |
line 19: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate'. delim | |
line 19: silent! imap <unique> <buffer> ) <Plug>delimitMate) | |
line 21: endfor | |
line 15: for delim in s:get('right_delims') | |
line 16: let delim = delim == '|' ? '<bar>' : delim | |
line 17: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb().delimitMate#JumpOut("\' . delim . '")' | |
line 17: inoremap <expr><silent> <Plug>delimitMate} <SID>TriggerAbb().delimitMate#JumpOut("\}") | |
line 19: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate'. delim | |
line 19: silent! imap <unique> <buffer> } <Plug>delimitMate} | |
line 21: endfor | |
line 15: for delim in s:get('right_delims') | |
line 16: let delim = delim == '|' ? '<bar>' : delim | |
line 17: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb().delimitMate#JumpOut("\' . delim . '")' | |
line 17: inoremap <expr><silent> <Plug>delimitMate] <SID>TriggerAbb().delimitMate#JumpOut("\]") | |
line 19: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate'. delim | |
line 19: silent! imap <unique> <buffer> ] <Plug>delimitMate] | |
line 21: endfor | |
line 15: for delim in s:get('right_delims') | |
line 16: let delim = delim == '|' ? '<bar>' : delim | |
line 17: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb().delimitMate#JumpOut("\' . delim . '")' | |
line 19: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate'. delim | |
line 21: endfor | |
line 22: | |
line 23: " Add matching quote and jump to the midle, or exit if inside a pair of matching quotes: | |
line 24: " inoremap <silent> <buffer> " <C-R>=delimitMate#QuoteDelim("\"")<CR> | |
line 25: for delim in s:get('quotes_list') | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('quotes_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('quotes_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('quotes_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning ['"', '''', '`'] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 26: if delim == '|' | |
line 27: let delim = '<Bar>' | |
line 28: endif | |
line 29: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\' . delim . '\")<CR>"' | |
line 29: inoremap <expr><silent> <Plug>delimitMate" <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\"\")<CR>" | |
line 31: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate' . delim | |
line 31: silent! imap <unique> <buffer> " <Plug>delimitMate" | |
line 33: endfor | |
line 25: for delim in s:get('quotes_list') | |
line 26: if delim == '|' | |
line 27: let delim = '<Bar>' | |
line 28: endif | |
line 29: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\' . delim . '\")<CR>"' | |
line 29: inoremap <expr><silent> <Plug>delimitMate' <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\'\")<CR>" | |
line 31: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate' . delim | |
line 31: silent! imap <unique> <buffer> ' <Plug>delimitMate' | |
line 33: endfor | |
line 25: for delim in s:get('quotes_list') | |
line 26: if delim == '|' | |
line 27: let delim = '<Bar>' | |
line 28: endif | |
line 29: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\' . delim . '\")<CR>"' | |
line 29: inoremap <expr><silent> <Plug>delimitMate` <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\`\")<CR>" | |
line 31: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate' . delim | |
line 31: silent! imap <unique> <buffer> ` <Plug>delimitMate` | |
line 33: endfor | |
line 25: for delim in s:get('quotes_list') | |
line 26: if delim == '|' | |
line 27: let delim = '<Bar>' | |
line 28: endif | |
line 29: exec 'inoremap <expr><silent> <Plug>delimitMate' . delim. ' <SID>TriggerAbb()."<C-R>=delimitMate#QuoteDelim(\"\\\' . delim . '\")<CR>"' | |
line 31: exec 'silent! imap <unique> <buffer> ' . delim. ' <Plug>delimitMate' . delim | |
line 33: endfor | |
line 34: | |
line 35: " Try to fix the use of apostrophes (kept for backward compatibility): | |
line 36: " inoremap <silent> <buffer> n't n't | |
line 37: for map in s:get('apostrophes_list') | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get('apostrophes_list') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get('apostrophes_list') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get('apostrophes_list') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get..<SNR>25_get returning [] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get..delimitMate#Get returning [] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose..<SNR>24_get returning [] | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose | |
line 38: exec "inoremap <silent> " . map . " " . map | |
line 39: exec 'silent! imap <unique> <buffer> ' . map . ' <Plug>delimitMate' . map | |
line 40: endfor | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_AutoClose returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_Map | |
line 12: else | |
line 13: call s:NoAutoClose() | |
line 14: endif | |
line 15: call s:ExtraMappings() | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings() | |
line 1: " If pair is empty, delete both delimiters: | |
line 2: inoremap <silent> <Plug>delimitMateBS <C-R>=delimitMate#BS()<CR> | |
line 3: if !hasmapto('<Plug>delimitMateBS','i') | |
line 4: if empty(maparg('<BS>', 'i')) | |
line 5: silent! imap <unique> <buffer> <BS> <Plug>delimitMateBS | |
line 6: endif | |
line 7: if empty(maparg('<C-H>', 'i')) | |
line 8: silent! imap <unique> <buffer> <C-h> <Plug>delimitMateBS | |
line 9: endif | |
line 10: endif | |
line 11: " If pair is empty, delete closing delimiter: | |
line 12: inoremap <silent> <expr> <Plug>delimitMateS-BS delimitMate#WithinEmptyPair() ? "\<Del>" : "\<S-BS>" | |
line 13: if !hasmapto('<Plug>delimitMateS-BS','i') && maparg('<S-BS>', 'i') == '' | |
line 14: silent! imap <unique> <buffer> <S-BS> <Plug>delimitMateS-BS | |
line 15: endif | |
line 16: " Expand return if inside an empty pair: | |
line 17: inoremap <expr><silent> <Plug>delimitMateCR <SID>TriggerAbb()."\<C-R>=delimitMate#ExpandReturn()\<CR>" | |
line 18: if s:get('expand_cr') && !hasmapto('<Plug>delimitMateCR', 'i') && maparg('<CR>', 'i') == '' | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get('expand_cr') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get('expand_cr') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get('expand_cr') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings | |
line 19: silent! imap <unique> <buffer> <CR> <Plug>delimitMateCR | |
line 20: endif | |
line 21: " Expand space if inside an empty pair: | |
line 22: inoremap <expr><silent> <Plug>delimitMateSpace <SID>TriggerAbb()."\<C-R>=delimitMate#ExpandSpace()\<CR>" | |
line 23: if s:get('expand_space') && !hasmapto('<Plug>delimitMateSpace', 'i') && maparg('<Space>', 'i') == '' | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get('expand_space') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get('expand_space') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get('expand_space') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings | |
line 24: silent! imap <unique> <buffer> <Space> <Plug>delimitMateSpace | |
line 25: endif | |
line 26: " Jump over any delimiter: | |
line 27: inoremap <expr><silent> <Plug>delimitMateS-Tab <SID>TriggerAbb()."\<C-R>=delimitMate#JumpAny()\<CR>" | |
line 28: if s:get('tab2exit') && !hasmapto('<Plug>delimitMateS-Tab', 'i') && maparg('<S-Tab>', 'i') == '' | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get('tab2exit') | |
line 1: return call('delimitMate#Get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get('tab2exit') | |
line 1: return call('s:get', a:000) | |
calling function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get('tab2exit') | |
line 1: if a:0 == 2 | |
line 2: return deepcopy(get(a:2, 'delimitMate_' . a:name, a:1)) | |
line 3: elseif a:0 == 1 | |
line 4: let bufoptions = get(s:options, bufnr('%'), {}) | |
line 5: return deepcopy(get(bufoptions, a:name, a:1)) | |
line 6: else | |
line 7: return deepcopy(eval('s:options.' . bufnr('%') . '.' . a:name)) | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get..<SNR>25_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get..delimitMate#Get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings..<SNR>24_get returning #1 | |
continuing in function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings | |
line 29: silent! imap <unique> <buffer> <S-Tab> <Plug>delimitMateS-Tab | |
line 30: endif | |
line 31: " Jump over next delimiters | |
line 32: inoremap <expr><buffer> <Plug>delimitMateJumpMany <SID>TriggerAbb()."\<C-R>=delimitMate#JumpMany()\<CR>" | |
line 33: if !hasmapto('<Plug>delimitMateJumpMany', 'i') && maparg("<C-G>g", 'i') == '' | |
line 34: imap <silent> <buffer> <C-G>g <Plug>delimitMateJumpMany | |
line 35: endif | |
function <SNR>24_setup..<SNR>24_Map..<SNR>24_ExtraMappings returning #0 | |
continuing in function <SNR>24_setup..<SNR>24_Map | |
line 16: finally | |
line 17: let &cpo = save_cpo | |
line 18: let &keymap = save_keymap | |
line 18: unlet! b:keymap_name | |
line 19: let &iminsert = save_iminsert | |
line 20: let &imsearch = save_imsearch | |
line 21: endtry | |
line 22: | |
line 23: let b:delimitMate_enabled = 1 | |
function <SNR>24_setup..<SNR>24_Map returning #0 | |
continuing in function <SNR>24_setup | |
line 37: if a:0 | |
line 38: echo "delimitMate is enabled." | |
line 39: endif | |
line 40: endif | |
function <SNR>24_setup returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/delimitMate/plugin/delimitMate.vim | |
line 399: | |
line 400: let &cpo = save_cpo | |
line 401: " GetLatestVimScripts: 2754 1 :AutoInstall: delimitMate.vim | |
line 402: " vim:foldmethod=marker:foldcolumn=4:ts=2:sw=2 | |
finished sourcing /Users/nhooyr/.nvim/plugged/delimitMate/plugin/delimitMate.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/plugin/tmux_navigator.vim" | |
line 1: " Maps <C-h/j/k/l> to switch vim splits in the given direction. If there are | |
line 2: " no more windows in that direction, forwards the operation to tmux. | |
line 3: " Additionally, <C-\> toggles between last active vim splits/tmux panes. | |
line 4: | |
line 5: if exists("g:loaded_tmux_navigator") || &cp || v:version < 700 | |
line 6: finish | |
line 7: endif | |
line 8: let g:loaded_tmux_navigator = 1 | |
line 9: | |
line 10: if !exists("g:tmux_navigator_save_on_switch") | |
line 11: let g:tmux_navigator_save_on_switch = 0 | |
line 12: endif | |
line 13: | |
line 14: function! s:UseTmuxNavigatorMappings() | |
line 17: | |
line 18: function! s:InTmuxSession() | |
line 21: | |
line 22: function! s:TmuxSocket() | |
line 26: | |
line 27: function! s:TmuxCommand(args) | |
line 31: | |
line 32: function! s:TmuxPaneCurrentCommand() | |
line 35: command! TmuxPaneCurrentCommand call <SID>TmuxPaneCurrentCommand() | |
line 36: | |
line 37: let s:tmux_is_last_pane = 0 | |
line 38: au WinEnter * let s:tmux_is_last_pane = 0 | |
line 39: | |
line 40: " Like `wincmd` but also change tmux panes instead of vim windows when needed. | |
line 41: function! s:TmuxWinCmd(direction) | |
line 48: | |
line 49: function! s:NeedsVitalityRedraw() | |
line 52: | |
line 53: function! s:TmuxAwareNavigate(direction) | |
line 76: | |
line 77: function! s:VimNavigate(direction) | |
line 84: | |
line 85: command! TmuxNavigateLeft call <SID>TmuxWinCmd('h') | |
line 86: command! TmuxNavigateDown call <SID>TmuxWinCmd('j') | |
line 87: command! TmuxNavigateUp call <SID>TmuxWinCmd('k') | |
line 88: command! TmuxNavigateRight call <SID>TmuxWinCmd('l') | |
line 89: command! TmuxNavigatePrevious call <SID>TmuxWinCmd('p') | |
line 90: | |
line 91: if s:UseTmuxNavigatorMappings() | |
calling function <SNR>26_UseTmuxNavigatorMappings() | |
line 1: return !exists("g:tmux_navigator_no_mappings") || !g:tmux_navigator_no_mappings | |
function <SNR>26_UseTmuxNavigatorMappings returning #1 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-tmux-navigator/plugin/tmux_navigator.vim | |
line 92: nnoremap <silent> <c-h> :TmuxNavigateLeft<cr> | |
line 93: nnoremap <silent> <c-j> :TmuxNavigateDown<cr> | |
line 94: nnoremap <silent> <c-k> :TmuxNavigateUp<cr> | |
line 95: nnoremap <silent> <c-l> :TmuxNavigateRight<cr> | |
line 96: nnoremap <silent> <c-\> :TmuxNavigatePrevious<cr> | |
line 97: endif | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-tmux-navigator/plugin/tmux_navigator.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-startify/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-startify/plugin/startify.vim" | |
line 1: " vim: et sw=2 sts=2 | |
line 2: | |
line 3: " Plugin: https://github.com/mhinz/vim-startify | |
line 4: " Description: A fancy start screen for Vim. | |
line 5: " Maintainer: Marco Hinz <http://github.com/mhinz> | |
line 6: | |
line 7: if exists('g:loaded_startify') || &cp | |
line 8: finish | |
line 9: endif | |
line 10: let g:loaded_startify = 1 | |
line 11: let g:startify_locked = 0 | |
line 12: | |
line 13: augroup startify | |
line 14: if !get(g:, 'startify_disable_at_vimenter') | |
line 15: autocmd VimEnter * nested call s:genesis() | |
line 16: endif | |
line 17: | |
line 18: if get(g:, 'startify_session_persistence') | |
line 19: autocmd VimLeave * call s:extinction() | |
line 20: endif | |
line 21: | |
line 22: autocmd QuickFixCmdPre *vimgrep* let g:startify_locked = 1 | |
line 23: autocmd QuickFixCmdPost *vimgrep* let g:startify_locked = 0 | |
line 24: augroup END | |
line 25: | |
line 26: function! s:genesis() | |
line 40: | |
line 41: function! s:extinction() | |
line 46: | |
line 47: command! -nargs=? -bar -complete=customlist,startify#session_list SSave call startify#session_save(<f-args>) | |
line 48: command! -nargs=? -bar -complete=customlist,startify#session_list SLoad call startify#session_load(<f-args>) | |
line 49: command! -nargs=? -bar -complete=customlist,startify#session_list SDelete call startify#session_delete(<f-args>) | |
line 50: command! -nargs=0 -bar SClose call startify#session_close() | |
line 51: command! -nargs=0 -bar Startify enew | call startify#insane_in_the_membrane() | |
line 52: command! -nargs=0 -bar StartifyDebug call startify#debug() | |
line 53: | |
line 54: nnoremap <silent><plug>(startify-open-buffers) :<c-u>call startify#open_buffers()<cr> | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-startify/plugin/startify.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/emmet-vim/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/emmet-vim/plugin/emmet.vim" | |
line 1: "============================================================================= | |
line 2: " File: emmet.vim | |
line 3: " Author: Yasuhiro Matsumoto <[email protected]> | |
line 4: " Last Change: 26-Jul-2015. | |
line 5: " Version: 0.86 | |
line 6: " WebPage: http://github.com/mattn/emmet-vim | |
line 7: " Description: vim plugins for HTML and CSS hi-speed coding. | |
line 8: " SeeAlso: http://emmet.io/ | |
line 9: " Usage: | |
line 10: " | |
line 11: " This is vim script support expanding abbreviation like emmet. | |
line 12: " ref: http://emmet.io/ | |
line 13: " | |
line 14: " Type abbreviation | |
line 15: " +------------------------------------- | |
line 16: " | html:5_ | |
line 17: " +------------------------------------- | |
line 18: " "_" is a cursor position. and type "<c-y>," (Ctrl+y and Comma) | |
line 19: " NOTE: Don't worry about key map. you can change it easily. | |
line 20: " +------------------------------------- | |
line 21: " | <!DOCTYPE HTML> | |
line 22: " | <html lang="en"> | |
line 23: " | <head> | |
line 24: " | <title></title> | |
line 25: " | <meta charset="UTF-8"> | |
line 26: " | </head> | |
line 27: " | <body> | |
line 28: " | _ | |
line 29: " | </body> | |
line 30: " | </html> | |
line 31: " +------------------------------------- | |
line 32: " Type following | |
line 33: " +------------------------------------- | |
line 34: " | div#foo$*2>div.bar | |
line 35: " +------------------------------------- | |
line 36: " And type "<c-y>," | |
line 37: " +------------------------------------- | |
line 38: " |<div id="foo1"> | |
line 39: " | <div class="bar">_</div> | |
line 40: " |</div> | |
line 41: " |<div id="foo2"> | |
line 42: " | <div class="bar"></div> | |
line 43: " |</div> | |
line 44: " +------------------------------------- | |
line 45: " | |
line 46: " Tips: | |
line 47: " | |
line 48: " You can customize behavior of expanding with overriding config. | |
line 49: " This configuration will be marged at loading plugin. | |
line 50: " | |
line 51: " let g:user_emmet_settings = { | |
line 52: " \ 'indentation' : ' ', | |
line 53: " \ 'perl' : { | |
line 54: " \ 'aliases' : { | |
line 55: " \ 'req' : 'require ' | |
line 56: " \ }, | |
line 57: " \ 'snippets' : { | |
line 58: " \ 'use' : "use strict\nuse warnings\n\n", | |
line 59: " \ 'warn' : "warn \"|\";", | |
line 60: " \ } | |
line 61: " \ } | |
line 62: " \} | |
line 63: " | |
line 64: " You can set language attribute in html using 'emmet_settings.lang'. | |
line 65: " | |
line 66: " GetLatestVimScripts: 2981 1 :AutoInstall: emmet.vim | |
line 67: " script type: plugin | |
line 68: | |
line 69: if &compatible || v:version < 702 || (exists('g:loaded_emmet_vim') && g:loaded_emmet_vim) | |
line 70: finish | |
line 71: endif | |
line 72: let g:loaded_emmet_vim = 1 | |
line 73: | |
line 74: let s:save_cpo = &cpoptions | |
line 75: set cpoptions&vim | |
line 76: | |
line 77: if !exists('g:emmet_html5') | |
line 78: let g:emmet_html5 = 1 | |
line 79: endif | |
line 80: | |
line 81: if !exists('g:emmet_docroot') | |
line 82: let g:emmet_docroot = {} | |
line 83: endif | |
line 84: | |
line 85: if !exists('g:emmet_debug') | |
line 86: let g:emmet_debug = 0 | |
line 87: endif | |
line 88: | |
line 89: if !exists('g:emmet_curl_command') | |
line 90: let g:emmet_curl_command = 'curl -s -L -A Mozilla/5.0' | |
line 91: endif | |
line 92: | |
line 93: if !exists('g:user_emmet_leader_key') | |
line 94: let g:user_emmet_leader_key = '<c-y>' | |
line 95: endif | |
line 96: | |
line 97: function! s:install_plugin(mode, buffer) | |
line 163: | |
line 164: command! -nargs=0 -bar EmmetInstall call <SID>install_plugin(get(g:, 'user_emmet_mode', 'a'), 1) | |
line 165: | |
line 166: if get(g:, 'user_emmet_install_global', 1) | |
line 167: call s:install_plugin(get(g:, 'user_emmet_mode', 'a'), 0) | |
line 168: endif | |
line 169: | |
line 170: if get(g:, 'user_emmet_install_command', 1) | |
line 171: command! -nargs=1 Emmet call emmet#expandAbbr(4, <q-args>) | |
line 172: endif | |
line 173: | |
line 174: let &cpoptions = s:save_cpo | |
line 175: unlet s:save_cpo | |
line 176: | |
line 177: " vim:set et: | |
finished sourcing /Users/nhooyr/.nvim/plugged/emmet-vim/plugin/emmet.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-surround/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-surround/plugin/surround.vim" | |
line 1: " surround.vim - Surroundings | |
line 2: " Author: Tim Pope <http://tpo.pe/> | |
line 3: " Version: 2.1 | |
line 4: " GetLatestVimScripts: 1697 1 :AutoInstall: surround.vim | |
line 5: | |
line 6: if exists("g:loaded_surround") || &cp || v:version < 700 | |
line 7: finish | |
line 8: endif | |
line 9: let g:loaded_surround = 1 | |
line 10: | |
line 11: " Input functions {{{1 | |
line 12: | |
line 13: function! s:getchar() | |
line 20: | |
line 21: function! s:inputtarget() | |
line 35: | |
line 36: function! s:inputreplacement() | |
line 47: | |
line 48: function! s:beep() | |
line 52: | |
line 53: function! s:redraw() | |
line 57: | |
line 58: " }}}1 | |
line 59: | |
line 60: " Wrapping functions {{{1 | |
line 61: | |
line 62: function! s:extractbefore(str) | |
line 69: | |
line 70: function! s:extractafter(str) | |
line 77: | |
line 78: function! s:fixindent(str,spc) | |
line 87: | |
line 88: function! s:process(string) | |
line 126: | |
line 127: function! s:wrap(string,char,type,removed,special) | |
line 297: | |
line 298: function! s:wrapreg(reg,char,removed,special) | |
line 304: " }}}1 | |
line 305: | |
line 306: function! s:insert(...) " {{{1 | |
line 348: | |
line 349: function! s:reindent() " {{{1 | |
line 354: | |
line 355: function! s:dosurround(...) " {{{1 | |
line 468: | |
line 469: function! s:changesurround(...) " {{{1 | |
line 480: | |
line 481: function! s:opfunc(type,...) " {{{1 | |
line 543: | |
line 544: function! s:opfunc2(arg) | |
line 547: | |
line 548: function! s:closematch(str) " {{{1 | |
line 563: | |
line 564: nnoremap <silent> <Plug>SurroundRepeat . | |
line 565: nnoremap <silent> <Plug>Dsurround :<C-U>call <SID>dosurround(<SID>inputtarget())<CR> | |
line 566: nnoremap <silent> <Plug>Csurround :<C-U>call <SID>changesurround()<CR> | |
line 567: nnoremap <silent> <Plug>CSurround :<C-U>call <SID>changesurround(1)<CR> | |
line 568: nnoremap <silent> <Plug>Yssurround :<C-U>call <SID>opfunc(v:count1)<CR> | |
line 569: nnoremap <silent> <Plug>YSsurround :<C-U>call <SID>opfunc2(v:count1)<CR> | |
line 570: " <C-U> discards the numerical argument but there's not much we can do with it | |
line 571: nnoremap <silent> <Plug>Ysurround :<C-U>set opfunc=<SID>opfunc<CR>g@ | |
line 572: nnoremap <silent> <Plug>YSurround :<C-U>set opfunc=<SID>opfunc2<CR>g@ | |
line 573: vnoremap <silent> <Plug>VSurround :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 1 : 0)<CR> | |
line 574: vnoremap <silent> <Plug>VgSurround :<C-U>call <SID>opfunc(visualmode(),visualmode() ==# 'V' ? 0 : 1)<CR> | |
line 575: inoremap <silent> <Plug>Isurround <C-R>=<SID>insert()<CR> | |
line 576: inoremap <silent> <Plug>ISurround <C-R>=<SID>insert(1)<CR> | |
line 577: | |
line 578: if !exists("g:surround_no_mappings") || ! g:surround_no_mappings | |
line 579: nmap ds <Plug>Dsurround | |
line 580: nmap cs <Plug>Csurround | |
line 581: nmap cS <Plug>CSurround | |
line 582: nmap ys <Plug>Ysurround | |
line 583: nmap yS <Plug>YSurround | |
line 584: nmap yss <Plug>Yssurround | |
line 585: nmap ySs <Plug>YSsurround | |
line 586: nmap ySS <Plug>YSsurround | |
line 587: xmap S <Plug>VSurround | |
line 588: xmap gS <Plug>VgSurround | |
line 589: if !exists("g:surround_no_insert_mappings") || ! g:surround_no_insert_mappings | |
line 590: if !hasmapto("<Plug>Isurround","i") && "" == mapcheck("<C-S>","i") | |
line 591: imap <C-S> <Plug>Isurround | |
line 592: endif | |
line 593: imap <C-G>s <Plug>Isurround | |
line 594: imap <C-G>S <Plug>ISurround | |
line 595: endif | |
line 596: endif | |
line 597: | |
line 598: " vim:set ft=vim sw=2 sts=2 et: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-surround/plugin/surround.vim | |
Searching for "/Users/nhooyr/.fzf/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.fzf/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.fzf/plugin/fzf.vim" | |
line 1: " Copyright (c) 2015 Junegunn Choi | |
line 2: " | |
line 3: " MIT License | |
line 4: " | |
line 5: " Permission is hereby granted, free of charge, to any person obtaining | |
line 6: " a copy of this software and associated documentation files (the | |
line 7: " "Software"), to deal in the Software without restriction, including | |
line 8: " without limitation the rights to use, copy, modify, merge, publish, | |
line 9: " distribute, sublicense, and/or sell copies of the Software, and to | |
line 10: " permit persons to whom the Software is furnished to do so, subject to | |
line 11: " the following conditions: | |
line 12: " | |
line 13: " The above copyright notice and this permission notice shall be | |
line 14: " included in all copies or substantial portions of the Software. | |
line 15: " | |
line 16: " THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
line 17: " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
line 18: " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
line 19: " NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
line 20: " LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
line 21: " OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
line 22: " WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
line 23: | |
line 24: let s:default_height = '40%' | |
line 25: let s:fzf_go = expand('<sfile>:h:h').'/bin/fzf' | |
line 26: let s:install = expand('<sfile>:h:h').'/install' | |
line 27: let s:installed = 0 | |
line 28: let s:fzf_tmux = expand('<sfile>:h:h').'/bin/fzf-tmux' | |
line 29: | |
line 30: let s:cpo_save = &cpo | |
line 31: set cpo&vim | |
line 32: | |
line 33: function! s:fzf_exec() | |
line 54: | |
line 55: function! s:tmux_not_zoomed() | |
line 58: | |
line 59: function! s:tmux_enabled() | |
line 75: | |
line 76: function! s:shellesc(arg) | |
line 79: | |
line 80: function! s:escape(path) | |
line 83: | |
line 84: " Upgrade legacy options | |
line 85: function! s:upgrade(dict) | |
line 98: | |
line 99: function! s:error(msg) | |
line 104: | |
line 105: function! s:warn(msg) | |
line 110: | |
line 111: function! fzf#run(...) abort | |
Searching for "autoload/fzf.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nhooyr | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/autoload/fzf.vim" | |
Searching for "/etc/xdg/nvim/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/fzf.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/fzf.vim" | |
Searching for "/usr/share/nvim/site/autoload/fzf.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/fzf.vim" | |
Searching for "/usr/share/nvim/site/after/autoload/fzf.vim" | |
Searching for "/usr/local/share/nvim/site/after/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/autoload/fzf.vim" | |
Searching for "/etc/xdg/nvim/after/autoload/fzf.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/autoload/fzf.vim" | |
not found in 'runtimepath': "autoload/fzf.vim" | |
line 161: | |
line 162: function! s:present(dict, ...) | |
line 170: | |
line 171: function! s:fzf_tmux(dict) | |
line 188: | |
line 189: function! s:splittable(dict) | |
line 192: | |
line 193: function! s:pushd(dict) | |
line 206: | |
line 207: function! s:popd(dict) | |
line 212: | |
line 213: function! s:xterm_launcher() | |
line 222: unlet! s:launcher | |
line 223: let s:launcher = function('s:xterm_launcher') | |
line 224: | |
line 225: function! s:exit_handler(code, command, ...) | |
line 237: | |
line 238: function! s:execute(dict, command, temps) | |
line 253: | |
line 254: function! s:execute_tmux(dict, command, temps) | |
line 265: | |
line 266: function! s:calc_size(max, val, dict) | |
line 282: | |
line 283: function! s:getpos() | |
line 286: | |
line 287: function! s:split(dict) | |
line 318: | |
line 319: function! s:execute_term(dict, command, temps) | |
line 364: | |
line 365: function! s:callback(dict, temps) | |
line 396: | |
line 401: let s:default_action = { 'ctrl-m': 'e', 'ctrl-t': 'tab split', 'ctrl-x': 'split', 'ctrl-v': 'vsplit' } | |
line 402: | |
line 403: function! s:cmd_callback(lines) abort | |
line 429: | |
line 430: function! s:cmd(bang, ...) abort | |
line 442: | |
line 443: command! -nargs=* -complete=dir -bang FZF call s:cmd(<bang>0, <f-args>) | |
line 444: | |
line 445: let &cpo = s:cpo_save | |
line 446: unlet s:cpo_save | |
line 447: | |
finished sourcing /Users/nhooyr/.fzf/plugin/fzf.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/plugin/**/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/plugin/**/*.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/quick-scope/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/quick-scope/plugin/quick_scope.vim" | |
line 1: " Initialize ----------------------------------------------------------------- | |
line 2: let s:plugin_name = "quick-scope" | |
line 3: | |
line 4: if exists('g:loaded_quick_scope') | |
line 5: finish | |
line 6: endif | |
line 7: | |
line 8: let g:loaded_quick_scope = 1 | |
line 9: | |
line 10: if &compatible | |
line 11: echoerr s:plugin_name . " won't load in Vi-compatible mode." | |
line 12: finish | |
line 13: endif | |
line 14: | |
line 15: if v:version < 701 || (v:version == 701 && !has('patch040')) | |
line 16: echoerr s:plugin_name . " requires Vim running in version 7.1.040 or later." | |
line 17: finish | |
line 18: endif | |
line 19: | |
line 20: unlet! s:plugin_name | |
line 21: | |
line 22: " Save cpoptions and reassign them later. See :h use-cpo-save. | |
line 23: let s:cpo_save = &cpo | |
line 24: set cpo&vim | |
line 25: | |
line 26: " Autocommands --------------------------------------------------------------- | |
line 27: augroup quick_scope | |
line 28: autocmd! | |
line 29: autocmd ColorScheme * call s:set_highlight_colors() | |
line 30: augroup END | |
line 31: | |
line 32: " Options -------------------------------------------------------------------- | |
line 33: if !exists('g:qs_enable') | |
line 34: let g:qs_enable = 1 | |
line 35: endif | |
line 36: | |
line 37: " Change this to an option for a future update... | |
line 38: if !exists('s:accepted_chars') | |
line 39: " Keys correspond to characters that can be highlighted. Values aren't used. | |
line 40: let s:accepted_chars = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0, 'h': 0, 'i': 0, 'j': 0, 'k': 0, 'l': 0, 'm': 0, 'n': 0, 'o': 0, 'p': 0, 'q': 0, 'r': 0, 's': 0, 't': 0, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0, 'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 0, 'I': 0, 'J': 0, 'K': 0, 'L': 0, 'M': 0, 'N': 0, 'O': 0, 'P': 0, 'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 0, 'V': 0, 'W': 0, 'X': 0, 'Y': 0, 'Z': 0, '0': 0, '1': 0, '2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0, '9': 0,} | |
line 41: endif | |
line 42: | |
line 43: if !exists('g:qs_highlight_on_keys') | |
line 44: " Vanilla mode. Highlight on cursor movement. | |
line 45: augroup quick_scope | |
line 46: autocmd CursorMoved,InsertLeave,ColorScheme * call s:unhighlight_line() | call s:highlight_line(2, s:accepted_chars) | |
line 47: autocmd InsertEnter * call s:unhighlight_line() | |
line 48: augroup END | |
line 49: else | |
line 50: " Highlight on key press. Set an 'augmented' mapping for each defined key. | |
line 51: for motion in filter(g:qs_highlight_on_keys, 'v:val =~# "^[fFtT]$"') | |
line 52: execute printf('noremap <unique> <silent> <expr> %s <sid>ready() . <sid>aim("%s") . <sid>reload() . <sid>double_tap()', motion, motion) | |
line 52: noremap <unique> <silent> <expr> f <sid>ready() . <sid>aim("f") . <sid>reload() . <sid>double_tap() | |
line 53: endfor | |
line 51: for motion in filter(g:qs_highlight_on_keys, 'v:val =~# "^[fFtT]$"') | |
line 52: execute printf('noremap <unique> <silent> <expr> %s <sid>ready() . <sid>aim("%s") . <sid>reload() . <sid>double_tap()', motion, motion) | |
line 52: noremap <unique> <silent> <expr> F <sid>ready() . <sid>aim("F") . <sid>reload() . <sid>double_tap() | |
line 53: endfor | |
line 51: for motion in filter(g:qs_highlight_on_keys, 'v:val =~# "^[fFtT]$"') | |
line 52: execute printf('noremap <unique> <silent> <expr> %s <sid>ready() . <sid>aim("%s") . <sid>reload() . <sid>double_tap()', motion, motion) | |
line 52: noremap <unique> <silent> <expr> t <sid>ready() . <sid>aim("t") . <sid>reload() . <sid>double_tap() | |
line 53: endfor | |
line 51: for motion in filter(g:qs_highlight_on_keys, 'v:val =~# "^[fFtT]$"') | |
line 52: execute printf('noremap <unique> <silent> <expr> %s <sid>ready() . <sid>aim("%s") . <sid>reload() . <sid>double_tap()', motion, motion) | |
line 52: noremap <unique> <silent> <expr> T <sid>ready() . <sid>aim("T") . <sid>reload() . <sid>double_tap() | |
line 53: endfor | |
line 51: for motion in filter(g:qs_highlight_on_keys, 'v:val =~# "^[fFtT]$"') | |
line 52: execute printf('noremap <unique> <silent> <expr> %s <sid>ready() . <sid>aim("%s") . <sid>reload() . <sid>double_tap()', motion, motion) | |
line 53: endfor | |
line 54: endif | |
line 55: | |
line 56: " User commands -------------------------------------------------------------- | |
line 57: function! s:toggle() | |
line 66: | |
line 67: command! -nargs=0 QuickScopeToggle call s:toggle() | |
line 68: | |
line 69: " Plug mappings -------------------------------------------------------------- | |
line 70: nnoremap <silent> <plug>(QuickScopeToggle) :call <sid>toggle()<cr> | |
line 71: vnoremap <silent> <plug>(QuickScopeToggle) :<c-u>call <sid>toggle()<cr> | |
line 72: | |
line 73: " Colors --------------------------------------------------------------------- | |
line 74: " Detect if the running instance of Vim acts as a GUI or terminal. | |
line 75: function! s:get_term() | |
line 84: | |
line 85: " Called when no color configurations are set. Choose default colors for | |
line 86: " highlighting. | |
line 87: function! s:set_default_color(group, co_gui, co_256, co_16) | |
line 110: | |
line 111: " Set or append to a custom highlight group. | |
line 112: function! s:add_to_highlight_group(group, attr, color) | |
line 115: | |
line 116: " Set the colors used for highlighting. | |
line 117: function! s:set_highlight_colors() | |
line 159: | |
line 160: call s:set_highlight_colors() | |
calling function <SNR>31_set_highlight_colors() | |
line 1: " Priority for overruling other highlight matches. | |
line 2: let s:priority = 1 | |
line 3: | |
line 4: " Highlight group marking first appearance of characters in a line. | |
line 5: let s:hi_group_primary = 'QuickScopePrimary' | |
line 6: let s:hi_group_secondary = 'QuickScopeSecondary' | |
line 7: | |
line 8: " Highlight group marking dummy cursor when quick-scope is enabled on key | |
line 9: " press. | |
line 10: let s:hi_group_cursor = 'QuickScopeCursor' | |
line 11: | |
line 12: if !exists('g:qs_first_occurrence_highlight_color') | |
line 13: " set color to match 'Function' highlight group or lime green | |
line 14: let s:primary_highlight_color = s:set_default_color('Function', '#afff5f', 155, 10) | |
line 15: else | |
line 16: let s:primary_highlight_color = g:qs_first_occurrence_highlight_color | |
line 17: endif | |
line 18: | |
line 19: if !exists('g:qs_second_occurrence_highlight_color') | |
line 20: " set color to match 'Keyword' highlight group or cyan | |
line 21: let s:secondary_highlight_color = s:set_default_color('Define', '#5fffff', 81, 14) | |
line 22: else | |
line 23: let s:secondary_highlight_color = g:qs_second_occurrence_highlight_color | |
line 24: endif | |
line 25: | |
line 26: call s:add_to_highlight_group(s:hi_group_primary, '', 'underline') | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group('QuickScopePrimary', '', 'underline') | |
line 1: execute printf("highlight %s %s%s=%s", a:group, s:get_term(), a:attr, a:color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term() | |
line 1: if has('gui_running') || (has('nvim') && $NVIM_TUI_ENABLE_TRUE_COLOR) | |
line 2: let term = 'gui' | |
line 3: else | |
line 4: let term ='cterm' | |
line 5: endif | |
line 6: | |
line 7: return term | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term returning 'cterm' | |
continuing in function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group | |
line 1: highlight QuickScopePrimary cterm=underline | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group returning #0 | |
continuing in function <SNR>31_set_highlight_colors | |
line 27: call s:add_to_highlight_group(s:hi_group_primary, 'fg', s:primary_highlight_color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group('QuickScopePrimary', 'fg', 2) | |
line 1: execute printf("highlight %s %s%s=%s", a:group, s:get_term(), a:attr, a:color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term() | |
line 1: if has('gui_running') || (has('nvim') && $NVIM_TUI_ENABLE_TRUE_COLOR) | |
line 2: let term = 'gui' | |
line 3: else | |
line 4: let term ='cterm' | |
line 5: endif | |
line 6: | |
line 7: return term | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term returning 'cterm' | |
continuing in function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group | |
line 1: highlight QuickScopePrimary ctermfg=2 | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group returning #0 | |
continuing in function <SNR>31_set_highlight_colors | |
line 28: call s:add_to_highlight_group(s:hi_group_secondary, '', 'underline') | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group('QuickScopeSecondary', '', 'underline') | |
line 1: execute printf("highlight %s %s%s=%s", a:group, s:get_term(), a:attr, a:color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term() | |
line 1: if has('gui_running') || (has('nvim') && $NVIM_TUI_ENABLE_TRUE_COLOR) | |
line 2: let term = 'gui' | |
line 3: else | |
line 4: let term ='cterm' | |
line 5: endif | |
line 6: | |
line 7: return term | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term returning 'cterm' | |
continuing in function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group | |
line 1: highlight QuickScopeSecondary cterm=underline | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group returning #0 | |
continuing in function <SNR>31_set_highlight_colors | |
line 29: call s:add_to_highlight_group(s:hi_group_secondary, 'fg', s:secondary_highlight_color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group('QuickScopeSecondary', 'fg', 1) | |
line 1: execute printf("highlight %s %s%s=%s", a:group, s:get_term(), a:attr, a:color) | |
calling function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term() | |
line 1: if has('gui_running') || (has('nvim') && $NVIM_TUI_ENABLE_TRUE_COLOR) | |
line 2: let term = 'gui' | |
line 3: else | |
line 4: let term ='cterm' | |
line 5: endif | |
line 6: | |
line 7: return term | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group..<SNR>31_get_term returning 'cterm' | |
continuing in function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group | |
line 1: highlight QuickScopeSecondary ctermfg=1 | |
function <SNR>31_set_highlight_colors..<SNR>31_add_to_highlight_group returning #0 | |
continuing in function <SNR>31_set_highlight_colors | |
line 30: execute printf("highlight link %s Cursor", s:hi_group_cursor) | |
line 30: highlight link QuickScopeCursor Cursor | |
line 31: | |
line 32: " Preserve the background color of cursorline if it exists. | |
line 33: if &cursorline | |
line 34: let bg_color = synIDattr(synIDtrans(hlID('CursorLine')), 'bg', s:get_term()) | |
line 35: | |
line 36: if bg_color != -1 | |
line 37: call s:add_to_highlight_group(s:hi_group_primary, 'bg', bg_color) | |
line 38: call s:add_to_highlight_group(s:hi_group_secondary, 'bg', bg_color) | |
line 39: endif | |
line 40: endif | |
function <SNR>31_set_highlight_colors returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/quick-scope/plugin/quick_scope.vim | |
line 161: | |
line 162: " Main highlighting functions ------------------------------------------------ | |
line 163: " Apply the highlights for each highlight group based on pattern strings. | |
line 164: " | |
line 165: " Arguments are expected to be lists of two items. | |
line 166: function! s:apply_highlight_patterns(patterns) | |
line 178: | |
line 179: " Keep track of which characters have a secondary highlight (but no primary | |
line 180: " highlight) and store them in :chars_s. Used when g:qs_highlight_on_keys is | |
line 181: " active to decide whether to trigger an extra highlight. | |
line 182: function! s:save_chars_with_secondary_highlights(chars) | |
line 191: | |
line 192: " Set or append to the pattern strings for the highlights. | |
line 193: function! s:add_to_highlight_patterns(patterns, highlights) | |
line 207: | |
line 208: " Finds which characters to highlight and returns their column positions as a | |
line 209: " pattern string. | |
line 210: function! s:get_highlight_patterns(line, start, end, targets) | |
line 298: | |
line 299: " The direction can be 0 (backward), 1 (forward) or 2 (both). Targets are the | |
line 300: " characters that can be highlighted. | |
line 301: function! s:highlight_line(direction, targets) | |
line 325: | |
line 326: function! s:unhighlight_line() | |
line 331: | |
line 332: " Highlight on key press ----------------------------------------------------- | |
line 333: " Manage state for keeping or removing the extra highlight after triggering a | |
line 334: " highlight on key press. | |
line 335: " | |
line 336: " State can be 0 (extra highlight has just been triggered), 1 (the cursor has | |
line 337: " moved while an extra highlight is active), or 2 (cancel an active extra | |
line 338: " highlight). | |
line 339: function! s:handle_extra_highlight(state) | |
line 354: | |
line 355: " Set or reset flags and state for highlighting on key press. | |
line 356: function! s:ready() | |
line 379: | |
line 380: " Returns {character motion}{captured char} (to map to a character motion) to | |
line 381: " emulate one as closely as possible. | |
line 382: function! s:aim(motion) | |
line 415: | |
line 416: " Cleanup after a character motion is executed. | |
line 417: function! s:reload() | |
line 434: | |
line 435: " Trigger an extra highlight for a target character only if it originally had | |
line 436: " a secondary highlight. | |
line 437: function! s:double_tap() | |
line 468: | |
line 469: let &cpo = s:cpo_save | |
line 470: unlet s:cpo_save | |
finished sourcing /Users/nhooyr/.nvim/plugged/quick-scope/plugin/quick_scope.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-superman/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-superman/plugin/superman.vim" | |
line 1: " Name: SuperMan man pages | |
line 2: " Author: Jacob Zimmerman <[email protected]> | |
line 3: " License: MIT License | |
line 4: " | |
line 5: " URL: <https://github.com/jez/vim-superman> | |
line 6: " | |
line 7: " Created: Dec 20 2014 | |
line 8: " Modified: Feb 02 2015 | |
line 9: | |
line 10: " Wrapper around man.vim's Man command | |
line 11: function! superman#SuperMan(...) | |
Searching for "autoload/superman.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/n | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/delimitMate/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-startify/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/emmet-vim/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-surround/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.fzf/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-repeat/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/Apprentice/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/quick-scope/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-superman/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/autoload/superman.vim" | |
Searching for "/etc/xdg/nvim/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/autoload/superman.vim" | |
Searching for "/usr/local/share/nvim/site/autoload/superman.vim" | |
Searching for "/usr/share/nvim/site/autoload/superman.vim" | |
Searching for "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/autoload/superman.vim" | |
Searching for "/usr/share/nvim/site/after/autoload/superman.vim" | |
Searching for "/usr/local/share/nvim/site/after/autoload/superman.vim" | |
Searching for "/Users/nhooyr/.local/share/nvim/site/after/autoload/superman.vim" | |
Searching for "/etc/xdg/nvim/after/autoload/superman.vim" | |
Searching for "/Users/nhooyr/dotfiles/nvim/after/autoload/superman.vim" | |
not found in 'runtimepath': "autoload/superman.vim" | |
line 46: | |
line 47: " Command alias for our function | |
line 48: command! -nargs=+ SuperMan call superman#SuperMan(<f-args>) | |
line 49: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-superman/plugin/superman.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/LanguageTool/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/LanguageTool/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/LanguageTool/plugin/LanguageTool.vim" | |
line 1: " LanguageTool: Grammar checker in Vim for English, French, German, etc. | |
line 2: " Maintainer: Dominique Pellé <[email protected]> | |
line 3: " Screenshots: http://dominique.pelle.free.fr/pic/LanguageToolVimPlugin_en.png | |
line 4: " http://dominique.pelle.free.fr/pic/LanguageToolVimPlugin_fr.png | |
line 5: " Last Change: 2014/02/20 | |
line 6: " Version: 1.28 | |
line 7: " | |
line 8: " Long Description: {{{1 | |
line 9: " | |
line 10: " This plugin integrates the LanguageTool grammar checker into Vim. | |
line 11: " Current version of LanguageTool can check grammar in many languages: | |
line 12: " ast, be, br, ca, da, de, el, en, eo, es, fr, gl, is, it, km, lt, ml, nl, | |
line 13: " pl, pt, ro, ru, sk, sl, sv, tl, uk, zh. | |
line 14: " | |
line 15: " See doc/LanguageTool.txt for more details about how to use the | |
line 16: " LanguageTool plugin. | |
line 17: " | |
line 18: " See http://www.languagetool.org/ for more information about LanguageTool. | |
line 19: " | |
line 20: " License: {{{1 | |
line 21: " | |
line 22: " The VIM LICENSE applies to LanguageTool.vim plugin | |
line 23: " (see ":help copyright" except use "LanguageTool.vim" instead of "Vim"). | |
line 24: " | |
line 25: " Plugin set up {{{1 | |
line 26: if &cp || exists("g:loaded_languagetool") | |
line 27: finish | |
line 28: endif | |
line 29: let g:loaded_languagetool = "1" | |
line 30: | |
line 31: " Guess language from 'a:lang' (either 'spelllang' or 'v:lang') | |
line 32: function s:FindLanguage(lang) "{{{1 | |
line 90: | |
line 91: " Return a regular expression used to highlight a grammatical error | |
line 92: " at line a:line in text. The error starts at character a:start in | |
line 93: " context a:context and its length in context is a:len. | |
line 94: function s:LanguageToolHighlightRegex(line, context, start, len) "{{{1 | |
line 110: | |
line 111: " Unescape XML special characters in a:text. | |
line 112: function s:XmlUnescape(text) "{{{1 | |
line 123: | |
line 124: " Parse a xml attribute such as: ruleId="FOO" in line a:line. | |
line 125: " where ruleId is the key a:key, and FOO is the returned value corresponding | |
line 126: " to that key. | |
line 127: function s:ParseKeyValue(key, line) "{{{1 | |
line 130: | |
line 131: " Set up configuration. | |
line 132: " Returns 0 if success, < 0 in case of error. | |
line 133: function s:LanguageToolSetUp() "{{{1 | |
line 178: | |
line 179: " Jump to a grammar mistake (called when pressing <Enter> | |
line 180: " on a particular error in scratch buffer). | |
line 181: function <sid>JumpToCurrentError() "{{{1 | |
line 209: | |
line 210: " This function performs grammar checking of text in the current buffer. | |
line 211: " It highlights grammar mistakes in current buffer and opens a scratch | |
line 212: " window with all errors found. It also populates the location-list of | |
line 213: " the window with all errors. | |
line 214: " a:line1 and a:line2 parameters are the first and last line number of | |
line 215: " the range of line to check. | |
line 216: " Returns 0 if success, < 0 in case of error. | |
line 217: function s:LanguageToolCheck(line1, line2) "{{{1 | |
line 360: | |
line 361: " This function clears syntax highlighting created by LanguageTool plugin | |
line 362: " and removes the scratch window containing grammar errors. | |
line 363: function s:LanguageToolClear() "{{{1 | |
line 382: | |
line 383: hi def link LanguageToolCmd Comment | |
line 384: hi def link LanguageToolLabel Label | |
line 385: hi def link LanguageToolLabelMoreInfo Label | |
line 386: hi def link LanguageToolGrammarError Error | |
line 387: hi def link LanguageToolSpellingError WarningMsg | |
line 388: hi def link LanguageToolErrorCount Title | |
line 389: hi def link LanguageToolUrl Underlined | |
line 390: | |
line 391: " Section: Menu items {{{1 | |
line 392: if has("gui_running") && has("menu") && &go =~ 'm' | |
line 393: amenu <silent> &Plugin.LanguageTool.Chec&k :LanguageToolCheck<CR> | |
line 394: amenu <silent> &Plugin.LanguageTool.Clea&r :LanguageToolClear<CR> | |
line 395: endif | |
line 396: | |
line 397: " Defines commands {{{1 | |
line 398: com! -nargs=0 LanguageToolClear :call s:LanguageToolClear() | |
line 400: com! -nargs=0 -range=% LanguageToolCheck :call s:LanguageToolCheck(<line1>, <line2>) | |
line 401: " vim: fdm=marker | |
finished sourcing /Users/nhooyr/.nvim/plugged/LanguageTool/plugin/LanguageTool.vim | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-over/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-over/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/Users/nhooyr/.nvim/plugged/vim-over/plugin/over.vim" | |
line 1: scriptencoding utf-8 | |
line 2: if exists('g:loaded_over') | |
line 3: finish | |
line 4: endif | |
line 5: let g:loaded_over = 1 | |
line 6: | |
line 7: let s:save_cpo = &cpo | |
line 8: set cpo&vim | |
line 9: | |
line 10: | |
line 11: let g:over_enable_auto_nohlsearch = get(g:, "over_enable_auto_nohlsearch", 1) | |
line 12: let g:over_enable_cmd_window = get(g:, "over_enable_cmd_window", 1) | |
line 13: let g:over_command_line_prompt = get(g:, "over_command_line_prompt", "> ") | |
line 14: let g:over_command_line_key_mappings = get(g:, "over_command_line_key_mappings", {}) | |
line 15: | |
line 16: | |
line 17: augroup plugin-over | |
line 18: ^Iautocmd! | |
line 19: ^Iautocmd CmdwinEnter * if g:over_enable_cmd_window | call over#setup() | endif | |
line 20: ^Iautocmd CmdwinLeave * if g:over_enable_cmd_window | call over#unsetup() | endif | |
line 21: augroup END | |
line 22: | |
line 23: | |
line 30: command! -range -nargs=*^IOverCommandLine^Icall over#command_line(^I^Ig:over_command_line_prompt,^I^I<line1> != <line2> ? printf("'<,'>%s", <q-args>) : <q-args>,^I^I{ "line1" : <line1>, "line2" : <line2> }^I) | |
line 31: | |
line 32: | |
line 33: function! s:key_mapping(lhs, rhs, noremap) | |
line 39: | |
line 40: function! s:as_keymapping(key) | |
line 44: | |
line 45: function! s:unmapping(key) | |
line 49: | |
line 52: command! -nargs=*^IOverCommandLineNoremap^Icall call("s:key_mapping", map([<f-args>], "s:as_keymapping(v:val)") + [1]) | |
line 53: | |
line 56: command! -nargs=*^IOverCommandLineMap^Icall call("s:key_mapping", map([<f-args>], "s:as_keymapping(v:val)") + [0]) | |
line 57: | |
line 59: command! -nargs=*^IOverCommandLineUnmap call s:unmapping(<q-args>) | |
line 60: | |
line 61: | |
line 62: let &cpo = s:save_cpo | |
line 63: unlet s:save_cpo | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-over/plugin/over.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/0.1.0/share/nvim/runtime/plugin/**/*.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin/getscriptPlugin.vim" | |
line 1: " --------------------------------------------------------------------- | |
line 2: " getscriptPlugin.vim | |
line 3: " Author:^ICharles E. Campbell | |
line 4: " Date:^INov 29, 2013 | |
line 5: " Installing:^I:help glvs-install | |
line 6: " Usage:^I:help glvs | |
line 7: " | |
line 8: " GetLatestVimScripts: 642 1 :AutoInstall: getscript.vim | |
line 9: " | |
line 10: " (Rom 15:11 WEB) Again, "Praise the Lord, all you Gentiles! Let | |
line 11: " all the peoples praise Him." | |
line 12: " --------------------------------------------------------------------- | |
line 13: " Initialization:^I{{{1 | |
line 14: " if you're sourcing this file, surely you can't be | |
line 15: " expecting vim to be in its vi-compatible mode | |
line 16: if exists("g:loaded_getscriptPlugin") | |
line 17: finish | |
line 18: endif | |
line 19: if &cp | |
line 20: if &verbose | |
line 21: echo "GetLatestVimScripts is not vi-compatible; not loaded (you need to set nocp)" | |
line 22: endif | |
line 23: finish | |
line 24: endif | |
line 25: let g:loaded_getscriptPlugin = "v36" | |
line 26: let s:keepcpo = &cpo | |
line 27: set cpo&vim | |
line 28: | |
line 29: " --------------------------------------------------------------------- | |
line 30: " Public Interface: {{{1 | |
line 31: com! -nargs=0 GetLatestVimScripts call getscript#GetLatestVimScripts() | |
line 32: com! -nargs=0 GetScripts call getscript#GetLatestVimScripts() | |
line 33: silent! com -nargs=0 GLVS call getscript#GetLatestVimScripts() | |
line 34: | |
line 35: " --------------------------------------------------------------------- | |
line 36: " Restore Options: {{{1 | |
line 37: let &cpo= s:keepcpo | |
line 38: unlet s:keepcpo | |
line 39: | |
line 40: " --------------------------------------------------------------------- | |
line 41: " vim: ts=8 sts=2 fdm=marker nowrap | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin/getscriptPlugin.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/gzip.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/man.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/matchit.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/matchparen.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/netrwPlugin.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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() | |
calling function remote#host#LoadRemotePlugins() | |
line 1: if filereadable(s:remote_plugins_manifest) | |
line 2: exe 'source '.s:remote_plugins_manifest | |
line 3: endif | |
function remote#host#LoadRemotePlugins returning #0 | |
continuing in /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin/rplugin.vim | |
finished sourcing /usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin/rplugin.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/rrhelper.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/spellfile.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/tarPlugin.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/tohtml.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/tutor.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/share/nvim/runtime/plugin/vimballPlugin.vim | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime/plugin) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
sourcing "/usr/local/Cellar/neovim/0.1.0/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/0.1.0/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 "/Users/nhooyr/dotfiles/nvim/after/plugin/**/*.vim" | |
Reading ShaDa file "/Users/nhooyr/.local/share/nvim/shada/main.shada" info marks oldfiles | |
Executing BufWinEnter Auto commands for "*" | |
autocommand call neomake#ProcessCurrentBuffer() | |
line 0: call neomake#ProcessCurrentBuffer() | |
Searching for "autoload/neomake.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Users/nh | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/neomake.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/neomake.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/neomake/autoload) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 0: sourcing "/Users/nhooyr/.nvim/plugged/neomake/autoload/neomake.vim" | |
line 1: " vim: ts=4 sw=4 et | |
line 2: scriptencoding utf-8 | |
line 3: | |
line 4: let s:make_id = 1 | |
line 5: let s:jobs = {} | |
line 6: let s:jobs_by_maker = {} | |
line 7: let s:job_output_by_buffer = {} | |
line 11: let s:current_errors = { 'project': {}, 'file': {} } | |
line 15: let s:need_errors_cleaning = { 'project': 1, 'file': {} } | |
line 16: | |
line 17: function! neomake#ListJobs() abort | |
line 23: | |
line 24: function! s:JobStart(make_id, exe, ...) abort | |
line 49: | |
line 50: function! s:GetMakerKey(maker) abort | |
line 53: | |
line 54: function! neomake#MakeJob(maker) abort | |
line 104: | |
line 105: function! neomake#GetMaker(name_or_maker, ...) abort | |
line 179: | |
line 180: function! neomake#GetEnabledMakers(...) abort | |
line 212: | |
line 213: function! neomake#Make(options) abort | |
line 282: | |
line 283: function! s:AddExprCallback(maker) abort | |
line 356: | |
line 357: function! s:CleanJobinfo(jobinfo) abort | |
line 365: | |
line 366: function! s:ProcessJobOutput(maker, lines) abort | |
line 383: | |
line 384: function! neomake#ProcessCurrentBuffer() abort | |
line 394: | |
line 395: function! s:RegisterJobOutput(jobinfo, maker, lines) abort | |
line 421: | |
line 422: function! neomake#MakeHandler(job_id, data, event_type) abort | |
line 508: | |
line 509: function! neomake#CleanOldProjectSignsAndErrors() abort | |
line 519: | |
line 520: function! neomake#CleanOldFileSignsAndErrors(bufnr) abort | |
line 530: | |
line 531: function! neomake#CleanOldErrors(bufnr, type) abort | |
line 533: | |
line 534: function! neomake#EchoCurrentError() abort | |
line 567: | |
line 568: function! neomake#CursorMoved() abort | |
line 572: | |
line 573: function! neomake#CompleteMakers(ArgLead, CmdLine, CursorPos) | |
finished sourcing /Users/nhooyr/.nvim/plugged/neomake/autoload/neomake.vim | |
continuing in BufWinEnter Auto commands for "*" | |
calling function neomake#ProcessCurrentBuffer() | |
line 1: let buf = bufnr('%') | |
line 2: if has_key(s:job_output_by_buffer, buf) | |
line 3: for output in s:job_output_by_buffer[buf] | |
line 4: call s:ProcessJobOutput(output.maker, output.lines) | |
line 5: endfor | |
line 6: unlet s:job_output_by_buffer[buf] | |
line 7: endif | |
line 8: call neomake#signs#PlaceVisibleSigns() | |
Searching for "autoload/neomake/signs.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/Us | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/neomake/signs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/neomake/signs.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/neomake/autoload/neomake) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 8: sourcing "/Users/nhooyr/.nvim/plugged/neomake/autoload/neomake/signs.vim" | |
line 1: " vim: ts=4 sw=4 et | |
line 2: | |
line 3: function! s:InitSigns() abort | |
line 25: call s:InitSigns() | |
calling function <SNR>50_InitSigns() | |
line 1: let s:sign_queue = { 'project': {}, 'file': {} } | |
line 5: let s:last_placed_signs = { 'project': {}, 'file': {} } | |
line 9: let s:placed_signs = { 'project': {}, 'file': {} } | |
line 13: let s:sign_queue = { 'project': {}, 'file': {} } | |
line 17: let s:neomake_sign_id = { 'project': {}, 'file': {} } | |
function <SNR>50_InitSigns returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/neomake/autoload/neomake/signs.vim | |
line 26: | |
line 27: " Reset signs placed by a :Neomake! call | |
line 28: " (resettting signs means the current signs will be deleted on the next call to ResetProject) | |
line 29: function! neomake#signs#ResetProject() abort | |
line 37: | |
line 38: " Reset signs placed by a :Neomake call in a buffer | |
line 39: function! neomake#signs#ResetFile(bufnr) abort | |
line 47: | |
line 48: function! neomake#signs#Reset(bufnr, type) abort | |
line 54: | |
line 55: " type may be either 'file' or 'project' | |
line 56: function! neomake#signs#RegisterSign(entry, type) abort | |
line 63: | |
line 64: " type may be either 'file' or 'project' | |
line 65: function! neomake#signs#PlaceSign(entry, type) abort | |
line 90: | |
line 91: function! neomake#signs#CleanAllOldSigns(type) abort | |
line 97: | |
line 98: " type may be either 'file' or 'project' | |
line 99: function! neomake#signs#CleanOldSigns(bufnr, type) abort | |
line 111: | |
line 112: function! neomake#signs#PlaceVisibleSigns() abort | |
line 131: | |
line 132: exe 'sign define neomake_invisible' | |
line 132: sign define neomake_invisible | |
line 133: | |
line 134: function! neomake#signs#RedefineSign(name, opts) | |
line 149: | |
line 150: function! neomake#signs#RedefineErrorSign(...) | |
line 161: | |
line 162: function! neomake#signs#RedefineWarningSign(...) | |
line 173: | |
line 174: let s:signs_defined = 0 | |
line 175: function! neomake#signs#DefineSigns() | |
finished sourcing /Users/nhooyr/.nvim/plugged/neomake/autoload/neomake/signs.vim | |
continuing in function neomake#ProcessCurrentBuffer | |
calling function neomake#ProcessCurrentBuffer..neomake#signs#PlaceVisibleSigns() | |
line 1: for type in ['file', 'project'] | |
line 2: let buf = bufnr('%') | |
line 3: if !has_key(s:sign_queue[type], buf) | |
line 4: continue | |
line 1: for type in ['file', 'project'] | |
line 2: let buf = bufnr('%') | |
line 3: if !has_key(s:sign_queue[type], buf) | |
line 4: continue | |
line 1: for type in ['file', 'project'] | |
line 2: let buf = bufnr('%') | |
line 3: if !has_key(s:sign_queue[type], buf) | |
line 4: continue | |
line 5: endif | |
line 6: let topline = line('w0') | |
line 7: let botline = line('w$') | |
line 8: for ln in range(topline, botline) | |
line 9: if has_key(s:sign_queue[type][buf], ln) | |
line 10: call neomake#signs#PlaceSign(s:sign_queue[type][buf][ln], type) | |
line 11: unlet s:sign_queue[type][buf][ln] | |
line 12: endif | |
line 13: endfor | |
line 14: if empty(s:sign_queue[type][buf]) | |
line 15: unlet s:sign_queue[type][buf] | |
line 16: endif | |
line 17: endfor | |
function neomake#ProcessCurrentBuffer..neomake#signs#PlaceVisibleSigns returning #0 | |
continuing in function neomake#ProcessCurrentBuffer | |
function neomake#ProcessCurrentBuffer returning #0 | |
continuing in BufWinEnter Auto commands for "*" | |
Executing BufWinEnter Auto commands for "*" | |
autocommand if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 | call s:diffoff() | endif | |
line 0: if s:can_diffoff(+expand('<abuf>')) && s:diff_window_count() == 1 | call s:diffoff() | endif | |
calling function <SNR>15_can_diffoff(1) | |
line 1: return getwinvar(bufwinnr(a:buf), '&diff') && !empty(getbufvar(a:buf, 'git_dir')) && !empty(getwinvar(bufwinnr(a:buf), 'fugitive_diff_restore')) | |
function <SNR>15_can_diffoff returning #0 | |
continuing in BufWinEnter Auto commands for "*" | |
line 0: call s:diffoff() | endif | |
line 0: endif | |
Executing BufWinEnter Auto commands for "*" | |
autocommand call <sid>on_window_changed() | |
line 0: call <sid>on_window_changed() | |
calling function <SNR>20_on_window_changed() | |
line 1: if pumvisible() | |
line 2: return | |
line 3: endif | |
line 4: call s:init() | |
calling function <SNR>20_on_window_changed..<SNR>20_init() | |
line 1: if s:airline_initialized | |
line 2: return | |
line 3: endif | |
line 4: let s:airline_initialized = 1 | |
line 5: | |
line 6: call airline#extensions#load() | |
Searching for "autoload/airline/extensions.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/afte | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 6: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:ext = {} | |
line 5: let s:ext._theme_funcrefs = [] | |
line 6: | |
line 7: function! s:ext.add_statusline_func(name) dict | |
line 10: function! s:ext.add_statusline_funcref(function) dict | |
line 13: function! s:ext.add_inactive_statusline_func(name) dict | |
line 16: function! s:ext.add_theme_func(name) dict | |
line 19: | |
line 20: let s:script_path = tolower(resolve(expand('<sfile>:p:h'))) | |
line 21: | |
line 29: let s:filetype_overrides = { 'nerdtree': [ 'NERD', '' ], 'gundo': [ 'Gundo', '' ], 'vimfiler': [ 'vimfiler', '%{vimfiler#get_status_string()}' ], 'minibufexpl': [ 'MiniBufExplorer', '' ], 'startify': [ 'startify', '' ], 'vim-plug': [ 'Plugins', '' ], } | |
line 30: | |
line 31: let s:filetype_regex_overrides = {} | |
line 32: | |
line 33: function! s:check_defined_section(name) | |
line 38: | |
line 39: function! airline#extensions#append_to_section(name, value) | |
line 43: | |
line 44: function! airline#extensions#prepend_to_section(name, value) | |
line 48: | |
line 49: function! airline#extensions#apply_left_override(section1, section2) | |
line 56: | |
line 57: let s:active_winnr = -1 | |
line 58: function! airline#extensions#apply(...) | |
line 89: | |
line 90: function! s:is_excluded_window() | |
line 109: | |
line 110: function! airline#extensions#load_theme() | |
line 113: | |
line 114: function! s:sync_active_winnr() | |
line 119: | |
line 120: function! airline#extensions#load() | |
line 257: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load() | |
line 1: " non-trivial number of external plugins use eventignore=all, so we need to account for that | |
line 2: autocmd CursorMoved * call <sid>sync_active_winnr() | |
line 3: | |
line 4: if exists('g:airline_extensions') | |
line 5: for ext in g:airline_extensions | |
line 6: call airline#extensions#{ext}#init(s:ext) | |
line 7: endfor | |
line 8: return | |
line 9: endif | |
line 10: | |
line 11: call airline#extensions#quickfix#init(s:ext) | |
Searching for "autoload/airline/extensions/quickfix.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/quickfix.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/quickfix.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/quickfix.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/quickfix.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/quickfix.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/quickfix.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 11: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/quickfix.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let g:airline#extensions#quickfix#quickfix_text = 'Quickfix' | |
line 5: let g:airline#extensions#quickfix#location_text = 'Location' | |
line 6: | |
line 7: function! airline#extensions#quickfix#apply(...) | |
line 15: | |
line 16: function! airline#extensions#quickfix#init(ext) | |
line 19: | |
line 20: function! s:get_text() | |
line 37: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/quickfix.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call a:ext.add_statusline_func('airline#extensions#quickfix#apply') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1('airline#extensions#quickfix#apply') | |
line 1: call airline#add_statusline_func(a:name) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1..airline#add_statusline_func('airline#extensions#quickfix#apply') | |
line 1: call airline#add_statusline_funcref(function(a:name)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1..airline#add_statusline_func..airline#add_statusline_funcref(function('airline#extensions#quickfix#apply')) | |
line 1: if index(g:airline_statusline_funcrefs, a:function) >= 0 | |
line 2: echohl WarningMsg | |
line 3: echo 'The airline statusline funcref '.string(a:function).' has already been added.' | |
line 4: echohl NONE | |
line 5: return | |
line 6: endif | |
line 7: call add(g:airline_statusline_funcrefs, a:function) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1..airline#add_statusline_func..airline#add_statusline_funcref returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1..airline#add_statusline_func | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1..airline#add_statusline_func returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init..1 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#quickfix#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 12: | |
line 13: if get(g:, 'loaded_unite', 0) | |
line 14: call airline#extensions#unite#init(s:ext) | |
line 15: endif | |
line 16: | |
line 17: if exists(':NetrwSettings') | |
line 18: call airline#extensions#netrw#init(s:ext) | |
Searching for "autoload/airline/extensions/netrw.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvi | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/netrw.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/netrw.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/netrw.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/netrw.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/netrw.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/netrw.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 18: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/netrw.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: if !exists(':NetrwSettings') | |
line 5: finish | |
line 6: endif | |
line 7: | |
line 8: function! airline#extensions#netrw#apply(...) | |
line 22: | |
line 23: function! airline#extensions#netrw#init(ext) | |
line 27: | |
line 28: | |
line 29: function! airline#extensions#netrw#sortstring() | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/netrw.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: let g:netrw_force_overwrite_statusline = 0 | |
line 2: call a:ext.add_statusline_func('airline#extensions#netrw#apply') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1('airline#extensions#netrw#apply') | |
line 1: call airline#add_statusline_func(a:name) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1..airline#add_statusline_func('airline#extensions#netrw#apply') | |
line 1: call airline#add_statusline_funcref(function(a:name)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1..airline#add_statusline_func..airline#add_statusline_funcref(function('airline#extensions#netrw#apply')) | |
line 1: if index(g:airline_statusline_funcrefs, a:function) >= 0 | |
line 2: echohl WarningMsg | |
line 3: echo 'The airline statusline funcref '.string(a:function).' has already been added.' | |
line 4: echohl NONE | |
line 5: return | |
line 6: endif | |
line 7: call add(g:airline_statusline_funcrefs, a:function) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1..airline#add_statusline_func..airline#add_statusline_funcref returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1..airline#add_statusline_func | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1..airline#add_statusline_func returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init..1 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#netrw#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 19: endif | |
line 20: | |
line 21: if get(g:, 'loaded_vimfiler', 0) | |
line 22: let g:vimfiler_force_overwrite_statusline = 0 | |
line 23: endif | |
line 24: | |
line 25: if get(g:, 'loaded_ctrlp', 0) | |
line 26: call airline#extensions#ctrlp#init(s:ext) | |
line 27: endif | |
line 28: | |
line 29: if get(g:, 'ctrlspace_loaded', 0) | |
line 30: call airline#extensions#ctrlspace#init(s:ext) | |
line 31: endif | |
line 32: | |
line 33: if get(g:, 'command_t_loaded', 0) | |
line 34: call airline#extensions#commandt#init(s:ext) | |
line 35: endif | |
line 36: | |
line 37: if exists(':UndotreeToggle') | |
line 38: call airline#extensions#undotree#init(s:ext) | |
line 39: endif | |
line 40: | |
line 41: if (get(g:, 'airline#extensions#hunks#enabled', 1) && get(g:, 'airline_enable_hunks', 1)) && (exists('g:loaded_signify') || exists('g:loaded_gitgutter') || exists('g:loaded_changes') || exists('g:loaded_quickfixsigns')) | |
line 43: call airline#extensions#hunks#init(s:ext) | |
line 44: endif | |
line 45: | |
line 46: if (get(g:, 'airline#extensions#tagbar#enabled', 1) && get(g:, 'airline_enable_tagbar', 1)) && exists(':TagbarToggle') | |
line 48: call airline#extensions#tagbar#init(s:ext) | |
Searching for "autoload/airline/extensions/tagbar.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nv | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/tagbar.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/tagbar.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/tagbar.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/tagbar.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/tagbar.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tagbar.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 48: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tagbar.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: if !exists(':TagbarToggle') | |
line 5: finish | |
line 6: endif | |
line 7: | |
line 8: let s:flags = get(g:, 'airline#extensions#tagbar#flags', '') | |
line 9: let s:spc = g:airline_symbols.space | |
line 10: | |
line 11: " Arguments: current, sort, fname | |
line 12: function! airline#extensions#tagbar#get_status(...) | |
line 19: | |
line 20: function! airline#extensions#tagbar#inactive_apply(...) | |
line 25: | |
line 26: let s:airline_tagbar_last_lookup_time = 0 | |
line 27: let s:airline_tagbar_last_lookup_val = '' | |
line 28: function! airline#extensions#tagbar#currenttag() | |
line 38: | |
line 39: function! airline#extensions#tagbar#init(ext) | |
line 45: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tagbar.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call a:ext.add_inactive_statusline_func('airline#extensions#tagbar#inactive_apply') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..3('airline#extensions#tagbar#inactive_apply') | |
line 1: call airline#add_inactive_statusline_func(a:name) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..3..airline#add_inactive_statusline_func('airline#extensions#tagbar#inactive_apply') | |
line 1: call add(s:inactive_funcrefs, function(a:name)) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..3..airline#add_inactive_statusline_func returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..3 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..3 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init | |
line 2: let g:tagbar_status_func = 'airline#extensions#tagbar#get_status' | |
line 3: | |
line 4: call airline#parts#define_function('tagbar', 'airline#extensions#tagbar#currenttag') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..airline#parts#define_function('tagbar', 'airline#extensions#tagbar#currenttag') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..airline#parts#define_function..airline#parts#define('tagbar', {'function': 'airline#extensions#tagbar#currenttag'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..airline#parts#define_function | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init..airline#parts#define_function returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tagbar#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 49: endif | |
line 50: | |
line 51: if (get(g:, 'airline#extensions#csv#enabled', 1) && get(g:, 'airline_enable_csv', 1)) && (get(g:, 'loaded_csv', 0) || exists(':Table')) | |
line 53: call airline#extensions#csv#init(s:ext) | |
line 54: endif | |
line 55: | |
line 56: if exists(':VimShell') | |
line 57: let s:filetype_overrides['vimshell'] = ['vimshell','%{vimshell#get_status_string()}'] | |
line 58: let s:filetype_regex_overrides['^int-'] = ['vimshell','%{substitute(&ft, "int-", "", "")}'] | |
line 59: endif | |
line 60: | |
line 61: if (get(g:, 'airline#extensions#branch#enabled', 1) && get(g:, 'airline_enable_branch', 1)) && (exists('*fugitive#head') || exists('*lawrencium#statusline') || (get(g:, 'airline#extensions#branch#use_vcscommand', 0) && exists('*VCSCommandGetStatusLine'))) | |
line 64: call airline#extensions#branch#init(s:ext) | |
Searching for "autoload/airline/extensions/branch.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nv | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/branch.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/branch.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/branch.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/branch.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/branch.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/branch.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 64: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/branch.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:has_fugitive = exists('*fugitive#head') | |
line 5: let s:has_lawrencium = exists('*lawrencium#statusline') | |
line 6: let s:has_vcscommand = get(g:, 'airline#extensions#branch#use_vcscommand', 0) && exists('*VCSCommandGetStatusLine') | |
line 7: | |
line 8: if !s:has_fugitive && !s:has_lawrencium && !s:has_vcscommand | |
line 9: finish | |
line 10: endif | |
line 11: | |
line 12: let s:head_format = get(g:, 'airline#extensions#branch#format', 0) | |
line 13: if s:head_format == 1 | |
line 14: function! s:format_name(name) | |
line 17: elseif type(s:head_format) == type('') | |
line 18: function! s:format_name(name) | |
line 21: else | |
line 22: function! s:format_name(name) | |
line 25: endif | |
line 26: | |
line 27: let s:git_dirs = {} | |
line 28: function! s:get_git_branch(path) | |
line 53: | |
line 54: function! airline#extensions#branch#head() | |
line 101: | |
line 102: function! airline#extensions#branch#get_head() | |
line 111: | |
line 112: function! s:check_in_path() | |
line 134: | |
line 135: function! airline#extensions#branch#init(ext) | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/branch.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call airline#parts#define_function('branch', 'airline#extensions#branch#get_head') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init..airline#parts#define_function('branch', 'airline#extensions#branch#get_head') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init..airline#parts#define_function..airline#parts#define('branch', {'function': 'airline#extensions#branch#get_head'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init..airline#parts#define_function | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init..airline#parts#define_function returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init | |
line 2: | |
line 3: autocmd BufReadPost * unlet! b:airline_file_in_root | |
line 4: autocmd CursorHold,ShellCmdPost,CmdwinLeave * unlet! b:airline_head | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#branch#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 65: endif | |
line 66: | |
line 67: if (get(g:, 'airline#extensions#bufferline#enabled', 1) && get(g:, 'airline_enable_bufferline', 1)) && exists('*bufferline#get_status_string') | |
line 69: call airline#extensions#bufferline#init(s:ext) | |
line 70: endif | |
line 71: | |
line 72: if isdirectory($VIRTUAL_ENV) && get(g:, 'airline#extensions#virtualenv#enabled', 1) | |
line 73: call airline#extensions#virtualenv#init(s:ext) | |
line 74: endif | |
line 75: | |
line 76: if (get(g:, 'airline#extensions#eclim#enabled', 1) && exists(':ProjectCreate')) | |
line 77: call airline#extensions#eclim#init(s:ext) | |
line 78: endif | |
line 79: | |
line 80: if (get(g:, 'airline#extensions#syntastic#enabled', 1) && get(g:, 'airline_enable_syntastic', 1)) && exists(':SyntasticCheck') | |
line 82: call airline#extensions#syntastic#init(s:ext) | |
line 83: endif | |
line 84: | |
line 85: if (get(g:, 'airline#extensions#whitespace#enabled', 1) && get(g:, 'airline_detect_whitespace', 1)) | |
line 86: call airline#extensions#whitespace#init(s:ext) | |
Searching for "autoload/airline/extensions/whitespace.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xd | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/whitespace.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/whitespace.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/whitespace.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/whitespace.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/whitespace.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/whitespace.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 86: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/whitespace.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: " http://got-ravings.blogspot.com/2008/10/vim-pr0n-statusline-whitespace-flags.html | |
line 5: | |
line 6: " for backwards compatibility | |
line 7: if exists('g:airline_detect_whitespace') | |
line 8: let s:show_message = g:airline_detect_whitespace == 1 | |
line 9: else | |
line 10: let s:show_message = get(g:, 'airline#extensions#whitespace#show_message', 1) | |
line 11: endif | |
line 12: | |
line 13: let s:symbol = get(g:, 'airline#extensions#whitespace#symbol', g:airline_symbols.whitespace) | |
line 14: let s:default_checks = ['indent', 'trailing'] | |
line 15: | |
line 16: let s:trailing_format = get(g:, 'airline#extensions#whitespace#trailing_format', 'trailing[%s]') | |
line 17: let s:mixed_indent_format = get(g:, 'airline#extensions#whitespace#mixed_indent_format', 'mixed-indent[%s]') | |
line 18: let s:long_format = get(g:, 'airline#extensions#whitespace#long_format', 'long[%s]') | |
line 19: let s:indent_algo = get(g:, 'airline#extensions#whitespace#mixed_indent_algo', 0) | |
line 20: | |
line 21: let s:max_lines = get(g:, 'airline#extensions#whitespace#max_lines', 20000) | |
line 22: | |
line 23: let s:enabled = get(g:, 'airline#extensions#whitespace#enabled', 1) | |
line 24: | |
line 25: function! s:check_mixed_indent() | |
line 40: | |
line 41: function! airline#extensions#whitespace#check() | |
line 82: | |
line 83: function! airline#extensions#whitespace#toggle() | |
line 104: | |
line 105: function! airline#extensions#whitespace#init(...) | |
line 114: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/whitespace.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call airline#parts#define_function('whitespace', 'airline#extensions#whitespace#check') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init..airline#parts#define_function('whitespace', 'airline#extensions#whitespace#check') | |
line 1: call airline#parts#define(a:key, { 'function': a:name }) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init..airline#parts#define_function..airline#parts#define('whitespace', {'function': 'airline#extensions#whitespace#check'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init..airline#parts#define_function..airline#parts#define returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init..airline#parts#define_function | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init..airline#parts#define_function returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init | |
line 2: | |
line 3: unlet! b:airline_whitespace_check | |
line 4: augroup airline_whitespace | |
line 5: autocmd! | |
line 6: autocmd CursorHold,BufWritePost * unlet! b:airline_whitespace_check | |
line 7: augroup END | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#whitespace#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 87: endif | |
line 88: | |
line 89: if get(g:, 'airline#extensions#wordcount#enabled', 1) | |
line 90: call airline#extensions#wordcount#init(s:ext) | |
Searching for "autoload/airline/extensions/wordcount.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/wordcount.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/wordcount.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/wordcount.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/wordcount.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/wordcount.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/wordcount.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 90: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/wordcount.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:filetypes = get(g:, 'airline#extensions#wordcount#filetypes', '\vhelp|markdown|rst|org') | |
line 5: | |
line 6: " adapted from http://stackoverflow.com/questions/114431/fast-word-count-function-in-vim | |
line 7: function! s:update() | |
line 29: | |
line 30: function! airline#extensions#wordcount#apply(...) | |
line 35: | |
line 36: function! airline#extensions#wordcount#init(ext) | |
line 40: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/wordcount.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call a:ext.add_statusline_func('airline#extensions#wordcount#apply') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1('airline#extensions#wordcount#apply') | |
line 1: call airline#add_statusline_func(a:name) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1..airline#add_statusline_func('airline#extensions#wordcount#apply') | |
line 1: call airline#add_statusline_funcref(function(a:name)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1..airline#add_statusline_func..airline#add_statusline_funcref(function('airline#extensions#wordcount#apply')) | |
line 1: if index(g:airline_statusline_funcrefs, a:function) >= 0 | |
line 2: echohl WarningMsg | |
line 3: echo 'The airline statusline funcref '.string(a:function).' has already been added.' | |
line 4: echohl NONE | |
line 5: return | |
line 6: endif | |
line 7: call add(g:airline_statusline_funcrefs, a:function) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1..airline#add_statusline_func..airline#add_statusline_funcref returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1..airline#add_statusline_func | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1..airline#add_statusline_func returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init..1 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init | |
line 2: autocmd BufReadPost,CursorMoved,CursorMovedI * call s:update() | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#wordcount#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 91: endif | |
line 92: | |
line 93: if get(g:, 'airline#extensions#tabline#enabled', 0) | |
line 94: call airline#extensions#tabline#init(s:ext) | |
Searching for "autoload/airline/extensions/tabline.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/n | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/tabline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/tabline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/tabline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/tabline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/tabline.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 94: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:formatter = get(g:, 'airline#extensions#tabline#formatter', 'default') | |
line 5: let s:show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) | |
line 6: let s:show_tabs = get(g:, 'airline#extensions#tabline#show_tabs', 1) | |
line 7: | |
line 8: let s:taboo = get(g:, 'airline#extensions#taboo#enabled', 1) && get(g:, 'loaded_taboo', 0) | |
line 9: if s:taboo | |
line 10: let g:taboo_tabline = 0 | |
line 11: endif | |
line 12: | |
line 13: | |
line 14: function! airline#extensions#tabline#init(ext) | |
line 25: | |
line 26: function! s:toggle_off() | |
line 31: | |
line 32: function! s:toggle_on() | |
line 39: | |
line 40: function! airline#extensions#tabline#load_theme(palette) | |
line 63: | |
line 64: let s:current_tabcnt = -1 | |
line 65: function! airline#extensions#tabline#get() | |
line 79: | |
line 80: function! airline#extensions#tabline#title(n) | |
line 94: | |
line 95: function! airline#extensions#tabline#get_buffer_name(nr) | |
line 98: | |
line 99: function! airline#extensions#tabline#new_builder() | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: if has('gui_running') | |
line 2: set guioptions-=e | |
line 3: endif | |
line 4: | |
line 5: autocmd User AirlineToggledOn call s:toggle_on() | |
line 6: autocmd User AirlineToggledOff call s:toggle_off() | |
line 7: | |
line 8: call s:toggle_on() | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on() | |
line 1: call airline#extensions#tabline#autoshow#on() | |
Searching for "autoload/airline/extensions/tabline/autoshow.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/tabline/autoshow.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/tabline/autoshow.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/tabline/autoshow.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/tabline/autoshow.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/tabline/autoshow.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/autoshow.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 1: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/autoshow.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:show_buffers = get(g:, 'airline#extensions#tabline#show_buffers', 1) | |
line 5: let s:buf_min_count = get(g:, 'airline#extensions#tabline#buffer_min_count', 0) | |
line 6: let s:tab_min_count = get(g:, 'airline#extensions#tabline#tab_min_count', 0) | |
line 7: | |
line 8: function! airline#extensions#tabline#autoshow#off() | |
line 18: | |
line 19: function! airline#extensions#tabline#autoshow#on() | |
line 40: | |
line 41: function! s:show_tabline(min_count, total_count) | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/autoshow.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#autoshow#on() | |
line 1: let [ s:original_tabline, s:original_showtabline ] = [ &tabline, &showtabline ] | |
line 2: | |
line 3: augroup airline_tabline_autoshow | |
line 4: autocmd! | |
line 5: if s:buf_min_count <= 0 && s:tab_min_count <= 1 | |
line 6: set showtabline=2 | |
line 7: else | |
line 8: if s:show_buffers == 1 | |
line 9: autocmd BufEnter * call <sid>show_tabline(s:buf_min_count, len(airline#extensions#tabline#buflist#list())) | |
line 10: autocmd BufUnload * call <sid>show_tabline(s:buf_min_count, len(airline#extensions#tabline#buflist#list()) - 1) | |
line 11: else | |
line 12: autocmd TabEnter * call <sid>show_tabline(s:tab_min_count, tabpagenr('$')) | |
line 13: endif | |
line 14: endif | |
line 15: | |
line 16: " Invalidate cache. This has to come after the BufUnload for | |
line 17: " s:show_buffers, to invalidate the cache for BufEnter. | |
line 18: autocmd BufLeave,BufAdd,BufUnload * call airline#extensions#tabline#buflist#invalidate() | |
line 19: augroup END | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#autoshow#on returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
line 2: call airline#extensions#tabline#tabs#on() | |
Searching for "autoload/airline/extensions/tabline/tabs.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/tabline/tabs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/tabline/tabs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/tabline/tabs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/tabline/tabs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/tabline/tabs.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/tabs.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 2: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/tabs.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:show_tab_nr = get(g:, 'airline#extensions#tabline#show_tab_nr', 1) | |
line 5: let s:tab_nr_type = get(g:, 'airline#extensions#tabline#tab_nr_type', 0) | |
line 6: let s:show_close_button = get(g:, 'airline#extensions#tabline#show_close_button', 1) | |
line 7: let s:show_tab_type = get(g:, 'airline#extensions#tabline#show_tab_type', 1) | |
line 8: let s:close_symbol = get(g:, 'airline#extensions#tabline#close_symbol', 'X') | |
line 9: | |
line 10: let s:current_bufnr = -1 | |
line 11: let s:current_tabnr = -1 | |
line 12: let s:current_modified = 0 | |
line 13: | |
line 14: function! airline#extensions#tabline#tabs#off() | |
line 19: | |
line 20: function! airline#extensions#tabline#tabs#on() | |
line 26: | |
line 27: function! airline#extensions#tabline#tabs#invalidate() | |
line 30: | |
line 31: function! airline#extensions#tabline#tabs#get() | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/tabs.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#tabs#on() | |
line 1: augroup airline_tabline_tabs | |
line 2: autocmd! | |
line 3: autocmd BufDelete * call airline#extensions#tabline#tabs#invalidate() | |
line 4: augroup END | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#tabs#on returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
line 3: call airline#extensions#tabline#buffers#on() | |
Searching for "autoload/airline/extensions/tabline/buffers.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/e | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/tabline/buffers.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/tabline/buffers.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/extensions/tabline/buffers.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/extensions/tabline/buffers.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/extensions/tabline/buffers.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/buffers.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 3: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/buffers.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: scriptencoding utf-8 | |
line 5: | |
line 6: let s:buffer_idx_mode = get(g:, 'airline#extensions#tabline#buffer_idx_mode', 0) | |
line 7: let s:show_tab_type = get(g:, 'airline#extensions#tabline#show_tab_type', 1) | |
line 8: let s:spc = g:airline_symbols.space | |
line 9: | |
line 10: let s:current_bufnr = -1 | |
line 11: let s:current_modified = 0 | |
line 12: let s:current_tabline = '' | |
line 13: let s:current_visible_buffers = [] | |
line 14: | |
line 28: let s:number_map = &encoding == 'utf-8' ? { '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴', '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹' } : {} | |
line 29: | |
line 30: function! airline#extensions#tabline#buffers#off() | |
line 35: | |
line 36: function! airline#extensions#tabline#buffers#on() | |
line 42: | |
line 43: function! airline#extensions#tabline#buffers#invalidate() | |
line 46: | |
line 47: function! airline#extensions#tabline#buffers#get() | |
line 104: | |
line 105: function! s:get_visible_buffers() | |
line 157: | |
line 158: function! s:select_tab(buf_index) | |
line 174: | |
line 175: function! s:jump_to_tab(offset) | |
line 182: | |
line 183: if s:buffer_idx_mode | |
line 184: noremap <unique> <Plug>AirlineSelectTab1 :call <SID>select_tab(0)<CR> | |
line 185: noremap <unique> <Plug>AirlineSelectTab2 :call <SID>select_tab(1)<CR> | |
line 186: noremap <unique> <Plug>AirlineSelectTab3 :call <SID>select_tab(2)<CR> | |
line 187: noremap <unique> <Plug>AirlineSelectTab4 :call <SID>select_tab(3)<CR> | |
line 188: noremap <unique> <Plug>AirlineSelectTab5 :call <SID>select_tab(4)<CR> | |
line 189: noremap <unique> <Plug>AirlineSelectTab6 :call <SID>select_tab(5)<CR> | |
line 190: noremap <unique> <Plug>AirlineSelectTab7 :call <SID>select_tab(6)<CR> | |
line 191: noremap <unique> <Plug>AirlineSelectTab8 :call <SID>select_tab(7)<CR> | |
line 192: noremap <unique> <Plug>AirlineSelectTab9 :call <SID>select_tab(8)<CR> | |
line 193: noremap <unique> <Plug>AirlineSelectPrevTab :<C-u>call <SID>jump_to_tab(-v:count1)<CR> | |
line 194: noremap <unique> <Plug>AirlineSelectNextTab :<C-u>call <SID>jump_to_tab(v:count1)<CR> | |
line 195: endif | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/extensions/tabline/buffers.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#buffers#on() | |
line 1: augroup airline_tabline_buffers | |
line 2: autocmd! | |
line 3: autocmd BufDelete * call airline#extensions#tabline#buffers#invalidate() | |
line 4: augroup END | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on..airline#extensions#tabline#buffers#on returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on | |
line 4: | |
line 5: set tabline=%!airline#extensions#tabline#get() | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..<SNR>58_toggle_on returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init | |
line 9: call a:ext.add_theme_func('airline#extensions#tabline#load_theme') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..4('airline#extensions#tabline#load_theme') | |
line 1: call add(self._theme_funcrefs, function(a:name)) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init..4 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#tabline#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 95: endif | |
line 96: | |
line 97: if get(g:, 'airline#extensions#tmuxline#enabled', 1) && exists(':Tmuxline') | |
line 98: call airline#extensions#tmuxline#init(s:ext) | |
line 99: endif | |
line 100: | |
line 101: if get(g:, 'airline#extensions#promptline#enabled', 1) && exists(':PromptlineSnapshot') && len(get(g:, 'airline#extensions#promptline#snapshot_file', '')) | |
line 102: call airline#extensions#promptline#init(s:ext) | |
line 103: endif | |
line 104: | |
line 105: if get(g:, 'airline#extensions#nrrwrgn#enabled', 1) && exists(':NR') == 2 | |
line 106: call airline#extensions#nrrwrgn#init(s:ext) | |
line 107: endif | |
line 108: | |
line 109: if (get(g:, 'airline#extensions#capslock#enabled', 1) && exists('*CapsLockStatusline')) | |
line 110: call airline#extensions#capslock#init(s:ext) | |
line 111: endif | |
line 112: | |
line 113: if (get(g:, 'airline#extensions#windowswap#enabled', 1) && get(g:, 'loaded_windowswap', 0)) | |
line 114: call airline#extensions#windowswap#init(s:ext) | |
line 115: endif | |
line 116: | |
line 117: if !get(g:, 'airline#extensions#disable_rtp_load', 0) | |
line 118: " load all other extensions, which are not part of the default distribution. | |
line 119: " (autoload/airline/extensions/*.vim outside of our s:script_path). | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
Searching for "autoload/airline/extensions/neomake.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/n | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/extensions/neomake.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/neomake.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 130: sourcing "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/neomake.vim" | |
line 1: " vim: ts=4 sw=4 et | |
line 2: | |
line 3: if exists('g:neomake_airline') && g:neomake_airline == 0 | |
line 4: finish | |
line 5: endif | |
line 6: | |
line 7: let s:spc = g:airline_symbols.space | |
line 8: | |
line 9: function! airline#extensions#neomake#apply(...) | |
line 13: | |
line 14: function! airline#extensions#neomake#init(ext) | |
finished sourcing /Users/nhooyr/.nvim/plugged/neomake/autoload/airline/extensions/neomake.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init({'add_theme_func': function('4'), 'ad...], 'add_statusline_func': function('1')}) | |
line 1: call airline#parts#define_raw('neomake', '%{neomake#statusline#LoclistStatus()}') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..airline#parts#define_raw('neomake', '%{neomake#statusline#LoclistStatus()}') | |
line 1: call airline#parts#define(a:key, { 'raw': a:raw }) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..airline#parts#define_raw..airline#parts#define('neomake', {'raw': '%{neomake#statusline#LoclistStatus()}'}) | |
line 1: let s:parts[a:key] = get(s:parts, a:key, {}) | |
line 2: if exists('g:airline#init#bootstrapping') | |
line 3: call extend(s:parts[a:key], a:config, 'keep') | |
line 4: else | |
line 5: call extend(s:parts[a:key], a:config, 'force') | |
line 6: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..airline#parts#define_raw..airline#parts#define returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..airline#parts#define_raw | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..airline#parts#define_raw returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init | |
line 2: call a:ext.add_statusline_func('airline#extensions#neomake#apply') | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1('airline#extensions#neomake#apply') | |
line 1: call airline#add_statusline_func(a:name) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1..airline#add_statusline_func('airline#extensions#neomake#apply') | |
line 1: call airline#add_statusline_funcref(function(a:name)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1..airline#add_statusline_func..airline#add_statusline_funcref(function('airline#extensions#neomake#apply')) | |
line 1: if index(g:airline_statusline_funcrefs, a:function) >= 0 | |
line 2: echohl WarningMsg | |
line 3: echo 'The airline statusline funcref '.string(a:function).' has already been added.' | |
line 4: echohl NONE | |
line 5: return | |
line 6: endif | |
line 7: call add(g:airline_statusline_funcrefs, a:function) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1..airline#add_statusline_func..airline#add_statusline_funcref returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1..airline#add_statusline_func | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1..airline#add_statusline_func returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init..1 returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load..airline#extensions#neomake#init returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 120: for file in split(globpath(&rtp, "autoload/airline/extensions/*.vim"), "\n") | |
line 121: " we have to check both resolved and unresolved paths, since it's possible | |
line 122: " that they might not get resolved properly (see #187) | |
line 123: if stridx(tolower(resolve(fnamemodify(file, ':p'))), s:script_path) < 0 && stridx(tolower(fnamemodify(file, ':p')), s:script_path) < 0 | |
line 125: let name = fnamemodify(file, ':t:r') | |
line 126: if !get(g:, 'airline#extensions#'.name.'#enabled', 1) | |
line 127: continue | |
line 128: endif | |
line 129: try | |
line 130: call airline#extensions#{name}#init(s:ext) | |
line 131: catch | |
line 132: endtry | |
line 133: endif | |
line 134: endfor | |
line 135: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#extensions#load returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init | |
line 7: call airline#init#sections() | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections() | |
line 1: let spc = g:airline_symbols.space | |
line 2: if !exists('g:airline_section_a') | |
line 3: let g:airline_section_a = airline#section#create_left(['mode', 'crypt', 'paste', 'capslock', 'iminsert']) | |
Searching for "autoload/airline/section.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/ | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/section.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/section.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/section.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/section.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/section.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/section.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 3: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/section.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: call airline#init#bootstrap() | |
calling function airline#init#bootstrap() | |
line 1: if s:loaded | |
line 2: return | |
function airline#init#bootstrap returning #0 | |
continuing in /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/section.vim | |
line 5: let s:spc = g:airline_symbols.space | |
line 6: | |
line 7: function! s:wrap_accent(part, value) | |
line 14: | |
line 15: function! s:create(parts, append) | |
line 61: | |
line 62: function! airline#section#create(parts) | |
line 65: | |
line 66: function! airline#section#create_left(parts) | |
line 69: | |
line 70: function! airline#section#create_right(parts) | |
line 73: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/section.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left(['mode', 'crypt', 'paste', 'capslock', 'iminsert']) | |
line 1: return s:create(a:parts, 1) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create(['mode', 'crypt', 'paste', 'capslock', 'iminsert'], 1) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get('mode') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#mode', 'accent': 'bold'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#mode', 'accent': 'bold'}, '%{airline#util#wrap(airline#parts#mode(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
Searching for "autoload/airline/highlighter.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/aft | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/highlighter.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/highlighter.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/highlighter.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/highlighter.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/highlighter.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/highlighter.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 2: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/highlighter.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: let s:is_win32term = (has('win32') || has('win64')) && !has('gui_running') && (empty($CONEMUBUILD) || &term !=? 'xterm') | |
line 5: | |
line 6: let s:separators = {} | |
line 7: let s:accents = {} | |
line 8: | |
line 9: function! s:gui2cui(rgb, fallback) | |
line 17: | |
line 18: function! s:get_syn(group, what) | |
line 34: | |
line 35: function! s:get_array(fg, bg, opts) | |
line 42: | |
line 43: function! airline#highlighter#get_highlight(group, ...) | |
line 52: | |
line 53: function! airline#highlighter#get_highlight2(fg, bg, ...) | |
line 58: | |
line 59: function! airline#highlighter#exec(group, colors) | |
line 75: | |
line 76: function! s:exec_separator(dict, from, to, inverse, suffix) | |
line 88: | |
line 89: function! airline#highlighter#load_theme() | |
line 96: | |
line 97: function! airline#highlighter#add_separator(from, to, inverse) | |
line 101: | |
line 102: function! airline#highlighter#add_accent(accent) | |
line 105: | |
line 106: function! airline#highlighter#highlight_modified_inactive(bufnr) | |
line 119: | |
line 120: function! airline#highlighter#highlight(modes) | |
line 160: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/highlighter.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent..airline#highlighter#add_accent('bold') | |
line 1: let s:accents[a:accent] = 1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent..airline#highlighter#add_accent returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent returning '%#__accent_bold#%{airline#util#wrap(airline#parts#mode(),0)}%#__restore__#' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get('crypt') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#crypt'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#crypt'}, '%{airline#util#append(airline#parts#crypt(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#append(airline#parts#crypt(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get('paste') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#paste'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#paste'}, '%{airline#util#append(airline#parts#paste(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#append(airline#parts#paste(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get('capslock') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get returning {'text': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent({'text': ''}, '%{airline#util#append("",0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#append("",0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get('iminsert') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#iminsert'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#iminsert'}, '%{airline#util#append(airline#parts#iminsert(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#append(airline#parts#iminsert(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left..<SNR>63_create returning '%#__accent_bold#%{airline#util#wrap(...til#append(airline#parts#iminsert(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_left returning '%#__accent_bold#%{airline#util#wrap(...til#append(airline#parts#iminsert(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 4: endif | |
line 5: if !exists('g:airline_section_b') | |
line 6: let g:airline_section_b = airline#section#create(['hunks', 'branch']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create(['hunks', 'branch']) | |
line 1: return s:create(a:parts, 0) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create(['hunks', 'branch'], 0) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('hunks') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': ''}, '') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('branch') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'function': 'airline#extensions#branch#get_head', 'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#extensions#branch#get_head', 'raw': ''}, '%{airline#util#wrap(airline#extensions#branch#get_head(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#wrap(airline#extensions#branch#get_head(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create returning '%{airline#util#wrap(airline#extensions#branch#get_head(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create returning '%{airline#util#wrap(airline#extensions#branch#get_head(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 7: endif | |
line 8: if !exists('g:airline_section_c') | |
line 9: let g:airline_section_c = airline#section#create(['%<', 'file', spc, 'readonly']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create(['%<', 'file', ' ', 'readonly']) | |
line 1: return s:create(a:parts, 0) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create(['%<', 'file', ' ', 'readonly'], 0) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('%<') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({}, '%<') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%<' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 22: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('file') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': '%f%m'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': '%f%m'}, '%f%m') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%f%m' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get(' ') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({}, ' ') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning ' ' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 22: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('readonly') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#readonly', 'accent': 'red'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#readonly', 'accent': 'red'}, '%{airline#util#wrap(airline#parts#readonly(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent..airline#highlighter#add_accent('red') | |
line 1: let s:accents[a:accent] = 1 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent..airline#highlighter#add_accent returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%#__accent_red#%{airline#util#wrap(airline#parts#readonly(),0)}%#__restore__#' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create returning '%<%f%m %#__accent_red#%{airline#util...line#parts#readonly(),0)}%#__restore__#' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create returning '%<%f%m %#__accent_red#%{airline#util...line#parts#readonly(),0)}%#__restore__#' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 10: endif | |
line 11: if !exists('g:airline_section_gutter') | |
line 12: let g:airline_section_gutter = airline#section#create(['%=']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create(['%=']) | |
line 1: return s:create(a:parts, 0) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create(['%='], 0) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('%=') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({}, '%=') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%=' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 22: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create returning '%=' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create returning '%=' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 13: endif | |
line 14: if !exists('g:airline_section_x') | |
line 15: let g:airline_section_x = airline#section#create_right(['tagbar', 'filetype']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right(['tagbar', 'filetype']) | |
line 1: return s:create(a:parts, -1) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create(['tagbar', 'filetype'], -1) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get('tagbar') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get returning {'function': 'airline#extensions#tagbar#currenttag', 'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#extensions#tagbar#currenttag', 'raw': ''}, '%{airline#util#prepend(airline#extensions#tagbar#currenttag(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#prepend(airline#extensions#tagbar#currenttag(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get('filetype') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#filetype'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#filetype'}, '%{airline#util#wrap(airline#parts#filetype(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#wrap(airline#parts#filetype(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create returning '%{airline#util#prepend(airline#exten...#util#wrap(airline#parts#filetype(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right returning '%{airline#util#prepend(airline#exten...#util#wrap(airline#parts#filetype(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 16: endif | |
line 17: if !exists('g:airline_section_y') | |
line 18: let g:airline_section_y = airline#section#create_right(['ffenc']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right(['ffenc']) | |
line 1: return s:create(a:parts, -1) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create(['ffenc'], -1) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get('ffenc') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..airline#parts#get returning {'function': 'airline#parts#ffenc'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#parts#ffenc'}, '%{airline#util#wrap(airline#parts#ffenc(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#wrap(airline#parts#ffenc(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right..<SNR>63_create returning '%{airline#util#wrap(airline#parts#ffenc(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create_right returning '%{airline#util#wrap(airline#parts#ffenc(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 19: endif | |
line 20: if !exists('g:airline_section_z') | |
line 21: let g:airline_section_z = airline#section#create(['windowswap', '%3p%%'.spc, 'linenr', ':%3v ']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create(['windowswap', '%3p%% ', 'linenr', ':%3v ']) | |
line 1: return s:create(a:parts, 0) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create(['windowswap', '%3p%% ', 'linenr', ':%3v '], 0) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('windowswap') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': ''}, '') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('%3p%% ') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({}, '%3p%% ') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%3p%% ' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 22: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('linenr') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#'} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#'}, '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get(':%3v ') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({}, ':%3v ') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning ':%3v ' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 22: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create returning '%3p%% %{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#:%3v ' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create returning '%3p%% %{g:airline_symbols.linenr}%#__accent_bold#%4l%#__restore__#:%3v ' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 22: endif | |
line 23: if !exists('g:airline_section_warning') | |
line 24: let g:airline_section_warning = airline#section#create(['syntastic', 'eclim', 'whitespace']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create(['syntastic', 'eclim', 'whitespace']) | |
line 1: return s:create(a:parts, 0) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create(['syntastic', 'eclim', 'whitespace'], 0) | |
line 1: let _ = '' | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('syntastic') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': ''}, '') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('eclim') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'raw': ''}, '') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 19: continue | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get('whitespace') | |
line 1: return get(s:parts, a:key, {}) | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..airline#parts#get returning {'function': 'airline#extensions#whitespace#check', 'raw': ''} | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent({'function': 'airline#extensions#whitespace#check', 'raw': ''}, '%{airline#util#wrap(airline#extensions#whitespace#check(),0)}') | |
line 1: if exists('a:part.accent') | |
line 2: call airline#highlighter#add_accent(a:part.accent) | |
line 3: return '%#__accent_'.(a:part.accent).'#'.a:value.'%#__restore__#' | |
line 4: endif | |
line 5: return a:value | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create..<SNR>63_wrap_accent returning '%{airline#util#wrap(airline#extensions#whitespace#check(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create | |
line 42: let _ .= val | |
line 43: endfor | |
line 2: for idx in range(len(a:parts)) | |
line 3: let part = airline#parts#get(a:parts[idx]) | |
line 4: let val = '' | |
line 5: | |
line 6: if exists('part.function') | |
line 7: let func = (part.function).'()' | |
line 8: elseif exists('part.text') | |
line 9: let func = '"'.(part.text).'"' | |
line 10: else | |
line 11: if a:append > 0 && idx != 0 | |
line 12: let val .= s:spc.g:airline_left_alt_sep.s:spc | |
line 13: endif | |
line 14: if a:append < 0 && idx != 0 | |
line 15: let val = s:spc.g:airline_right_alt_sep.s:spc.val | |
line 16: endif | |
line 17: if exists('part.raw') | |
line 18: let _ .= s:wrap_accent(part, val.(part.raw)) | |
line 19: continue | |
line 20: else | |
line 21: let _ .= s:wrap_accent(part, val.a:parts[idx]) | |
line 22: continue | |
line 23: endif | |
line 24: endif | |
line 25: | |
line 26: let minwidth = get(part, 'minwidth', 0) | |
line 27: | |
line 28: if a:append > 0 && idx != 0 | |
line 29: let partval = printf('%%{airline#util#append(%s,%s)}', func, minwidth) | |
line 30: elseif a:append < 0 && idx != len(a:parts) - 1 | |
line 31: let partval = printf('%%{airline#util#prepend(%s,%s)}', func, minwidth) | |
line 32: else | |
line 33: let partval = printf('%%{airline#util#wrap(%s,%s)}', func, minwidth) | |
line 34: endif | |
line 35: | |
line 36: if exists('part.condition') | |
line 37: let partval = substitute(partval, '{', '\="{".(part.condition)." ? "', '') | |
line 38: let partval = substitute(partval, '}', ' : ""}', '') | |
line 39: endif | |
line 40: | |
line 41: let val .= s:wrap_accent(part, partval) | |
line 42: let _ .= val | |
line 43: endfor | |
line 44: return _ | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create..<SNR>63_create returning '%{airline#util#wrap(airline#extensions#whitespace#check(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections..airline#section#create returning '%{airline#util#wrap(airline#extensions#whitespace#check(),0)}' | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections | |
line 25: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#init#sections returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init | |
line 8: | |
line 9: let s:airline_theme_defined = exists('g:airline_theme') | |
line 10: if s:airline_theme_defined || !airline#switch_matching_theme() | |
line 11: let g:airline_theme = get(g:, 'airline_theme', 'dark') | |
line 12: call airline#switch_theme(g:airline_theme) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme('nhooyr') | |
line 1: try | |
line 2: let palette = g:airline#themes#{a:name}#palette "also lazy loads the theme | |
Searching for "autoload/airline/themes/nhooyr.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/share/nvim/runtime,/usr/share/nvim/site/after,/usr/local/share/nvim/site/after,/Users/nhooyr/.local/share/nvim/site/after,/etc/xdg/nvim/a | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/dotfiles/nvim/autoload/airline/themes) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 2: sourcing "/Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim" | |
line 1: " Each theme is contained in its own file and declares variables scoped to the | |
line 2: " file. These variables represent the possible "modes" that airline can | |
line 3: " detect. The mode is the return value of mode(), which gets converted to a | |
line 4: " readable string. The following is a list currently supported modes: normal, | |
line 5: " insert, replace, visual, and inactive. | |
line 6: " | |
line 7: " Each mode can also have overrides. These are small changes to the mode that | |
line 8: " don't require a completely different look. "modified" and "paste" are two | |
line 9: " such supported overrides. These are simply suffixed to the major mode, | |
line 10: " separated by an underscore. For example, "normal_modified" would be normal | |
line 11: " mode where the current buffer is modified. | |
line 12: " | |
line 13: " The theming algorithm is a 2-pass system where the mode will draw over all | |
line 14: " parts of the statusline, and then the override is applied after. This means | |
line 15: " it is possible to specify a subset of the theme in overrides, as it will | |
line 16: " simply overwrite the previous colors. If you want simultaneous overrides, | |
line 17: " then they will need to change different parts of the statusline so they do | |
line 18: " not conflict with each other. | |
line 19: " | |
line 20: " First, let's define an empty dictionary and assign it to the "palette" | |
line 21: " variable. The # is a separator that maps with the directory structure. If | |
line 22: " you get this wrong, Vim will complain loudly. | |
line 23: let g:airline#themes#nhooyr#palette = {} | |
line 24: | |
line 25: " First let's define some arrays. The s: is just a VimL thing for scoping the | |
line 26: " variables to the current script. Without this, these variables would be | |
line 27: " declared globally. Now lejlsksadjlt's declare some colors for normal mode and add it | |
line 28: " to the dictionary. The array is in the format: | |
line 29: " [ guifg, guibg, ctermfg, ctermbg, opts ]. See "help attr-list" for valid | |
line 30: " values for the "opt" value. | |
line 31: let s:N1 = [ '#00005f' , '#dfff00' , 8 , 3 ] | |
line 32: let s:N2 = [ '#ffffff' , '#444444' , 7 , 8 ] | |
line 33: let s:N3 = [ '#9cffd3' , '#202020' , 7 , 235 ] | |
line 34: let g:airline#themes#nhooyr#palette.normal = airline#themes#generate_color_map(s:N1, s:N2, s:N3) | |
Searching for "autoload/airline/themes.vim" in "/Users/nhooyr/dotfiles/nvim,/Users/nhooyr/.nvim/plugged/neomake/,/Users/nhooyr/.nvim/plugged/tagbar/,/Users/nhooyr/.nvim/plugged/vim-fugitive/,/Users/nhooyr/.nvim/plugged/YouCompleteMe/,/Users/nhooyr/.nvim/plugged/vim-airline/,/Users/nhooyr/.nvim/plugged/delimitMate/,/Users/nhooyr/.nvim/plugged/vim-tmux-navigator/,/Users/nhooyr/.nvim/plugged/vim-startify/,/Users/nhooyr/.nvim/plugged/emmet-vim/,/Users/nhooyr/.nvim/plugged/vim-surround/,/Users/nhooyr/.fzf/,/Users/nhooyr/.nvim/plugged/vim-repeat/,/Users/nhooyr/.nvim/plugged/Apprentice/,/Users/nhooyr/.nvim/plugged/quick-scope/,/Users/nhooyr/.nvim/plugged/vim-superman/,/Users/nhooyr/.nvim/plugged/LanguageTool/,/Users/nhooyr/.nvim/plugged/vim-over/,/etc/xdg/nvim,/Users/nhooyr/.local/share/nvim/site,/usr/local/share/nvim/site,/usr/share/nvim/site,/usr/local/Cellar/neovim/0.1.0/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,/U | |
Searching for "/Users/nhooyr/dotfiles/nvim/autoload/airline/themes.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/neomake/autoload/airline/themes.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/tagbar/autoload/airline/themes.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-fugitive/autoload/airline/themes.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/YouCompleteMe/autoload/airline/themes.vim" | |
Searching for "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/themes.vim" | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
chdir(/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline) | |
chdir(/Users/nhooyr/dotfiles/nvim) | |
line 34: sourcing "/Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/themes.vim" | |
line 1: " MIT License. Copyright (c) 2013-2015 Bailey Ling. | |
line 2: " vim: et ts=2 sts=2 sw=2 | |
line 3: | |
line 4: " generates a dictionary which defines the colors for each highlight group | |
line 5: function! airline#themes#generate_color_map(sect1, sect2, sect3, ...) | |
line 28: | |
line 29: function! airline#themes#get_highlight(group, ...) | |
line 32: | |
line 33: function! airline#themes#get_highlight2(fg, bg, ...) | |
line 36: | |
line 37: function! airline#themes#patch(palette) | |
line 67: | |
finished sourcing /Users/nhooyr/.nvim/plugged/vim-airline/autoload/airline/themes.vim | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
calling function airline#themes#generate_color_map(['#00005f', '#dfff00', 8, 3], ['#ffffff', '#444444', 7, 8], ['#9cffd3', '#202020', 7, 235]) | |
line 1: let palette = { 'airline_a': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , get(a:sect1 , 4 , '') ] , 'airline_b': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , get(a:sect2 , 4 , '') ] , 'airline_c': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , get(a:sect3 , 4 , '') ] , } | |
line 6: | |
line 7: if a:0 > 0 | |
line 8: call extend(palette, { 'airline_x': [ a:1[0] , a:1[1] , a:1[2] , a:1[3] , get(a:1 , 4 , '' ) ] , 'airline_y': [ a:2[0] , a:2[1] , a:2[2] , a:2[3] , get(a:2 , 4 , '' ) ] , 'airline_z': [ a:3[0] , a:3[1] , a:3[2] , a:3[3] , get(a:3 , 4 , '' ) ] , }) | |
line 13: else | |
line 14: call extend(palette, { 'airline_x': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , '' ] , 'airline_y': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , '' ] , 'airline_z': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , '' ] , }) | |
line 19: endif | |
line 20: | |
line 21: return palette | |
function airline#themes#generate_color_map returning {'airline_x': ['#9cffd3', '#202020', ..._c': ['#9cffd3', '#202020', 7, 235, '']} | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
line 35: " Here we define overrides for when the buffer is modified. This will be | |
line 36: " applied after g:airline#themes#nhooyr#palette.normal, hence why only certain keys are | |
line 37: " declared. | |
line 38: let g:airline#themes#nhooyr#palette.normal_modified = g:airline#themes#nhooyr#palette.normal | |
line 39: let g:airline#themes#nhooyr#palette.normal.airline_warning = [ '' , '', 7 , 8] | |
line 40: let g:airline#themes#nhooyr#palette.normal_modified.airline_warning = [ '' , '', 7 , 8] | |
line 41: | |
line 42: let s:R1 = [ '#00005f' , '#dfff00' , 8 , 5 ] | |
line 43: let s:R2 = [ '#ffffff' , '#444444' , 7 , 8 ] | |
line 44: let s:R3 = [ '#9cffd3' , '#202020' , 7 , 235 ] | |
line 45: let g:airline#themes#nhooyr#palette.replace = airline#themes#generate_color_map(s:R1, s:R2, s:R3) | |
calling function airline#themes#generate_color_map(['#00005f', '#dfff00', 8, 5], ['#ffffff', '#444444', 7, 8], ['#9cffd3', '#202020', 7, 235]) | |
line 1: let palette = { 'airline_a': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , get(a:sect1 , 4 , '') ] , 'airline_b': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , get(a:sect2 , 4 , '') ] , 'airline_c': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , get(a:sect3 , 4 , '') ] , } | |
line 6: | |
line 7: if a:0 > 0 | |
line 8: call extend(palette, { 'airline_x': [ a:1[0] , a:1[1] , a:1[2] , a:1[3] , get(a:1 , 4 , '' ) ] , 'airline_y': [ a:2[0] , a:2[1] , a:2[2] , a:2[3] , get(a:2 , 4 , '' ) ] , 'airline_z': [ a:3[0] , a:3[1] , a:3[2] , a:3[3] , get(a:3 , 4 , '' ) ] , }) | |
line 13: else | |
line 14: call extend(palette, { 'airline_x': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , '' ] , 'airline_y': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , '' ] , 'airline_z': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , '' ] , }) | |
line 19: endif | |
line 20: | |
line 21: return palette | |
function airline#themes#generate_color_map returning {'airline_x': ['#9cffd3', '#202020', ..._c': ['#9cffd3', '#202020', 7, 235, '']} | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
line 46: let g:airline#themes#nhooyr#palette.replace_modified = g:airline#themes#nhooyr#palette.replace | |
line 47: let g:airline#themes#nhooyr#palette.replace.airline_warning = [ '' , '', 7 , 8] | |
line 48: let s:I1 = [ '#00005f' , '#00dfff' , 8 , 6 ] | |
line 49: let s:I2 = [ '#ffffff' , '#005fff' , 7 , 8 ] | |
line 50: let s:I3 = [ '#ffffff' , '#000080' , 7 , 235 ] | |
line 51: | |
line 52: let g:airline#themes#nhooyr#palette.insert = airline#themes#generate_color_map(s:I1, s:I2, s:I3) | |
calling function airline#themes#generate_color_map(['#00005f', '#00dfff', 8, 6], ['#ffffff', '#005fff', 7, 8], ['#ffffff', '#000080', 7, 235]) | |
line 1: let palette = { 'airline_a': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , get(a:sect1 , 4 , '') ] , 'airline_b': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , get(a:sect2 , 4 , '') ] , 'airline_c': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , get(a:sect3 , 4 , '') ] , } | |
line 6: | |
line 7: if a:0 > 0 | |
line 8: call extend(palette, { 'airline_x': [ a:1[0] , a:1[1] , a:1[2] , a:1[3] , get(a:1 , 4 , '' ) ] , 'airline_y': [ a:2[0] , a:2[1] , a:2[2] , a:2[3] , get(a:2 , 4 , '' ) ] , 'airline_z': [ a:3[0] , a:3[1] , a:3[2] , a:3[3] , get(a:3 , 4 , '' ) ] , }) | |
line 13: else | |
line 14: call extend(palette, { 'airline_x': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , '' ] , 'airline_y': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , '' ] , 'airline_z': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , '' ] , }) | |
line 19: endif | |
line 20: | |
line 21: return palette | |
function airline#themes#generate_color_map returning {'airline_x': ['#ffffff', '#000080', ..._c': ['#ffffff', '#000080', 7, 235, '']} | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
line 53: let g:airline#themes#nhooyr#palette.insert_modified = g:airline#themes#nhooyr#palette.insert | |
line 56: let g:airline#themes#nhooyr#palette.insert_paste = { 'airline_a': [ s:I1[0] , '#d78700' , 8 , 235 , '' ] , } | |
line 57: | |
line 58: let g:airline#themes#nhooyr#palette.insert.airline_warning = [ '' , '', 7 , 8] | |
line 59: let s:V1 = [ '#000000' , '#ffaf00' , 8 , 12 ] | |
line 60: let s:V2 = [ '#000000' , '#ff5f00' , 7 , 8 ] | |
line 61: let s:V3 = [ '#ffffff' , '#5f0000' , 7 , 235 ] | |
line 62: let g:airline#themes#nhooyr#palette.visual = airline#themes#generate_color_map(s:V1, s:V2, s:V3) | |
calling function airline#themes#generate_color_map(['#000000', '#ffaf00', 8, 12], ['#000000', '#ff5f00', 7, 8], ['#ffffff', '#5f0000', 7, 235]) | |
line 1: let palette = { 'airline_a': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , get(a:sect1 , 4 , '') ] , 'airline_b': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , get(a:sect2 , 4 , '') ] , 'airline_c': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , get(a:sect3 , 4 , '') ] , } | |
line 6: | |
line 7: if a:0 > 0 | |
line 8: call extend(palette, { 'airline_x': [ a:1[0] , a:1[1] , a:1[2] , a:1[3] , get(a:1 , 4 , '' ) ] , 'airline_y': [ a:2[0] , a:2[1] , a:2[2] , a:2[3] , get(a:2 , 4 , '' ) ] , 'airline_z': [ a:3[0] , a:3[1] , a:3[2] , a:3[3] , get(a:3 , 4 , '' ) ] , }) | |
line 13: else | |
line 14: call extend(palette, { 'airline_x': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , '' ] , 'airline_y': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , '' ] , 'airline_z': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , '' ] , }) | |
line 19: endif | |
line 20: | |
line 21: return palette | |
function airline#themes#generate_color_map returning {'airline_x': ['#ffffff', '#5f0000', ..._c': ['#ffffff', '#5f0000', 7, 235, '']} | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
line 63: let g:airline#themes#nhooyr#palette.visual_modified = g:airline#themes#nhooyr#palette.visual | |
line 64: let g:airline#themes#nhooyr#palette.visual.airline_warning = [ '' , '', 7 , 8] | |
line 65: | |
line 66: | |
line 67: let s:IA1 = [ '#4e4e4e' , '#1c1c1c' , 7 , 235 , '' ] | |
line 68: let s:IA2 = [ '#4e4e4e' , '#262626' , 7 , 235 , '' ] | |
line 69: let s:IA3 = [ '#4e4e4e' , '#303030' , 7 , 235 , '' ] | |
line 70: let g:airline#themes#nhooyr#palette.inactive = airline#themes#generate_color_map(s:IA1, s:IA2, s:IA3) | |
calling function airline#themes#generate_color_map(['#4e4e4e', '#1c1c1c', 7, 235, ''], ['#4e4e4e', '#262626', 7, 235, ''], ['#4e4e4e', '#303030', 7, 235, '']) | |
line 1: let palette = { 'airline_a': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , get(a:sect1 , 4 , '') ] , 'airline_b': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , get(a:sect2 , 4 , '') ] , 'airline_c': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , get(a:sect3 , 4 , '') ] , } | |
line 6: | |
line 7: if a:0 > 0 | |
line 8: call extend(palette, { 'airline_x': [ a:1[0] , a:1[1] , a:1[2] , a:1[3] , get(a:1 , 4 , '' ) ] , 'airline_y': [ a:2[0] , a:2[1] , a:2[2] , a:2[3] , get(a:2 , 4 , '' ) ] , 'airline_z': [ a:3[0] , a:3[1] , a:3[2] , a:3[3] , get(a:3 , 4 , '' ) ] , }) | |
line 13: else | |
line 14: call extend(palette, { 'airline_x': [ a:sect3[0] , a:sect3[1] , a:sect3[2] , a:sect3[3] , '' ] , 'airline_y': [ a:sect2[0] , a:sect2[1] , a:sect2[2] , a:sect2[3] , '' ] , 'airline_z': [ a:sect1[0] , a:sect1[1] , a:sect1[2] , a:sect1[3] , '' ] , }) | |
line 19: endif | |
line 20: | |
line 21: return palette | |
function airline#themes#generate_color_map returning {'airline_x': ['#4e4e4e', '#303030', ..._c': ['#4e4e4e', '#303030', 7, 235, '']} | |
continuing in /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
line 73: let g:airline#themes#nhooyr#palette.inactive_modified = { 'airline_c': [ '#875faf' , 252 , 235 , '' , '' ] , } | |
line 81: let g:airline#themes#nhooyr#palette.tabline = { 'airline_tab': [ '' , '' , 249 , 8, '' ], 'airline_tabsel': [ '' , '' , 8 , 10, '' ], 'airline_tabtype': [ '' , '' , 8 , 6, '' ], 'airline_tabfill': [ '' , '' , 8 , 235 , '' ], 'airline_tabhid': [ '' , '' , 7 , 8, '' ], 'airline_tabmod': [ '' , '' , 8 , 13, ''] } | |
line 82: | |
line 83: " Accents are used to give parts within a section a slightly different look or | |
line 84: " color. Here we are defining a "red" accent, which is used by the 'readonly' | |
line 85: " part by default. Only the foreground colors are specified, so the background | |
line 86: " colors are automatically extracted from the underlying section colors. What | |
line 87: " this means is that regardless of which section the part is defined in, it | |
line 88: " will be red instead of the section's foreground color. You can also have | |
line 89: " multiple parts with accents within a section. | |
line 92: let g:airline#themes#nhooyr#palette.accents = { 'orange': [ '#ff0312' , '' , 8 , '' ] } | |
line 93: | |
line 94: | |
line 95: " Here we define the color map for ctrlp. We check for the g:loaded_ctrlp | |
line 96: " variable so that related functionality is loaded iff the user is using | |
line 97: " ctrlp. Note that this is optional, and if you do not define ctrlp colors | |
line 98: " they will be chosen automatically from the existing palette. | |
line 99: if !get(g:, 'loaded_ctrlp', 0) | |
line 100: ^Ifinish | |
finished sourcing /Users/nhooyr/dotfiles/nvim/autoload/airline/themes/nhooyr.vim | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme | |
line 3: let g:airline_theme = a:name | |
line 4: catch | |
line 5: echohl WarningMsg | echo 'The specified theme cannot be found.' | echohl NONE | |
line 5: echo 'The specified theme cannot be found.' | echohl NONE | |
line 5: echohl NONE | |
line 6: if exists('g:airline_theme') | |
line 7: return | |
line 8: else | |
line 9: let g:airline_theme = 'dark' | |
line 10: endif | |
line 11: endtry | |
line 12: | |
line 13: let w:airline_lastmode = '' | |
line 14: call airline#load_theme() | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme() | |
line 1: if exists('*airline#themes#{g:airline_theme}#refresh') | |
line 2: call airline#themes#{g:airline_theme}#refresh() | |
line 3: endif | |
line 4: | |
line 5: let palette = g:airline#themes#{g:airline_theme}#palette | |
line 6: call airline#themes#patch(palette) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#themes#patch({'normal_modified': {'airline_x': ['#...ts': {'orange': ['#ff0312', '', 8, '']}}) | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 1: for mode in keys(a:palette) | |
line 2: if !has_key(a:palette[mode], 'airline_warning') | |
line 3: let a:palette[mode]['airline_warning'] = [ '#000000', '#df5f00', 232, 166 ] | |
line 4: endif | |
line 5: endfor | |
line 6: | |
line 7: let a:palette.accents = get(a:palette, 'accents', {}) | |
line 8: let a:palette.accents.bold = [ '', '', '', '', 'bold' ] | |
line 9: let a:palette.accents.italic = [ '', '', '', '', 'italic' ] | |
line 10: | |
line 11: if !has_key(a:palette.accents, 'red') | |
line 12: let a:palette.accents.red = [ '#ff0000' , '' , 160 , '' ] | |
line 13: endif | |
line 14: if !has_key(a:palette.accents, 'green') | |
line 15: let a:palette.accents.green = [ '#008700' , '' , 22 , '' ] | |
line 16: endif | |
line 17: if !has_key(a:palette.accents, 'blue') | |
line 18: let a:palette.accents.blue = [ '#005fff' , '' , 27 , '' ] | |
line 19: endif | |
line 20: if !has_key(a:palette.accents, 'yellow') | |
line 21: let a:palette.accents.yellow = [ '#dfff00' , '' , 190 , '' ] | |
line 22: endif | |
line 23: if !has_key(a:palette.accents, 'orange') | |
line 24: let a:palette.accents.orange = [ '#df5f00' , '' , 166 , '' ] | |
line 25: endif | |
line 26: if !has_key(a:palette.accents, 'purple') | |
line 27: let a:palette.accents.purple = [ '#af00df' , '' , 128 , '' ] | |
line 28: endif | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#themes#patch returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme | |
line 7: | |
line 8: if exists('g:airline_theme_patch_func') | |
line 9: let Fn = function(g:airline_theme_patch_func) | |
line 10: call Fn(palette) | |
line 11: endif | |
line 12: | |
line 13: call airline#highlighter#load_theme() | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme() | |
line 1: for winnr in filter(range(1, winnr('$')), 'v:val != winnr()') | |
line 2: call airline#highlighter#highlight_modified_inactive(winbufnr(winnr)) | |
line 3: endfor | |
line 4: call airline#highlighter#highlight(['inactive']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight(['inactive']) | |
line 1: let p = g:airline#themes#{g:airline_theme}#palette | |
line 2: | |
line 3: " draw the base mode, followed by any overrides | |
line 4: let mapped = map(a:modes, 'v:val == a:modes[0] ? v:val : a:modes[0]."_".v:val') | |
line 5: let suffix = a:modes[0] == 'inactive' ? '_inactive' : '' | |
line 6: for mode in mapped | |
line 7: if exists('g:airline#themes#{g:airline_theme}#palette[mode]') | |
line 8: let dict = g:airline#themes#{g:airline_theme}#palette[mode] | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x_inactive', ['#4e4e4e', '#303030', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x_inactive guifg=#4e4e4e guibg=#303030 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x_inactive_bold', ['#4e4e4e', '#303030', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x_inactive_bold guifg=#4e4e4e guibg=#303030 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x_inactive_red', ['#ff0000', '#303030', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x_inactive_red guifg=#ff0000 guibg=#303030 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y_inactive', ['#4e4e4e', '#262626', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y_inactive guifg=#4e4e4e guibg=#262626 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y_inactive_bold', ['#4e4e4e', '#262626', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y_inactive_bold guifg=#4e4e4e guibg=#262626 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y_inactive_red', ['#ff0000', '#262626', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y_inactive_red guifg=#ff0000 guibg=#262626 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z_inactive', ['#4e4e4e', '#1c1c1c', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z_inactive guifg=#4e4e4e guibg=#1c1c1c ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z_inactive_bold', ['#4e4e4e', '#1c1c1c', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z_inactive_bold guifg=#4e4e4e guibg=#1c1c1c ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z_inactive_red', ['#ff0000', '#1c1c1c', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z_inactive_red guifg=#ff0000 guibg=#1c1c1c ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a_inactive', ['#4e4e4e', '#1c1c1c', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a_inactive guifg=#4e4e4e guibg=#1c1c1c ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a_inactive_bold', ['#4e4e4e', '#1c1c1c', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a_inactive_bold guifg=#4e4e4e guibg=#1c1c1c ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a_inactive_red', ['#ff0000', '#1c1c1c', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a_inactive_red guifg=#ff0000 guibg=#1c1c1c ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b_inactive', ['#4e4e4e', '#262626', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b_inactive guifg=#4e4e4e guibg=#262626 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b_inactive_bold', ['#4e4e4e', '#262626', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b_inactive_bold guifg=#4e4e4e guibg=#262626 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b_inactive_red', ['#ff0000', '#262626', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b_inactive_red guifg=#ff0000 guibg=#262626 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c_inactive', ['#4e4e4e', '#303030', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c_inactive guifg=#4e4e4e guibg=#303030 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c_inactive_bold', ['#4e4e4e', '#303030', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c_inactive_bold guifg=#4e4e4e guibg=#303030 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c_inactive_red', ['#ff0000', '#303030', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c_inactive_red guifg=#ff0000 guibg=#303030 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_warning_inactive', ['#000000', '#df5f00', 232, 166]) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_warning_inactive guifg=#000000 guibg=#df5f00 ctermfg=232 ctermbg=166 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_warning_inactive_bold', ['#000000', '#df5f00', 232, 166, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_warning_inactive_bold guifg=#000000 guibg=#df5f00 ctermfg=232 ctermbg=166 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_warning_inactive_red', ['#ff0000', '#df5f00', 160, 166, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_warning_inactive_red guifg=#ff0000 guibg=#df5f00 ctermfg=160 ctermbg=166 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 32: | |
line 33: " TODO: optimize this | |
line 34: for sep in items(s:separators) | |
line 35: call <sid>exec_separator(dict, sep[1][0], sep[1][1], sep[1][2], suffix) | |
line 36: endfor | |
line 37: endif | |
line 38: endfor | |
line 6: for mode in mapped | |
line 7: if exists('g:airline#themes#{g:airline_theme}#palette[mode]') | |
line 8: let dict = g:airline#themes#{g:airline_theme}#palette[mode] | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 32: | |
line 33: " TODO: optimize this | |
line 34: for sep in items(s:separators) | |
line 35: call <sid>exec_separator(dict, sep[1][0], sep[1][1], sep[1][2], suffix) | |
line 36: endfor | |
line 37: endif | |
line 38: endfor | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme | |
line 5: call airline#highlighter#highlight(['normal']) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight(['normal']) | |
line 1: let p = g:airline#themes#{g:airline_theme}#palette | |
line 2: | |
line 3: " draw the base mode, followed by any overrides | |
line 4: let mapped = map(a:modes, 'v:val == a:modes[0] ? v:val : a:modes[0]."_".v:val') | |
line 5: let suffix = a:modes[0] == 'inactive' ? '_inactive' : '' | |
line 6: for mode in mapped | |
line 7: if exists('g:airline#themes#{g:airline_theme}#palette[mode]') | |
line 8: let dict = g:airline#themes#{g:airline_theme}#palette[mode] | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x', ['#9cffd3', '#202020', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x guifg=#9cffd3 guibg=#202020 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x_bold', ['#9cffd3', '#202020', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x_bold guifg=#9cffd3 guibg=#202020 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_x_red', ['#ff0000', '#202020', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_x_red guifg=#ff0000 guibg=#202020 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y', ['#ffffff', '#444444', 7, 8, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y guifg=#ffffff guibg=#444444 ctermfg=7 ctermbg=8 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y_bold', ['#ffffff', '#444444', 7, 8, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y_bold guifg=#ffffff guibg=#444444 ctermfg=7 ctermbg=8 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_y_red', ['#ff0000', '#444444', 160, 8, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_y_red guifg=#ff0000 guibg=#444444 ctermfg=160 ctermbg=8 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z', ['#00005f', '#dfff00', 8, 3, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z guifg=#00005f guibg=#dfff00 ctermfg=8 ctermbg=3 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z_bold', ['#00005f', '#dfff00', 8, 3, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z_bold guifg=#00005f guibg=#dfff00 ctermfg=8 ctermbg=3 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_z_red', ['#ff0000', '#dfff00', 160, 3, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_z_red guifg=#ff0000 guibg=#dfff00 ctermfg=160 ctermbg=3 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a', ['#00005f', '#dfff00', 8, 3, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a guifg=#00005f guibg=#dfff00 ctermfg=8 ctermbg=3 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a_bold', ['#00005f', '#dfff00', 8, 3, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a_bold guifg=#00005f guibg=#dfff00 ctermfg=8 ctermbg=3 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_a_red', ['#ff0000', '#dfff00', 160, 3, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_a_red guifg=#ff0000 guibg=#dfff00 ctermfg=160 ctermbg=3 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b', ['#ffffff', '#444444', 7, 8, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b guifg=#ffffff guibg=#444444 ctermfg=7 ctermbg=8 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b_bold', ['#ffffff', '#444444', 7, 8, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b_bold guifg=#ffffff guibg=#444444 ctermfg=7 ctermbg=8 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_b_red', ['#ff0000', '#444444', 160, 8, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_b_red guifg=#ff0000 guibg=#444444 ctermfg=160 ctermbg=8 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: call airline#highlighter#exec(kvp[0].suffix, mode_colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c', ['#9cffd3', '#202020', 7, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c guifg=#9cffd3 guibg=#202020 ctermfg=7 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 12: | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c_bold', ['#9cffd3', '#202020', 7, 235, 'bold']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c_bold guifg=#9cffd3 guibg=#202020 ctermfg=7 ctermbg=235 gui=bold cterm=bold term=bold | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
calling function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec('airline_c_red', ['#ff0000', '#202020', 160, 235, '']) | |
line 1: let colors = a:colors | |
line 2: if s:is_win32term | |
line 3: let colors[2] = s:gui2cui(get(colors, 0, ''), get(colors, 2, '')) | |
line 4: let colors[3] = s:gui2cui(get(colors, 1, ''), get(colors, 3, '')) | |
line 5: endif | |
line 6: exec printf('hi %s %s %s %s %s %s %s %s', a:group, get(colors, 0, '') != '' ? 'guifg='.colors[0] : '', get(colors, 1, '') != '' ? 'guibg='.colors[1] : '', get(colors, 2, '') != '' ? 'ctermfg='.colors[2] : '', get(colors, 3, '') != '' ? 'ctermbg='.colors[3] : '', get(colors, 4, '') != '' ? 'gui='.colors[4] : '', get(colors, 4, '') != '' ? 'cterm='.colors[4] : '', get(colors, 4, '') != '' ? 'term='.colors[4] : '') | |
line 6: hi airline_c_red guifg=#ff0000 guibg=#202020 ctermfg=160 ctermbg=235 | |
function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight..airline#highlighter#exec returning #0 | |
continuing in function <SNR>20_on_window_changed..<SNR>20_init..airline#switch_theme..airline#load_theme..airline#highlighter#load_theme..airline#highlighter#highlight | |
line 30: endfor | |
line 13: for accent in keys(s:accents) | |
line 14: if !has_key(p.accents, accent) | |
line 15: continue | |
line 16: endif | |
line 17: let colors = copy(mode_colors) | |
line 18: if p.accents[accent][0] != '' | |
line 19: let colors[0] = p.accents[accent][0] | |
line 20: endif | |
line 21: if p.accents[accent][2] != '' | |
line 22: let colors[2] = p.accents[accent][2] | |
line 23: endif | |
line 24: if len(colors) >= 5 | |
line 25: let colors[4] = get(p.accents[accent], 4, '') | |
line 26: else | |
line 27: call add(colors, get(p.accents[accent], 4, '')) | |
line 28: endif | |
line 29: call airline#highlighter#exec(kvp[0].suffix.'_'.accent, colors) | |
line 30: endfor | |
line 31: endfor | |
line 9: for kvp in items(dict) | |
line 10: let mode_colors = kvp[1] | |
line 11: |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment