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 10 r""" 11 Clang Indexing Library Bindings 12 =============================== 13 14 This module provides an interface to the Clang indexing library. It is a 15 low-level interface to the indexing library which attempts to match the Clang 16 API directly while also being "pythonic". Notable differences from the C API 17 are: 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 25 The 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 44 Most object information is exposed using properties, when the underlying API 45 call 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 65 from ctypes import * 66 import collections 67 68 def 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**. 85 c_object_p = POINTER(c_void_p) 86 87 lib = get_cindex_library() 88 89 ### Structures and Utility Classes ### 90 91 class _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 104 class 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 164 class 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 205 class 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 301 class 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 317 class 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. 412 CursorKind.UNEXPOSED_DECL = CursorKind(1) 413 414 # A C or C++ struct. 415 CursorKind.STRUCT_DECL = CursorKind(2) 416 417 # A C or C++ union. 418 CursorKind.UNION_DECL = CursorKind(3) 419 420 # A C++ class. 421 CursorKind.CLASS_DECL = CursorKind(4) 422 423 # An enumeration. 424 CursorKind.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. 428 CursorKind.FIELD_DECL = CursorKind(6) 429 430 # An enumerator constant. 431 CursorKind.ENUM_CONSTANT_DECL = CursorKind(7) 432 433 # A function. 434 CursorKind.FUNCTION_DECL = CursorKind(8) 435 436 # A variable. 437 CursorKind.VAR_DECL = CursorKind(9) 438 439 # A function or method parameter. 440 CursorKind.PARM_DECL = CursorKind(10) 441 442 # An Objective-C @interface. 443 CursorKind.OBJC_INTERFACE_DECL = CursorKind(11) 444 445 # An Objective-C @interface for a category. 446 CursorKind.OBJC_CATEGORY_DECL = CursorKind(12) 447 448 # An Objective-C @protocol declaration. 449 CursorKind.OBJC_PROTOCOL_DECL = CursorKind(13) 450 451 # An Objective-C @property declaration. 452 CursorKind.OBJC_PROPERTY_DECL = CursorKind(14) 453 454 # An Objective-C instance variable. 455 CursorKind.OBJC_IVAR_DECL = CursorKind(15) 456 457 # An Objective-C instance method. 458 CursorKind.OBJC_INSTANCE_METHOD_DECL = CursorKind(16) 459 460 # An Objective-C class method. 461 CursorKind.OBJC_CLASS_METHOD_DECL = CursorKind(17) 462 463 # An Objective-C @implementation. 464 CursorKind.OBJC_IMPLEMENTATION_DECL = CursorKind(18) 465 466 # An Objective-C @implementation for a category. 467 CursorKind.OBJC_CATEGORY_IMPL_DECL = CursorKind(19) 468 469 # A typedef. 470 CursorKind.TYPEDEF_DECL = CursorKind(20) 471 472 # A C++ class method. 473 CursorKind.CXX_METHOD = CursorKind(21) 474 475 # A C++ namespace. 476 CursorKind.NAMESPACE = CursorKind(22) 477 478 # A linkage specification, e.g. 'extern "C"'. 479 CursorKind.LINKAGE_SPEC = CursorKind(23) 480 481 # A C++ constructor. 482 CursorKind.CONSTRUCTOR = CursorKind(24) 483 484 # A C++ destructor. 485 CursorKind.DESTRUCTOR = CursorKind(25) 486 487 # A C++ conversion function. 488 CursorKind.CONVERSION_FUNCTION = CursorKind(26) 489 490 # A C++ template type parameter 491 CursorKind.TEMPLATE_TYPE_PARAMETER = CursorKind(27) 492 493 # A C++ non-type template paramater. 494 CursorKind.TEMPLATE_NON_TYPE_PARAMETER = CursorKind(28) 495 496 # A C++ template template parameter. 497 CursorKind.TEMPLATE_TEMPLATE_PARAMTER = CursorKind(29) 498 499 # A C++ function template. 500 CursorKind.FUNCTION_TEMPLATE = CursorKind(30) 501 502 # A C++ class template. 503 CursorKind.CLASS_TEMPLATE = CursorKind(31) 504 505 # A C++ class template partial specialization. 506 CursorKind.CLASS_TEMPLATE_PARTIAL_SPECIALIZATION = CursorKind(32) 507 508 # A C++ namespace alias declaration. 509 CursorKind.NAMESPACE_ALIAS = CursorKind(33) 510 511 # A C++ using directive 512 CursorKind.USING_DIRECTIVE = CursorKind(34) 513 514 # A C++ using declaration 515 CursorKind.USING_DECLARATION = CursorKind(35) 516 517 # A Type alias decl. 518 CursorKind.TYPE_ALIAS_DECL = CursorKind(36) 519 520 # A Objective-C synthesize decl 521 CursorKind.OBJC_SYNTHESIZE_DECL = CursorKind(37) 522 523 # A Objective-C dynamic decl 524 CursorKind.OBJC_DYNAMIC_DECL = CursorKind(38) 525 526 # A C++ access specifier decl. 527 CursorKind.CXX_ACCESS_SPEC_DECL = CursorKind(39) 528 529 530 ### 531 # Reference Kinds 532 533 CursorKind.OBJC_SUPER_CLASS_REF = CursorKind(40) 534 CursorKind.OBJC_PROTOCOL_REF = CursorKind(41) 535 CursorKind.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. 547 CursorKind.TYPE_REF = CursorKind(43) 548 CursorKind.CXX_BASE_SPECIFIER = CursorKind(44) 549 550 # A reference to a class template, function template, template 551 # template parameter, or class template partial specialization. 552 CursorKind.TEMPLATE_REF = CursorKind(45) 553 554 # A reference to a namespace or namepsace alias. 555 CursorKind.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. 559 CursorKind.MEMBER_REF = CursorKind(47) 560 561 # A reference to a labeled statement. 562 CursorKind.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. 566 CursorKind.OVERLOADED_DECL_REF = CursorKind(49) 567 568 ### 569 # Invalid/Error Kinds 570 571 CursorKind.INVALID_FILE = CursorKind(70) 572 CursorKind.NO_DECL_FOUND = CursorKind(71) 573 CursorKind.NOT_IMPLEMENTED = CursorKind(72) 574 CursorKind.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. 584 CursorKind.UNEXPOSED_EXPR = CursorKind(100) 585 586 # An expression that refers to some value declaration, such as a function, 587 # varible, or enumerator. 588 CursorKind.DECL_REF_EXPR = CursorKind(101) 589 590 # An expression that refers to a member of a struct, union, class, Objective-C 591 # class, etc. 592 CursorKind.MEMBER_REF_EXPR = CursorKind(102) 593 594 # An expression that calls a function. 595 CursorKind.CALL_EXPR = CursorKind(103) 596 597 # An expression that sends a message to an Objective-C object or class. 598 CursorKind.OBJC_MESSAGE_EXPR = CursorKind(104) 599 600 # An expression that represents a block literal. 601 CursorKind.BLOCK_EXPR = CursorKind(105) 602 603 # An integer literal. 604 CursorKind.INTEGER_LITERAL = CursorKind(106) 605 606 # A floating point number literal. 607 CursorKind.FLOATING_LITERAL = CursorKind(107) 608 609 # An imaginary number literal. 610 CursorKind.IMAGINARY_LITERAL = CursorKind(108) 611 612 # A string literal. 613 CursorKind.STRING_LITERAL = CursorKind(109) 614 615 # A character literal. 616 CursorKind.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. 621 CursorKind.PAREN_EXPR = CursorKind(111) 622 623 # This represents the unary-expression's (except sizeof and 624 # alignof). 625 CursorKind.UNARY_OPERATOR = CursorKind(112) 626 627 # [C99 6.5.2.1] Array Subscripting. 628 CursorKind.ARRAY_SUBSCRIPT_EXPR = CursorKind(113) 629 630 # A builtin binary operation expression such as "x + y" or 631 # "x <= y". 632 CursorKind.BINARY_OPERATOR = CursorKind(114) 633 634 # Compound assignment such as "+=". 635 CursorKind.COMPOUND_ASSIGNMENT_OPERATOR = CursorKind(115) 636 637 # The ?: ternary operator. 638 CursorKind.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. 644 CursorKind.CSTYLE_CAST_EXPR = CursorKind(117) 645 646 # [C99 6.5.2.5] 647 CursorKind.COMPOUND_LITERAL_EXPR = CursorKind(118) 648 649 # Describes an C or C++ initializer list. 650 CursorKind.INIT_LIST_EXPR = CursorKind(119) 651 652 # The GNU address of label extension, representing &&label. 653 CursorKind.ADDR_LABEL_EXPR = CursorKind(120) 654 655 # This is the GNU Statement Expression extension: ({int X=4; X;}) 656 CursorKind.StmtExpr = CursorKind(121) 657 658 # Represents a C11 generic selection. 659 CursorKind.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). 668 CursorKind.GNU_NULL_EXPR = CursorKind(123) 669 670 # C++'s static_cast<> expression. 671 CursorKind.CXX_STATIC_CAST_EXPR = CursorKind(124) 672 673 # C++'s dynamic_cast<> expression. 674 CursorKind.CXX_DYNAMIC_CAST_EXPR = CursorKind(125) 675 676 # C++'s reinterpret_cast<> expression. 677 CursorKind.CXX_REINTERPRET_CAST_EXPR = CursorKind(126) 678 679 # C++'s const_cast<> expression. 680 CursorKind.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 689 CursorKind.CXX_FUNCTIONAL_CAST_EXPR = CursorKind(128) 690 691 # A C++ typeid expression (C++ [expr.typeid]). 692 CursorKind.CXX_TYPEID_EXPR = CursorKind(129) 693 694 # [C++ 2.13.5] C++ Boolean Literal. 695 CursorKind.CXX_BOOL_LITERAL_EXPR = CursorKind(130) 696 697 # [C++0x 2.14.7] C++ Pointer Literal. 698 CursorKind.CXX_NULL_PTR_LITERAL_EXPR = CursorKind(131) 699 700 # Represents the "this" expression in C++ 701 CursorKind.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. 707 CursorKind.CXX_THROW_EXPR = CursorKind(133) 708 709 # A new expression for memory allocation and constructor calls, e.g: 710 # "new CXXNewExpr(foo)". 711 CursorKind.CXX_NEW_EXPR = CursorKind(134) 712 713 # A delete expression for memory deallocation and destructor calls, 714 # e.g. "delete[] pArray". 715 CursorKind.CXX_DELETE_EXPR = CursorKind(135) 716 717 # Represents a unary expression. 718 CursorKind.CXX_UNARY_EXPR = CursorKind(136) 719 720 # ObjCStringLiteral, used for Objective-C string literals i.e. "foo". 721 CursorKind.OBJC_STRING_LITERAL = CursorKind(137) 722 723 # ObjCEncodeExpr, used for in Objective-C. 724 CursorKind.OBJC_ENCODE_EXPR = CursorKind(138) 725 726 # ObjCSelectorExpr used for in Objective-C. 727 CursorKind.OBJC_SELECTOR_EXPR = CursorKind(139) 728 729 # Objective-C's protocol expression. 730 CursorKind.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 738 CursorKind.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: 745 CursorKind.PACK_EXPANSION_EXPR = CursorKind(142) 746 747 # Represents an expression that computes the length of a parameter 748 # pack. 749 CursorKind.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. 756 CursorKind.UNEXPOSED_STMT = CursorKind(200) 757 758 # A labelled statement in a function. 759 CursorKind.LABEL_STMT = CursorKind(201) 760 761 # A compound statement 762 CursorKind.COMPOUND_STMT = CursorKind(202) 763 764 # A case statement. 765 CursorKind.CASE_STMT = CursorKind(203) 766 767 # A default statement. 768 CursorKind.DEFAULT_STMT = CursorKind(204) 769 770 # An if statement. 771 CursorKind.IF_STMT = CursorKind(205) 772 773 # A switch statement. 774 CursorKind.SWITCH_STMT = CursorKind(206) 775 776 # A while statement. 777 CursorKind.WHILE_STMT = CursorKind(207) 778 779 # A do statement. 780 CursorKind.DO_STMT = CursorKind(208) 781 782 # A for statement. 783 CursorKind.FOR_STMT = CursorKind(209) 784 785 # A goto statement. 786 CursorKind.GOTO_STMT = CursorKind(210) 787 788 # An indirect goto statement. 789 CursorKind.INDIRECT_GOTO_STMT = CursorKind(211) 790 791 # A continue statement. 792 CursorKind.CONTINUE_STMT = CursorKind(212) 793 794 # A break statement. 795 CursorKind.BREAK_STMT = CursorKind(213) 796 797 # A return statement. 798 CursorKind.RETURN_STMT = CursorKind(214) 799 800 # A GNU-style inline assembler statement. 801 CursorKind.ASM_STMT = CursorKind(215) 802 803 # Objective-C's overall @try-@catch-@finally statement. 804 CursorKind.OBJC_AT_TRY_STMT = CursorKind(216) 805 806 # Objective-C's @catch statement. 807 CursorKind.OBJC_AT_CATCH_STMT = CursorKind(217) 808 809 # Objective-C's @finally statement. 810 CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218) 811 812 # Objective-C's @throw statement. 813 CursorKind.OBJC_AT_THROW_STMT = CursorKind(219) 814 815 # Objective-C's @synchronized statement. 816 CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220) 817 818 # Objective-C's autorealease pool statement. 819 CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221) 820 821 # Objective-C's for collection statement. 822 CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222) 823 824 # C++'s catch statement. 825 CursorKind.CXX_CATCH_STMT = CursorKind(223) 826 827 # C++'s try statement. 828 CursorKind.CXX_TRY_STMT = CursorKind(224) 829 830 # C++'s for (* : *) statement. 831 CursorKind.CXX_FOR_RANGE_STMT = CursorKind(225) 832 833 # Windows Structured Exception Handling's try statement. 834 CursorKind.SEH_TRY_STMT = CursorKind(226) 835 836 # Windows Structured Exception Handling's except statement. 837 CursorKind.SEH_EXCEPT_STMT = CursorKind(227) 838 839 # Windows Structured Exception Handling's finally statement. 840 CursorKind.SEH_FINALLY_STMT = CursorKind(228) 841 842 # The null statement. 843 CursorKind.NULL_STMT = CursorKind(230) 844 845 # Adaptor class for mixing declarations with statements and expressions. 846 CursorKind.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. 855 CursorKind.TRANSLATION_UNIT = CursorKind(300) 856 857 ### 858 # Attributes 859 860 # An attribute whoe specific kind is note exposed via this interface 861 CursorKind.UNEXPOSED_ATTR = CursorKind(400) 862 863 CursorKind.IB_ACTION_ATTR = CursorKind(401) 864 CursorKind.IB_OUTLET_ATTR = CursorKind(402) 865 CursorKind.IB_OUTLET_COLLECTION_ATTR = CursorKind(403) 866 867 CursorKind.CXX_FINAL_ATTR = CursorKind(404) 868 CursorKind.CXX_OVERRIDE_ATTR = CursorKind(405) 869 CursorKind.ANNOTATE_ATTR = CursorKind(406) 870 CursorKind.ASM_LABEL_ATTR = CursorKind(407) 871 872 ### 873 # Preprocessing 874 CursorKind.PREPROCESSING_DIRECTIVE = CursorKind(500) 875 CursorKind.MACRO_DEFINITION = CursorKind(501) 876 CursorKind.MACRO_INSTANTIATION = CursorKind(502) 877 CursorKind.INCLUSION_DIRECTIVE = CursorKind(503) 878 879 ### Cursors ### 880 881 class 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 1051 class 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 @property 1083 def spelling(self): 1084 """Retrieve the spelling of this TypeKind.""" 1085 return TypeKind_spelling(self.value) 1086 1087 @staticmethod 1088 def from_id(id): 1089 if id >= len(TypeKind._kinds) or TypeKind._kinds[id] is None: 1090 raise ValueError,'Unknown type kind %d' % id 1091 return TypeKind._kinds[id] 1092 1093 def __repr__(self): 1094 return 'TypeKind.%s' % (self.name,) 1095 1096 TypeKind_spelling = lib.clang_getTypeKindSpelling 1097 TypeKind_spelling.argtypes = [c_uint] 1098 TypeKind_spelling.restype = _CXString 1099 TypeKind_spelling.errcheck = _CXString.from_result 1100 1101 1102 TypeKind.INVALID = TypeKind(0) 1103 TypeKind.UNEXPOSED = TypeKind(1) 1104 TypeKind.VOID = TypeKind(2) 1105 TypeKind.BOOL = TypeKind(3) 1106 TypeKind.CHAR_U = TypeKind(4) 1107 TypeKind.UCHAR = TypeKind(5) 1108 TypeKind.CHAR16 = TypeKind(6) 1109 TypeKind.CHAR32 = TypeKind(7) 1110 TypeKind.USHORT = TypeKind(8) 1111 TypeKind.UINT = TypeKind(9) 1112 TypeKind.ULONG = TypeKind(10) 1113 TypeKind.ULONGLONG = TypeKind(11) 1114 TypeKind.UINT128 = TypeKind(12) 1115 TypeKind.CHAR_S = TypeKind(13) 1116 TypeKind.SCHAR = TypeKind(14) 1117 TypeKind.WCHAR = TypeKind(15) 1118 TypeKind.SHORT = TypeKind(16) 1119 TypeKind.INT = TypeKind(17) 1120 TypeKind.LONG = TypeKind(18) 1121 TypeKind.LONGLONG = TypeKind(19) 1122 TypeKind.INT128 = TypeKind(20) 1123 TypeKind.FLOAT = TypeKind(21) 1124 TypeKind.DOUBLE = TypeKind(22) 1125 TypeKind.LONGDOUBLE = TypeKind(23) 1126 TypeKind.NULLPTR = TypeKind(24) 1127 TypeKind.OVERLOAD = TypeKind(25) 1128 TypeKind.DEPENDENT = TypeKind(26) 1129 TypeKind.OBJCID = TypeKind(27) 1130 TypeKind.OBJCCLASS = TypeKind(28) 1131 TypeKind.OBJCSEL = TypeKind(29) 1132 TypeKind.COMPLEX = TypeKind(100) 1133 TypeKind.POINTER = TypeKind(101) 1134 TypeKind.BLOCKPOINTER = TypeKind(102) 1135 TypeKind.LVALUEREFERENCE = TypeKind(103) 1136 TypeKind.RVALUEREFERENCE = TypeKind(104) 1137 TypeKind.RECORD = TypeKind(105) 1138 TypeKind.ENUM = TypeKind(106) 1139 TypeKind.TYPEDEF = TypeKind(107) 1140 TypeKind.OBJCINTERFACE = TypeKind(108) 1141 TypeKind.OBJCOBJECTPOINTER = TypeKind(109) 1142 TypeKind.FUNCTIONNOPROTO = TypeKind(110) 1143 TypeKind.FUNCTIONPROTO = TypeKind(111) 1144 TypeKind.CONSTANTARRAY = TypeKind(112) 1145 TypeKind.VECTOR = TypeKind(113) 1146 1147 class Type(Structure): 1148 """ 1149 The type of an element in the abstract syntax tree. 1150 """ 1151 _fields_ = [("_kind_id", c_int), ("data", c_void_p * 2)] 1152 1153 @property 1154 def kind(self): 1155 """Return the kind of this type.""" 1156 return TypeKind.from_id(self._kind_id) 1157 1158 def argument_types(self): 1159 """Retrieve a container for the non-variadic arguments for this type. 1160 1161 The returned object is iterable and indexable. Each item in the 1162 container is a Type instance. 1163 """ 1164 class ArgumentsIterator(collections.Sequence): 1165 def __init__(self, parent): 1166 self.parent = parent 1167 self.length = None 1168 1169 def __len__(self): 1170 if self.length is None: 1171 self.length = Type_get_num_arg_types(self.parent) 1172 1173 return self.length 1174 1175 def __getitem__(self, key): 1176 # FIXME Support slice objects. 1177 if not isinstance(key, int): 1178 raise TypeError("Must supply a non-negative int.") 1179 1180 if key < 0: 1181 raise IndexError("Only non-negative indexes are accepted.") 1182 1183 if key >= len(self): 1184 raise IndexError("Index greater than container length: " 1185 "%d > %d" % ( key, len(self) )) 1186 1187 result = Type_get_arg_type(self.parent, key) 1188 if result.kind == TypeKind.INVALID: 1189 raise IndexError("Argument could not be retrieved.") 1190 1191 return result 1192 1193 assert self.kind == TypeKind.FUNCTIONPROTO 1194 return ArgumentsIterator(self) 1195 1196 @property 1197 def element_type(self): 1198 """Retrieve the Type of elements within this Type. 1199 1200 If accessed on a type that is not an array, complex, or vector type, an 1201 exception will be raised. 1202 """ 1203 result = Type_get_element_type(self) 1204 if result.kind == TypeKind.INVALID: 1205 raise Exception('Element type not available on this type.') 1206 1207 return result 1208 1209 @property 1210 def element_count(self): 1211 """Retrieve the number of elements in this type. 1212 1213 Returns an int. 1214 1215 If the Type is not an array or vector, this raises. 1216 """ 1217 result = Type_get_num_elements(self) 1218 if result < 0: 1219 raise Exception('Type does not have elements.') 1220 1221 return result 1222 1223 @staticmethod 1224 def from_result(res, fn, args): 1225 assert isinstance(res, Type) 1226 return res 1227 1228 def get_canonical(self): 1229 """ 1230 Return the canonical type for a Type. 1231 1232 Clang's type system explicitly models typedefs and all the 1233 ways a specific type can be represented. The canonical type 1234 is the underlying type with all the "sugar" removed. For 1235 example, if 'T' is a typedef for 'int', the canonical type for 1236 'T' would be 'int'. 1237 """ 1238 return Type_get_canonical(self) 1239 1240 def is_const_qualified(self): 1241 """Determine whether a Type has the "const" qualifier set. 1242 1243 This does not look through typedefs that may have added "const" 1244 at a different level. 1245 """ 1246 return Type_is_const_qualified(self) 1247 1248 def is_volatile_qualified(self): 1249 """Determine whether a Type has the "volatile" qualifier set. 1250 1251 This does not look through typedefs that may have added "volatile" 1252 at a different level. 1253 """ 1254 return Type_is_volatile_qualified(self) 1255 1256 def is_restrict_qualified(self): 1257 """Determine whether a Type has the "restrict" qualifier set. 1258 1259 This does not look through typedefs that may have added "restrict" at 1260 a different level. 1261 """ 1262 return Type_is_restrict_qualified(self) 1263 1264 def is_function_variadic(self): 1265 """Determine whether this function Type is a variadic function type.""" 1266 assert self.kind == TypeKind.FUNCTIONPROTO 1267 1268 return Type_is_variadic(self) 1269 1270 def is_pod(self): 1271 """Determine whether this Type represents plain old data (POD).""" 1272 return Type_is_pod(self) 1273 1274 def get_pointee(self): 1275 """ 1276 For pointer types, returns the type of the pointee. 1277 """ 1278 return Type_get_pointee(self) 1279 1280 def get_declaration(self): 1281 """ 1282 Return the cursor for the declaration of the given type. 1283 """ 1284 return Type_get_declaration(self) 1285 1286 def get_result(self): 1287 """ 1288 Retrieve the result type associated with a function type. 1289 """ 1290 return Type_get_result(self) 1291 1292 def get_array_element_type(self): 1293 """ 1294 Retrieve the type of the elements of the array type. 1295 """ 1296 return Type_get_array_element(self) 1297 1298 def get_array_size(self): 1299 """ 1300 Retrieve the size of the constant array. 1301 """ 1302 return Type_get_array_size(self) 1303 1304 def __eq__(self, other): 1305 if type(other) != type(self): 1306 return False 1307 1308 return Type_equal(self, other) 1309 1310 def __ne__(self, other): 1311 return not self.__eq__(other) 1312 1313 ## CIndex Objects ## 1314 1315 # CIndex objects (derived from ClangObject) are essentially lightweight 1316 # wrappers attached to some underlying object, which is exposed via CIndex as 1317 # a void*. 1318 1319 class ClangObject(object): 1320 """ 1321 A helper for Clang objects. This class helps act as an intermediary for 1322 the ctypes library and the Clang CIndex library. 1323 """ 1324 def __init__(self, obj): 1325 assert isinstance(obj, c_object_p) and obj 1326 self.obj = self._as_parameter_ = obj 1327 1328 def from_param(self): 1329 return self._as_parameter_ 1330 1331 1332 class _CXUnsavedFile(Structure): 1333 """Helper for passing unsaved file arguments.""" 1334 _fields_ = [("name", c_char_p), ("contents", c_char_p), ('length', c_ulong)] 1335 1336 ## Diagnostic Conversion ## 1337 1338 _clang_getNumDiagnostics = lib.clang_getNumDiagnostics 1339 _clang_getNumDiagnostics.argtypes = [c_object_p] 1340 _clang_getNumDiagnostics.restype = c_uint 1341 1342 _clang_getDiagnostic = lib.clang_getDiagnostic 1343 _clang_getDiagnostic.argtypes = [c_object_p, c_uint] 1344 _clang_getDiagnostic.restype = c_object_p 1345 1346 _clang_disposeDiagnostic = lib.clang_disposeDiagnostic 1347 _clang_disposeDiagnostic.argtypes = [Diagnostic] 1348 1349 _clang_getDiagnosticSeverity = lib.clang_getDiagnosticSeverity 1350 _clang_getDiagnosticSeverity.argtypes = [Diagnostic] 1351 _clang_getDiagnosticSeverity.restype = c_int 1352 1353 _clang_getDiagnosticLocation = lib.clang_getDiagnosticLocation 1354 _clang_getDiagnosticLocation.argtypes = [Diagnostic] 1355 _clang_getDiagnosticLocation.restype = SourceLocation 1356 1357 _clang_getDiagnosticSpelling = lib.clang_getDiagnosticSpelling 1358 _clang_getDiagnosticSpelling.argtypes = [Diagnostic] 1359 _clang_getDiagnosticSpelling.restype = _CXString 1360 _clang_getDiagnosticSpelling.errcheck = _CXString.from_result 1361 1362 _clang_getDiagnosticNumRanges = lib.clang_getDiagnosticNumRanges 1363 _clang_getDiagnosticNumRanges.argtypes = [Diagnostic] 1364 _clang_getDiagnosticNumRanges.restype = c_uint 1365 1366 _clang_getDiagnosticRange = lib.clang_getDiagnosticRange 1367 _clang_getDiagnosticRange.argtypes = [Diagnostic, c_uint] 1368 _clang_getDiagnosticRange.restype = SourceRange 1369 1370 _clang_getDiagnosticNumFixIts = lib.clang_getDiagnosticNumFixIts 1371 _clang_getDiagnosticNumFixIts.argtypes = [Diagnostic] 1372 _clang_getDiagnosticNumFixIts.restype = c_uint 1373 1374 _clang_getDiagnosticFixIt = lib.clang_getDiagnosticFixIt 1375 _clang_getDiagnosticFixIt.argtypes = [Diagnostic, c_uint, POINTER(SourceRange)] 1376 _clang_getDiagnosticFixIt.restype = _CXString 1377 _clang_getDiagnosticFixIt.errcheck = _CXString.from_result 1378 1379 _clang_getDiagnosticCategory = lib.clang_getDiagnosticCategory 1380 _clang_getDiagnosticCategory.argtypes = [Diagnostic] 1381 _clang_getDiagnosticCategory.restype = c_uint 1382 1383 _clang_getDiagnosticCategoryName = lib.clang_getDiagnosticCategoryName 1384 _clang_getDiagnosticCategoryName.argtypes = [c_uint] 1385 _clang_getDiagnosticCategoryName.restype = _CXString 1386 _clang_getDiagnosticCategoryName.errcheck = _CXString.from_result 1387 1388 _clang_getDiagnosticOption = lib.clang_getDiagnosticOption 1389 _clang_getDiagnosticOption.argtypes = [Diagnostic, POINTER(_CXString)] 1390 _clang_getDiagnosticOption.restype = _CXString 1391 _clang_getDiagnosticOption.errcheck = _CXString.from_result 1392 1393 ### 1394 1395 class CompletionChunk: 1396 class Kind: 1397 def __init__(self, name): 1398 self.name = name 1399 1400 def __str__(self): 1401 return self.name 1402 1403 def __repr__(self): 1404 return "<ChunkKind: %s>" % self 1405 1406 def __init__(self, completionString, key): 1407 self.cs = completionString 1408 self.key = key 1409 1410 def __repr__(self): 1411 return "{'" + self.spelling + "', " + str(self.kind) + "}" 1412 1413 @property 1414 def spelling(self): 1415 return _clang_getCompletionChunkText(self.cs, self.key).spelling 1416 1417 @property 1418 def kind(self): 1419 res = _clang_getCompletionChunkKind(self.cs, self.key) 1420 return completionChunkKindMap[res] 1421 1422 @property 1423 def string(self): 1424 res = _clang_getCompletionChunkCompletionString(self.cs, self.key) 1425 1426 if (res): 1427 return CompletionString(res) 1428 else: 1429 None 1430 1431 def isKindOptional(self): 1432 return self.kind == completionChunkKindMap[0] 1433 1434 def isKindTypedText(self): 1435 return self.kind == completionChunkKindMap[1] 1436 1437 def isKindPlaceHolder(self): 1438 return self.kind == completionChunkKindMap[3] 1439 1440 def isKindInformative(self): 1441 return self.kind == completionChunkKindMap[4] 1442 1443 def isKindResultType(self): 1444 return self.kind == completionChunkKindMap[15] 1445 1446 completionChunkKindMap = { 1447 0: CompletionChunk.Kind("Optional"), 1448 1: CompletionChunk.Kind("TypedText"), 1449 2: CompletionChunk.Kind("Text"), 1450 3: CompletionChunk.Kind("Placeholder"), 1451 4: CompletionChunk.Kind("Informative"), 1452 5: CompletionChunk.Kind("CurrentParameter"), 1453 6: CompletionChunk.Kind("LeftParen"), 1454 7: CompletionChunk.Kind("RightParen"), 1455 8: CompletionChunk.Kind("LeftBracket"), 1456 9: CompletionChunk.Kind("RightBracket"), 1457 10: CompletionChunk.Kind("LeftBrace"), 1458 11: CompletionChunk.Kind("RightBrace"), 1459 12: CompletionChunk.Kind("LeftAngle"), 1460 13: CompletionChunk.Kind("RightAngle"), 1461 14: CompletionChunk.Kind("Comma"), 1462 15: CompletionChunk.Kind("ResultType"), 1463 16: CompletionChunk.Kind("Colon"), 1464 17: CompletionChunk.Kind("SemiColon"), 1465 18: CompletionChunk.Kind("Equal"), 1466 19: CompletionChunk.Kind("HorizontalSpace"), 1467 20: CompletionChunk.Kind("VerticalSpace")} 1468 1469 class CompletionString(ClangObject): 1470 class Availability: 1471 def __init__(self, name): 1472 self.name = name 1473 1474 def __str__(self): 1475 return self.name 1476 1477 def __repr__(self): 1478 return "<Availability: %s>" % self 1479 1480 def __len__(self): 1481 return _clang_getNumCompletionChunks(self.obj) 1482 1483 def __getitem__(self, key): 1484 if len(self) <= key: 1485 raise IndexError 1486 return CompletionChunk(self.obj, key) 1487 1488 @property 1489 def priority(self): 1490 return _clang_getCompletionPriority(self.obj) 1491 1492 @property 1493 def availability(self): 1494 res = _clang_getCompletionAvailability(self.obj) 1495 return availabilityKinds[res] 1496 1497 def __repr__(self): 1498 return " | ".join([str(a) for a in self]) \ 1499 + " || Priority: " + str(self.priority) \ 1500 + " || Availability: " + str(self.availability) 1501 1502 availabilityKinds = { 1503 0: CompletionChunk.Kind("Available"), 1504 1: CompletionChunk.Kind("Deprecated"), 1505 2: CompletionChunk.Kind("NotAvailable")} 1506 1507 class CodeCompletionResult(Structure): 1508 _fields_ = [('cursorKind', c_int), ('completionString', c_object_p)] 1509 1510 def __repr__(self): 1511 return str(CompletionString(self.completionString)) 1512 1513 @property 1514 def kind(self): 1515 return CursorKind.from_id(self.cursorKind) 1516 1517 @property 1518 def string(self): 1519 return CompletionString(self.completionString) 1520 1521 class CCRStructure(Structure): 1522 _fields_ = [('results', POINTER(CodeCompletionResult)), 1523 ('numResults', c_int)] 1524 1525 def __len__(self): 1526 return self.numResults 1527 1528 def __getitem__(self, key): 1529 if len(self) <= key: 1530 raise IndexError 1531 1532 return self.results[key] 1533 1534 class CodeCompletionResults(ClangObject): 1535 def __init__(self, ptr): 1536 assert isinstance(ptr, POINTER(CCRStructure)) and ptr 1537 self.ptr = self._as_parameter_ = ptr 1538 1539 def from_param(self): 1540 return self._as_parameter_ 1541 1542 def __del__(self): 1543 CodeCompletionResults_dispose(self) 1544 1545 @property 1546 def results(self): 1547 return self.ptr.contents 1548 1549 @property 1550 def diagnostics(self): 1551 class DiagnosticsItr: 1552 def __init__(self, ccr): 1553 self.ccr= ccr 1554 1555 def __len__(self): 1556 return int(_clang_codeCompleteGetNumDiagnostics(self.ccr)) 1557 1558 def __getitem__(self, key): 1559 return _clang_codeCompleteGetDiagnostic(self.ccr, key) 1560 1561 return DiagnosticsItr(self) 1562 1563 1564 class Index(ClangObject): 1565 """ 1566 The Index type provides the primary interface to the Clang CIndex library, 1567 primarily by providing an interface for reading and parsing translation 1568 units. 1569 """ 1570 1571 @staticmethod 1572 def create(excludeDecls=False): 1573 """ 1574 Create a new Index. 1575 Parameters: 1576 excludeDecls -- Exclude local declarations from translation units. 1577 """ 1578 return Index(Index_create(excludeDecls, 0)) 1579 1580 def __del__(self): 1581 Index_dispose(self) 1582 1583 def read(self, path): 1584 """Load the translation unit from the given AST file.""" 1585 ptr = TranslationUnit_read(self, path) 1586 if ptr: 1587 return TranslationUnit(ptr) 1588 return None 1589 1590 def parse(self, path, args = [], unsaved_files = [], options = 0): 1591 """ 1592 Load the translation unit from the given source code file by running 1593 clang and generating the AST before loading. Additional command line 1594 parameters can be passed to clang via the args parameter. 1595 1596 In-memory contents for files can be provided by passing a list of pairs 1597 to as unsaved_files, the first item should be the filenames to be mapped 1598 and the second should be the contents to be substituted for the 1599 file. The contents may be passed as strings or file objects. 1600 """ 1601 arg_array = 0 1602 if len(args): 1603 arg_array = (c_char_p * len(args))(* args) 1604 unsaved_files_array = 0 1605 if len(unsaved_files): 1606 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1607 for i,(name,value) in enumerate(unsaved_files): 1608 if not isinstance(value, str): 1609 # FIXME: It would be great to support an efficient version 1610 # of this, one day. 1611 value = value.read() 1612 print value 1613 if not isinstance(value, str): 1614 raise TypeError,'Unexpected unsaved file contents.' 1615 unsaved_files_array[i].name = name 1616 unsaved_files_array[i].contents = value 1617 unsaved_files_array[i].length = len(value) 1618 ptr = TranslationUnit_parse(self, path, arg_array, len(args), 1619 unsaved_files_array, len(unsaved_files), 1620 options) 1621 if ptr: 1622 return TranslationUnit(ptr) 1623 return None 1624 1625 1626 class TranslationUnit(ClangObject): 1627 """ 1628 The TranslationUnit class represents a source code translation unit and 1629 provides read-only access to its top-level declarations. 1630 """ 1631 1632 def __init__(self, ptr): 1633 ClangObject.__init__(self, ptr) 1634 1635 def __del__(self): 1636 TranslationUnit_dispose(self) 1637 1638 @property 1639 def cursor(self): 1640 """Retrieve the cursor that represents the given translation unit.""" 1641 return TranslationUnit_cursor(self) 1642 1643 @property 1644 def spelling(self): 1645 """Get the original translation unit source file name.""" 1646 return TranslationUnit_spelling(self) 1647 1648 def get_includes(self): 1649 """ 1650 Return an iterable sequence of FileInclusion objects that describe the 1651 sequence of inclusions in a translation unit. The first object in 1652 this sequence is always the input file. Note that this method will not 1653 recursively iterate over header files included through precompiled 1654 headers. 1655 """ 1656 def visitor(fobj, lptr, depth, includes): 1657 if depth > 0: 1658 loc = lptr.contents 1659 includes.append(FileInclusion(loc.file, File(fobj), loc, depth)) 1660 1661 # Automatically adapt CIndex/ctype pointers to python objects 1662 includes = [] 1663 TranslationUnit_includes(self, 1664 TranslationUnit_includes_callback(visitor), 1665 includes) 1666 return iter(includes) 1667 1668 @property 1669 def diagnostics(self): 1670 """ 1671 Return an iterable (and indexable) object containing the diagnostics. 1672 """ 1673 class DiagIterator: 1674 def __init__(self, tu): 1675 self.tu = tu 1676 1677 def __len__(self): 1678 return int(_clang_getNumDiagnostics(self.tu)) 1679 1680 def __getitem__(self, key): 1681 diag = _clang_getDiagnostic(self.tu, key) 1682 if not diag: 1683 raise IndexError 1684 return Diagnostic(diag) 1685 1686 return DiagIterator(self) 1687 1688 def reparse(self, unsaved_files = [], options = 0): 1689 """ 1690 Reparse an already parsed translation unit. 1691 1692 In-memory contents for files can be provided by passing a list of pairs 1693 as unsaved_files, the first items should be the filenames to be mapped 1694 and the second should be the contents to be substituted for the 1695 file. The contents may be passed as strings or file objects. 1696 """ 1697 unsaved_files_array = 0 1698 if len(unsaved_files): 1699 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1700 for i,(name,value) in enumerate(unsaved_files): 1701 if not isinstance(value, str): 1702 # FIXME: It would be great to support an efficient version 1703 # of this, one day. 1704 value = value.read() 1705 print value 1706 if not isinstance(value, str): 1707 raise TypeError,'Unexpected unsaved file contents.' 1708 unsaved_files_array[i].name = name 1709 unsaved_files_array[i].contents = value 1710 unsaved_files_array[i].length = len(value) 1711 ptr = TranslationUnit_reparse(self, len(unsaved_files), 1712 unsaved_files_array, 1713 options) 1714 def codeComplete(self, path, line, column, unsaved_files = [], options = 0): 1715 """ 1716 Code complete in this translation unit. 1717 1718 In-memory contents for files can be provided by passing a list of pairs 1719 as unsaved_files, the first items should be the filenames to be mapped 1720 and the second should be the contents to be substituted for the 1721 file. The contents may be passed as strings or file objects. 1722 """ 1723 unsaved_files_array = 0 1724 if len(unsaved_files): 1725 unsaved_files_array = (_CXUnsavedFile * len(unsaved_files))() 1726 for i,(name,value) in enumerate(unsaved_files): 1727 if not isinstance(value, str): 1728 # FIXME: It would be great to support an efficient version 1729 # of this, one day. 1730 value = value.read() 1731 print value 1732 if not isinstance(value, str): 1733 raise TypeError,'Unexpected unsaved file contents.' 1734 unsaved_files_array[i].name = name 1735 unsaved_files_array[i].contents = value 1736 unsaved_files_array[i].length = len(value) 1737 ptr = TranslationUnit_codeComplete(self, path, 1738 line, column, 1739 unsaved_files_array, 1740 len(unsaved_files), 1741 options) 1742 if ptr: 1743 return CodeCompletionResults(ptr) 1744 return None 1745 1746 class File(ClangObject): 1747 """ 1748 The File class represents a particular source file that is part of a 1749 translation unit. 1750 """ 1751 1752 @staticmethod 1753 def from_name(translation_unit, file_name): 1754 """Retrieve a file handle within the given translation unit.""" 1755 return File(File_getFile(translation_unit, file_name)) 1756 1757 @property 1758 def name(self): 1759 """Return the complete file and path name of the file.""" 1760 return _CXString_getCString(File_name(self)) 1761 1762 @property 1763 def time(self): 1764 """Return the last modification time of the file.""" 1765 return File_time(self) 1766 1767 def __str__(self): 1768 return self.name 1769 1770 def __repr__(self): 1771 return "<File: %s>" % (self.name) 1772 1773 class FileInclusion(object): 1774 """ 1775 The FileInclusion class represents the inclusion of one source file by 1776 another via a '#include' directive or as the input file for the translation 1777 unit. This class provides information about the included file, the including 1778 file, the location of the '#include' directive and the depth of the included 1779 file in the stack. Note that the input file has depth 0. 1780 """ 1781 1782 def __init__(self, src, tgt, loc, depth): 1783 self.source = src 1784 self.include = tgt 1785 self.location = loc 1786 self.depth = depth 1787 1788 @property 1789 def is_input_file(self): 1790 """True if the included file is the input file.""" 1791 return self.depth == 0 1792 1793 # Additional Functions and Types 1794 1795 # String Functions 1796 _CXString_dispose = lib.clang_disposeString 1797 _CXString_dispose.argtypes = [_CXString] 1798 1799 _CXString_getCString = lib.clang_getCString 1800 _CXString_getCString.argtypes = [_CXString] 1801 _CXString_getCString.restype = c_char_p 1802 1803 # Source Location Functions 1804 SourceLocation_loc = lib.clang_getInstantiationLocation 1805 SourceLocation_loc.argtypes = [SourceLocation, POINTER(c_object_p), 1806 POINTER(c_uint), POINTER(c_uint), 1807 POINTER(c_uint)] 1808 1809 SourceLocation_getLocation = lib.clang_getLocation 1810 SourceLocation_getLocation.argtypes = [TranslationUnit, File, c_uint, c_uint] 1811 SourceLocation_getLocation.restype = SourceLocation 1812 1813 SourceLocation_equalLocations = lib.clang_equalLocations 1814 SourceLocation_equalLocations.argtypes = [SourceLocation, SourceLocation] 1815 SourceLocation_equalLocations.restype = bool 1816 1817 # Source Range Functions 1818 SourceRange_getRange = lib.clang_getRange 1819 SourceRange_getRange.argtypes = [SourceLocation, SourceLocation] 1820 SourceRange_getRange.restype = SourceRange 1821 1822 SourceRange_start = lib.clang_getRangeStart 1823 SourceRange_start.argtypes = [SourceRange] 1824 SourceRange_start.restype = SourceLocation 1825 1826 SourceRange_end = lib.clang_getRangeEnd 1827 SourceRange_end.argtypes = [SourceRange] 1828 SourceRange_end.restype = SourceLocation 1829 1830 SourceRange_equalRanges = lib.clang_equalRanges 1831 SourceRange_equalRanges.argtypes = [SourceRange, SourceRange] 1832 SourceRange_equalRanges.restype = bool 1833 1834 # CursorKind Functions 1835 CursorKind_is_decl = lib.clang_isDeclaration 1836 CursorKind_is_decl.argtypes = [CursorKind] 1837 CursorKind_is_decl.restype = bool 1838 1839 CursorKind_is_ref = lib.clang_isReference 1840 CursorKind_is_ref.argtypes = [CursorKind] 1841 CursorKind_is_ref.restype = bool 1842 1843 CursorKind_is_expr = lib.clang_isExpression 1844 CursorKind_is_expr.argtypes = [CursorKind] 1845 CursorKind_is_expr.restype = bool 1846 1847 CursorKind_is_stmt = lib.clang_isStatement 1848 CursorKind_is_stmt.argtypes = [CursorKind] 1849 CursorKind_is_stmt.restype = bool 1850 1851 CursorKind_is_attribute = lib.clang_isAttribute 1852 CursorKind_is_attribute.argtypes = [CursorKind] 1853 CursorKind_is_attribute.restype = bool 1854 1855 CursorKind_is_inv = lib.clang_isInvalid 1856 CursorKind_is_inv.argtypes = [CursorKind] 1857 CursorKind_is_inv.restype = bool 1858 1859 CursorKind_is_translation_unit = lib.clang_isTranslationUnit 1860 CursorKind_is_translation_unit.argtypes = [CursorKind] 1861 CursorKind_is_translation_unit.restype = bool 1862 1863 CursorKind_is_preprocessing = lib.clang_isPreprocessing 1864 CursorKind_is_preprocessing.argtypes = [CursorKind] 1865 CursorKind_is_preprocessing.restype = bool 1866 1867 CursorKind_is_unexposed = lib.clang_isUnexposed 1868 CursorKind_is_unexposed.argtypes = [CursorKind] 1869 CursorKind_is_unexposed.restype = bool 1870 1871 # Cursor Functions 1872 # TODO: Implement this function 1873 Cursor_get = lib.clang_getCursor 1874 Cursor_get.argtypes = [TranslationUnit, SourceLocation] 1875 Cursor_get.restype = Cursor 1876 1877 Cursor_null = lib.clang_getNullCursor 1878 Cursor_null.restype = Cursor 1879 1880 Cursor_usr = lib.clang_getCursorUSR 1881 Cursor_usr.argtypes = [Cursor] 1882 Cursor_usr.restype = _CXString 1883 Cursor_usr.errcheck = _CXString.from_result 1884 1885 Cursor_is_def = lib.clang_isCursorDefinition 1886 Cursor_is_def.argtypes = [Cursor] 1887 Cursor_is_def.restype = bool 1888 1889 Cursor_def = lib.clang_getCursorDefinition 1890 Cursor_def.argtypes = [Cursor] 1891 Cursor_def.restype = Cursor 1892 Cursor_def.errcheck = Cursor.from_result 1893 1894 Cursor_eq = lib.clang_equalCursors 1895 Cursor_eq.argtypes = [Cursor, Cursor] 1896 Cursor_eq.restype = bool 1897 1898 Cursor_hash = lib.clang_hashCursor 1899 Cursor_hash.argtypes = [Cursor] 1900 Cursor_hash.restype = c_uint 1901 1902 Cursor_spelling = lib.clang_getCursorSpelling 1903 Cursor_spelling.argtypes = [Cursor] 1904 Cursor_spelling.restype = _CXString 1905 Cursor_spelling.errcheck = _CXString.from_result 1906 1907 Cursor_displayname = lib.clang_getCursorDisplayName 1908 Cursor_displayname.argtypes = [Cursor] 1909 Cursor_displayname.restype = _CXString 1910 Cursor_displayname.errcheck = _CXString.from_result 1911 1912 Cursor_loc = lib.clang_getCursorLocation 1913 Cursor_loc.argtypes = [Cursor] 1914 Cursor_loc.restype = SourceLocation 1915 1916 Cursor_extent = lib.clang_getCursorExtent 1917 Cursor_extent.argtypes = [Cursor] 1918 Cursor_extent.restype = SourceRange 1919 1920 Cursor_ref = lib.clang_getCursorReferenced 1921 Cursor_ref.argtypes = [Cursor] 1922 Cursor_ref.restype = Cursor 1923 Cursor_ref.errcheck = Cursor.from_result 1924 1925 Cursor_type = lib.clang_getCursorType 1926 Cursor_type.argtypes = [Cursor] 1927 Cursor_type.restype = Type 1928 Cursor_type.errcheck = Type.from_result 1929 1930 Cursor_underlying_type = lib.clang_getTypedefDeclUnderlyingType 1931 Cursor_underlying_type.argtypes = [Cursor] 1932 Cursor_underlying_type.restype = Type 1933 Cursor_underlying_type.errcheck = Type.from_result 1934 1935 Cursor_enum_type = lib.clang_getEnumDeclIntegerType 1936 Cursor_enum_type.argtypes = [Cursor] 1937 Cursor_enum_type.restype = Type 1938 Cursor_enum_type.errcheck = Type.from_result 1939 1940 Cursor_objc_type_encoding = lib.clang_getDeclObjCTypeEncoding 1941 Cursor_objc_type_encoding.argtypes = [Cursor] 1942 Cursor_objc_type_encoding.restype = _CXString 1943 Cursor_objc_type_encoding.errcheck = _CXString.from_result 1944 1945 Cursor_visit_callback = CFUNCTYPE(c_int, Cursor, Cursor, py_object) 1946 Cursor_visit = lib.clang_visitChildren 1947 Cursor_visit.argtypes = [Cursor, Cursor_visit_callback, py_object] 1948 Cursor_visit.restype = c_uint 1949 1950 # Type Functions 1951 Type_get_canonical = lib.clang_getCanonicalType 1952 Type_get_canonical.argtypes = [Type] 1953 Type_get_canonical.restype = Type 1954 Type_get_canonical.errcheck = Type.from_result 1955 1956 Type_is_const_qualified = lib.clang_isConstQualifiedType 1957 Type_is_const_qualified.argtypes = [Type] 1958 Type_is_const_qualified.restype = bool 1959 1960 Type_is_volatile_qualified = lib.clang_isVolatileQualifiedType 1961 Type_is_volatile_qualified.argtypes = [Type] 1962 Type_is_volatile_qualified.restype = bool 1963 1964 Type_is_restrict_qualified = lib.clang_isRestrictQualifiedType 1965 Type_is_restrict_qualified.argtypes = [Type] 1966 Type_is_restrict_qualified.restype = bool 1967 1968 Type_is_pod = lib.clang_isPODType 1969 Type_is_pod.argtypes = [Type] 1970 Type_is_pod.restype = bool 1971 1972 Type_is_variadic = lib.clang_isFunctionTypeVariadic 1973 Type_is_variadic.argtypes = [Type] 1974 Type_is_variadic.restype = bool 1975 1976 Type_get_pointee = lib.clang_getPointeeType 1977 Type_get_pointee.argtypes = [Type] 1978 Type_get_pointee.restype = Type 1979 Type_get_pointee.errcheck = Type.from_result 1980 1981 Type_get_declaration = lib.clang_getTypeDeclaration 1982 Type_get_declaration.argtypes = [Type] 1983 Type_get_declaration.restype = Cursor 1984 Type_get_declaration.errcheck = Cursor.from_result 1985 1986 Type_get_result = lib.clang_getResultType 1987 Type_get_result.argtypes = [Type] 1988 Type_get_result.restype = Type 1989 Type_get_result.errcheck = Type.from_result 1990 1991 Type_get_num_arg_types = lib.clang_getNumArgTypes 1992 Type_get_num_arg_types.argtypes = [Type] 1993 Type_get_num_arg_types.restype = c_uint 1994 1995 Type_get_arg_type = lib.clang_getArgType 1996 Type_get_arg_type.argtypes = [Type, c_uint] 1997 Type_get_arg_type.restype = Type 1998 Type_get_arg_type.errcheck = Type.from_result 1999 Type_get_element_type = lib.clang_getElementType 2000 2001 Type_get_element_type.argtypes = [Type] 2002 Type_get_element_type.restype = Type 2003 Type_get_element_type.errcheck = Type.from_result 2004 2005 Type_get_num_elements = lib.clang_getNumElements 2006 Type_get_num_elements.argtypes = [Type] 2007 Type_get_num_elements.restype = c_longlong 2008 2009 Type_get_array_element = lib.clang_getArrayElementType 2010 Type_get_array_element.argtypes = [Type] 2011 Type_get_array_element.restype = Type 2012 Type_get_array_element.errcheck = Type.from_result 2013 2014 Type_get_array_size = lib.clang_getArraySize 2015 Type_get_array_size.argtype = [Type] 2016 Type_get_array_size.restype = c_longlong 2017 2018 Type_equal = lib.clang_equalTypes 2019 Type_equal.argtypes = [Type, Type] 2020 Type_equal.restype = bool 2021 2022 # Index Functions 2023 Index_create = lib.clang_createIndex 2024 Index_create.argtypes = [c_int, c_int] 2025 Index_create.restype = c_object_p 2026 2027 Index_dispose = lib.clang_disposeIndex 2028 Index_dispose.argtypes = [Index] 2029 2030 # Translation Unit Functions 2031 TranslationUnit_read = lib.clang_createTranslationUnit 2032 TranslationUnit_read.argtypes = [Index, c_char_p] 2033 TranslationUnit_read.restype = c_object_p 2034 2035 TranslationUnit_parse = lib.clang_parseTranslationUnit 2036 TranslationUnit_parse.argtypes = [Index, c_char_p, c_void_p, 2037 c_int, c_void_p, c_int, c_int] 2038 TranslationUnit_parse.restype = c_object_p 2039 2040 TranslationUnit_reparse = lib.clang_reparseTranslationUnit 2041 TranslationUnit_reparse.argtypes = [TranslationUnit, c_int, c_void_p, c_int] 2042 TranslationUnit_reparse.restype = c_int 2043 2044 TranslationUnit_codeComplete = lib.clang_codeCompleteAt 2045 TranslationUnit_codeComplete.argtypes = [TranslationUnit, c_char_p, c_int, 2046 c_int, c_void_p, c_int, c_int] 2047 TranslationUnit_codeComplete.restype = POINTER(CCRStructure) 2048 2049 TranslationUnit_cursor = lib.clang_getTranslationUnitCursor 2050 TranslationUnit_cursor.argtypes = [TranslationUnit] 2051 TranslationUnit_cursor.restype = Cursor 2052 TranslationUnit_cursor.errcheck = Cursor.from_result 2053 2054 TranslationUnit_spelling = lib.clang_getTranslationUnitSpelling 2055 TranslationUnit_spelling.argtypes = [TranslationUnit] 2056 TranslationUnit_spelling.restype = _CXString 2057 TranslationUnit_spelling.errcheck = _CXString.from_result 2058 2059 TranslationUnit_dispose = lib.clang_disposeTranslationUnit 2060 TranslationUnit_dispose.argtypes = [TranslationUnit] 2061 2062 TranslationUnit_includes_callback = CFUNCTYPE(None, 2063 c_object_p, 2064 POINTER(SourceLocation), 2065 c_uint, py_object) 2066 TranslationUnit_includes = lib.clang_getInclusions 2067 TranslationUnit_includes.argtypes = [TranslationUnit, 2068 TranslationUnit_includes_callback, 2069 py_object] 2070 2071 # File Functions 2072 File_getFile = lib.clang_getFile 2073 File_getFile.argtypes = [TranslationUnit, c_char_p] 2074 File_getFile.restype = c_object_p 2075 2076 File_name = lib.clang_getFileName 2077 File_name.argtypes = [File] 2078 File_name.restype = _CXString 2079 2080 File_time = lib.clang_getFileTime 2081 File_time.argtypes = [File] 2082 File_time.restype = c_uint 2083 2084 # Code completion 2085 2086 CodeCompletionResults_dispose = lib.clang_disposeCodeCompleteResults 2087 CodeCompletionResults_dispose.argtypes = [CodeCompletionResults] 2088 2089 _clang_codeCompleteGetNumDiagnostics = lib.clang_codeCompleteGetNumDiagnostics 2090 _clang_codeCompleteGetNumDiagnostics.argtypes = [CodeCompletionResults] 2091 _clang_codeCompleteGetNumDiagnostics.restype = c_int 2092 2093 _clang_codeCompleteGetDiagnostic = lib.clang_codeCompleteGetDiagnostic 2094 _clang_codeCompleteGetDiagnostic.argtypes = [CodeCompletionResults, c_int] 2095 _clang_codeCompleteGetDiagnostic.restype = Diagnostic 2096 2097 _clang_getCompletionChunkText = lib.clang_getCompletionChunkText 2098 _clang_getCompletionChunkText.argtypes = [c_void_p, c_int] 2099 _clang_getCompletionChunkText.restype = _CXString 2100 2101 _clang_getCompletionChunkKind = lib.clang_getCompletionChunkKind 2102 _clang_getCompletionChunkKind.argtypes = [c_void_p, c_int] 2103 _clang_getCompletionChunkKind.restype = c_int 2104 2105 _clang_getCompletionChunkCompletionString = lib.clang_getCompletionChunkCompletionString 2106 _clang_getCompletionChunkCompletionString.argtypes = [c_void_p, c_int] 2107 _clang_getCompletionChunkCompletionString.restype = c_object_p 2108 2109 _clang_getNumCompletionChunks = lib.clang_getNumCompletionChunks 2110 _clang_getNumCompletionChunks.argtypes = [c_void_p] 2111 _clang_getNumCompletionChunks.restype = c_int 2112 2113 _clang_getCompletionAvailability = lib.clang_getCompletionAvailability 2114 _clang_getCompletionAvailability.argtypes = [c_void_p] 2115 _clang_getCompletionAvailability.restype = c_int 2116 2117 _clang_getCompletionPriority = lib.clang_getCompletionPriority 2118 _clang_getCompletionPriority.argtypes = [c_void_p] 2119 _clang_getCompletionPriority.restype = c_int 2120 2121 2122 ### 2123 2124 __all__ = ['Index', 'TranslationUnit', 'Cursor', 'CursorKind', 'Type', 'TypeKind', 2125 'Diagnostic', 'FixIt', 'CodeCompletionResults', 'SourceRange', 2126 'SourceLocation', 'File'] 2127