309 lines
8.1 KiB
VimL
309 lines
8.1 KiB
VimL
scriptencoding utf-8
|
|
|
|
let s:save_cpo = &cpo
|
|
set cpo&vim
|
|
|
|
|
|
let s:idtypes = {
|
|
\ 'skProc': ["p", "Function"],
|
|
\ 'skTemplate': ["t", "Template"],
|
|
\ 'skType': ["T", "Type"],
|
|
\ 'skMacro': ["M", "Macro"],
|
|
\ 'skMethod': ["m", "Method"],
|
|
\ 'skField': ["field", "Field"],
|
|
\ 'skAlias': ["a", "Alias"],
|
|
\ 'skConditional': ["c", "Conditional"],
|
|
\ 'skConst': ["C", "Constant"],
|
|
\ 'skConverter': ["c", "Converter"],
|
|
\ 'skDynLib': ["d", "Dynamic library"],
|
|
\ 'skEnumField': ["e", "Enum field"],
|
|
\ 'skForVar': ["l", "Loop variable"],
|
|
\ 'skGenericParam': ["g", "Generic parameter"],
|
|
\ 'skGlobalVar': ["g", "Global variable"],
|
|
\ 'skGlobalLet': ["g", "Global constant"],
|
|
\ 'skIterator': ["i", "Iterator"],
|
|
\ 'skLabel': ["l", "Label"],
|
|
\ 'skLet': ["r", "Runtime constant"],
|
|
\ 'skModule': ["m", "Module"],
|
|
\ 'skPackage': ["p", "Package"],
|
|
\ 'skParam': ["p", "Parameter"],
|
|
\ 'skResult': ["r", "Result"],
|
|
\ 'skStub': ["s", "Stub"],
|
|
\ 'skTemp': ["t", "Temporary"],
|
|
\ 'skUnknown': ["u", "Unknown"],
|
|
\ 'skVar': ["v", "Variable"],
|
|
\ }
|
|
|
|
|
|
function! util#FirstNonEmpty(lines)
|
|
for line in a:lines
|
|
if len(line) > 0
|
|
return line
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
|
|
function! util#FirstNonEmpty(lines)
|
|
for line in a:lines
|
|
if len(line) > 0
|
|
return line
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
|
|
function! util#MemFilePath(file)
|
|
return "/tmp/nvimnvimtemp" . substitute(a:file, "\/", "_-_", "g")
|
|
endfunction
|
|
|
|
|
|
"" Writes current buffer into a memfile
|
|
function! util#WriteMemfile()
|
|
let memfile = util#MemFilePath(expand("%:p"))
|
|
call writefile(getline(1, '$'), memfile)
|
|
return memfile
|
|
endfunction
|
|
|
|
|
|
function! util#JumpToWindow(window, line, col)
|
|
execute ":" . a:window . "wincmd w"
|
|
execute ":" . a:line
|
|
execute ":norm " . (a:col) . "|"
|
|
endfunction
|
|
|
|
|
|
function! util#JumpToLocation(file, line, col)
|
|
if expand("%:p") != a:file
|
|
execute ":e " . a:file
|
|
endif
|
|
execute ":" . a:line
|
|
execute ":norm " . (a:col) . "|"
|
|
endfunction
|
|
|
|
|
|
function! util#JumpFromQuickfix(shouldReturn)
|
|
let [file, location, _] = split(getline(line(".")), "|")
|
|
let [l, c] = split(location, " col ")
|
|
wincmd p
|
|
call util#JumpToLocation(file, l, c)
|
|
if a:shouldReturn
|
|
norm zt
|
|
wincmd p
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! util#StartQuery()
|
|
" echohl Comment | echo "..."
|
|
endfunction
|
|
|
|
|
|
function! s:GetModule(path)
|
|
return a:path[0]
|
|
endfunction
|
|
|
|
|
|
function! util#ParseV1(line)
|
|
let res = split(a:line, " ")
|
|
let path = split(res[2], "\\.")
|
|
let result = {
|
|
\ "ctype": res[0],
|
|
\ "kind": res[1],
|
|
\ "symbol": res[2],
|
|
\ "name": res[3],
|
|
\ "file": res[4],
|
|
\ "line": res[5],
|
|
\ "col": res[6],
|
|
\ "doc": res[7],
|
|
\ "module": s:GetModule(path),
|
|
\ "location": join(path[0:-2], "."),
|
|
\ "lname": path[-1],
|
|
\ "kindstr": s:idtypes[res[1]][1],
|
|
\ "kindshort": s:idtypes[res[1]][0],
|
|
\ }
|
|
return result
|
|
endfunction
|
|
|
|
|
|
function! util#ParseV2(line)
|
|
let res = split(a:line, " ")
|
|
let path = split(res[2], "\\.")
|
|
let result = {
|
|
\ "ctype": res[0],
|
|
\ "kind": res[1],
|
|
\ "symbol": res[2],
|
|
\ "type": res[3],
|
|
\ "file": res[4],
|
|
\ "line": res[5],
|
|
\ "col": res[6],
|
|
\ "doc": res[7],
|
|
\ "module": s:GetModule(path),
|
|
\ "location": join(path[0:-2], "."),
|
|
\ "name": path[-1],
|
|
\ "lname": path[-1],
|
|
\ "kindstr": s:idtypes[res[1]][1],
|
|
\ "kindshort": s:idtypes[res[1]][0],
|
|
\ }
|
|
" \ "quality": res[8],
|
|
return result
|
|
endfunction
|
|
|
|
|
|
function! util#FilterCompletionLine(line)
|
|
let result = a:line =~ "^\\(def\\|sug\\|use\\|con\\|outline\\|highlight\\)\\t"
|
|
return result
|
|
endfunction
|
|
|
|
|
|
function! util#FilterCompletions(lines)
|
|
let result = []
|
|
for line in a:lines
|
|
if util#FilterCompletionLine(line)
|
|
call add(result, line)
|
|
endif
|
|
endfor
|
|
return result
|
|
endfunction
|
|
|
|
|
|
let s:nesting_chars = ['(', '[', '{']
|
|
let s:unnesting_chars = [')', ']', '}']
|
|
let s:strip_regex = '\v^\s*(.{-})\s*$'
|
|
|
|
function! util#ParseSignature(input)
|
|
let pstart = stridx(a:input, "(") + 1
|
|
let pend = strridx(a:input, ")")
|
|
let parameters = strpart(a:input, pstart, pend - pstart)
|
|
let parameters_end = len(parameters) - 1
|
|
|
|
let depth = 0
|
|
let tsep = -1
|
|
let result = {'params': [], 'reval': '' }
|
|
|
|
" Parameters
|
|
let idx = 0
|
|
for s:char in split(parameters, '\zs')
|
|
if index(s:nesting_chars, s:char) >= 0
|
|
let depth += 1
|
|
elseif index(s:unnesting_chars, s:char) >= 0
|
|
let depth -= 1
|
|
endif
|
|
|
|
if depth == 0
|
|
if s:char == ':'
|
|
let tsep = idx
|
|
elseif s:char == ',' || s:char == ';'
|
|
call add(result.params, substitute(strpart(parameters, tsep + 1, idx - tsep - 1), s:strip_regex, '\1', ''))
|
|
let tsep = -1
|
|
endif
|
|
endif
|
|
|
|
let idx += 1
|
|
endfor
|
|
|
|
if tsep != -1
|
|
call add(result.params, substitute(strpart(parameters, tsep + 1, parameters_end + 1), s:strip_regex, '\1', ''))
|
|
endif
|
|
|
|
" Return value
|
|
let rstart = stridx(a:input, ":", pend + 1)
|
|
let rend = stridx(a:input, "{\.", pend + 1)
|
|
if rstart != -1 && rstart < rend
|
|
let reval = strpart(a:input, rstart + 1)
|
|
if rend != -1
|
|
let reval = strpart(reval, 0, rend - rstart - 1)
|
|
endif
|
|
let result.reval = substitute(reval, s:strip_regex, '\1', '')
|
|
endif
|
|
|
|
return result
|
|
endfunction
|
|
|
|
function! util#SignatureStr(input)
|
|
let tinfo = util#ParseSignature(a:input)
|
|
return join(tinfo.params, " -> ") . (tinfo.reval != "" ? (" => " . tinfo.reval) : "")
|
|
endfunction
|
|
|
|
function! util#djb(str)
|
|
let hash = 0
|
|
for s:char in split(a:str, '\zs')
|
|
let hash = (hash * 11) + char2nr(s:char)
|
|
endfor
|
|
return float2nr(hash)
|
|
endfunction
|
|
|
|
function! util#open_module_doc(module, symbol)
|
|
call system("$BROWSER " . "http://nim-lang.org/docs/" . a:module . ".html#" . a:symbol)
|
|
endfunction
|
|
|
|
function! util#SelectNimProc(inner)
|
|
let curline = nextnonblank(line("."))
|
|
if curline == 0
|
|
let curline = prevnonblank(line("."))
|
|
endif
|
|
|
|
let curindent = indent(curline)
|
|
let lastline = line("$")
|
|
let sl = curline
|
|
|
|
function! s:IsProcStart(l)
|
|
return getline(a:l) =~ "\s*\\(proc\\|template\\|macro\\|func\\|method\\)\\s\\+\\w\\+("
|
|
endfunction
|
|
|
|
while sl > 0
|
|
if s:IsProcStart(sl) && (curindent == -1 || curline == sl || indent(sl) < curindent)
|
|
break
|
|
endif
|
|
let sl -= 1
|
|
endwhile
|
|
|
|
if !s:IsProcStart(sl)
|
|
return
|
|
endif
|
|
|
|
call cursor(sl, 0)
|
|
normal! 0V
|
|
let el = sl + 1
|
|
|
|
while el < line("$") - 1 && (getline(el) =~ "^\\s*$" || indent(el) > indent(sl))
|
|
let el += 1
|
|
endwhile
|
|
|
|
let el -= 1
|
|
if a:inner
|
|
while getline(el) =~ "^\\s*$"
|
|
let el -= 1
|
|
endwhile
|
|
endif
|
|
|
|
call cursor(el, 0)
|
|
normal! $
|
|
if a:inner
|
|
normal! h
|
|
endif
|
|
endfunction
|
|
|
|
|
|
function! util#goto_file()
|
|
let module_loc = modules#moduleLocation(expand("<cword>"))
|
|
endfunction
|
|
|
|
|
|
try
|
|
call operator#user#define('nimrepl_send', 'NimReplSend')
|
|
function! NimReplSend(motion_wiseness)
|
|
let start = getpos("'[")
|
|
let stop = getpos("']")
|
|
let start_line = start[1]
|
|
let stop_line = stop[1]
|
|
let str = join(getline(start_line, stop_line), "\n")
|
|
echom str
|
|
call features#repl#send(str)
|
|
endfunction
|
|
catch
|
|
endtry
|
|
|
|
|
|
let &cpo = s:save_cpo
|
|
unlet s:save_cpo
|