Created
February 17, 2018 14:17
-
-
Save micbou/c8576b8716bf41686d11ebcc1e39d340 to your computer and use it in GitHub Desktop.
Issue exiting nvim-qt when executing Python code after GuiClose
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| Searching for "autoload/provider/python3.vim" in "C:\Users\micbou\AppData\Local\nvim,C:\Users\micbou\AppData\Local\nvim\site,C:\nvim\share\nvim\runtime,C:\Users\micbou\AppData\Local\nvim\site\after,C:\Users\micbou\AppData\Local\nvim\after,C:/nvim/share" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\autoload/provider/python3.vim" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\site\autoload/provider/python3.vim" | |
| Searching for "C:\nvim\share\nvim\runtime\autoload/provider/python3.vim" | |
| line 0: sourcing "C:\nvim\share\nvim\runtime\autoload\provider\python3.vim" | |
| line 1: " The Python3 provider uses a Python3 host to emulate an environment for running | |
| line 2: " python3 plugins. :help provider | |
| line 3: " | |
| line 4: " Associating the plugin with the Python3 host is the first step because | |
| line 5: " plugins will be passed as command-line arguments | |
| line 6: | |
| line 7: if exists('g:loaded_python3_provider') | |
| line 8: finish | |
| line 9: endif | |
| line 10: let g:loaded_python3_provider = 1 | |
| line 11: | |
| line 12: let [s:prog, s:err] = provider#pythonx#Detect(3) | |
| Searching for "autoload/provider/pythonx.vim" in "C:\Users\micbou\AppData\Local\nvim,C:\Users\micbou\AppData\Local\nvim\site,C:\nvim\share\nvim\runtime,C:\Users\micbou\AppData\Local\nvim\site\after,C:\Users\micbou\AppData\Local\nvim\after,C:/nvim/share" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\autoload/provider/pythonx.vim" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\site\autoload/provider/pythonx.vim" | |
| Searching for "C:\nvim\share\nvim\runtime\autoload/provider/pythonx.vim" | |
| line 12: sourcing "C:\nvim\share\nvim\runtime\autoload\provider\pythonx.vim" | |
| line 1: " The Python provider helper | |
| line 2: if exists('s:loaded_pythonx_provider') | |
| line 3: finish | |
| line 4: endif | |
| line 5: | |
| line 6: let s:loaded_pythonx_provider = 1 | |
| line 7: | |
| line 8: let s:job_opts = {'rpc': v:true, 'stderr_buffered': v:true} | |
| line 9: | |
| line 10: function! provider#pythonx#Require(host) abort | |
| line 39: | |
| line 40: function! provider#pythonx#Detect(major_ver) abort | |
| line 72: | |
| line 73: function! s:check_interpreter(prog, major_ver) abort | |
| finished sourcing C:\nvim\share\nvim\runtime\autoload\provider\pythonx.vim | |
| continuing in C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| calling function provider#pythonx#Detect(3) | |
| line 1: if a:major_ver == 2 | |
| line 2: if exists('g:python_host_prog') | |
| line 3: return [g:python_host_prog, ''] | |
| line 4: else | |
| line 5: let progs = ['python2', 'python2.7', 'python2.6', 'python'] | |
| line 6: endif | |
| line 7: else | |
| line 8: if exists('g:python3_host_prog') | |
| line 9: return [g:python3_host_prog, ''] | |
| line 10: else | |
| line 11: let progs = ['python3', 'python3.7', 'python3.6', 'python3.5', 'python3.4', 'python3.3', 'python'] | |
| line 13: endif | |
| line 14: endif | |
| line 15: | |
| line 16: let errors = [] | |
| line 17: | |
| line 18: for prog in progs | |
| line 19: let [result, err] = s:check_interpreter(prog, a:major_ver) | |
| calling function provider#pythonx#Detect[19]..<SNR>24_check_interpreter('python3', 3) | |
| line 1: let prog_path = exepath(a:prog) | |
| line 2: if prog_path ==# '' | |
| line 3: return [0, a:prog . ' not found in search path or not executable.'] | |
| line 4: endif | |
| line 5: | |
| line 6: let min_version = (a:major_ver == 2) ? '2.6' : '3.3' | |
| line 7: | |
| line 8: " Try to load neovim module, and output Python version. | |
| line 9: " Return codes: | |
| line 10: " 0 Neovim module can be loaded. | |
| line 11: " 2 Neovim module cannot be loaded. | |
| line 12: " Otherwise something else went wrong (e.g. 1 or 127). | |
| line 13: let prog_ver = system([ a:prog , '-c' , 'import sys; ' . 'sys.path.remove(""); ' . 'sys.stdout.write(str(sys.version_info[0]) + "." + str(sys.version_info[1])); ' . 'import pkgutil; ' . 'exit(2*int(pkgutil.get_loader("neovim") is None))' ]) | |
| line 20: | |
| line 21: if v:shell_error == 2 || v:shell_error == 0 | |
| line 22: " Check version only for expected return codes. | |
| line 23: if prog_ver !~ '^' . a:major_ver | |
| line 24: return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python ' . a:major_ver . '.'] | |
| line 26: elseif prog_ver =~ '^' . a:major_ver && prog_ver < min_version | |
| line 27: return [0, prog_path . ' is Python ' . prog_ver . ' and cannot provide Python >= ' . min_version . '.'] | |
| line 29: endif | |
| line 30: endif | |
| line 31: | |
| line 32: if v:shell_error == 2 | |
| line 33: return [0, prog_path.' does not have the "neovim" module. :help provider-python'] | |
| line 34: elseif v:shell_error == 127 | |
| line 35: " This can happen with pyenv's shims. | |
| line 36: return [0, prog_path . ' does not exist: ' . prog_ver] | |
| line 37: elseif v:shell_error | |
| line 38: return [0, 'Checking ' . prog_path . ' caused an unknown error. ' . '(' . v:shell_error . ', output: ' . prog_ver . ')' . ' Report this at https://github.com/neovim/neovim'] | |
| line 41: endif | |
| line 42: | |
| line 43: return [1, ''] | |
| function provider#pythonx#Detect[19]..<SNR>24_check_interpreter returning [1, ''] | |
| continuing in function provider#pythonx#Detect | |
| line 20: if result | |
| line 21: return [prog, err] | |
| function provider#pythonx#Detect returning ['python3', ''] | |
| continuing in C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| line 13: | |
| line 14: function! provider#python3#Prog() abort | |
| line 17: | |
| line 18: function! provider#python3#Error() abort | |
| line 21: | |
| line 22: if s:prog == '' | |
| line 23: " Detection failed | |
| line 24: finish | |
| line 25: endif | |
| line 26: | |
| line 27: " The Python3 provider plugin will run in a separate instance of the Python3 | |
| line 28: " host. | |
| line 29: call remote#host#RegisterClone('legacy-python3-provider', 'python3') | |
| Searching for "autoload/remote/host.vim" in "C:\Users\micbou\AppData\Local\nvim,C:\Users\micbou\AppData\Local\nvim\site,C:\nvim\share\nvim\runtime,C:\Users\micbou\AppData\Local\nvim\site\after,C:\Users\micbou\AppData\Local\nvim\after,C:/nvim/share" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\autoload/remote/host.vim" | |
| Searching for "C:\Users\micbou\AppData\Local\nvim\site\autoload/remote/host.vim" | |
| Searching for "C:\nvim\share\nvim\runtime\autoload/remote/host.vim" | |
| line 29: sourcing "C:\nvim\share\nvim\runtime\autoload\remote\host.vim" | |
| line 1: let s:hosts = {} | |
| line 2: let s:plugin_patterns = {} | |
| line 3: let s:plugins_for_host = {} | |
| line 4: | |
| line 5: " Register a host by associating it with a factory(funcref) | |
| line 6: function! remote#host#Register(name, pattern, factory) abort | |
| line 14: | |
| line 15: " Register a clone to an existing host. The new host will use the same factory | |
| line 16: " as `source`, but it will run as a different process. This can be used by | |
| line 17: " plugins that should run isolated from other plugins created for the same host | |
| line 18: " type | |
| line 19: function! remote#host#RegisterClone(name, orig_name) abort | |
| line 31: | |
| line 32: " Get a host channel, bootstrapping it if necessary | |
| line 33: function! remote#host#Require(name) abort | |
| line 48: | |
| line 49: function! remote#host#IsRunning(name) abort | |
| line 55: | |
| line 56: " Example of registering a Python plugin with two commands (one async), one | |
| line 57: " autocmd (async) and one function (sync): | |
| line 58: " | |
| line 59: " let s:plugin_path = expand('<sfile>:p:h').'/nvim_plugin.py' | |
| line 60: " call remote#host#RegisterPlugin('python', s:plugin_path, [ | |
| line 61: " \ {'type': 'command', 'name': 'PyCmd', 'sync': 1, 'opts': {}}, | |
| line 62: " \ {'type': 'command', 'name': 'PyAsyncCmd', 'sync': 0, 'opts': {'eval': 'cursor()'}}, | |
| line 63: " \ {'type': 'autocmd', 'name': 'BufEnter', 'sync': 0, 'opts': {'eval': 'expand("<afile>")'}}, | |
| line 64: " \ {'type': 'function', 'name': 'PyFunc', 'sync': 1, 'opts': {}} | |
| line 65: " \ ]) | |
| line 66: " | |
| line 67: " The third item in a declaration is a boolean: non zero means the command, | |
| line 68: " autocommand or function will be executed synchronously with rpcrequest. | |
| line 69: function! remote#host#RegisterPlugin(host, path, specs) abort | |
| line 111: | |
| line 112: function! s:RegistrationCommands(host) abort | |
| line 155: | |
| line 156: function! remote#host#UpdateRemotePlugins() abort | |
| line 176: | |
| line 177: function! remote#host#PluginsForHost(host) abort | |
| line 183: | |
| line 184: function! remote#host#LoadErrorForHost(host, log) abort | |
| line 190: | |
| line 191: " Registration of standard hosts | |
| line 192: | |
| line 193: " Python/Python3 | |
| line 195: call remote#host#Register('python', '*', function('provider#pythonx#Require')) | |
| calling function remote#host#Register('python', '*', function('provider#pythonx#Require')) | |
| line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
| line 2: let s:plugin_patterns[a:name] = a:pattern | |
| line 3: if type(a:factory) == type(1) && a:factory | |
| line 4: " Passed a channel directly | |
| line 5: let s:hosts[a:name].channel = a:factory | |
| line 6: endif | |
| function remote#host#Register returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\remote\host.vim | |
| line 197: call remote#host#Register('python3', '*', function('provider#pythonx#Require')) | |
| calling function remote#host#Register('python3', '*', function('provider#pythonx#Require')) | |
| line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
| line 2: let s:plugin_patterns[a:name] = a:pattern | |
| line 3: if type(a:factory) == type(1) && a:factory | |
| line 4: " Passed a channel directly | |
| line 5: let s:hosts[a:name].channel = a:factory | |
| line 6: endif | |
| function remote#host#Register returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\remote\host.vim | |
| line 198: | |
| line 199: " Ruby | |
| line 201: call remote#host#Register('ruby', '*.rb', function('provider#ruby#Require')) | |
| calling function remote#host#Register('ruby', '*.rb', function('provider#ruby#Require')) | |
| line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
| line 2: let s:plugin_patterns[a:name] = a:pattern | |
| line 3: if type(a:factory) == type(1) && a:factory | |
| line 4: " Passed a channel directly | |
| line 5: let s:hosts[a:name].channel = a:factory | |
| line 6: endif | |
| function remote#host#Register returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\remote\host.vim | |
| line 202: | |
| line 203: " nodejs | |
| line 205: call remote#host#Register('node', '*', function('provider#node#Require')) | |
| calling function remote#host#Register('node', '*', function('provider#node#Require')) | |
| line 1: let s:hosts[a:name] = {'factory': a:factory, 'channel': 0, 'initialized': 0} | |
| line 2: let s:plugin_patterns[a:name] = a:pattern | |
| line 3: if type(a:factory) == type(1) && a:factory | |
| line 4: " Passed a channel directly | |
| line 5: let s:hosts[a:name].channel = a:factory | |
| line 6: endif | |
| function remote#host#Register returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\remote\host.vim | |
| finished sourcing C:\nvim\share\nvim\runtime\autoload\remote\host.vim | |
| continuing in C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| calling function remote#host#RegisterClone('legacy-python3-provider', 'python3') | |
| line 1: if !has_key(s:hosts, a:orig_name) | |
| line 2: throw 'No host named "'.a:orig_name.'" is registered' | |
| line 3: endif | |
| line 4: let Factory = s:hosts[a:orig_name].factory | |
| line 5: let s:hosts[a:name] = { 'factory': Factory, 'channel': 0, 'initialized': 0, 'orig_name': a:orig_name } | |
| function remote#host#RegisterClone returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| line 30: call remote#host#RegisterPlugin('legacy-python3-provider', 'script_host.py', []) | |
| calling function remote#host#RegisterPlugin('legacy-python3-provider', 'script_host.py', []) | |
| line 1: let plugins = remote#host#PluginsForHost(a:host) | |
| calling function remote#host#RegisterPlugin[1]..remote#host#PluginsForHost('legacy-python3-provider') | |
| line 1: if !has_key(s:plugins_for_host, a:host) | |
| line 2: let s:plugins_for_host[a:host] = [] | |
| line 3: end | |
| line 4: return s:plugins_for_host[a:host] | |
| function remote#host#RegisterPlugin[1]..remote#host#PluginsForHost returning [] | |
| continuing in function remote#host#RegisterPlugin | |
| line 2: | |
| line 3: for plugin in plugins | |
| line 4: if plugin.path == a:path | |
| line 5: throw 'Plugin "'.a:path.'" is already registered' | |
| line 6: endif | |
| line 7: endfor | |
| line 8: | |
| line 9: if has_key(s:hosts, a:host) && remote#host#IsRunning(a:host) | |
| calling function remote#host#RegisterPlugin[9]..remote#host#IsRunning('legacy-python3-provider') | |
| line 1: if !has_key(s:hosts, a:name) | |
| line 2: throw 'No host named "'.a:name.'" is registered' | |
| line 3: endif | |
| line 4: return s:hosts[a:name].channel != 0 | |
| function remote#host#RegisterPlugin[9]..remote#host#IsRunning returning #0 | |
| continuing in function remote#host#RegisterPlugin | |
| line 10: " For now we won't allow registration of plugins when the host is already | |
| line 11: " running. | |
| line 12: throw 'Host "'.a:host.'" is already running' | |
| line 13: endif | |
| line 14: | |
| line 15: for spec in a:specs | |
| line 16: let type = spec.type | |
| line 17: let name = spec.name | |
| line 18: let sync = spec.sync | |
| line 19: let opts = spec.opts | |
| line 20: let rpc_method = a:path | |
| line 21: if type == 'command' | |
| line 22: let rpc_method .= ':command:'.name | |
| line 23: call remote#define#CommandOnHost(a:host, rpc_method, sync, name, opts) | |
| line 24: elseif type == 'autocmd' | |
| line 25: " Since multiple handlers can be attached to the same autocmd event by a | |
| line 26: " single plugin, we need a way to uniquely identify the rpc method to | |
| line 27: " call. The solution is to append the autocmd pattern to the method | |
| line 28: " name(This still has a limit: one handler per event/pattern combo, but | |
| line 29: " there's no need to allow plugins define multiple handlers in that case) | |
| line 30: let rpc_method .= ':autocmd:'.name.':'.get(opts, 'pattern', '*') | |
| line 31: call remote#define#AutocmdOnHost(a:host, rpc_method, sync, name, opts) | |
| line 32: elseif type == 'function' | |
| line 33: let rpc_method .= ':function:'.name | |
| line 34: call remote#define#FunctionOnHost(a:host, rpc_method, sync, name, opts) | |
| line 35: else | |
| line 36: echoerr 'Invalid declaration type: '.type | |
| line 37: endif | |
| line 38: endfor | |
| line 39: | |
| line 40: call add(plugins, {'path': a:path, 'specs': a:specs}) | |
| function remote#host#RegisterPlugin returning #0 | |
| continuing in C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| line 31: | |
| line 32: function! provider#python3#Call(method, args) abort | |
| finished sourcing C:\nvim\share\nvim\runtime\autoload\provider\python3.vim | |
| continuing in VimLeave Auto commands for "*" | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| calling function provider#python3#Call[9]..remote#host#Require('legacy-python3-provider') | |
| line 1: if !has_key(s:hosts, a:name) | |
| line 2: throw 'No host named "'.a:name.'" is registered' | |
| line 3: endif | |
| line 4: let host = s:hosts[a:name] | |
| line 5: if !host.channel && !host.initialized | |
| line 6: let host_info = { 'name': a:name, 'orig_name': get(host, 'orig_name', a:name) } | |
| line 10: let host.channel = call(host.factory, [host_info]) | |
| calling function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require({'orig_name': 'python3', 'name': 'legacy-python3-provider'}) | |
| line 1: let ver = (a:host.orig_name ==# 'python') ? 2 : 3 | |
| line 2: | |
| line 3: " Python host arguments | |
| line 4: let prog = (ver == '2' ? provider#python#Prog() : provider#python3#Prog()) | |
| calling function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require[4]..provider#python3#Prog() | |
| line 1: return s:prog | |
| function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require[4]..provider#python3#Prog returning 'python3' | |
| continuing in function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require | |
| line 5: let args = [prog, '-c', 'import sys; sys.path.remove(""); import neovim; neovim.start_host()'] | |
| line 6: | |
| line 7: " Collect registered Python plugins into args | |
| line 8: let python_plugins = remote#host#PluginsForHost(a:host.name) | |
| calling function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require[8]..remote#host#PluginsForHost('legacy-python3-provider') | |
| line 1: if !has_key(s:plugins_for_host, a:host) | |
| line 2: let s:plugins_for_host[a:host] = [] | |
| line 3: end | |
| line 4: return s:plugins_for_host[a:host] | |
| function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require[8]..remote#host#PluginsForHost returning [{'specs': [], 'path': 'script_host.py'}] | |
| continuing in function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require | |
| line 9: for plugin in python_plugins | |
| line 10: call add(args, plugin.path) | |
| line 11: endfor | |
| line 9: for plugin in python_plugins | |
| line 10: call add(args, plugin.path) | |
| line 11: endfor | |
| line 12: | |
| line 13: try | |
| line 14: let job = copy(s:job_opts) | |
| line 15: let channel_id = jobstart(args, job) | |
| line 16: if rpcrequest(channel_id, 'poll') ==# 'ok' | |
| line 17: return channel_id | |
| :return 3 made pending | |
| line 18: endif | |
| line 19: catch | |
| line 20: echomsg v:throwpoint | |
| line 21: echomsg v:exception | |
| line 22: for row in job.stderr | |
| line 23: echomsg row | |
| line 24: endfor | |
| line 25: endtry | |
| :return 3 resumed | |
| function provider#python3#Call[9]..remote#host#Require[10]..provider#pythonx#Require returning #3 | |
| continuing in function provider#python3#Call[9]..remote#host#Require | |
| line 11: let host.initialized = 1 | |
| line 12: endif | |
| line 13: return host.channel | |
| function provider#python3#Call[9]..remote#host#Require returning #3 | |
| continuing in function provider#python3#Call | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| line 1: call rpcnotify(0, 'Gui', 'Close') | |
| function GuiClose returning #0 | |
| continuing in VimLeave Auto commands for "*" | |
| autocommand python3 pass | |
| line 0: python3 pass | |
| calling function provider#python3#Call('execute', ['pass', 1, 1]) | |
| line 1: if s:err != '' | |
| line 2: return | |
| line 3: endif | |
| line 4: if !exists('s:host') | |
| line 5: let s:rpcrequest = function('rpcrequest') | |
| line 6: | |
| line 7: " Ensure that we can load the Python3 host before bootstrapping | |
| line 8: try | |
| line 9: let s:host = remote#host#Require('legacy-python3-provider') | |
| line 10: catch | |
| line 11: let s:err = v:exception | |
| line 12: echohl WarningMsg | |
| line 13: echomsg v:exception | |
| line 14: echohl None | |
| line 15: return | |
| line 16: endtry | |
| line 17: endif | |
| line 18: return call(s:rpcrequest, insert(insert(a:args, 'python_'.a:method), s:host)) | |
| function provider#python3#Call returning v:null | |
| continuing in VimLeave Auto commands for "*" | |
| Writing ShaDa file "C:\Users\micbou\AppData\Local\nvim-data\shada\main.shada" | |
| Executing VimLeave Auto commands for "*" | |
| autocommand call GuiClose() | |
| line 0: call GuiClose() | |
| calling function GuiClose() | |
| Exception thrown: Vim:E169: Command too recursive | |
| function GuiClose aborted | |
| continuing in VimLeave Auto commands for "*" |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment