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