> overridden,
IntPtr num_overridden);
+ /**
+ * Free the set of overridden cursors returned by \c
+ * clang_getOverriddenCursors().
+ */
@Generated
@CFunction
public static native void clang_disposeOverriddenCursors(
@UncertainArgument("Options: reference, array Fallback: reference") CXCursor overridden);
+ /**
+ * Retrieve the file that is included by the given inclusion directive
+ * cursor.
+ */
@Generated
@CFunction
public static native VoidPtr clang_getIncludedFile(@ByValue CXCursor cursor);
+ /**
+ * Map a source location to the cursor that describes the entity at that
+ * location in the source code.
+ *
+ * clang_getCursor() maps an arbitrary source location within a translation
+ * unit down to the most specific cursor that describes the entity at that
+ * location. For example, given an expression \c x + y, invoking
+ * clang_getCursor() with a source location pointing to "x" will return the
+ * cursor for "x"; similarly for "y". If the cursor points anywhere between
+ * "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
+ * will return a cursor referring to the "+" expression.
+ *
+ * \returns a cursor representing the entity at the given source location, or
+ * a NULL cursor if no such entity can be found.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getCursor(CXTranslationUnit arg1, @ByValue CXSourceLocation arg2);
+ /**
+ * Retrieve the physical location of the source constructor referenced
+ * by the given cursor.
+ *
+ * The location of a declaration is typically the location of the name of that
+ * declaration, where the name of that declaration would occur if it is
+ * unnamed, or some keyword that introduces that particular declaration.
+ * The location of a reference is where that reference occurs within the
+ * source code.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceLocation clang_getCursorLocation(@ByValue CXCursor arg1);
+ /**
+ * Retrieve the physical extent of the source construct referenced by
+ * the given cursor.
+ *
+ * The extent of a cursor starts with the file/line/column pointing at the
+ * first character within the source construct that the cursor refers to and
+ * ends with the last character within that source construct. For a
+ * declaration, the extent covers the declaration itself. For a reference,
+ * the extent covers the location of the reference (e.g., where the referenced
+ * entity was actually used).
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceRange clang_getCursorExtent(@ByValue CXCursor arg1);
+ /**
+ * Retrieve the type of a CXCursor (if any).
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getCursorType(@ByValue CXCursor C);
+ /**
+ * Pretty-print the underlying type using the rules of the
+ * language of the translation unit from which it came.
+ *
+ * If the type is invalid, an empty string is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getTypeSpelling(@ByValue CXType CT);
+ /**
+ * Retrieve the underlying type of a typedef declaration.
+ *
+ * If the cursor does not reference a typedef declaration, an invalid type is
+ * returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getTypedefDeclUnderlyingType(@ByValue CXCursor C);
+ /**
+ * Retrieve the integer type of an enum declaration.
+ *
+ * If the cursor does not reference an enum declaration, an invalid type is
+ * returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getEnumDeclIntegerType(@ByValue CXCursor C);
+ /**
+ * Retrieve the integer value of an enum constant declaration as a signed
+ * long long.
+ *
+ * If the cursor does not reference an enum constant declaration, LLONG_MIN is
+ * returned. Since this is also potentially a valid constant value, the kind of
+ * the cursor must be verified before calling this function.
+ */
@Generated
@CFunction
public static native long clang_getEnumConstantDeclValue(@ByValue CXCursor C);
+ /**
+ * Retrieve the integer value of an enum constant declaration as an unsigned
+ * long long.
+ *
+ * If the cursor does not reference an enum constant declaration, ULLONG_MAX is
+ * returned. Since this is also potentially a valid constant value, the kind of
+ * the cursor must be verified before calling this function.
+ */
@Generated
@CFunction
public static native long clang_getEnumConstantDeclUnsignedValue(@ByValue CXCursor C);
+ /**
+ * Retrieve the bit width of a bit field declaration as an integer.
+ *
+ * If a cursor that is not a bit field declaration is passed in, -1 is returned.
+ */
@Generated
@CFunction
public static native int clang_getFieldDeclBitWidth(@ByValue CXCursor C);
+ /**
+ * Retrieve the number of non-variadic arguments associated with a given
+ * cursor.
+ *
+ * The number of arguments can be determined for calls as well as for
+ * declarations of functions or methods. For other cursors -1 is returned.
+ */
@Generated
@CFunction
public static native int clang_Cursor_getNumArguments(@ByValue CXCursor C);
+ /**
+ * Retrieve the argument cursor of a function or method.
+ *
+ * The argument cursor can be determined for calls as well as for declarations
+ * of functions or methods. For other cursors and for invalid indices, an
+ * invalid cursor is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_Cursor_getArgument(@ByValue CXCursor C, int i);
+ /**
+ * Determine whether two CXTypes represent the same type.
+ *
+ * \returns non-zero if the CXTypes represent the same type and
+ * zero otherwise.
+ */
@Generated
@CFunction
public static native int clang_equalTypes(@ByValue CXType A, @ByValue CXType B);
+ /**
+ * Return the canonical type for a CXType.
+ *
+ * Clang's type system explicitly models typedefs and all the ways
+ * a specific type can be represented. The canonical type is the underlying
+ * type with all the "sugar" removed. For example, if 'T' is a typedef
+ * for 'int', the canonical type for 'T' would be 'int'.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getCanonicalType(@ByValue CXType T);
+ /**
+ * Determine whether a CXType has the "const" qualifier set,
+ * without looking through typedefs that may have added "const" at a
+ * different level.
+ */
@Generated
@CFunction
public static native int clang_isConstQualifiedType(@ByValue CXType T);
+ /**
+ * Determine whether a CXType has the "volatile" qualifier set,
+ * without looking through typedefs that may have added "volatile" at
+ * a different level.
+ */
@Generated
@CFunction
public static native int clang_isVolatileQualifiedType(@ByValue CXType T);
+ /**
+ * Determine whether a CXType has the "restrict" qualifier set,
+ * without looking through typedefs that may have added "restrict" at a
+ * different level.
+ */
@Generated
@CFunction
public static native int clang_isRestrictQualifiedType(@ByValue CXType T);
+ /**
+ * For pointer types, returns the type of the pointee.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getPointeeType(@ByValue CXType T);
+ /**
+ * Return the cursor for the declaration of the given type.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getTypeDeclaration(@ByValue CXType T);
+ /**
+ * Returns the Objective-C type encoding for the specified declaration.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getDeclObjCTypeEncoding(@ByValue CXCursor C);
+ /**
+ * Retrieve the spelling of a given CXTypeKind.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getTypeKindSpelling(int K);
+ /**
+ * Retrieve the calling convention associated with a function type.
+ *
+ * If a non-function type is passed in, CXCallingConv_Invalid is returned.
+ */
@Generated
@CFunction
public static native int clang_getFunctionTypeCallingConv(@ByValue CXType T);
+ /**
+ * Retrieve the return type associated with a function type.
+ *
+ * If a non-function type is passed in, an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getResultType(@ByValue CXType T);
+ /**
+ * Retrieve the number of non-variadic parameters associated with a
+ * function type.
+ *
+ * If a non-function type is passed in, -1 is returned.
+ */
@Generated
@CFunction
public static native int clang_getNumArgTypes(@ByValue CXType T);
+ /**
+ * Retrieve the type of a parameter of a function type.
+ *
+ * If a non-function type is passed in or the function does not have enough
+ * parameters, an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getArgType(@ByValue CXType T, int i);
+ /**
+ * Return 1 if the CXType is a variadic function type, and 0 otherwise.
+ */
@Generated
@CFunction
public static native int clang_isFunctionTypeVariadic(@ByValue CXType T);
+ /**
+ * Retrieve the return type associated with a given cursor.
+ *
+ * This only returns a valid type if the cursor refers to a function or method.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getCursorResultType(@ByValue CXCursor C);
+ /**
+ * Return 1 if the CXType is a POD (plain old data) type, and 0
+ * otherwise.
+ */
@Generated
@CFunction
public static native int clang_isPODType(@ByValue CXType T);
+ /**
+ * Return the element type of an array, complex, or vector type.
+ *
+ * If a type is passed in that is not an array, complex, or vector type,
+ * an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getElementType(@ByValue CXType T);
+ /**
+ * Return the number of elements of an array or vector type.
+ *
+ * If a type is passed in that is not an array or vector type,
+ * -1 is returned.
+ */
@Generated
@CFunction
public static native long clang_getNumElements(@ByValue CXType T);
+ /**
+ * Return the element type of an array type.
+ *
+ * If a non-array type is passed in, an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getArrayElementType(@ByValue CXType T);
+ /**
+ * Return the array size of a constant array.
+ *
+ * If a non-array type is passed in, -1 is returned.
+ */
@Generated
@CFunction
public static native long clang_getArraySize(@ByValue CXType T);
+ /**
+ * Retrieve the type named by the qualified-id.
+ *
+ * If a non-elaborated type is passed in, an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_Type_getNamedType(@ByValue CXType T);
+ /**
+ * Return the alignment of a type in bytes as per C++[expr.alignof]
+ * standard.
+ *
+ * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
+ * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
+ * is returned.
+ * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
+ * returned.
+ * If the type declaration is not a constant size type,
+ * CXTypeLayoutError_NotConstantSize is returned.
+ */
@Generated
@CFunction
public static native long clang_Type_getAlignOf(@ByValue CXType T);
+ /**
+ * Return the class type of an member pointer type.
+ *
+ * If a non-member-pointer type is passed in, an invalid type is returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_Type_getClassType(@ByValue CXType T);
+ /**
+ * Return the size of a type in bytes as per C++[expr.sizeof] standard.
+ *
+ * If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
+ * If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
+ * is returned.
+ * If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
+ * returned.
+ */
@Generated
@CFunction
public static native long clang_Type_getSizeOf(@ByValue CXType T);
+ /**
+ * Return the offset of a field named S in a record of type T in bits
+ * as it would be returned by __offsetof__ as per C++11[18.2p4]
+ *
+ * If the cursor is not a record field declaration, CXTypeLayoutError_Invalid
+ * is returned.
+ * If the field's type declaration is an incomplete type,
+ * CXTypeLayoutError_Incomplete is returned.
+ * If the field's type declaration is a dependent type,
+ * CXTypeLayoutError_Dependent is returned.
+ * If the field's name S is not found,
+ * CXTypeLayoutError_InvalidFieldName is returned.
+ */
@Generated
@CFunction
public static native long clang_Type_getOffsetOf(@ByValue CXType T,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String S);
+ /**
+ * Retrieve the ref-qualifier kind of a function or method.
+ *
+ * The ref-qualifier is returned for C++ functions or methods. For other types
+ * or non-C++ declarations, CXRefQualifier_None is returned.
+ */
@Generated
@CFunction
public static native int clang_Type_getCXXRefQualifier(@ByValue CXType T);
+ /**
+ * Returns non-zero if the cursor specifies a Record member that is a
+ * bitfield.
+ */
@Generated
@CFunction
public static native int clang_Cursor_isBitField(@ByValue CXCursor C);
+ /**
+ * Returns 1 if the base class specified by the cursor with kind
+ * CX_CXXBaseSpecifier is virtual.
+ */
@Generated
@CFunction
public static native int clang_isVirtualBase(@ByValue CXCursor arg1);
+ /**
+ * Returns the access control level for the referenced object.
+ *
+ * If the cursor refers to a C++ declaration, its access control level within
+ * its parent scope is returned. Otherwise, if the cursor refers to a base
+ * specifier or access specifier, the specifier itself is returned.
+ */
@Generated
@CFunction
public static native int clang_getCXXAccessSpecifier(@ByValue CXCursor arg1);
+ /**
+ * Determine the number of overloaded declarations referenced by a
+ * \c CXCursor_OverloadedDeclRef cursor.
+ *
+ * \param cursor The cursor whose overloaded declarations are being queried.
+ *
+ * \returns The number of overloaded declarations referenced by \c cursor. If it
+ * is not a \c CXCursor_OverloadedDeclRef cursor, returns 0.
+ */
@Generated
@CFunction
public static native int clang_getNumOverloadedDecls(@ByValue CXCursor cursor);
+ /**
+ * Retrieve a cursor for one of the overloaded declarations referenced
+ * by a \c CXCursor_OverloadedDeclRef cursor.
+ *
+ * \param cursor The cursor whose overloaded declarations are being queried.
+ *
+ * \param index The zero-based index into the set of overloaded declarations in
+ * the cursor.
+ *
+ * \returns A cursor representing the declaration referenced by the given
+ * \c cursor at the specified \c index. If the cursor does not have an
+ * associated set of overloaded declarations, or if the index is out of bounds,
+ * returns \c clang_getNullCursor();
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getOverloadedDecl(@ByValue CXCursor cursor, int index);
+ /**
+ * For cursors representing an iboutletcollection attribute,
+ * this function returns the collection element type.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_getIBOutletCollectionType(@ByValue CXCursor arg1);
+ /**
+ * Visit the children of a particular cursor.
+ *
+ * This function visits all the direct children of the given cursor,
+ * invoking the given \p visitor function with the cursors of each
+ * visited child. The traversal may be recursive, if the visitor returns
+ * \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
+ * the visitor returns \c CXChildVisit_Break.
+ *
+ * \param parent the cursor whose child may be visited. All kinds of
+ * cursors can be visited, including invalid cursors (which, by
+ * definition, have no children).
+ *
+ * \param visitor the visitor function that will be invoked for each
+ * child of \p parent.
+ *
+ * \param client_data pointer data supplied by the client, which will
+ * be passed to the visitor each time it is invoked.
+ *
+ * \returns a non-zero value if the traversal was terminated
+ * prematurely by the visitor returning \c CXChildVisit_Break.
+ */
@Generated
@CFunction
public static native int clang_visitChildren(@ByValue CXCursor parent,
@FunctionPtr(name = "call_clang_visitChildren") Function_clang_visitChildren visitor, VoidPtr client_data);
+ /**
+ * Visits the children of a cursor using the specified block. Behaves
+ * identically to clang_visitChildren() in all other respects.
+ */
@Generated
@CFunction
public static native int clang_visitChildrenWithBlock(@ByValue CXCursor parent,
@ObjCBlock(name = "call_clang_visitChildrenWithBlock") Block_clang_visitChildrenWithBlock block);
+ /**
+ * Retrieve a Unified Symbol Resolution (USR) for the entity referenced
+ * by the given cursor.
+ *
+ * A Unified Symbol Resolution (USR) is a string that identifies a particular
+ * entity (function, class, variable, etc.) within a program. USRs can be
+ * compared across translation units to determine, e.g., when references in
+ * one translation refer to an entity defined in another translation unit.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCursorUSR(@ByValue CXCursor arg1);
+ /**
+ * Construct a USR for a specified Objective-C class.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_constructUSR_ObjCClass(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String class_name);
+ /**
+ * Construct a USR for a specified Objective-C category.
+ */
@Generated
@CFunction
@ByValue
@@ -760,12 +1886,19 @@ public static native CXString clang_constructUSR_ObjCCategory(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String class_name,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String category_name);
+ /**
+ * Construct a USR for a specified Objective-C protocol.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_constructUSR_ObjCProtocol(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String protocol_name);
+ /**
+ * Construct a USR for a specified Objective-C instance variable and
+ * the USR for its containing class.
+ */
@Generated
@CFunction
@ByValue
@@ -773,6 +1906,10 @@ public static native CXString clang_constructUSR_ObjCIvar(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String name,
@ByValue CXString classUSR);
+ /**
+ * Construct a USR for a specified Objective-C method and
+ * the USR for its containing class.
+ */
@Generated
@CFunction
@ByValue
@@ -780,6 +1917,10 @@ public static native CXString clang_constructUSR_ObjCMethod(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String name,
int isInstanceMethod, @ByValue CXString classUSR);
+ /**
+ * Construct a USR for a specified Objective-C property and the USR
+ * for its containing class.
+ */
@Generated
@CFunction
@ByValue
@@ -787,54 +1928,175 @@ public static native CXString clang_constructUSR_ObjCProperty(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String property,
@ByValue CXString classUSR);
+ /**
+ * Retrieve a name for the entity referenced by this cursor.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCursorSpelling(@ByValue CXCursor arg1);
+ /**
+ * Retrieve a range for a piece that forms the cursors spelling name.
+ * Most of the times there is only one range for the complete spelling but for
+ * Objective-C methods and Objective-C message expressions, there are multiple
+ * pieces for each selector identifier.
+ *
+ * \param pieceIndex the index of the spelling name piece. If this is greater
+ * than the actual number of pieces, it will return a NULL (invalid) range.
+ *
+ * \param options Reserved.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceRange clang_Cursor_getSpellingNameRange(@ByValue CXCursor arg1, int pieceIndex,
int options);
+ /**
+ * Retrieve the display name for the entity referenced by this cursor.
+ *
+ * The display name contains extra information that helps identify the cursor,
+ * such as the parameters of a function or template or the arguments of a
+ * class template specialization.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCursorDisplayName(@ByValue CXCursor arg1);
+ /**
+ * For a cursor that is a reference, retrieve a cursor representing the
+ * entity that it references.
+ *
+ * Reference cursors refer to other entities in the AST. For example, an
+ * Objective-C superclass reference cursor refers to an Objective-C class.
+ * This function produces the cursor for the Objective-C class from the
+ * cursor for the superclass reference. If the input cursor is a declaration or
+ * definition, it returns that declaration or definition unchanged.
+ * Otherwise, returns the NULL cursor.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getCursorReferenced(@ByValue CXCursor arg1);
+ /**
+ * For a cursor that is either a reference to or a declaration
+ * of some entity, retrieve a cursor that describes the definition of
+ * that entity.
+ *
+ * Some entities can be declared multiple times within a translation
+ * unit, but only one of those declarations can also be a
+ * definition. For example, given:
+ *
+ * \code
+ * int f(int, int);
+ * int g(int x, int y) { return f(x, y); }
+ * int f(int a, int b) { return a + b; }
+ * int f(int, int);
+ * \endcode
+ *
+ * there are three declarations of the function "f", but only the
+ * second one is a definition. The clang_getCursorDefinition()
+ * function will take any cursor pointing to a declaration of "f"
+ * (the first or fourth lines of the example) or a cursor referenced
+ * that uses "f" (the call to "f' inside "g") and will return a
+ * declaration cursor pointing to the definition (the second "f"
+ * declaration).
+ *
+ * If given a cursor for which there is no corresponding definition,
+ * e.g., because there is no definition of that entity within this
+ * translation unit, returns a NULL cursor.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getCursorDefinition(@ByValue CXCursor arg1);
+ /**
+ * Determine whether the declaration pointed to by this cursor
+ * is also a definition of that entity.
+ */
@Generated
@CFunction
public static native int clang_isCursorDefinition(@ByValue CXCursor arg1);
+ /**
+ * Retrieve the canonical cursor corresponding to the given cursor.
+ *
+ * In the C family of languages, many kinds of entities can be declared several
+ * times within a single translation unit. For example, a structure type can
+ * be forward-declared (possibly multiple times) and later defined:
+ *
+ * \code
+ * struct X;
+ * struct X;
+ * struct X {
+ * int member;
+ * };
+ * \endcode
+ *
+ * The declarations and the definition of \c X are represented by three
+ * different cursors, all of which are declarations of the same underlying
+ * entity. One of these cursor is considered the "canonical" cursor, which
+ * is effectively the representative for the underlying entity. One can
+ * determine if two cursors are declarations of the same underlying entity by
+ * comparing their canonical cursors.
+ *
+ * \returns The canonical cursor for the entity referred to by the given cursor.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getCanonicalCursor(@ByValue CXCursor arg1);
+ /**
+ * If the cursor points to a selector identifier in an Objective-C
+ * method or message expression, this returns the selector index.
+ *
+ * After getting a cursor with #clang_getCursor, this can be called to
+ * determine if the location points to a selector identifier.
+ *
+ * \returns The selector index if the cursor is an Objective-C method or message
+ * expression and the cursor is pointing to a selector identifier, or -1
+ * otherwise.
+ */
@Generated
@CFunction
public static native int clang_Cursor_getObjCSelectorIndex(@ByValue CXCursor arg1);
+ /**
+ * Given a cursor pointing to a C++ method call or an Objective-C
+ * message, returns non-zero if the method/message is "dynamic", meaning:
+ *
+ * For a C++ method: the call is virtual.
+ * For an Objective-C message: the receiver is an object instance, not 'super'
+ * or a specific class.
+ *
+ * If the method/message is "static" or the cursor does not point to a
+ * method/message, it will return zero.
+ */
@Generated
@CFunction
public static native int clang_Cursor_isDynamicCall(@ByValue CXCursor C);
+ /**
+ * Given a cursor pointing to an Objective-C message or property
+ * reference, or C++ method call, returns the CXType of the receiver.
+ */
@Generated
@CFunction
@ByValue
public static native CXType clang_Cursor_getReceiverType(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a property declaration, return the
+ * associated property attributes. The bits are formed from
+ * \c CXObjCPropertyAttrKind.
+ *
+ * \param reserved Reserved for future use, pass 0.
+ */
@Generated
@CFunction
public static native int clang_Cursor_getObjCPropertyAttributes(@ByValue CXCursor C, int reserved);
@@ -844,278 +2106,735 @@ public static native CXSourceRange clang_Cursor_getSpellingNameRange(@ByValue CX
@ByValue
public static native CXString clang_Cursor_getObjCRuntimeName(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents an Objective-C method or parameter
+ * declaration, return the associated Objective-C qualifiers for the return
+ * type or the parameter respectively. The bits are formed from
+ * CXObjCDeclQualifierKind.
+ */
@Generated
@CFunction
public static native int clang_Cursor_getObjCDeclQualifiers(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents an Objective-C method or property
+ * declaration, return non-zero if the declaration was affected by "\@optional".
+ * Returns zero if the cursor is not such a declaration or it is "\@required".
+ */
@Generated
@CFunction
public static native int clang_Cursor_isObjCOptional(@ByValue CXCursor C);
+ /**
+ * Returns non-zero if the given cursor is a variadic function or method.
+ */
@Generated
@CFunction
public static native int clang_Cursor_isVariadic(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a declaration, return the associated
+ * comment's source range. The range may include multiple consecutive comments
+ * with whitespace in between.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceRange clang_Cursor_getCommentRange(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a declaration, return the associated
+ * comment text, including comment markers.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_Cursor_getRawCommentText(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a documentable entity (e.g.,
+ * declaration), return the associated \paragraph; otherwise return the
+ * first paragraph.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_Cursor_getBriefCommentText(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a documentable entity (e.g.,
+ * declaration), return the associated parsed comment as a
+ * \c CXComment_FullComment AST node.
+ */
@Generated
@CFunction
@ByValue
public static native CXComment clang_Cursor_getParsedComment(@ByValue CXCursor C);
+ /**
+ * Given a CXCursor_ModuleImportDecl cursor, return the associated module.
+ */
@Generated
@CFunction
public static native VoidPtr clang_Cursor_getModule(@ByValue CXCursor C);
+ /**
+ * \param Module a module object.
+ *
+ * \returns the module file where the provided module object came from.
+ */
@Generated
@CFunction
public static native VoidPtr clang_Module_getASTFile(VoidPtr Module);
+ /**
+ * \param Module a module object.
+ *
+ * \returns the parent of a sub-module or NULL if the given module is top-level,
+ * e.g. for 'std.vector' it will return the 'std' module.
+ */
@Generated
@CFunction
public static native VoidPtr clang_Module_getParent(VoidPtr Module);
+ /**
+ * \param Module a module object.
+ *
+ * \returns the name of the module, e.g. for the 'std.vector' sub-module it
+ * will return "vector".
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_Module_getName(VoidPtr Module);
+ /**
+ * \param Module a module object.
+ *
+ * \returns the full name of the module, e.g. "std.vector".
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_Module_getFullName(VoidPtr Module);
+ /**
+ * \param Module a module object.
+ *
+ * \returns the number of top level headers associated with this module.
+ */
@Generated
@CFunction
public static native int clang_Module_getNumTopLevelHeaders(CXTranslationUnit arg1, VoidPtr Module);
+ /**
+ * \param Module a module object.
+ *
+ * \param Index top level header index (zero-based).
+ *
+ * \returns the specified top level header associated with the module.
+ */
@Generated
@CFunction
public static native VoidPtr clang_Module_getTopLevelHeader(CXTranslationUnit arg1, VoidPtr Module, int Index);
+ /**
+ * \param Comment AST node of any kind.
+ *
+ * \returns the type of the AST node.
+ */
@Generated
@CFunction
public static native int clang_Comment_getKind(@ByValue CXComment Comment);
+ /**
+ * \param Comment AST node of any kind.
+ *
+ * \returns number of children of the AST node.
+ */
@Generated
@CFunction
public static native int clang_Comment_getNumChildren(@ByValue CXComment Comment);
+ /**
+ * \param Comment AST node of any kind.
+ *
+ * \param ChildIdx child index (zero-based).
+ *
+ * \returns the specified child of the AST node.
+ */
@Generated
@CFunction
@ByValue
public static native CXComment clang_Comment_getChild(@ByValue CXComment Comment, int ChildIdx);
+ /**
+ * A \c CXComment_Paragraph node is considered whitespace if it contains
+ * only \c CXComment_Text nodes that are empty or whitespace.
+ *
+ * Other AST nodes (except \c CXComment_Paragraph and \c CXComment_Text) are
+ * never considered whitespace.
+ *
+ * \returns non-zero if \c Comment is whitespace.
+ */
@Generated
@CFunction
public static native int clang_Comment_isWhitespace(@ByValue CXComment Comment);
+ /**
+ * \returns non-zero if \c Comment is inline content and has a newline
+ * immediately following it in the comment text. Newlines between paragraphs
+ * do not count.
+ */
@Generated
@CFunction
public static native int clang_InlineContentComment_hasTrailingNewline(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_Text AST node.
+ *
+ * \returns text contained in the AST node.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_TextComment_getText(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_InlineCommand AST node.
+ *
+ * \returns name of the inline command.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_InlineCommandComment_getCommandName(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_InlineCommand AST node.
+ *
+ * \returns the most appropriate rendering mode, chosen on command
+ * semantics in Doxygen.
+ */
@Generated
@CFunction
public static native int clang_InlineCommandComment_getRenderKind(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_InlineCommand AST node.
+ *
+ * \returns number of command arguments.
+ */
@Generated
@CFunction
public static native int clang_InlineCommandComment_getNumArgs(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_InlineCommand AST node.
+ *
+ * \param ArgIdx argument index (zero-based).
+ *
+ * \returns text of the specified argument.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_InlineCommandComment_getArgText(@ByValue CXComment Comment, int ArgIdx);
+ /**
+ * \param Comment a \c CXComment_HTMLStartTag or \c CXComment_HTMLEndTag AST
+ * node.
+ *
+ * \returns HTML tag name.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_HTMLTagComment_getTagName(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_HTMLStartTag AST node.
+ *
+ * \returns non-zero if tag is self-closing (for example, <br />).
+ */
@Generated
@CFunction
public static native int clang_HTMLStartTagComment_isSelfClosing(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_HTMLStartTag AST node.
+ *
+ * \returns number of attributes (name-value pairs) attached to the start tag.
+ */
@Generated
@CFunction
public static native int clang_HTMLStartTag_getNumAttrs(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_HTMLStartTag AST node.
+ *
+ * \param AttrIdx attribute index (zero-based).
+ *
+ * \returns name of the specified attribute.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_HTMLStartTag_getAttrName(@ByValue CXComment Comment, int AttrIdx);
+ /**
+ * \param Comment a \c CXComment_HTMLStartTag AST node.
+ *
+ * \param AttrIdx attribute index (zero-based).
+ *
+ * \returns value of the specified attribute.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_HTMLStartTag_getAttrValue(@ByValue CXComment Comment, int AttrIdx);
+ /**
+ * \param Comment a \c CXComment_BlockCommand AST node.
+ *
+ * \returns name of the block command.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_BlockCommandComment_getCommandName(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_BlockCommand AST node.
+ *
+ * \returns number of word-like arguments.
+ */
@Generated
@CFunction
public static native int clang_BlockCommandComment_getNumArgs(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_BlockCommand AST node.
+ *
+ * \param ArgIdx argument index (zero-based).
+ *
+ * \returns text of the specified word-like argument.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_BlockCommandComment_getArgText(@ByValue CXComment Comment, int ArgIdx);
+ /**
+ * \param Comment a \c CXComment_BlockCommand or
+ * \c CXComment_VerbatimBlockCommand AST node.
+ *
+ * \returns paragraph argument of the block command.
+ */
@Generated
@CFunction
@ByValue
public static native CXComment clang_BlockCommandComment_getParagraph(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_ParamCommand AST node.
+ *
+ * \returns parameter name.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_ParamCommandComment_getParamName(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_ParamCommand AST node.
+ *
+ * \returns non-zero if the parameter that this AST node represents was found
+ * in the function prototype and \c clang_ParamCommandComment_getParamIndex
+ * function will return a meaningful value.
+ */
@Generated
@CFunction
public static native int clang_ParamCommandComment_isParamIndexValid(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_ParamCommand AST node.
+ *
+ * \returns zero-based parameter index in function prototype.
+ */
@Generated
@CFunction
public static native int clang_ParamCommandComment_getParamIndex(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_ParamCommand AST node.
+ *
+ * \returns non-zero if parameter passing direction was specified explicitly in
+ * the comment.
+ */
@Generated
@CFunction
public static native int clang_ParamCommandComment_isDirectionExplicit(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_ParamCommand AST node.
+ *
+ * \returns parameter passing direction.
+ */
@Generated
@CFunction
public static native int clang_ParamCommandComment_getDirection(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_TParamCommand AST node.
+ *
+ * \returns template parameter name.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_TParamCommandComment_getParamName(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_TParamCommand AST node.
+ *
+ * \returns non-zero if the parameter that this AST node represents was found
+ * in the template parameter list and
+ * \c clang_TParamCommandComment_getDepth and
+ * \c clang_TParamCommandComment_getIndex functions will return a meaningful
+ * value.
+ */
@Generated
@CFunction
public static native int clang_TParamCommandComment_isParamPositionValid(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_TParamCommand AST node.
+ *
+ * \returns zero-based nesting depth of this parameter in the template parameter list.
+ *
+ * For example,
+ * \verbatim
+ * template class TT>
+ * void test(TT aaa);
+ * \endverbatim
+ * for C and TT nesting depth is 0,
+ * for T nesting depth is 1.
+ */
@Generated
@CFunction
public static native int clang_TParamCommandComment_getDepth(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_TParamCommand AST node.
+ *
+ * \returns zero-based parameter index in the template parameter list at a
+ * given nesting depth.
+ *
+ * For example,
+ * \verbatim
+ * template class TT>
+ * void test(TT aaa);
+ * \endverbatim
+ * for C and TT nesting depth is 0, so we can ask for index at depth 0:
+ * at depth 0 C's index is 0, TT's index is 1.
+ *
+ * For T nesting depth is 1, so we can ask for index at depth 0 and 1:
+ * at depth 0 T's index is 1 (same as TT's),
+ * at depth 1 T's index is 0.
+ */
@Generated
@CFunction
public static native int clang_TParamCommandComment_getIndex(@ByValue CXComment Comment, int Depth);
+ /**
+ * \param Comment a \c CXComment_VerbatimBlockLine AST node.
+ *
+ * \returns text contained in the AST node.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_VerbatimBlockLineComment_getText(@ByValue CXComment Comment);
+ /**
+ * \param Comment a \c CXComment_VerbatimLine AST node.
+ *
+ * \returns text contained in the AST node.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_VerbatimLineComment_getText(@ByValue CXComment Comment);
+ /**
+ * Convert an HTML tag AST node to string.
+ *
+ * \param Comment a \c CXComment_HTMLStartTag or \c CXComment_HTMLEndTag AST
+ * node.
+ *
+ * \returns string containing an HTML tag.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_HTMLTagComment_getAsString(@ByValue CXComment Comment);
+ /**
+ * Convert a given full parsed comment to an HTML fragment.
+ *
+ * Specific details of HTML layout are subject to change. Don't try to parse
+ * this HTML back into an AST, use other APIs instead.
+ *
+ * Currently the following CSS classes are used:
+ * \li "para-brief" for \paragraph and equivalent commands;
+ * \li "para-returns" for \\returns paragraph and equivalent commands;
+ * \li "word-returns" for the "Returns" word in \\returns paragraph.
+ *
+ * Function argument documentation is rendered as a \ list with arguments
+ * sorted in function prototype order. CSS classes used:
+ * \li "param-name-index-NUMBER" for parameter name (\);
+ * \li "param-descr-index-NUMBER" for parameter description (\);
+ * \li "param-name-index-invalid" and "param-descr-index-invalid" are used if
+ * parameter index is invalid.
+ *
+ * Template parameter documentation is rendered as a \ list with
+ * parameters sorted in template parameter list order. CSS classes used:
+ * \li "tparam-name-index-NUMBER" for parameter name (\);
+ * \li "tparam-descr-index-NUMBER" for parameter description (\);
+ * \li "tparam-name-index-other" and "tparam-descr-index-other" are used for
+ * names inside template template parameters;
+ * \li "tparam-name-index-invalid" and "tparam-descr-index-invalid" are used if
+ * parameter position is invalid.
+ *
+ * \param Comment a \c CXComment_FullComment AST node.
+ *
+ * \returns string containing an HTML fragment.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_FullComment_getAsHTML(@ByValue CXComment Comment);
+ /**
+ * Convert a given full parsed comment to an XML document.
+ *
+ * A Relax NG schema for the XML can be found in comment-xml-schema.rng file
+ * inside clang source tree.
+ *
+ * \param Comment a \c CXComment_FullComment AST node.
+ *
+ * \returns string containing an XML document.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_FullComment_getAsXML(@ByValue CXComment Comment);
+ /**
+ * Determine if a C++ member function or member function template is
+ * pure virtual.
+ */
@Generated
@CFunction
public static native int clang_CXXMethod_isPureVirtual(@ByValue CXCursor C);
+ /**
+ * Determine if a C++ member function or member function template is
+ * declared 'static'.
+ */
@Generated
@CFunction
public static native int clang_CXXMethod_isStatic(@ByValue CXCursor C);
+ /**
+ * Determine if a C++ member function or member function template is
+ * explicitly declared 'virtual' or if it overrides a virtual method from
+ * one of the base classes.
+ */
@Generated
@CFunction
public static native int clang_CXXMethod_isVirtual(@ByValue CXCursor C);
+ /**
+ * Given a cursor that represents a template, determine
+ * the cursor kind of the specializations would be generated by instantiating
+ * the template.
+ *
+ * This routine can be used to determine what flavor of function template,
+ * class template, or class template partial specialization is stored in the
+ * cursor. For example, it can describe whether a class template cursor is
+ * declared with "struct", "class" or "union".
+ *
+ * \param C The cursor to query. This cursor should represent a template
+ * declaration.
+ *
+ * \returns The cursor kind of the specializations that would be generated
+ * by instantiating the template \p C. If \p C is not a template, returns
+ * \c CXCursor_NoDeclFound.
+ */
@Generated
@CFunction
public static native int clang_getTemplateCursorKind(@ByValue CXCursor C);
+ /**
+ * Given a cursor that may represent a specialization or instantiation
+ * of a template, retrieve the cursor that represents the template that it
+ * specializes or from which it was instantiated.
+ *
+ * This routine determines the template involved both for explicit
+ * specializations of templates and for implicit instantiations of the template,
+ * both of which are referred to as "specializations". For a class template
+ * specialization (e.g., \c std::vector), this routine will return
+ * either the primary template (\c std::vector) or, if the specialization was
+ * instantiated from a class template partial specialization, the class template
+ * partial specialization. For a class template partial specialization and a
+ * function template specialization (including instantiations), this
+ * this routine will return the specialized template.
+ *
+ * For members of a class template (e.g., member functions, member classes, or
+ * static data members), returns the specialized or instantiated member.
+ * Although not strictly "templates" in the C++ language, members of class
+ * templates have the same notions of specializations and instantiations that
+ * templates do, so this routine treats them similarly.
+ *
+ * \param C A cursor that may be a specialization of a template or a member
+ * of a template.
+ *
+ * \returns If the given cursor is a specialization or instantiation of a
+ * template or a member thereof, the template or member that it specializes or
+ * from which it was instantiated. Otherwise, returns a NULL cursor.
+ */
@Generated
@CFunction
@ByValue
public static native CXCursor clang_getSpecializedCursorTemplate(@ByValue CXCursor C);
+ /**
+ * Given a cursor that references something else, return the source range
+ * covering that reference.
+ *
+ * \param C A cursor pointing to a member reference, a declaration reference, or
+ * an operator call.
+ * \param NameFlags A bitset with three independent flags:
+ * CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and
+ * CXNameRange_WantSinglePiece.
+ * \param PieceIndex For contiguous names or when passing the flag
+ * CXNameRange_WantSinglePiece, only one piece with index 0 is
+ * available. When the CXNameRange_WantSinglePiece flag is not passed for a
+ * non-contiguous names, this index can be used to retrieve the individual
+ * pieces of the name. See also CXNameRange_WantSinglePiece.
+ *
+ * \returns The piece of the name pointed to by the given cursor. If there is no
+ * name, or if the PieceIndex is out-of-range, a null-cursor will be returned.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceRange clang_getCursorReferenceNameRange(@ByValue CXCursor C, int NameFlags,
int PieceIndex);
+ /**
+ * Determine the kind of the given token.
+ */
@Generated
@CFunction
public static native int clang_getTokenKind(@ByValue CXToken arg1);
+ /**
+ * Determine the spelling of the given token.
+ *
+ * The spelling of a token is the textual representation of that token, e.g.,
+ * the text of an identifier or keyword.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getTokenSpelling(CXTranslationUnit arg1, @ByValue CXToken arg2);
+ /**
+ * Retrieve the source location of the given token.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceLocation clang_getTokenLocation(CXTranslationUnit arg1, @ByValue CXToken arg2);
+ /**
+ * Retrieve a source range that covers the given token.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceRange clang_getTokenExtent(CXTranslationUnit arg1, @ByValue CXToken arg2);
+ /**
+ * Tokenize the source code described by the given range into raw
+ * lexical tokens.
+ *
+ * \param TU the translation unit whose text is being tokenized.
+ *
+ * \param Range the source range in which text should be tokenized. All of the
+ * tokens produced by tokenization will fall within this source range,
+ *
+ * \param Tokens this pointer will be set to point to the array of tokens
+ * that occur within the given source range. The returned pointer must be
+ * freed with clang_disposeTokens() before the translation unit is destroyed.
+ *
+ * \param NumTokens will be set to the number of tokens in the \c *Tokens
+ * array.
+ */
@Generated
@CFunction
public static native void clang_tokenize(CXTranslationUnit TU, @ByValue CXSourceRange Range,
Ptr> Tokens, IntPtr NumTokens);
+ /**
+ * Annotate the given set of tokens by providing cursors for each token
+ * that can be mapped to a specific entity within the abstract syntax tree.
+ *
+ * This token-annotation routine is equivalent to invoking
+ * clang_getCursor() for the source locations of each of the
+ * tokens. The cursors provided are filtered, so that only those
+ * cursors that have a direct correspondence to the token are
+ * accepted. For example, given a function call \c f(x),
+ * clang_getCursor() would provide the following cursors:
+ *
+ * * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.
+ * * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.
+ * * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.
+ *
+ * Only the first and last of these cursors will occur within the
+ * annotate, since the tokens "f" and "x' directly refer to a function
+ * and a variable, respectively, but the parentheses are just a small
+ * part of the full syntax of the function call expression, which is
+ * not provided as an annotation.
+ *
+ * \param TU the translation unit that owns the given tokens.
+ *
+ * \param Tokens the set of tokens to annotate.
+ *
+ * \param NumTokens the number of tokens in \p Tokens.
+ *
+ * \param Cursors an array of \p NumTokens cursors, whose contents will be
+ * replaced with the cursors corresponding to each token.
+ */
@Generated
@CFunction
public static native void clang_annotateTokens(CXTranslationUnit TU,
@UncertainArgument("Options: reference, array Fallback: reference") CXToken Tokens, int NumTokens,
@UncertainArgument("Options: reference, array Fallback: reference") CXCursor Cursors);
+ /**
+ * Free the given set of tokens.
+ */
@Generated
@CFunction
public static native void clang_disposeTokens(CXTranslationUnit TU, Ptr Tokens, int NumTokens);
+ /**
+ * for debug/testing
+ */
@Generated
@CFunction
@ByValue
@@ -1138,58 +2857,232 @@ public static native void clang_executeOnThread(
@FunctionPtr(name = "call_clang_executeOnThread") Function_clang_executeOnThread fn, VoidPtr user_data,
int stack_size);
+ /**
+ * Determine the kind of a particular chunk within a completion string.
+ *
+ * \param completion_string the completion string to query.
+ *
+ * \param chunk_number the 0-based index of the chunk in the completion string.
+ *
+ * \returns the kind of the chunk at the index \c chunk_number.
+ */
@Generated
@CFunction
public static native int clang_getCompletionChunkKind(VoidPtr completion_string, int chunk_number);
+ /**
+ * Retrieve the text associated with a particular chunk within a
+ * completion string.
+ *
+ * \param completion_string the completion string to query.
+ *
+ * \param chunk_number the 0-based index of the chunk in the completion string.
+ *
+ * \returns the text associated with the chunk at index \c chunk_number.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCompletionChunkText(VoidPtr completion_string, int chunk_number);
+ /**
+ * Retrieve the completion string associated with a particular chunk
+ * within a completion string.
+ *
+ * \param completion_string the completion string to query.
+ *
+ * \param chunk_number the 0-based index of the chunk in the completion string.
+ *
+ * \returns the completion string associated with the chunk at index
+ * \c chunk_number.
+ */
@Generated
@CFunction
public static native VoidPtr clang_getCompletionChunkCompletionString(VoidPtr completion_string, int chunk_number);
+ /**
+ * Retrieve the number of chunks in the given code-completion string.
+ */
@Generated
@CFunction
public static native int clang_getNumCompletionChunks(VoidPtr completion_string);
+ /**
+ * Determine the priority of this code completion.
+ *
+ * The priority of a code completion indicates how likely it is that this
+ * particular completion is the completion that the user will select. The
+ * priority is selected by various internal heuristics.
+ *
+ * \param completion_string The completion string to query.
+ *
+ * \returns The priority of this completion string. Smaller values indicate
+ * higher-priority (more likely) completions.
+ */
@Generated
@CFunction
public static native int clang_getCompletionPriority(VoidPtr completion_string);
+ /**
+ * Determine the availability of the entity that this code-completion
+ * string refers to.
+ *
+ * \param completion_string The completion string to query.
+ *
+ * \returns The availability of the completion string.
+ */
@Generated
@CFunction
public static native int clang_getCompletionAvailability(VoidPtr completion_string);
+ /**
+ * Retrieve the number of annotations associated with the given
+ * completion string.
+ *
+ * \param completion_string the completion string to query.
+ *
+ * \returns the number of annotations associated with the given completion
+ * string.
+ */
@Generated
@CFunction
public static native int clang_getCompletionNumAnnotations(VoidPtr completion_string);
+ /**
+ * Retrieve the annotation associated with the given completion string.
+ *
+ * \param completion_string the completion string to query.
+ *
+ * \param annotation_number the 0-based index of the annotation of the
+ * completion string.
+ *
+ * \returns annotation string associated with the completion at index
+ * \c annotation_number, or a NULL string if that annotation is not available.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCompletionAnnotation(VoidPtr completion_string, int annotation_number);
+ /**
+ * Retrieve the parent context of the given completion string.
+ *
+ * The parent context of a completion string is the semantic parent of
+ * the declaration (if any) that the code completion represents. For example,
+ * a code completion for an Objective-C method would have the method's class
+ * or protocol as its context.
+ *
+ * \param completion_string The code completion string whose parent is
+ * being queried.
+ *
+ * \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL.
+ *
+ * \returns The name of the completion parent, e.g., "NSObject" if
+ * the completion string represents a method in the NSObject class.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCompletionParent(VoidPtr completion_string, IntPtr kind);
+ /**
+ * Retrieve the brief documentation comment attached to the declaration
+ * that corresponds to the given completion string.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getCompletionBriefComment(VoidPtr completion_string);
+ /**
+ * Retrieve a completion string for an arbitrary declaration or macro
+ * definition cursor.
+ *
+ * \param cursor The cursor to query.
+ *
+ * \returns A non-context-sensitive completion string for declaration and macro
+ * definition cursors, or NULL for other kinds of cursors.
+ */
@Generated
@CFunction
public static native VoidPtr clang_getCursorCompletionString(@ByValue CXCursor cursor);
+ /**
+ * Returns a default set of code-completion options that can be
+ * passed to\c clang_codeCompleteAt().
+ */
@Generated
@CFunction
public static native int clang_defaultCodeCompleteOptions();
+ /**
+ * Perform code completion at a given location in a translation unit.
+ *
+ * This function performs code completion at a particular file, line, and
+ * column within source code, providing results that suggest potential
+ * code snippets based on the context of the completion. The basic model
+ * for code completion is that Clang will parse a complete source file,
+ * performing syntax checking up to the location where code-completion has
+ * been requested. At that point, a special code-completion token is passed
+ * to the parser, which recognizes this token and determines, based on the
+ * current location in the C/Objective-C/C++ grammar and the state of
+ * semantic analysis, what completions to provide. These completions are
+ * returned via a new \c CXCodeCompleteResults structure.
+ *
+ * Code completion itself is meant to be triggered by the client when the
+ * user types punctuation characters or whitespace, at which point the
+ * code-completion location will coincide with the cursor. For example, if \c p
+ * is a pointer, code-completion might be triggered after the "-" and then
+ * after the ">" in \c p->. When the code-completion location is after the ">",
+ * the completion results will provide, e.g., the members of the struct that
+ * "p" points to. The client is responsible for placing the cursor at the
+ * beginning of the token currently being typed, then filtering the results
+ * based on the contents of the token. For example, when code-completing for
+ * the expression \c p->get, the client should provide the location just after
+ * the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
+ * client can filter the results based on the current token text ("get"), only
+ * showing those results that start with "get". The intent of this interface
+ * is to separate the relatively high-latency acquisition of code-completion
+ * results from the filtering of results on a per-character basis, which must
+ * have a lower latency.
+ *
+ * \param TU The translation unit in which code-completion should
+ * occur. The source files for this translation unit need not be
+ * completely up-to-date (and the contents of those source files may
+ * be overridden via \p unsaved_files). Cursors referring into the
+ * translation unit may be invalidated by this invocation.
+ *
+ * \param complete_filename The name of the source file where code
+ * completion should be performed. This filename may be any file
+ * included in the translation unit.
+ *
+ * \param complete_line The line at which code-completion should occur.
+ *
+ * \param complete_column The column at which code-completion should occur.
+ * Note that the column should point just after the syntactic construct that
+ * initiated code completion, and not in the middle of a lexical token.
+ *
+ * \param unsaved_files the Files that have not yet been saved to disk
+ * but may be required for parsing or code completion, including the
+ * contents of those files. The contents and name of these files (as
+ * specified by CXUnsavedFile) are copied when necessary, so the
+ * client only needs to guarantee their validity until the call to
+ * this function returns.
+ *
+ * \param num_unsaved_files The number of unsaved file entries in \p
+ * unsaved_files.
+ *
+ * \param options Extra options that control the behavior of code
+ * completion, expressed as a bitwise OR of the enumerators of the
+ * CXCodeComplete_Flags enumeration. The
+ * \c clang_defaultCodeCompleteOptions() function returns a default set
+ * of code-completion options.
+ *
+ * \returns If successful, a new \c CXCodeCompleteResults structure
+ * containing code-completion results, which should eventually be
+ * freed with \c clang_disposeCodeCompleteResults(). If code
+ * completion fails, returns NULL.
+ */
@Generated
@CFunction
@UncertainReturn("Options: reference, array Fallback: reference")
@@ -1199,95 +3092,237 @@ public static native CXCodeCompleteResults clang_codeCompleteAt(CXTranslationUni
@UncertainArgument("Options: reference, array Fallback: reference") CXUnsavedFile unsaved_files,
int num_unsaved_files, int options);
+ /**
+ * Sort the code-completion results in case-insensitive alphabetical
+ * order.
+ *
+ * \param Results The set of results to sort.
+ * \param NumResults The number of results in \p Results.
+ */
@Generated
@CFunction
public static native void clang_sortCodeCompletionResults(
@UncertainArgument("Options: reference, array Fallback: reference") CXCompletionResult Results,
int NumResults);
+ /**
+ * Free the given set of code-completion results.
+ */
@Generated
@CFunction
public static native void clang_disposeCodeCompleteResults(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results);
+ /**
+ * Determine the number of diagnostics produced prior to the
+ * location where code completion was performed.
+ */
@Generated
@CFunction
public static native int clang_codeCompleteGetNumDiagnostics(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results);
+ /**
+ * Retrieve a diagnostic associated with the given code completion.
+ *
+ * \param Results the code completion results to query.
+ * \param Index the zero-based diagnostic number to retrieve.
+ *
+ * \returns the requested diagnostic. This diagnostic must be freed
+ * via a call to \c clang_disposeDiagnostic().
+ */
@Generated
@CFunction
public static native VoidPtr clang_codeCompleteGetDiagnostic(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results,
int Index);
+ /**
+ * Determines what completions are appropriate for the context
+ * the given code completion.
+ *
+ * \param Results the code completion results to query
+ *
+ * \returns the kinds of completions that are appropriate for use
+ * along with the given code completion results.
+ */
@Generated
@CFunction
public static native long clang_codeCompleteGetContexts(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results);
+ /**
+ * Returns the cursor kind for the container for the current code
+ * completion context. The container is only guaranteed to be set for
+ * contexts where a container exists (i.e. member accesses or Objective-C
+ * message sends); if there is not a container, this function will return
+ * CXCursor_InvalidCode.
+ *
+ * \param Results the code completion results to query
+ *
+ * \param IsIncomplete on return, this value will be false if Clang has complete
+ * information about the container. If Clang does not have complete
+ * information, this value will be true.
+ *
+ * \returns the container kind, or CXCursor_InvalidCode if there is not a
+ * container
+ */
@Generated
@CFunction
public static native int clang_codeCompleteGetContainerKind(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results,
IntPtr IsIncomplete);
+ /**
+ * Returns the USR for the container for the current code completion
+ * context. If there is not a container for the current context, this
+ * function will return the empty string.
+ *
+ * \param Results the code completion results to query
+ *
+ * \returns the USR for the container
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_codeCompleteGetContainerUSR(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results);
+ /**
+ * Returns the currently-entered selector for an Objective-C message
+ * send, formatted like "initWithFoo:bar:". Only guaranteed to return a
+ * non-empty string for CXCompletionContext_ObjCInstanceMessage and
+ * CXCompletionContext_ObjCClassMessage.
+ *
+ * \param Results the code completion results to query
+ *
+ * \returns the selector (or partial selector) that has been entered thus far
+ * for an Objective-C message send.
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_codeCompleteGetObjCSelector(
@UncertainArgument("Options: reference, array Fallback: reference") CXCodeCompleteResults Results);
+ /**
+ * Return a version string, suitable for showing to a user, but not
+ * intended to be parsed (the format is not guaranteed to be stable).
+ */
@Generated
@CFunction
@ByValue
public static native CXString clang_getClangVersion();
+ /**
+ * Enable/disable crash recovery.
+ *
+ * \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero
+ * value enables crash recovery, while 0 disables it.
+ */
@Generated
@CFunction
public static native void clang_toggleCrashRecovery(int isEnabled);
+ /**
+ * Visit the set of preprocessor inclusions in a translation unit.
+ * The visitor function is called with the provided data for every included
+ * file. This does not include headers included by the PCH file (unless one
+ * is inspecting the inclusions in the PCH file itself).
+ */
@Generated
@CFunction
public static native void clang_getInclusions(CXTranslationUnit tu,
@FunctionPtr(name = "call_clang_getInclusions") Function_clang_getInclusions visitor, VoidPtr client_data);
+ /**
+ * Retrieve a remapping.
+ *
+ * \param path the path that contains metadata about remappings.
+ *
+ * \returns the requested remapping. This remapping must be freed
+ * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
+ */
@Generated
@CFunction
public static native VoidPtr clang_getRemappings(
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String path);
+ /**
+ * Retrieve a remapping.
+ *
+ * \param filePaths pointer to an array of file paths containing remapping info.
+ *
+ * \param numFiles number of file paths.
+ *
+ * \returns the requested remapping. This remapping must be freed
+ * via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
+ */
@Generated
@CFunction
public static native VoidPtr clang_getRemappingsFromFileList(
@UncertainArgument("Options: java.string.array, c.const-byte-ptr-ptr Fallback: java.string.array") @Mapped(CStringArrayMapper.class) String[] filePaths,
int numFiles);
+ /**
+ * Determine the number of remappings.
+ */
@Generated
@CFunction
public static native int clang_remap_getNumFiles(VoidPtr arg1);
+ /**
+ * Get the original and the associated filename from the remapping.
+ *
+ * \param original If non-NULL, will be set to the original filename.
+ *
+ * \param transformed If non-NULL, will be set to the filename that the original
+ * is associated with.
+ */
@Generated
@CFunction
public static native void clang_remap_getFilenames(VoidPtr arg1, int index,
@UncertainArgument("Options: reference, array Fallback: reference") CXString original,
@UncertainArgument("Options: reference, array Fallback: reference") CXString transformed);
+ /**
+ * Dispose the remapping.
+ */
@Generated
@CFunction
public static native void clang_remap_dispose(VoidPtr arg1);
+ /**
+ * Find references of a declaration in a specific file.
+ *
+ * \param cursor pointing to a declaration or a reference of one.
+ *
+ * \param file to search for references.
+ *
+ * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
+ * each reference found.
+ * The CXSourceRange will point inside the file; if the reference is inside
+ * a macro (and not a macro argument) the CXSourceRange will be invalid.
+ *
+ * \returns one of the CXResult enumerators.
+ */
@Generated
@CFunction
public static native int clang_findReferencesInFile(@ByValue CXCursor cursor, VoidPtr file,
@ByValue CXCursorAndRangeVisitor visitor);
+ /**
+ * Find #import/#include directives in a specific file.
+ *
+ * \param TU translation unit containing the file to query.
+ *
+ * \param file to search for #import/#include directives.
+ *
+ * \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
+ * each directive found.
+ *
+ * \returns one of the CXResult enumerators.
+ */
@Generated
@CFunction
public static native int clang_findIncludesInFile(CXTranslationUnit TU, VoidPtr file,
@@ -1349,34 +3384,85 @@ public static native CXIdxIBOutletCollectionAttrInfo clang_index_getIBOutletColl
public static native CXIdxCXXClassDeclInfo clang_index_getCXXClassDeclInfo(
@UncertainArgument("Options: reference, array Fallback: reference") CXIdxDeclInfo arg1);
+ /**
+ * For retrieving a custom CXIdxClientContainer attached to a
+ * container.
+ */
@Generated
@CFunction
public static native VoidPtr clang_index_getClientContainer(
@UncertainArgument("Options: reference, array Fallback: reference") CXIdxContainerInfo arg1);
+ /**
+ * For setting a custom CXIdxClientContainer attached to a
+ * container.
+ */
@Generated
@CFunction
public static native void clang_index_setClientContainer(
@UncertainArgument("Options: reference, array Fallback: reference") CXIdxContainerInfo arg1, VoidPtr arg2);
+ /**
+ * For retrieving a custom CXIdxClientEntity attached to an entity.
+ */
@Generated
@CFunction
public static native VoidPtr clang_index_getClientEntity(
@UncertainArgument("Options: reference, array Fallback: reference") CXIdxEntityInfo arg1);
+ /**
+ * For setting a custom CXIdxClientEntity attached to an entity.
+ */
@Generated
@CFunction
public static native void clang_index_setClientEntity(
@UncertainArgument("Options: reference, array Fallback: reference") CXIdxEntityInfo arg1, VoidPtr arg2);
+ /**
+ * An indexing action/session, to be applied to one or multiple
+ * translation units.
+ *
+ * \param CIdx The index object with which the index action will be associated.
+ */
@Generated
@CFunction
public static native VoidPtr clang_IndexAction_create(VoidPtr CIdx);
+ /**
+ * Destroy the given index action.
+ *
+ * The index action must not be destroyed until all of the translation units
+ * created within that index action have been destroyed.
+ */
@Generated
@CFunction
public static native void clang_IndexAction_dispose(VoidPtr arg1);
+ /**
+ * Index the given source file and the translation unit corresponding
+ * to that file via callbacks implemented through #IndexerCallbacks.
+ *
+ * \param client_data pointer data supplied by the client, which will
+ * be passed to the invoked callbacks.
+ *
+ * \param index_callbacks Pointer to indexing callbacks that the client
+ * implements.
+ *
+ * \param index_callbacks_size Size of #IndexerCallbacks structure that gets
+ * passed in index_callbacks.
+ *
+ * \param index_options A bitmask of options that affects how indexing is
+ * performed. This should be a bitwise OR of the CXIndexOpt_XXX flags.
+ *
+ * \param[out] out_TU pointer to store a \c CXTranslationUnit that can be
+ * reused after indexing is finished. Set to \c NULL if you do not require it.
+ *
+ * \returns 0 on success or if there were errors from which the compiler could
+ * recover. If there is a failure from which there is no recovery, returns
+ * a non-zero \c CXErrorCode.
+ *
+ * The rest of the parameters are the same as #clang_parseTranslationUnit.
+ */
@Generated
@CFunction
public static native int clang_indexSourceFile(VoidPtr arg1, VoidPtr client_data,
@@ -1388,88 +3474,235 @@ public static native int clang_indexSourceFile(VoidPtr arg1, VoidPtr client_data
@UncertainArgument("Options: reference, array Fallback: reference") CXUnsavedFile unsaved_files,
int num_unsaved_files, Ptr out_TU, int TU_options);
+ /**
+ * Index the given translation unit via callbacks implemented through
+ * #IndexerCallbacks.
+ *
+ * The order of callback invocations is not guaranteed to be the same as
+ * when indexing a source file. The high level order will be:
+ *
+ * -Preprocessor callbacks invocations
+ * -Declaration/reference callbacks invocations
+ * -Diagnostic callback invocations
+ *
+ * The parameters are the same as #clang_indexSourceFile.
+ *
+ * \returns If there is a failure from which there is no recovery, returns
+ * non-zero, otherwise returns 0.
+ */
@Generated
@CFunction
public static native int clang_indexTranslationUnit(VoidPtr arg1, VoidPtr client_data,
@UncertainArgument("Options: reference, array Fallback: reference") IndexerCallbacks index_callbacks,
int index_callbacks_size, int index_options, CXTranslationUnit arg6);
+ /**
+ * Retrieve the CXIdxFile, file, line, column, and offset represented by
+ * the given CXIdxLoc.
+ *
+ * If the location refers into a macro expansion, retrieves the
+ * location of the macro expansion and if it refers into a macro argument
+ * retrieves the location of the argument.
+ */
@Generated
@CFunction
public static native void clang_indexLoc_getFileLocation(@ByValue CXIdxLoc loc, Ptr indexFile,
Ptr file, IntPtr line, IntPtr column, IntPtr offset);
+ /**
+ * Retrieve the CXSourceLocation represented by the given CXIdxLoc.
+ */
@Generated
@CFunction
@ByValue
public static native CXSourceLocation clang_indexLoc_getCXSourceLocation(@ByValue CXIdxLoc loc);
+ /**
+ * Return the timestamp for use with Clang's
+ * \c -fbuild-session-timestamp= option.
+ */
@Generated
@CFunction
public static native long clang_getBuildSessionTimestamp();
+ /**
+ * Create a \c CXVirtualFileOverlay object.
+ * Must be disposed with \c clang_VirtualFileOverlay_dispose().
+ *
+ * \param options is reserved, always pass 0.
+ */
@Generated
@CFunction
public static native CXVirtualFileOverlay clang_VirtualFileOverlay_create(int options);
+ /**
+ * Map an absolute virtual file path to an absolute real one.
+ * The virtual path must be canonicalized (not contain "."/"..").
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_VirtualFileOverlay_addFileMapping(CXVirtualFileOverlay arg1,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String virtualPath,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String realPath);
+ /**
+ * Set the case sensitivity for the \c CXVirtualFileOverlay object.
+ * The \c CXVirtualFileOverlay object is case-sensitive by default, this
+ * option can be used to override the default.
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_VirtualFileOverlay_setCaseSensitivity(CXVirtualFileOverlay arg1, int caseSensitive);
+ /**
+ * Write out the \c CXVirtualFileOverlay object to a char buffer.
+ *
+ * \param options is reserved, always pass 0.
+ * \param out_buffer_ptr pointer to receive the buffer pointer, which should be
+ * disposed using \c clang_free().
+ * \param out_buffer_size pointer to receive the buffer size.
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_VirtualFileOverlay_writeToBuffer(CXVirtualFileOverlay arg1, int options,
Ptr out_buffer_ptr, IntPtr out_buffer_size);
+ /**
+ * Dispose a \c CXVirtualFileOverlay object.
+ */
@Generated
@CFunction
public static native void clang_VirtualFileOverlay_dispose(CXVirtualFileOverlay arg1);
+ /**
+ * Create a \c CXModuleMapDescriptor object.
+ * Must be disposed with \c clang_ModuleMapDescriptor_dispose().
+ *
+ * \param options is reserved, always pass 0.
+ */
@Generated
@CFunction
public static native CXModuleMapDescriptor clang_ModuleMapDescriptor_create(int options);
+ /**
+ * Sets the framework module name that the module.map describes.
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_ModuleMapDescriptor_setFrameworkModuleName(CXModuleMapDescriptor arg1,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String name);
+ /**
+ * Sets the umbrella header name that the module.map describes.
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_ModuleMapDescriptor_setUmbrellaHeader(CXModuleMapDescriptor arg1,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String name);
+ /**
+ * Write out the \c CXModuleMapDescriptor object to a char buffer.
+ *
+ * \param options is reserved, always pass 0.
+ * \param out_buffer_ptr pointer to receive the buffer pointer, which should be
+ * disposed using \c clang_free().
+ * \param out_buffer_size pointer to receive the buffer size.
+ * \returns 0 for success, non-zero to indicate an error.
+ */
@Generated
@CFunction
public static native int clang_ModuleMapDescriptor_writeToBuffer(CXModuleMapDescriptor arg1, int options,
Ptr out_buffer_ptr, IntPtr out_buffer_size);
+ /**
+ * Dispose a \c CXModuleMapDescriptor object.
+ */
@Generated
@CFunction
public static native void clang_ModuleMapDescriptor_dispose(CXModuleMapDescriptor arg1);
+ /**
+ * Retrieve all ranges that were skipped by the preprocessor.
+ *
+ * The preprocessor will skip lines when they are surrounded by an
+ * if/ifdef/ifndef directive whose condition does not evaluate to true.
+ */
@Generated
@CFunction
@UncertainReturn("Options: reference, array Fallback: reference")
public static native CXSourceRangeList clang_getSkippedRanges(CXTranslationUnit tu, VoidPtr file);
+ /**
+ * Destroy the given \c CXSourceRangeList.
+ */
@Generated
@CFunction
public static native void clang_disposeSourceRangeList(
@UncertainArgument("Options: reference, array Fallback: reference") CXSourceRangeList ranges);
+ /**
+ * Create a translation unit from an AST file (\c -emit-ast).
+ *
+ * \param[out] out_TU A non-NULL pointer to store the created
+ * \c CXTranslationUnit.
+ *
+ * \returns Zero on success, otherwise returns an error code.
+ */
@Generated
@CFunction
public static native int clang_createTranslationUnit2(VoidPtr CIdx,
@UncertainArgument("Options: java.string, c.const-byte-ptr Fallback: java.string") String ast_filename,
Ptr out_TU);
+ /**
+ * Parse the given source file and the translation unit corresponding
+ * to that file.
+ *
+ * This routine is the main entry point for the Clang C API, providing the
+ * ability to parse a source file into a translation unit that can then be
+ * queried by other functions in the API. This routine accepts a set of
+ * command-line arguments so that the compilation can be configured in the same
+ * way that the compiler is configured on the command line.
+ *
+ * \param CIdx The index object with which the translation unit will be
+ * associated.
+ *
+ * \param source_filename The name of the source file to load, or NULL if the
+ * source file is included in \c command_line_args.
+ *
+ * \param command_line_args The command-line arguments that would be
+ * passed to the \c clang executable if it were being invoked out-of-process.
+ * These command-line options will be parsed and will affect how the translation
+ * unit is parsed. Note that the following options are ignored: '-c',
+ * '-emit-ast', '-fsyntax-only' (which is the default), and '-o \