Created
February 2, 2017 22:29
-
-
Save marcusbuffett/fdcb92bde17f5117827fe26c55c89464 to your computer and use it in GitHub Desktop.
neomake prof
This file contains hidden or 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
| SCRIPT /Users/marcusbuffett/.vim/plugged/neomake/autoload/neomake/makers/ft/java.vim | |
| Sourced 1 time | |
| Total time: 0.000946 | |
| Self time: 0.000946 | |
| count total (s) self (s) | |
| "============================================================================ | |
| "File: java.vim | |
| "Description: Syntax checking plugin for neomake | |
| "Maintainer: Wang Shidong <wsdjeg at outlook dot com> | |
| "License: This program is free software. It comes without any warranty, | |
| " to the extent permitted by applicable law. You can redistribute | |
| " it and/or modify it under the terms of the Do What The Fuck You | |
| " Want To Public License, Version 2, as published by Sam Hocevar. | |
| " See http://sam.zoy.org/wtfpl/COPYING for more details. | |
| "============================================================================ | |
| 1 0.000007 let s:save_cpo = &cpoptions | |
| 1 0.000006 set cpoptions&vim | |
| 1 0.000006 if exists('g:neomake_java_javac_maker') | |
| finish | |
| endif | |
| 1 0.000002 let g:neomake_java_javac_maker = 1 | |
| 1 0.000003 let g:neomake_java_javac_maven_pom_tags = ['build', 'properties'] | |
| 1 0.000002 let g:neomake_java_javac_maven_pom_properties = {} | |
| 1 0.000012 let s:is_windows = has('win32') || has('win64') || has('win16') || has('dos32') || has('dos16') | |
| 1 0.000002 if s:is_windows | |
| let s:fsep = ';' | |
| let s:psep = '\' | |
| else | |
| 1 0.000002 let s:fsep = ':' | |
| 1 0.000001 let s:psep = '/' | |
| 1 0.000001 endif | |
| 1 0.000019 let g:neomake_java_checker_home = fnamemodify(expand('<sfile>'), ':p:h:gs?\\?/?') | |
| " custom options | |
| 1 0.000005 let g:neomake_java_javac_executable = | |
| \ get(g:, 'neomake_java_javac_executable', 'javac') | |
| 1 0.000004 let g:neomake_java_maven_executable = | |
| \ get(g:, 'neomake_java_maven_executable', 'mvn') | |
| 1 0.000005 let g:neomake_java_gradle_executable = | |
| \ get(g:, 'neomake_java_gradle_executable', s:is_windows? '.\gradlew.bat' : './gradlew') | |
| 1 0.000004 let g:neomake_java_checkstyle_executable = | |
| \ get(g:, 'neomake_java_checkstyle_executable', 'checkstyle') | |
| 1 0.000004 let g:neomake_java_javac_options = | |
| \ get(g:, 'neomake_java_javac_options', ['-Xlint']) | |
| 1 0.000004 let g:neomake_java_maven_options = | |
| \ get(g:, 'neomake_java_maven_options', '') | |
| 1 0.000003 let g:neomake_java_javac_classpath = | |
| \ get(g:, 'neomake_java_javac_classpath', '') | |
| 1 0.000004 let g:neomake_java_javac_outputdir = | |
| \ get(g:, 'neomake_java_javac_outputdir', '') | |
| 1 0.000004 let g:neomake_java_checkstyle_xml = | |
| \ get(g:, 'neomake_java_checkstyle_xml', '/usr/share/checkstyle/google_checks.xml') | |
| 1 0.000003 let g:neomake_java_javac_delete_output = | |
| \ get(g:, 'neomake_java_javac_delete_output', 1) | |
| 1 0.000004 let g:neomake_java_javac_autoload_maven_classpath = | |
| \ get(g:, 'neomake_java_javac_autoload_maven_classpath', 1) | |
| 1 0.000004 let g:neomake_java_javac_autoload_gradle_classpath = | |
| \ get(g:, 'neomake_java_javac_autoload_gradle_classpath', 1) | |
| 1 0.000004 let g:neomake_java_javac_autoload_eclipse_classpath = | |
| \ get(g:, 'neomake_java_javac_autoload_eclipse_classpath', 1) | |
| 1 0.000003 let g:neomake_java_javac_maven_pom_ftime = | |
| \ get(g:, 'neomake_java_javac_maven_pom_ftime', {}) | |
| 1 0.000004 let g:neomake_java_javac_maven_pom_classpath = | |
| \ get(g:, 'neomake_java_javac_maven_pom_classpath', {}) | |
| 1 0.000004 let g:neomake_java_javac_gradle_ftime = | |
| \ get(g:, 'neomake_java_javac_gradle_ftime', {}) | |
| 1 0.000004 let g:neomake_java_javac_gradle_classpath = | |
| \ get(g:, 'neomake_java_javac_gradle_classpath', {}) | |
| 1 0.000061 let s:has_maven = executable(expand(g:neomake_java_maven_executable, 1)) | |
| 1 0.000010 let s:has_gradle = executable(expand(g:neomake_java_gradle_executable, 1)) | |
| 1 0.000003 function! s:tmpdir() abort | |
| let tempdir = '' | |
| if (has('unix') || has('mac')) && executable('mktemp') && !has('win32unix') | |
| " TODO: option "-t" to mktemp(1) is not portable | |
| let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp' | |
| let out = split(system('mktemp -q -d ' . tmp . '/neomake-java-' . getpid() . '-XXXXXXXX'), "\n") | |
| if v:shell_error == 0 && len(out) == 1 | |
| let tempdir = out[0] | |
| endif | |
| endif | |
| if tempdir ==# '' | |
| if has('win32') || has('win64') | |
| let tempdir = $TEMP . s:psep . 'neomake-java-' . getpid() | |
| elseif has('win32unix') | |
| let tempdir = substitute(system('cygpath -m ' . s:shescape('/neomake-java-' . getpid())), "\n", '', 'g') | |
| elseif $TMPDIR !=# '' | |
| let tempdir = $TMPDIR . '/neomake-java-' . getpid() | |
| else | |
| let tempdir = '/tmp/neomake-java-' . getpid() | |
| endif | |
| try | |
| call mkdir(tempdir, 'p', 0700) | |
| catch /\m^Vim\%((\a\+)\)\=:E739/ | |
| let tempdir = '.' | |
| endtry | |
| endif | |
| return tempdir | |
| endfunction | |
| 1 0.000005 function! s:ClassSep() abort | |
| return (s:is_windows || has('win32unix')) ? ';' : ':' | |
| endfunction | |
| 1 0.000002 function! s:shescape(string) abort | |
| return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) | |
| endfunction | |
| 1 0.000002 function! s:AddToClasspath(classpath, path) abort | |
| if a:path ==# '' | |
| return a:classpath | |
| endif | |
| return (a:classpath !=# '') ? a:classpath . s:ClassSep() . a:path : a:path | |
| endfunction | |
| " @vimlint(EVL103, 1, a:classpathFile) | |
| 1 0.000002 function! s:ReadClassPathFile(classpathFile) abort | |
| let cp = '' | |
| let file = g:neomake_java_checker_home. s:psep. 'java'. s:psep. 'classpath.py' | |
| if has('python3') | |
| execute 'py3file' file | |
| py3 import vim | |
| py3 vim.command("let cp = '%s'" % os.pathsep.join(ReadClasspathFile(vim.eval('a:classpathFile'))).replace('\\', '/')) | |
| elseif has('python') | |
| execute 'pyfile' file | |
| py import vim | |
| py vim.command("let cp = '%s'" % os.pathsep.join(ReadClasspathFile(vim.eval('a:classpathFile'))).replace('\\', '/')) | |
| endif | |
| return cp | |
| endfunction | |
| " @vimlint(EVL103, 0) | |
| 1 0.000004 function! neomake#makers#ft#java#EnabledMakers() abort | |
| let makers = [] | |
| if executable(expand(g:neomake_java_javac_executable, 1)) | |
| call add(makers, g:neomake_java_javac_executable) | |
| endif | |
| if executable(expand(g:neomake_java_checkstyle_executable, 1)) | |
| call add(makers, g:neomake_java_checkstyle_executable) | |
| endif | |
| return makers | |
| endfunction | |
| 1 0.000003 function! neomake#makers#ft#java#javac() abort | |
| let javac_opts = extend([], g:neomake_java_javac_options) | |
| let output_dir = '' | |
| if g:neomake_java_javac_delete_output | |
| let output_dir = s:tmpdir() | |
| let javac_opts = extend(javac_opts, ['-d', s:shescape(output_dir)]) | |
| endif | |
| let javac_classpath = get(g:, 'neomake_java_javac_classpath', '') | |
| if s:has_maven && g:neomake_java_javac_autoload_maven_classpath && empty(javac_classpath) | |
| if !g:neomake_java_javac_delete_output | |
| let javac_opts = extend(javac_opts, ['-d', s:shescape(s:MavenOutputDirectory())]) | |
| endif | |
| let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath()) | |
| endif | |
| if s:has_gradle && g:neomake_java_javac_autoload_gradle_classpath && empty(javac_classpath) | |
| if !g:neomake_java_javac_delete_output | |
| let javac_opts = extend(javac_opts, ['-d', s:shescape(s:GradleOutputDirectory())]) | |
| endif | |
| let javac_classpath = s:AddToClasspath(javac_classpath, s:GetGradleClasspath()) | |
| endif | |
| if (has('python') || has('python3')) && empty(javac_classpath) | |
| let classpathFile = fnamemodify(findfile('.classpath', escape(expand('.'), '*[]?{}, ') . ';'), ':p') | |
| if !empty(classpathFile) && filereadable(classpathFile) | |
| let javac_classpath = s:ReadClassPathFile(classpathFile) | |
| endif | |
| endif | |
| if javac_classpath !=# '' | |
| let javac_opts = extend(javac_opts, ['-cp', javac_classpath]) | |
| endif | |
| return { | |
| \ 'args': javac_opts, | |
| \ 'exe': g:neomake_java_javac_executable, | |
| \ 'errorformat': | |
| \ '%E%f:%l: error: %m,'. | |
| \ '%W%f:%l: warning: %m,'. | |
| \ '%E%f:%l: %m,'. | |
| \ '%Z%p^,'. | |
| \ '%-G%.%#' | |
| \ } | |
| endfunction | |
| 1 0.000003 function! neomake#makers#ft#java#checkstyle() abort | |
| return { | |
| \ 'args': ['-c', g:neomake_java_checkstyle_xml], | |
| \ 'exe': g:neomake_java_checkstyle_executable, | |
| \ 'errorformat': | |
| \ '[%t%*[^]]] %f:%l:%c: %m [%s]' | |
| \ } | |
| endfunction | |
| 1 0.000002 function! s:findFileInParent(what, where) abort " {{{2 | |
| let old_suffixesadd = &suffixesadd | |
| let &suffixesadd = '' | |
| let file = findfile(a:what, escape(a:where, ' ') . ';') | |
| let &suffixesadd = old_suffixesadd | |
| return file | |
| endfunction " }}}2 | |
| 1 0.000003 function! s:GetMavenProperties() abort " {{{2 | |
| let mvn_properties = {} | |
| let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) | |
| if s:has_maven && filereadable(pom) | |
| if !has_key(g:neomake_java_javac_maven_pom_properties, pom) | |
| let mvn_cmd = s:shescape(expand(g:neomake_java_maven_executable, 1)) . | |
| \ ' -f ' . s:shescape(pom) . | |
| \ ' ' . g:neomake_java_maven_options | |
| let mvn_is_managed_tag = 1 | |
| let mvn_settings_output = split(system(mvn_cmd . ' help:effective-pom'), "\n") | |
| let current_path = 'project' | |
| for line in mvn_settings_output | |
| let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\s*$') | |
| if mvn_is_managed_tag && !empty(matches) | |
| let mvn_is_managed_tag = index(g:neomake_java_javac_maven_pom_tags, matches[1]) >= 0 | |
| let current_path .= '.' . matches[1] | |
| else | |
| let matches = matchlist(line, '\m^\s*</\([a-zA-Z0-9\-\.]\+\)>\s*$') | |
| if !empty(matches) | |
| let mvn_is_managed_tag = index(g:neomake_java_javac_maven_pom_tags, matches[1]) < 0 | |
| let current_path = substitute(current_path, '\m\.' . matches[1] . '$', '', '') | |
| else | |
| let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)</[a-zA-Z0-9\-\.]\+>\s*$') | |
| if mvn_is_managed_tag && !empty(matches) | |
| let mvn_properties[current_path . '.' . matches[1]] = matches[2] | |
| endif | |
| endif | |
| endif | |
| endfor | |
| let g:neomake_java_javac_maven_pom_properties[pom] = mvn_properties | |
| endif | |
| return g:neomake_java_javac_maven_pom_properties[pom] | |
| endif | |
| return mvn_properties | |
| endfunction " }}}2 | |
| 1 0.000002 function! s:GetMavenClasspath() abort " {{{2 | |
| let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) | |
| if s:has_maven && filereadable(pom) | |
| if !has_key(g:neomake_java_javac_maven_pom_ftime, pom) || g:neomake_java_javac_maven_pom_ftime[pom] != getftime(pom) | |
| let mvn_cmd = s:shescape(expand(g:neomake_java_maven_executable, 1)) . | |
| \ ' -f ' . s:shescape(pom) . | |
| \ ' ' . g:neomake_java_maven_options | |
| let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath -DincludeScope=test'), "\n") | |
| let mvn_classpath = '' | |
| let class_path_next = 0 | |
| for line in mvn_classpath_output | |
| if class_path_next == 1 | |
| let mvn_classpath = substitute(line, "\r", '', 'g') | |
| break | |
| endif | |
| if stridx(line, 'Dependencies classpath:') >= 0 | |
| let class_path_next = 1 | |
| endif | |
| endfor | |
| let mvn_properties = s:GetMavenProperties() | |
| let output_dir = get(mvn_properties, 'project.build.outputDirectory', join(['target', 'classes'], s:psep)) | |
| let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir) | |
| let test_output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join(['target', 'test-classes'], s:psep)) | |
| let mvn_classpath = s:AddToClasspath(mvn_classpath, test_output_dir) | |
| let g:neomake_java_javac_maven_pom_ftime[pom] = getftime(pom) | |
| let g:neomake_java_javac_maven_pom_classpath[pom] = mvn_classpath | |
| endif | |
| return g:neomake_java_javac_maven_pom_classpath[pom] | |
| endif | |
| return '' | |
| endfunction " }}}2 | |
| 1 0.000002 function! s:MavenOutputDirectory() abort " {{{2 | |
| let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) | |
| if s:has_maven && filereadable(pom) | |
| let mvn_properties = s:GetMavenProperties() | |
| let output_dir = get(mvn_properties, 'project.properties.build.dir', getcwd()) | |
| let src_main_dir = get(mvn_properties, 'project.build.sourceDirectory', join(['src', 'main', 'java'], s:psep)) | |
| let src_test_dir = get(mvn_properties, 'project.build.testsourceDirectory', join(['src', 'test', 'java'], s:psep)) | |
| if stridx(expand('%:p:h', 1), src_main_dir) >= 0 | |
| let output_dir = get(mvn_properties, 'project.build.outputDirectory', join ([output_dir, 'target', 'classes'], s:psep)) | |
| endif | |
| if stridx(expand('%:p:h', 1), src_test_dir) >= 0 | |
| let output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join([output_dir, 'target', 'test-classes'], s:psep)) | |
| endif | |
| if has('win32unix') | |
| let output_dir = substitute(system('cygpath -m ' . s:shescape(output_dir)), "\n", '', 'g') | |
| endif | |
| return output_dir | |
| endif | |
| return '.' | |
| endfunction " }}}2 | |
| 1 0.000005 function! s:GradleOutputDirectory() abort | |
| let gradle_build = s:findFileInParent('build.gradle', expand('%:p:h', 1)) | |
| let items = split(gradle_build, s:psep) | |
| if len(items)==1 | |
| return join(['build', 'intermediates', 'classes', 'debug'], s:psep) | |
| endif | |
| let outputdir = '' | |
| for i in items | |
| if i !=# 'build.gradle' | |
| let outputdir .= i . s:psep | |
| endif | |
| endfor | |
| return outputdir . join(['build', 'intermediates', 'classes', 'debug'], s:psep) | |
| endf | |
| 1 0.000002 function! s:GetGradleClasspath() abort | |
| let gradle = s:findFileInParent('build.gradle', expand('%:p:h', 1)) | |
| if s:has_gradle && filereadable(gradle) | |
| if !has_key(g:neomake_java_javac_gradle_ftime, gradle) || g:neomake_java_javac_gradle_ftime[gradle] != getftime(gradle) | |
| try | |
| let f = tempname() | |
| if s:is_windows | |
| let gradle_cmd = '.\gradlew.bat' | |
| else | |
| let gradle_cmd = './gradlew' | |
| endif | |
| call writefile(["allprojects{apply from: '" . g:neomake_java_checker_home . s:psep. 'java'. s:psep. "classpath.gradle'}"], f) | |
| let ret = system(gradle_cmd . ' -q -I ' . shellescape(f) . ' classpath' ) | |
| if v:shell_error == 0 | |
| let cp = filter(split(ret, "\n"), "v:val =~# '^CLASSPATH:'")[0][10:] | |
| if filereadable(getcwd() . s:psep . 'build.gradle') | |
| let out_putdir = s:GlobPathList(getcwd(), join( | |
| \ ['**', 'build', 'intermediates', 'classes', 'debug'], | |
| \ s:psep), 0) | |
| for classes in out_putdir | |
| let cp .= s:ClassSep() . classes | |
| endfor | |
| endif | |
| else | |
| let cp = '' | |
| endif | |
| catch | |
| finally | |
| call delete(f) | |
| endtry | |
| let g:neomake_java_javac_gradle_ftime[gradle] = getftime(gradle) | |
| let g:neomake_java_javac_gradle_classpath[gradle] = cp | |
| endif | |
| return g:neomake_java_javac_gradle_classpath[gradle] | |
| endif | |
| return '' | |
| endf | |
| 1 0.000003 function! s:GlobPathList(path, pattern, suf) abort | |
| if v:version >= 705 || (v:version == 704 && has('patch279')) | |
| return globpath(a:path, a:pattern, a:suf, 1) | |
| else | |
| return split(globpath(a:path, a:pattern, a:suf), "\n") | |
| endif | |
| endfunction | |
| 1 0.000008 let &cpoptions = s:save_cpo | |
| 1 0.000004 unlet s:save_cpo | |
| SCRIPT /usr/local/Cellar/neovim/0.1.7/share/nvim/runtime/autoload/provider/python.vim | |
| Sourced 1 time | |
| Total time: 0.049101 | |
| Self time: 0.000461 | |
| count total (s) self (s) | |
| " The Python provider uses a Python host to emulate an environment for running | |
| " python-vim plugins. See ":help provider". | |
| " | |
| " Associating the plugin with the Python host is the first step because plugins | |
| " will be passed as command-line arguments | |
| 1 0.000006 if exists('g:loaded_python_provider') | |
| finish | |
| endif | |
| 1 0.000004 let g:loaded_python_provider = 1 | |
| 1 0.000088 let [s:prog, s:err] = provider#pythonx#Detect(2) | |
| 1 0.000004 function! provider#python#Prog() | |
| return s:prog | |
| endfunction | |
| 1 0.000002 function! provider#python#Error() | |
| return s:err | |
| endfunction | |
| 1 0.000002 if s:prog == '' | |
| " Detection failed | |
| finish | |
| endif | |
| " The Python provider plugin will run in a separate instance of the Python | |
| " host. | |
| 1 0.000037 0.000017 call remote#host#RegisterClone('legacy-python-provider', 'python') | |
| 1 0.000086 0.000012 call remote#host#RegisterPlugin('legacy-python-provider', 'script_host.py', []) | |
| 1 0.000003 function! provider#python#Call(method, args) | |
| if s:err != '' | |
| return | |
| endif | |
| if !exists('s:host') | |
| let s:rpcrequest = function('rpcrequest') | |
| " Ensure that we can load the Python host before bootstrapping | |
| try | |
| let s:host = remote#host#Require('legacy-python-provider') | |
| catch | |
| let s:err = v:exception | |
| echohl WarningMsg | |
| echomsg v:exception | |
| echohl None | |
| return | |
| endtry | |
| endif | |
| return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| endfunction | |
| SCRIPT /usr/local/Cellar/neovim/0.1.7/share/nvim/runtime/autoload/provider/pythonx.vim | |
| Sourced 1 time | |
| Total time: 0.000488 | |
| Self time: 0.000488 | |
| count total (s) self (s) | |
| " The Python provider helper | |
| 1 0.000008 if exists('s:loaded_pythonx_provider') | |
| finish | |
| endif | |
| 1 0.000005 let s:loaded_pythonx_provider = 1 | |
| 1 0.000003 let s:stderr = {} | |
| 1 0.000005 let s:job_opts = {'rpc': v:true} | |
| " TODO(bfredl): this logic is common and should be builtin | |
| 1 0.000005 function! s:job_opts.on_stderr(chan_id, data, event) | |
| let stderr = get(s:stderr, a:chan_id, ['']) | |
| let last = remove(stderr, -1) | |
| let a:data[0] = last.a:data[0] | |
| call extend(stderr, a:data) | |
| let s:stderr[a:chan_id] = stderr | |
| endfunction | |
| 1 0.000005 function! provider#pythonx#Require(host) abort | |
| let ver = (a:host.orig_name ==# 'python') ? 2 : 3 | |
| " Python host arguments | |
| let prog = (ver == '2' ? provider#python#Prog() : provider#python3#Prog()) | |
| let args = [prog, '-c', 'import sys; sys.path.remove(""); import neovim; neovim.start_host()'] | |
| " Collect registered Python plugins into args | |
| let python_plugins = remote#host#PluginsForHost(a:host.name) | |
| for plugin in python_plugins | |
| call add(args, plugin.path) | |
| endfor | |
| try | |
| let channel_id = jobstart(args, s:job_opts) | |
| if rpcrequest(channel_id, 'poll') ==# 'ok' | |
| return channel_id | |
| endif | |
| catch | |
| echomsg v:throwpoint | |
| echomsg v:exception | |
| for row in get(s:stderr, channel_id, []) | |
| echomsg row | |
| endfor | |
| endtry | |
| throw remote#host#LoadErrorForHost(a:host.orig_name, | |
| \ '$NVIM_PYTHON_LOG_FILE') | |
| endfunction | |
| 1 0.000004 function! provider#pythonx#Detect(major_ver) abort | |
| let host_var = (a:major_ver == 2) ? | |
| \ 'g:python_host_prog' : 'g:python3_host_prog' | |
| let skip_var = (a:major_ver == 2) ? | |
| \ 'g:python_host_skip_check' : 'g:python3_host_skip_check' | |
| let skip = exists(skip_var) ? {skip_var} : 0 | |
| if exists(host_var) | |
| " Disable auto detection. | |
| let [result, err] = s:check_interpreter({host_var}, a:major_ver, skip) | |
| if result | |
| return [{host_var}, err] | |
| endif | |
| return ['', 'provider/pythonx: Could not load Python ' . a:major_ver | |
| \ . ' from ' . host_var . ': ' . err] | |
| endif | |
| let prog_suffixes = (a:major_ver == 2) ? | |
| \ ['2', '2.7', '2.6', ''] | |
| \ : ['3', '3.5', '3.4', '3.3', ''] | |
| let errors = [] | |
| for prog in map(prog_suffixes, "'python' . v:val") | |
| let [result, err] = s:check_interpreter(prog, a:major_ver, skip) | |
| if result | |
| return [prog, err] | |
| endif | |
| " Accumulate errors in case we don't find | |
| " any suitable Python interpreter. | |
| call add(errors, err) | |
| endfor | |
| " No suitable Python interpreter found. | |
| return ['', 'provider/pythonx: Could not load Python ' . a:major_ver | |
| \ . ":\n" . join(errors, "\n")] | |
| endfunction | |
| 1 0.000005 function! s:check_interpreter(prog, major_ver, skip) abort | |
| let prog_path = exepath(a:prog) | |
| if prog_path ==# '' | |
| return [0, a:prog . ' not found in search path or not executable.'] | |
| endif | |
| if a:skip | |
| return [1, ''] | |
| endif | |
| let min_version = (a:major_ver == 2) ? '2.6' : '3.3' | |
| " Try to load neovim module, and output Python version. | |
| " Return codes: | |
| " 0 Neovim module can be loaded. | |
| " 2 Neovim module cannot be loaded. | |
| " Otherwise something else went wrong (e.g. 1 or 127). | |
| 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))' | |
| \ ]) | |
| if v:shell_error == 2 || v:shell_error == 0 | |
| " Check version only for expected return codes. | |
| if prog_ver !~ '^' . a:major_ver | |
| return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python ' | |
| \ . a:major_ver . '.'] | |
| elseif prog_ver =~ '^' . a:major_ver && prog_ver < min_version | |
| return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python >= ' | |
| \ . min_version . '.'] | |
| endif | |
| endif | |
| if v:shell_error == 2 | |
| return [0, prog_path . ' does not have the neovim module installed. ' | |
| \ . 'See ":help provider-python".'] | |
| elseif v:shell_error == 127 | |
| " This can happen with pyenv's shims. | |
| return [0, prog_path . ' does not exist: ' . prog_ver] | |
| elseif v:shell_error | |
| return [0, 'Checking ' . prog_path . ' caused an unknown error. ' | |
| \ . '(' . v:shell_error . ', output: ' . prog_ver . ')' | |
| \ . ' Please report this at github.com/neovim/neovim.'] | |
| endif | |
| return [1, ''] | |
| endfunction | |
| SCRIPT /Users/marcusbuffett/.vim/plugged/neomake/autoload/neomake/compat.vim | |
| Sourced 1 time | |
| Total time: 0.000025 | |
| Self time: 0.000025 | |
| count total (s) self (s) | |
| " Function to wrap Compatibility across different (Neo)Vim versions. | |
| 1 0.000004 if v:version >= 704 | |
| 1 0.000004 function! neomake#compat#getbufvar(buf, key, def) abort | |
| return getbufvar(a:buf, a:key, a:def) | |
| endfunction | |
| 1 0.000001 else | |
| function! neomake#compat#getbufvar(buf, key, def) abort | |
| return get(getbufvar(a:buf, ''), a:key, a:def) | |
| endfunction | |
| endif | |
| SCRIPT /Users/marcusbuffett/.vim/plugged/neomake/autoload/neomake/statusline.vim | |
| Sourced 1 time | |
| Total time: 0.000097 | |
| Self time: 0.000097 | |
| count total (s) self (s) | |
| let s:qflist_counts = {} | |
| 1 0.000002 let s:loclist_counts = {} | |
| 1 0.000004 function! s:setCount(counts, item, buf) abort | |
| let type = toupper(a:item.type) | |
| if len(type) && (!a:buf || a:item.bufnr ==# a:buf) | |
| let a:counts[type] = get(a:counts, type, 0) + 1 | |
| return 1 | |
| endif | |
| return 0 | |
| endfunction | |
| 1 0.000003 function! neomake#statusline#ResetCountsForBuf(...) abort | |
| let bufnr = a:0 ? a:1 : bufnr('%') | |
| let r = (get(s:loclist_counts, bufnr, {}) != {}) | |
| let s:loclist_counts[bufnr] = {} | |
| if r | |
| call neomake#utils#hook('NeomakeCountsChanged', { | |
| \ 'file_mode': 1, | |
| \ 'bufnr': bufnr}) | |
| endif | |
| return r | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#ResetCountsForProject(...) abort | |
| let r = s:qflist_counts != {} | |
| let s:qflist_counts = {} | |
| if r | |
| call neomake#utils#hook('NeomakeCountsChanged', { | |
| \ 'file_mode': 0, | |
| \ 'bufnr': bufnr('%')}) | |
| endif | |
| return r | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#ResetCounts() abort | |
| let r = neomake#statusline#ResetCountsForProject() | |
| for bufnr in keys(s:loclist_counts) | |
| let r = neomake#statusline#ResetCountsForBuf(bufnr) || r | |
| endfor | |
| let s:loclist_counts = {} | |
| return r | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#AddLoclistCount(buf, item) abort | |
| let s:loclist_counts[a:buf] = get(s:loclist_counts, a:buf, {}) | |
| return s:setCount(s:loclist_counts[a:buf], a:item, a:buf) | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#AddQflistCount(item) abort | |
| return s:setCount(s:qflist_counts, a:item, 0) | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#LoclistCounts(...) abort | |
| let buf = a:0 ? a:1 : bufnr('%') | |
| if buf is# 'all' | |
| return s:loclist_counts | |
| endif | |
| return get(s:loclist_counts, buf, {}) | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#QflistCounts() abort | |
| return s:qflist_counts | |
| endfunction | |
| 1 0.000002 function! s:showErrWarning(counts, prefix) abort | |
| let w = get(a:counts, 'W', 0) | |
| let e = get(a:counts, 'E', 0) | |
| if w || e | |
| let result = a:prefix | |
| if e | |
| let result .= 'E:'.e | |
| endif | |
| if w | |
| if e | |
| let result .= ',' | |
| endif | |
| let result .= 'W:'.w | |
| endif | |
| return result | |
| else | |
| return '' | |
| endif | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#LoclistStatus(...) abort | |
| return s:showErrWarning(neomake#statusline#LoclistCounts(), a:0 ? a:1 : '') | |
| endfunction | |
| 1 0.000002 function! neomake#statusline#QflistStatus(...) abort | |
| return s:showErrWarning(neomake#statusline#QflistCounts(), a:0 ? a:1 : '') | |
| endfunction | |
| FUNCTION <SNR>35_Make() | |
| Called 1 time | |
| Total time: 0.016088 | |
| Self time: 0.000701 | |
| count total (s) self (s) | |
| 1 0.000003 let options = copy(a:options) | |
| 1 0.000008 call extend(options, { 'file_mode': 0, 'enabled_makers': [], 'bufnr': bufnr('%'), 'ft': '', }, 'keep') | |
| 1 0.000002 let bufnr = options.bufnr | |
| 1 0.000001 let file_mode = options.file_mode | |
| 1 0.000001 let enabled_makers = options.enabled_makers | |
| 1 0.000001 let ft = options.ft | |
| " Reset/clear on first run, but not when using 'serialize'. | |
| 1 0.000002 if !get(options, 'continuation', 0) | |
| 1 0.000001 if !len(enabled_makers) | |
| if file_mode | |
| call neomake#utils#DebugMessage('Nothing to make: no enabled makers.') | |
| return [] | |
| endif | |
| let enabled_makers = ['makeprg'] | |
| endif | |
| 1 0.000002 let s:make_id += 1 | |
| 1 0.000018 let s:make_options[s:make_id] = { 'cwd': getcwd(), } | |
| 1 0.000001 if file_mode | |
| 1 0.000485 0.000353 call neomake#statusline#ResetCountsForBuf(bufnr) | |
| 1 0.000001 else | |
| call neomake#statusline#ResetCountsForProject() | |
| endif | |
| " Empty the quickfix/location list (using a valid 'errorformat' setting). | |
| 1 0.000003 let l:efm = &errorformat | |
| 1 0.000001 try | |
| 1 0.000008 let &errorformat = '%-G' | |
| 1 0.000001 if file_mode | |
| 1 0.000016 lgetexpr '' | |
| 1 0.000001 else | |
| cgetexpr '' | |
| endif | |
| 1 0.000001 finally | |
| 1 0.000005 let &errorformat = l:efm | |
| 1 0.000001 endtry | |
| 1 0.000026 0.000011 call s:HandleLoclistQflistDisplay(file_mode) | |
| 1 0.000001 if file_mode | |
| 1 0.000001 if g:neomake_place_signs | |
| 1 0.000040 0.000007 call neomake#signs#ResetFile(bufnr) | |
| 1 0.000001 endif | |
| 1 0.000003 let s:need_errors_cleaning['file'][bufnr] = 1 | |
| 1 0.000001 else | |
| if g:neomake_place_signs | |
| call neomake#signs#ResetProject() | |
| endif | |
| let s:need_errors_cleaning['project'] = 1 | |
| endif | |
| 1 0.000038 0.000009 call s:AddMakeInfoForCurrentWin(s:make_id) | |
| 1 0.000001 endif | |
| 1 0.000001 let job_ids = [] | |
| 1 0.010926 0.000020 let enabled_makers = filter(map(copy(enabled_makers), 'neomake#GetMaker(v:val, ft)'), '!empty(v:val)') | |
| 1 0.000001 if !len(enabled_makers) | |
| return [] | |
| endif | |
| 1 0.000085 0.000018 call neomake#utils#DebugMessage(printf('Running makers: %s', join(map(copy(enabled_makers), 'v:val.name'), ', '))) | |
| 1 0.000001 let maker = {} | |
| 2 0.000004 while len(enabled_makers) | |
| 1 0.000002 let maker = remove(enabled_makers, 0) | |
| 1 0.000001 if empty(maker) | |
| continue | |
| endif | |
| " call neomake#utils#DebugMessage('Maker: '.string(enabled_makers), {'make_id': s:make_id}) | |
| " Check for already running job for the same maker (from other runs). | |
| " This used to use this key: maker.name.',ft='.maker.ft.',buf='.maker.bufnr | |
| 1 0.000003 if len(s:jobs) | |
| let running_already = values(filter(copy(s:jobs), 'v:val.make_id != s:make_id && v:val.maker == maker' ." && v:val.bufnr == bufnr && !get(v:val, 'restarting')")) | |
| if len(running_already) | |
| let jobinfo = running_already[0] | |
| " let jobinfo.next = copy(options) | |
| " TODO: required?! ( | |
| " let jobinfo.next.enabled_makers = [maker] | |
| call neomake#utils#LoudMessage(printf( 'Restarting already running job (%d.%d) for the same maker.', jobinfo.make_id, jobinfo.id), {'make_id': s:make_id}) | |
| let jobinfo.restarting = 1 | |
| call neomake#CancelJob(jobinfo.id) | |
| continue | |
| endif | |
| endif | |
| 1 0.000010 0.000006 if neomake#has_async_support() | |
| 1 0.000104 0.000006 let serialize = neomake#utils#GetSetting('serialize', maker, 0, [ft], bufnr) | |
| 1 0.000001 else | |
| let serialize = 1 | |
| endif | |
| 1 0.000002 if serialize && len(enabled_makers) > 0 | |
| let next_opts = copy(options) | |
| let next_opts.enabled_makers = enabled_makers | |
| let next_opts.continuation = 1 | |
| call extend(next_opts, { 'file_mode': file_mode, 'bufnr': bufnr, 'serialize_abort_on_error': neomake#utils#GetSetting('serialize_abort_on_error', maker, 0, [ft], bufnr), }) | |
| let options.next = next_opts | |
| endif | |
| 1 0.000002 let options.maker = maker | |
| 1 0.000001 try | |
| 1 0.004131 0.000028 let job_id = s:MakeJob(s:make_id, options) | |
| 1 0.000002 catch /^Neomake: / | |
| let error = substitute(v:exception, '^Neomake: ', '', '') | |
| call neomake#utils#ErrorMessage(error, {'make_id': s:make_id}) | |
| continue | |
| endtry | |
| 1 0.000001 if job_id != -1 | |
| 1 0.000004 call add(job_ids, job_id) | |
| 1 0.000001 endif | |
| " If we are serializing makers, stop after the first one. The | |
| " remaining makers will be processed in turn when this one is done. | |
| 1 0.000001 if serialize | |
| break | |
| endif | |
| 1 0.000002 endwhile | |
| 1 0.000002 return job_ids | |
| FUNCTION neomake#has_async_support() | |
| Called 4 times | |
| Total time: 0.000016 | |
| Self time: 0.000016 | |
| count total (s) self (s) | |
| 4 0.000015 return has('nvim') || has('channel') && has('job') && has('patch-8.0.0027') | |
| FUNCTION remote#host#RegisterClone() | |
| Called 1 time | |
| Total time: 0.000020 | |
| Self time: 0.000020 | |
| count total (s) self (s) | |
| 1 0.000005 if !has_key(s:hosts, a:orig_name) | |
| throw 'No host named "'.a:orig_name.'" is registered' | |
| endif | |
| 1 0.000006 let Factory = s:hosts[a:orig_name].factory | |
| 1 0.000006 let s:hosts[a:name] = { 'factory': Factory, 'channel': 0, 'initialized': 0, 'orig_name': a:orig_name } | |
| FUNCTION 2() | |
| Called 1 time | |
| Total time: 0.000360 | |
| Self time: 0.000126 | |
| count total (s) self (s) | |
| 1 0.000002 let bufnr = a:0 ? a:1 : 0 | |
| " Resolve exe/args, which might be a function or dictionary. | |
| 1 0.000004 if type(self.exe) == type(function('tr')) | |
| let exe = call(self.exe, []) | |
| elseif type(self.exe) == type({}) | |
| let exe = call(self.exe.fn, [], self.exe) | |
| else | |
| 1 0.000001 let exe = self.exe | |
| 1 0.000001 endif | |
| 1 0.000003 if type(self.args) == type(function('tr')) | |
| let args = call(self.args, []) | |
| elseif type(self.args) == type({}) | |
| let args = call(self.args.fn, [], self.args) | |
| else | |
| 1 0.000005 let args = copy(self.args) | |
| 1 0.000001 endif | |
| 1 0.000002 let args_is_list = type(args) == type([]) | |
| 1 0.000001 if args_is_list | |
| 1 0.000137 0.000007 call neomake#utils#ExpandArgs(args) | |
| 1 0.000001 endif | |
| 1 0.000106 0.000006 if bufnr && neomake#utils#GetSetting('append_file', self, 1, [self.ft], bufnr) | |
| 1 0.000002 let bufname = bufname(bufnr) | |
| 1 0.000002 if !len(bufname) | |
| throw 'Neomake: no file name' | |
| endif | |
| 1 0.000024 let bufname = fnamemodify(bufname, ':p') | |
| 1 0.000005 if !filereadable(bufname) | |
| throw 'Neomake: file is not readable ('.bufname.')' | |
| endif | |
| 1 0.000001 if args_is_list | |
| 1 0.000003 call add(args, bufname) | |
| 1 0.000001 else | |
| let args .= ' '.fnameescape(bufname) | |
| endif | |
| 1 0.000001 endif | |
| 1 0.000007 0.000003 if neomake#has_async_support() | |
| 1 0.000001 if args_is_list | |
| 1 0.000006 let argv = [exe] + args | |
| 1 0.000001 else | |
| let argv = exe . (len(args) ? ' ' . args : '') | |
| endif | |
| 1 0.000002 if !has('nvim') | |
| if !args_is_list | |
| " Have to use a shell to handle argv properly (Vim splits it | |
| " at spaces). | |
| let argv = [&shell, &shellcmdflag, argv] | |
| endif | |
| endif | |
| 1 0.000001 else | |
| let argv = exe | |
| if len(args) | |
| if args_is_list | |
| if neomake#utils#IsRunningWindows() | |
| let argv .= ' '.join(args) | |
| else | |
| let argv .= ' '.join(map(args, 'shellescape(v:val)')) | |
| endif | |
| else | |
| let argv .= ' '.args | |
| endif | |
| endif | |
| endif | |
| 1 0.000001 return argv | |
| FUNCTION neomake#utils#GetSortedFiletypes() | |
| Called 3 times | |
| Total time: 0.000061 | |
| Self time: 0.000061 | |
| count total (s) self (s) | |
| 3 0.000008 function! CompareFiletypes(ft1, ft2) abort | |
| if neomake#utils#GetSupersetOf(a:ft1) ==# a:ft2 | |
| return -1 | |
| elseif neomake#utils#GetSupersetOf(a:ft2) ==# a:ft1 | |
| return 1 | |
| else | |
| return 0 | |
| endif | |
| endfunction | |
| 3 0.000030 return sort(split(a:ft, '\.'), function('CompareFiletypes')) | |
| FUNCTION remote#host#PluginsForHost() | |
| Called 1 time | |
| Total time: 0.000009 | |
| Self time: 0.000009 | |
| count total (s) self (s) | |
| 1 0.000003 if !has_key(s:plugins_for_host, a:host) | |
| 1 0.000002 let s:plugins_for_host[a:host] = [] | |
| 1 0.000001 end | |
| 1 0.000002 return s:plugins_for_host[a:host] | |
| FUNCTION <SNR>36_tmpdir() | |
| Called 2 times | |
| Total time: 0.019386 | |
| Self time: 0.019386 | |
| count total (s) self (s) | |
| 2 0.000003 let tempdir = '' | |
| 2 0.000045 if (has('unix') || has('mac')) && executable('mktemp') && !has('win32unix') | |
| " TODO: option "-t" to mktemp(1) is not portable | |
| 2 0.000007 let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp' | |
| 2 0.019212 let out = split(system('mktemp -q -d ' . tmp . '/neomake-java-' . getpid() . '-XXXXXXXX'), "\n") | |
| 2 0.000019 if v:shell_error == 0 && len(out) == 1 | |
| 2 0.000010 let tempdir = out[0] | |
| 2 0.000003 endif | |
| 2 0.000001 endif | |
| 2 0.000004 if tempdir ==# '' | |
| if has('win32') || has('win64') | |
| let tempdir = $TEMP . s:psep . 'neomake-java-' . getpid() | |
| elseif has('win32unix') | |
| let tempdir = substitute(system('cygpath -m ' . s:shescape('/neomake-java-' . getpid())), "\n", '', 'g') | |
| elseif $TMPDIR !=# '' | |
| let tempdir = $TMPDIR . '/neomake-java-' . getpid() | |
| else | |
| let tempdir = '/tmp/neomake-java-' . getpid() | |
| endif | |
| try | |
| call mkdir(tempdir, 'p', 0700) | |
| catch /\m^Vim\%((\a\+)\)\=:E739/ | |
| let tempdir = '.' | |
| endtry | |
| endif | |
| 2 0.000010 return tempdir | |
| FUNCTION neomake#Make() | |
| Called 1 time | |
| Total time: 73.057440 | |
| Self time: 0.000072 | |
| count total (s) self (s) | |
| 1 0.000007 let options = a:0 ? { 'exit_callback': a:1 } : {} | |
| 1 0.000003 let options.file_mode = a:file_mode | |
| 1 0.000002 if a:file_mode | |
| 1 0.000003 let options.ft = &filetype | |
| 1 0.000001 endif | |
| 1 73.041299 0.000020 let options.enabled_makers = len(a:enabled_makers) ? a:enabled_makers : neomake#GetEnabledMakers(a:file_mode ? &filetype : '') | |
| 1 0.016121 0.000033 return s:Make(options) | |
| FUNCTION neomake#utils#DebugMessage() | |
| Called 54 times | |
| Total time: 0.003922 | |
| Self time: 0.000479 | |
| count total (s) self (s) | |
| 54 0.003901 0.000458 call call('neomake#utils#LogMessage', [3] + a:000) | |
| FUNCTION neomake#signs#ResetFile() | |
| Called 1 time | |
| Total time: 0.000033 | |
| Self time: 0.000021 | |
| count total (s) self (s) | |
| 1 0.000003 let s:sign_queue.file[a:bufnr] = {} | |
| 1 0.000012 0.000007 call neomake#signs#CleanOldSigns(a:bufnr, 'file') | |
| 1 0.000013 0.000006 call neomake#signs#Reset(a:bufnr, 'file') | |
| 1 0.000002 if has_key(s:neomake_sign_id.file, a:bufnr) | |
| unlet s:neomake_sign_id.file[a:bufnr] | |
| endif | |
| FUNCTION neomake#statusline#ResetCountsForBuf() | |
| Called 1 time | |
| Total time: 0.000018 | |
| Self time: 0.000018 | |
| count total (s) self (s) | |
| 1 0.000004 let bufnr = a:0 ? a:1 : bufnr('%') | |
| 1 0.000004 let r = (get(s:loclist_counts, bufnr, {}) != {}) | |
| 1 0.000003 let s:loclist_counts[bufnr] = {} | |
| 1 0.000001 if r | |
| call neomake#utils#hook('NeomakeCountsChanged', { 'file_mode': 1, 'bufnr': bufnr}) | |
| endif | |
| 1 0.000001 return r | |
| FUNCTION neomake#utils#LogMessage() | |
| Called 55 times | |
| Total time: 0.003524 | |
| Self time: 0.003524 | |
| count total (s) self (s) | |
| 55 0.000163 let verbose = get(g:, 'neomake_verbose', 1) | |
| 55 0.000132 let logfile = get(g:, 'neomake_logfile') | |
| 55 0.000206 if exists(':Log') != 2 && verbose < a:level && logfile is# '' | |
| return | |
| endif | |
| 55 0.000048 if a:0 | |
| 51 0.000071 let jobinfo = a:1 | |
| 51 0.000100 if has_key(jobinfo, 'id') | |
| 50 0.000284 let msg = printf('[%s.%d] %s', get(jobinfo, 'make_id', '-'), jobinfo.id, a:msg) | |
| 50 0.000040 else | |
| 1 0.000030 let msg = printf('[%s] %s', get(jobinfo, 'make_id', '?'), a:msg) | |
| 1 0.000001 endif | |
| 51 0.000029 else | |
| 4 0.000004 let jobinfo = {} | |
| 4 0.000005 let msg = a:msg | |
| 4 0.000002 endif | |
| " Use Vader's log for messages during tests. | |
| 55 0.000143 if exists('*vader#log') && exists('g:neomake_test_messages') | |
| let test_msg = '['.s:level_to_name[a:level].'] ['.s:timestr().']: '.msg | |
| call vader#log(test_msg) | |
| " Only keep jobinfo entries that are relevant for / used in the message. | |
| let g:neomake_test_messages += [[a:level, a:msg, filter(copy(jobinfo), "index(['id', 'make_id'], v:key) != -1")]] | |
| elseif verbose >= a:level | |
| redraw | |
| if a:level ==# 0 | |
| echohl ErrorMsg | |
| endif | |
| if verbose > 2 | |
| echom 'Neomake ['.s:timestr().']: '.msg | |
| else | |
| echom 'Neomake: '.msg | |
| endif | |
| if a:level ==# 0 | |
| echohl None | |
| endif | |
| endif | |
| 55 0.000157 if type(logfile) ==# type('') && len(logfile) | |
| let date = strftime('%Y-%m-%dT%H:%M:%S%z') | |
| call writefile(['['.date.' @'.s:timestr().', '.s:level_to_name[a:level].'] '.msg], logfile, 'a') | |
| endif | |
| FUNCTION neomake#utils#LoudMessage() | |
| Called 1 time | |
| Total time: 0.000096 | |
| Self time: 0.000015 | |
| count total (s) self (s) | |
| 1 0.000096 0.000014 call call('neomake#utils#LogMessage', [2] + a:000) | |
| FUNCTION <SNR>36_AddToClasspath() | |
| Called 4 times | |
| Total time: 0.000046 | |
| Self time: 0.000046 | |
| count total (s) self (s) | |
| 4 0.000024 if a:path ==# '' | |
| 2 0.000004 return a:classpath | |
| endif | |
| 2 0.000010 return (a:classpath !=# '') ? a:classpath . s:ClassSep() . a:path : a:path | |
| FUNCTION neomake#signs#Reset() | |
| Called 1 time | |
| Total time: 0.000007 | |
| Self time: 0.000007 | |
| count total (s) self (s) | |
| 1 0.000003 if has_key(s:placed_signs[a:type], a:bufnr) | |
| let s:last_placed_signs[a:type][a:bufnr] = s:placed_signs[a:type][a:bufnr] | |
| unlet s:placed_signs[a:type][a:bufnr] | |
| endif | |
| FUNCTION <SNR>36_GetGradleClasspath() | |
| Called 2 times | |
| Total time: 72.978494 | |
| Self time: 71.505160 | |
| count total (s) self (s) | |
| 2 0.000546 0.000086 let gradle = s:findFileInParent('build.gradle', expand('%:p:h', 1)) | |
| 2 0.000020 if s:has_gradle && filereadable(gradle) | |
| 2 0.000015 if !has_key(g:neomake_java_javac_gradle_ftime, gradle) || g:neomake_java_javac_gradle_ftime[gradle] != getftime(gradle) | |
| 1 0.000002 try | |
| 1 0.000015 let f = tempname() | |
| 1 0.000002 if s:is_windows | |
| let gradle_cmd = '.\gradlew.bat' | |
| else | |
| 1 0.000002 let gradle_cmd = './gradlew' | |
| 1 0.000001 endif | |
| 1 0.000233 call writefile(["allprojects{apply from: '" . g:neomake_java_checker_home . s:psep. 'java'. s:psep. "classpath.gradle'}"], f) | |
| 1 71.503611 let ret = system(gradle_cmd . ' -q -I ' . shellescape(f) . ' classpath' ) | |
| 1 0.000013 if v:shell_error == 0 | |
| 1 0.000454 let cp = filter(split(ret, "\n"), "v:val =~# '^CLASSPATH:'")[0][10:] | |
| 1 0.000071 if filereadable(getcwd() . s:psep . 'build.gradle') | |
| 1 1.472909 0.000043 let out_putdir = s:GlobPathList(getcwd(), join( ['**', 'build', 'intermediates', 'classes', 'debug'], s:psep), 0) | |
| 2 0.000008 for classes in out_putdir | |
| 1 0.000052 0.000044 let cp .= s:ClassSep() . classes | |
| 1 0.000001 endfor | |
| 1 0.000001 endif | |
| 1 0.000001 else | |
| let cp = '' | |
| endif | |
| 1 0.000001 catch | |
| finally | |
| 1 0.000414 call delete(f) | |
| 1 0.000002 endtry | |
| 1 0.000012 let g:neomake_java_javac_gradle_ftime[gradle] = getftime(gradle) | |
| 1 0.000007 let g:neomake_java_javac_gradle_classpath[gradle] = cp | |
| 1 0.000001 endif | |
| 2 0.000039 return g:neomake_java_javac_gradle_classpath[gradle] | |
| endif | |
| return '' | |
| FUNCTION <SNR>35_nvim_output_handler() | |
| Called 46 times | |
| Total time: 0.001750 | |
| Self time: 0.001750 | |
| count total (s) self (s) | |
| " @vimlint(EVL108, 1) | |
| 46 0.000204 if has('nvim-0.2.0') | |
| call s:output_handler(a:job_id, a:data, a:event_type) | |
| return | |
| endif | |
| " @vimlint(EVL108, 0) | |
| 46 0.000127 let jobinfo = s:jobs[a:job_id] | |
| 46 0.000126 let args = [a:job_id, a:data, a:event_type] | |
| 46 0.000126 call add(s:nvim_output_handler_queue, args) | |
| 46 0.000109 if !exists('jobinfo._nvim_in_handler') | |
| 43 0.000085 let jobinfo._nvim_in_handler = 1 | |
| 43 0.000031 else | |
| 3 0.000004 let jobinfo._nvim_in_handler += 1 | |
| 3 0.000002 endif | |
| 46 0.000115 if !exists('s:nvim_output_handler_timer') | |
| 43 0.000346 let s:nvim_output_handler_timer = timer_start(0, function('s:nvim_output_handler_cb')) | |
| 43 0.000033 endif | |
| FUNCTION <SNR>15_Highlight_Matching_Pair() | |
| Called 10 times | |
| Total time: 0.000614 | |
| Self time: 0.000614 | |
| count total (s) self (s) | |
| " Remove any previous match. | |
| 10 0.000025 if exists('w:paren_hl_on') && w:paren_hl_on | |
| silent! call matchdelete(3) | |
| let w:paren_hl_on = 0 | |
| endif | |
| " Avoid that we remove the popup menu. | |
| " Return when there are no colors (looks like the cursor jumps). | |
| 10 0.000025 if pumvisible() || (&t_Co < 8 && !has("gui_running")) | |
| return | |
| endif | |
| " Get the character under the cursor and check if it's in 'matchpairs'. | |
| 10 0.000019 let c_lnum = line('.') | |
| 10 0.000017 let c_col = col('.') | |
| 10 0.000011 let before = 0 | |
| 10 0.000019 let text = getline(c_lnum) | |
| 10 0.000123 let matches = matchlist(text, '\(.\)\=\%'.c_col.'c\(.\=\)') | |
| 10 0.000015 if empty(matches) | |
| let [c_before, c] = ['', ''] | |
| else | |
| 10 0.000034 let [c_before, c] = matches[1:2] | |
| 10 0.000007 endif | |
| 10 0.000087 let plist = split(&matchpairs, '.\zs[:,]') | |
| 10 0.000022 let i = index(plist, c) | |
| 10 0.000009 if i < 0 | |
| " not found, in Insert mode try character before the cursor | |
| 10 0.000024 if c_col > 1 && (mode() == 'i' || mode() == 'R') | |
| let before = strlen(c_before) | |
| let c = c_before | |
| let i = index(plist, c) | |
| endif | |
| 10 0.000007 if i < 0 | |
| " not found, nothing to do | |
| 10 0.000007 return | |
| endif | |
| endif | |
| " Figure out the arguments for searchpairpos(). | |
| if i % 2 == 0 | |
| let s_flags = 'nW' | |
| let c2 = plist[i + 1] | |
| else | |
| let s_flags = 'nbW' | |
| let c2 = c | |
| let c = plist[i - 1] | |
| endif | |
| if c == '[' | |
| let c = '\[' | |
| let c2 = '\]' | |
| endif | |
| " Find the match. When it was just before the cursor move it there for a | |
| " moment. | |
| if before > 0 | |
| let has_getcurpos = exists("*getcurpos") | |
| if has_getcurpos | |
| " getcurpos() is more efficient but doesn't exist before 7.4.313. | |
| let save_cursor = getcurpos() | |
| else | |
| let save_cursor = winsaveview() | |
| endif | |
| call cursor(c_lnum, c_col - before) | |
| endif | |
| " Build an expression that detects whether the current cursor position is in | |
| " certain syntax types (string, comment, etc.), for use as searchpairpos()'s | |
| " skip argument. | |
| " We match "escape" for special items, such as lispEscapeSpecial. | |
| let s_skip = '!empty(filter(map(synstack(line("."), col(".")), ''synIDattr(v:val, "name")''), ' . '''v:val =~? "string\\|character\\|singlequote\\|escape\\|comment"''))' | |
| " If executing the expression determines that the cursor is currently in | |
| " one of the syntax types, then we want searchpairpos() to find the pair | |
| " within those syntax types (i.e., not skip). Otherwise, the cursor is | |
| " outside of the syntax types and s_skip should keep its value so we skip any | |
| " matching pair inside the syntax types. | |
| execute 'if' s_skip '| let s_skip = 0 | endif' | |
| " Limit the search to lines visible in the window. | |
| let stoplinebottom = line('w$') | |
| let stoplinetop = line('w0') | |
| if i % 2 == 0 | |
| let stopline = stoplinebottom | |
| else | |
| let stopline = stoplinetop | |
| endif | |
| " Limit the search time to 300 msec to avoid a hang on very long lines. | |
| " This fails when a timeout is not supported. | |
| if mode() == 'i' || mode() == 'R' | |
| let timeout = exists("b:matchparen_insert_timeout") ? b:matchparen_insert_timeout : g:matchparen_insert_timeout | |
| else | |
| let timeout = exists("b:matchparen_timeout") ? b:matchparen_timeout : g:matchparen_timeout | |
| endif | |
| try | |
| let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline, timeout) | |
| catch /E118/ | |
| " Can't use the timeout, restrict the stopline a bit more to avoid taking | |
| " a long time on closed folds and long lines. | |
| " The "viewable" variables give a range in which we can scroll while | |
| " keeping the cursor at the same position. | |
| " adjustedScrolloff accounts for very large numbers of scrolloff. | |
| let adjustedScrolloff = min([&scrolloff, (line('w$') - line('w0')) / 2]) | |
| let bottom_viewable = min([line('$'), c_lnum + &lines - adjustedScrolloff - 2]) | |
| let top_viewable = max([1, c_lnum-&lines+adjustedScrolloff + 2]) | |
| " one of these stoplines will be adjusted below, but the current values are | |
| " minimal boundaries within the current window | |
| if i % 2 == 0 | |
| if has("byte_offset") && has("syntax_items") && &smc > 0 | |
| let stopbyte = min([line2byte("$"), line2byte(".") + col(".") + &smc * 2]) | |
| let stopline = min([bottom_viewable, byte2line(stopbyte)]) | |
| else | |
| let stopline = min([bottom_viewable, c_lnum + 100]) | |
| endif | |
| let stoplinebottom = stopline | |
| else | |
| if has("byte_offset") && has("syntax_items") && &smc > 0 | |
| let stopbyte = max([1, line2byte(".") + col(".") - &smc * 2]) | |
| let stopline = max([top_viewable, byte2line(stopbyte)]) | |
| else | |
| let stopline = max([top_viewable, c_lnum - 100]) | |
| endif | |
| let stoplinetop = stopline | |
| endif | |
| let [m_lnum, m_col] = searchpairpos(c, '', c2, s_flags, s_skip, stopline) | |
| endtry | |
| if before > 0 | |
| if has_getcurpos | |
| call setpos('.', save_cursor) | |
| else | |
| call winrestview(save_cursor) | |
| endif | |
| endif | |
| " If a match is found setup match highlighting. | |
| if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom | |
| if exists('*matchaddpos') | |
| call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3) | |
| else | |
| exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) . 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/' | |
| endif | |
| let w:paren_hl_on = 1 | |
| endif | |
| FUNCTION <SNR>36_shescape() | |
| Called 2 times | |
| Total time: 0.000062 | |
| Self time: 0.000062 | |
| count total (s) self (s) | |
| 2 0.000059 return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) | |
| FUNCTION neomake#highlights#ResetFile() | |
| Called 1 time | |
| Total time: 0.000066 | |
| Self time: 0.000025 | |
| count total (s) self (s) | |
| 1 0.000047 0.000008 call s:InitBufHighlights('file', a:buf) | |
| 1 0.000005 0.000003 call neomake#highlights#ShowHighlights() | |
| FUNCTION <SNR>36_ClassSep() | |
| Called 1 time | |
| Total time: 0.000008 | |
| Self time: 0.000008 | |
| count total (s) self (s) | |
| 1 0.000007 return (s:is_windows || has('win32unix')) ? ';' : ':' | |
| FUNCTION <SNR>35_ProcessJobOutput() | |
| Called 1 time | |
| Total time: 0.004275 | |
| Self time: 0.004041 | |
| count total (s) self (s) | |
| 1 0.000002 let maker = a:jobinfo.maker | |
| 1 0.000002 let file_mode = a:jobinfo.file_mode | |
| 1 0.000068 0.000007 call neomake#utils#DebugMessage(printf( '%s: processing %d lines of output.', maker.name, len(a:lines)), a:jobinfo) | |
| 1 0.000002 if has_key(maker, 'mapexpr') | |
| let l:neomake_bufname = bufname(a:jobinfo.bufnr) | |
| " @vimlint(EVL102, 1, l:neomake_bufdir) | |
| let l:neomake_bufdir = fnamemodify(neomake_bufname, ':h') | |
| " @vimlint(EVL102, 1, l:neomake_output_source) | |
| let l:neomake_output_source = a:source | |
| call map(a:lines, maker.mapexpr) | |
| endif | |
| 1 0.000003 let olderrformat = &errorformat | |
| 1 0.000009 let &errorformat = maker.errorformat | |
| 1 0.000001 try | |
| 1 0.000001 if file_mode | |
| 1 0.000003 let prev_list = getloclist(0) | |
| 1 0.003959 laddexpr a:lines | |
| 1 0.000001 else | |
| let prev_list = getqflist() | |
| caddexpr a:lines | |
| endif | |
| 1 0.000127 0.000012 let counts_changed = s:AddExprCallback(a:jobinfo, len(prev_list)) | |
| 1 0.000001 if !counts_changed | |
| 1 0.000004 let counts_changed = (file_mode && getloclist(0) != prev_list) || (!file_mode && getqflist() != prev_list) | |
| 1 0.000001 endif | |
| 1 0.000001 if counts_changed | |
| call neomake#utils#hook('NeomakeCountsChanged', { 'file_mode': file_mode, 'bufnr': a:jobinfo.bufnr, }, a:jobinfo) | |
| endif | |
| 1 0.000001 finally | |
| 1 0.000004 let &errorformat = olderrformat | |
| 1 0.000001 endtry | |
| 1 0.000021 0.000006 call s:HandleLoclistQflistDisplay(a:jobinfo.file_mode) | |
| 1 0.000048 0.000004 call neomake#EchoCurrentError() | |
| FUNCTION <SNR>35_GetTabWinForMakeId() | |
| Called 1 time | |
| Total time: 0.000040 | |
| Self time: 0.000028 | |
| count total (s) self (s) | |
| 1 0.000011 for t in [tabpagenr()] + range(1, tabpagenr()-1) + range(tabpagenr()+1, tabpagenr('$')) | |
| 1 0.000004 for w in range(1, tabpagewinnr(t, '$')) | |
| 1 0.000020 0.000008 if index(s:gettabwinvar(t, w, 'neomake_make_ids', []), a:make_id) != -1 | |
| 1 0.000002 return [t, w] | |
| endif | |
| endfor | |
| endfor | |
| return [-1, -1] | |
| FUNCTION remote#host#RegisterPlugin() | |
| Called 1 time | |
| Total time: 0.000074 | |
| Self time: 0.000059 | |
| count total (s) self (s) | |
| 1 0.000019 0.000011 let plugins = remote#host#PluginsForHost(a:host) | |
| 1 0.000002 for plugin in plugins | |
| if plugin.path == a:path | |
| throw 'Plugin "'.a:path.'" is already registered' | |
| endif | |
| endfor | |
| 1 0.000013 0.000007 if has_key(s:hosts, a:host) && remote#host#IsRunning(a:host) | |
| " For now we won't allow registration of plugins when the host is already | |
| " running. | |
| throw 'Host "'.a:host.'" is already running' | |
| endif | |
| 1 0.000001 for spec in a:specs | |
| let type = spec.type | |
| let name = spec.name | |
| let sync = spec.sync | |
| let opts = spec.opts | |
| let rpc_method = a:path | |
| if type == 'command' | |
| let rpc_method .= ':command:'.name | |
| call remote#define#CommandOnHost(a:host, rpc_method, sync, name, opts) | |
| elseif type == 'autocmd' | |
| " Since multiple handlers can be attached to the same autocmd event by a | |
| " single plugin, we need a way to uniquely identify the rpc method to | |
| " call. The solution is to append the autocmd pattern to the method | |
| " name(This still has a limit: one handler per event/pattern combo, but | |
| " there's no need to allow plugins define multiple handlers in that case) | |
| let rpc_method .= ':autocmd:'.name.':'.get(opts, 'pattern', '*') | |
| call remote#define#AutocmdOnHost(a:host, rpc_method, sync, name, opts) | |
| elseif type == 'function' | |
| let rpc_method .= ':function:'.name | |
| call remote#define#FunctionOnHost(a:host, rpc_method, sync, name, opts) | |
| else | |
| echoerr 'Invalid declaration type: '.type | |
| endif | |
| endfor | |
| 1 0.000004 call add(plugins, {'path': a:path, 'specs': a:specs}) | |
| FUNCTION provider#pythonx#Detect() | |
| Called 1 time | |
| Total time: 0.048033 | |
| Self time: 0.000098 | |
| count total (s) self (s) | |
| 1 0.000010 let host_var = (a:major_ver == 2) ? 'g:python_host_prog' : 'g:python3_host_prog' | |
| 1 0.000004 let skip_var = (a:major_ver == 2) ? 'g:python_host_skip_check' : 'g:python3_host_skip_check' | |
| 1 0.000007 let skip = exists(skip_var) ? {skip_var} : 0 | |
| 1 0.000004 if exists(host_var) | |
| " Disable auto detection. | |
| let [result, err] = s:check_interpreter({host_var}, a:major_ver, skip) | |
| if result | |
| return [{host_var}, err] | |
| endif | |
| return ['', 'provider/pythonx: Could not load Python ' . a:major_ver . ' from ' . host_var . ': ' . err] | |
| endif | |
| 1 0.000006 let prog_suffixes = (a:major_ver == 2) ? ['2', '2.7', '2.6', ''] : ['3', '3.5', '3.4', '3.3', ''] | |
| 1 0.000002 let errors = [] | |
| 1 0.000013 for prog in map(prog_suffixes, "'python' . v:val") | |
| 1 0.047958 0.000024 let [result, err] = s:check_interpreter(prog, a:major_ver, skip) | |
| 1 0.000001 if result | |
| 1 0.000003 return [prog, err] | |
| endif | |
| " Accumulate errors in case we don't find | |
| " any suitable Python interpreter. | |
| call add(errors, err) | |
| endfor | |
| " No suitable Python interpreter found. | |
| return ['', 'provider/pythonx: Could not load Python ' . a:major_ver . ":\n" . join(errors, "\n")] | |
| FUNCTION neomake#makers#ft#java#javac() | |
| Called 2 times | |
| Total time: 73.048697 | |
| Self time: 0.000783 | |
| count total (s) self (s) | |
| 2 0.000007 let javac_opts = extend([], g:neomake_java_javac_options) | |
| 2 0.000003 let output_dir = '' | |
| 2 0.000003 if g:neomake_java_javac_delete_output | |
| 2 0.019416 0.000030 let output_dir = s:tmpdir() | |
| 2 0.000133 0.000071 let javac_opts = extend(javac_opts, ['-d', s:shescape(output_dir)]) | |
| 2 0.000002 endif | |
| 2 0.000009 let javac_classpath = get(g:, 'neomake_java_javac_classpath', '') | |
| 2 0.000008 if s:has_maven && g:neomake_java_javac_autoload_maven_classpath && empty(javac_classpath) | |
| 2 0.000003 if !g:neomake_java_javac_delete_output | |
| let javac_opts = extend(javac_opts, ['-d', s:shescape(s:MavenOutputDirectory())]) | |
| endif | |
| 2 0.000850 0.000057 let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath()) | |
| 2 0.000002 endif | |
| 2 0.000008 if s:has_gradle && g:neomake_java_javac_autoload_gradle_classpath && empty(javac_classpath) | |
| 2 0.000003 if !g:neomake_java_javac_delete_output | |
| let javac_opts = extend(javac_opts, ['-d', s:shescape(s:GradleOutputDirectory())]) | |
| endif | |
| 2 72.978596 0.000070 let javac_classpath = s:AddToClasspath(javac_classpath, s:GetGradleClasspath()) | |
| 2 0.000001 endif | |
| 2 0.049512 0.000364 if (has('python') || has('python3')) && empty(javac_classpath) | |
| let classpathFile = fnamemodify(findfile('.classpath', escape(expand('.'), '*[]?{}, ') . ';'), ':p') | |
| if !empty(classpathFile) && filereadable(classpathFile) | |
| let javac_classpath = s:ReadClassPathFile(classpathFile) | |
| endif | |
| endif | |
| 2 0.000006 if javac_classpath !=# '' | |
| 2 0.000034 let javac_opts = extend(javac_opts, ['-cp', javac_classpath]) | |
| 2 0.000001 endif | |
| 2 0.000023 return { 'args': javac_opts, 'exe': g:neomake_java_javac_executable, 'errorformat': '%E%f:%l: error: %m,'. '%W%f:%l: warning: %m,'. '%E%f:%l: %m,'. '%Z%p^,'. '%-G%.%#' } | |
| FUNCTION <SNR>35_nvim_output_handler_cb() | |
| Called 43 times | |
| Total time: 0.009534 | |
| Self time: 0.002788 | |
| count total (s) self (s) | |
| 89 0.000229 while len(s:nvim_output_handler_queue) | |
| 46 0.000149 let args = remove(s:nvim_output_handler_queue, 0) | |
| 46 0.000106 let job_id = args[0] | |
| 46 0.000099 let jobinfo = s:jobs[job_id] | |
| 46 0.007312 0.000566 call call('s:output_handler', args) | |
| 46 0.000082 let jobinfo._nvim_in_handler -= 1 | |
| 46 0.000056 if !jobinfo._nvim_in_handler | |
| " Trigger previously delayed exit handler. | |
| 43 0.000063 unlet jobinfo._nvim_in_handler | |
| 43 0.000126 if exists('jobinfo._exited_while_in_handler') | |
| call neomake#utils#DebugMessage('Trigger delayed exit', jobinfo) | |
| call s:exit_handler(jobinfo.id, jobinfo._exited_while_in_handler, 'exit') | |
| endif | |
| 43 0.000028 endif | |
| 46 0.000045 endwhile | |
| 43 0.000076 unlet! s:nvim_output_handler_timer | |
| FUNCTION <SNR>35_MakeJob() | |
| Called 1 time | |
| Total time: 0.004102 | |
| Self time: 0.003643 | |
| count total (s) self (s) | |
| 1 0.000002 let job_id = s:job_id | |
| 1 0.000001 let s:job_id += 1 | |
| 1 0.000002 let maker = a:options.maker | |
| 1 0.000008 let jobinfo = { 'name': 'neomake_'.job_id, 'bufnr': a:options.bufnr, 'file_mode': a:options.file_mode, 'maker': maker, 'make_id': a:make_id, 'next': get(a:options, 'next', {}), } | |
| " Call .fn function in maker object, if any. | |
| 1 0.000002 if has_key(maker, 'fn') | |
| " TODO: Allow to throw and/or return 0 to abort/skip?! | |
| let maker = call(maker.fn, [jobinfo], maker) | |
| endif | |
| 1 0.000005 let cwd = get(maker, 'cwd', s:make_options[a:make_id].cwd) | |
| 1 0.000001 if len(cwd) | |
| 1 0.000012 let old_wd = getcwd() | |
| 1 0.000007 let cwd = expand(cwd, 1) | |
| 1 0.000001 try | |
| 1 0.000043 exe 'cd' fnameescape(cwd) | |
| " Tests fail with E344, but in reality it is E472?! | |
| " If uncaught, both are shown. Let's just catch every error here. | |
| 1 0.000001 catch | |
| call neomake#utils#ErrorMessage( maker.name.": could not change to maker's cwd (".cwd.'): ' .v:exception, jobinfo) | |
| return -1 | |
| endtry | |
| 1 0.000001 endif | |
| 1 0.000001 try | |
| 1 0.000001 let error = '' | |
| 1 0.000369 0.000009 let argv = maker.get_argv(jobinfo.file_mode ? jobinfo.bufnr : 0) | |
| 1 0.000006 0.000002 if neomake#has_async_support() | |
| 1 0.000002 if has('nvim') | |
| 1 0.000009 let opts = { 'on_stdout': function('s:nvim_output_handler'), 'on_stderr': function('s:nvim_output_handler'), 'on_exit': function('s:exit_handler') } | |
| 1 0.000001 try | |
| 1 0.000253 0.000157 call neomake#utils#LoudMessage(printf( 'Starting async job: %s', string(argv)), jobinfo) | |
| 1 0.003212 let job = jobstart(argv, opts) | |
| 1 0.000005 catch | |
| let error = printf('Failed to start Neovim job: %s: %s', string(argv), v:exception) | |
| endtry | |
| 1 0.000006 if empty(error) | |
| 1 0.000001 if job == 0 | |
| let error = printf('Failed to start Neovim job: %s: %s', 'Job table is full or invalid arguments given', string(argv)) | |
| elseif job == -1 | |
| let error = printf('Failed to start Neovim job: %s: %s', 'Executable not found', string(argv)) | |
| else | |
| 1 0.000002 let jobinfo.id = job | |
| 1 0.000007 let s:jobs[jobinfo.id] = jobinfo | |
| 1 0.000001 endif | |
| 1 0.000001 endif | |
| 1 0.000001 else | |
| " vim-async. | |
| let opts = { 'out_cb': function('s:vim_output_handler_stdout'), 'err_cb': function('s:vim_output_handler_stderr'), 'close_cb': function('s:vim_exit_handler'), 'mode': 'raw', } | |
| try | |
| call neomake#utils#LoudMessage(printf( 'Starting async job: %s', string(argv)), jobinfo) | |
| let job = job_start(argv, opts) | |
| " Get this as early as possible! | |
| let jobinfo.id = ch_info(job)['id'] | |
| let jobinfo.vim_job = job | |
| let s:jobs[jobinfo.id] = jobinfo | |
| catch | |
| let error = printf('Failed to start Vim job: %s: %s', argv, v:exception) | |
| endtry | |
| if empty(error) | |
| call neomake#utils#DebugMessage(printf('Vim job: %s', string(job_info(job))), jobinfo) | |
| call neomake#utils#DebugMessage(printf('Vim channel: %s', string(ch_info(job))), jobinfo) | |
| endif | |
| endif | |
| " Bail out on errors. | |
| 1 0.000002 if len(error) | |
| call neomake#utils#ErrorMessage(error, jobinfo) | |
| call s:handle_next_makers(jobinfo, 122) | |
| return -1 | |
| endif | |
| 1 0.000002 let r = jobinfo.id | |
| 1 0.000001 else | |
| call neomake#utils#DebugMessage('Running synchronously') | |
| call neomake#utils#LoudMessage('Starting: '.argv, jobinfo) | |
| let jobinfo.id = job_id | |
| let s:jobs[job_id] = jobinfo | |
| call s:output_handler(job_id, split(system(argv), '\r\?\n', 1), 'stdout') | |
| call s:exit_handler(job_id, v:shell_error, 'exit') | |
| let r = -1 | |
| endif | |
| 1 0.000001 finally | |
| 1 0.000002 if exists('old_wd') | |
| 1 0.000050 exe 'cd' fnameescape(old_wd) | |
| 1 0.000001 endif | |
| 1 0.000001 endtry | |
| 1 0.000002 return r | |
| FUNCTION <SNR>29_InitBufHighlights() | |
| Called 1 time | |
| Total time: 0.000039 | |
| Self time: 0.000039 | |
| count total (s) self (s) | |
| 1 0.000001 if s:nvim_api | |
| 1 0.000002 if !bufexists(a:buf) | |
| " The buffer might be wiped by now: prevent 'Invalid buffer id'. | |
| return | |
| endif | |
| 1 0.000003 if has_key(s:highlights[a:type], a:buf) | |
| call nvim_buf_clear_highlight(a:buf, s:highlights[a:type][a:buf], 0, -1) | |
| endif | |
| 1 0.000024 let s:highlights[a:type][a:buf] = nvim_buf_add_highlight(a:buf, 0, '', 0, 0, -1) | |
| 1 0.000001 else | |
| let s:highlights[a:type][a:buf] = { 'NeomakeError': [], 'NeomakeWarning': [], 'NeomakeInfo': [], 'NeomakeMessage': [] } | |
| endif | |
| FUNCTION neomake#utils#AvailableMakers() | |
| Called 1 time | |
| Total time: 73.039677 | |
| Self time: 0.000032 | |
| count total (s) self (s) | |
| 1 73.039676 0.000032 return filter(copy(a:makers), 'neomake#utils#MakerIsAvailable(a:ft, v:val)') | |
| FUNCTION <SNR>35_has_pending_output() | |
| Called 1 time | |
| Total time: 0.000010 | |
| Self time: 0.000010 | |
| count total (s) self (s) | |
| 1 0.000004 if index(get(s:buffer_job_output, a:jobinfo.bufnr, []), a:jobinfo.id) != -1 | |
| return 1 | |
| endif | |
| 1 0.000002 if has_key(s:project_job_output, a:jobinfo.id) | |
| return 1 | |
| endif | |
| 1 0.000001 return 0 | |
| FUNCTION neomake#ProcessPendingOutput() | |
| Called 1 time | |
| Total time: 0.000155 | |
| Self time: 0.000065 | |
| count total (s) self (s) | |
| 1 0.000065 0.000030 if !s:CanProcessJobOutput() | |
| return | |
| endif | |
| 1 0.000063 0.000012 call neomake#ProcessCurrentWindow() | |
| 1 0.000003 if len(s:project_job_output) | |
| call s:ProcessPendingOutput(s:project_job_output) | |
| if g:neomake_place_signs | |
| call neomake#signs#PlaceVisibleSigns() | |
| endif | |
| endif | |
| 1 0.000009 0.000005 call neomake#highlights#ShowHighlights() | |
| FUNCTION <SNR>35_gettabwinvar() | |
| Called 4 times | |
| Total time: 0.000038 | |
| Self time: 0.000038 | |
| count total (s) self (s) | |
| " Wrapper around gettabwinvar that has no default (Vim in Travis). | |
| 4 0.000013 let r = gettabwinvar(a:t, a:w, a:v) | |
| 4 0.000005 if r is# '' | |
| 2 0.000002 unlet r | |
| 2 0.000002 let r = a:d | |
| 2 0.000001 endif | |
| 4 0.000004 return r | |
| FUNCTION <SNR>35_handle_next_makers() | |
| Called 1 time | |
| Total time: 0.000774 | |
| Self time: 0.000023 | |
| count total (s) self (s) | |
| 1 0.000001 if len(a:jobinfo.next) | |
| let next = a:jobinfo.next | |
| let next_makers = '['.join(map(copy(next.enabled_makers), 'v:val.name'), ', ').']' | |
| if (a:status != 0 && index([122, 127], a:status) == -1 && next.serialize_abort_on_error) | |
| call neomake#utils#LoudMessage('Aborting next makers '.next_makers.' (status '.a:status.')') | |
| else | |
| call neomake#utils#DebugMessage(printf('next makers: %s', next_makers), a:jobinfo) | |
| call s:Make(next) | |
| endif | |
| endif | |
| 1 0.000002 if !get(a:jobinfo, 'pending_output', 0) | |
| 1 0.000758 0.000007 call s:CleanJobinfo(a:jobinfo) | |
| 1 0.000001 endif | |
| FUNCTION neomake#utils#ExpandArgs() | |
| Called 1 time | |
| Total time: 0.000130 | |
| Self time: 0.000130 | |
| count total (s) self (s) | |
| " Expand args that start with '%' only. | |
| " It handles '%:r.o', by splitting it into '%:r' and '.o', and only | |
| " expanding the first part. | |
| 1 0.000128 call map(a:args, "v:val =~# '\\(^%$\\|^%:\\l\\+\\)' ? join(map(split(v:val, '^%:\\l\\+\\zs'), 'v:key == 0 ? expand(v:val) : v:val'), '') : v:val") | |
| FUNCTION neomake#CleanOldFileSignsAndErrors() | |
| Called 1 time | |
| Total time: 0.000205 | |
| Self time: 0.000078 | |
| count total (s) self (s) | |
| 1 0.000008 let bufnr = a:0 ? a:1 : bufnr('%') | |
| 1 0.000010 if get(s:need_errors_cleaning['file'], bufnr, 0) | |
| 1 0.000004 if has_key(s:current_errors['file'], bufnr) | |
| unlet s:current_errors['file'][bufnr] | |
| endif | |
| 1 0.000004 unlet s:need_errors_cleaning['file'][bufnr] | |
| 1 0.000100 0.000034 call neomake#highlights#ResetFile(bufnr) | |
| 1 0.000061 0.000004 call neomake#utils#DebugMessage('File-level errors cleaned in buffer '.bufnr) | |
| 1 0.000001 endif | |
| 1 0.000001 if g:neomake_place_signs | |
| 1 0.000008 0.000004 call neomake#signs#CleanOldSigns(bufnr, 'file') | |
| 1 0.000001 endif | |
| FUNCTION neomake#ProcessCurrentWindow() | |
| Called 1 time | |
| Total time: 0.000051 | |
| Self time: 0.000029 | |
| count total (s) self (s) | |
| 1 0.000031 0.000009 if s:CanProcessJobOutput() | |
| 1 0.000008 let outputs = get(w:, 'neomake_jobs_output', {}) | |
| 1 0.000003 if len(outputs) | |
| unlet w:neomake_jobs_output | |
| call s:ProcessPendingOutput(outputs) | |
| endif | |
| 1 0.000001 endif | |
| FUNCTION neomake#compat#getbufvar() | |
| Called 42 times | |
| Total time: 0.000100 | |
| Self time: 0.000100 | |
| count total (s) self (s) | |
| 42 0.000088 return getbufvar(a:buf, a:key, a:def) | |
| FUNCTION neomake#utils#GetSetting() | |
| Called 12 times | |
| Total time: 0.001497 | |
| Self time: 0.001335 | |
| count total (s) self (s) | |
| 12 0.000041 let maker_name = has_key(a:maker, 'name') ? a:maker.name : '' | |
| 36 0.000059 for ft in a:fts + [''] | |
| " Look through the override vars for a filetype maker, like | |
| " neomake_scss_sasslint_exe (should be a string), and | |
| " neomake_scss_sasslint_args (should be a list). | |
| 24 0.000164 let part = join(filter([ft, maker_name], 'len(v:val)'), '_') | |
| 24 0.000032 if !len(part) | |
| break | |
| endif | |
| 24 0.000065 let config_var = 'neomake_'.part.'_'.a:key | |
| 24 0.000581 0.000458 if has_key(g:, config_var) || neomake#compat#getbufvar(a:bufnr, config_var, s:unset) isnot s:unset | |
| break | |
| endif | |
| 24 0.000016 endfor | |
| 12 0.000023 if exists('config_var') | |
| 12 0.000068 0.000042 let bufcfgvar = neomake#compat#getbufvar(a:bufnr, config_var, s:unset) | |
| 12 0.000013 if bufcfgvar isnot s:unset | |
| return copy(bufcfgvar) | |
| elseif has_key(g:, config_var) | |
| return copy(get(g:, config_var)) | |
| endif | |
| 12 0.000006 endif | |
| 12 0.000019 if has_key(a:maker, a:key) | |
| 6 0.000009 return a:maker[a:key] | |
| endif | |
| " Look for 'neomake_'.key in the buffer and global namespace. | |
| 6 0.000035 0.000023 let bufvar = neomake#compat#getbufvar(a:bufnr, 'neomake_'.a:key, s:unset) | |
| 6 0.000006 if bufvar isnot s:unset | |
| return bufvar | |
| endif | |
| 6 0.000011 if has_key(g:, 'neomake_'.a:key) | |
| return get(g:, 'neomake_'.a:key) | |
| endif | |
| 6 0.000006 return a:default | |
| FUNCTION neomake#highlights#ShowHighlights() | |
| Called 3 times | |
| Total time: 0.000009 | |
| Self time: 0.000009 | |
| count total (s) self (s) | |
| 3 0.000004 if s:nvim_api | |
| 3 0.000003 return | |
| endif | |
| call s:ResetHighlights() | |
| let l:buf = bufnr('%') | |
| for l:type in ['file', 'project'] | |
| for l:hi in keys(get(s:highlights[l:type], l:buf, {})) | |
| if exists('*matchaddpos') | |
| call add(w:current_highlights, matchaddpos(l:hi, s:highlights[l:type][l:buf][l:hi])) | |
| else | |
| for l:loc in s:highlights[l:type][l:buf][l:hi] | |
| if len(l:loc) == 1 | |
| call add(w:current_highlights, matchadd(l:hi, '\%' . l:loc[0] . 'l')) | |
| else | |
| call add(w:current_highlights, matchadd(l:hi, '\%' . l:loc[0] . 'l\%' . l:loc[1] . 'c.\{' . l:loc[2] . '}')) | |
| endif | |
| endfor | |
| endif | |
| endfor | |
| endfor | |
| FUNCTION remote#host#IsRunning() | |
| Called 1 time | |
| Total time: 0.000006 | |
| Self time: 0.000006 | |
| count total (s) self (s) | |
| 1 0.000002 if !has_key(s:hosts, a:name) | |
| throw 'No host named "'.a:name.'" is registered' | |
| endif | |
| 1 0.000002 return s:hosts[a:name].channel != 0 | |
| FUNCTION neomake#EchoCurrentError() | |
| Called 2 times | |
| Total time: 0.000117 | |
| Self time: 0.000117 | |
| count total (s) self (s) | |
| " a:1 might be a timer from the VimResized event. | |
| 2 0.000004 let force = a:0 ? a:1 : 0 | |
| 2 0.000005 if !force && !get(g:, 'neomake_echo_current_error', 1) | |
| return | |
| endif | |
| 2 0.000004 let buf = bufnr('%') | |
| 2 0.000003 let ln = line('.') | |
| 2 0.000003 let ln_errors = [] | |
| 6 0.000010 for maker_type in ['file', 'project'] | |
| 4 0.000018 let buf_errors = get(s:current_errors[maker_type], buf, {}) | |
| 4 0.000012 let ln_errors += get(buf_errors, ln, []) | |
| 4 0.000004 endfor | |
| 2 0.000005 if empty(ln_errors) | |
| 2 0.000005 if exists('s:neomake_last_echoed_error') | |
| echon '' | |
| unlet s:neomake_last_echoed_error | |
| endif | |
| 2 0.000002 return | |
| endif | |
| if len(ln_errors) > 1 | |
| let ln_errors = copy(ln_errors) | |
| call sort(ln_errors, function('neomake#utils#sort_by_col')) | |
| endif | |
| let error_entry = ln_errors[0] | |
| if !force && exists('s:neomake_last_echoed_error') && s:neomake_last_echoed_error == error_entry | |
| return | |
| endif | |
| let s:neomake_last_echoed_error = error_entry | |
| let message = error_entry.maker_name.': '.error_entry.text | |
| call neomake#utils#WideMessage(message) | |
| FUNCTION neomake#utils#hook() | |
| Called 2 times | |
| Total time: 0.000252 | |
| Self time: 0.000086 | |
| count total (s) self (s) | |
| 2 0.000006 if exists('#User#'.a:event) | |
| let jobinfo = a:0 ? a:1 : ( has_key(a:context, 'jobinfo') ? a:context.jobinfo : {}) | |
| let g:neomake_hook_context = a:context | |
| let args = ['Calling User autocmd '.a:event .' with context: '.string(map(copy(a:context), "v:key == 'jobinfo' ? '…' : v:val"))] | |
| if len(jobinfo) | |
| let args += [jobinfo] | |
| endif | |
| call call('neomake#utils#LoudMessage', args) | |
| if v:version >= 704 || (v:version == 703 && has('patch442')) | |
| exec 'doautocmd <nomodeline> User ' . a:event | |
| else | |
| exec 'doautocmd User ' . a:event | |
| endif | |
| unlet g:neomake_hook_context | |
| else | |
| 2 0.000195 0.000028 call neomake#utils#DebugMessage(printf( 'Skipping User autocmd %s: no hooks.', a:event)) | |
| 2 0.000001 endif | |
| FUNCTION <SNR>35_cursormoved_delayed_cb() | |
| Called 1 time | |
| Total time: 0.000852 | |
| Self time: 0.000049 | |
| count total (s) self (s) | |
| 1 0.000025 if getpos('.') == s:cursormoved_last_pos | |
| 1 0.000824 0.000021 call neomake#CursorMoved() | |
| 1 0.000001 endif | |
| FUNCTION <SNR>35_HandleLoclistQflistDisplay() | |
| Called 2 times | |
| Total time: 0.000029 | |
| Self time: 0.000029 | |
| count total (s) self (s) | |
| 2 0.000006 let open_val = get(g:, 'neomake_open_list') | |
| 2 0.000002 if open_val | |
| let height = get(g:, 'neomake_list_height', 10) | |
| let win_val = winnr() | |
| if a:file_mode | |
| exe 'lwindow' height | |
| else | |
| exe 'cwindow' height | |
| endif | |
| if open_val == 2 && win_val != winnr() | |
| wincmd p | |
| endif | |
| endif | |
| FUNCTION neomake#CursorMoved() | |
| Called 1 time | |
| Total time: 0.000803 | |
| Self time: 0.000052 | |
| count total (s) self (s) | |
| 1 0.000005 let l:line = line('.') | |
| 1 0.000004 if s:last_cursormoved[0] != l:line || s:last_cursormoved[1] != bufnr('%') | |
| 1 0.000015 let s:last_cursormoved = [l:line, bufnr('%')] | |
| 1 0.000002 if g:neomake_place_signs | |
| 1 0.000691 0.000012 call neomake#signs#PlaceVisibleSigns() | |
| 1 0.000001 endif | |
| 1 0.000001 endif | |
| 1 0.000083 0.000010 call neomake#EchoCurrentError() | |
| FUNCTION neomake#GetMaker() | |
| Called 2 times | |
| Total time: 73.050476 | |
| Self time: 0.000444 | |
| count total (s) self (s) | |
| 2 0.000002 if a:0 | |
| 2 0.000003 let real_ft = a:1 | |
| 2 0.000044 0.000008 let fts = neomake#utils#GetSortedFiletypes(real_ft) | |
| 2 0.000002 else | |
| let fts = [] | |
| endif | |
| 2 0.000006 if type(a:name_or_maker) == type({}) | |
| let maker = a:name_or_maker | |
| elseif a:name_or_maker ==# 'makeprg' | |
| let maker = neomake#utils#MakerFromCommand(&makeprg) | |
| elseif a:name_or_maker !~# '\v^\w+$' | |
| call neomake#utils#ErrorMessage('Invalid maker name: '.a:name_or_maker) | |
| return {} | |
| else | |
| 2 0.000003 if len(fts) | |
| 4 0.000006 for ft in fts | |
| 2 0.000010 let m = get(g:, 'neomake_'.ft.'_'.a:name_or_maker.'_maker') | |
| 2 0.000004 if type(m) == type({}) | |
| let maker = m | |
| break | |
| endif | |
| 2 0.000002 unlet m | |
| 2 0.000002 endfor | |
| 2 0.000003 elseif exists('g:neomake_'.a:name_or_maker.'_maker') | |
| let maker = get(g:, 'neomake_'.a:name_or_maker.'_maker') | |
| endif | |
| 2 0.000004 if !exists('maker') | |
| 2 0.000003 if len(fts) | |
| 2 0.000003 for ft in fts | |
| 2 0.000002 try | |
| 2 73.048734 0.000037 let maker = eval('neomake#makers#ft#'.ft.'#'.a:name_or_maker.'()') | |
| 2 0.000002 break | |
| catch /^Vim\%((\a\+)\)\=:E117/ | |
| endtry | |
| endfor | |
| 2 0.000001 else | |
| try | |
| let maker = eval('neomake#makers#'.a:name_or_maker.'#'.a:name_or_maker.'()') | |
| catch /^Vim\%((\a\+)\)\=:E117/ | |
| endtry | |
| endif | |
| 2 0.000001 endif | |
| 2 0.000004 if !exists('maker') | |
| call neomake#utils#ErrorMessage('Maker not found: '.a:name_or_maker) | |
| return {} | |
| endif | |
| 2 0.000001 endif | |
| " Create the maker object. | |
| 2 0.000026 let maker = deepcopy(maker) | |
| 2 0.000004 if !has_key(maker, 'name') | |
| 2 0.000006 if type(a:name_or_maker) == type('') | |
| 2 0.000004 let maker.name = a:name_or_maker | |
| 2 0.000001 else | |
| let maker.name = 'unnamed_maker' | |
| endif | |
| 2 0.000001 endif | |
| 2 0.000008 let maker.get_argv = s:maker_base.get_argv | |
| 2 0.000009 let defaults = copy(s:maker_defaults) | |
| 2 0.000016 call extend(defaults, { 'exe': maker.name, 'args': [], 'errorformat': &errorformat, }) | |
| 2 0.000005 let bufnr = bufnr('%') | |
| 12 0.000032 for [key, default] in items(defaults) | |
| 10 0.001371 0.000070 let maker[key] = neomake#utils#GetSetting(key, maker, default, fts, bufnr) | |
| 10 0.000012 unlet! default " workaround for old Vim (7.3.429) | |
| 10 0.000007 endfor | |
| 2 0.000004 if exists('real_ft') | |
| 2 0.000003 let maker.ft = real_ft | |
| 2 0.000001 endif | |
| 2 0.000009 return maker | |
| FUNCTION neomake#signs#CleanOldSigns() | |
| Called 2 times | |
| Total time: 0.000010 | |
| Self time: 0.000010 | |
| count total (s) self (s) | |
| 2 0.000007 if !has_key(s:last_placed_signs[a:type], a:bufnr) | |
| 2 0.000002 return | |
| endif | |
| call neomake#utils#DebugObject('Cleaning old signs in buffer '.a:bufnr.': ', s:last_placed_signs[a:type]) | |
| if bufexists(str2nr(a:bufnr)) | |
| for ln in keys(s:last_placed_signs[a:type][a:bufnr]) | |
| let cmd = 'sign unplace '.s:last_placed_signs[a:type][a:bufnr][ln].' buffer='.a:bufnr | |
| call neomake#utils#DebugMessage('Unplacing sign: '.cmd) | |
| exe cmd | |
| endfor | |
| endif | |
| unlet s:last_placed_signs[a:type][a:bufnr] | |
| FUNCTION neomake#signs#PlaceVisibleSigns() | |
| Called 2 times | |
| Total time: 0.000714 | |
| Self time: 0.000714 | |
| count total (s) self (s) | |
| 6 0.000012 for type in ['file', 'project'] | |
| 4 0.000009 let buf = bufnr('%') | |
| 4 0.000015 if !has_key(s:sign_queue[type], buf) | |
| 3 0.000003 continue | |
| endif | |
| 1 0.000003 let topline = line('w0') | |
| 1 0.000002 let botline = line('w$') | |
| 82 0.000074 for ln in range(topline, botline) | |
| 81 0.000215 if has_key(s:sign_queue[type][buf], ln) | |
| call neomake#signs#PlaceSign(s:sign_queue[type][buf][ln], type) | |
| unlet s:sign_queue[type][buf][ln] | |
| endif | |
| 81 0.000050 endfor | |
| 1 0.000002 if empty(s:sign_queue[type][buf]) | |
| 1 0.000004 unlet s:sign_queue[type][buf] | |
| 1 0.000001 endif | |
| 1 0.000001 endfor | |
| FUNCTION <SNR>36_findFileInParent() | |
| Called 4 times | |
| Total time: 0.000967 | |
| Self time: 0.000967 | |
| count total (s) self (s) | |
| 4 0.000017 let old_suffixesadd = &suffixesadd | |
| 4 0.000025 let &suffixesadd = '' | |
| 4 0.000886 let file = findfile(a:what, escape(a:where, ' ') . ';') | |
| 4 0.000027 let &suffixesadd = old_suffixesadd | |
| 4 0.000006 return file | |
| FUNCTION <SNR>35_CanProcessJobOutput() | |
| Called 3 times | |
| Total time: 0.000072 | |
| Self time: 0.000072 | |
| count total (s) self (s) | |
| " We can only process output (change the location/quickfix list) in | |
| " certain modes, otherwise e.g. the visual selection gets lost. | |
| 3 0.000021 if index(['n', 'i'], mode()) == -1 | |
| call neomake#utils#DebugMessage('Not processing output for mode '.mode()) | |
| elseif exists('*getcmdwintype') && getcmdwintype() !=# '' | |
| call neomake#utils#DebugMessage('Not processing output from command-line window '.getcmdwintype()) | |
| else | |
| 3 0.000004 return 1 | |
| endif | |
| return 0 | |
| FUNCTION neomake#makers#ft#java#EnabledMakers() | |
| Called 1 time | |
| Total time: 0.000102 | |
| Self time: 0.000102 | |
| count total (s) self (s) | |
| 1 0.000003 let makers = [] | |
| 1 0.000044 if executable(expand(g:neomake_java_javac_executable, 1)) | |
| 1 0.000005 call add(makers, g:neomake_java_javac_executable) | |
| 1 0.000001 endif | |
| 1 0.000043 if executable(expand(g:neomake_java_checkstyle_executable, 1)) | |
| call add(makers, g:neomake_java_checkstyle_executable) | |
| endif | |
| 1 0.000001 return makers | |
| FUNCTION neomake#GetEnabledMakers() | |
| Called 1 time | |
| Total time: 73.041280 | |
| Self time: 0.000502 | |
| count total (s) self (s) | |
| 1 0.000004 if !a:0 || type(a:1) !=# type('') | |
| " If we have no filetype, use the global default makers. | |
| " This variable is also used for project jobs, so it has no | |
| " buffer local ('b:') counterpart for now. | |
| return get(g:, 'neomake_enabled_makers', []) | |
| endif | |
| " If a filetype was passed, get the makers that are enabled for each of | |
| " the filetypes represented. | |
| 1 0.000002 let makers = [] | |
| 1 0.000002 let makers_count = {} | |
| 1 0.000040 0.000014 let fts = neomake#utils#GetSortedFiletypes(a:1) | |
| 2 0.000005 for ft in fts | |
| 1 0.000010 let ft = substitute(ft, '\W', '_', 'g') | |
| 1 0.000002 unlet! l:enabled_makers | |
| 3 0.000008 for l:varname in [ 'b:neomake_'.ft.'_enabled_makers', 'g:neomake_'.ft.'_enabled_makers'] | |
| 2 0.000006 if exists(l:varname) | |
| let l:enabled_makers = eval(l:varname) | |
| break | |
| endif | |
| 2 0.000002 endfor | |
| " Use plugin's defaults if not customized. | |
| 1 0.000002 if !exists('l:enabled_makers') | |
| 1 0.000001 try | |
| 1 0.000003 let fnname = 'neomake#makers#ft#'.ft.'#EnabledMakers' | |
| 1 0.001405 0.000330 let default_makers = eval(fnname . '()') | |
| 1 0.000002 catch /^Vim\%((\a\+)\)\=:E117/ | |
| let default_makers = [] | |
| endtry | |
| 1 73.039693 0.000017 let l:enabled_makers = neomake#utils#AvailableMakers(ft, default_makers) | |
| 1 0.000002 endif | |
| " @vimlint(EVL104, 1, l:enabled_makers) | |
| 2 0.000003 for maker_name in l:enabled_makers | |
| 1 0.000003 let c = get(makers_count, maker_name, 0) | |
| 1 0.000003 let makers_count[maker_name] = c + 1 | |
| " Add each maker only once, but keep the order. | |
| 1 0.000001 if c == 0 | |
| 1 0.000002 let makers += [maker_name] | |
| 1 0.000001 endif | |
| 1 0.000001 endfor | |
| 1 0.000001 endfor | |
| 1 0.000002 let l = len(fts) | |
| 1 0.000008 return filter(makers, 'makers_count[v:val] ==# l') | |
| FUNCTION <SNR>35_exit_handler() | |
| Called 1 time | |
| Total time: 0.005499 | |
| Self time: 0.000183 | |
| count total (s) self (s) | |
| 1 0.000012 if !has_key(s:jobs, a:job_id) | |
| call neomake#utils#QuietMessage('exit: job not found: '.string(a:job_id)) | |
| return | |
| endif | |
| 1 0.000004 let jobinfo = s:jobs[a:job_id] | |
| 1 0.000002 if get(jobinfo, 'restarting') | |
| call neomake#utils#DebugMessage('exit: job is restarting.', jobinfo) | |
| call s:MakeJob(jobinfo.make_id, jobinfo) | |
| call remove(s:jobs, jobinfo.id) | |
| return | |
| endif | |
| 1 0.000002 if get(jobinfo, 'canceled') | |
| call neomake#utils#DebugMessage('exit: job was canceled.', jobinfo) | |
| call s:CleanJobinfo(jobinfo) | |
| return | |
| endif | |
| 1 0.000002 let maker = jobinfo.maker | |
| 1 0.000004 if exists('jobinfo._vim_in_handler') || exists('jobinfo._nvim_in_handler') | |
| let jobinfo._exited_while_in_handler = a:data | |
| call neomake#utils#DebugMessage(printf('exit (delayed): %s: %s', maker.name, string(a:data)), jobinfo) | |
| return | |
| endif | |
| 1 0.000081 0.000010 call neomake#utils#DebugMessage(printf('%s: %s: %s', a:event_type, maker.name, string(a:data)), jobinfo) | |
| " Handle any unfinished lines from stdout/stderr callbacks. | |
| 1 0.000002 let has_pending_output = 0 | |
| 3 0.000005 for event_type in ['stdout', 'stderr'] | |
| 2 0.000004 if has_key(jobinfo, event_type) | |
| 1 0.000002 let lines = jobinfo[event_type] | |
| 1 0.000002 if len(lines) | |
| 1 0.000002 if lines[-1] ==# '' | |
| 1 0.000003 call remove(lines, -1) | |
| 1 0.000001 endif | |
| 1 0.000001 if len(lines) | |
| 1 0.004395 0.000012 if s:RegisterJobOutput(jobinfo, lines, event_type) | |
| let has_pending_output = 1 | |
| endif | |
| 1 0.000001 endif | |
| 1 0.000002 unlet jobinfo[event_type] | |
| 1 0.000001 endif | |
| 1 0.000001 endif | |
| 2 0.000002 endfor | |
| 1 0.000002 let status = a:data | |
| 1 0.000002 if has_key(maker, 'exit_callback') && !get(jobinfo, 'failed_to_start') | |
| let callback_dict = { 'status': status, 'name': maker.name, 'has_next': has_key(maker, 'next') } | |
| if type(maker.exit_callback) == type('') | |
| let l:ExitCallback = function(maker.exit_callback) | |
| else | |
| let l:ExitCallback = maker.exit_callback | |
| endif | |
| try | |
| call call(l:ExitCallback, [callback_dict], jobinfo) | |
| catch /^Vim\%((\a\+)\)\=:E117/ | |
| endtry | |
| endif | |
| 1 0.000009 0.000004 if neomake#has_async_support() && (has('nvim') || status != 122) | |
| 1 0.000082 0.000007 call neomake#utils#DebugMessage(printf( '%s: completed with exit code %d.', maker.name, status), jobinfo) | |
| 1 0.000001 endif | |
| 1 0.000016 0.000007 if has_pending_output || s:has_pending_output(jobinfo) | |
| call neomake#utils#DebugMessage( 'Output left to be processed, not cleaning job yet.', jobinfo) | |
| let jobinfo.pending_output = 1 | |
| let jobinfo.finished = 1 | |
| endif | |
| 1 0.000781 0.000008 call s:handle_next_makers(jobinfo, status) | |
| FUNCTION <SNR>38_check_interpreter() | |
| Called 1 time | |
| Total time: 0.047934 | |
| Self time: 0.047934 | |
| count total (s) self (s) | |
| 1 0.000065 let prog_path = exepath(a:prog) | |
| 1 0.000004 if prog_path ==# '' | |
| return [0, a:prog . ' not found in search path or not executable.'] | |
| endif | |
| 1 0.000001 if a:skip | |
| return [1, ''] | |
| endif | |
| 1 0.000003 let min_version = (a:major_ver == 2) ? '2.6' : '3.3' | |
| " Try to load neovim module, and output Python version. | |
| " Return codes: | |
| " 0 Neovim module can be loaded. | |
| " 2 Neovim module cannot be loaded. | |
| " Otherwise something else went wrong (e.g. 1 or 127). | |
| 1 0.047781 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))' ]) | |
| 1 0.000006 if v:shell_error == 2 || v:shell_error == 0 | |
| " Check version only for expected return codes. | |
| 1 0.000028 if prog_ver !~ '^' . a:major_ver | |
| return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python ' . a:major_ver . '.'] | |
| elseif prog_ver =~ '^' . a:major_ver && prog_ver < min_version | |
| return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python >= ' . min_version . '.'] | |
| endif | |
| 1 0.000001 endif | |
| 1 0.000001 if v:shell_error == 2 | |
| return [0, prog_path . ' does not have the neovim module installed. ' . 'See ":help provider-python".'] | |
| elseif v:shell_error == 127 | |
| " This can happen with pyenv's shims. | |
| return [0, prog_path . ' does not exist: ' . prog_ver] | |
| elseif v:shell_error | |
| return [0, 'Checking ' . prog_path . ' caused an unknown error. ' . '(' . v:shell_error . ', output: ' . prog_ver . ')' . ' Please report this at github.com/neovim/neovim.'] | |
| endif | |
| 1 0.000003 return [1, ''] | |
| FUNCTION <SNR>36_GlobPathList() | |
| Called 1 time | |
| Total time: 1.472866 | |
| Self time: 1.472866 | |
| count total (s) self (s) | |
| 1 0.000009 if v:version >= 705 || (v:version == 704 && has('patch279')) | |
| 1 1.472852 return globpath(a:path, a:pattern, a:suf, 1) | |
| else | |
| return split(globpath(a:path, a:pattern, a:suf), "\n") | |
| endif | |
| FUNCTION neomake#CursorMovedDelayed() | |
| Called 10 times | |
| Total time: 0.000195 | |
| Self time: 0.000195 | |
| count total (s) self (s) | |
| 10 0.000029 if exists('s:cursormoved_timer') | |
| 10 0.000024 call timer_stop(s:cursormoved_timer) | |
| 10 0.000008 endif | |
| 10 0.000085 let s:cursormoved_timer = timer_start(get(g:, 'neomake_cursormoved_delay', 100), function('s:cursormoved_delayed_cb')) | |
| 10 0.000038 let s:cursormoved_last_pos = getpos('.') | |
| FUNCTION <SNR>35_RegisterJobOutput() | |
| Called 1 time | |
| Total time: 0.004382 | |
| Self time: 0.000054 | |
| count total (s) self (s) | |
| 1 0.000002 if !a:jobinfo.file_mode | |
| if s:CanProcessJobOutput() | |
| call s:ProcessJobOutput(a:jobinfo, a:lines, a:source) | |
| if g:neomake_place_signs | |
| call neomake#signs#PlaceVisibleSigns() | |
| endif | |
| return 0 | |
| else | |
| if !exists('s:project_job_output[a:jobinfo.id]') | |
| let s:project_job_output[a:jobinfo.id] = {} | |
| endif | |
| if !exists('s:project_job_output[a:jobinfo.id][a:source]') | |
| let s:project_job_output[a:jobinfo.id][a:source] = [] | |
| endif | |
| let s:project_job_output[a:jobinfo.id][a:source] += a:lines | |
| endif | |
| return 1 | |
| endif | |
| " Process the window directly if we can. | |
| 1 0.000026 0.000011 if s:CanProcessJobOutput() && index(get(w:, 'neomake_make_ids', []), a:jobinfo.make_id) != -1 | |
| 1 0.004284 0.000009 call s:ProcessJobOutput(a:jobinfo, a:lines, a:source) | |
| 1 0.000039 0.000003 call neomake#signs#PlaceVisibleSigns() | |
| 1 0.000011 0.000008 call neomake#highlights#ShowHighlights() | |
| 1 0.000001 return 0 | |
| endif | |
| " file mode: append lines to jobs's window's output. | |
| let [t, w] = s:GetTabWinForMakeId(a:jobinfo.make_id) | |
| if w == -1 | |
| call neomake#utils#LoudMessage('No window found for output!', a:jobinfo) | |
| return 0 | |
| endif | |
| let w_output = s:gettabwinvar(t, w, 'neomake_jobs_output', {}) | |
| if !has_key(w_output, a:jobinfo.id) | |
| let w_output[a:jobinfo.id] = {} | |
| endif | |
| if !has_key(w_output[a:jobinfo.id], a:source) | |
| let w_output[a:jobinfo.id][a:source] = [] | |
| if !exists('s:buffer_job_output[a:jobinfo.bufnr]') | |
| let s:buffer_job_output[a:jobinfo.bufnr] = [] | |
| endif | |
| let s:buffer_job_output[a:jobinfo.bufnr] += [a:jobinfo.id] | |
| endif | |
| let w_output[a:jobinfo.id][a:source] += a:lines | |
| call settabwinvar(t, w, 'neomake_jobs_output', w_output) | |
| return 1 | |
| FUNCTION <SNR>35_CleanJobinfo() | |
| Called 1 time | |
| Total time: 0.000751 | |
| Self time: 0.000108 | |
| count total (s) self (s) | |
| 1 0.000135 0.000004 call neomake#utils#DebugMessage('Cleaning jobinfo', a:jobinfo) | |
| 1 0.000003 if has_key(a:jobinfo, 'id') | |
| 1 0.000004 call remove(s:jobs, a:jobinfo.id) | |
| 1 0.000051 0.000010 let [t, w] = s:GetTabWinForMakeId(a:jobinfo.make_id) | |
| 1 0.000016 0.000007 let jobs_output = s:gettabwinvar(t, w, 'neomake_jobs_output', {}) | |
| 1 0.000002 if has_key(jobs_output, a:jobinfo.id) | |
| unlet jobs_output[a:jobinfo.id] | |
| endif | |
| 1 0.000002 if has_key(s:project_job_output, a:jobinfo.id) | |
| unlet s:project_job_output[a:jobinfo.id] | |
| endif | |
| " If signs were not cleared before this point, then the maker did not return | |
| " any errors, so all signs must be removed | |
| 1 0.000001 if a:jobinfo.file_mode | |
| 1 0.000226 0.000022 call neomake#CleanOldFileSignsAndErrors(a:jobinfo.bufnr) | |
| 1 0.000001 else | |
| call neomake#CleanOldProjectSignsAndErrors() | |
| endif | |
| 1 0.000000 endif | |
| 1 0.000149 0.000009 call neomake#utils#hook('NeomakeJobFinished', {'jobinfo': a:jobinfo}) | |
| " Trigger autocmd if all jobs for a s:Make instance have finished. | |
| 1 0.000006 if !len(filter(copy(s:jobs), 'v:val.make_id == a:jobinfo.make_id')) | |
| " Remove make_id from its window. | |
| 1 0.000002 if !exists('l:t') | |
| let [t, w] = s:GetTabWinForMakeId(a:jobinfo.make_id) | |
| endif | |
| " @vimlint(EVL104, 1, l:t) | |
| " @vimlint(EVL104, 1, l:w) | |
| 1 0.000011 0.000004 let make_ids = s:gettabwinvar(t, w, 'neomake_make_ids', []) | |
| 1 0.000002 let idx = index(make_ids, a:jobinfo.make_id) | |
| 1 0.000001 if idx != -1 | |
| 1 0.000002 call remove(make_ids, idx) | |
| 1 0.000003 call settabwinvar(t, w, 'neomake_make_ids', make_ids) | |
| 1 0.000001 endif | |
| 1 0.000118 0.000006 call neomake#utils#hook('NeomakeFinished', { 'file_mode': a:jobinfo.file_mode, 'make_id': a:jobinfo.make_id}, a:jobinfo) | |
| 1 0.000001 endif | |
| FUNCTION <SNR>35_AddExprCallback() | |
| Called 1 time | |
| Total time: 0.000115 | |
| Self time: 0.000115 | |
| count total (s) self (s) | |
| 1 0.000002 let maker = a:jobinfo.maker | |
| 1 0.000002 let file_mode = a:jobinfo.file_mode | |
| 1 0.000003 let highlight_columns = get(g:, 'neomake_highlight_columns', 1) | |
| 1 0.000003 let highlight_lines = get(g:, 'neomake_highlight_lines', 0) | |
| 1 0.000002 let list = file_mode ? getloclist(0) : getqflist() | |
| 1 0.000001 let list_modified = 0 | |
| 1 0.000001 let counts_changed = 0 | |
| 1 0.000001 let index = a:prev_index | |
| 1 0.000002 let maker_type = file_mode ? 'file' : 'project' | |
| 1 0.000001 let cleaned_signs = 0 | |
| 1 0.000001 let ignored_signs = 0 | |
| 1 0.000005 let s:postprocess = get(maker, 'postprocess', function('neomake#utils#CompressWhitespace')) | |
| 1 0.000002 let debug = get(g:, 'neomake_verbose', 0) >= 3 | |
| 1 0.000002 while index < len(list) | |
| let entry = list[index] | |
| let entry.maker_name = has_key(maker, 'name') ? maker.name : 'makeprg' | |
| let index += 1 | |
| let before = copy(entry) | |
| call call(s:postprocess, [entry], maker) | |
| if entry != before | |
| let list_modified = 1 | |
| if debug | |
| call neomake#utils#DebugMessage(printf( 'Modified list entry (postprocess): %s', join(values(map(neomake#utils#diff_dict(before, entry)[0], "v:key.': '.string(v:val[0]).' => '.string(v:val[1])"))))) | |
| endif | |
| endif | |
| if !entry.valid | |
| if maker.remove_invalid_entries | |
| let index -= 1 | |
| call remove(list, index) | |
| let list_modified = 1 | |
| let entry_copy = copy(entry) | |
| call neomake#utils#DebugMessage(printf( 'Removing invalid entry: %s (%s)', remove(entry_copy, 'text'), string(entry_copy)), a:jobinfo) | |
| endif | |
| continue | |
| endif | |
| if !file_mode | |
| if neomake#statusline#AddQflistCount(entry) | |
| let counts_changed = 1 | |
| endif | |
| endif | |
| if !entry.bufnr | |
| continue | |
| endif | |
| if file_mode | |
| if neomake#statusline#AddLoclistCount(entry.bufnr, entry) | |
| let counts_changed = 1 | |
| endif | |
| endif | |
| if !cleaned_signs | |
| if file_mode | |
| call neomake#CleanOldFileSignsAndErrors(entry.bufnr) | |
| else | |
| call neomake#CleanOldProjectSignsAndErrors() | |
| endif | |
| let cleaned_signs = 1 | |
| endif | |
| " Track all errors by buffer and line | |
| let s:current_errors[maker_type][entry.bufnr] = get(s:current_errors[maker_type], entry.bufnr, {}) | |
| let s:current_errors[maker_type][entry.bufnr][entry.lnum] = get( s:current_errors[maker_type][entry.bufnr], entry.lnum, []) | |
| call add(s:current_errors[maker_type][entry.bufnr][entry.lnum], entry) | |
| if g:neomake_place_signs | |
| if entry.lnum is 0 | |
| let ignored_signs += 1 | |
| else | |
| call neomake#signs#RegisterSign(entry, maker_type) | |
| endif | |
| endif | |
| if highlight_columns || highlight_lines | |
| call neomake#highlights#AddHighlight(entry, maker_type) | |
| endif | |
| endwhile | |
| 1 0.000001 if list_modified | |
| if file_mode | |
| call setloclist(0, list, 'r') | |
| else | |
| call setqflist(list, 'r') | |
| endif | |
| endif | |
| 1 0.000001 if ignored_signs | |
| call neomake#utils#DebugMessage(printf( 'Could not place signs for %d entries without line number.', ignored_signs)) | |
| endif | |
| 1 0.000001 return counts_changed | |
| FUNCTION <SNR>35_output_handler() | |
| Called 46 times | |
| Total time: 0.006746 | |
| Self time: 0.003451 | |
| count total (s) self (s) | |
| 46 0.000099 let jobinfo = s:jobs[a:job_id] | |
| 46 0.003825 0.000530 call neomake#utils#DebugMessage(printf('%s: %s: %s', a:event_type, jobinfo.maker.name, string(a:data)), jobinfo) | |
| 46 0.000159 let last_event_type = get(jobinfo, 'event_type', a:event_type) | |
| " a:data is a list of 'lines' read. Each element *after* the first | |
| " element represents a newline. | |
| 46 0.000094 if has_key(jobinfo, a:event_type) | |
| 45 0.000093 let lines = jobinfo[a:event_type] | |
| " As per https://github.com/neovim/neovim/issues/3555 | |
| 45 0.001650 let jobinfo[a:event_type] = lines[:-2] + [lines[-1] . get(a:data, 0, '')] + a:data[1:] | |
| 45 0.000038 else | |
| 1 0.000002 let jobinfo[a:event_type] = a:data | |
| 1 0.000001 endif | |
| 46 0.000127 if !jobinfo.maker.buffer_output || last_event_type !=# a:event_type | |
| let lines = jobinfo[a:event_type][:-2] | |
| let jobinfo[a:event_type] = jobinfo[a:event_type][-1:] | |
| if len(lines) | |
| call s:RegisterJobOutput(jobinfo, lines, a:event_type) | |
| endif | |
| endif | |
| FUNCTION neomake#utils#MakerIsAvailable() | |
| Called 1 time | |
| Total time: 73.039644 | |
| Self time: 0.000074 | |
| count total (s) self (s) | |
| 1 0.000003 if a:maker_name ==# 'makeprg' | |
| " makeprg refers to the actual makeprg, which we don't need to check | |
| " for our purposes | |
| return 1 | |
| endif | |
| 1 73.039590 0.000020 let maker = neomake#GetMaker(a:maker_name, a:ft) | |
| 1 0.000002 if empty(maker) | |
| return 0 | |
| endif | |
| 1 0.000002 if !has_key(s:available_makers, maker.exe) | |
| 1 0.000033 let s:available_makers[maker.exe] = executable(maker.exe) | |
| 1 0.000001 endif | |
| 1 0.000007 return s:available_makers[maker.exe] | |
| FUNCTION <SNR>36_GetMavenClasspath() | |
| Called 2 times | |
| Total time: 0.000779 | |
| Self time: 0.000273 | |
| count total (s) self (s) | |
| 2 0.000636 0.000130 let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) | |
| 2 0.000006 if s:has_maven && filereadable(pom) | |
| if !has_key(g:neomake_java_javac_maven_pom_ftime, pom) || g:neomake_java_javac_maven_pom_ftime[pom] != getftime(pom) | |
| let mvn_cmd = s:shescape(expand(g:neomake_java_maven_executable, 1)) . ' -f ' . s:shescape(pom) . ' ' . g:neomake_java_maven_options | |
| let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath -DincludeScope=test'), "\n") | |
| let mvn_classpath = '' | |
| let class_path_next = 0 | |
| for line in mvn_classpath_output | |
| if class_path_next == 1 | |
| let mvn_classpath = substitute(line, "\r", '', 'g') | |
| break | |
| endif | |
| if stridx(line, 'Dependencies classpath:') >= 0 | |
| let class_path_next = 1 | |
| endif | |
| endfor | |
| let mvn_properties = s:GetMavenProperties() | |
| let output_dir = get(mvn_properties, 'project.build.outputDirectory', join(['target', 'classes'], s:psep)) | |
| let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir) | |
| let test_output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join(['target', 'test-classes'], s:psep)) | |
| let mvn_classpath = s:AddToClasspath(mvn_classpath, test_output_dir) | |
| let g:neomake_java_javac_maven_pom_ftime[pom] = getftime(pom) | |
| let g:neomake_java_javac_maven_pom_classpath[pom] = mvn_classpath | |
| endif | |
| return g:neomake_java_javac_maven_pom_classpath[pom] | |
| endif | |
| 2 0.000003 return '' | |
| FUNCTION <SNR>35_AddMakeInfoForCurrentWin() | |
| Called 1 time | |
| Total time: 0.000030 | |
| Self time: 0.000020 | |
| count total (s) self (s) | |
| " Add jobinfo.make_id to current window. | |
| 1 0.000002 let tabpagenr = tabpagenr() | |
| 1 0.000002 let winnr = winnr() | |
| 1 0.000017 0.000007 let w_ids = s:gettabwinvar(tabpagenr, winnr, 'neomake_make_ids', []) | |
| 1 0.000003 let w_ids += [a:job_id] | |
| 1 0.000005 call settabwinvar(tabpagenr, winnr, 'neomake_make_ids', w_ids) | |
| FUNCTIONS SORTED ON TOTAL TIME | |
| count total (s) self (s) function | |
| 1 73.057440 0.000072 neomake#Make() | |
| 2 73.050476 0.000444 neomake#GetMaker() | |
| 2 73.048697 0.000783 neomake#makers#ft#java#javac() | |
| 1 73.041280 0.000502 neomake#GetEnabledMakers() | |
| 1 73.039677 0.000032 neomake#utils#AvailableMakers() | |
| 1 73.039644 0.000074 neomake#utils#MakerIsAvailable() | |
| 2 72.978494 71.505160 <SNR>36_GetGradleClasspath() | |
| 1 1.472866 <SNR>36_GlobPathList() | |
| 1 0.048033 0.000098 provider#pythonx#Detect() | |
| 1 0.047934 <SNR>38_check_interpreter() | |
| 2 0.019386 <SNR>36_tmpdir() | |
| 1 0.016088 0.000701 <SNR>35_Make() | |
| 43 0.009534 0.002788 <SNR>35_nvim_output_handler_cb() | |
| 46 0.006746 0.003451 <SNR>35_output_handler() | |
| 1 0.005499 0.000183 <SNR>35_exit_handler() | |
| 1 0.004382 0.000054 <SNR>35_RegisterJobOutput() | |
| 1 0.004275 0.004041 <SNR>35_ProcessJobOutput() | |
| 1 0.004102 0.003643 <SNR>35_MakeJob() | |
| 54 0.003922 0.000479 neomake#utils#DebugMessage() | |
| 55 0.003524 neomake#utils#LogMessage() | |
| FUNCTIONS SORTED ON SELF TIME | |
| count total (s) self (s) function | |
| 2 72.978494 71.505160 <SNR>36_GetGradleClasspath() | |
| 1 1.472866 <SNR>36_GlobPathList() | |
| 1 0.047934 <SNR>38_check_interpreter() | |
| 2 0.019386 <SNR>36_tmpdir() | |
| 1 0.004275 0.004041 <SNR>35_ProcessJobOutput() | |
| 1 0.004102 0.003643 <SNR>35_MakeJob() | |
| 55 0.003524 neomake#utils#LogMessage() | |
| 46 0.006746 0.003451 <SNR>35_output_handler() | |
| 43 0.009534 0.002788 <SNR>35_nvim_output_handler_cb() | |
| 46 0.001750 <SNR>35_nvim_output_handler() | |
| 12 0.001497 0.001335 neomake#utils#GetSetting() | |
| 4 0.000967 <SNR>36_findFileInParent() | |
| 2 73.048697 0.000783 neomake#makers#ft#java#javac() | |
| 2 0.000714 neomake#signs#PlaceVisibleSigns() | |
| 1 0.016088 0.000701 <SNR>35_Make() | |
| 10 0.000614 <SNR>15_Highlight_Matching_Pair() | |
| 1 73.041280 0.000502 neomake#GetEnabledMakers() | |
| 54 0.003922 0.000479 neomake#utils#DebugMessage() | |
| 2 73.050476 0.000444 neomake#GetMaker() | |
| 2 0.000779 0.000273 <SNR>36_GetMavenClasspath() | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment