PACKAGES/clang_complete.vmb

   1 " Vimball Archiver by Charles E. Campbell, Jr., Ph.D.
   2 UseVimball
   3 finish
   4 autoload/snippets/clang_complete.vim    [[[1
   5 96
   6 " clang_complete clang_complete's snippet generator
   7 " Author: Xavier Deguillard, Philippe Vaucher
   8
   9 function! snippets#clang_complete#init()
  10   noremap <expr> <silent> <buffer> <tab> UpdateSnips()
  11   snoremap <expr> <silent> <buffer> <tab> UpdateSnips()
  12   syntax match Conceal /<#/ conceal
  13   syntax match Conceal /#>/ conceal
  14 endfunction
  15
  16 " fullname = strcat(char *dest, const char *src)
  17 " args_pos = [ [8, 17], [20, 34] ]
  18 function! snippets#clang_complete#add_snippet(fullname, args_pos)
  19   let l:res = ''
  20   let l:prev_idx = 0
  21   for elt in a:args_pos
  22     let l:res .= a:fullname[l:prev_idx : elt[0] - 1] . '<#' . a:fullname[elt[0] : elt[1] - 1] . '#>'
  23     let l:prev_idx = elt[1]
  24   endfor
  25
  26   let l:res .= a:fullname[l:prev_idx : ]
  27
  28   return l:res
  29 endfunction
  30
  31 function! snippets#clang_complete#trigger()
  32   call s:BeginSnips()
  33 endfunction
  34
  35 function! snippets#clang_complete#reset()
  36 endfunction
  37
  38
  39 " ---------------- Helpers ----------------
  40
  41 function! UpdateSnips()
  42   let l:line = getline('.')
  43   let l:pattern = '<#[^#]*#>'
  44   if match(l:line, l:pattern) == -1
  45     return "\<c-i>"
  46   endif
  47
  48   let l:commands = ""
  49   if mode() != 'n'
  50       let l:commands .= "\<esc>"
  51   endif
  52
  53   let l:commands .= ":call MoveToCCSnippetBegin()\<CR>"
  54   let l:commands .= "m'"
  55   let l:commands .= ":call MoveToCCSnippetEnd()\<CR>"
  56
  57   if &selection == "exclusive"
  58     let l:commands .= "ll"
  59   else
  60     let l:commands .= "l"
  61   endif
  62
  63   let l:commands .= "v`'o\<C-G>"
  64
  65   return l:commands
  66 endfunction
  67
  68 function! MoveToCCSnippetBegin()
  69   let l:pattern = '<#'
  70   let l:line = getline('.')
  71   let l:startpos = col('.') + 1
  72   let l:ind = match(l:line, l:pattern, l:startpos)
  73   if l:ind == -1
  74     let l:ind = match(l:line, l:pattern, 0)
  75   endif
  76   call cursor(line('.'), l:ind + 1)
  77 endfunction
  78
  79 function! MoveToCCSnippetEnd()
  80   let l:line = getline('.')
  81   let l:pattern = '#>'
  82   let l:startpos = col('.') + 2
  83
  84   call cursor(line('.'), match(l:line, l:pattern, l:startpos) + 1)
  85 endfunction
  86
  87 function! s:BeginSnips()
  88   if pumvisible() != 0
  89     return
  90   endif
  91
  92   " Do we need to launch UpdateSnippets()?
  93   let l:line = getline('.')
  94   let l:pattern = '<#[^#]*#>'
  95   if match(l:line, l:pattern) == -1
  96     return
  97   endif
  98   call feedkeys("\<esc>^\<tab>")
  99 endfunction
 100
 101 " vim: set ts=2 sts=2 sw=2 expandtab :
 102 autoload/snippets/dummy.vim     [[[1
 103 24
 104 " Prepare the snippet engine
 105 function! snippets#dummy#init()
 106   echo 'Initializing stuffs'
 107 endfunction
 108
 109 " Add a snippet to be triggered
 110 " fullname: contain an unmangled name. ex: strcat(char *dest, const char *src)
 111 " args_pos: contain the position of the argument in fullname. ex [ [8, 17], [20, 34] ]
 112 " Returns: text to be inserted for when trigger() is called
 113 function! snippets#dummy#add_snippet(fullname, args_pos)
 114   echo 'Creating snippet for "' . a:fullname
 115   return a:fullname
 116 endfunction
 117
 118 " Trigger the snippet
 119 " Note: usually as simple as triggering the tab key
 120 function! snippets#dummy#trigger()
 121   echo 'Triggering snippet'
 122 endfunction
 123
 124 " Remove all snippets
 125 function! snippets#dummy#reset()
 126   echo 'Resetting all snippets'
 127 endfunction
 128 autoload/snippets/snipmate.vim  [[[1
 129 50
 130 " clang_complete snipmate's snippet generator
 131 " Author: Philippe Vaucher
 132
 133 function! snippets#snipmate#init()
 134   call snippets#snipmate#reset()
 135 endfunction
 136
 137 " fullname = strcat(char *dest, const char *src)
 138 " args_pos = [ [8, 17], [20, 34] ]
 139 function! snippets#snipmate#add_snippet(fullname, args_pos)
 140   " If we are already in a snipmate snippet, well not much we can do until snipmate supports nested snippets
 141   if exists('g:snipPos')
 142     return a:fullname
 143   endif
 144
 145   let l:snip = ''
 146   let l:prev_idx = 0
 147   let l:snip_idx = 1
 148   for elt in a:args_pos
 149     let l:snip .= a:fullname[l:prev_idx : elt[0] - 1] . '${' . l:snip_idx . ':' . a:fullname[elt[0] : elt[1] - 1] . '}'
 150     let l:snip_idx += 1
 151     let l:prev_idx = elt[1]
 152   endfor
 153
 154   let l:snip .= a:fullname[l:prev_idx : ] . '${' . l:snip_idx . '}'
 155
 156   let l:snippet_id = substitute(a:fullname, ' ', '_', 'g')
 157
 158   call MakeSnip(&filetype, l:snippet_id, l:snip)
 159
 160   return l:snippet_id
 161 endfunction
 162
 163 function! snippets#snipmate#trigger()
 164   " If we are already in a snipmate snippet, well not much we can do until snipmate supports nested snippets
 165   if exists('g:snipPos')
 166     return
 167   endif
 168
 169   " Trigger snipmate
 170   call feedkeys("\<Tab>", 't')
 171 endfunction
 172
 173 function! snippets#snipmate#reset()
 174   " Quick & Easy way to prevent snippets to be added twice
 175   " Ideally we should modify snipmate to be smarter about this
 176   call ReloadSnippets(&filetype)
 177 endfunction
 178
 179 " vim: set ts=2 sts=2 sw=2 expandtab :
 180 autoload/snippets/ultisnips.vim [[[1
 181 37
 182 " clang_complete ultisnips's snippet generator
 183 " Author: Philippe Vaucher
 184
 185 function! snippets#ultisnips#init()
 186   call snippets#ultisnips#reset()
 187 endfunction
 188
 189 " fullname = strcat(char *dest, const char *src)
 190 " args_pos = [ [8, 17], [20, 34] ]
 191 function! snippets#ultisnips#add_snippet(fullname, args_pos)
 192   let l:snip = ''
 193   let l:prev_idx = 0
 194   let l:snip_idx = 1
 195   for elt in a:args_pos
 196     let l:snip .= a:fullname[l:prev_idx : elt[0] - 1] . '${' . l:snip_idx . ':' . a:fullname[elt[0] : elt[1] - 1] . '}'
 197     let l:snip_idx += 1
 198     let l:prev_idx = elt[1]
 199   endfor
 200
 201   let l:snip .= a:fullname[l:prev_idx : ] . '${' . l:snip_idx . '}'
 202
 203   let l:snippet_id = substitute(a:fullname, ' ', '_', 'g')
 204
 205   call UltiSnips_AddSnippet(l:snippet_id, l:snip, a:fullname, 'i', &filetype)
 206
 207   return l:snippet_id
 208 endfunction
 209
 210 function! snippets#ultisnips#trigger()
 211   call UltiSnips_ExpandSnippet()
 212 endfunction
 213
 214 function! snippets#ultisnips#reset()
 215   python UltiSnips_Manager.reset()
 216 endfunction
 217
 218 " vim: set ts=2 sts=2 sw=2 expandtab :
 219 bin/cc_args.py  [[[1
 220 84
 221 #!/usr/bin/env python
 222 #-*- coding: utf-8 -*-
 223
 224 import os
 225 import sys
 226
 227 CONFIG_NAME = ".clang_complete"
 228
 229 def readConfiguration():
 230   try:
 231     f = open(CONFIG_NAME, "r")
 232   except IOError:
 233     return []
 234
 235   result = []
 236   for line in f.readlines():
 237     strippedLine = line.strip()
 238     if len(strippedLine) > 0:
 239       result += [strippedLine]
 240   f.close()
 241   return result
 242
 243 def writeConfiguration(lines):
 244   f = open(CONFIG_NAME, "w")
 245   f.writelines(lines)
 246   f.close()
 247
 248 def parseArguments(arguments):
 249   nextIsInclude = False
 250   nextIsDefine = False
 251   nextIsIncludeFile = False
 252
 253   includes = []
 254   defines = []
 255   include_file = []
 256
 257   for arg in arguments:
 258     if nextIsInclude:
 259       includes += [arg]
 260       nextIsInclude = False
 261     elif nextIsDefine:
 262       defines += [arg]
 263       nextIsDefine = False
 264     elif nextIsIncludeFile:
 265       include_file += [arg]
 266       nextIsIncludeFile = False
 267     elif arg == "-I":
 268       nextIsInclude = True
 269     elif arg == "-D":
 270       nextIsDefine = True
 271     elif arg[:2] == "-I":
 272       includes += [arg[2:]]
 273     elif arg[:2] == "-D":
 274       defines += [arg[2:]]
 275     elif arg == "-include":
 276       nextIsIncludeFile = True
 277
 278   result = map(lambda x: "-I" + x, includes)
 279   result += map(lambda x: "-D" + x, defines)
 280   result += map(lambda x: "-include " + x, include_file)
 281
 282   return result
 283
 284 def mergeLists(base, new):
 285   result = list(base)
 286   for newLine in new:
 287     try:
 288       result.index(newLine)
 289     except ValueError:
 290       result += [newLine]
 291   return result
 292
 293 configuration = readConfiguration()
 294 args = parseArguments(sys.argv)
 295 result = mergeLists(configuration, args)
 296 writeConfiguration(map(lambda x: x + "\n", result))
 297
 298
 299 status = os.system(" ".join(sys.argv[1:]))
 300 if not os.WIFEXITED(status):
 301   sys.exit(1)
 302 sys.exit(os.WEXITSTATUS(status))
 303
 304 # vim: set ts=2 sts=2 sw=2 expandtab :
 305 doc/clang_complete.txt  [[[1
 306 257
 307 *clang_complete.txt*    For Vim version 7.3.  Last change: 2011 Jun 04
 308
 309
 310                   clang_complete plugin documentation
 311
 312
 313 clang_complete plugin                           *clang_complete*
 314
 315 1. Description          |clang_complete-description|
 316 2. Completion kinds     |clang_complete-compl_kinds|
 317 3. Configuration        |clang_complete-configuration|
 318 4. Options              |clang_complete-options|
 319 5. Known issues         |clang_complete-issues|
 320 6. PCH                  |clang_complete-pch|
 321 7. cc_args.py script    |clang_complete-cc_args|
 322 8. To do                |clang_complete-todo|
 323 9. License              |clang_complete-license|
 324
 325 Author: Xavier Deguillard <deguilx@gmail.com>   *clang_complete-author*
 326
 327 ==============================================================================
 328 1. Description                                  *clang_complete-description*
 329
 330 This plugin use clang for accurately completing C and C++ code.
 331
 332 Note: This plugin is incompatible with omnicppcomplete due to the
 333 unconditionnaly set mapping done by omnicppcomplete. So don't forget to
 334 suppress it before using this plugin.
 335
 336 ==============================================================================
 337 2. Completion kinds                             *clang_complete-compl_kinds*
 338
 339 Because libclang provides a lot of information about completion, there are
 340 some additional kinds of completion along with standard ones (see >
 341  :help complete-items
 342 for details):
 343  '+' - constructor
 344  '~' - destructor
 345  'e' - enumerator constant
 346  'a' - parameter ('a' from "argument") of a function, method or template
 347  'u' - unknown or buildin type (int, float, ...)
 348  'n' - namespace or its alias
 349  'p' - template ('p' from "pattern")
 350
 351 ==============================================================================
 352 3. Configuration                                *clang_complete-configuration*
 353
 354 Each project can have a .clang_complete at his root, containing the compiler
 355 options. This is useful if you're using some non-standard include paths. For
 356 simplicity, please don't put relative and absolute include path on the same
 357 line. It is not currently correctly handled.
 358
 359 ==============================================================================
 360 4. Options                                      *clang_complete-options*
 361
 362                                         *clang_complete-auto_select*
 363                                         *g:clang_auto_select*
 364 If equal to 0, nothing is selected.
 365 If equal to 1, automatically select the first entry in the popup menu, but
 366 without inserting it into the code.
 367 If equal to 2, automatically select the first entry in the popup menu, and
 368 insert it into the code.
 369 Default: 0
 370
 371                                         *clang_complete-complete_auto*
 372                                         *g:clang_complete_auto*
 373 If equal to 1, automatically complete after ->, ., ::
 374 Default: 1
 375
 376                                         *clang_complete-copen*
 377                                         *g:clang_complete_copen*
 378 If equal to 1, open quickfix window on error.
 379 Default: 0
 380
 381                                         *clang_complete-hl_errors*
 382                                         *g:clang_hl_errors*
 383 If equal to 1, it will highlight the warnings and errors the same way clang
 384 does it.
 385 Default: 1
 386
 387                                         *clang_complete-periodic_quickfix*
 388                                         *g:clang_periodic_quickfix*
 389 If equal to 1, it will periodically update the quickfix window.
 390 Default: 0
 391 Note: You could use the g:ClangUpdateQuickFix() to do the same with a mapping.
 392
 393                                         *clang_complete-snippets*
 394                                         *g:clang_snippets*
 395 If equal to 1, it will do some snippets magic after a ( or a , inside function
 396 call. Not currently fully working.
 397 Default: 0
 398
 399                                         *clang_complete-snippets_engine*
 400                                         *g:clang_snippets_engine*
 401 The snippets engine (clang_complete, snipmate, ultisnips... see the snippets
 402 subdirectory).
 403 Default: "clang_complete"
 404
 405                                         *clang_complete-conceal_snippets*
 406                                         *g:clang_conceal_snippets*
 407 If equal to 1, vim will use vim 7.3 conceal feature to hide <# and #> which
 408 delimit a snippets.
 409 Default: 1 (0 if conceal not available)
 410 Note: See concealcursor and conceallevel for conceal configuration.
 411
 412                                         *clang_complete-exec*
 413                                         *g:clang_exec*
 414 Name or path of clang executable.
 415 Note: Use this if clang has a non-standard name, or isn't in the path.
 416 Default: "clang"
 417
 418                                         *clang_complete-user_options*
 419                                         *g:clang_user_options*
 420 Option added at the end of clang command. Useful if you want to filter the
 421 result, or do other stuffs. To ignore the error code returned by clang, set
 422 |g:clang_exec| to `"clang` and |g:clang_user_options| to `2>/dev/null || exit
 423 0"` if you're on *nix, or `2>NUL || exit 0"` if you are on windows.
 424 Default: ""
 425
 426                                         *clang_complete-auto_user_options*
 427                                         *g:clang_auto_user_options*
 428 Set sources for user options passed to clang. Available sources are:
 429 - path - use &path content as list of include directories (relative paths are
 430   ignored)
 431 - .clang_complete - use information from .clang_complete file Multiple options
 432   are separated by comma.
 433 Default: "path, .clang_complete"
 434
 435                                         *clang_complete-use_library*
 436                                         *g:clang_use_library*
 437 Instead of calling the clang/clang++ tool use libclang directly. This gives
 438 access to many more clang features. Furthermore it automatically caches all
 439 includes in memory. Updates after changes in the same file will therefore be a
 440 lot faster.
 441 Default: 0
 442
 443                                         *clang_complete-library_path*
 444                                         *g:clang_library_path*
 445 If libclang.[dll/so/dylib] is not in your library search path, set this to the
 446 absolute path where libclang is available.
 447 Default: ""
 448
 449                                         *clang_complete-sort_algo*
 450                                         *g:clang_sort_algo*
 451 How results are sorted (alpha, priority). Currently only works with libclang.
 452 Default: "priority"
 453
 454                                         *clang_complete-complete_macros*
 455                                         *g:clang_complete_macros*
 456 If clang should complete preprocessor macros and constants.
 457 Default: 0
 458
 459                                         *clang_complete-complete_patterns*
 460                                         *g:clang_complete_patterns*
 461 If clang should complete code patterns, i.e loop constructs etc.
 462 Defaut: 0
 463
 464 ==============================================================================
 465 5. Known issues                                 *clang_complete-issues*
 466
 467 If you find that completion is slow, please read the |clang_complete-pch|
 468 section below.
 469
 470 If you get following error message while trying to complete anything: >
 471  E121: Undefined variable: b:should_overload
 472 it means that your version of Vim is too old (this is an old bug and it has
 473 been fixed with one of patches for Vim 7.2) and you need to update it.
 474
 475 If clang is not able to compile your file, it cannot complete anything. Since
 476 clang is not supporting every C++0x features, this is normal if it can do any
 477 completion on C++0x file.
 478
 479 There is no difference in clang's output between private methods/members and
 480 public ones. Which means that I cannot filter private methods on the
 481 completion list.
 482
 483 ==============================================================================
 484 6. PCH                                          *clang_complete-pch*
 485
 486 In case you can not or you do not want to install libclang, a precompiled
 487 header file is another way to accelerate compilation, and so, to accelerate
 488 the completion. It is however more complicated to install and is still slower
 489 than the use of libclang.
 490
 491 Here is how to create the <vector> pch, on linux (OSX users may use
 492 -fnext-runtime instead of -fgnu-runtime): >
 493  clang -x c++-header /path/to/c++/vector -fno-exceptions -fgnu-runtime \
 494     -o vector.pch
 495 You just have to insert it into your .clang_complete: >
 496  echo '-include-pch /path/to/vector.pch -fgnu-runtime' >> .clang_complete
 497 <
 498 One of the major problem is that you cannot include more that one pch, the
 499 solution is to put the system headers or non changing headers into another
 500 header and then compile it to pch: >
 501  echo '#include <iostream>\n#include <vector>' > pchheader.h
 502  clang -x c++-header ./pchheader.h -fno-exceptions -fnu-runtime \
 503     -o ./pchheader.pch
 504 And then add it to the .clang_complete file.
 505
 506 ==============================================================================
 507 7. cc_args.py script                            *clang_complete-cc_args*
 508
 509 This script, installed at ~/.vim/bin/cc_args.py, could be used to generate or
 510 update the .clang_complete file. It works similar to gccsence's gccrec and
 511 simply stores -I and -D arguments passed to the compiler in the
 512 .clang_complete file.  Just add the cc_args.py script as the first argument of
 513 the compile command. You should do that every time compile options have
 514 changed.
 515
 516 Example (we need -B flag to force compiling even if project is up to date): >
 517  make CC='~/.vim/bin/cc_args.py gcc' CXX='~/.vim/bin/cc_args.py g++' -B
 518 After running this command, .clang_complete will be created or updated with
 519 new options. If you don't want to update an existing configuration file,
 520 delete it before running make.
 521
 522 ==============================================================================
 523 8. To do                                                *clang_complete-todo*
 524
 525 - Write some unit tests
 526   - clang vs libclang accuracy for complex completions
 527   - clang vs libclang timing
 528 - Explore "jump to declaration/definition" with libclang FGJ
 529 - Think about supertab (<C-X><C-U> with supertab and clang_auto_select)
 530 - Parse fix-its and do something useful with it
 531
 532 ==============================================================================
 533 9. License                                      *clang_complete-license*
 534
 535 Copyright (c) 2010, 2011, Xavier Deguillard
 536 All rights reserved.
 537
 538 Redistribution and use in source and binary forms, with or without
 539 modification, are permitted provided that the following conditions are met:
 540     * Redistributions of source code must retain the above copyright
 541       notice, this list of conditions and the following disclaimer.
 542     * Redistributions in binary form must reproduce the above copyright
 543       notice, this list of conditions and the following disclaimer in the
 544       documentation and/or other materials provided with the distribution.
 545     * Neither the name of Xavier Deguillard nor the
 546       names of its contributors may be used to endorse or promote products
 547       derived from this software without specific prior written permission.
 548
 549 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 550 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 551 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 552 DISCLAIMED. IN NO EVENT SHALL XAVIER DEGUILLARD BE LIABLE FOR ANY
 553 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 554 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 555 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 556 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 557 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 558 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 559
 560 Note: This license does not cover the files that come from the LLVM project,
 561 namely, cindex.py and __init__.py, which are covered by the LLVM license.
 562
 563  vim:tw=78:ts=8:ft=help:norl:
 564 plugin/clang/__init__.py        [[[1
 565 24
 566 #===- __init__.py - Clang Python Bindings --------------------*- python -*--===#
 567 #
 568 #                     The LLVM Compiler Infrastructure
 569 #
 570 # This file is distributed under the University of Illinois Open Source
 571 # License. See LICENSE.TXT for details.
 572 #
 573 #===------------------------------------------------------------------------===#
 574
 575 r"""
 576 Clang Library Bindings
 577 ======================
 578
 579 This package provides access to the Clang compiler and libraries.
 580
 581 The available modules are:
 582
 583   cindex
 584
 585     Bindings for the Clang indexing library.
 586 """
 587
 588 __all__ = ['cindex']
 589
 590 plugin/clang/cindex.py  [[[1
 591 1236
 592 #===- cindex.py - Python Indexing Library Bindings -----------*- python -*--===#
 593 #
 594 #                     The LLVM Compiler Infrastructure
 595 #
 596 # This file is distributed under the University of Illinois Open Source
 597 # License. See LICENSE.TXT for details.
 598 #
 599 #===------------------------------------------------------------------------===#
 600
 601 r"""
 602 Clang Indexing Library Bindings
 603 ===============================
 604
 605 This module provides an interface to the Clang indexing library. It is a
 606 low-level interface to the indexing library which attempts to match the Clang
 607 API directly while also being "pythonic". Notable differences from the C API
 608 are:
 609
 610  * string results are returned as Python strings, not CXString objects.
 611
 612  * null cursors are translated to None.
 613
 614  * access to child cursors is done via iteration, not visitation.
 615
 616 The major indexing objects are:
 617
 618   Index
 619
 620     The top-level object which manages some global library state.
 621
 622   TranslationUnit
 623
 624     High-level object encapsulating the AST for a single translation unit. These
 625     can be loaded from .ast files or parsed on the fly.
 626
 627   Cursor
 628
 629     Generic object for representing a node in the AST.
 630
 631   SourceRange, SourceLocation, and File
 632
 633     Objects representing information about the input source.
 634
 635 Most object information is exposed using properties, when the underlying API
 636 call is efficient.
 637 """
 638
 639 # TODO
 640 # ====
 641 #
 642 # o API support for invalid translation units. Currently we can't even get the
 643 #   diagnostics on failure because they refer to locations in an object that
 644 #   will have been invalidated.
 645 #
 646 # o fix memory management issues (currently client must hold on to index and
 647 #   translation unit, or risk crashes).
 648 #
 649 # o expose code completion APIs.
 650 #
 651 # o cleanup ctypes wrapping, would be nice to separate the ctypes details more
 652 #   clearly, and hide from the external interface (i.e., help(cindex)).
 653 #
 654 # o implement additional SourceLocation, SourceRange, and File methods.
 655
 656 import sys
 657 from ctypes import *
 658
 659 def get_cindex_library():
 660     # FIXME: It's probably not the case that the library is actually found in
 661     # this location. We need a better system of identifying and loading the
 662     # CIndex library. It could be on path or elsewhere, or versioned, etc.
 663     import platform
 664     name = platform.system()
 665     path = sys.argv[0]
 666     if path != '':
 667         path += '/'
 668     if name == 'Darwin':
 669         path += 'libclang.dylib'
 670     elif name == 'Windows':
 671         path += 'libclang.dll'
 672     else:
 673         path += 'libclang.so'
 674     return cdll.LoadLibrary(path)
 675
 676 # ctypes doesn't implicitly convert c_void_p to the appropriate wrapper
 677 # object. This is a problem, because it means that from_parameter will see an
 678 # integer and pass the wrong value on platforms where int != void*. Work around
 679 # this by marshalling object arguments as void**.
 680 c_object_p = POINTER(c_void_p)
 681
 682 lib = get_cindex_library()
 683
 684 ### Structures and Utility Classes ###
 685
 686 class _CXString(Structure):
 687     """Helper for transforming CXString results."""
 688
 689     _fields_ = [("spelling", c_char_p), ("free", c_int)]
 690
 691     def __del__(self):
 692         _CXString_dispose(self)
 693
 694     @staticmethod
 695     def from_result(res, fn, args):
 696         assert isinstance(res, _CXString)
 697         return _CXString_getCString(res)
 698
 699 class SourceLocation(Structure):
 700     """
 701     A SourceLocation represents a particular location within a source file.
 702     """
 703     _fields_ = [("ptr_data", c_void_p * 2), ("int_data", c_uint)]
 704     _data = None
 705
 706     def _get_instantiation(self):
 707         if self._data is None:
 708             f, l, c, o = c_object_p(), c_uint(), c_uint(), c_uint()
 709             SourceLocation_loc(self, byref(f), byref(l), byref(c), byref(o))
 710             if f:
 711                 f = File(f)
 712             else:
 713                 f = None
 714             self._data = (f, int(l.value), int(c.value), int(c.value))
 715         return self._data
 716
 717     @property
 718     def file(self):
 719         """Get the file represented by this source location."""
 720         return self._get_instantiation()[0]
 721
 722     @property
 723     def line(self):
 724         """Get the line represented by this source location."""
 725         return self._get_instantiation()[1]
 726
 727     @property
 728     def column(self):
 729         """Get the column represented by this source location."""
 730         return self._get_instantiation()[2]
 731
 732     @property
 733     def offset(self):
 734         """Get the file offset represented by this source location."""
 735         return self._get_instantiation()[3]
 736
 737     def __repr__(self):
 738         if self.file:
 739             filename = self.file.name
 740         else:
 741             filename = None
 742         return "<SourceLocation file %r, line %r, column %r>" % (
 743             filename, self.line, self.column)
 744
 745 class SourceRange(Structure):
 746     """
 747     A SourceRange describes a range of source locations within the source
 748     code.
 749     """
 750     _fields_ = [
 751         ("ptr_data", c_void_p * 2),
 752         ("begin_int_data", c_uint),
 753         ("end_int_data", c_uint)]
 754
 755     # FIXME: Eliminate this and make normal constructor? Requires hiding ctypes
 756     # object.
 757     @staticmethod
 758     def from_locations(start, end):
 759         return SourceRange_getRange(start, end)
 760
 761     @property
 762     def start(self):
 763         """
 764         Return a SourceLocation representing the first character within a
 765         source range.
 766         """
 767         return SourceRange_start(self)
 768
 769     @property
 770     def end(self):
 771         """
 772         Return a SourceLocation representing the last character within a
 773         source range.
 774         """
 775         return SourceRange_end(self)
 776
 777     def __repr__(self):
 778         return "<SourceRange start %r, end %r>" % (self.start, self.end)
 779
 780 class Diagnostic(object):
 781     """
 782     A Diagnostic is a single instance of a Clang diagnostic. It includes the
 783     diagnostic severity, the message, the location the diagnostic occurred, as
 784     well as additional source ranges and associated fix-it hints.
 785     """
 786
 787     Ignored = 0
 788     Note    = 1
 789     Warning = 2
 790     Error   = 3
 791     Fatal   = 4
 792
 793     def __init__(self, ptr):
 794         self.ptr = ptr
 795
 796     def __del__(self):
 797         _clang_disposeDiagnostic(self)
 798
 799     @property
 800     def severity(self):
 801         return _clang_getDiagnosticSeverity(self)
 802
 803     @property
 804     def location(self):
 805         return _clang_getDiagnosticLocation(self)
 806
 807     @property
 808     def spelling(self):
 809         return _clang_getDiagnosticSpelling(self)
 810
 811     @property
 812     def ranges(self):
 813         class RangeIterator:
 814             def __init__(self, diag):
 815                 self.diag = diag
 816
 817             def __len__(self):
 818                 return int(_clang_getDiagnosticNumRanges(self.diag))
 819
 820             def __getitem__(self, key):
 821                 if (key >= len(self)):
 822                     raise IndexError
 823                 return _clang_getDiagnosticRange(self.diag, key)
 824
 825         return RangeIterator(self)
 826
 827     @property
 828     def fixits(self):
 829         class FixItIterator:
 830             def __init__(self, diag):
 831                 self.diag = diag
 832
 833             def __len__(self):
 834                 return int(_clang_getDiagnosticNumFixIts(self.diag))
 835
 836             def __getitem__(self, key):
 837                 range = SourceRange()
 838                 value = _clang_getDiagnosticFixIt(self.diag, key, byref(range))
 839                 if len(value) == 0:
 840                     raise IndexError
 841
 842                 return FixIt(range, value)
 843
 844         return FixItIterator(self)
 845
 846     def __repr__(self):
 847         return "<Diagnostic severity %r, location %r, spelling %r>" % (
 848             self.severity, self.location, self.spelling)
 849
 850     def from_param(self):
 851       return self.ptr
 852
 853 class FixIt(object):
 854     """
 855     A FixIt represents a transformation to be applied to the source to
 856     "fix-it". The fix-it shouldbe applied by replacing the given source range
 857     with the given value.
 858     """
 859
 860     def __init__(self, range, value):
 861         self.range = range
 862         self.value = value
 863
 864     def __repr__(self):
 865         return "<FixIt range %r, value %r>" % (self.range, self.value)
 866
 867 ### Cursor Kinds ###
 868
 869 class CursorKind(object):
 870     """
 871     A CursorKind describes the kind of entity that a cursor points to.
 872     """
 873
 874     # The unique kind objects, indexed by id.
 875     _kinds = []
 876     _name_map = None
 877
 878     def __init__(self, value):
 879         if value >= len(CursorKind._kinds):
 880             CursorKind._kinds += [None] * (value - len(CursorKind._kinds) + 1)
 881         if CursorKind._kinds[value] is not None:
 882             raise ValueError,'CursorKind already loaded'
 883         self.value = value
 884         CursorKind._kinds[value] = self
 885         CursorKind._name_map = None
 886
 887     def from_param(self):
 888         return self.value
 889
 890     @property
 891     def name(self):
 892         """Get the enumeration name of this cursor kind."""
 893         if self._name_map is None:
 894             self._name_map = {}
 895             for key,value in CursorKind.__dict__.items():
 896                 if isinstance(value,CursorKind):
 897                     self._name_map[value] = key
 898         return self._name_map[self]
 899
 900     @staticmethod
 901     def from_id(id):
 902         if id >= len(CursorKind._kinds) or CursorKind._kinds[id] is None:
 903             raise ValueError,'Unknown cursor kind'
 904         return CursorKind._kinds[id]
 905
 906     @staticmethod
 907     def get_all_kinds():
 908         """Return all CursorKind enumeration instances."""
 909         return filter(None, CursorKind._kinds)
 910
 911     def is_declaration(self):
 912         """Test if this is a declaration kind."""
 913         return CursorKind_is_decl(self)
 914
 915     def is_reference(self):
 916         """Test if this is a reference kind."""
 917         return CursorKind_is_ref(self)
 918
 919     def is_expression(self):
 920         """Test if this is an expression kind."""
 921         return CursorKind_is_expr(self)
 922
 923     def is_statement(self):
 924         """Test if this is a statement kind."""
 925         return CursorKind_is_stmt(self)
 926
 927     def is_invalid(self):
 928         """Test if this is an invalid kind."""
 929         return CursorKind_is_inv(self)
 930
 931     def __repr__(self):
 932         return 'CursorKind.%s' % (self.name,)
 933
 934 # FIXME: Is there a nicer way to expose this enumeration? We could potentially
 935 # represent the nested structure, or even build a class hierarchy. The main
 936 # things we want for sure are (a) simple external access to kinds, (b) a place
 937 # to hang a description and name, (c) easy to keep in sync with Index.h.
 938
 939 ###
 940 # Declaration Kinds
 941
 942 # A declaration whose specific kind is not exposed via this interface.
 943 #
 944 # Unexposed declarations have the same operations as any other kind of
 945 # declaration; one can extract their location information, spelling, find their
 946 # definitions, etc. However, the specific kind of the declaration is not
 947 # reported.
 948 CursorKind.UNEXPOSED_DECL = CursorKind(1)
 949
 950 # A C or C++ struct.
 951 CursorKind.STRUCT_DECL = CursorKind(2)
 952
 953 # A C or C++ union.
 954 CursorKind.UNION_DECL = CursorKind(3)
 955
 956 # A C++ class.
 957 CursorKind.CLASS_DECL = CursorKind(4)
 958
 959 # An enumeration.
 960 CursorKind.ENUM_DECL = CursorKind(5)
 961
 962 # A field (in C) or non-static data member (in C++) in a struct, union, or C++
 963 # class.
 964 CursorKind.FIELD_DECL = CursorKind(6)
 965
 966 # An enumerator constant.
 967 CursorKind.ENUM_CONSTANT_DECL = CursorKind(7)
 968
 969 # A function.
 970 CursorKind.FUNCTION_DECL = CursorKind(8)
 971
 972 # A variable.
 973 CursorKind.VAR_DECL = CursorKind(9)
 974
 975 # A function or method parameter.
 976 CursorKind.PARM_DECL = CursorKind(10)
 977
 978 # An Objective-C @interface.
 979 CursorKind.OBJC_INTERFACE_DECL = CursorKind(11)
 980
 981 # An Objective-C @interface for a category.
 982 CursorKind.OBJC_CATEGORY_DECL = CursorKind(12)
 983
 984 # An Objective-C @protocol declaration.
 985 CursorKind.OBJC_PROTOCOL_DECL = CursorKind(13)
 986
 987 # An Objective-C @property declaration.
 988 CursorKind.OBJC_PROPERTY_DECL = CursorKind(14)
 989
 990 # An Objective-C instance variable.
 991 CursorKind.OBJC_IVAR_DECL = CursorKind(15)
 992
 993 # An Objective-C instance method.
 994 CursorKind.OBJC_INSTANCE_METHOD_DECL = CursorKind(16)
 995
 996 # An Objective-C class method.
 997 CursorKind.OBJC_CLASS_METHOD_DECL = CursorKind(17)
 998
 999 # An Objective-C @implementation.
1000 CursorKind.OBJC_IMPLEMENTATION_DECL = CursorKind(18)
1001
1002 # An Objective-C @implementation for a category.
1003 CursorKind.OBJC_CATEGORY_IMPL_DECL = CursorKind(19)
1004
1005 # A typedef.
1006 CursorKind.TYPEDEF_DECL = CursorKind(20)
1007
1008 ###
1009 # Reference Kinds
1010
1011 CursorKind.OBJC_SUPER_CLASS_REF = CursorKind(40)
1012 CursorKind.OBJC_PROTOCOL_REF = CursorKind(41)
1013 CursorKind.OBJC_CLASS_REF = CursorKind(42)
1014
1015 # A reference to a type declaration.
1016 #
1017 # A type reference occurs anywhere where a type is named but not
1018 # declared. For example, given:
1019 #   typedef unsigned size_type;
1020 #   size_type size;
1021 #
1022 # The typedef is a declaration of size_type (CXCursor_TypedefDecl),
1023 # while the type of the variable "size" is referenced. The cursor
1024 # referenced by the type of size is the typedef for size_type.
1025 CursorKind.TYPE_REF = CursorKind(43)
1026
1027 ###
1028 # Invalid/Error Kinds
1029
1030 CursorKind.INVALID_FILE = CursorKind(70)
1031 CursorKind.NO_DECL_FOUND = CursorKind(71)
1032 CursorKind.NOT_IMPLEMENTED = CursorKind(72)
1033
1034 ###
1035 # Expression Kinds
1036
1037 # An expression whose specific kind is not exposed via this interface.
1038 #
1039 # Unexposed expressions have the same operations as any other kind of
1040 # expression; one can extract their location information, spelling, children,
1041 # etc. However, the specific kind of the expression is not reported.
1042 CursorKind.UNEXPOSED_EXPR = CursorKind(100)
1043
1044 # An expression that refers to some value declaration, such as a function,
1045 # varible, or enumerator.
1046 CursorKind.DECL_REF_EXPR = CursorKind(101)
1047
1048 # An expression that refers to a member of a struct, union, class, Objective-C
1049 # class, etc.
1050 CursorKind.MEMBER_REF_EXPR = CursorKind(102)
1051
1052 # An expression that calls a function.
1053 CursorKind.CALL_EXPR = CursorKind(103)
1054
1055 # An expression that sends a message to an Objective-C object or class.
1056 CursorKind.OBJC_MESSAGE_EXPR = CursorKind(104)
1057
1058 # A statement whose specific kind is not exposed via this interface.
1059 #
1060 # Unexposed statements have the same operations as any other kind of statement;
1061 # one can extract their location information, spelling, children, etc. However,
1062 # the specific kind of the statement is not reported.
1063 CursorKind.UNEXPOSED_STMT = CursorKind(200)
1064
1065 ###
1066 # Other Kinds
1067
1068 # Cursor that represents the translation unit itself.
1069 #
1070 # The translation unit cursor exists primarily to act as the root cursor for
1071 # traversing the contents of a translation unit.
1072 CursorKind.TRANSLATION_UNIT = CursorKind(300)
1073
1074 ### Cursors ###
1075
1076 class Cursor(Structure):
1077     """
1078     The Cursor class represents a reference to an element within the AST. It
1079     acts as a kind of iterator.
1080     """
1081     _fields_ = [("_kind_id", c_int), ("data", c_void_p * 3)]
1082
1083     def __eq__(self, other):
1084         return Cursor_eq(self, other)
1085
1086     def __ne__(self, other):
1087         return not Cursor_eq(self, other)
1088
1089     def is_definition(self):
1090         """
1091         Returns true if the declaration pointed at by the cursor is also a
1092         definition of that entity.
1093         """
1094         return Cursor_is_def(self)
1095
1096     def get_definition(self):
1097         """
1098         If the cursor is a reference to a declaration or a declaration of
1099         some entity, return a cursor that points to the definition of that
1100         entity.
1101         """
1102         # TODO: Should probably check that this is either a reference or
1103         # declaration prior to issuing the lookup.
1104         return Cursor_def(self)
1105
1106     def get_usr(self):
1107         """Return the Unified Symbol Resultion (USR) for the entity referenced
1108         by the given cursor (or None).
1109
1110         A Unified Symbol Resolution (USR) is a string that identifies a
1111         particular entity (function, class, variable, etc.) within a
1112         program. USRs can be compared across translation units to determine,
1113         e.g., when references in one translation refer to an entity defined in
1114         another translation unit."""
1115         return Cursor_usr(self)
1116
1117     @property
1118     def kind(self):
1119         """Return the kind of this cursor."""
1120         return CursorKind.from_id(self._kind_id)
1121
1122     @property
1123     def spelling(self):
1124         """Return the spelling of the entity pointed at by the cursor."""
1125         if not self.kind.is_declaration():
1126             # FIXME: clang_getCursorSpelling should be fixed to not assert on
1127             # this, for consistency with clang_getCursorUSR.
1128             return None
1129         return Cursor_spelling(self)
1130
1131     @property
1132     def location(self):
1133         """
1134         Return the source location (the starting character) of the entity
1135         pointed at by the cursor.
1136         """
1137         return Cursor_loc(self)
1138
1139     @property
1140     def extent(self):
1141         """
1142         Return the source range (the range of text) occupied by the entity
1143         pointed at by the cursor.
1144         """
1145         return Cursor_extent(self)
1146
1147     def get_children(self):
1148         """Return an iterator for accessing the children of this cursor."""
1149
1150         # FIXME: Expose iteration from CIndex, PR6125.
1151         def visitor(child, parent, children):
1152             # FIXME: Document this assertion in API.
1153             # FIXME: There should just be an isNull method.
1154             assert child != Cursor_null()
1155             children.append(child)
1156             return 1 # continue
1157         children = []
1158         Cursor_visit(self, Cursor_visit_callback(visitor), children)
1159         return iter(children)
1160
1161     @staticmethod
1162     def from_result(res, fn, args):
1163         assert isinstance(res, Cursor)
1164         # FIXME: There should just be an isNull method.
1165         if res == Cursor_null():
1166             return None
1167         return res
1168
1169 ## CIndex Objects ##
1170
1171 # CIndex objects (derived from ClangObject) are essentially lightweight
1172 # wrappers attached to some underlying object, which is exposed via CIndex as
1173 # a void*.
1174
1175 class ClangObject(object):
1176     """
1177     A helper for Clang objects. This class helps act as an intermediary for
1178     the ctypes library and the Clang CIndex library.
1179     """
1180     def __init__(self, obj):
1181         assert isinstance(obj, c_object_p) and obj
1182         self.obj = self._as_parameter_ = obj
1183
1184     def from_param(self):
1185         return self._as_parameter_
1186
1187
1188 class _CXUnsavedFile(Structure):
1189     """Helper for passing unsaved file arguments."""
1190     _fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)]
1191
1192 ## Diagnostic Conversion ##
1193
1194 _clang_getNumDiagnostics = lib.clang_getNumDiagnostics
1195 _clang_getNumDiagnostics.argtypes = [c_object_p]
1196 _clang_getNumDiagnostics.restype = c_uint
1197
1198 _clang_getDiagnostic = lib.clang_getDiagnostic
1199 _clang_getDiagnostic.argtypes = [c_object_p, c_uint]
1200 _clang_getDiagnostic.restype = c_object_p
1201
1202 _clang_disposeDiagnostic = lib.clang_disposeDiagnostic
1203 _clang_disposeDiagnostic.argtypes = [Diagnostic]
1204
1205 _clang_getDiagnosticSeverity = lib.clang_getDiagnosticSeverity
1206 _clang_getDiagnosticSeverity.argtypes = [Diagnostic]
1207 _clang_getDiagnosticSeverity.restype = c_int
1208
1209 _clang_getDiagnosticLocation = lib.clang_getDiagnosticLocation
1210 _clang_getDiagnosticLocation.argtypes = [Diagnostic]
1211 _clang_getDiagnosticLocation.restype = SourceLocation
1212
1213 _clang_getDiagnosticSpelling = lib.clang_getDiagnosticSpelling
1214 _clang_getDiagnosticSpelling.argtypes = [Diagnostic]
1215 _clang_getDiagnosticSpelling.restype = _CXString
1216 _clang_getDiagnosticSpelling.errcheck = _CXString.from_result
1217
1218 _clang_getDiagnosticNumRanges = lib.clang_getDiagnosticNumRanges
1219 _clang_getDiagnosticNumRanges.argtypes = [Diagnostic]
1220 _clang_getDiagnosticNumRanges.restype = c_uint
1221
1222 _clang_getDiagnosticRange = lib.clang_getDiagnosticRange
1223 _clang_getDiagnosticRange.argtypes = [Diagnostic, c_uint]
1224 _clang_getDiagnosticRange.restype = SourceRange
1225
1226 _clang_getDiagnosticNumFixIts = lib.clang_getDiagnosticNumFixIts
1227 _clang_getDiagnosticNumFixIts.argtypes = [Diagnostic]
1228 _clang_getDiagnosticNumFixIts.restype = c_uint
1229
1230 _clang_getDiagnosticFixIt = lib.clang_getDiagnosticFixIt
1231 _clang_getDiagnosticFixIt.argtypes = [Diagnostic, c_uint, POINTER(SourceRange)]
1232 _clang_getDiagnosticFixIt.restype = _CXString
1233 _clang_getDiagnosticFixIt.errcheck = _CXString.from_result
1234
1235 ###
1236
1237 class CompletionChunk:
1238     class Kind:
1239         def __init__(self, name):
1240             self.name = name
1241
1242         def __str__(self):
1243             return self.name
1244
1245         def __repr__(self):
1246             return "<ChunkKind: %s>" % self
1247
1248     def __init__(self, completionString, key):
1249         self.cs = completionString
1250         self.key = key
1251
1252     def __repr__(self):
1253         return "{'" + self.spelling + "', " + str(self.kind) + "}"
1254
1255     @property
1256     def spelling(self):
1257         return _clang_getCompletionChunkText(self.cs, self.key).spelling
1258
1259     @property
1260     def kind(self):
1261         res = _clang_getCompletionChunkKind(self.cs, self.key)
1262         return completionChunkKindMap[res]
1263
1264     @property
1265     def string(self):
1266         res = _clang_getCompletionChunkCompletionString(self.cs, self.key)
1267
1268         if (res):
1269           return CompletionString(res)
1270         else:
1271           None
1272
1273     def isKindOptional(self):
1274       return self.kind == completionChunkKindMap[0]
1275
1276     def isKindTypedText(self):
1277       return self.kind == completionChunkKindMap[1]
1278
1279     def isKindPlaceHolder(self):
1280       return self.kind == completionChunkKindMap[3]
1281
1282     def isKindInformative(self):
1283       return self.kind == completionChunkKindMap[4]
1284
1285     def isKindResultType(self):
1286       return self.kind == completionChunkKindMap[15]
1287
1288 completionChunkKindMap = {
1289             0: CompletionChunk.Kind("Optional"),
1290             1: CompletionChunk.Kind("TypedText"),
1291             2: CompletionChunk.Kind("Text"),
1292             3: CompletionChunk.Kind("Placeholder"),
1293             4: CompletionChunk.Kind("Informative"),
1294             5: CompletionChunk.Kind("CurrentParameter"),
1295             6: CompletionChunk.Kind("LeftParen"),
1296             7: CompletionChunk.Kind("RightParen"),
1297             8: CompletionChunk.Kind("LeftBracket"),
1298             9: CompletionChunk.Kind("RightBracket"),
1299             10: CompletionChunk.Kind("LeftBrace"),
1300             11: CompletionChunk.Kind("RightBrace"),
1301             12: CompletionChunk.Kind("LeftAngle"),
1302             13: CompletionChunk.Kind("RightAngle"),
1303             14: CompletionChunk.Kind("Comma"),
1304             15: CompletionChunk.Kind("ResultType"),
1305             16: CompletionChunk.Kind("Colon"),
1306             17: CompletionChunk.Kind("SemiColon"),
1307             18: CompletionChunk.Kind("Equal"),
1308             19: CompletionChunk.Kind("HorizontalSpace"),
1309             20: CompletionChunk.Kind("VerticalSpace")}
1310
1311 class CompletionString(ClangObject):
1312     class Availability:
1313         def __init__(self, name):
1314             self.name = name
1315
1316         def __str__(self):
1317             return self.name
1318
1319         def __repr__(self):
1320             return "<Availability: %s>" % self
1321
1322     def __len__(self):
1323         return _clang_getNumCompletionChunks(self.obj)
1324
1325     def __getitem__(self, key):
1326         if len(self) <= key:
1327             raise IndexError
1328         return CompletionChunk(self.obj, key)
1329
1330     @property
1331     def priority(self):
1332         return _clang_getCompletionPriority(self.obj)
1333
1334     @property
1335     def availability(self):
1336         res = _clang_getCompletionAvailability(self.obj)
1337         return availabilityKinds[res]
1338
1339     def __repr__(self):
1340         return " | ".join([str(a) for a in self]) \
1341                + " || Priority: " + str(self.priority) \
1342                + " || Availability: " + str(self.availability)
1343
1344 availabilityKinds = {
1345             0: CompletionChunk.Kind("Available"),
1346             1: CompletionChunk.Kind("Deprecated"),
1347             2: CompletionChunk.Kind("NotAvailable")}
1348
1349 class CodeCompletionResult(Structure):
1350     _fields_ = [('cursorKind', c_int), ('completionString', c_object_p)]
1351
1352     def __repr__(self):
1353         return str(CompletionString(self.completionString))
1354
1355     @property
1356     def string(self):
1357         return CompletionString(self.completionString)
1358
1359 class CCRStructure(Structure):
1360     _fields_ = [('results', POINTER(CodeCompletionResult)),
1361                 ('numResults', c_int)]
1362
1363     def __len__(self):
1364         return self.numResults
1365
1366     def __getitem__(self, key):
1367         if len(self) <= key:
1368             raise IndexError
1369
1370         return self.results[key]
1371
1372 class CodeCompletionResults(ClangObject):
1373     def __init__(self, ptr):
1374         assert isinstance(ptr, POINTER(CCRStructure)) and ptr
1375         self.ptr = self._as_parameter_ = ptr
1376
1377     def from_param(self):
1378         return self._as_parameter_
1379
1380     def __del__(self):
1381         CodeCompletionResults_dispose(self)
1382
1383     @property
1384     def results(self):
1385         return self.ptr.contents
1386
1387     @property
1388     def diagnostics(self):
1389         class DiagnosticsItr:
1390             def __init__(self, ccr):
1391                 self.ccr= ccr
1392
1393             def __len__(self):
1394                 return int(_clang_codeCompleteGetNumDiagnostics(self.ccr))
1395
1396             def __getitem__(self, key):
1397                 return _clang_codeCompleteGetDiagnostic(self.ccr, key)
1398
1399         return DiagnosticsItr(self)
1400
1401 class TranslationUnit(ClangObject):
1402     """
1403     The TranslationUnit class represents a source code translation unit and
1404     provides read-only access to its top-level declarations.
1405     """
1406
1407     # enum CXTranslationUnit_Flags
1408     Nothing = 0x0
1409     DetailedPreprocessingRecord = 0x01
1410     Incomplete = 0x02
1411     PrecompiledPreamble = 0x04
1412     CacheCompletionResults = 0x08
1413     CXXPrecompiledPreamble = 0x10
1414     CXXChainedPCH = 0x20
1415
1416     def __init__(self, ptr):
1417         ClangObject.__init__(self, ptr)
1418
1419     def __del__(self):
1420         TranslationUnit_dispose(self)
1421
1422     @property
1423     def cursor(self):
1424         """Retrieve the cursor that represents the given translation unit."""
1425         return TranslationUnit_cursor(self)
1426
1427     @property
1428     def spelling(self):
1429         """Get the original translation unit source file name."""
1430         return TranslationUnit_spelling(self)
1431
1432     def get_includes(self):
1433         """
1434         Return an iterable sequence of FileInclusion objects that describe the
1435         sequence of inclusions in a translation unit. The first object in
1436         this sequence is always the input file. Note that this method will not
1437         recursively iterate over header files included through precompiled
1438         headers.
1439         """
1440         def visitor(fobj, lptr, depth, includes):
1441             loc = lptr.contents
1442             includes.append(FileInclusion(loc.file, File(fobj), loc, depth))
1443
1444         # Automatically adapt CIndex/ctype pointers to python objects
1445         includes = []
1446         TranslationUnit_includes(self,
1447                                  TranslationUnit_includes_callback(visitor),
1448                                  includes)
1449         return iter(includes)
1450
1451     @property
1452     def diagnostics(self):
1453         """
1454         Return an iterable (and indexable) object containing the diagnostics.
1455         """
1456         class DiagIterator:
1457             def __init__(self, tu):
1458                 self.tu = tu
1459
1460             def __len__(self):
1461                 return int(_clang_getNumDiagnostics(self.tu))
1462
1463             def __getitem__(self, key):
1464                 diag = _clang_getDiagnostic(self.tu, key)
1465                 if not diag:
1466                     raise IndexError
1467                 return Diagnostic(diag)
1468
1469         return DiagIterator(self)
1470
1471     def reparse(self, unsaved_files = [], options = Nothing):
1472         """
1473         Reparse an already parsed translation unit.
1474
1475         In-memory contents for files can be provided by passing a list of pairs
1476         as unsaved_files, the first items should be the filenames to be mapped
1477         and the second should be the contents to be substituted for the
1478         file. The contents may be passed as strings or file objects.
1479         """
1480         unsaved_files_array = 0
1481         if len(unsaved_files):
1482             unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
1483             for i,(name,value) in enumerate(unsaved_files):
1484                 if not isinstance(value, str):
1485                     # FIXME: It would be great to support an efficient version
1486                     # of this, one day.
1487                     value = value.read()
1488                     print value
1489                 if not isinstance(value, str):
1490                     raise TypeError,'Unexpected unsaved file contents.'
1491                 unsaved_files_array[i].name = name
1492                 unsaved_files_array[i].contents = value
1493                 unsaved_files_array[i].length = len(value)
1494         ptr = TranslationUnit_reparse(self, len(unsaved_files),
1495                                       unsaved_files_array,
1496                                       options)
1497     def codeComplete(self, path, line, column, unsaved_files = [], options = 0):
1498         """
1499         Code complete in this translation unit.
1500
1501         In-memory contents for files can be provided by passing a list of pairs
1502         as unsaved_files, the first items should be the filenames to be mapped
1503         and the second should be the contents to be substituted for the
1504         file. The contents may be passed as strings or file objects.
1505         """
1506         unsaved_files_array = 0
1507         if len(unsaved_files):
1508             unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
1509             for i,(name,value) in enumerate(unsaved_files):
1510                 if not isinstance(value, str):
1511                     # FIXME: It would be great to support an efficient version
1512                     # of this, one day.
1513                     value = value.read()
1514                     print value
1515                 if not isinstance(value, str):
1516                     raise TypeError,'Unexpected unsaved file contents.'
1517                 unsaved_files_array[i].name = name
1518                 unsaved_files_array[i].contents = value
1519                 unsaved_files_array[i].length = len(value)
1520         ptr = TranslationUnit_codeComplete(self, path,
1521                                            line, column,
1522                                            unsaved_files_array,
1523                                            len(unsaved_files),
1524                                            options)
1525         if ptr:
1526             return CodeCompletionResults(ptr)
1527
1528         return None
1529
1530 class Index(ClangObject):
1531     """
1532     The Index type provides the primary interface to the Clang CIndex library,
1533     primarily by providing an interface for reading and parsing translation
1534     units.
1535     """
1536
1537     @staticmethod
1538     def create(excludeDecls=False):
1539         """
1540         Create a new Index.
1541         Parameters:
1542         excludeDecls -- Exclude local declarations from translation units.
1543         """
1544         return Index(Index_create(excludeDecls, 0))
1545
1546     def __del__(self):
1547         Index_dispose(self)
1548
1549     def read(self, path):
1550         """Load the translation unit from the given AST file."""
1551         ptr = TranslationUnit_read(self, path)
1552         if ptr:
1553             return TranslationUnit(ptr)
1554         return None
1555
1556     def parse(self, path, args = [], unsaved_files = [], options = TranslationUnit.Nothing):
1557         """
1558         Load the translation unit from the given source code file by running
1559         clang and generating the AST before loading. Additional command line
1560         parameters can be passed to clang via the args parameter.
1561
1562         In-memory contents for files can be provided by passing a list of pairs
1563         to as unsaved_files, the first item should be the filenames to be mapped
1564         and the second should be the contents to be substituted for the
1565         file. The contents may be passed as strings or file objects.
1566         """
1567         arg_array = 0
1568         if len(args):
1569             arg_array = (c_char_p * len(args))(* args)
1570         unsaved_files_array = 0
1571         if len(unsaved_files):
1572             unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))()
1573             for i,(name,value) in enumerate(unsaved_files):
1574                 if not isinstance(value, str):
1575                     # FIXME: It would be great to support an efficient version
1576                     # of this, one day.
1577                     value = value.read()
1578                     print value
1579                 if not isinstance(value, str):
1580                     raise TypeError,'Unexpected unsaved file contents.'
1581                 unsaved_files_array[i].name = name
1582                 unsaved_files_array[i].contents = value
1583                 unsaved_files_array[i].length = len(value)
1584         ptr = TranslationUnit_parse(self, path, arg_array, len(args),
1585                                     unsaved_files_array, len(unsaved_files),
1586                                     options)
1587         if ptr:
1588             return TranslationUnit(ptr)
1589         return None
1590
1591 class File(ClangObject):
1592     """
1593     The File class represents a particular source file that is part of a
1594     translation unit.
1595     """
1596
1597     @property
1598     def name(self):
1599         """Return the complete file and path name of the file."""
1600         return File_name(self)
1601
1602     @property
1603     def time(self):
1604         """Return the last modification time of the file."""
1605         return File_time(self)
1606
1607 class FileInclusion(object):
1608     """
1609     The FileInclusion class represents the inclusion of one source file by
1610     another via a '#include' directive or as the input file for the translation
1611     unit. This class provides information about the included file, the including
1612     file, the location of the '#include' directive and the depth of the included
1613     file in the stack. Note that the input file has depth 0.
1614     """
1615
1616     def __init__(self, src, tgt, loc, depth):
1617         self.source = src
1618         self.include = tgt
1619         self.location = loc
1620         self.depth = depth
1621
1622     @property
1623     def is_input_file(self):
1624         """True if the included file is the input file."""
1625         return self.depth == 0
1626
1627 # Additional Functions and Types
1628
1629 # String Functions
1630 _CXString_dispose = lib.clang_disposeString
1631 _CXString_dispose.argtypes = [_CXString]
1632
1633 _CXString_getCString = lib.clang_getCString
1634 _CXString_getCString.argtypes = [_CXString]
1635 _CXString_getCString.restype = c_char_p
1636
1637 # Source Location Functions
1638 SourceLocation_loc = lib.clang_getInstantiationLocation
1639 SourceLocation_loc.argtypes = [SourceLocation, POINTER(c_object_p),
1640                                POINTER(c_uint), POINTER(c_uint),
1641                                POINTER(c_uint)]
1642
1643 # Source Range Functions
1644 SourceRange_getRange = lib.clang_getRange
1645 SourceRange_getRange.argtypes = [SourceLocation, SourceLocation]
1646 SourceRange_getRange.restype = SourceRange
1647
1648 SourceRange_start = lib.clang_getRangeStart
1649 SourceRange_start.argtypes = [SourceRange]
1650 SourceRange_start.restype = SourceLocation
1651
1652 SourceRange_end = lib.clang_getRangeEnd
1653 SourceRange_end.argtypes = [SourceRange]
1654 SourceRange_end.restype = SourceLocation
1655
1656 # CursorKind Functions
1657 CursorKind_is_decl = lib.clang_isDeclaration
1658 CursorKind_is_decl.argtypes = [CursorKind]
1659 CursorKind_is_decl.restype = bool
1660
1661 CursorKind_is_ref = lib.clang_isReference
1662 CursorKind_is_ref.argtypes = [CursorKind]
1663 CursorKind_is_ref.restype = bool
1664
1665 CursorKind_is_expr = lib.clang_isExpression
1666 CursorKind_is_expr.argtypes = [CursorKind]
1667 CursorKind_is_expr.restype = bool
1668
1669 CursorKind_is_stmt = lib.clang_isStatement
1670 CursorKind_is_stmt.argtypes = [CursorKind]
1671 CursorKind_is_stmt.restype = bool
1672
1673 CursorKind_is_inv = lib.clang_isInvalid
1674 CursorKind_is_inv.argtypes = [CursorKind]
1675 CursorKind_is_inv.restype = bool
1676
1677 # Cursor Functions
1678 # TODO: Implement this function
1679 Cursor_get = lib.clang_getCursor
1680 Cursor_get.argtypes = [TranslationUnit, SourceLocation]
1681 Cursor_get.restype = Cursor
1682
1683 Cursor_null = lib.clang_getNullCursor
1684 Cursor_null.restype = Cursor
1685
1686 Cursor_usr = lib.clang_getCursorUSR
1687 Cursor_usr.argtypes = [Cursor]
1688 Cursor_usr.restype = _CXString
1689 Cursor_usr.errcheck = _CXString.from_result
1690
1691 Cursor_is_def = lib.clang_isCursorDefinition
1692 Cursor_is_def.argtypes = [Cursor]
1693 Cursor_is_def.restype = bool
1694
1695 Cursor_def = lib.clang_getCursorDefinition
1696 Cursor_def.argtypes = [Cursor]
1697 Cursor_def.restype = Cursor
1698 Cursor_def.errcheck = Cursor.from_result
1699
1700 Cursor_eq = lib.clang_equalCursors
1701 Cursor_eq.argtypes = [Cursor, Cursor]
1702 Cursor_eq.restype = c_uint
1703
1704 Cursor_spelling = lib.clang_getCursorSpelling
1705 Cursor_spelling.argtypes = [Cursor]
1706 Cursor_spelling.restype = _CXString
1707 Cursor_spelling.errcheck = _CXString.from_result
1708
1709 Cursor_loc = lib.clang_getCursorLocation
1710 Cursor_loc.argtypes = [Cursor]
1711 Cursor_loc.restype = SourceLocation
1712
1713 Cursor_extent = lib.clang_getCursorExtent
1714 Cursor_extent.argtypes = [Cursor]
1715 Cursor_extent.restype = SourceRange
1716
1717 Cursor_ref = lib.clang_getCursorReferenced
1718 Cursor_ref.argtypes = [Cursor]
1719 Cursor_ref.restype = Cursor
1720 Cursor_ref.errcheck = Cursor.from_result
1721
1722 Cursor_visit_callback = CFUNCTYPE(c_int, Cursor, Cursor, py_object)
1723 Cursor_visit = lib.clang_visitChildren
1724 Cursor_visit.argtypes = [Cursor, Cursor_visit_callback, py_object]
1725 Cursor_visit.restype = c_uint
1726
1727 # Index Functions
1728 Index_create = lib.clang_createIndex
1729 Index_create.argtypes = [c_int, c_int]
1730 Index_create.restype = c_object_p
1731
1732 Index_dispose = lib.clang_disposeIndex
1733 Index_dispose.argtypes = [Index]
1734
1735 # Translation Unit Functions
1736 TranslationUnit_read = lib.clang_createTranslationUnit
1737 TranslationUnit_read.argtypes = [Index, c_char_p]
1738 TranslationUnit_read.restype = c_object_p
1739
1740 TranslationUnit_parse = lib.clang_parseTranslationUnit
1741 TranslationUnit_parse.argtypes = [Index, c_char_p, c_void_p,
1742                                   c_int, c_void_p, c_int, c_int]
1743 TranslationUnit_parse.restype = c_object_p
1744
1745 TranslationUnit_reparse = lib.clang_reparseTranslationUnit
1746 TranslationUnit_reparse.argtypes = [TranslationUnit, c_int, c_void_p, c_int]
1747 TranslationUnit_reparse.restype = c_int
1748
1749 TranslationUnit_codeComplete = lib.clang_codeCompleteAt
1750 TranslationUnit_codeComplete.argtypes = [TranslationUnit, c_char_p, c_int,
1751                                          c_int, c_void_p, c_int, c_int]
1752 TranslationUnit_codeComplete.restype = POINTER(CCRStructure)
1753
1754 TranslationUnit_cursor = lib.clang_getTranslationUnitCursor
1755 TranslationUnit_cursor.argtypes = [TranslationUnit]
1756 TranslationUnit_cursor.restype = Cursor
1757 TranslationUnit_cursor.errcheck = Cursor.from_result
1758
1759 TranslationUnit_spelling = lib.clang_getTranslationUnitSpelling
1760 TranslationUnit_spelling.argtypes = [TranslationUnit]
1761 TranslationUnit_spelling.restype = _CXString
1762 TranslationUnit_spelling.errcheck = _CXString.from_result
1763
1764 TranslationUnit_dispose = lib.clang_disposeTranslationUnit
1765 TranslationUnit_dispose.argtypes = [TranslationUnit]
1766
1767 TranslationUnit_includes_callback = CFUNCTYPE(None,
1768                                               c_object_p,
1769                                               POINTER(SourceLocation),
1770                                               c_uint, py_object)
1771 TranslationUnit_includes = lib.clang_getInclusions
1772 TranslationUnit_includes.argtypes = [TranslationUnit,
1773                                      TranslationUnit_includes_callback,
1774                                      py_object]
1775
1776 # File Functions
1777 File_name = lib.clang_getFileName
1778 File_name.argtypes = [File]
1779 File_name.restype = c_char_p
1780
1781 File_time = lib.clang_getFileTime
1782 File_time.argtypes = [File]
1783 File_time.restype = c_uint
1784
1785 # Code completion
1786
1787 CodeCompletionResults_dispose = lib.clang_disposeCodeCompleteResults
1788 CodeCompletionResults_dispose.argtypes = [CodeCompletionResults]
1789
1790 _clang_codeCompleteGetNumDiagnostics = lib.clang_codeCompleteGetNumDiagnostics
1791 _clang_codeCompleteGetNumDiagnostics.argtypes = [CodeCompletionResults]
1792 _clang_codeCompleteGetNumDiagnostics.restype = c_int
1793
1794 _clang_codeCompleteGetDiagnostic = lib.clang_codeCompleteGetDiagnostic
1795 _clang_codeCompleteGetDiagnostic.argtypes = [CodeCompletionResults, c_int]
1796 _clang_codeCompleteGetDiagnostic.restype = Diagnostic
1797
1798 _clang_getCompletionChunkText = lib.clang_getCompletionChunkText
1799 _clang_getCompletionChunkText.argtypes = [c_void_p, c_int]
1800 _clang_getCompletionChunkText.restype = _CXString
1801
1802 _clang_getCompletionChunkKind = lib.clang_getCompletionChunkKind
1803 _clang_getCompletionChunkKind.argtypes = [c_void_p, c_int]
1804 _clang_getCompletionChunkKind.restype = c_int
1805
1806 _clang_getCompletionChunkCompletionString = lib.clang_getCompletionChunkCompletionString
1807 _clang_getCompletionChunkCompletionString.argtypes = [c_void_p, c_int]
1808 _clang_getCompletionChunkCompletionString.restype = c_object_p
1809
1810 _clang_getNumCompletionChunks = lib.clang_getNumCompletionChunks
1811 _clang_getNumCompletionChunks.argtypes = [c_void_p]
1812 _clang_getNumCompletionChunks.restype = c_int
1813
1814 _clang_getCompletionAvailability = lib.clang_getCompletionAvailability
1815 _clang_getCompletionAvailability.argtypes = [c_void_p]
1816 _clang_getCompletionAvailability.restype = c_int
1817
1818 _clang_getCompletionPriority = lib.clang_getCompletionPriority
1819 _clang_getCompletionPriority.argtypes = [c_void_p]
1820 _clang_getCompletionPriority.restype = c_int
1821
1822
1823 ###
1824
1825 __all__ = ['Index', 'TranslationUnit', 'Cursor', 'CursorKind',
1826            'Diagnostic', 'FixIt', 'CodeCompletionResults', 'SourceRange',
1827            'SourceLocation', 'File']
1828 plugin/clang_complete.vim       [[[1
1829 668
1830 "
1831 " File: clang_complete.vim
1832 " Author: Xavier Deguillard <deguilx@gmail.com>
1833 "
1834 " Description: Use of clang to complete in C/C++.
1835 "
1836 " Help: Use :help clang_complete
1837 "
1838
1839 au FileType c,cpp,objc,objcpp call <SID>ClangCompleteInit()
1840
1841 let b:clang_parameters = ''
1842 let b:clang_user_options = ''
1843 let b:my_changedtick = 0
1844
1845 " Store plugin path, as this is available only when sourcing the file,
1846 " not during a function call.
1847 let s:plugin_path = escape(expand('<sfile>:p:h'), '\')
1848
1849 function! s:ClangCompleteInit()
1850   if !exists('g:clang_auto_select')
1851     let g:clang_auto_select = 0
1852   endif
1853
1854   if !exists('g:clang_complete_auto')
1855     let g:clang_complete_auto = 1
1856   endif
1857
1858   if !exists('g:clang_complete_copen')
1859     let g:clang_complete_copen = 0
1860   endif
1861
1862   if !exists('g:clang_hl_errors')
1863     let g:clang_hl_errors = 1
1864   endif
1865
1866   if !exists('g:clang_periodic_quickfix')
1867     let g:clang_periodic_quickfix = 0
1868   endif
1869
1870   if !exists('g:clang_snippets')
1871     let g:clang_snippets = 0
1872   endif
1873
1874   if !exists('g:clang_snippets_engine')
1875     let g:clang_snippets_engine = 'clang_complete'
1876   endif
1877
1878   if !exists('g:clang_exec')
1879     let g:clang_exec = 'clang'
1880   endif
1881
1882   if !exists('g:clang_user_options')
1883     let g:clang_user_options = ''
1884   endif
1885
1886   " Only use libclang if the user clearly show intent to do so for now
1887   if !exists('g:clang_use_library')
1888     let g:clang_use_library = (has('python') && exists('g:clang_library_path'))
1889   endif
1890
1891   if !exists('g:clang_complete_macros')
1892     let g:clang_complete_macros = 0
1893   endif
1894
1895   if !exists('g:clang_complete_patterns')
1896     let g:clang_complete_patterns = 0
1897   endif
1898
1899   if !exists('g:clang_debug')
1900     let g:clang_debug = 0
1901   endif
1902
1903   if !exists('g:clang_sort_algo')
1904     let g:clang_sort_algo = 'priority'
1905   endif
1906
1907   if !exists('g:clang_auto_user_options')
1908     let g:clang_auto_user_options = 'path, .clang_complete'
1909   endif
1910
1911   call LoadUserOptions()
1912
1913   inoremap <expr> <buffer> <C-X><C-U> <SID>LaunchCompletion()
1914   inoremap <expr> <buffer> . <SID>CompleteDot()
1915   inoremap <expr> <buffer> > <SID>CompleteArrow()
1916   inoremap <expr> <buffer> : <SID>CompleteColon()
1917   inoremap <expr> <buffer> <CR> <SID>HandlePossibleSelectionEnter()
1918
1919   if g:clang_snippets == 1
1920     call g:ClangSetSnippetEngine(g:clang_snippets_engine)
1921   endif
1922
1923   " Force menuone. Without it, when there's only one completion result,
1924   " it can be confusing (not completing and no popup)
1925   if g:clang_auto_select != 2
1926     set completeopt-=menu
1927     set completeopt+=menuone
1928   endif
1929
1930   " Disable every autocmd that could have been set.
1931   augroup ClangComplete
1932     autocmd!
1933   augroup end
1934
1935   let b:should_overload = 0
1936   let b:my_changedtick = b:changedtick
1937   let b:clang_parameters = '-x c'
1938
1939   if &filetype == 'objc'
1940     let b:clang_parameters = '-x objective-c'
1941   endif
1942
1943   if &filetype == 'cpp' || &filetype == 'objcpp'
1944     let b:clang_parameters .= '++'
1945   endif
1946
1947   if expand('%:e') =~ 'h*'
1948     let b:clang_parameters .= '-header'
1949   endif
1950
1951   let g:clang_complete_lib_flags = 0
1952
1953   if g:clang_complete_macros == 1
1954     let b:clang_parameters .= ' -code-completion-macros'
1955     let g:clang_complete_lib_flags = 1
1956   endif
1957
1958   if g:clang_complete_patterns == 1
1959     let b:clang_parameters .= ' -code-completion-patterns'
1960     let g:clang_complete_lib_flags += 2
1961   endif
1962
1963   setlocal completefunc=ClangComplete
1964   setlocal omnifunc=ClangComplete
1965
1966   if g:clang_periodic_quickfix == 1
1967     augroup ClangComplete
1968       au CursorHold,CursorHoldI <buffer> call <SID>DoPeriodicQuickFix()
1969     augroup end
1970   endif
1971
1972   " Load the python bindings of libclang
1973   if g:clang_use_library == 1
1974     if has('python')
1975       exe s:initClangCompletePython()
1976     else
1977       echoe 'clang_complete: No python support available.'
1978       echoe 'Cannot use clang library, using executable'
1979       echoe 'Compile vim with python support to use libclang'
1980       let g:clang_use_library = 0
1981       return
1982     endif
1983   endif
1984 endfunction
1985
1986 function! LoadUserOptions()
1987   let b:clang_user_options = ''
1988
1989   let l:option_sources = split(g:clang_auto_user_options, ',')
1990   let l:remove_spaces_cmd = 'substitute(v:val, "\\s*\\(.*\\)\\s*", "\\1", "")'
1991   let l:option_sources = map(l:option_sources, l:remove_spaces_cmd)
1992
1993   for l:source in l:option_sources
1994     if l:source == 'path'
1995       call s:parsePathOption()
1996     elseif l:source == '.clang_complete'
1997       call s:parseConfig()
1998     endif
1999   endfor
2000 endfunction
2001
2002 function! s:parseConfig()
2003   let l:local_conf = findfile('.clang_complete', getcwd() . ',.;')
2004   if l:local_conf == '' || !filereadable(l:local_conf)
2005     return
2006   endif
2007
2008   let l:opts = readfile(l:local_conf)
2009   for l:opt in l:opts
2010     " Better handling of absolute path
2011     " I don't know if those pattern will work on windows
2012     " platform
2013     if matchstr(l:opt, '\C-I\s*/') != ''
2014       let l:opt = substitute(l:opt, '\C-I\s*\(/\%(\w\|\\\s\)*\)',
2015             \ '-I' . '\1', 'g')
2016     else
2017       let l:opt = substitute(l:opt, '\C-I\s*\(\%(\w\|\\\s\)*\)',
2018             \ '-I' . l:local_conf[:-16] . '\1', 'g')
2019     endif
2020     let b:clang_user_options .= ' ' . l:opt
2021   endfor
2022 endfunction
2023
2024 function! s:parsePathOption()
2025   let l:dirs = split(&path, ',')
2026   for l:dir in l:dirs
2027     if len(l:dir) == 0 || !isdirectory(l:dir)
2028       continue
2029     endif
2030
2031     " Add only absolute paths
2032     if matchstr(l:dir, '\s*/') != ''
2033       let l:opt = '-I' . l:dir
2034       let b:clang_user_options .= ' ' . l:opt
2035     endif
2036   endfor
2037 endfunction
2038
2039 function! s:initClangCompletePython()
2040   " Only parse the python library once
2041   if !exists('s:libclang_loaded')
2042     python import sys
2043     if exists('g:clang_library_path')
2044       " Load the library from the given library path.
2045       exe 'python sys.argv = ["' . escape(g:clang_library_path, '\') . '"]'
2046     else
2047       " By setting argv[0] to '' force the python bindings to load the library
2048       " from the normal system search path.
2049       python sys.argv[0] = ''
2050     endif
2051
2052     exe 'python sys.path = ["' . s:plugin_path . '"] + sys.path'
2053     exe 'pyfile ' . s:plugin_path . '/libclang.py'
2054     python initClangComplete(vim.eval('g:clang_complete_lib_flags'))
2055     let s:libclang_loaded = 1
2056   endif
2057   python WarmupCache()
2058 endfunction
2059
2060 function! s:GetKind(proto)
2061   if a:proto == ''
2062     return 't'
2063   endif
2064   let l:ret = match(a:proto, '^\[#')
2065   let l:params = match(a:proto, '(')
2066   if l:ret == -1 && l:params == -1
2067     return 't'
2068   endif
2069   if l:ret != -1 && l:params == -1
2070     return 'v'
2071   endif
2072   if l:params != -1
2073     return 'f'
2074   endif
2075   return 'm'
2076 endfunction
2077
2078 function! s:CallClangBinaryForDiagnostics(tempfile)
2079   let l:escaped_tempfile = shellescape(a:tempfile)
2080   let l:buf = getline(1, '$')
2081   try
2082     call writefile(l:buf, a:tempfile)
2083   catch /^Vim\%((\a\+)\)\=:E482/
2084     return
2085   endtry
2086
2087   let l:command = g:clang_exec . ' -cc1 -fsyntax-only'
2088         \ . ' -fno-caret-diagnostics -fdiagnostics-print-source-range-info'
2089         \ . ' ' . l:escaped_tempfile
2090         \ . ' ' . b:clang_parameters . ' ' . b:clang_user_options . ' ' . g:clang_user_options
2091
2092   let l:clang_output = split(system(l:command), "\n")
2093   call delete(a:tempfile)
2094   return l:clang_output
2095 endfunction
2096
2097 function! s:CallClangForDiagnostics(tempfile)
2098   if g:clang_use_library == 1
2099     python updateCurrentDiagnostics()
2100   else
2101     return s:CallClangBinaryForDiagnostics(a:tempfile)
2102   endif
2103 endfunction
2104
2105 function! s:DoPeriodicQuickFix()
2106   " Don't do any superfluous reparsing.
2107   if b:my_changedtick == b:changedtick
2108     return
2109   endif
2110   let b:my_changedtick = b:changedtick
2111
2112   " Create tempfile name for clang/clang++ executable mode
2113   let b:my_changedtick = b:changedtick
2114   let l:tempfile = expand('%:p:h') . '/' . localtime() . expand('%:t')
2115
2116   let l:clang_output = s:CallClangForDiagnostics(l:tempfile)
2117
2118   call s:ClangQuickFix(l:clang_output, l:tempfile)
2119 endfunction
2120
2121 function! s:ClangQuickFix(clang_output, tempfname)
2122   " Clear the bad spell, the user may have corrected them.
2123   syntax clear SpellBad
2124   syntax clear SpellLocal
2125
2126   if g:clang_use_library == 0
2127     let l:list = s:ClangUpdateQuickFix(a:clang_output, a:tempfname)
2128   else
2129     python vim.command('let l:list = ' + str(getCurrentQuickFixList()))
2130     python highlightCurrentDiagnostics()
2131   endif
2132
2133   if g:clang_complete_copen == 1
2134     " We should get back to the original buffer
2135     let l:bufnr = bufnr('%')
2136
2137     " Workaround:
2138     " http://vim.1045645.n5.nabble.com/setqflist-inconsistency-td1211423.html
2139     if l:list == []
2140       cclose
2141     else
2142       copen
2143     endif
2144
2145     let l:winbufnr = bufwinnr(l:bufnr)
2146     exe l:winbufnr . 'wincmd w'
2147   endif
2148   call setqflist(l:list)
2149   silent doautocmd QuickFixCmdPost make
2150 endfunction
2151
2152 function! s:ClangUpdateQuickFix(clang_output, tempfname)
2153   let l:list = []
2154   for l:line in a:clang_output
2155     let l:erridx = match(l:line, '\%(error\|warning\|note\): ')
2156     if l:erridx == -1
2157       " Error are always at the beginning.
2158       if l:line[:11] == 'COMPLETION: ' || l:line[:9] == 'OVERLOAD: '
2159         break
2160       endif
2161       continue
2162     endif
2163     let l:pattern = '^\(.*\):\(\d*\):\(\d*\):\(\%({\d\+:\d\+-\d\+:\d\+}\)*\)'
2164     let l:tmp = matchstr(l:line, l:pattern)
2165     let l:fname = substitute(l:tmp, l:pattern, '\1', '')
2166     if l:fname == a:tempfname
2167       let l:fname = '%'
2168     endif
2169     let l:bufnr = bufnr(l:fname, 1)
2170     let l:lnum = substitute(l:tmp, l:pattern, '\2', '')
2171     let l:col = substitute(l:tmp, l:pattern, '\3', '')
2172     let l:errors = substitute(l:tmp, l:pattern, '\4', '')
2173     if l:line[l:erridx] == 'e'
2174       let l:text = l:line[l:erridx + 7:]
2175       let l:type = 'E'
2176       let l:hlgroup = ' SpellBad '
2177     elseif l:line[l:erridx] == 'w'
2178       let l:text = l:line[l:erridx + 9:]
2179       let l:type = 'W'
2180       let l:hlgroup = ' SpellLocal '
2181     else
2182       let l:text = l:line[l:erridx + 6:]
2183       let l:type = 'I'
2184       let l:hlgroup = ' '
2185     endif
2186     let l:item = {
2187           \ 'bufnr': l:bufnr,
2188           \ 'lnum': l:lnum,
2189           \ 'col': l:col,
2190           \ 'text': l:text,
2191           \ 'type': l:type }
2192     let l:list = add(l:list, l:item)
2193
2194     if g:clang_hl_errors == 0 || l:fname != '%' || l:type == 'I'
2195       continue
2196     endif
2197
2198     " Highlighting the ^
2199     let l:pat = '/\%' . l:lnum . 'l' . '\%' . l:col . 'c./'
2200     exe 'syntax match' . l:hlgroup . l:pat
2201
2202     if l:errors == ''
2203       continue
2204     endif
2205     let l:ranges = split(l:errors, '}')
2206     for l:range in l:ranges
2207       " Doing precise error and warning handling.
2208       " The highlight will be the same as clang's carets.
2209       let l:pattern = '{\%(\d\+\):\(\d\+\)-\%(\d\+\):\(\d\+\)'
2210       let l:tmp = matchstr(l:range, l:pattern)
2211       let l:startcol = substitute(l:tmp, l:pattern, '\1', '')
2212       let l:endcol = substitute(l:tmp, l:pattern, '\2', '')
2213       " Highlighting the ~~~~
2214       let l:pat = '/\%' . l:lnum . 'l'
2215             \ . '\%' . l:startcol . 'c'
2216             \ . '.*'
2217             \ . '\%' . l:endcol . 'c/'
2218       exe 'syntax match' . l:hlgroup . l:pat
2219     endfor
2220   endfor
2221   return l:list
2222 endfunction
2223
2224 function! s:DemangleProto(prototype)
2225   let l:proto = substitute(a:prototype, '\[#[^#]*#\]', '', 'g')
2226   let l:proto = substitute(l:proto, '{#.*#}', '', 'g')
2227   return l:proto
2228 endfunction
2229
2230 let b:col = 0
2231
2232 function! s:ClangCompleteBinary(base)
2233   let l:buf = getline(1, '$')
2234   let l:tempfile = expand('%:p:h') . '/' . localtime() . expand('%:t')
2235   try
2236     call writefile(l:buf, l:tempfile)
2237   catch /^Vim\%((\a\+)\)\=:E482/
2238     return {}
2239   endtry
2240   let l:escaped_tempfile = shellescape(l:tempfile)
2241
2242   let l:command = g:clang_exec . ' -cc1 -fsyntax-only'
2243         \ . ' -fno-caret-diagnostics -fdiagnostics-print-source-range-info'
2244         \ . ' -code-completion-at=' . l:escaped_tempfile . ':'
2245         \ . line('.') . ':' . b:col . ' ' . l:escaped_tempfile
2246         \ . ' ' . b:clang_parameters . ' ' . b:clang_user_options . ' ' . g:clang_user_options
2247   let l:clang_output = split(system(l:command), "\n")
2248   call delete(l:tempfile)
2249
2250   call s:ClangQuickFix(l:clang_output, l:tempfile)
2251   if v:shell_error
2252     return []
2253   endif
2254   if l:clang_output == []
2255     return []
2256   endif
2257
2258   let l:filter_str = "v:val =~ '^COMPLETION: " . a:base . "\\|^OVERLOAD: '"
2259   call filter(l:clang_output, l:filter_str)
2260
2261   let l:res = []
2262   for l:line in l:clang_output
2263
2264     if l:line[:11] == 'COMPLETION: ' && b:should_overload != 1
2265
2266       let l:value = l:line[12:]
2267
2268       let l:colonidx = stridx(l:value, ' : ')
2269       if l:colonidx == -1
2270         let l:wabbr = s:DemangleProto(l:value)
2271         let l:word = l:value
2272         let l:proto = l:value
2273       else
2274         let l:word = l:value[:l:colonidx - 1]
2275         " WTF is that?
2276         if l:word =~ '(Hidden)'
2277           let l:word = l:word[:-10]
2278         endif
2279         let l:wabbr = l:word
2280         let l:proto = l:value[l:colonidx + 3:]
2281       endif
2282
2283       let l:kind = s:GetKind(l:proto)
2284       if l:kind == 't' && b:clang_complete_type == 0
2285         continue
2286       endif
2287
2288       let l:word = l:wabbr
2289
2290       let l:proto = s:DemangleProto(l:proto)
2291
2292     elseif l:line[:9] == 'OVERLOAD: ' && b:should_overload == 1
2293
2294       let l:value = l:line[10:]
2295       if match(l:value, '<#') == -1
2296         continue
2297       endif
2298       let l:word = substitute(l:value, '.*<#', '<#', 'g')
2299       let l:word = substitute(l:word, '#>.*', '#>', 'g')
2300       let l:wabbr = substitute(l:word, '<#\([^#]*\)#>', '\1', 'g')
2301       let l:proto = l:value
2302       let l:proto = s:DemangleProto(l:value)
2303       let l:kind = ''
2304     else
2305       continue
2306     endif
2307
2308     let l:args_pos = []
2309     if g:clang_snippets == 1
2310       let l:startidx = match(l:proto, '<#')
2311       while l:startidx != -1
2312         let l:proto = substitute(l:proto, '<#', '', '')
2313         let l:endidx = match(l:proto, '#>')
2314         let l:proto = substitute(l:proto, '#>', '', '')
2315         let l:args_pos += [[ l:startidx, l:endidx ]]
2316         let l:startidx = match(l:proto, '<#')
2317       endwhile
2318     endif
2319
2320     let l:item = {
2321           \ 'word': l:word,
2322           \ 'abbr': l:wabbr,
2323           \ 'menu': l:proto,
2324           \ 'info': l:proto,
2325           \ 'dup': 0,
2326           \ 'kind': l:kind,
2327           \ 'args_pos': l:args_pos }
2328
2329     call add(l:res, l:item)
2330   endfor
2331   return l:res
2332 endfunction
2333
2334 function! ClangComplete(findstart, base)
2335   if a:findstart
2336     let l:line = getline('.')
2337     let l:start = col('.') - 1
2338     let b:clang_complete_type = 1
2339     let l:wsstart = l:start
2340     if l:line[l:wsstart - 1] =~ '\s'
2341       while l:wsstart > 0 && l:line[l:wsstart - 1] =~ '\s'
2342         let l:wsstart -= 1
2343       endwhile
2344     endif
2345     if l:line[l:wsstart - 1] =~ '[(,]'
2346       let b:should_overload = 1
2347       let b:col = l:wsstart + 1
2348       return l:wsstart
2349     endif
2350     let b:should_overload = 0
2351     while l:start > 0 && l:line[l:start - 1] =~ '\i'
2352       let l:start -= 1
2353     endwhile
2354     if l:line[l:start - 2:] =~ '->' || l:line[l:start - 1] == '.'
2355       let b:clang_complete_type = 0
2356     endif
2357     let b:col = l:start + 1
2358     return l:start
2359   else
2360     if g:clang_debug == 1
2361       let l:time_start = reltime()
2362     endif
2363
2364     if g:clang_snippets == 1
2365       call b:ResetSnip()
2366     endif
2367
2368     if g:clang_use_library == 1
2369       python vim.command('let l:res = ' + str(getCurrentCompletions(vim.eval('a:base'))))
2370     else
2371       let l:res = s:ClangCompleteBinary(a:base)
2372     endif
2373
2374     for item in l:res
2375       if g:clang_snippets == 1
2376         let item['word'] = b:AddSnip(item['info'], item['args_pos'])
2377       else
2378         let item['word'] = item['abbr']
2379       endif
2380     endfor
2381     if g:clang_snippets == 1
2382       inoremap <expr> <buffer> <C-Y> <SID>HandlePossibleSelectionCtrlY()
2383       augroup ClangComplete
2384         au CursorMovedI <buffer> call <SID>TriggerSnippet()
2385       augroup end
2386       let b:snippet_chosen = 0
2387     endif
2388
2389   if g:clang_debug == 1
2390     echom 'clang_complete: completion time (' . (g:clang_use_library == 1 ? 'library' : 'binary') . ') '. split(reltimestr(reltime(l:time_start)))[0]
2391   endif
2392   return l:res
2393 endif
2394 endfunction
2395
2396 function! s:HandlePossibleSelectionEnter()
2397   if pumvisible()
2398     let b:snippet_chosen = 1
2399     return "\<C-Y>"
2400   end
2401   return "\<CR>"
2402 endfunction
2403
2404 function! s:HandlePossibleSelectionCtrlY()
2405   if pumvisible()
2406     let b:snippet_chosen = 1
2407   end
2408   return "\<C-Y>"
2409 endfunction
2410
2411 function! s:TriggerSnippet()
2412   " Dont bother doing anything until we're sure the user exited the menu
2413   if !b:snippet_chosen
2414     return
2415   endif
2416
2417   " Stop monitoring as we'll trigger a snippet
2418   silent! iunmap <buffer> <C-Y>
2419   augroup ClangComplete
2420     au! CursorMovedI <buffer>
2421   augroup end
2422
2423   " Trigger the snippet
2424   call b:TriggerSnip()
2425 endfunction
2426
2427 function! s:ShouldComplete()
2428   if (getline('.') =~ '#\s*\(include\|import\)')
2429     return 0
2430   else
2431     if col('.') == 1
2432       return 1
2433     endif
2434     for l:id in synstack(line('.'), col('.') - 1)
2435       if match(synIDattr(l:id, 'name'), '\CComment\|String\|Number')
2436             \ != -1
2437         return 0
2438       endif
2439     endfor
2440     return 1
2441   endif
2442 endfunction
2443
2444 function! s:LaunchCompletion()
2445   let l:result = ""
2446   if s:ShouldComplete()
2447     let l:result = "\<C-X>\<C-U>"
2448     if g:clang_auto_select != 2
2449       let l:result .= "\<C-P>"
2450     endif
2451     if g:clang_auto_select == 1
2452       let l:result .= "\<C-R>=(pumvisible() ? \"\\<Down>\" : '')\<CR>"
2453     endif
2454   endif
2455   return l:result
2456 endfunction
2457
2458 function! s:CompleteDot()
2459   if g:clang_complete_auto == 1
2460     return '.' . s:LaunchCompletion()
2461   endif
2462   return '.'
2463 endfunction
2464
2465 function! s:CompleteArrow()
2466   if g:clang_complete_auto != 1 || getline('.')[col('.') - 2] != '-'
2467     return '>'
2468   endif
2469   return '>' . s:LaunchCompletion()
2470 endfunction
2471
2472 function! s:CompleteColon()
2473   if g:clang_complete_auto != 1 || getline('.')[col('.') - 2] != ':'
2474     return ':'
2475   endif
2476   return ':' . s:LaunchCompletion()
2477 endfunction
2478
2479 " May be used in a mapping to update the quickfix window.
2480 function! g:ClangUpdateQuickFix()
2481   call s:DoPeriodicQuickFix()
2482   return ''
2483 endfunction
2484
2485 function! g:ClangSetSnippetEngine(engine_name)
2486   try
2487     call eval('snippets#' . a:engine_name . '#init()')
2488     let b:AddSnip = function('snippets#' . a:engine_name . '#add_snippet')
2489     let b:ResetSnip = function('snippets#' . a:engine_name . '#reset')
2490     let b:TriggerSnip = function('snippets#' . a:engine_name . '#trigger')
2491   catch /^Vim\%((\a\+)\)\=:E117/
2492     echoe 'Snippets engine ' . a:engine_name . ' not found.'
2493     let g:clang_snippets = 0
2494   endtry
2495 endfunction
2496
2497 " vim: set ts=2 sts=2 sw=2 expandtab :
2498 plugin/libclang.py      [[[1
2499 381
2500 from clang.cindex import *
2501 import vim
2502 import time
2503 import re
2504 import threading
2505
2506 def initClangComplete(clang_complete_flags):
2507   global index
2508   index = Index.create()
2509   global translationUnits
2510   translationUnits = dict()
2511   global complete_flags
2512   complete_flags = int(clang_complete_flags)
2513
2514 # Get a tuple (fileName, fileContent) for the file opened in the current
2515 # vim buffer. The fileContent contains the unsafed buffer content.
2516 def getCurrentFile():
2517   file = "\n".join(vim.eval("getline(1, '$')"))
2518   return (vim.current.buffer.name, file)
2519
2520 def getCurrentTranslationUnit(args, currentFile, fileName, update = False):
2521   if fileName in translationUnits:
2522     tu = translationUnits[fileName]
2523     if update:
2524       if debug:
2525         start = time.time()
2526       tu.reparse([currentFile])
2527       if debug:
2528         elapsed = (time.time() - start)
2529         print "LibClang - Reparsing: " + str(elapsed)
2530     return tu
2531
2532   if debug:
2533     start = time.time()
2534   flags = TranslationUnit.PrecompiledPreamble | TranslationUnit.CXXPrecompiledPreamble # | TranslationUnit.CacheCompletionResults
2535   tu = index.parse(fileName, args, [currentFile], flags)
2536   if debug:
2537     elapsed = (time.time() - start)
2538     print "LibClang - First parse: " + str(elapsed)
2539
2540   if tu == None:
2541     print "Cannot parse this source file. The following arguments " \
2542         + "are used for clang: " + " ".join(args)
2543     return None
2544
2545   translationUnits[fileName] = tu
2546
2547   # Reparse to initialize the PCH cache even for auto completion
2548   # This should be done by index.parse(), however it is not.
2549   # So we need to reparse ourselves.
2550   if debug:
2551     start = time.time()
2552   tu.reparse([currentFile])
2553   if debug:
2554     elapsed = (time.time() - start)
2555     print "LibClang - First reparse (generate PCH cache): " + str(elapsed)
2556   return tu
2557
2558 def splitOptions(options):
2559   optsList = []
2560   opt = ""
2561   quoted = False
2562
2563   for char in options:
2564     if char == ' ' and not quoted:
2565       if opt != "":
2566         optsList += [opt]
2567         opt = ""
2568       continue
2569     elif char == '"':
2570       quoted = not quoted
2571     opt += char
2572
2573   if opt != "":
2574     optsList += [opt]
2575   return optsList
2576
2577 def getQuickFix(diagnostic):
2578   # Some diagnostics have no file, e.g. "too many errors emitted, stopping now"
2579   if diagnostic.location.file:
2580     filename = diagnostic.location.file.name
2581   else:
2582     filename = ""
2583
2584   if diagnostic.severity == diagnostic.Ignored:
2585     type = 'I'
2586   elif diagnostic.severity == diagnostic.Note:
2587     type = 'I'
2588   elif diagnostic.severity == diagnostic.Warning:
2589     type = 'W'
2590   elif diagnostic.severity == diagnostic.Error:
2591     type = 'E'
2592   elif diagnostic.severity == diagnostic.Fatal:
2593     type = 'E'
2594   else:
2595     return None
2596
2597   return dict({ 'bufnr' : int(vim.eval("bufnr('" + filename + "', 1)")),
2598     'lnum' : diagnostic.location.line,
2599     'col' : diagnostic.location.column,
2600     'text' : diagnostic.spelling,
2601     'type' : type})
2602
2603 def getQuickFixList(tu):
2604   return filter (None, map (getQuickFix, tu.diagnostics))
2605
2606 def highlightRange(range, hlGroup):
2607   pattern = '/\%' + str(range.start.line) + 'l' + '\%' \
2608       + str(range.start.column) + 'c' + '.*' \
2609       + '\%' + str(range.end.column) + 'c/'
2610   command = "exe 'syntax match' . ' " + hlGroup + ' ' + pattern + "'"
2611   vim.command(command)
2612
2613 def highlightDiagnostic(diagnostic):
2614   if diagnostic.severity == diagnostic.Warning:
2615     hlGroup = 'SpellLocal'
2616   elif diagnostic.severity == diagnostic.Error:
2617     hlGroup = 'SpellBad'
2618   else:
2619     return
2620
2621   pattern = '/\%' + str(diagnostic.location.line) + 'l\%' \
2622       + str(diagnostic.location.column) + 'c./'
2623   command = "exe 'syntax match' . ' " + hlGroup + ' ' + pattern + "'"
2624   vim.command(command)
2625
2626   # Use this wired kind of iterator as the python clang libraries
2627         # have a bug in the range iterator that stops us to use:
2628         #
2629         # | for range in diagnostic.ranges
2630         #
2631   for i in range(len(diagnostic.ranges)):
2632     highlightRange(diagnostic.ranges[i], hlGroup)
2633
2634 def highlightDiagnostics(tu):
2635   map (highlightDiagnostic, tu.diagnostics)
2636
2637 def highlightCurrentDiagnostics():
2638   if vim.current.buffer.name in translationUnits:
2639     highlightDiagnostics(translationUnits[vim.current.buffer.name])
2640
2641 def getCurrentQuickFixList():
2642   if vim.current.buffer.name in translationUnits:
2643     return getQuickFixList(translationUnits[vim.current.buffer.name])
2644   return []
2645
2646 def updateCurrentDiagnostics():
2647   global debug
2648   debug = int(vim.eval("g:clang_debug")) == 1
2649   userOptionsGlobal = splitOptions(vim.eval("g:clang_user_options"))
2650   userOptionsLocal = splitOptions(vim.eval("b:clang_user_options"))
2651   args = userOptionsGlobal + userOptionsLocal
2652   getCurrentTranslationUnit(args, getCurrentFile(),
2653                           vim.current.buffer.name, update = True)
2654
2655 def getCurrentCompletionResults(line, column, args, currentFile, fileName):
2656   tu = getCurrentTranslationUnit(args, currentFile, fileName)
2657   if debug:
2658     start = time.time()
2659   cr = tu.codeComplete(fileName, line, column, [currentFile],
2660       complete_flags)
2661   if debug:
2662     elapsed = (time.time() - start)
2663     print "LibClang - Code completion time: " + str(elapsed)
2664   return cr
2665
2666 def formatResult(result):
2667   completion = dict()
2668
2669   abbr = getAbbr(result.string)
2670   word = filter(lambda x: not x.isKindInformative() and not x.isKindResultType(), result.string)
2671
2672   args_pos = []
2673   cur_pos = 0
2674   for chunk in word:
2675     chunk_len = len(chunk.spelling)
2676     if chunk.isKindPlaceHolder():
2677       args_pos += [[ cur_pos, cur_pos + chunk_len ]]
2678     cur_pos += chunk_len
2679
2680   word = "".join(map(lambda x: x.spelling, word))
2681
2682   completion['word'] = word
2683   completion['abbr'] = abbr
2684   completion['menu'] = word
2685   completion['info'] = word
2686   completion['args_pos'] = args_pos
2687   completion['dup'] = 0
2688
2689   # Replace the number that represents a specific kind with a better
2690   # textual representation.
2691   completion['kind'] = kinds[result.cursorKind]
2692
2693   return completion
2694
2695
2696 class CompleteThread(threading.Thread):
2697   lock = threading.Lock()
2698
2699   def __init__(self, line, column, currentFile, fileName):
2700     threading.Thread.__init__(self)
2701     self.line = line
2702     self.column = column
2703     self.currentFile = currentFile
2704     self.fileName = fileName
2705     self.result = None
2706     userOptionsGlobal = splitOptions(vim.eval("g:clang_user_options"))
2707     userOptionsLocal = splitOptions(vim.eval("b:clang_user_options"))
2708     self.args = userOptionsGlobal + userOptionsLocal
2709
2710   def run(self):
2711     try:
2712       CompleteThread.lock.acquire()
2713       if self.line == -1:
2714         # Warm up the caches. For this it is sufficient to get the current
2715         # translation unit. No need to retrieve completion results.
2716         # This short pause is necessary to allow vim to initialize itself.
2717         # Otherwise we would get: E293: block was not locked
2718         # The user does not see any delay, as we just pause a background thread.
2719         time.sleep(0.1)
2720         getCurrentTranslationUnit(self.args, self.currentFile, self.fileName)
2721       else:
2722         self.result = getCurrentCompletionResults(self.line, self.column,
2723                                           self.args, self.currentFile, self.fileName)
2724     except Exception:
2725       pass
2726     CompleteThread.lock.release()
2727
2728 def WarmupCache():
2729   global debug
2730   debug = int(vim.eval("g:clang_debug")) == 1
2731   t = CompleteThread(-1, -1, getCurrentFile(), vim.current.buffer.name)
2732   t.start()
2733   return
2734
2735
2736 def getCurrentCompletions(base):
2737   global debug
2738   debug = int(vim.eval("g:clang_debug")) == 1
2739   priority = vim.eval("g:clang_sort_algo") == 'priority'
2740   line = int(vim.eval("line('.')"))
2741   column = int(vim.eval("b:col"))
2742
2743   t = CompleteThread(line, column, getCurrentFile(), vim.current.buffer.name)
2744   t.start()
2745   while t.isAlive():
2746     t.join(0.01)
2747     cancel = int(vim.eval('complete_check()'))
2748     if cancel != 0:
2749       return []
2750   cr = t.result
2751   if cr is None:
2752     return []
2753
2754   regexp = re.compile("^" + base)
2755   filteredResult = filter(lambda x: regexp.match(getAbbr(x.string)), cr.results)
2756
2757   getPriority = lambda x: x.string.priority
2758   getAbbrevation = lambda x: getAbbr(x.string).lower()
2759   if priority:
2760     key = getPriority
2761   else:
2762     key = getAbbrevation
2763   sortedResult = sorted(filteredResult, None, key)
2764   return map(formatResult, sortedResult)
2765
2766 def getAbbr(strings):
2767   tmplst = filter(lambda x: x.isKindTypedText(), strings)
2768   if len(tmplst) == 0:
2769     return ""
2770   else:
2771     return tmplst[0].spelling
2772
2773 kinds = dict({                                                                 \
2774 # Declarations                                                                 \
2775  1 : 't',  # CXCursor_UnexposedDecl (A declaration whose specific kind is not  \
2776            # exposed via this interface)                                       \
2777  2 : 't',  # CXCursor_StructDecl (A C or C++ struct)                           \
2778  3 : 't',  # CXCursor_UnionDecl (A C or C++ union)                             \
2779  4 : 't',  # CXCursor_ClassDecl (A C++ class)                                  \
2780  5 : 't',  # CXCursor_EnumDecl (An enumeration)                                \
2781  6 : 'm',  # CXCursor_FieldDecl (A field (in C) or non-static data member      \
2782            # (in C++) in a struct, union, or C++ class)                        \
2783  7 : 'e',  # CXCursor_EnumConstantDecl (An enumerator constant)                \
2784  8 : 'f',  # CXCursor_FunctionDecl (A function)                                \
2785  9 : 'v',  # CXCursor_VarDecl (A variable)                                     \
2786 10 : 'a',  # CXCursor_ParmDecl (A function or method parameter)                \
2787 11 : '11', # CXCursor_ObjCInterfaceDecl (An Objective-C @interface)            \
2788 12 : '12', # CXCursor_ObjCCategoryDecl (An Objective-C @interface for a        \
2789            # category)                                                         \
2790 13 : '13', # CXCursor_ObjCProtocolDecl (An Objective-C @protocol declaration)  \
2791 14 : '14', # CXCursor_ObjCPropertyDecl (An Objective-C @property declaration)  \
2792 15 : '15', # CXCursor_ObjCIvarDecl (An Objective-C instance variable)          \
2793 16 : '16', # CXCursor_ObjCInstanceMethodDecl (An Objective-C instance method)  \
2794 17 : '17', # CXCursor_ObjCClassMethodDecl (An Objective-C class method)        \
2795 18 : '18', # CXCursor_ObjCImplementationDec (An Objective-C @implementation)   \
2796 19 : '19', # CXCursor_ObjCCategoryImplDecll (An Objective-C @implementation    \
2797            # for a category)                                                   \
2798 20 : 't',  # CXCursor_TypedefDecl (A typedef)                                  \
2799 21 : 'f',  # CXCursor_CXXMethod (A C++ class method)                           \
2800 22 : 'n',  # CXCursor_Namespace (A C++ namespace)                              \
2801 23 : '23', # CXCursor_LinkageSpec (A linkage specification, e.g. 'extern "C"') \
2802 24 : '+',  # CXCursor_Constructor (A C++ constructor)                          \
2803 25 : '~',  # CXCursor_Destructor (A C++ destructor)                            \
2804 26 : '26', # CXCursor_ConversionFunction (A C++ conversion function)           \
2805 27 : 'a',  # CXCursor_TemplateTypeParameter (A C++ template type parameter)    \
2806 28 : 'a',  # CXCursor_NonTypeTemplateParameter (A C++ non-type template        \
2807            # parameter)                                                        \
2808 29 : 'a',  # CXCursor_TemplateTemplateParameter (A C++ template template       \
2809            # parameter)                                                        \
2810 30 : 'f',  # CXCursor_FunctionTemplate (A C++ function template)               \
2811 31 : 'p',  # CXCursor_ClassTemplate (A C++ class template)                     \
2812 32 : '32', # CXCursor_ClassTemplatePartialSpecialization (A C++ class template \
2813            # partial specialization)                                           \
2814 33 : 'n',  # CXCursor_NamespaceAlias (A C++ namespace alias declaration)       \
2815 34 : '34', # CXCursor_UsingDirective (A C++ using directive)                   \
2816 35 : '35', # CXCursor_UsingDeclaration (A using declaration)                   \
2817                                                                                \
2818 # References                                                                   \
2819 40 : '40', # CXCursor_ObjCSuperClassRef                                        \
2820 41 : '41', # CXCursor_ObjCProtocolRef                                          \
2821 42 : '42', # CXCursor_ObjCClassRef                                             \
2822 43 : '43', # CXCursor_TypeRef                                                  \
2823 44 : '44', # CXCursor_CXXBaseSpecifier                                         \
2824 45 : '45', # CXCursor_TemplateRef (A reference to a class template, function   \
2825            # template, template template parameter, or class template partial  \
2826            # specialization)                                                   \
2827 46 : '46', # CXCursor_NamespaceRef (A reference to a namespace or namespace    \
2828            # alias)                                                            \
2829 47 : '47', # CXCursor_MemberRef (A reference to a member of a struct, union,   \
2830            # or class that occurs in some non-expression context, e.g., a      \
2831            # designated initializer)                                           \
2832 48 : '48', # CXCursor_LabelRef (A reference to a labeled statement)            \
2833 49 : '49', # CXCursor_OverloadedDeclRef (A reference to a set of overloaded    \
2834            # functions or function templates that has not yet been resolved to \
2835            # a specific function or function template)                         \
2836                                                                                \
2837 # Error conditions                                                             \
2838 #70 : '70', # CXCursor_FirstInvalid                                            \
2839 70 : '70',  # CXCursor_InvalidFile                                             \
2840 71 : '71',  # CXCursor_NoDeclFound                                             \
2841 72 : 'u',   # CXCursor_NotImplemented                                          \
2842 73 : '73',  # CXCursor_InvalidCode                                             \
2843                                                                                \
2844 # Expressions                                                                  \
2845 100 : '100',  # CXCursor_UnexposedExpr (An expression whose specific kind is   \
2846               # not exposed via this interface)                                \
2847 101 : '101',  # CXCursor_DeclRefExpr (An expression that refers to some value  \
2848               # declaration, such as a function, varible, or enumerator)       \
2849 102 : '102',  # CXCursor_MemberRefExpr (An expression that refers to a member  \
2850               # of a struct, union, class, Objective-C class, etc)             \
2851 103 : '103',  # CXCursor_CallExpr (An expression that calls a function)        \
2852 104 : '104',  # CXCursor_ObjCMessageExpr (An expression that sends a message   \
2853               # to an Objective-C object or class)                             \
2854 105 : '105',  # CXCursor_BlockExpr (An expression that represents a block      \
2855               # literal)                                                       \
2856                                                                                \
2857 # Statements                                                                   \
2858 200 : '200',  # CXCursor_UnexposedStmt (A statement whose specific kind is not \
2859               # exposed via this interface)                                    \
2860 201 : '201',  # CXCursor_LabelStmt (A labelled statement in a function)        \
2861                                                                                \
2862 # Translation unit                                                             \
2863 300 : '300',  # CXCursor_TranslationUnit (Cursor that represents the           \
2864               # translation unit itself)                                       \
2865                                                                                \
2866 # Attributes                                                                   \
2867 400 : '400',  # CXCursor_UnexposedAttr (An attribute whose specific kind is    \
2868               # not exposed via this interface)                                \
2869 401 : '401',  # CXCursor_IBActionAttr                                          \
2870 402 : '402',  # CXCursor_IBOutletAttr                                          \
2871 403 : '403',  # CXCursor_IBOutletCollectionAttr                                \
2872                                                                                \
2873 # Preprocessing                                                                \
2874 500 : '500', # CXCursor_PreprocessingDirective                                 \
2875 501 : 'd',   # CXCursor_MacroDefinition                                        \
2876 502 : '502', # CXCursor_MacroInstantiation                                     \
2877 503 : '503'  # CXCursor_InclusionDirective                                     \
2878 })
2879
2880 # vim: set ts=2 sts=2 sw=2 expandtab :