| " Vim completion script |
| " Language: C |
| " Maintainer: Bram Moolenaar <Bram@vim.org> |
| " Last Change: 2005 Sep 13 |
| |
| |
| " This function is used for the 'omnifunc' option. |
| function! ccomplete#Complete(findstart, base) |
| if a:findstart |
| " Locate the start of the item, including "." and "->". |
| let line = getline('.') |
| let start = col('.') - 1 |
| while start > 0 |
| if line[start - 1] =~ '\w\|\.' |
| let start -= 1 |
| elseif start > 1 && line[start - 2] == '-' && line[start - 1] == '>' |
| let start -= 2 |
| else |
| break |
| endif |
| endwhile |
| return start |
| endif |
| |
| " Return list of matches. |
| |
| " Split item in words, keep empty word after "." or "->". |
| " "aa" -> ['aa'], "aa." -> ['aa', ''], "aa.bb" -> ['aa', 'bb'], etc. |
| let items = split(a:base, '\.\|->', 1) |
| if len(items) <= 1 |
| " Only one part, no "." or "->": complete from tags file. |
| " When local completion is wanted CTRL-N would have been used. |
| return map(taglist('^' . a:base), 'v:val["name"]') |
| endif |
| |
| " 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('.') |
| let res = s:Nextitem(strpart(line, 0, col), items[1:]) |
| endif |
| |
| if len(res) == 0 |
| " Find the variable in the tags file(s) |
| let diclist = taglist('^' . items[0] . '$') |
| |
| let res = [] |
| for i in range(len(diclist)) |
| " New ctags has the "typename" field. |
| if has_key(diclist[i], 'typename') |
| call extend(res, s:StructMembers(diclist[i]['typename'], items[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:])) |
| 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:]) |
| endif |
| |
| " If the one and only match was what's already there and it is a composite |
| " type, add a "." or "->". |
| if len(res) == 1 && res[0]['match'] == items[-1] && len(s:SearchMembers(res, [''])) > 0 |
| " If there is a '*' before the name use "->". |
| if match(res[0]['tagline'], '\*\s*' . res[0]['match']) > 0 |
| let res[0]['match'] .= '->' |
| else |
| let res[0]['match'] .= '.' |
| endif |
| endif |
| |
| " The basetext is up to the last "." or "->" and won't be changed. The |
| " matching members are concatenated to this. |
| let basetext = matchstr(a:base, '.*\(\.\|->\)') |
| return map(res, 'basetext . v:val["match"]') |
| endfunc |
| |
| " Find composing type in "lead" and match items[0] with it. |
| " Repeat this recursively for items[1], if it's there. |
| " Return the list of matches. |
| function! s:Nextitem(lead, items) |
| |
| " 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)) |
| |
| " Recognize "struct foobar" and "union foobar". |
| if (tokens[tidx] == 'struct' || tokens[tidx] == 'union') && tidx + 1 < len(tokens) |
| let res = s:StructMembers(tokens[tidx] . ':' . tokens[tidx + 1], a:items) |
| break |
| endif |
| |
| " TODO: add more reserved words |
| if index(['int', 'float', '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)) |
| " New ctags has the "typename" field. |
| if has_key(diclist[tagidx], 'typename') |
| call extend(res, s:StructMembers(diclist[tagidx]['typename'], a:items)) |
| continue |
| endif |
| |
| " Only handle typedefs here. |
| if diclist[tagidx]['kind'] != 't' |
| continue |
| endif |
| |
| " For old ctags we recognize "typedef struct aaa" and |
| " "typedef union bbb" in the tags file command. |
| let cmd = diclist[tagidx]['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' |
| 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)) |
| endif |
| else |
| " Could be "typedef other_T some_T". |
| call extend(res, s:Nextitem(cmdtokens[0], a:items)) |
| endif |
| endif |
| endif |
| endfor |
| if len(res) > 0 |
| break |
| endif |
| endfor |
| |
| return res |
| endfunction |
| |
| |
| " Return a list with resulting matches. |
| " Each match is a dictionary with "match" and "tagline" entries. |
| function! s:StructMembers(typename, items) |
| " Todo: What about local structures? |
| let fnames = join(map(tagfiles(), 'escape(v:val, " \\")')) |
| if fnames == '' |
| return [] |
| endif |
| |
| let typename = a:typename |
| let qflist = [] |
| while 1 |
| exe 'silent! 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 |
| |
| let matches = [] |
| for l in qflist |
| let memb = matchstr(l['text'], '[^\t]*') |
| if memb =~ '^' . a:items[0] |
| call add(matches, {'match': memb, 'tagline': l['text']}) |
| endif |
| endfor |
| |
| if len(matches) > 0 |
| " No further items, return the result. |
| if len(a:items) == 1 |
| return matches |
| endif |
| |
| " More items following. For each of the possible members find the |
| " matching following members. |
| return s:SearchMembers(matches, a:items[1:]) |
| endif |
| |
| " Failed to find anything. |
| return [] |
| endfunction |
| |
| " For matching members, find matches for following items. |
| function! s:SearchMembers(matches, items) |
| let res = [] |
| for i in range(len(a:matches)) |
| let line = a:matches[i]['tagline'] |
| let e = matchend(line, '\ttypename:') |
| if e > 0 |
| " Use typename field |
| let name = matchstr(line, '[^\t]*', e) |
| call extend(res, s:StructMembers(name, a:items)) |
| 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)) |
| endif |
| endif |
| endif |
| endfor |
| return res |
| endfunc |