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 directive.*
1914	*/
1915	CXCursor_OMPOrderedDirective = `248`,
1916
1917	/* OpenMP atomic directive.*
1918	*/
1919	CXCursor_OMPAtomicDirective = `249`,
1920
1921	/* OpenMP for SIMD directive.*
1922	*/
1923	CXCursor_OMPForSimdDirective = `250`,
1924
1925	/* OpenMP parallel for SIMD directive.*
1926	*/
1927	CXCursor_OMPParallelForSimdDirective = `251`,
1928
1929	/* OpenMP target directive.*
1930	*/
1931	CXCursor_OMPTargetDirective = `252`,
1932
1933	/* OpenMP teams directive.*
1934	*/
1935	CXCursor_OMPTeamsDirective = `253`,
1936
1937	/* OpenMP taskgroup directive.*
1938	*/
1939	CXCursor_OMPTaskgroupDirective = `254`,
1940
1941	/* OpenMP cancellation point directive.*
1942	*/
1943	CXCursor_OMPCancellationPointDirective = `255`,
1944
1945	/* OpenMP cancel directive.*
1946	*/
1947	CXCursor_OMPCancelDirective = `256`,
1948
1949	/* OpenMP target data directive.*
1950	*/
1951	CXCursor_OMPTargetDataDirective = `257`,
1952
1953	/* OpenMP taskloop directive.*
1954	*/
1955	CXCursor_OMPTaskLoopDirective = `258`,
1956
1957	/* OpenMP taskloop simd directive.*
1958	*/
1959	CXCursor_OMPTaskLoopSimdDirective = `259`,
1960
1961	/* OpenMP distribute directive.*
1962	*/
1963	CXCursor_OMPDistributeDirective = `260`,
1964
1965	/* OpenMP target enter data directive.*
1966	*/
1967	CXCursor_OMPTargetEnterDataDirective = `261`,
1968
1969	/* OpenMP target exit data directive.*
1970	*/
1971	CXCursor_OMPTargetExitDataDirective = `262`,
1972
1973	/* OpenMP target parallel directive.*
1974	*/
1975	CXCursor_OMPTargetParallelDirective = `263`,
1976
1977	/* OpenMP target parallel for directive.*
1978	*/
1979	CXCursor_OMPTargetParallelForDirective = `264`,
1980
1981	/* OpenMP target update directive.*
1982	*/
1983	CXCursor_OMPTargetUpdateDirective = `265`,
1984
1985	/* OpenMP distribute parallel for directive.*
1986	*/
1987	CXCursor_OMPDistributeParallelForDirective = `266`,
1988
1989	/* OpenMP distribute parallel for simd directive.*
1990	*/
1991	CXCursor_OMPDistributeParallelForSimdDirective = `267`,
1992
1993	/* OpenMP distribute simd directive.*
1994	*/
1995	CXCursor_OMPDistributeSimdDirective = `268`,
1996
1997	/* OpenMP target parallel for simd directive.*
1998	*/
1999	CXCursor_OMPTargetParallelForSimdDirective = `269`,
2000
2001	/* OpenMP target simd directive.*
2002	*/
2003	CXCursor_OMPTargetSimdDirective = `270`,
2004
2005	/* OpenMP teams distribute directive.*
2006	*/
2007	CXCursor_OMPTeamsDistributeDirective = `271`,
2008
2009	/* OpenMP teams distribute simd directive.*
2010	*/
2011	CXCursor_OMPTeamsDistributeSimdDirective = `272`,
2012
2013	/* OpenMP teams distribute parallel for simd directive.*
2014	*/
2015	CXCursor_OMPTeamsDistributeParallelForSimdDirective = `273`,
2016
2017	/* OpenMP teams distribute parallel for directive.*
2018	*/
2019	CXCursor_OMPTeamsDistributeParallelForDirective = `274`,
2020
2021	/* OpenMP target teams directive.*
2022	*/
2023	CXCursor_OMPTargetTeamsDirective = `275`,
2024
2025	/* OpenMP target teams distribute directive.*
2026	*/
2027	CXCursor_OMPTargetTeamsDistributeDirective = `276`,
2028
2029	/* OpenMP target teams distribute parallel for directive.*
2030	*/
2031	CXCursor_OMPTargetTeamsDistributeParallelForDirective = `277`,
2032
2033	/* OpenMP target teams distribute parallel for simd directive.*
2034	*/
2035	CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective = `278`,
2036
2037	/* OpenMP target teams distribute simd directive.*
2038	*/
2039	CXCursor_OMPTargetTeamsDistributeSimdDirective = `279`,
2040
2041	/* C++2a std::bit_cast expression.*
2042	*/
2043	CXCursor_BuiltinBitCastExpr = `280`,
2044
2045	/* OpenMP master taskloop directive.*
2046	*/
2047	CXCursor_OMPMasterTaskLoopDirective = `281`,
2048
2049	/* OpenMP parallel master taskloop directive.*
2050	*/
2051	CXCursor_OMPParallelMasterTaskLoopDirective = `282`,
2052
2053	/* OpenMP master taskloop simd directive.*
2054	*/
2055	CXCursor_OMPMasterTaskLoopSimdDirective = `283`,
2056
2057	/* OpenMP parallel master taskloop simd directive.*
2058	*/
2059	CXCursor_OMPParallelMasterTaskLoopSimdDirective = `284`,
2060
2061	/* OpenMP parallel master directive.*
2062	*/
2063	CXCursor_OMPParallelMasterDirective = `285`,
2064
2065	/* OpenMP depobj directive.*
2066	*/
2067	CXCursor_OMPDepobjDirective = `286`,
2068
2069	/* OpenMP scan directive.*
2070	*/
2071	CXCursor_OMPScanDirective = `287`,
2072
2073	/* OpenMP tile directive.*
2074	*/
2075	CXCursor_OMPTileDirective = `288`,
2076
2077	/* OpenMP canonical loop.*
2078	*/
2079	CXCursor_OMPCanonicalLoop = `289`,
2080
2081	/* OpenMP interop directive.*
2082	*/
2083	CXCursor_OMPInteropDirective = `290`,
2084
2085	/* OpenMP dispatch directive.*
2086	*/
2087	CXCursor_OMPDispatchDirective = `291`,
2088
2089	/* OpenMP masked directive.*
2090	*/
2091	CXCursor_OMPMaskedDirective = `292`,
2092
2093	/* OpenMP unroll directive.*
2094	*/
2095	CXCursor_OMPUnrollDirective = `293`,
2096
2097	/* OpenMP metadirective directive.*
2098	*/
2099	CXCursor_OMPMetaDirective = `294`,
2100
2101	/* OpenMP loop directive.*
2102	*/
2103	CXCursor_OMPGenericLoopDirective = `295`,
2104
2105	/* OpenMP teams loop directive.*
2106	*/
2107	CXCursor_OMPTeamsGenericLoopDirective = `296`,
2108
2109	/* OpenMP target teams loop directive.*
2110	*/
2111	CXCursor_OMPTargetTeamsGenericLoopDirective = `297`,
2112
2113	/* OpenMP parallel loop directive.*
2114	*/
2115	CXCursor_OMPParallelGenericLoopDirective = `298`,
2116
2117	/* OpenMP target parallel loop directive.*
2118	*/
2119	CXCursor_OMPTargetParallelGenericLoopDirective = `299`,
2120
2121	/* OpenMP parallel masked directive.*
2122	*/
2123	CXCursor_OMPParallelMaskedDirective = `300`,
2124
2125	/* OpenMP masked taskloop directive.*
2126	*/
2127	CXCursor_OMPMaskedTaskLoopDirective = `301`,
2128
2129	/* OpenMP masked taskloop simd directive.*
2130	*/
2131	CXCursor_OMPMaskedTaskLoopSimdDirective = `302`,
2132
2133	/* OpenMP parallel masked taskloop directive.*
2134	*/
2135	CXCursor_OMPParallelMaskedTaskLoopDirective = `303`,
2136
2137	/* OpenMP parallel masked taskloop simd directive.*
2138	*/
2139	CXCursor_OMPParallelMaskedTaskLoopSimdDirective = `304`,
2140
2141	/* OpenMP error directive.*
2142	*/
2143	CXCursor_OMPErrorDirective = `305`,
2144
2145	/* OpenMP scope directive.*
2146	*/
2147	CXCursor_OMPScopeDirective = `306`,
2148
2149	/* OpenMP reverse directive.*
2150	*/
2151	CXCursor_OMPReverseDirective = `307`,
2152
2153	/* OpenMP interchange directive.*
2154	*/
2155	CXCursor_OMPInterchangeDirective = `308`,
2156
2157	/* OpenACC Compute Construct.*
2158	*/
2159	CXCursor_OpenACCComputeConstruct = `320`,
2160
2161	/* OpenACC Loop Construct.*
2162	*/
2163	CXCursor_OpenACCLoopConstruct = `321`,
2164
2165	CXCursor_LastStmt = CXCursor_OpenACCLoopConstruct,
2166
2167	/**
2168	* Cursor that represents the translation unit itself.
2169	*
2170	* The translation unit cursor exists primarily to act as the root
2171	* cursor for traversing the contents of a translation unit.
2172	*/
2173	CXCursor_TranslationUnit = `350`,
2174
2175	/ Attributes /
2176	CXCursor_FirstAttr = `400`,
2177	/**
2178	* An attribute whose specific kind is not exposed via this
2179	* interface.
2180	*/
2181	CXCursor_UnexposedAttr = `400`,
2182
2183	CXCursor_IBActionAttr = `401`,
2184	CXCursor_IBOutletAttr = `402`,
2185	CXCursor_IBOutletCollectionAttr = `403`,
2186	CXCursor_CXXFinalAttr = `404`,
2187	CXCursor_CXXOverrideAttr = `405`,
2188	CXCursor_AnnotateAttr = `406`,
2189	CXCursor_AsmLabelAttr = `407`,
2190	CXCursor_PackedAttr = `408`,
2191	CXCursor_PureAttr = `409`,
2192	CXCursor_ConstAttr = `410`,
2193	CXCursor_NoDuplicateAttr = `411`,
2194	CXCursor_CUDAConstantAttr = `412`,
2195	CXCursor_CUDADeviceAttr = `413`,
2196	CXCursor_CUDAGlobalAttr = `414`,
2197	CXCursor_CUDAHostAttr = `415`,
2198	CXCursor_CUDASharedAttr = `416`,
2199	CXCursor_VisibilityAttr = `417`,
2200	CXCursor_DLLExport = `418`,
2201	CXCursor_DLLImport = `419`,
2202	CXCursor_NSReturnsRetained = `420`,
2203	CXCursor_NSReturnsNotRetained = `421`,
2204	CXCursor_NSReturnsAutoreleased = `422`,
2205	CXCursor_NSConsumesSelf = `423`,
2206	CXCursor_NSConsumed = `424`,
2207	CXCursor_ObjCException = `425`,
2208	CXCursor_ObjCNSObject = `426`,
2209	CXCursor_ObjCIndependentClass = `427`,
2210	CXCursor_ObjCPreciseLifetime = `428`,
2211	CXCursor_ObjCReturnsInnerPointer = `429`,
2212	CXCursor_ObjCRequiresSuper = `430`,
2213	CXCursor_ObjCRootClass = `431`,
2214	CXCursor_ObjCSubclassingRestricted = `432`,
2215	CXCursor_ObjCExplicitProtocolImpl = `433`,
2216	CXCursor_ObjCDesignatedInitializer = `434`,
2217	CXCursor_ObjCRuntimeVisible = `435`,
2218	CXCursor_ObjCBoxable = `436`,
2219	CXCursor_FlagEnum = `437`,
2220	CXCursor_ConvergentAttr = `438`,
2221	CXCursor_WarnUnusedAttr = `439`,
2222	CXCursor_WarnUnusedResultAttr = `440`,
2223	CXCursor_AlignedAttr = `441`,
2224	CXCursor_LastAttr = CXCursor_AlignedAttr,
2225
2226	/ Preprocessing /
2227	CXCursor_PreprocessingDirective = `500`,
2228	CXCursor_MacroDefinition = `501`,
2229	CXCursor_MacroExpansion = `502`,
2230	CXCursor_MacroInstantiation = CXCursor_MacroExpansion,
2231	CXCursor_InclusionDirective = `503`,
2232	CXCursor_FirstPreprocessing = CXCursor_PreprocessingDirective,
2233	CXCursor_LastPreprocessing = CXCursor_InclusionDirective,
2234
2235	/ Extra Declarations /
2236	/**
2237	* A module import declaration.
2238	*/
2239	CXCursor_ModuleImportDecl = `600`,
2240	CXCursor_TypeAliasTemplateDecl = `601`,
2241	/**
2242	* A static_assert or _Static_assert node
2243	*/
2244	CXCursor_StaticAssert = `602`,
2245	/**
2246	* a friend declaration.
2247	*/
2248	CXCursor_FriendDecl = `603`,
2249	/**
2250	* a concept declaration.
2251	*/
2252	CXCursor_ConceptDecl = `604`,
2253
2254	CXCursor_FirstExtraDecl = CXCursor_ModuleImportDecl,
2255	CXCursor_LastExtraDecl = CXCursor_ConceptDecl,
2256
2257	/**
2258	* A code completion overload candidate.
2259	*/
2260	CXCursor_OverloadCandidate = `700`
2261	};
2262
2263	/**
2264	* A cursor representing some element in the abstract syntax tree for
2265	* a translation unit.
2266	*
2267	* The cursor abstraction unifies the different kinds of entities in a
2268	* program--declaration, statements, expressions, references to declarations,
2269	* etc.--under a single "cursor" abstraction with a common set of operations.
2270	* Common operation for a cursor include: getting the physical location in
2271	* a source file where the cursor points, getting the name associated with a
2272	* cursor, and retrieving cursors for any child nodes of a particular cursor.
2273	*
2274	* Cursors can be produced in two specific ways.
2275	* clang_getTranslationUnitCursor() produces a cursor for a translation unit,
2276	* from which one can use clang_visitChildren() to explore the rest of the
2277	* translation unit. clang_getCursor() maps from a physical source location
2278	* to the entity that resides at that location, allowing one to map from the
2279	* source code into the AST.
2280	*/
2281	typedef struct {
2282	enum CXCursorKind kind;
2283	int xdata;
2284	const void *data[`3`];
2285	} CXCursor;
2286
2287	/**
2288	* \defgroup CINDEX_CURSOR_MANIP Cursor manipulations
2289	*
2290	* @{
2291	*/
2292
2293	/**
2294	* Retrieve the NULL cursor, which represents no entity.
2295	*/
2296	CINDEX_LINKAGE CXCursor clang_getNullCursor(void);
2297
2298	/**
2299	* Retrieve the cursor that represents the given translation unit.
2300	*
2301	* The translation unit cursor can be used to start traversing the
2302	* various declarations within the given translation unit.
2303	*/
2304	CINDEX_LINKAGE CXCursor clang_getTranslationUnitCursor(CXTranslationUnit);
2305
2306	/**
2307	* Determine whether two cursors are equivalent.
2308	*/
2309	CINDEX_LINKAGE unsigned clang_equalCursors(CXCursor, CXCursor);
2310
2311	/**
2312	* Returns non-zero if \p cursor is null.
2313	*/
2314	CINDEX_LINKAGE int clang_Cursor_isNull(CXCursor cursor);
2315
2316	/**
2317	* Compute a hash value for the given cursor.
2318	*/
2319	CINDEX_LINKAGE unsigned clang_hashCursor(CXCursor);
2320
2321	/**
2322	* Retrieve the kind of the given cursor.
2323	*/
2324	CINDEX_LINKAGE enum CXCursorKind clang_getCursorKind(CXCursor);
2325
2326	/**
2327	* Determine whether the given cursor kind represents a declaration.
2328	*/
2329	CINDEX_LINKAGE unsigned clang_isDeclaration(enum CXCursorKind);
2330
2331	/**
2332	* Determine whether the given declaration is invalid.
2333	*
2334	* A declaration is invalid if it could not be parsed successfully.
2335	*
2336	* \returns non-zero if the cursor represents a declaration and it is
2337	* invalid, otherwise NULL.
2338	*/
2339	CINDEX_LINKAGE unsigned clang_isInvalidDeclaration(CXCursor);
2340
2341	/**
2342	* Determine whether the given cursor kind represents a simple
2343	* reference.
2344	*
2345	* Note that other kinds of cursors (such as expressions) can also refer to
2346	* other cursors. Use clang_getCursorReferenced() to determine whether a
2347	* particular cursor refers to another entity.
2348	*/
2349	CINDEX_LINKAGE unsigned clang_isReference(enum CXCursorKind);
2350
2351	/**
2352	* Determine whether the given cursor kind represents an expression.
2353	*/
2354	CINDEX_LINKAGE unsigned clang_isExpression(enum CXCursorKind);
2355
2356	/**
2357	* Determine whether the given cursor kind represents a statement.
2358	*/
2359	CINDEX_LINKAGE unsigned clang_isStatement(enum CXCursorKind);
2360
2361	/**
2362	* Determine whether the given cursor kind represents an attribute.
2363	*/
2364	CINDEX_LINKAGE unsigned clang_isAttribute(enum CXCursorKind);
2365
2366	/**
2367	* Determine whether the given cursor has any attributes.
2368	*/
2369	CINDEX_LINKAGE unsigned clang_Cursor_hasAttrs(CXCursor C);
2370
2371	/**
2372	* Determine whether the given cursor kind represents an invalid
2373	* cursor.
2374	*/
2375	CINDEX_LINKAGE unsigned clang_isInvalid(enum CXCursorKind);
2376
2377	/**
2378	* Determine whether the given cursor kind represents a translation
2379	* unit.
2380	*/
2381	CINDEX_LINKAGE unsigned clang_isTranslationUnit(enum CXCursorKind);
2382
2383	/***
2384	* Determine whether the given cursor represents a preprocessing
2385	* element, such as a preprocessor directive or macro instantiation.
2386	*/
2387	CINDEX_LINKAGE unsigned clang_isPreprocessing(enum CXCursorKind);
2388
2389	/***
2390	* Determine whether the given cursor represents a currently
2391	* unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).
2392	*/
2393	CINDEX_LINKAGE unsigned clang_isUnexposed(enum CXCursorKind);
2394
2395	/**
2396	* Describe the linkage of the entity referred to by a cursor.
2397	*/
2398	enum CXLinkageKind {
2399	/* This value indicates that no linkage information is available*
2400	* for a provided CXCursor. */
2401	CXLinkage_Invalid,
2402	/**
2403	* This is the linkage for variables, parameters, and so on that
2404	* have automatic storage. This covers normal (non-extern) local variables.
2405	*/
2406	CXLinkage_NoLinkage,
2407	/* This is the linkage for static variables and static functions. /
2408	CXLinkage_Internal,
2409	/* This is the linkage for entities with external linkage that live*
2410	* in C++ anonymous namespaces.*/
2411	CXLinkage_UniqueExternal,
2412	/* This is the linkage for entities with true, external linkage. /
2413	CXLinkage_External
2414	};
2415
2416	/**
2417	* Determine the linkage of the entity referred to by a given cursor.
2418	*/
2419	CINDEX_LINKAGE enum CXLinkageKind clang_getCursorLinkage(CXCursor cursor);
2420
2421	enum CXVisibilityKind {
2422	/* This value indicates that no visibility information is available*
2423	* for a provided CXCursor. */
2424	CXVisibility_Invalid,
2425
2426	/* Symbol not seen by the linker. /
2427	CXVisibility_Hidden,
2428	/* Symbol seen by the linker but resolves to a symbol inside this object. /
2429	CXVisibility_Protected,
2430	/* Symbol seen by the linker and acts like a normal symbol. /
2431	CXVisibility_Default
2432	};
2433
2434	/**
2435	* Describe the visibility of the entity referred to by a cursor.
2436	*
2437	* This returns the default visibility if not explicitly specified by
2438	* a visibility attribute. The default visibility may be changed by
2439	* commandline arguments.
2440	*
2441	* \param cursor The cursor to query.
2442	*
2443	* \returns The visibility of the cursor.
2444	*/
2445	CINDEX_LINKAGE enum CXVisibilityKind clang_getCursorVisibility(CXCursor cursor);
2446
2447	/**
2448	* Determine the availability of the entity that this cursor refers to,
2449	* taking the current target platform into account.
2450	*
2451	* \param cursor The cursor to query.
2452	*
2453	* \returns The availability of the cursor.
2454	*/
2455	CINDEX_LINKAGE enum CXAvailabilityKind
2456	clang_getCursorAvailability(CXCursor cursor);
2457
2458	/**
2459	* Describes the availability of a given entity on a particular platform, e.g.,
2460	* a particular class might only be available on Mac OS 10.7 or newer.
2461	*/
2462	typedef struct CXPlatformAvailability {
2463	/**
2464	* A string that describes the platform for which this structure
2465	* provides availability information.
2466	*
2467	* Possible values are "ios" or "macos".
2468	*/
2469	CXString Platform;
2470	/**
2471	* The version number in which this entity was introduced.
2472	*/
2473	CXVersion Introduced;
2474	/**
2475	* The version number in which this entity was deprecated (but is
2476	* still available).
2477	*/
2478	CXVersion Deprecated;
2479	/**
2480	* The version number in which this entity was obsoleted, and therefore
2481	* is no longer available.
2482	*/
2483	CXVersion Obsoleted;
2484	/**
2485	* Whether the entity is unconditionally unavailable on this platform.
2486	*/
2487	int Unavailable;
2488	/**
2489	* An optional message to provide to a user of this API, e.g., to
2490	* suggest replacement APIs.
2491	*/
2492	CXString Message;
2493	} CXPlatformAvailability;
2494
2495	/**
2496	* Determine the availability of the entity that this cursor refers to
2497	* on any platforms for which availability information is known.
2498	*
2499	* \param cursor The cursor to query.
2500	*
2501	* \param always_deprecated If non-NULL, will be set to indicate whether the
2502	* entity is deprecated on all platforms.
2503	*
2504	* \param deprecated_message If non-NULL, will be set to the message text
2505	* provided along with the unconditional deprecation of this entity. The client
2506	* is responsible for deallocating this string.
2507	*
2508	* \param always_unavailable If non-NULL, will be set to indicate whether the
2509	* entity is unavailable on all platforms.
2510	*
2511	* \param unavailable_message If non-NULL, will be set to the message text
2512	* provided along with the unconditional unavailability of this entity. The
2513	* client is responsible for deallocating this string.
2514	*
2515	* \param availability If non-NULL, an array of CXPlatformAvailability instances
2516	* that will be populated with platform availability information, up to either
2517	* the number of platforms for which availability information is available (as
2518	* returned by this function) or \c availability_size, whichever is smaller.
2519	*
2520	* \param availability_size The number of elements available in the
2521	* \c availability array.
2522	*
2523	* \returns The number of platforms (N) for which availability information is
2524	* available (which is unrelated to \c availability_size).
2525	*
2526	* Note that the client is responsible for calling
2527	* \c clang_disposeCXPlatformAvailability to free each of the
2528	* platform-availability structures returned. There are
2529	* \c min(N, availability_size) such structures.
2530	*/
2531	CINDEX_LINKAGE int clang_getCursorPlatformAvailability(
2532	CXCursor cursor, int always_deprecated, CXString deprecated_message,
2533	int always_unavailable, CXString unavailable_message,
2534	CXPlatformAvailability availability, int* availability_size);
2535
2536	/**
2537	* Free the memory associated with a \c CXPlatformAvailability structure.
2538	*/
2539	CINDEX_LINKAGE void
2540	clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability);
2541
2542	/**
2543	* If cursor refers to a variable declaration and it has initializer returns
2544	* cursor referring to the initializer otherwise return null cursor.
2545	*/
2546	CINDEX_LINKAGE CXCursor clang_Cursor_getVarDeclInitializer(CXCursor cursor);
2547
2548	/**
2549	* If cursor refers to a variable declaration that has global storage returns 1.
2550	* If cursor refers to a variable declaration that doesn't have global storage
2551	* returns 0. Otherwise returns -1.
2552	*/
2553	CINDEX_LINKAGE int clang_Cursor_hasVarDeclGlobalStorage(CXCursor cursor);
2554
2555	/**
2556	* If cursor refers to a variable declaration that has external storage
2557	* returns 1. If cursor refers to a variable declaration that doesn't have
2558	* external storage returns 0. Otherwise returns -1.
2559	*/
2560	CINDEX_LINKAGE int clang_Cursor_hasVarDeclExternalStorage(CXCursor cursor);
2561
2562	/**
2563	* Describe the "language" of the entity referred to by a cursor.
2564	*/
2565	enum CXLanguageKind {
2566	CXLanguage_Invalid = `0`,
2567	CXLanguage_C,
2568	CXLanguage_ObjC,
2569	CXLanguage_CPlusPlus
2570	};
2571
2572	/**
2573	* Determine the "language" of the entity referred to by a given cursor.
2574	*/
2575	CINDEX_LINKAGE enum CXLanguageKind clang_getCursorLanguage(CXCursor cursor);
2576
2577	/**
2578	* Describe the "thread-local storage (TLS) kind" of the declaration
2579	* referred to by a cursor.
2580	*/
2581	enum CXTLSKind { CXTLS_None = `0`, CXTLS_Dynamic, CXTLS_Static };
2582
2583	/**
2584	* Determine the "thread-local storage (TLS) kind" of the declaration
2585	* referred to by a cursor.
2586	*/
2587	CINDEX_LINKAGE enum CXTLSKind clang_getCursorTLSKind(CXCursor cursor);
2588
2589	/**
2590	* Returns the translation unit that a cursor originated from.
2591	*/
2592	CINDEX_LINKAGE CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor);
2593
2594	/**
2595	* A fast container representing a set of CXCursors.
2596	*/
2597	typedef struct CXCursorSetImpl *CXCursorSet;
2598
2599	/**
2600	* Creates an empty CXCursorSet.
2601	*/
2602	CINDEX_LINKAGE CXCursorSet clang_createCXCursorSet(void);
2603
2604	/**
2605	* Disposes a CXCursorSet and releases its associated memory.
2606	*/
2607	CINDEX_LINKAGE void clang_disposeCXCursorSet(CXCursorSet cset);
2608
2609	/**
2610	* Queries a CXCursorSet to see if it contains a specific CXCursor.
2611	*
2612	* \returns non-zero if the set contains the specified cursor.
2613	*/
2614	CINDEX_LINKAGE unsigned clang_CXCursorSet_contains(CXCursorSet cset,
2615	CXCursor cursor);
2616
2617	/**
2618	* Inserts a CXCursor into a CXCursorSet.
2619	*
2620	* \returns zero if the CXCursor was already in the set, and non-zero otherwise.
2621	*/
2622	CINDEX_LINKAGE unsigned clang_CXCursorSet_insert(CXCursorSet cset,
2623	CXCursor cursor);
2624
2625	/**
2626	* Determine the semantic parent of the given cursor.
2627	*
2628	* The semantic parent of a cursor is the cursor that semantically contains
2629	* the given \p cursor. For many declarations, the lexical and semantic parents
2630	* are equivalent (the lexical parent is returned by
2631	* \c clang_getCursorLexicalParent()). They diverge when declarations or
2632	* definitions are provided out-of-line. For example:
2633	*
2634	* \code
2635	* class C {
2636	* void f();
2637	* };
2638	*
2639	* void C::f() { }
2640	* \endcode
2641	*
2642	* In the out-of-line definition of \c C::f, the semantic parent is
2643	* the class \c C, of which this function is a member. The lexical parent is
2644	* the place where the declaration actually occurs in the source code; in this
2645	* case, the definition occurs in the translation unit. In general, the
2646	* lexical parent for a given entity can change without affecting the semantics
2647	* of the program, and the lexical parent of different declarations of the
2648	* same entity may be different. Changing the semantic parent of a declaration,
2649	* on the other hand, can have a major impact on semantics, and redeclarations
2650	* of a particular entity should all have the same semantic context.
2651	*
2652	* In the example above, both declarations of \c C::f have \c C as their
2653	* semantic context, while the lexical context of the first \c C::f is \c C
2654	* and the lexical context of the second \c C::f is the translation unit.
2655	*
2656	* For global declarations, the semantic parent is the translation unit.
2657	*/
2658	CINDEX_LINKAGE CXCursor clang_getCursorSemanticParent(CXCursor cursor);
2659
2660	/**
2661	* Determine the lexical parent of the given cursor.
2662	*
2663	* The lexical parent of a cursor is the cursor in which the given \p cursor
2664	* was actually written. For many declarations, the lexical and semantic parents
2665	* are equivalent (the semantic parent is returned by
2666	* \c clang_getCursorSemanticParent()). They diverge when declarations or
2667	* definitions are provided out-of-line. For example:
2668	*
2669	* \code
2670	* class C {
2671	* void f();
2672	* };
2673	*
2674	* void C::f() { }
2675	* \endcode
2676	*
2677	* In the out-of-line definition of \c C::f, the semantic parent is
2678	* the class \c C, of which this function is a member. The lexical parent is
2679	* the place where the declaration actually occurs in the source code; in this
2680	* case, the definition occurs in the translation unit. In general, the
2681	* lexical parent for a given entity can change without affecting the semantics
2682	* of the program, and the lexical parent of different declarations of the
2683	* same entity may be different. Changing the semantic parent of a declaration,
2684	* on the other hand, can have a major impact on semantics, and redeclarations
2685	* of a particular entity should all have the same semantic context.
2686	*
2687	* In the example above, both declarations of \c C::f have \c C as their
2688	* semantic context, while the lexical context of the first \c C::f is \c C
2689	* and the lexical context of the second \c C::f is the translation unit.
2690	*
2691	* For declarations written in the global scope, the lexical parent is
2692	* the translation unit.
2693	*/
2694	CINDEX_LINKAGE CXCursor clang_getCursorLexicalParent(CXCursor cursor);
2695
2696	/**
2697	* Determine the set of methods that are overridden by the given
2698	* method.
2699	*
2700	* In both Objective-C and C++, a method (aka virtual member function,
2701	* in C++) can override a virtual method in a base class. For
2702	* Objective-C, a method is said to override any method in the class's
2703	* base class, its protocols, or its categories' protocols, that has the same
2704	* selector and is of the same kind (class or instance).
2705	* If no such method exists, the search continues to the class's superclass,
2706	* its protocols, and its categories, and so on. A method from an Objective-C
2707	* implementation is considered to override the same methods as its
2708	* corresponding method in the interface.
2709	*
2710	* For C++, a virtual member function overrides any virtual member
2711	* function with the same signature that occurs in its base
2712	* classes. With multiple inheritance, a virtual member function can
2713	* override several virtual member functions coming from different
2714	* base classes.
2715	*
2716	* In all cases, this function determines the immediate overridden
2717	* method, rather than all of the overridden methods. For example, if
2718	* a method is originally declared in a class A, then overridden in B
2719	* (which in inherits from A) and also in C (which inherited from B),
2720	* then the only overridden method returned from this function when
2721	* invoked on C's method will be B's method. The client may then
2722	* invoke this function again, given the previously-found overridden
2723	* methods, to map out the complete method-override set.
2724	*
2725	* \param cursor A cursor representing an Objective-C or C++
2726	* method. This routine will compute the set of methods that this
2727	* method overrides.
2728	*
2729	* \param overridden A pointer whose pointee will be replaced with a
2730	* pointer to an array of cursors, representing the set of overridden
2731	* methods. If there are no overridden methods, the pointee will be
2732	* set to NULL. The pointee must be freed via a call to
2733	* \c clang_disposeOverriddenCursors().
2734	*
2735	* \param num_overridden A pointer to the number of overridden
2736	* functions, will be set to the number of overridden functions in the
2737	* array pointed to by \p overridden.
2738	*/
2739	CINDEX_LINKAGE void clang_getOverriddenCursors(CXCursor cursor,
2740	CXCursor **overridden,
2741	unsigned *num_overridden);
2742
2743	/**
2744	* Free the set of overridden cursors returned by \c
2745	* clang_getOverriddenCursors().
2746	*/
2747	CINDEX_LINKAGE void clang_disposeOverriddenCursors(CXCursor *overridden);
2748
2749	/**
2750	* Retrieve the file that is included by the given inclusion directive
2751	* cursor.
2752	*/
2753	CINDEX_LINKAGE CXFile clang_getIncludedFile(CXCursor cursor);
2754
2755	/**
2756	* @}
2757	*/
2758
2759	/**
2760	* \defgroup CINDEX_CURSOR_SOURCE Mapping between cursors and source code
2761	*
2762	* Cursors represent a location within the Abstract Syntax Tree (AST). These
2763	* routines help map between cursors and the physical locations where the
2764	* described entities occur in the source code. The mapping is provided in
2765	* both directions, so one can map from source code to the AST and back.
2766	*
2767	* @{
2768	*/
2769
2770	/**
2771	* Map a source location to the cursor that describes the entity at that
2772	* location in the source code.
2773	*
2774	* clang_getCursor() maps an arbitrary source location within a translation
2775	* unit down to the most specific cursor that describes the entity at that
2776	* location. For example, given an expression \c x + y, invoking
2777	* clang_getCursor() with a source location pointing to "x" will return the
2778	* cursor for "x"; similarly for "y". If the cursor points anywhere between
2779	* "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
2780	* will return a cursor referring to the "+" expression.
2781	*
2782	* \returns a cursor representing the entity at the given source location, or
2783	* a NULL cursor if no such entity can be found.
2784	*/
2785	CINDEX_LINKAGE CXCursor clang_getCursor(CXTranslationUnit, CXSourceLocation);
2786
2787	/**
2788	* Retrieve the physical location of the source constructor referenced
2789	* by the given cursor.
2790	*
2791	* The location of a declaration is typically the location of the name of that
2792	* declaration, where the name of that declaration would occur if it is
2793	* unnamed, or some keyword that introduces that particular declaration.
2794	* The location of a reference is where that reference occurs within the
2795	* source code.
2796	*/
2797	CINDEX_LINKAGE CXSourceLocation clang_getCursorLocation(CXCursor);
2798
2799	/**
2800	* Retrieve the physical extent of the source construct referenced by
2801	* the given cursor.
2802	*
2803	* The extent of a cursor starts with the file/line/column pointing at the
2804	* first character within the source construct that the cursor refers to and
2805	* ends with the last character within that source construct. For a
2806	* declaration, the extent covers the declaration itself. For a reference,
2807	* the extent covers the location of the reference (e.g., where the referenced
2808	* entity was actually used).
2809	*/
2810	CINDEX_LINKAGE CXSourceRange clang_getCursorExtent(CXCursor);
2811
2812	/**
2813	* @}
2814	*/
2815
2816	/**
2817	* \defgroup CINDEX_TYPES Type information for CXCursors
2818	*
2819	* @{
2820	*/
2821
2822	/**
2823	* Describes the kind of type
2824	*/
2825	enum CXTypeKind {
2826	/**
2827	* Represents an invalid type (e.g., where no type is available).
2828	*/
2829	CXType_Invalid = `0`,
2830
2831	/**
2832	* A type whose specific kind is not exposed via this
2833	* interface.
2834	*/
2835	CXType_Unexposed = `1`,
2836
2837	/ Builtin types /
2838	CXType_Void = `2`,
2839	CXType_Bool = `3`,
2840	CXType_Char_U = `4`,
2841	CXType_UChar = `5`,
2842	CXType_Char16 = `6`,
2843	CXType_Char32 = `7`,
2844	CXType_UShort = `8`,
2845	CXType_UInt = `9`,
2846	CXType_ULong = `10`,
2847	CXType_ULongLong = `11`,
2848	CXType_UInt128 = `12`,
2849	CXType_Char_S = `13`,
2850	CXType_SChar = `14`,
2851	CXType_WChar = `15`,
2852	CXType_Short = `16`,
2853	CXType_Int = `17`,
2854	CXType_Long = `18`,
2855	CXType_LongLong = `19`,
2856	CXType_Int128 = `20`,
2857	CXType_Float = `21`,
2858	CXType_Double = `22`,
2859	CXType_LongDouble = `23`,
2860	CXType_NullPtr = `24`,
2861	CXType_Overload = `25`,
2862	CXType_Dependent = `26`,
2863	CXType_ObjCId = `27`,
2864	CXType_ObjCClass = `28`,
2865	CXType_ObjCSel = `29`,
2866	CXType_Float128 = `30`,
2867	CXType_Half = `31`,
2868	CXType_Float16 = `32`,
2869	CXType_ShortAccum = `33`,
2870	CXType_Accum = `34`,
2871	CXType_LongAccum = `35`,
2872	CXType_UShortAccum = `36`,
2873	CXType_UAccum = `37`,
2874	CXType_ULongAccum = `38`,
2875	CXType_BFloat16 = `39`,
2876	CXType_Ibm128 = `40`,
2877	CXType_FirstBuiltin = CXType_Void,
2878	CXType_LastBuiltin = CXType_Ibm128,
2879
2880	CXType_Complex = `100`,
2881	CXType_Pointer = `101`,
2882	CXType_BlockPointer = `102`,
2883	CXType_LValueReference = `103`,
2884	CXType_RValueReference = `104`,
2885	CXType_Record = `105`,
2886	CXType_Enum = `106`,
2887	CXType_Typedef = `107`,
2888	CXType_ObjCInterface = `108`,
2889	CXType_ObjCObjectPointer = `109`,
2890	CXType_FunctionNoProto = `110`,
2891	CXType_FunctionProto = `111`,
2892	CXType_ConstantArray = `112`,
2893	CXType_Vector = `113`,
2894	CXType_IncompleteArray = `114`,
2895	CXType_VariableArray = `115`,
2896	CXType_DependentSizedArray = `116`,
2897	CXType_MemberPointer = `117`,
2898	CXType_Auto = `118`,
2899
2900	/**
2901	* Represents a type that was referred to using an elaborated type keyword.
2902	*
2903	* E.g., struct S, or via a qualified name, e.g., N::M::type, or both.
2904	*/
2905	CXType_Elaborated = `119`,
2906
2907	/ OpenCL PipeType. /
2908	CXType_Pipe = `120`,
2909
2910	/ OpenCL builtin types. /
2911	CXType_OCLImage1dRO = `121`,
2912	CXType_OCLImage1dArrayRO = `122`,
2913	CXType_OCLImage1dBufferRO = `123`,
2914	CXType_OCLImage2dRO = `124`,
2915	CXType_OCLImage2dArrayRO = `125`,
2916	CXType_OCLImage2dDepthRO = `126`,
2917	CXType_OCLImage2dArrayDepthRO = `127`,
2918	CXType_OCLImage2dMSAARO = `128`,
2919	CXType_OCLImage2dArrayMSAARO = `129`,
2920	CXType_OCLImage2dMSAADepthRO = `130`,
2921	CXType_OCLImage2dArrayMSAADepthRO = `131`,
2922	CXType_OCLImage3dRO = `132`,
2923	CXType_OCLImage1dWO = `133`,
2924	CXType_OCLImage1dArrayWO = `134`,
2925	CXType_OCLImage1dBufferWO = `135`,
2926	CXType_OCLImage2dWO = `136`,
2927	CXType_OCLImage2dArrayWO = `137`,
2928	CXType_OCLImage2dDepthWO = `138`,
2929	CXType_OCLImage2dArrayDepthWO = `139`,
2930	CXType_OCLImage2dMSAAWO = `140`,
2931	CXType_OCLImage2dArrayMSAAWO = `141`,
2932	CXType_OCLImage2dMSAADepthWO = `142`,
2933	CXType_OCLImage2dArrayMSAADepthWO = `143`,
2934	CXType_OCLImage3dWO = `144`,
2935	CXType_OCLImage1dRW = `145`,
2936	CXType_OCLImage1dArrayRW = `146`,
2937	CXType_OCLImage1dBufferRW = `147`,
2938	CXType_OCLImage2dRW = `148`,
2939	CXType_OCLImage2dArrayRW = `149`,
2940	CXType_OCLImage2dDepthRW = `150`,
2941	CXType_OCLImage2dArrayDepthRW = `151`,
2942	CXType_OCLImage2dMSAARW = `152`,
2943	CXType_OCLImage2dArrayMSAARW = `153`,
2944	CXType_OCLImage2dMSAADepthRW = `154`,
2945	CXType_OCLImage2dArrayMSAADepthRW = `155`,
2946	CXType_OCLImage3dRW = `156`,
2947	CXType_OCLSampler = `157`,
2948	CXType_OCLEvent = `158`,
2949	CXType_OCLQueue = `159`,
2950	CXType_OCLReserveID = `160`,
2951
2952	CXType_ObjCObject = `161`,
2953	CXType_ObjCTypeParam = `162`,
2954	CXType_Attributed = `163`,
2955
2956	CXType_OCLIntelSubgroupAVCMcePayload = `164`,
2957	CXType_OCLIntelSubgroupAVCImePayload = `165`,
2958	CXType_OCLIntelSubgroupAVCRefPayload = `166`,
2959	CXType_OCLIntelSubgroupAVCSicPayload = `167`,
2960	CXType_OCLIntelSubgroupAVCMceResult = `168`,
2961	CXType_OCLIntelSubgroupAVCImeResult = `169`,
2962	CXType_OCLIntelSubgroupAVCRefResult = `170`,
2963	CXType_OCLIntelSubgroupAVCSicResult = `171`,
2964	CXType_OCLIntelSubgroupAVCImeResultSingleReferenceStreamout = `172`,
2965	CXType_OCLIntelSubgroupAVCImeResultDualReferenceStreamout = `173`,
2966	CXType_OCLIntelSubgroupAVCImeSingleReferenceStreamin = `174`,
2967	CXType_OCLIntelSubgroupAVCImeDualReferenceStreamin = `175`,
2968
2969	/ Old aliases for AVC OpenCL extension types. /
2970	CXType_OCLIntelSubgroupAVCImeResultSingleRefStreamout = `172`,
2971	CXType_OCLIntelSubgroupAVCImeResultDualRefStreamout = `173`,
2972	CXType_OCLIntelSubgroupAVCImeSingleRefStreamin = `174`,
2973	CXType_OCLIntelSubgroupAVCImeDualRefStreamin = `175`,
2974
2975	CXType_ExtVector = `176`,
2976	CXType_Atomic = `177`,
2977	CXType_BTFTagAttributed = `178`
2978	};
2979
2980	/**
2981	* Describes the calling convention of a function type
2982	*/
2983	enum CXCallingConv {
2984	CXCallingConv_Default = `0`,
2985	CXCallingConv_C = `1`,
2986	CXCallingConv_X86StdCall = `2`,
2987	CXCallingConv_X86FastCall = `3`,
2988	CXCallingConv_X86ThisCall = `4`,
2989	CXCallingConv_X86Pascal = `5`,
2990	CXCallingConv_AAPCS = `6`,
2991	CXCallingConv_AAPCS_VFP = `7`,
2992	CXCallingConv_X86RegCall = `8`,
2993	CXCallingConv_IntelOclBicc = `9`,
2994	CXCallingConv_Win64 = `10`,
2995	/ Alias for compatibility with older versions of API. /
2996	CXCallingConv_X86_64Win64 = CXCallingConv_Win64,
2997	CXCallingConv_X86_64SysV = `11`,
2998	CXCallingConv_X86VectorCall = `12`,
2999	CXCallingConv_Swift = `13`,
3000	CXCallingConv_PreserveMost = `14`,
3001	CXCallingConv_PreserveAll = `15`,
3002	CXCallingConv_AArch64VectorCall = `16`,
3003	CXCallingConv_SwiftAsync = `17`,
3004	CXCallingConv_AArch64SVEPCS = `18`,
3005	CXCallingConv_M68kRTD = `19`,
3006	CXCallingConv_PreserveNone = `20`,
3007	CXCallingConv_RISCVVectorCall = `21`,
3008
3009	CXCallingConv_Invalid = `100`,
3010	CXCallingConv_Unexposed = `200`
3011	};
3012
3013	/**
3014	* The type of an element in the abstract syntax tree.
3015	*
3016	*/
3017	typedef struct {
3018	enum CXTypeKind kind;
3019	void *data[`2`];
3020	} CXType;
3021
3022	/**
3023	* Retrieve the type of a CXCursor (if any).
3024	*/
3025	CINDEX_LINKAGE CXType clang_getCursorType(CXCursor C);
3026
3027	/**
3028	* Pretty-print the underlying type using the rules of the
3029	* language of the translation unit from which it came.
3030	*
3031	* If the type is invalid, an empty string is returned.
3032	*/
3033	CINDEX_LINKAGE CXString clang_getTypeSpelling(CXType CT);
3034
3035	/**
3036	* Retrieve the underlying type of a typedef declaration.
3037	*
3038	* If the cursor does not reference a typedef declaration, an invalid type is
3039	* returned.
3040	*/
3041	CINDEX_LINKAGE CXType clang_getTypedefDeclUnderlyingType(CXCursor C);
3042
3043	/**
3044	* Retrieve the integer type of an enum declaration.
3045	*
3046	* If the cursor does not reference an enum declaration, an invalid type is
3047	* returned.
3048	*/
3049	CINDEX_LINKAGE CXType clang_getEnumDeclIntegerType(CXCursor C);
3050
3051	/**
3052	* Retrieve the integer value of an enum constant declaration as a signed
3053	* long long.
3054	*
3055	* If the cursor does not reference an enum constant declaration, LLONG_MIN is
3056	* returned. Since this is also potentially a valid constant value, the kind of
3057	* the cursor must be verified before calling this function.
3058	*/
3059	CINDEX_LINKAGE long long clang_getEnumConstantDeclValue(CXCursor C);
3060
3061	/**
3062	* Retrieve the integer value of an enum constant declaration as an unsigned
3063	* long long.
3064	*
3065	* If the cursor does not reference an enum constant declaration, ULLONG_MAX is
3066	* returned. Since this is also potentially a valid constant value, the kind of
3067	* the cursor must be verified before calling this function.
3068	*/
3069	CINDEX_LINKAGE unsigned long long
3070	clang_getEnumConstantDeclUnsignedValue(CXCursor C);
3071
3072	/**
3073	* Returns non-zero if the cursor specifies a Record member that is a bit-field.
3074	*/
3075	CINDEX_LINKAGE unsigned clang_Cursor_isBitField(CXCursor C);
3076
3077	/**
3078	* Retrieve the bit width of a bit-field declaration as an integer.
3079	*
3080	* If the cursor does not reference a bit-field, or if the bit-field's width
3081	* expression cannot be evaluated, -1 is returned.
3082	*
3083	* For example:
3084	* \code
3085	* if (clang_Cursor_isBitField(Cursor)) {
3086	* int Width = clang_getFieldDeclBitWidth(Cursor);
3087	* if (Width != -1) {
3088	* // The bit-field width is not value-dependent.
3089	* }
3090	* }
3091	* \endcode
3092	*/
3093	CINDEX_LINKAGE int clang_getFieldDeclBitWidth(CXCursor C);
3094
3095	/**
3096	* Retrieve the number of non-variadic arguments associated with a given
3097	* cursor.
3098	*
3099	* The number of arguments can be determined for calls as well as for
3100	* declarations of functions or methods. For other cursors -1 is returned.
3101	*/
3102	CINDEX_LINKAGE int clang_Cursor_getNumArguments(CXCursor C);
3103
3104	/**
3105	* Retrieve the argument cursor of a function or method.
3106	*
3107	* The argument cursor can be determined for calls as well as for declarations
3108	* of functions or methods. For other cursors and for invalid indices, an
3109	* invalid cursor is returned.
3110	*/
3111	CINDEX_LINKAGE CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i);
3112
3113	/**
3114	* Describes the kind of a template argument.
3115	*
3116	* See the definition of llvm::clang::TemplateArgument::ArgKind for full
3117	* element descriptions.
3118	*/
3119	enum CXTemplateArgumentKind {
3120	CXTemplateArgumentKind_Null,
3121	CXTemplateArgumentKind_Type,
3122	CXTemplateArgumentKind_Declaration,
3123	CXTemplateArgumentKind_NullPtr,
3124	CXTemplateArgumentKind_Integral,
3125	CXTemplateArgumentKind_Template,
3126	CXTemplateArgumentKind_TemplateExpansion,
3127	CXTemplateArgumentKind_Expression,
3128	CXTemplateArgumentKind_Pack,
3129	/ Indicates an error case, preventing the kind from being deduced. /
3130	CXTemplateArgumentKind_Invalid
3131	};
3132
3133	/**
3134	* Returns the number of template args of a function, struct, or class decl
3135	* representing a template specialization.
3136	*
3137	* If the argument cursor cannot be converted into a template function
3138	* declaration, -1 is returned.
3139	*
3140	* For example, for the following declaration and specialization:
3141	* template <typename T, int kInt, bool kBool>
3142	* void foo() { ... }
3143	*
3144	* template <>
3145	* void foo<float, -7, true>();
3146	*
3147	* The value 3 would be returned from this call.
3148	*/
3149	CINDEX_LINKAGE int clang_Cursor_getNumTemplateArguments(CXCursor C);
3150
3151	/**
3152	* Retrieve the kind of the I'th template argument of the CXCursor C.
3153	*
3154	* If the argument CXCursor does not represent a FunctionDecl, StructDecl, or
3155	* ClassTemplatePartialSpecialization, an invalid template argument kind is
3156	* returned.
3157	*
3158	* For example, for the following declaration and specialization:
3159	* template <typename T, int kInt, bool kBool>
3160	* void foo() { ... }
3161	*
3162	* template <>
3163	* void foo<float, -7, true>();
3164	*
3165	* For I = 0, 1, and 2, Type, Integral, and Integral will be returned,
3166	* respectively.
3167	*/
3168	CINDEX_LINKAGE enum CXTemplateArgumentKind
3169	clang_Cursor_getTemplateArgumentKind(CXCursor C, unsigned I);
3170
3171	/**
3172	* Retrieve a CXType representing the type of a TemplateArgument of a
3173	* function decl representing a template specialization.
3174	*
3175	* If the argument CXCursor does not represent a FunctionDecl, StructDecl,
3176	* ClassDecl or ClassTemplatePartialSpecialization whose I'th template argument
3177	* has a kind of CXTemplateArgKind_Integral, an invalid type is returned.
3178	*
3179	* For example, for the following declaration and specialization:
3180	* template <typename T, int kInt, bool kBool>
3181	* void foo() { ... }
3182	*
3183	* template <>
3184	* void foo<float, -7, true>();
3185	*
3186	* If called with I = 0, "float", will be returned.
3187	* Invalid types will be returned for I == 1 or 2.
3188	*/
3189	CINDEX_LINKAGE CXType clang_Cursor_getTemplateArgumentType(CXCursor C,
3190	unsigned I);
3191
3192	/**
3193	* Retrieve the value of an Integral TemplateArgument (of a function
3194	* decl representing a template specialization) as a signed long long.
3195	*
3196	* It is undefined to call this function on a CXCursor that does not represent a
3197	* FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization
3198	* whose I'th template argument is not an integral value.
3199	*
3200	* For example, for the following declaration and specialization:
3201	* template <typename T, int kInt, bool kBool>
3202	* void foo() { ... }
3203	*
3204	* template <>
3205	* void foo<float, -7, true>();
3206	*
3207	* If called with I = 1 or 2, -7 or true will be returned, respectively.
3208	* For I == 0, this function's behavior is undefined.
3209	*/
3210	CINDEX_LINKAGE long long clang_Cursor_getTemplateArgumentValue(CXCursor C,
3211	unsigned I);
3212
3213	/**
3214	* Retrieve the value of an Integral TemplateArgument (of a function
3215	* decl representing a template specialization) as an unsigned long long.
3216	*
3217	* It is undefined to call this function on a CXCursor that does not represent a
3218	* FunctionDecl, StructDecl, ClassDecl or ClassTemplatePartialSpecialization or
3219	* whose I'th template argument is not an integral value.
3220	*
3221	* For example, for the following declaration and specialization:
3222	* template <typename T, int kInt, bool kBool>
3223	* void foo() { ... }
3224	*
3225	* template <>
3226	* void foo<float, 2147483649, true>();
3227	*
3228	* If called with I = 1 or 2, 2147483649 or true will be returned, respectively.
3229	* For I == 0, this function's behavior is undefined.
3230	*/
3231	CINDEX_LINKAGE unsigned long long
3232	clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C, unsigned I);
3233
3234	/**
3235	* Determine whether two CXTypes represent the same type.
3236	*
3237	* \returns non-zero if the CXTypes represent the same type and
3238	* zero otherwise.
3239	*/
3240	CINDEX_LINKAGE unsigned clang_equalTypes(CXType A, CXType B);
3241
3242	/**
3243	* Return the canonical type for a CXType.
3244	*
3245	* Clang's type system explicitly models typedefs and all the ways
3246	* a specific type can be represented. The canonical type is the underlying
3247	* type with all the "sugar" removed. For example, if 'T' is a typedef
3248	* for 'int', the canonical type for 'T' would be 'int'.
3249	*/
3250	CINDEX_LINKAGE CXType clang_getCanonicalType(CXType T);
3251
3252	/**
3253	* Determine whether a CXType has the "const" qualifier set,
3254	* without looking through typedefs that may have added "const" at a
3255	* different level.
3256	*/
3257	CINDEX_LINKAGE unsigned clang_isConstQualifiedType(CXType T);
3258
3259	/**
3260	* Determine whether a CXCursor that is a macro, is
3261	* function like.
3262	*/
3263	CINDEX_LINKAGE unsigned clang_Cursor_isMacroFunctionLike(CXCursor C);
3264
3265	/**
3266	* Determine whether a CXCursor that is a macro, is a
3267	* builtin one.
3268	*/
3269	CINDEX_LINKAGE unsigned clang_Cursor_isMacroBuiltin(CXCursor C);
3270
3271	/**
3272	* Determine whether a CXCursor that is a function declaration, is an
3273	* inline declaration.
3274	*/
3275	CINDEX_LINKAGE unsigned clang_Cursor_isFunctionInlined(CXCursor C);
3276
3277	/**
3278	* Determine whether a CXType has the "volatile" qualifier set,
3279	* without looking through typedefs that may have added "volatile" at
3280	* a different level.
3281	*/
3282	CINDEX_LINKAGE unsigned clang_isVolatileQualifiedType(CXType T);
3283
3284	/**
3285	* Determine whether a CXType has the "restrict" qualifier set,
3286	* without looking through typedefs that may have added "restrict" at a
3287	* different level.
3288	*/
3289	CINDEX_LINKAGE unsigned clang_isRestrictQualifiedType(CXType T);
3290
3291	/**
3292	* Returns the address space of the given type.
3293	*/
3294	CINDEX_LINKAGE unsigned clang_getAddressSpace(CXType T);
3295
3296	/**
3297	* Returns the typedef name of the given type.
3298	*/
3299	CINDEX_LINKAGE CXString clang_getTypedefName(CXType CT);
3300
3301	/**
3302	* For pointer types, returns the type of the pointee.
3303	*/
3304	CINDEX_LINKAGE CXType clang_getPointeeType(CXType T);
3305
3306	/**
3307	* Retrieve the unqualified variant of the given type, removing as
3308	* little sugar as possible.
3309	*
3310	* For example, given the following series of typedefs:
3311	*
3312	* \code
3313	* typedef int Integer;
3314	* typedef const Integer CInteger;
3315	* typedef CInteger DifferenceType;
3316	* \endcode
3317	*
3318	* Executing \c clang_getUnqualifiedType() on a \c CXType that
3319	* represents \c DifferenceType, will desugar to a type representing
3320	* \c Integer, that has no qualifiers.
3321	*
3322	* And, executing \c clang_getUnqualifiedType() on the type of the
3323	* first argument of the following function declaration:
3324	*
3325	* \code
3326	* void foo(const int);
3327	* \endcode
3328	*
3329	* Will return a type representing \c int, removing the \c const
3330	* qualifier.
3331	*
3332	* Sugar over array types is not desugared.
3333	*
3334	* A type can be checked for qualifiers with \c
3335	* clang_isConstQualifiedType(), \c clang_isVolatileQualifiedType()
3336	* and \c clang_isRestrictQualifiedType().
3337	*
3338	* A type that resulted from a call to \c clang_getUnqualifiedType
3339	* will return \c false for all of the above calls.
3340	*/
3341	CINDEX_LINKAGE CXType clang_getUnqualifiedType(CXType CT);
3342
3343	/**
3344	* For reference types (e.g., "const int&"), returns the type that the
3345	* reference refers to (e.g "const int").
3346	*
3347	* Otherwise, returns the type itself.
3348	*
3349	* A type that has kind \c CXType_LValueReference or
3350	* \c CXType_RValueReference is a reference type.
3351	*/
3352	CINDEX_LINKAGE CXType clang_getNonReferenceType(CXType CT);
3353
3354	/**
3355	* Return the cursor for the declaration of the given type.
3356	*/
3357	CINDEX_LINKAGE CXCursor clang_getTypeDeclaration(CXType T);
3358
3359	/**
3360	* Returns the Objective-C type encoding for the specified declaration.
3361	*/
3362	CINDEX_LINKAGE CXString clang_getDeclObjCTypeEncoding(CXCursor C);
3363
3364	/**
3365	* Returns the Objective-C type encoding for the specified CXType.
3366	*/
3367	CINDEX_LINKAGE CXString clang_Type_getObjCEncoding(CXType type);
3368
3369	/**
3370	* Retrieve the spelling of a given CXTypeKind.
3371	*/
3372	CINDEX_LINKAGE CXString clang_getTypeKindSpelling(enum CXTypeKind K);
3373
3374	/**
3375	* Retrieve the calling convention associated with a function type.
3376	*
3377	* If a non-function type is passed in, CXCallingConv_Invalid is returned.
3378	*/
3379	CINDEX_LINKAGE enum CXCallingConv clang_getFunctionTypeCallingConv(CXType T);
3380
3381	/**
3382	* Retrieve the return type associated with a function type.
3383	*
3384	* If a non-function type is passed in, an invalid type is returned.
3385	*/
3386	CINDEX_LINKAGE CXType clang_getResultType(CXType T);
3387
3388	/**
3389	* Retrieve the exception specification type associated with a function type.
3390	* This is a value of type CXCursor_ExceptionSpecificationKind.
3391	*
3392	* If a non-function type is passed in, an error code of -1 is returned.
3393	*/
3394	CINDEX_LINKAGE int clang_getExceptionSpecificationType(CXType T);
3395
3396	/**
3397	* Retrieve the number of non-variadic parameters associated with a
3398	* function type.
3399	*
3400	* If a non-function type is passed in, -1 is returned.
3401	*/
3402	CINDEX_LINKAGE int clang_getNumArgTypes(CXType T);
3403
3404	/**
3405	* Retrieve the type of a parameter of a function type.
3406	*
3407	* If a non-function type is passed in or the function does not have enough
3408	* parameters, an invalid type is returned.
3409	*/
3410	CINDEX_LINKAGE CXType clang_getArgType(CXType T, unsigned i);
3411
3412	/**
3413	* Retrieves the base type of the ObjCObjectType.
3414	*
3415	* If the type is not an ObjC object, an invalid type is returned.
3416	*/
3417	CINDEX_LINKAGE CXType clang_Type_getObjCObjectBaseType(CXType T);
3418
3419	/**
3420	* Retrieve the number of protocol references associated with an ObjC object/id.
3421	*
3422	* If the type is not an ObjC object, 0 is returned.
3423	*/
3424	CINDEX_LINKAGE unsigned clang_Type_getNumObjCProtocolRefs(CXType T);
3425
3426	/**
3427	* Retrieve the decl for a protocol reference for an ObjC object/id.
3428	*
3429	* If the type is not an ObjC object or there are not enough protocol
3430	* references, an invalid cursor is returned.
3431	*/
3432	CINDEX_LINKAGE CXCursor clang_Type_getObjCProtocolDecl(CXType T, unsigned i);
3433
3434	/**
3435	* Retrieve the number of type arguments associated with an ObjC object.
3436	*
3437	* If the type is not an ObjC object, 0 is returned.
3438	*/
3439	CINDEX_LINKAGE unsigned clang_Type_getNumObjCTypeArgs(CXType T);
3440
3441	/**
3442	* Retrieve a type argument associated with an ObjC object.
3443	*
3444	* If the type is not an ObjC or the index is not valid,
3445	* an invalid type is returned.
3446	*/
3447	CINDEX_LINKAGE CXType clang_Type_getObjCTypeArg(CXType T, unsigned i);
3448
3449	/**
3450	* Return 1 if the CXType is a variadic function type, and 0 otherwise.
3451	*/
3452	CINDEX_LINKAGE unsigned clang_isFunctionTypeVariadic(CXType T);
3453
3454	/**
3455	* Retrieve the return type associated with a given cursor.
3456	*
3457	* This only returns a valid type if the cursor refers to a function or method.
3458	*/
3459	CINDEX_LINKAGE CXType clang_getCursorResultType(CXCursor C);
3460
3461	/**
3462	* Retrieve the exception specification type associated with a given cursor.
3463	* This is a value of type CXCursor_ExceptionSpecificationKind.
3464	*
3465	* This only returns a valid result if the cursor refers to a function or
3466	* method.
3467	*/
3468	CINDEX_LINKAGE int clang_getCursorExceptionSpecificationType(CXCursor C);
3469
3470	/**
3471	* Return 1 if the CXType is a POD (plain old data) type, and 0
3472	* otherwise.
3473	*/
3474	CINDEX_LINKAGE unsigned clang_isPODType(CXType T);
3475
3476	/**
3477	* Return the element type of an array, complex, or vector type.
3478	*
3479	* If a type is passed in that is not an array, complex, or vector type,
3480	* an invalid type is returned.
3481	*/
3482	CINDEX_LINKAGE CXType clang_getElementType(CXType T);
3483
3484	/**
3485	* Return the number of elements of an array or vector type.
3486	*
3487	* If a type is passed in that is not an array or vector type,
3488	* -1 is returned.
3489	*/
3490	CINDEX_LINKAGE long long clang_getNumElements(CXType T);
3491
3492	/**
3493	* Return the element type of an array type.
3494	*
3495	* If a non-array type is passed in, an invalid type is returned.
3496	*/
3497	CINDEX_LINKAGE CXType clang_getArrayElementType(CXType T);
3498
3499	/**
3500	* Return the array size of a constant array.
3501	*
3502	* If a non-array type is passed in, -1 is returned.
3503	*/
3504	CINDEX_LINKAGE long long clang_getArraySize(CXType T);
3505
3506	/**
3507	* Retrieve the type named by the qualified-id.
3508	*
3509	* If a non-elaborated type is passed in, an invalid type is returned.
3510	*/
3511	CINDEX_LINKAGE CXType clang_Type_getNamedType(CXType T);
3512
3513	/**
3514	* Determine if a typedef is 'transparent' tag.
3515	*
3516	* A typedef is considered 'transparent' if it shares a name and spelling
3517	* location with its underlying tag type, as is the case with the NS_ENUM macro.
3518	*
3519	* \returns non-zero if transparent and zero otherwise.
3520	*/
3521	CINDEX_LINKAGE unsigned clang_Type_isTransparentTagTypedef(CXType T);
3522
3523	enum CXTypeNullabilityKind {
3524	/**
3525	* Values of this type can never be null.
3526	*/
3527	CXTypeNullability_NonNull = `0`,
3528	/**
3529	* Values of this type can be null.
3530	*/
3531	CXTypeNullability_Nullable = `1`,
3532	/**
3533	* Whether values of this type can be null is (explicitly)
3534	* unspecified. This captures a (fairly rare) case where we
3535	* can't conclude anything about the nullability of the type even
3536	* though it has been considered.
3537	*/
3538	CXTypeNullability_Unspecified = `2`,
3539	/**
3540	* Nullability is not applicable to this type.
3541	*/
3542	CXTypeNullability_Invalid = `3`,
3543
3544	/**
3545	* Generally behaves like Nullable, except when used in a block parameter that
3546	* was imported into a swift async method. There, swift will assume that the
3547	* parameter can get null even if no error occurred. _Nullable parameters are
3548	* assumed to only get null on error.
3549	*/
3550	CXTypeNullability_NullableResult = `4`
3551	};
3552
3553	/**
3554	* Retrieve the nullability kind of a pointer type.
3555	*/
3556	CINDEX_LINKAGE enum CXTypeNullabilityKind clang_Type_getNullability(CXType T);
3557
3558	/**
3559	* List the possible error codes for \c clang_Type_getSizeOf,
3560	* \c clang_Type_getAlignOf, \c clang_Type_getOffsetOf and
3561	* \c clang_Cursor_getOffsetOf.
3562	*
3563	* A value of this enumeration type can be returned if the target type is not
3564	* a valid argument to sizeof, alignof or offsetof.
3565	*/
3566	enum CXTypeLayoutError {
3567	/**
3568	* Type is of kind CXType_Invalid.
3569	*/
3570	CXTypeLayoutError_Invalid = -`1`,
3571	/**
3572	* The type is an incomplete Type.
3573	*/
3574	CXTypeLayoutError_Incomplete = -`2`,
3575	/**
3576	* The type is a dependent Type.
3577	*/
3578	CXTypeLayoutError_Dependent = -`3`,
3579	/**
3580	* The type is not a constant size type.
3581	*/
3582	CXTypeLayoutError_NotConstantSize = -`4`,
3583	/**
3584	* The Field name is not valid for this record.
3585	*/
3586	CXTypeLayoutError_InvalidFieldName = -`5`,
3587	/**
3588	* The type is undeduced.
3589	*/
3590	CXTypeLayoutError_Undeduced = -`6`
3591	};
3592
3593	/**
3594	* Return the alignment of a type in bytes as per C++[expr.alignof]
3595	* standard.
3596	*
3597	* If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
3598	* If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
3599	* is returned.
3600	* If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
3601	* returned.
3602	* If the type declaration is not a constant size type,
3603	* CXTypeLayoutError_NotConstantSize is returned.
3604	*/
3605	CINDEX_LINKAGE long long clang_Type_getAlignOf(CXType T);
3606
3607	/**
3608	* Return the class type of an member pointer type.
3609	*
3610	* If a non-member-pointer type is passed in, an invalid type is returned.
3611	*/
3612	CINDEX_LINKAGE CXType clang_Type_getClassType(CXType T);
3613
3614	/**
3615	* Return the size of a type in bytes as per C++[expr.sizeof] standard.
3616	*
3617	* If the type declaration is invalid, CXTypeLayoutError_Invalid is returned.
3618	* If the type declaration is an incomplete type, CXTypeLayoutError_Incomplete
3619	* is returned.
3620	* If the type declaration is a dependent type, CXTypeLayoutError_Dependent is
3621	* returned.
3622	*/
3623	CINDEX_LINKAGE long long clang_Type_getSizeOf(CXType T);
3624
3625	/**
3626	* Return the offset of a field named S in a record of type T in bits
3627	* as it would be returned by __offsetof__ as per C++11[18.2p4]
3628	*
3629	* If the cursor is not a record field declaration, CXTypeLayoutError_Invalid
3630	* is returned.
3631	* If the field's type declaration is an incomplete type,
3632	* CXTypeLayoutError_Incomplete is returned.
3633	* If the field's type declaration is a dependent type,
3634	* CXTypeLayoutError_Dependent is returned.
3635	* If the field's name S is not found,
3636	* CXTypeLayoutError_InvalidFieldName is returned.
3637	*/
3638	CINDEX_LINKAGE long long clang_Type_getOffsetOf(CXType T, const char *S);
3639
3640	/**
3641	* Return the type that was modified by this attributed type.
3642	*
3643	* If the type is not an attributed type, an invalid type is returned.
3644	*/
3645	CINDEX_LINKAGE CXType clang_Type_getModifiedType(CXType T);
3646
3647	/**
3648	* Gets the type contained by this atomic type.
3649	*
3650	* If a non-atomic type is passed in, an invalid type is returned.
3651	*/
3652	CINDEX_LINKAGE CXType clang_Type_getValueType(CXType CT);
3653
3654	/**
3655	* Return the offset of the field represented by the Cursor.
3656	*
3657	* If the cursor is not a field declaration, -1 is returned.
3658	* If the cursor semantic parent is not a record field declaration,
3659	* CXTypeLayoutError_Invalid is returned.
3660	* If the field's type declaration is an incomplete type,
3661	* CXTypeLayoutError_Incomplete is returned.
3662	* If the field's type declaration is a dependent type,
3663	* CXTypeLayoutError_Dependent is returned.
3664	* If the field's name S is not found,
3665	* CXTypeLayoutError_InvalidFieldName is returned.
3666	*/
3667	CINDEX_LINKAGE long long clang_Cursor_getOffsetOfField(CXCursor C);
3668
3669	/**
3670	* Determine whether the given cursor represents an anonymous
3671	* tag or namespace
3672	*/
3673	CINDEX_LINKAGE unsigned clang_Cursor_isAnonymous(CXCursor C);
3674
3675	/**
3676	* Determine whether the given cursor represents an anonymous record
3677	* declaration.
3678	*/
3679	CINDEX_LINKAGE unsigned clang_Cursor_isAnonymousRecordDecl(CXCursor C);
3680
3681	/**
3682	* Determine whether the given cursor represents an inline namespace
3683	* declaration.
3684	*/
3685	CINDEX_LINKAGE unsigned clang_Cursor_isInlineNamespace(CXCursor C);
3686
3687	enum CXRefQualifierKind {
3688	/* No ref-qualifier was provided. /
3689	CXRefQualifier_None = `0`,
3690	/* An lvalue ref-qualifier was provided (\c &). /
3691	CXRefQualifier_LValue,
3692	/* An rvalue ref-qualifier was provided (\c &&). /
3693	CXRefQualifier_RValue
3694	};
3695
3696	/**
3697	* Returns the number of template arguments for given template
3698	* specialization, or -1 if type \c T is not a template specialization.
3699	*/
3700	CINDEX_LINKAGE int clang_Type_getNumTemplateArguments(CXType T);
3701
3702	/**
3703	* Returns the type template argument of a template class specialization
3704	* at given index.
3705	*
3706	* This function only returns template type arguments and does not handle
3707	* template template arguments or variadic packs.
3708	*/
3709	CINDEX_LINKAGE CXType clang_Type_getTemplateArgumentAsType(CXType T,
3710	unsigned i);
3711
3712	/**
3713	* Retrieve the ref-qualifier kind of a function or method.
3714	*
3715	* The ref-qualifier is returned for C++ functions or methods. For other types
3716	* or non-C++ declarations, CXRefQualifier_None is returned.
3717	*/
3718	CINDEX_LINKAGE enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T);
3719
3720	/**
3721	* Returns 1 if the base class specified by the cursor with kind
3722	* CX_CXXBaseSpecifier is virtual.
3723	*/
3724	CINDEX_LINKAGE unsigned clang_isVirtualBase(CXCursor);
3725
3726	/**
3727	* Represents the C++ access control level to a base class for a
3728	* cursor with kind CX_CXXBaseSpecifier.
3729	*/
3730	enum CX_CXXAccessSpecifier {
3731	CX_CXXInvalidAccessSpecifier,
3732	CX_CXXPublic,
3733	CX_CXXProtected,
3734	CX_CXXPrivate
3735	};
3736
3737	/**
3738	* Returns the access control level for the referenced object.
3739	*
3740	* If the cursor refers to a C++ declaration, its access control level within
3741	* its parent scope is returned. Otherwise, if the cursor refers to a base
3742	* specifier or access specifier, the specifier itself is returned.
3743	*/
3744	CINDEX_LINKAGE enum CX_CXXAccessSpecifier clang_getCXXAccessSpecifier(CXCursor);
3745
3746	/**
3747	* Represents the storage classes as declared in the source. CX_SC_Invalid
3748	* was added for the case that the passed cursor in not a declaration.
3749	*/
3750	enum CX_StorageClass {
3751	CX_SC_Invalid,
3752	CX_SC_None,
3753	CX_SC_Extern,
3754	CX_SC_Static,
3755	CX_SC_PrivateExtern,
3756	CX_SC_OpenCLWorkGroupLocal,
3757	CX_SC_Auto,
3758	CX_SC_Register
3759	};
3760
3761	/**
3762	* Represents a specific kind of binary operator which can appear at a cursor.
3763	*/
3764	enum CX_BinaryOperatorKind {
3765	CX_BO_Invalid = `0`,
3766	CX_BO_PtrMemD = `1`,
3767	CX_BO_PtrMemI = `2`,
3768	CX_BO_Mul = `3`,
3769	CX_BO_Div = `4`,
3770	CX_BO_Rem = `5`,
3771	CX_BO_Add = `6`,
3772	CX_BO_Sub = `7`,
3773	CX_BO_Shl = `8`,
3774	CX_BO_Shr = `9`,
3775	CX_BO_Cmp = `10`,
3776	CX_BO_LT = `11`,
3777	CX_BO_GT = `12`,
3778	CX_BO_LE = `13`,
3779	CX_BO_GE = `14`,
3780	CX_BO_EQ = `15`,
3781	CX_BO_NE = `16`,
3782	CX_BO_And = `17`,
3783	CX_BO_Xor = `18`,
3784	CX_BO_Or = `19`,
3785	CX_BO_LAnd = `20`,
3786	CX_BO_LOr = `21`,
3787	CX_BO_Assign = `22`,
3788	CX_BO_MulAssign = `23`,
3789	CX_BO_DivAssign = `24`,
3790	CX_BO_RemAssign = `25`,
3791	CX_BO_AddAssign = `26`,
3792	CX_BO_SubAssign = `27`,
3793	CX_BO_ShlAssign = `28`,
3794	CX_BO_ShrAssign = `29`,
3795	CX_BO_AndAssign = `30`,
3796	CX_BO_XorAssign = `31`,
3797	CX_BO_OrAssign = `32`,
3798	CX_BO_Comma = `33`,
3799	CX_BO_LAST = CX_BO_Comma
3800	};
3801
3802	/**
3803	* \brief Returns the operator code for the binary operator.
3804	*/
3805	CINDEX_LINKAGE enum CX_BinaryOperatorKind
3806	clang_Cursor_getBinaryOpcode(CXCursor C);
3807
3808	/**
3809	* \brief Returns a string containing the spelling of the binary operator.
3810	*/
3811	CINDEX_LINKAGE CXString
3812	clang_Cursor_getBinaryOpcodeStr(enum CX_BinaryOperatorKind Op);
3813
3814	/**
3815	* Returns the storage class for a function or variable declaration.
3816	*
3817	* If the passed in Cursor is not a function or variable declaration,
3818	* CX_SC_Invalid is returned else the storage class.
3819	*/
3820	CINDEX_LINKAGE enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor);
3821
3822	/**
3823	* Determine the number of overloaded declarations referenced by a
3824	* \c CXCursor_OverloadedDeclRef cursor.
3825	*
3826	* \param cursor The cursor whose overloaded declarations are being queried.
3827	*
3828	* \returns The number of overloaded declarations referenced by \c cursor. If it
3829	* is not a \c CXCursor_OverloadedDeclRef cursor, returns 0.
3830	*/
3831	CINDEX_LINKAGE unsigned clang_getNumOverloadedDecls(CXCursor cursor);
3832
3833	/**
3834	* Retrieve a cursor for one of the overloaded declarations referenced
3835	* by a \c CXCursor_OverloadedDeclRef cursor.
3836	*
3837	* \param cursor The cursor whose overloaded declarations are being queried.
3838	*
3839	* \param index The zero-based index into the set of overloaded declarations in
3840	* the cursor.
3841	*
3842	* \returns A cursor representing the declaration referenced by the given
3843	* \c cursor at the specified \c index. If the cursor does not have an
3844	* associated set of overloaded declarations, or if the index is out of bounds,
3845	* returns \c clang_getNullCursor();
3846	*/
3847	CINDEX_LINKAGE CXCursor clang_getOverloadedDecl(CXCursor cursor,
3848	unsigned index);
3849
3850	/**
3851	* @}
3852	*/
3853
3854	/**
3855	* \defgroup CINDEX_ATTRIBUTES Information for attributes
3856	*
3857	* @{
3858	*/
3859
3860	/**
3861	* For cursors representing an iboutletcollection attribute,
3862	* this function returns the collection element type.
3863	*
3864	*/
3865	CINDEX_LINKAGE CXType clang_getIBOutletCollectionType(CXCursor);
3866
3867	/**
3868	* @}
3869	*/
3870
3871	/**
3872	* \defgroup CINDEX_CURSOR_TRAVERSAL Traversing the AST with cursors
3873	*
3874	* These routines provide the ability to traverse the abstract syntax tree
3875	* using cursors.
3876	*
3877	* @{
3878	*/
3879
3880	/**
3881	* Describes how the traversal of the children of a particular
3882	* cursor should proceed after visiting a particular child cursor.
3883	*
3884	* A value of this enumeration type should be returned by each
3885	* \c CXCursorVisitor to indicate how clang_visitChildren() proceed.
3886	*/
3887	enum CXChildVisitResult {
3888	/**
3889	* Terminates the cursor traversal.
3890	*/
3891	CXChildVisit_Break,
3892	/**
3893	* Continues the cursor traversal with the next sibling of
3894	* the cursor just visited, without visiting its children.
3895	*/
3896	CXChildVisit_Continue,
3897	/**
3898	* Recursively traverse the children of this cursor, using
3899	* the same visitor and client data.
3900	*/
3901	CXChildVisit_Recurse
3902	};
3903
3904	/**
3905	* Visitor invoked for each cursor found by a traversal.
3906	*
3907	* This visitor function will be invoked for each cursor found by
3908	* clang_visitCursorChildren(). Its first argument is the cursor being
3909	* visited, its second argument is the parent visitor for that cursor,
3910	* and its third argument is the client data provided to
3911	* clang_visitCursorChildren().
3912	*
3913	* The visitor should return one of the \c CXChildVisitResult values
3914	* to direct clang_visitCursorChildren().
3915	*/
3916	typedef enum CXChildVisitResult (*CXCursorVisitor)(CXCursor cursor,
3917	CXCursor parent,
3918	CXClientData client_data);
3919
3920	/**
3921	* Visit the children of a particular cursor.
3922	*
3923	* This function visits all the direct children of the given cursor,
3924	* invoking the given \p visitor function with the cursors of each
3925	* visited child. The traversal may be recursive, if the visitor returns
3926	* \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
3927	* the visitor returns \c CXChildVisit_Break.
3928	*
3929	* \param parent the cursor whose child may be visited. All kinds of
3930	* cursors can be visited, including invalid cursors (which, by
3931	* definition, have no children).
3932	*
3933	* \param visitor the visitor function that will be invoked for each
3934	* child of \p parent.
3935	*
3936	* \param client_data pointer data supplied by the client, which will
3937	* be passed to the visitor each time it is invoked.
3938	*
3939	* \returns a non-zero value if the traversal was terminated
3940	* prematurely by the visitor returning \c CXChildVisit_Break.
3941	*/
3942	CINDEX_LINKAGE unsigned clang_visitChildren(CXCursor parent,
3943	CXCursorVisitor visitor,
3944	CXClientData client_data);
3945	/**
3946	* Visitor invoked for each cursor found by a traversal.
3947	*
3948	* This visitor block will be invoked for each cursor found by
3949	* clang_visitChildrenWithBlock(). Its first argument is the cursor being
3950	* visited, its second argument is the parent visitor for that cursor.
3951	*
3952	* The visitor should return one of the \c CXChildVisitResult values
3953	* to direct clang_visitChildrenWithBlock().
3954	*/
3955	#if __has_feature(blocks)
3956	typedef enum CXChildVisitResult (^CXCursorVisitorBlock)(CXCursor cursor,
3957	CXCursor parent);
3958	#else
3959	typedef struct _CXChildVisitResult *CXCursorVisitorBlock;
3960	#endif
3961
3962	/**
3963	* Visits the children of a cursor using the specified block. Behaves
3964	* identically to clang_visitChildren() in all other respects.
3965	*/
3966	CINDEX_LINKAGE unsigned
3967	clang_visitChildrenWithBlock(CXCursor parent, CXCursorVisitorBlock block);
3968
3969	/**
3970	* @}
3971	*/
3972
3973	/**
3974	* \defgroup CINDEX_CURSOR_XREF Cross-referencing in the AST
3975	*
3976	* These routines provide the ability to determine references within and
3977	* across translation units, by providing the names of the entities referenced
3978	* by cursors, follow reference cursors to the declarations they reference,
3979	* and associate declarations with their definitions.
3980	*
3981	* @{
3982	*/
3983
3984	/**
3985	* Retrieve a Unified Symbol Resolution (USR) for the entity referenced
3986	* by the given cursor.
3987	*
3988	* A Unified Symbol Resolution (USR) is a string that identifies a particular
3989	* entity (function, class, variable, etc.) within a program. USRs can be
3990	* compared across translation units to determine, e.g., when references in
3991	* one translation refer to an entity defined in another translation unit.
3992	*/
3993	CINDEX_LINKAGE CXString clang_getCursorUSR(CXCursor);
3994
3995	/**
3996	* Construct a USR for a specified Objective-C class.
3997	*/
3998	CINDEX_LINKAGE CXString clang_constructUSR_ObjCClass(const char *class_name);
3999
4000	/**
4001	* Construct a USR for a specified Objective-C category.
4002	*/
4003	CINDEX_LINKAGE CXString clang_constructUSR_ObjCCategory(
4004	const char class_name, const* char *category_name);
4005
4006	/**
4007	* Construct a USR for a specified Objective-C protocol.
4008	*/
4009	CINDEX_LINKAGE CXString
4010	clang_constructUSR_ObjCProtocol(const char *protocol_name);
4011
4012	/**
4013	* Construct a USR for a specified Objective-C instance variable and
4014	* the USR for its containing class.
4015	*/
4016	CINDEX_LINKAGE CXString clang_constructUSR_ObjCIvar(const char *name,
4017	CXString classUSR);
4018
4019	/**
4020	* Construct a USR for a specified Objective-C method and
4021	* the USR for its containing class.
4022	*/
4023	CINDEX_LINKAGE CXString clang_constructUSR_ObjCMethod(const char *name,
4024	unsigned isInstanceMethod,
4025	CXString classUSR);
4026
4027	/**
4028	* Construct a USR for a specified Objective-C property and the USR
4029	* for its containing class.
4030	*/
4031	CINDEX_LINKAGE CXString clang_constructUSR_ObjCProperty(const char *property,
4032	CXString classUSR);
4033
4034	/**
4035	* Retrieve a name for the entity referenced by this cursor.
4036	*/
4037	CINDEX_LINKAGE CXString clang_getCursorSpelling(CXCursor);
4038
4039	/**
4040	* Retrieve a range for a piece that forms the cursors spelling name.
4041	* Most of the times there is only one range for the complete spelling but for
4042	* Objective-C methods and Objective-C message expressions, there are multiple
4043	* pieces for each selector identifier.
4044	*
4045	* \param pieceIndex the index of the spelling name piece. If this is greater
4046	* than the actual number of pieces, it will return a NULL (invalid) range.
4047	*
4048	* \param options Reserved.
4049	*/
4050	CINDEX_LINKAGE CXSourceRange clang_Cursor_getSpellingNameRange(
4051	CXCursor, unsigned pieceIndex, unsigned options);
4052
4053	/**
4054	* Opaque pointer representing a policy that controls pretty printing
4055	* for \c clang_getCursorPrettyPrinted.
4056	*/
4057	typedef void *CXPrintingPolicy;
4058
4059	/**
4060	* Properties for the printing policy.
4061	*
4062	* See \c clang::PrintingPolicy for more information.
4063	*/
4064	enum CXPrintingPolicyProperty {
4065	CXPrintingPolicy_Indentation,
4066	CXPrintingPolicy_SuppressSpecifiers,
4067	CXPrintingPolicy_SuppressTagKeyword,
4068	CXPrintingPolicy_IncludeTagDefinition,
4069	CXPrintingPolicy_SuppressScope,
4070	CXPrintingPolicy_SuppressUnwrittenScope,
4071	CXPrintingPolicy_SuppressInitializers,
4072	CXPrintingPolicy_ConstantArraySizeAsWritten,
4073	CXPrintingPolicy_AnonymousTagLocations,
4074	CXPrintingPolicy_SuppressStrongLifetime,
4075	CXPrintingPolicy_SuppressLifetimeQualifiers,
4076	CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors,
4077	CXPrintingPolicy_Bool,
4078	CXPrintingPolicy_Restrict,
4079	CXPrintingPolicy_Alignof,
4080	CXPrintingPolicy_UnderscoreAlignof,
4081	CXPrintingPolicy_UseVoidForZeroParams,
4082	CXPrintingPolicy_TerseOutput,
4083	CXPrintingPolicy_PolishForDeclaration,
4084	CXPrintingPolicy_Half,
4085	CXPrintingPolicy_MSWChar,
4086	CXPrintingPolicy_IncludeNewlines,
4087	CXPrintingPolicy_MSVCFormatting,
4088	CXPrintingPolicy_ConstantsAsWritten,
4089	CXPrintingPolicy_SuppressImplicitBase,
4090	CXPrintingPolicy_FullyQualifiedName,
4091
4092	CXPrintingPolicy_LastProperty = CXPrintingPolicy_FullyQualifiedName
4093	};
4094
4095	/**
4096	* Get a property value for the given printing policy.
4097	*/
4098	CINDEX_LINKAGE unsigned
4099	clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy,
4100	enum CXPrintingPolicyProperty Property);
4101
4102	/**
4103	* Set a property value for the given printing policy.
4104	*/
4105	CINDEX_LINKAGE void
4106	clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy,
4107	enum CXPrintingPolicyProperty Property,
4108	unsigned Value);
4109
4110	/**
4111	* Retrieve the default policy for the cursor.
4112	*
4113	* The policy should be released after use with \c
4114	* clang_PrintingPolicy_dispose.
4115	*/
4116	CINDEX_LINKAGE CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor);
4117
4118	/**
4119	* Release a printing policy.
4120	*/
4121	CINDEX_LINKAGE void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy);
4122
4123	/**
4124	* Pretty print declarations.
4125	*
4126	* \param Cursor The cursor representing a declaration.
4127	*
4128	* \param Policy The policy to control the entities being printed. If
4129	* NULL, a default policy is used.
4130	*
4131	* \returns The pretty printed declaration or the empty string for
4132	* other cursors.
4133	*/
4134	CINDEX_LINKAGE CXString clang_getCursorPrettyPrinted(CXCursor Cursor,
4135	CXPrintingPolicy Policy);
4136
4137	/**
4138	* Retrieve the display name for the entity referenced by this cursor.
4139	*
4140	* The display name contains extra information that helps identify the cursor,
4141	* such as the parameters of a function or template or the arguments of a
4142	* class template specialization.
4143	*/
4144	CINDEX_LINKAGE CXString clang_getCursorDisplayName(CXCursor);
4145
4146	/* For a cursor that is a reference, retrieve a cursor representing the*
4147	* entity that it references.
4148	*
4149	* Reference cursors refer to other entities in the AST. For example, an
4150	* Objective-C superclass reference cursor refers to an Objective-C class.
4151	* This function produces the cursor for the Objective-C class from the
4152	* cursor for the superclass reference. If the input cursor is a declaration or
4153	* definition, it returns that declaration or definition unchanged.
4154	* Otherwise, returns the NULL cursor.
4155	*/
4156	CINDEX_LINKAGE CXCursor clang_getCursorReferenced(CXCursor);
4157
4158	/**
4159	* For a cursor that is either a reference to or a declaration
4160	* of some entity, retrieve a cursor that describes the definition of
4161	* that entity.
4162	*
4163	* Some entities can be declared multiple times within a translation
4164	* unit, but only one of those declarations can also be a
4165	* definition. For example, given:
4166	*
4167	* \code
4168	* int f(int, int);
4169	* int g(int x, int y) { return f(x, y); }
4170	* int f(int a, int b) { return a + b; }
4171	* int f(int, int);
4172	* \endcode
4173	*
4174	* there are three declarations of the function "f", but only the
4175	* second one is a definition. The clang_getCursorDefinition()
4176	* function will take any cursor pointing to a declaration of "f"
4177	* (the first or fourth lines of the example) or a cursor referenced
4178	* that uses "f" (the call to "f' inside "g") and will return a
4179	* declaration cursor pointing to the definition (the second "f"
4180	* declaration).
4181	*
4182	* If given a cursor for which there is no corresponding definition,
4183	* e.g., because there is no definition of that entity within this
4184	* translation unit, returns a NULL cursor.
4185	*/
4186	CINDEX_LINKAGE CXCursor clang_getCursorDefinition(CXCursor);
4187
4188	/**
4189	* Determine whether the declaration pointed to by this cursor
4190	* is also a definition of that entity.
4191	*/
4192	CINDEX_LINKAGE unsigned clang_isCursorDefinition(CXCursor);
4193
4194	/**
4195	* Retrieve the canonical cursor corresponding to the given cursor.
4196	*
4197	* In the C family of languages, many kinds of entities can be declared several
4198	* times within a single translation unit. For example, a structure type can
4199	* be forward-declared (possibly multiple times) and later defined:
4200	*
4201	* \code
4202	* struct X;
4203	* struct X;
4204	* struct X {
4205	* int member;
4206	* };
4207	* \endcode
4208	*
4209	* The declarations and the definition of \c X are represented by three
4210	* different cursors, all of which are declarations of the same underlying
4211	* entity. One of these cursor is considered the "canonical" cursor, which
4212	* is effectively the representative for the underlying entity. One can
4213	* determine if two cursors are declarations of the same underlying entity by
4214	* comparing their canonical cursors.
4215	*
4216	* \returns The canonical cursor for the entity referred to by the given cursor.
4217	*/
4218	CINDEX_LINKAGE CXCursor clang_getCanonicalCursor(CXCursor);
4219
4220	/**
4221	* If the cursor points to a selector identifier in an Objective-C
4222	* method or message expression, this returns the selector index.
4223	*
4224	* After getting a cursor with #clang_getCursor, this can be called to
4225	* determine if the location points to a selector identifier.
4226	*
4227	* \returns The selector index if the cursor is an Objective-C method or message
4228	* expression and the cursor is pointing to a selector identifier, or -1
4229	* otherwise.
4230	*/
4231	CINDEX_LINKAGE int clang_Cursor_getObjCSelectorIndex(CXCursor);
4232
4233	/**
4234	* Given a cursor pointing to a C++ method call or an Objective-C
4235	* message, returns non-zero if the method/message is "dynamic", meaning:
4236	*
4237	* For a C++ method: the call is virtual.
4238	* For an Objective-C message: the receiver is an object instance, not 'super'
4239	* or a specific class.
4240	*
4241	* If the method/message is "static" or the cursor does not point to a
4242	* method/message, it will return zero.
4243	*/
4244	CINDEX_LINKAGE int clang_Cursor_isDynamicCall(CXCursor C);
4245
4246	/**
4247	* Given a cursor pointing to an Objective-C message or property
4248	* reference, or C++ method call, returns the CXType of the receiver.
4249	*/
4250	CINDEX_LINKAGE CXType clang_Cursor_getReceiverType(CXCursor C);
4251
4252	/**
4253	* Property attributes for a \c CXCursor_ObjCPropertyDecl.
4254	*/
4255	typedef enum {
4256	CXObjCPropertyAttr_noattr = `0x00`,
4257	CXObjCPropertyAttr_readonly = `0x01`,
4258	CXObjCPropertyAttr_getter = `0x02`,
4259	CXObjCPropertyAttr_assign = `0x04`,
4260	CXObjCPropertyAttr_readwrite = `0x08`,
4261	CXObjCPropertyAttr_retain = `0x10`,
4262	CXObjCPropertyAttr_copy = `0x20`,
4263	CXObjCPropertyAttr_nonatomic = `0x40`,
4264	CXObjCPropertyAttr_setter = `0x80`,
4265	CXObjCPropertyAttr_atomic = `0x100`,
4266	CXObjCPropertyAttr_weak = `0x200`,
4267	CXObjCPropertyAttr_strong = `0x400`,
4268	CXObjCPropertyAttr_unsafe_unretained = `0x800`,
4269	CXObjCPropertyAttr_class = `0x1000`
4270	} CXObjCPropertyAttrKind;
4271
4272	/**
4273	* Given a cursor that represents a property declaration, return the
4274	* associated property attributes. The bits are formed from
4275	* \c CXObjCPropertyAttrKind.
4276	*
4277	* \param reserved Reserved for future use, pass 0.
4278	*/
4279	CINDEX_LINKAGE unsigned
4280	clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved);
4281
4282	/**
4283	* Given a cursor that represents a property declaration, return the
4284	* name of the method that implements the getter.
4285	*/
4286	CINDEX_LINKAGE CXString clang_Cursor_getObjCPropertyGetterName(CXCursor C);
4287
4288	/**
4289	* Given a cursor that represents a property declaration, return the
4290	* name of the method that implements the setter, if any.
4291	*/
4292	CINDEX_LINKAGE CXString clang_Cursor_getObjCPropertySetterName(CXCursor C);
4293
4294	/**
4295	* 'Qualifiers' written next to the return and parameter types in
4296	* Objective-C method declarations.
4297	*/
4298	typedef enum {
4299	CXObjCDeclQualifier_None = `0x0`,
4300	CXObjCDeclQualifier_In = `0x1`,
4301	CXObjCDeclQualifier_Inout = `0x2`,
4302	CXObjCDeclQualifier_Out = `0x4`,
4303	CXObjCDeclQualifier_Bycopy = `0x8`,
4304	CXObjCDeclQualifier_Byref = `0x10`,
4305	CXObjCDeclQualifier_Oneway = `0x20`
4306	} CXObjCDeclQualifierKind;
4307
4308	/**
4309	* Given a cursor that represents an Objective-C method or parameter
4310	* declaration, return the associated Objective-C qualifiers for the return
4311	* type or the parameter respectively. The bits are formed from
4312	* CXObjCDeclQualifierKind.
4313	*/
4314	CINDEX_LINKAGE unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C);
4315
4316	/**
4317	* Given a cursor that represents an Objective-C method or property
4318	* declaration, return non-zero if the declaration was affected by "\@optional".
4319	* Returns zero if the cursor is not such a declaration or it is "\@required".
4320	*/
4321	CINDEX_LINKAGE unsigned clang_Cursor_isObjCOptional(CXCursor C);
4322
4323	/**
4324	* Returns non-zero if the given cursor is a variadic function or method.
4325	*/
4326	CINDEX_LINKAGE unsigned clang_Cursor_isVariadic(CXCursor C);
4327
4328	/**
4329	* Returns non-zero if the given cursor points to a symbol marked with
4330	* external_source_symbol attribute.
4331	*
4332	* \param language If non-NULL, and the attribute is present, will be set to
4333	* the 'language' string from the attribute.
4334	*
4335	* \param definedIn If non-NULL, and the attribute is present, will be set to
4336	* the 'definedIn' string from the attribute.
4337	*
4338	* \param isGenerated If non-NULL, and the attribute is present, will be set to
4339	* non-zero if the 'generated_declaration' is set in the attribute.
4340	*/
4341	CINDEX_LINKAGE unsigned clang_Cursor_isExternalSymbol(CXCursor C,
4342	CXString *language,
4343	CXString *definedIn,
4344	unsigned *isGenerated);
4345
4346	/**
4347	* Given a cursor that represents a declaration, return the associated
4348	* comment's source range. The range may include multiple consecutive comments
4349	* with whitespace in between.
4350	*/
4351	CINDEX_LINKAGE CXSourceRange clang_Cursor_getCommentRange(CXCursor C);
4352
4353	/**
4354	* Given a cursor that represents a declaration, return the associated
4355	* comment text, including comment markers.
4356	*/
4357	CINDEX_LINKAGE CXString clang_Cursor_getRawCommentText(CXCursor C);
4358
4359	/**
4360	* Given a cursor that represents a documentable entity (e.g.,
4361	* declaration), return the associated \paragraph; otherwise return the
4362	* first paragraph.
4363	*/
4364	CINDEX_LINKAGE CXString clang_Cursor_getBriefCommentText(CXCursor C);
4365
4366	/**
4367	* @}
4368	*/
4369
4370	/* \defgroup CINDEX_MANGLE Name Mangling API Functions*
4371	*
4372	* @{
4373	*/
4374
4375	/**
4376	* Retrieve the CXString representing the mangled name of the cursor.
4377	*/
4378	CINDEX_LINKAGE CXString clang_Cursor_getMangling(CXCursor);
4379
4380	/**
4381	* Retrieve the CXStrings representing the mangled symbols of the C++
4382	* constructor or destructor at the cursor.
4383	*/
4384	CINDEX_LINKAGE CXStringSet *clang_Cursor_getCXXManglings(CXCursor);
4385
4386	/**
4387	* Retrieve the CXStrings representing the mangled symbols of the ObjC
4388	* class interface or implementation at the cursor.
4389	*/
4390	CINDEX_LINKAGE CXStringSet *clang_Cursor_getObjCManglings(CXCursor);
4391
4392	/**
4393	* @}
4394	*/
4395
4396	/**
4397	* \defgroup CINDEX_MODULE Module introspection
4398	*
4399	* The functions in this group provide access to information about modules.
4400	*
4401	* @{
4402	*/
4403
4404	typedef void *CXModule;
4405
4406	/**
4407	* Given a CXCursor_ModuleImportDecl cursor, return the associated module.
4408	*/
4409	CINDEX_LINKAGE CXModule clang_Cursor_getModule(CXCursor C);
4410
4411	/**
4412	* Given a CXFile header file, return the module that contains it, if one
4413	* exists.
4414	*/
4415	CINDEX_LINKAGE CXModule clang_getModuleForFile(CXTranslationUnit, CXFile);
4416
4417	/**
4418	* \param Module a module object.
4419	*
4420	* \returns the module file where the provided module object came from.
4421	*/
4422	CINDEX_LINKAGE CXFile clang_Module_getASTFile(CXModule Module);
4423
4424	/**
4425	* \param Module a module object.
4426	*
4427	* \returns the parent of a sub-module or NULL if the given module is top-level,
4428	* e.g. for 'std.vector' it will return the 'std' module.
4429	*/
4430	CINDEX_LINKAGE CXModule clang_Module_getParent(CXModule Module);
4431
4432	/**
4433	* \param Module a module object.
4434	*
4435	* \returns the name of the module, e.g. for the 'std.vector' sub-module it
4436	* will return "vector".
4437	*/
4438	CINDEX_LINKAGE CXString clang_Module_getName(CXModule Module);
4439
4440	/**
4441	* \param Module a module object.
4442	*
4443	* \returns the full name of the module, e.g. "std.vector".
4444	*/
4445	CINDEX_LINKAGE CXString clang_Module_getFullName(CXModule Module);
4446
4447	/**
4448	* \param Module a module object.
4449	*
4450	* \returns non-zero if the module is a system one.
4451	*/
4452	CINDEX_LINKAGE int clang_Module_isSystem(CXModule Module);
4453
4454	/**
4455	* \param Module a module object.
4456	*
4457	* \returns the number of top level headers associated with this module.
4458	*/
4459	CINDEX_LINKAGE unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit,
4460	CXModule Module);
4461
4462	/**
4463	* \param Module a module object.
4464	*
4465	* \param Index top level header index (zero-based).
4466	*
4467	* \returns the specified top level header associated with the module.
4468	*/
4469	CINDEX_LINKAGE
4470	CXFile clang_Module_getTopLevelHeader(CXTranslationUnit, CXModule Module,
4471	unsigned Index);
4472
4473	/**
4474	* @}
4475	*/
4476
4477	/**
4478	* \defgroup CINDEX_CPP C++ AST introspection
4479	*
4480	* The routines in this group provide access information in the ASTs specific
4481	* to C++ language features.
4482	*
4483	* @{
4484	*/
4485
4486	/**
4487	* Determine if a C++ constructor is a converting constructor.
4488	*/
4489	CINDEX_LINKAGE unsigned
4490	clang_CXXConstructor_isConvertingConstructor(CXCursor C);
4491
4492	/**
4493	* Determine if a C++ constructor is a copy constructor.
4494	*/
4495	CINDEX_LINKAGE unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C);
4496
4497	/**
4498	* Determine if a C++ constructor is the default constructor.
4499	*/
4500	CINDEX_LINKAGE unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C);
4501
4502	/**
4503	* Determine if a C++ constructor is a move constructor.
4504	*/
4505	CINDEX_LINKAGE unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C);
4506
4507	/**
4508	* Determine if a C++ field is declared 'mutable'.
4509	*/
4510	CINDEX_LINKAGE unsigned clang_CXXField_isMutable(CXCursor C);
4511
4512	/**
4513	* Determine if a C++ method is declared '= default'.
4514	*/
4515	CINDEX_LINKAGE unsigned clang_CXXMethod_isDefaulted(CXCursor C);
4516
4517	/**
4518	* Determine if a C++ method is declared '= delete'.
4519	*/
4520	CINDEX_LINKAGE unsigned clang_CXXMethod_isDeleted(CXCursor C);
4521
4522	/**
4523	* Determine if a C++ member function or member function template is
4524	* pure virtual.
4525	*/
4526	CINDEX_LINKAGE unsigned clang_CXXMethod_isPureVirtual(CXCursor C);
4527
4528	/**
4529	* Determine if a C++ member function or member function template is
4530	* declared 'static'.
4531	*/
4532	CINDEX_LINKAGE unsigned clang_CXXMethod_isStatic(CXCursor C);
4533
4534	/**
4535	* Determine if a C++ member function or member function template is
4536	* explicitly declared 'virtual' or if it overrides a virtual method from
4537	* one of the base classes.
4538	*/
4539	CINDEX_LINKAGE unsigned clang_CXXMethod_isVirtual(CXCursor C);
4540
4541	/**
4542	* Determine if a C++ member function is a copy-assignment operator,
4543	* returning 1 if such is the case and 0 otherwise.
4544	*
4545	* > A copy-assignment operator `X::operator=` is a non-static,
4546	* > non-template member function of _class_ `X` with exactly one
4547	* > parameter of type `X`, `X&`, `const X&`, `volatile X&` or `const
4548	* > volatile X&`.
4549	*
4550	* That is, for example, the `operator=` in:
4551	*
4552	* class Foo {
4553	* bool operator=(const volatile Foo&);
4554	* };
4555	*
4556	* Is a copy-assignment operator, while the `operator=` in:
4557	*
4558	* class Bar {
4559	* bool operator=(const int&);
4560	* };
4561	*
4562	* Is not.
4563	*/
4564	CINDEX_LINKAGE unsigned clang_CXXMethod_isCopyAssignmentOperator(CXCursor C);
4565
4566	/**
4567	* Determine if a C++ member function is a move-assignment operator,
4568	* returning 1 if such is the case and 0 otherwise.
4569	*
4570	* > A move-assignment operator `X::operator=` is a non-static,
4571	* > non-template member function of _class_ `X` with exactly one
4572	* > parameter of type `X&&`, `const X&&`, `volatile X&&` or `const
4573	* > volatile X&&`.
4574	*
4575	* That is, for example, the `operator=` in:
4576	*
4577	* class Foo {
4578	* bool operator=(const volatile Foo&&);
4579	* };
4580	*
4581	* Is a move-assignment operator, while the `operator=` in:
4582	*
4583	* class Bar {
4584	* bool operator=(const int&&);
4585	* };
4586	*
4587	* Is not.
4588	*/
4589	CINDEX_LINKAGE unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C);
4590
4591	/**
4592	* Determines if a C++ constructor or conversion function was declared
4593	* explicit, returning 1 if such is the case and 0 otherwise.
4594	*
4595	* Constructors or conversion functions are declared explicit through
4596	* the use of the explicit specifier.
4597	*
4598	* For example, the following constructor and conversion function are
4599	* not explicit as they lack the explicit specifier:
4600	*
4601	* class Foo {
4602	* Foo();
4603	* operator int();
4604	* };
4605	*
4606	* While the following constructor and conversion function are
4607	* explicit as they are declared with the explicit specifier.
4608	*
4609	* class Foo {
4610	* explicit Foo();
4611	* explicit operator int();
4612	* };
4613	*
4614	* This function will return 0 when given a cursor pointing to one of
4615	* the former declarations and it will return 1 for a cursor pointing
4616	* to the latter declarations.
4617	*
4618	* The explicit specifier allows the user to specify a
4619	* conditional compile-time expression whose value decides
4620	* whether the marked element is explicit or not.
4621	*
4622	* For example:
4623	*
4624	* constexpr bool foo(int i) { return i % 2 == 0; }
4625	*
4626	* class Foo {
4627	* explicit(foo(1)) Foo();
4628	* explicit(foo(2)) operator int();
4629	* }
4630	*
4631	* This function will return 0 for the constructor and 1 for
4632	* the conversion function.
4633	*/
4634	CINDEX_LINKAGE unsigned clang_CXXMethod_isExplicit(CXCursor C);
4635
4636	/**
4637	* Determine if a C++ record is abstract, i.e. whether a class or struct
4638	* has a pure virtual member function.
4639	*/
4640	CINDEX_LINKAGE unsigned clang_CXXRecord_isAbstract(CXCursor C);
4641
4642	/**
4643	* Determine if an enum declaration refers to a scoped enum.
4644	*/
4645	CINDEX_LINKAGE unsigned clang_EnumDecl_isScoped(CXCursor C);
4646
4647	/**
4648	* Determine if a C++ member function or member function template is
4649	* declared 'const'.
4650	*/
4651	CINDEX_LINKAGE unsigned clang_CXXMethod_isConst(CXCursor C);
4652
4653	/**
4654	* Given a cursor that represents a template, determine
4655	* the cursor kind of the specializations would be generated by instantiating
4656	* the template.
4657	*
4658	* This routine can be used to determine what flavor of function template,
4659	* class template, or class template partial specialization is stored in the
4660	* cursor. For example, it can describe whether a class template cursor is
4661	* declared with "struct", "class" or "union".
4662	*
4663	* \param C The cursor to query. This cursor should represent a template
4664	* declaration.
4665	*
4666	* \returns The cursor kind of the specializations that would be generated
4667	* by instantiating the template \p C. If \p C is not a template, returns
4668	* \c CXCursor_NoDeclFound.
4669	*/
4670	CINDEX_LINKAGE enum CXCursorKind clang_getTemplateCursorKind(CXCursor C);
4671
4672	/**
4673	* Given a cursor that may represent a specialization or instantiation
4674	* of a template, retrieve the cursor that represents the template that it
4675	* specializes or from which it was instantiated.
4676	*
4677	* This routine determines the template involved both for explicit
4678	* specializations of templates and for implicit instantiations of the template,
4679	* both of which are referred to as "specializations". For a class template
4680	* specialization (e.g., \c std::vector<bool>), this routine will return
4681	* either the primary template (\c std::vector) or, if the specialization was
4682	* instantiated from a class template partial specialization, the class template
4683	* partial specialization. For a class template partial specialization and a
4684	* function template specialization (including instantiations), this
4685	* this routine will return the specialized template.
4686	*
4687	* For members of a class template (e.g., member functions, member classes, or
4688	* static data members), returns the specialized or instantiated member.
4689	* Although not strictly "templates" in the C++ language, members of class
4690	* templates have the same notions of specializations and instantiations that
4691	* templates do, so this routine treats them similarly.
4692	*
4693	* \param C A cursor that may be a specialization of a template or a member
4694	* of a template.
4695	*
4696	* \returns If the given cursor is a specialization or instantiation of a
4697	* template or a member thereof, the template or member that it specializes or
4698	* from which it was instantiated. Otherwise, returns a NULL cursor.
4699	*/
4700	CINDEX_LINKAGE CXCursor clang_getSpecializedCursorTemplate(CXCursor C);
4701
4702	/**
4703	* Given a cursor that references something else, return the source range
4704	* covering that reference.
4705	*
4706	* \param C A cursor pointing to a member reference, a declaration reference, or
4707	* an operator call.
4708	* \param NameFlags A bitset with three independent flags:
4709	* CXNameRange_WantQualifier, CXNameRange_WantTemplateArgs, and
4710	* CXNameRange_WantSinglePiece.
4711	* \param PieceIndex For contiguous names or when passing the flag
4712	* CXNameRange_WantSinglePiece, only one piece with index 0 is
4713	* available. When the CXNameRange_WantSinglePiece flag is not passed for a
4714	* non-contiguous names, this index can be used to retrieve the individual
4715	* pieces of the name. See also CXNameRange_WantSinglePiece.
4716	*
4717	* \returns The piece of the name pointed to by the given cursor. If there is no
4718	* name, or if the PieceIndex is out-of-range, a null-cursor will be returned.
4719	*/
4720	CINDEX_LINKAGE CXSourceRange clang_getCursorReferenceNameRange(
4721	CXCursor C, unsigned NameFlags, unsigned PieceIndex);
4722
4723	enum CXNameRefFlags {
4724	/**
4725	* Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the
4726	* range.
4727	*/
4728	CXNameRange_WantQualifier = `0x1`,
4729
4730	/**
4731	* Include the explicit template arguments, e.g. \<int> in x.f<int>,
4732	* in the range.
4733	*/
4734	CXNameRange_WantTemplateArgs = `0x2`,
4735
4736	/**
4737	* If the name is non-contiguous, return the full spanning range.
4738	*
4739	* Non-contiguous names occur in Objective-C when a selector with two or more
4740	* parameters is used, or in C++ when using an operator:
4741	* \code
4742	* [object doSomething:here withValue:there]; // Objective-C
4743	* return some_vector[1]; // C++
4744	* \endcode
4745	*/
4746	CXNameRange_WantSinglePiece = `0x4`
4747	};
4748
4749	/**
4750	* @}
4751	*/
4752
4753	/**
4754	* \defgroup CINDEX_LEX Token extraction and manipulation
4755	*
4756	* The routines in this group provide access to the tokens within a
4757	* translation unit, along with a semantic mapping of those tokens to
4758	* their corresponding cursors.
4759	*
4760	* @{
4761	*/
4762
4763	/**
4764	* Describes a kind of token.
4765	*/
4766	typedef enum CXTokenKind {
4767	/**
4768	* A token that contains some kind of punctuation.
4769	*/
4770	CXToken_Punctuation,
4771
4772	/**
4773	* A language keyword.
4774	*/
4775	CXToken_Keyword,
4776
4777	/**
4778	* An identifier (that is not a keyword).
4779	*/
4780	CXToken_Identifier,
4781
4782	/**
4783	* A numeric, string, or character literal.
4784	*/
4785	CXToken_Literal,
4786
4787	/**
4788	* A comment.
4789	*/
4790	CXToken_Comment
4791	} CXTokenKind;
4792
4793	/**
4794	* Describes a single preprocessing token.
4795	*/
4796	typedef struct {
4797	unsigned int_data[`4`];
4798	void *ptr_data;
4799	} CXToken;
4800
4801	/**
4802	* Get the raw lexical token starting with the given location.
4803	*
4804	* \param TU the translation unit whose text is being tokenized.
4805	*
4806	* \param Location the source location with which the token starts.
4807	*
4808	* \returns The token starting with the given location or NULL if no such token
4809	* exist. The returned pointer must be freed with clang_disposeTokens before the
4810	* translation unit is destroyed.
4811	*/
4812	CINDEX_LINKAGE CXToken *clang_getToken(CXTranslationUnit TU,
4813	CXSourceLocation Location);
4814
4815	/**
4816	* Determine the kind of the given token.
4817	*/
4818	CINDEX_LINKAGE CXTokenKind clang_getTokenKind(CXToken);
4819
4820	/**
4821	* Determine the spelling of the given token.
4822	*
4823	* The spelling of a token is the textual representation of that token, e.g.,
4824	* the text of an identifier or keyword.
4825	*/
4826	CINDEX_LINKAGE CXString clang_getTokenSpelling(CXTranslationUnit, CXToken);
4827
4828	/**
4829	* Retrieve the source location of the given token.
4830	*/
4831	CINDEX_LINKAGE CXSourceLocation clang_getTokenLocation(CXTranslationUnit,
4832	CXToken);
4833
4834	/**
4835	* Retrieve a source range that covers the given token.
4836	*/
4837	CINDEX_LINKAGE CXSourceRange clang_getTokenExtent(CXTranslationUnit, CXToken);
4838
4839	/**
4840	* Tokenize the source code described by the given range into raw
4841	* lexical tokens.
4842	*
4843	* \param TU the translation unit whose text is being tokenized.
4844	*
4845	* \param Range the source range in which text should be tokenized. All of the
4846	* tokens produced by tokenization will fall within this source range,
4847	*
4848	* \param Tokens this pointer will be set to point to the array of tokens
4849	* that occur within the given source range. The returned pointer must be
4850	* freed with clang_disposeTokens() before the translation unit is destroyed.
4851	*
4852	* \param NumTokens will be set to the number of tokens in the \c *Tokens
4853	* array.
4854	*
4855	*/
4856	CINDEX_LINKAGE void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
4857	CXToken *Tokens, unsigned* *NumTokens);
4858
4859	/**
4860	* Annotate the given set of tokens by providing cursors for each token
4861	* that can be mapped to a specific entity within the abstract syntax tree.
4862	*
4863	* This token-annotation routine is equivalent to invoking
4864	* clang_getCursor() for the source locations of each of the
4865	* tokens. The cursors provided are filtered, so that only those
4866	* cursors that have a direct correspondence to the token are
4867	* accepted. For example, given a function call \c f(x),
4868	* clang_getCursor() would provide the following cursors:
4869	*
4870	* * when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.
4871	* * when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.
4872	* * when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'.
4873	*
4874	* Only the first and last of these cursors will occur within the
4875	* annotate, since the tokens "f" and "x' directly refer to a function
4876	* and a variable, respectively, but the parentheses are just a small
4877	* part of the full syntax of the function call expression, which is
4878	* not provided as an annotation.
4879	*
4880	* \param TU the translation unit that owns the given tokens.
4881	*
4882	* \param Tokens the set of tokens to annotate.
4883	*
4884	* \param NumTokens the number of tokens in \p Tokens.
4885	*
4886	* \param Cursors an array of \p NumTokens cursors, whose contents will be
4887	* replaced with the cursors corresponding to each token.
4888	*/
4889	CINDEX_LINKAGE void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens,
4890	unsigned NumTokens, CXCursor *Cursors);
4891
4892	/**
4893	* Free the given set of tokens.
4894	*/
4895	CINDEX_LINKAGE void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens,
4896	unsigned NumTokens);
4897
4898	/**
4899	* @}
4900	*/
4901
4902	/**
4903	* \defgroup CINDEX_DEBUG Debugging facilities
4904	*
4905	* These routines are used for testing and debugging, only, and should not
4906	* be relied upon.
4907	*
4908	* @{
4909	*/
4910
4911	/ for debug/testing /
4912	CINDEX_LINKAGE CXString clang_getCursorKindSpelling(enum CXCursorKind Kind);
4913	CINDEX_LINKAGE void clang_getDefinitionSpellingAndExtent(
4914	CXCursor, const char *startBuf, const* char *endBuf, unsigned* *startLine,
4915	unsigned startColumn, unsigned* endLine, unsigned* *endColumn);
4916	CINDEX_LINKAGE void clang_enableStackTraces(void);
4917	CINDEX_LINKAGE void clang_executeOnThread(void (fn)(void* ), void* *user_data,
4918	unsigned stack_size);
4919
4920	/**
4921	* @}
4922	*/
4923
4924	/**
4925	* \defgroup CINDEX_CODE_COMPLET Code completion
4926	*
4927	* Code completion involves taking an (incomplete) source file, along with
4928	* knowledge of where the user is actively editing that file, and suggesting
4929	* syntactically- and semantically-valid constructs that the user might want to
4930	* use at that particular point in the source code. These data structures and
4931	* routines provide support for code completion.
4932	*
4933	* @{
4934	*/
4935
4936	/**
4937	* A semantic string that describes a code-completion result.
4938	*
4939	* A semantic string that describes the formatting of a code-completion
4940	* result as a single "template" of text that should be inserted into the
4941	* source buffer when a particular code-completion result is selected.
4942	* Each semantic string is made up of some number of "chunks", each of which
4943	* contains some text along with a description of what that text means, e.g.,
4944	* the name of the entity being referenced, whether the text chunk is part of
4945	* the template, or whether it is a "placeholder" that the user should replace
4946	* with actual code,of a specific kind. See \c CXCompletionChunkKind for a
4947	* description of the different kinds of chunks.
4948	*/
4949	typedef void *CXCompletionString;
4950
4951	/**
4952	* A single result of code completion.
4953	*/
4954	typedef struct {
4955	/**
4956	* The kind of entity that this completion refers to.
4957	*
4958	* The cursor kind will be a macro, keyword, or a declaration (one of the
4959	* *Decl cursor kinds), describing the entity that the completion is
4960	* referring to.
4961	*
4962	* \todo In the future, we would like to provide a full cursor, to allow
4963	* the client to extract additional information from declaration.
4964	*/
4965	enum CXCursorKind CursorKind;
4966
4967	/**
4968	* The code-completion string that describes how to insert this
4969	* code-completion result into the editing buffer.
4970	*/
4971	CXCompletionString CompletionString;
4972	} CXCompletionResult;
4973
4974	/**
4975	* Describes a single piece of text within a code-completion string.
4976	*
4977	* Each "chunk" within a code-completion string (\c CXCompletionString) is
4978	* either a piece of text with a specific "kind" that describes how that text
4979	* should be interpreted by the client or is another completion string.
4980	*/
4981	enum CXCompletionChunkKind {
4982	/**
4983	* A code-completion string that describes "optional" text that
4984	* could be a part of the template (but is not required).
4985	*
4986	* The Optional chunk is the only kind of chunk that has a code-completion
4987	* string for its representation, which is accessible via
4988	* \c clang_getCompletionChunkCompletionString(). The code-completion string
4989	* describes an additional part of the template that is completely optional.
4990	* For example, optional chunks can be used to describe the placeholders for
4991	* arguments that match up with defaulted function parameters, e.g. given:
4992	*
4993	* \code
4994	* void f(int x, float y = 3.14, double z = 2.71828);
4995	* \endcode
4996	*
4997	* The code-completion string for this function would contain:
4998	* - a TypedText chunk for "f".
4999	* - a LeftParen chunk for "(".
5000	* - a Placeholder chunk for "int x"
5001	* - an Optional chunk containing the remaining defaulted arguments, e.g.,
5002	* - a Comma chunk for ","
5003	* - a Placeholder chunk for "float y"
5004	* - an Optional chunk containing the last defaulted argument:
5005	* - a Comma chunk for ","
5006	* - a Placeholder chunk for "double z"
5007	* - a RightParen chunk for ")"
5008	*
5009	* There are many ways to handle Optional chunks. Two simple approaches are:
5010	* - Completely ignore optional chunks, in which case the template for the
5011	* function "f" would only include the first parameter ("int x").
5012	* - Fully expand all optional chunks, in which case the template for the
5013	* function "f" would have all of the parameters.
5014	*/
5015	CXCompletionChunk_Optional,
5016	/**
5017	* Text that a user would be expected to type to get this
5018	* code-completion result.
5019	*
5020	* There will be exactly one "typed text" chunk in a semantic string, which
5021	* will typically provide the spelling of a keyword or the name of a
5022	* declaration that could be used at the current code point. Clients are
5023	* expected to filter the code-completion results based on the text in this
5024	* chunk.
5025	*/
5026	CXCompletionChunk_TypedText,
5027	/**
5028	* Text that should be inserted as part of a code-completion result.
5029	*
5030	* A "text" chunk represents text that is part of the template to be
5031	* inserted into user code should this particular code-completion result
5032	* be selected.
5033	*/
5034	CXCompletionChunk_Text,
5035	/**
5036	* Placeholder text that should be replaced by the user.
5037	*
5038	* A "placeholder" chunk marks a place where the user should insert text
5039	* into the code-completion template. For example, placeholders might mark
5040	* the function parameters for a function declaration, to indicate that the
5041	* user should provide arguments for each of those parameters. The actual
5042	* text in a placeholder is a suggestion for the text to display before
5043	* the user replaces the placeholder with real code.
5044	*/
5045	CXCompletionChunk_Placeholder,
5046	/**
5047	* Informative text that should be displayed but never inserted as
5048	* part of the template.
5049	*
5050	* An "informative" chunk contains annotations that can be displayed to
5051	* help the user decide whether a particular code-completion result is the
5052	* right option, but which is not part of the actual template to be inserted
5053	* by code completion.
5054	*/
5055	CXCompletionChunk_Informative,
5056	/**
5057	* Text that describes the current parameter when code-completion is
5058	* referring to function call, message send, or template specialization.
5059	*
5060	* A "current parameter" chunk occurs when code-completion is providing
5061	* information about a parameter corresponding to the argument at the
5062	* code-completion point. For example, given a function
5063	*
5064	* \code
5065	* int add(int x, int y);
5066	* \endcode
5067	*
5068	* and the source code \c add(, where the code-completion point is after the
5069	* "(", the code-completion string will contain a "current parameter" chunk
5070	* for "int x", indicating that the current argument will initialize that
5071	* parameter. After typing further, to \c add(17, (where the code-completion
5072	* point is after the ","), the code-completion string will contain a
5073	* "current parameter" chunk to "int y".
5074	*/
5075	CXCompletionChunk_CurrentParameter,
5076	/**
5077	* A left parenthesis ('('), used to initiate a function call or
5078	* signal the beginning of a function parameter list.
5079	*/
5080	CXCompletionChunk_LeftParen,
5081	/**
5082	* A right parenthesis (')'), used to finish a function call or
5083	* signal the end of a function parameter list.
5084	*/
5085	CXCompletionChunk_RightParen,
5086	/**
5087	* A left bracket ('[').
5088	*/
5089	CXCompletionChunk_LeftBracket,
5090	/**
5091	* A right bracket (']').
5092	*/
5093	CXCompletionChunk_RightBracket,
5094	/**
5095	* A left brace ('{').
5096	*/
5097	CXCompletionChunk_LeftBrace,
5098	/**
5099	* A right brace ('}').
5100	*/
5101	CXCompletionChunk_RightBrace,
5102	/**
5103	* A left angle bracket ('<').
5104	*/
5105	CXCompletionChunk_LeftAngle,
5106	/**
5107	* A right angle bracket ('>').
5108	*/
5109	CXCompletionChunk_RightAngle,
5110	/**
5111	* A comma separator (',').
5112	*/
5113	CXCompletionChunk_Comma,
5114	/**
5115	* Text that specifies the result type of a given result.
5116	*
5117	* This special kind of informative chunk is not meant to be inserted into
5118	* the text buffer. Rather, it is meant to illustrate the type that an
5119	* expression using the given completion string would have.
5120	*/
5121	CXCompletionChunk_ResultType,
5122	/**
5123	* A colon (':').
5124	*/
5125	CXCompletionChunk_Colon,
5126	/**
5127	* A semicolon (';').
5128	*/
5129	CXCompletionChunk_SemiColon,
5130	/**
5131	* An '=' sign.
5132	*/
5133	CXCompletionChunk_Equal,
5134	/**
5135	* Horizontal space (' ').
5136	*/
5137	CXCompletionChunk_HorizontalSpace,
5138	/**
5139	* Vertical space ('\\n'), after which it is generally a good idea to
5140	* perform indentation.
5141	*/
5142	CXCompletionChunk_VerticalSpace
5143	};
5144
5145	/**
5146	* Determine the kind of a particular chunk within a completion string.
5147	*
5148	* \param completion_string the completion string to query.
5149	*
5150	* \param chunk_number the 0-based index of the chunk in the completion string.
5151	*
5152	* \returns the kind of the chunk at the index \c chunk_number.
5153	*/
5154	CINDEX_LINKAGE enum CXCompletionChunkKind
5155	clang_getCompletionChunkKind(CXCompletionString completion_string,
5156	unsigned chunk_number);
5157
5158	/**
5159	* Retrieve the text associated with a particular chunk within a
5160	* completion string.
5161	*
5162	* \param completion_string the completion string to query.
5163	*
5164	* \param chunk_number the 0-based index of the chunk in the completion string.
5165	*
5166	* \returns the text associated with the chunk at index \c chunk_number.
5167	*/
5168	CINDEX_LINKAGE CXString clang_getCompletionChunkText(
5169	CXCompletionString completion_string, unsigned chunk_number);
5170
5171	/**
5172	* Retrieve the completion string associated with a particular chunk
5173	* within a completion string.
5174	*
5175	* \param completion_string the completion string to query.
5176	*
5177	* \param chunk_number the 0-based index of the chunk in the completion string.
5178	*
5179	* \returns the completion string associated with the chunk at index
5180	* \c chunk_number.
5181	*/
5182	CINDEX_LINKAGE CXCompletionString clang_getCompletionChunkCompletionString(
5183	CXCompletionString completion_string, unsigned chunk_number);
5184
5185	/**
5186	* Retrieve the number of chunks in the given code-completion string.
5187	*/
5188	CINDEX_LINKAGE unsigned
5189	clang_getNumCompletionChunks(CXCompletionString completion_string);
5190
5191	/**
5192	* Determine the priority of this code completion.
5193	*
5194	* The priority of a code completion indicates how likely it is that this
5195	* particular completion is the completion that the user will select. The
5196	* priority is selected by various internal heuristics.
5197	*
5198	* \param completion_string The completion string to query.
5199	*
5200	* \returns The priority of this completion string. Smaller values indicate
5201	* higher-priority (more likely) completions.
5202	*/
5203	CINDEX_LINKAGE unsigned
5204	clang_getCompletionPriority(CXCompletionString completion_string);
5205
5206	/**
5207	* Determine the availability of the entity that this code-completion
5208	* string refers to.
5209	*
5210	* \param completion_string The completion string to query.
5211	*
5212	* \returns The availability of the completion string.
5213	*/
5214	CINDEX_LINKAGE enum CXAvailabilityKind
5215	clang_getCompletionAvailability(CXCompletionString completion_string);
5216
5217	/**
5218	* Retrieve the number of annotations associated with the given
5219	* completion string.
5220	*
5221	* \param completion_string the completion string to query.
5222	*
5223	* \returns the number of annotations associated with the given completion
5224	* string.
5225	*/
5226	CINDEX_LINKAGE unsigned
5227	clang_getCompletionNumAnnotations(CXCompletionString completion_string);
5228
5229	/**
5230	* Retrieve the annotation associated with the given completion string.
5231	*
5232	* \param completion_string the completion string to query.
5233	*
5234	* \param annotation_number the 0-based index of the annotation of the
5235	* completion string.
5236	*
5237	* \returns annotation string associated with the completion at index
5238	* \c annotation_number, or a NULL string if that annotation is not available.
5239	*/
5240	CINDEX_LINKAGE CXString clang_getCompletionAnnotation(
5241	CXCompletionString completion_string, unsigned annotation_number);
5242
5243	/**
5244	* Retrieve the parent context of the given completion string.
5245	*
5246	* The parent context of a completion string is the semantic parent of
5247	* the declaration (if any) that the code completion represents. For example,
5248	* a code completion for an Objective-C method would have the method's class
5249	* or protocol as its context.
5250	*
5251	* \param completion_string The code completion string whose parent is
5252	* being queried.
5253	*
5254	* \param kind DEPRECATED: always set to CXCursor_NotImplemented if non-NULL.
5255	*
5256	* \returns The name of the completion parent, e.g., "NSObject" if
5257	* the completion string represents a method in the NSObject class.
5258	*/
5259	CINDEX_LINKAGE CXString clang_getCompletionParent(
5260	CXCompletionString completion_string, enum CXCursorKind *kind);
5261
5262	/**
5263	* Retrieve the brief documentation comment attached to the declaration
5264	* that corresponds to the given completion string.
5265	*/
5266	CINDEX_LINKAGE CXString
5267	clang_getCompletionBriefComment(CXCompletionString completion_string);
5268
5269	/**
5270	* Retrieve a completion string for an arbitrary declaration or macro
5271	* definition cursor.
5272	*
5273	* \param cursor The cursor to query.
5274	*
5275	* \returns A non-context-sensitive completion string for declaration and macro
5276	* definition cursors, or NULL for other kinds of cursors.
5277	*/
5278	CINDEX_LINKAGE CXCompletionString
5279	clang_getCursorCompletionString(CXCursor cursor);
5280
5281	/**
5282	* Contains the results of code-completion.
5283	*
5284	* This data structure contains the results of code completion, as
5285	* produced by \c clang_codeCompleteAt(). Its contents must be freed by
5286	* \c clang_disposeCodeCompleteResults.
5287	*/
5288	typedef struct {
5289	/**
5290	* The code-completion results.
5291	*/
5292	CXCompletionResult *Results;
5293
5294	/**
5295	* The number of code-completion results stored in the
5296	* \c Results array.
5297	*/
5298	unsigned NumResults;
5299	} CXCodeCompleteResults;
5300
5301	/**
5302	* Retrieve the number of fix-its for the given completion index.
5303	*
5304	* Calling this makes sense only if CXCodeComplete_IncludeCompletionsWithFixIts
5305	* option was set.
5306	*
5307	* \param results The structure keeping all completion results
5308	*
5309	* \param completion_index The index of the completion
5310	*
5311	* \return The number of fix-its which must be applied before the completion at
5312	* completion_index can be applied
5313	*/
5314	CINDEX_LINKAGE unsigned
5315	clang_getCompletionNumFixIts(CXCodeCompleteResults *results,
5316	unsigned completion_index);
5317
5318	/**
5319	* Fix-its that must be applied before inserting the text for the
5320	* corresponding completion.
5321	*
5322	* By default, clang_codeCompleteAt() only returns completions with empty
5323	* fix-its. Extra completions with non-empty fix-its should be explicitly
5324	* requested by setting CXCodeComplete_IncludeCompletionsWithFixIts.
5325	*
5326	* For the clients to be able to compute position of the cursor after applying
5327	* fix-its, the following conditions are guaranteed to hold for
5328	* replacement_range of the stored fix-its:
5329	* - Ranges in the fix-its are guaranteed to never contain the completion
5330	* point (or identifier under completion point, if any) inside them, except
5331	* at the start or at the end of the range.
5332	* - If a fix-it range starts or ends with completion point (or starts or
5333	* ends after the identifier under completion point), it will contain at
5334	* least one character. It allows to unambiguously recompute completion
5335	* point after applying the fix-it.
5336	*
5337	* The intuition is that provided fix-its change code around the identifier we
5338	* complete, but are not allowed to touch the identifier itself or the
5339	* completion point. One example of completions with corrections are the ones
5340	* replacing '.' with '->' and vice versa:
5341	*
5342	* std::unique_ptr<std::vector<int>> vec_ptr;
5343	* In 'vec_ptr.^', one of the completions is 'push_back', it requires
5344	* replacing '.' with '->'.
5345	* In 'vec_ptr->^', one of the completions is 'release', it requires
5346	* replacing '->' with '.'.
5347	*
5348	* \param results The structure keeping all completion results
5349	*
5350	* \param completion_index The index of the completion
5351	*
5352	* \param fixit_index The index of the fix-it for the completion at
5353	* completion_index
5354	*
5355	* \param replacement_range The fix-it range that must be replaced before the
5356	* completion at completion_index can be applied
5357	*
5358	* \returns The fix-it string that must replace the code at replacement_range
5359	* before the completion at completion_index can be applied
5360	*/
5361	CINDEX_LINKAGE CXString clang_getCompletionFixIt(
5362	CXCodeCompleteResults results, unsigned* completion_index,
5363	unsigned fixit_index, CXSourceRange *replacement_range);
5364
5365	/**
5366	* Flags that can be passed to \c clang_codeCompleteAt() to
5367	* modify its behavior.
5368	*
5369	* The enumerators in this enumeration can be bitwise-OR'd together to
5370	* provide multiple options to \c clang_codeCompleteAt().
5371	*/
5372	enum CXCodeComplete_Flags {
5373	/**
5374	* Whether to include macros within the set of code
5375	* completions returned.
5376	*/
5377	CXCodeComplete_IncludeMacros = `0x01`,
5378
5379	/**
5380	* Whether to include code patterns for language constructs
5381	* within the set of code completions, e.g., for loops.
5382	*/
5383	CXCodeComplete_IncludeCodePatterns = `0x02`,
5384
5385	/**
5386	* Whether to include brief documentation within the set of code
5387	* completions returned.
5388	*/
5389	CXCodeComplete_IncludeBriefComments = `0x04`,
5390
5391	/**
5392	* Whether to speed up completion by omitting top- or namespace-level entities
5393	* defined in the preamble. There's no guarantee any particular entity is
5394	* omitted. This may be useful if the headers are indexed externally.
5395	*/
5396	CXCodeComplete_SkipPreamble = `0x08`,
5397
5398	/**
5399	* Whether to include completions with small
5400	* fix-its, e.g. change '.' to '->' on member access, etc.
5401	*/
5402	CXCodeComplete_IncludeCompletionsWithFixIts = `0x10`
5403	};
5404
5405	/**
5406	* Bits that represent the context under which completion is occurring.
5407	*
5408	* The enumerators in this enumeration may be bitwise-OR'd together if multiple
5409	* contexts are occurring simultaneously.
5410	*/
5411	enum CXCompletionContext {
5412	/**
5413	* The context for completions is unexposed, as only Clang results
5414	* should be included. (This is equivalent to having no context bits set.)
5415	*/
5416	CXCompletionContext_Unexposed = `0`,
5417
5418	/**
5419	* Completions for any possible type should be included in the results.
5420	*/
5421	CXCompletionContext_AnyType = `1` << `0`,
5422
5423	/**
5424	* Completions for any possible value (variables, function calls, etc.)
5425	* should be included in the results.
5426	*/
5427	CXCompletionContext_AnyValue = `1` << `1`,
5428	/**
5429	* Completions for values that resolve to an Objective-C object should
5430	* be included in the results.
5431	*/
5432	CXCompletionContext_ObjCObjectValue = `1` << `2`,
5433	/**
5434	* Completions for values that resolve to an Objective-C selector
5435	* should be included in the results.
5436	*/
5437	CXCompletionContext_ObjCSelectorValue = `1` << `3`,
5438	/**
5439	* Completions for values that resolve to a C++ class type should be
5440	* included in the results.
5441	*/
5442	CXCompletionContext_CXXClassTypeValue = `1` << `4`,
5443
5444	/**
5445	* Completions for fields of the member being accessed using the dot
5446	* operator should be included in the results.
5447	*/
5448	CXCompletionContext_DotMemberAccess = `1` << `5`,
5449	/**
5450	* Completions for fields of the member being accessed using the arrow
5451	* operator should be included in the results.
5452	*/
5453	CXCompletionContext_ArrowMemberAccess = `1` << `6`,
5454	/**
5455	* Completions for properties of the Objective-C object being accessed
5456	* using the dot operator should be included in the results.
5457	*/
5458	CXCompletionContext_ObjCPropertyAccess = `1` << `7`,
5459
5460	/**
5461	* Completions for enum tags should be included in the results.
5462	*/
5463	CXCompletionContext_EnumTag = `1` << `8`,
5464	/**
5465	* Completions for union tags should be included in the results.
5466	*/
5467	CXCompletionContext_UnionTag = `1` << `9`,
5468	/**
5469	* Completions for struct tags should be included in the results.
5470	*/
5471	CXCompletionContext_StructTag = `1` << `10`,
5472
5473	/**
5474	* Completions for C++ class names should be included in the results.
5475	*/
5476	CXCompletionContext_ClassTag = `1` << `11`,
5477	/**
5478	* Completions for C++ namespaces and namespace aliases should be
5479	* included in the results.
5480	*/
5481	CXCompletionContext_Namespace = `1` << `12`,
5482	/**
5483	* Completions for C++ nested name specifiers should be included in
5484	* the results.
5485	*/
5486	CXCompletionContext_NestedNameSpecifier = `1` << `13`,
5487
5488	/**
5489	* Completions for Objective-C interfaces (classes) should be included
5490	* in the results.
5491	*/
5492	CXCompletionContext_ObjCInterface = `1` << `14`,
5493	/**
5494	* Completions for Objective-C protocols should be included in
5495	* the results.
5496	*/
5497	CXCompletionContext_ObjCProtocol = `1` << `15`,
5498	/**
5499	* Completions for Objective-C categories should be included in
5500	* the results.
5501	*/
5502	CXCompletionContext_ObjCCategory = `1` << `16`,
5503	/**
5504	* Completions for Objective-C instance messages should be included
5505	* in the results.
5506	*/
5507	CXCompletionContext_ObjCInstanceMessage = `1` << `17`,
5508	/**
5509	* Completions for Objective-C class messages should be included in
5510	* the results.
5511	*/
5512	CXCompletionContext_ObjCClassMessage = `1` << `18`,
5513	/**
5514	* Completions for Objective-C selector names should be included in
5515	* the results.
5516	*/
5517	CXCompletionContext_ObjCSelectorName = `1` << `19`,
5518
5519	/**
5520	* Completions for preprocessor macro names should be included in
5521	* the results.
5522	*/
5523	CXCompletionContext_MacroName = `1` << `20`,
5524
5525	/**
5526	* Natural language completions should be included in the results.
5527	*/
5528	CXCompletionContext_NaturalLanguage = `1` << `21`,
5529
5530	/**
5531	* #include file completions should be included in the results.
5532	*/
5533	CXCompletionContext_IncludedFile = `1` << `22`,
5534
5535	/**
5536	* The current context is unknown, so set all contexts.
5537	*/
5538	CXCompletionContext_Unknown = ((`1` << `23`) - `1`)
5539	};
5540
5541	/**
5542	* Returns a default set of code-completion options that can be
5543	* passed to\c clang_codeCompleteAt().
5544	*/
5545	CINDEX_LINKAGE unsigned clang_defaultCodeCompleteOptions(void);
5546
5547	/**
5548	* Perform code completion at a given location in a translation unit.
5549	*
5550	* This function performs code completion at a particular file, line, and
5551	* column within source code, providing results that suggest potential
5552	* code snippets based on the context of the completion. The basic model
5553	* for code completion is that Clang will parse a complete source file,
5554	* performing syntax checking up to the location where code-completion has
5555	* been requested. At that point, a special code-completion token is passed
5556	* to the parser, which recognizes this token and determines, based on the
5557	* current location in the C/Objective-C/C++ grammar and the state of
5558	* semantic analysis, what completions to provide. These completions are
5559	* returned via a new \c CXCodeCompleteResults structure.
5560	*
5561	* Code completion itself is meant to be triggered by the client when the
5562	* user types punctuation characters or whitespace, at which point the
5563	* code-completion location will coincide with the cursor. For example, if \c p
5564	* is a pointer, code-completion might be triggered after the "-" and then
5565	* after the ">" in \c p->. When the code-completion location is after the ">",
5566	* the completion results will provide, e.g., the members of the struct that
5567	* "p" points to. The client is responsible for placing the cursor at the
5568	* beginning of the token currently being typed, then filtering the results
5569	* based on the contents of the token. For example, when code-completing for
5570	* the expression \c p->get, the client should provide the location just after
5571	* the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
5572	* client can filter the results based on the current token text ("get"), only
5573	* showing those results that start with "get". The intent of this interface
5574	* is to separate the relatively high-latency acquisition of code-completion
5575	* results from the filtering of results on a per-character basis, which must
5576	* have a lower latency.
5577	*
5578	* \param TU The translation unit in which code-completion should
5579	* occur. The source files for this translation unit need not be
5580	* completely up-to-date (and the contents of those source files may
5581	* be overridden via \p unsaved_files). Cursors referring into the
5582	* translation unit may be invalidated by this invocation.
5583	*
5584	* \param complete_filename The name of the source file where code
5585	* completion should be performed. This filename may be any file
5586	* included in the translation unit.
5587	*
5588	* \param complete_line The line at which code-completion should occur.
5589	*
5590	* \param complete_column The column at which code-completion should occur.
5591	* Note that the column should point just after the syntactic construct that
5592	* initiated code completion, and not in the middle of a lexical token.
5593	*
5594	* \param unsaved_files the Files that have not yet been saved to disk
5595	* but may be required for parsing or code completion, including the
5596	* contents of those files. The contents and name of these files (as
5597	* specified by CXUnsavedFile) are copied when necessary, so the
5598	* client only needs to guarantee their validity until the call to
5599	* this function returns.
5600	*
5601	* \param num_unsaved_files The number of unsaved file entries in \p
5602	* unsaved_files.
5603	*
5604	* \param options Extra options that control the behavior of code
5605	* completion, expressed as a bitwise OR of the enumerators of the
5606	* CXCodeComplete_Flags enumeration. The
5607	* \c clang_defaultCodeCompleteOptions() function returns a default set
5608	* of code-completion options.
5609	*
5610	* \returns If successful, a new \c CXCodeCompleteResults structure
5611	* containing code-completion results, which should eventually be
5612	* freed with \c clang_disposeCodeCompleteResults(). If code
5613	* completion fails, returns NULL.
5614	*/
5615	CINDEX_LINKAGE
5616	CXCodeCompleteResults *
5617	clang_codeCompleteAt(CXTranslationUnit TU, const char *complete_filename,
5618	unsigned complete_line, unsigned complete_column,
5619	struct CXUnsavedFile *unsaved_files,
5620	unsigned num_unsaved_files, unsigned options);
5621
5622	/**
5623	* Sort the code-completion results in case-insensitive alphabetical
5624	* order.
5625	*
5626	* \param Results The set of results to sort.
5627	* \param NumResults The number of results in \p Results.
5628	*/
5629	CINDEX_LINKAGE
5630	void clang_sortCodeCompletionResults(CXCompletionResult *Results,
5631	unsigned NumResults);
5632
5633	/**
5634	* Free the given set of code-completion results.
5635	*/
5636	CINDEX_LINKAGE
5637	void clang_disposeCodeCompleteResults(CXCodeCompleteResults *Results);
5638
5639	/**
5640	* Determine the number of diagnostics produced prior to the
5641	* location where code completion was performed.
5642	*/
5643	CINDEX_LINKAGE
5644	unsigned clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *Results);
5645
5646	/**
5647	* Retrieve a diagnostic associated with the given code completion.
5648	*
5649	* \param Results the code completion results to query.
5650	* \param Index the zero-based diagnostic number to retrieve.
5651	*
5652	* \returns the requested diagnostic. This diagnostic must be freed
5653	* via a call to \c clang_disposeDiagnostic().
5654	*/
5655	CINDEX_LINKAGE
5656	CXDiagnostic clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *Results,
5657	unsigned Index);
5658
5659	/**
5660	* Determines what completions are appropriate for the context
5661	* the given code completion.
5662	*
5663	* \param Results the code completion results to query
5664	*
5665	* \returns the kinds of completions that are appropriate for use
5666	* along with the given code completion results.
5667	*/
5668	CINDEX_LINKAGE
5669	unsigned long long
5670	clang_codeCompleteGetContexts(CXCodeCompleteResults *Results);
5671
5672	/**
5673	* Returns the cursor kind for the container for the current code
5674	* completion context. The container is only guaranteed to be set for
5675	* contexts where a container exists (i.e. member accesses or Objective-C
5676	* message sends); if there is not a container, this function will return
5677	* CXCursor_InvalidCode.
5678	*
5679	* \param Results the code completion results to query
5680	*
5681	* \param IsIncomplete on return, this value will be false if Clang has complete
5682	* information about the container. If Clang does not have complete
5683	* information, this value will be true.
5684	*
5685	* \returns the container kind, or CXCursor_InvalidCode if there is not a
5686	* container
5687	*/
5688	CINDEX_LINKAGE
5689	enum CXCursorKind
5690	clang_codeCompleteGetContainerKind(CXCodeCompleteResults *Results,
5691	unsigned *IsIncomplete);
5692
5693	/**
5694	* Returns the USR for the container for the current code completion
5695	* context. If there is not a container for the current context, this
5696	* function will return the empty string.
5697	*
5698	* \param Results the code completion results to query
5699	*
5700	* \returns the USR for the container
5701	*/
5702	CINDEX_LINKAGE
5703	CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *Results);
5704
5705	/**
5706	* Returns the currently-entered selector for an Objective-C message
5707	* send, formatted like "initWithFoo:bar:". Only guaranteed to return a
5708	* non-empty string for CXCompletionContext_ObjCInstanceMessage and
5709	* CXCompletionContext_ObjCClassMessage.
5710	*
5711	* \param Results the code completion results to query
5712	*
5713	* \returns the selector (or partial selector) that has been entered thus far
5714	* for an Objective-C message send.
5715	*/
5716	CINDEX_LINKAGE
5717	CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *Results);
5718
5719	/**
5720	* @}
5721	*/
5722
5723	/**
5724	* \defgroup CINDEX_MISC Miscellaneous utility functions
5725	*
5726	* @{
5727	*/
5728
5729	/**
5730	* Return a version string, suitable for showing to a user, but not
5731	* intended to be parsed (the format is not guaranteed to be stable).
5732	*/
5733	CINDEX_LINKAGE CXString clang_getClangVersion(void);
5734
5735	/**
5736	* Enable/disable crash recovery.
5737	*
5738	* \param isEnabled Flag to indicate if crash recovery is enabled. A non-zero
5739	* value enables crash recovery, while 0 disables it.
5740	*/
5741	CINDEX_LINKAGE void clang_toggleCrashRecovery(unsigned isEnabled);
5742
5743	/**
5744	* Visitor invoked for each file in a translation unit
5745	* (used with clang_getInclusions()).
5746	*
5747	* This visitor function will be invoked by clang_getInclusions() for each
5748	* file included (either at the top-level or by \#include directives) within
5749	* a translation unit. The first argument is the file being included, and
5750	* the second and third arguments provide the inclusion stack. The
5751	* array is sorted in order of immediate inclusion. For example,
5752	* the first element refers to the location that included 'included_file'.
5753	*/
5754	typedef void (*CXInclusionVisitor)(CXFile included_file,
5755	CXSourceLocation *inclusion_stack,
5756	unsigned include_len,
5757	CXClientData client_data);
5758
5759	/**
5760	* Visit the set of preprocessor inclusions in a translation unit.
5761	* The visitor function is called with the provided data for every included
5762	* file. This does not include headers included by the PCH file (unless one
5763	* is inspecting the inclusions in the PCH file itself).
5764	*/
5765	CINDEX_LINKAGE void clang_getInclusions(CXTranslationUnit tu,
5766	CXInclusionVisitor visitor,
5767	CXClientData client_data);
5768
5769	typedef enum {
5770	CXEval_Int = `1`,
5771	CXEval_Float = `2`,
5772	CXEval_ObjCStrLiteral = `3`,
5773	CXEval_StrLiteral = `4`,
5774	CXEval_CFStr = `5`,
5775	CXEval_Other = `6`,
5776
5777	CXEval_UnExposed = `0`
5778
5779	} CXEvalResultKind;
5780
5781	/**
5782	* Evaluation result of a cursor
5783	*/
5784	typedef void *CXEvalResult;
5785
5786	/**
5787	* If cursor is a statement declaration tries to evaluate the
5788	* statement and if its variable, tries to evaluate its initializer,
5789	* into its corresponding type.
5790	* If it's an expression, tries to evaluate the expression.
5791	*/
5792	CINDEX_LINKAGE CXEvalResult clang_Cursor_Evaluate(CXCursor C);
5793
5794	/**
5795	* Returns the kind of the evaluated result.
5796	*/
5797	CINDEX_LINKAGE CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E);
5798
5799	/**
5800	* Returns the evaluation result as integer if the
5801	* kind is Int.
5802	*/
5803	CINDEX_LINKAGE int clang_EvalResult_getAsInt(CXEvalResult E);
5804
5805	/**
5806	* Returns the evaluation result as a long long integer if the
5807	* kind is Int. This prevents overflows that may happen if the result is
5808	* returned with clang_EvalResult_getAsInt.
5809	*/
5810	CINDEX_LINKAGE long long clang_EvalResult_getAsLongLong(CXEvalResult E);
5811
5812	/**
5813	* Returns a non-zero value if the kind is Int and the evaluation
5814	* result resulted in an unsigned integer.
5815	*/
5816	CINDEX_LINKAGE unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E);
5817
5818	/**
5819	* Returns the evaluation result as an unsigned integer if
5820	* the kind is Int and clang_EvalResult_isUnsignedInt is non-zero.
5821	*/
5822	CINDEX_LINKAGE unsigned long long
5823	clang_EvalResult_getAsUnsigned(CXEvalResult E);
5824
5825	/**
5826	* Returns the evaluation result as double if the
5827	* kind is double.
5828	*/
5829	CINDEX_LINKAGE double clang_EvalResult_getAsDouble(CXEvalResult E);
5830
5831	/**
5832	* Returns the evaluation result as a constant string if the
5833	* kind is other than Int or float. User must not free this pointer,
5834	* instead call clang_EvalResult_dispose on the CXEvalResult returned
5835	* by clang_Cursor_Evaluate.
5836	*/
5837	CINDEX_LINKAGE const char *clang_EvalResult_getAsStr(CXEvalResult E);
5838
5839	/**
5840	* Disposes the created Eval memory.
5841	*/
5842	CINDEX_LINKAGE void clang_EvalResult_dispose(CXEvalResult E);
5843	/**
5844	* @}
5845	*/
5846
5847	/* \defgroup CINDEX_REMAPPING Remapping functions*
5848	*
5849	* @{
5850	*/
5851
5852	/**
5853	* A remapping of original source files and their translated files.
5854	*/
5855	typedef void *CXRemapping;
5856
5857	/**
5858	* Retrieve a remapping.
5859	*
5860	* \param path the path that contains metadata about remappings.
5861	*
5862	* \returns the requested remapping. This remapping must be freed
5863	* via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
5864	*/
5865	CINDEX_LINKAGE CXRemapping clang_getRemappings(const char *path);
5866
5867	/**
5868	* Retrieve a remapping.
5869	*
5870	* \param filePaths pointer to an array of file paths containing remapping info.
5871	*
5872	* \param numFiles number of file paths.
5873	*
5874	* \returns the requested remapping. This remapping must be freed
5875	* via a call to \c clang_remap_dispose(). Can return NULL if an error occurred.
5876	*/
5877	CINDEX_LINKAGE
5878	CXRemapping clang_getRemappingsFromFileList(const char **filePaths,
5879	unsigned numFiles);
5880
5881	/**
5882	* Determine the number of remappings.
5883	*/
5884	CINDEX_LINKAGE unsigned clang_remap_getNumFiles(CXRemapping);
5885
5886	/**
5887	* Get the original and the associated filename from the remapping.
5888	*
5889	* \param original If non-NULL, will be set to the original filename.
5890	*
5891	* \param transformed If non-NULL, will be set to the filename that the original
5892	* is associated with.
5893	*/
5894	CINDEX_LINKAGE void clang_remap_getFilenames(CXRemapping, unsigned index,
5895	CXString *original,
5896	CXString *transformed);
5897
5898	/**
5899	* Dispose the remapping.
5900	*/
5901	CINDEX_LINKAGE void clang_remap_dispose(CXRemapping);
5902
5903	/**
5904	* @}
5905	*/
5906
5907	/* \defgroup CINDEX_HIGH Higher level API functions*
5908	*
5909	* @{
5910	*/
5911
5912	enum CXVisitorResult { CXVisit_Break, CXVisit_Continue };
5913
5914	typedef struct CXCursorAndRangeVisitor {
5915	void *context;
5916	enum CXVisitorResult (visit)(void* *context, CXCursor, CXSourceRange);
5917	} CXCursorAndRangeVisitor;
5918
5919	typedef enum {
5920	/**
5921	* Function returned successfully.
5922	*/
5923	CXResult_Success = `0`,
5924	/**
5925	* One of the parameters was invalid for the function.
5926	*/
5927	CXResult_Invalid = `1`,
5928	/**
5929	* The function was terminated by a callback (e.g. it returned
5930	* CXVisit_Break)
5931	*/
5932	CXResult_VisitBreak = `2`
5933
5934	} CXResult;
5935
5936	/**
5937	* Find references of a declaration in a specific file.
5938	*
5939	* \param cursor pointing to a declaration or a reference of one.
5940	*
5941	* \param file to search for references.
5942	*
5943	* \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
5944	* each reference found.
5945	* The CXSourceRange will point inside the file; if the reference is inside
5946	* a macro (and not a macro argument) the CXSourceRange will be invalid.
5947	*
5948	* \returns one of the CXResult enumerators.
5949	*/
5950	CINDEX_LINKAGE CXResult clang_findReferencesInFile(
5951	CXCursor cursor, CXFile file, CXCursorAndRangeVisitor visitor);
5952
5953	/**
5954	* Find #import/#include directives in a specific file.
5955	*
5956	* \param TU translation unit containing the file to query.
5957	*
5958	* \param file to search for #import/#include directives.
5959	*
5960	* \param visitor callback that will receive pairs of CXCursor/CXSourceRange for
5961	* each directive found.
5962	*
5963	* \returns one of the CXResult enumerators.
5964	*/
5965	CINDEX_LINKAGE CXResult clang_findIncludesInFile(
5966	CXTranslationUnit TU, CXFile file, CXCursorAndRangeVisitor visitor);
5967
5968	#if __has_feature(blocks)
5969	typedef enum CXVisitorResult (^CXCursorAndRangeVisitorBlock)(CXCursor,
5970	CXSourceRange);
5971	#else
5972	typedef struct _CXCursorAndRangeVisitorBlock *CXCursorAndRangeVisitorBlock;
5973	#endif
5974
5975	CINDEX_LINKAGE
5976	CXResult clang_findReferencesInFileWithBlock(CXCursor, CXFile,
5977	CXCursorAndRangeVisitorBlock);
5978
5979	CINDEX_LINKAGE
5980	CXResult clang_findIncludesInFileWithBlock(CXTranslationUnit, CXFile,
5981	CXCursorAndRangeVisitorBlock);
5982
5983	/**
5984	* The client's data object that is associated with a CXFile.
5985	*/
5986	typedef void *CXIdxClientFile;
5987
5988	/**
5989	* The client's data object that is associated with a semantic entity.
5990	*/
5991	typedef void *CXIdxClientEntity;
5992
5993	/**
5994	* The client's data object that is associated with a semantic container
5995	* of entities.
5996	*/
5997	typedef void *CXIdxClientContainer;
5998
5999	/**
6000	* The client's data object that is associated with an AST file (PCH
6001	* or module).
6002	*/
6003	typedef void *CXIdxClientASTFile;
6004
6005	/**
6006	* Source location passed to index callbacks.
6007	*/
6008	typedef struct {
6009	void *ptr_data[`2`];
6010	unsigned int_data;
6011	} CXIdxLoc;
6012
6013	/**
6014	* Data for ppIncludedFile callback.
6015	*/
6016	typedef struct {
6017	/**
6018	* Location of '#' in the \#include/\#import directive.
6019	*/
6020	CXIdxLoc hashLoc;
6021	/**
6022	* Filename as written in the \#include/\#import directive.
6023	*/
6024	const char *filename;
6025	/**
6026	* The actual file that the \#include/\#import directive resolved to.
6027	*/
6028	CXFile file;
6029	int isImport;
6030	int isAngled;
6031	/**
6032	* Non-zero if the directive was automatically turned into a module
6033	* import.
6034	*/
6035	int isModuleImport;
6036	} CXIdxIncludedFileInfo;
6037
6038	/**
6039	* Data for IndexerCallbacks#importedASTFile.
6040	*/
6041	typedef struct {
6042	/**
6043	* Top level AST file containing the imported PCH, module or submodule.
6044	*/
6045	CXFile file;
6046	/**
6047	* The imported module or NULL if the AST file is a PCH.
6048	*/
6049	CXModule module;
6050	/**
6051	* Location where the file is imported. Applicable only for modules.
6052	*/
6053	CXIdxLoc loc;
6054	/**
6055	* Non-zero if an inclusion directive was automatically turned into
6056	* a module import. Applicable only for modules.
6057	*/
6058	int isImplicit;
6059
6060	} CXIdxImportedASTFileInfo;
6061
6062	typedef enum {
6063	CXIdxEntity_Unexposed = `0`,
6064	CXIdxEntity_Typedef = `1`,
6065	CXIdxEntity_Function = `2`,
6066	CXIdxEntity_Variable = `3`,
6067	CXIdxEntity_Field = `4`,
6068	CXIdxEntity_EnumConstant = `5`,
6069
6070	CXIdxEntity_ObjCClass = `6`,
6071	CXIdxEntity_ObjCProtocol = `7`,
6072	CXIdxEntity_ObjCCategory = `8`,
6073
6074	CXIdxEntity_ObjCInstanceMethod = `9`,
6075	CXIdxEntity_ObjCClassMethod = `10`,
6076	CXIdxEntity_ObjCProperty = `11`,
6077	CXIdxEntity_ObjCIvar = `12`,
6078
6079	CXIdxEntity_Enum = `13`,
6080	CXIdxEntity_Struct = `14`,
6081	CXIdxEntity_Union = `15`,
6082
6083	CXIdxEntity_CXXClass = `16`,
6084	CXIdxEntity_CXXNamespace = `17`,
6085	CXIdxEntity_CXXNamespaceAlias = `18`,
6086	CXIdxEntity_CXXStaticVariable = `19`,
6087	CXIdxEntity_CXXStaticMethod = `20`,
6088	CXIdxEntity_CXXInstanceMethod = `21`,
6089	CXIdxEntity_CXXConstructor = `22`,
6090	CXIdxEntity_CXXDestructor = `23`,
6091	CXIdxEntity_CXXConversionFunction = `24`,
6092	CXIdxEntity_CXXTypeAlias = `25`,
6093	CXIdxEntity_CXXInterface = `26`,
6094	CXIdxEntity_CXXConcept = `27`
6095
6096	} CXIdxEntityKind;
6097
6098	typedef enum {
6099	CXIdxEntityLang_None = `0`,
6100	CXIdxEntityLang_C = `1`,
6101	CXIdxEntityLang_ObjC = `2`,
6102	CXIdxEntityLang_CXX = `3`,
6103	CXIdxEntityLang_Swift = `4`
6104	} CXIdxEntityLanguage;
6105
6106	/**
6107	* Extra C++ template information for an entity. This can apply to:
6108	* CXIdxEntity_Function
6109	* CXIdxEntity_CXXClass
6110	* CXIdxEntity_CXXStaticMethod
6111	* CXIdxEntity_CXXInstanceMethod
6112	* CXIdxEntity_CXXConstructor
6113	* CXIdxEntity_CXXConversionFunction
6114	* CXIdxEntity_CXXTypeAlias
6115	*/
6116	typedef enum {
6117	CXIdxEntity_NonTemplate = `0`,
6118	CXIdxEntity_Template = `1`,
6119	CXIdxEntity_TemplatePartialSpecialization = `2`,
6120	CXIdxEntity_TemplateSpecialization = `3`
6121	} CXIdxEntityCXXTemplateKind;
6122
6123	typedef enum {
6124	CXIdxAttr_Unexposed = `0`,
6125	CXIdxAttr_IBAction = `1`,
6126	CXIdxAttr_IBOutlet = `2`,
6127	CXIdxAttr_IBOutletCollection = `3`
6128	} CXIdxAttrKind;
6129
6130	typedef struct {
6131	CXIdxAttrKind kind;
6132	CXCursor cursor;
6133	CXIdxLoc loc;
6134	} CXIdxAttrInfo;
6135
6136	typedef struct {
6137	CXIdxEntityKind kind;
6138	CXIdxEntityCXXTemplateKind templateKind;
6139	CXIdxEntityLanguage lang;
6140	const char *name;
6141	const char *USR;
6142	CXCursor cursor;
6143	const CXIdxAttrInfo *const *attributes;
6144	unsigned numAttributes;
6145	} CXIdxEntityInfo;
6146
6147	typedef struct {
6148	CXCursor cursor;
6149	} CXIdxContainerInfo;
6150
6151	typedef struct {
6152	const CXIdxAttrInfo *attrInfo;
6153	const CXIdxEntityInfo *objcClass;
6154	CXCursor classCursor;
6155	CXIdxLoc classLoc;
6156	} CXIdxIBOutletCollectionAttrInfo;
6157
6158	typedef enum { CXIdxDeclFlag_Skipped = `0x1` } CXIdxDeclInfoFlags;
6159
6160	typedef struct {
6161	const CXIdxEntityInfo *entityInfo;
6162	CXCursor cursor;
6163	CXIdxLoc loc;
6164	const CXIdxContainerInfo *semanticContainer;
6165	/**
6166	* Generally same as #semanticContainer but can be different in
6167	* cases like out-of-line C++ member functions.
6168	*/
6169	const CXIdxContainerInfo *lexicalContainer;
6170	int isRedeclaration;
6171	int isDefinition;
6172	int isContainer;
6173	const CXIdxContainerInfo *declAsContainer;
6174	/**
6175	* Whether the declaration exists in code or was created implicitly
6176	* by the compiler, e.g. implicit Objective-C methods for properties.
6177	*/
6178	int isImplicit;
6179	const CXIdxAttrInfo *const *attributes;
6180	unsigned numAttributes;
6181
6182	unsigned flags;
6183
6184	} CXIdxDeclInfo;
6185
6186	typedef enum {
6187	CXIdxObjCContainer_ForwardRef = `0`,
6188	CXIdxObjCContainer_Interface = `1`,
6189	CXIdxObjCContainer_Implementation = `2`
6190	} CXIdxObjCContainerKind;
6191
6192	typedef struct {
6193	const CXIdxDeclInfo *declInfo;
6194	CXIdxObjCContainerKind kind;
6195	} CXIdxObjCContainerDeclInfo;
6196
6197	typedef struct {
6198	const CXIdxEntityInfo *base;
6199	CXCursor cursor;
6200	CXIdxLoc loc;
6201	} CXIdxBaseClassInfo;
6202
6203	typedef struct {
6204	const CXIdxEntityInfo *protocol;
6205	CXCursor cursor;
6206	CXIdxLoc loc;
6207	} CXIdxObjCProtocolRefInfo;
6208
6209	typedef struct {
6210	const CXIdxObjCProtocolRefInfo *const *protocols;
6211	unsigned numProtocols;
6212	} CXIdxObjCProtocolRefListInfo;
6213
6214	typedef struct {
6215	const CXIdxObjCContainerDeclInfo *containerInfo;
6216	const CXIdxBaseClassInfo *superInfo;
6217	const CXIdxObjCProtocolRefListInfo *protocols;
6218	} CXIdxObjCInterfaceDeclInfo;
6219
6220	typedef struct {
6221	const CXIdxObjCContainerDeclInfo *containerInfo;
6222	const CXIdxEntityInfo *objcClass;
6223	CXCursor classCursor;
6224	CXIdxLoc classLoc;
6225	const CXIdxObjCProtocolRefListInfo *protocols;
6226	} CXIdxObjCCategoryDeclInfo;
6227
6228	typedef struct {
6229	const CXIdxDeclInfo *declInfo;
6230	const CXIdxEntityInfo *getter;
6231	const CXIdxEntityInfo *setter;
6232	} CXIdxObjCPropertyDeclInfo;
6233
6234	typedef struct {
6235	const CXIdxDeclInfo *declInfo;
6236	const CXIdxBaseClassInfo *const *bases;
6237	unsigned numBases;
6238	} CXIdxCXXClassDeclInfo;
6239
6240	/**
6241	* Data for IndexerCallbacks#indexEntityReference.
6242	*
6243	* This may be deprecated in a future version as this duplicates
6244	* the \c CXSymbolRole_Implicit bit in \c CXSymbolRole.
6245	*/
6246	typedef enum {
6247	/**
6248	* The entity is referenced directly in user's code.
6249	*/
6250	CXIdxEntityRef_Direct = `1`,
6251	/**
6252	* An implicit reference, e.g. a reference of an Objective-C method
6253	* via the dot syntax.
6254	*/
6255	CXIdxEntityRef_Implicit = `2`
6256	} CXIdxEntityRefKind;
6257
6258	/**
6259	* Roles that are attributed to symbol occurrences.
6260	*
6261	* Internal: this currently mirrors low 9 bits of clang::index::SymbolRole with
6262	* higher bits zeroed. These high bits may be exposed in the future.
6263	*/
6264	typedef enum {
6265	CXSymbolRole_None = `0`,
6266	CXSymbolRole_Declaration = `1` << `0`,
6267	CXSymbolRole_Definition = `1` << `1`,
6268	CXSymbolRole_Reference = `1` << `2`,
6269	CXSymbolRole_Read = `1` << `3`,
6270	CXSymbolRole_Write = `1` << `4`,
6271	CXSymbolRole_Call = `1` << `5`,
6272	CXSymbolRole_Dynamic = `1` << `6`,
6273	CXSymbolRole_AddressOf = `1` << `7`,
6274	CXSymbolRole_Implicit = `1` << `8`
6275	} CXSymbolRole;
6276
6277	/**
6278	* Data for IndexerCallbacks#indexEntityReference.
6279	*/
6280	typedef struct {
6281	CXIdxEntityRefKind kind;
6282	/**
6283	* Reference cursor.
6284	*/
6285	CXCursor cursor;
6286	CXIdxLoc loc;
6287	/**
6288	* The entity that gets referenced.
6289	*/
6290	const CXIdxEntityInfo *referencedEntity;
6291	/**
6292	* Immediate "parent" of the reference. For example:
6293	*
6294	* \code
6295	* Foo *var;
6296	* \endcode
6297	*
6298	* The parent of reference of type 'Foo' is the variable 'var'.
6299	* For references inside statement bodies of functions/methods,
6300	* the parentEntity will be the function/method.
6301	*/
6302	const CXIdxEntityInfo *parentEntity;
6303	/**
6304	* Lexical container context of the reference.
6305	*/
6306	const CXIdxContainerInfo *container;
6307	/**
6308	* Sets of symbol roles of the reference.
6309	*/
6310	CXSymbolRole role;
6311	} CXIdxEntityRefInfo;
6312
6313	/**
6314	* A group of callbacks used by #clang_indexSourceFile and
6315	* #clang_indexTranslationUnit.
6316	*/
6317	typedef struct {
6318	/**
6319	* Called periodically to check whether indexing should be aborted.
6320	* Should return 0 to continue, and non-zero to abort.
6321	*/
6322	int (abortQuery)(CXClientData client_data, void* *reserved);
6323
6324	/**
6325	* Called at the end of indexing; passes the complete diagnostic set.
6326	*/
6327	void (diagnostic)(CXClientData client_data, CXDiagnosticSet, void* *reserved);
6328
6329	CXIdxClientFile (*enteredMainFile)(CXClientData client_data, CXFile mainFile,
6330	void *reserved);
6331
6332	/**
6333	* Called when a file gets \#included/\#imported.
6334	*/
6335	CXIdxClientFile (*ppIncludedFile)(CXClientData client_data,
6336	const CXIdxIncludedFileInfo *);
6337
6338	/**
6339	* Called when a AST file (PCH or module) gets imported.
6340	*
6341	* AST files will not get indexed (there will not be callbacks to index all
6342	* the entities in an AST file). The recommended action is that, if the AST
6343	* file is not already indexed, to initiate a new indexing job specific to
6344	* the AST file.
6345	*/
6346	CXIdxClientASTFile (*importedASTFile)(CXClientData client_data,
6347	const CXIdxImportedASTFileInfo *);
6348
6349	/**
6350	* Called at the beginning of indexing a translation unit.
6351	*/
6352	CXIdxClientContainer (*startedTranslationUnit)(CXClientData client_data,
6353	void *reserved);
6354
6355	void (indexDeclaration)(CXClientData client_data, const* CXIdxDeclInfo *);
6356
6357	/**
6358	* Called to index a reference of an entity.
6359	*/
6360	void (*indexEntityReference)(CXClientData client_data,
6361	const CXIdxEntityRefInfo *);
6362
6363	} IndexerCallbacks;
6364
6365	CINDEX_LINKAGE int clang_index_isEntityObjCContainerKind(CXIdxEntityKind);
6366	CINDEX_LINKAGE const CXIdxObjCContainerDeclInfo *
6367	clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *);
6368
6369	CINDEX_LINKAGE const CXIdxObjCInterfaceDeclInfo *
6370	clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *);
6371
6372	CINDEX_LINKAGE
6373	const CXIdxObjCCategoryDeclInfo *
6374	clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *);
6375
6376	CINDEX_LINKAGE const CXIdxObjCProtocolRefListInfo *
6377	clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *);
6378
6379	CINDEX_LINKAGE const CXIdxObjCPropertyDeclInfo *
6380	clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *);
6381
6382	CINDEX_LINKAGE const CXIdxIBOutletCollectionAttrInfo *
6383	clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *);
6384
6385	CINDEX_LINKAGE const CXIdxCXXClassDeclInfo *
6386	clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *);
6387
6388	/**
6389	* For retrieving a custom CXIdxClientContainer attached to a
6390	* container.
6391	*/
6392	CINDEX_LINKAGE CXIdxClientContainer
6393	clang_index_getClientContainer(const CXIdxContainerInfo *);
6394
6395	/**
6396	* For setting a custom CXIdxClientContainer attached to a
6397	* container.
6398	*/
6399	CINDEX_LINKAGE void clang_index_setClientContainer(const CXIdxContainerInfo *,
6400	CXIdxClientContainer);
6401
6402	/**
6403	* For retrieving a custom CXIdxClientEntity attached to an entity.
6404	*/
6405	CINDEX_LINKAGE CXIdxClientEntity
6406	clang_index_getClientEntity(const CXIdxEntityInfo *);
6407
6408	/**
6409	* For setting a custom CXIdxClientEntity attached to an entity.
6410	*/
6411	CINDEX_LINKAGE void clang_index_setClientEntity(const CXIdxEntityInfo *,
6412	CXIdxClientEntity);
6413
6414	/**
6415	* An indexing action/session, to be applied to one or multiple
6416	* translation units.
6417	*/
6418	typedef void *CXIndexAction;
6419
6420	/**
6421	* An indexing action/session, to be applied to one or multiple
6422	* translation units.
6423	*
6424	* \param CIdx The index object with which the index action will be associated.
6425	*/
6426	CINDEX_LINKAGE CXIndexAction clang_IndexAction_create(CXIndex CIdx);
6427
6428	/**
6429	* Destroy the given index action.
6430	*
6431	* The index action must not be destroyed until all of the translation units
6432	* created within that index action have been destroyed.
6433	*/
6434	CINDEX_LINKAGE void clang_IndexAction_dispose(CXIndexAction);
6435
6436	typedef enum {
6437	/**
6438	* Used to indicate that no special indexing options are needed.
6439	*/
6440	CXIndexOpt_None = `0x0`,
6441
6442	/**
6443	* Used to indicate that IndexerCallbacks#indexEntityReference should
6444	* be invoked for only one reference of an entity per source file that does
6445	* not also include a declaration/definition of the entity.
6446	*/
6447	CXIndexOpt_SuppressRedundantRefs = `0x1`,
6448
6449	/**
6450	* Function-local symbols should be indexed. If this is not set
6451	* function-local symbols will be ignored.
6452	*/
6453	CXIndexOpt_IndexFunctionLocalSymbols = `0x2`,
6454
6455	/**
6456	* Implicit function/class template instantiations should be indexed.
6457	* If this is not set, implicit instantiations will be ignored.
6458	*/
6459	CXIndexOpt_IndexImplicitTemplateInstantiations = `0x4`,
6460
6461	/**
6462	* Suppress all compiler warnings when parsing for indexing.
6463	*/
6464	CXIndexOpt_SuppressWarnings = `0x8`,
6465
6466	/**
6467	* Skip a function/method body that was already parsed during an
6468	* indexing session associated with a \c CXIndexAction object.
6469	* Bodies in system headers are always skipped.
6470	*/
6471	CXIndexOpt_SkipParsedBodiesInSession = `0x10`
6472
6473	} CXIndexOptFlags;
6474
6475	/**
6476	* Index the given source file and the translation unit corresponding
6477	* to that file via callbacks implemented through #IndexerCallbacks.
6478	*
6479	* \param client_data pointer data supplied by the client, which will
6480	* be passed to the invoked callbacks.
6481	*
6482	* \param index_callbacks Pointer to indexing callbacks that the client
6483	* implements.
6484	*
6485	* \param index_callbacks_size Size of #IndexerCallbacks structure that gets
6486	* passed in index_callbacks.
6487	*
6488	* \param index_options A bitmask of options that affects how indexing is
6489	* performed. This should be a bitwise OR of the CXIndexOpt_XXX flags.
6490	*
6491	* \param[out] out_TU pointer to store a \c CXTranslationUnit that can be
6492	* reused after indexing is finished. Set to \c NULL if you do not require it.
6493	*
6494	* \returns 0 on success or if there were errors from which the compiler could
6495	* recover. If there is a failure from which there is no recovery, returns
6496	* a non-zero \c CXErrorCode.
6497	*
6498	* The rest of the parameters are the same as #clang_parseTranslationUnit.
6499	*/
6500	CINDEX_LINKAGE int clang_indexSourceFile(
6501	CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks,
6502	unsigned index_callbacks_size, unsigned index_options,
6503	const char source_filename, const* char *const *command_line_args,
6504	int num_command_line_args, struct CXUnsavedFile *unsaved_files,
6505	unsigned num_unsaved_files, CXTranslationUnit out_TU, unsigned* TU_options);
6506
6507	/**
6508	* Same as clang_indexSourceFile but requires a full command line
6509	* for \c command_line_args including argv[0]. This is useful if the standard
6510	* library paths are relative to the binary.
6511	*/
6512	CINDEX_LINKAGE int clang_indexSourceFileFullArgv(
6513	CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks,
6514	unsigned index_callbacks_size, unsigned index_options,
6515	const char source_filename, const* char *const *command_line_args,
6516	int num_command_line_args, struct CXUnsavedFile *unsaved_files,
6517	unsigned num_unsaved_files, CXTranslationUnit out_TU, unsigned* TU_options);
6518
6519	/**
6520	* Index the given translation unit via callbacks implemented through
6521	* #IndexerCallbacks.
6522	*
6523	* The order of callback invocations is not guaranteed to be the same as
6524	* when indexing a source file. The high level order will be:
6525	*
6526	* -Preprocessor callbacks invocations
6527	* -Declaration/reference callbacks invocations
6528	* -Diagnostic callback invocations
6529	*
6530	* The parameters are the same as #clang_indexSourceFile.
6531	*
6532	* \returns If there is a failure from which there is no recovery, returns
6533	* non-zero, otherwise returns 0.
6534	*/
6535	CINDEX_LINKAGE int clang_indexTranslationUnit(
6536	CXIndexAction, CXClientData client_data, IndexerCallbacks *index_callbacks,
6537	unsigned index_callbacks_size, unsigned index_options, CXTranslationUnit);
6538
6539	/**
6540	* Retrieve the CXIdxFile, file, line, column, and offset represented by
6541	* the given CXIdxLoc.
6542	*
6543	* If the location refers into a macro expansion, retrieves the
6544	* location of the macro expansion and if it refers into a macro argument
6545	* retrieves the location of the argument.
6546	*/
6547	CINDEX_LINKAGE void clang_indexLoc_getFileLocation(CXIdxLoc loc,
6548	CXIdxClientFile *indexFile,
6549	CXFile file, unsigned* *line,
6550	unsigned *column,
6551	unsigned *offset);
6552
6553	/**
6554	* Retrieve the CXSourceLocation represented by the given CXIdxLoc.
6555	*/
6556	CINDEX_LINKAGE
6557	CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc loc);
6558
6559	/**
6560	* Visitor invoked for each field found by a traversal.
6561	*
6562	* This visitor function will be invoked for each field found by
6563	* \c clang_Type_visitFields. Its first argument is the cursor being
6564	* visited, its second argument is the client data provided to
6565	* \c clang_Type_visitFields.
6566	*
6567	* The visitor should return one of the \c CXVisitorResult values
6568	* to direct \c clang_Type_visitFields.
6569	*/
6570	typedef enum CXVisitorResult (*CXFieldVisitor)(CXCursor C,
6571	CXClientData client_data);
6572
6573	/**
6574	* Visit the fields of a particular type.
6575	*
6576	* This function visits all the direct fields of the given cursor,
6577	* invoking the given \p visitor function with the cursors of each
6578	* visited field. The traversal may be ended prematurely, if
6579	* the visitor returns \c CXFieldVisit_Break.
6580	*
6581	* \param T the record type whose field may be visited.
6582	*
6583	* \param visitor the visitor function that will be invoked for each
6584	* field of \p T.
6585	*
6586	* \param client_data pointer data supplied by the client, which will
6587	* be passed to the visitor each time it is invoked.
6588	*
6589	* \returns a non-zero value if the traversal was terminated
6590	* prematurely by the visitor returning \c CXFieldVisit_Break.
6591	*/
6592	CINDEX_LINKAGE unsigned clang_Type_visitFields(CXType T, CXFieldVisitor visitor,
6593	CXClientData client_data);
6594
6595	/**
6596	* Describes the kind of binary operators.
6597	*/
6598	enum CXBinaryOperatorKind {
6599	/* This value describes cursors which are not binary operators. /
6600	CXBinaryOperator_Invalid,
6601	/* C++ Pointer - to - member operator. /
6602	CXBinaryOperator_PtrMemD,
6603	/* C++ Pointer - to - member operator. /
6604	CXBinaryOperator_PtrMemI,
6605	/* Multiplication operator. /
6606	CXBinaryOperator_Mul,
6607	/* Division operator. /
6608	CXBinaryOperator_Div,
6609	/* Remainder operator. /
6610	CXBinaryOperator_Rem,
6611	/* Addition operator. /
6612	CXBinaryOperator_Add,
6613	/* Subtraction operator. /
6614	CXBinaryOperator_Sub,
6615	/* Bitwise shift left operator. /
6616	CXBinaryOperator_Shl,
6617	/* Bitwise shift right operator. /
6618	CXBinaryOperator_Shr,
6619	/* C++ three-way comparison (spaceship) operator. /
6620	CXBinaryOperator_Cmp,
6621	/* Less than operator. /
6622	CXBinaryOperator_LT,
6623	/* Greater than operator. /
6624	CXBinaryOperator_GT,
6625	/* Less or equal operator. /
6626	CXBinaryOperator_LE,
6627	/* Greater or equal operator. /
6628	CXBinaryOperator_GE,
6629	/* Equal operator. /
6630	CXBinaryOperator_EQ,
6631	/* Not equal operator. /
6632	CXBinaryOperator_NE,
6633	/* Bitwise AND operator. /
6634	CXBinaryOperator_And,
6635	/* Bitwise XOR operator. /
6636	CXBinaryOperator_Xor,
6637	/* Bitwise OR operator. /
6638	CXBinaryOperator_Or,
6639	/* Logical AND operator. /
6640	CXBinaryOperator_LAnd,
6641	/* Logical OR operator. /
6642	CXBinaryOperator_LOr,
6643	/* Assignment operator. /
6644	CXBinaryOperator_Assign,
6645	/* Multiplication assignment operator. /
6646	CXBinaryOperator_MulAssign,
6647	/* Division assignment operator. /
6648	CXBinaryOperator_DivAssign,
6649	/* Remainder assignment operator. /
6650	CXBinaryOperator_RemAssign,
6651	/* Addition assignment operator. /
6652	CXBinaryOperator_AddAssign,
6653	/* Subtraction assignment operator. /
6654	CXBinaryOperator_SubAssign,
6655	/* Bitwise shift left assignment operator. /
6656	CXBinaryOperator_ShlAssign,
6657	/* Bitwise shift right assignment operator. /
6658	CXBinaryOperator_ShrAssign,
6659	/* Bitwise AND assignment operator. /
6660	CXBinaryOperator_AndAssign,
6661	/* Bitwise XOR assignment operator. /
6662	CXBinaryOperator_XorAssign,
6663	/* Bitwise OR assignment operator. /
6664	CXBinaryOperator_OrAssign,
6665	/* Comma operator. /
6666	CXBinaryOperator_Comma
6667	};
6668
6669	/**
6670	* Retrieve the spelling of a given CXBinaryOperatorKind.
6671	*/
6672	CINDEX_LINKAGE CXString
6673	clang_getBinaryOperatorKindSpelling(enum CXBinaryOperatorKind kind);
6674
6675	/**
6676	* Retrieve the binary operator kind of this cursor.
6677	*
6678	* If this cursor is not a binary operator then returns Invalid.
6679	*/
6680	CINDEX_LINKAGE enum CXBinaryOperatorKind
6681	clang_getCursorBinaryOperatorKind(CXCursor cursor);
6682
6683	/**
6684	* Describes the kind of unary operators.
6685	*/
6686	enum CXUnaryOperatorKind {
6687	/* This value describes cursors which are not unary operators. /
6688	CXUnaryOperator_Invalid,
6689	/* Postfix increment operator. /
6690	CXUnaryOperator_PostInc,
6691	/* Postfix decrement operator. /
6692	CXUnaryOperator_PostDec,
6693	/* Prefix increment operator. /
6694	CXUnaryOperator_PreInc,
6695	/* Prefix decrement operator. /
6696	CXUnaryOperator_PreDec,
6697	/* Address of operator. /
6698	CXUnaryOperator_AddrOf,
6699	/* Dereference operator. /
6700	CXUnaryOperator_Deref,
6701	/* Plus operator. /
6702	CXUnaryOperator_Plus,
6703	/* Minus operator. /
6704	CXUnaryOperator_Minus,
6705	/* Not operator. /
6706	CXUnaryOperator_Not,
6707	/* LNot operator. /
6708	CXUnaryOperator_LNot,
6709	/* "__real expr" operator. /
6710	CXUnaryOperator_Real,
6711	/* "__imag expr" operator. /
6712	CXUnaryOperator_Imag,
6713	/* __extension__ marker operator. /
6714	CXUnaryOperator_Extension,
6715	/* C++ co_await operator. /
6716	CXUnaryOperator_Coawait
6717	};
6718
6719	/**
6720	* Retrieve the spelling of a given CXUnaryOperatorKind.
6721	*/
6722	CINDEX_LINKAGE CXString
6723	clang_getUnaryOperatorKindSpelling(enum CXUnaryOperatorKind kind);
6724
6725	/**
6726	* Retrieve the unary operator kind of this cursor.
6727	*
6728	* If this cursor is not a unary operator then returns Invalid.
6729	*/
6730	CINDEX_LINKAGE enum CXUnaryOperatorKind
6731	clang_getCursorUnaryOperatorKind(CXCursor cursor);
6732
6733	/**
6734	* @}
6735	*/
6736
6737	/**
6738	* @}
6739	*/
6740
6741	LLVM_CLANG_C_EXTERN_C_END
6742
6743	#endif
6744

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