cindex.py revision 8261345a32e58dfb5f4269ed92e1608a4ec3379a
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 Cursor_eq(self, 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 hash(self): 1012 """Returns a hash of the cursor as an int.""" 1013 if not hasattr(self, '_hash'): 1014 self._hash = Cursor_hash(self) 1015 1016 return self._hash 1017 1018 def get_children(self): 1019 """Return an iterator for accessing the children of this cursor.""" 1020 1021 # FIXME: Expose iteration from CIndex, PR6125. 1022 def visitor(child, parent, children): 1023 # FIXME: Document this assertion in API. 1024 # FIXME: There should just be an isNull method. 1025 assert child != Cursor_null() 1026 children.append(child) 1027 return 1 # continue 1028 children = [] 1029 Cursor_visit(self, Cursor_visit_callback(visitor), children) 1030 return iter(children) 1031 1032 @staticmethod 1033 def from_result(res, fn, args): 1034 assert isinstance(res, Cursor) 1035 # FIXME: There should just be an isNull method. 1036 if res == Cursor_null(): 1037 return None 1038 return res 1039 1040 1041### Type Kinds ### 1042 1043class TypeKind(object): 1044 """ 1045 Describes the kind of type. 1046 """ 1047 1048 # The unique kind objects, indexed by id. 1049 _kinds = [] 1050 _name_map = None 1051 1052 def __init__(self, value): 1053 if value >= len(TypeKind._kinds): 1054 TypeKind._kinds += [None] * (value - len(TypeKind._kinds) + 1) 1055 if TypeKind._kinds[value] is not None: 1056 raise ValueError,'TypeKind already loaded' 1057 self.value = value 1058 TypeKind._kinds[value] = self 1059 TypeKind._name_map = None 1060 1061 def from_param(self): 1062 return self.value 1063 1064 @property 1065 def name(self): 1066 """Get the enumeration name of this cursor kind.""" 1067 if self._name_map is None: 1068 self._name_map = {} 1069 for key,value in TypeKind.__dict__.items(): 1070 if isinstance(value,TypeKind): 1071 self._name_map[value] = key 1072 return self._name_map[self] 1073 1074 @staticmethod 1075 def from_id(id): 1076 if id >= len(TypeKind._kinds) or TypeKind._kinds[id] is None: 1077 raise ValueError,'Unknown type kind %d' % id 1078 return TypeKind._kinds[id] 1079 1080 def __repr__(self): 1081 return 'TypeKind.%s' % (self.name,) 1082 1083 1084 1085TypeKind.INVALID = TypeKind(0) 1086TypeKind.UNEXPOSED = TypeKind(1) 1087TypeKind.VOID = TypeKind(2) 1088TypeKind.BOOL = TypeKind(3) 1089TypeKind.CHAR_U = TypeKind(4) 1090TypeKind.UCHAR = TypeKind(5) 1091TypeKind.CHAR16 = TypeKind(6) 1092TypeKind.CHAR32 = TypeKind(7) 1093TypeKind.USHORT = TypeKind(8) 1094TypeKind.UINT = TypeKind(9) 1095TypeKind.ULONG = TypeKind(10) 1096TypeKind.ULONGLONG = TypeKind(11) 1097TypeKind.UINT128 = TypeKind(12) 1098TypeKind.CHAR_S = TypeKind(13) 1099TypeKind.SCHAR = TypeKind(14) 1100TypeKind.WCHAR = TypeKind(15) 1101TypeKind.SHORT = TypeKind(16) 1102TypeKind.INT = TypeKind(17) 1103TypeKind.LONG = TypeKind(18) 1104TypeKind.LONGLONG = TypeKind(19) 1105TypeKind.INT128 = TypeKind(20) 1106TypeKind.FLOAT = TypeKind(21) 1107TypeKind.DOUBLE = TypeKind(22) 1108TypeKind.LONGDOUBLE = TypeKind(23) 1109TypeKind.NULLPTR = TypeKind(24) 1110TypeKind.OVERLOAD = TypeKind(25) 1111TypeKind.DEPENDENT = TypeKind(26) 1112TypeKind.OBJCID = TypeKind(27) 1113TypeKind.OBJCCLASS = TypeKind(28) 1114TypeKind.OBJCSEL = TypeKind(29) 1115TypeKind.COMPLEX = TypeKind(100) 1116TypeKind.POINTER = TypeKind(101) 1117TypeKind.BLOCKPOINTER = TypeKind(102) 1118TypeKind.LVALUEREFERENCE = TypeKind(103) 1119TypeKind.RVALUEREFERENCE = TypeKind(104) 1120TypeKind.RECORD = TypeKind(105) 1121TypeKind.ENUM = TypeKind(106) 1122TypeKind.TYPEDEF = TypeKind(107) 1123TypeKind.OBJCINTERFACE = TypeKind(108) 1124TypeKind.OBJCOBJECTPOINTER = TypeKind(109) 1125TypeKind.FUNCTIONNOPROTO = TypeKind(110) 1126TypeKind.FUNCTIONPROTO = TypeKind(111) 1127TypeKind.CONSTANTARRAY = TypeKind(112) 1128TypeKind.VECTOR = TypeKind(113) 1129 1130class Type(Structure): 1131 """ 1132 The type of an element in the abstract syntax tree. 1133 """ 1134 _fields_ = [("_kind_id", c_int), ("data", c_void_p * 2)] 1135 1136 @property 1137 def kind(self): 1138 """Return the kind of this type.""" 1139 return TypeKind.from_id(self._kind_id) 1140 1141 def argument_types(self): 1142 """Retrieve a container for the non-variadic arguments for this type. 1143 1144 The returned object is iterable and indexable. Each item in the 1145 container is a Type instance. 1146 """ 1147 class ArgumentsIterator(collections.Sequence): 1148 def __init__(self, parent): 1149 self.parent = parent 1150 self.length = None 1151 1152 def __len__(self): 1153 if self.length is None: 1154 self.length = Type_get_num_arg_types(self.parent) 1155 1156 return self.length 1157 1158 def __getitem__(self, key): 1159 # FIXME Support slice objects. 1160 if not isinstance(key, int): 1161 raise TypeError("Must supply a non-negative int.") 1162 1163 if key < 0: 1164 raise IndexError("Only non-negative indexes are accepted.") 1165 1166 if key >= len(self): 1167 raise IndexError("Index greater than container length: " 1168 "%d > %d" % ( key, len(self) )) 1169 1170 result = Type_get_arg_type(self.parent, key) 1171 if result.kind == TypeKind.INVALID: 1172 raise IndexError("Argument could not be retrieved.") 1173 1174 return result 1175 1176 assert self.kind == TypeKind.FUNCTIONPROTO 1177 return ArgumentsIterator(self) 1178 1179 @property 1180 def element_type(self): 1181 """Retrieve the Type of elements within this Type. 1182 1183 If accessed on a type that is not an array, complex, or vector type, an 1184 exception will be raised. 1185 """ 1186 result = Type_get_element_type(self) 1187 if result.kind == TypeKind.INVALID: 1188 raise Exception('Element type not available on this type.') 1189 1190 return result 1191 1192 @property 1193 def element_count(self): 1194 """Retrieve the number of elements in this type. 1195 1196 Returns an int. 1197 1198 If the Type is not an array or vector, this raises. 1199 """ 1200 result = Type_get_num_elements(self) 1201 if result < 0: 1202 raise Exception('Type does not have elements.') 1203 1204 return result 1205 1206 @staticmethod 1207 def from_result(res, fn, args): 1208 assert isinstance(res, Type) 1209 return res 1210 1211 def get_canonical(self): 1212 """ 1213 Return the canonical type for a Type. 1214 1215 Clang's type system explicitly models typedefs and all the 1216 ways a specific type can be represented. The canonical type 1217 is the underlying type with all the "sugar" removed. For 1218 example, if 'T' is a typedef for 'int', the canonical type for 1219 'T' would be 'int'. 1220 """ 1221 return Type_get_canonical(self) 1222 1223 def is_const_qualified(self): 1224 """Determine whether a Type has the "const" qualifier set. 1225 1226 This does not look through typedefs that may have added "const" 1227 at a different level. 1228 """ 1229 return Type_is_const_qualified(self) 1230 1231 def is_volatile_qualified(self): 1232 """Determine whether a Type has the "volatile" qualifier set. 1233 1234 This does not look through typedefs that may have added "volatile" 1235 at a different level. 1236 """ 1237 return Type_is_volatile_qualified(self) 1238 1239 def is_restrict_qualified(self): 1240 """Determine whether a Type has the "restrict" qualifier set. 1241 1242 This does not look through typedefs that may have added "restrict" at 1243 a different level. 1244 """ 1245 return Type_is_restrict_qualified(self) 1246 1247 def is_function_variadic(self): 1248 """Determine whether this function Type is a variadic function type.""" 1249 assert self.kind == TypeKind.FUNCTIONPROTO 1250 1251 return Type_is_variadic(self) 1252 1253 def is_pod(self): 1254 """Determine whether this Type represents plain old data (POD).""" 1255 return Type_is_pod(self) 1256 1257 def get_pointee(self): 1258 """ 1259 For pointer types, returns the type of the pointee. 1260 """ 1261 return Type_get_pointee(self) 1262 1263 def get_declaration(self): 1264 """ 1265 Return the cursor for the declaration of the given type. 1266 """ 1267 return Type_get_declaration(self) 1268 1269 def get_result(self): 1270 """ 1271 Retrieve the result type associated with a function type. 1272 """ 1273 return Type_get_result(self) 1274 1275 def get_array_element_type(self): 1276 """ 1277 Retrieve the type of the elements of the array type. 1278 """ 1279 return Type_get_array_element(self) 1280 1281 def get_array_size(self): 1282 """ 1283 Retrieve the size of the constant array. 1284 """ 1285 return Type_get_array_size(self) 1286 1287 def __eq__(self, other): 1288 if type(other) != type(self): 1289 return False 1290 1291 return Type_equal(self, other) 1292 1293 def __ne__(self, other): 1294 return not self.__eq__(other) 1295 1296## CIndex Objects ## 1297 1298# CIndex objects (derived from ClangObject) are essentially lightweight 1299# wrappers attached to some underlying object, which is exposed via CIndex as 1300# a void*. 1301 1302class ClangObject(object): 1303 """ 1304 A helper for Clang objects. This class helps act as an intermediary for 1305 the ctypes library and the Clang CIndex library. 1306 """ 1307 def __init__(self, obj): 1308 assert isinstance(obj, c_object_p) and obj 1309 self.obj = self._as_parameter_ = obj 1310 1311 def from_param(self): 1312 return self._as_parameter_ 1313 1314 1315class _CXUnsavedFile(Structure): 1316 """Helper for passing unsaved file arguments.""" 1317 _fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)] 1318 1319## Diagnostic Conversion ## 1320 1321_clang_getNumDiagnostics = lib.clang_getNumDiagnostics 1322_clang_getNumDiagnostics.argtypes = [c_object_p] 1323_clang_getNumDiagnostics.restype = c_uint 1324 1325_clang_getDiagnostic = lib.clang_getDiagnostic 1326_clang_getDiagnostic.argtypes = [c_object_p, c_uint] 1327_clang_getDiagnostic.restype = c_object_p 1328 1329_clang_disposeDiagnostic = lib.clang_disposeDiagnostic 1330_clang_disposeDiagnostic.argtypes = [Diagnostic] 1331 1332_clang_getDiagnosticSeverity = lib.clang_getDiagnosticSeverity 1333_clang_getDiagnosticSeverity.argtypes = [Diagnostic] 1334_clang_getDiagnosticSeverity.restype = c_int 1335 1336_clang_getDiagnosticLocation = lib.clang_getDiagnosticLocation 1337_clang_getDiagnosticLocation.argtypes = [Diagnostic] 1338_clang_getDiagnosticLocation.restype = SourceLocation 1339 1340_clang_getDiagnosticSpelling = lib.clang_getDiagnosticSpelling 1341_clang_getDiagnosticSpelling.argtypes = [Diagnostic] 1342_clang_getDiagnosticSpelling.restype = _CXString 1343_clang_getDiagnosticSpelling.errcheck = _CXString.from_result 1344 1345_clang_getDiagnosticNumRanges = lib.clang_getDiagnosticNumRanges 1346_clang_getDiagnosticNumRanges.argtypes = [Diagnostic] 1347_clang_getDiagnosticNumRanges.restype = c_uint 1348 1349_clang_getDiagnosticRange = lib.clang_getDiagnosticRange 1350_clang_getDiagnosticRange.argtypes = [Diagnostic, c_uint] 1351_clang_getDiagnosticRange.restype = SourceRange 1352 1353_clang_getDiagnosticNumFixIts = lib.clang_getDiagnosticNumFixIts 1354_clang_getDiagnosticNumFixIts.argtypes = [Diagnostic] 1355_clang_getDiagnosticNumFixIts.restype = c_uint 1356 1357_clang_getDiagnosticFixIt = lib.clang_getDiagnosticFixIt 1358_clang_getDiagnosticFixIt.argtypes = [Diagnostic, c_uint, POINTER(SourceRange)] 1359_clang_getDiagnosticFixIt.restype = _CXString 1360_clang_getDiagnosticFixIt.errcheck = _CXString.from_result 1361 1362_clang_getDiagnosticCategory = lib.clang_getDiagnosticCategory 1363_clang_getDiagnosticCategory.argtypes = [Diagnostic] 1364_clang_getDiagnosticCategory.restype = c_uint 1365 1366_clang_getDiagnosticCategoryName = lib.clang_getDiagnosticCategoryName 1367_clang_getDiagnosticCategoryName.argtypes = [c_uint] 1368_clang_getDiagnosticCategoryName.restype = _CXString 1369_clang_getDiagnosticCategoryName.errcheck = _CXString.from_result 1370 1371_clang_getDiagnosticOption = lib.clang_getDiagnosticOption 1372_clang_getDiagnosticOption.argtypes = [Diagnostic, POINTER(_CXString)] 1373_clang_getDiagnosticOption.restype = _CXString 1374_clang_getDiagnosticOption.errcheck = _CXString.from_result 1375 1376### 1377 1378class CompletionChunk: 1379 class Kind: 1380 def __init__(self, name): 1381 self.name = name 1382 1383 def __str__(self): 1384 return self.name 1385 1386 def __repr__(self): 1387 return "<ChunkKind: %s>" % self 1388 1389 def __init__(self, completionString, key): 1390 self.cs = completionString 1391 self.key = key 1392 1393 def __repr__(self): 1394 return "{'" + self.spelling + "', " + str(self.kind) + "}" 1395 1396 @property 1397 def spelling(self): 1398 return _clang_getCompletionChunkText(self.cs, self.key).spelling 1399 1400 @property 1401 def kind(self): 1402 res = _clang_getCompletionChunkKind(self.cs, self.key) 1403 return completionChunkKindMap[res] 1404 1405 @property 1406 def string(self): 1407 res = _clang_getCompletionChunkCompletionString(self.cs, self.key) 1408 1409 if (res): 1410 return CompletionString(res) 1411 else: 1412 None 1413 1414 def isKindOptional(self): 1415 return self.kind == completionChunkKindMap[0] 1416 1417 def isKindTypedText(self): 1418 return self.kind == completionChunkKindMap[1] 1419 1420 def isKindPlaceHolder(self): 1421 return self.kind == completionChunkKindMap[3] 1422 1423 def isKindInformative(self): 1424 return self.kind == completionChunkKindMap[4] 1425 1426 def isKindResultType(self): 1427 return self.kind == completionChunkKindMap[15] 1428 1429completionChunkKindMap = { 1430 0: CompletionChunk.Kind("Optional"), 1431 1: CompletionChunk.Kind("TypedText"), 1432 2: CompletionChunk.Kind("Text"), 1433 3: CompletionChunk.Kind("Placeholder"), 1434 4: CompletionChunk.Kind("Informative"), 1435 5: CompletionChunk.Kind("CurrentParameter"), 1436 6: CompletionChunk.Kind("LeftParen"), 1437 7: CompletionChunk.Kind("RightParen"), 1438 8: CompletionChunk.Kind("LeftBracket"), 1439 9: CompletionChunk.Kind("RightBracket"), 1440 10: CompletionChunk.Kind("LeftBrace"), 1441 11: CompletionChunk.Kind("RightBrace"), 1442 12: CompletionChunk.Kind("LeftAngle"), 1443 13: CompletionChunk.Kind("RightAngle"), 1444 14: CompletionChunk.Kind("Comma"), 1445 15: CompletionChunk.Kind("ResultType"), 1446 16: CompletionChunk.Kind("Colon"), 1447 17: CompletionChunk.Kind("SemiColon"), 1448 18: CompletionChunk.Kind("Equal"), 1449 19: CompletionChunk.Kind("HorizontalSpace"), 1450 20: CompletionChunk.Kind("VerticalSpace")} 1451 1452class CompletionString(ClangObject): 1453 class Availability: 1454 def __init__(self, name): 1455 self.name = name 1456 1457 def __str__(self): 1458 return self.name 1459 1460 def __repr__(self): 1461 return "<Availability: %s>" % self 1462 1463 def __len__(self): 1464 return _clang_getNumCompletionChunks(self.obj) 1465 1466 def __getitem__(self, key): 1467 if len(self) <= key: 1468 raise IndexError 1469 return CompletionChunk(self.obj, key) 1470 1471 @property 1472 def priority(self): 1473 return _clang_getCompletionPriority(self.obj) 1474 1475 @property 1476 def availability(self): 1477 res = _clang_getCompletionAvailability(self.obj) 1478 return availabilityKinds[res] 1479 1480 def __repr__(self): 1481 return " | ".join([str(a) for a in self]) \ 1482 + " || Priority: " + str(self.priority) \ 1483 + " || Availability: " + str(self.availability) 1484 1485availabilityKinds = { 1486 0: CompletionChunk.Kind("Available"), 1487 1: CompletionChunk.Kind("Deprecated"), 1488 2: CompletionChunk.Kind("NotAvailable")} 1489 1490class CodeCompletionResult(Structure): 1491 _fields_ = [('cursorKind', c_int), ('completionString', c_object_p)] 1492 1493 def __repr__(self): 1494 return str(CompletionString(self.completionString)) 1495 1496 @property 1497 def kind(self): 1498 return CursorKind.from_id(self.cursorKind) 1499 1500 @property 1501 def string(self): 1502 return CompletionString(self.completionString) 1503 1504class CCRStructure(Structure): 1505 _fields_ = [('results', POINTER(CodeCompletionResult)), 1506 ('numResults', c_int)] 1507 1508 def __len__(self): 1509 return self.numResults 1510 1511 def __getitem__(self, key): 1512 if len(self) <= key: 1513 raise IndexError 1514 1515 return self.results[key] 1516 1517class CodeCompletionResults(ClangObject): 1518 def __init__(self, ptr): 1519 assert isinstance(ptr, POINTER(CCRStructure)) and ptr 1520 self.ptr = self._as_parameter_ = ptr 1521 1522 def from_param(self): 1523 return self._as_parameter_ 1524 1525 def __del__(self): 1526 CodeCompletionResults_dispose(self) 1527 1528 @property 1529 def results(self): 1530 return self.ptr.contents 1531 1532 @property 1533 def diagnostics(self): 1534 class DiagnosticsItr: 1535 def __init__(self, ccr): 1536 self.ccr= ccr 1537 1538 def __len__(self): 1539 return int(_clang_codeCompleteGetNumDiagnostics(self.ccr)) 1540 1541 def __getitem__(self, key): 1542 return _clang_codeCompleteGetDiagnostic(self.ccr, key) 1543 1544 return DiagnosticsItr(self) 1545 1546 1547class Index(ClangObject): 1548 """ 1549 The Index type provides the primary interface to the Clang CIndex library, 1550 primarily by providing an interface for reading and parsing translation 1551 units. 1552 """ 1553 1554 @staticmethod 1555 def create(excludeDecls=False): 1556 """ 1557 Create a new Index. 1558 Parameters: 1559 excludeDecls -- Exclude local declarations from translation units. 1560 """ 1561 return Index(Index_create(excludeDecls, 0)) 1562 1563 def __del__(self): 1564 Index_dispose(self) 1565 1566 def read(self, path): 1567 """Load the translation unit from the given AST file.""" 1568 ptr = TranslationUnit_read(self, path) 1569 if ptr: 1570 return TranslationUnit(ptr) 1571 return None 1572 1573 def parse(self, path, args = [], unsaved_files = [], options = 0): 1574 """ 1575 Load the translation unit from the given source code file by running 1576 clang and generating the AST before loading. Additional command line 1577 parameters can be passed to clang via the args parameter. 1578 1579 In-memory contents for files can be provided by passing a list of pairs 1580 to as unsaved_files, the first item should be the filenames to be mapped 1581 and the second should be the contents to be substituted for the 1582 file. The contents may be passed as strings or file objects. 1583 """ 1584 arg_array = 0 1585 if len(args): 1586 arg_array = (c_char_p * len(args))(* args) 1587 unsaved_files_array = 0 1588 if len(unsaved_files): 1589 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1590 for i,(name,value) in enumerate(unsaved_files): 1591 if not isinstance(value, str): 1592 # FIXME: It would be great to support an efficient version 1593 # of this, one day. 1594 value = value.read() 1595 print value 1596 if not isinstance(value, str): 1597 raise TypeError,'Unexpected unsaved file contents.' 1598 unsaved_files_array[i].name = name 1599 unsaved_files_array[i].contents = value 1600 unsaved_files_array[i].length = len(value) 1601 ptr = TranslationUnit_parse(self, path, arg_array, len(args), 1602 unsaved_files_array, len(unsaved_files), 1603 options) 1604 if ptr: 1605 return TranslationUnit(ptr) 1606 return None 1607 1608 1609class TranslationUnit(ClangObject): 1610 """ 1611 The TranslationUnit class represents a source code translation unit and 1612 provides read-only access to its top-level declarations. 1613 """ 1614 1615 def __init__(self, ptr): 1616 ClangObject.__init__(self, ptr) 1617 1618 def __del__(self): 1619 TranslationUnit_dispose(self) 1620 1621 @property 1622 def cursor(self): 1623 """Retrieve the cursor that represents the given translation unit.""" 1624 return TranslationUnit_cursor(self) 1625 1626 @property 1627 def spelling(self): 1628 """Get the original translation unit source file name.""" 1629 return TranslationUnit_spelling(self) 1630 1631 def get_includes(self): 1632 """ 1633 Return an iterable sequence of FileInclusion objects that describe the 1634 sequence of inclusions in a translation unit. The first object in 1635 this sequence is always the input file. Note that this method will not 1636 recursively iterate over header files included through precompiled 1637 headers. 1638 """ 1639 def visitor(fobj, lptr, depth, includes): 1640 if depth > 0: 1641 loc = lptr.contents 1642 includes.append(FileInclusion(loc.file, File(fobj), loc, depth)) 1643 1644 # Automatically adapt CIndex/ctype pointers to python objects 1645 includes = [] 1646 TranslationUnit_includes(self, 1647 TranslationUnit_includes_callback(visitor), 1648 includes) 1649 return iter(includes) 1650 1651 @property 1652 def diagnostics(self): 1653 """ 1654 Return an iterable (and indexable) object containing the diagnostics. 1655 """ 1656 class DiagIterator: 1657 def __init__(self, tu): 1658 self.tu = tu 1659 1660 def __len__(self): 1661 return int(_clang_getNumDiagnostics(self.tu)) 1662 1663 def __getitem__(self, key): 1664 diag = _clang_getDiagnostic(self.tu, key) 1665 if not diag: 1666 raise IndexError 1667 return Diagnostic(diag) 1668 1669 return DiagIterator(self) 1670 1671 def reparse(self, unsaved_files = [], options = 0): 1672 """ 1673 Reparse an already parsed translation unit. 1674 1675 In-memory contents for files can be provided by passing a list of pairs 1676 as unsaved_files, the first items should be the filenames to be mapped 1677 and the second should be the contents to be substituted for the 1678 file. The contents may be passed as strings or file objects. 1679 """ 1680 unsaved_files_array = 0 1681 if len(unsaved_files): 1682 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1683 for i,(name,value) in enumerate(unsaved_files): 1684 if not isinstance(value, str): 1685 # FIXME: It would be great to support an efficient version 1686 # of this, one day. 1687 value = value.read() 1688 print value 1689 if not isinstance(value, str): 1690 raise TypeError,'Unexpected unsaved file contents.' 1691 unsaved_files_array[i].name = name 1692 unsaved_files_array[i].contents = value 1693 unsaved_files_array[i].length = len(value) 1694 ptr = TranslationUnit_reparse(self, len(unsaved_files), 1695 unsaved_files_array, 1696 options) 1697 def codeComplete(self, path, line, column, unsaved_files = [], options = 0): 1698 """ 1699 Code complete in this translation unit. 1700 1701 In-memory contents for files can be provided by passing a list of pairs 1702 as unsaved_files, the first items should be the filenames to be mapped 1703 and the second should be the contents to be substituted for the 1704 file. The contents may be passed as strings or file objects. 1705 """ 1706 unsaved_files_array = 0 1707 if len(unsaved_files): 1708 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1709 for i,(name,value) in enumerate(unsaved_files): 1710 if not isinstance(value, str): 1711 # FIXME: It would be great to support an efficient version 1712 # of this, one day. 1713 value = value.read() 1714 print value 1715 if not isinstance(value, str): 1716 raise TypeError,'Unexpected unsaved file contents.' 1717 unsaved_files_array[i].name = name 1718 unsaved_files_array[i].contents = value 1719 unsaved_files_array[i].length = len(value) 1720 ptr = TranslationUnit_codeComplete(self, path, 1721 line, column, 1722 unsaved_files_array, 1723 len(unsaved_files), 1724 options) 1725 if ptr: 1726 return CodeCompletionResults(ptr) 1727 return None 1728 1729class File(ClangObject): 1730 """ 1731 The File class represents a particular source file that is part of a 1732 translation unit. 1733 """ 1734 1735 @staticmethod 1736 def from_name(translation_unit, file_name): 1737 """Retrieve a file handle within the given translation unit.""" 1738 return File(File_getFile(translation_unit, file_name)) 1739 1740 @property 1741 def name(self): 1742 """Return the complete file and path name of the file.""" 1743 return _CXString_getCString(File_name(self)) 1744 1745 @property 1746 def time(self): 1747 """Return the last modification time of the file.""" 1748 return File_time(self) 1749 1750 def __str__(self): 1751 return self.name 1752 1753 def __repr__(self): 1754 return "<File: %s>" % (self.name) 1755 1756class FileInclusion(object): 1757 """ 1758 The FileInclusion class represents the inclusion of one source file by 1759 another via a '#include' directive or as the input file for the translation 1760 unit. This class provides information about the included file, the including 1761 file, the location of the '#include' directive and the depth of the included 1762 file in the stack. Note that the input file has depth 0. 1763 """ 1764 1765 def __init__(self, src, tgt, loc, depth): 1766 self.source = src 1767 self.include = tgt 1768 self.location = loc 1769 self.depth = depth 1770 1771 @property 1772 def is_input_file(self): 1773 """True if the included file is the input file.""" 1774 return self.depth == 0 1775 1776# Additional Functions and Types 1777 1778# String Functions 1779_CXString_dispose = lib.clang_disposeString 1780_CXString_dispose.argtypes = [_CXString] 1781 1782_CXString_getCString = lib.clang_getCString 1783_CXString_getCString.argtypes = [_CXString] 1784_CXString_getCString.restype = c_char_p 1785 1786# Source Location Functions 1787SourceLocation_loc = lib.clang_getInstantiationLocation 1788SourceLocation_loc.argtypes = [SourceLocation, POINTER(c_object_p), 1789 POINTER(c_uint), POINTER(c_uint), 1790 POINTER(c_uint)] 1791 1792SourceLocation_getLocation = lib.clang_getLocation 1793SourceLocation_getLocation.argtypes = [TranslationUnit, File, c_uint, c_uint] 1794SourceLocation_getLocation.restype = SourceLocation 1795 1796SourceLocation_equalLocations = lib.clang_equalLocations 1797SourceLocation_equalLocations.argtypes = [SourceLocation, SourceLocation] 1798SourceLocation_equalLocations.restype = bool 1799 1800# Source Range Functions 1801SourceRange_getRange = lib.clang_getRange 1802SourceRange_getRange.argtypes = [SourceLocation, SourceLocation] 1803SourceRange_getRange.restype = SourceRange 1804 1805SourceRange_start = lib.clang_getRangeStart 1806SourceRange_start.argtypes = [SourceRange] 1807SourceRange_start.restype = SourceLocation 1808 1809SourceRange_end = lib.clang_getRangeEnd 1810SourceRange_end.argtypes = [SourceRange] 1811SourceRange_end.restype = SourceLocation 1812 1813SourceRange_equalRanges = lib.clang_equalRanges 1814SourceRange_equalRanges.argtypes = [SourceRange, SourceRange] 1815SourceRange_equalRanges.restype = bool 1816 1817# CursorKind Functions 1818CursorKind_is_decl = lib.clang_isDeclaration 1819CursorKind_is_decl.argtypes = [CursorKind] 1820CursorKind_is_decl.restype = bool 1821 1822CursorKind_is_ref = lib.clang_isReference 1823CursorKind_is_ref.argtypes = [CursorKind] 1824CursorKind_is_ref.restype = bool 1825 1826CursorKind_is_expr = lib.clang_isExpression 1827CursorKind_is_expr.argtypes = [CursorKind] 1828CursorKind_is_expr.restype = bool 1829 1830CursorKind_is_stmt = lib.clang_isStatement 1831CursorKind_is_stmt.argtypes = [CursorKind] 1832CursorKind_is_stmt.restype = bool 1833 1834CursorKind_is_attribute = lib.clang_isAttribute 1835CursorKind_is_attribute.argtypes = [CursorKind] 1836CursorKind_is_attribute.restype = bool 1837 1838CursorKind_is_inv = lib.clang_isInvalid 1839CursorKind_is_inv.argtypes = [CursorKind] 1840CursorKind_is_inv.restype = bool 1841 1842CursorKind_is_translation_unit = lib.clang_isTranslationUnit 1843CursorKind_is_translation_unit.argtypes = [CursorKind] 1844CursorKind_is_translation_unit.restype = bool 1845 1846CursorKind_is_preprocessing = lib.clang_isPreprocessing 1847CursorKind_is_preprocessing.argtypes = [CursorKind] 1848CursorKind_is_preprocessing.restype = bool 1849 1850CursorKind_is_unexposed = lib.clang_isUnexposed 1851CursorKind_is_unexposed.argtypes = [CursorKind] 1852CursorKind_is_unexposed.restype = bool 1853 1854# Cursor Functions 1855# TODO: Implement this function 1856Cursor_get = lib.clang_getCursor 1857Cursor_get.argtypes = [TranslationUnit, SourceLocation] 1858Cursor_get.restype = Cursor 1859 1860Cursor_null = lib.clang_getNullCursor 1861Cursor_null.restype = Cursor 1862 1863Cursor_usr = lib.clang_getCursorUSR 1864Cursor_usr.argtypes = [Cursor] 1865Cursor_usr.restype = _CXString 1866Cursor_usr.errcheck = _CXString.from_result 1867 1868Cursor_is_def = lib.clang_isCursorDefinition 1869Cursor_is_def.argtypes = [Cursor] 1870Cursor_is_def.restype = bool 1871 1872Cursor_def = lib.clang_getCursorDefinition 1873Cursor_def.argtypes = [Cursor] 1874Cursor_def.restype = Cursor 1875Cursor_def.errcheck = Cursor.from_result 1876 1877Cursor_eq = lib.clang_equalCursors 1878Cursor_eq.argtypes = [Cursor, Cursor] 1879Cursor_eq.restype = c_uint 1880 1881Cursor_hash = lib.clang_hashCursor 1882Cursor_hash.argtypes = [Cursor] 1883Cursor_hash.restype = c_uint 1884 1885Cursor_spelling = lib.clang_getCursorSpelling 1886Cursor_spelling.argtypes = [Cursor] 1887Cursor_spelling.restype = _CXString 1888Cursor_spelling.errcheck = _CXString.from_result 1889 1890Cursor_displayname = lib.clang_getCursorDisplayName 1891Cursor_displayname.argtypes = [Cursor] 1892Cursor_displayname.restype = _CXString 1893Cursor_displayname.errcheck = _CXString.from_result 1894 1895Cursor_loc = lib.clang_getCursorLocation 1896Cursor_loc.argtypes = [Cursor] 1897Cursor_loc.restype = SourceLocation 1898 1899Cursor_extent = lib.clang_getCursorExtent 1900Cursor_extent.argtypes = [Cursor] 1901Cursor_extent.restype = SourceRange 1902 1903Cursor_ref = lib.clang_getCursorReferenced 1904Cursor_ref.argtypes = [Cursor] 1905Cursor_ref.restype = Cursor 1906Cursor_ref.errcheck = Cursor.from_result 1907 1908Cursor_type = lib.clang_getCursorType 1909Cursor_type.argtypes = [Cursor] 1910Cursor_type.restype = Type 1911Cursor_type.errcheck = Type.from_result 1912 1913Cursor_underlying_type = lib.clang_getTypedefDeclUnderlyingType 1914Cursor_underlying_type.argtypes = [Cursor] 1915Cursor_underlying_type.restype = Type 1916Cursor_underlying_type.errcheck = Type.from_result 1917 1918Cursor_enum_type = lib.clang_getEnumDeclIntegerType 1919Cursor_enum_type.argtypes = [Cursor] 1920Cursor_enum_type.restype = Type 1921Cursor_enum_type.errcheck = Type.from_result 1922 1923Cursor_visit_callback = CFUNCTYPE(c_int, Cursor, Cursor, py_object) 1924Cursor_visit = lib.clang_visitChildren 1925Cursor_visit.argtypes = [Cursor, Cursor_visit_callback, py_object] 1926Cursor_visit.restype = c_uint 1927 1928# Type Functions 1929Type_get_canonical = lib.clang_getCanonicalType 1930Type_get_canonical.argtypes = [Type] 1931Type_get_canonical.restype = Type 1932Type_get_canonical.errcheck = Type.from_result 1933 1934Type_is_const_qualified = lib.clang_isConstQualifiedType 1935Type_is_const_qualified.argtypes = [Type] 1936Type_is_const_qualified.restype = bool 1937 1938Type_is_volatile_qualified = lib.clang_isVolatileQualifiedType 1939Type_is_volatile_qualified.argtypes = [Type] 1940Type_is_volatile_qualified.restype = bool 1941 1942Type_is_restrict_qualified = lib.clang_isRestrictQualifiedType 1943Type_is_restrict_qualified.argtypes = [Type] 1944Type_is_restrict_qualified.restype = bool 1945 1946Type_is_pod = lib.clang_isPODType 1947Type_is_pod.argtypes = [Type] 1948Type_is_pod.restype = bool 1949 1950Type_is_variadic = lib.clang_isFunctionTypeVariadic 1951Type_is_variadic.argtypes = [Type] 1952Type_is_variadic.restype = bool 1953 1954Type_get_pointee = lib.clang_getPointeeType 1955Type_get_pointee.argtypes = [Type] 1956Type_get_pointee.restype = Type 1957Type_get_pointee.errcheck = Type.from_result 1958 1959Type_get_declaration = lib.clang_getTypeDeclaration 1960Type_get_declaration.argtypes = [Type] 1961Type_get_declaration.restype = Cursor 1962Type_get_declaration.errcheck = Cursor.from_result 1963 1964Type_get_result = lib.clang_getResultType 1965Type_get_result.argtypes = [Type] 1966Type_get_result.restype = Type 1967Type_get_result.errcheck = Type.from_result 1968 1969Type_get_num_arg_types = lib.clang_getNumArgTypes 1970Type_get_num_arg_types.argtypes = [Type] 1971Type_get_num_arg_types.restype = c_uint 1972 1973Type_get_arg_type = lib.clang_getArgType 1974Type_get_arg_type.argtypes = [Type, c_uint] 1975Type_get_arg_type.restype = Type 1976Type_get_arg_type.errcheck = Type.from_result 1977Type_get_element_type = lib.clang_getElementType 1978 1979Type_get_element_type.argtypes = [Type] 1980Type_get_element_type.restype = Type 1981Type_get_element_type.errcheck = Type.from_result 1982 1983Type_get_num_elements = lib.clang_getNumElements 1984Type_get_num_elements.argtypes = [Type] 1985Type_get_num_elements.restype = c_longlong 1986 1987Type_get_array_element = lib.clang_getArrayElementType 1988Type_get_array_element.argtypes = [Type] 1989Type_get_array_element.restype = Type 1990Type_get_array_element.errcheck = Type.from_result 1991 1992Type_get_array_size = lib.clang_getArraySize 1993Type_get_array_size.argtype = [Type] 1994Type_get_array_size.restype = c_longlong 1995 1996Type_equal = lib.clang_equalTypes 1997Type_equal.argtypes = [Type, Type] 1998Type_equal.restype = bool 1999 2000# Index Functions 2001Index_create = lib.clang_createIndex 2002Index_create.argtypes = [c_int, c_int] 2003Index_create.restype = c_object_p 2004 2005Index_dispose = lib.clang_disposeIndex 2006Index_dispose.argtypes = [Index] 2007 2008# Translation Unit Functions 2009TranslationUnit_read = lib.clang_createTranslationUnit 2010TranslationUnit_read.argtypes = [Index, c_char_p] 2011TranslationUnit_read.restype = c_object_p 2012 2013TranslationUnit_parse = lib.clang_parseTranslationUnit 2014TranslationUnit_parse.argtypes = [Index, c_char_p, c_void_p, 2015 c_int, c_void_p, c_int, c_int] 2016TranslationUnit_parse.restype = c_object_p 2017 2018TranslationUnit_reparse = lib.clang_reparseTranslationUnit 2019TranslationUnit_reparse.argtypes = [TranslationUnit, c_int, c_void_p, c_int] 2020TranslationUnit_reparse.restype = c_int 2021 2022TranslationUnit_codeComplete = lib.clang_codeCompleteAt 2023TranslationUnit_codeComplete.argtypes = [TranslationUnit, c_char_p, c_int, 2024 c_int, c_void_p, c_int, c_int] 2025TranslationUnit_codeComplete.restype = POINTER(CCRStructure) 2026 2027TranslationUnit_cursor = lib.clang_getTranslationUnitCursor 2028TranslationUnit_cursor.argtypes = [TranslationUnit] 2029TranslationUnit_cursor.restype = Cursor 2030TranslationUnit_cursor.errcheck = Cursor.from_result 2031 2032TranslationUnit_spelling = lib.clang_getTranslationUnitSpelling 2033TranslationUnit_spelling.argtypes = [TranslationUnit] 2034TranslationUnit_spelling.restype = _CXString 2035TranslationUnit_spelling.errcheck = _CXString.from_result 2036 2037TranslationUnit_dispose = lib.clang_disposeTranslationUnit 2038TranslationUnit_dispose.argtypes = [TranslationUnit] 2039 2040TranslationUnit_includes_callback = CFUNCTYPE(None, 2041 c_object_p, 2042 POINTER(SourceLocation), 2043 c_uint, py_object) 2044TranslationUnit_includes = lib.clang_getInclusions 2045TranslationUnit_includes.argtypes = [TranslationUnit, 2046 TranslationUnit_includes_callback, 2047 py_object] 2048 2049# File Functions 2050File_getFile = lib.clang_getFile 2051File_getFile.argtypes = [TranslationUnit, c_char_p] 2052File_getFile.restype = c_object_p 2053 2054File_name = lib.clang_getFileName 2055File_name.argtypes = [File] 2056File_name.restype = _CXString 2057 2058File_time = lib.clang_getFileTime 2059File_time.argtypes = [File] 2060File_time.restype = c_uint 2061 2062# Code completion 2063 2064CodeCompletionResults_dispose = lib.clang_disposeCodeCompleteResults 2065CodeCompletionResults_dispose.argtypes = [CodeCompletionResults] 2066 2067_clang_codeCompleteGetNumDiagnostics = lib.clang_codeCompleteGetNumDiagnostics 2068_clang_codeCompleteGetNumDiagnostics.argtypes = [CodeCompletionResults] 2069_clang_codeCompleteGetNumDiagnostics.restype = c_int 2070 2071_clang_codeCompleteGetDiagnostic = lib.clang_codeCompleteGetDiagnostic 2072_clang_codeCompleteGetDiagnostic.argtypes = [CodeCompletionResults, c_int] 2073_clang_codeCompleteGetDiagnostic.restype = Diagnostic 2074 2075_clang_getCompletionChunkText = lib.clang_getCompletionChunkText 2076_clang_getCompletionChunkText.argtypes = [c_void_p, c_int] 2077_clang_getCompletionChunkText.restype = _CXString 2078 2079_clang_getCompletionChunkKind = lib.clang_getCompletionChunkKind 2080_clang_getCompletionChunkKind.argtypes = [c_void_p, c_int] 2081_clang_getCompletionChunkKind.restype = c_int 2082 2083_clang_getCompletionChunkCompletionString = lib.clang_getCompletionChunkCompletionString 2084_clang_getCompletionChunkCompletionString.argtypes = [c_void_p, c_int] 2085_clang_getCompletionChunkCompletionString.restype = c_object_p 2086 2087_clang_getNumCompletionChunks = lib.clang_getNumCompletionChunks 2088_clang_getNumCompletionChunks.argtypes = [c_void_p] 2089_clang_getNumCompletionChunks.restype = c_int 2090 2091_clang_getCompletionAvailability = lib.clang_getCompletionAvailability 2092_clang_getCompletionAvailability.argtypes = [c_void_p] 2093_clang_getCompletionAvailability.restype = c_int 2094 2095_clang_getCompletionPriority = lib.clang_getCompletionPriority 2096_clang_getCompletionPriority.argtypes = [c_void_p] 2097_clang_getCompletionPriority.restype = c_int 2098 2099 2100### 2101 2102__all__ = ['Index', 'TranslationUnit', 'Cursor', 'CursorKind', 'Type', 'TypeKind', 2103 'Diagnostic', 'FixIt', 'CodeCompletionResults', 'SourceRange', 2104 'SourceLocation', 'File'] 2105