mirror of
https://github.com/neovim/neovim.git
synced 2025-09-05 19:08:15 +00:00
feat(runtime): revert cfilter, ccomplete to legacy Vim
Problem: Transpiled Lua code from vim9script is not amenable to static analysis, requiring manual cleanup or ignoring parts of our codebase. Solution: Revert to pre-rewrite version of (low-impact) legacy plugins and remove the vim9jit shim.
This commit is contained in:
Christian Clason
committed by
Christian Clason
Christian Clason
parent
65170e8dad
commit
8c81ed8678
@@ -10,7 +10,6 @@
|
|||||||
],
|
],
|
||||||
"ignoreDir": [
|
"ignoreDir": [
|
||||||
"test",
|
"test",
|
||||||
"_vim9script.lua"
|
|
||||||
],
|
],
|
||||||
"checkThirdParty": "Disable"
|
"checkThirdParty": "Disable"
|
||||||
},
|
},
|
||||||
|
|||||||
@@ -1,859 +0,0 @@
|
|||||||
----------------------------------------
|
|
||||||
-- This file is generated via github.com/tjdevries/vim9jit
|
|
||||||
-- For any bugs, please first consider reporting there.
|
|
||||||
----------------------------------------
|
|
||||||
|
|
||||||
-- Ignore "value assigned to a local variable is unused" because
|
|
||||||
-- we can't guarantee that local variables will be used by plugins
|
|
||||||
-- luacheck: ignore
|
|
||||||
--- @diagnostic disable
|
|
||||||
|
|
||||||
local vim9 = require('_vim9script')
|
|
||||||
local M = {}
|
|
||||||
local prepended = nil
|
|
||||||
local grepCache = nil
|
|
||||||
local Complete = nil
|
|
||||||
local GetAddition = nil
|
|
||||||
local Tag2item = nil
|
|
||||||
local Dict2info = nil
|
|
||||||
local ParseTagline = nil
|
|
||||||
local Tagline2item = nil
|
|
||||||
local Tagcmd2extra = nil
|
|
||||||
local Nextitem = nil
|
|
||||||
local StructMembers = nil
|
|
||||||
local SearchMembers = nil
|
|
||||||
-- vim9script
|
|
||||||
|
|
||||||
-- # Vim completion script
|
|
||||||
-- # Language: C
|
|
||||||
-- # Maintainer: The Vim Project <https://github.com/vim/vim>
|
|
||||||
-- # Last Change: 2023 Aug 10
|
|
||||||
-- # Rewritten in Vim9 script by github user lacygoill
|
|
||||||
-- # Former Maintainer: Bram Moolenaar <Bram@vim.org>
|
|
||||||
|
|
||||||
prepended = ''
|
|
||||||
grepCache = vim.empty_dict()
|
|
||||||
|
|
||||||
-- # This function is used for the 'omnifunc' option.
|
|
||||||
|
|
||||||
Complete = function(findstart, abase)
|
|
||||||
findstart = vim9.bool(findstart)
|
|
||||||
if vim9.bool(findstart) then
|
|
||||||
-- # Locate the start of the item, including ".", "->" and "[...]".
|
|
||||||
local line = vim9.fn.getline('.')
|
|
||||||
local start = vim9.fn.charcol('.') - 1
|
|
||||||
local lastword = -1
|
|
||||||
while start > 0 do
|
|
||||||
if vim9.ops.RegexpMatches(vim9.index(line, vim9.ops.Minus(start, 1)), '\\w') then
|
|
||||||
start = start - 1
|
|
||||||
elseif
|
|
||||||
vim9.bool(vim9.ops.RegexpMatches(vim9.index(line, vim9.ops.Minus(start, 1)), '\\.'))
|
|
||||||
then
|
|
||||||
if lastword == -1 then
|
|
||||||
lastword = start
|
|
||||||
end
|
|
||||||
start = start - 1
|
|
||||||
elseif
|
|
||||||
vim9.bool(
|
|
||||||
start > 1
|
|
||||||
and vim9.index(line, vim9.ops.Minus(start, 2)) == '-'
|
|
||||||
and vim9.index(line, vim9.ops.Minus(start, 1)) == '>'
|
|
||||||
)
|
|
||||||
then
|
|
||||||
if lastword == -1 then
|
|
||||||
lastword = start
|
|
||||||
end
|
|
||||||
start = vim9.ops.Minus(start, 2)
|
|
||||||
elseif vim9.bool(vim9.index(line, vim9.ops.Minus(start, 1)) == ']') then
|
|
||||||
-- # Skip over [...].
|
|
||||||
local n = 0
|
|
||||||
start = start - 1
|
|
||||||
while start > 0 do
|
|
||||||
start = start - 1
|
|
||||||
if vim9.index(line, start) == '[' then
|
|
||||||
if n == 0 then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
n = n - 1
|
|
||||||
elseif vim9.bool(vim9.index(line, start) == ']') then
|
|
||||||
n = n + 1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
else
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Return the column of the last word, which is going to be changed.
|
|
||||||
-- # Remember the text that comes before it in prepended.
|
|
||||||
if lastword == -1 then
|
|
||||||
prepended = ''
|
|
||||||
return vim9.fn.byteidx(line, start)
|
|
||||||
end
|
|
||||||
prepended = vim9.slice(line, start, vim9.ops.Minus(lastword, 1))
|
|
||||||
return vim9.fn.byteidx(line, lastword)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Return list of matches.
|
|
||||||
|
|
||||||
local base = prepended .. abase
|
|
||||||
|
|
||||||
-- # Don't do anything for an empty base, would result in all the tags in the
|
|
||||||
-- # tags file.
|
|
||||||
if base == '' then
|
|
||||||
return {}
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # init cache for vimgrep to empty
|
|
||||||
grepCache = {}
|
|
||||||
|
|
||||||
-- # Split item in words, keep empty word after "." or "->".
|
|
||||||
-- # "aa" -> ['aa'], "aa." -> ['aa', ''], "aa.bb" -> ['aa', 'bb'], etc.
|
|
||||||
-- # We can't use split, because we need to skip nested [...].
|
|
||||||
-- # "aa[...]" -> ['aa', '[...]'], "aa.bb[...]" -> ['aa', 'bb', '[...]'], etc.
|
|
||||||
local items = {}
|
|
||||||
local s = 0
|
|
||||||
local arrays = 0
|
|
||||||
while 1 do
|
|
||||||
local e = vim9.fn.charidx(base, vim9.fn.match(base, '\\.\\|->\\|\\[', s))
|
|
||||||
if e < 0 then
|
|
||||||
if s == 0 or vim9.index(base, vim9.ops.Minus(s, 1)) ~= ']' then
|
|
||||||
vim9.fn.add(items, vim9.slice(base, s, nil))
|
|
||||||
end
|
|
||||||
break
|
|
||||||
end
|
|
||||||
if s == 0 or vim9.index(base, vim9.ops.Minus(s, 1)) ~= ']' then
|
|
||||||
vim9.fn.add(items, vim9.slice(base, s, vim9.ops.Minus(e, 1)))
|
|
||||||
end
|
|
||||||
if vim9.index(base, e) == '.' then
|
|
||||||
-- # skip over '.'
|
|
||||||
s = vim9.ops.Plus(e, 1)
|
|
||||||
elseif vim9.bool(vim9.index(base, e) == '-') then
|
|
||||||
-- # skip over '->'
|
|
||||||
s = vim9.ops.Plus(e, 2)
|
|
||||||
else
|
|
||||||
-- # Skip over [...].
|
|
||||||
local n = 0
|
|
||||||
s = e
|
|
||||||
e = e + 1
|
|
||||||
while e < vim9.fn.strcharlen(base) do
|
|
||||||
if vim9.index(base, e) == ']' then
|
|
||||||
if n == 0 then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
n = n - 1
|
|
||||||
elseif vim9.bool(vim9.index(base, e) == '[') then
|
|
||||||
n = n + 1
|
|
||||||
end
|
|
||||||
e = e + 1
|
|
||||||
end
|
|
||||||
e = e + 1
|
|
||||||
vim9.fn.add(items, vim9.slice(base, s, vim9.ops.Minus(e, 1)))
|
|
||||||
arrays = arrays + 1
|
|
||||||
s = e
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Find the variable items[0].
|
|
||||||
-- # 1. in current function (like with "gd")
|
|
||||||
-- # 2. in tags file(s) (like with ":tag")
|
|
||||||
-- # 3. in current file (like with "gD")
|
|
||||||
local res = {}
|
|
||||||
if vim9.fn.searchdecl(vim9.index(items, 0), false, true) == 0 then
|
|
||||||
-- # Found, now figure out the type.
|
|
||||||
-- # TODO: join previous line if it makes sense
|
|
||||||
local line = vim9.fn.getline('.')
|
|
||||||
local col = vim9.fn.charcol('.')
|
|
||||||
if vim9.fn.stridx(vim9.slice(line, nil, vim9.ops.Minus(col, 1)), ';') >= 0 then
|
|
||||||
-- # Handle multiple declarations on the same line.
|
|
||||||
local col2 = vim9.ops.Minus(col, 1)
|
|
||||||
while vim9.index(line, col2) ~= ';' do
|
|
||||||
col2 = col2 - 1
|
|
||||||
end
|
|
||||||
line = vim9.slice(line, vim9.ops.Plus(col2, 1), nil)
|
|
||||||
col = vim9.ops.Minus(col, col2)
|
|
||||||
end
|
|
||||||
if vim9.fn.stridx(vim9.slice(line, nil, vim9.ops.Minus(col, 1)), ',') >= 0 then
|
|
||||||
-- # Handle multiple declarations on the same line in a function
|
|
||||||
-- # declaration.
|
|
||||||
local col2 = vim9.ops.Minus(col, 1)
|
|
||||||
while vim9.index(line, col2) ~= ',' do
|
|
||||||
col2 = col2 - 1
|
|
||||||
end
|
|
||||||
if
|
|
||||||
vim9.ops.RegexpMatches(
|
|
||||||
vim9.slice(line, vim9.ops.Plus(col2, 1), vim9.ops.Minus(col, 1)),
|
|
||||||
' *[^ ][^ ]* *[^ ]'
|
|
||||||
)
|
|
||||||
then
|
|
||||||
line = vim9.slice(line, vim9.ops.Plus(col2, 1), nil)
|
|
||||||
col = vim9.ops.Minus(col, col2)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if vim9.fn.len(items) == 1 then
|
|
||||||
-- # Completing one word and it's a local variable: May add '[', '.' or
|
|
||||||
-- # '->'.
|
|
||||||
local match = vim9.index(items, 0)
|
|
||||||
local kind = 'v'
|
|
||||||
if vim9.fn.match(line, '\\<' .. match .. '\\s*\\[') > 0 then
|
|
||||||
match = match .. '['
|
|
||||||
else
|
|
||||||
res = Nextitem(vim9.slice(line, nil, vim9.ops.Minus(col, 1)), { '' }, 0, true)
|
|
||||||
if vim9.fn.len(res) > 0 then
|
|
||||||
-- # There are members, thus add "." or "->".
|
|
||||||
if vim9.fn.match(line, '\\*[ \\t(]*' .. match .. '\\>') > 0 then
|
|
||||||
match = match .. '->'
|
|
||||||
else
|
|
||||||
match = match .. '.'
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
res = { { ['match'] = match, ['tagline'] = '', ['kind'] = kind, ['info'] = line } }
|
|
||||||
elseif vim9.bool(vim9.fn.len(items) == vim9.ops.Plus(arrays, 1)) then
|
|
||||||
-- # Completing one word and it's a local array variable: build tagline
|
|
||||||
-- # from declaration line
|
|
||||||
local match = vim9.index(items, 0)
|
|
||||||
local kind = 'v'
|
|
||||||
local tagline = '\t/^' .. line .. '$/'
|
|
||||||
res = { { ['match'] = match, ['tagline'] = tagline, ['kind'] = kind, ['info'] = line } }
|
|
||||||
else
|
|
||||||
-- # Completing "var.", "var.something", etc.
|
|
||||||
res =
|
|
||||||
Nextitem(vim9.slice(line, nil, vim9.ops.Minus(col, 1)), vim9.slice(items, 1, nil), 0, true)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.fn.len(items) == 1 or vim9.fn.len(items) == vim9.ops.Plus(arrays, 1) then
|
|
||||||
-- # Only one part, no "." or "->": complete from tags file.
|
|
||||||
local tags = {}
|
|
||||||
if vim9.fn.len(items) == 1 then
|
|
||||||
tags = vim9.fn.taglist('^' .. base)
|
|
||||||
else
|
|
||||||
tags = vim9.fn.taglist('^' .. vim9.index(items, 0) .. '$')
|
|
||||||
end
|
|
||||||
|
|
||||||
vim9.fn_mut('filter', {
|
|
||||||
vim9.fn_mut('filter', {
|
|
||||||
tags,
|
|
||||||
function(_, v)
|
|
||||||
return vim9.ternary(vim9.fn.has_key(v, 'kind'), function()
|
|
||||||
return v.kind ~= 'm'
|
|
||||||
end, true)
|
|
||||||
end,
|
|
||||||
}, { replace = 0 }),
|
|
||||||
function(_, v)
|
|
||||||
return vim9.ops.Or(
|
|
||||||
vim9.ops.Or(
|
|
||||||
vim9.prefix['Bang'](vim9.fn.has_key(v, 'static')),
|
|
||||||
vim9.prefix['Bang'](vim9.index(v, 'static'))
|
|
||||||
),
|
|
||||||
vim9.fn.bufnr('%') == vim9.fn.bufnr(vim9.index(v, 'filename'))
|
|
||||||
)
|
|
||||||
end,
|
|
||||||
}, { replace = 0 })
|
|
||||||
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
vim9.fn.map(tags, function(_, v)
|
|
||||||
return Tag2item(v)
|
|
||||||
end)
|
|
||||||
)
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.fn.len(res) == 0 then
|
|
||||||
-- # Find the variable in the tags file(s)
|
|
||||||
local diclist = vim9.fn.filter(
|
|
||||||
vim9.fn.taglist('^' .. vim9.index(items, 0) .. '$'),
|
|
||||||
function(_, v)
|
|
||||||
return vim9.ternary(vim9.fn.has_key(v, 'kind'), function()
|
|
||||||
return v.kind ~= 'm'
|
|
||||||
end, true)
|
|
||||||
end
|
|
||||||
)
|
|
||||||
|
|
||||||
res = {}
|
|
||||||
|
|
||||||
for _, i in vim9.iter(vim9.fn.range(vim9.fn.len(diclist))) do
|
|
||||||
-- # New ctags has the "typeref" field. Patched version has "typename".
|
|
||||||
if vim9.bool(vim9.fn.has_key(vim9.index(diclist, i), 'typename')) then
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
StructMembers(
|
|
||||||
vim9.index(vim9.index(diclist, i), 'typename'),
|
|
||||||
vim9.slice(items, 1, nil),
|
|
||||||
true
|
|
||||||
)
|
|
||||||
)
|
|
||||||
elseif vim9.bool(vim9.fn.has_key(vim9.index(diclist, i), 'typeref')) then
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
StructMembers(
|
|
||||||
vim9.index(vim9.index(diclist, i), 'typeref'),
|
|
||||||
vim9.slice(items, 1, nil),
|
|
||||||
true
|
|
||||||
)
|
|
||||||
)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # For a variable use the command, which must be a search pattern that
|
|
||||||
-- # shows the declaration of the variable.
|
|
||||||
if vim9.index(vim9.index(diclist, i), 'kind') == 'v' then
|
|
||||||
local line = vim9.index(vim9.index(diclist, i), 'cmd')
|
|
||||||
if vim9.slice(line, nil, 1) == '/^' then
|
|
||||||
local col =
|
|
||||||
vim9.fn.charidx(line, vim9.fn.match(line, '\\<' .. vim9.index(items, 0) .. '\\>'))
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
Nextitem(
|
|
||||||
vim9.slice(line, 2, vim9.ops.Minus(col, 1)),
|
|
||||||
vim9.slice(items, 1, nil),
|
|
||||||
0,
|
|
||||||
true
|
|
||||||
)
|
|
||||||
)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.fn.len(res) == 0 and vim9.fn.searchdecl(vim9.index(items, 0), true) == 0 then
|
|
||||||
-- # Found, now figure out the type.
|
|
||||||
-- # TODO: join previous line if it makes sense
|
|
||||||
local line = vim9.fn.getline('.')
|
|
||||||
local col = vim9.fn.charcol('.')
|
|
||||||
res =
|
|
||||||
Nextitem(vim9.slice(line, nil, vim9.ops.Minus(col, 1)), vim9.slice(items, 1, nil), 0, true)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # If the last item(s) are [...] they need to be added to the matches.
|
|
||||||
local last = vim9.fn.len(items) - 1
|
|
||||||
local brackets = ''
|
|
||||||
while last >= 0 do
|
|
||||||
if vim9.index(vim9.index(items, last), 0) ~= '[' then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
brackets = vim9.index(items, last) .. brackets
|
|
||||||
last = last - 1
|
|
||||||
end
|
|
||||||
|
|
||||||
return vim9.fn.map(res, function(_, v)
|
|
||||||
return Tagline2item(v, brackets)
|
|
||||||
end)
|
|
||||||
end
|
|
||||||
M['Complete'] = Complete
|
|
||||||
|
|
||||||
GetAddition = function(line, match, memarg, bracket)
|
|
||||||
bracket = vim9.bool(bracket)
|
|
||||||
-- # Guess if the item is an array.
|
|
||||||
if vim9.bool(vim9.ops.And(bracket, vim9.fn.match(line, match .. '\\s*\\[') > 0)) then
|
|
||||||
return '['
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Check if the item has members.
|
|
||||||
if vim9.fn.len(SearchMembers(memarg, { '' }, false)) > 0 then
|
|
||||||
-- # If there is a '*' before the name use "->".
|
|
||||||
if vim9.fn.match(line, '\\*[ \\t(]*' .. match .. '\\>') > 0 then
|
|
||||||
return '->'
|
|
||||||
else
|
|
||||||
return '.'
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return ''
|
|
||||||
end
|
|
||||||
|
|
||||||
Tag2item = function(val)
|
|
||||||
-- # Turn the tag info "val" into an item for completion.
|
|
||||||
-- # "val" is is an item in the list returned by taglist().
|
|
||||||
-- # If it is a variable we may add "." or "->". Don't do it for other types,
|
|
||||||
-- # such as a typedef, by not including the info that GetAddition() uses.
|
|
||||||
local res = vim9.convert.decl_dict({ ['match'] = vim9.index(val, 'name') })
|
|
||||||
|
|
||||||
res[vim9.index_expr('extra')] =
|
|
||||||
Tagcmd2extra(vim9.index(val, 'cmd'), vim9.index(val, 'name'), vim9.index(val, 'filename'))
|
|
||||||
|
|
||||||
local s = Dict2info(val)
|
|
||||||
if s ~= '' then
|
|
||||||
res[vim9.index_expr('info')] = s
|
|
||||||
end
|
|
||||||
|
|
||||||
res[vim9.index_expr('tagline')] = ''
|
|
||||||
if vim9.bool(vim9.fn.has_key(val, 'kind')) then
|
|
||||||
local kind = vim9.index(val, 'kind')
|
|
||||||
res[vim9.index_expr('kind')] = kind
|
|
||||||
if kind == 'v' then
|
|
||||||
res[vim9.index_expr('tagline')] = '\t' .. vim9.index(val, 'cmd')
|
|
||||||
res[vim9.index_expr('dict')] = val
|
|
||||||
elseif vim9.bool(kind == 'f') then
|
|
||||||
res[vim9.index_expr('match')] = vim9.index(val, 'name') .. '('
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
Dict2info = function(dict)
|
|
||||||
-- # Use all the items in dictionary for the "info" entry.
|
|
||||||
local info = ''
|
|
||||||
|
|
||||||
for _, k in vim9.iter(vim9.fn_mut('sort', { vim9.fn.keys(dict) }, { replace = 0 })) do
|
|
||||||
info = info .. k .. vim9.fn['repeat'](' ', 10 - vim9.fn.strlen(k))
|
|
||||||
if k == 'cmd' then
|
|
||||||
info = info
|
|
||||||
.. vim9.fn.substitute(
|
|
||||||
vim9.fn.matchstr(vim9.index(dict, 'cmd'), '/^\\s*\\zs.*\\ze$/'),
|
|
||||||
'\\\\\\(.\\)',
|
|
||||||
'\\1',
|
|
||||||
'g'
|
|
||||||
)
|
|
||||||
else
|
|
||||||
local dictk = vim9.index(dict, k)
|
|
||||||
if vim9.fn.typename(dictk) ~= 'string' then
|
|
||||||
info = info .. vim9.fn.string(dictk)
|
|
||||||
else
|
|
||||||
info = info .. dictk
|
|
||||||
end
|
|
||||||
end
|
|
||||||
info = info .. '\n'
|
|
||||||
end
|
|
||||||
|
|
||||||
return info
|
|
||||||
end
|
|
||||||
|
|
||||||
ParseTagline = function(line)
|
|
||||||
-- # Parse a tag line and return a dictionary with items like taglist()
|
|
||||||
local l = vim9.fn.split(line, '\t')
|
|
||||||
local d = vim.empty_dict()
|
|
||||||
if vim9.fn.len(l) >= 3 then
|
|
||||||
d[vim9.index_expr('name')] = vim9.index(l, 0)
|
|
||||||
d[vim9.index_expr('filename')] = vim9.index(l, 1)
|
|
||||||
d[vim9.index_expr('cmd')] = vim9.index(l, 2)
|
|
||||||
local n = 2
|
|
||||||
if vim9.ops.RegexpMatches(vim9.index(l, 2), '^/') then
|
|
||||||
-- # Find end of cmd, it may contain Tabs.
|
|
||||||
while n < vim9.fn.len(l) and vim9.ops.NotRegexpMatches(vim9.index(l, n), '/;"$') do
|
|
||||||
n = n + 1
|
|
||||||
d[vim9.index_expr('cmd')] = vim9.index(d, 'cmd') .. ' ' .. vim9.index(l, n)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for _, i in vim9.iter(vim9.fn.range(vim9.ops.Plus(n, 1), vim9.fn.len(l) - 1)) do
|
|
||||||
if vim9.index(l, i) == 'file:' then
|
|
||||||
d[vim9.index_expr('static')] = 1
|
|
||||||
elseif vim9.bool(vim9.ops.NotRegexpMatches(vim9.index(l, i), ':')) then
|
|
||||||
d[vim9.index_expr('kind')] = vim9.index(l, i)
|
|
||||||
else
|
|
||||||
d[vim9.index_expr(vim9.fn.matchstr(vim9.index(l, i), '[^:]*'))] =
|
|
||||||
vim9.fn.matchstr(vim9.index(l, i), ':\\zs.*')
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return d
|
|
||||||
end
|
|
||||||
|
|
||||||
Tagline2item = function(val, brackets)
|
|
||||||
-- # Turn a match item "val" into an item for completion.
|
|
||||||
-- # "val['match']" is the matching item.
|
|
||||||
-- # "val['tagline']" is the tagline in which the last part was found.
|
|
||||||
local line = vim9.index(val, 'tagline')
|
|
||||||
local add = GetAddition(line, vim9.index(val, 'match'), { val }, brackets == '')
|
|
||||||
local res = vim9.convert.decl_dict({ ['word'] = vim9.index(val, 'match') .. brackets .. add })
|
|
||||||
|
|
||||||
if vim9.bool(vim9.fn.has_key(val, 'info')) then
|
|
||||||
-- # Use info from Tag2item().
|
|
||||||
res[vim9.index_expr('info')] = vim9.index(val, 'info')
|
|
||||||
else
|
|
||||||
-- # Parse the tag line and add each part to the "info" entry.
|
|
||||||
local s = Dict2info(ParseTagline(line))
|
|
||||||
if s ~= '' then
|
|
||||||
res[vim9.index_expr('info')] = s
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.bool(vim9.fn.has_key(val, 'kind')) then
|
|
||||||
res[vim9.index_expr('kind')] = vim9.index(val, 'kind')
|
|
||||||
elseif vim9.bool(add == '(') then
|
|
||||||
res[vim9.index_expr('kind')] = 'f'
|
|
||||||
else
|
|
||||||
local s = vim9.fn.matchstr(line, '\\t\\(kind:\\)\\=\\zs\\S\\ze\\(\\t\\|$\\)')
|
|
||||||
if s ~= '' then
|
|
||||||
res[vim9.index_expr('kind')] = s
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.bool(vim9.fn.has_key(val, 'extra')) then
|
|
||||||
res[vim9.index_expr('menu')] = vim9.index(val, 'extra')
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Isolate the command after the tag and filename.
|
|
||||||
local s = vim9.fn.matchstr(
|
|
||||||
line,
|
|
||||||
'[^\\t]*\\t[^\\t]*\\t\\zs\\(/^.*$/\\|[^\\t]*\\)\\ze\\(;"\\t\\|\\t\\|$\\)'
|
|
||||||
)
|
|
||||||
if s ~= '' then
|
|
||||||
res[vim9.index_expr('menu')] = Tagcmd2extra(
|
|
||||||
s,
|
|
||||||
vim9.index(val, 'match'),
|
|
||||||
vim9.fn.matchstr(line, '[^\\t]*\\t\\zs[^\\t]*\\ze\\t')
|
|
||||||
)
|
|
||||||
end
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
Tagcmd2extra = function(cmd, name, fname)
|
|
||||||
-- # Turn a command from a tag line to something that is useful in the menu
|
|
||||||
local x = ''
|
|
||||||
if vim9.ops.RegexpMatches(cmd, '^/^') then
|
|
||||||
-- # The command is a search command, useful to see what it is.
|
|
||||||
x = vim9.fn.substitute(
|
|
||||||
vim9.fn.substitute(
|
|
||||||
vim9.fn.matchstr(cmd, '^/^\\s*\\zs.*\\ze$/'),
|
|
||||||
'\\<' .. name .. '\\>',
|
|
||||||
'@@',
|
|
||||||
''
|
|
||||||
),
|
|
||||||
'\\\\\\(.\\)',
|
|
||||||
'\\1',
|
|
||||||
'g'
|
|
||||||
) .. ' - ' .. fname
|
|
||||||
elseif vim9.bool(vim9.ops.RegexpMatches(cmd, '^\\d*$')) then
|
|
||||||
-- # The command is a line number, the file name is more useful.
|
|
||||||
x = fname .. ' - ' .. cmd
|
|
||||||
else
|
|
||||||
-- # Not recognized, use command and file name.
|
|
||||||
x = cmd .. ' - ' .. fname
|
|
||||||
end
|
|
||||||
return x
|
|
||||||
end
|
|
||||||
|
|
||||||
Nextitem = function(lead, items, depth, all)
|
|
||||||
all = vim9.bool(all)
|
|
||||||
-- # Find composing type in "lead" and match items[0] with it.
|
|
||||||
-- # Repeat this recursively for items[1], if it's there.
|
|
||||||
-- # When resolving typedefs "depth" is used to avoid infinite recursion.
|
|
||||||
-- # Return the list of matches.
|
|
||||||
|
|
||||||
-- # Use the text up to the variable name and split it in tokens.
|
|
||||||
local tokens = vim9.fn.split(lead, '\\s\\+\\|\\<')
|
|
||||||
|
|
||||||
-- # Try to recognize the type of the variable. This is rough guessing...
|
|
||||||
local res = {}
|
|
||||||
|
|
||||||
local body = function(_, tidx)
|
|
||||||
-- # Skip tokens starting with a non-ID character.
|
|
||||||
if vim9.ops.NotRegexpMatches(vim9.index(tokens, tidx), '^\\h') then
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Recognize "struct foobar" and "union foobar".
|
|
||||||
-- # Also do "class foobar" when it's C++ after all (doesn't work very well
|
|
||||||
-- # though).
|
|
||||||
if
|
|
||||||
(
|
|
||||||
vim9.index(tokens, tidx) == 'struct'
|
|
||||||
or vim9.index(tokens, tidx) == 'union'
|
|
||||||
or vim9.index(tokens, tidx) == 'class'
|
|
||||||
) and vim9.ops.Plus(tidx, 1) < vim9.fn.len(tokens)
|
|
||||||
then
|
|
||||||
res = StructMembers(
|
|
||||||
vim9.index(tokens, tidx) .. ':' .. vim9.index(tokens, vim9.ops.Plus(tidx, 1)),
|
|
||||||
items,
|
|
||||||
all
|
|
||||||
)
|
|
||||||
return vim9.ITER_BREAK
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # TODO: add more reserved words
|
|
||||||
if
|
|
||||||
vim9.fn.index(
|
|
||||||
{ 'int', 'short', 'char', 'float', 'double', 'static', 'unsigned', 'extern' },
|
|
||||||
vim9.index(tokens, tidx)
|
|
||||||
) >= 0
|
|
||||||
then
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Use the tags file to find out if this is a typedef.
|
|
||||||
local diclist = vim9.fn.taglist('^' .. vim9.index(tokens, tidx) .. '$')
|
|
||||||
|
|
||||||
local body = function(_, tagidx)
|
|
||||||
local item = vim9.convert.decl_dict(vim9.index(diclist, tagidx))
|
|
||||||
|
|
||||||
-- # New ctags has the "typeref" field. Patched version has "typename".
|
|
||||||
if vim9.bool(vim9.fn.has_key(item, 'typeref')) then
|
|
||||||
res = vim9.fn.extend(res, StructMembers(vim9.index(item, 'typeref'), items, all))
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
if vim9.bool(vim9.fn.has_key(item, 'typename')) then
|
|
||||||
res = vim9.fn.extend(res, StructMembers(vim9.index(item, 'typename'), items, all))
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Only handle typedefs here.
|
|
||||||
if vim9.index(item, 'kind') ~= 't' then
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Skip matches local to another file.
|
|
||||||
if
|
|
||||||
vim9.bool(
|
|
||||||
vim9.ops.And(
|
|
||||||
vim9.ops.And(vim9.fn.has_key(item, 'static'), vim9.index(item, 'static')),
|
|
||||||
vim9.fn.bufnr('%') ~= vim9.fn.bufnr(vim9.index(item, 'filename'))
|
|
||||||
)
|
|
||||||
)
|
|
||||||
then
|
|
||||||
return vim9.ITER_CONTINUE
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # For old ctags we recognize "typedef struct aaa" and
|
|
||||||
-- # "typedef union bbb" in the tags file command.
|
|
||||||
local cmd = vim9.index(item, 'cmd')
|
|
||||||
local ei = vim9.fn.charidx(cmd, vim9.fn.matchend(cmd, 'typedef\\s\\+'))
|
|
||||||
if ei > 1 then
|
|
||||||
local cmdtokens = vim9.fn.split(vim9.slice(cmd, ei, nil), '\\s\\+\\|\\<')
|
|
||||||
if vim9.fn.len(cmdtokens) > 1 then
|
|
||||||
if
|
|
||||||
vim9.index(cmdtokens, 0) == 'struct'
|
|
||||||
or vim9.index(cmdtokens, 0) == 'union'
|
|
||||||
or vim9.index(cmdtokens, 0) == 'class'
|
|
||||||
then
|
|
||||||
local name = ''
|
|
||||||
-- # Use the first identifier after the "struct" or "union"
|
|
||||||
|
|
||||||
for _, ti in vim9.iter(vim9.fn.range((vim9.fn.len(cmdtokens) - 1))) do
|
|
||||||
if vim9.ops.RegexpMatches(vim9.index(cmdtokens, ti), '^\\w') then
|
|
||||||
name = vim9.index(cmdtokens, ti)
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if name ~= '' then
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
StructMembers(vim9.index(cmdtokens, 0) .. ':' .. name, items, all)
|
|
||||||
)
|
|
||||||
end
|
|
||||||
elseif vim9.bool(depth < 10) then
|
|
||||||
-- # Could be "typedef other_T some_T".
|
|
||||||
res = vim9.fn.extend(
|
|
||||||
res,
|
|
||||||
Nextitem(vim9.index(cmdtokens, 0), items, vim9.ops.Plus(depth, 1), all)
|
|
||||||
)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return vim9.ITER_DEFAULT
|
|
||||||
end
|
|
||||||
|
|
||||||
for _, tagidx in vim9.iter(vim9.fn.range(vim9.fn.len(diclist))) do
|
|
||||||
local nvim9_status, nvim9_ret = body(_, tagidx)
|
|
||||||
if nvim9_status == vim9.ITER_BREAK then
|
|
||||||
break
|
|
||||||
elseif nvim9_status == vim9.ITER_RETURN then
|
|
||||||
return nvim9_ret
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.fn.len(res) > 0 then
|
|
||||||
return vim9.ITER_BREAK
|
|
||||||
end
|
|
||||||
|
|
||||||
return vim9.ITER_DEFAULT
|
|
||||||
end
|
|
||||||
|
|
||||||
for _, tidx in vim9.iter(vim9.fn.range(vim9.fn.len(tokens))) do
|
|
||||||
local nvim9_status, nvim9_ret = body(_, tidx)
|
|
||||||
if nvim9_status == vim9.ITER_BREAK then
|
|
||||||
break
|
|
||||||
elseif nvim9_status == vim9.ITER_RETURN then
|
|
||||||
return nvim9_ret
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
StructMembers = function(atypename, items, all)
|
|
||||||
all = vim9.bool(all)
|
|
||||||
|
|
||||||
-- # Search for members of structure "typename" in tags files.
|
|
||||||
-- # Return a list with resulting matches.
|
|
||||||
-- # Each match is a dictionary with "match" and "tagline" entries.
|
|
||||||
-- # When "all" is true find all, otherwise just return 1 if there is any member.
|
|
||||||
|
|
||||||
-- # Todo: What about local structures?
|
|
||||||
local fnames = vim9.fn.join(vim9.fn.map(vim9.fn.tagfiles(), function(_, v)
|
|
||||||
return vim9.fn.escape(v, ' \\#%')
|
|
||||||
end))
|
|
||||||
if fnames == '' then
|
|
||||||
return {}
|
|
||||||
end
|
|
||||||
|
|
||||||
local typename = atypename
|
|
||||||
local qflist = {}
|
|
||||||
local cached = 0
|
|
||||||
local n = ''
|
|
||||||
if vim9.bool(vim9.prefix['Bang'](all)) then
|
|
||||||
n = '1'
|
|
||||||
if vim9.bool(vim9.fn.has_key(grepCache, typename)) then
|
|
||||||
qflist = vim9.index(grepCache, typename)
|
|
||||||
cached = 1
|
|
||||||
end
|
|
||||||
else
|
|
||||||
n = ''
|
|
||||||
end
|
|
||||||
if vim9.bool(vim9.prefix['Bang'](cached)) then
|
|
||||||
while 1 do
|
|
||||||
vim.api.nvim_command(
|
|
||||||
'silent! keepjumps noautocmd '
|
|
||||||
.. n
|
|
||||||
.. 'vimgrep '
|
|
||||||
.. '/\\t'
|
|
||||||
.. typename
|
|
||||||
.. '\\(\\t\\|$\\)/j '
|
|
||||||
.. fnames
|
|
||||||
)
|
|
||||||
|
|
||||||
qflist = vim9.fn.getqflist()
|
|
||||||
if vim9.fn.len(qflist) > 0 or vim9.fn.match(typename, '::') < 0 then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
-- # No match for "struct:context::name", remove "context::" and try again.
|
|
||||||
typename = vim9.fn.substitute(typename, ':[^:]*::', ':', '')
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.bool(vim9.prefix['Bang'](all)) then
|
|
||||||
-- # Store the result to be able to use it again later.
|
|
||||||
grepCache[vim9.index_expr(typename)] = qflist
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Skip over [...] items
|
|
||||||
local idx = 0
|
|
||||||
local target = ''
|
|
||||||
while 1 do
|
|
||||||
if idx >= vim9.fn.len(items) then
|
|
||||||
target = ''
|
|
||||||
break
|
|
||||||
end
|
|
||||||
if vim9.index(vim9.index(items, idx), 0) ~= '[' then
|
|
||||||
target = vim9.index(items, idx)
|
|
||||||
break
|
|
||||||
end
|
|
||||||
idx = idx + 1
|
|
||||||
end
|
|
||||||
-- # Put matching members in matches[].
|
|
||||||
local matches = {}
|
|
||||||
|
|
||||||
for _, l in vim9.iter(qflist) do
|
|
||||||
local memb = vim9.fn.matchstr(vim9.index(l, 'text'), '[^\\t]*')
|
|
||||||
if vim9.ops.RegexpMatches(memb, '^' .. target) then
|
|
||||||
-- # Skip matches local to another file.
|
|
||||||
if
|
|
||||||
vim9.fn.match(vim9.index(l, 'text'), '\tfile:') < 0
|
|
||||||
or vim9.fn.bufnr('%')
|
|
||||||
== vim9.fn.bufnr(vim9.fn.matchstr(vim9.index(l, 'text'), '\\t\\zs[^\\t]*'))
|
|
||||||
then
|
|
||||||
local item =
|
|
||||||
vim9.convert.decl_dict({ ['match'] = memb, ['tagline'] = vim9.index(l, 'text') })
|
|
||||||
|
|
||||||
-- # Add the kind of item.
|
|
||||||
local s =
|
|
||||||
vim9.fn.matchstr(vim9.index(l, 'text'), '\\t\\(kind:\\)\\=\\zs\\S\\ze\\(\\t\\|$\\)')
|
|
||||||
if s ~= '' then
|
|
||||||
item[vim9.index_expr('kind')] = s
|
|
||||||
if s == 'f' then
|
|
||||||
item[vim9.index_expr('match')] = memb .. '('
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
vim9.fn.add(matches, item)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim9.fn.len(matches) > 0 then
|
|
||||||
-- # Skip over next [...] items
|
|
||||||
idx = idx + 1
|
|
||||||
while 1 do
|
|
||||||
if idx >= vim9.fn.len(items) then
|
|
||||||
return matches
|
|
||||||
end
|
|
||||||
if vim9.index(vim9.index(items, idx), 0) ~= '[' then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
idx = idx + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # More items following. For each of the possible members find the
|
|
||||||
-- # matching following members.
|
|
||||||
return SearchMembers(matches, vim9.slice(items, idx, nil), all)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- # Failed to find anything.
|
|
||||||
return {}
|
|
||||||
end
|
|
||||||
|
|
||||||
SearchMembers = function(matches, items, all)
|
|
||||||
all = vim9.bool(all)
|
|
||||||
|
|
||||||
-- # For matching members, find matches for following items.
|
|
||||||
-- # When "all" is true find all, otherwise just return 1 if there is any member.
|
|
||||||
local res = {}
|
|
||||||
|
|
||||||
for _, i in vim9.iter(vim9.fn.range(vim9.fn.len(matches))) do
|
|
||||||
local typename = ''
|
|
||||||
local line = ''
|
|
||||||
if vim9.bool(vim9.fn.has_key(vim9.index(matches, i), 'dict')) then
|
|
||||||
if vim9.bool(vim9.fn.has_key(vim9.index(vim9.index(matches, i), 'dict'), 'typename')) then
|
|
||||||
typename = vim9.index(vim9.index(vim9.index(matches, i), 'dict'), 'typename')
|
|
||||||
elseif vim9.bool(vim9.fn.has_key(vim9.index(vim9.index(matches, i), 'dict'), 'typeref')) then
|
|
||||||
typename = vim9.index(vim9.index(vim9.index(matches, i), 'dict'), 'typeref')
|
|
||||||
end
|
|
||||||
line = '\t' .. vim9.index(vim9.index(vim9.index(matches, i), 'dict'), 'cmd')
|
|
||||||
else
|
|
||||||
line = vim9.index(vim9.index(matches, i), 'tagline')
|
|
||||||
local eb = vim9.fn.matchend(line, '\\ttypename:')
|
|
||||||
local e = vim9.fn.charidx(line, eb)
|
|
||||||
if e < 0 then
|
|
||||||
eb = vim9.fn.matchend(line, '\\ttyperef:')
|
|
||||||
e = vim9.fn.charidx(line, eb)
|
|
||||||
end
|
|
||||||
if e > 0 then
|
|
||||||
-- # Use typename field
|
|
||||||
typename = vim9.fn.matchstr(line, '[^\\t]*', eb)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
if typename ~= '' then
|
|
||||||
res = vim9.fn.extend(res, StructMembers(typename, items, all))
|
|
||||||
else
|
|
||||||
-- # Use the search command (the declaration itself).
|
|
||||||
local sb = vim9.fn.match(line, '\\t\\zs/^')
|
|
||||||
local s = vim9.fn.charidx(line, sb)
|
|
||||||
if s > 0 then
|
|
||||||
local e = vim9.fn.charidx(
|
|
||||||
line,
|
|
||||||
vim9.fn.match(line, '\\<' .. vim9.index(vim9.index(matches, i), 'match') .. '\\>', sb)
|
|
||||||
)
|
|
||||||
if e > 0 then
|
|
||||||
res =
|
|
||||||
vim9.fn.extend(res, Nextitem(vim9.slice(line, s, vim9.ops.Minus(e, 1)), items, 0, all))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if vim9.bool(vim9.ops.And(vim9.prefix['Bang'](all), vim9.fn.len(res) > 0)) then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
-- #}}}1
|
|
||||||
|
|
||||||
-- # vim: noet sw=2 sts=2
|
|
||||||
return M
|
|
||||||
@@ -1,8 +1,639 @@
|
|||||||
" Generated vim file by vim9jit. Please do not edit
|
" Vim completion script
|
||||||
let s:path = expand("<script>")
|
" Language: C
|
||||||
let s:lua_path = fnamemodify(s:path, ":r") . ".lua"
|
" Maintainer: Bram Moolenaar <Bram@vim.org>
|
||||||
let s:nvim_module = luaeval('require("_vim9script").autoload(_A)', s:lua_path)
|
" Last Change: 2020 Nov 14
|
||||||
|
|
||||||
function! ccomplete#Complete(findstart, abase) abort
|
let s:cpo_save = &cpo
|
||||||
return s:nvim_module.Complete(a:findstart, a:abase)
|
set cpo&vim
|
||||||
endfunction
|
|
||||||
|
" This function is used for the 'omnifunc' option.
|
||||||
|
func ccomplete#Complete(findstart, base)
|
||||||
|
if a:findstart
|
||||||
|
" Locate the start of the item, including ".", "->" and "[...]".
|
||||||
|
let line = getline('.')
|
||||||
|
let start = col('.') - 1
|
||||||
|
let lastword = -1
|
||||||
|
while start > 0
|
||||||
|
if line[start - 1] =~ '\w'
|
||||||
|
let start -= 1
|
||||||
|
elseif line[start - 1] =~ '\.'
|
||||||
|
if lastword == -1
|
||||||
|
let lastword = start
|
||||||
|
endif
|
||||||
|
let start -= 1
|
||||||
|
elseif start > 1 && line[start - 2] == '-' && line[start - 1] == '>'
|
||||||
|
if lastword == -1
|
||||||
|
let lastword = start
|
||||||
|
endif
|
||||||
|
let start -= 2
|
||||||
|
elseif line[start - 1] == ']'
|
||||||
|
" Skip over [...].
|
||||||
|
let n = 0
|
||||||
|
let start -= 1
|
||||||
|
while start > 0
|
||||||
|
let start -= 1
|
||||||
|
if line[start] == '['
|
||||||
|
if n == 0
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
let n -= 1
|
||||||
|
elseif line[start] == ']' " nested []
|
||||||
|
let n += 1
|
||||||
|
endif
|
||||||
|
endwhile
|
||||||
|
else
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
endwhile
|
||||||
|
|
||||||
|
" Return the column of the last word, which is going to be changed.
|
||||||
|
" Remember the text that comes before it in s:prepended.
|
||||||
|
if lastword == -1
|
||||||
|
let s:prepended = ''
|
||||||
|
return start
|
||||||
|
endif
|
||||||
|
let s:prepended = strpart(line, start, lastword - start)
|
||||||
|
return lastword
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Return list of matches.
|
||||||
|
|
||||||
|
let base = s:prepended . a:base
|
||||||
|
|
||||||
|
" Don't do anything for an empty base, would result in all the tags in the
|
||||||
|
" tags file.
|
||||||
|
if base == ''
|
||||||
|
return []
|
||||||
|
endif
|
||||||
|
|
||||||
|
" init cache for vimgrep to empty
|
||||||
|
let s:grepCache = {}
|
||||||
|
|
||||||
|
" Split item in words, keep empty word after "." or "->".
|
||||||
|
" "aa" -> ['aa'], "aa." -> ['aa', ''], "aa.bb" -> ['aa', 'bb'], etc.
|
||||||
|
" We can't use split, because we need to skip nested [...].
|
||||||
|
" "aa[...]" -> ['aa', '[...]'], "aa.bb[...]" -> ['aa', 'bb', '[...]'], etc.
|
||||||
|
let items = []
|
||||||
|
let s = 0
|
||||||
|
let arrays = 0
|
||||||
|
while 1
|
||||||
|
let e = match(base, '\.\|->\|\[', s)
|
||||||
|
if e < 0
|
||||||
|
if s == 0 || base[s - 1] != ']'
|
||||||
|
call add(items, strpart(base, s))
|
||||||
|
endif
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
if s == 0 || base[s - 1] != ']'
|
||||||
|
call add(items, strpart(base, s, e - s))
|
||||||
|
endif
|
||||||
|
if base[e] == '.'
|
||||||
|
let s = e + 1 " skip over '.'
|
||||||
|
elseif base[e] == '-'
|
||||||
|
let s = e + 2 " skip over '->'
|
||||||
|
else
|
||||||
|
" Skip over [...].
|
||||||
|
let n = 0
|
||||||
|
let s = e
|
||||||
|
let e += 1
|
||||||
|
while e < len(base)
|
||||||
|
if base[e] == ']'
|
||||||
|
if n == 0
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
let n -= 1
|
||||||
|
elseif base[e] == '[' " nested [...]
|
||||||
|
let n += 1
|
||||||
|
endif
|
||||||
|
let e += 1
|
||||||
|
endwhile
|
||||||
|
let e += 1
|
||||||
|
call add(items, strpart(base, s, e - s))
|
||||||
|
let arrays += 1
|
||||||
|
let s = e
|
||||||
|
endif
|
||||||
|
endwhile
|
||||||
|
|
||||||
|
" Find the variable items[0].
|
||||||
|
" 1. in current function (like with "gd")
|
||||||
|
" 2. in tags file(s) (like with ":tag")
|
||||||
|
" 3. in current file (like with "gD")
|
||||||
|
let res = []
|
||||||
|
if searchdecl(items[0], 0, 1) == 0
|
||||||
|
" Found, now figure out the type.
|
||||||
|
" TODO: join previous line if it makes sense
|
||||||
|
let line = getline('.')
|
||||||
|
let col = col('.')
|
||||||
|
if stridx(strpart(line, 0, col), ';') != -1
|
||||||
|
" Handle multiple declarations on the same line.
|
||||||
|
let col2 = col - 1
|
||||||
|
while line[col2] != ';'
|
||||||
|
let col2 -= 1
|
||||||
|
endwhile
|
||||||
|
let line = strpart(line, col2 + 1)
|
||||||
|
let col -= col2
|
||||||
|
endif
|
||||||
|
if stridx(strpart(line, 0, col), ',') != -1
|
||||||
|
" Handle multiple declarations on the same line in a function
|
||||||
|
" declaration.
|
||||||
|
let col2 = col - 1
|
||||||
|
while line[col2] != ','
|
||||||
|
let col2 -= 1
|
||||||
|
endwhile
|
||||||
|
if strpart(line, col2 + 1, col - col2 - 1) =~ ' *[^ ][^ ]* *[^ ]'
|
||||||
|
let line = strpart(line, col2 + 1)
|
||||||
|
let col -= col2
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
if len(items) == 1
|
||||||
|
" Completing one word and it's a local variable: May add '[', '.' or
|
||||||
|
" '->'.
|
||||||
|
let match = items[0]
|
||||||
|
let kind = 'v'
|
||||||
|
if match(line, '\<' . match . '\s*\[') > 0
|
||||||
|
let match .= '['
|
||||||
|
else
|
||||||
|
let res = s:Nextitem(strpart(line, 0, col), [''], 0, 1)
|
||||||
|
if len(res) > 0
|
||||||
|
" There are members, thus add "." or "->".
|
||||||
|
if match(line, '\*[ \t(]*' . match . '\>') > 0
|
||||||
|
let match .= '->'
|
||||||
|
else
|
||||||
|
let match .= '.'
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
let res = [{'match': match, 'tagline' : '', 'kind' : kind, 'info' : line}]
|
||||||
|
elseif len(items) == arrays + 1
|
||||||
|
" Completing one word and it's a local array variable: build tagline
|
||||||
|
" from declaration line
|
||||||
|
let match = items[0]
|
||||||
|
let kind = 'v'
|
||||||
|
let tagline = "\t/^" . line . '$/'
|
||||||
|
let res = [{'match': match, 'tagline' : tagline, 'kind' : kind, 'info' : line}]
|
||||||
|
else
|
||||||
|
" Completing "var.", "var.something", etc.
|
||||||
|
let res = s:Nextitem(strpart(line, 0, col), items[1:], 0, 1)
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
if len(items) == 1 || len(items) == arrays + 1
|
||||||
|
" Only one part, no "." or "->": complete from tags file.
|
||||||
|
if len(items) == 1
|
||||||
|
let tags = taglist('^' . base)
|
||||||
|
else
|
||||||
|
let tags = taglist('^' . items[0] . '$')
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Remove members, these can't appear without something in front.
|
||||||
|
call filter(tags, 'has_key(v:val, "kind") ? v:val["kind"] != "m" : 1')
|
||||||
|
|
||||||
|
" Remove static matches in other files.
|
||||||
|
call filter(tags, '!has_key(v:val, "static") || !v:val["static"] || bufnr("%") == bufnr(v:val["filename"])')
|
||||||
|
|
||||||
|
call extend(res, map(tags, 's:Tag2item(v:val)'))
|
||||||
|
endif
|
||||||
|
|
||||||
|
if len(res) == 0
|
||||||
|
" Find the variable in the tags file(s)
|
||||||
|
let diclist = taglist('^' . items[0] . '$')
|
||||||
|
|
||||||
|
" Remove members, these can't appear without something in front.
|
||||||
|
call filter(diclist, 'has_key(v:val, "kind") ? v:val["kind"] != "m" : 1')
|
||||||
|
|
||||||
|
let res = []
|
||||||
|
for i in range(len(diclist))
|
||||||
|
" New ctags has the "typeref" field. Patched version has "typename".
|
||||||
|
if has_key(diclist[i], 'typename')
|
||||||
|
call extend(res, s:StructMembers(diclist[i]['typename'], items[1:], 1))
|
||||||
|
elseif has_key(diclist[i], 'typeref')
|
||||||
|
call extend(res, s:StructMembers(diclist[i]['typeref'], items[1:], 1))
|
||||||
|
endif
|
||||||
|
|
||||||
|
" For a variable use the command, which must be a search pattern that
|
||||||
|
" shows the declaration of the variable.
|
||||||
|
if diclist[i]['kind'] == 'v'
|
||||||
|
let line = diclist[i]['cmd']
|
||||||
|
if line[0] == '/' && line[1] == '^'
|
||||||
|
let col = match(line, '\<' . items[0] . '\>')
|
||||||
|
call extend(res, s:Nextitem(strpart(line, 2, col - 2), items[1:], 0, 1))
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
endif
|
||||||
|
|
||||||
|
if len(res) == 0 && searchdecl(items[0], 1) == 0
|
||||||
|
" Found, now figure out the type.
|
||||||
|
" TODO: join previous line if it makes sense
|
||||||
|
let line = getline('.')
|
||||||
|
let col = col('.')
|
||||||
|
let res = s:Nextitem(strpart(line, 0, col), items[1:], 0, 1)
|
||||||
|
endif
|
||||||
|
|
||||||
|
" If the last item(s) are [...] they need to be added to the matches.
|
||||||
|
let last = len(items) - 1
|
||||||
|
let brackets = ''
|
||||||
|
while last >= 0
|
||||||
|
if items[last][0] != '['
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
let brackets = items[last] . brackets
|
||||||
|
let last -= 1
|
||||||
|
endwhile
|
||||||
|
|
||||||
|
return map(res, 's:Tagline2item(v:val, brackets)')
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
func s:GetAddition(line, match, memarg, bracket)
|
||||||
|
" Guess if the item is an array.
|
||||||
|
if a:bracket && match(a:line, a:match . '\s*\[') > 0
|
||||||
|
return '['
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Check if the item has members.
|
||||||
|
if len(s:SearchMembers(a:memarg, [''], 0)) > 0
|
||||||
|
" If there is a '*' before the name use "->".
|
||||||
|
if match(a:line, '\*[ \t(]*' . a:match . '\>') > 0
|
||||||
|
return '->'
|
||||||
|
else
|
||||||
|
return '.'
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
return ''
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Turn the tag info "val" into an item for completion.
|
||||||
|
" "val" is is an item in the list returned by taglist().
|
||||||
|
" If it is a variable we may add "." or "->". Don't do it for other types,
|
||||||
|
" such as a typedef, by not including the info that s:GetAddition() uses.
|
||||||
|
func s:Tag2item(val)
|
||||||
|
let res = {'match': a:val['name']}
|
||||||
|
|
||||||
|
let res['extra'] = s:Tagcmd2extra(a:val['cmd'], a:val['name'], a:val['filename'])
|
||||||
|
|
||||||
|
let s = s:Dict2info(a:val)
|
||||||
|
if s != ''
|
||||||
|
let res['info'] = s
|
||||||
|
endif
|
||||||
|
|
||||||
|
let res['tagline'] = ''
|
||||||
|
if has_key(a:val, "kind")
|
||||||
|
let kind = a:val['kind']
|
||||||
|
let res['kind'] = kind
|
||||||
|
if kind == 'v'
|
||||||
|
let res['tagline'] = "\t" . a:val['cmd']
|
||||||
|
let res['dict'] = a:val
|
||||||
|
elseif kind == 'f'
|
||||||
|
let res['match'] = a:val['name'] . '('
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
return res
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Use all the items in dictionary for the "info" entry.
|
||||||
|
func s:Dict2info(dict)
|
||||||
|
let info = ''
|
||||||
|
for k in sort(keys(a:dict))
|
||||||
|
let info .= k . repeat(' ', 10 - len(k))
|
||||||
|
if k == 'cmd'
|
||||||
|
let info .= substitute(matchstr(a:dict['cmd'], '/^\s*\zs.*\ze$/'), '\\\(.\)', '\1', 'g')
|
||||||
|
else
|
||||||
|
let info .= a:dict[k]
|
||||||
|
endif
|
||||||
|
let info .= "\n"
|
||||||
|
endfor
|
||||||
|
return info
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Parse a tag line and return a dictionary with items like taglist()
|
||||||
|
func s:ParseTagline(line)
|
||||||
|
let l = split(a:line, "\t")
|
||||||
|
let d = {}
|
||||||
|
if len(l) >= 3
|
||||||
|
let d['name'] = l[0]
|
||||||
|
let d['filename'] = l[1]
|
||||||
|
let d['cmd'] = l[2]
|
||||||
|
let n = 2
|
||||||
|
if l[2] =~ '^/'
|
||||||
|
" Find end of cmd, it may contain Tabs.
|
||||||
|
while n < len(l) && l[n] !~ '/;"$'
|
||||||
|
let n += 1
|
||||||
|
let d['cmd'] .= " " . l[n]
|
||||||
|
endwhile
|
||||||
|
endif
|
||||||
|
for i in range(n + 1, len(l) - 1)
|
||||||
|
if l[i] == 'file:'
|
||||||
|
let d['static'] = 1
|
||||||
|
elseif l[i] !~ ':'
|
||||||
|
let d['kind'] = l[i]
|
||||||
|
else
|
||||||
|
let d[matchstr(l[i], '[^:]*')] = matchstr(l[i], ':\zs.*')
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
endif
|
||||||
|
|
||||||
|
return d
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Turn a match item "val" into an item for completion.
|
||||||
|
" "val['match']" is the matching item.
|
||||||
|
" "val['tagline']" is the tagline in which the last part was found.
|
||||||
|
func s:Tagline2item(val, brackets)
|
||||||
|
let line = a:val['tagline']
|
||||||
|
let add = s:GetAddition(line, a:val['match'], [a:val], a:brackets == '')
|
||||||
|
let res = {'word': a:val['match'] . a:brackets . add }
|
||||||
|
|
||||||
|
if has_key(a:val, 'info')
|
||||||
|
" Use info from Tag2item().
|
||||||
|
let res['info'] = a:val['info']
|
||||||
|
else
|
||||||
|
" Parse the tag line and add each part to the "info" entry.
|
||||||
|
let s = s:Dict2info(s:ParseTagline(line))
|
||||||
|
if s != ''
|
||||||
|
let res['info'] = s
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
if has_key(a:val, 'kind')
|
||||||
|
let res['kind'] = a:val['kind']
|
||||||
|
elseif add == '('
|
||||||
|
let res['kind'] = 'f'
|
||||||
|
else
|
||||||
|
let s = matchstr(line, '\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
|
||||||
|
if s != ''
|
||||||
|
let res['kind'] = s
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
if has_key(a:val, 'extra')
|
||||||
|
let res['menu'] = a:val['extra']
|
||||||
|
return res
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Isolate the command after the tag and filename.
|
||||||
|
let s = matchstr(line, '[^\t]*\t[^\t]*\t\zs\(/^.*$/\|[^\t]*\)\ze\(;"\t\|\t\|$\)')
|
||||||
|
if s != ''
|
||||||
|
let res['menu'] = s:Tagcmd2extra(s, a:val['match'], matchstr(line, '[^\t]*\t\zs[^\t]*\ze\t'))
|
||||||
|
endif
|
||||||
|
return res
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Turn a command from a tag line to something that is useful in the menu
|
||||||
|
func s:Tagcmd2extra(cmd, name, fname)
|
||||||
|
if a:cmd =~ '^/^'
|
||||||
|
" The command is a search command, useful to see what it is.
|
||||||
|
let x = matchstr(a:cmd, '^/^\s*\zs.*\ze$/')
|
||||||
|
let x = substitute(x, '\<' . a:name . '\>', '@@', '')
|
||||||
|
let x = substitute(x, '\\\(.\)', '\1', 'g')
|
||||||
|
let x = x . ' - ' . a:fname
|
||||||
|
elseif a:cmd =~ '^\d*$'
|
||||||
|
" The command is a line number, the file name is more useful.
|
||||||
|
let x = a:fname . ' - ' . a:cmd
|
||||||
|
else
|
||||||
|
" Not recognized, use command and file name.
|
||||||
|
let x = a:cmd . ' - ' . a:fname
|
||||||
|
endif
|
||||||
|
return x
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" Find composing type in "lead" and match items[0] with it.
|
||||||
|
" Repeat this recursively for items[1], if it's there.
|
||||||
|
" When resolving typedefs "depth" is used to avoid infinite recursion.
|
||||||
|
" Return the list of matches.
|
||||||
|
func s:Nextitem(lead, items, depth, all)
|
||||||
|
|
||||||
|
" Use the text up to the variable name and split it in tokens.
|
||||||
|
let tokens = split(a:lead, '\s\+\|\<')
|
||||||
|
|
||||||
|
" Try to recognize the type of the variable. This is rough guessing...
|
||||||
|
let res = []
|
||||||
|
for tidx in range(len(tokens))
|
||||||
|
|
||||||
|
" Skip tokens starting with a non-ID character.
|
||||||
|
if tokens[tidx] !~ '^\h'
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Recognize "struct foobar" and "union foobar".
|
||||||
|
" Also do "class foobar" when it's C++ after all (doesn't work very well
|
||||||
|
" though).
|
||||||
|
if (tokens[tidx] == 'struct' || tokens[tidx] == 'union' || tokens[tidx] == 'class') && tidx + 1 < len(tokens)
|
||||||
|
let res = s:StructMembers(tokens[tidx] . ':' . tokens[tidx + 1], a:items, a:all)
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
|
||||||
|
" TODO: add more reserved words
|
||||||
|
if index(['int', 'short', 'char', 'float', 'double', 'static', 'unsigned', 'extern'], tokens[tidx]) >= 0
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Use the tags file to find out if this is a typedef.
|
||||||
|
let diclist = taglist('^' . tokens[tidx] . '$')
|
||||||
|
for tagidx in range(len(diclist))
|
||||||
|
let item = diclist[tagidx]
|
||||||
|
|
||||||
|
" New ctags has the "typeref" field. Patched version has "typename".
|
||||||
|
if has_key(item, 'typeref')
|
||||||
|
call extend(res, s:StructMembers(item['typeref'], a:items, a:all))
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
if has_key(item, 'typename')
|
||||||
|
call extend(res, s:StructMembers(item['typename'], a:items, a:all))
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Only handle typedefs here.
|
||||||
|
if item['kind'] != 't'
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Skip matches local to another file.
|
||||||
|
if has_key(item, 'static') && item['static'] && bufnr('%') != bufnr(item['filename'])
|
||||||
|
continue
|
||||||
|
endif
|
||||||
|
|
||||||
|
" For old ctags we recognize "typedef struct aaa" and
|
||||||
|
" "typedef union bbb" in the tags file command.
|
||||||
|
let cmd = item['cmd']
|
||||||
|
let ei = matchend(cmd, 'typedef\s\+')
|
||||||
|
if ei > 1
|
||||||
|
let cmdtokens = split(strpart(cmd, ei), '\s\+\|\<')
|
||||||
|
if len(cmdtokens) > 1
|
||||||
|
if cmdtokens[0] == 'struct' || cmdtokens[0] == 'union' || cmdtokens[0] == 'class'
|
||||||
|
let name = ''
|
||||||
|
" Use the first identifier after the "struct" or "union"
|
||||||
|
for ti in range(len(cmdtokens) - 1)
|
||||||
|
if cmdtokens[ti] =~ '^\w'
|
||||||
|
let name = cmdtokens[ti]
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
if name != ''
|
||||||
|
call extend(res, s:StructMembers(cmdtokens[0] . ':' . name, a:items, a:all))
|
||||||
|
endif
|
||||||
|
elseif a:depth < 10
|
||||||
|
" Could be "typedef other_T some_T".
|
||||||
|
call extend(res, s:Nextitem(cmdtokens[0], a:items, a:depth + 1, a:all))
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
if len(res) > 0
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
|
||||||
|
return res
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
|
||||||
|
" Search for members of structure "typename" in tags files.
|
||||||
|
" Return a list with resulting matches.
|
||||||
|
" Each match is a dictionary with "match" and "tagline" entries.
|
||||||
|
" When "all" is non-zero find all, otherwise just return 1 if there is any
|
||||||
|
" member.
|
||||||
|
func s:StructMembers(typename, items, all)
|
||||||
|
" Todo: What about local structures?
|
||||||
|
let fnames = join(map(tagfiles(), 'escape(v:val, " \\#%")'))
|
||||||
|
if fnames == ''
|
||||||
|
return []
|
||||||
|
endif
|
||||||
|
|
||||||
|
let typename = a:typename
|
||||||
|
let qflist = []
|
||||||
|
let cached = 0
|
||||||
|
if a:all == 0
|
||||||
|
let n = '1' " stop at first found match
|
||||||
|
if has_key(s:grepCache, a:typename)
|
||||||
|
let qflist = s:grepCache[a:typename]
|
||||||
|
let cached = 1
|
||||||
|
endif
|
||||||
|
else
|
||||||
|
let n = ''
|
||||||
|
endif
|
||||||
|
if !cached
|
||||||
|
while 1
|
||||||
|
exe 'silent! keepj noautocmd ' . n . 'vimgrep /\t' . typename . '\(\t\|$\)/j ' . fnames
|
||||||
|
|
||||||
|
let qflist = getqflist()
|
||||||
|
if len(qflist) > 0 || match(typename, "::") < 0
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
" No match for "struct:context::name", remove "context::" and try again.
|
||||||
|
let typename = substitute(typename, ':[^:]*::', ':', '')
|
||||||
|
endwhile
|
||||||
|
|
||||||
|
if a:all == 0
|
||||||
|
" Store the result to be able to use it again later.
|
||||||
|
let s:grepCache[a:typename] = qflist
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Skip over [...] items
|
||||||
|
let idx = 0
|
||||||
|
while 1
|
||||||
|
if idx >= len(a:items)
|
||||||
|
let target = '' " No further items, matching all members
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
if a:items[idx][0] != '['
|
||||||
|
let target = a:items[idx]
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
let idx += 1
|
||||||
|
endwhile
|
||||||
|
" Put matching members in matches[].
|
||||||
|
let matches = []
|
||||||
|
for l in qflist
|
||||||
|
let memb = matchstr(l['text'], '[^\t]*')
|
||||||
|
if memb =~ '^' . target
|
||||||
|
" Skip matches local to another file.
|
||||||
|
if match(l['text'], "\tfile:") < 0 || bufnr('%') == bufnr(matchstr(l['text'], '\t\zs[^\t]*'))
|
||||||
|
let item = {'match': memb, 'tagline': l['text']}
|
||||||
|
|
||||||
|
" Add the kind of item.
|
||||||
|
let s = matchstr(l['text'], '\t\(kind:\)\=\zs\S\ze\(\t\|$\)')
|
||||||
|
if s != ''
|
||||||
|
let item['kind'] = s
|
||||||
|
if s == 'f'
|
||||||
|
let item['match'] = memb . '('
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
call add(matches, item)
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
|
||||||
|
if len(matches) > 0
|
||||||
|
" Skip over next [...] items
|
||||||
|
let idx += 1
|
||||||
|
while 1
|
||||||
|
if idx >= len(a:items)
|
||||||
|
return matches " No further items, return the result.
|
||||||
|
endif
|
||||||
|
if a:items[idx][0] != '['
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
let idx += 1
|
||||||
|
endwhile
|
||||||
|
|
||||||
|
" More items following. For each of the possible members find the
|
||||||
|
" matching following members.
|
||||||
|
return s:SearchMembers(matches, a:items[idx :], a:all)
|
||||||
|
endif
|
||||||
|
|
||||||
|
" Failed to find anything.
|
||||||
|
return []
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
" For matching members, find matches for following items.
|
||||||
|
" When "all" is non-zero find all, otherwise just return 1 if there is any
|
||||||
|
" member.
|
||||||
|
func s:SearchMembers(matches, items, all)
|
||||||
|
let res = []
|
||||||
|
for i in range(len(a:matches))
|
||||||
|
let typename = ''
|
||||||
|
if has_key(a:matches[i], 'dict')
|
||||||
|
if has_key(a:matches[i].dict, 'typename')
|
||||||
|
let typename = a:matches[i].dict['typename']
|
||||||
|
elseif has_key(a:matches[i].dict, 'typeref')
|
||||||
|
let typename = a:matches[i].dict['typeref']
|
||||||
|
endif
|
||||||
|
let line = "\t" . a:matches[i].dict['cmd']
|
||||||
|
else
|
||||||
|
let line = a:matches[i]['tagline']
|
||||||
|
let e = matchend(line, '\ttypename:')
|
||||||
|
if e < 0
|
||||||
|
let e = matchend(line, '\ttyperef:')
|
||||||
|
endif
|
||||||
|
if e > 0
|
||||||
|
" Use typename field
|
||||||
|
let typename = matchstr(line, '[^\t]*', e)
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
|
||||||
|
if typename != ''
|
||||||
|
call extend(res, s:StructMembers(typename, a:items, a:all))
|
||||||
|
else
|
||||||
|
" Use the search command (the declaration itself).
|
||||||
|
let s = match(line, '\t\zs/^')
|
||||||
|
if s > 0
|
||||||
|
let e = match(line, '\<' . a:matches[i]['match'] . '\>', s)
|
||||||
|
if e > 0
|
||||||
|
call extend(res, s:Nextitem(strpart(line, s, e - s), a:items, 0, a:all))
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
endif
|
||||||
|
if a:all == 0 && len(res) > 0
|
||||||
|
break
|
||||||
|
endif
|
||||||
|
endfor
|
||||||
|
return res
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
let &cpo = s:cpo_save
|
||||||
|
unlet s:cpo_save
|
||||||
|
|
||||||
|
" vim: noet sw=2 sts=2
|
||||||
|
|||||||
@@ -450,10 +450,7 @@ grow and enhance it. Changing the rules of Lua gains nothing in this context.
|
|||||||
|
|
||||||
WILL NEOVIM TRANSLATE VIMSCRIPT TO LUA, INSTEAD OF EXECUTING VIMSCRIPT DIRECTLY? ~
|
WILL NEOVIM TRANSLATE VIMSCRIPT TO LUA, INSTEAD OF EXECUTING VIMSCRIPT DIRECTLY? ~
|
||||||
|
|
||||||
- We are experimenting with vim9jit https://github.com/tjdevries/vim9jit to
|
We have no plans for transpiling Vimscript. It was explored in https://github.com/tjdevries/vim9jit
|
||||||
transpile Vim9script (Vim9's Vimscript variant) to Lua and have used this to
|
|
||||||
port Vim9 plugins https://github.com/neovim/neovim/pull/21662 to Nvim Lua.
|
|
||||||
- We have no plans for transpiling legacy Vimscript.
|
|
||||||
|
|
||||||
|
|
||||||
ARE PLUGIN AUTHORS ENCOURAGED TO PORT THEIR PLUGINS FROM VIMSCRIPT TO LUA? DO YOU PLAN ON SUPPORTING VIMSCRIPT INDEFINITELY? (#1152) ~
|
ARE PLUGIN AUTHORS ENCOURAGED TO PORT THEIR PLUGINS FROM VIMSCRIPT TO LUA? DO YOU PLAN ON SUPPORTING VIMSCRIPT INDEFINITELY? (#1152) ~
|
||||||
@@ -468,4 +465,8 @@ emphatically a fork of Vim in order to leverage the work already spent on
|
|||||||
thousands of Vim plugins, while enabling new types of plugins and
|
thousands of Vim plugins, while enabling new types of plugins and
|
||||||
integrations.
|
integrations.
|
||||||
|
|
||||||
|
That being said, reimplementing legacy plugins in Lua in order to make use of
|
||||||
|
Nvim API and to integrate with Nvim-specific features such as treesitter can
|
||||||
|
be worthwhile.
|
||||||
|
|
||||||
vim:tw=78:ts=8:noet:ft=help:norl:
|
vim:tw=78:ts=8:noet:ft=help:norl:
|
||||||
|
|||||||
@@ -1,650 +0,0 @@
|
|||||||
-------------------------------------------------------------------------------
|
|
||||||
-- This file is auto generated by vim9jit. Do not edit by hand.
|
|
||||||
-- All content is in the source repository.
|
|
||||||
-- Bugs should be reported to: github.com/tjdevries/vim9jit
|
|
||||||
--
|
|
||||||
-- In addition, this file is considered "private" by neovim. You should
|
|
||||||
-- not expect any of the APIs, functions, etc to be stable. They are subject
|
|
||||||
-- to change at any time.
|
|
||||||
-------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
local vim9 = (function()
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M.ternary = function(cond, if_true, if_false)
|
|
||||||
if cond then
|
|
||||||
if type(if_true) == 'function' then
|
|
||||||
return if_true()
|
|
||||||
else
|
|
||||||
return if_true
|
|
||||||
end
|
|
||||||
else
|
|
||||||
if type(if_false) == 'function' then
|
|
||||||
return if_false()
|
|
||||||
else
|
|
||||||
return if_false
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M.fn_ref = function(module, name, copied, ...)
|
|
||||||
for _, val in ipairs({ ... }) do
|
|
||||||
table.insert(copied, val)
|
|
||||||
end
|
|
||||||
|
|
||||||
local funcref = name
|
|
||||||
if type(funcref) == 'function' then
|
|
||||||
return funcref(unpack(copied))
|
|
||||||
elseif type(funcref) == 'string' then
|
|
||||||
if vim.fn.exists('*' .. funcref) == 1 then
|
|
||||||
return vim.fn[funcref](unpack(copied))
|
|
||||||
end
|
|
||||||
|
|
||||||
if module[funcref] then
|
|
||||||
module[funcref](unpack(copied))
|
|
||||||
end
|
|
||||||
|
|
||||||
error('unknown function: ' .. funcref)
|
|
||||||
else
|
|
||||||
error(string.format('unable to call funcref: %s', funcref))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M.fn_mut = function(name, args, info)
|
|
||||||
local result = vim.fn._Vim9ScriptFn(name, args)
|
|
||||||
for idx, val in pairs(result[2]) do
|
|
||||||
M.replace(args[idx], val)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Substitute returning the reference to the
|
|
||||||
-- returned value
|
|
||||||
if info.replace then
|
|
||||||
return args[info.replace + 1]
|
|
||||||
end
|
|
||||||
|
|
||||||
return result[1]
|
|
||||||
end
|
|
||||||
|
|
||||||
M.replace = function(orig, new)
|
|
||||||
if type(orig) == 'table' and type(new) == 'table' then
|
|
||||||
for k in pairs(orig) do
|
|
||||||
orig[k] = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
for k, v in pairs(new) do
|
|
||||||
orig[k] = v
|
|
||||||
end
|
|
||||||
|
|
||||||
return orig
|
|
||||||
end
|
|
||||||
|
|
||||||
return new
|
|
||||||
end
|
|
||||||
|
|
||||||
M.index = function(obj, idx)
|
|
||||||
if vim.islist(obj) then
|
|
||||||
if idx < 0 then
|
|
||||||
return obj[#obj + idx + 1]
|
|
||||||
else
|
|
||||||
return obj[idx + 1]
|
|
||||||
end
|
|
||||||
elseif type(obj) == 'table' then
|
|
||||||
return obj[idx]
|
|
||||||
elseif type(obj) == 'string' then
|
|
||||||
return string.sub(obj, idx + 1, idx + 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
error('invalid type for indexing: ' .. vim.inspect(obj))
|
|
||||||
end
|
|
||||||
|
|
||||||
M.index_expr = function(idx)
|
|
||||||
if type(idx) == 'string' then
|
|
||||||
return idx
|
|
||||||
elseif type(idx) == 'number' then
|
|
||||||
return idx + 1
|
|
||||||
else
|
|
||||||
error(string.format('not yet handled: %s', vim.inspect(idx)))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M.slice = function(obj, start, finish)
|
|
||||||
if start == nil then
|
|
||||||
start = 0
|
|
||||||
end
|
|
||||||
|
|
||||||
if start < 0 then
|
|
||||||
start = #obj + start
|
|
||||||
end
|
|
||||||
assert(type(start) == 'number')
|
|
||||||
|
|
||||||
if finish == nil then
|
|
||||||
finish = #obj
|
|
||||||
end
|
|
||||||
|
|
||||||
if finish < 0 then
|
|
||||||
finish = #obj + finish
|
|
||||||
end
|
|
||||||
assert(type(finish) == 'number')
|
|
||||||
|
|
||||||
local slicer
|
|
||||||
if vim.islist(obj) then
|
|
||||||
slicer = vim.list_slice
|
|
||||||
elseif type(obj) == 'string' then
|
|
||||||
slicer = string.sub
|
|
||||||
else
|
|
||||||
error('invalid type for slicing: ' .. vim.inspect(obj))
|
|
||||||
end
|
|
||||||
|
|
||||||
return slicer(obj, start + 1, finish + 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Currently unused, but this could be used to embed vim9jit within a
|
|
||||||
-- running nvim application and transpile "on the fly" as files are
|
|
||||||
-- sourced. There would still need to be some work done to make that
|
|
||||||
-- work correctly with imports and what not, but overall it could
|
|
||||||
-- work well for calling ":source X" from within a vimscript/vim9script
|
|
||||||
-- function
|
|
||||||
M.make_source_cmd = function()
|
|
||||||
local group = vim.api.nvim_create_augroup('nvim.vim9script_source', {})
|
|
||||||
vim.api.nvim_create_autocmd('SourceCmd', {
|
|
||||||
pattern = '*.vim',
|
|
||||||
group = group,
|
|
||||||
callback = function(a)
|
|
||||||
local file = vim.fn.readfile(a.file)
|
|
||||||
for _, line in ipairs(file) do
|
|
||||||
-- TODO: Or starts with def <something>
|
|
||||||
-- You can use def in legacy vim files
|
|
||||||
if vim.startswith(line, 'vim9script') then
|
|
||||||
-- TODO: Use the rust lib to actually
|
|
||||||
-- generate the corresponding lua code and then
|
|
||||||
-- execute that (instead of sourcing it directly)
|
|
||||||
return
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
vim.api.nvim_exec2(table.concat(file, '\n'), { output = false })
|
|
||||||
end,
|
|
||||||
})
|
|
||||||
end
|
|
||||||
|
|
||||||
M.iter = function(expr)
|
|
||||||
if vim.islist(expr) then
|
|
||||||
return ipairs(expr)
|
|
||||||
else
|
|
||||||
return pairs(expr)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M.ITER_DEFAULT = 0
|
|
||||||
M.ITER_CONTINUE = 1
|
|
||||||
M.ITER_BREAK = 2
|
|
||||||
M.ITER_RETURN = 3
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
|
|
||||||
vim.cmd([[
|
|
||||||
function! _Vim9ScriptFn(name, args) abort
|
|
||||||
try
|
|
||||||
let ret = function(a:name, a:args)()
|
|
||||||
catch
|
|
||||||
echo "Failed..."
|
|
||||||
echo a:name
|
|
||||||
echo a:args
|
|
||||||
|
|
||||||
throw v:errmsg
|
|
||||||
endtry
|
|
||||||
|
|
||||||
return [ret, a:args]
|
|
||||||
endfunction
|
|
||||||
]])
|
|
||||||
|
|
||||||
vim9['autoload'] = (function()
|
|
||||||
return function(path)
|
|
||||||
return loadfile(path)()
|
|
||||||
end
|
|
||||||
end)()
|
|
||||||
vim9['bool'] = (function()
|
|
||||||
return function(...)
|
|
||||||
return vim9.convert.to_vim_bool(...)
|
|
||||||
end
|
|
||||||
end)()
|
|
||||||
vim9['convert'] = (function()
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M.decl_bool = function(val)
|
|
||||||
if type(val) == 'boolean' then
|
|
||||||
return val
|
|
||||||
elseif type(val) == 'number' then
|
|
||||||
if val == 0 then
|
|
||||||
return false
|
|
||||||
elseif val == 1 then
|
|
||||||
return true
|
|
||||||
else
|
|
||||||
error(string.format('bad number passed to bool declaration: %s', val))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
error(string.format('invalid bool declaration: %s', vim.inspect(val)))
|
|
||||||
end
|
|
||||||
|
|
||||||
M.decl_dict = function(val)
|
|
||||||
if type(val) == 'nil' then
|
|
||||||
return vim.empty_dict()
|
|
||||||
elseif type(val) == 'table' then
|
|
||||||
if vim.tbl_isempty(val) then
|
|
||||||
return vim.empty_dict()
|
|
||||||
elseif vim.islist(val) then
|
|
||||||
error(string.format('Cannot pass list to dictionary? %s', vim.inspect(val)))
|
|
||||||
else
|
|
||||||
return val
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
error(string.format('invalid dict declaration: %s', vim.inspect(val)))
|
|
||||||
end
|
|
||||||
|
|
||||||
M.to_vim_bool = function(val)
|
|
||||||
if type(val) == 'boolean' then
|
|
||||||
return val
|
|
||||||
elseif type(val) == 'number' then
|
|
||||||
return val ~= 0
|
|
||||||
elseif type(val) == 'string' then
|
|
||||||
return string.len(val) ~= 0
|
|
||||||
elseif type(val) == 'table' then
|
|
||||||
return not vim.tbl_isempty(val)
|
|
||||||
elseif val == nil then
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
|
|
||||||
error('unhandled type: ' .. vim.inspect(val))
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
vim9['fn'] = (function()
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M.insert = function(list, item, idx)
|
|
||||||
if idx == nil then
|
|
||||||
idx = 1
|
|
||||||
end
|
|
||||||
|
|
||||||
table.insert(list, idx + 1, item)
|
|
||||||
|
|
||||||
return list
|
|
||||||
end
|
|
||||||
|
|
||||||
M.extend = function(left, right, expr3)
|
|
||||||
if expr3 ~= nil then
|
|
||||||
error("haven't written this code yet")
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim.islist(right) then
|
|
||||||
vim.list_extend(left, right)
|
|
||||||
return left
|
|
||||||
else
|
|
||||||
-- local result = vim.tbl_extend(left, right)
|
|
||||||
for k, v in pairs(right) do
|
|
||||||
left[k] = v
|
|
||||||
end
|
|
||||||
|
|
||||||
return left
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M.add = function(list, item)
|
|
||||||
table.insert(list, item)
|
|
||||||
return list
|
|
||||||
end
|
|
||||||
|
|
||||||
M.has_key = function(obj, key)
|
|
||||||
return not not obj[key]
|
|
||||||
end
|
|
||||||
|
|
||||||
M.prop_type_add = function(...)
|
|
||||||
local args = { ... }
|
|
||||||
print('[prop_type_add]', vim.inspect(args))
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local has_overrides = {
|
|
||||||
-- We do have vim9script ;) that's this plugin
|
|
||||||
['vim9script'] = true,
|
|
||||||
|
|
||||||
-- Include some vim patches that are sometimes required by various vim9script plugins
|
|
||||||
-- that we implement via vim9jit
|
|
||||||
[ [[patch-8.2.2261]] ] = true,
|
|
||||||
[ [[patch-8.2.4257]] ] = true,
|
|
||||||
}
|
|
||||||
|
|
||||||
M.has = function(patch)
|
|
||||||
if has_overrides[patch] then
|
|
||||||
return true
|
|
||||||
end
|
|
||||||
|
|
||||||
return vim.fn.has(patch)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--[=[
|
|
||||||
Currently missing patch, can be removed in the future.
|
|
||||||
|
|
||||||
readdirex({directory} [, {expr} [, {dict}]]) *readdirex()*
|
|
||||||
Extended version of |readdir()|.
|
|
||||||
Return a list of Dictionaries with file and directory
|
|
||||||
information in {directory}.
|
|
||||||
This is useful if you want to get the attributes of file and
|
|
||||||
directory at the same time as getting a list of a directory.
|
|
||||||
This is much faster than calling |readdir()| then calling
|
|
||||||
|getfperm()|, |getfsize()|, |getftime()| and |getftype()| for
|
|
||||||
each file and directory especially on MS-Windows.
|
|
||||||
The list will by default be sorted by name (case sensitive),
|
|
||||||
the sorting can be changed by using the optional {dict}
|
|
||||||
argument, see |readdir()|.
|
|
||||||
|
|
||||||
The Dictionary for file and directory information has the
|
|
||||||
following items:
|
|
||||||
group Group name of the entry. (Only on Unix)
|
|
||||||
name Name of the entry.
|
|
||||||
perm Permissions of the entry. See |getfperm()|.
|
|
||||||
size Size of the entry. See |getfsize()|.
|
|
||||||
time Timestamp of the entry. See |getftime()|.
|
|
||||||
type Type of the entry.
|
|
||||||
On Unix, almost same as |getftype()| except:
|
|
||||||
Symlink to a dir "linkd"
|
|
||||||
Other symlink "link"
|
|
||||||
On MS-Windows:
|
|
||||||
Normal file "file"
|
|
||||||
Directory "dir"
|
|
||||||
Junction "junction"
|
|
||||||
Symlink to a dir "linkd"
|
|
||||||
Other symlink "link"
|
|
||||||
Other reparse point "reparse"
|
|
||||||
user User name of the entry's owner. (Only on Unix)
|
|
||||||
On Unix, if the entry is a symlink, the Dictionary includes
|
|
||||||
the information of the target (except the "type" item).
|
|
||||||
On MS-Windows, it includes the information of the symlink
|
|
||||||
itself because of performance reasons.
|
|
||||||
--]=]
|
|
||||||
M.readdirex = function(dir)
|
|
||||||
local files = vim.fn.readdir(dir)
|
|
||||||
local direx = {}
|
|
||||||
for _, f in ipairs(files) do
|
|
||||||
table.insert(direx, {
|
|
||||||
name = f,
|
|
||||||
type = vim.fn.getftype(f),
|
|
||||||
})
|
|
||||||
end
|
|
||||||
|
|
||||||
return direx
|
|
||||||
end
|
|
||||||
|
|
||||||
M.mapnew = function(tbl, expr)
|
|
||||||
return vim.fn.map(tbl, expr)
|
|
||||||
end
|
|
||||||
|
|
||||||
M.typename = function(val)
|
|
||||||
local ty = type(val)
|
|
||||||
if ty == 'string' then
|
|
||||||
return 'string'
|
|
||||||
elseif ty == 'boolean' then
|
|
||||||
return 'bool'
|
|
||||||
elseif ty == 'number' then
|
|
||||||
return 'number'
|
|
||||||
else
|
|
||||||
error(string.format('typename: %s', val))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Popup menu stuff: Could be rolled into other plugin later
|
|
||||||
-- but currently is here for testing purposes (and implements
|
|
||||||
-- some very simple compat layers at the moment)
|
|
||||||
do
|
|
||||||
local pos_map = {
|
|
||||||
topleft = 'NW',
|
|
||||||
topright = 'NE',
|
|
||||||
botleft = 'SW',
|
|
||||||
botright = 'SE',
|
|
||||||
}
|
|
||||||
|
|
||||||
M.popup_menu = function(_, options)
|
|
||||||
-- print "OPTIONS:"
|
|
||||||
|
|
||||||
local buf = vim.api.nvim_create_buf(false, true)
|
|
||||||
local win = vim.api.nvim_open_win(buf, true, {
|
|
||||||
relative = 'editor',
|
|
||||||
style = 'minimal',
|
|
||||||
anchor = pos_map[options.pos],
|
|
||||||
height = options.maxheight or options.minheight,
|
|
||||||
width = options.maxwidth or options.minwidth,
|
|
||||||
row = options.line,
|
|
||||||
col = options.col,
|
|
||||||
})
|
|
||||||
|
|
||||||
if options.filter then
|
|
||||||
local loop
|
|
||||||
loop = function()
|
|
||||||
vim.cmd([[redraw!]])
|
|
||||||
local ok, ch = pcall(vim.fn.getcharstr)
|
|
||||||
if not ok then
|
|
||||||
return
|
|
||||||
end -- interrupted
|
|
||||||
|
|
||||||
if ch == '<C-C>' then
|
|
||||||
return
|
|
||||||
end
|
|
||||||
|
|
||||||
if not require('vim9script').bool(options.filter(nil, ch)) then
|
|
||||||
vim.cmd.normal(ch)
|
|
||||||
end
|
|
||||||
|
|
||||||
vim.schedule(loop)
|
|
||||||
end
|
|
||||||
|
|
||||||
vim.schedule(loop)
|
|
||||||
end
|
|
||||||
|
|
||||||
return win
|
|
||||||
end
|
|
||||||
|
|
||||||
M.popup_settext = function(id, text)
|
|
||||||
if type(text) == 'string' then
|
|
||||||
-- text = vim.split(text, "\n")
|
|
||||||
error("Haven't handled string yet")
|
|
||||||
end
|
|
||||||
|
|
||||||
local lines = {}
|
|
||||||
for _, obj in ipairs(text) do
|
|
||||||
table.insert(lines, obj.text)
|
|
||||||
end
|
|
||||||
|
|
||||||
vim.api.nvim_buf_set_lines(vim.api.nvim_win_get_buf(id), 0, -1, false, lines)
|
|
||||||
end
|
|
||||||
|
|
||||||
M.popup_filter_menu = function()
|
|
||||||
print('ok, just pretend we filtered the menu')
|
|
||||||
end
|
|
||||||
|
|
||||||
M.popup_setoptions = function(id, _)
|
|
||||||
print('setting options...', id)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
M = setmetatable(M, {
|
|
||||||
__index = vim.fn,
|
|
||||||
})
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
vim9['heredoc'] = (function()
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M.trim = function(lines)
|
|
||||||
local min_whitespace = 9999
|
|
||||||
for _, line in ipairs(lines) do
|
|
||||||
local _, finish = string.find(line, '^%s*')
|
|
||||||
min_whitespace = math.min(min_whitespace, finish)
|
|
||||||
end
|
|
||||||
|
|
||||||
local trimmed_lines = {}
|
|
||||||
for _, line in ipairs(lines) do
|
|
||||||
table.insert(trimmed_lines, string.sub(line, min_whitespace + 1))
|
|
||||||
end
|
|
||||||
|
|
||||||
return trimmed_lines
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
vim9['import'] = (function()
|
|
||||||
local imported = {}
|
|
||||||
imported.autoload = setmetatable({}, {
|
|
||||||
__index = function(_, name)
|
|
||||||
local luaname = 'autoload/' .. string.gsub(name, '%.vim$', '.lua')
|
|
||||||
local runtime_file = vim.api.nvim_get_runtime_file(luaname, false)[1]
|
|
||||||
if not runtime_file then
|
|
||||||
error('unable to find autoload file:' .. name)
|
|
||||||
end
|
|
||||||
|
|
||||||
return imported.absolute[vim.fn.fnamemodify(runtime_file, ':p')]
|
|
||||||
end,
|
|
||||||
})
|
|
||||||
|
|
||||||
imported.absolute = setmetatable({}, {
|
|
||||||
__index = function(self, name)
|
|
||||||
if vim.uv.fs_stat(name) then
|
|
||||||
local result = loadfile(name)()
|
|
||||||
rawset(self, name, result)
|
|
||||||
|
|
||||||
return result
|
|
||||||
end
|
|
||||||
|
|
||||||
error(string.format('unabled to find absolute file: %s', name))
|
|
||||||
end,
|
|
||||||
})
|
|
||||||
|
|
||||||
return function(info)
|
|
||||||
local name = info.name
|
|
||||||
|
|
||||||
if info.autoload then
|
|
||||||
return imported.autoload[info.name]
|
|
||||||
end
|
|
||||||
|
|
||||||
local debug_info = debug.getinfo(2, 'S')
|
|
||||||
local sourcing_path = vim.fn.fnamemodify(string.sub(debug_info.source, 2), ':p')
|
|
||||||
|
|
||||||
-- Relative paths
|
|
||||||
if vim.startswith(name, '../') or vim.startswith(name, './') then
|
|
||||||
local luaname = string.gsub(name, '%.vim$', '.lua')
|
|
||||||
local directory = vim.fn.fnamemodify(sourcing_path, ':h')
|
|
||||||
local search = directory .. '/' .. luaname
|
|
||||||
return imported.absolute[search]
|
|
||||||
end
|
|
||||||
|
|
||||||
if vim.startswith(name, '/') then
|
|
||||||
error('absolute path')
|
|
||||||
-- local luaname = string.gsub(name, "%.vim", ".lua")
|
|
||||||
-- local runtime_file = vim.api.nvim_get_runtime_file(luaname, false)[1]
|
|
||||||
-- if runtime_file then
|
|
||||||
-- runtime_file = vim.fn.fnamemodify(runtime_file, ":p")
|
|
||||||
-- return loadfile(runtime_file)()
|
|
||||||
-- end
|
|
||||||
end
|
|
||||||
|
|
||||||
error('Unhandled case' .. vim.inspect(info) .. vim.inspect(debug_info))
|
|
||||||
end
|
|
||||||
end)()
|
|
||||||
vim9['ops'] = (function()
|
|
||||||
local lib = vim9
|
|
||||||
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M['And'] = function(left, right)
|
|
||||||
return lib.bool(left) and lib.bool(right)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Or'] = function(left, right)
|
|
||||||
return lib.bool(left) or lib.bool(right)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Plus'] = function(left, right)
|
|
||||||
return left + right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Multiply'] = function(left, right)
|
|
||||||
return left * right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Divide'] = function(left, right)
|
|
||||||
return left / right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['StringConcat'] = function(left, right)
|
|
||||||
return left .. right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['EqualTo'] = function(left, right)
|
|
||||||
return left == right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['NotEqualTo'] = function(left, right)
|
|
||||||
return not M['EqualTo'](left, right)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['LessThan'] = function(left, right)
|
|
||||||
return left < right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['LessThanOrEqual'] = function(left, right)
|
|
||||||
return left <= right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['GreaterThan'] = function(left, right)
|
|
||||||
return left > right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['GreaterThanOrEqual'] = function(left, right)
|
|
||||||
return left >= right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['RegexpMatches'] = function(left, right)
|
|
||||||
return not not vim.regex(right):match_str(left)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['RegexpMatchesIns'] = function(left, right)
|
|
||||||
return not not vim.regex('\\c' .. right):match_str(left)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['NotRegexpMatches'] = function(left, right)
|
|
||||||
return not M['RegexpMatches'](left, right)
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Modulo'] = function(left, right)
|
|
||||||
return left % right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Minus'] = function(left, right)
|
|
||||||
-- TODO: This is not right :)
|
|
||||||
return left - right
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
vim9['prefix'] = (function()
|
|
||||||
local lib = vim9
|
|
||||||
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
M['Minus'] = function(right)
|
|
||||||
return -right
|
|
||||||
end
|
|
||||||
|
|
||||||
M['Bang'] = function(right)
|
|
||||||
return not lib.bool(right)
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
end)()
|
|
||||||
|
|
||||||
return vim9
|
|
||||||
115
runtime/pack/dist/opt/cfilter/plugin/cfilter.lua
vendored
115
runtime/pack/dist/opt/cfilter/plugin/cfilter.lua
vendored
@@ -1,115 +0,0 @@
|
|||||||
----------------------------------------
|
|
||||||
-- This file is generated via github.com/tjdevries/vim9jit
|
|
||||||
-- For any bugs, please first consider reporting there.
|
|
||||||
----------------------------------------
|
|
||||||
|
|
||||||
-- Ignore "value assigned to a local variable is unused" because
|
|
||||||
-- we can't guarantee that local variables will be used by plugins
|
|
||||||
-- luacheck: ignore
|
|
||||||
--- @diagnostic disable
|
|
||||||
|
|
||||||
local vim9 = require('_vim9script')
|
|
||||||
local M = {}
|
|
||||||
local Qf_filter = nil
|
|
||||||
-- vim9script
|
|
||||||
|
|
||||||
-- # cfilter.vim: Plugin to filter entries from a quickfix/location list
|
|
||||||
-- # Last Change: Jun 30, 2022
|
|
||||||
-- # Maintainer: Yegappan Lakshmanan (yegappan AT yahoo DOT com)
|
|
||||||
-- # Version: 2.0
|
|
||||||
-- #
|
|
||||||
-- # Commands to filter the quickfix list:
|
|
||||||
-- # :Cfilter[!] /{pat}/
|
|
||||||
-- # Create a new quickfix list from entries matching {pat} in the current
|
|
||||||
-- # quickfix list. Both the file name and the text of the entries are
|
|
||||||
-- # matched against {pat}. If ! is supplied, then entries not matching
|
|
||||||
-- # {pat} are used. The pattern can be optionally enclosed using one of
|
|
||||||
-- # the following characters: ', ", /. If the pattern is empty, then the
|
|
||||||
-- # last used search pattern is used.
|
|
||||||
-- # :Lfilter[!] /{pat}/
|
|
||||||
-- # Same as :Cfilter but operates on the current location list.
|
|
||||||
-- #
|
|
||||||
|
|
||||||
Qf_filter = function(qf, searchpat, bang)
|
|
||||||
qf = vim9.bool(qf)
|
|
||||||
local Xgetlist = function() end
|
|
||||||
local Xsetlist = function() end
|
|
||||||
local cmd = ''
|
|
||||||
local firstchar = ''
|
|
||||||
local lastchar = ''
|
|
||||||
local pat = ''
|
|
||||||
local title = ''
|
|
||||||
local Cond = function() end
|
|
||||||
local items = {}
|
|
||||||
|
|
||||||
if vim9.bool(qf) then
|
|
||||||
Xgetlist = function(...)
|
|
||||||
return vim.fn['getqflist'](...)
|
|
||||||
end
|
|
||||||
Xsetlist = function(...)
|
|
||||||
return vim.fn['setqflist'](...)
|
|
||||||
end
|
|
||||||
cmd = ':Cfilter' .. bang
|
|
||||||
else
|
|
||||||
Xgetlist = function(...)
|
|
||||||
return vim9.fn_ref(M, 'getloclist', vim.deepcopy({ 0 }), ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
Xsetlist = function(...)
|
|
||||||
return vim9.fn_ref(M, 'setloclist', vim.deepcopy({ 0 }), ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
cmd = ':Lfilter' .. bang
|
|
||||||
end
|
|
||||||
|
|
||||||
firstchar = vim9.index(searchpat, 0)
|
|
||||||
lastchar = vim9.slice(searchpat, -1, nil)
|
|
||||||
if firstchar == lastchar and (firstchar == '/' or firstchar == '"' or firstchar == "'") then
|
|
||||||
pat = vim9.slice(searchpat, 1, -2)
|
|
||||||
if pat == '' then
|
|
||||||
-- # Use the last search pattern
|
|
||||||
pat = vim.fn.getreg('/')
|
|
||||||
end
|
|
||||||
else
|
|
||||||
pat = searchpat
|
|
||||||
end
|
|
||||||
|
|
||||||
if pat == '' then
|
|
||||||
return
|
|
||||||
end
|
|
||||||
|
|
||||||
if bang == '!' then
|
|
||||||
Cond = function(_, val)
|
|
||||||
return vim9.ops.NotRegexpMatches(val.text, pat)
|
|
||||||
and vim9.ops.NotRegexpMatches(vim9.fn.bufname(val.bufnr), pat)
|
|
||||||
end
|
|
||||||
else
|
|
||||||
Cond = function(_, val)
|
|
||||||
return vim9.ops.RegexpMatches(val.text, pat)
|
|
||||||
or vim9.ops.RegexpMatches(vim9.fn.bufname(val.bufnr), pat)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
items = vim9.fn_mut('filter', { Xgetlist(), Cond }, { replace = 0 })
|
|
||||||
title = cmd .. ' /' .. pat .. '/'
|
|
||||||
Xsetlist({}, ' ', { ['title'] = title, ['items'] = items })
|
|
||||||
end
|
|
||||||
|
|
||||||
vim.api.nvim_create_user_command('Cfilter', function(__vim9_arg_1)
|
|
||||||
Qf_filter(true, __vim9_arg_1.args, (__vim9_arg_1.bang and '!' or ''))
|
|
||||||
end, {
|
|
||||||
bang = true,
|
|
||||||
nargs = '+',
|
|
||||||
complete = nil,
|
|
||||||
})
|
|
||||||
|
|
||||||
vim.api.nvim_create_user_command('Lfilter', function(__vim9_arg_1)
|
|
||||||
Qf_filter(false, __vim9_arg_1.args, (__vim9_arg_1.bang and '!' or ''))
|
|
||||||
end, {
|
|
||||||
bang = true,
|
|
||||||
nargs = '+',
|
|
||||||
complete = nil,
|
|
||||||
})
|
|
||||||
|
|
||||||
-- # vim: shiftwidth=2 sts=2 expandtab
|
|
||||||
return M
|
|
||||||
62
runtime/pack/dist/opt/cfilter/plugin/cfilter.vim
vendored
Normal file
62
runtime/pack/dist/opt/cfilter/plugin/cfilter.vim
vendored
Normal file
@@ -0,0 +1,62 @@
|
|||||||
|
" cfilter.vim: Plugin to filter entries from a quickfix/location list
|
||||||
|
" Last Change: Aug 23, 2018
|
||||||
|
" Maintainer: Yegappan Lakshmanan (yegappan AT yahoo DOT com)
|
||||||
|
" Version: 1.1
|
||||||
|
"
|
||||||
|
" Commands to filter the quickfix list:
|
||||||
|
" :Cfilter[!] /{pat}/
|
||||||
|
" Create a new quickfix list from entries matching {pat} in the current
|
||||||
|
" quickfix list. Both the file name and the text of the entries are
|
||||||
|
" matched against {pat}. If ! is supplied, then entries not matching
|
||||||
|
" {pat} are used. The pattern can be optionally enclosed using one of
|
||||||
|
" the following characters: ', ", /. If the pattern is empty, then the
|
||||||
|
" last used search pattern is used.
|
||||||
|
" :Lfilter[!] /{pat}/
|
||||||
|
" Same as :Cfilter but operates on the current location list.
|
||||||
|
"
|
||||||
|
if exists("loaded_cfilter")
|
||||||
|
finish
|
||||||
|
endif
|
||||||
|
let loaded_cfilter = 1
|
||||||
|
|
||||||
|
func s:Qf_filter(qf, searchpat, bang)
|
||||||
|
if a:qf
|
||||||
|
let Xgetlist = function('getqflist')
|
||||||
|
let Xsetlist = function('setqflist')
|
||||||
|
let cmd = ':Cfilter' . a:bang
|
||||||
|
else
|
||||||
|
let Xgetlist = function('getloclist', [0])
|
||||||
|
let Xsetlist = function('setloclist', [0])
|
||||||
|
let cmd = ':Lfilter' . a:bang
|
||||||
|
endif
|
||||||
|
|
||||||
|
let firstchar = a:searchpat[0]
|
||||||
|
let lastchar = a:searchpat[-1:]
|
||||||
|
if firstchar == lastchar &&
|
||||||
|
\ (firstchar == '/' || firstchar == '"' || firstchar == "'")
|
||||||
|
let pat = a:searchpat[1:-2]
|
||||||
|
if pat == ''
|
||||||
|
" Use the last search pattern
|
||||||
|
let pat = @/
|
||||||
|
endif
|
||||||
|
else
|
||||||
|
let pat = a:searchpat
|
||||||
|
endif
|
||||||
|
|
||||||
|
if pat == ''
|
||||||
|
return
|
||||||
|
endif
|
||||||
|
|
||||||
|
if a:bang == '!'
|
||||||
|
let cond = 'v:val.text !~# pat && bufname(v:val.bufnr) !~# pat'
|
||||||
|
else
|
||||||
|
let cond = 'v:val.text =~# pat || bufname(v:val.bufnr) =~# pat'
|
||||||
|
endif
|
||||||
|
|
||||||
|
let items = filter(Xgetlist(), cond)
|
||||||
|
let title = cmd . ' /' . pat . '/'
|
||||||
|
call Xsetlist([], ' ', {'title' : title, 'items' : items})
|
||||||
|
endfunc
|
||||||
|
|
||||||
|
com! -nargs=+ -bang Cfilter call s:Qf_filter(1, <q-args>, <q-bang>)
|
||||||
|
com! -nargs=+ -bang Lfilter call s:Qf_filter(0, <q-args>, <q-bang>)
|
||||||
@@ -1,63 +0,0 @@
|
|||||||
local t = require('test.testutil')
|
|
||||||
local n = require('test.functional.testnvim')()
|
|
||||||
|
|
||||||
local clear = n.clear
|
|
||||||
local command = n.command
|
|
||||||
local eq = t.eq
|
|
||||||
local eval = n.eval
|
|
||||||
local feed = n.feed
|
|
||||||
local write_file = t.write_file
|
|
||||||
|
|
||||||
describe('ccomplete#Complete', function()
|
|
||||||
setup(function()
|
|
||||||
-- Realistic tags generated from neovim source tree using `ctags -R *`
|
|
||||||
write_file(
|
|
||||||
'Xtags',
|
|
||||||
[[
|
|
||||||
augroup_del src/nvim/autocmd.c /^void augroup_del(char *name, bool stupid_legacy_mode)$/;" f typeref:typename:void
|
|
||||||
augroup_exists src/nvim/autocmd.c /^bool augroup_exists(const char *name)$/;" f typeref:typename:bool
|
|
||||||
augroup_find src/nvim/autocmd.c /^int augroup_find(const char *name)$/;" f typeref:typename:int
|
|
||||||
aupat_get_buflocal_nr src/nvim/autocmd.c /^int aupat_get_buflocal_nr(char *pat, int patlen)$/;" f typeref:typename:int
|
|
||||||
aupat_is_buflocal src/nvim/autocmd.c /^bool aupat_is_buflocal(char *pat, int patlen)$/;" f typeref:typename:bool
|
|
||||||
expand_get_augroup_name src/nvim/autocmd.c /^char *expand_get_augroup_name(expand_T *xp, int idx)$/;" f typeref:typename:char *
|
|
||||||
expand_get_event_name src/nvim/autocmd.c /^char *expand_get_event_name(expand_T *xp, int idx)$/;" f typeref:typename:char *
|
|
||||||
]]
|
|
||||||
)
|
|
||||||
end)
|
|
||||||
|
|
||||||
before_each(function()
|
|
||||||
clear()
|
|
||||||
command('set tags=Xtags')
|
|
||||||
end)
|
|
||||||
|
|
||||||
teardown(function()
|
|
||||||
os.remove('Xtags')
|
|
||||||
end)
|
|
||||||
|
|
||||||
it('can complete from Xtags', function()
|
|
||||||
local completed = eval('ccomplete#Complete(0, "a")')
|
|
||||||
eq(5, #completed)
|
|
||||||
eq('augroup_del(', completed[1].word)
|
|
||||||
eq('f', completed[1].kind)
|
|
||||||
|
|
||||||
local aupat = eval('ccomplete#Complete(0, "aupat")')
|
|
||||||
eq(2, #aupat)
|
|
||||||
eq('aupat_get_buflocal_nr(', aupat[1].word)
|
|
||||||
eq('f', aupat[1].kind)
|
|
||||||
end)
|
|
||||||
|
|
||||||
it('does not error when returning no matches', function()
|
|
||||||
local completed = eval('ccomplete#Complete(0, "doesnotmatch")')
|
|
||||||
eq({}, completed)
|
|
||||||
end)
|
|
||||||
|
|
||||||
it('can find the beginning of a word for C', function()
|
|
||||||
command('set filetype=c')
|
|
||||||
feed('i int something = augroup')
|
|
||||||
local result = eval('ccomplete#Complete(1, "")')
|
|
||||||
eq(#' int something = ', result)
|
|
||||||
|
|
||||||
local completed = eval('ccomplete#Complete(0, "augroup")')
|
|
||||||
eq(3, #completed)
|
|
||||||
end)
|
|
||||||
end)
|
|
||||||
Reference in New Issue
Block a user