<h2>Editing File: /usr/share/vim/vim80/autoload/ccomplete.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim completion script
&quot; Language:	C
&quot; Maintainer:	Bram Moolenaar &lt;Bram@vim.org&gt;
&quot; Last Change:	2012 Jun 20

let s:cpo_save = &amp;cpo
set cpo&amp;vim

&quot; This function is used for the 'omnifunc' option.
function! ccomplete#Complete(findstart, base)
  if a:findstart
    &quot; Locate the start of the item, including &quot;.&quot;, &quot;-&gt;&quot; and &quot;[...]&quot;.
    let line = getline('.')
    let start = col('.') - 1
    let lastword = -1
    while start &gt; 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 &gt; 1 &amp;&amp; line[start - 2] == '-' &amp;&amp; line[start - 1] == '&gt;'
	if lastword == -1
	  let lastword = start
	endif
	let start -= 2
      elseif line[start - 1] == ']'
	&quot; Skip over [...].
	let n = 0
	let start -= 1
	while start &gt; 0
	  let start -= 1
	  if line[start] == '['
	    if n == 0
	      break
	    endif
	    let n -= 1
	  elseif line[start] == ']'  &quot; nested []
	    let n += 1
	  endif
	endwhile
      else
	break
      endif
    endwhile

    &quot; Return the column of the last word, which is going to be changed.
    &quot; 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

  &quot; Return list of matches.

  let base = s:prepended . a:base

  &quot; Don't do anything for an empty base, would result in all the tags in the
  &quot; tags file.
  if base == ''
    return []
  endif

  &quot; init cache for vimgrep to empty
  let s:grepCache = {}

  &quot; Split item in words, keep empty word after &quot;.&quot; or &quot;-&gt;&quot;.
  &quot; &quot;aa&quot; -&gt; ['aa'], &quot;aa.&quot; -&gt; ['aa', ''], &quot;aa.bb&quot; -&gt; ['aa', 'bb'], etc.
  &quot; We can't use split, because we need to skip nested [...].
  let items = []
  let s = 0
  while 1
    let e = match(base, '\.\|-&gt;\|\[', s)
    if e &lt; 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	&quot; skip over '.'
    elseif base[e] == '-'
      let s = e + 2	&quot; skip over '-&gt;'
    else
      &quot; Skip over [...].
      let n = 0
      let s = e
      let e += 1
      while e &lt; len(base)
	if base[e] == ']'
	  if n == 0
	    break
	  endif
	  let n -= 1
	elseif base[e] == '['  &quot; nested [...]
	  let n += 1
	endif
	let e += 1
      endwhile
      let e += 1
      call add(items, strpart(base, s, e - s))
      let s = e
    endif
  endwhile

  &quot; Find the variable items[0].
  &quot; 1. in current function (like with &quot;gd&quot;)
  &quot; 2. in tags file(s) (like with &quot;:tag&quot;)
  &quot; 3. in current file (like with &quot;gD&quot;)
  let res = []
  if searchdecl(items[0], 0, 1) == 0
    &quot; Found, now figure out the type.
    &quot; TODO: join previous line if it makes sense
    let line = getline('.')
    let col = col('.')
    if stridx(strpart(line, 0, col), ';') != -1
      &quot; 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
      &quot; Handle multiple declarations on the same line in a function
      &quot; 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
      &quot; Completing one word and it's a local variable: May add '[', '.' or
      &quot; '-&gt;'.
      let match = items[0]
      let kind = 'v'
      if match(line, '\&lt;' . match . '\s*\[') &gt; 0
	let match .= '['
      else
	let res = s:Nextitem(strpart(line, 0, col), [''], 0, 1)
	if len(res) &gt; 0
	  &quot; There are members, thus add &quot;.&quot; or &quot;-&gt;&quot;.
	  if match(line, '\*[ \t(]*' . match . '\&gt;') &gt; 0
	    let match .= '-&gt;'
	  else
	    let match .= '.'
	  endif
	endif
      endif
      let res = [{'match': match, 'tagline' : '', 'kind' : kind, 'info' : line}]
    else
      &quot; Completing &quot;var.&quot;, &quot;var.something&quot;, etc.
      let res = s:Nextitem(strpart(line, 0, col), items[1:], 0, 1)
    endif
  endif

  if len(items) == 1
    &quot; Only one part, no &quot;.&quot; or &quot;-&gt;&quot;: complete from tags file.
    let tags = taglist('^' . base)

    &quot; Remove members, these can't appear without something in front.
    call filter(tags, 'has_key(v:val, &quot;kind&quot;) ? v:val[&quot;kind&quot;] != &quot;m&quot; : 1')

    &quot; Remove static matches in other files.
    call filter(tags, '!has_key(v:val, &quot;static&quot;) || !v:val[&quot;static&quot;] || bufnr(&quot;%&quot;) == bufnr(v:val[&quot;filename&quot;])')

    call extend(res, map(tags, 's:Tag2item(v:val)'))
  endif

  if len(res) == 0
    &quot; Find the variable in the tags file(s)
    let diclist = taglist('^' . items[0] . '$')

    &quot; Remove members, these can't appear without something in front.
    call filter(diclist, 'has_key(v:val, &quot;kind&quot;) ? v:val[&quot;kind&quot;] != &quot;m&quot; : 1')

    let res = []
    for i in range(len(diclist))
      &quot; New ctags has the &quot;typeref&quot; field.  Patched version has &quot;typename&quot;.
      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

      &quot; For a variable use the command, which must be a search pattern that
      &quot; shows the declaration of the variable.
      if diclist[i]['kind'] == 'v'
	let line = diclist[i]['cmd']
	if line[0] == '/' &amp;&amp; line[1] == '^'
	  let col = match(line, '\&lt;' . items[0] . '\&gt;')
	  call extend(res, s:Nextitem(strpart(line, 2, col - 2), items[1:], 0, 1))
	endif
      endif
    endfor
  endif

  if len(res) == 0 &amp;&amp; searchdecl(items[0], 1) == 0
    &quot; Found, now figure out the type.
    &quot; 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

  &quot; If the last item(s) are [...] they need to be added to the matches.
  let last = len(items) - 1
  let brackets = ''
  while last &gt;= 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

function! s:GetAddition(line, match, memarg, bracket)
  &quot; Guess if the item is an array.
  if a:bracket &amp;&amp; match(a:line, a:match . '\s*\[') &gt; 0
    return '['
  endif

  &quot; Check if the item has members.
  if len(s:SearchMembers(a:memarg, [''], 0)) &gt; 0
    &quot; If there is a '*' before the name use &quot;-&gt;&quot;.
    if match(a:line, '\*[ \t(]*' . a:match . '\&gt;') &gt; 0
      return '-&gt;'
    else
      return '.'
    endif
  endif
  return ''
endfunction

&quot; Turn the tag info &quot;val&quot; into an item for completion.
&quot; &quot;val&quot; is is an item in the list returned by taglist().
&quot; If it is a variable we may add &quot;.&quot; or &quot;-&gt;&quot;.  Don't do it for other types,
&quot; such as a typedef, by not including the info that s:GetAddition() uses.
function! 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, &quot;kind&quot;)
    let kind = a:val['kind']
    let res['kind'] = kind
    if kind == 'v'
      let res['tagline'] = &quot;\t&quot; . a:val['cmd']
      let res['dict'] = a:val
    elseif kind == 'f'
      let res['match'] = a:val['name'] . '('
    endif
  endif

  return res
endfunction

&quot; Use all the items in dictionary for the &quot;info&quot; entry.
function! 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 .= &quot;\n&quot;
  endfor
  return info
endfunc

&quot; Parse a tag line and return a dictionary with items like taglist()
function! s:ParseTagline(line)
  let l = split(a:line, &quot;\t&quot;)
  let d = {}
  if len(l) &gt;= 3
    let d['name'] = l[0]
    let d['filename'] = l[1]
    let d['cmd'] = l[2]
    let n = 2
    if l[2] =~ '^/'
      &quot; Find end of cmd, it may contain Tabs.
      while n &lt; len(l) &amp;&amp; l[n] !~ '/;&quot;$'
	let n += 1
	let d['cmd'] .= &quot;  &quot; . 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
endfunction

&quot; Turn a match item &quot;val&quot; into an item for completion.
&quot; &quot;val['match']&quot; is the matching item.
&quot; &quot;val['tagline']&quot; is the tagline in which the last part was found.
function! 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')
    &quot; Use info from Tag2item().
    let res['info'] = a:val['info']
  else
    &quot; Parse the tag line and add each part to the &quot;info&quot; 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

  &quot; Isolate the command after the tag and filename.
  let s = matchstr(line, '[^\t]*\t[^\t]*\t\zs\(/^.*$/\|[^\t]*\)\ze\(;&quot;\t\|\t\|$\)')
  if s != ''
    let res['menu'] = s:Tagcmd2extra(s, a:val['match'], matchstr(line, '[^\t]*\t\zs[^\t]*\ze\t'))
  endif
  return res
endfunction

&quot; Turn a command from a tag line to something that is useful in the menu
function! s:Tagcmd2extra(cmd, name, fname)
  if a:cmd =~ '^/^'
    &quot; The command is a search command, useful to see what it is.
    let x = matchstr(a:cmd, '^/^\s*\zs.*\ze$/')
    let x = substitute(x, '\&lt;' . a:name . '\&gt;', '@@', '')
    let x = substitute(x, '\\\(.\)', '\1', 'g')
    let x = x . ' - ' . a:fname
  elseif a:cmd =~ '^\d*$'
    &quot; The command is a line number, the file name is more useful.
    let x = a:fname . ' - ' . a:cmd
  else
    &quot; Not recognized, use command and file name.
    let x = a:cmd . ' - ' . a:fname
  endif
  return x
endfunction

&quot; Find composing type in &quot;lead&quot; and match items[0] with it.
&quot; Repeat this recursively for items[1], if it's there.
&quot; When resolving typedefs &quot;depth&quot; is used to avoid infinite recursion.
&quot; Return the list of matches.
function! s:Nextitem(lead, items, depth, all)

  &quot; Use the text up to the variable name and split it in tokens.
  let tokens = split(a:lead, '\s\+\|\&lt;')

  &quot; Try to recognize the type of the variable.  This is rough guessing...
  let res = []
  for tidx in range(len(tokens))

    &quot; Skip tokens starting with a non-ID character.
    if tokens[tidx] !~ '^\h'
      continue
    endif

    &quot; Recognize &quot;struct foobar&quot; and &quot;union foobar&quot;.
    &quot; Also do &quot;class foobar&quot; when it's C++ after all (doesn't work very well
    &quot; though).
    if (tokens[tidx] == 'struct' || tokens[tidx] == 'union' || tokens[tidx] == 'class') &amp;&amp; tidx + 1 &lt; len(tokens)
      let res = s:StructMembers(tokens[tidx] . ':' . tokens[tidx + 1], a:items, a:all)
      break
    endif

    &quot; TODO: add more reserved words
    if index(['int', 'short', 'char', 'float', 'double', 'static', 'unsigned', 'extern'], tokens[tidx]) &gt;= 0
      continue
    endif

    &quot; 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]

      &quot; New ctags has the &quot;typeref&quot; field.  Patched version has &quot;typename&quot;.
      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

      &quot; Only handle typedefs here.
      if item['kind'] != 't'
	continue
      endif

      &quot; Skip matches local to another file.
      if has_key(item, 'static') &amp;&amp; item['static'] &amp;&amp; bufnr('%') != bufnr(item['filename'])
	continue
      endif

      &quot; For old ctags we recognize &quot;typedef struct aaa&quot; and
      &quot; &quot;typedef union bbb&quot; in the tags file command.
      let cmd = item['cmd']
      let ei = matchend(cmd, 'typedef\s\+')
      if ei &gt; 1
	let cmdtokens = split(strpart(cmd, ei), '\s\+\|\&lt;')
	if len(cmdtokens) &gt; 1
	  if cmdtokens[0] == 'struct' || cmdtokens[0] == 'union' || cmdtokens[0] == 'class'
	    let name = ''
	    &quot; Use the first identifier after the &quot;struct&quot; or &quot;union&quot;
	    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 &lt; 10
	    &quot; Could be &quot;typedef other_T some_T&quot;.
	    call extend(res, s:Nextitem(cmdtokens[0], a:items, a:depth + 1, a:all))
	  endif
	endif
      endif
    endfor
    if len(res) &gt; 0
      break
    endif
  endfor

  return res
endfunction


&quot; Search for members of structure &quot;typename&quot; in tags files.
&quot; Return a list with resulting matches.
&quot; Each match is a dictionary with &quot;match&quot; and &quot;tagline&quot; entries.
&quot; When &quot;all&quot; is non-zero find all, otherwise just return 1 if there is any
&quot; member.
function! s:StructMembers(typename, items, all)
  &quot; Todo: What about local structures?
  let fnames = join(map(tagfiles(), 'escape(v:val, &quot; \\#%&quot;)'))
  if fnames == ''
    return []
  endif

  let typename = a:typename
  let qflist = []
  let cached = 0
  if a:all == 0
    let n = '1'	&quot; 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' . escape(typename, '/\') . '\(\t\|$\)/j ' . fnames

      let qflist = getqflist()
      if len(qflist) &gt; 0 || match(typename, &quot;::&quot;) &lt; 0
	break
      endif
      &quot; No match for &quot;struct:context::name&quot;, remove &quot;context::&quot; and try again.
      let typename = substitute(typename, ':[^:]*::', ':', '')
    endwhile

    if a:all == 0
      &quot; Store the result to be able to use it again later.
      let s:grepCache[a:typename] = qflist
    endif
  endif

  &quot; Put matching members in matches[].
  let matches = []
  for l in qflist
    let memb = matchstr(l['text'], '[^\t]*')
    if memb =~ '^' . a:items[0]
      &quot; Skip matches local to another file.
      if match(l['text'], &quot;\tfile:&quot;) &lt; 0 || bufnr('%') == bufnr(matchstr(l['text'], '\t\zs[^\t]*'))
	let item = {'match': memb, 'tagline': l['text']}

	&quot; 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) &gt; 0
    &quot; Skip over [...] items
    let idx = 1
    while 1
      if idx &gt;= len(a:items)
	return matches		&quot; No further items, return the result.
      endif
      if a:items[idx][0] != '['
	break
      endif
      let idx += 1
    endwhile

    &quot; More items following.  For each of the possible members find the
    &quot; matching following members.
    return s:SearchMembers(matches, a:items[idx :], a:all)
  endif

  &quot; Failed to find anything.
  return []
endfunction

&quot; For matching members, find matches for following items.
&quot; When &quot;all&quot; is non-zero find all, otherwise just return 1 if there is any
&quot; member.
function! 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 = &quot;\t&quot; . a:matches[i].dict['cmd']
    else
      let line = a:matches[i]['tagline']
      let e = matchend(line, '\ttypename:')
      if e &lt; 0
	let e = matchend(line, '\ttyperef:')
      endif
      if e &gt; 0
	&quot; Use typename field
	let typename = matchstr(line, '[^\t]*', e)
      endif
    endif

    if typename != ''
      call extend(res, s:StructMembers(typename, a:items, a:all))
    else
      &quot; Use the search command (the declaration itself).
      let s = match(line, '\t\zs/^')
      if s &gt; 0
	let e = match(line, '\&lt;' . a:matches[i]['match'] . '\&gt;', s)
	if e &gt; 0
	  call extend(res, s:Nextitem(strpart(line, s, e - s), a:items, 0, a:all))
	endif
      endif
    endif
    if a:all == 0 &amp;&amp; len(res) &gt; 0
      break
    endif
  endfor
  return res
endfunc

let &amp;cpo = s:cpo_save
unlet s:cpo_save
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload'>Back to Directory</a>