Index.h source code [clang_source_code/include/clang-c/Index.h]

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