cindex.py revision 5cc6787b1ce76fc3b6e5fc6c2729f0dbfaf6c749
1#===- cindex.py - Python Indexing Library Bindings -----------*- python -*--===# 2# 3# The LLVM Compiler Infrastructure 4# 5# This file is distributed under the University of Illinois Open Source 6# License. See LICENSE.TXT for details. 7# 8#===------------------------------------------------------------------------===# 9 10r""" 11Clang Indexing Library Bindings 12=============================== 13 14This module provides an interface to the Clang indexing library. It is a 15low-level interface to the indexing library which attempts to match the Clang 16API directly while also being "pythonic". Notable differences from the C API 17are: 18 19 * string results are returned as Python strings, not CXString objects. 20 21 * null cursors are translated to None. 22 23 * access to child cursors is done via iteration, not visitation. 24 25The major indexing objects are: 26 27 Index 28 29 The top-level object which manages some global library state. 30 31 TranslationUnit 32 33 High-level object encapsulating the AST for a single translation unit. These 34 can be loaded from .ast files or parsed on the fly. 35 36 Cursor 37 38 Generic object for representing a node in the AST. 39 40 SourceRange, SourceLocation, and File 41 42 Objects representing information about the input source. 43 44Most object information is exposed using properties, when the underlying API 45call is efficient. 46""" 47 48# TODO 49# ==== 50# 51# o API support for invalid translation units. Currently we can't even get the 52# diagnostics on failure because they refer to locations in an object that 53# will have been invalidated. 54# 55# o fix memory management issues (currently client must hold on to index and 56# translation unit, or risk crashes). 57# 58# o expose code completion APIs. 59# 60# o cleanup ctypes wrapping, would be nice to separate the ctypes details more 61# clearly, and hide from the external interface (i.e., help(cindex)). 62# 63# o implement additional SourceLocation, SourceRange, and File methods. 64 65from ctypes import * 66import collections 67 68def get_cindex_library(): 69 # FIXME: It's probably not the case that the library is actually found in 70 # this location. We need a better system of identifying and loading the 71 # CIndex library. It could be on path or elsewhere, or versioned, etc. 72 import platform 73 name = platform.system() 74 if name == 'Darwin': 75 return cdll.LoadLibrary('libclang.dylib') 76 elif name == 'Windows': 77 return cdll.LoadLibrary('libclang.dll') 78 else: 79 return cdll.LoadLibrary('libclang.so') 80 81# ctypes doesn't implicitly convert c_void_p to the appropriate wrapper 82# object. This is a problem, because it means that from_parameter will see an 83# integer and pass the wrong value on platforms where int != void*. Work around 84# this by marshalling object arguments as void**. 85c_object_p = POINTER(c_void_p) 86 87lib = get_cindex_library() 88 89### Structures and Utility Classes ### 90 91class _CXString(Structure): 92 """Helper for transforming CXString results.""" 93 94 _fields_ = [("spelling", c_char_p), ("free", c_int)] 95 96 def __del__(self): 97 _CXString_dispose(self) 98 99 @staticmethod 100 def from_result(res, fn, args): 101 assert isinstance(res, _CXString) 102 return _CXString_getCString(res) 103 104class SourceLocation(Structure): 105 """ 106 A SourceLocation represents a particular location within a source file. 107 """ 108 _fields_ = [("ptr_data", c_void_p * 2), ("int_data", c_uint)] 109 _data = None 110 111 def _get_instantiation(self): 112 if self._data is None: 113 f, l, c, o = c_object_p(), c_uint(), c_uint(), c_uint() 114 SourceLocation_loc(self, byref(f), byref(l), byref(c), byref(o)) 115 if f: 116 f = File(f) 117 else: 118 f = None 119 self._data = (f, int(l.value), int(c.value), int(o.value)) 120 return self._data 121 122 @staticmethod 123 def from_position(tu, file, line, column): 124 """ 125 Retrieve the source location associated with a given file/line/column in 126 a particular translation unit. 127 """ 128 return SourceLocation_getLocation(tu, file, line, column) 129 130 @property 131 def file(self): 132 """Get the file represented by this source location.""" 133 return self._get_instantiation()[0] 134 135 @property 136 def line(self): 137 """Get the line represented by this source location.""" 138 return self._get_instantiation()[1] 139 140 @property 141 def column(self): 142 """Get the column represented by this source location.""" 143 return self._get_instantiation()[2] 144 145 @property 146 def offset(self): 147 """Get the file offset represented by this source location.""" 148 return self._get_instantiation()[3] 149 150 def __eq__(self, other): 151 return SourceLocation_equalLocations(self, other) 152 153 def __ne__(self, other): 154 return not self.__eq__(other) 155 156 def __repr__(self): 157 if self.file: 158 filename = self.file.name 159 else: 160 filename = None 161 return "<SourceLocation file %r, line %r, column %r>" % ( 162 filename, self.line, self.column) 163 164class SourceRange(Structure): 165 """ 166 A SourceRange describes a range of source locations within the source 167 code. 168 """ 169 _fields_ = [ 170 ("ptr_data", c_void_p * 2), 171 ("begin_int_data", c_uint), 172 ("end_int_data", c_uint)] 173 174 # FIXME: Eliminate this and make normal constructor? Requires hiding ctypes 175 # object. 176 @staticmethod 177 def from_locations(start, end): 178 return SourceRange_getRange(start, end) 179 180 @property 181 def start(self): 182 """ 183 Return a SourceLocation representing the first character within a 184 source range. 185 """ 186 return SourceRange_start(self) 187 188 @property 189 def end(self): 190 """ 191 Return a SourceLocation representing the last character within a 192 source range. 193 """ 194 return SourceRange_end(self) 195 196 def __eq__(self, other): 197 return SourceRange_equalRanges(self, other) 198 199 def __ne__(self, other): 200 return not self.__eq__(other) 201 202 def __repr__(self): 203 return "<SourceRange start %r, end %r>" % (self.start, self.end) 204 205class Diagnostic(object): 206 """ 207 A Diagnostic is a single instance of a Clang diagnostic. It includes the 208 diagnostic severity, the message, the location the diagnostic occurred, as 209 well as additional source ranges and associated fix-it hints. 210 """ 211 212 Ignored = 0 213 Note = 1 214 Warning = 2 215 Error = 3 216 Fatal = 4 217 218 def __init__(self, ptr): 219 self.ptr = ptr 220 221 def __del__(self): 222 _clang_disposeDiagnostic(self) 223 224 @property 225 def severity(self): 226 return _clang_getDiagnosticSeverity(self) 227 228 @property 229 def location(self): 230 return _clang_getDiagnosticLocation(self) 231 232 @property 233 def spelling(self): 234 return _clang_getDiagnosticSpelling(self) 235 236 @property 237 def ranges(self): 238 class RangeIterator: 239 def __init__(self, diag): 240 self.diag = diag 241 242 def __len__(self): 243 return int(_clang_getDiagnosticNumRanges(self.diag)) 244 245 def __getitem__(self, key): 246 if (key >= len(self)): 247 raise IndexError 248 return _clang_getDiagnosticRange(self.diag, key) 249 250 return RangeIterator(self) 251 252 @property 253 def fixits(self): 254 class FixItIterator: 255 def __init__(self, diag): 256 self.diag = diag 257 258 def __len__(self): 259 return int(_clang_getDiagnosticNumFixIts(self.diag)) 260 261 def __getitem__(self, key): 262 range = SourceRange() 263 value = _clang_getDiagnosticFixIt(self.diag, key, byref(range)) 264 if len(value) == 0: 265 raise IndexError 266 267 return FixIt(range, value) 268 269 return FixItIterator(self) 270 271 @property 272 def category_number(self): 273 """The category number for this diagnostic.""" 274 return _clang_getDiagnosticCategory(self) 275 276 @property 277 def category_name(self): 278 """The string name of the category for this diagnostic.""" 279 return _clang_getDiagnosticCategoryName(self.category_number) 280 281 @property 282 def option(self): 283 """The command-line option that enables this diagnostic.""" 284 return _clang_getDiagnosticOption(self, None) 285 286 @property 287 def disable_option(self): 288 """The command-line option that disables this diagnostic.""" 289 disable = _CXString() 290 _clang_getDiagnosticOption(self, byref(disable)) 291 292 return _CXString_getCString(disable) 293 294 def __repr__(self): 295 return "<Diagnostic severity %r, location %r, spelling %r>" % ( 296 self.severity, self.location, self.spelling) 297 298 def from_param(self): 299 return self.ptr 300 301class FixIt(object): 302 """ 303 A FixIt represents a transformation to be applied to the source to 304 "fix-it". The fix-it shouldbe applied by replacing the given source range 305 with the given value. 306 """ 307 308 def __init__(self, range, value): 309 self.range = range 310 self.value = value 311 312 def __repr__(self): 313 return "<FixIt range %r, value %r>" % (self.range, self.value) 314 315### Cursor Kinds ### 316 317class CursorKind(object): 318 """ 319 A CursorKind describes the kind of entity that a cursor points to. 320 """ 321 322 # The unique kind objects, indexed by id. 323 _kinds = [] 324 _name_map = None 325 326 def __init__(self, value): 327 if value >= len(CursorKind._kinds): 328 CursorKind._kinds += [None] * (value - len(CursorKind._kinds) + 1) 329 if CursorKind._kinds[value] is not None: 330 raise ValueError,'CursorKind already loaded' 331 self.value = value 332 CursorKind._kinds[value] = self 333 CursorKind._name_map = None 334 335 def from_param(self): 336 return self.value 337 338 @property 339 def name(self): 340 """Get the enumeration name of this cursor kind.""" 341 if self._name_map is None: 342 self._name_map = {} 343 for key,value in CursorKind.__dict__.items(): 344 if isinstance(value,CursorKind): 345 self._name_map[value] = key 346 return self._name_map[self] 347 348 @staticmethod 349 def from_id(id): 350 if id >= len(CursorKind._kinds) or CursorKind._kinds[id] is None: 351 raise ValueError,'Unknown cursor kind' 352 return CursorKind._kinds[id] 353 354 @staticmethod 355 def get_all_kinds(): 356 """Return all CursorKind enumeration instances.""" 357 return filter(None, CursorKind._kinds) 358 359 def is_declaration(self): 360 """Test if this is a declaration kind.""" 361 return CursorKind_is_decl(self) 362 363 def is_reference(self): 364 """Test if this is a reference kind.""" 365 return CursorKind_is_ref(self) 366 367 def is_expression(self): 368 """Test if this is an expression kind.""" 369 return CursorKind_is_expr(self) 370 371 def is_statement(self): 372 """Test if this is a statement kind.""" 373 return CursorKind_is_stmt(self) 374 375 def is_attribute(self): 376 """Test if this is an attribute kind.""" 377 return CursorKind_is_attribute(self) 378 379 def is_invalid(self): 380 """Test if this is an invalid kind.""" 381 return CursorKind_is_inv(self) 382 383 def is_translation_unit(self): 384 """Test if this is a translation unit kind.""" 385 return CursorKind_is_translation_unit(self) 386 387 def is_preprocessing(self): 388 """Test if this is a preprocessing kind.""" 389 return CursorKind_is_preprocessing(self) 390 391 def is_unexposed(self): 392 """Test if this is an unexposed kind.""" 393 return CursorKind_is_unexposed(self) 394 395 def __repr__(self): 396 return 'CursorKind.%s' % (self.name,) 397 398# FIXME: Is there a nicer way to expose this enumeration? We could potentially 399# represent the nested structure, or even build a class hierarchy. The main 400# things we want for sure are (a) simple external access to kinds, (b) a place 401# to hang a description and name, (c) easy to keep in sync with Index.h. 402 403### 404# Declaration Kinds 405 406# A declaration whose specific kind is not exposed via this interface. 407# 408# Unexposed declarations have the same operations as any other kind of 409# declaration; one can extract their location information, spelling, find their 410# definitions, etc. However, the specific kind of the declaration is not 411# reported. 412CursorKind.UNEXPOSED_DECL = CursorKind(1) 413 414# A C or C++ struct. 415CursorKind.STRUCT_DECL = CursorKind(2) 416 417# A C or C++ union. 418CursorKind.UNION_DECL = CursorKind(3) 419 420# A C++ class. 421CursorKind.CLASS_DECL = CursorKind(4) 422 423# An enumeration. 424CursorKind.ENUM_DECL = CursorKind(5) 425 426# A field (in C) or non-static data member (in C++) in a struct, union, or C++ 427# class. 428CursorKind.FIELD_DECL = CursorKind(6) 429 430# An enumerator constant. 431CursorKind.ENUM_CONSTANT_DECL = CursorKind(7) 432 433# A function. 434CursorKind.FUNCTION_DECL = CursorKind(8) 435 436# A variable. 437CursorKind.VAR_DECL = CursorKind(9) 438 439# A function or method parameter. 440CursorKind.PARM_DECL = CursorKind(10) 441 442# An Objective-C @interface. 443CursorKind.OBJC_INTERFACE_DECL = CursorKind(11) 444 445# An Objective-C @interface for a category. 446CursorKind.OBJC_CATEGORY_DECL = CursorKind(12) 447 448# An Objective-C @protocol declaration. 449CursorKind.OBJC_PROTOCOL_DECL = CursorKind(13) 450 451# An Objective-C @property declaration. 452CursorKind.OBJC_PROPERTY_DECL = CursorKind(14) 453 454# An Objective-C instance variable. 455CursorKind.OBJC_IVAR_DECL = CursorKind(15) 456 457# An Objective-C instance method. 458CursorKind.OBJC_INSTANCE_METHOD_DECL = CursorKind(16) 459 460# An Objective-C class method. 461CursorKind.OBJC_CLASS_METHOD_DECL = CursorKind(17) 462 463# An Objective-C @implementation. 464CursorKind.OBJC_IMPLEMENTATION_DECL = CursorKind(18) 465 466# An Objective-C @implementation for a category. 467CursorKind.OBJC_CATEGORY_IMPL_DECL = CursorKind(19) 468 469# A typedef. 470CursorKind.TYPEDEF_DECL = CursorKind(20) 471 472# A C++ class method. 473CursorKind.CXX_METHOD = CursorKind(21) 474 475# A C++ namespace. 476CursorKind.NAMESPACE = CursorKind(22) 477 478# A linkage specification, e.g. 'extern "C"'. 479CursorKind.LINKAGE_SPEC = CursorKind(23) 480 481# A C++ constructor. 482CursorKind.CONSTRUCTOR = CursorKind(24) 483 484# A C++ destructor. 485CursorKind.DESTRUCTOR = CursorKind(25) 486 487# A C++ conversion function. 488CursorKind.CONVERSION_FUNCTION = CursorKind(26) 489 490# A C++ template type parameter 491CursorKind.TEMPLATE_TYPE_PARAMETER = CursorKind(27) 492 493# A C++ non-type template paramater. 494CursorKind.TEMPLATE_NON_TYPE_PARAMETER = CursorKind(28) 495 496# A C++ template template parameter. 497CursorKind.TEMPLATE_TEMPLATE_PARAMTER = CursorKind(29) 498 499# A C++ function template. 500CursorKind.FUNCTION_TEMPLATE = CursorKind(30) 501 502# A C++ class template. 503CursorKind.CLASS_TEMPLATE = CursorKind(31) 504 505# A C++ class template partial specialization. 506CursorKind.CLASS_TEMPLATE_PARTIAL_SPECIALIZATION = CursorKind(32) 507 508# A C++ namespace alias declaration. 509CursorKind.NAMESPACE_ALIAS = CursorKind(33) 510 511# A C++ using directive 512CursorKind.USING_DIRECTIVE = CursorKind(34) 513 514# A C++ using declaration 515CursorKind.USING_DECLARATION = CursorKind(35) 516 517# A Type alias decl. 518CursorKind.TYPE_ALIAS_DECL = CursorKind(36) 519 520# A Objective-C synthesize decl 521CursorKind.OBJC_SYNTHESIZE_DECL = CursorKind(37) 522 523# A Objective-C dynamic decl 524CursorKind.OBJC_DYNAMIC_DECL = CursorKind(38) 525 526# A C++ access specifier decl. 527CursorKind.CXX_ACCESS_SPEC_DECL = CursorKind(39) 528 529 530### 531# Reference Kinds 532 533CursorKind.OBJC_SUPER_CLASS_REF = CursorKind(40) 534CursorKind.OBJC_PROTOCOL_REF = CursorKind(41) 535CursorKind.OBJC_CLASS_REF = CursorKind(42) 536 537# A reference to a type declaration. 538# 539# A type reference occurs anywhere where a type is named but not 540# declared. For example, given: 541# typedef unsigned size_type; 542# size_type size; 543# 544# The typedef is a declaration of size_type (CXCursor_TypedefDecl), 545# while the type of the variable "size" is referenced. The cursor 546# referenced by the type of size is the typedef for size_type. 547CursorKind.TYPE_REF = CursorKind(43) 548CursorKind.CXX_BASE_SPECIFIER = CursorKind(44) 549 550# A reference to a class template, function template, template 551# template parameter, or class template partial specialization. 552CursorKind.TEMPLATE_REF = CursorKind(45) 553 554# A reference to a namespace or namepsace alias. 555CursorKind.NAMESPACE_REF = CursorKind(46) 556 557# A reference to a member of a struct, union, or class that occurs in 558# some non-expression context, e.g., a designated initializer. 559CursorKind.MEMBER_REF = CursorKind(47) 560 561# A reference to a labeled statement. 562CursorKind.LABEL_REF = CursorKind(48) 563 564# A reference toa a set of overloaded functions or function templates 565# that has not yet been resolved to a specific function or function template. 566CursorKind.OVERLOADED_DECL_REF = CursorKind(49) 567 568### 569# Invalid/Error Kinds 570 571CursorKind.INVALID_FILE = CursorKind(70) 572CursorKind.NO_DECL_FOUND = CursorKind(71) 573CursorKind.NOT_IMPLEMENTED = CursorKind(72) 574CursorKind.INVALID_CODE = CursorKind(73) 575 576### 577# Expression Kinds 578 579# An expression whose specific kind is not exposed via this interface. 580# 581# Unexposed expressions have the same operations as any other kind of 582# expression; one can extract their location information, spelling, children, 583# etc. However, the specific kind of the expression is not reported. 584CursorKind.UNEXPOSED_EXPR = CursorKind(100) 585 586# An expression that refers to some value declaration, such as a function, 587# varible, or enumerator. 588CursorKind.DECL_REF_EXPR = CursorKind(101) 589 590# An expression that refers to a member of a struct, union, class, Objective-C 591# class, etc. 592CursorKind.MEMBER_REF_EXPR = CursorKind(102) 593 594# An expression that calls a function. 595CursorKind.CALL_EXPR = CursorKind(103) 596 597# An expression that sends a message to an Objective-C object or class. 598CursorKind.OBJC_MESSAGE_EXPR = CursorKind(104) 599 600# An expression that represents a block literal. 601CursorKind.BLOCK_EXPR = CursorKind(105) 602 603# An integer literal. 604CursorKind.INTEGER_LITERAL = CursorKind(106) 605 606# A floating point number literal. 607CursorKind.FLOATING_LITERAL = CursorKind(107) 608 609# An imaginary number literal. 610CursorKind.IMAGINARY_LITERAL = CursorKind(108) 611 612# A string literal. 613CursorKind.STRING_LITERAL = CursorKind(109) 614 615# A character literal. 616CursorKind.CHARACTER_LITERAL = CursorKind(110) 617 618# A parenthesized expression, e.g. "(1)". 619# 620# This AST node is only formed if full location information is requested. 621CursorKind.PAREN_EXPR = CursorKind(111) 622 623# This represents the unary-expression's (except sizeof and 624# alignof). 625CursorKind.UNARY_OPERATOR = CursorKind(112) 626 627# [C99 6.5.2.1] Array Subscripting. 628CursorKind.ARRAY_SUBSCRIPT_EXPR = CursorKind(113) 629 630# A builtin binary operation expression such as "x + y" or 631# "x <= y". 632CursorKind.BINARY_OPERATOR = CursorKind(114) 633 634# Compound assignment such as "+=". 635CursorKind.COMPOUND_ASSIGNMENT_OPERATOR = CursorKind(115) 636 637# The ?: ternary operator. 638CursorKind.CONDITONAL_OPERATOR = CursorKind(116) 639 640# An explicit cast in C (C99 6.5.4) or a C-style cast in C++ 641# (C++ [expr.cast]), which uses the syntax (Type)expr. 642# 643# For example: (int)f. 644CursorKind.CSTYLE_CAST_EXPR = CursorKind(117) 645 646# [C99 6.5.2.5] 647CursorKind.COMPOUND_LITERAL_EXPR = CursorKind(118) 648 649# Describes an C or C++ initializer list. 650CursorKind.INIT_LIST_EXPR = CursorKind(119) 651 652# The GNU address of label extension, representing &&label. 653CursorKind.ADDR_LABEL_EXPR = CursorKind(120) 654 655# This is the GNU Statement Expression extension: ({int X=4; X;}) 656CursorKind.StmtExpr = CursorKind(121) 657 658# Represents a C11 generic selection. 659CursorKind.GENERIC_SELECTION_EXPR = CursorKind(122) 660 661# Implements the GNU __null extension, which is a name for a null 662# pointer constant that has integral type (e.g., int or long) and is the same 663# size and alignment as a pointer. 664# 665# The __null extension is typically only used by system headers, which define 666# NULL as __null in C++ rather than using 0 (which is an integer that may not 667# match the size of a pointer). 668CursorKind.GNU_NULL_EXPR = CursorKind(123) 669 670# C++'s static_cast<> expression. 671CursorKind.CXX_STATIC_CAST_EXPR = CursorKind(124) 672 673# C++'s dynamic_cast<> expression. 674CursorKind.CXX_DYNAMIC_CAST_EXPR = CursorKind(125) 675 676# C++'s reinterpret_cast<> expression. 677CursorKind.CXX_REINTERPRET_CAST_EXPR = CursorKind(126) 678 679# C++'s const_cast<> expression. 680CursorKind.CXX_CONST_CAST_EXPR = CursorKind(127) 681 682# Represents an explicit C++ type conversion that uses "functional" 683# notion (C++ [expr.type.conv]). 684# 685# Example: 686# \code 687# x = int(0.5); 688# \endcode 689CursorKind.CXX_FUNCTIONAL_CAST_EXPR = CursorKind(128) 690 691# A C++ typeid expression (C++ [expr.typeid]). 692CursorKind.CXX_TYPEID_EXPR = CursorKind(129) 693 694# [C++ 2.13.5] C++ Boolean Literal. 695CursorKind.CXX_BOOL_LITERAL_EXPR = CursorKind(130) 696 697# [C++0x 2.14.7] C++ Pointer Literal. 698CursorKind.CXX_NULL_PTR_LITERAL_EXPR = CursorKind(131) 699 700# Represents the "this" expression in C++ 701CursorKind.CXX_THIS_EXPR = CursorKind(132) 702 703# [C++ 15] C++ Throw Expression. 704# 705# This handles 'throw' and 'throw' assignment-expression. When 706# assignment-expression isn't present, Op will be null. 707CursorKind.CXX_THROW_EXPR = CursorKind(133) 708 709# A new expression for memory allocation and constructor calls, e.g: 710# "new CXXNewExpr(foo)". 711CursorKind.CXX_NEW_EXPR = CursorKind(134) 712 713# A delete expression for memory deallocation and destructor calls, 714# e.g. "delete[] pArray". 715CursorKind.CXX_DELETE_EXPR = CursorKind(135) 716 717# Represents a unary expression. 718CursorKind.CXX_UNARY_EXPR = CursorKind(136) 719 720# ObjCStringLiteral, used for Objective-C string literals i.e. "foo". 721CursorKind.OBJC_STRING_LITERAL = CursorKind(137) 722 723# ObjCEncodeExpr, used for in Objective-C. 724CursorKind.OBJC_ENCODE_EXPR = CursorKind(138) 725 726# ObjCSelectorExpr used for in Objective-C. 727CursorKind.OBJC_SELECTOR_EXPR = CursorKind(139) 728 729# Objective-C's protocol expression. 730CursorKind.OBJC_PROTOCOL_EXPR = CursorKind(140) 731 732# An Objective-C "bridged" cast expression, which casts between 733# Objective-C pointers and C pointers, transferring ownership in the process. 734# 735# \code 736# NSString *str = (__bridge_transfer NSString *)CFCreateString(); 737# \endcode 738CursorKind.OBJC_BRIDGE_CAST_EXPR = CursorKind(141) 739 740# Represents a C++0x pack expansion that produces a sequence of 741# expressions. 742# 743# A pack expansion expression contains a pattern (which itself is an 744# expression) followed by an ellipsis. For example: 745CursorKind.PACK_EXPANSION_EXPR = CursorKind(142) 746 747# Represents an expression that computes the length of a parameter 748# pack. 749CursorKind.SIZE_OF_PACK_EXPR = CursorKind(143) 750 751# A statement whose specific kind is not exposed via this interface. 752# 753# Unexposed statements have the same operations as any other kind of statement; 754# one can extract their location information, spelling, children, etc. However, 755# the specific kind of the statement is not reported. 756CursorKind.UNEXPOSED_STMT = CursorKind(200) 757 758# A labelled statement in a function. 759CursorKind.LABEL_STMT = CursorKind(201) 760 761# A compound statement 762CursorKind.COMPOUND_STMT = CursorKind(202) 763 764# A case statement. 765CursorKind.CASE_STMT = CursorKind(203) 766 767# A default statement. 768CursorKind.DEFAULT_STMT = CursorKind(204) 769 770# An if statement. 771CursorKind.IF_STMT = CursorKind(205) 772 773# A switch statement. 774CursorKind.SWITCH_STMT = CursorKind(206) 775 776# A while statement. 777CursorKind.WHILE_STMT = CursorKind(207) 778 779# A do statement. 780CursorKind.DO_STMT = CursorKind(208) 781 782# A for statement. 783CursorKind.FOR_STMT = CursorKind(209) 784 785# A goto statement. 786CursorKind.GOTO_STMT = CursorKind(210) 787 788# An indirect goto statement. 789CursorKind.INDIRECT_GOTO_STMT = CursorKind(211) 790 791# A continue statement. 792CursorKind.CONTINUE_STMT = CursorKind(212) 793 794# A break statement. 795CursorKind.BREAK_STMT = CursorKind(213) 796 797# A return statement. 798CursorKind.RETURN_STMT = CursorKind(214) 799 800# A GNU-style inline assembler statement. 801CursorKind.ASM_STMT = CursorKind(215) 802 803# Objective-C's overall @try-@catch-@finally statement. 804CursorKind.OBJC_AT_TRY_STMT = CursorKind(216) 805 806# Objective-C's @catch statement. 807CursorKind.OBJC_AT_CATCH_STMT = CursorKind(217) 808 809# Objective-C's @finally statement. 810CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218) 811 812# Objective-C's @throw statement. 813CursorKind.OBJC_AT_THROW_STMT = CursorKind(219) 814 815# Objective-C's @synchronized statement. 816CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220) 817 818# Objective-C's autorealease pool statement. 819CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221) 820 821# Objective-C's for collection statement. 822CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222) 823 824# C++'s catch statement. 825CursorKind.CXX_CATCH_STMT = CursorKind(223) 826 827# C++'s try statement. 828CursorKind.CXX_TRY_STMT = CursorKind(224) 829 830# C++'s for (* : *) statement. 831CursorKind.CXX_FOR_RANGE_STMT = CursorKind(225) 832 833# Windows Structured Exception Handling's try statement. 834CursorKind.SEH_TRY_STMT = CursorKind(226) 835 836# Windows Structured Exception Handling's except statement. 837CursorKind.SEH_EXCEPT_STMT = CursorKind(227) 838 839# Windows Structured Exception Handling's finally statement. 840CursorKind.SEH_FINALLY_STMT = CursorKind(228) 841 842# The null statement. 843CursorKind.NULL_STMT = CursorKind(230) 844 845# Adaptor class for mixing declarations with statements and expressions. 846CursorKind.DECL_STMT = CursorKind(231) 847 848### 849# Other Kinds 850 851# Cursor that represents the translation unit itself. 852# 853# The translation unit cursor exists primarily to act as the root cursor for 854# traversing the contents of a translation unit. 855CursorKind.TRANSLATION_UNIT = CursorKind(300) 856 857### 858# Attributes 859 860# An attribute whoe specific kind is note exposed via this interface 861CursorKind.UNEXPOSED_ATTR = CursorKind(400) 862 863CursorKind.IB_ACTION_ATTR = CursorKind(401) 864CursorKind.IB_OUTLET_ATTR = CursorKind(402) 865CursorKind.IB_OUTLET_COLLECTION_ATTR = CursorKind(403) 866 867CursorKind.CXX_FINAL_ATTR = CursorKind(404) 868CursorKind.CXX_OVERRIDE_ATTR = CursorKind(405) 869CursorKind.ANNOTATE_ATTR = CursorKind(406) 870CursorKind.ASM_LABEL_ATTR = CursorKind(407) 871 872### 873# Preprocessing 874CursorKind.PREPROCESSING_DIRECTIVE = CursorKind(500) 875CursorKind.MACRO_DEFINITION = CursorKind(501) 876CursorKind.MACRO_INSTANTIATION = CursorKind(502) 877CursorKind.INCLUSION_DIRECTIVE = CursorKind(503) 878 879### Cursors ### 880 881class Cursor(Structure): 882 """ 883 The Cursor class represents a reference to an element within the AST. It 884 acts as a kind of iterator. 885 """ 886 _fields_ = [("_kind_id", c_int), ("xdata", c_int), ("data", c_void_p * 3)] 887 888 @staticmethod 889 def from_location(tu, location): 890 return Cursor_get(tu, location) 891 892 def __eq__(self, other): 893 return Cursor_eq(self, other) 894 895 def __ne__(self, other): 896 return not self.__eq__(other) 897 898 def is_definition(self): 899 """ 900 Returns true if the declaration pointed at by the cursor is also a 901 definition of that entity. 902 """ 903 return Cursor_is_def(self) 904 905 def get_definition(self): 906 """ 907 If the cursor is a reference to a declaration or a declaration of 908 some entity, return a cursor that points to the definition of that 909 entity. 910 """ 911 # TODO: Should probably check that this is either a reference or 912 # declaration prior to issuing the lookup. 913 return Cursor_def(self) 914 915 def get_usr(self): 916 """Return the Unified Symbol Resultion (USR) for the entity referenced 917 by the given cursor (or None). 918 919 A Unified Symbol Resolution (USR) is a string that identifies a 920 particular entity (function, class, variable, etc.) within a 921 program. USRs can be compared across translation units to determine, 922 e.g., when references in one translation refer to an entity defined in 923 another translation unit.""" 924 return Cursor_usr(self) 925 926 @property 927 def kind(self): 928 """Return the kind of this cursor.""" 929 return CursorKind.from_id(self._kind_id) 930 931 @property 932 def spelling(self): 933 """Return the spelling of the entity pointed at by the cursor.""" 934 if not self.kind.is_declaration(): 935 # FIXME: clang_getCursorSpelling should be fixed to not assert on 936 # this, for consistency with clang_getCursorUSR. 937 return None 938 if not hasattr(self, '_spelling'): 939 self._spelling = Cursor_spelling(self) 940 return self._spelling 941 942 @property 943 def displayname(self): 944 """ 945 Return the display name for the entity referenced by this cursor. 946 947 The display name contains extra information that helps identify the cursor, 948 such as the parameters of a function or template or the arguments of a 949 class template specialization. 950 """ 951 if not hasattr(self, '_displayname'): 952 self._displayname = Cursor_displayname(self) 953 return self._displayname 954 955 @property 956 def location(self): 957 """ 958 Return the source location (the starting character) of the entity 959 pointed at by the cursor. 960 """ 961 if not hasattr(self, '_loc'): 962 self._loc = Cursor_loc(self) 963 return self._loc 964 965 @property 966 def extent(self): 967 """ 968 Return the source range (the range of text) occupied by the entity 969 pointed at by the cursor. 970 """ 971 if not hasattr(self, '_extent'): 972 self._extent = Cursor_extent(self) 973 return self._extent 974 975 @property 976 def type(self): 977 """ 978 Retrieve the Type (if any) of the entity pointed at by the cursor. 979 """ 980 if not hasattr(self, '_type'): 981 self._type = Cursor_type(self) 982 return self._type 983 984 @property 985 def underlying_typedef_type(self): 986 """Return the underlying type of a typedef declaration. 987 988 Returns a Type for the typedef this cursor is a declaration for. If 989 the current cursor is not a typedef, this raises. 990 """ 991 if not hasattr(self, '_underlying_type'): 992 assert self.kind.is_declaration() 993 self._underlying_type = Cursor_underlying_type(self) 994 995 return self._underlying_type 996 997 @property 998 def enum_type(self): 999 """Return the integer type of an enum declaration. 1000 1001 Returns a Type corresponding to an integer. If the cursor is not for an 1002 enum, this raises. 1003 """ 1004 if not hasattr(self, '_enum_type'): 1005 assert self.kind == CursorKind.ENUM_DECL 1006 self._enum_type = Cursor_enum_type(self) 1007 1008 return self._enum_type 1009 1010 @property 1011 def objc_type_encoding(self): 1012 """Return the Objective-C type encoding as a str.""" 1013 if not hasattr(self, '_objc_type_encoding'): 1014 self._objc_type_encoding = Cursor_objc_type_encoding(self) 1015 1016 return self._objc_type_encoding 1017 1018 @property 1019 def hash(self): 1020 """Returns a hash of the cursor as an int.""" 1021 if not hasattr(self, '_hash'): 1022 self._hash = Cursor_hash(self) 1023 1024 return self._hash 1025 1026 def get_children(self): 1027 """Return an iterator for accessing the children of this cursor.""" 1028 1029 # FIXME: Expose iteration from CIndex, PR6125. 1030 def visitor(child, parent, children): 1031 # FIXME: Document this assertion in API. 1032 # FIXME: There should just be an isNull method. 1033 assert child != Cursor_null() 1034 children.append(child) 1035 return 1 # continue 1036 children = [] 1037 Cursor_visit(self, Cursor_visit_callback(visitor), children) 1038 return iter(children) 1039 1040 @staticmethod 1041 def from_result(res, fn, args): 1042 assert isinstance(res, Cursor) 1043 # FIXME: There should just be an isNull method. 1044 if res == Cursor_null(): 1045 return None 1046 return res 1047 1048 1049### Type Kinds ### 1050 1051class TypeKind(object): 1052 """ 1053 Describes the kind of type. 1054 """ 1055 1056 # The unique kind objects, indexed by id. 1057 _kinds = [] 1058 _name_map = None 1059 1060 def __init__(self, value): 1061 if value >= len(TypeKind._kinds): 1062 TypeKind._kinds += [None] * (value - len(TypeKind._kinds) + 1) 1063 if TypeKind._kinds[value] is not None: 1064 raise ValueError,'TypeKind already loaded' 1065 self.value = value 1066 TypeKind._kinds[value] = self 1067 TypeKind._name_map = None 1068 1069 def from_param(self): 1070 return self.value 1071 1072 @property 1073 def name(self): 1074 """Get the enumeration name of this cursor kind.""" 1075 if self._name_map is None: 1076 self._name_map = {} 1077 for key,value in TypeKind.__dict__.items(): 1078 if isinstance(value,TypeKind): 1079 self._name_map[value] = key 1080 return self._name_map[self] 1081 1082 @staticmethod 1083 def from_id(id): 1084 if id >= len(TypeKind._kinds) or TypeKind._kinds[id] is None: 1085 raise ValueError,'Unknown type kind %d' % id 1086 return TypeKind._kinds[id] 1087 1088 def __repr__(self): 1089 return 'TypeKind.%s' % (self.name,) 1090 1091 1092 1093TypeKind.INVALID = TypeKind(0) 1094TypeKind.UNEXPOSED = TypeKind(1) 1095TypeKind.VOID = TypeKind(2) 1096TypeKind.BOOL = TypeKind(3) 1097TypeKind.CHAR_U = TypeKind(4) 1098TypeKind.UCHAR = TypeKind(5) 1099TypeKind.CHAR16 = TypeKind(6) 1100TypeKind.CHAR32 = TypeKind(7) 1101TypeKind.USHORT = TypeKind(8) 1102TypeKind.UINT = TypeKind(9) 1103TypeKind.ULONG = TypeKind(10) 1104TypeKind.ULONGLONG = TypeKind(11) 1105TypeKind.UINT128 = TypeKind(12) 1106TypeKind.CHAR_S = TypeKind(13) 1107TypeKind.SCHAR = TypeKind(14) 1108TypeKind.WCHAR = TypeKind(15) 1109TypeKind.SHORT = TypeKind(16) 1110TypeKind.INT = TypeKind(17) 1111TypeKind.LONG = TypeKind(18) 1112TypeKind.LONGLONG = TypeKind(19) 1113TypeKind.INT128 = TypeKind(20) 1114TypeKind.FLOAT = TypeKind(21) 1115TypeKind.DOUBLE = TypeKind(22) 1116TypeKind.LONGDOUBLE = TypeKind(23) 1117TypeKind.NULLPTR = TypeKind(24) 1118TypeKind.OVERLOAD = TypeKind(25) 1119TypeKind.DEPENDENT = TypeKind(26) 1120TypeKind.OBJCID = TypeKind(27) 1121TypeKind.OBJCCLASS = TypeKind(28) 1122TypeKind.OBJCSEL = TypeKind(29) 1123TypeKind.COMPLEX = TypeKind(100) 1124TypeKind.POINTER = TypeKind(101) 1125TypeKind.BLOCKPOINTER = TypeKind(102) 1126TypeKind.LVALUEREFERENCE = TypeKind(103) 1127TypeKind.RVALUEREFERENCE = TypeKind(104) 1128TypeKind.RECORD = TypeKind(105) 1129TypeKind.ENUM = TypeKind(106) 1130TypeKind.TYPEDEF = TypeKind(107) 1131TypeKind.OBJCINTERFACE = TypeKind(108) 1132TypeKind.OBJCOBJECTPOINTER = TypeKind(109) 1133TypeKind.FUNCTIONNOPROTO = TypeKind(110) 1134TypeKind.FUNCTIONPROTO = TypeKind(111) 1135TypeKind.CONSTANTARRAY = TypeKind(112) 1136TypeKind.VECTOR = TypeKind(113) 1137 1138class Type(Structure): 1139 """ 1140 The type of an element in the abstract syntax tree. 1141 """ 1142 _fields_ = [("_kind_id", c_int), ("data", c_void_p * 2)] 1143 1144 @property 1145 def kind(self): 1146 """Return the kind of this type.""" 1147 return TypeKind.from_id(self._kind_id) 1148 1149 def argument_types(self): 1150 """Retrieve a container for the non-variadic arguments for this type. 1151 1152 The returned object is iterable and indexable. Each item in the 1153 container is a Type instance. 1154 """ 1155 class ArgumentsIterator(collections.Sequence): 1156 def __init__(self, parent): 1157 self.parent = parent 1158 self.length = None 1159 1160 def __len__(self): 1161 if self.length is None: 1162 self.length = Type_get_num_arg_types(self.parent) 1163 1164 return self.length 1165 1166 def __getitem__(self, key): 1167 # FIXME Support slice objects. 1168 if not isinstance(key, int): 1169 raise TypeError("Must supply a non-negative int.") 1170 1171 if key < 0: 1172 raise IndexError("Only non-negative indexes are accepted.") 1173 1174 if key >= len(self): 1175 raise IndexError("Index greater than container length: " 1176 "%d > %d" % ( key, len(self) )) 1177 1178 result = Type_get_arg_type(self.parent, key) 1179 if result.kind == TypeKind.INVALID: 1180 raise IndexError("Argument could not be retrieved.") 1181 1182 return result 1183 1184 assert self.kind == TypeKind.FUNCTIONPROTO 1185 return ArgumentsIterator(self) 1186 1187 @property 1188 def element_type(self): 1189 """Retrieve the Type of elements within this Type. 1190 1191 If accessed on a type that is not an array, complex, or vector type, an 1192 exception will be raised. 1193 """ 1194 result = Type_get_element_type(self) 1195 if result.kind == TypeKind.INVALID: 1196 raise Exception('Element type not available on this type.') 1197 1198 return result 1199 1200 @property 1201 def element_count(self): 1202 """Retrieve the number of elements in this type. 1203 1204 Returns an int. 1205 1206 If the Type is not an array or vector, this raises. 1207 """ 1208 result = Type_get_num_elements(self) 1209 if result < 0: 1210 raise Exception('Type does not have elements.') 1211 1212 return result 1213 1214 @staticmethod 1215 def from_result(res, fn, args): 1216 assert isinstance(res, Type) 1217 return res 1218 1219 def get_canonical(self): 1220 """ 1221 Return the canonical type for a Type. 1222 1223 Clang's type system explicitly models typedefs and all the 1224 ways a specific type can be represented. The canonical type 1225 is the underlying type with all the "sugar" removed. For 1226 example, if 'T' is a typedef for 'int', the canonical type for 1227 'T' would be 'int'. 1228 """ 1229 return Type_get_canonical(self) 1230 1231 def is_const_qualified(self): 1232 """Determine whether a Type has the "const" qualifier set. 1233 1234 This does not look through typedefs that may have added "const" 1235 at a different level. 1236 """ 1237 return Type_is_const_qualified(self) 1238 1239 def is_volatile_qualified(self): 1240 """Determine whether a Type has the "volatile" qualifier set. 1241 1242 This does not look through typedefs that may have added "volatile" 1243 at a different level. 1244 """ 1245 return Type_is_volatile_qualified(self) 1246 1247 def is_restrict_qualified(self): 1248 """Determine whether a Type has the "restrict" qualifier set. 1249 1250 This does not look through typedefs that may have added "restrict" at 1251 a different level. 1252 """ 1253 return Type_is_restrict_qualified(self) 1254 1255 def is_function_variadic(self): 1256 """Determine whether this function Type is a variadic function type.""" 1257 assert self.kind == TypeKind.FUNCTIONPROTO 1258 1259 return Type_is_variadic(self) 1260 1261 def is_pod(self): 1262 """Determine whether this Type represents plain old data (POD).""" 1263 return Type_is_pod(self) 1264 1265 def get_pointee(self): 1266 """ 1267 For pointer types, returns the type of the pointee. 1268 """ 1269 return Type_get_pointee(self) 1270 1271 def get_declaration(self): 1272 """ 1273 Return the cursor for the declaration of the given type. 1274 """ 1275 return Type_get_declaration(self) 1276 1277 def get_result(self): 1278 """ 1279 Retrieve the result type associated with a function type. 1280 """ 1281 return Type_get_result(self) 1282 1283 def get_array_element_type(self): 1284 """ 1285 Retrieve the type of the elements of the array type. 1286 """ 1287 return Type_get_array_element(self) 1288 1289 def get_array_size(self): 1290 """ 1291 Retrieve the size of the constant array. 1292 """ 1293 return Type_get_array_size(self) 1294 1295 def __eq__(self, other): 1296 if type(other) != type(self): 1297 return False 1298 1299 return Type_equal(self, other) 1300 1301 def __ne__(self, other): 1302 return not self.__eq__(other) 1303 1304## CIndex Objects ## 1305 1306# CIndex objects (derived from ClangObject) are essentially lightweight 1307# wrappers attached to some underlying object, which is exposed via CIndex as 1308# a void*. 1309 1310class ClangObject(object): 1311 """ 1312 A helper for Clang objects. This class helps act as an intermediary for 1313 the ctypes library and the Clang CIndex library. 1314 """ 1315 def __init__(self, obj): 1316 assert isinstance(obj, c_object_p) and obj 1317 self.obj = self._as_parameter_ = obj 1318 1319 def from_param(self): 1320 return self._as_parameter_ 1321 1322 1323class _CXUnsavedFile(Structure): 1324 """Helper for passing unsaved file arguments.""" 1325 _fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)] 1326 1327## Diagnostic Conversion ## 1328 1329_clang_getNumDiagnostics = lib.clang_getNumDiagnostics 1330_clang_getNumDiagnostics.argtypes = [c_object_p] 1331_clang_getNumDiagnostics.restype = c_uint 1332 1333_clang_getDiagnostic = lib.clang_getDiagnostic 1334_clang_getDiagnostic.argtypes = [c_object_p, c_uint] 1335_clang_getDiagnostic.restype = c_object_p 1336 1337_clang_disposeDiagnostic = lib.clang_disposeDiagnostic 1338_clang_disposeDiagnostic.argtypes = [Diagnostic] 1339 1340_clang_getDiagnosticSeverity = lib.clang_getDiagnosticSeverity 1341_clang_getDiagnosticSeverity.argtypes = [Diagnostic] 1342_clang_getDiagnosticSeverity.restype = c_int 1343 1344_clang_getDiagnosticLocation = lib.clang_getDiagnosticLocation 1345_clang_getDiagnosticLocation.argtypes = [Diagnostic] 1346_clang_getDiagnosticLocation.restype = SourceLocation 1347 1348_clang_getDiagnosticSpelling = lib.clang_getDiagnosticSpelling 1349_clang_getDiagnosticSpelling.argtypes = [Diagnostic] 1350_clang_getDiagnosticSpelling.restype = _CXString 1351_clang_getDiagnosticSpelling.errcheck = _CXString.from_result 1352 1353_clang_getDiagnosticNumRanges = lib.clang_getDiagnosticNumRanges 1354_clang_getDiagnosticNumRanges.argtypes = [Diagnostic] 1355_clang_getDiagnosticNumRanges.restype = c_uint 1356 1357_clang_getDiagnosticRange = lib.clang_getDiagnosticRange 1358_clang_getDiagnosticRange.argtypes = [Diagnostic, c_uint] 1359_clang_getDiagnosticRange.restype = SourceRange 1360 1361_clang_getDiagnosticNumFixIts = lib.clang_getDiagnosticNumFixIts 1362_clang_getDiagnosticNumFixIts.argtypes = [Diagnostic] 1363_clang_getDiagnosticNumFixIts.restype = c_uint 1364 1365_clang_getDiagnosticFixIt = lib.clang_getDiagnosticFixIt 1366_clang_getDiagnosticFixIt.argtypes = [Diagnostic, c_uint, POINTER(SourceRange)] 1367_clang_getDiagnosticFixIt.restype = _CXString 1368_clang_getDiagnosticFixIt.errcheck = _CXString.from_result 1369 1370_clang_getDiagnosticCategory = lib.clang_getDiagnosticCategory 1371_clang_getDiagnosticCategory.argtypes = [Diagnostic] 1372_clang_getDiagnosticCategory.restype = c_uint 1373 1374_clang_getDiagnosticCategoryName = lib.clang_getDiagnosticCategoryName 1375_clang_getDiagnosticCategoryName.argtypes = [c_uint] 1376_clang_getDiagnosticCategoryName.restype = _CXString 1377_clang_getDiagnosticCategoryName.errcheck = _CXString.from_result 1378 1379_clang_getDiagnosticOption = lib.clang_getDiagnosticOption 1380_clang_getDiagnosticOption.argtypes = [Diagnostic, POINTER(_CXString)] 1381_clang_getDiagnosticOption.restype = _CXString 1382_clang_getDiagnosticOption.errcheck = _CXString.from_result 1383 1384### 1385 1386class CompletionChunk: 1387 class Kind: 1388 def __init__(self, name): 1389 self.name = name 1390 1391 def __str__(self): 1392 return self.name 1393 1394 def __repr__(self): 1395 return "<ChunkKind: %s>" % self 1396 1397 def __init__(self, completionString, key): 1398 self.cs = completionString 1399 self.key = key 1400 1401 def __repr__(self): 1402 return "{'" + self.spelling + "', " + str(self.kind) + "}" 1403 1404 @property 1405 def spelling(self): 1406 return _clang_getCompletionChunkText(self.cs, self.key).spelling 1407 1408 @property 1409 def kind(self): 1410 res = _clang_getCompletionChunkKind(self.cs, self.key) 1411 return completionChunkKindMap[res] 1412 1413 @property 1414 def string(self): 1415 res = _clang_getCompletionChunkCompletionString(self.cs, self.key) 1416 1417 if (res): 1418 return CompletionString(res) 1419 else: 1420 None 1421 1422 def isKindOptional(self): 1423 return self.kind == completionChunkKindMap[0] 1424 1425 def isKindTypedText(self): 1426 return self.kind == completionChunkKindMap[1] 1427 1428 def isKindPlaceHolder(self): 1429 return self.kind == completionChunkKindMap[3] 1430 1431 def isKindInformative(self): 1432 return self.kind == completionChunkKindMap[4] 1433 1434 def isKindResultType(self): 1435 return self.kind == completionChunkKindMap[15] 1436 1437completionChunkKindMap = { 1438 0: CompletionChunk.Kind("Optional"), 1439 1: CompletionChunk.Kind("TypedText"), 1440 2: CompletionChunk.Kind("Text"), 1441 3: CompletionChunk.Kind("Placeholder"), 1442 4: CompletionChunk.Kind("Informative"), 1443 5: CompletionChunk.Kind("CurrentParameter"), 1444 6: CompletionChunk.Kind("LeftParen"), 1445 7: CompletionChunk.Kind("RightParen"), 1446 8: CompletionChunk.Kind("LeftBracket"), 1447 9: CompletionChunk.Kind("RightBracket"), 1448 10: CompletionChunk.Kind("LeftBrace"), 1449 11: CompletionChunk.Kind("RightBrace"), 1450 12: CompletionChunk.Kind("LeftAngle"), 1451 13: CompletionChunk.Kind("RightAngle"), 1452 14: CompletionChunk.Kind("Comma"), 1453 15: CompletionChunk.Kind("ResultType"), 1454 16: CompletionChunk.Kind("Colon"), 1455 17: CompletionChunk.Kind("SemiColon"), 1456 18: CompletionChunk.Kind("Equal"), 1457 19: CompletionChunk.Kind("HorizontalSpace"), 1458 20: CompletionChunk.Kind("VerticalSpace")} 1459 1460class CompletionString(ClangObject): 1461 class Availability: 1462 def __init__(self, name): 1463 self.name = name 1464 1465 def __str__(self): 1466 return self.name 1467 1468 def __repr__(self): 1469 return "<Availability: %s>" % self 1470 1471 def __len__(self): 1472 return _clang_getNumCompletionChunks(self.obj) 1473 1474 def __getitem__(self, key): 1475 if len(self) <= key: 1476 raise IndexError 1477 return CompletionChunk(self.obj, key) 1478 1479 @property 1480 def priority(self): 1481 return _clang_getCompletionPriority(self.obj) 1482 1483 @property 1484 def availability(self): 1485 res = _clang_getCompletionAvailability(self.obj) 1486 return availabilityKinds[res] 1487 1488 def __repr__(self): 1489 return " | ".join([str(a) for a in self]) \ 1490 + " || Priority: " + str(self.priority) \ 1491 + " || Availability: " + str(self.availability) 1492 1493availabilityKinds = { 1494 0: CompletionChunk.Kind("Available"), 1495 1: CompletionChunk.Kind("Deprecated"), 1496 2: CompletionChunk.Kind("NotAvailable")} 1497 1498class CodeCompletionResult(Structure): 1499 _fields_ = [('cursorKind', c_int), ('completionString', c_object_p)] 1500 1501 def __repr__(self): 1502 return str(CompletionString(self.completionString)) 1503 1504 @property 1505 def kind(self): 1506 return CursorKind.from_id(self.cursorKind) 1507 1508 @property 1509 def string(self): 1510 return CompletionString(self.completionString) 1511 1512class CCRStructure(Structure): 1513 _fields_ = [('results', POINTER(CodeCompletionResult)), 1514 ('numResults', c_int)] 1515 1516 def __len__(self): 1517 return self.numResults 1518 1519 def __getitem__(self, key): 1520 if len(self) <= key: 1521 raise IndexError 1522 1523 return self.results[key] 1524 1525class CodeCompletionResults(ClangObject): 1526 def __init__(self, ptr): 1527 assert isinstance(ptr, POINTER(CCRStructure)) and ptr 1528 self.ptr = self._as_parameter_ = ptr 1529 1530 def from_param(self): 1531 return self._as_parameter_ 1532 1533 def __del__(self): 1534 CodeCompletionResults_dispose(self) 1535 1536 @property 1537 def results(self): 1538 return self.ptr.contents 1539 1540 @property 1541 def diagnostics(self): 1542 class DiagnosticsItr: 1543 def __init__(self, ccr): 1544 self.ccr= ccr 1545 1546 def __len__(self): 1547 return int(_clang_codeCompleteGetNumDiagnostics(self.ccr)) 1548 1549 def __getitem__(self, key): 1550 return _clang_codeCompleteGetDiagnostic(self.ccr, key) 1551 1552 return DiagnosticsItr(self) 1553 1554 1555class Index(ClangObject): 1556 """ 1557 The Index type provides the primary interface to the Clang CIndex library, 1558 primarily by providing an interface for reading and parsing translation 1559 units. 1560 """ 1561 1562 @staticmethod 1563 def create(excludeDecls=False): 1564 """ 1565 Create a new Index. 1566 Parameters: 1567 excludeDecls -- Exclude local declarations from translation units. 1568 """ 1569 return Index(Index_create(excludeDecls, 0)) 1570 1571 def __del__(self): 1572 Index_dispose(self) 1573 1574 def read(self, path): 1575 """Load the translation unit from the given AST file.""" 1576 ptr = TranslationUnit_read(self, path) 1577 if ptr: 1578 return TranslationUnit(ptr) 1579 return None 1580 1581 def parse(self, path, args = [], unsaved_files = [], options = 0): 1582 """ 1583 Load the translation unit from the given source code file by running 1584 clang and generating the AST before loading. Additional command line 1585 parameters can be passed to clang via the args parameter. 1586 1587 In-memory contents for files can be provided by passing a list of pairs 1588 to as unsaved_files, the first item should be the filenames to be mapped 1589 and the second should be the contents to be substituted for the 1590 file. The contents may be passed as strings or file objects. 1591 """ 1592 arg_array = 0 1593 if len(args): 1594 arg_array = (c_char_p * len(args))(* args) 1595 unsaved_files_array = 0 1596 if len(unsaved_files): 1597 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1598 for i,(name,value) in enumerate(unsaved_files): 1599 if not isinstance(value, str): 1600 # FIXME: It would be great to support an efficient version 1601 # of this, one day. 1602 value = value.read() 1603 print value 1604 if not isinstance(value, str): 1605 raise TypeError,'Unexpected unsaved file contents.' 1606 unsaved_files_array[i].name = name 1607 unsaved_files_array[i].contents = value 1608 unsaved_files_array[i].length = len(value) 1609 ptr = TranslationUnit_parse(self, path, arg_array, len(args), 1610 unsaved_files_array, len(unsaved_files), 1611 options) 1612 if ptr: 1613 return TranslationUnit(ptr) 1614 return None 1615 1616 1617class TranslationUnit(ClangObject): 1618 """ 1619 The TranslationUnit class represents a source code translation unit and 1620 provides read-only access to its top-level declarations. 1621 """ 1622 1623 def __init__(self, ptr): 1624 ClangObject.__init__(self, ptr) 1625 1626 def __del__(self): 1627 TranslationUnit_dispose(self) 1628 1629 @property 1630 def cursor(self): 1631 """Retrieve the cursor that represents the given translation unit.""" 1632 return TranslationUnit_cursor(self) 1633 1634 @property 1635 def spelling(self): 1636 """Get the original translation unit source file name.""" 1637 return TranslationUnit_spelling(self) 1638 1639 def get_includes(self): 1640 """ 1641 Return an iterable sequence of FileInclusion objects that describe the 1642 sequence of inclusions in a translation unit. The first object in 1643 this sequence is always the input file. Note that this method will not 1644 recursively iterate over header files included through precompiled 1645 headers. 1646 """ 1647 def visitor(fobj, lptr, depth, includes): 1648 if depth > 0: 1649 loc = lptr.contents 1650 includes.append(FileInclusion(loc.file, File(fobj), loc, depth)) 1651 1652 # Automatically adapt CIndex/ctype pointers to python objects 1653 includes = [] 1654 TranslationUnit_includes(self, 1655 TranslationUnit_includes_callback(visitor), 1656 includes) 1657 return iter(includes) 1658 1659 @property 1660 def diagnostics(self): 1661 """ 1662 Return an iterable (and indexable) object containing the diagnostics. 1663 """ 1664 class DiagIterator: 1665 def __init__(self, tu): 1666 self.tu = tu 1667 1668 def __len__(self): 1669 return int(_clang_getNumDiagnostics(self.tu)) 1670 1671 def __getitem__(self, key): 1672 diag = _clang_getDiagnostic(self.tu, key) 1673 if not diag: 1674 raise IndexError 1675 return Diagnostic(diag) 1676 1677 return DiagIterator(self) 1678 1679 def reparse(self, unsaved_files = [], options = 0): 1680 """ 1681 Reparse an already parsed translation unit. 1682 1683 In-memory contents for files can be provided by passing a list of pairs 1684 as unsaved_files, the first items should be the filenames to be mapped 1685 and the second should be the contents to be substituted for the 1686 file. The contents may be passed as strings or file objects. 1687 """ 1688 unsaved_files_array = 0 1689 if len(unsaved_files): 1690 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1691 for i,(name,value) in enumerate(unsaved_files): 1692 if not isinstance(value, str): 1693 # FIXME: It would be great to support an efficient version 1694 # of this, one day. 1695 value = value.read() 1696 print value 1697 if not isinstance(value, str): 1698 raise TypeError,'Unexpected unsaved file contents.' 1699 unsaved_files_array[i].name = name 1700 unsaved_files_array[i].contents = value 1701 unsaved_files_array[i].length = len(value) 1702 ptr = TranslationUnit_reparse(self, len(unsaved_files), 1703 unsaved_files_array, 1704 options) 1705 def codeComplete(self, path, line, column, unsaved_files = [], options = 0): 1706 """ 1707 Code complete in this translation unit. 1708 1709 In-memory contents for files can be provided by passing a list of pairs 1710 as unsaved_files, the first items should be the filenames to be mapped 1711 and the second should be the contents to be substituted for the 1712 file. The contents may be passed as strings or file objects. 1713 """ 1714 unsaved_files_array = 0 1715 if len(unsaved_files): 1716 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1717 for i,(name,value) in enumerate(unsaved_files): 1718 if not isinstance(value, str): 1719 # FIXME: It would be great to support an efficient version 1720 # of this, one day. 1721 value = value.read() 1722 print value 1723 if not isinstance(value, str): 1724 raise TypeError,'Unexpected unsaved file contents.' 1725 unsaved_files_array[i].name = name 1726 unsaved_files_array[i].contents = value 1727 unsaved_files_array[i].length = len(value) 1728 ptr = TranslationUnit_codeComplete(self, path, 1729 line, column, 1730 unsaved_files_array, 1731 len(unsaved_files), 1732 options) 1733 if ptr: 1734 return CodeCompletionResults(ptr) 1735 return None 1736 1737class File(ClangObject): 1738 """ 1739 The File class represents a particular source file that is part of a 1740 translation unit. 1741 """ 1742 1743 @staticmethod 1744 def from_name(translation_unit, file_name): 1745 """Retrieve a file handle within the given translation unit.""" 1746 return File(File_getFile(translation_unit, file_name)) 1747 1748 @property 1749 def name(self): 1750 """Return the complete file and path name of the file.""" 1751 return _CXString_getCString(File_name(self)) 1752 1753 @property 1754 def time(self): 1755 """Return the last modification time of the file.""" 1756 return File_time(self) 1757 1758 def __str__(self): 1759 return self.name 1760 1761 def __repr__(self): 1762 return "<File: %s>" % (self.name) 1763 1764class FileInclusion(object): 1765 """ 1766 The FileInclusion class represents the inclusion of one source file by 1767 another via a '#include' directive or as the input file for the translation 1768 unit. This class provides information about the included file, the including 1769 file, the location of the '#include' directive and the depth of the included 1770 file in the stack. Note that the input file has depth 0. 1771 """ 1772 1773 def __init__(self, src, tgt, loc, depth): 1774 self.source = src 1775 self.include = tgt 1776 self.location = loc 1777 self.depth = depth 1778 1779 @property 1780 def is_input_file(self): 1781 """True if the included file is the input file.""" 1782 return self.depth == 0 1783 1784# Additional Functions and Types 1785 1786# String Functions 1787_CXString_dispose = lib.clang_disposeString 1788_CXString_dispose.argtypes = [_CXString] 1789 1790_CXString_getCString = lib.clang_getCString 1791_CXString_getCString.argtypes = [_CXString] 1792_CXString_getCString.restype = c_char_p 1793 1794# Source Location Functions 1795SourceLocation_loc = lib.clang_getInstantiationLocation 1796SourceLocation_loc.argtypes = [SourceLocation, POINTER(c_object_p), 1797 POINTER(c_uint), POINTER(c_uint), 1798 POINTER(c_uint)] 1799 1800SourceLocation_getLocation = lib.clang_getLocation 1801SourceLocation_getLocation.argtypes = [TranslationUnit, File, c_uint, c_uint] 1802SourceLocation_getLocation.restype = SourceLocation 1803 1804SourceLocation_equalLocations = lib.clang_equalLocations 1805SourceLocation_equalLocations.argtypes = [SourceLocation, SourceLocation] 1806SourceLocation_equalLocations.restype = bool 1807 1808# Source Range Functions 1809SourceRange_getRange = lib.clang_getRange 1810SourceRange_getRange.argtypes = [SourceLocation, SourceLocation] 1811SourceRange_getRange.restype = SourceRange 1812 1813SourceRange_start = lib.clang_getRangeStart 1814SourceRange_start.argtypes = [SourceRange] 1815SourceRange_start.restype = SourceLocation 1816 1817SourceRange_end = lib.clang_getRangeEnd 1818SourceRange_end.argtypes = [SourceRange] 1819SourceRange_end.restype = SourceLocation 1820 1821SourceRange_equalRanges = lib.clang_equalRanges 1822SourceRange_equalRanges.argtypes = [SourceRange, SourceRange] 1823SourceRange_equalRanges.restype = bool 1824 1825# CursorKind Functions 1826CursorKind_is_decl = lib.clang_isDeclaration 1827CursorKind_is_decl.argtypes = [CursorKind] 1828CursorKind_is_decl.restype = bool 1829 1830CursorKind_is_ref = lib.clang_isReference 1831CursorKind_is_ref.argtypes = [CursorKind] 1832CursorKind_is_ref.restype = bool 1833 1834CursorKind_is_expr = lib.clang_isExpression 1835CursorKind_is_expr.argtypes = [CursorKind] 1836CursorKind_is_expr.restype = bool 1837 1838CursorKind_is_stmt = lib.clang_isStatement 1839CursorKind_is_stmt.argtypes = [CursorKind] 1840CursorKind_is_stmt.restype = bool 1841 1842CursorKind_is_attribute = lib.clang_isAttribute 1843CursorKind_is_attribute.argtypes = [CursorKind] 1844CursorKind_is_attribute.restype = bool 1845 1846CursorKind_is_inv = lib.clang_isInvalid 1847CursorKind_is_inv.argtypes = [CursorKind] 1848CursorKind_is_inv.restype = bool 1849 1850CursorKind_is_translation_unit = lib.clang_isTranslationUnit 1851CursorKind_is_translation_unit.argtypes = [CursorKind] 1852CursorKind_is_translation_unit.restype = bool 1853 1854CursorKind_is_preprocessing = lib.clang_isPreprocessing 1855CursorKind_is_preprocessing.argtypes = [CursorKind] 1856CursorKind_is_preprocessing.restype = bool 1857 1858CursorKind_is_unexposed = lib.clang_isUnexposed 1859CursorKind_is_unexposed.argtypes = [CursorKind] 1860CursorKind_is_unexposed.restype = bool 1861 1862# Cursor Functions 1863# TODO: Implement this function 1864Cursor_get = lib.clang_getCursor 1865Cursor_get.argtypes = [TranslationUnit, SourceLocation] 1866Cursor_get.restype = Cursor 1867 1868Cursor_null = lib.clang_getNullCursor 1869Cursor_null.restype = Cursor 1870 1871Cursor_usr = lib.clang_getCursorUSR 1872Cursor_usr.argtypes = [Cursor] 1873Cursor_usr.restype = _CXString 1874Cursor_usr.errcheck = _CXString.from_result 1875 1876Cursor_is_def = lib.clang_isCursorDefinition 1877Cursor_is_def.argtypes = [Cursor] 1878Cursor_is_def.restype = bool 1879 1880Cursor_def = lib.clang_getCursorDefinition 1881Cursor_def.argtypes = [Cursor] 1882Cursor_def.restype = Cursor 1883Cursor_def.errcheck = Cursor.from_result 1884 1885Cursor_eq = lib.clang_equalCursors 1886Cursor_eq.argtypes = [Cursor, Cursor] 1887Cursor_eq.restype = bool 1888 1889Cursor_hash = lib.clang_hashCursor 1890Cursor_hash.argtypes = [Cursor] 1891Cursor_hash.restype = c_uint 1892 1893Cursor_spelling = lib.clang_getCursorSpelling 1894Cursor_spelling.argtypes = [Cursor] 1895Cursor_spelling.restype = _CXString 1896Cursor_spelling.errcheck = _CXString.from_result 1897 1898Cursor_displayname = lib.clang_getCursorDisplayName 1899Cursor_displayname.argtypes = [Cursor] 1900Cursor_displayname.restype = _CXString 1901Cursor_displayname.errcheck = _CXString.from_result 1902 1903Cursor_loc = lib.clang_getCursorLocation 1904Cursor_loc.argtypes = [Cursor] 1905Cursor_loc.restype = SourceLocation 1906 1907Cursor_extent = lib.clang_getCursorExtent 1908Cursor_extent.argtypes = [Cursor] 1909Cursor_extent.restype = SourceRange 1910 1911Cursor_ref = lib.clang_getCursorReferenced 1912Cursor_ref.argtypes = [Cursor] 1913Cursor_ref.restype = Cursor 1914Cursor_ref.errcheck = Cursor.from_result 1915 1916Cursor_type = lib.clang_getCursorType 1917Cursor_type.argtypes = [Cursor] 1918Cursor_type.restype = Type 1919Cursor_type.errcheck = Type.from_result 1920 1921Cursor_underlying_type = lib.clang_getTypedefDeclUnderlyingType 1922Cursor_underlying_type.argtypes = [Cursor] 1923Cursor_underlying_type.restype = Type 1924Cursor_underlying_type.errcheck = Type.from_result 1925 1926Cursor_enum_type = lib.clang_getEnumDeclIntegerType 1927Cursor_enum_type.argtypes = [Cursor] 1928Cursor_enum_type.restype = Type 1929Cursor_enum_type.errcheck = Type.from_result 1930 1931Cursor_objc_type_encoding = lib.clang_getDeclObjCTypeEncoding 1932Cursor_objc_type_encoding.argtypes = [Cursor] 1933Cursor_objc_type_encoding.restype = _CXString 1934Cursor_objc_type_encoding.errcheck = _CXString.from_result 1935 1936Cursor_visit_callback = CFUNCTYPE(c_int, Cursor, Cursor, py_object) 1937Cursor_visit = lib.clang_visitChildren 1938Cursor_visit.argtypes = [Cursor, Cursor_visit_callback, py_object] 1939Cursor_visit.restype = c_uint 1940 1941# Type Functions 1942Type_get_canonical = lib.clang_getCanonicalType 1943Type_get_canonical.argtypes = [Type] 1944Type_get_canonical.restype = Type 1945Type_get_canonical.errcheck = Type.from_result 1946 1947Type_is_const_qualified = lib.clang_isConstQualifiedType 1948Type_is_const_qualified.argtypes = [Type] 1949Type_is_const_qualified.restype = bool 1950 1951Type_is_volatile_qualified = lib.clang_isVolatileQualifiedType 1952Type_is_volatile_qualified.argtypes = [Type] 1953Type_is_volatile_qualified.restype = bool 1954 1955Type_is_restrict_qualified = lib.clang_isRestrictQualifiedType 1956Type_is_restrict_qualified.argtypes = [Type] 1957Type_is_restrict_qualified.restype = bool 1958 1959Type_is_pod = lib.clang_isPODType 1960Type_is_pod.argtypes = [Type] 1961Type_is_pod.restype = bool 1962 1963Type_is_variadic = lib.clang_isFunctionTypeVariadic 1964Type_is_variadic.argtypes = [Type] 1965Type_is_variadic.restype = bool 1966 1967Type_get_pointee = lib.clang_getPointeeType 1968Type_get_pointee.argtypes = [Type] 1969Type_get_pointee.restype = Type 1970Type_get_pointee.errcheck = Type.from_result 1971 1972Type_get_declaration = lib.clang_getTypeDeclaration 1973Type_get_declaration.argtypes = [Type] 1974Type_get_declaration.restype = Cursor 1975Type_get_declaration.errcheck = Cursor.from_result 1976 1977Type_get_result = lib.clang_getResultType 1978Type_get_result.argtypes = [Type] 1979Type_get_result.restype = Type 1980Type_get_result.errcheck = Type.from_result 1981 1982Type_get_num_arg_types = lib.clang_getNumArgTypes 1983Type_get_num_arg_types.argtypes = [Type] 1984Type_get_num_arg_types.restype = c_uint 1985 1986Type_get_arg_type = lib.clang_getArgType 1987Type_get_arg_type.argtypes = [Type, c_uint] 1988Type_get_arg_type.restype = Type 1989Type_get_arg_type.errcheck = Type.from_result 1990Type_get_element_type = lib.clang_getElementType 1991 1992Type_get_element_type.argtypes = [Type] 1993Type_get_element_type.restype = Type 1994Type_get_element_type.errcheck = Type.from_result 1995 1996Type_get_num_elements = lib.clang_getNumElements 1997Type_get_num_elements.argtypes = [Type] 1998Type_get_num_elements.restype = c_longlong 1999 2000Type_get_array_element = lib.clang_getArrayElementType 2001Type_get_array_element.argtypes = [Type] 2002Type_get_array_element.restype = Type 2003Type_get_array_element.errcheck = Type.from_result 2004 2005Type_get_array_size = lib.clang_getArraySize 2006Type_get_array_size.argtype = [Type] 2007Type_get_array_size.restype = c_longlong 2008 2009Type_equal = lib.clang_equalTypes 2010Type_equal.argtypes = [Type, Type] 2011Type_equal.restype = bool 2012 2013# Index Functions 2014Index_create = lib.clang_createIndex 2015Index_create.argtypes = [c_int, c_int] 2016Index_create.restype = c_object_p 2017 2018Index_dispose = lib.clang_disposeIndex 2019Index_dispose.argtypes = [Index] 2020 2021# Translation Unit Functions 2022TranslationUnit_read = lib.clang_createTranslationUnit 2023TranslationUnit_read.argtypes = [Index, c_char_p] 2024TranslationUnit_read.restype = c_object_p 2025 2026TranslationUnit_parse = lib.clang_parseTranslationUnit 2027TranslationUnit_parse.argtypes = [Index, c_char_p, c_void_p, 2028 c_int, c_void_p, c_int, c_int] 2029TranslationUnit_parse.restype = c_object_p 2030 2031TranslationUnit_reparse = lib.clang_reparseTranslationUnit 2032TranslationUnit_reparse.argtypes = [TranslationUnit, c_int, c_void_p, c_int] 2033TranslationUnit_reparse.restype = c_int 2034 2035TranslationUnit_codeComplete = lib.clang_codeCompleteAt 2036TranslationUnit_codeComplete.argtypes = [TranslationUnit, c_char_p, c_int, 2037 c_int, c_void_p, c_int, c_int] 2038TranslationUnit_codeComplete.restype = POINTER(CCRStructure) 2039 2040TranslationUnit_cursor = lib.clang_getTranslationUnitCursor 2041TranslationUnit_cursor.argtypes = [TranslationUnit] 2042TranslationUnit_cursor.restype = Cursor 2043TranslationUnit_cursor.errcheck = Cursor.from_result 2044 2045TranslationUnit_spelling = lib.clang_getTranslationUnitSpelling 2046TranslationUnit_spelling.argtypes = [TranslationUnit] 2047TranslationUnit_spelling.restype = _CXString 2048TranslationUnit_spelling.errcheck = _CXString.from_result 2049 2050TranslationUnit_dispose = lib.clang_disposeTranslationUnit 2051TranslationUnit_dispose.argtypes = [TranslationUnit] 2052 2053TranslationUnit_includes_callback = CFUNCTYPE(None, 2054 c_object_p, 2055 POINTER(SourceLocation), 2056 c_uint, py_object) 2057TranslationUnit_includes = lib.clang_getInclusions 2058TranslationUnit_includes.argtypes = [TranslationUnit, 2059 TranslationUnit_includes_callback, 2060 py_object] 2061 2062# File Functions 2063File_getFile = lib.clang_getFile 2064File_getFile.argtypes = [TranslationUnit, c_char_p] 2065File_getFile.restype = c_object_p 2066 2067File_name = lib.clang_getFileName 2068File_name.argtypes = [File] 2069File_name.restype = _CXString 2070 2071File_time = lib.clang_getFileTime 2072File_time.argtypes = [File] 2073File_time.restype = c_uint 2074 2075# Code completion 2076 2077CodeCompletionResults_dispose = lib.clang_disposeCodeCompleteResults 2078CodeCompletionResults_dispose.argtypes = [CodeCompletionResults] 2079 2080_clang_codeCompleteGetNumDiagnostics = lib.clang_codeCompleteGetNumDiagnostics 2081_clang_codeCompleteGetNumDiagnostics.argtypes = [CodeCompletionResults] 2082_clang_codeCompleteGetNumDiagnostics.restype = c_int 2083 2084_clang_codeCompleteGetDiagnostic = lib.clang_codeCompleteGetDiagnostic 2085_clang_codeCompleteGetDiagnostic.argtypes = [CodeCompletionResults, c_int] 2086_clang_codeCompleteGetDiagnostic.restype = Diagnostic 2087 2088_clang_getCompletionChunkText = lib.clang_getCompletionChunkText 2089_clang_getCompletionChunkText.argtypes = [c_void_p, c_int] 2090_clang_getCompletionChunkText.restype = _CXString 2091 2092_clang_getCompletionChunkKind = lib.clang_getCompletionChunkKind 2093_clang_getCompletionChunkKind.argtypes = [c_void_p, c_int] 2094_clang_getCompletionChunkKind.restype = c_int 2095 2096_clang_getCompletionChunkCompletionString = lib.clang_getCompletionChunkCompletionString 2097_clang_getCompletionChunkCompletionString.argtypes = [c_void_p, c_int] 2098_clang_getCompletionChunkCompletionString.restype = c_object_p 2099 2100_clang_getNumCompletionChunks = lib.clang_getNumCompletionChunks 2101_clang_getNumCompletionChunks.argtypes = [c_void_p] 2102_clang_getNumCompletionChunks.restype = c_int 2103 2104_clang_getCompletionAvailability = lib.clang_getCompletionAvailability 2105_clang_getCompletionAvailability.argtypes = [c_void_p] 2106_clang_getCompletionAvailability.restype = c_int 2107 2108_clang_getCompletionPriority = lib.clang_getCompletionPriority 2109_clang_getCompletionPriority.argtypes = [c_void_p] 2110_clang_getCompletionPriority.restype = c_int 2111 2112 2113### 2114 2115__all__ = ['Index', 'TranslationUnit', 'Cursor', 'CursorKind', 'Type', 'TypeKind', 2116 'Diagnostic', 'FixIt', 'CodeCompletionResults', 'SourceRange', 2117 'SourceLocation', 'File'] 2118