1 /*===-- clang-c/Index.h - Indexing Public C Interface -------------*- C -*-===*\ 2 |* *| 3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| 4 |* Exceptions. *| 5 |* See https://llvm.org/LICENSE.txt for license information. *| 6 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| 7 |* *| 8 |*===----------------------------------------------------------------------===*| 9 |* *| 10 |* This header provides a public interface to a Clang library for extracting *| 11 |* high-level symbol information from source files without exposing the full *| 12 |* Clang C++ API. *| 13 |* *| 14 \*===----------------------------------------------------------------------===*/ 15 16 #ifndef LLVM_CLANG_C_INDEX_H 17 #define LLVM_CLANG_C_INDEX_H 18 19 #include "clang-c/BuildSystem.h" 20 #include "clang-c/CXDiagnostic.h" 21 #include "clang-c/CXErrorCode.h" 22 #include "clang-c/CXFile.h" 23 #include "clang-c/CXSourceLocation.h" 24 #include "clang-c/CXString.h" 25 #include "clang-c/ExternC.h" 26 #include "clang-c/Platform.h" 27 28 /** 29 * The version constants for the libclang API. 30 * CINDEX_VERSION_MINOR should increase when there are API additions. 31 * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes. 32 * 33 * The policy about the libclang API was always to keep it source and ABI 34 * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable. 35 */ 36 #define CINDEX_VERSION_MAJOR 0 37 #define CINDEX_VERSION_MINOR 64 38 39 #define CINDEX_VERSION_ENCODE(major, minor) (((major)*10000) + ((minor)*1)) 40 41 #define CINDEX_VERSION \ 42 CINDEX_VERSION_ENCODE(CINDEX_VERSION_MAJOR, CINDEX_VERSION_MINOR) 43 44 #define CINDEX_VERSION_STRINGIZE_(major, minor) #major "." #minor 45 #define CINDEX_VERSION_STRINGIZE(major, minor) \ 46 CINDEX_VERSION_STRINGIZE_(major, minor) 47 48 #define CINDEX_VERSION_STRING \ 49 CINDEX_VERSION_STRINGIZE(CINDEX_VERSION_MAJOR, CINDEX_VERSION_MINOR) 50 51 #ifndef __has_feature 52 #define __has_feature(feature) 0 53 #endif 54 55 LLVM_CLANG_C_EXTERN_C_BEGIN 56 57 /** \defgroup CINDEX libclang: C Interface to Clang 58 * 59 * The C Interface to Clang provides a relatively small API that exposes 60 * facilities for parsing source code into an abstract syntax tree (AST), 61 * loading already-parsed ASTs, traversing the AST, associating 62 * physical source locations with elements within the AST, and other 63 * facilities that support Clang-based development tools. 64 * 65 * This C interface to Clang will never provide all of the information 66 * representation stored in Clang's C++ AST, nor should it: the intent is to 67 * maintain an API that is relatively stable from one release to the next, 68 * providing only the basic functionality needed to support development tools. 69 * 70 * To avoid namespace pollution, data types are prefixed with "CX" and 71 * functions are prefixed with "clang_". 72 * 73 * @{ 74 */ 75 76 /** 77 * An "index" that consists of a set of translation units that would 78 * typically be linked together into an executable or library. 79 */ 80 typedef void *CXIndex; 81 82 /** 83 * An opaque type representing target information for a given translation 84 * unit. 85 */ 86 typedef struct CXTargetInfoImpl *CXTargetInfo; 87 88 /** 89 * A single translation unit, which resides in an index. 90 */ 91 typedef struct CXTranslationUnitImpl *CXTranslationUnit; 92 93 /** 94 * Opaque pointer representing client data that will be passed through 95 * to various callbacks and visitors. 96 */ 97 typedef void *CXClientData; 98 99 /** 100 * Provides the contents of a file that has not yet been saved to disk. 101 * 102 * Each CXUnsavedFile instance provides the name of a file on the 103 * system along with the current contents of that file that have not 104 * yet been saved to disk. 105 */ 106 struct CXUnsavedFile { 107 /** 108 * The file whose contents have not yet been saved. 109 * 110 * This file must already exist in the file system. 111 */ 112 const char *Filename; 113 114 /** 115 * A buffer containing the unsaved contents of this file. 116 */ 117 const char *Contents; 118 119 /** 120 * The length of the unsaved contents of this buffer. 121 */ 122 unsigned long Length; 123 }; 124 125 /** 126 * Describes the availability of a particular entity, which indicates 127 * whether the use of this entity will result in a warning or error due to 128 * it being deprecated or unavailable. 129 */ 130 enum CXAvailabilityKind { 131 /** 132 * The entity is available. 133 */ 134 CXAvailability_Available, 135 /** 136 * The entity is available, but has been deprecated (and its use is 137 * not recommended). 138 */ 139 CXAvailability_Deprecated, 140 /** 141 * The entity is not available; any use of it will be an error. 142 */ 143 CXAvailability_NotAvailable, 144 /** 145 * The entity is available, but not accessible; any use of it will be 146 * an error. 147 */ 148 CXAvailability_NotAccessible 149 }; 150 151 /** 152 * Describes a version number of the form major.minor.subminor. 153 */ 154 typedef struct CXVersion { 155 /** 156 * The major version number, e.g., the '10' in '10.7.3'. A negative 157 * value indicates that there is no version number at all. 158 */ 159 int Major; 160 /** 161 * The minor version number, e.g., the '7' in '10.7.3'. This value 162 * will be negative if no minor version number was provided, e.g., for 163 * version '10'. 164 */ 165 int Minor; 166 /** 167 * The subminor version number, e.g., the '3' in '10.7.3'. This value 168 * will be negative if no minor or subminor version number was provided, 169 * e.g., in version '10' or '10.7'. 170 */ 171 int Subminor; 172 } CXVersion; 173 174 /** 175 * Describes the exception specification of a cursor. 176 * 177 * A negative value indicates that the cursor is not a function declaration. 178 */ 179 enum CXCursor_ExceptionSpecificationKind { 180 /** 181 * The cursor has no exception specification. 182 */ 183 CXCursor_ExceptionSpecificationKind_None, 184 185 /** 186 * The cursor has exception specification throw() 187 */ 188 CXCursor_ExceptionSpecificationKind_DynamicNone, 189 190 /** 191 * The cursor has exception specification throw(T1, T2) 192 */ 193 CXCursor_ExceptionSpecificationKind_Dynamic, 194 195 /** 196 * The cursor has exception specification throw(...). 197 */ 198 CXCursor_ExceptionSpecificationKind_MSAny, 199 200 /** 201 * The cursor has exception specification basic noexcept. 202 */ 203 CXCursor_ExceptionSpecificationKind_BasicNoexcept, 204 205 /** 206 * The cursor has exception specification computed noexcept. 207 */ 208 CXCursor_ExceptionSpecificationKind_ComputedNoexcept, 209 210 /** 211 * The exception specification has not yet been evaluated. 212 */ 213 CXCursor_ExceptionSpecificationKind_Unevaluated, 214 215 /** 216 * The exception specification has not yet been instantiated. 217 */ 218 CXCursor_ExceptionSpecificationKind_Uninstantiated, 219 220 /** 221 * The exception specification has not been parsed yet. 222 */ 223 CXCursor_ExceptionSpecificationKind_Unparsed, 224 225 /** 226 * The cursor has a __declspec(nothrow) exception specification. 227 */ 228 CXCursor_ExceptionSpecificationKind_NoThrow 229 }; 230 231 /** 232 * Provides a shared context for creating translation units. 233 * 234 * It provides two options: 235 * 236 * - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local" 237 * declarations (when loading any new translation units). A "local" declaration 238 * is one that belongs in the translation unit itself and not in a precompiled 239 * header that was used by the translation unit. If zero, all declarations 240 * will be enumerated. 241 * 242 * Here is an example: 243 * 244 * \code 245 * // excludeDeclsFromPCH = 1, displayDiagnostics=1 246 * Idx = clang_createIndex(1, 1); 247 * 248 * // IndexTest.pch was produced with the following command: 249 * // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch" 250 * TU = clang_createTranslationUnit(Idx, "IndexTest.pch"); 251 * 252 * // This will load all the symbols from 'IndexTest.pch' 253 * clang_visitChildren(clang_getTranslationUnitCursor(TU), 254 * TranslationUnitVisitor, 0); 255 * clang_disposeTranslationUnit(TU); 256 * 257 * // This will load all the symbols from 'IndexTest.c', excluding symbols 258 * // from 'IndexTest.pch'. 259 * char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" }; 260 * TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args, 261 * 0, 0); 262 * clang_visitChildren(clang_getTranslationUnitCursor(TU), 263 * TranslationUnitVisitor, 0); 264 * clang_disposeTranslationUnit(TU); 265 * \endcode 266 * 267 * This process of creating the 'pch', loading it separately, and using it (via 268 * -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks 269 * (which gives the indexer the same performance benefit as the compiler). 270 */ 271 CINDEX_LINKAGE CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 272 int displayDiagnostics); 273 274 /** 275 * Destroy the given index. 276 * 277 * The index must not be destroyed until all of the translation units created 278 * within that index have been destroyed. 279 */ 280 CINDEX_LINKAGE void clang_disposeIndex(CXIndex index); 281 282 typedef enum { 283 /** 284 * Use the default value of an option that may depend on the process 285 * environment. 286 */ 287 CXChoice_Default = 0, 288 /** 289 * Enable the option. 290 */ 291 CXChoice_Enabled = 1, 292 /** 293 * Disable the option. 294 */ 295 CXChoice_Disabled = 2 296 } CXChoice; 297 298 typedef enum { 299 /** 300 * Used to indicate that no special CXIndex options are needed. 301 */ 302 CXGlobalOpt_None = 0x0, 303 304 /** 305 * Used to indicate that threads that libclang creates for indexing 306 * purposes should use background priority. 307 * 308 * Affects #clang_indexSourceFile, #clang_indexTranslationUnit, 309 * #clang_parseTranslationUnit, #clang_saveTranslationUnit. 310 */ 311 CXGlobalOpt_ThreadBackgroundPriorityForIndexing = 0x1, 312 313 /** 314 * Used to indicate that threads that libclang creates for editing 315 * purposes should use background priority. 316 * 317 * Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt, 318 * #clang_annotateTokens 319 */ 320 CXGlobalOpt_ThreadBackgroundPriorityForEditing = 0x2, 321 322 /** 323 * Used to indicate that all threads that libclang creates should use 324 * background priority. 325 */ 326 CXGlobalOpt_ThreadBackgroundPriorityForAll = 327 CXGlobalOpt_ThreadBackgroundPriorityForIndexing | 328 CXGlobalOpt_ThreadBackgroundPriorityForEditing 329 330 } CXGlobalOptFlags; 331 332 /** 333 * Index initialization options. 334 * 335 * 0 is the default value of each member of this struct except for Size. 336 * Initialize the struct in one of the following three ways to avoid adapting 337 * code each time a new member is added to it: 338 * \code 339 * CXIndexOptions Opts; 340 * memset(&Opts, 0, sizeof(Opts)); 341 * Opts.Size = sizeof(CXIndexOptions); 342 * \endcode 343 * or explicitly initialize the first data member and zero-initialize the rest: 344 * \code 345 * CXIndexOptions Opts = { sizeof(CXIndexOptions) }; 346 * \endcode 347 * or to prevent the -Wmissing-field-initializers warning for the above version: 348 * \code 349 * CXIndexOptions Opts{}; 350 * Opts.Size = sizeof(CXIndexOptions); 351 * \endcode 352 */ 353 typedef struct CXIndexOptions { 354 /** 355 * The size of struct CXIndexOptions used for option versioning. 356 * 357 * Always initialize this member to sizeof(CXIndexOptions), or assign 358 * sizeof(CXIndexOptions) to it right after creating a CXIndexOptions object. 359 */ 360 unsigned Size; 361 /** 362 * A CXChoice enumerator that specifies the indexing priority policy. 363 * \sa CXGlobalOpt_ThreadBackgroundPriorityForIndexing 364 */ 365 unsigned char ThreadBackgroundPriorityForIndexing; 366 /** 367 * A CXChoice enumerator that specifies the editing priority policy. 368 * \sa CXGlobalOpt_ThreadBackgroundPriorityForEditing 369 */ 370 unsigned char ThreadBackgroundPriorityForEditing; 371 /** 372 * \see clang_createIndex() 373 */ 374 unsigned ExcludeDeclarationsFromPCH : 1; 375 /** 376 * \see clang_createIndex() 377 */ 378 unsigned DisplayDiagnostics : 1; 379 /** 380 * Store PCH in memory. If zero, PCH are stored in temporary files. 381 */ 382 unsigned StorePreamblesInMemory : 1; 383 unsigned /*Reserved*/ : 13; 384 385 /** 386 * The path to a directory, in which to store temporary PCH files. If null or 387 * empty, the default system temporary directory is used. These PCH files are 388 * deleted on clean exit but stay on disk if the program crashes or is killed. 389 * 390 * This option is ignored if \a StorePreamblesInMemory is non-zero. 391 * 392 * Libclang does not create the directory at the specified path in the file 393 * system. Therefore it must exist, or storing PCH files will fail. 394 */ 395 const char *PreambleStoragePath; 396 /** 397 * Specifies a path which will contain log files for certain libclang 398 * invocations. A null value implies that libclang invocations are not logged. 399 */ 400 const char *InvocationEmissionPath; 401 } CXIndexOptions; 402 403 /** 404 * Provides a shared context for creating translation units. 405 * 406 * Call this function instead of clang_createIndex() if you need to configure 407 * the additional options in CXIndexOptions. 408 * 409 * \returns The created index or null in case of error, such as an unsupported 410 * value of options->Size. 411 * 412 * For example: 413 * \code 414 * CXIndex createIndex(const char *ApplicationTemporaryPath) { 415 * const int ExcludeDeclarationsFromPCH = 1; 416 * const int DisplayDiagnostics = 1; 417 * CXIndex Idx; 418 * #if CINDEX_VERSION_MINOR >= 64 419 * CXIndexOptions Opts; 420 * memset(&Opts, 0, sizeof(Opts)); 421 * Opts.Size = sizeof(CXIndexOptions); 422 * Opts.ThreadBackgroundPriorityForIndexing = 1; 423 * Opts.ExcludeDeclarationsFromPCH = ExcludeDeclarationsFromPCH; 424 * Opts.DisplayDiagnostics = DisplayDiagnostics; 425 * Opts.PreambleStoragePath = ApplicationTemporaryPath; 426 * Idx = clang_createIndexWithOptions(&Opts); 427 * if (Idx) 428 * return Idx; 429 * fprintf(stderr, 430 * "clang_createIndexWithOptions() failed. " 431 * "CINDEX_VERSION_MINOR = %d, sizeof(CXIndexOptions) = %u\n", 432 * CINDEX_VERSION_MINOR, Opts.Size); 433 * #else 434 * (void)ApplicationTemporaryPath; 435 * #endif 436 * Idx = clang_createIndex(ExcludeDeclarationsFromPCH, DisplayDiagnostics); 437 * clang_CXIndex_setGlobalOptions( 438 * Idx, clang_CXIndex_getGlobalOptions(Idx) | 439 * CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 440 * return Idx; 441 * } 442 * \endcode 443 * 444 * \sa clang_createIndex() 445 */ 446 CINDEX_LINKAGE CXIndex 447 clang_createIndexWithOptions(const CXIndexOptions *options); 448 449 /** 450 * Sets general options associated with a CXIndex. 451 * 452 * This function is DEPRECATED. Set 453 * CXIndexOptions::ThreadBackgroundPriorityForIndexing and/or 454 * CXIndexOptions::ThreadBackgroundPriorityForEditing and call 455 * clang_createIndexWithOptions() instead. 456 * 457 * For example: 458 * \code 459 * CXIndex idx = ...; 460 * clang_CXIndex_setGlobalOptions(idx, 461 * clang_CXIndex_getGlobalOptions(idx) | 462 * CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 463 * \endcode 464 * 465 * \param options A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags. 466 */ 467 CINDEX_LINKAGE void clang_CXIndex_setGlobalOptions(CXIndex, unsigned options); 468 469 /** 470 * Gets the general options associated with a CXIndex. 471 * 472 * This function allows to obtain the final option values used by libclang after 473 * specifying the option policies via CXChoice enumerators. 474 * 475 * \returns A bitmask of options, a bitwise OR of CXGlobalOpt_XXX flags that 476 * are associated with the given CXIndex object. 477 */ 478 CINDEX_LINKAGE unsigned clang_CXIndex_getGlobalOptions(CXIndex); 479 480 /** 481 * Sets the invocation emission path option in a CXIndex. 482 * 483 * This function is DEPRECATED. Set CXIndexOptions::InvocationEmissionPath and 484 * call clang_createIndexWithOptions() instead. 485 * 486 * The invocation emission path specifies a path which will contain log 487 * files for certain libclang invocations. A null value (default) implies that 488 * libclang invocations are not logged.. 489 */ 490 CINDEX_LINKAGE void 491 clang_CXIndex_setInvocationEmissionPathOption(CXIndex, const char *Path); 492 493 /** 494 * Determine whether the given header is guarded against 495 * multiple inclusions, either with the conventional 496 * \#ifndef/\#define/\#endif macro guards or with \#pragma once. 497 */ 498 CINDEX_LINKAGE unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, 499 CXFile file); 500 501 /** 502 * Retrieve a file handle within the given translation unit. 503 * 504 * \param tu the translation unit 505 * 506 * \param file_name the name of the file. 507 * 508 * \returns the file handle for the named file in the translation unit \p tu, 509 * or a NULL file handle if the file was not a part of this translation unit. 510 */ 511 CINDEX_LINKAGE CXFile clang_getFile(CXTranslationUnit tu, 512 const char *file_name); 513 514 /** 515 * Retrieve the buffer associated with the given file. 516 * 517 * \param tu the translation unit 518 * 519 * \param file the file for which to retrieve the buffer. 520 * 521 * \param size [out] if non-NULL, will be set to the size of the buffer. 522 * 523 * \returns a pointer to the buffer in memory that holds the contents of 524 * \p file, or a NULL pointer when the file is not loaded. 525 */ 526 CINDEX_LINKAGE const char *clang_getFileContents(CXTranslationUnit tu, 527 CXFile file, size_t *size); 528 529 /** 530 * Retrieves the source location associated with a given file/line/column 531 * in a particular translation unit. 532 */ 533 CINDEX_LINKAGE CXSourceLocation clang_getLocation(CXTranslationUnit tu, 534 CXFile file, unsigned line, 535 unsigned column); 536 /** 537 * Retrieves the source location associated with a given character offset 538 * in a particular translation unit. 539 */ 540 CINDEX_LINKAGE CXSourceLocation clang_getLocationForOffset(CXTranslationUnit tu, 541 CXFile file, 542 unsigned offset); 543 544 /** 545 * Retrieve all ranges that were skipped by the preprocessor. 546 * 547 * The preprocessor will skip lines when they are surrounded by an 548 * if/ifdef/ifndef directive whose condition does not evaluate to true. 549 */ 550 CINDEX_LINKAGE CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit tu, 551 CXFile file); 552 553 /** 554 * Retrieve all ranges from all files that were skipped by the 555 * preprocessor. 556 * 557 * The preprocessor will skip lines when they are surrounded by an 558 * if/ifdef/ifndef directive whose condition does not evaluate to true. 559 */ 560 CINDEX_LINKAGE CXSourceRangeList * 561 clang_getAllSkippedRanges(CXTranslationUnit tu); 562 563 /** 564 * Determine the number of diagnostics produced for the given 565 * translation unit. 566 */ 567 CINDEX_LINKAGE unsigned clang_getNumDiagnostics(CXTranslationUnit Unit); 568 569 /** 570 * Retrieve a diagnostic associated with the given translation unit. 571 * 572 * \param Unit the translation unit to query. 573 * \param Index the zero-based diagnostic number to retrieve. 574 * 575 * \returns the requested diagnostic. This diagnostic must be freed 576 * via a call to \c clang_disposeDiagnostic(). 577 */ 578 CINDEX_LINKAGE CXDiagnostic clang_getDiagnostic(CXTranslationUnit Unit, 579 unsigned Index); 580 581 /** 582 * Retrieve the complete set of diagnostics associated with a 583 * translation unit. 584 * 585 * \param Unit the translation unit to query. 586 */ 587 CINDEX_LINKAGE CXDiagnosticSet 588 clang_getDiagnosticSetFromTU(CXTranslationUnit Unit); 589 590 /** 591 * \defgroup CINDEX_TRANSLATION_UNIT Translation unit manipulation 592 * 593 * The routines in this group provide the ability to create and destroy 594 * translation units from files, either by parsing the contents of the files or 595 * by reading in a serialized representation of a translation unit. 596 * 597 * @{ 598 */ 599 600 /** 601 * Get the original translation unit source file name. 602 */ 603 CINDEX_LINKAGE CXString 604 clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit); 605 606 /** 607 * Return the CXTranslationUnit for a given source file and the provided 608 * command line arguments one would pass to the compiler. 609 * 610 * Note: The 'source_filename' argument is optional. If the caller provides a 611 * NULL pointer, the name of the source file is expected to reside in the 612 * specified command line arguments. 613 * 614 * Note: When encountered in 'clang_command_line_args', the following options 615 * are ignored: 616 * 617 * '-c' 618 * '-emit-ast' 619 * '-fsyntax-only' 620 * '-o \<output file>' (both '-o' and '\<output file>' are ignored) 621 * 622 * \param CIdx The index object with which the translation unit will be 623 * associated. 624 * 625 * \param source_filename The name of the source file to load, or NULL if the 626 * source file is included in \p clang_command_line_args. 627 * 628 * \param num_clang_command_line_args The number of command-line arguments in 629 * \p clang_command_line_args. 630 * 631 * \param clang_command_line_args The command-line arguments that would be 632 * passed to the \c clang executable if it were being invoked out-of-process. 633 * These command-line options will be parsed and will affect how the translation 634 * unit is parsed. Note that the following options are ignored: '-c', 635 * '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. 636 * 637 * \param num_unsaved_files the number of unsaved file entries in \p 638 * unsaved_files. 639 * 640 * \param unsaved_files the files that have not yet been saved to disk 641 * but may be required for code completion, including the contents of 642 * those files. The contents and name of these files (as specified by 643 * CXUnsavedFile) are copied when necessary, so the client only needs to 644 * guarantee their validity until the call to this function returns. 645 */ 646 CINDEX_LINKAGE CXTranslationUnit clang_createTranslationUnitFromSourceFile( 647 CXIndex CIdx, const char *source_filename, int num_clang_command_line_args, 648 const char *const *clang_command_line_args, unsigned num_unsaved_files, 649 struct CXUnsavedFile *unsaved_files); 650 651 /** 652 * Same as \c clang_createTranslationUnit2, but returns 653 * the \c CXTranslationUnit instead of an error code. In case of an error this 654 * routine returns a \c NULL \c CXTranslationUnit, without further detailed 655 * error codes. 656 */ 657 CINDEX_LINKAGE CXTranslationUnit 658 clang_createTranslationUnit(CXIndex CIdx, const char *ast_filename); 659 660 /** 661 * Create a translation unit from an AST file (\c -emit-ast). 662 * 663 * \param[out] out_TU A non-NULL pointer to store the created 664 * \c CXTranslationUnit. 665 * 666 * \returns Zero on success, otherwise returns an error code. 667 */ 668 CINDEX_LINKAGE enum CXErrorCode 669 clang_createTranslationUnit2(CXIndex CIdx, const char *ast_filename, 670 CXTranslationUnit *out_TU); 671 672 /** 673 * Flags that control the creation of translation units. 674 * 675 * The enumerators in this enumeration type are meant to be bitwise 676 * ORed together to specify which options should be used when 677 * constructing the translation unit. 678 */ 679 enum CXTranslationUnit_Flags { 680 /** 681 * Used to indicate that no special translation-unit options are 682 * needed. 683 */ 684 CXTranslationUnit_None = 0x0, 685 686 /** 687 * Used to indicate that the parser should construct a "detailed" 688 * preprocessing record, including all macro definitions and instantiations. 689 * 690 * Constructing a detailed preprocessing record requires more memory 691 * and time to parse, since the information contained in the record 692 * is usually not retained. However, it can be useful for 693 * applications that require more detailed information about the 694 * behavior of the preprocessor. 695 */ 696 CXTranslationUnit_DetailedPreprocessingRecord = 0x01, 697 698 /** 699 * Used to indicate that the translation unit is incomplete. 700 * 701 * When a translation unit is considered "incomplete", semantic 702 * analysis that is typically performed at the end of the 703 * translation unit will be suppressed. For example, this suppresses 704 * the completion of tentative declarations in C and of 705 * instantiation of implicitly-instantiation function templates in 706 * C++. This option is typically used when parsing a header with the 707 * intent of producing a precompiled header. 708 */ 709 CXTranslationUnit_Incomplete = 0x02, 710 711 /** 712 * Used to indicate that the translation unit should be built with an 713 * implicit precompiled header for the preamble. 714 * 715 * An implicit precompiled header is used as an optimization when a 716 * particular translation unit is likely to be reparsed many times 717 * when the sources aren't changing that often. In this case, an 718 * implicit precompiled header will be built containing all of the 719 * initial includes at the top of the main file (what we refer to as 720 * the "preamble" of the file). In subsequent parses, if the 721 * preamble or the files in it have not changed, \c 722 * clang_reparseTranslationUnit() will re-use the implicit 723 * precompiled header to improve parsing performance. 724 */ 725 CXTranslationUnit_PrecompiledPreamble = 0x04, 726 727 /** 728 * Used to indicate that the translation unit should cache some 729 * code-completion results with each reparse of the source file. 730 * 731 * Caching of code-completion results is a performance optimization that 732 * introduces some overhead to reparsing but improves the performance of 733 * code-completion operations. 734 */ 735 CXTranslationUnit_CacheCompletionResults = 0x08, 736 737 /** 738 * Used to indicate that the translation unit will be serialized with 739 * \c clang_saveTranslationUnit. 740 * 741 * This option is typically used when parsing a header with the intent of 742 * producing a precompiled header. 743 */ 744 CXTranslationUnit_ForSerialization = 0x10, 745 746 /** 747 * DEPRECATED: Enabled chained precompiled preambles in C++. 748 * 749 * Note: this is a *temporary* option that is available only while 750 * we are testing C++ precompiled preamble support. It is deprecated. 751 */ 752 CXTranslationUnit_CXXChainedPCH = 0x20, 753 754 /** 755 * Used to indicate that function/method bodies should be skipped while 756 * parsing. 757 * 758 * This option can be used to search for declarations/definitions while 759 * ignoring the usages. 760 */ 761 CXTranslationUnit_SkipFunctionBodies = 0x40, 762 763 /** 764 * Used to indicate that brief documentation comments should be 765 * included into the set of code completions returned from this translation 766 * unit. 767 */ 768 CXTranslationUnit_IncludeBriefCommentsInCodeCompletion = 0x80, 769 770 /** 771 * Used to indicate that the precompiled preamble should be created on 772 * the first parse. Otherwise it will be created on the first reparse. This 773 * trades runtime on the first parse (serializing the preamble takes time) for 774 * reduced runtime on the second parse (can now reuse the preamble). 775 */ 776 CXTranslationUnit_CreatePreambleOnFirstParse = 0x100, 777 778 /** 779 * Do not stop processing when fatal errors are encountered. 780 * 781 * When fatal errors are encountered while parsing a translation unit, 782 * semantic analysis is typically stopped early when compiling code. A common 783 * source for fatal errors are unresolvable include files. For the 784 * purposes of an IDE, this is undesirable behavior and as much information 785 * as possible should be reported. Use this flag to enable this behavior. 786 */ 787 CXTranslationUnit_KeepGoing = 0x200, 788 789 /** 790 * Sets the preprocessor in a mode for parsing a single file only. 791 */ 792 CXTranslationUnit_SingleFileParse = 0x400, 793 794 /** 795 * Used in combination with CXTranslationUnit_SkipFunctionBodies to 796 * constrain the skipping of function bodies to the preamble. 797 * 798 * The function bodies of the main file are not skipped. 799 */ 800 CXTranslationUnit_LimitSkipFunctionBodiesToPreamble = 0x800, 801 802 /** 803 * Used to indicate that attributed types should be included in CXType. 804 */ 805 CXTranslationUnit_IncludeAttributedTypes = 0x1000, 806 807 /** 808 * Used to indicate that implicit attributes should be visited. 809 */ 810 CXTranslationUnit_VisitImplicitAttributes = 0x2000, 811 812 /** 813 * Used to indicate that non-errors from included files should be ignored. 814 * 815 * If set, clang_getDiagnosticSetFromTU() will not report e.g. warnings from 816 * included files anymore. This speeds up clang_getDiagnosticSetFromTU() for 817 * the case where these warnings are not of interest, as for an IDE for 818 * example, which typically shows only the diagnostics in the main file. 819 */ 820 CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles = 0x4000, 821 822 /** 823 * Tells the preprocessor not to skip excluded conditional blocks. 824 */ 825 CXTranslationUnit_RetainExcludedConditionalBlocks = 0x8000 826 }; 827 828 /** 829 * Returns the set of flags that is suitable for parsing a translation 830 * unit that is being edited. 831 * 832 * The set of flags returned provide options for \c clang_parseTranslationUnit() 833 * to indicate that the translation unit is likely to be reparsed many times, 834 * either explicitly (via \c clang_reparseTranslationUnit()) or implicitly 835 * (e.g., by code completion (\c clang_codeCompletionAt())). The returned flag 836 * set contains an unspecified set of optimizations (e.g., the precompiled 837 * preamble) geared toward improving the performance of these routines. The 838 * set of optimizations enabled may change from one version to the next. 839 */ 840 CINDEX_LINKAGE unsigned clang_defaultEditingTranslationUnitOptions(void); 841 842 /** 843 * Same as \c clang_parseTranslationUnit2, but returns 844 * the \c CXTranslationUnit instead of an error code. In case of an error this 845 * routine returns a \c NULL \c CXTranslationUnit, without further detailed 846 * error codes. 847 */ 848 CINDEX_LINKAGE CXTranslationUnit clang_parseTranslationUnit( 849 CXIndex CIdx, const char *source_filename, 850 const char *const *command_line_args, int num_command_line_args, 851 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 852 unsigned options); 853 854 /** 855 * Parse the given source file and the translation unit corresponding 856 * to that file. 857 * 858 * This routine is the main entry point for the Clang C API, providing the 859 * ability to parse a source file into a translation unit that can then be 860 * queried by other functions in the API. This routine accepts a set of 861 * command-line arguments so that the compilation can be configured in the same 862 * way that the compiler is configured on the command line. 863 * 864 * \param CIdx The index object with which the translation unit will be 865 * associated. 866 * 867 * \param source_filename The name of the source file to load, or NULL if the 868 * source file is included in \c command_line_args. 869 * 870 * \param command_line_args The command-line arguments that would be 871 * passed to the \c clang executable if it were being invoked out-of-process. 872 * These command-line options will be parsed and will affect how the translation 873 * unit is parsed. Note that the following options are ignored: '-c', 874 * '-emit-ast', '-fsyntax-only' (which is the default), and '-o \<output file>'. 875 * 876 * \param num_command_line_args The number of command-line arguments in 877 * \c command_line_args. 878 * 879 * \param unsaved_files the files that have not yet been saved to disk 880 * but may be required for parsing, including the contents of 881 * those files. The contents and name of these files (as specified by 882 * CXUnsavedFile) are copied when necessary, so the client only needs to 883 * guarantee their validity until the call to this function returns. 884 * 885 * \param num_unsaved_files the number of unsaved file entries in \p 886 * unsaved_files. 887 * 888 * \param options A bitmask of options that affects how the translation unit 889 * is managed but not its compilation. This should be a bitwise OR of the 890 * CXTranslationUnit_XXX flags. 891 * 892 * \param[out] out_TU A non-NULL pointer to store the created 893 * \c CXTranslationUnit, describing the parsed code and containing any 894 * diagnostics produced by the compiler. 895 * 896 * \returns Zero on success, otherwise returns an error code. 897 */ 898 CINDEX_LINKAGE enum CXErrorCode clang_parseTranslationUnit2( 899 CXIndex CIdx, const char *source_filename, 900 const char *const *command_line_args, int num_command_line_args, 901 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 902 unsigned options, CXTranslationUnit *out_TU); 903 904 /** 905 * Same as clang_parseTranslationUnit2 but requires a full command line 906 * for \c command_line_args including argv[0]. This is useful if the standard 907 * library paths are relative to the binary. 908 */ 909 CINDEX_LINKAGE enum CXErrorCode clang_parseTranslationUnit2FullArgv( 910 CXIndex CIdx, const char *source_filename, 911 const char *const *command_line_args, int num_command_line_args, 912 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 913 unsigned options, CXTranslationUnit *out_TU); 914 915 /** 916 * Flags that control how translation units are saved. 917 * 918 * The enumerators in this enumeration type are meant to be bitwise 919 * ORed together to specify which options should be used when 920 * saving the translation unit. 921 */ 922 enum CXSaveTranslationUnit_Flags { 923 /** 924 * Used to indicate that no special saving options are needed. 925 */ 926 CXSaveTranslationUnit_None = 0x0 927 }; 928 929 /** 930 * Returns the set of flags that is suitable for saving a translation 931 * unit. 932 * 933 * The set of flags returned provide options for 934 * \c clang_saveTranslationUnit() by default. The returned flag 935 * set contains an unspecified set of options that save translation units with 936 * the most commonly-requested data. 937 */ 938 CINDEX_LINKAGE unsigned clang_defaultSaveOptions(CXTranslationUnit TU); 939 940 /** 941 * Describes the kind of error that occurred (if any) in a call to 942 * \c clang_saveTranslationUnit(). 943 */ 944 enum CXSaveError { 945 /** 946 * Indicates that no error occurred while saving a translation unit. 947 */ 948 CXSaveError_None = 0, 949 950 /** 951 * Indicates that an unknown error occurred while attempting to save 952 * the file. 953 * 954 * This error typically indicates that file I/O failed when attempting to 955 * write the file. 956 */ 957 CXSaveError_Unknown = 1, 958 959 /** 960 * Indicates that errors during translation prevented this attempt 961 * to save the translation unit. 962 * 963 * Errors that prevent the translation unit from being saved can be 964 * extracted using \c clang_getNumDiagnostics() and \c clang_getDiagnostic(). 965 */ 966 CXSaveError_TranslationErrors = 2, 967 968 /** 969 * Indicates that the translation unit to be saved was somehow 970 * invalid (e.g., NULL). 971 */ 972 CXSaveError_InvalidTU = 3 973 }; 974 975 /** 976 * Saves a translation unit into a serialized representation of 977 * that translation unit on disk. 978 * 979 * Any translation unit that was parsed without error can be saved 980 * into a file. The translation unit can then be deserialized into a 981 * new \c CXTranslationUnit with \c clang_createTranslationUnit() or, 982 * if it is an incomplete translation unit that corresponds to a 983 * header, used as a precompiled header when parsing other translation 984 * units. 985 * 986 * \param TU The translation unit to save. 987 * 988 * \param FileName The file to which the translation unit will be saved. 989 * 990 * \param options A bitmask of options that affects how the translation unit 991 * is saved. This should be a bitwise OR of the 992 * CXSaveTranslationUnit_XXX flags. 993 * 994 * \returns A value that will match one of the enumerators of the CXSaveError 995 * enumeration. Zero (CXSaveError_None) indicates that the translation unit was 996 * saved successfully, while a non-zero value indicates that a problem occurred. 997 */ 998 CINDEX_LINKAGE int clang_saveTranslationUnit(CXTranslationUnit TU, 999 const char *FileName, 1000 unsigned options); 1001 1002 /** 1003 * Suspend a translation unit in order to free memory associated with it. 1004 * 1005 * A suspended translation unit uses significantly less memory but on the other 1006 * side does not support any other calls than \c clang_reparseTranslationUnit 1007 * to resume it or \c clang_disposeTranslationUnit to dispose it completely. 1008 */ 1009 CINDEX_LINKAGE unsigned clang_suspendTranslationUnit(CXTranslationUnit); 1010 1011 /** 1012 * Destroy the specified CXTranslationUnit object. 1013 */ 1014 CINDEX_LINKAGE void clang_disposeTranslationUnit(CXTranslationUnit); 1015 1016 /** 1017 * Flags that control the reparsing of translation units. 1018 * 1019 * The enumerators in this enumeration type are meant to be bitwise 1020 * ORed together to specify which options should be used when 1021 * reparsing the translation unit. 1022 */ 1023 enum CXReparse_Flags { 1024 /** 1025 * Used to indicate that no special reparsing options are needed. 1026 */ 1027 CXReparse_None = 0x0 1028 }; 1029 1030 /** 1031 * Returns the set of flags that is suitable for reparsing a translation 1032 * unit. 1033 * 1034 * The set of flags returned provide options for 1035 * \c clang_reparseTranslationUnit() by default. The returned flag 1036 * set contains an unspecified set of optimizations geared toward common uses 1037 * of reparsing. The set of optimizations enabled may change from one version 1038 * to the next. 1039 */ 1040 CINDEX_LINKAGE unsigned clang_defaultReparseOptions(CXTranslationUnit TU); 1041 1042 /** 1043 * Reparse the source files that produced this translation unit. 1044 * 1045 * This routine can be used to re-parse the source files that originally 1046 * created the given translation unit, for example because those source files 1047 * have changed (either on disk or as passed via \p unsaved_files). The 1048 * source code will be reparsed with the same command-line options as it 1049 * was originally parsed. 1050 * 1051 * Reparsing a translation unit invalidates all cursors and source locations 1052 * that refer into that translation unit. This makes reparsing a translation 1053 * unit semantically equivalent to destroying the translation unit and then 1054 * creating a new translation unit with the same command-line arguments. 1055 * However, it may be more efficient to reparse a translation 1056 * unit using this routine. 1057 * 1058 * \param TU The translation unit whose contents will be re-parsed. The 1059 * translation unit must originally have been built with 1060 * \c clang_createTranslationUnitFromSourceFile(). 1061 * 1062 * \param num_unsaved_files The number of unsaved file entries in \p 1063 * unsaved_files. 1064 * 1065 * \param unsaved_files The files that have not yet been saved to disk 1066 * but may be required for parsing, including the contents of 1067 * those files. The contents and name of these files (as specified by 1068 * CXUnsavedFile) are copied when necessary, so the client only needs to 1069 * guarantee their validity until the call to this function returns. 1070 * 1071 * \param options A bitset of options composed of the flags in CXReparse_Flags. 1072 * The function \c clang_defaultReparseOptions() produces a default set of 1073 * options recommended for most uses, based on the translation unit. 1074 * 1075 * \returns 0 if the sources could be reparsed. A non-zero error code will be 1076 * returned if reparsing was impossible, such that the translation unit is 1077 * invalid. In such cases, the only valid call for \c TU is 1078 * \c clang_disposeTranslationUnit(TU). The error codes returned by this 1079 * routine are described by the \c CXErrorCode enum. 1080 */ 1081 CINDEX_LINKAGE int 1082 clang_reparseTranslationUnit(CXTranslationUnit TU, unsigned num_unsaved_files, 1083 struct CXUnsavedFile *unsaved_files, 1084 unsigned options); 1085 1086 /** 1087 * Categorizes how memory is being used by a translation unit. 1088 */ 1089 enum CXTUResourceUsageKind { 1090 CXTUResourceUsage_AST = 1, 1091 CXTUResourceUsage_Identifiers = 2, 1092 CXTUResourceUsage_Selectors = 3, 1093 CXTUResourceUsage_GlobalCompletionResults = 4, 1094 CXTUResourceUsage_SourceManagerContentCache = 5, 1095 CXTUResourceUsage_AST_SideTables = 6, 1096 CXTUResourceUsage_SourceManager_Membuffer_Malloc = 7, 1097 CXTUResourceUsage_SourceManager_Membuffer_MMap = 8, 1098 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc = 9, 1099 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap = 10, 1100 CXTUResourceUsage_Preprocessor = 11, 1101 CXTUResourceUsage_PreprocessingRecord = 12, 1102 CXTUResourceUsage_SourceManager_DataStructures = 13, 1103 CXTUResourceUsage_Preprocessor_HeaderSearch = 14, 1104 CXTUResourceUsage_MEMORY_IN_BYTES_BEGIN = CXTUResourceUsage_AST, 1105 CXTUResourceUsage_MEMORY_IN_BYTES_END = 1106 CXTUResourceUsage_Preprocessor_HeaderSearch, 1107 1108 CXTUResourceUsage_First = CXTUResourceUsage_AST, 1109 CXTUResourceUsage_Last = CXTUResourceUsage_Preprocessor_HeaderSearch 1110 }; 1111 1112 /** 1113 * Returns the human-readable null-terminated C string that represents 1114 * the name of the memory category. This string should never be freed. 1115 */ 1116 CINDEX_LINKAGE 1117 const char *clang_getTUResourceUsageName(enum CXTUResourceUsageKind kind); 1118 1119 typedef struct CXTUResourceUsageEntry { 1120 /* The memory usage category. */ 1121 enum CXTUResourceUsageKind kind; 1122 /* Amount of resources used. 1123 The units will depend on the resource kind. */ 1124 unsigned long amount; 1125 } CXTUResourceUsageEntry; 1126 1127 /** 1128 * The memory usage of a CXTranslationUnit, broken into categories. 1129 */ 1130 typedef struct CXTUResourceUsage { 1131 /* Private data member, used for queries. */ 1132 void *data; 1133 1134 /* The number of entries in the 'entries' array. */ 1135 unsigned numEntries; 1136 1137 /* An array of key-value pairs, representing the breakdown of memory 1138 usage. */ 1139 CXTUResourceUsageEntry *entries; 1140 1141 } CXTUResourceUsage; 1142 1143 /** 1144 * Return the memory usage of a translation unit. This object 1145 * should be released with clang_disposeCXTUResourceUsage(). 1146 */ 1147 CINDEX_LINKAGE CXTUResourceUsage 1148 clang_getCXTUResourceUsage(CXTranslationUnit TU); 1149 1150 CINDEX_LINKAGE void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage); 1151 1152 /** 1153 * Get target information for this translation unit. 1154 * 1155 * The CXTargetInfo object cannot outlive the CXTranslationUnit object. 1156 */ 1157 CINDEX_LINKAGE CXTargetInfo 1158 clang_getTranslationUnitTargetInfo(CXTranslationUnit CTUnit); 1159 1160 /** 1161 * Destroy the CXTargetInfo object. 1162 */ 1163 CINDEX_LINKAGE void clang_TargetInfo_dispose(CXTargetInfo Info); 1164 1165 /** 1166 * Get the normalized target triple as a string. 1167 * 1168 * Returns the empty string in case of any error. 1169 */ 1170 CINDEX_LINKAGE CXString clang_TargetInfo_getTriple(CXTargetInfo Info); 1171 1172 /** 1173 * Get the pointer width of the target in bits. 1174 * 1175 * Returns -1 in case of error. 1176 */ 1177 CINDEX_LINKAGE int clang_TargetInfo_getPointerWidth(CXTargetInfo Info); 1178 1179 /** 1180 * @} 1181 */ 1182 1183 /** 1184 * Describes the kind of entity that a cursor refers to. 1185 */ 1186 enum CXCursorKind { 1187 /* Declarations */ 1188 /** 1189 * A declaration whose specific kind is not exposed via this 1190 * interface. 1191 * 1192 * Unexposed declarations have the same operations as any other kind 1193 * of declaration; one can extract their location information, 1194 * spelling, find their definitions, etc. However, the specific kind 1195 * of the declaration is not reported. 1196 */ 1197 CXCursor_UnexposedDecl = 1, 1198 /** A C or C++ struct. */ 1199 CXCursor_StructDecl = 2, 1200 /** A C or C++ union. */ 1201 CXCursor_UnionDecl = 3, 1202 /** A C++ class. */ 1203 CXCursor_ClassDecl = 4, 1204 /** An enumeration. */ 1205 CXCursor_EnumDecl = 5, 1206 /** 1207 * A field (in C) or non-static data member (in C++) in a 1208 * struct, union, or C++ class. 1209 */ 1210 CXCursor_FieldDecl = 6, 1211 /** An enumerator constant. */ 1212 CXCursor_EnumConstantDecl = 7, 1213 /** A function. */ 1214 CXCursor_FunctionDecl = 8, 1215 /** A variable. */ 1216 CXCursor_VarDecl = 9, 1217 /** A function or method parameter. */ 1218 CXCursor_ParmDecl = 10, 1219 /** An Objective-C \@interface. */ 1220 CXCursor_ObjCInterfaceDecl = 11, 1221 /** An Objective-C \@interface for a category. */ 1222 CXCursor_ObjCCategoryDecl = 12, 1223 /** An Objective-C \@protocol declaration. */ 1224 CXCursor_ObjCProtocolDecl = 13, 1225 /** An Objective-C \@property declaration. */ 1226 CXCursor_ObjCPropertyDecl = 14, 1227 /** An Objective-C instance variable. */ 1228 CXCursor_ObjCIvarDecl = 15, 1229 /** An Objective-C instance method. */ 1230 CXCursor_ObjCInstanceMethodDecl = 16, 1231 /** An Objective-C class method. */ 1232 CXCursor_ObjCClassMethodDecl = 17, 1233 /** An Objective-C \@implementation. */ 1234 CXCursor_ObjCImplementationDecl = 18, 1235 /** An Objective-C \@implementation for a category. */ 1236 CXCursor_ObjCCategoryImplDecl = 19, 1237 /** A typedef. */ 1238 CXCursor_TypedefDecl = 20, 1239 /** A C++ class method. */ 1240 CXCursor_CXXMethod = 21, 1241 /** A C++ namespace. */ 1242 CXCursor_Namespace = 22, 1243 /** A linkage specification, e.g. 'extern "C"'. */ 1244 CXCursor_LinkageSpec = 23, 1245 /** A C++ constructor. */ 1246 CXCursor_Constructor = 24, 1247 /** A C++ destructor. */ 1248 CXCursor_Destructor = 25, 1249 /** A C++ conversion function. */ 1250 CXCursor_ConversionFunction = 26, 1251 /** A C++ template type parameter. */ 1252 CXCursor_TemplateTypeParameter = 27, 1253 /** A C++ non-type template parameter. */ 1254 CXCursor_NonTypeTemplateParameter = 28, 1255 /** A C++ template template parameter. */ 1256 CXCursor_TemplateTemplateParameter = 29, 1257 /** A C++ function template. */ 1258 CXCursor_FunctionTemplate = 30, 1259 /** A C++ class template. */ 1260 CXCursor_ClassTemplate = 31, 1261 /** A C++ class template partial specialization. */ 1262 CXCursor_ClassTemplatePartialSpecialization = 32, 1263 /** A C++ namespace alias declaration. */ 1264 CXCursor_NamespaceAlias = 33, 1265 /** A C++ using directive. */ 1266 CXCursor_UsingDirective = 34, 1267 /** A C++ using declaration. */ 1268 CXCursor_UsingDeclaration = 35, 1269 /** A C++ alias declaration */ 1270 CXCursor_TypeAliasDecl = 36, 1271 /** An Objective-C \@synthesize definition. */ 1272 CXCursor_ObjCSynthesizeDecl = 37, 1273 /** An Objective-C \@dynamic definition. */ 1274 CXCursor_ObjCDynamicDecl = 38, 1275 /** An access specifier. */ 1276 CXCursor_CXXAccessSpecifier = 39, 1277 1278 CXCursor_FirstDecl = CXCursor_UnexposedDecl, 1279 CXCursor_LastDecl = CXCursor_CXXAccessSpecifier, 1280 1281 /* References */ 1282 CXCursor_FirstRef = 40, /* Decl references */ 1283 CXCursor_ObjCSuperClassRef = 40, 1284 CXCursor_ObjCProtocolRef = 41, 1285 CXCursor_ObjCClassRef = 42, 1286 /** 1287 * A reference to a type declaration. 1288 * 1289 * A type reference occurs anywhere where a type is named but not 1290 * declared. For example, given: 1291 * 1292 * \code 1293 * typedef unsigned size_type; 1294 * size_type size; 1295 * \endcode 1296 * 1297 * The typedef is a declaration of size_type (CXCursor_TypedefDecl), 1298 * while the type of the variable "size" is referenced. The cursor 1299 * referenced by the type of size is the typedef for size_type. 1300 */ 1301 CXCursor_TypeRef = 43, 1302 CXCursor_CXXBaseSpecifier = 44, 1303 /** 1304 * A reference to a class template, function template, template 1305 * template parameter, or class template partial specialization. 1306 */ 1307 CXCursor_TemplateRef = 45, 1308 /** 1309 * A reference to a namespace or namespace alias. 1310 */ 1311 CXCursor_NamespaceRef = 46, 1312 /** 1313 * A reference to a member of a struct, union, or class that occurs in 1314 * some non-expression context, e.g., a designated initializer. 1315 */ 1316 CXCursor_MemberRef = 47, 1317 /** 1318 * A reference to a labeled statement. 1319 * 1320 * This cursor kind is used to describe the jump to "start_over" in the 1321 * goto statement in the following example: 1322 * 1323 * \code 1324 * start_over: 1325 * ++counter; 1326 * 1327 * goto start_over; 1328 * \endcode 1329 * 1330 * A label reference cursor refers to a label statement. 1331 */ 1332 CXCursor_LabelRef = 48, 1333 1334 /** 1335 * A reference to a set of overloaded functions or function templates 1336 * that has not yet been resolved to a specific function or function template. 1337 * 1338 * An overloaded declaration reference cursor occurs in C++ templates where 1339 * a dependent name refers to a function. For example: 1340 * 1341 * \code 1342 * template<typename T> void swap(T&, T&); 1343 * 1344 * struct X { ... }; 1345 * void swap(X&, X&); 1346 * 1347 * template<typename T> 1348 * void reverse(T* first, T* last) { 1349 * while (first < last - 1) { 1350 * swap(*first, *--last); 1351 * ++first; 1352 * } 1353 * } 1354 * 1355 * struct Y { }; 1356 * void swap(Y&, Y&); 1357 * \endcode 1358 * 1359 * Here, the identifier "swap" is associated with an overloaded declaration 1360 * reference. In the template definition, "swap" refers to either of the two 1361 * "swap" functions declared above, so both results will be available. At 1362 * instantiation time, "swap" may also refer to other functions found via 1363 * argument-dependent lookup (e.g., the "swap" function at the end of the 1364 * example). 1365 * 1366 * The functions \c clang_getNumOverloadedDecls() and 1367 * \c clang_getOverloadedDecl() can be used to retrieve the definitions 1368 * referenced by this cursor. 1369 */ 1370 CXCursor_OverloadedDeclRef = 49, 1371 1372 /** 1373 * A reference to a variable that occurs in some non-expression 1374 * context, e.g., a C++ lambda capture list. 1375 */ 1376 CXCursor_VariableRef = 50, 1377 1378 CXCursor_LastRef = CXCursor_VariableRef, 1379 1380 /* Error conditions */ 1381 CXCursor_FirstInvalid = 70, 1382 CXCursor_InvalidFile = 70, 1383 CXCursor_NoDeclFound = 71, 1384 CXCursor_NotImplemented = 72, 1385 CXCursor_InvalidCode = 73, 1386 CXCursor_LastInvalid = CXCursor_InvalidCode, 1387 1388 /* Expressions */ 1389 CXCursor_FirstExpr = 100, 1390 1391 /** 1392 * An expression whose specific kind is not exposed via this 1393 * interface. 1394 * 1395 * Unexposed expressions have the same operations as any other kind 1396 * of expression; one can extract their location information, 1397 * spelling, children, etc. However, the specific kind of the 1398 * expression is not reported. 1399 */ 1400 CXCursor_UnexposedExpr = 100, 1401 1402 /** 1403 * An expression that refers to some value declaration, such 1404 * as a function, variable, or enumerator. 1405 */ 1406 CXCursor_DeclRefExpr = 101, 1407 1408 /** 1409 * An expression that refers to a member of a struct, union, 1410 * class, Objective-C class, etc. 1411 */ 1412 CXCursor_MemberRefExpr = 102, 1413 1414 /** An expression that calls a function. */ 1415 CXCursor_CallExpr = 103, 1416 1417 /** An expression that sends a message to an Objective-C 1418 object or class. */ 1419 CXCursor_ObjCMessageExpr = 104, 1420 1421 /** An expression that represents a block literal. */ 1422 CXCursor_BlockExpr = 105, 1423 1424 /** An integer literal. 1425 */ 1426 CXCursor_IntegerLiteral = 106, 1427 1428 /** A floating point number literal. 1429 */ 1430 CXCursor_FloatingLiteral = 107, 1431 1432 /** An imaginary number literal. 1433 */ 1434 CXCursor_ImaginaryLiteral = 108, 1435 1436 /** A string literal. 1437 */ 1438 CXCursor_StringLiteral = 109, 1439 1440 /** A character literal. 1441 */ 1442 CXCursor_CharacterLiteral = 110, 1443 1444 /** A parenthesized expression, e.g. "(1)". 1445 * 1446 * This AST node is only formed if full location information is requested. 1447 */ 1448 CXCursor_ParenExpr = 111, 1449 1450 /** This represents the unary-expression's (except sizeof and 1451 * alignof). 1452 */ 1453 CXCursor_UnaryOperator = 112, 1454 1455 /** [C99 6.5.2.1] Array Subscripting. 1456 */ 1457 CXCursor_ArraySubscriptExpr = 113, 1458 1459 /** A builtin binary operation expression such as "x + y" or 1460 * "x <= y". 1461 */ 1462 CXCursor_BinaryOperator = 114, 1463 1464 /** Compound assignment such as "+=". 1465 */ 1466 CXCursor_CompoundAssignOperator = 115, 1467 1468 /** The ?: ternary operator. 1469 */ 1470 CXCursor_ConditionalOperator = 116, 1471 1472 /** An explicit cast in C (C99 6.5.4) or a C-style cast in C++ 1473 * (C++ [expr.cast]), which uses the syntax (Type)expr. 1474 * 1475 * For example: (int)f. 1476 */ 1477 CXCursor_CStyleCastExpr = 117, 1478 1479 /** [C99 6.5.2.5] 1480 */ 1481 CXCursor_CompoundLiteralExpr = 118, 1482 1483 /** Describes an C or C++ initializer list. 1484 */ 1485 CXCursor_InitListExpr = 119, 1486 1487 /** The GNU address of label extension, representing &&label. 1488 */ 1489 CXCursor_AddrLabelExpr = 120, 1490 1491 /** This is the GNU Statement Expression extension: ({int X=4; X;}) 1492 */ 1493 CXCursor_StmtExpr = 121, 1494 1495 /** Represents a C11 generic selection. 1496 */ 1497 CXCursor_GenericSelectionExpr = 122, 1498 1499 /** Implements the GNU __null extension, which is a name for a null 1500 * pointer constant that has integral type (e.g., int or long) and is the same 1501 * size and alignment as a pointer. 1502 * 1503 * The __null extension is typically only used by system headers, which define 1504 * NULL as __null in C++ rather than using 0 (which is an integer that may not 1505 * match the size of a pointer). 1506 */ 1507 CXCursor_GNUNullExpr = 123, 1508 1509 /** C++'s static_cast<> expression. 1510 */ 1511 CXCursor_CXXStaticCastExpr = 124, 1512 1513 /** C++'s dynamic_cast<> expression. 1514 */ 1515 CXCursor_CXXDynamicCastExpr = 125, 1516 1517 /** C++'s reinterpret_cast<> expression. 1518 */ 1519 CXCursor_CXXReinterpretCastExpr = 126, 1520 1521 /** C++'s const_cast<> expression. 1522 */ 1523 CXCursor_CXXConstCastExpr = 127, 1524 1525 /** Represents an explicit C++ type conversion that uses "functional" 1526 * notion (C++ [expr.type.conv]). 1527 * 1528 * Example: 1529 * \code 1530 * x = int(0.5); 1531 * \endcode 1532 */ 1533 CXCursor_CXXFunctionalCastExpr = 128, 1534 1535 /** A C++ typeid expression (C++ [expr.typeid]). 1536 */ 1537 CXCursor_CXXTypeidExpr = 129, 1538 1539 /** [C++ 2.13.5] C++ Boolean Literal. 1540 */ 1541 CXCursor_CXXBoolLiteralExpr = 130, 1542 1543 /** [C++0x 2.14.7] C++ Pointer Literal. 1544 */ 1545 CXCursor_CXXNullPtrLiteralExpr = 131, 1546 1547 /** Represents the "this" expression in C++ 1548 */ 1549 CXCursor_CXXThisExpr = 132, 1550 1551 /** [C++ 15] C++ Throw Expression. 1552 * 1553 * This handles 'throw' and 'throw' assignment-expression. When 1554 * assignment-expression isn't present, Op will be null. 1555 */ 1556 CXCursor_CXXThrowExpr = 133, 1557 1558 /** A new expression for memory allocation and constructor calls, e.g: 1559 * "new CXXNewExpr(foo)". 1560 */ 1561 CXCursor_CXXNewExpr = 134, 1562 1563 /** A delete expression for memory deallocation and destructor calls, 1564 * e.g. "delete[] pArray". 1565 */ 1566 CXCursor_CXXDeleteExpr = 135, 1567 1568 /** A unary expression. (noexcept, sizeof, or other traits) 1569 */ 1570 CXCursor_UnaryExpr = 136, 1571 1572 /** An Objective-C string literal i.e. @"foo". 1573 */ 1574 CXCursor_ObjCStringLiteral = 137, 1575 1576 /** An Objective-C \@encode expression. 1577 */ 1578 CXCursor_ObjCEncodeExpr = 138, 1579 1580 /** An Objective-C \@selector expression. 1581 */ 1582 CXCursor_ObjCSelectorExpr = 139, 1583 1584 /** An Objective-C \@protocol expression. 1585 */ 1586 CXCursor_ObjCProtocolExpr = 140, 1587 1588 /** An Objective-C "bridged" cast expression, which casts between 1589 * Objective-C pointers and C pointers, transferring ownership in the process. 1590 * 1591 * \code 1592 * NSString *str = (__bridge_transfer NSString *)CFCreateString(); 1593 * \endcode 1594 */ 1595 CXCursor_ObjCBridgedCastExpr = 141, 1596 1597 /** Represents a C++0x pack expansion that produces a sequence of 1598 * expressions. 1599 * 1600 * A pack expansion expression contains a pattern (which itself is an 1601 * expression) followed by an ellipsis. For example: 1602 * 1603 * \code 1604 * template<typename F, typename ...Types> 1605 * void forward(F f, Types &&...args) { 1606 * f(static_cast<Types&&>(args)...); 1607 * } 1608 * \endcode 1609 */ 1610 CXCursor_PackExpansionExpr = 142, 1611 1612 /** Represents an expression that computes the length of a parameter 1613 * pack. 1614 * 1615 * \code 1616 * template<typename ...Types> 1617 * struct count { 1618 * static const unsigned value = sizeof...(Types); 1619 * }; 1620 * \endcode 1621 */ 1622 CXCursor_SizeOfPackExpr = 143, 1623 1624 /* Represents a C++ lambda expression that produces a local function 1625 * object. 1626 * 1627 * \code 1628 * void abssort(float *x, unsigned N) { 1629 * std::sort(x, x + N, 1630 * [](float a, float b) { 1631 * return std::abs(a) < std::abs(b); 1632 * }); 1633 * } 1634 * \endcode 1635 */ 1636 CXCursor_LambdaExpr = 144, 1637 1638 /** Objective-c Boolean Literal. 1639 */ 1640 CXCursor_ObjCBoolLiteralExpr = 145, 1641 1642 /** Represents the "self" expression in an Objective-C method. 1643 */ 1644 CXCursor_ObjCSelfExpr = 146, 1645 1646 /** OpenMP 5.0 [2.1.5, Array Section]. 1647 * OpenACC 3.3 [2.7.1, Data Specification for Data Clauses (Sub Arrays)] 1648 */ 1649 CXCursor_ArraySectionExpr = 147, 1650 1651 /** Represents an @available(...) check. 1652 */ 1653 CXCursor_ObjCAvailabilityCheckExpr = 148, 1654 1655 /** 1656 * Fixed point literal 1657 */ 1658 CXCursor_FixedPointLiteral = 149, 1659 1660 /** OpenMP 5.0 [2.1.4, Array Shaping]. 1661 */ 1662 CXCursor_OMPArrayShapingExpr = 150, 1663 1664 /** 1665 * OpenMP 5.0 [2.1.6 Iterators] 1666 */ 1667 CXCursor_OMPIteratorExpr = 151, 1668 1669 /** OpenCL's addrspace_cast<> expression. 1670 */ 1671 CXCursor_CXXAddrspaceCastExpr = 152, 1672 1673 /** 1674 * Expression that references a C++20 concept. 1675 */ 1676 CXCursor_ConceptSpecializationExpr = 153, 1677 1678 /** 1679 * Expression that references a C++20 requires expression. 1680 */ 1681 CXCursor_RequiresExpr = 154, 1682 1683 /** 1684 * Expression that references a C++20 parenthesized list aggregate 1685 * initializer. 1686 */ 1687 CXCursor_CXXParenListInitExpr = 155, 1688 1689 /** 1690 * Represents a C++26 pack indexing expression. 1691 */ 1692 CXCursor_PackIndexingExpr = 156, 1693 1694 CXCursor_LastExpr = CXCursor_PackIndexingExpr, 1695 1696 /* Statements */ 1697 CXCursor_FirstStmt = 200, 1698 /** 1699 * A statement whose specific kind is not exposed via this 1700 * interface. 1701 * 1702 * Unexposed statements have the same operations as any other kind of 1703 * statement; one can extract their location information, spelling, 1704 * children, etc. However, the specific kind of the statement is not 1705 * reported. 1706 */ 1707 CXCursor_UnexposedStmt = 200, 1708 1709 /** A labelled statement in a function. 1710 * 1711 * This cursor kind is used to describe the "start_over:" label statement in 1712 * the following example: 1713 * 1714 * \code 1715 * start_over: 1716 * ++counter; 1717 * \endcode 1718 * 1719 */ 1720 CXCursor_LabelStmt = 201, 1721 1722 /** A group of statements like { stmt stmt }. 1723 * 1724 * This cursor kind is used to describe compound statements, e.g. function 1725 * bodies. 1726 */ 1727 CXCursor_CompoundStmt = 202, 1728 1729 /** A case statement. 1730 */ 1731 CXCursor_CaseStmt = 203, 1732 1733 /** A default statement. 1734 */ 1735 CXCursor_DefaultStmt = 204, 1736 1737 /** An if statement 1738 */ 1739 CXCursor_IfStmt = 205, 1740 1741 /** A switch statement. 1742 */ 1743 CXCursor_SwitchStmt = 206, 1744 1745 /** A while statement. 1746 */ 1747 CXCursor_WhileStmt = 207, 1748 1749 /** A do statement. 1750 */ 1751 CXCursor_DoStmt = 208, 1752 1753 /** A for statement. 1754 */ 1755 CXCursor_ForStmt = 209, 1756 1757 /** A goto statement. 1758 */ 1759 CXCursor_GotoStmt = 210, 1760 1761 /** An indirect goto statement. 1762 */ 1763 CXCursor_IndirectGotoStmt = 211, 1764 1765 /** A continue statement. 1766 */ 1767 CXCursor_ContinueStmt = 212, 1768 1769 /** A break statement. 1770 */ 1771 CXCursor_BreakStmt = 213, 1772 1773 /** A return statement. 1774 */ 1775 CXCursor_ReturnStmt = 214, 1776 1777 /** A GCC inline assembly statement extension. 1778 */ 1779 CXCursor_GCCAsmStmt = 215, 1780 CXCursor_AsmStmt = CXCursor_GCCAsmStmt, 1781 1782 /** Objective-C's overall \@try-\@catch-\@finally statement. 1783 */ 1784 CXCursor_ObjCAtTryStmt = 216, 1785 1786 /** Objective-C's \@catch statement. 1787 */ 1788 CXCursor_ObjCAtCatchStmt = 217, 1789 1790 /** Objective-C's \@finally statement. 1791 */ 1792 CXCursor_ObjCAtFinallyStmt = 218, 1793 1794 /** Objective-C's \@throw statement. 1795 */ 1796 CXCursor_ObjCAtThrowStmt = 219, 1797 1798 /** Objective-C's \@synchronized statement. 1799 */ 1800 CXCursor_ObjCAtSynchronizedStmt = 220, 1801 1802 /** Objective-C's autorelease pool statement. 1803 */ 1804 CXCursor_ObjCAutoreleasePoolStmt = 221, 1805 1806 /** Objective-C's collection statement. 1807 */ 1808 CXCursor_ObjCForCollectionStmt = 222, 1809 1810 /** C++'s catch statement. 1811 */ 1812 CXCursor_CXXCatchStmt = 223, 1813 1814 /** C++'s try statement. 1815 */ 1816 CXCursor_CXXTryStmt = 224, 1817 1818 /** C++'s for (* : *) statement. 1819 */ 1820 CXCursor_CXXForRangeStmt = 225, 1821 1822 /** Windows Structured Exception Handling's try statement. 1823 */ 1824 CXCursor_SEHTryStmt = 226, 1825 1826 /** Windows Structured Exception Handling's except statement. 1827 */ 1828 CXCursor_SEHExceptStmt = 227, 1829 1830 /** Windows Structured Exception Handling's finally statement. 1831 */ 1832 CXCursor_SEHFinallyStmt = 228, 1833 1834 /** A MS inline assembly statement extension. 1835 */ 1836 CXCursor_MSAsmStmt = 229, 1837 1838 /** The null statement ";": C99 6.8.3p3. 1839 * 1840 * This cursor kind is used to describe the null statement. 1841 */ 1842 CXCursor_NullStmt = 230, 1843 1844 /** Adaptor class for mixing declarations with statements and 1845 * expressions. 1846 */ 1847 CXCursor_DeclStmt = 231, 1848 1849 /** OpenMP parallel directive. 1850 */ 1851 CXCursor_OMPParallelDirective = 232, 1852 1853 /** OpenMP SIMD directive. 1854 */ 1855 CXCursor_OMPSimdDirective = 233, 1856 1857 /** OpenMP for directive. 1858 */ 1859 CXCursor_OMPForDirective = 234, 1860 1861 /** OpenMP sections directive. 1862 */ 1863 CXCursor_OMPSectionsDirective = 235, 1864 1865 /** OpenMP section directive. 1866 */ 1867 CXCursor_OMPSectionDirective = 236, 1868 1869 /** OpenMP single directive. 1870 */ 1871 CXCursor_OMPSingleDirective = 237, 1872 1873 /** OpenMP parallel for directive. 1874 */ 1875 CXCursor_OMPParallelForDirective = 238, 1876 1877 /** OpenMP parallel sections directive. 1878 */ 1879 CXCursor_OMPParallelSectionsDirective = 239, 1880 1881 /** OpenMP task directive. 1882 */ 1883 CXCursor_OMPTaskDirective = 240, 1884 1885 /** OpenMP master directive. 1886 */ 1887 CXCursor_OMPMasterDirective = 241, 1888 1889 /** OpenMP critical directive. 1890 */ 1891 CXCursor_OMPCriticalDirective = 242, 1892 1893 /** OpenMP taskyield directive. 1894 */ 1895 CXCursor_OMPTaskyieldDirective = 243, 1896 1897 /** OpenMP barrier directive. 1898 */ 1899 CXCursor_OMPBarrierDirective = 244, 1900 1901 /** OpenMP taskwait directive. 1902 */ 1903 CXCursor_OMPTaskwaitDirective = 245, 1904 1905 /** OpenMP flush directive. 1906 */ 1907 CXCursor_OMPFlushDirective = 246, 1908 1909 /** Windows Structured Exception Handling's leave statement. 1910 */ 1911 CXCursor_SEHLeaveStmt = 247, 1912 1913 /** OpenMP ordered directive. 1914 */ 1915 CXCursor_OMPOrderedDirective = 248, 1916 1917 /** OpenMP atomic directive. 1918 */ 1919 CXCursor_OMPAtomicDirective = 249, 1920 1921 /** OpenMP for SIMD directive. 1922 */ 1923 CXCursor_OMPForSimdDirective = 250, 1924 1925 /** OpenMP parallel for SIMD directive. 1926 */ 1927 CXCursor_OMPParallelForSimdDirective = 251, 1928 1929 /** OpenMP target directive. 1930 */ 1931 CXCursor_OMPTargetDirective = 252, 1932 1933 /** OpenMP teams directive. 1934 */ 1935 CXCursor_OMPTeamsDirective = 253, 1936 1937 /** OpenMP taskgroup directive. 1938 */ 1939 CXCursor_OMPTaskgroupDirective = 254, 1940 1941 /** OpenMP cancellation point directive. 1942 */ 1943 CXCursor_OMPCancellationPointDirective = 255, 1944 1945 /** OpenMP cancel directive. 1946 */ 1947 CXCursor_OMPCancelDirective = 256, 1948 1949 /** OpenMP target data directive. 1950 */ 1951 CXCursor_OMPTargetDataDirective = 257, 1952 1953 /** OpenMP taskloop directive. 1954 */ 1955 CXCursor_OMPTaskLoopDirective = 258, 1956 1957 /** OpenMP taskloop simd directive. 1958 */ 1959 CXCursor_OMPTaskLoopSimdDirective = 259, 1960 1961 /** OpenMP distribute directive. 1962 */ 1963 CXCursor_OMPDistributeDirective = 260, 1964 1965 /** OpenMP target enter data directive. 1966 */ 1967 CXCursor_OMPTargetEnterDataDirective = 261, 1968 1969 /** OpenMP target exit data directive. 1970 */ 1971 CXCursor_OMPTargetExitDataDirective = 262, 1972 1973 /** OpenMP target parallel directive. 1974 */ 1975 CXCursor_OMPTargetParallelDirective = 263, 1976 1977 /** OpenMP target parallel for directive. 1978 */ 1979 CXCursor_OMPTargetParallelForDirective = 264, 1980 1981 /** OpenMP target update directive. 1982 */ 1983 CXCursor_OMPTargetUpdateDirective = 265, 1984 1985 /** OpenMP distribute parallel for directive. 1986 */ 1987 CXCursor_OMPDistributeParallelForDirective = 266, 1988 1989 /** OpenMP distribute parallel for simd directive. 1990 */ 1991 CXCursor_OMPDistributeParallelForSimdDirective = 267, 1992 1993 /** OpenMP distribute simd directive. 1994 */ 1995 CXCursor_OMPDistributeSimdDirective = 268, 1996 1997 /** OpenMP target parallel for simd directive. 1998 */ 1999 CXCursor_OMPTargetParallelForSimdDirective = 269, 2000 2001 /** OpenMP target simd directive. 2002 */ 2003 CXCursor_OMPTargetSimdDirective = 270, 2004 2005 /** OpenMP teams distribute directive. 2006 */ 2007 CXCursor_OMPTeamsDistributeDirective = 271, 2008 2009 /** OpenMP teams distribute simd directive. 2010 */ 2011 CXCursor_OMPTeamsDistributeSimdDirective = 272, 2012 2013 /** OpenMP teams distribute parallel for simd directive. 2014 */ 2015 CXCursor_OMPTeamsDistributeParallelForSimdDirective = 273, 2016 2017 /** OpenMP teams distribute parallel for directive. 2018 */ 2019 CXCursor_OMPTeamsDistributeParallelForDirective = 274, 2020 2021 /** OpenMP target teams directive. 2022 */ 2023 CXCursor_OMPTargetTeamsDirective = 275, 2024 2025 /** OpenMP target teams distribute directive. 2026 */ 2027 CXCursor_OMPTargetTeamsDistributeDirective = 276, 2028 2029 /** OpenMP target teams distribute parallel for directive. 2030 */ 2031 CXCursor_OMPTargetTeamsDistributeParallelForDirective = 277, 2032 2033 /** OpenMP target teams distribute parallel for simd directive. 2034 */ 2035 CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective = 278, 2036 2037 /** OpenMP target teams distribute simd directive. 2038 */ 2039 CXCursor_OMPTargetTeamsDistributeSimdDirective = 279, 2040 2041 /** C++2a std::bit_cast expression. 2042 */ 2043 CXCursor_BuiltinBitCastExpr = 280, 2044 2045 /** OpenMP master taskloop directive. 2046 */ 2047 CXCursor_OMPMasterTaskLoopDirective = 281, 2048 2049 /** OpenMP parallel master taskloop directive. 2050 */ 2051 CXCursor_OMPParallelMasterTaskLoopDirective = 282, 2052 2053 /** OpenMP master taskloop simd directive. 2054 */ 2055 CXCursor_OMPMasterTaskLoopSimdDirective = 283, 2056 2057 /** OpenMP parallel master taskloop simd directive. 2058 */ 2059 CXCursor_OMPParallelMasterTaskLoopSimdDirective = 284, 2060 2061 /** OpenMP parallel master directive. 2062 */ 2063 CXCursor_OMPParallelMasterDirective = 285, 2064 2065 /** OpenMP depobj directive. 2066 */ 2067 CXCursor_OMPDepobjDirective = 286, 2068 2069 /** OpenMP scan directive. 2070 */ 2071 CXCursor_OMPScanDirective = 287, 2072 2073 /** OpenMP tile directive. 2074 */ 2075 CXCursor_OMPTileDirective = 288, 2076 2077 /** OpenMP canonical loop. 2078 */ 2079 CXCursor_OMPCanonicalLoop = 289, 2080 2081 /** OpenMP interop directive. 2082 */ 2083 CXCursor_OMPInteropDirective = 290, 2084 2085 /** OpenMP dispatch directive. 2086 */ 2087 CXCursor_OMPDispatchDirective = 291, 2088 2089 /** OpenMP masked directive. 2090 */ 2091 CXCursor_OMPMaskedDirective = 292, 2092 2093 /** OpenMP unroll directive. 2094 */ 2095 CXCursor_OMPUnrollDirective = 293, 2096 2097 /** OpenMP metadirective directive. 2098 */ 2099 CXCursor_OMPMetaDirective = 294, 2100 2101 /** OpenMP loop directive. 2102 */ 2103 CXCursor_OMPGenericLoopDirective = 295, 2104 2105 /** OpenMP teams loop directive. 2106 */ 2107 CXCursor_OMPTeamsGenericLoopDirective = 296, 2108 2109 /** OpenMP target teams loop directive. 2110 */ 2111 CXCursor_OMPTargetTeamsGenericLoopDirective = 297, 2112 2113 /** OpenMP parallel loop directive. 2114 */ 2115 CXCursor_OMPParallelGenericLoopDirective = 298, 2116 2117 /** OpenMP target parallel loop directive. 2118 */ 2119 CXCursor_OMPTargetParallelGenericLoopDirective = 299, 2120 2121 /** OpenMP parallel masked directive. 2122 */ 2123 CXCursor_OMPParallelMaskedDirective = 300, 2124 2125 /** OpenMP masked taskloop directive. 2126 */ 2127 CXCursor_OMPMaskedTaskLoopDirective = 301, 2128 2129 /** OpenMP masked taskloop simd directive. 2130 */ 2131 CXCursor_OMPMaskedTaskLoopSimdDirective = 302, 2132 2133 /** OpenMP parallel masked taskloop directive. 2134 */ 2135 CXCursor_OMPParallelMaskedTaskLoopDirective = 303, 2136 2137 /** OpenMP parallel masked taskloop simd directive. 2138 */ 2139 CXCursor_OMPParallelMaskedTaskLoopSimdDirective = 304, 2140 2141 /** OpenMP error directive. 2142 */ 2143 CXCursor_OMPErrorDirective = 305, 2144 2145 /** OpenMP scope directive. 2146 */ 2147 CXCursor_OMPScopeDirective = 306, 2148 2149 /** OpenMP reverse directive. 2150 */ 2151 CXCursor_OMPReverseDirective = 307, 2152 2153 /** OpenMP interchange directive. 2154 */ 2155 CXCursor_OMPInterchangeDirective = 308, 2156 2157 /** OpenACC Compute Construct. 2158 */ 2159 CXCursor_OpenACCComputeConstruct = 320, 2160 2161 /** OpenACC Loop Construct. 2162 */ 2163 CXCursor_OpenACCLoopConstruct = 321, 2164 2165 CXCursor_LastStmt = CXCursor_OpenACCLoopConstruct, 2166 2167 /** 2168 * Cursor that represents the translation unit itself. 2169 * 2170 * The translation unit cursor exists primarily to act as the root 2171 * cursor for traversing the contents of a translation unit. 2172 */ 2173 CXCursor_TranslationUnit = 350, 2174 2175 /* Attributes */ 2176 CXCursor_FirstAttr = 400, 2177 /** 2178 * An attribute whose specific kind is not exposed via this 2179 * interface. 2180 */ 2181 CXCursor_UnexposedAttr = 400, 2182 2183 CXCursor_IBActionAttr = 401, 2184 CXCursor_IBOutletAttr = 402, 2185 CXCursor_IBOutletCollectionAttr = 403, 2186 CXCursor_CXXFinalAttr = 404, 2187 CXCursor_CXXOverrideAttr = 405, 2188 CXCursor_AnnotateAttr = 406, 2189 CXCursor_AsmLabelAttr = 407, 2190 CXCursor_PackedAttr = 408, 2191 CXCursor_PureAttr = 409, 2192 CXCursor_ConstAttr = 410, 2193 CXCursor_NoDuplicateAttr = 411, 2194 CXCursor_CUDAConstantAttr = 412, 2195 CXCursor_CUDADeviceAttr = 413, 2196 CXCursor_CUDAGlobalAttr = 414, 2197 CXCursor_CUDAHostAttr = 415, 2198 CXCursor_CUDASharedAttr = 416, 2199 CXCursor_VisibilityAttr = 417, 2200 CXCursor_DLLExport = 418, 2201 CXCursor_DLLImport = 419, 2202 CXCursor_NSReturnsRetained = 420, 2203 CXCursor_NSReturnsNotRetained = 421, 2204 CXCursor_NSReturnsAutoreleased = 422, 2205 CXCursor_NSConsumesSelf = 423, 2206 CXCursor_NSConsumed = 424, 2207 CXCursor_ObjCException = 425, 2208 CXCursor_ObjCNSObject = 426, 2209 CXCursor_ObjCIndependentClass = 427, 2210 CXCursor_ObjCPreciseLifetime = 428, 2211 CXCursor_ObjCReturnsInnerPointer = 429, 2212 CXCursor_ObjCRequiresSuper = 430, 2213 CXCursor_ObjCRootClass = 431, 2214 CXCursor_ObjCSubclassingRestricted = 432, 2215 CXCursor_ObjCExplicitProtocolImpl = 433, 2216 CXCursor_ObjCDesignatedInitializer = 434, 2217 CXCursor_ObjCRuntimeVisible = 435, 2218 CXCursor_ObjCBoxable = 436, 2219 CXCursor_FlagEnum = 437, 2220 CXCursor_ConvergentAttr = 438, 2221 CXCursor_WarnUnusedAttr = 439, 2222 CXCursor_WarnUnusedResultAttr = 440, 2223 CXCursor_AlignedAttr = 441, 2224 CXCursor_LastAttr = CXCursor_AlignedAttr, 2225 2226 /* Preprocessing */ 2227 CXCursor_PreprocessingDirective = 500, 2228 CXCursor_MacroDefinition = 501, 2229 CXCursor_MacroExpansion = 502, 2230 CXCursor_MacroInstantiation = CXCursor_MacroExpansion, 2231 CXCursor_InclusionDirective = 503, 2232 CXCursor_FirstPreprocessing = CXCursor_PreprocessingDirective, 2233 CXCursor_LastPreprocessing = CXCursor_InclusionDirective, 2234 2235 /* Extra Declarations */ 2236 /** 2237 * A module import declaration. 2238 */ 2239 CXCursor_ModuleImportDecl = 600, 2240 CXCursor_TypeAliasTemplateDecl = 601, 2241 /** 2242 * A static_assert or _Static_assert node 2243 */ 2244 CXCursor_StaticAssert = 602, 2245 /** 2246 * a friend declaration. 2247 */ 2248 CXCursor_FriendDecl = 603, 2249 /** 2250 * a concept declaration. 2251 */ 2252 CXCursor_ConceptDecl = 604, 2253 2254 CXCursor_FirstExtraDecl = CXCursor_ModuleImportDecl, 2255 CXCursor_LastExtraDecl = CXCursor_ConceptDecl, 2256 2257 /** 2258 * A code completion overload candidate. 2259 */ 2260 CXCursor_OverloadCandidate = 700 2261 }; 2262 2263 /** 2264 * A cursor representing some element in the abstract syntax tree for 2265 * a translation unit. 2266 * 2267 * The cursor abstraction unifies the different kinds of entities in a 2268 * program--declaration, statements, expressions, references to declarations, 2269 * etc.--under a single "cursor" abstraction with a common set of operations. 2270 * Common operation for a cursor include: getting the physical location in 2271 * a source file where the cursor points, getting the name associated with a 2272 * cursor, and retrieving cursors for any child nodes of a particular cursor. 2273 * 2274 * Cursors can be produced in two specific ways. 2275 * clang_getTranslationUnitCursor() produces a cursor for a translation unit, 2276 * from which one can use clang_visitChildren() to explore the rest of the 2277 * translation unit. clang_getCursor() maps from a physical source location 2278 * to the entity that resides at that location, allowing one to map from the 2279 * source code into the AST. 2280 */ 2281 typedef struct { 2282 enum CXCursorKind kind; 2283 int xdata; 2284 const void *data[3]; 2285 } CXCursor; 2286 2287 /** 2288 * \defgroup CINDEX_CURSOR_MANIP Cursor manipulations 2289 * 2290 * @{ 2291 */ 2292 2293 /** 2294 * Retrieve the NULL cursor, which represents no entity. 2295 */ 2296 CINDEX_LINKAGE CXCursor clang_getNullCursor(void); 2297 2298 /** 2299 * Retrieve the cursor that represents the given translation unit. 2300 * 2301 * The translation unit cursor can be used to start traversing the 2302 * various declarations within the given translation unit. 2303 */ 2304 CINDEX_LINKAGE CXCursor clang_getTranslationUnitCursor(CXTranslationUnit); 2305 2306 /** 2307 * Determine whether two cursors are equivalent. 2308 */ 2309 CINDEX_LINKAGE unsigned clang_equalCursors(CXCursor, CXCursor); 2310 2311 /** 2312 * Returns non-zero if \p cursor is null. 2313 */ 2314 CINDEX_LINKAGE int clang_Cursor_isNull(CXCursor cursor); 2315 2316 /** 2317 * Compute a hash value for the given cursor. 2318 */ 2319 CINDEX_LINKAGE unsigned clang_hashCursor(CXCursor); 2320 2321 /** 2322 * Retrieve the kind of the given cursor. 2323 */ 2324 CINDEX_LINKAGE enum CXCursorKind clang_getCursorKind(CXCursor); 2325 2326 /** 2327 * Determine whether the given cursor kind represents a declaration. 2328 */ 2329 CINDEX_LINKAGE unsigned clang_isDeclaration(enum CXCursorKind); 2330 2331 /** 2332 * Determine whether the given declaration is invalid. 2333 * 2334 * A declaration is invalid if it could not be parsed successfully. 2335 * 2336 * \returns non-zero if the cursor represents a declaration and it is 2337 * invalid, otherwise NULL. 2338 */ 2339 CINDEX_LINKAGE unsigned clang_isInvalidDeclaration(CXCursor); 2340 2341 /** 2342 * Determine whether the given cursor kind represents a simple 2343 * reference. 2344 * 2345 * Note that other kinds of cursors (such as expressions) can also refer to 2346 * other cursors. Use clang_getCursorReferenced() to determine whether a 2347 * particular cursor refers to another entity. 2348 */ 2349 CINDEX_LINKAGE unsigned clang_isReference(enum CXCursorKind); 2350 2351 /** 2352 * Determine whether the given cursor kind represents an expression. 2353 */ 2354 CINDEX_LINKAGE unsigned clang_isExpression(enum CXCursorKind); 2355 2356 /** 2357 * Determine whether the given cursor kind represents a statement. 2358 */ 2359 CINDEX_LINKAGE unsigned clang_isStatement(enum CXCursorKind); 2360 2361 /** 2362 * Determine whether the given cursor kind represents an attribute. 2363 */ 2364 CINDEX_LINKAGE unsigned clang_isAttribute(enum CXCursorKind); 2365 2366 /** 2367 * Determine whether the given cursor has any attributes. 2368 */ 2369 CINDEX_LINKAGE unsigned clang_Cursor_hasAttrs(CXCursor C); 2370 2371 /** 2372 * Determine whether the given cursor kind represents an invalid 2373 * cursor. 2374 */ 2375 CINDEX_LINKAGE unsigned clang_isInvalid(enum CXCursorKind); 2376 2377 /** 2378 * Determine whether the given cursor kind represents a translation 2379 * unit. 2380 */ 2381 CINDEX_LINKAGE unsigned clang_isTranslationUnit(enum CXCursorKind); 2382 2383 /*** 2384 * Determine whether the given cursor represents a preprocessing 2385 * element, such as a preprocessor directive or macro instantiation. 2386 */ 2387 CINDEX_LINKAGE unsigned clang_isPreprocessing(enum CXCursorKind); 2388 2389 /*** 2390 * Determine whether the given cursor represents a currently 2391 * unexposed piece of the AST (e.g., CXCursor_UnexposedStmt). 2392 */ 2393 CINDEX_LINKAGE unsigned clang_isUnexposed(enum CXCursorKind); 2394 2395 /** 2396 * Describe the linkage of the entity referred to by a cursor. 2397 */ 2398 enum CXLinkageKind { 2399 /** This value indicates that no linkage information is available 2400 * for a provided CXCursor. */ 2401 CXLinkage_Invalid, 2402 /** 2403 * This is the linkage for variables, parameters, and so on that 2404 * have automatic storage. This covers normal (non-extern) local variables. 2405 */ 2406 CXLinkage_NoLinkage, 2407 /** This is the linkage for static variables and static functions. */ 2408 CXLinkage_Internal, 2409 /** This is the linkage for entities with external linkage that live 2410 * in C++ anonymous namespaces.*/ 2411 CXLinkage_UniqueExternal, 2412 /** This is the linkage for entities with true, external linkage. */ 2413 CXLinkage_External 2414 }; 2415 2416 /** 2417 * Determine the linkage of the entity referred to by a given cursor. 2418 */ 2419 CINDEX_LINKAGE enum CXLinkageKind clang_getCursorLinkage(CXCursor cursor); 2420 2421 enum CXVisibilityKind { 2422 /** This value indicates that no visibility information is available 2423 * for a provided CXCursor. */ 2424 CXVisibility_Invalid, 2425 2426 /** Symbol not seen by the linker. */ 2427 CXVisibility_Hidden, 2428 /** Symbol seen by the linker but resolves to a symbol inside this object. */ 2429 CXVisibility_Protected, 2430 /** Symbol seen by the linker and acts like a normal symbol. */ 2431 CXVisibility_Default 2432 }; 2433 2434 /** 2435 * Describe the visibility of the entity referred to by a cursor. 2436 * 2437 * This returns the default visibility if not explicitly specified by 2438 * a visibility attribute. The default visibility may be changed by 2439 * commandline arguments. 2440 * 2441 * \param cursor The cursor to query. 2442 * 2443 * \returns The visibility of the cursor. 2444 */ 2445 CINDEX_LINKAGE enum CXVisibilityKind clang_getCursorVisibility(CXCursor cursor); 2446 2447 /** 2448 * Determine the availability of the entity that this cursor refers to, 2449 * taking the current target platform into account. 2450 * 2451 * \param cursor The cursor to query. 2452 * 2453 * \returns The availability of the cursor. 2454 */ 2455 CINDEX_LINKAGE enum CXAvailabilityKind 2456 clang_getCursorAvailability(CXCursor cursor); 2457 2458 /** 2459 * Describes the availability of a given entity on a particular platform, e.g., 2460 * a particular class might only be available on Mac OS 10.7 or newer. 2461 */ 2462 typedef struct CXPlatformAvailability { 2463 /** 2464 * A string that describes the platform for which this structure 2465 * provides availability information. 2466 * 2467 * Possible values are "ios" or "macos". 2468 */ 2469 CXString Platform; 2470 /** 2471 * The version number in which this entity was introduced. 2472 */ 2473 CXVersion Introduced; 2474 /** 2475 * The version number in which this entity was deprecated (but is 2476 * still available). 2477 */ 2478 CXVersion Deprecated; 2479 /** 2480 * The version number in which this entity was obsoleted, and therefore 2481 * is no longer available. 2482 */ 2483 CXVersion Obsoleted; 2484 /** 2485 * Whether the entity is unconditionally unavailable on this platform. 2486 */ 2487 int Unavailable; 2488 /** 2489 * An optional message to provide to a user of this API, e.g., to 2490 * suggest replacement APIs. 2491 */ 2492 CXString Message; 2493 } CXPlatformAvailability; 2494 2495 /** 2496 * Determine the availability of the entity that this cursor refers to 2497 * on any platforms for which availability information is known. 2498 * 2499 * \param cursor The cursor to query. 2500 * 2501 * \param always_deprecated If non-NULL, will be set to indicate whether the 2502 * entity is deprecated on all platforms. 2503 * 2504 * \param deprecated_message If non-NULL, will be set to the message text 2505 * provided along with the unconditional deprecation of this entity. The client 2506 * is responsible for deallocating this string. 2507 * 2508 * \param always_unavailable If non-NULL, will be set to indicate whether the 2509 * entity is unavailable on all platforms. 2510 * 2511 * \param unavailable_message If non-NULL, will be set to the message text 2512 * provided along with the unconditional unavailability of this entity. The 2513 * client is responsible for deallocating this string. 2514 * 2515 * \param availability If non-NULL, an array of CXPlatformAvailability instances 2516 * that will be populated with platform availability information, up to either 2517 * the number of platforms for which availability information is available (as 2518 * returned by this function) or \c availability_size, whichever is smaller. 2519 * 2520 * \param availability_size The number of elements available in the 2521 * \c availability array. 2522 * 2523 * \returns The number of platforms (N) for which availability information is 2524 * available (which is unrelated to \c availability_size). 2525 * 2526 * Note that the client is responsible for calling 2527 * \c clang_disposeCXPlatformAvailability to free each of the 2528 * platform-availability structures returned. There are 2529 * \c min(N, availability_size) such structures. 2530 */ 2531 CINDEX_LINKAGE int clang_getCursorPlatformAvailability( 2532 CXCursor cursor, int *always_deprecated, CXString *deprecated_message, 2533 int *always_unavailable, CXString *unavailable_message, 2534 CXPlatformAvailability *availability, int availability_size); 2535 2536 /** 2537 * Free the memory associated with a \c CXPlatformAvailability structure. 2538 */ 2539 CINDEX_LINKAGE void 2540 clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability); 2541 2542 /** 2543 * If cursor refers to a variable declaration and it has initializer returns 2544 * cursor referring to the initializer otherwise return null cursor. 2545 */ 2546 CINDEX_LINKAGE CXCursor clang_Cursor_getVarDeclInitializer(CXCursor cursor); 2547 2548 /** 2549 * If cursor refers to a variable declaration that has global storage returns 1. 2550 * If cursor refers to a variable declaration that doesn't have global storage 2551 * returns 0. Otherwise returns -1. 2552 */ 2553 CINDEX_LINKAGE int clang_Cursor_hasVarDeclGlobalStorage(CXCursor cursor); 2554 2555 /** 2556 * If cursor refers to a variable declaration that has external storage 2557 * returns 1. If cursor refers to a variable declaration that doesn't have 2558 * external storage returns 0. Otherwise returns -1. 2559 */ 2560 CINDEX_LINKAGE int clang_Cursor_hasVarDeclExternalStorage(CXCursor cursor); 2561 2562 /** 2563 * Describe the "language" of the entity referred to by a cursor. 2564 */ 2565 enum CXLanguageKind { 2566 CXLanguage_Invalid = 0, 2567 CXLanguage_C, 2568 CXLanguage_ObjC, 2569 CXLanguage_CPlusPlus 2570 }; 2571 2572 /** 2573 * Determine the "language" of the entity referred to by a given cursor. 2574 */ 2575 CINDEX_LINKAGE enum CXLanguageKind clang_getCursorLanguage(CXCursor cursor); 2576 2577 /** 2578 * Describe the "thread-local storage (TLS) kind" of the declaration 2579 * referred to by a cursor. 2580 */ 2581 enum CXTLSKind { CXTLS_None = 0, CXTLS_Dynamic, CXTLS_Static }; 2582 2583 /** 2584 * Determine the "thread-local storage (TLS) kind" of the declaration 2585 * referred to by a cursor. 2586 */ 2587 CINDEX_LINKAGE enum CXTLSKind clang_getCursorTLSKind(CXCursor cursor); 2588 2589 /** 2590 * Returns the translation unit that a cursor originated from. 2591 */ 2592 CINDEX_LINKAGE CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor); 2593 2594 /** 2595 * A fast container representing a set of CXCursors. 2596 */ 2597 typedef struct CXCursorSetImpl *CXCursorSet; 2598 2599 /** 2600 * Creates an empty CXCursorSet. 2601 */ 2602 CINDEX_LINKAGE CXCursorSet clang_createCXCursorSet(void); 2603 2604 /** 2605 * Disposes a CXCursorSet and releases its associated memory. 2606 */ 2607 CINDEX_LINKAGE void clang_disposeCXCursorSet(CXCursorSet cset); 2608 2609 /** 2610 * Queries a CXCursorSet to see if it contains a specific CXCursor. 2611 * 2612 * \returns non-zero if the set contains the specified cursor. 2613 */ 2614 CINDEX_LINKAGE unsigned clang_CXCursorSet_contains(CXCursorSet cset, 2615 CXCursor cursor); 2616 2617 /** 2618 * Inserts a CXCursor into a CXCursorSet. 2619 * 2620 * \returns zero if the CXCursor was already in the set, and non-zero otherwise. 2621 */ 2622 CINDEX_LINKAGE unsigned clang_CXCursorSet_insert(CXCursorSet cset, 2623 CXCursor cursor); 2624 2625 /** 2626 * Determine the semantic parent of the given cursor. 2627 * 2628 * The semantic parent of a cursor is the cursor that semantically contains 2629 * the given \p cursor. For many declarations, the lexical and semantic parents 2630 * are equivalent (the lexical parent is returned by 2631 * \c clang_getCursorLexicalParent()). They diverge when declarations or 2632 * definitions are provided out-of-line. For example: 2633 * 2634 * \code 2635 * class C { 2636 * void f(); 2637 * }; 2638 * 2639 * void C::f() { } 2640 * \endcode 2641 * 2642 * In the out-of-line definition of \c C::f, the semantic parent is 2643 * the class \c C, of which this function is a member. The lexical parent is 2644 * the place where the declaration actually occurs in the source code; in this 2645 * case, the definition occurs in the translation unit. In general, the 2646 * lexical parent for a given entity can change without affecting the semantics 2647 * of the program, and the lexical parent of different declarations of the 2648 * same entity may be different. Changing the semantic parent of a declaration, 2649 * on the other hand, can have a major impact on semantics, and redeclarations 2650 * of a particular entity should all have the same semantic context. 2651 * 2652 * In the example above, both declarations of \c C::f have \c C as their 2653 * semantic context, while the lexical context of the first \c C::f is \c C 2654 * and the lexical context of the second \c C::f is the translation unit. 2655 * 2656 * For global declarations, the semantic parent is the translation unit. 2657 */ 2658 CINDEX_LINKAGE CXCursor clang_getCursorSemanticParent(CXCursor cursor); 2659 2660 /** 2661 * Determine the lexical parent of the given cursor. 2662 * 2663 * The lexical parent of a cursor is the cursor in which the given \p cursor 2664 * was actually written. For many declarations, the lexical and semantic parents 2665 * are equivalent (the semantic parent is returned by 2666 * \c clang_getCursorSemanticParent()). They diverge when declarations or 2667 * definitions are provided out-of-line. For example: 2668 * 2669 * \code 2670 * class C { 2671 * void f(); 2672 * }; 2673 * 2674 * void C::f() { } 2675 * \endcode 2676 * 2677 * In the out-of-line definition of \c C::f, the semantic parent is 2678 * the class \c C, of which this function is a member. The lexical parent is 2679 * the place where the declaration actually occurs in the source code; in this 2680 * case, the definition occurs in the translation unit. In general, the 2681 * lexical parent for a given entity can change without affecting the semantics 2682 * of the program, and the lexical parent of different declarations of the 2683 * same entity may be different. Changing the semantic parent of a declaration, 2684 * on the other hand, can have a major impact on semantics, and redeclarations 2685 * of a particular entity should all have the same semantic context. 2686 * 2687 * In the example above, both declarations of \c C::f have \c C as their 2688 * semantic context, while the lexical context of the first \c C::f is \c C 2689 * and the lexical context of the second \c C::f is the translation unit. 2690 * 2691 * For declarations written in the global scope, the lexical parent is 2692 * the translation unit. 2693 */ 2694 CINDEX_LINKAGE CXCursor clang_getCursorLexicalParent(CXCursor cursor); 2695 2696 /** 2697 * Determine the set of methods that are overridden by the given 2698 * method. 2699 * 2700 * In both Objective-C and C++, a method (aka virtual member function, 2701 * in C++) can override a virtual method in a base class. For 2702 * Objective-C, a method is said to override any method in the class's 2703 * base class, its protocols, or its categories' protocols, that has the same 2704 * selector and is of the same kind (class or instance). 2705 * If no such method exists, the search continues to the class's superclass, 2706 * its protocols, and its categories, and so on. A method from an Objective-C 2707 * implementation is considered to override the same methods as its 2708 * corresponding method in the interface. 2709 * 2710 * For C++, a virtual member function overrides any virtual member 2711 * function with the same signature that occurs in its base 2712 * classes. With multiple inheritance, a virtual member function can 2713 * override several virtual member functions coming from different 2714 * base classes. 2715 * 2716 * In all cases, this function determines the immediate overridden 2717 * method, rather than all of the overridden methods. For example, if 2718 * a method is originally declared in a class A, then overridden in B 2719 * (which in inherits from A) and also in C (which inherited from B), 2720 * then the only overridden method returned from this function when 2721 * invoked on C's method will be B's method. The client may then 2722 * invoke this function again, given the previously-found overridden 2723 * methods, to map out the complete method-override set. 2724 * 2725 * \param cursor A cursor representing an Objective-C or C++ 2726 * method. This routine will compute the set of methods that this 2727 * method overrides. 2728 * 2729 * \param overridden A pointer whose pointee will be replaced with a 2730 * pointer to an array of cursors, representing the set of overridden 2731 * methods. If there are no overridden methods, the pointee will be 2732 * set to NULL. The pointee must be freed via a call to 2733 * \c clang_disposeOverriddenCursors(). 2734 * 2735 * \param num_overridden A pointer to the number of overridden 2736 * functions, will be set to the number of overridden functions in the 2737 * array pointed to by \p overridden. 2738 */ 2739 CINDEX_LINKAGE void clang_getOverriddenCursors(CXCursor cursor, 2740 CXCursor **overridden, 2741 unsigned *num_overridden); 2742 2743 /** 2744 * Free the set of overridden cursors returned by \c 2745 * clang_getOverriddenCursors(). 2746 */ 2747 CINDEX_LINKAGE void clang_disposeOverriddenCursors(CXCursor *overridden); 2748 2749 /** 2750 * Retrieve the file that is included by the given inclusion directive 2751 * cursor. 2752 */ 2753 CINDEX_LINKAGE CXFile clang_getIncludedFile(CXCursor cursor); 2754 2755 /** 2756 * @} 2757 */ 2758 2759 /** 2760 * \defgroup CINDEX_CURSOR_SOURCE Mapping between cursors and source code 2761 * 2762 * Cursors represent a location within the Abstract Syntax Tree (AST). These 2763 * routines help map between cursors and the physical locations where the 2764 * described entities occur in the source code. The mapping is provided in 2765 * both directions, so one can map from source code to the AST and back. 2766 * 2767 * @{ 2768 */ 2769 2770 /** 2771 * Map a source location to the cursor that describes the entity at that 2772 * location in the source code. 2773 * 2774 * clang_getCursor() maps an arbitrary source location within a translation 2775 * unit down to the most specific cursor that describes the entity at that 2776 * location. For example, given an expression \c x + y, invoking 2777 * clang_getCursor() with a source location pointing to "x" will return the 2778 * cursor for "x"; similarly for "y". If the cursor points anywhere between 2779 * "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor() 2780 * will return a cursor referring to the "+" expression. 2781 * 2782 * \returns a cursor representing the entity at the given source location, or 2783 * a NULL cursor if no such entity can be found. 2784 */ 2785 CINDEX_LINKAGE CXCursor clang_getCursor(CXTranslationUnit, CXSourceLocation); 2786 2787 /** 2788 * Retrieve the physical location of the source constructor referenced 2789 * by the given cursor. 2790 * 2791 * The location of a declaration is typically the location of the name of that 2792 * declaration, where the name of that declaration would occur if it is 2793 * unnamed, or some keyword that introduces that particular declaration. 2794 * The location of a reference is where that reference occurs within the 2795 * source code. 2796 */ 2797 CINDEX_LINKAGE CXSourceLocation clang_getCursorLocation(CXCursor); 2798 2799 /** 2800 * Retrieve the physical extent of the source construct referenced by 2801 * the given cursor. 2802 * 2803 * The extent of a cursor starts with the file/line/column pointing at the 2804 * first character within the source construct that the cursor refers to and 2805 * ends with the last character within that source construct. For a 2806 * declaration, the extent covers the declaration itself. For a reference, 2807 * the extent covers the location of the reference (e.g., where the referenced 2808 * entity was actually used). 2809 */ 2810 CINDEX_LINKAGE CXSourceRange clang_getCursorExtent(CXCursor); 2811 2812 /** 2813 * @} 2814 */ 2815 2816 /** 2817 * \defgroup CINDEX_TYPES Type information for CXCursors 2818 * 2819 * @{ 2820 */ 2821 2822 /** 2823 * Describes the kind of type 2824 */ 2825 enum CXTypeKind { 2826 /** 2827 * Represents an invalid type (e.g., where no type is available). 2828 */ 2829 CXType_Invalid = 0, 2830 2831 /** 2832 * A type whose specific kind is not exposed via this 2833 * interface. 2834 */ 2835 CXType_Unexposed = 1, 2836 2837 /* Builtin types */ 2838 CXType_Void = 2, 2839 CXType_Bool = 3, 2840 CXType_Char_U = 4, 2841 CXType_UChar = 5, 2842 CXType_Char16 = 6, 2843 CXType_Char32 = 7, 2844 CXType_UShort = 8, 2845 CXType_UInt = 9, 2846 CXType_ULong = 10, 2847 CXType_ULongLong = 11, 2848 CXType_UInt128 = 12, 2849 CXType_Char_S = 13, 2850 CXType_SChar = 14, 2851 CXType_WChar = 15, 2852 CXType_Short = 16, 2853 CXType_Int = 17, 2854 CXType_Long = 18, 2855 CXType_LongLong = 19, 2856 CXType_Int128 = 20, 2857 CXType_Float = 21, 2858 CXType_Double = 22, 2859 CXType_LongDouble = 23, 2860 CXType_NullPtr = 24, 2861 CXType_Overload = 25, 2862 CXType_Dependent = 26, 2863 CXType_ObjCId = 27, 2864 CXType_ObjCClass = 28, 2865 CXType_ObjCSel = 29, 2866 CXType_Float128 = 30, 2867 CXType_Half = 31, 2868 CXType_Float16 = 32, 2869 CXType_ShortAccum = 33, 2870 CXType_Accum = 34, 2871 CXType_LongAccum = 35, 2872 CXType_UShortAccum = 36, 2873 CXType_UAccum = 37, 2874 CXType_ULongAccum = 38, 2875 CXType_BFloat16 = 39, 2876 CXType_Ibm128 = 40, 2877 CXType_FirstBuiltin = CXType_Void, 2878 CXType_LastBuiltin = CXType_Ibm128, 2879 2880 CXType_Complex = 100, 2881 CXType_Pointer = 101, 2882 CXType_BlockPointer = 102, 2883 CXType_LValueReference = 103, 2884 CXType_RValueReference = 104, 2885 CXType_Record = 105, 2886 CXType_Enum = 106, 2887 CXType_Typedef = 107, 2888 CXType_ObjCInterface = 108, 2889 CXType_ObjCObjectPointer = 109, 2890 CXType_FunctionNoProto = 110, 2891 CXType_FunctionProto = 111, 2892 CXType_ConstantArray = 112, 2893 CXType_Vector = 113, 2894 CXType_IncompleteArray = 114, 2895 CXType_VariableArray = 115, 2896 CXType_DependentSizedArray = 116, 2897 CXType_MemberPointer = 117, 2898 CXType_Auto = 118, 2899 2900 /** 2901 * Represents a type that was referred to using an elaborated type keyword. 2902 * 2903 * E.g., struct S, or via a qualified name, e.g., N::M::type, or both. 2904 */ 2905 CXType_Elaborated = 119, 2906 2907 /* OpenCL PipeType. */ 2908 CXType_Pipe = 120, 2909 2910 /* OpenCL builtin types. */ 2911 CXType_OCLImage1dRO = 121, 2912 CXType_OCLImage1dArrayRO = 122, 2913 CXType_OCLImage1dBufferRO = 123, 2914 CXType_OCLImage2dRO = 124, 2915 CXType_OCLImage2dArrayRO = 125, 2916 CXType_OCLImage2dDepthRO = 126, 2917 CXType_OCLImage2dArrayDepthRO = 127, 2918 CXType_OCLImage2dMSAARO = 128, 2919 CXType_OCLImage2dArrayMSAARO = 129, 2920 CXType_OCLImage2dMSAADepthRO = 130, 2921 CXType_OCLImage2dArrayMSAADepthRO = 131, 2922 CXType_OCLImage3dRO = 132, 2923 CXType_OCLImage1dWO = 133, 2924 CXType_OCLImage1dArrayWO = 134, 2925 CXType_OCLImage1dBufferWO = 135, 2926 CXType_OCLImage2dWO = 136, 2927 CXType_OCLImage2dArrayWO = 137, 2928 CXType_OCLImage2dDepthWO = 138, 2929 CXType_OCLImage2dArrayDepthWO = 139, 2930 CXType_OCLImage2dMSAAWO = 140, 2931 CXType_OCLImage2dArrayMSAAWO = 141, 2932 CXType_OCLImage2dMSAADepthWO = 142, 2933 CXType_OCLImage2dArrayMSAADepthWO = 143, 2934 CXType_OCLImage3dWO = 144, 2935 CXType_OCLImage1dRW = 145, 2936 CXType_OCLImage1dArrayRW = 146, 2937 CXType_OCLImage1dBufferRW = 147, 2938 CXType_OCLImage2dRW = 148, 2939 CXType_OCLImage2dArrayRW = 149, 2940 CXType_OCLImage2dDepthRW = 150, 2941 CXType_OCLImage2dArrayDepthRW = 151, 2942 CXType_OCLImage2dMSAARW = 152, 2943 CXType_OCLImage2dArrayMSAARW = 153, 2944 CXType_OCLImage2dMSAADepthRW = 154, 2945 CXType_OCLImage2dArrayMSAADepthRW = 155, 2946 CXType_OCLImage3dRW = 156, 2947 CXType_OCLSampler = 157, 2948 CXType_OCLEvent = 158, 2949 CXType_OCLQueue = 159, 2950 CXType_OCLReserveID = 160, 2951 2952 CXType_ObjCObject = 161, 2953 CXType_ObjCTypeParam = 162, 2954 CXType_Attributed = 163, 2955 2956 CXType_OCLIntelSubgroupAVCMcePayload = 164, 2957 CXType_OCLIntelSubgroupAVCImePayload = 165, 2958 CXType_OCLIntelSubgroupAVCRefPayload = 166, 2959 CXType_OCLIntelSubgroupAVCSicPayload = 167, 2960 CXType_OCLIntelSubgroupAVCMceResult = 168, 2961 CXType_OCLIntelSubgroupAVCImeResult = 169, 2962 CXType_OCLIntelSubgroupAVCRefResult = 170, 2963 CXType_OCLIntelSubgroupAVCSicResult = 171, 2964 CXType_OCLIntelSubgroupAVCImeResultSingleReferenceStreamout = 172, 2965 CXType_OCLIntelSubgroupAVCImeResultDualReferenceStreamout = 173, 2966 CXType_OCLIntelSubgroupAVCImeSingleReferenceStreamin = 174, 2967 CXType_OCLIntelSubgroupAVCImeDualReferenceStreamin = 175, 2968 2969 /* Old aliases for AVC OpenCL extension types. */ 2970 CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = 172, 2971 CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = 173, 2972 CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = 174, 2973 CXType_OCLIntelSubgroupAVCImeDualRefStreamin = 175, 2974 2975 CXType_ExtVector = 176, 2976 CXType_Atomic = 177, 2977 CXType_BTFTagAttributed = 178 2978 }; 2979 2980 /** 2981 * Describes the calling convention of a function type 2982 */ 2983 enum CXCallingConv { 2984 CXCallingConv_Default = 0, 2985 CXCallingConv_C = 1, 2986 CXCallingConv_X86StdCall = 2, 2987 CXCallingConv_X86FastCall = 3, 2988 CXCallingConv_X86ThisCall = 4, 2989 CXCallingConv_X86Pascal = 5, 2990 CXCallingConv_AAPCS = 6, 2991 CXCallingConv_AAPCS_VFP = 7, 2992 CXCallingConv_X86RegCall = 8, 2993 CXCallingConv_IntelOclBicc = 9, 2994 CXCallingConv_Win64 = 10, 2995 /* Alias for compatibility with older versions of API. */ 2996 CXCallingConv_X86_64Win64 = CXCallingConv_Win64, 2997 CXCallingConv_X86_64SysV = 11, 2998 CXCallingConv_X86VectorCall = 12, 2999 CXCallingConv_Swift = 13, 3000 CXCallingConv_PreserveMost = 14, 3001 CXCallingConv_PreserveAll = 15, 3002 CXCallingConv_AArch64VectorCall = 16, 3003 CXCallingConv_SwiftAsync = 17, 3004 CXCallingConv_AArch64SVEPCS = 18, 3005 CXCallingConv_M68kRTD = 19, 3006 CXCallingConv_PreserveNone = 20, 3007 CXCallingConv_RISCVVectorCall = 21, 3008 3009 CXCallingConv_Invalid = 100, 3010 CXCallingConv_Unexposed = 200 3011 }; 3012 3013 /** 3014 * The type of an element in the abstract syntax tree. 3015 * 3016 */ 3017 typedef struct { 3018 enum CXTypeKind kind; 3019 void *data[2]; 3020 } CXType; 3021 3022 /** 3023 * Retrieve the type of a CXCursor (if any). 3024 */ 3025 CINDEX_LINKAGE CXType clang_getCursorType(CXCursor C); 3026 3027 /** 3028 * Pretty-print the underlying type using the rules of the 3029 * language of the translation unit from which it came. 3030 * 3031 * If the type is invalid, an empty string is returned. 3032 */ 3033 CINDEX_LINKAGE CXString clang_getTypeSpelling(CXType CT); 3034 3035 /** 3036 * Retrieve the underlying type of a typedef declaration. 3037 * 3038 * If the cursor does not reference a typedef declaration, an invalid type is 3039 * returned. 3040 */ 3041 CINDEX_LINKAGE CXType clang_getTypedefDeclUnderlyingType(CXCursor C); 3042 3043 /** 3044 * Retrieve the integer type of an enum declaration. 3045 * 3046 * If the cursor does not reference an enum declaration, an invalid type is 3047 * returned. 3048 */ 3049 CINDEX_LINKAGE CXType clang_getEnumDeclIntegerType(CXCursor C); 3050 3051 /** 3052 * Retrieve the integer value of an enum constant declaration as a signed 3053 * long long. 3054 * 3055 * If the cursor does not reference an enum constant declaration, LLONG_MIN is 3056 * returned. Since this is also potentially a valid constant value, the kind of 3057 * the cursor must be verified before calling this function. 3058 */ 3059 CINDEX_LINKAGE long long clang_getEnumConstantDeclValue(CXCursor C); 3060 3061 /** 3062 * Retrieve the integer value of an enum constant declaration as an unsigned 3063 * long long. 3064 * 3065 * If the cursor does not reference an enum constant declaration, ULLONG_MAX is 3066 * returned. Since this is also potentially a valid constant value, the kind of 3067 * the cursor must be verified before calling this function. 3068 */ 3069 CINDEX_LINKAGE unsigned long long 3070 clang_getEnumConstantDeclUnsignedValue(CXCursor C); 3071 3072 /** 3073 * Returns non-zero if the cursor specifies a Record member that is a bit-field. 3074 */ 3075 CINDEX_LINKAGE unsigned clang_Cursor_isBitField(CXCursor C); 3076 3077 /** 3078 * Retrieve the bit width of a bit-field declaration as an integer. 3079 * 3080 * If the cursor does not reference a bit-field, or if the bit-field's width 3081 * expression cannot be evaluated, -1 is returned. 3082 * 3083 * For example: 3084 * \code 3085 * if (clang_Cursor_isBitField(Cursor)) { 3086 * int Width = clang_getFieldDeclBitWidth(Cursor); 3087 * if (Width != -1) { 3088 * // The bit-field width is not value-dependent. 3089 * } 3090 * } 3091 * \endcode 3092 */ 3093 CINDEX_LINKAGE int clang_getFieldDeclBitWidth(CXCursor C); 3094 3095 /** 3096 * Retrieve the number of non-variadic arguments associated with a given 3097 * cursor. 3098 * 3099 * The number of arguments can be determined for calls as well as for 3100 * declarations of functions or methods. For other cursors -1 is returned. 3101 */ 3102 CINDEX_LINKAGE int clang_Cursor_getNumArguments(CXCursor C); 3103 3104 /** 3105 * Retrieve the argument cursor of a function or method. 3106 * 3107 * The argument cursor can be determined for calls as well as for declarations 3108 * of functions or methods. For other cursors and for invalid indices, an 3109 * invalid cursor is returned. 3110 */ 3111 CINDEX_LINKAGE CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i); 3112 3113 /** 3114 * Describes the kind of a template argument. 3115 * 3116 * See the definition of llvm::clang::TemplateArgument::ArgKind for full 3117 * element descriptions. 3118 */ 3119 enum CXTemplateArgumentKind { 3120 CXTemplateArgumentKind_Null, 3121 CXTemplateArgumentKind_Type, 3122 CXTemplateArgumentKind_Declaration, 3123 CXTemplateArgumentKind_NullPtr, 3124 CXTemplateArgumentKind_Integral, 3125 CXTemplateArgumentKind_Template, 3126 CXTemplateArgumentKind_TemplateExpansion, 3127 CXTemplateArgumentKind_Expression, 3128 CXTemplateArgumentKind_Pack, 3129 /* Indicates an error case, preventing the kind from being deduced. */ 3130 CXTemplateArgumentKind_Invalid 3131 }; 3132 3133 /** 3134 * Returns the number of template args of a function, struct, or class decl 3135 * representing a template specialization. 3136 * 3137 * If the argument cursor cannot be converted into a template function 3138 * declaration, -1 is returned. 3139 * 3140 * For example, for the following declaration and specialization: 3141 * template <typename T, int kInt, bool kBool> 3142 * void foo() { ... } 3143 * 3144 * template <> 3145 * void foo<float, -7, true>(); 3146 * 3147 * The value 3 would be returned from this call. 3148 */ 3149 CINDEX_LINKAGE int clang_Cursor_getNumTemplateArguments(CXCursor C); 3150 3151 /** 3152 * Retrieve the kind of the I'th template argument of the CXCursor C. 3153 * 3154 * If the argument CXCursor does not represent a FunctionDecl, StructDecl, or 3155 * ClassTemplatePartialSpecialization, an invalid template argument kind is 3156 * returned. 3157 * 3158 * For example, for the following declaration and specialization: 3159 * template <typename T, int kInt, bool kBool> 3160 * void foo() { ... } 3161 * 3162 * template <> 3163 * void foo<float, -7, true>(); 3164 * 3165 * For I = 0, 1, and 2, Type, Integral, and Integral will be returned, 3166 * respectively. 3167 */ 3168 CINDEX_LINKAGE enum CXTemplateArgumentKind 3169 clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I); 3170 3171 /** 3172 * Retrieve a CXType representing the type of a TemplateArgument of a 3173 * function decl representing a template specialization. 3174 * 3175 * If the argument CXCursor does not represent a FunctionDecl, StructDecl, 3176 * ClassDecl or ClassTemplatePartialSpecialization whose I'th template argument 3177 * has a kind of CXTemplateArgKind_Integral, an invalid type is returned. 3178 * 3179 * For example, for the following declaration and specialization: 3180 * template <typename T, int kInt, bool kBool> 3181 * void foo() { ... } 3182 * 3183 * template <> 3184 * void foo<float, -7, true>(); 3185 * 3186 * If called with I = 0, "float", will be returned. 3187 * Invalid types will be returned for I == 1 or 2. 3188 */ 3189 CINDEX_LINKAGE CXType clang_Cursor_getTemplateArgumentType(CXCursor C, 3190 unsigned I); 3191 3192 /** 3193 * Retrieve the value of an Integral TemplateArgument (of a function 3194 * decl representing a template specialization) as a signed long long. 3195 * 3196 * It is undefined to call this function on a CXCursor that does not represent a 3197 * FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization 3198 * whose I'th template argument is not an integral value. 3199 * 3200 * For example, for the following declaration and specialization: 3201 * template <typename T, int kInt, bool kBool> 3202 * void foo() { ... } 3203 * 3204 * template <> 3205 * void foo<float, -7, true>(); 3206 * 3207 * If called with I = 1 or 2, -7 or true will be returned, respectively. 3208 * For I == 0, this function's behavior is undefined. 3209 */ 3210 CINDEX_LINKAGE long long clang_Cursor_getTemplateArgumentValue(CXCursor C, 3211 unsigned I); 3212 3213 /** 3214 * Retrieve the value of an Integral TemplateArgument (of a function 3215 * decl representing a template specialization) as an unsigned long long. 3216 * 3217 * It is undefined to call this function on a CXCursor that does not represent a 3218 * FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization or 3219 * whose I'th template argument is not an integral value. 3220 * 3221 * For example, for the following declaration and specialization: 3222 * template <typename T, int kInt, bool kBool> 3223 * void foo() { ... } 3224 * 3225 * template <> 3226 * void foo<float, 2147483649, true>(); 3227 * 3228 * If called with I = 1 or 2, 2147483649 or true will be returned, respectively. 3229 * For I == 0, this function's behavior is undefined. 3230 */ 3231 CINDEX_LINKAGE unsigned long long 3232 clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, unsigned I); 3233 3234 /** 3235 * Determine whether two CXTypes represent the same type. 3236 * 3237 * \returns non-zero if the CXTypes represent the same type and 3238 * zero otherwise. 3239 */ 3240 CINDEX_LINKAGE unsigned clang_equalTypes(CXType A, CXType B); 3241 3242 /** 3243 * Return the canonical type for a CXType. 3244 * 3245 * Clang's type system explicitly models typedefs and all the ways 3246 * a specific type can be represented. The canonical type is the underlying 3247 * type with all the "sugar" removed. For example, if 'T' is a typedef 3248 * for 'int', the canonical type for 'T' would be 'int'. 3249 */ 3250 CINDEX_LINKAGE CXType clang_getCanonicalType(CXType T); 3251 3252 /** 3253 * Determine whether a CXType has the "const" qualifier set, 3254 * without looking through typedefs that may have added "const" at a 3255 * different level. 3256 */ 3257 CINDEX_LINKAGE unsigned clang_isConstQualifiedType(CXType T); 3258 3259 /** 3260 * Determine whether a CXCursor that is a macro, is 3261 * function like. 3262 */ 3263 CINDEX_LINKAGE unsigned clang_Cursor_isMacroFunctionLike(CXCursor C); 3264 3265 /** 3266 * Determine whether a CXCursor that is a macro, is a 3267 * builtin one. 3268 */ 3269 CINDEX_LINKAGE unsigned clang_Cursor_isMacroBuiltin(CXCursor C); 3270 3271 /** 3272 * Determine whether a CXCursor that is a function declaration, is an 3273 * inline declaration. 3274 */ 3275 CINDEX_LINKAGE unsigned clang_Cursor_isFunctionInlined(CXCursor C); 3276 3277 /** 3278 * Determine whether a CXType has the "volatile" qualifier set, 3279 * without looking through typedefs that may have added "volatile" at 3280 * a different level. 3281 */ 3282 CINDEX_LINKAGE unsigned clang_isVolatileQualifiedType(CXType T); 3283 3284 /** 3285 * Determine whether a CXType has the "restrict" qualifier set, 3286 * without looking through typedefs that may have added "restrict" at a 3287 * different level. 3288 */ 3289 CINDEX_LINKAGE unsigned clang_isRestrictQualifiedType(CXType T); 3290 3291 /** 3292 * Returns the address space of the given type. 3293 */ 3294 CINDEX_LINKAGE unsigned clang_getAddressSpace(CXType T); 3295 3296 /** 3297 * Returns the typedef name of the given type. 3298 */ 3299 CINDEX_LINKAGE CXString clang_getTypedefName(CXType CT); 3300 3301 /** 3302 * For pointer types, returns the type of the pointee. 3303 */ 3304 CINDEX_LINKAGE CXType clang_getPointeeType(CXType T); 3305 3306 /** 3307 * Retrieve the unqualified variant of the given type, removing as 3308 * little sugar as possible. 3309 * 3310 * For example, given the following series of typedefs: 3311 * 3312 * \code 3313 * typedef int Integer; 3314 * typedef const Integer CInteger; 3315 * typedef CInteger DifferenceType; 3316 * \endcode 3317 * 3318 * Executing \c clang_getUnqualifiedType() on a \c CXType that 3319 * represents \c DifferenceType, will desugar to a type representing 3320 * \c Integer, that has no qualifiers. 3321 * 3322 * And, executing \c clang_getUnqualifiedType() on the type of the 3323 * first argument of the following function declaration: 3324 * 3325 * \code 3326 * void foo(const int); 3327 * \endcode 3328 * 3329 * Will return a type representing \c int, removing the \c const 3330 * qualifier. 3331 * 3332 * Sugar over array types is not desugared. 3333 * 3334 * A type can be checked for qualifiers with \c 3335 * clang_isConstQualifiedType(), \c clang_isVolatileQualifiedType() 3336 * and \c clang_isRestrictQualifiedType(). 3337 * 3338 * A type that resulted from a call to \c clang_getUnqualifiedType 3339 * will return \c false for all of the above calls. 3340 */ 3341 CINDEX_LINKAGE CXType clang_getUnqualifiedType(CXType CT); 3342 3343 /** 3344 * For reference types (e.g., "const int&"), returns the type that the 3345 * reference refers to (e.g "const int"). 3346 * 3347 * Otherwise, returns the type itself. 3348 * 3349 * A type that has kind \c CXType_LValueReference or 3350 * \c CXType_RValueReference is a reference type. 3351 */ 3352 CINDEX_LINKAGE CXType clang_getNonReferenceType(CXType CT); 3353 3354 /** 3355 * Return the cursor for the declaration of the given type. 3356 */ 3357 CINDEX_LINKAGE CXCursor clang_getTypeDeclaration(CXType T); 3358 3359 /** 3360 * Returns the Objective-C type encoding for the specified declaration. 3361 */ 3362 CINDEX_LINKAGE CXString clang_getDeclObjCTypeEncoding(CXCursor C); 3363 3364 /** 3365 * Returns the Objective-C type encoding for the specified CXType. 3366 */ 3367 CINDEX_LINKAGE CXString clang_Type_getObjCEncoding(CXType type); 3368 3369 /** 3370 * Retrieve the spelling of a given CXTypeKind. 3371 */ 3372 CINDEX_LINKAGE CXString clang_getTypeKindSpelling(enum CXTypeKind K); 3373 3374 /** 3375 * Retrieve the calling convention associated with a function type. 3376 * 3377 * If a non-function type is passed in, CXCallingConv_Invalid is returned. 3378 */ 3379 CINDEX_LINKAGE enum CXCallingConv clang_getFunctionTypeCallingConv(CXType T); 3380 3381 /** 3382 * Retrieve the return type associated with a function type. 3383 * 3384 * If a non-function type is passed in, an invalid type is returned. 3385 */ 3386 CINDEX_LINKAGE CXType clang_getResultType(CXType T); 3387 3388 /** 3389 * Retrieve the exception specification type associated with a function type. 3390 * This is a value of type CXCursor_ExceptionSpecificationKind. 3391 * 3392 * If a non-function type is passed in, an error code of -1 is returned. 3393 */ 3394 CINDEX_LINKAGE int clang_getExceptionSpecificationType(CXType T); 3395 3396 /** 3397 * Retrieve the number of non-variadic parameters associated with a 3398 * function type. 3399 * 3400 * If a non-function type is passed in, -1 is returned. 3401 */ 3402 CINDEX_LINKAGE int clang_getNumArgTypes(CXType T); 3403 3404 /** 3405 * Retrieve the type of a parameter of a function type. 3406 * 3407 * If a non-function type is passed in or the function does not have enough 3408 * parameters, an invalid type is returned. 3409 */ 3410 CINDEX_LINKAGE CXType clang_getArgType(CXType T, unsigned i); 3411 3412 /** 3413 * Retrieves the base type of the ObjCObjectType. 3414 * 3415 * If the type is not an ObjC object, an invalid type is returned. 3416 */ 3417 CINDEX_LINKAGE CXType clang_Type_getObjCObjectBaseType(CXType T); 3418 3419 /** 3420 * Retrieve the number of protocol references associated with an ObjC object/id. 3421 * 3422 * If the type is not an ObjC object, 0 is returned. 3423 */ 3424 CINDEX_LINKAGE unsigned clang_Type_getNumObjCProtocolRefs(CXType T); 3425 3426 /** 3427 * Retrieve the decl for a protocol reference for an ObjC object/id. 3428 * 3429 * If the type is not an ObjC object or there are not enough protocol 3430 * references, an invalid cursor is returned. 3431 */ 3432 CINDEX_LINKAGE CXCursor clang_Type_getObjCProtocolDecl(CXType T, unsigned i); 3433 3434 /** 3435 * Retrieve the number of type arguments associated with an ObjC object. 3436 * 3437 * If the type is not an ObjC object, 0 is returned. 3438 */ 3439 CINDEX_LINKAGE unsigned clang_Type_getNumObjCTypeArgs(CXType T); 3440 3441 /** 3442 * Retrieve a type argument associated with an ObjC object. 3443 * 3444 * If the type is not an ObjC or the index is not valid, 3445 * an invalid type is returned. 3446 */ 3447 CINDEX_LINKAGE CXType clang_Type_getObjCTypeArg(CXType T, unsigned i); 3448 3449 /** 3450 * Return 1 if the CXType is a variadic function type, and 0 otherwise. 3451 */ 3452 CINDEX_LINKAGE unsigned clang_isFunctionTypeVariadic(CXType T); 3453 3454 /** 3455 * Retrieve the return type associated with a given cursor. 3456 * 3457 * This only returns a valid type if the cursor refers to a function or method. 3458 */ 3459 CINDEX_LINKAGE CXType clang_getCursorResultType(CXCursor C); 3460 3461 /** 3462 * Retrieve the exception specification type associated with a given cursor. 3463 * This is a value of type CXCursor_ExceptionSpecificationKind. 3464 * 3465 * This only returns a valid result if the cursor refers to a function or 3466 * method. 3467 */ 3468 CINDEX_LINKAGE int clang_getCursorExceptionSpecificationType(CXCursor C); 3469 3470 /** 3471 * Return 1 if the CXType is a POD (plain old data) type, and 0 3472 * otherwise. 3473 */ 3474 CINDEX_LINKAGE unsigned clang_isPODType(CXType T); 3475 3476 /** 3477 * Return the element type of an array, complex, or vector type. 3478 * 3479 * If a type is passed in that is not an array, complex, or vector type, 3480 * an invalid type is returned. 3481 */ 3482 CINDEX_LINKAGE CXType clang_getElementType(CXType T); 3483 3484 /** 3485 * Return the number of elements of an array or vector type. 3486 * 3487 * If a type is passed in that is not an array or vector type, 3488 * -1 is returned. 3489 */ 3490 CINDEX_LINKAGE long long clang_getNumElements(CXType T); 3491 3492 /** 3493 * Return the element type of an array type. 3494 * 3495 * If a non-array type is passed in, an invalid type is returned. 3496 */ 3497 CINDEX_LINKAGE CXType clang_getArrayElementType(CXType T); 3498 3499 /** 3500 * Return the array size of a constant array. 3501 * 3502 * If a non-array type is passed in, -1 is returned. 3503 */ 3504 CINDEX_LINKAGE long long clang_getArraySize(CXType T); 3505 3506 /** 3507 * Retrieve the type named by the qualified-id. 3508 * 3509 * If a non-elaborated type is passed in, an invalid type is returned. 3510 */ 3511 CINDEX_LINKAGE CXType clang_Type_getNamedType(CXType T); 3512 3513 /** 3514 * Determine if a typedef is 'transparent' tag. 3515 * 3516 * A typedef is considered 'transparent' if it shares a name and spelling 3517 * location with its underlying tag type, as is the case with the NS_ENUM macro. 3518 * 3519 * \returns non-zero if transparent and zero otherwise. 3520 */ 3521 CINDEX_LINKAGE unsigned clang_Type_isTransparentTagTypedef(CXType T); 3522 3523 enum CXTypeNullabilityKind { 3524 /** 3525 * Values of this type can never be null. 3526 */ 3527 CXTypeNullability_NonNull = 0, 3528 /** 3529 * Values of this type can be null. 3530 */ 3531 CXTypeNullability_Nullable = 1, 3532 /** 3533 * Whether values of this type can be null is (explicitly) 3534 * unspecified. This captures a (fairly rare) case where we 3535 * can't conclude anything about the nullability of the type even 3536 * though it has been considered. 3537 */ 3538 CXTypeNullability_Unspecified = 2, 3539 /** 3540 * Nullability is not applicable to this type. 3541 */ 3542 CXTypeNullability_Invalid = 3, 3543 3544 /** 3545 * Generally behaves like Nullable, except when used in a block parameter that 3546 * was imported into a swift async method. There, swift will assume that the 3547 * parameter can get null even if no error occurred. _Nullable parameters are 3548 * assumed to only get null on error. 3549 */ 3550 CXTypeNullability_NullableResult = 4 3551 }; 3552 3553 /** 3554 * Retrieve the nullability kind of a pointer type. 3555 */ 3556 CINDEX_LINKAGE enum CXTypeNullabilityKind clang_Type_getNullability(CXType T); 3557 3558 /** 3559 * List the possible error codes for \c clang_Type_getSizeOf, 3560 * \c clang_Type_getAlignOf, \c clang_Type_getOffsetOf and 3561 * \c clang_Cursor_getOffsetOf. 3562 * 3563 * A value of this enumeration type can be returned if the target type is not 3564 * a valid argument to sizeof, alignof or offsetof. 3565 */ 3566 enum CXTypeLayoutError { 3567 /** 3568 * Type is of kind CXType_Invalid. 3569 */ 3570 CXTypeLayoutError_Invalid = -1, 3571 /** 3572 * The type is an incomplete Type. 3573 */ 3574 CXTypeLayoutError_Incomplete = -2, 3575 /** 3576 * The type is a dependent Type. 3577 */ 3578 CXTypeLayoutError_Dependent = -3, 3579 /** 3580 * The type is not a constant size type. 3581 */ 3582 CXTypeLayoutError_NotConstantSize = -4, 3583 /** 3584 * The Field name is not valid for this record. 3585 */ 3586 CXTypeLayoutError_InvalidFieldName = -5, 3587 /** 3588 * The type is undeduced. 3589 */ 3590 CXTypeLayoutError_Undeduced = -6 3591 }; 3592 3593 /** 3594 * Return the alignment of a type in bytes as per C++[expr.alignof] 3595 * standard. 3596 * 3597 * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. 3598 * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete 3599 * is returned. 3600 * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is 3601 * returned. 3602 * If the type declaration is not a constant size type, 3603 * CXTypeLayoutError_NotConstantSize is returned. 3604 */ 3605 CINDEX_LINKAGE long long clang_Type_getAlignOf(CXType T); 3606 3607 /** 3608 * Return the class type of an member pointer type. 3609 * 3610 * If a non-member-pointer type is passed in, an invalid type is returned. 3611 */ 3612 CINDEX_LINKAGE CXType clang_Type_getClassType(CXType T); 3613 3614 /** 3615 * Return the size of a type in bytes as per C++[expr.sizeof] standard. 3616 * 3617 * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned. 3618 * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete 3619 * is returned. 3620 * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is 3621 * returned. 3622 */ 3623 CINDEX_LINKAGE long long clang_Type_getSizeOf(CXType T); 3624 3625 /** 3626 * Return the offset of a field named S in a record of type T in bits 3627 * as it would be returned by __offsetof__ as per C++11[18.2p4] 3628 * 3629 * If the cursor is not a record field declaration, CXTypeLayoutError_Invalid 3630 * is returned. 3631 * If the field's type declaration is an incomplete type, 3632 * CXTypeLayoutError_Incomplete is returned. 3633 * If the field's type declaration is a dependent type, 3634 * CXTypeLayoutError_Dependent is returned. 3635 * If the field's name S is not found, 3636 * CXTypeLayoutError_InvalidFieldName is returned. 3637 */ 3638 CINDEX_LINKAGE long long clang_Type_getOffsetOf(CXType T, const char *S); 3639 3640 /** 3641 * Return the type that was modified by this attributed type. 3642 * 3643 * If the type is not an attributed type, an invalid type is returned. 3644 */ 3645 CINDEX_LINKAGE CXType clang_Type_getModifiedType(CXType T); 3646 3647 /** 3648 * Gets the type contained by this atomic type. 3649 * 3650 * If a non-atomic type is passed in, an invalid type is returned. 3651 */ 3652 CINDEX_LINKAGE CXType clang_Type_getValueType(CXType CT); 3653 3654 /** 3655 * Return the offset of the field represented by the Cursor. 3656 * 3657 * If the cursor is not a field declaration, -1 is returned. 3658 * If the cursor semantic parent is not a record field declaration, 3659 * CXTypeLayoutError_Invalid is returned. 3660 * If the field's type declaration is an incomplete type, 3661 * CXTypeLayoutError_Incomplete is returned. 3662 * If the field's type declaration is a dependent type, 3663 * CXTypeLayoutError_Dependent is returned. 3664 * If the field's name S is not found, 3665 * CXTypeLayoutError_InvalidFieldName is returned. 3666 */ 3667 CINDEX_LINKAGE long long clang_Cursor_getOffsetOfField(CXCursor C); 3668 3669 /** 3670 * Determine whether the given cursor represents an anonymous 3671 * tag or namespace 3672 */ 3673 CINDEX_LINKAGE unsigned clang_Cursor_isAnonymous(CXCursor C); 3674 3675 /** 3676 * Determine whether the given cursor represents an anonymous record 3677 * declaration. 3678 */ 3679 CINDEX_LINKAGE unsigned clang_Cursor_isAnonymousRecordDecl(CXCursor C); 3680 3681 /** 3682 * Determine whether the given cursor represents an inline namespace 3683 * declaration. 3684 */ 3685 CINDEX_LINKAGE unsigned clang_Cursor_isInlineNamespace(CXCursor C); 3686 3687 enum CXRefQualifierKind { 3688 /** No ref-qualifier was provided. */ 3689 CXRefQualifier_None = 0, 3690 /** An lvalue ref-qualifier was provided (\c &). */ 3691 CXRefQualifier_LValue, 3692 /** An rvalue ref-qualifier was provided (\c &&). */ 3693 CXRefQualifier_RValue 3694 }; 3695 3696 /** 3697 * Returns the number of template arguments for given template 3698 * specialization, or -1 if type \c T is not a template specialization. 3699 */ 3700 CINDEX_LINKAGE int clang_Type_getNumTemplateArguments(CXType T); 3701 3702 /** 3703 * Returns the type template argument of a template class specialization 3704 * at given index. 3705 * 3706 * This function only returns template type arguments and does not handle 3707 * template template arguments or variadic packs. 3708 */ 3709 CINDEX_LINKAGE CXType clang_Type_getTemplateArgumentAsType(CXType T, 3710 unsigned i); 3711 3712 /** 3713 * Retrieve the ref-qualifier kind of a function or method. 3714 * 3715 * The ref-qualifier is returned for C++ functions or methods. For other types 3716 * or non-C++ declarations, CXRefQualifier_None is returned. 3717 */ 3718 CINDEX_LINKAGE enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T); 3719 3720 /** 3721 * Returns 1 if the base class specified by the cursor with kind 3722 * CX_CXXBaseSpecifier is virtual. 3723 */ 3724 CINDEX_LINKAGE unsigned clang_isVirtualBase(CXCursor); 3725 3726 /** 3727 * Represents the C++ access control level to a base class for a 3728 * cursor with kind CX_CXXBaseSpecifier. 3729 */ 3730 enum CX_CXXAccessSpecifier { 3731 CX_CXXInvalidAccessSpecifier, 3732 CX_CXXPublic, 3733 CX_CXXProtected, 3734 CX_CXXPrivate 3735 }; 3736 3737 /** 3738 * Returns the access control level for the referenced object. 3739 * 3740 * If the cursor refers to a C++ declaration, its access control level within 3741 * its parent scope is returned. Otherwise, if the cursor refers to a base 3742 * specifier or access specifier, the specifier itself is returned. 3743 */ 3744 CINDEX_LINKAGE enum CX_CXXAccessSpecifier clang_getCXXAccessSpecifier(CXCursor); 3745 3746 /** 3747 * Represents the storage classes as declared in the source. CX_SC_Invalid 3748 * was added for the case that the passed cursor in not a declaration. 3749 */ 3750 enum CX_StorageClass { 3751 CX_SC_Invalid, 3752 CX_SC_None, 3753 CX_SC_Extern, 3754 CX_SC_Static, 3755 CX_SC_PrivateExtern, 3756 CX_SC_OpenCLWorkGroupLocal, 3757 CX_SC_Auto, 3758 CX_SC_Register 3759 }; 3760 3761 /** 3762 * Represents a specific kind of binary operator which can appear at a cursor. 3763 */ 3764 enum CX_BinaryOperatorKind { 3765 CX_BO_Invalid = 0, 3766 CX_BO_PtrMemD = 1, 3767 CX_BO_PtrMemI = 2, 3768 CX_BO_Mul = 3, 3769 CX_BO_Div = 4, 3770 CX_BO_Rem = 5, 3771 CX_BO_Add = 6, 3772 CX_BO_Sub = 7, 3773 CX_BO_Shl = 8, 3774 CX_BO_Shr = 9, 3775 CX_BO_Cmp = 10, 3776 CX_BO_LT = 11, 3777 CX_BO_GT = 12, 3778 CX_BO_LE = 13, 3779 CX_BO_GE = 14, 3780 CX_BO_EQ = 15, 3781 CX_BO_NE = 16, 3782 CX_BO_And = 17, 3783 CX_BO_Xor = 18, 3784 CX_BO_Or = 19, 3785 CX_BO_LAnd = 20, 3786 CX_BO_LOr = 21, 3787 CX_BO_Assign = 22, 3788 CX_BO_MulAssign = 23, 3789 CX_BO_DivAssign = 24, 3790 CX_BO_RemAssign = 25, 3791 CX_BO_AddAssign = 26, 3792 CX_BO_SubAssign = 27, 3793 CX_BO_ShlAssign = 28, 3794 CX_BO_ShrAssign = 29, 3795 CX_BO_AndAssign = 30, 3796 CX_BO_XorAssign = 31, 3797 CX_BO_OrAssign = 32, 3798 CX_BO_Comma = 33, 3799 CX_BO_LAST = CX_BO_Comma 3800 }; 3801 3802 /** 3803 * \brief Returns the operator code for the binary operator. 3804 */ 3805 CINDEX_LINKAGE enum CX_BinaryOperatorKind 3806 clang_Cursor_getBinaryOpcode(CXCursor C); 3807 3808 /** 3809 * \brief Returns a string containing the spelling of the binary operator. 3810 */ 3811 CINDEX_LINKAGE CXString 3812 clang_Cursor_getBinaryOpcodeStr(enum CX_BinaryOperatorKind Op); 3813 3814 /** 3815 * Returns the storage class for a function or variable declaration. 3816 * 3817 * If the passed in Cursor is not a function or variable declaration, 3818 * CX_SC_Invalid is returned else the storage class. 3819 */ 3820 CINDEX_LINKAGE enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor); 3821 3822 /** 3823 * Determine the number of overloaded declarations referenced by a 3824 * \c CXCursor_OverloadedDeclRef cursor. 3825 * 3826 * \param cursor The cursor whose overloaded declarations are being queried. 3827 * 3828 * \returns The number of overloaded declarations referenced by \c cursor. If it 3829 * is not a \c CXCursor_OverloadedDeclRef cursor, returns 0. 3830 */ 3831 CINDEX_LINKAGE unsigned clang_getNumOverloadedDecls(CXCursor cursor); 3832 3833 /** 3834 * Retrieve a cursor for one of the overloaded declarations referenced 3835 * by a \c CXCursor_OverloadedDeclRef cursor. 3836 * 3837 * \param cursor The cursor whose overloaded declarations are being queried. 3838 * 3839 * \param index The zero-based index into the set of overloaded declarations in 3840 * the cursor. 3841 * 3842 * \returns A cursor representing the declaration referenced by the given 3843 * \c cursor at the specified \c index. If the cursor does not have an 3844 * associated set of overloaded declarations, or if the index is out of bounds, 3845 * returns \c clang_getNullCursor(); 3846 */ 3847 CINDEX_LINKAGE CXCursor clang_getOverloadedDecl(CXCursor cursor, 3848 unsigned index); 3849 3850 /** 3851 * @} 3852 */ 3853 3854 /** 3855 * \defgroup CINDEX_ATTRIBUTES Information for attributes 3856 * 3857 * @{ 3858 */ 3859 3860 /** 3861 * For cursors representing an iboutletcollection attribute, 3862 * this function returns the collection element type. 3863 * 3864 */ 3865 CINDEX_LINKAGE CXType clang_getIBOutletCollectionType(CXCursor); 3866 3867 /** 3868 * @} 3869 */ 3870 3871 /** 3872 * \defgroup CINDEX_CURSOR_TRAVERSAL Traversing the AST with cursors 3873 * 3874 * These routines provide the ability to traverse the abstract syntax tree 3875 * using cursors. 3876 * 3877 * @{ 3878 */ 3879 3880 /** 3881 * Describes how the traversal of the children of a particular 3882 * cursor should proceed after visiting a particular child cursor. 3883 * 3884 * A value of this enumeration type should be returned by each 3885 * \c CXCursorVisitor to indicate how clang_visitChildren() proceed. 3886 */ 3887 enum CXChildVisitResult { 3888 /** 3889 * Terminates the cursor traversal. 3890 */ 3891 CXChildVisit_Break, 3892 /** 3893 * Continues the cursor traversal with the next sibling of 3894 * the cursor just visited, without visiting its children. 3895 */ 3896 CXChildVisit_Continue, 3897 /** 3898 * Recursively traverse the children of this cursor, using 3899 * the same visitor and client data. 3900 */ 3901 CXChildVisit_Recurse 3902 }; 3903 3904 /** 3905 * Visitor invoked for each cursor found by a traversal. 3906 * 3907 * This visitor function will be invoked for each cursor found by 3908 * clang_visitCursorChildren(). Its first argument is the cursor being 3909 * visited, its second argument is the parent visitor for that cursor, 3910 * and its third argument is the client data provided to 3911 * clang_visitCursorChildren(). 3912 * 3913 * The visitor should return one of the \c CXChildVisitResult values 3914 * to direct clang_visitCursorChildren(). 3915 */ 3916 typedef enum CXChildVisitResult (*CXCursorVisitor)(CXCursor cursor, 3917 CXCursor parent, 3918 CXClientData client_data); 3919 3920 /** 3921 * Visit the children of a particular cursor. 3922 * 3923 * This function visits all the direct children of the given cursor, 3924 * invoking the given \p visitor function with the cursors of each 3925 * visited child. The traversal may be recursive, if the visitor returns 3926 * \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if 3927 * the visitor returns \c CXChildVisit_Break. 3928 * 3929 * \param parent the cursor whose child may be visited. All kinds of 3930 * cursors can be visited, including invalid cursors (which, by 3931 * definition, have no children). 3932 * 3933 * \param visitor the visitor function that will be invoked for each 3934 * child of \p parent. 3935 * 3936 * \param client_data pointer data supplied by the client, which will 3937 * be passed to the visitor each time it is invoked. 3938 * 3939 * \returns a non-zero value if the traversal was terminated 3940 * prematurely by the visitor returning \c CXChildVisit_Break. 3941 */ 3942 CINDEX_LINKAGE unsigned clang_visitChildren(CXCursor parent, 3943 CXCursorVisitor visitor, 3944 CXClientData client_data); 3945 /** 3946 * Visitor invoked for each cursor found by a traversal. 3947 * 3948 * This visitor block will be invoked for each cursor found by 3949 * clang_visitChildrenWithBlock(). Its first argument is the cursor being 3950 * visited, its second argument is the parent visitor for that cursor. 3951 * 3952 * The visitor should return one of the \c CXChildVisitResult values 3953 * to direct clang_visitChildrenWithBlock(). 3954 */ 3955 #if __has_feature(blocks) 3956 typedef enum CXChildVisitResult (^CXCursorVisitorBlock)(CXCursor cursor, 3957 CXCursor parent); 3958 #else 3959 typedef struct _CXChildVisitResult *CXCursorVisitorBlock; 3960 #endif 3961 3962 /** 3963 * Visits the children of a cursor using the specified block. Behaves 3964 * identically to clang_visitChildren() in all other respects. 3965 */ 3966 CINDEX_LINKAGE unsigned 3967 clang_visitChildrenWithBlock(CXCursor parent, CXCursorVisitorBlock block); 3968 3969 /** 3970 * @} 3971 */ 3972 3973 /** 3974 * \defgroup CINDEX_CURSOR_XREF Cross-referencing in the AST 3975 * 3976 * These routines provide the ability to determine references within and 3977 * across translation units, by providing the names of the entities referenced 3978 * by cursors, follow reference cursors to the declarations they reference, 3979 * and associate declarations with their definitions. 3980 * 3981 * @{ 3982 */ 3983 3984 /** 3985 * Retrieve a Unified Symbol Resolution (USR) for the entity referenced 3986 * by the given cursor. 3987 * 3988 * A Unified Symbol Resolution (USR) is a string that identifies a particular 3989 * entity (function, class, variable, etc.) within a program. USRs can be 3990 * compared across translation units to determine, e.g., when references in 3991 * one translation refer to an entity defined in another translation unit. 3992 */ 3993 CINDEX_LINKAGE CXString clang_getCursorUSR(CXCursor); 3994 3995 /** 3996 * Construct a USR for a specified Objective-C class. 3997 */ 3998 CINDEX_LINKAGE CXString clang_constructUSR_ObjCClass(const char *class_name); 3999 4000 /** 4001 * Construct a USR for a specified Objective-C category. 4002 */ 4003 CINDEX_LINKAGE CXString clang_constructUSR_ObjCCategory( 4004 const char *class_name, const char *category_name); 4005 4006 /** 4007 * Construct a USR for a specified Objective-C protocol. 4008 */ 4009 CINDEX_LINKAGE CXString 4010 clang_constructUSR_ObjCProtocol(const char *protocol_name); 4011 4012 /** 4013 * Construct a USR for a specified Objective-C instance variable and 4014 * the USR for its containing class. 4015 */ 4016 CINDEX_LINKAGE CXString clang_constructUSR_ObjCIvar(const char *name, 4017 CXString classUSR); 4018 4019 /** 4020 * Construct a USR for a specified Objective-C method and 4021 * the USR for its containing class. 4022 */ 4023 CINDEX_LINKAGE CXString clang_constructUSR_ObjCMethod(const char *name, 4024 unsigned isInstanceMethod, 4025 CXString classUSR); 4026 4027 /** 4028 * Construct a USR for a specified Objective-C property and the USR 4029 * for its containing class. 4030 */ 4031 CINDEX_LINKAGE CXString clang_constructUSR_ObjCProperty(const char *property, 4032 CXString classUSR); 4033 4034 /** 4035 * Retrieve a name for the entity referenced by this cursor. 4036 */ 4037 CINDEX_LINKAGE CXString clang_getCursorSpelling(CXCursor); 4038 4039 /** 4040 * Retrieve a range for a piece that forms the cursors spelling name. 4041 * Most of the times there is only one range for the complete spelling but for 4042 * Objective-C methods and Objective-C message expressions, there are multiple 4043 * pieces for each selector identifier. 4044 * 4045 * \param pieceIndex the index of the spelling name piece. If this is greater 4046 * than the actual number of pieces, it will return a NULL (invalid) range. 4047 * 4048 * \param options Reserved. 4049 */ 4050 CINDEX_LINKAGE CXSourceRange clang_Cursor_getSpellingNameRange( 4051 CXCursor, unsigned pieceIndex, unsigned options); 4052 4053 /** 4054 * Opaque pointer representing a policy that controls pretty printing 4055 * for \c clang_getCursorPrettyPrinted. 4056 */ 4057 typedef void *CXPrintingPolicy; 4058 4059 /** 4060 * Properties for the printing policy. 4061 * 4062 * See \c clang::PrintingPolicy for more information. 4063 */ 4064 enum CXPrintingPolicyProperty { 4065 CXPrintingPolicy_Indentation, 4066 CXPrintingPolicy_SuppressSpecifiers, 4067 CXPrintingPolicy_SuppressTagKeyword, 4068 CXPrintingPolicy_IncludeTagDefinition, 4069 CXPrintingPolicy_SuppressScope, 4070 CXPrintingPolicy_SuppressUnwrittenScope, 4071 CXPrintingPolicy_SuppressInitializers, 4072 CXPrintingPolicy_ConstantArraySizeAsWritten, 4073 CXPrintingPolicy_AnonymousTagLocations, 4074 CXPrintingPolicy_SuppressStrongLifetime, 4075 CXPrintingPolicy_SuppressLifetimeQualifiers, 4076 CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors, 4077 CXPrintingPolicy_Bool, 4078 CXPrintingPolicy_Restrict, 4079 CXPrintingPolicy_Alignof, 4080 CXPrintingPolicy_UnderscoreAlignof, 4081 CXPrintingPolicy_UseVoidForZeroParams, 4082 CXPrintingPolicy_TerseOutput, 4083 CXPrintingPolicy_PolishForDeclaration, 4084 CXPrintingPolicy_Half, 4085 CXPrintingPolicy_MSWChar, 4086 CXPrintingPolicy_IncludeNewlines, 4087 CXPrintingPolicy_MSVCFormatting, 4088 CXPrintingPolicy_ConstantsAsWritten, 4089 CXPrintingPolicy_SuppressImplicitBase, 4090 CXPrintingPolicy_FullyQualifiedName, 4091 4092 CXPrintingPolicy_LastProperty = CXPrintingPolicy_FullyQualifiedName 4093 }; 4094 4095 /** 4096 * Get a property value for the given printing policy. 4097 */ 4098 CINDEX_LINKAGE unsigned 4099 clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy, 4100 enum CXPrintingPolicyProperty Property); 4101 4102 /** 4103 * Set a property value for the given printing policy. 4104 */ 4105 CINDEX_LINKAGE void 4106 clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy, 4107 enum CXPrintingPolicyProperty Property, 4108 unsigned Value); 4109 4110 /** 4111 * Retrieve the default policy for the cursor. 4112 * 4113 * The policy should be released after use with \c 4114 * clang_PrintingPolicy_dispose. 4115 */ 4116 CINDEX_LINKAGE CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor); 4117 4118 /** 4119 * Release a printing policy. 4120 */ 4121 CINDEX_LINKAGE void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy); 4122 4123 /** 4124 * Pretty print declarations. 4125 * 4126 * \param Cursor The cursor representing a declaration. 4127 * 4128 * \param Policy The policy to control the entities being printed. If 4129 * NULL, a default policy is used. 4130 * 4131 * \returns The pretty printed declaration or the empty string for 4132 * other cursors. 4133 */ 4134 CINDEX_LINKAGE CXString clang_getCursorPrettyPrinted(CXCursor Cursor, 4135 CXPrintingPolicy Policy); 4136 4137 /** 4138 * Retrieve the display name for the entity referenced by this cursor. 4139 * 4140 * The display name contains extra information that helps identify the cursor, 4141 * such as the parameters of a function or template or the arguments of a 4142 * class template specialization. 4143 */ 4144 CINDEX_LINKAGE CXString clang_getCursorDisplayName(CXCursor); 4145 4146 /** For a cursor that is a reference, retrieve a cursor representing the 4147 * entity that it references. 4148 * 4149 * Reference cursors refer to other entities in the AST. For example, an 4150 * Objective-C superclass reference cursor refers to an Objective-C class. 4151 * This function produces the cursor for the Objective-C class from the 4152 * cursor for the superclass reference. If the input cursor is a declaration or 4153 * definition, it returns that declaration or definition unchanged. 4154 * Otherwise, returns the NULL cursor. 4155 */ 4156 CINDEX_LINKAGE CXCursor clang_getCursorReferenced(CXCursor); 4157 4158 /** 4159 * For a cursor that is either a reference to or a declaration 4160 * of some entity, retrieve a cursor that describes the definition of 4161 * that entity. 4162 * 4163 * Some entities can be declared multiple times within a translation 4164 * unit, but only one of those declarations can also be a 4165 * definition. For example, given: 4166 * 4167 * \code 4168 * int f(int, int); 4169 * int g(int x, int y) { return f(x, y); } 4170 * int f(int a, int b) { return a + b; } 4171 * int f(int, int); 4172 * \endcode 4173 * 4174 * there are three declarations of the function "f", but only the 4175 * second one is a definition. The clang_getCursorDefinition() 4176 * function will take any cursor pointing to a declaration of "f" 4177 * (the first or fourth lines of the example) or a cursor referenced 4178 * that uses "f" (the call to "f' inside "g") and will return a 4179 * declaration cursor pointing to the definition (the second "f" 4180 * declaration). 4181 * 4182 * If given a cursor for which there is no corresponding definition, 4183 * e.g., because there is no definition of that entity within this 4184 * translation unit, returns a NULL cursor. 4185 */ 4186 CINDEX_LINKAGE CXCursor clang_getCursorDefinition(CXCursor); 4187 4188 /** 4189 * Determine whether the declaration pointed to by this cursor 4190 * is also a definition of that entity. 4191 */ 4192 CINDEX_LINKAGE unsigned clang_isCursorDefinition(CXCursor); 4193 4194 /** 4195 * Retrieve the canonical cursor corresponding to the given cursor. 4196 * 4197 * In the C family of languages, many kinds of entities can be declared several 4198 * times within a single translation unit. For example, a structure type can 4199 * be forward-declared (possibly multiple times) and later defined: 4200 * 4201 * \code 4202 * struct X; 4203 * struct X; 4204 * struct X { 4205 * int member; 4206 * }; 4207 * \endcode 4208 * 4209 * The declarations and the definition of \c X are represented by three 4210 * different cursors, all of which are declarations of the same underlying 4211 * entity. One of these cursor is considered the "canonical" cursor, which 4212 * is effectively the representative for the underlying entity. One can 4213 * determine if two cursors are declarations of the same underlying entity by 4214 * comparing their canonical cursors. 4215 * 4216 * \returns The canonical cursor for the entity referred to by the given cursor. 4217 */ 4218 CINDEX_LINKAGE CXCursor clang_getCanonicalCursor(CXCursor); 4219 4220 /** 4221 * If the cursor points to a selector identifier in an Objective-C 4222 * method or message expression, this returns the selector index. 4223 * 4224 * After getting a cursor with #clang_getCursor, this can be called to 4225 * determine if the location points to a selector identifier. 4226 * 4227 * \returns The selector index if the cursor is an Objective-C method or message 4228 * expression and the cursor is pointing to a selector identifier, or -1 4229 * otherwise. 4230 */ 4231 CINDEX_LINKAGE int clang_Cursor_getObjCSelectorIndex(CXCursor); 4232 4233 /** 4234 * Given a cursor pointing to a C++ method call or an Objective-C 4235 * message, returns non-zero if the method/message is "dynamic", meaning: 4236 * 4237 * For a C++ method: the call is virtual. 4238 * For an Objective-C message: the receiver is an object instance, not 'super' 4239 * or a specific class. 4240 * 4241 * If the method/message is "static" or the cursor does not point to a 4242 * method/message, it will return zero. 4243 */ 4244 CINDEX_LINKAGE int clang_Cursor_isDynamicCall(CXCursor C); 4245 4246 /** 4247 * Given a cursor pointing to an Objective-C message or property 4248 * reference, or C++ method call, returns the CXType of the receiver. 4249 */ 4250 CINDEX_LINKAGE CXType clang_Cursor_getReceiverType(CXCursor C); 4251 4252 /** 4253 * Property attributes for a \c CXCursor_ObjCPropertyDecl. 4254 */ 4255 typedef enum { 4256 CXObjCPropertyAttr_noattr = 0x00, 4257 CXObjCPropertyAttr_readonly = 0x01, 4258 CXObjCPropertyAttr_getter = 0x02, 4259 CXObjCPropertyAttr_assign = 0x04, 4260 CXObjCPropertyAttr_readwrite = 0x08, 4261 CXObjCPropertyAttr_retain = 0x10, 4262 CXObjCPropertyAttr_copy = 0x20, 4263 CXObjCPropertyAttr_nonatomic = 0x40, 4264 CXObjCPropertyAttr_setter = 0x80, 4265 CXObjCPropertyAttr_atomic = 0x100, 4266 CXObjCPropertyAttr_weak = 0x200, 4267 CXObjCPropertyAttr_strong = 0x400, 4268 CXObjCPropertyAttr_unsafe_unretained = 0x800, 4269 CXObjCPropertyAttr_class = 0x1000 4270 } CXObjCPropertyAttrKind; 4271 4272 /** 4273 * Given a cursor that represents a property declaration, return the 4274 * associated property attributes. The bits are formed from 4275 * \c CXObjCPropertyAttrKind. 4276 * 4277 * \param reserved Reserved for future use, pass 0. 4278 */ 4279 CINDEX_LINKAGE unsigned 4280 clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved); 4281 4282 /** 4283 * Given a cursor that represents a property declaration, return the 4284 * name of the method that implements the getter. 4285 */ 4286 CINDEX_LINKAGE CXString clang_Cursor_getObjCPropertyGetterName(CXCursor C); 4287 4288 /** 4289 * Given a cursor that represents a property declaration, return the 4290 * name of the method that implements the setter, if any. 4291 */ 4292 CINDEX_LINKAGE CXString clang_Cursor_getObjCPropertySetterName(CXCursor C); 4293 4294 /** 4295 * 'Qualifiers' written next to the return and parameter types in 4296 * Objective-C method declarations. 4297 */ 4298 typedef enum { 4299 CXObjCDeclQualifier_None = 0x0, 4300 CXObjCDeclQualifier_In = 0x1, 4301 CXObjCDeclQualifier_Inout = 0x2, 4302 CXObjCDeclQualifier_Out = 0x4, 4303 CXObjCDeclQualifier_Bycopy = 0x8, 4304 CXObjCDeclQualifier_Byref = 0x10, 4305 CXObjCDeclQualifier_Oneway = 0x20 4306 } CXObjCDeclQualifierKind; 4307 4308 /** 4309 * Given a cursor that represents an Objective-C method or parameter 4310 * declaration, return the associated Objective-C qualifiers for the return 4311 * type or the parameter respectively. The bits are formed from 4312 * CXObjCDeclQualifierKind. 4313 */ 4314 CINDEX_LINKAGE unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C); 4315 4316 /** 4317 * Given a cursor that represents an Objective-C method or property 4318 * declaration, return non-zero if the declaration was affected by "\@optional". 4319 * Returns zero if the cursor is not such a declaration or it is "\@required". 4320 */ 4321 CINDEX_LINKAGE unsigned clang_Cursor_isObjCOptional(CXCursor C); 4322 4323 /** 4324 * Returns non-zero if the given cursor is a variadic function or method. 4325 */ 4326 CINDEX_LINKAGE unsigned clang_Cursor_isVariadic(CXCursor C); 4327 4328 /** 4329 * Returns non-zero if the given cursor points to a symbol marked with 4330 * external_source_symbol attribute. 4331 * 4332 * \param language If non-NULL, and the attribute is present, will be set to 4333 * the 'language' string from the attribute. 4334 * 4335 * \param definedIn If non-NULL, and the attribute is present, will be set to 4336 * the 'definedIn' string from the attribute. 4337 * 4338 * \param isGenerated If non-NULL, and the attribute is present, will be set to 4339 * non-zero if the 'generated_declaration' is set in the attribute. 4340 */ 4341 CINDEX_LINKAGE unsigned clang_Cursor_isExternalSymbol(CXCursor C, 4342 CXString *language, 4343 CXString *definedIn, 4344 unsigned *isGenerated); 4345 4346 /** 4347 * Given a cursor that represents a declaration, return the associated 4348 * comment's source range. The range may include multiple consecutive comments 4349 * with whitespace in between. 4350 */ 4351 CINDEX_LINKAGE CXSourceRange clang_Cursor_getCommentRange(CXCursor C); 4352 4353 /** 4354 * Given a cursor that represents a declaration, return the associated 4355 * comment text, including comment markers. 4356 */ 4357 CINDEX_LINKAGE CXString clang_Cursor_getRawCommentText(CXCursor C); 4358 4359 /** 4360 * Given a cursor that represents a documentable entity (e.g., 4361 * declaration), return the associated \paragraph; otherwise return the 4362 * first paragraph. 4363 */ 4364 CINDEX_LINKAGE CXString clang_Cursor_getBriefCommentText(CXCursor C); 4365 4366 /** 4367 * @} 4368 */ 4369 4370 /** \defgroup CINDEX_MANGLE Name Mangling API Functions 4371 * 4372 * @{ 4373 */ 4374 4375 /** 4376 * Retrieve the CXString representing the mangled name of the cursor. 4377 */ 4378 CINDEX_LINKAGE CXString clang_Cursor_getMangling(CXCursor); 4379 4380 /** 4381 * Retrieve the CXStrings representing the mangled symbols of the C++ 4382 * constructor or destructor at the cursor. 4383 */ 4384 CINDEX_LINKAGE CXStringSet *clang_Cursor_getCXXManglings(CXCursor); 4385 4386 /** 4387 * Retrieve the CXStrings representing the mangled symbols of the ObjC 4388 * class interface or implementation at the cursor. 4389 */ 4390 CINDEX_LINKAGE CXStringSet *clang_Cursor_getObjCManglings(CXCursor); 4391 4392 /** 4393 * @} 4394 */ 4395 4396 /** 4397 * \defgroup CINDEX_MODULE Module introspection 4398 * 4399 * The functions in this group provide access to information about modules. 4400 * 4401 * @{ 4402 */ 4403 4404 typedef void *CXModule; 4405 4406 /** 4407 * Given a CXCursor_ModuleImportDecl cursor, return the associated module. 4408 */ 4409 CINDEX_LINKAGE CXModule clang_Cursor_getModule(CXCursor C); 4410 4411 /** 4412 * Given a CXFile header file, return the module that contains it, if one 4413 * exists. 4414 */ 4415 CINDEX_LINKAGE CXModule clang_getModuleForFile(CXTranslationUnit, CXFile); 4416 4417 /** 4418 * \param Module a module object. 4419 * 4420 * \returns the module file where the provided module object came from. 4421 */ 4422 CINDEX_LINKAGE CXFile clang_Module_getASTFile(CXModule Module); 4423 4424 /** 4425 * \param Module a module object. 4426 * 4427 * \returns the parent of a sub-module or NULL if the given module is top-level, 4428 * e.g. for 'std.vector' it will return the 'std' module. 4429 */ 4430 CINDEX_LINKAGE CXModule clang_Module_getParent(CXModule Module); 4431 4432 /** 4433 * \param Module a module object. 4434 * 4435 * \returns the name of the module, e.g. for the 'std.vector' sub-module it 4436 * will return "vector". 4437 */ 4438 CINDEX_LINKAGE CXString clang_Module_getName(CXModule Module); 4439 4440 /** 4441 * \param Module a module object. 4442 * 4443 * \returns the full name of the module, e.g. "std.vector". 4444 */ 4445 CINDEX_LINKAGE CXString clang_Module_getFullName(CXModule Module); 4446 4447 /** 4448 * \param Module a module object. 4449 * 4450 * \returns non-zero if the module is a system one. 4451 */ 4452 CINDEX_LINKAGE int clang_Module_isSystem(CXModule Module); 4453 4454 /** 4455 * \param Module a module object. 4456 * 4457 * \returns the number of top level headers associated with this module. 4458 */ 4459 CINDEX_LINKAGE unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit, 4460 CXModule Module); 4461 4462 /** 4463 * \param Module a module object. 4464 * 4465 * \param Index top level header index (zero-based). 4466 * 4467 * \returns the specified top level header associated with the module. 4468 */ 4469 CINDEX_LINKAGE 4470 CXFile clang_Module_getTopLevelHeader(CXTranslationUnit, CXModule Module, 4471 unsigned Index); 4472 4473 /** 4474 * @} 4475 */ 4476 4477 /** 4478 * \defgroup CINDEX_CPP C++ AST introspection 4479 * 4480 * The routines in this group provide access information in the ASTs specific 4481 * to C++ language features. 4482 * 4483 * @{ 4484 */ 4485 4486 /** 4487 * Determine if a C++ constructor is a converting constructor. 4488 */ 4489 CINDEX_LINKAGE unsigned 4490 clang_CXXConstructor_isConvertingConstructor(CXCursor C); 4491 4492 /** 4493 * Determine if a C++ constructor is a copy constructor. 4494 */ 4495 CINDEX_LINKAGE unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C); 4496 4497 /** 4498 * Determine if a C++ constructor is the default constructor. 4499 */ 4500 CINDEX_LINKAGE unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C); 4501 4502 /** 4503 * Determine if a C++ constructor is a move constructor. 4504 */ 4505 CINDEX_LINKAGE unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C); 4506 4507 /** 4508 * Determine if a C++ field is declared 'mutable'. 4509 */ 4510 CINDEX_LINKAGE unsigned clang_CXXField_isMutable(CXCursor C); 4511 4512 /** 4513 * Determine if a C++ method is declared '= default'. 4514 */ 4515 CINDEX_LINKAGE unsigned clang_CXXMethod_isDefaulted(CXCursor C); 4516 4517 /** 4518 * Determine if a C++ method is declared '= delete'. 4519 */ 4520 CINDEX_LINKAGE unsigned clang_CXXMethod_isDeleted(CXCursor C); 4521 4522 /** 4523 * Determine if a C++ member function or member function template is 4524 * pure virtual. 4525 */ 4526 CINDEX_LINKAGE unsigned clang_CXXMethod_isPureVirtual(CXCursor C); 4527 4528 /** 4529 * Determine if a C++ member function or member function template is 4530 * declared 'static'. 4531 */ 4532 CINDEX_LINKAGE unsigned clang_CXXMethod_isStatic(CXCursor C); 4533 4534 /** 4535 * Determine if a C++ member function or member function template is 4536 * explicitly declared 'virtual' or if it overrides a virtual method from 4537 * one of the base classes. 4538 */ 4539 CINDEX_LINKAGE unsigned clang_CXXMethod_isVirtual(CXCursor C); 4540 4541 /** 4542 * Determine if a C++ member function is a copy-assignment operator, 4543 * returning 1 if such is the case and 0 otherwise. 4544 * 4545 * > A copy-assignment operator `X::operator=` is a non-static, 4546 * > non-template member function of _class_ `X` with exactly one 4547 * > parameter of type `X`, `X&`, `const X&`, `volatile X&` or `const 4548 * > volatile X&`. 4549 * 4550 * That is, for example, the `operator=` in: 4551 * 4552 * class Foo { 4553 * bool operator=(const volatile Foo&); 4554 * }; 4555 * 4556 * Is a copy-assignment operator, while the `operator=` in: 4557 * 4558 * class Bar { 4559 * bool operator=(const int&); 4560 * }; 4561 * 4562 * Is not. 4563 */ 4564 CINDEX_LINKAGE unsigned clang_CXXMethod_isCopyAssignmentOperator(CXCursor C); 4565 4566 /** 4567 * Determine if a C++ member function is a move-assignment operator, 4568 * returning 1 if such is the case and 0 otherwise. 4569 * 4570 * > A move-assignment operator `X::operator=` is a non-static, 4571 * > non-template member function of _class_ `X` with exactly one 4572 * > parameter of type `X&&`, `const X&&`, `volatile X&&` or `const 4573 * > volatile X&&`. 4574 * 4575 * That is, for example, the `operator=` in: 4576 * 4577 * class Foo { 4578 * bool operator=(const volatile Foo&&); 4579 * }; 4580 * 4581 * Is a move-assignment operator, while the `operator=` in: 4582 * 4583 * class Bar { 4584 * bool operator=(const int&&); 4585 * }; 4586 * 4587 * Is not. 4588 */ 4589 CINDEX_LINKAGE unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C); 4590 4591 /** 4592 * Determines if a C++ constructor or conversion function was declared 4593 * explicit, returning 1 if such is the case and 0 otherwise. 4594 * 4595 * Constructors or conversion functions are declared explicit through 4596 * the use of the explicit specifier. 4597 * 4598 * For example, the following constructor and conversion function are 4599 * not explicit as they lack the explicit specifier: 4600 * 4601 * class Foo { 4602 * Foo(); 4603 * operator int(); 4604 * }; 4605 * 4606 * While the following constructor and conversion function are 4607 * explicit as they are declared with the explicit specifier. 4608 * 4609 * class Foo { 4610 * explicit Foo(); 4611 * explicit operator int(); 4612 * }; 4613 * 4614 * This function will return 0 when given a cursor pointing to one of 4615 * the former declarations and it will return 1 for a cursor pointing 4616 * to the latter declarations. 4617 * 4618 * The explicit specifier allows the user to specify a 4619 * conditional compile-time expression whose value decides 4620 * whether the marked element is explicit or not. 4621 * 4622 * For example: 4623 * 4624 * constexpr bool foo(int i) { return i % 2 == 0; } 4625 * 4626 * class Foo { 4627 * explicit(foo(1)) Foo(); 4628 * explicit(foo(2)) operator int(); 4629 * } 4630 * 4631 * This function will return 0 for the constructor and 1 for 4632 * the conversion function. 4633 */ 4634 CINDEX_LINKAGE unsigned clang_CXXMethod_isExplicit(CXCursor C); 4635 4636 /** 4637 * Determine if a C++ record is abstract, i.e. whether a class or struct 4638 * has a pure virtual member function. 4639 */ 4640 CINDEX_LINKAGE unsigned clang_CXXRecord_isAbstract(CXCursor C); 4641 4642 /** 4643 * Determine if an enum declaration refers to a scoped enum. 4644 */ 4645 CINDEX_LINKAGE unsigned clang_EnumDecl_isScoped(CXCursor C); 4646 4647 /** 4648 * Determine if a C++ member function or member function template is 4649 * declared 'const'. 4650 */ 4651 CINDEX_LINKAGE unsigned clang_CXXMethod_isConst(CXCursor C); 4652 4653 /** 4654 * Given a cursor that represents a template, determine 4655 * the cursor kind of the specializations would be generated by instantiating 4656 * the template. 4657 * 4658 * This routine can be used to determine what flavor of function template, 4659 * class template, or class template partial specialization is stored in the 4660 * cursor. For example, it can describe whether a class template cursor is 4661 * declared with "struct", "class" or "union". 4662 * 4663 * \param C The cursor to query. This cursor should represent a template 4664 * declaration. 4665 * 4666 * \returns The cursor kind of the specializations that would be generated 4667 * by instantiating the template \p C. If \p C is not a template, returns 4668 * \c CXCursor_NoDeclFound. 4669 */ 4670 CINDEX_LINKAGE enum CXCursorKind clang_getTemplateCursorKind(CXCursor C); 4671 4672 /** 4673 * Given a cursor that may represent a specialization or instantiation 4674 * of a template, retrieve the cursor that represents the template that it 4675 * specializes or from which it was instantiated. 4676 * 4677 * This routine determines the template involved both for explicit 4678 * specializations of templates and for implicit instantiations of the template, 4679 * both of which are referred to as "specializations". For a class template 4680 * specialization (e.g., \c std::vector<bool>), this routine will return 4681 * either the primary template (\c std::vector) or, if the specialization was 4682 * instantiated from a class template partial specialization, the class template 4683 * partial specialization. For a class template partial specialization and a 4684 * function template specialization (including instantiations), this 4685 * this routine will return the specialized template. 4686 * 4687 * For members of a class template (e.g., member functions, member classes, or 4688 * static data members), returns the specialized or instantiated member. 4689 * Although not strictly "templates" in the C++ language, members of class 4690 * templates have the same notions of specializations and instantiations that 4691 * templates do, so this routine treats them similarly. 4692 * 4693 * \param C A cursor that may be a specialization of a template or a member 4694 * of a template. 4695 * 4696 * \returns If the given cursor is a specialization or instantiation of a 4697 * template or a member thereof, the template or member that it specializes or 4698 * from which it was instantiated. Otherwise, returns a NULL cursor. 4699 */ 4700 CINDEX_LINKAGE CXCursor clang_getSpecializedCursorTemplate(CXCursor C); 4701 4702 /** 4703 * Given a cursor that references something else, return the source range 4704 * covering that reference. 4705 * 4706 * \param C A cursor pointing to a member reference, a declaration reference, or 4707 * an operator call. 4708 * \param NameFlags A bitset with three independent flags: 4709 * CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and 4710 * CXNameRange_WantSinglePiece. 4711 * \param PieceIndex For contiguous names or when passing the flag 4712 * CXNameRange_WantSinglePiece, only one piece with index 0 is 4713 * available. When the CXNameRange_WantSinglePiece flag is not passed for a 4714 * non-contiguous names, this index can be used to retrieve the individual 4715 * pieces of the name. See also CXNameRange_WantSinglePiece. 4716 * 4717 * \returns The piece of the name pointed to by the given cursor. If there is no 4718 * name, or if the PieceIndex is out-of-range, a null-cursor will be returned. 4719 */ 4720 CINDEX_LINKAGE CXSourceRange clang_getCursorReferenceNameRange( 4721 CXCursor C, unsigned NameFlags, unsigned PieceIndex); 4722 4723 enum CXNameRefFlags { 4724 /** 4725 * Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the 4726 * range. 4727 */ 4728 CXNameRange_WantQualifier = 0x1, 4729 4730 /** 4731 * Include the explicit template arguments, e.g. \<int> in x.f<int>, 4732 * in the range. 4733 */ 4734 CXNameRange_WantTemplateArgs = 0x2, 4735 4736 /** 4737 * If the name is non-contiguous, return the full spanning range. 4738 * 4739 * Non-contiguous names occur in Objective-C when a selector with two or more 4740 * parameters is used, or in C++ when using an operator: 4741 * \code 4742 * [object doSomething:here withValue:there]; // Objective-C 4743 * return some_vector[1]; // C++ 4744 * \endcode 4745 */ 4746 CXNameRange_WantSinglePiece = 0x4 4747 }; 4748 4749 /** 4750 * @} 4751 */ 4752 4753 /** 4754 * \defgroup CINDEX_LEX Token extraction and manipulation 4755 * 4756 * The routines in this group provide access to the tokens within a 4757 * translation unit, along with a semantic mapping of those tokens to 4758 * their corresponding cursors. 4759 * 4760 * @{ 4761 */ 4762 4763 /** 4764 * Describes a kind of token. 4765 */ 4766 typedef enum CXTokenKind { 4767 /** 4768 * A token that contains some kind of punctuation. 4769 */ 4770 CXToken_Punctuation, 4771 4772 /** 4773 * A language keyword. 4774 */ 4775 CXToken_Keyword, 4776 4777 /** 4778 * An identifier (that is not a keyword). 4779 */ 4780 CXToken_Identifier, 4781 4782 /** 4783 * A numeric, string, or character literal. 4784 */ 4785 CXToken_Literal, 4786 4787 /** 4788 * A comment. 4789 */ 4790 CXToken_Comment 4791 } CXTokenKind; 4792 4793 /** 4794 * Describes a single preprocessing token. 4795 */ 4796 typedef struct { 4797 unsigned int_data[4]; 4798 void *ptr_data; 4799 } CXToken; 4800 4801 /** 4802 * Get the raw lexical token starting with the given location. 4803 * 4804 * \param TU the translation unit whose text is being tokenized. 4805 * 4806 * \param Location the source location with which the token starts. 4807 * 4808 * \returns The token starting with the given location or NULL if no such token 4809 * exist. The returned pointer must be freed with clang_disposeTokens before the 4810 * translation unit is destroyed. 4811 */ 4812 CINDEX_LINKAGE CXToken *clang_getToken(CXTranslationUnit TU, 4813 CXSourceLocation Location); 4814 4815 /** 4816 * Determine the kind of the given token. 4817 */ 4818 CINDEX_LINKAGE CXTokenKind clang_getTokenKind(CXToken); 4819 4820 /** 4821 * Determine the spelling of the given token. 4822 * 4823 * The spelling of a token is the textual representation of that token, e.g., 4824 * the text of an identifier or keyword. 4825 */ 4826 CINDEX_LINKAGE CXString clang_getTokenSpelling(CXTranslationUnit, CXToken); 4827 4828 /** 4829 * Retrieve the source location of the given token. 4830 */ 4831 CINDEX_LINKAGE CXSourceLocation clang_getTokenLocation(CXTranslationUnit, 4832 CXToken); 4833 4834 /** 4835 * Retrieve a source range that covers the given token. 4836 */ 4837 CINDEX_LINKAGE CXSourceRange clang_getTokenExtent(CXTranslationUnit, CXToken); 4838 4839 /** 4840 * Tokenize the source code described by the given range into raw 4841 * lexical tokens. 4842 * 4843 * \param TU the translation unit whose text is being tokenized. 4844 * 4845 * \param Range the source range in which text should be tokenized. All of the 4846 * tokens produced by tokenization will fall within this source range, 4847 * 4848 * \param Tokens this pointer will be set to point to the array of tokens 4849 * that occur within the given source range. The returned pointer must be 4850 * freed with clang_disposeTokens() before the translation unit is destroyed. 4851 * 4852 * \param NumTokens will be set to the number of tokens in the \c *Tokens 4853 * array. 4854 * 4855 */ 4856 CINDEX_LINKAGE void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 4857 CXToken **Tokens, unsigned *NumTokens); 4858 4859 /** 4860 * Annotate the given set of tokens by providing cursors for each token 4861 * that can be mapped to a specific entity within the abstract syntax tree. 4862 * 4863 * This token-annotation routine is equivalent to invoking 4864 * clang_getCursor() for the source locations of each of the 4865 * tokens. The cursors provided are filtered, so that only those 4866 * cursors that have a direct correspondence to the token are 4867 * accepted. For example, given a function call \c f(x), 4868 * clang_getCursor() would provide the following cursors: 4869 * 4870 * * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'. 4871 * * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'. 4872 * * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'. 4873 * 4874 * Only the first and last of these cursors will occur within the 4875 * annotate, since the tokens "f" and "x' directly refer to a function 4876 * and a variable, respectively, but the parentheses are just a small 4877 * part of the full syntax of the function call expression, which is 4878 * not provided as an annotation. 4879 * 4880 * \param TU the translation unit that owns the given tokens. 4881 * 4882 * \param Tokens the set of tokens to annotate. 4883 * 4884 * \param NumTokens the number of tokens in \p Tokens. 4885 * 4886 * \param Cursors an array of \p NumTokens cursors, whose contents will be 4887 * replaced with the cursors corresponding to each token. 4888 */ 4889 CINDEX_LINKAGE void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens, 4890 unsigned NumTokens, CXCursor *Cursors); 4891 4892 /** 4893 * Free the given set of tokens. 4894 */ 4895 CINDEX_LINKAGE void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens, 4896 unsigned NumTokens); 4897 4898 /** 4899 * @} 4900 */ 4901 4902 /** 4903 * \defgroup CINDEX_DEBUG Debugging facilities 4904 * 4905 * These routines are used for testing and debugging, only, and should not 4906 * be relied upon. 4907 * 4908 * @{ 4909 */ 4910 4911 /* for debug/testing */ 4912 CINDEX_LINKAGE CXString clang_getCursorKindSpelling(enum CXCursorKind Kind); 4913 CINDEX_LINKAGE void clang_getDefinitionSpellingAndExtent( 4914 CXCursor, const char **startBuf, const char **endBuf, unsigned *startLine, 4915 unsigned *startColumn, unsigned *endLine, unsigned *endColumn); 4916 CINDEX_LINKAGE void clang_enableStackTraces(void); 4917 CINDEX_LINKAGE void clang_executeOnThread(void (*fn)(void *), void *user_data, 4918 unsigned stack_size); 4919 4920 /** 4921 * @} 4922 */ 4923 4924 /** 4925 * \defgroup CINDEX_CODE_COMPLET Code completion 4926 * 4927 * Code completion involves taking an (incomplete) source file, along with 4928 * knowledge of where the user is actively editing that file, and suggesting 4929 * syntactically- and semantically-valid constructs that the user might want to 4930 * use at that particular point in the source code. These data structures and 4931 * routines provide support for code completion. 4932 * 4933 * @{ 4934 */ 4935 4936 /** 4937 * A semantic string that describes a code-completion result. 4938 * 4939 * A semantic string that describes the formatting of a code-completion 4940 * result as a single "template" of text that should be inserted into the 4941 * source buffer when a particular code-completion result is selected. 4942 * Each semantic string is made up of some number of "chunks", each of which 4943 * contains some text along with a description of what that text means, e.g., 4944 * the name of the entity being referenced, whether the text chunk is part of 4945 * the template, or whether it is a "placeholder" that the user should replace 4946 * with actual code,of a specific kind. See \c CXCompletionChunkKind for a 4947 * description of the different kinds of chunks. 4948 */ 4949 typedef void *CXCompletionString; 4950 4951 /** 4952 * A single result of code completion. 4953 */ 4954 typedef struct { 4955 /** 4956 * The kind of entity that this completion refers to. 4957 * 4958 * The cursor kind will be a macro, keyword, or a declaration (one of the 4959 * *Decl cursor kinds), describing the entity that the completion is 4960 * referring to. 4961 * 4962 * \todo In the future, we would like to provide a full cursor, to allow 4963 * the client to extract additional information from declaration. 4964 */ 4965 enum CXCursorKind CursorKind; 4966 4967 /** 4968 * The code-completion string that describes how to insert this 4969 * code-completion result into the editing buffer. 4970 */ 4971 CXCompletionString CompletionString; 4972 } CXCompletionResult; 4973 4974 /** 4975 * Describes a single piece of text within a code-completion string. 4976 * 4977 * Each "chunk" within a code-completion string (\c CXCompletionString) is 4978 * either a piece of text with a specific "kind" that describes how that text 4979 * should be interpreted by the client or is another completion string. 4980 */ 4981 enum CXCompletionChunkKind { 4982 /** 4983 * A code-completion string that describes "optional" text that 4984 * could be a part of the template (but is not required). 4985 * 4986 * The Optional chunk is the only kind of chunk that has a code-completion 4987 * string for its representation, which is accessible via 4988 * \c clang_getCompletionChunkCompletionString(). The code-completion string 4989 * describes an additional part of the template that is completely optional. 4990 * For example, optional chunks can be used to describe the placeholders for 4991 * arguments that match up with defaulted function parameters, e.g. given: 4992 * 4993 * \code 4994 * void f(int x, float y = 3.14, double z = 2.71828); 4995 * \endcode 4996 * 4997 * The code-completion string for this function would contain: 4998 * - a TypedText chunk for "f". 4999 * - a LeftParen chunk for "(". 5000 * - a Placeholder chunk for "int x" 5001 * - an Optional chunk containing the remaining defaulted arguments, e.g., 5002 * - a Comma chunk for "," 5003 * - a Placeholder chunk for "float y" 5004 * - an Optional chunk containing the last defaulted argument: 5005 * - a Comma chunk for "," 5006 * - a Placeholder chunk for "double z" 5007 * - a RightParen chunk for ")" 5008 * 5009 * There are many ways to handle Optional chunks. Two simple approaches are: 5010 * - Completely ignore optional chunks, in which case the template for the 5011 * function "f" would only include the first parameter ("int x"). 5012 * - Fully expand all optional chunks, in which case the template for the 5013 * function "f" would have all of the parameters. 5014 */ 5015 CXCompletionChunk_Optional, 5016 /** 5017 * Text that a user would be expected to type to get this 5018 * code-completion result. 5019 * 5020 * There will be exactly one "typed text" chunk in a semantic string, which 5021 * will typically provide the spelling of a keyword or the name of a 5022 * declaration that could be used at the current code point. Clients are 5023 * expected to filter the code-completion results based on the text in this 5024 * chunk. 5025 */ 5026 CXCompletionChunk_TypedText, 5027 /** 5028 * Text that should be inserted as part of a code-completion result. 5029 * 5030 * A "text" chunk represents text that is part of the template to be 5031 * inserted into user code should this particular code-completion result 5032 * be selected. 5033 */ 5034 CXCompletionChunk_Text, 5035 /** 5036 * Placeholder text that should be replaced by the user. 5037 * 5038 * A "placeholder" chunk marks a place where the user should insert text 5039 * into the code-completion template. For example, placeholders might mark 5040 * the function parameters for a function declaration, to indicate that the 5041 * user should provide arguments for each of those parameters. The actual 5042 * text in a placeholder is a suggestion for the text to display before 5043 * the user replaces the placeholder with real code. 5044 */ 5045 CXCompletionChunk_Placeholder, 5046 /** 5047 * Informative text that should be displayed but never inserted as 5048 * part of the template. 5049 * 5050 * An "informative" chunk contains annotations that can be displayed to 5051 * help the user decide whether a particular code-completion result is the 5052 * right option, but which is not part of the actual template to be inserted 5053 * by code completion. 5054 */ 5055 CXCompletionChunk_Informative, 5056 /** 5057 * Text that describes the current parameter when code-completion is 5058 * referring to function call, message send, or template specialization. 5059 * 5060 * A "current parameter" chunk occurs when code-completion is providing 5061 * information about a parameter corresponding to the argument at the 5062 * code-completion point. For example, given a function 5063 * 5064 * \code 5065 * int add(int x, int y); 5066 * \endcode 5067 * 5068 * and the source code \c add(, where the code-completion point is after the 5069 * "(", the code-completion string will contain a "current parameter" chunk 5070 * for "int x", indicating that the current argument will initialize that 5071 * parameter. After typing further, to \c add(17, (where the code-completion 5072 * point is after the ","), the code-completion string will contain a 5073 * "current parameter" chunk to "int y". 5074 */ 5075 CXCompletionChunk_CurrentParameter, 5076 /** 5077 * A left parenthesis ('('), used to initiate a function call or 5078 * signal the beginning of a function parameter list. 5079 */ 5080 CXCompletionChunk_LeftParen, 5081 /** 5082 * A right parenthesis (')'), used to finish a function call or 5083 * signal the end of a function parameter list. 5084 */ 5085 CXCompletionChunk_RightParen, 5086 /** 5087 * A left bracket ('['). 5088 */ 5089 CXCompletionChunk_LeftBracket, 5090 /** 5091 * A right bracket (']'). 5092 */ 5093 CXCompletionChunk_RightBracket, 5094 /** 5095 * A left brace ('{'). 5096 */ 5097 CXCompletionChunk_LeftBrace, 5098 /** 5099 * A right brace ('}'). 5100 */ 5101 CXCompletionChunk_RightBrace, 5102 /** 5103 * A left angle bracket ('<'). 5104 */ 5105 CXCompletionChunk_LeftAngle, 5106 /** 5107 * A right angle bracket ('>'). 5108 */ 5109 CXCompletionChunk_RightAngle, 5110 /** 5111 * A comma separator (','). 5112 */ 5113 CXCompletionChunk_Comma, 5114 /** 5115 * Text that specifies the result type of a given result. 5116 * 5117 * This special kind of informative chunk is not meant to be inserted into 5118 * the text buffer. Rather, it is meant to illustrate the type that an 5119 * expression using the given completion string would have. 5120 */ 5121 CXCompletionChunk_ResultType, 5122 /** 5123 * A colon (':'). 5124 */ 5125 CXCompletionChunk_Colon, 5126 /** 5127 * A semicolon (';'). 5128 */ 5129 CXCompletionChunk_SemiColon, 5130 /** 5131 * An '=' sign. 5132 */ 5133 CXCompletionChunk_Equal, 5134 /** 5135 * Horizontal space (' '). 5136 */ 5137 CXCompletionChunk_HorizontalSpace, 5138 /** 5139 * Vertical space ('\\n'), after which it is generally a good idea to 5140 * perform indentation. 5141 */ 5142 CXCompletionChunk_VerticalSpace 5143 }; 5144 5145 /** 5146 * Determine the kind of a particular chunk within a completion string. 5147 * 5148 * \param completion_string the completion string to query. 5149 * 5150 * \param chunk_number the 0-based index of the chunk in the completion string. 5151 * 5152 * \returns the kind of the chunk at the index \c chunk_number. 5153 */ 5154 CINDEX_LINKAGE enum CXCompletionChunkKind 5155 clang_getCompletionChunkKind(CXCompletionString completion_string, 5156 unsigned chunk_number); 5157 5158 /** 5159 * Retrieve the text associated with a particular chunk within a 5160 * completion string. 5161 * 5162 * \param completion_string the completion string to query. 5163 * 5164 * \param chunk_number the 0-based index of the chunk in the completion string. 5165 * 5166 * \returns the text associated with the chunk at index \c chunk_number. 5167 */ 5168 CINDEX_LINKAGE CXString clang_getCompletionChunkText( 5169 CXCompletionString completion_string, unsigned chunk_number); 5170 5171 /** 5172 * Retrieve the completion string associated with a particular chunk 5173 * within a completion string. 5174 * 5175 * \param completion_string the completion string to query. 5176 * 5177 * \param chunk_number the 0-based index of the chunk in the completion string. 5178 * 5179 * \returns the completion string associated with the chunk at index 5180 * \c chunk_number. 5181 */ 5182 CINDEX_LINKAGE CXCompletionString clang_getCompletionChunkCompletionString( 5183 CXCompletionString completion_string, unsigned chunk_number); 5184 5185 /** 5186 * Retrieve the number of chunks in the given code-completion string. 5187 */ 5188 CINDEX_LINKAGE unsigned 5189 clang_getNumCompletionChunks(CXCompletionString completion_string); 5190 5191 /** 5192 * Determine the priority of this code completion. 5193 * 5194 * The priority of a code completion indicates how likely it is that this 5195 * particular completion is the completion that the user will select. The 5196 * priority is selected by various internal heuristics. 5197 * 5198 * \param completion_string The completion string to query. 5199 * 5200 * \returns The priority of this completion string. Smaller values indicate 5201 * higher-priority (more likely) completions. 5202 */ 5203 CINDEX_LINKAGE unsigned 5204 clang_getCompletionPriority(CXCompletionString completion_string); 5205 5206 /** 5207 * Determine the availability of the entity that this code-completion 5208 * string refers to. 5209 * 5210 * \param completion_string The completion string to query. 5211 * 5212 * \returns The availability of the completion string. 5213 */ 5214 CINDEX_LINKAGE enum CXAvailabilityKind 5215 clang_getCompletionAvailability(CXCompletionString completion_string); 5216 5217 /** 5218 * Retrieve the number of annotations associated with the given 5219 * completion string. 5220 * 5221 * \param completion_string the completion string to query. 5222 * 5223 * \returns the number of annotations associated with the given completion 5224 * string. 5225 */ 5226 CINDEX_LINKAGE unsigned 5227 clang_getCompletionNumAnnotations(CXCompletionString completion_string); 5228 5229 /** 5230 * Retrieve the annotation associated with the given completion string. 5231 * 5232 * \param completion_string the completion string to query. 5233 * 5234 * \param annotation_number the 0-based index of the annotation of the 5235 * completion string. 5236 * 5237 * \returns annotation string associated with the completion at index 5238 * \c annotation_number, or a NULL string if that annotation is not available. 5239 */ 5240 CINDEX_LINKAGE CXString clang_getCompletionAnnotation( 5241 CXCompletionString completion_string, unsigned annotation_number); 5242 5243 /** 5244 * Retrieve the parent context of the given completion string. 5245 * 5246 * The parent context of a completion string is the semantic parent of 5247 * the declaration (if any) that the code completion represents. For example, 5248 * a code completion for an Objective-C method would have the method's class 5249 * or protocol as its context. 5250 * 5251 * \param completion_string The code completion string whose parent is 5252 * being queried. 5253 * 5254 * \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL. 5255 * 5256 * \returns The name of the completion parent, e.g., "NSObject" if 5257 * the completion string represents a method in the NSObject class. 5258 */ 5259 CINDEX_LINKAGE CXString clang_getCompletionParent( 5260 CXCompletionString completion_string, enum CXCursorKind *kind); 5261 5262 /** 5263 * Retrieve the brief documentation comment attached to the declaration 5264 * that corresponds to the given completion string. 5265 */ 5266 CINDEX_LINKAGE CXString 5267 clang_getCompletionBriefComment(CXCompletionString completion_string); 5268 5269 /** 5270 * Retrieve a completion string for an arbitrary declaration or macro 5271 * definition cursor. 5272 * 5273 * \param cursor The cursor to query. 5274 * 5275 * \returns A non-context-sensitive completion string for declaration and macro 5276 * definition cursors, or NULL for other kinds of cursors. 5277 */ 5278 CINDEX_LINKAGE CXCompletionString 5279 clang_getCursorCompletionString(CXCursor cursor); 5280 5281 /** 5282 * Contains the results of code-completion. 5283 * 5284 * This data structure contains the results of code completion, as 5285 * produced by \c clang_codeCompleteAt(). Its contents must be freed by 5286 * \c clang_disposeCodeCompleteResults. 5287 */ 5288 typedef struct { 5289 /** 5290 * The code-completion results. 5291 */ 5292 CXCompletionResult *Results; 5293 5294 /** 5295 * The number of code-completion results stored in the 5296 * \c Results array. 5297 */ 5298 unsigned NumResults; 5299 } CXCodeCompleteResults; 5300 5301 /** 5302 * Retrieve the number of fix-its for the given completion index. 5303 * 5304 * Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts 5305 * option was set. 5306 * 5307 * \param results The structure keeping all completion results 5308 * 5309 * \param completion_index The index of the completion 5310 * 5311 * \return The number of fix-its which must be applied before the completion at 5312 * completion_index can be applied 5313 */ 5314 CINDEX_LINKAGE unsigned 5315 clang_getCompletionNumFixIts(CXCodeCompleteResults *results, 5316 unsigned completion_index); 5317 5318 /** 5319 * Fix-its that *must* be applied before inserting the text for the 5320 * corresponding completion. 5321 * 5322 * By default, clang_codeCompleteAt() only returns completions with empty 5323 * fix-its. Extra completions with non-empty fix-its should be explicitly 5324 * requested by setting CXCodeComplete_IncludeCompletionsWithFixIts. 5325 * 5326 * For the clients to be able to compute position of the cursor after applying 5327 * fix-its, the following conditions are guaranteed to hold for 5328 * replacement_range of the stored fix-its: 5329 * - Ranges in the fix-its are guaranteed to never contain the completion 5330 * point (or identifier under completion point, if any) inside them, except 5331 * at the start or at the end of the range. 5332 * - If a fix-it range starts or ends with completion point (or starts or 5333 * ends after the identifier under completion point), it will contain at 5334 * least one character. It allows to unambiguously recompute completion 5335 * point after applying the fix-it. 5336 * 5337 * The intuition is that provided fix-its change code around the identifier we 5338 * complete, but are not allowed to touch the identifier itself or the 5339 * completion point. One example of completions with corrections are the ones 5340 * replacing '.' with '->' and vice versa: 5341 * 5342 * std::unique_ptr<std::vector<int>> vec_ptr; 5343 * In 'vec_ptr.^', one of the completions is 'push_back', it requires 5344 * replacing '.' with '->'. 5345 * In 'vec_ptr->^', one of the completions is 'release', it requires 5346 * replacing '->' with '.'. 5347 * 5348 * \param results The structure keeping all completion results 5349 * 5350 * \param completion_index The index of the completion 5351 * 5352 * \param fixit_index The index of the fix-it for the completion at 5353 * completion_index 5354 * 5355 * \param replacement_range The fix-it range that must be replaced before the 5356 * completion at completion_index can be applied 5357 * 5358 * \returns The fix-it string that must replace the code at replacement_range 5359 * before the completion at completion_index can be applied 5360 */ 5361 CINDEX_LINKAGE CXString clang_getCompletionFixIt( 5362 CXCodeCompleteResults *results, unsigned completion_index, 5363 unsigned fixit_index, CXSourceRange *replacement_range); 5364 5365 /** 5366 * Flags that can be passed to \c clang_codeCompleteAt() to 5367 * modify its behavior. 5368 * 5369 * The enumerators in this enumeration can be bitwise-OR'd together to 5370 * provide multiple options to \c clang_codeCompleteAt(). 5371 */ 5372 enum CXCodeComplete_Flags { 5373 /** 5374 * Whether to include macros within the set of code 5375 * completions returned. 5376 */ 5377 CXCodeComplete_IncludeMacros = 0x01, 5378 5379 /** 5380 * Whether to include code patterns for language constructs 5381 * within the set of code completions, e.g., for loops. 5382 */ 5383 CXCodeComplete_IncludeCodePatterns = 0x02, 5384 5385 /** 5386 * Whether to include brief documentation within the set of code 5387 * completions returned. 5388 */ 5389 CXCodeComplete_IncludeBriefComments = 0x04, 5390 5391 /** 5392 * Whether to speed up completion by omitting top- or namespace-level entities 5393 * defined in the preamble. There's no guarantee any particular entity is 5394 * omitted. This may be useful if the headers are indexed externally. 5395 */ 5396 CXCodeComplete_SkipPreamble = 0x08, 5397 5398 /** 5399 * Whether to include completions with small 5400 * fix-its, e.g. change '.' to '->' on member access, etc. 5401 */ 5402 CXCodeComplete_IncludeCompletionsWithFixIts = 0x10 5403 }; 5404 5405 /** 5406 * Bits that represent the context under which completion is occurring. 5407 * 5408 * The enumerators in this enumeration may be bitwise-OR'd together if multiple 5409 * contexts are occurring simultaneously. 5410 */ 5411 enum CXCompletionContext { 5412 /** 5413 * The context for completions is unexposed, as only Clang results 5414 * should be included. (This is equivalent to having no context bits set.) 5415 */ 5416 CXCompletionContext_Unexposed = 0, 5417 5418 /** 5419 * Completions for any possible type should be included in the results. 5420 */ 5421 CXCompletionContext_AnyType = 1 << 0, 5422 5423 /** 5424 * Completions for any possible value (variables, function calls, etc.) 5425 * should be included in the results. 5426 */ 5427 CXCompletionContext_AnyValue = 1 << 1, 5428 /** 5429 * Completions for values that resolve to an Objective-C object should 5430 * be included in the results. 5431 */ 5432 CXCompletionContext_ObjCObjectValue = 1 << 2, 5433 /** 5434 * Completions for values that resolve to an Objective-C selector 5435 * should be included in the results. 5436 */ 5437 CXCompletionContext_ObjCSelectorValue = 1 << 3, 5438 /** 5439 * Completions for values that resolve to a C++ class type should be 5440 * included in the results. 5441 */ 5442 CXCompletionContext_CXXClassTypeValue = 1 << 4, 5443 5444 /** 5445 * Completions for fields of the member being accessed using the dot 5446 * operator should be included in the results. 5447 */ 5448 CXCompletionContext_DotMemberAccess = 1 << 5, 5449 /** 5450 * Completions for fields of the member being accessed using the arrow 5451 * operator should be included in the results. 5452 */ 5453 CXCompletionContext_ArrowMemberAccess = 1 << 6, 5454 /** 5455 * Completions for properties of the Objective-C object being accessed 5456 * using the dot operator should be included in the results. 5457 */ 5458 CXCompletionContext_ObjCPropertyAccess = 1 << 7, 5459 5460 /** 5461 * Completions for enum tags should be included in the results. 5462 */ 5463 CXCompletionContext_EnumTag = 1 << 8, 5464 /** 5465 * Completions for union tags should be included in the results. 5466 */ 5467 CXCompletionContext_UnionTag = 1 << 9, 5468 /** 5469 * Completions for struct tags should be included in the results. 5470 */ 5471 CXCompletionContext_StructTag = 1 << 10, 5472 5473 /** 5474 * Completions for C++ class names should be included in the results. 5475 */ 5476 CXCompletionContext_ClassTag = 1 << 11, 5477 /** 5478 * Completions for C++ namespaces and namespace aliases should be 5479 * included in the results. 5480 */ 5481 CXCompletionContext_Namespace = 1 << 12, 5482 /** 5483 * Completions for C++ nested name specifiers should be included in 5484 * the results. 5485 */ 5486 CXCompletionContext_NestedNameSpecifier = 1 << 13, 5487 5488 /** 5489 * Completions for Objective-C interfaces (classes) should be included 5490 * in the results. 5491 */ 5492 CXCompletionContext_ObjCInterface = 1 << 14, 5493 /** 5494 * Completions for Objective-C protocols should be included in 5495 * the results. 5496 */ 5497 CXCompletionContext_ObjCProtocol = 1 << 15, 5498 /** 5499 * Completions for Objective-C categories should be included in 5500 * the results. 5501 */ 5502 CXCompletionContext_ObjCCategory = 1 << 16, 5503 /** 5504 * Completions for Objective-C instance messages should be included 5505 * in the results. 5506 */ 5507 CXCompletionContext_ObjCInstanceMessage = 1 << 17, 5508 /** 5509 * Completions for Objective-C class messages should be included in 5510 * the results. 5511 */ 5512 CXCompletionContext_ObjCClassMessage = 1 << 18, 5513 /** 5514 * Completions for Objective-C selector names should be included in 5515 * the results. 5516 */ 5517 CXCompletionContext_ObjCSelectorName = 1 << 19, 5518 5519 /** 5520 * Completions for preprocessor macro names should be included in 5521 * the results. 5522 */ 5523 CXCompletionContext_MacroName = 1 << 20, 5524 5525 /** 5526 * Natural language completions should be included in the results. 5527 */ 5528 CXCompletionContext_NaturalLanguage = 1 << 21, 5529 5530 /** 5531 * #include file completions should be included in the results. 5532 */ 5533 CXCompletionContext_IncludedFile = 1 << 22, 5534 5535 /** 5536 * The current context is unknown, so set all contexts. 5537 */ 5538 CXCompletionContext_Unknown = ((1 << 23) - 1) 5539 }; 5540 5541 /** 5542 * Returns a default set of code-completion options that can be 5543 * passed to\c clang_codeCompleteAt(). 5544 */ 5545 CINDEX_LINKAGE unsigned clang_defaultCodeCompleteOptions(void); 5546 5547 /** 5548 * Perform code completion at a given location in a translation unit. 5549 * 5550 * This function performs code completion at a particular file, line, and 5551 * column within source code, providing results that suggest potential 5552 * code snippets based on the context of the completion. The basic model 5553 * for code completion is that Clang will parse a complete source file, 5554 * performing syntax checking up to the location where code-completion has 5555 * been requested. At that point, a special code-completion token is passed 5556 * to the parser, which recognizes this token and determines, based on the 5557 * current location in the C/Objective-C/C++ grammar and the state of 5558 * semantic analysis, what completions to provide. These completions are 5559 * returned via a new \c CXCodeCompleteResults structure. 5560 * 5561 * Code completion itself is meant to be triggered by the client when the 5562 * user types punctuation characters or whitespace, at which point the 5563 * code-completion location will coincide with the cursor. For example, if \c p 5564 * is a pointer, code-completion might be triggered after the "-" and then 5565 * after the ">" in \c p->. When the code-completion location is after the ">", 5566 * the completion results will provide, e.g., the members of the struct that 5567 * "p" points to. The client is responsible for placing the cursor at the 5568 * beginning of the token currently being typed, then filtering the results 5569 * based on the contents of the token. For example, when code-completing for 5570 * the expression \c p->get, the client should provide the location just after 5571 * the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the 5572 * client can filter the results based on the current token text ("get"), only 5573 * showing those results that start with "get". The intent of this interface 5574 * is to separate the relatively high-latency acquisition of code-completion 5575 * results from the filtering of results on a per-character basis, which must 5576 * have a lower latency. 5577 * 5578 * \param TU The translation unit in which code-completion should 5579 * occur. The source files for this translation unit need not be 5580 * completely up-to-date (and the contents of those source files may 5581 * be overridden via \p unsaved_files). Cursors referring into the 5582 * translation unit may be invalidated by this invocation. 5583 * 5584 * \param complete_filename The name of the source file where code 5585 * completion should be performed. This filename may be any file 5586 * included in the translation unit. 5587 * 5588 * \param complete_line The line at which code-completion should occur. 5589 * 5590 * \param complete_column The column at which code-completion should occur. 5591 * Note that the column should point just after the syntactic construct that 5592 * initiated code completion, and not in the middle of a lexical token. 5593 * 5594 * \param unsaved_files the Files that have not yet been saved to disk 5595 * but may be required for parsing or code completion, including the 5596 * contents of those files. The contents and name of these files (as 5597 * specified by CXUnsavedFile) are copied when necessary, so the 5598 * client only needs to guarantee their validity until the call to 5599 * this function returns. 5600 * 5601 * \param num_unsaved_files The number of unsaved file entries in \p 5602 * unsaved_files. 5603 * 5604 * \param options Extra options that control the behavior of code 5605 * completion, expressed as a bitwise OR of the enumerators of the 5606 * CXCodeComplete_Flags enumeration. The 5607 * \c clang_defaultCodeCompleteOptions() function returns a default set 5608 * of code-completion options. 5609 * 5610 * \returns If successful, a new \c CXCodeCompleteResults structure 5611 * containing code-completion results, which should eventually be 5612 * freed with \c clang_disposeCodeCompleteResults(). If code 5613 * completion fails, returns NULL. 5614 */ 5615 CINDEX_LINKAGE 5616 CXCodeCompleteResults * 5617 clang_codeCompleteAt(CXTranslationUnit TU, const char *complete_filename, 5618 unsigned complete_line, unsigned complete_column, 5619 struct CXUnsavedFile *unsaved_files, 5620 unsigned num_unsaved_files, unsigned options); 5621 5622 /** 5623 * Sort the code-completion results in case-insensitive alphabetical 5624 * order. 5625 * 5626 * \param Results The set of results to sort. 5627 * \param NumResults The number of results in \p Results. 5628 */ 5629 CINDEX_LINKAGE 5630 void clang_sortCodeCompletionResults(CXCompletionResult *Results, 5631 unsigned NumResults); 5632 5633 /** 5634 * Free the given set of code-completion results. 5635 */ 5636 CINDEX_LINKAGE 5637 void clang_disposeCodeCompleteResults(CXCodeCompleteResults *Results); 5638 5639 /** 5640 * Determine the number of diagnostics produced prior to the 5641 * location where code completion was performed. 5642 */ 5643 CINDEX_LINKAGE 5644 unsigned clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *Results); 5645 5646 /** 5647 * Retrieve a diagnostic associated with the given code completion. 5648 * 5649 * \param Results the code completion results to query. 5650 * \param Index the zero-based diagnostic number to retrieve. 5651 * 5652 * \returns the requested diagnostic. This diagnostic must be freed 5653 * via a call to \c clang_disposeDiagnostic(). 5654 */ 5655 CINDEX_LINKAGE 5656 CXDiagnostic clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *Results, 5657 unsigned Index); 5658 5659 /** 5660 * Determines what completions are appropriate for the context 5661 * the given code completion. 5662 * 5663 * \param Results the code completion results to query 5664 * 5665 * \returns the kinds of completions that are appropriate for use 5666 * along with the given code completion results. 5667 */ 5668 CINDEX_LINKAGE 5669 unsigned long long 5670 clang_codeCompleteGetContexts(CXCodeCompleteResults *Results); 5671 5672 /** 5673 * Returns the cursor kind for the container for the current code 5674 * completion context. The container is only guaranteed to be set for 5675 * contexts where a container exists (i.e. member accesses or Objective-C 5676 * message sends); if there is not a container, this function will return 5677 * CXCursor_InvalidCode. 5678 * 5679 * \param Results the code completion results to query 5680 * 5681 * \param IsIncomplete on return, this value will be false if Clang has complete 5682 * information about the container. If Clang does not have complete 5683 * information, this value will be true. 5684 * 5685 * \returns the container kind, or CXCursor_InvalidCode if there is not a 5686 * container 5687 */ 5688 CINDEX_LINKAGE 5689 enum CXCursorKind 5690 clang_codeCompleteGetContainerKind(CXCodeCompleteResults *Results, 5691 unsigned *IsIncomplete); 5692 5693 /** 5694 * Returns the USR for the container for the current code completion 5695 * context. If there is not a container for the current context, this 5696 * function will return the empty string. 5697 * 5698 * \param Results the code completion results to query 5699 * 5700 * \returns the USR for the container 5701 */ 5702 CINDEX_LINKAGE 5703 CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *Results); 5704 5705 /** 5706 * Returns the currently-entered selector for an Objective-C message 5707 * send, formatted like "initWithFoo:bar:". Only guaranteed to return a 5708 * non-empty string for CXCompletionContext_ObjCInstanceMessage and 5709 * CXCompletionContext_ObjCClassMessage. 5710 * 5711 * \param Results the code completion results to query 5712 * 5713 * \returns the selector (or partial selector) that has been entered thus far 5714 * for an Objective-C message send. 5715 */ 5716 CINDEX_LINKAGE 5717 CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *Results); 5718 5719 /** 5720 * @} 5721 */ 5722 5723 /** 5724 * \defgroup CINDEX_MISC Miscellaneous utility functions 5725 * 5726 * @{ 5727 */ 5728 5729 /** 5730 * Return a version string, suitable for showing to a user, but not 5731 * intended to be parsed (the format is not guaranteed to be stable). 5732 */ 5733 CINDEX_LINKAGE CXString clang_getClangVersion(void); 5734 5735 /** 5736 * Enable/disable crash recovery. 5737 * 5738 * \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero 5739 * value enables crash recovery, while 0 disables it. 5740 */ 5741 CINDEX_LINKAGE void clang_toggleCrashRecovery(unsigned isEnabled); 5742 5743 /** 5744 * Visitor invoked for each file in a translation unit 5745 * (used with clang_getInclusions()). 5746 * 5747 * This visitor function will be invoked by clang_getInclusions() for each 5748 * file included (either at the top-level or by \#include directives) within 5749 * a translation unit. The first argument is the file being included, and 5750 * the second and third arguments provide the inclusion stack. The 5751 * array is sorted in order of immediate inclusion. For example, 5752 * the first element refers to the location that included 'included_file'. 5753 */ 5754 typedef void (*CXInclusionVisitor)(CXFile included_file, 5755 CXSourceLocation *inclusion_stack, 5756 unsigned include_len, 5757 CXClientData client_data); 5758 5759 /** 5760 * Visit the set of preprocessor inclusions in a translation unit. 5761 * The visitor function is called with the provided data for every included 5762 * file. This does not include headers included by the PCH file (unless one 5763 * is inspecting the inclusions in the PCH file itself). 5764 */ 5765 CINDEX_LINKAGE void clang_getInclusions(CXTranslationUnit tu, 5766 CXInclusionVisitor visitor, 5767 CXClientData client_data); 5768 5769 typedef enum { 5770 CXEval_Int = 1, 5771 CXEval_Float = 2, 5772 CXEval_ObjCStrLiteral = 3, 5773 CXEval_StrLiteral = 4, 5774 CXEval_CFStr = 5, 5775 CXEval_Other = 6, 5776 5777 CXEval_UnExposed = 0 5778 5779 } CXEvalResultKind; 5780 5781 /** 5782 * Evaluation result of a cursor 5783 */ 5784 typedef void *CXEvalResult; 5785 5786 /** 5787 * If cursor is a statement declaration tries to evaluate the 5788 * statement and if its variable, tries to evaluate its initializer, 5789 * into its corresponding type. 5790 * If it's an expression, tries to evaluate the expression. 5791 */ 5792 CINDEX_LINKAGE CXEvalResult clang_Cursor_Evaluate(CXCursor C); 5793 5794 /** 5795 * Returns the kind of the evaluated result. 5796 */ 5797 CINDEX_LINKAGE CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E); 5798 5799 /** 5800 * Returns the evaluation result as integer if the 5801 * kind is Int. 5802 */ 5803 CINDEX_LINKAGE int clang_EvalResult_getAsInt(CXEvalResult E); 5804 5805 /** 5806 * Returns the evaluation result as a long long integer if the 5807 * kind is Int. This prevents overflows that may happen if the result is 5808 * returned with clang_EvalResult_getAsInt. 5809 */ 5810 CINDEX_LINKAGE long long clang_EvalResult_getAsLongLong(CXEvalResult E); 5811 5812 /** 5813 * Returns a non-zero value if the kind is Int and the evaluation 5814 * result resulted in an unsigned integer. 5815 */ 5816 CINDEX_LINKAGE unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E); 5817 5818 /** 5819 * Returns the evaluation result as an unsigned integer if 5820 * the kind is Int and clang_EvalResult_isUnsignedInt is non-zero. 5821 */ 5822 CINDEX_LINKAGE unsigned long long 5823 clang_EvalResult_getAsUnsigned(CXEvalResult E); 5824 5825 /** 5826 * Returns the evaluation result as double if the 5827 * kind is double. 5828 */ 5829 CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E); 5830 5831 /** 5832 * Returns the evaluation result as a constant string if the 5833 * kind is other than Int or float. User must not free this pointer, 5834 * instead call clang_EvalResult_dispose on the CXEvalResult returned 5835 * by clang_Cursor_Evaluate. 5836 */ 5837 CINDEX_LINKAGE const char *clang_EvalResult_getAsStr(CXEvalResult E); 5838 5839 /** 5840 * Disposes the created Eval memory. 5841 */ 5842 CINDEX_LINKAGE void clang_EvalResult_dispose(CXEvalResult E); 5843 /** 5844 * @} 5845 */ 5846 5847 /** \defgroup CINDEX_REMAPPING Remapping functions 5848 * 5849 * @{ 5850 */ 5851 5852 /** 5853 * A remapping of original source files and their translated files. 5854 */ 5855 typedef void *CXRemapping; 5856 5857 /** 5858 * Retrieve a remapping. 5859 * 5860 * \param path the path that contains metadata about remappings. 5861 * 5862 * \returns the requested remapping. This remapping must be freed 5863 * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. 5864 */ 5865 CINDEX_LINKAGE CXRemapping clang_getRemappings(const char *path); 5866 5867 /** 5868 * Retrieve a remapping. 5869 * 5870 * \param filePaths pointer to an array of file paths containing remapping info. 5871 * 5872 * \param numFiles number of file paths. 5873 * 5874 * \returns the requested remapping. This remapping must be freed 5875 * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred. 5876 */ 5877 CINDEX_LINKAGE 5878 CXRemapping clang_getRemappingsFromFileList(const char **filePaths, 5879 unsigned numFiles); 5880 5881 /** 5882 * Determine the number of remappings. 5883 */ 5884 CINDEX_LINKAGE unsigned clang_remap_getNumFiles(CXRemapping); 5885 5886 /** 5887 * Get the original and the associated filename from the remapping. 5888 * 5889 * \param original If non-NULL, will be set to the original filename. 5890 * 5891 * \param transformed If non-NULL, will be set to the filename that the original 5892 * is associated with. 5893 */ 5894 CINDEX_LINKAGE void clang_remap_getFilenames(CXRemapping, unsigned index, 5895 CXString *original, 5896 CXString *transformed); 5897 5898 /** 5899 * Dispose the remapping. 5900 */ 5901 CINDEX_LINKAGE void clang_remap_dispose(CXRemapping); 5902 5903 /** 5904 * @} 5905 */ 5906 5907 /** \defgroup CINDEX_HIGH Higher level API functions 5908 * 5909 * @{ 5910 */ 5911 5912 enum CXVisitorResult { CXVisit_Break, CXVisit_Continue }; 5913 5914 typedef struct CXCursorAndRangeVisitor { 5915 void *context; 5916 enum CXVisitorResult (*visit)(void *context, CXCursor, CXSourceRange); 5917 } CXCursorAndRangeVisitor; 5918 5919 typedef enum { 5920 /** 5921 * Function returned successfully. 5922 */ 5923 CXResult_Success = 0, 5924 /** 5925 * One of the parameters was invalid for the function. 5926 */ 5927 CXResult_Invalid = 1, 5928 /** 5929 * The function was terminated by a callback (e.g. it returned 5930 * CXVisit_Break) 5931 */ 5932 CXResult_VisitBreak = 2 5933 5934 } CXResult; 5935 5936 /** 5937 * Find references of a declaration in a specific file. 5938 * 5939 * \param cursor pointing to a declaration or a reference of one. 5940 * 5941 * \param file to search for references. 5942 * 5943 * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for 5944 * each reference found. 5945 * The CXSourceRange will point inside the file; if the reference is inside 5946 * a macro (and not a macro argument) the CXSourceRange will be invalid. 5947 * 5948 * \returns one of the CXResult enumerators. 5949 */ 5950 CINDEX_LINKAGE CXResult clang_findReferencesInFile( 5951 CXCursor cursor, CXFile file, CXCursorAndRangeVisitor visitor); 5952 5953 /** 5954 * Find #import/#include directives in a specific file. 5955 * 5956 * \param TU translation unit containing the file to query. 5957 * 5958 * \param file to search for #import/#include directives. 5959 * 5960 * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for 5961 * each directive found. 5962 * 5963 * \returns one of the CXResult enumerators. 5964 */ 5965 CINDEX_LINKAGE CXResult clang_findIncludesInFile( 5966 CXTranslationUnit TU, CXFile file, CXCursorAndRangeVisitor visitor); 5967 5968 #if __has_feature(blocks) 5969 typedef enum CXVisitorResult (^CXCursorAndRangeVisitorBlock)(CXCursor, 5970 CXSourceRange); 5971 #else 5972 typedef struct _CXCursorAndRangeVisitorBlock *CXCursorAndRangeVisitorBlock; 5973 #endif 5974 5975 CINDEX_LINKAGE 5976 CXResult clang_findReferencesInFileWithBlock(CXCursor, CXFile, 5977 CXCursorAndRangeVisitorBlock); 5978 5979 CINDEX_LINKAGE 5980 CXResult clang_findIncludesInFileWithBlock(CXTranslationUnit, CXFile, 5981 CXCursorAndRangeVisitorBlock); 5982 5983 /** 5984 * The client's data object that is associated with a CXFile. 5985 */ 5986 typedef void *CXIdxClientFile; 5987 5988 /** 5989 * The client's data object that is associated with a semantic entity. 5990 */ 5991 typedef void *CXIdxClientEntity; 5992 5993 /** 5994 * The client's data object that is associated with a semantic container 5995 * of entities. 5996 */ 5997 typedef void *CXIdxClientContainer; 5998 5999 /** 6000 * The client's data object that is associated with an AST file (PCH 6001 * or module). 6002 */ 6003 typedef void *CXIdxClientASTFile; 6004 6005 /** 6006 * Source location passed to index callbacks. 6007 */ 6008 typedef struct { 6009 void *ptr_data[2]; 6010 unsigned int_data; 6011 } CXIdxLoc; 6012 6013 /** 6014 * Data for ppIncludedFile callback. 6015 */ 6016 typedef struct { 6017 /** 6018 * Location of '#' in the \#include/\#import directive. 6019 */ 6020 CXIdxLoc hashLoc; 6021 /** 6022 * Filename as written in the \#include/\#import directive. 6023 */ 6024 const char *filename; 6025 /** 6026 * The actual file that the \#include/\#import directive resolved to. 6027 */ 6028 CXFile file; 6029 int isImport; 6030 int isAngled; 6031 /** 6032 * Non-zero if the directive was automatically turned into a module 6033 * import. 6034 */ 6035 int isModuleImport; 6036 } CXIdxIncludedFileInfo; 6037 6038 /** 6039 * Data for IndexerCallbacks#importedASTFile. 6040 */ 6041 typedef struct { 6042 /** 6043 * Top level AST file containing the imported PCH, module or submodule. 6044 */ 6045 CXFile file; 6046 /** 6047 * The imported module or NULL if the AST file is a PCH. 6048 */ 6049 CXModule module; 6050 /** 6051 * Location where the file is imported. Applicable only for modules. 6052 */ 6053 CXIdxLoc loc; 6054 /** 6055 * Non-zero if an inclusion directive was automatically turned into 6056 * a module import. Applicable only for modules. 6057 */ 6058 int isImplicit; 6059 6060 } CXIdxImportedASTFileInfo; 6061 6062 typedef enum { 6063 CXIdxEntity_Unexposed = 0, 6064 CXIdxEntity_Typedef = 1, 6065 CXIdxEntity_Function = 2, 6066 CXIdxEntity_Variable = 3, 6067 CXIdxEntity_Field = 4, 6068 CXIdxEntity_EnumConstant = 5, 6069 6070 CXIdxEntity_ObjCClass = 6, 6071 CXIdxEntity_ObjCProtocol = 7, 6072 CXIdxEntity_ObjCCategory = 8, 6073 6074 CXIdxEntity_ObjCInstanceMethod = 9, 6075 CXIdxEntity_ObjCClassMethod = 10, 6076 CXIdxEntity_ObjCProperty = 11, 6077 CXIdxEntity_ObjCIvar = 12, 6078 6079 CXIdxEntity_Enum = 13, 6080 CXIdxEntity_Struct = 14, 6081 CXIdxEntity_Union = 15, 6082 6083 CXIdxEntity_CXXClass = 16, 6084 CXIdxEntity_CXXNamespace = 17, 6085 CXIdxEntity_CXXNamespaceAlias = 18, 6086 CXIdxEntity_CXXStaticVariable = 19, 6087 CXIdxEntity_CXXStaticMethod = 20, 6088 CXIdxEntity_CXXInstanceMethod = 21, 6089 CXIdxEntity_CXXConstructor = 22, 6090 CXIdxEntity_CXXDestructor = 23, 6091 CXIdxEntity_CXXConversionFunction = 24, 6092 CXIdxEntity_CXXTypeAlias = 25, 6093 CXIdxEntity_CXXInterface = 26, 6094 CXIdxEntity_CXXConcept = 27 6095 6096 } CXIdxEntityKind; 6097 6098 typedef enum { 6099 CXIdxEntityLang_None = 0, 6100 CXIdxEntityLang_C = 1, 6101 CXIdxEntityLang_ObjC = 2, 6102 CXIdxEntityLang_CXX = 3, 6103 CXIdxEntityLang_Swift = 4 6104 } CXIdxEntityLanguage; 6105 6106 /** 6107 * Extra C++ template information for an entity. This can apply to: 6108 * CXIdxEntity_Function 6109 * CXIdxEntity_CXXClass 6110 * CXIdxEntity_CXXStaticMethod 6111 * CXIdxEntity_CXXInstanceMethod 6112 * CXIdxEntity_CXXConstructor 6113 * CXIdxEntity_CXXConversionFunction 6114 * CXIdxEntity_CXXTypeAlias 6115 */ 6116 typedef enum { 6117 CXIdxEntity_NonTemplate = 0, 6118 CXIdxEntity_Template = 1, 6119 CXIdxEntity_TemplatePartialSpecialization = 2, 6120 CXIdxEntity_TemplateSpecialization = 3 6121 } CXIdxEntityCXXTemplateKind; 6122 6123 typedef enum { 6124 CXIdxAttr_Unexposed = 0, 6125 CXIdxAttr_IBAction = 1, 6126 CXIdxAttr_IBOutlet = 2, 6127 CXIdxAttr_IBOutletCollection = 3 6128 } CXIdxAttrKind; 6129 6130 typedef struct { 6131 CXIdxAttrKind kind; 6132 CXCursor cursor; 6133 CXIdxLoc loc; 6134 } CXIdxAttrInfo; 6135 6136 typedef struct { 6137 CXIdxEntityKind kind; 6138 CXIdxEntityCXXTemplateKind templateKind; 6139 CXIdxEntityLanguage lang; 6140 const char *name; 6141 const char *USR; 6142 CXCursor cursor; 6143 const CXIdxAttrInfo *const *attributes; 6144 unsigned numAttributes; 6145 } CXIdxEntityInfo; 6146 6147 typedef struct { 6148 CXCursor cursor; 6149 } CXIdxContainerInfo; 6150 6151 typedef struct { 6152 const CXIdxAttrInfo *attrInfo; 6153 const CXIdxEntityInfo *objcClass; 6154 CXCursor classCursor; 6155 CXIdxLoc classLoc; 6156 } CXIdxIBOutletCollectionAttrInfo; 6157 6158 typedef enum { CXIdxDeclFlag_Skipped = 0x1 } CXIdxDeclInfoFlags; 6159 6160 typedef struct { 6161 const CXIdxEntityInfo *entityInfo; 6162 CXCursor cursor; 6163 CXIdxLoc loc; 6164 const CXIdxContainerInfo *semanticContainer; 6165 /** 6166 * Generally same as #semanticContainer but can be different in 6167 * cases like out-of-line C++ member functions. 6168 */ 6169 const CXIdxContainerInfo *lexicalContainer; 6170 int isRedeclaration; 6171 int isDefinition; 6172 int isContainer; 6173 const CXIdxContainerInfo *declAsContainer; 6174 /** 6175 * Whether the declaration exists in code or was created implicitly 6176 * by the compiler, e.g. implicit Objective-C methods for properties. 6177 */ 6178 int isImplicit; 6179 const CXIdxAttrInfo *const *attributes; 6180 unsigned numAttributes; 6181 6182 unsigned flags; 6183 6184 } CXIdxDeclInfo; 6185 6186 typedef enum { 6187 CXIdxObjCContainer_ForwardRef = 0, 6188 CXIdxObjCContainer_Interface = 1, 6189 CXIdxObjCContainer_Implementation = 2 6190 } CXIdxObjCContainerKind; 6191 6192 typedef struct { 6193 const CXIdxDeclInfo *declInfo; 6194 CXIdxObjCContainerKind kind; 6195 } CXIdxObjCContainerDeclInfo; 6196 6197 typedef struct { 6198 const CXIdxEntityInfo *base; 6199 CXCursor cursor; 6200 CXIdxLoc loc; 6201 } CXIdxBaseClassInfo; 6202 6203 typedef struct { 6204 const CXIdxEntityInfo *protocol; 6205 CXCursor cursor; 6206 CXIdxLoc loc; 6207 } CXIdxObjCProtocolRefInfo; 6208 6209 typedef struct { 6210 const CXIdxObjCProtocolRefInfo *const *protocols; 6211 unsigned numProtocols; 6212 } CXIdxObjCProtocolRefListInfo; 6213 6214 typedef struct { 6215 const CXIdxObjCContainerDeclInfo *containerInfo; 6216 const CXIdxBaseClassInfo *superInfo; 6217 const CXIdxObjCProtocolRefListInfo *protocols; 6218 } CXIdxObjCInterfaceDeclInfo; 6219 6220 typedef struct { 6221 const CXIdxObjCContainerDeclInfo *containerInfo; 6222 const CXIdxEntityInfo *objcClass; 6223 CXCursor classCursor; 6224 CXIdxLoc classLoc; 6225 const CXIdxObjCProtocolRefListInfo *protocols; 6226 } CXIdxObjCCategoryDeclInfo; 6227 6228 typedef struct { 6229 const CXIdxDeclInfo *declInfo; 6230 const CXIdxEntityInfo *getter; 6231 const CXIdxEntityInfo *setter; 6232 } CXIdxObjCPropertyDeclInfo; 6233 6234 typedef struct { 6235 const CXIdxDeclInfo *declInfo; 6236 const CXIdxBaseClassInfo *const *bases; 6237 unsigned numBases; 6238 } CXIdxCXXClassDeclInfo; 6239 6240 /** 6241 * Data for IndexerCallbacks#indexEntityReference. 6242 * 6243 * This may be deprecated in a future version as this duplicates 6244 * the \c CXSymbolRole_Implicit bit in \c CXSymbolRole. 6245 */ 6246 typedef enum { 6247 /** 6248 * The entity is referenced directly in user's code. 6249 */ 6250 CXIdxEntityRef_Direct = 1, 6251 /** 6252 * An implicit reference, e.g. a reference of an Objective-C method 6253 * via the dot syntax. 6254 */ 6255 CXIdxEntityRef_Implicit = 2 6256 } CXIdxEntityRefKind; 6257 6258 /** 6259 * Roles that are attributed to symbol occurrences. 6260 * 6261 * Internal: this currently mirrors low 9 bits of clang::index::SymbolRole with 6262 * higher bits zeroed. These high bits may be exposed in the future. 6263 */ 6264 typedef enum { 6265 CXSymbolRole_None = 0, 6266 CXSymbolRole_Declaration = 1 << 0, 6267 CXSymbolRole_Definition = 1 << 1, 6268 CXSymbolRole_Reference = 1 << 2, 6269 CXSymbolRole_Read = 1 << 3, 6270 CXSymbolRole_Write = 1 << 4, 6271 CXSymbolRole_Call = 1 << 5, 6272 CXSymbolRole_Dynamic = 1 << 6, 6273 CXSymbolRole_AddressOf = 1 << 7, 6274 CXSymbolRole_Implicit = 1 << 8 6275 } CXSymbolRole; 6276 6277 /** 6278 * Data for IndexerCallbacks#indexEntityReference. 6279 */ 6280 typedef struct { 6281 CXIdxEntityRefKind kind; 6282 /** 6283 * Reference cursor. 6284 */ 6285 CXCursor cursor; 6286 CXIdxLoc loc; 6287 /** 6288 * The entity that gets referenced. 6289 */ 6290 const CXIdxEntityInfo *referencedEntity; 6291 /** 6292 * Immediate "parent" of the reference. For example: 6293 * 6294 * \code 6295 * Foo *var; 6296 * \endcode 6297 * 6298 * The parent of reference of type 'Foo' is the variable 'var'. 6299 * For references inside statement bodies of functions/methods, 6300 * the parentEntity will be the function/method. 6301 */ 6302 const CXIdxEntityInfo *parentEntity; 6303 /** 6304 * Lexical container context of the reference. 6305 */ 6306 const CXIdxContainerInfo *container; 6307 /** 6308 * Sets of symbol roles of the reference. 6309 */ 6310 CXSymbolRole role; 6311 } CXIdxEntityRefInfo; 6312 6313 /** 6314 * A group of callbacks used by #clang_indexSourceFile and 6315 * #clang_indexTranslationUnit. 6316 */ 6317 typedef struct { 6318 /** 6319 * Called periodically to check whether indexing should be aborted. 6320 * Should return 0 to continue, and non-zero to abort. 6321 */ 6322 int (*abortQuery)(CXClientData client_data, void *reserved); 6323 6324 /** 6325 * Called at the end of indexing; passes the complete diagnostic set. 6326 */ 6327 void (*diagnostic)(CXClientData client_data, CXDiagnosticSet, void *reserved); 6328 6329 CXIdxClientFile (*enteredMainFile)(CXClientData client_data, CXFile mainFile, 6330 void *reserved); 6331 6332 /** 6333 * Called when a file gets \#included/\#imported. 6334 */ 6335 CXIdxClientFile (*ppIncludedFile)(CXClientData client_data, 6336 const CXIdxIncludedFileInfo *); 6337 6338 /** 6339 * Called when a AST file (PCH or module) gets imported. 6340 * 6341 * AST files will not get indexed (there will not be callbacks to index all 6342 * the entities in an AST file). The recommended action is that, if the AST 6343 * file is not already indexed, to initiate a new indexing job specific to 6344 * the AST file. 6345 */ 6346 CXIdxClientASTFile (*importedASTFile)(CXClientData client_data, 6347 const CXIdxImportedASTFileInfo *); 6348 6349 /** 6350 * Called at the beginning of indexing a translation unit. 6351 */ 6352 CXIdxClientContainer (*startedTranslationUnit)(CXClientData client_data, 6353 void *reserved); 6354 6355 void (*indexDeclaration)(CXClientData client_data, const CXIdxDeclInfo *); 6356 6357 /** 6358 * Called to index a reference of an entity. 6359 */ 6360 void (*indexEntityReference)(CXClientData client_data, 6361 const CXIdxEntityRefInfo *); 6362 6363 } IndexerCallbacks; 6364 6365 CINDEX_LINKAGE int clang_index_isEntityObjCContainerKind(CXIdxEntityKind); 6366 CINDEX_LINKAGE const CXIdxObjCContainerDeclInfo * 6367 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *); 6368 6369 CINDEX_LINKAGE const CXIdxObjCInterfaceDeclInfo * 6370 clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *); 6371 6372 CINDEX_LINKAGE 6373 const CXIdxObjCCategoryDeclInfo * 6374 clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *); 6375 6376 CINDEX_LINKAGE const CXIdxObjCProtocolRefListInfo * 6377 clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *); 6378 6379 CINDEX_LINKAGE const CXIdxObjCPropertyDeclInfo * 6380 clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *); 6381 6382 CINDEX_LINKAGE const CXIdxIBOutletCollectionAttrInfo * 6383 clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *); 6384 6385 CINDEX_LINKAGE const CXIdxCXXClassDeclInfo * 6386 clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *); 6387 6388 /** 6389 * For retrieving a custom CXIdxClientContainer attached to a 6390 * container. 6391 */ 6392 CINDEX_LINKAGE CXIdxClientContainer 6393 clang_index_getClientContainer(const CXIdxContainerInfo *); 6394 6395 /** 6396 * For setting a custom CXIdxClientContainer attached to a 6397 * container. 6398 */ 6399 CINDEX_LINKAGE void clang_index_setClientContainer(const CXIdxContainerInfo *, 6400 CXIdxClientContainer); 6401 6402 /** 6403 * For retrieving a custom CXIdxClientEntity attached to an entity. 6404 */ 6405 CINDEX_LINKAGE CXIdxClientEntity 6406 clang_index_getClientEntity(const CXIdxEntityInfo *); 6407 6408 /** 6409 * For setting a custom CXIdxClientEntity attached to an entity. 6410 */ 6411 CINDEX_LINKAGE void clang_index_setClientEntity(const CXIdxEntityInfo *, 6412 CXIdxClientEntity); 6413 6414 /** 6415 * An indexing action/session, to be applied to one or multiple 6416 * translation units. 6417 */ 6418 typedef void *CXIndexAction; 6419 6420 /** 6421 * An indexing action/session, to be applied to one or multiple 6422 * translation units. 6423 * 6424 * \param CIdx The index object with which the index action will be associated. 6425 */ 6426 CINDEX_LINKAGE CXIndexAction clang_IndexAction_create(CXIndex CIdx); 6427 6428 /** 6429 * Destroy the given index action. 6430 * 6431 * The index action must not be destroyed until all of the translation units 6432 * created within that index action have been destroyed. 6433 */ 6434 CINDEX_LINKAGE void clang_IndexAction_dispose(CXIndexAction); 6435 6436 typedef enum { 6437 /** 6438 * Used to indicate that no special indexing options are needed. 6439 */ 6440 CXIndexOpt_None = 0x0, 6441 6442 /** 6443 * Used to indicate that IndexerCallbacks#indexEntityReference should 6444 * be invoked for only one reference of an entity per source file that does 6445 * not also include a declaration/definition of the entity. 6446 */ 6447 CXIndexOpt_SuppressRedundantRefs = 0x1, 6448 6449 /** 6450 * Function-local symbols should be indexed. If this is not set 6451 * function-local symbols will be ignored. 6452 */ 6453 CXIndexOpt_IndexFunctionLocalSymbols = 0x2, 6454 6455 /** 6456 * Implicit function/class template instantiations should be indexed. 6457 * If this is not set, implicit instantiations will be ignored. 6458 */ 6459 CXIndexOpt_IndexImplicitTemplateInstantiations = 0x4, 6460 6461 /** 6462 * Suppress all compiler warnings when parsing for indexing. 6463 */ 6464 CXIndexOpt_SuppressWarnings = 0x8, 6465 6466 /** 6467 * Skip a function/method body that was already parsed during an 6468 * indexing session associated with a \c CXIndexAction object. 6469 * Bodies in system headers are always skipped. 6470 */ 6471 CXIndexOpt_SkipParsedBodiesInSession = 0x10 6472 6473 } CXIndexOptFlags; 6474 6475 /** 6476 * Index the given source file and the translation unit corresponding 6477 * to that file via callbacks implemented through #IndexerCallbacks. 6478 * 6479 * \param client_data pointer data supplied by the client, which will 6480 * be passed to the invoked callbacks. 6481 * 6482 * \param index_callbacks Pointer to indexing callbacks that the client 6483 * implements. 6484 * 6485 * \param index_callbacks_size Size of #IndexerCallbacks structure that gets 6486 * passed in index_callbacks. 6487 * 6488 * \param index_options A bitmask of options that affects how indexing is 6489 * performed. This should be a bitwise OR of the CXIndexOpt_XXX flags. 6490 * 6491 * \param[out] out_TU pointer to store a \c CXTranslationUnit that can be 6492 * reused after indexing is finished. Set to \c NULL if you do not require it. 6493 * 6494 * \returns 0 on success or if there were errors from which the compiler could 6495 * recover. If there is a failure from which there is no recovery, returns 6496 * a non-zero \c CXErrorCode. 6497 * 6498 * The rest of the parameters are the same as #clang_parseTranslationUnit. 6499 */ 6500 CINDEX_LINKAGE int clang_indexSourceFile( 6501 CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, 6502 unsigned index_callbacks_size, unsigned index_options, 6503 const char *source_filename, const char *const *command_line_args, 6504 int num_command_line_args, struct CXUnsavedFile *unsaved_files, 6505 unsigned num_unsaved_files, CXTranslationUnit *out_TU, unsigned TU_options); 6506 6507 /** 6508 * Same as clang_indexSourceFile but requires a full command line 6509 * for \c command_line_args including argv[0]. This is useful if the standard 6510 * library paths are relative to the binary. 6511 */ 6512 CINDEX_LINKAGE int clang_indexSourceFileFullArgv( 6513 CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, 6514 unsigned index_callbacks_size, unsigned index_options, 6515 const char *source_filename, const char *const *command_line_args, 6516 int num_command_line_args, struct CXUnsavedFile *unsaved_files, 6517 unsigned num_unsaved_files, CXTranslationUnit *out_TU, unsigned TU_options); 6518 6519 /** 6520 * Index the given translation unit via callbacks implemented through 6521 * #IndexerCallbacks. 6522 * 6523 * The order of callback invocations is not guaranteed to be the same as 6524 * when indexing a source file. The high level order will be: 6525 * 6526 * -Preprocessor callbacks invocations 6527 * -Declaration/reference callbacks invocations 6528 * -Diagnostic callback invocations 6529 * 6530 * The parameters are the same as #clang_indexSourceFile. 6531 * 6532 * \returns If there is a failure from which there is no recovery, returns 6533 * non-zero, otherwise returns 0. 6534 */ 6535 CINDEX_LINKAGE int clang_indexTranslationUnit( 6536 CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks, 6537 unsigned index_callbacks_size, unsigned index_options, CXTranslationUnit); 6538 6539 /** 6540 * Retrieve the CXIdxFile, file, line, column, and offset represented by 6541 * the given CXIdxLoc. 6542 * 6543 * If the location refers into a macro expansion, retrieves the 6544 * location of the macro expansion and if it refers into a macro argument 6545 * retrieves the location of the argument. 6546 */ 6547 CINDEX_LINKAGE void clang_indexLoc_getFileLocation(CXIdxLoc loc, 6548 CXIdxClientFile *indexFile, 6549 CXFile *file, unsigned *line, 6550 unsigned *column, 6551 unsigned *offset); 6552 6553 /** 6554 * Retrieve the CXSourceLocation represented by the given CXIdxLoc. 6555 */ 6556 CINDEX_LINKAGE 6557 CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc loc); 6558 6559 /** 6560 * Visitor invoked for each field found by a traversal. 6561 * 6562 * This visitor function will be invoked for each field found by 6563 * \c clang_Type_visitFields. Its first argument is the cursor being 6564 * visited, its second argument is the client data provided to 6565 * \c clang_Type_visitFields. 6566 * 6567 * The visitor should return one of the \c CXVisitorResult values 6568 * to direct \c clang_Type_visitFields. 6569 */ 6570 typedef enum CXVisitorResult (*CXFieldVisitor)(CXCursor C, 6571 CXClientData client_data); 6572 6573 /** 6574 * Visit the fields of a particular type. 6575 * 6576 * This function visits all the direct fields of the given cursor, 6577 * invoking the given \p visitor function with the cursors of each 6578 * visited field. The traversal may be ended prematurely, if 6579 * the visitor returns \c CXFieldVisit_Break. 6580 * 6581 * \param T the record type whose field may be visited. 6582 * 6583 * \param visitor the visitor function that will be invoked for each 6584 * field of \p T. 6585 * 6586 * \param client_data pointer data supplied by the client, which will 6587 * be passed to the visitor each time it is invoked. 6588 * 6589 * \returns a non-zero value if the traversal was terminated 6590 * prematurely by the visitor returning \c CXFieldVisit_Break. 6591 */ 6592 CINDEX_LINKAGE unsigned clang_Type_visitFields(CXType T, CXFieldVisitor visitor, 6593 CXClientData client_data); 6594 6595 /** 6596 * Describes the kind of binary operators. 6597 */ 6598 enum CXBinaryOperatorKind { 6599 /** This value describes cursors which are not binary operators. */ 6600 CXBinaryOperator_Invalid, 6601 /** C++ Pointer - to - member operator. */ 6602 CXBinaryOperator_PtrMemD, 6603 /** C++ Pointer - to - member operator. */ 6604 CXBinaryOperator_PtrMemI, 6605 /** Multiplication operator. */ 6606 CXBinaryOperator_Mul, 6607 /** Division operator. */ 6608 CXBinaryOperator_Div, 6609 /** Remainder operator. */ 6610 CXBinaryOperator_Rem, 6611 /** Addition operator. */ 6612 CXBinaryOperator_Add, 6613 /** Subtraction operator. */ 6614 CXBinaryOperator_Sub, 6615 /** Bitwise shift left operator. */ 6616 CXBinaryOperator_Shl, 6617 /** Bitwise shift right operator. */ 6618 CXBinaryOperator_Shr, 6619 /** C++ three-way comparison (spaceship) operator. */ 6620 CXBinaryOperator_Cmp, 6621 /** Less than operator. */ 6622 CXBinaryOperator_LT, 6623 /** Greater than operator. */ 6624 CXBinaryOperator_GT, 6625 /** Less or equal operator. */ 6626 CXBinaryOperator_LE, 6627 /** Greater or equal operator. */ 6628 CXBinaryOperator_GE, 6629 /** Equal operator. */ 6630 CXBinaryOperator_EQ, 6631 /** Not equal operator. */ 6632 CXBinaryOperator_NE, 6633 /** Bitwise AND operator. */ 6634 CXBinaryOperator_And, 6635 /** Bitwise XOR operator. */ 6636 CXBinaryOperator_Xor, 6637 /** Bitwise OR operator. */ 6638 CXBinaryOperator_Or, 6639 /** Logical AND operator. */ 6640 CXBinaryOperator_LAnd, 6641 /** Logical OR operator. */ 6642 CXBinaryOperator_LOr, 6643 /** Assignment operator. */ 6644 CXBinaryOperator_Assign, 6645 /** Multiplication assignment operator. */ 6646 CXBinaryOperator_MulAssign, 6647 /** Division assignment operator. */ 6648 CXBinaryOperator_DivAssign, 6649 /** Remainder assignment operator. */ 6650 CXBinaryOperator_RemAssign, 6651 /** Addition assignment operator. */ 6652 CXBinaryOperator_AddAssign, 6653 /** Subtraction assignment operator. */ 6654 CXBinaryOperator_SubAssign, 6655 /** Bitwise shift left assignment operator. */ 6656 CXBinaryOperator_ShlAssign, 6657 /** Bitwise shift right assignment operator. */ 6658 CXBinaryOperator_ShrAssign, 6659 /** Bitwise AND assignment operator. */ 6660 CXBinaryOperator_AndAssign, 6661 /** Bitwise XOR assignment operator. */ 6662 CXBinaryOperator_XorAssign, 6663 /** Bitwise OR assignment operator. */ 6664 CXBinaryOperator_OrAssign, 6665 /** Comma operator. */ 6666 CXBinaryOperator_Comma 6667 }; 6668 6669 /** 6670 * Retrieve the spelling of a given CXBinaryOperatorKind. 6671 */ 6672 CINDEX_LINKAGE CXString 6673 clang_getBinaryOperatorKindSpelling(enum CXBinaryOperatorKind kind); 6674 6675 /** 6676 * Retrieve the binary operator kind of this cursor. 6677 * 6678 * If this cursor is not a binary operator then returns Invalid. 6679 */ 6680 CINDEX_LINKAGE enum CXBinaryOperatorKind 6681 clang_getCursorBinaryOperatorKind(CXCursor cursor); 6682 6683 /** 6684 * Describes the kind of unary operators. 6685 */ 6686 enum CXUnaryOperatorKind { 6687 /** This value describes cursors which are not unary operators. */ 6688 CXUnaryOperator_Invalid, 6689 /** Postfix increment operator. */ 6690 CXUnaryOperator_PostInc, 6691 /** Postfix decrement operator. */ 6692 CXUnaryOperator_PostDec, 6693 /** Prefix increment operator. */ 6694 CXUnaryOperator_PreInc, 6695 /** Prefix decrement operator. */ 6696 CXUnaryOperator_PreDec, 6697 /** Address of operator. */ 6698 CXUnaryOperator_AddrOf, 6699 /** Dereference operator. */ 6700 CXUnaryOperator_Deref, 6701 /** Plus operator. */ 6702 CXUnaryOperator_Plus, 6703 /** Minus operator. */ 6704 CXUnaryOperator_Minus, 6705 /** Not operator. */ 6706 CXUnaryOperator_Not, 6707 /** LNot operator. */ 6708 CXUnaryOperator_LNot, 6709 /** "__real expr" operator. */ 6710 CXUnaryOperator_Real, 6711 /** "__imag expr" operator. */ 6712 CXUnaryOperator_Imag, 6713 /** __extension__ marker operator. */ 6714 CXUnaryOperator_Extension, 6715 /** C++ co_await operator. */ 6716 CXUnaryOperator_Coawait 6717 }; 6718 6719 /** 6720 * Retrieve the spelling of a given CXUnaryOperatorKind. 6721 */ 6722 CINDEX_LINKAGE CXString 6723 clang_getUnaryOperatorKindSpelling(enum CXUnaryOperatorKind kind); 6724 6725 /** 6726 * Retrieve the unary operator kind of this cursor. 6727 * 6728 * If this cursor is not a unary operator then returns Invalid. 6729 */ 6730 CINDEX_LINKAGE enum CXUnaryOperatorKind 6731 clang_getCursorUnaryOperatorKind(CXCursor cursor); 6732 6733 /** 6734 * @} 6735 */ 6736 6737 /** 6738 * @} 6739 */ 6740 6741 LLVM_CLANG_C_EXTERN_C_END 6742 6743 #endif 6744