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

Browse the source code of llvm_projects/clang/include/clang-c/Index.h