1 | /* c-index-test.c */ |
---|---|
2 | |
3 | #include "clang-c/BuildSystem.h" |
4 | #include "clang-c/CXCompilationDatabase.h" |
5 | #include "clang-c/CXDiagnostic.h" |
6 | #include "clang-c/CXErrorCode.h" |
7 | #include "clang-c/CXFile.h" |
8 | #include "clang-c/CXSourceLocation.h" |
9 | #include "clang-c/CXString.h" |
10 | #include "clang-c/Documentation.h" |
11 | #include "clang-c/Index.h" |
12 | #include "clang/Config/config.h" |
13 | #include "llvm/Support/AutoConvert.h" |
14 | #include <assert.h> |
15 | #include <ctype.h> |
16 | #include <stdio.h> |
17 | #include <stdlib.h> |
18 | #include <string.h> |
19 | |
20 | #ifdef CLANG_HAVE_LIBXML |
21 | #include <libxml/parser.h> |
22 | #include <libxml/relaxng.h> |
23 | #include <libxml/xmlerror.h> |
24 | #endif |
25 | |
26 | #ifdef _WIN32 |
27 | # include <direct.h> |
28 | #else |
29 | # include <unistd.h> |
30 | #endif |
31 | |
32 | extern int indextest_core_main(int argc, const char **argv); |
33 | extern int indextest_perform_shell_execution(const char *command_line); |
34 | |
35 | /******************************************************************************/ |
36 | /* Utility functions. */ |
37 | /******************************************************************************/ |
38 | |
39 | #ifdef _MSC_VER |
40 | char *basename(const char* path) |
41 | { |
42 | char* base1 = (char*)strrchr(path, '/'); |
43 | char* base2 = (char*)strrchr(path, '\\'); |
44 | if (base1 && base2) |
45 | return((base1 > base2) ? base1 + 1 : base2 + 1); |
46 | else if (base1) |
47 | return(base1 + 1); |
48 | else if (base2) |
49 | return(base2 + 1); |
50 | |
51 | #ifdef __clang__ |
52 | #pragma clang diagnostic push |
53 | #pragma clang diagnostic ignored "-Wcast-qual" |
54 | #endif |
55 | return ((char *)path); |
56 | #ifdef __clang__ |
57 | #pragma clang diagnostic pop |
58 | #endif |
59 | } |
60 | char *dirname(char* path) |
61 | { |
62 | char* base1 = (char*)strrchr(path, '/'); |
63 | char* base2 = (char*)strrchr(path, '\\'); |
64 | if (base1 && base2) |
65 | if (base1 > base2) |
66 | *base1 = 0; |
67 | else |
68 | *base2 = 0; |
69 | else if (base1) |
70 | *base1 = 0; |
71 | else if (base2) |
72 | *base2 = 0; |
73 | |
74 | return path; |
75 | } |
76 | #else |
77 | extern char *basename(const char *); |
78 | extern char *dirname(char *); |
79 | #endif |
80 | |
81 | CXIndex createIndexWithInvocationEmissionPath(int ExcludeDeclarationsFromPCH, |
82 | int DisplayDiagnostics) { |
83 | CXIndex Idx; |
84 | |
85 | CXIndexOptions Opts; |
86 | memset(s: &Opts, c: 0, n: sizeof(Opts)); |
87 | Opts.Size = sizeof(CXIndexOptions); |
88 | Opts.ExcludeDeclarationsFromPCH = ExcludeDeclarationsFromPCH; |
89 | Opts.DisplayDiagnostics = DisplayDiagnostics; |
90 | Opts.InvocationEmissionPath = getenv(name: "CINDEXTEST_INVOCATION_EMISSION_PATH"); |
91 | |
92 | Idx = clang_createIndexWithOptions(options: &Opts); |
93 | if (!Idx) { |
94 | fprintf(stderr, |
95 | format: "clang_createIndexWithOptions() failed. " |
96 | "CINDEX_VERSION_MINOR = %d, sizeof(CXIndexOptions) = %u\n", |
97 | CINDEX_VERSION_MINOR, Opts.Size); |
98 | } |
99 | return Idx; |
100 | } |
101 | |
102 | /** Return the default parsing options. */ |
103 | static unsigned getDefaultParsingOptions(void) { |
104 | unsigned options = CXTranslationUnit_DetailedPreprocessingRecord; |
105 | |
106 | if (getenv(name: "CINDEXTEST_EDITING")) |
107 | options |= clang_defaultEditingTranslationUnitOptions(); |
108 | if (getenv(name: "CINDEXTEST_COMPLETION_CACHING")) |
109 | options |= CXTranslationUnit_CacheCompletionResults; |
110 | if (getenv(name: "CINDEXTEST_COMPLETION_NO_CACHING")) |
111 | options &= ~CXTranslationUnit_CacheCompletionResults; |
112 | if (getenv(name: "CINDEXTEST_SKIP_FUNCTION_BODIES")) |
113 | options |= CXTranslationUnit_SkipFunctionBodies; |
114 | if (getenv(name: "CINDEXTEST_COMPLETION_BRIEF_COMMENTS")) |
115 | options |= CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; |
116 | if (getenv(name: "CINDEXTEST_CREATE_PREAMBLE_ON_FIRST_PARSE")) |
117 | options |= CXTranslationUnit_CreatePreambleOnFirstParse; |
118 | if (getenv(name: "CINDEXTEST_KEEP_GOING")) |
119 | options |= CXTranslationUnit_KeepGoing; |
120 | if (getenv(name: "CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_PREAMBLE")) |
121 | options |= CXTranslationUnit_LimitSkipFunctionBodiesToPreamble; |
122 | if (getenv(name: "CINDEXTEST_INCLUDE_ATTRIBUTED_TYPES")) |
123 | options |= CXTranslationUnit_IncludeAttributedTypes; |
124 | if (getenv(name: "CINDEXTEST_VISIT_IMPLICIT_ATTRIBUTES")) |
125 | options |= CXTranslationUnit_VisitImplicitAttributes; |
126 | if (getenv(name: "CINDEXTEST_IGNORE_NONERRORS_FROM_INCLUDED_FILES")) |
127 | options |= CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles; |
128 | |
129 | return options; |
130 | } |
131 | |
132 | static void ModifyPrintingPolicyAccordingToEnv(CXPrintingPolicy Policy) { |
133 | struct Mapping { |
134 | const char *name; |
135 | enum CXPrintingPolicyProperty property; |
136 | }; |
137 | struct Mapping mappings[] = { |
138 | {"CINDEXTEST_PRINTINGPOLICY_INDENTATION", CXPrintingPolicy_Indentation}, |
139 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSSPECIFIERS", |
140 | CXPrintingPolicy_SuppressSpecifiers}, |
141 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSTAGKEYWORD", |
142 | CXPrintingPolicy_SuppressTagKeyword}, |
143 | {"CINDEXTEST_PRINTINGPOLICY_INCLUDETAGDEFINITION", |
144 | CXPrintingPolicy_IncludeTagDefinition}, |
145 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSSCOPE", |
146 | CXPrintingPolicy_SuppressScope}, |
147 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSUNWRITTENSCOPE", |
148 | CXPrintingPolicy_SuppressUnwrittenScope}, |
149 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSINITIALIZERS", |
150 | CXPrintingPolicy_SuppressInitializers}, |
151 | {"CINDEXTEST_PRINTINGPOLICY_CONSTANTARRAYSIZEASWRITTEN", |
152 | CXPrintingPolicy_ConstantArraySizeAsWritten}, |
153 | {"CINDEXTEST_PRINTINGPOLICY_ANONYMOUSTAGLOCATIONS", |
154 | CXPrintingPolicy_AnonymousTagLocations}, |
155 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSSTRONGLIFETIME", |
156 | CXPrintingPolicy_SuppressStrongLifetime}, |
157 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSLIFETIMEQUALIFIERS", |
158 | CXPrintingPolicy_SuppressLifetimeQualifiers}, |
159 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSTEMPLATEARGSINCXXCONSTRUCTORS", |
160 | CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors}, |
161 | {"CINDEXTEST_PRINTINGPOLICY_BOOL", CXPrintingPolicy_Bool}, |
162 | {"CINDEXTEST_PRINTINGPOLICY_RESTRICT", CXPrintingPolicy_Restrict}, |
163 | {"CINDEXTEST_PRINTINGPOLICY_ALIGNOF", CXPrintingPolicy_Alignof}, |
164 | {"CINDEXTEST_PRINTINGPOLICY_UNDERSCOREALIGNOF", |
165 | CXPrintingPolicy_UnderscoreAlignof}, |
166 | {"CINDEXTEST_PRINTINGPOLICY_USEVOIDFORZEROPARAMS", |
167 | CXPrintingPolicy_UseVoidForZeroParams}, |
168 | {"CINDEXTEST_PRINTINGPOLICY_TERSEOUTPUT", CXPrintingPolicy_TerseOutput}, |
169 | {"CINDEXTEST_PRINTINGPOLICY_POLISHFORDECLARATION", |
170 | CXPrintingPolicy_PolishForDeclaration}, |
171 | {"CINDEXTEST_PRINTINGPOLICY_HALF", CXPrintingPolicy_Half}, |
172 | {"CINDEXTEST_PRINTINGPOLICY_MSWCHAR", CXPrintingPolicy_MSWChar}, |
173 | {"CINDEXTEST_PRINTINGPOLICY_INCLUDENEWLINES", |
174 | CXPrintingPolicy_IncludeNewlines}, |
175 | {"CINDEXTEST_PRINTINGPOLICY_MSVCFORMATTING", |
176 | CXPrintingPolicy_MSVCFormatting}, |
177 | {"CINDEXTEST_PRINTINGPOLICY_CONSTANTSASWRITTEN", |
178 | CXPrintingPolicy_ConstantsAsWritten}, |
179 | {"CINDEXTEST_PRINTINGPOLICY_SUPPRESSIMPLICITBASE", |
180 | CXPrintingPolicy_SuppressImplicitBase}, |
181 | {"CINDEXTEST_PRINTINGPOLICY_FULLYQUALIFIEDNAME", |
182 | CXPrintingPolicy_FullyQualifiedName}, |
183 | }; |
184 | |
185 | unsigned i; |
186 | for (i = 0; i < sizeof(mappings) / sizeof(struct Mapping); i++) { |
187 | char *value = getenv(name: mappings[i].name); |
188 | if (value) { |
189 | clang_PrintingPolicy_setProperty(Policy, Property: mappings[i].property, |
190 | Value: (unsigned)strtoul(nptr: value, endptr: 0L, base: 10)); |
191 | } |
192 | } |
193 | } |
194 | |
195 | /** Returns 0 in case of success, non-zero in case of a failure. */ |
196 | static int checkForErrors(CXTranslationUnit TU); |
197 | |
198 | static void describeLibclangFailure(enum CXErrorCode Err) { |
199 | switch (Err) { |
200 | case CXError_Success: |
201 | fprintf(stderr, format: "Success\n"); |
202 | return; |
203 | |
204 | case CXError_Failure: |
205 | fprintf(stderr, format: "Failure (no details available)\n"); |
206 | return; |
207 | |
208 | case CXError_Crashed: |
209 | fprintf(stderr, format: "Failure: libclang crashed\n"); |
210 | return; |
211 | |
212 | case CXError_InvalidArguments: |
213 | fprintf(stderr, format: "Failure: invalid arguments passed to a libclang routine\n"); |
214 | return; |
215 | |
216 | case CXError_ASTReadError: |
217 | fprintf(stderr, format: "Failure: AST deserialization error occurred\n"); |
218 | return; |
219 | } |
220 | } |
221 | |
222 | static void PrintExtent(FILE *out, unsigned begin_line, unsigned begin_column, |
223 | unsigned end_line, unsigned end_column) { |
224 | fprintf(stream: out, format: "[%d:%d - %d:%d]", begin_line, begin_column, |
225 | end_line, end_column); |
226 | } |
227 | |
228 | static unsigned CreateTranslationUnit(CXIndex Idx, const char *file, |
229 | CXTranslationUnit *TU) { |
230 | enum CXErrorCode Err = clang_createTranslationUnit2(CIdx: Idx, ast_filename: file, out_TU: TU); |
231 | if (Err != CXError_Success) { |
232 | fprintf(stderr, format: "Unable to load translation unit from '%s'!\n", file); |
233 | describeLibclangFailure(Err); |
234 | *TU = 0; |
235 | return 0; |
236 | } |
237 | return 1; |
238 | } |
239 | |
240 | void free_remapped_files(struct CXUnsavedFile *unsaved_files, |
241 | int num_unsaved_files) { |
242 | int i; |
243 | for (i = 0; i != num_unsaved_files; ++i) { |
244 | #ifdef __GNUC__ |
245 | #pragma GCC diagnostic push |
246 | #pragma GCC diagnostic ignored "-Wcast-qual" |
247 | #elif defined(__clang__) |
248 | #pragma clang diagnostic push |
249 | #pragma clang diagnostic ignored "-Wcast-qual" |
250 | #endif |
251 | free(ptr: (char *)unsaved_files[i].Filename); |
252 | free(ptr: (char *)unsaved_files[i].Contents); |
253 | #ifdef __GNUC__ |
254 | #pragma GCC diagnostic pop |
255 | #elif defined(__clang__) |
256 | #pragma clang diagnostic pop |
257 | #endif |
258 | } |
259 | free(ptr: unsaved_files); |
260 | } |
261 | |
262 | static int parse_remapped_files_with_opt(const char *opt_name, |
263 | int argc, const char **argv, |
264 | int start_arg, |
265 | struct CXUnsavedFile **unsaved_files, |
266 | int *num_unsaved_files) { |
267 | int i; |
268 | int arg; |
269 | int prefix_len = strlen(s: opt_name); |
270 | int arg_indices[20]; |
271 | *unsaved_files = 0; |
272 | *num_unsaved_files = 0; |
273 | |
274 | /* Count the number of remapped files. */ |
275 | for (arg = start_arg; arg < argc; ++arg) { |
276 | if (strncmp(s1: argv[arg], s2: opt_name, n: prefix_len)) |
277 | continue; |
278 | |
279 | assert(*num_unsaved_files < (int)(sizeof(arg_indices)/sizeof(int))); |
280 | arg_indices[*num_unsaved_files] = arg; |
281 | ++*num_unsaved_files; |
282 | } |
283 | |
284 | if (*num_unsaved_files == 0) |
285 | return 0; |
286 | |
287 | *unsaved_files |
288 | = (struct CXUnsavedFile *)malloc(size: sizeof(struct CXUnsavedFile) * |
289 | *num_unsaved_files); |
290 | assert(*unsaved_files); |
291 | for (i = 0; i != *num_unsaved_files; ++i) { |
292 | struct CXUnsavedFile *unsaved = *unsaved_files + i; |
293 | const char *arg_string = argv[arg_indices[i]] + prefix_len; |
294 | int filename_len; |
295 | char *filename; |
296 | char *contents; |
297 | FILE *to_file; |
298 | const char *sep = strchr(s: arg_string, c: ','); |
299 | if (!sep) { |
300 | fprintf(stderr, |
301 | format: "error: %sfrom:to argument is missing comma\n", opt_name); |
302 | free_remapped_files(unsaved_files: *unsaved_files, num_unsaved_files: i); |
303 | *unsaved_files = 0; |
304 | *num_unsaved_files = 0; |
305 | return -1; |
306 | } |
307 | |
308 | /* Open the file that we're remapping to. */ |
309 | to_file = fopen(filename: sep + 1, modes: "rb"); |
310 | if (!to_file) { |
311 | fprintf(stderr, format: "error: cannot open file %s that we are remapping to\n", |
312 | sep + 1); |
313 | free_remapped_files(unsaved_files: *unsaved_files, num_unsaved_files: i); |
314 | *unsaved_files = 0; |
315 | *num_unsaved_files = 0; |
316 | return -1; |
317 | } |
318 | |
319 | /* Determine the length of the file we're remapping to. */ |
320 | fseek(stream: to_file, off: 0, SEEK_END); |
321 | unsaved->Length = ftell(stream: to_file); |
322 | fseek(stream: to_file, off: 0, SEEK_SET); |
323 | |
324 | /* Read the contents of the file we're remapping to. */ |
325 | contents = (char *)malloc(size: unsaved->Length + 1); |
326 | assert(contents); |
327 | if (fread(ptr: contents, size: 1, n: unsaved->Length, stream: to_file) != unsaved->Length) { |
328 | fprintf(stderr, format: "error: unexpected %s reading 'to' file %s\n", |
329 | (feof(stream: to_file) ? "EOF": "error"), sep + 1); |
330 | fclose(stream: to_file); |
331 | free_remapped_files(unsaved_files: *unsaved_files, num_unsaved_files: i); |
332 | free(ptr: contents); |
333 | *unsaved_files = 0; |
334 | *num_unsaved_files = 0; |
335 | return -1; |
336 | } |
337 | contents[unsaved->Length] = 0; |
338 | unsaved->Contents = contents; |
339 | |
340 | /* Close the file. */ |
341 | fclose(stream: to_file); |
342 | |
343 | /* Copy the file name that we're remapping from. */ |
344 | filename_len = sep - arg_string; |
345 | filename = (char *)malloc(size: filename_len + 1); |
346 | assert(filename); |
347 | memcpy(dest: filename, src: arg_string, n: filename_len); |
348 | filename[filename_len] = 0; |
349 | unsaved->Filename = filename; |
350 | } |
351 | |
352 | return 0; |
353 | } |
354 | |
355 | static int parse_remapped_files(int argc, const char **argv, int start_arg, |
356 | struct CXUnsavedFile **unsaved_files, |
357 | int *num_unsaved_files) { |
358 | return parse_remapped_files_with_opt(opt_name: "-remap-file=", argc, argv, start_arg, |
359 | unsaved_files, num_unsaved_files); |
360 | } |
361 | |
362 | static int parse_remapped_files_with_try(int try_idx, |
363 | int argc, const char **argv, |
364 | int start_arg, |
365 | struct CXUnsavedFile **unsaved_files, |
366 | int *num_unsaved_files) { |
367 | struct CXUnsavedFile *unsaved_files_no_try_idx; |
368 | int num_unsaved_files_no_try_idx; |
369 | struct CXUnsavedFile *unsaved_files_try_idx; |
370 | int num_unsaved_files_try_idx; |
371 | int ret; |
372 | char opt_name[32]; |
373 | |
374 | ret = parse_remapped_files(argc, argv, start_arg, |
375 | unsaved_files: &unsaved_files_no_try_idx, num_unsaved_files: &num_unsaved_files_no_try_idx); |
376 | if (ret) |
377 | return ret; |
378 | |
379 | snprintf(s: opt_name, maxlen: sizeof(opt_name), format: "-remap-file-%d=", try_idx); |
380 | ret = parse_remapped_files_with_opt(opt_name, argc, argv, start_arg, |
381 | unsaved_files: &unsaved_files_try_idx, num_unsaved_files: &num_unsaved_files_try_idx); |
382 | if (ret) |
383 | return ret; |
384 | |
385 | if (num_unsaved_files_no_try_idx == 0) { |
386 | *unsaved_files = unsaved_files_try_idx; |
387 | *num_unsaved_files = num_unsaved_files_try_idx; |
388 | return 0; |
389 | } |
390 | if (num_unsaved_files_try_idx == 0) { |
391 | *unsaved_files = unsaved_files_no_try_idx; |
392 | *num_unsaved_files = num_unsaved_files_no_try_idx; |
393 | return 0; |
394 | } |
395 | |
396 | *num_unsaved_files = num_unsaved_files_no_try_idx + num_unsaved_files_try_idx; |
397 | *unsaved_files |
398 | = (struct CXUnsavedFile *)realloc(ptr: unsaved_files_no_try_idx, |
399 | size: sizeof(struct CXUnsavedFile) * |
400 | *num_unsaved_files); |
401 | assert(*unsaved_files); |
402 | memcpy(dest: *unsaved_files + num_unsaved_files_no_try_idx, |
403 | src: unsaved_files_try_idx, n: sizeof(struct CXUnsavedFile) * |
404 | num_unsaved_files_try_idx); |
405 | free(ptr: unsaved_files_try_idx); |
406 | return 0; |
407 | } |
408 | |
409 | static const char *parse_comments_schema(int argc, const char **argv) { |
410 | const char *CommentsSchemaArg = "-comments-xml-schema="; |
411 | const char *CommentSchemaFile = NULL; |
412 | |
413 | if (argc == 0) |
414 | return CommentSchemaFile; |
415 | |
416 | if (!strncmp(s1: argv[0], s2: CommentsSchemaArg, n: strlen(s: CommentsSchemaArg))) |
417 | CommentSchemaFile = argv[0] + strlen(s: CommentsSchemaArg); |
418 | |
419 | return CommentSchemaFile; |
420 | } |
421 | |
422 | /******************************************************************************/ |
423 | /* Pretty-printing. */ |
424 | /******************************************************************************/ |
425 | |
426 | static const char *FileCheckPrefix = "CHECK"; |
427 | |
428 | static void PrintCString(const char *CStr) { |
429 | if (CStr != NULL && CStr[0] != '\0') { |
430 | for ( ; *CStr; ++CStr) { |
431 | const char C = *CStr; |
432 | switch (C) { |
433 | case '\n': printf(format: "\\n"); break; |
434 | case '\r': printf(format: "\\r"); break; |
435 | case '\t': printf(format: "\\t"); break; |
436 | case '\v': printf(format: "\\v"); break; |
437 | case '\f': printf(format: "\\f"); break; |
438 | default: putchar(c: C); break; |
439 | } |
440 | } |
441 | } |
442 | } |
443 | |
444 | static void PrintCStringWithPrefix(const char *Prefix, const char *CStr) { |
445 | printf(format: " %s=[", Prefix); |
446 | PrintCString(CStr); |
447 | printf(format: "]"); |
448 | } |
449 | |
450 | static void PrintCXStringAndDispose(CXString Str) { |
451 | PrintCString(CStr: clang_getCString(string: Str)); |
452 | clang_disposeString(string: Str); |
453 | } |
454 | |
455 | static void PrintCXStringWithPrefix(const char *Prefix, CXString Str) { |
456 | PrintCStringWithPrefix(Prefix, CStr: clang_getCString(string: Str)); |
457 | } |
458 | |
459 | static void PrintCXStringWithPrefixAndDispose(const char *Prefix, |
460 | CXString Str) { |
461 | PrintCStringWithPrefix(Prefix, CStr: clang_getCString(string: Str)); |
462 | clang_disposeString(string: Str); |
463 | } |
464 | |
465 | static void PrintRange(CXSourceRange R, const char *str) { |
466 | CXFile begin_file, end_file; |
467 | unsigned begin_line, begin_column, end_line, end_column; |
468 | |
469 | clang_getFileLocation(location: clang_getRangeStart(range: R), file: &begin_file, line: &begin_line, |
470 | column: &begin_column, offset: 0); |
471 | clang_getFileLocation(location: clang_getRangeEnd(range: R), file: &end_file, line: &end_line, column: &end_column, |
472 | offset: 0); |
473 | if (!begin_file || !end_file) |
474 | return; |
475 | |
476 | if (str) |
477 | printf(format: " %s=", str); |
478 | PrintExtent(stdout, begin_line, begin_column, end_line, end_column); |
479 | } |
480 | |
481 | static enum DisplayType { |
482 | DisplayType_Spelling, |
483 | DisplayType_DisplayName, |
484 | DisplayType_Pretty |
485 | } wanted_display_type = DisplayType_Spelling; |
486 | |
487 | static void printVersion(const char *Prefix, CXVersion Version) { |
488 | if (Version.Major < 0) |
489 | return; |
490 | printf(format: "%s%d", Prefix, Version.Major); |
491 | |
492 | if (Version.Minor < 0) |
493 | return; |
494 | printf(format: ".%d", Version.Minor); |
495 | |
496 | if (Version.Subminor < 0) |
497 | return; |
498 | printf(format: ".%d", Version.Subminor); |
499 | } |
500 | |
501 | struct CommentASTDumpingContext { |
502 | int IndentLevel; |
503 | }; |
504 | |
505 | static void DumpCXCommentInternal(struct CommentASTDumpingContext *Ctx, |
506 | CXComment Comment) { |
507 | unsigned i; |
508 | unsigned e; |
509 | enum CXCommentKind Kind = clang_Comment_getKind(Comment); |
510 | |
511 | Ctx->IndentLevel++; |
512 | for (i = 0, e = Ctx->IndentLevel; i != e; ++i) |
513 | printf(format: " "); |
514 | |
515 | printf(format: "("); |
516 | switch (Kind) { |
517 | case CXComment_Null: |
518 | printf(format: "CXComment_Null"); |
519 | break; |
520 | case CXComment_Text: |
521 | printf(format: "CXComment_Text"); |
522 | PrintCXStringWithPrefixAndDispose(Prefix: "Text", |
523 | Str: clang_TextComment_getText(Comment)); |
524 | if (clang_Comment_isWhitespace(Comment)) |
525 | printf(format: " IsWhitespace"); |
526 | if (clang_InlineContentComment_hasTrailingNewline(Comment)) |
527 | printf(format: " HasTrailingNewline"); |
528 | break; |
529 | case CXComment_InlineCommand: |
530 | printf(format: "CXComment_InlineCommand"); |
531 | PrintCXStringWithPrefixAndDispose( |
532 | Prefix: "CommandName", |
533 | Str: clang_InlineCommandComment_getCommandName(Comment)); |
534 | switch (clang_InlineCommandComment_getRenderKind(Comment)) { |
535 | case CXCommentInlineCommandRenderKind_Normal: |
536 | printf(format: " RenderNormal"); |
537 | break; |
538 | case CXCommentInlineCommandRenderKind_Bold: |
539 | printf(format: " RenderBold"); |
540 | break; |
541 | case CXCommentInlineCommandRenderKind_Monospaced: |
542 | printf(format: " RenderMonospaced"); |
543 | break; |
544 | case CXCommentInlineCommandRenderKind_Emphasized: |
545 | printf(format: " RenderEmphasized"); |
546 | break; |
547 | case CXCommentInlineCommandRenderKind_Anchor: |
548 | printf(format: " RenderAnchor"); |
549 | break; |
550 | } |
551 | for (i = 0, e = clang_InlineCommandComment_getNumArgs(Comment); |
552 | i != e; ++i) { |
553 | printf(format: " Arg[%u]=", i); |
554 | PrintCXStringAndDispose( |
555 | Str: clang_InlineCommandComment_getArgText(Comment, ArgIdx: i)); |
556 | } |
557 | if (clang_InlineContentComment_hasTrailingNewline(Comment)) |
558 | printf(format: " HasTrailingNewline"); |
559 | break; |
560 | case CXComment_HTMLStartTag: { |
561 | unsigned NumAttrs; |
562 | printf(format: "CXComment_HTMLStartTag"); |
563 | PrintCXStringWithPrefixAndDispose( |
564 | Prefix: "Name", |
565 | Str: clang_HTMLTagComment_getTagName(Comment)); |
566 | NumAttrs = clang_HTMLStartTag_getNumAttrs(Comment); |
567 | if (NumAttrs != 0) { |
568 | printf(format: " Attrs:"); |
569 | for (i = 0; i != NumAttrs; ++i) { |
570 | printf(format: " "); |
571 | PrintCXStringAndDispose(Str: clang_HTMLStartTag_getAttrName(Comment, AttrIdx: i)); |
572 | printf(format: "="); |
573 | PrintCXStringAndDispose(Str: clang_HTMLStartTag_getAttrValue(Comment, AttrIdx: i)); |
574 | } |
575 | } |
576 | if (clang_HTMLStartTagComment_isSelfClosing(Comment)) |
577 | printf(format: " SelfClosing"); |
578 | if (clang_InlineContentComment_hasTrailingNewline(Comment)) |
579 | printf(format: " HasTrailingNewline"); |
580 | break; |
581 | } |
582 | case CXComment_HTMLEndTag: |
583 | printf(format: "CXComment_HTMLEndTag"); |
584 | PrintCXStringWithPrefixAndDispose( |
585 | Prefix: "Name", |
586 | Str: clang_HTMLTagComment_getTagName(Comment)); |
587 | if (clang_InlineContentComment_hasTrailingNewline(Comment)) |
588 | printf(format: " HasTrailingNewline"); |
589 | break; |
590 | case CXComment_Paragraph: |
591 | printf(format: "CXComment_Paragraph"); |
592 | if (clang_Comment_isWhitespace(Comment)) |
593 | printf(format: " IsWhitespace"); |
594 | break; |
595 | case CXComment_BlockCommand: |
596 | printf(format: "CXComment_BlockCommand"); |
597 | PrintCXStringWithPrefixAndDispose( |
598 | Prefix: "CommandName", |
599 | Str: clang_BlockCommandComment_getCommandName(Comment)); |
600 | for (i = 0, e = clang_BlockCommandComment_getNumArgs(Comment); |
601 | i != e; ++i) { |
602 | printf(format: " Arg[%u]=", i); |
603 | PrintCXStringAndDispose( |
604 | Str: clang_BlockCommandComment_getArgText(Comment, ArgIdx: i)); |
605 | } |
606 | break; |
607 | case CXComment_ParamCommand: |
608 | printf(format: "CXComment_ParamCommand"); |
609 | switch (clang_ParamCommandComment_getDirection(Comment)) { |
610 | case CXCommentParamPassDirection_In: |
611 | printf(format: " in"); |
612 | break; |
613 | case CXCommentParamPassDirection_Out: |
614 | printf(format: " out"); |
615 | break; |
616 | case CXCommentParamPassDirection_InOut: |
617 | printf(format: " in,out"); |
618 | break; |
619 | } |
620 | if (clang_ParamCommandComment_isDirectionExplicit(Comment)) |
621 | printf(format: " explicitly"); |
622 | else |
623 | printf(format: " implicitly"); |
624 | PrintCXStringWithPrefixAndDispose( |
625 | Prefix: "ParamName", |
626 | Str: clang_ParamCommandComment_getParamName(Comment)); |
627 | if (clang_ParamCommandComment_isParamIndexValid(Comment)) |
628 | printf(format: " ParamIndex=%u", clang_ParamCommandComment_getParamIndex(Comment)); |
629 | else |
630 | printf(format: " ParamIndex=Invalid"); |
631 | break; |
632 | case CXComment_TParamCommand: |
633 | printf(format: "CXComment_TParamCommand"); |
634 | PrintCXStringWithPrefixAndDispose( |
635 | Prefix: "ParamName", |
636 | Str: clang_TParamCommandComment_getParamName(Comment)); |
637 | if (clang_TParamCommandComment_isParamPositionValid(Comment)) { |
638 | printf(format: " ParamPosition={"); |
639 | for (i = 0, e = clang_TParamCommandComment_getDepth(Comment); |
640 | i != e; ++i) { |
641 | printf(format: "%u", clang_TParamCommandComment_getIndex(Comment, Depth: i)); |
642 | if (i != e - 1) |
643 | printf(format: ", "); |
644 | } |
645 | printf(format: "}"); |
646 | } else |
647 | printf(format: " ParamPosition=Invalid"); |
648 | break; |
649 | case CXComment_VerbatimBlockCommand: |
650 | printf(format: "CXComment_VerbatimBlockCommand"); |
651 | PrintCXStringWithPrefixAndDispose( |
652 | Prefix: "CommandName", |
653 | Str: clang_BlockCommandComment_getCommandName(Comment)); |
654 | break; |
655 | case CXComment_VerbatimBlockLine: |
656 | printf(format: "CXComment_VerbatimBlockLine"); |
657 | PrintCXStringWithPrefixAndDispose( |
658 | Prefix: "Text", |
659 | Str: clang_VerbatimBlockLineComment_getText(Comment)); |
660 | break; |
661 | case CXComment_VerbatimLine: |
662 | printf(format: "CXComment_VerbatimLine"); |
663 | PrintCXStringWithPrefixAndDispose( |
664 | Prefix: "Text", |
665 | Str: clang_VerbatimLineComment_getText(Comment)); |
666 | break; |
667 | case CXComment_FullComment: |
668 | printf(format: "CXComment_FullComment"); |
669 | break; |
670 | } |
671 | if (Kind != CXComment_Null) { |
672 | const unsigned NumChildren = clang_Comment_getNumChildren(Comment); |
673 | unsigned i; |
674 | for (i = 0; i != NumChildren; ++i) { |
675 | printf(format: "\n// %s: ", FileCheckPrefix); |
676 | DumpCXCommentInternal(Ctx, Comment: clang_Comment_getChild(Comment, ChildIdx: i)); |
677 | } |
678 | } |
679 | printf(format: ")"); |
680 | Ctx->IndentLevel--; |
681 | } |
682 | |
683 | static void DumpCXComment(CXComment Comment) { |
684 | struct CommentASTDumpingContext Ctx; |
685 | Ctx.IndentLevel = 1; |
686 | printf(format: "\n// %s: CommentAST=[\n// %s:", FileCheckPrefix, FileCheckPrefix); |
687 | DumpCXCommentInternal(Ctx: &Ctx, Comment); |
688 | printf(format: "]"); |
689 | } |
690 | |
691 | static void ValidateCommentXML(const char *Str, const char *CommentSchemaFile) { |
692 | #ifdef CLANG_HAVE_LIBXML |
693 | xmlRelaxNGParserCtxtPtr RNGParser; |
694 | xmlRelaxNGPtr Schema; |
695 | xmlDocPtr Doc; |
696 | xmlRelaxNGValidCtxtPtr ValidationCtxt; |
697 | int status; |
698 | |
699 | if (!CommentSchemaFile) |
700 | return; |
701 | |
702 | RNGParser = xmlRelaxNGNewParserCtxt(URL: CommentSchemaFile); |
703 | if (!RNGParser) { |
704 | printf(format: " libXMLError"); |
705 | return; |
706 | } |
707 | Schema = xmlRelaxNGParse(ctxt: RNGParser); |
708 | |
709 | Doc = xmlParseDoc(cur: (const xmlChar *) Str); |
710 | |
711 | if (!Doc) { |
712 | const xmlError *Error = xmlGetLastError(); |
713 | printf(format: " CommentXMLInvalid [not well-formed XML: %s]", Error->message); |
714 | return; |
715 | } |
716 | |
717 | ValidationCtxt = xmlRelaxNGNewValidCtxt(schema: Schema); |
718 | status = xmlRelaxNGValidateDoc(ctxt: ValidationCtxt, doc: Doc); |
719 | if (!status) |
720 | printf(format: " CommentXMLValid"); |
721 | else if (status > 0) { |
722 | const xmlError *Error = xmlGetLastError(); |
723 | printf(format: " CommentXMLInvalid [not valid XML: %s]", Error->message); |
724 | } else |
725 | printf(format: " libXMLError"); |
726 | |
727 | xmlRelaxNGFreeValidCtxt(ctxt: ValidationCtxt); |
728 | xmlFreeDoc(cur: Doc); |
729 | xmlRelaxNGFree(schema: Schema); |
730 | xmlRelaxNGFreeParserCtxt(ctxt: RNGParser); |
731 | #endif |
732 | } |
733 | |
734 | static void PrintCursorComments(CXCursor Cursor, |
735 | const char *CommentSchemaFile) { |
736 | { |
737 | CXString RawComment; |
738 | const char *RawCommentCString; |
739 | CXString BriefComment; |
740 | const char *BriefCommentCString; |
741 | |
742 | RawComment = clang_Cursor_getRawCommentText(C: Cursor); |
743 | RawCommentCString = clang_getCString(string: RawComment); |
744 | if (RawCommentCString != NULL && RawCommentCString[0] != '\0') { |
745 | PrintCStringWithPrefix(Prefix: "RawComment", CStr: RawCommentCString); |
746 | PrintRange(R: clang_Cursor_getCommentRange(C: Cursor), str: "RawCommentRange"); |
747 | |
748 | BriefComment = clang_Cursor_getBriefCommentText(C: Cursor); |
749 | BriefCommentCString = clang_getCString(string: BriefComment); |
750 | if (BriefCommentCString != NULL && BriefCommentCString[0] != '\0') |
751 | PrintCStringWithPrefix(Prefix: "BriefComment", CStr: BriefCommentCString); |
752 | clang_disposeString(string: BriefComment); |
753 | } |
754 | clang_disposeString(string: RawComment); |
755 | } |
756 | |
757 | { |
758 | CXComment Comment = clang_Cursor_getParsedComment(C: Cursor); |
759 | if (clang_Comment_getKind(Comment) != CXComment_Null) { |
760 | PrintCXStringWithPrefixAndDispose(Prefix: "FullCommentAsHTML", |
761 | Str: clang_FullComment_getAsHTML(Comment)); |
762 | { |
763 | CXString XML; |
764 | XML = clang_FullComment_getAsXML(Comment); |
765 | PrintCXStringWithPrefix(Prefix: "FullCommentAsXML", Str: XML); |
766 | ValidateCommentXML(Str: clang_getCString(string: XML), CommentSchemaFile); |
767 | clang_disposeString(string: XML); |
768 | } |
769 | |
770 | DumpCXComment(Comment); |
771 | } |
772 | } |
773 | } |
774 | |
775 | typedef struct { |
776 | unsigned line; |
777 | unsigned col; |
778 | } LineCol; |
779 | |
780 | static int lineCol_cmp(const void *p1, const void *p2) { |
781 | const LineCol *lhs = p1; |
782 | const LineCol *rhs = p2; |
783 | if (lhs->line != rhs->line) |
784 | return (int)lhs->line - (int)rhs->line; |
785 | return (int)lhs->col - (int)rhs->col; |
786 | } |
787 | |
788 | static CXString CursorToText(CXCursor Cursor) { |
789 | CXString text; |
790 | switch (wanted_display_type) { |
791 | case DisplayType_Spelling: |
792 | return clang_getCursorSpelling(Cursor); |
793 | case DisplayType_DisplayName: |
794 | return clang_getCursorDisplayName(Cursor); |
795 | case DisplayType_Pretty: { |
796 | CXPrintingPolicy Policy = clang_getCursorPrintingPolicy(Cursor); |
797 | ModifyPrintingPolicyAccordingToEnv(Policy); |
798 | text = clang_getCursorPrettyPrinted(Cursor, Policy); |
799 | clang_PrintingPolicy_dispose(Policy); |
800 | return text; |
801 | } |
802 | } |
803 | assert(0 && "unknown display type"); /* no llvm_unreachable in C. */ |
804 | /* Set to NULL to prevent uninitialized variable warnings. */ |
805 | text.data = NULL; |
806 | text.private_flags = 0; |
807 | return text; |
808 | } |
809 | |
810 | static void PrintCursor(CXCursor Cursor, const char *CommentSchemaFile) { |
811 | CXTranslationUnit TU = clang_Cursor_getTranslationUnit(Cursor); |
812 | if (clang_isInvalid(Cursor.kind)) { |
813 | CXString ks = clang_getCursorKindSpelling(Kind: Cursor.kind); |
814 | printf(format: "Invalid Cursor => %s", clang_getCString(string: ks)); |
815 | clang_disposeString(string: ks); |
816 | } |
817 | else { |
818 | CXString string, ks; |
819 | CXCursor Referenced; |
820 | unsigned line, column; |
821 | CXCursor SpecializationOf; |
822 | CXCursor *overridden; |
823 | unsigned num_overridden; |
824 | unsigned RefNameRangeNr; |
825 | CXSourceRange CursorExtent; |
826 | CXSourceRange RefNameRange; |
827 | int AlwaysUnavailable; |
828 | int AlwaysDeprecated; |
829 | CXString UnavailableMessage; |
830 | CXString DeprecatedMessage; |
831 | CXPlatformAvailability PlatformAvailability[2]; |
832 | int NumPlatformAvailability; |
833 | int I; |
834 | |
835 | ks = clang_getCursorKindSpelling(Kind: Cursor.kind); |
836 | string = CursorToText(Cursor); |
837 | printf(format: "%s=%s", clang_getCString(string: ks), |
838 | clang_getCString(string)); |
839 | clang_disposeString(string: ks); |
840 | clang_disposeString(string); |
841 | |
842 | Referenced = clang_getCursorReferenced(Cursor); |
843 | if (!clang_equalCursors(Referenced, clang_getNullCursor())) { |
844 | if (clang_getCursorKind(Referenced) == CXCursor_OverloadedDeclRef) { |
845 | unsigned I, N = clang_getNumOverloadedDecls(cursor: Referenced); |
846 | printf(format: "["); |
847 | for (I = 0; I != N; ++I) { |
848 | CXCursor Ovl = clang_getOverloadedDecl(cursor: Referenced, index: I); |
849 | CXSourceLocation Loc; |
850 | if (I) |
851 | printf(format: ", "); |
852 | |
853 | Loc = clang_getCursorLocation(Ovl); |
854 | clang_getFileLocation(location: Loc, file: 0, line: &line, column: &column, offset: 0); |
855 | printf(format: "%d:%d", line, column); |
856 | } |
857 | printf(format: "]"); |
858 | } else { |
859 | CXSourceLocation Loc = clang_getCursorLocation(Referenced); |
860 | clang_getFileLocation(location: Loc, file: 0, line: &line, column: &column, offset: 0); |
861 | printf(format: ":%d:%d", line, column); |
862 | } |
863 | |
864 | if (clang_getCursorKind(Referenced) == CXCursor_TypedefDecl) { |
865 | CXType T = clang_getCursorType(C: Referenced); |
866 | if (clang_Type_isTransparentTagTypedef(T)) { |
867 | CXType Underlying = clang_getTypedefDeclUnderlyingType(C: Referenced); |
868 | CXString S = clang_getTypeSpelling(CT: Underlying); |
869 | printf(format: " (Transparent: %s)", clang_getCString(string: S)); |
870 | clang_disposeString(string: S); |
871 | } |
872 | } |
873 | } |
874 | |
875 | if (clang_isCursorDefinition(Cursor)) |
876 | printf(format: " (Definition)"); |
877 | |
878 | switch (clang_getCursorAvailability(cursor: Cursor)) { |
879 | case CXAvailability_Available: |
880 | break; |
881 | |
882 | case CXAvailability_Deprecated: |
883 | printf(format: " (deprecated)"); |
884 | break; |
885 | |
886 | case CXAvailability_NotAvailable: |
887 | printf(format: " (unavailable)"); |
888 | break; |
889 | |
890 | case CXAvailability_NotAccessible: |
891 | printf(format: " (inaccessible)"); |
892 | break; |
893 | } |
894 | |
895 | NumPlatformAvailability |
896 | = clang_getCursorPlatformAvailability(cursor: Cursor, |
897 | always_deprecated: &AlwaysDeprecated, |
898 | deprecated_message: &DeprecatedMessage, |
899 | always_unavailable: &AlwaysUnavailable, |
900 | unavailable_message: &UnavailableMessage, |
901 | availability: PlatformAvailability, availability_size: 2); |
902 | if (AlwaysUnavailable) { |
903 | printf(format: " (always unavailable: \"%s\")", |
904 | clang_getCString(string: UnavailableMessage)); |
905 | } else if (AlwaysDeprecated) { |
906 | printf(format: " (always deprecated: \"%s\")", |
907 | clang_getCString(string: DeprecatedMessage)); |
908 | } else { |
909 | for (I = 0; I != NumPlatformAvailability; ++I) { |
910 | if (I >= 2) |
911 | break; |
912 | |
913 | printf(format: " (%s", clang_getCString(string: PlatformAvailability[I].Platform)); |
914 | if (PlatformAvailability[I].Unavailable) |
915 | printf(format: ", unavailable"); |
916 | else { |
917 | printVersion(Prefix: ", introduced=", Version: PlatformAvailability[I].Introduced); |
918 | printVersion(Prefix: ", deprecated=", Version: PlatformAvailability[I].Deprecated); |
919 | printVersion(Prefix: ", obsoleted=", Version: PlatformAvailability[I].Obsoleted); |
920 | } |
921 | if (clang_getCString(string: PlatformAvailability[I].Message)[0]) |
922 | printf(format: ", message=\"%s\"", |
923 | clang_getCString(string: PlatformAvailability[I].Message)); |
924 | printf(format: ")"); |
925 | } |
926 | } |
927 | for (I = 0; I != NumPlatformAvailability; ++I) { |
928 | if (I >= 2) |
929 | break; |
930 | clang_disposeCXPlatformAvailability(availability: PlatformAvailability + I); |
931 | } |
932 | |
933 | clang_disposeString(string: DeprecatedMessage); |
934 | clang_disposeString(string: UnavailableMessage); |
935 | |
936 | if (clang_CXXConstructor_isDefaultConstructor(C: Cursor)) |
937 | printf(format: " (default constructor)"); |
938 | |
939 | if (clang_CXXConstructor_isMoveConstructor(C: Cursor)) |
940 | printf(format: " (move constructor)"); |
941 | if (clang_CXXConstructor_isCopyConstructor(C: Cursor)) |
942 | printf(format: " (copy constructor)"); |
943 | if (clang_CXXConstructor_isConvertingConstructor(C: Cursor)) |
944 | printf(format: " (converting constructor)"); |
945 | if (clang_CXXField_isMutable(C: Cursor)) |
946 | printf(format: " (mutable)"); |
947 | if (clang_CXXMethod_isDefaulted(C: Cursor)) |
948 | printf(format: " (defaulted)"); |
949 | if (clang_CXXMethod_isDeleted(C: Cursor)) |
950 | printf(format: " (deleted)"); |
951 | if (clang_CXXMethod_isStatic(C: Cursor)) |
952 | printf(format: " (static)"); |
953 | if (clang_CXXMethod_isVirtual(C: Cursor)) |
954 | printf(format: " (virtual)"); |
955 | if (clang_CXXMethod_isConst(C: Cursor)) |
956 | printf(format: " (const)"); |
957 | if (clang_CXXMethod_isPureVirtual(C: Cursor)) |
958 | printf(format: " (pure)"); |
959 | if (clang_CXXMethod_isCopyAssignmentOperator(C: Cursor)) |
960 | printf(format: " (copy-assignment operator)"); |
961 | if (clang_CXXMethod_isMoveAssignmentOperator(C: Cursor)) |
962 | printf(format: " (move-assignment operator)"); |
963 | if (clang_CXXMethod_isExplicit(C: Cursor)) |
964 | printf(format: " (explicit)"); |
965 | if (clang_CXXRecord_isAbstract(C: Cursor)) |
966 | printf(format: " (abstract)"); |
967 | if (clang_EnumDecl_isScoped(C: Cursor)) |
968 | printf(format: " (scoped)"); |
969 | if (clang_Cursor_isVariadic(C: Cursor)) |
970 | printf(format: " (variadic)"); |
971 | if (clang_Cursor_isObjCOptional(C: Cursor)) |
972 | printf(format: " (@optional)"); |
973 | if (clang_isInvalidDeclaration(Cursor)) |
974 | printf(format: " (invalid)"); |
975 | |
976 | switch (clang_getCursorExceptionSpecificationType(C: Cursor)) |
977 | { |
978 | case CXCursor_ExceptionSpecificationKind_None: |
979 | break; |
980 | |
981 | case CXCursor_ExceptionSpecificationKind_DynamicNone: |
982 | printf(format: " (noexcept dynamic none)"); |
983 | break; |
984 | |
985 | case CXCursor_ExceptionSpecificationKind_Dynamic: |
986 | printf(format: " (noexcept dynamic)"); |
987 | break; |
988 | |
989 | case CXCursor_ExceptionSpecificationKind_MSAny: |
990 | printf(format: " (noexcept dynamic any)"); |
991 | break; |
992 | |
993 | case CXCursor_ExceptionSpecificationKind_BasicNoexcept: |
994 | printf(format: " (noexcept)"); |
995 | break; |
996 | |
997 | case CXCursor_ExceptionSpecificationKind_ComputedNoexcept: |
998 | printf(format: " (computed-noexcept)"); |
999 | break; |
1000 | |
1001 | case CXCursor_ExceptionSpecificationKind_Unevaluated: |
1002 | case CXCursor_ExceptionSpecificationKind_Uninstantiated: |
1003 | case CXCursor_ExceptionSpecificationKind_Unparsed: |
1004 | break; |
1005 | } |
1006 | |
1007 | { |
1008 | CXString language; |
1009 | CXString definedIn; |
1010 | unsigned generated; |
1011 | if (clang_Cursor_isExternalSymbol(C: Cursor, language: &language, definedIn: &definedIn, |
1012 | isGenerated: &generated)) { |
1013 | printf(format: " (external lang: %s, defined: %s, gen: %d)", |
1014 | clang_getCString(string: language), clang_getCString(string: definedIn), generated); |
1015 | clang_disposeString(string: language); |
1016 | clang_disposeString(string: definedIn); |
1017 | } |
1018 | } |
1019 | |
1020 | if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { |
1021 | CXType T = |
1022 | clang_getCanonicalType(T: clang_getIBOutletCollectionType(Cursor)); |
1023 | CXString S = clang_getTypeKindSpelling(K: T.kind); |
1024 | printf(format: " [IBOutletCollection=%s]", clang_getCString(string: S)); |
1025 | clang_disposeString(string: S); |
1026 | } |
1027 | |
1028 | if (Cursor.kind == CXCursor_CXXBaseSpecifier) { |
1029 | enum CX_CXXAccessSpecifier access = clang_getCXXAccessSpecifier(Cursor); |
1030 | unsigned isVirtual = clang_isVirtualBase(Cursor); |
1031 | const char *accessStr = 0; |
1032 | |
1033 | switch (access) { |
1034 | case CX_CXXInvalidAccessSpecifier: |
1035 | accessStr = "invalid"; break; |
1036 | case CX_CXXPublic: |
1037 | accessStr = "public"; break; |
1038 | case CX_CXXProtected: |
1039 | accessStr = "protected"; break; |
1040 | case CX_CXXPrivate: |
1041 | accessStr = "private"; break; |
1042 | } |
1043 | |
1044 | printf(format: " [access=%s isVirtual=%s]", accessStr, |
1045 | isVirtual ? "true": "false"); |
1046 | } |
1047 | |
1048 | SpecializationOf = clang_getSpecializedCursorTemplate(C: Cursor); |
1049 | if (!clang_equalCursors(SpecializationOf, clang_getNullCursor())) { |
1050 | CXSourceLocation Loc = clang_getCursorLocation(SpecializationOf); |
1051 | CXString Name = clang_getCursorSpelling(SpecializationOf); |
1052 | clang_getFileLocation(location: Loc, file: 0, line: &line, column: &column, offset: 0); |
1053 | printf(format: " [Specialization of %s:%d:%d]", |
1054 | clang_getCString(string: Name), line, column); |
1055 | clang_disposeString(string: Name); |
1056 | |
1057 | if (Cursor.kind == CXCursor_FunctionDecl |
1058 | || Cursor.kind == CXCursor_StructDecl |
1059 | || Cursor.kind == CXCursor_ClassDecl |
1060 | || Cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { |
1061 | /* Collect the template parameter kinds from the base template. */ |
1062 | int NumTemplateArgs = clang_Cursor_getNumTemplateArguments(C: Cursor); |
1063 | int I; |
1064 | if (NumTemplateArgs < 0) { |
1065 | printf(format: " [no template arg info]"); |
1066 | } |
1067 | for (I = 0; I < NumTemplateArgs; I++) { |
1068 | enum CXTemplateArgumentKind TAK = |
1069 | clang_Cursor_getTemplateArgumentKind(C: Cursor, I); |
1070 | switch(TAK) { |
1071 | case CXTemplateArgumentKind_Type: |
1072 | { |
1073 | CXType T = clang_Cursor_getTemplateArgumentType(C: Cursor, I); |
1074 | CXString S = clang_getTypeSpelling(CT: T); |
1075 | printf(format: " [Template arg %d: kind: %d, type: %s]", |
1076 | I, TAK, clang_getCString(string: S)); |
1077 | clang_disposeString(string: S); |
1078 | } |
1079 | break; |
1080 | case CXTemplateArgumentKind_Integral: |
1081 | printf(format: " [Template arg %d: kind: %d, intval: %lld]", |
1082 | I, TAK, clang_Cursor_getTemplateArgumentValue(C: Cursor, I)); |
1083 | break; |
1084 | default: |
1085 | printf(format: " [Template arg %d: kind: %d]\n", I, TAK); |
1086 | } |
1087 | } |
1088 | } |
1089 | } |
1090 | |
1091 | clang_getOverriddenCursors(cursor: Cursor, overridden: &overridden, num_overridden: &num_overridden); |
1092 | if (num_overridden) { |
1093 | unsigned I; |
1094 | LineCol lineCols[50]; |
1095 | assert(num_overridden <= 50); |
1096 | printf(format: " [Overrides "); |
1097 | for (I = 0; I != num_overridden; ++I) { |
1098 | CXSourceLocation Loc = clang_getCursorLocation(overridden[I]); |
1099 | clang_getFileLocation(location: Loc, file: 0, line: &line, column: &column, offset: 0); |
1100 | lineCols[I].line = line; |
1101 | lineCols[I].col = column; |
1102 | } |
1103 | /* Make the order of the override list deterministic. */ |
1104 | qsort(base: lineCols, nmemb: num_overridden, size: sizeof(LineCol), compar: lineCol_cmp); |
1105 | for (I = 0; I != num_overridden; ++I) { |
1106 | if (I) |
1107 | printf(format: ", "); |
1108 | printf(format: "@%d:%d", lineCols[I].line, lineCols[I].col); |
1109 | } |
1110 | printf(format: "]"); |
1111 | clang_disposeOverriddenCursors(overridden); |
1112 | } |
1113 | |
1114 | if (Cursor.kind == CXCursor_InclusionDirective) { |
1115 | CXFile File = clang_getIncludedFile(cursor: Cursor); |
1116 | CXString Included = clang_getFileName(SFile: File); |
1117 | const char *IncludedString = clang_getCString(string: Included); |
1118 | printf(format: " (%s)", IncludedString ? IncludedString : "(null)"); |
1119 | clang_disposeString(string: Included); |
1120 | |
1121 | if (clang_isFileMultipleIncludeGuarded(tu: TU, file: File)) |
1122 | printf(format: " [multi-include guarded]"); |
1123 | } |
1124 | |
1125 | CursorExtent = clang_getCursorExtent(Cursor); |
1126 | RefNameRange = clang_getCursorReferenceNameRange(C: Cursor, |
1127 | NameFlags: CXNameRange_WantQualifier |
1128 | | CXNameRange_WantSinglePiece |
1129 | | CXNameRange_WantTemplateArgs, |
1130 | PieceIndex: 0); |
1131 | if (!clang_equalRanges(range1: CursorExtent, range2: RefNameRange)) |
1132 | PrintRange(R: RefNameRange, str: "SingleRefName"); |
1133 | |
1134 | for (RefNameRangeNr = 0; 1; RefNameRangeNr++) { |
1135 | RefNameRange = clang_getCursorReferenceNameRange(C: Cursor, |
1136 | NameFlags: CXNameRange_WantQualifier |
1137 | | CXNameRange_WantTemplateArgs, |
1138 | PieceIndex: RefNameRangeNr); |
1139 | if (clang_equalRanges(range1: clang_getNullRange(), range2: RefNameRange)) |
1140 | break; |
1141 | if (!clang_equalRanges(range1: CursorExtent, range2: RefNameRange)) |
1142 | PrintRange(R: RefNameRange, str: "RefName"); |
1143 | } |
1144 | |
1145 | PrintCursorComments(Cursor, CommentSchemaFile); |
1146 | |
1147 | { |
1148 | unsigned PropAttrs = clang_Cursor_getObjCPropertyAttributes(C: Cursor, reserved: 0); |
1149 | if (PropAttrs != CXObjCPropertyAttr_noattr) { |
1150 | printf(format: " ["); |
1151 | #define PRINT_PROP_ATTR(A) \ |
1152 | if (PropAttrs & CXObjCPropertyAttr_##A) printf(#A ",") |
1153 | PRINT_PROP_ATTR(readonly); |
1154 | PRINT_PROP_ATTR(getter); |
1155 | PRINT_PROP_ATTR(assign); |
1156 | PRINT_PROP_ATTR(readwrite); |
1157 | PRINT_PROP_ATTR(retain); |
1158 | PRINT_PROP_ATTR(copy); |
1159 | PRINT_PROP_ATTR(nonatomic); |
1160 | PRINT_PROP_ATTR(setter); |
1161 | PRINT_PROP_ATTR(atomic); |
1162 | PRINT_PROP_ATTR(weak); |
1163 | PRINT_PROP_ATTR(strong); |
1164 | PRINT_PROP_ATTR(unsafe_unretained); |
1165 | PRINT_PROP_ATTR(class); |
1166 | printf(format: "]"); |
1167 | } |
1168 | } |
1169 | |
1170 | if (Cursor.kind == CXCursor_ObjCPropertyDecl) { |
1171 | CXString Name = clang_Cursor_getObjCPropertyGetterName(C: Cursor); |
1172 | CXString Spelling = clang_getCursorSpelling(Cursor); |
1173 | const char *CName = clang_getCString(string: Name); |
1174 | const char *CSpelling = clang_getCString(string: Spelling); |
1175 | if (CName && strcmp(s1: CName, s2: CSpelling)) { |
1176 | printf(format: " (getter=%s)", CName); |
1177 | } |
1178 | clang_disposeString(string: Spelling); |
1179 | clang_disposeString(string: Name); |
1180 | } |
1181 | |
1182 | if (Cursor.kind == CXCursor_ObjCPropertyDecl) { |
1183 | CXString Name = clang_Cursor_getObjCPropertySetterName(C: Cursor); |
1184 | CXString Spelling = clang_getCursorSpelling(Cursor); |
1185 | const char *CName = clang_getCString(string: Name); |
1186 | const char *CSpelling = clang_getCString(string: Spelling); |
1187 | size_t Len = strlen(s: CSpelling) + 5; |
1188 | char *DefaultSetter = malloc(size: Len); |
1189 | snprintf(s: DefaultSetter, maxlen: Len, format: "set%s:", CSpelling); |
1190 | DefaultSetter[3] &= ~(1 << 5); /* Make uppercase */ |
1191 | if (CName && strcmp(s1: CName, s2: DefaultSetter)) { |
1192 | printf(format: " (setter=%s)", CName); |
1193 | } |
1194 | free(ptr: DefaultSetter); |
1195 | clang_disposeString(string: Spelling); |
1196 | clang_disposeString(string: Name); |
1197 | } |
1198 | |
1199 | { |
1200 | unsigned QT = clang_Cursor_getObjCDeclQualifiers(C: Cursor); |
1201 | if (QT != CXObjCDeclQualifier_None) { |
1202 | printf(format: " ["); |
1203 | #define PRINT_OBJC_QUAL(A) \ |
1204 | if (QT & CXObjCDeclQualifier_##A) printf(#A ",") |
1205 | PRINT_OBJC_QUAL(In); |
1206 | PRINT_OBJC_QUAL(Inout); |
1207 | PRINT_OBJC_QUAL(Out); |
1208 | PRINT_OBJC_QUAL(Bycopy); |
1209 | PRINT_OBJC_QUAL(Byref); |
1210 | PRINT_OBJC_QUAL(Oneway); |
1211 | printf(format: "]"); |
1212 | } |
1213 | } |
1214 | } |
1215 | } |
1216 | |
1217 | static CXString createCXString(const char *CS) { |
1218 | CXString Str; |
1219 | Str.data = (const void *)CS; |
1220 | Str.private_flags = 0; |
1221 | return Str; |
1222 | } |
1223 | |
1224 | static CXString duplicateCXString(const char *CS) { |
1225 | CXString Str; |
1226 | Str.data = strdup(s: CS); |
1227 | Str.private_flags = 1; /* CXS_Malloc */ |
1228 | return Str; |
1229 | } |
1230 | |
1231 | static CXString GetCursorSource(CXCursor Cursor) { |
1232 | CXSourceLocation Loc = clang_getCursorLocation(Cursor); |
1233 | CXString source; |
1234 | CXFile file; |
1235 | const char *b; |
1236 | CXString result; |
1237 | clang_getExpansionLocation(location: Loc, file: &file, line: 0, column: 0, offset: 0); |
1238 | source = clang_getFileName(SFile: file); |
1239 | if (!clang_getCString(string: source)) { |
1240 | clang_disposeString(string: source); |
1241 | return createCXString(CS: "<invalid loc>"); |
1242 | } |
1243 | b = basename(clang_getCString(string: source)); |
1244 | result = duplicateCXString(CS: b); |
1245 | clang_disposeString(string: source); |
1246 | return result; |
1247 | } |
1248 | |
1249 | /******************************************************************************/ |
1250 | /* Callbacks. */ |
1251 | /******************************************************************************/ |
1252 | |
1253 | typedef void (*PostVisitTU)(CXTranslationUnit); |
1254 | |
1255 | void PrintDiagnostic(CXDiagnostic Diagnostic) { |
1256 | FILE *out = stderr; |
1257 | CXFile file; |
1258 | CXString Msg; |
1259 | unsigned display_opts = CXDiagnostic_DisplaySourceLocation |
1260 | | CXDiagnostic_DisplayColumn | CXDiagnostic_DisplaySourceRanges |
1261 | | CXDiagnostic_DisplayOption; |
1262 | unsigned i, num_fixits; |
1263 | |
1264 | if (clang_getDiagnosticSeverity(Diagnostic) == CXDiagnostic_Ignored) |
1265 | return; |
1266 | |
1267 | Msg = clang_formatDiagnostic(Diagnostic, Options: display_opts); |
1268 | fprintf(stderr, format: "%s\n", clang_getCString(string: Msg)); |
1269 | clang_disposeString(string: Msg); |
1270 | |
1271 | clang_getFileLocation(location: clang_getDiagnosticLocation(Diagnostic), file: &file, line: 0, column: 0, |
1272 | offset: 0); |
1273 | if (!file) |
1274 | return; |
1275 | |
1276 | num_fixits = clang_getDiagnosticNumFixIts(Diagnostic); |
1277 | fprintf(stderr, format: "Number FIX-ITs = %d\n", num_fixits); |
1278 | for (i = 0; i != num_fixits; ++i) { |
1279 | CXSourceRange range; |
1280 | CXString insertion_text = clang_getDiagnosticFixIt(Diagnostic, FixIt: i, ReplacementRange: &range); |
1281 | CXSourceLocation start = clang_getRangeStart(range); |
1282 | CXSourceLocation end = clang_getRangeEnd(range); |
1283 | unsigned start_line, start_column, end_line, end_column; |
1284 | CXFile start_file, end_file; |
1285 | clang_getFileLocation(location: start, file: &start_file, line: &start_line, column: &start_column, offset: 0); |
1286 | clang_getFileLocation(location: end, file: &end_file, line: &end_line, column: &end_column, offset: 0); |
1287 | if (clang_equalLocations(loc1: start, loc2: end)) { |
1288 | /* Insertion. */ |
1289 | if (start_file == file) |
1290 | fprintf(stream: out, format: "FIX-IT: Insert \"%s\" at %d:%d\n", |
1291 | clang_getCString(string: insertion_text), start_line, start_column); |
1292 | } else if (strcmp(s1: clang_getCString(string: insertion_text), s2: "") == 0) { |
1293 | /* Removal. */ |
1294 | if (start_file == file && end_file == file) { |
1295 | fprintf(stream: out, format: "FIX-IT: Remove "); |
1296 | PrintExtent(out, begin_line: start_line, begin_column: start_column, end_line, end_column); |
1297 | fprintf(stream: out, format: "\n"); |
1298 | } |
1299 | } else { |
1300 | /* Replacement. */ |
1301 | if (start_file == end_file) { |
1302 | fprintf(stream: out, format: "FIX-IT: Replace "); |
1303 | PrintExtent(out, begin_line: start_line, begin_column: start_column, end_line, end_column); |
1304 | fprintf(stream: out, format: " with \"%s\"\n", clang_getCString(string: insertion_text)); |
1305 | } |
1306 | } |
1307 | clang_disposeString(string: insertion_text); |
1308 | } |
1309 | } |
1310 | |
1311 | void PrintDiagnosticSet(CXDiagnosticSet Set) { |
1312 | int i = 0, n = clang_getNumDiagnosticsInSet(Diags: Set); |
1313 | for ( ; i != n ; ++i) { |
1314 | CXDiagnostic Diag = clang_getDiagnosticInSet(Diags: Set, Index: i); |
1315 | CXDiagnosticSet ChildDiags = clang_getChildDiagnostics(D: Diag); |
1316 | PrintDiagnostic(Diagnostic: Diag); |
1317 | if (ChildDiags) |
1318 | PrintDiagnosticSet(Set: ChildDiags); |
1319 | } |
1320 | } |
1321 | |
1322 | void PrintDiagnostics(CXTranslationUnit TU) { |
1323 | CXDiagnosticSet TUSet = clang_getDiagnosticSetFromTU(Unit: TU); |
1324 | PrintDiagnosticSet(Set: TUSet); |
1325 | clang_disposeDiagnosticSet(Diags: TUSet); |
1326 | } |
1327 | |
1328 | void PrintMemoryUsage(CXTranslationUnit TU) { |
1329 | unsigned long total = 0; |
1330 | unsigned i = 0; |
1331 | CXTUResourceUsage usage = clang_getCXTUResourceUsage(TU); |
1332 | fprintf(stderr, format: "Memory usage:\n"); |
1333 | for (i = 0 ; i != usage.numEntries; ++i) { |
1334 | const char *name = clang_getTUResourceUsageName(kind: usage.entries[i].kind); |
1335 | unsigned long amount = usage.entries[i].amount; |
1336 | total += amount; |
1337 | fprintf(stderr, format: " %s : %ld bytes (%f MBytes)\n", name, amount, |
1338 | ((double) amount)/(1024*1024)); |
1339 | } |
1340 | fprintf(stderr, format: " TOTAL = %ld bytes (%f MBytes)\n", total, |
1341 | ((double) total)/(1024*1024)); |
1342 | clang_disposeCXTUResourceUsage(usage); |
1343 | } |
1344 | |
1345 | /******************************************************************************/ |
1346 | /* Logic for testing traversal. */ |
1347 | /******************************************************************************/ |
1348 | |
1349 | static void PrintCursorExtent(CXCursor C) { |
1350 | CXSourceRange extent = clang_getCursorExtent(C); |
1351 | PrintRange(R: extent, str: "Extent"); |
1352 | } |
1353 | |
1354 | /* Data used by the visitors. */ |
1355 | typedef struct { |
1356 | CXTranslationUnit TU; |
1357 | enum CXCursorKind *Filter; |
1358 | const char *CommentSchemaFile; |
1359 | } VisitorData; |
1360 | |
1361 | |
1362 | enum CXChildVisitResult FilteredPrintingVisitor(CXCursor Cursor, |
1363 | CXCursor Parent, |
1364 | CXClientData ClientData) { |
1365 | VisitorData *Data = (VisitorData *)ClientData; |
1366 | if (!Data->Filter || (Cursor.kind == *(enum CXCursorKind *)Data->Filter)) { |
1367 | CXSourceLocation Loc = clang_getCursorLocation(Cursor); |
1368 | unsigned line, column; |
1369 | CXString source; |
1370 | clang_getFileLocation(location: Loc, file: 0, line: &line, column: &column, offset: 0); |
1371 | source = GetCursorSource(Cursor); |
1372 | printf(format: "// %s: %s:%d:%d: ", FileCheckPrefix, clang_getCString(string: source), line, |
1373 | column); |
1374 | clang_disposeString(string: source); |
1375 | PrintCursor(Cursor, CommentSchemaFile: Data->CommentSchemaFile); |
1376 | PrintCursorExtent(C: Cursor); |
1377 | if (clang_isDeclaration(Cursor.kind)) { |
1378 | enum CX_CXXAccessSpecifier access = clang_getCXXAccessSpecifier(Cursor); |
1379 | const char *accessStr = 0; |
1380 | |
1381 | switch (access) { |
1382 | case CX_CXXInvalidAccessSpecifier: break; |
1383 | case CX_CXXPublic: |
1384 | accessStr = "public"; break; |
1385 | case CX_CXXProtected: |
1386 | accessStr = "protected"; break; |
1387 | case CX_CXXPrivate: |
1388 | accessStr = "private"; break; |
1389 | } |
1390 | |
1391 | if (accessStr) |
1392 | printf(format: " [access=%s]", accessStr); |
1393 | } |
1394 | printf(format: "\n"); |
1395 | return CXChildVisit_Recurse; |
1396 | } |
1397 | |
1398 | return CXChildVisit_Continue; |
1399 | } |
1400 | |
1401 | static enum CXChildVisitResult FunctionScanVisitor(CXCursor Cursor, |
1402 | CXCursor Parent, |
1403 | CXClientData ClientData) { |
1404 | const char *startBuf, *endBuf; |
1405 | unsigned startLine, startColumn, endLine, endColumn, curLine, curColumn; |
1406 | CXCursor Ref; |
1407 | VisitorData *Data = (VisitorData *)ClientData; |
1408 | |
1409 | if (Cursor.kind != CXCursor_FunctionDecl || |
1410 | !clang_isCursorDefinition(Cursor)) |
1411 | return CXChildVisit_Continue; |
1412 | |
1413 | clang_getDefinitionSpellingAndExtent(Cursor, startBuf: &startBuf, endBuf: &endBuf, |
1414 | startLine: &startLine, startColumn: &startColumn, |
1415 | endLine: &endLine, endColumn: &endColumn); |
1416 | /* Probe the entire body, looking for both decls and refs. */ |
1417 | curLine = startLine; |
1418 | curColumn = startColumn; |
1419 | |
1420 | while (startBuf < endBuf) { |
1421 | CXSourceLocation Loc; |
1422 | CXFile file; |
1423 | CXString source; |
1424 | |
1425 | if (*startBuf == '\n') { |
1426 | startBuf++; |
1427 | curLine++; |
1428 | curColumn = 1; |
1429 | } else if (*startBuf != '\t') |
1430 | curColumn++; |
1431 | |
1432 | Loc = clang_getCursorLocation(Cursor); |
1433 | clang_getFileLocation(location: Loc, file: &file, line: 0, column: 0, offset: 0); |
1434 | |
1435 | source = clang_getFileName(SFile: file); |
1436 | if (clang_getCString(string: source)) { |
1437 | CXSourceLocation RefLoc |
1438 | = clang_getLocation(tu: Data->TU, file, line: curLine, column: curColumn); |
1439 | Ref = clang_getCursor(Data->TU, RefLoc); |
1440 | if (Ref.kind == CXCursor_NoDeclFound) { |
1441 | /* Nothing found here; that's fine. */ |
1442 | } else if (Ref.kind != CXCursor_FunctionDecl) { |
1443 | CXString CursorSource = GetCursorSource(Cursor: Ref); |
1444 | printf(format: "// %s: %s:%d:%d: ", FileCheckPrefix, |
1445 | clang_getCString(string: CursorSource), curLine, curColumn); |
1446 | clang_disposeString(string: CursorSource); |
1447 | PrintCursor(Cursor: Ref, CommentSchemaFile: Data->CommentSchemaFile); |
1448 | printf(format: "\n"); |
1449 | } |
1450 | } |
1451 | clang_disposeString(string: source); |
1452 | startBuf++; |
1453 | } |
1454 | |
1455 | return CXChildVisit_Continue; |
1456 | } |
1457 | |
1458 | /******************************************************************************/ |
1459 | /* USR testing. */ |
1460 | /******************************************************************************/ |
1461 | |
1462 | enum CXChildVisitResult USRVisitor(CXCursor C, CXCursor parent, |
1463 | CXClientData ClientData) { |
1464 | VisitorData *Data = (VisitorData *)ClientData; |
1465 | if (!Data->Filter || (C.kind == *(enum CXCursorKind *)Data->Filter)) { |
1466 | CXString USR = clang_getCursorUSR(C); |
1467 | const char *cstr = clang_getCString(string: USR); |
1468 | CXString CursorSource; |
1469 | if (!cstr || cstr[0] == '\0') { |
1470 | clang_disposeString(string: USR); |
1471 | return CXChildVisit_Recurse; |
1472 | } |
1473 | CursorSource = GetCursorSource(Cursor: C); |
1474 | printf(format: "// %s: %s %s", FileCheckPrefix, clang_getCString(string: CursorSource), |
1475 | cstr); |
1476 | clang_disposeString(string: CursorSource); |
1477 | |
1478 | PrintCursorExtent(C); |
1479 | printf(format: "\n"); |
1480 | clang_disposeString(string: USR); |
1481 | |
1482 | return CXChildVisit_Recurse; |
1483 | } |
1484 | |
1485 | return CXChildVisit_Continue; |
1486 | } |
1487 | |
1488 | /******************************************************************************/ |
1489 | /* Inclusion stack testing. */ |
1490 | /******************************************************************************/ |
1491 | |
1492 | void InclusionVisitor(CXFile includedFile, CXSourceLocation *includeStack, |
1493 | unsigned includeStackLen, CXClientData data) { |
1494 | |
1495 | unsigned i; |
1496 | CXString fname; |
1497 | |
1498 | fname = clang_getFileName(SFile: includedFile); |
1499 | printf(format: "file: %s\nincluded by:\n", clang_getCString(string: fname)); |
1500 | clang_disposeString(string: fname); |
1501 | |
1502 | for (i = 0; i < includeStackLen; ++i) { |
1503 | CXFile includingFile; |
1504 | unsigned line, column; |
1505 | clang_getFileLocation(location: includeStack[i], file: &includingFile, line: &line, column: &column, offset: 0); |
1506 | fname = clang_getFileName(SFile: includingFile); |
1507 | printf(format: " %s:%d:%d\n", clang_getCString(string: fname), line, column); |
1508 | clang_disposeString(string: fname); |
1509 | } |
1510 | printf(format: "\n"); |
1511 | } |
1512 | |
1513 | void PrintInclusionStack(CXTranslationUnit TU) { |
1514 | clang_getInclusions(tu: TU, visitor: InclusionVisitor, NULL); |
1515 | } |
1516 | |
1517 | /******************************************************************************/ |
1518 | /* Linkage testing. */ |
1519 | /******************************************************************************/ |
1520 | |
1521 | static enum CXChildVisitResult PrintLinkage(CXCursor cursor, CXCursor p, |
1522 | CXClientData d) { |
1523 | const char *linkage = 0; |
1524 | |
1525 | if (clang_isInvalid(clang_getCursorKind(cursor))) |
1526 | return CXChildVisit_Recurse; |
1527 | |
1528 | switch (clang_getCursorLinkage(cursor)) { |
1529 | case CXLinkage_Invalid: break; |
1530 | case CXLinkage_NoLinkage: linkage = "NoLinkage"; break; |
1531 | case CXLinkage_Internal: linkage = "Internal"; break; |
1532 | case CXLinkage_UniqueExternal: linkage = "UniqueExternal"; break; |
1533 | case CXLinkage_External: linkage = "External"; break; |
1534 | } |
1535 | |
1536 | if (linkage) { |
1537 | PrintCursor(Cursor: cursor, NULL); |
1538 | printf(format: "linkage=%s\n", linkage); |
1539 | } |
1540 | |
1541 | return CXChildVisit_Recurse; |
1542 | } |
1543 | |
1544 | /******************************************************************************/ |
1545 | /* Visibility testing. */ |
1546 | /******************************************************************************/ |
1547 | |
1548 | static enum CXChildVisitResult PrintVisibility(CXCursor cursor, CXCursor p, |
1549 | CXClientData d) { |
1550 | const char *visibility = 0; |
1551 | |
1552 | if (clang_isInvalid(clang_getCursorKind(cursor))) |
1553 | return CXChildVisit_Recurse; |
1554 | |
1555 | switch (clang_getCursorVisibility(cursor)) { |
1556 | case CXVisibility_Invalid: break; |
1557 | case CXVisibility_Hidden: visibility = "Hidden"; break; |
1558 | case CXVisibility_Protected: visibility = "Protected"; break; |
1559 | case CXVisibility_Default: visibility = "Default"; break; |
1560 | } |
1561 | |
1562 | if (visibility) { |
1563 | PrintCursor(Cursor: cursor, NULL); |
1564 | printf(format: "visibility=%s\n", visibility); |
1565 | } |
1566 | |
1567 | return CXChildVisit_Recurse; |
1568 | } |
1569 | |
1570 | /******************************************************************************/ |
1571 | /* Typekind testing. */ |
1572 | /******************************************************************************/ |
1573 | |
1574 | static void PrintTypeAndTypeKind(CXType T, const char *Format) { |
1575 | CXString TypeSpelling, TypeKindSpelling; |
1576 | |
1577 | TypeSpelling = clang_getTypeSpelling(CT: T); |
1578 | TypeKindSpelling = clang_getTypeKindSpelling(K: T.kind); |
1579 | printf(format: Format, |
1580 | clang_getCString(string: TypeSpelling), |
1581 | clang_getCString(string: TypeKindSpelling)); |
1582 | clang_disposeString(string: TypeSpelling); |
1583 | clang_disposeString(string: TypeKindSpelling); |
1584 | } |
1585 | |
1586 | static enum CXVisitorResult FieldVisitor(CXCursor C, |
1587 | CXClientData client_data) { |
1588 | (*(int *) client_data)+=1; |
1589 | return CXVisit_Continue; |
1590 | } |
1591 | |
1592 | static void PrintTypeTemplateArgs(CXType T, const char *Format) { |
1593 | int NumTArgs = clang_Type_getNumTemplateArguments(T); |
1594 | if (NumTArgs != -1 && NumTArgs != 0) { |
1595 | int i; |
1596 | CXType TArg; |
1597 | printf(format: Format, NumTArgs); |
1598 | for (i = 0; i < NumTArgs; ++i) { |
1599 | TArg = clang_Type_getTemplateArgumentAsType(T, i); |
1600 | if (TArg.kind != CXType_Invalid) { |
1601 | PrintTypeAndTypeKind(T: TArg, Format: " [type=%s] [typekind=%s]"); |
1602 | } |
1603 | } |
1604 | /* Ensure that the returned type is invalid when indexing off-by-one. */ |
1605 | TArg = clang_Type_getTemplateArgumentAsType(T, i); |
1606 | assert(TArg.kind == CXType_Invalid); |
1607 | printf(format: "]"); |
1608 | } |
1609 | } |
1610 | |
1611 | static void PrintNullabilityKind(CXType T, const char *Format) { |
1612 | enum CXTypeNullabilityKind N = clang_Type_getNullability(T); |
1613 | |
1614 | const char *nullability = 0; |
1615 | switch (N) { |
1616 | case CXTypeNullability_NonNull: |
1617 | nullability = "nonnull"; |
1618 | break; |
1619 | case CXTypeNullability_Nullable: |
1620 | nullability = "nullable"; |
1621 | break; |
1622 | case CXTypeNullability_NullableResult: |
1623 | nullability = "nullable_result"; |
1624 | break; |
1625 | case CXTypeNullability_Unspecified: |
1626 | nullability = "unspecified"; |
1627 | break; |
1628 | case CXTypeNullability_Invalid: |
1629 | break; |
1630 | } |
1631 | |
1632 | if (nullability) { |
1633 | printf(format: Format, nullability); |
1634 | } |
1635 | } |
1636 | |
1637 | static enum CXChildVisitResult PrintType(CXCursor cursor, CXCursor p, |
1638 | CXClientData d) { |
1639 | if (!clang_isInvalid(clang_getCursorKind(cursor))) { |
1640 | CXType T = clang_getCursorType(C: cursor); |
1641 | CXType PT = clang_getPointeeType(T); |
1642 | enum CXRefQualifierKind RQ = clang_Type_getCXXRefQualifier(T); |
1643 | PrintCursor(Cursor: cursor, NULL); |
1644 | PrintTypeAndTypeKind(T, Format: " [type=%s] [typekind=%s]"); |
1645 | PrintNullabilityKind(T, Format: " [nullability=%s]"); |
1646 | if (clang_isConstQualifiedType(T)) |
1647 | printf(format: " const"); |
1648 | if (clang_isVolatileQualifiedType(T)) |
1649 | printf(format: " volatile"); |
1650 | if (clang_isRestrictQualifiedType(T)) |
1651 | printf(format: " restrict"); |
1652 | if (RQ == CXRefQualifier_LValue) |
1653 | printf(format: " lvalue-ref-qualifier"); |
1654 | if (RQ == CXRefQualifier_RValue) |
1655 | printf(format: " rvalue-ref-qualifier"); |
1656 | /* Print the template argument types if they exist. */ |
1657 | PrintTypeTemplateArgs(T, Format: " [templateargs/%d="); |
1658 | /* Print the canonical type if it is different. */ |
1659 | { |
1660 | CXType CT = clang_getCanonicalType(T); |
1661 | if (!clang_equalTypes(A: T, B: CT)) { |
1662 | PrintTypeAndTypeKind(T: CT, Format: " [canonicaltype=%s] [canonicaltypekind=%s]"); |
1663 | PrintTypeTemplateArgs(T: CT, Format: " [canonicaltemplateargs/%d="); |
1664 | } |
1665 | } |
1666 | /* Print the value type if it exists. */ |
1667 | { |
1668 | CXType VT = clang_Type_getValueType(CT: T); |
1669 | if (VT.kind != CXType_Invalid) |
1670 | PrintTypeAndTypeKind(T: VT, Format: " [valuetype=%s] [valuetypekind=%s]"); |
1671 | } |
1672 | /* Print the modified type if it exists. */ |
1673 | { |
1674 | CXType MT = clang_Type_getModifiedType(T); |
1675 | if (MT.kind != CXType_Invalid) { |
1676 | PrintTypeAndTypeKind(T: MT, Format: " [modifiedtype=%s] [modifiedtypekind=%s]"); |
1677 | } |
1678 | } |
1679 | /* Print the return type if it exists. */ |
1680 | { |
1681 | CXType RT = clang_getCursorResultType(C: cursor); |
1682 | if (RT.kind != CXType_Invalid) { |
1683 | PrintTypeAndTypeKind(T: RT, Format: " [resulttype=%s] [resulttypekind=%s]"); |
1684 | } |
1685 | PrintNullabilityKind(T: RT, Format: " [resultnullability=%s]"); |
1686 | } |
1687 | /* Print the argument types if they exist. */ |
1688 | { |
1689 | int NumArgs = clang_Cursor_getNumArguments(C: cursor); |
1690 | if (NumArgs != -1 && NumArgs != 0) { |
1691 | int i; |
1692 | printf(format: " [args="); |
1693 | for (i = 0; i < NumArgs; ++i) { |
1694 | CXType T = clang_getCursorType(C: clang_Cursor_getArgument(C: cursor, i)); |
1695 | if (T.kind != CXType_Invalid) { |
1696 | PrintTypeAndTypeKind(T, Format: " [%s] [%s]"); |
1697 | PrintNullabilityKind(T, Format: " [%s]"); |
1698 | } |
1699 | } |
1700 | printf(format: "]"); |
1701 | } |
1702 | } |
1703 | /* Print ObjC base types, type arguments, and protocol list if available. */ |
1704 | { |
1705 | CXType BT = clang_Type_getObjCObjectBaseType(T: PT); |
1706 | if (BT.kind != CXType_Invalid) { |
1707 | PrintTypeAndTypeKind(T: BT, Format: " [basetype=%s] [basekind=%s]"); |
1708 | } |
1709 | } |
1710 | { |
1711 | unsigned NumTypeArgs = clang_Type_getNumObjCTypeArgs(T: PT); |
1712 | if (NumTypeArgs > 0) { |
1713 | unsigned i; |
1714 | printf(format: " [typeargs="); |
1715 | for (i = 0; i < NumTypeArgs; ++i) { |
1716 | CXType TA = clang_Type_getObjCTypeArg(T: PT, i); |
1717 | if (TA.kind != CXType_Invalid) { |
1718 | PrintTypeAndTypeKind(T: TA, Format: " [%s] [%s]"); |
1719 | } |
1720 | } |
1721 | printf(format: "]"); |
1722 | } |
1723 | } |
1724 | { |
1725 | unsigned NumProtocols = clang_Type_getNumObjCProtocolRefs(T: PT); |
1726 | if (NumProtocols > 0) { |
1727 | unsigned i; |
1728 | printf(format: " [protocols="); |
1729 | for (i = 0; i < NumProtocols; ++i) { |
1730 | CXCursor P = clang_Type_getObjCProtocolDecl(T: PT, i); |
1731 | if (!clang_isInvalid(clang_getCursorKind(P))) { |
1732 | PrintCursor(Cursor: P, NULL); |
1733 | } |
1734 | } |
1735 | printf(format: "]"); |
1736 | } |
1737 | } |
1738 | /* Print if this is a non-POD type. */ |
1739 | printf(format: " [isPOD=%d]", clang_isPODType(T)); |
1740 | /* Print the pointee type. */ |
1741 | { |
1742 | if (PT.kind != CXType_Invalid) { |
1743 | PrintTypeAndTypeKind(T: PT, Format: " [pointeetype=%s] [pointeekind=%s]"); |
1744 | } |
1745 | } |
1746 | /* Print the number of fields if they exist. */ |
1747 | { |
1748 | int numFields = 0; |
1749 | if (clang_Type_visitFields(T, visitor: FieldVisitor, client_data: &numFields)){ |
1750 | if (numFields != 0) { |
1751 | printf(format: " [nbFields=%d]", numFields); |
1752 | } |
1753 | } |
1754 | } |
1755 | |
1756 | /* Print if it is an anonymous record or namespace. */ |
1757 | { |
1758 | unsigned isAnon = clang_Cursor_isAnonymous(C: cursor); |
1759 | if (isAnon != 0) { |
1760 | printf(format: " [isAnon=%d]", isAnon); |
1761 | } |
1762 | } |
1763 | |
1764 | /* Print if it is an anonymous record decl */ |
1765 | { |
1766 | unsigned isAnonRecDecl = clang_Cursor_isAnonymousRecordDecl(C: cursor); |
1767 | printf(format: " [isAnonRecDecl=%d]", isAnonRecDecl); |
1768 | } |
1769 | |
1770 | /* Print if it is an inline namespace decl */ |
1771 | { |
1772 | unsigned isInlineNamespace = clang_Cursor_isInlineNamespace(C: cursor); |
1773 | if (isInlineNamespace != 0) |
1774 | printf(format: " [isInlineNamespace=%d]", isInlineNamespace); |
1775 | } |
1776 | |
1777 | printf(format: "\n"); |
1778 | } |
1779 | return CXChildVisit_Recurse; |
1780 | } |
1781 | |
1782 | static void PrintSingleTypeSize(CXType T, const char *TypeKindFormat, |
1783 | const char *SizeFormat, |
1784 | const char *AlignFormat) { |
1785 | PrintTypeAndTypeKind(T, Format: TypeKindFormat); |
1786 | /* Print the type sizeof if applicable. */ |
1787 | { |
1788 | long long Size = clang_Type_getSizeOf(T); |
1789 | if (Size >= 0 || Size < -1 ) { |
1790 | printf(format: SizeFormat, Size); |
1791 | } |
1792 | } |
1793 | /* Print the type alignof if applicable. */ |
1794 | { |
1795 | long long Align = clang_Type_getAlignOf(T); |
1796 | if (Align >= 0 || Align < -1) { |
1797 | printf(format: AlignFormat, Align); |
1798 | } |
1799 | } |
1800 | |
1801 | /* Print the return type if it exists. */ |
1802 | { |
1803 | CXType RT = clang_getResultType(T); |
1804 | if (RT.kind != CXType_Invalid) |
1805 | PrintSingleTypeSize(T: RT, TypeKindFormat: " [resulttype=%s] [resulttypekind=%s]", |
1806 | SizeFormat: " [resultsizeof=%lld]", AlignFormat: " [resultalignof=%lld]"); |
1807 | } |
1808 | } |
1809 | |
1810 | static enum CXChildVisitResult PrintTypeSize(CXCursor cursor, CXCursor p, |
1811 | CXClientData d) { |
1812 | CXType T; |
1813 | enum CXCursorKind K = clang_getCursorKind(cursor); |
1814 | if (clang_isInvalid(K)) |
1815 | return CXChildVisit_Recurse; |
1816 | T = clang_getCursorType(C: cursor); |
1817 | PrintCursor(Cursor: cursor, NULL); |
1818 | PrintSingleTypeSize(T, TypeKindFormat: " [type=%s] [typekind=%s]", SizeFormat: " [sizeof=%lld]", |
1819 | AlignFormat: " [alignof=%lld]"); |
1820 | /* Print the record field offset if applicable. */ |
1821 | { |
1822 | CXString FieldSpelling = clang_getCursorSpelling(cursor); |
1823 | const char *FieldName = clang_getCString(string: FieldSpelling); |
1824 | /* recurse to get the first parent record that is not anonymous. */ |
1825 | unsigned RecordIsAnonymous = 0; |
1826 | if (clang_getCursorKind(cursor) == CXCursor_FieldDecl) { |
1827 | CXCursor Record; |
1828 | CXCursor Parent = p; |
1829 | do { |
1830 | Record = Parent; |
1831 | Parent = clang_getCursorSemanticParent(cursor: Record); |
1832 | RecordIsAnonymous = clang_Cursor_isAnonymous(C: Record); |
1833 | /* Recurse as long as the parent is a CXType_Record and the Record |
1834 | is anonymous */ |
1835 | } while ( clang_getCursorType(C: Parent).kind == CXType_Record && |
1836 | RecordIsAnonymous > 0); |
1837 | { |
1838 | long long Offset = clang_Type_getOffsetOf(T: clang_getCursorType(C: Record), |
1839 | S: FieldName); |
1840 | long long Offset2 = clang_Cursor_getOffsetOfField(C: cursor); |
1841 | if (Offset == Offset2){ |
1842 | printf(format: " [offsetof=%lld]", Offset); |
1843 | } else { |
1844 | /* Offsets will be different in anonymous records. */ |
1845 | printf(format: " [offsetof=%lld/%lld]", Offset, Offset2); |
1846 | } |
1847 | } |
1848 | } |
1849 | clang_disposeString(string: FieldSpelling); |
1850 | } |
1851 | /* Print if its a bitfield */ |
1852 | { |
1853 | int IsBitfield = clang_Cursor_isBitField(C: cursor); |
1854 | if (IsBitfield) |
1855 | printf(format: " [BitFieldSize=%d]", clang_getFieldDeclBitWidth(C: cursor)); |
1856 | } |
1857 | |
1858 | printf(format: "\n"); |
1859 | |
1860 | return CXChildVisit_Recurse; |
1861 | } |
1862 | |
1863 | static enum CXChildVisitResult PrintBinOps(CXCursor C, CXCursor p, |
1864 | CXClientData d) { |
1865 | enum CXCursorKind ck = clang_getCursorKind(C); |
1866 | enum CXBinaryOperatorKind bok; |
1867 | CXString opstr; |
1868 | if (ck != CXCursor_BinaryOperator && ck != CXCursor_CompoundAssignOperator) |
1869 | return CXChildVisit_Recurse; |
1870 | |
1871 | PrintCursor(Cursor: C, NULL); |
1872 | bok = clang_getCursorBinaryOperatorKind(cursor: C); |
1873 | opstr = clang_getBinaryOperatorKindSpelling(kind: bok); |
1874 | printf(format: " BinOp=%s %d\n", clang_getCString(string: opstr), bok); |
1875 | clang_disposeString(string: opstr); |
1876 | return CXChildVisit_Recurse; |
1877 | } |
1878 | |
1879 | /******************************************************************************/ |
1880 | /* Mangling testing. */ |
1881 | /******************************************************************************/ |
1882 | |
1883 | static enum CXChildVisitResult PrintMangledName(CXCursor cursor, CXCursor p, |
1884 | CXClientData d) { |
1885 | CXString MangledName; |
1886 | if (clang_isUnexposed(clang_getCursorKind(cursor))) |
1887 | return CXChildVisit_Recurse; |
1888 | if (clang_getCursorKind(cursor) == CXCursor_LinkageSpec) |
1889 | return CXChildVisit_Recurse; |
1890 | PrintCursor(Cursor: cursor, NULL); |
1891 | MangledName = clang_Cursor_getMangling(cursor); |
1892 | printf(format: " [mangled=%s]\n", clang_getCString(string: MangledName)); |
1893 | clang_disposeString(string: MangledName); |
1894 | return CXChildVisit_Continue; |
1895 | } |
1896 | |
1897 | static enum CXChildVisitResult PrintManglings(CXCursor cursor, CXCursor p, |
1898 | CXClientData d) { |
1899 | unsigned I, E; |
1900 | CXStringSet *Manglings = NULL; |
1901 | if (clang_isUnexposed(clang_getCursorKind(cursor))) |
1902 | return CXChildVisit_Recurse; |
1903 | if (!clang_isDeclaration(clang_getCursorKind(cursor))) |
1904 | return CXChildVisit_Recurse; |
1905 | if (clang_getCursorKind(cursor) == CXCursor_LinkageSpec) |
1906 | return CXChildVisit_Recurse; |
1907 | if (clang_getCursorKind(cursor) == CXCursor_ParmDecl) |
1908 | return CXChildVisit_Continue; |
1909 | PrintCursor(Cursor: cursor, NULL); |
1910 | Manglings = clang_Cursor_getCXXManglings(cursor); |
1911 | if (Manglings) { |
1912 | for (I = 0, E = Manglings->Count; I < E; ++I) |
1913 | printf(format: " [mangled=%s]", clang_getCString(string: Manglings->Strings[I])); |
1914 | clang_disposeStringSet(set: Manglings); |
1915 | printf(format: "\n"); |
1916 | } |
1917 | Manglings = clang_Cursor_getObjCManglings(cursor); |
1918 | if (Manglings) { |
1919 | for (I = 0, E = Manglings->Count; I < E; ++I) |
1920 | printf(format: " [mangled=%s]", clang_getCString(string: Manglings->Strings[I])); |
1921 | clang_disposeStringSet(set: Manglings); |
1922 | printf(format: "\n"); |
1923 | } |
1924 | return CXChildVisit_Recurse; |
1925 | } |
1926 | |
1927 | static enum CXChildVisitResult |
1928 | PrintSingleSymbolSGFs(CXCursor cursor, CXCursor parent, CXClientData data) { |
1929 | CXString SGFData = clang_getSymbolGraphForCursor(cursor); |
1930 | const char *SGF = clang_getCString(string: SGFData); |
1931 | if (SGF) |
1932 | printf(format: "%s\n", SGF); |
1933 | |
1934 | clang_disposeString(string: SGFData); |
1935 | |
1936 | return CXChildVisit_Recurse; |
1937 | } |
1938 | |
1939 | /******************************************************************************/ |
1940 | /* Bitwidth testing. */ |
1941 | /******************************************************************************/ |
1942 | |
1943 | static enum CXChildVisitResult PrintBitWidth(CXCursor cursor, CXCursor p, |
1944 | CXClientData d) { |
1945 | int Bitwidth; |
1946 | if (clang_getCursorKind(cursor) != CXCursor_FieldDecl) |
1947 | return CXChildVisit_Recurse; |
1948 | |
1949 | Bitwidth = clang_getFieldDeclBitWidth(C: cursor); |
1950 | if (Bitwidth >= 0) { |
1951 | PrintCursor(Cursor: cursor, NULL); |
1952 | printf(format: " bitwidth=%d\n", Bitwidth); |
1953 | } |
1954 | |
1955 | return CXChildVisit_Recurse; |
1956 | } |
1957 | |
1958 | /******************************************************************************/ |
1959 | /* Type declaration testing */ |
1960 | /******************************************************************************/ |
1961 | |
1962 | static enum CXChildVisitResult PrintTypeDeclaration(CXCursor cursor, CXCursor p, |
1963 | CXClientData d) { |
1964 | CXCursor typeDeclaration = clang_getTypeDeclaration(T: clang_getCursorType(C: cursor)); |
1965 | |
1966 | if (clang_isDeclaration(typeDeclaration.kind)) { |
1967 | PrintCursor(Cursor: cursor, NULL); |
1968 | PrintTypeAndTypeKind(T: clang_getCursorType(C: typeDeclaration), Format: " [typedeclaration=%s] [typekind=%s]\n"); |
1969 | } |
1970 | |
1971 | return CXChildVisit_Recurse; |
1972 | } |
1973 | |
1974 | /******************************************************************************/ |
1975 | /* Declaration attributes testing */ |
1976 | /******************************************************************************/ |
1977 | |
1978 | static enum CXChildVisitResult PrintDeclAttributes(CXCursor cursor, CXCursor p, |
1979 | CXClientData d) { |
1980 | if (clang_isDeclaration(cursor.kind)) { |
1981 | printf(format: "\n"); |
1982 | PrintCursor(Cursor: cursor, NULL); |
1983 | return CXChildVisit_Recurse; |
1984 | } else if (clang_isAttribute(cursor.kind)) { |
1985 | printf(format: " "); |
1986 | PrintCursor(Cursor: cursor, NULL); |
1987 | } |
1988 | return CXChildVisit_Continue; |
1989 | } |
1990 | |
1991 | /******************************************************************************/ |
1992 | /* Target information testing. */ |
1993 | /******************************************************************************/ |
1994 | |
1995 | static int print_target_info(int argc, const char **argv) { |
1996 | CXIndex Idx; |
1997 | CXTranslationUnit TU; |
1998 | CXTargetInfo TargetInfo; |
1999 | CXString Triple; |
2000 | const char *FileName; |
2001 | enum CXErrorCode Err; |
2002 | int PointerWidth; |
2003 | |
2004 | if (argc == 0) { |
2005 | fprintf(stderr, format: "No filename specified\n"); |
2006 | return 1; |
2007 | } |
2008 | |
2009 | FileName = argv[1]; |
2010 | |
2011 | Idx = clang_createIndex(excludeDeclarationsFromPCH: 0, displayDiagnostics: 1); |
2012 | Err = clang_parseTranslationUnit2(CIdx: Idx, source_filename: FileName, command_line_args: argv, num_command_line_args: argc, NULL, num_unsaved_files: 0, |
2013 | options: getDefaultParsingOptions(), out_TU: &TU); |
2014 | if (Err != CXError_Success) { |
2015 | fprintf(stderr, format: "Couldn't parse translation unit!\n"); |
2016 | describeLibclangFailure(Err); |
2017 | clang_disposeIndex(index: Idx); |
2018 | return 1; |
2019 | } |
2020 | |
2021 | TargetInfo = clang_getTranslationUnitTargetInfo(CTUnit: TU); |
2022 | |
2023 | Triple = clang_TargetInfo_getTriple(Info: TargetInfo); |
2024 | printf(format: "TargetTriple: %s\n", clang_getCString(string: Triple)); |
2025 | clang_disposeString(string: Triple); |
2026 | |
2027 | PointerWidth = clang_TargetInfo_getPointerWidth(Info: TargetInfo); |
2028 | printf(format: "PointerWidth: %d\n", PointerWidth); |
2029 | |
2030 | clang_TargetInfo_dispose(Info: TargetInfo); |
2031 | clang_disposeTranslationUnit(TU); |
2032 | clang_disposeIndex(index: Idx); |
2033 | return 0; |
2034 | } |
2035 | |
2036 | /******************************************************************************/ |
2037 | /* Loading ASTs/source. */ |
2038 | /******************************************************************************/ |
2039 | |
2040 | static int perform_test_load(CXIndex Idx, CXTranslationUnit TU, |
2041 | const char *filter, const char *prefix, |
2042 | CXCursorVisitor Visitor, |
2043 | PostVisitTU PV, |
2044 | const char *CommentSchemaFile) { |
2045 | |
2046 | if (prefix) |
2047 | FileCheckPrefix = prefix; |
2048 | |
2049 | if (Visitor) { |
2050 | enum CXCursorKind K = CXCursor_NotImplemented; |
2051 | enum CXCursorKind *ck = &K; |
2052 | VisitorData Data; |
2053 | |
2054 | /* Perform some simple filtering. */ |
2055 | if (!strcmp(s1: filter, s2: "all") || !strcmp(s1: filter, s2: "local")) ck = NULL; |
2056 | else if (!strcmp(s1: filter, s2: "all-display") || |
2057 | !strcmp(s1: filter, s2: "local-display")) { |
2058 | ck = NULL; |
2059 | wanted_display_type = DisplayType_DisplayName; |
2060 | } |
2061 | else if (!strcmp(s1: filter, s2: "all-pretty") || |
2062 | !strcmp(s1: filter, s2: "local-pretty")) { |
2063 | ck = NULL; |
2064 | wanted_display_type = DisplayType_Pretty; |
2065 | } |
2066 | else if (!strcmp(s1: filter, s2: "none")) K = (enum CXCursorKind) ~0; |
2067 | else if (!strcmp(s1: filter, s2: "category")) K = CXCursor_ObjCCategoryDecl; |
2068 | else if (!strcmp(s1: filter, s2: "interface")) K = CXCursor_ObjCInterfaceDecl; |
2069 | else if (!strcmp(s1: filter, s2: "protocol")) K = CXCursor_ObjCProtocolDecl; |
2070 | else if (!strcmp(s1: filter, s2: "function")) K = CXCursor_FunctionDecl; |
2071 | else if (!strcmp(s1: filter, s2: "typedef")) K = CXCursor_TypedefDecl; |
2072 | else if (!strcmp(s1: filter, s2: "scan-function")) Visitor = FunctionScanVisitor; |
2073 | else { |
2074 | fprintf(stderr, format: "Unknown filter for -test-load-tu: %s\n", filter); |
2075 | return 1; |
2076 | } |
2077 | |
2078 | Data.TU = TU; |
2079 | Data.Filter = ck; |
2080 | Data.CommentSchemaFile = CommentSchemaFile; |
2081 | clang_visitChildren(parent: clang_getTranslationUnitCursor(TU), visitor: Visitor, client_data: &Data); |
2082 | } |
2083 | |
2084 | if (PV) |
2085 | PV(TU); |
2086 | |
2087 | PrintDiagnostics(TU); |
2088 | if (checkForErrors(TU) != 0) { |
2089 | clang_disposeTranslationUnit(TU); |
2090 | return -1; |
2091 | } |
2092 | |
2093 | clang_disposeTranslationUnit(TU); |
2094 | return 0; |
2095 | } |
2096 | |
2097 | int perform_test_load_tu(const char *file, const char *filter, |
2098 | const char *prefix, CXCursorVisitor Visitor, |
2099 | PostVisitTU PV) { |
2100 | CXIndex Idx; |
2101 | CXTranslationUnit TU; |
2102 | int result; |
2103 | Idx = clang_createIndex(/* excludeDeclsFromPCH */ |
2104 | excludeDeclarationsFromPCH: !strcmp(s1: filter, s2: "local") ? 1 : 0, |
2105 | /* displayDiagnostics=*/1); |
2106 | |
2107 | if (!CreateTranslationUnit(Idx, file, TU: &TU)) { |
2108 | clang_disposeIndex(index: Idx); |
2109 | return 1; |
2110 | } |
2111 | |
2112 | result = perform_test_load(Idx, TU, filter, prefix, Visitor, PV, NULL); |
2113 | clang_disposeIndex(index: Idx); |
2114 | return result; |
2115 | } |
2116 | |
2117 | int perform_test_load_source(int argc, const char **argv, |
2118 | const char *filter, CXCursorVisitor Visitor, |
2119 | PostVisitTU PV) { |
2120 | CXIndex Idx; |
2121 | CXTranslationUnit TU; |
2122 | const char *CommentSchemaFile; |
2123 | struct CXUnsavedFile *unsaved_files = 0; |
2124 | int num_unsaved_files = 0; |
2125 | enum CXErrorCode Err; |
2126 | int result; |
2127 | unsigned Repeats = 0; |
2128 | unsigned I; |
2129 | |
2130 | Idx = |
2131 | createIndexWithInvocationEmissionPath(/* excludeDeclsFromPCH */ |
2132 | ExcludeDeclarationsFromPCH: (!strcmp(s1: filter, s2: "local") || |
2133 | !strcmp(s1: filter, s2: "local-display") || |
2134 | !strcmp(s1: filter, s2: "local-pretty")) |
2135 | ? 1 |
2136 | : 0, |
2137 | /* displayDiagnostics=*/DisplayDiagnostics: 1); |
2138 | if (!Idx) |
2139 | return -1; |
2140 | |
2141 | if ((CommentSchemaFile = parse_comments_schema(argc, argv))) { |
2142 | argc--; |
2143 | argv++; |
2144 | } |
2145 | |
2146 | if (parse_remapped_files(argc, argv, start_arg: 0, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
2147 | clang_disposeIndex(index: Idx); |
2148 | return -1; |
2149 | } |
2150 | |
2151 | if (getenv(name: "CINDEXTEST_EDITING")) |
2152 | Repeats = 5; |
2153 | |
2154 | Err = clang_parseTranslationUnit2(CIdx: Idx, source_filename: 0, |
2155 | command_line_args: argv + num_unsaved_files, |
2156 | num_command_line_args: argc - num_unsaved_files, |
2157 | unsaved_files, num_unsaved_files, |
2158 | options: getDefaultParsingOptions(), out_TU: &TU); |
2159 | if (Err != CXError_Success) { |
2160 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
2161 | describeLibclangFailure(Err); |
2162 | free_remapped_files(unsaved_files, num_unsaved_files); |
2163 | clang_disposeIndex(index: Idx); |
2164 | return 1; |
2165 | } |
2166 | |
2167 | for (I = 0; I != Repeats; ++I) { |
2168 | if (checkForErrors(TU) != 0) |
2169 | return -1; |
2170 | |
2171 | if (Repeats > 1) { |
2172 | clang_suspendTranslationUnit(TU); |
2173 | |
2174 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, |
2175 | options: clang_defaultReparseOptions(TU)); |
2176 | if (Err != CXError_Success) { |
2177 | describeLibclangFailure(Err); |
2178 | free_remapped_files(unsaved_files, num_unsaved_files); |
2179 | clang_disposeIndex(index: Idx); |
2180 | return 1; |
2181 | } |
2182 | } |
2183 | } |
2184 | |
2185 | result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV, |
2186 | CommentSchemaFile); |
2187 | free_remapped_files(unsaved_files, num_unsaved_files); |
2188 | clang_disposeIndex(index: Idx); |
2189 | return result; |
2190 | } |
2191 | |
2192 | int perform_test_reparse_source(int argc, const char **argv, int trials, |
2193 | const char *filter, CXCursorVisitor Visitor, |
2194 | PostVisitTU PV) { |
2195 | CXIndex Idx; |
2196 | CXTranslationUnit TU; |
2197 | struct CXUnsavedFile *unsaved_files = 0; |
2198 | int num_unsaved_files = 0; |
2199 | int compiler_arg_idx = 0; |
2200 | enum CXErrorCode Err; |
2201 | int result, i; |
2202 | int trial; |
2203 | int execute_after_trial = 0; |
2204 | const char *execute_command = NULL; |
2205 | int remap_after_trial = 0; |
2206 | char *endptr = 0; |
2207 | |
2208 | Idx = clang_createIndex(/* excludeDeclsFromPCH */ |
2209 | excludeDeclarationsFromPCH: !strcmp(s1: filter, s2: "local") ? 1 : 0, |
2210 | /* displayDiagnostics=*/1); |
2211 | |
2212 | if (parse_remapped_files(argc, argv, start_arg: 0, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
2213 | clang_disposeIndex(index: Idx); |
2214 | return -1; |
2215 | } |
2216 | |
2217 | for (i = 0; i < argc; ++i) { |
2218 | if (strcmp(s1: argv[i], s2: "--") == 0) |
2219 | break; |
2220 | } |
2221 | if (i < argc) |
2222 | compiler_arg_idx = i+1; |
2223 | if (num_unsaved_files > compiler_arg_idx) |
2224 | compiler_arg_idx = num_unsaved_files; |
2225 | |
2226 | /* Load the initial translation unit -- we do this without honoring remapped |
2227 | * files, so that we have a way to test results after changing the source. */ |
2228 | Err = clang_parseTranslationUnit2(CIdx: Idx, source_filename: 0, |
2229 | command_line_args: argv + compiler_arg_idx, |
2230 | num_command_line_args: argc - compiler_arg_idx, |
2231 | unsaved_files: 0, num_unsaved_files: 0, options: getDefaultParsingOptions(), out_TU: &TU); |
2232 | if (Err != CXError_Success) { |
2233 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
2234 | describeLibclangFailure(Err); |
2235 | free_remapped_files(unsaved_files, num_unsaved_files); |
2236 | clang_disposeIndex(index: Idx); |
2237 | return 1; |
2238 | } |
2239 | |
2240 | if (checkForErrors(TU) != 0) |
2241 | return -1; |
2242 | |
2243 | if (getenv(name: "CINDEXTEST_EXECUTE_COMMAND")) { |
2244 | execute_command = getenv(name: "CINDEXTEST_EXECUTE_COMMAND"); |
2245 | } |
2246 | if (getenv(name: "CINDEXTEST_EXECUTE_AFTER_TRIAL")) { |
2247 | execute_after_trial = |
2248 | strtol(nptr: getenv(name: "CINDEXTEST_EXECUTE_AFTER_TRIAL"), endptr: &endptr, base: 10); |
2249 | } |
2250 | |
2251 | if (getenv(name: "CINDEXTEST_REMAP_AFTER_TRIAL")) { |
2252 | remap_after_trial = |
2253 | strtol(nptr: getenv(name: "CINDEXTEST_REMAP_AFTER_TRIAL"), endptr: &endptr, base: 10); |
2254 | } |
2255 | |
2256 | for (trial = 0; trial < trials; ++trial) { |
2257 | if (execute_command && trial == execute_after_trial) { |
2258 | result = indextest_perform_shell_execution(command_line: execute_command); |
2259 | if (result != 0) |
2260 | return result; |
2261 | } |
2262 | |
2263 | free_remapped_files(unsaved_files, num_unsaved_files); |
2264 | if (parse_remapped_files_with_try(try_idx: trial, argc, argv, start_arg: 0, |
2265 | unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
2266 | clang_disposeTranslationUnit(TU); |
2267 | clang_disposeIndex(index: Idx); |
2268 | return -1; |
2269 | } |
2270 | |
2271 | Err = clang_reparseTranslationUnit( |
2272 | TU, |
2273 | num_unsaved_files: trial >= remap_after_trial ? num_unsaved_files : 0, |
2274 | unsaved_files: trial >= remap_after_trial ? unsaved_files : 0, |
2275 | options: clang_defaultReparseOptions(TU)); |
2276 | if (Err != CXError_Success) { |
2277 | fprintf(stderr, format: "Unable to reparse translation unit!\n"); |
2278 | describeLibclangFailure(Err); |
2279 | clang_disposeTranslationUnit(TU); |
2280 | free_remapped_files(unsaved_files, num_unsaved_files); |
2281 | clang_disposeIndex(index: Idx); |
2282 | return -1; |
2283 | } |
2284 | |
2285 | if (checkForErrors(TU) != 0) |
2286 | return -1; |
2287 | } |
2288 | |
2289 | result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV, NULL); |
2290 | |
2291 | free_remapped_files(unsaved_files, num_unsaved_files); |
2292 | clang_disposeIndex(index: Idx); |
2293 | return result; |
2294 | } |
2295 | |
2296 | static int perform_single_file_parse(const char *filename) { |
2297 | CXIndex Idx; |
2298 | CXTranslationUnit TU; |
2299 | enum CXErrorCode Err; |
2300 | int result; |
2301 | |
2302 | Idx = clang_createIndex(/* excludeDeclsFromPCH */excludeDeclarationsFromPCH: 1, |
2303 | /* displayDiagnostics=*/1); |
2304 | |
2305 | Err = clang_parseTranslationUnit2(CIdx: Idx, source_filename: filename, |
2306 | /*command_line_args=*/NULL, |
2307 | /*num_command_line_args=*/0, |
2308 | /*unsaved_files=*/NULL, |
2309 | /*num_unsaved_files=*/0, |
2310 | options: CXTranslationUnit_SingleFileParse, out_TU: &TU); |
2311 | if (Err != CXError_Success) { |
2312 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
2313 | describeLibclangFailure(Err); |
2314 | clang_disposeIndex(index: Idx); |
2315 | return 1; |
2316 | } |
2317 | |
2318 | result = perform_test_load(Idx, TU, /*filter=*/"all", /*prefix=*/NULL, Visitor: FilteredPrintingVisitor, /*PostVisit=*/NULL, |
2319 | /*CommentSchemaFile=*/NULL); |
2320 | clang_disposeIndex(index: Idx); |
2321 | return result; |
2322 | } |
2323 | |
2324 | static int perform_file_retain_excluded_cb(const char *filename) { |
2325 | CXIndex Idx; |
2326 | CXTranslationUnit TU; |
2327 | enum CXErrorCode Err; |
2328 | int result; |
2329 | |
2330 | Idx = clang_createIndex(/* excludeDeclsFromPCH */excludeDeclarationsFromPCH: 1, |
2331 | /* displayDiagnostics=*/1); |
2332 | |
2333 | Err = clang_parseTranslationUnit2(CIdx: Idx, source_filename: filename, |
2334 | /*command_line_args=*/NULL, |
2335 | /*num_command_line_args=*/0, |
2336 | /*unsaved_files=*/NULL, |
2337 | /*num_unsaved_files=*/0, |
2338 | options: CXTranslationUnit_RetainExcludedConditionalBlocks, out_TU: &TU); |
2339 | if (Err != CXError_Success) { |
2340 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
2341 | describeLibclangFailure(Err); |
2342 | clang_disposeIndex(index: Idx); |
2343 | return 1; |
2344 | } |
2345 | |
2346 | result = perform_test_load(Idx, TU, /*filter=*/"all", /*prefix=*/NULL, Visitor: FilteredPrintingVisitor, /*PostVisit=*/NULL, |
2347 | /*CommentSchemaFile=*/NULL); |
2348 | clang_disposeIndex(index: Idx); |
2349 | return result; |
2350 | } |
2351 | |
2352 | /******************************************************************************/ |
2353 | /* Logic for testing clang_getCursor(). */ |
2354 | /******************************************************************************/ |
2355 | |
2356 | static void print_cursor_file_scan(CXTranslationUnit TU, CXCursor cursor, |
2357 | unsigned start_line, unsigned start_col, |
2358 | unsigned end_line, unsigned end_col, |
2359 | const char *prefix) { |
2360 | printf(format: "// %s: ", FileCheckPrefix); |
2361 | if (prefix) |
2362 | printf(format: "-%s", prefix); |
2363 | PrintExtent(stdout, begin_line: start_line, begin_column: start_col, end_line, end_column: end_col); |
2364 | printf(format: " "); |
2365 | PrintCursor(Cursor: cursor, NULL); |
2366 | printf(format: "\n"); |
2367 | } |
2368 | |
2369 | static int perform_file_scan(const char *ast_file, const char *source_file, |
2370 | const char *prefix) { |
2371 | CXIndex Idx; |
2372 | CXTranslationUnit TU; |
2373 | FILE *fp; |
2374 | CXCursor prevCursor = clang_getNullCursor(); |
2375 | CXFile file; |
2376 | unsigned line = 1, col = 1; |
2377 | unsigned start_line = 1, start_col = 1; |
2378 | |
2379 | if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ excludeDeclarationsFromPCH: 1, |
2380 | /* displayDiagnostics=*/1))) { |
2381 | fprintf(stderr, format: "Could not create Index\n"); |
2382 | return 1; |
2383 | } |
2384 | |
2385 | if (!CreateTranslationUnit(Idx, file: ast_file, TU: &TU)) |
2386 | return 1; |
2387 | |
2388 | if ((fp = fopen(filename: source_file, modes: "r")) == NULL) { |
2389 | fprintf(stderr, format: "Could not open '%s'\n", source_file); |
2390 | clang_disposeTranslationUnit(TU); |
2391 | return 1; |
2392 | } |
2393 | |
2394 | file = clang_getFile(tu: TU, file_name: source_file); |
2395 | for (;;) { |
2396 | CXCursor cursor; |
2397 | int c = fgetc(stream: fp); |
2398 | |
2399 | if (c == '\n') { |
2400 | ++line; |
2401 | col = 1; |
2402 | } else |
2403 | ++col; |
2404 | |
2405 | /* Check the cursor at this position, and dump the previous one if we have |
2406 | * found something new. |
2407 | */ |
2408 | cursor = clang_getCursor(TU, clang_getLocation(tu: TU, file, line, column: col)); |
2409 | if ((c == EOF || !clang_equalCursors(cursor, prevCursor)) && |
2410 | prevCursor.kind != CXCursor_InvalidFile) { |
2411 | print_cursor_file_scan(TU, cursor: prevCursor, start_line, start_col, |
2412 | end_line: line, end_col: col, prefix); |
2413 | start_line = line; |
2414 | start_col = col; |
2415 | } |
2416 | if (c == EOF) |
2417 | break; |
2418 | |
2419 | prevCursor = cursor; |
2420 | } |
2421 | |
2422 | fclose(stream: fp); |
2423 | clang_disposeTranslationUnit(TU); |
2424 | clang_disposeIndex(index: Idx); |
2425 | return 0; |
2426 | } |
2427 | |
2428 | /******************************************************************************/ |
2429 | /* Logic for testing clang code completion. */ |
2430 | /******************************************************************************/ |
2431 | |
2432 | /* Parse file:line:column from the input string. Returns 0 on success, non-zero |
2433 | on failure. If successful, the pointer *filename will contain newly-allocated |
2434 | memory (that will be owned by the caller) to store the file name. */ |
2435 | int parse_file_line_column(const char *input, char **filename, unsigned *line, |
2436 | unsigned *column, unsigned *second_line, |
2437 | unsigned *second_column) { |
2438 | /* Find the second colon. */ |
2439 | const char *last_colon = strrchr(s: input, c: ':'); |
2440 | unsigned values[4], i; |
2441 | unsigned num_values = (second_line && second_column)? 4 : 2; |
2442 | |
2443 | char *endptr = 0; |
2444 | if (!last_colon || last_colon == input) { |
2445 | if (num_values == 4) |
2446 | fprintf(stderr, format: "could not parse filename:line:column:line:column in " |
2447 | "'%s'\n", input); |
2448 | else |
2449 | fprintf(stderr, format: "could not parse filename:line:column in '%s'\n", input); |
2450 | return 1; |
2451 | } |
2452 | |
2453 | for (i = 0; i != num_values; ++i) { |
2454 | const char *prev_colon; |
2455 | |
2456 | /* Parse the next line or column. */ |
2457 | values[num_values - i - 1] = strtol(nptr: last_colon + 1, endptr: &endptr, base: 10); |
2458 | if (*endptr != 0 && *endptr != ':') { |
2459 | fprintf(stderr, format: "could not parse %s in '%s'\n", |
2460 | (i % 2 ? "column": "line"), input); |
2461 | return 1; |
2462 | } |
2463 | |
2464 | if (i + 1 == num_values) |
2465 | break; |
2466 | |
2467 | /* Find the previous colon. */ |
2468 | prev_colon = last_colon - 1; |
2469 | while (prev_colon != input && *prev_colon != ':') |
2470 | --prev_colon; |
2471 | if (prev_colon == input) { |
2472 | fprintf(stderr, format: "could not parse %s in '%s'\n", |
2473 | (i % 2 == 0? "column": "line"), input); |
2474 | return 1; |
2475 | } |
2476 | |
2477 | last_colon = prev_colon; |
2478 | } |
2479 | |
2480 | *line = values[0]; |
2481 | *column = values[1]; |
2482 | |
2483 | if (second_line && second_column) { |
2484 | *second_line = values[2]; |
2485 | *second_column = values[3]; |
2486 | } |
2487 | |
2488 | /* Copy the file name. */ |
2489 | *filename = (char*)malloc(size: last_colon - input + 1); |
2490 | assert(*filename); |
2491 | memcpy(dest: *filename, src: input, n: last_colon - input); |
2492 | (*filename)[last_colon - input] = 0; |
2493 | return 0; |
2494 | } |
2495 | |
2496 | const char * |
2497 | clang_getCompletionChunkKindSpelling(enum CXCompletionChunkKind Kind) { |
2498 | switch (Kind) { |
2499 | case CXCompletionChunk_Optional: return "Optional"; |
2500 | case CXCompletionChunk_TypedText: return "TypedText"; |
2501 | case CXCompletionChunk_Text: return "Text"; |
2502 | case CXCompletionChunk_Placeholder: return "Placeholder"; |
2503 | case CXCompletionChunk_Informative: return "Informative"; |
2504 | case CXCompletionChunk_CurrentParameter: return "CurrentParameter"; |
2505 | case CXCompletionChunk_LeftParen: return "LeftParen"; |
2506 | case CXCompletionChunk_RightParen: return "RightParen"; |
2507 | case CXCompletionChunk_LeftBracket: return "LeftBracket"; |
2508 | case CXCompletionChunk_RightBracket: return "RightBracket"; |
2509 | case CXCompletionChunk_LeftBrace: return "LeftBrace"; |
2510 | case CXCompletionChunk_RightBrace: return "RightBrace"; |
2511 | case CXCompletionChunk_LeftAngle: return "LeftAngle"; |
2512 | case CXCompletionChunk_RightAngle: return "RightAngle"; |
2513 | case CXCompletionChunk_Comma: return "Comma"; |
2514 | case CXCompletionChunk_ResultType: return "ResultType"; |
2515 | case CXCompletionChunk_Colon: return "Colon"; |
2516 | case CXCompletionChunk_SemiColon: return "SemiColon"; |
2517 | case CXCompletionChunk_Equal: return "Equal"; |
2518 | case CXCompletionChunk_HorizontalSpace: return "HorizontalSpace"; |
2519 | case CXCompletionChunk_VerticalSpace: return "VerticalSpace"; |
2520 | } |
2521 | |
2522 | return "Unknown"; |
2523 | } |
2524 | |
2525 | static int checkForErrors(CXTranslationUnit TU) { |
2526 | unsigned Num, i; |
2527 | CXDiagnostic Diag; |
2528 | CXString DiagStr; |
2529 | |
2530 | if (!getenv(name: "CINDEXTEST_FAILONERROR")) |
2531 | return 0; |
2532 | |
2533 | Num = clang_getNumDiagnostics(Unit: TU); |
2534 | for (i = 0; i != Num; ++i) { |
2535 | Diag = clang_getDiagnostic(Unit: TU, Index: i); |
2536 | if (clang_getDiagnosticSeverity(Diag) >= CXDiagnostic_Error) { |
2537 | DiagStr = clang_formatDiagnostic(Diagnostic: Diag, |
2538 | Options: clang_defaultDiagnosticDisplayOptions()); |
2539 | fprintf(stderr, format: "%s\n", clang_getCString(string: DiagStr)); |
2540 | clang_disposeString(string: DiagStr); |
2541 | clang_disposeDiagnostic(Diagnostic: Diag); |
2542 | return -1; |
2543 | } |
2544 | clang_disposeDiagnostic(Diagnostic: Diag); |
2545 | } |
2546 | |
2547 | return 0; |
2548 | } |
2549 | |
2550 | static void print_completion_string(CXCompletionString completion_string, |
2551 | FILE *file) { |
2552 | int I, N; |
2553 | |
2554 | N = clang_getNumCompletionChunks(completion_string); |
2555 | for (I = 0; I != N; ++I) { |
2556 | CXString text; |
2557 | const char *cstr; |
2558 | enum CXCompletionChunkKind Kind |
2559 | = clang_getCompletionChunkKind(completion_string, chunk_number: I); |
2560 | |
2561 | if (Kind == CXCompletionChunk_Optional) { |
2562 | fprintf(stream: file, format: "{Optional "); |
2563 | print_completion_string( |
2564 | completion_string: clang_getCompletionChunkCompletionString(completion_string, chunk_number: I), |
2565 | file); |
2566 | fprintf(stream: file, format: "}"); |
2567 | continue; |
2568 | } |
2569 | |
2570 | if (Kind == CXCompletionChunk_VerticalSpace) { |
2571 | fprintf(stream: file, format: "{VerticalSpace }"); |
2572 | continue; |
2573 | } |
2574 | |
2575 | text = clang_getCompletionChunkText(completion_string, chunk_number: I); |
2576 | cstr = clang_getCString(string: text); |
2577 | fprintf(stream: file, format: "{%s %s}", |
2578 | clang_getCompletionChunkKindSpelling(Kind), |
2579 | cstr ? cstr : ""); |
2580 | clang_disposeString(string: text); |
2581 | } |
2582 | |
2583 | } |
2584 | |
2585 | static void print_line_column(CXSourceLocation location, FILE *file) { |
2586 | unsigned line, column; |
2587 | clang_getExpansionLocation(location, NULL, line: &line, column: &column, NULL); |
2588 | fprintf(stream: file, format: "%d:%d", line, column); |
2589 | } |
2590 | |
2591 | static void print_token_range(CXTranslationUnit translation_unit, |
2592 | CXSourceLocation start, FILE *file) { |
2593 | CXToken *token = clang_getToken(TU: translation_unit, Location: start); |
2594 | |
2595 | fprintf(stream: file, format: "{"); |
2596 | if (token != NULL) { |
2597 | CXSourceRange token_range = clang_getTokenExtent(translation_unit, *token); |
2598 | print_line_column(location: clang_getRangeStart(range: token_range), file); |
2599 | fprintf(stream: file, format: "-"); |
2600 | print_line_column(location: clang_getRangeEnd(range: token_range), file); |
2601 | clang_disposeTokens(TU: translation_unit, Tokens: token, NumTokens: 1); |
2602 | } |
2603 | |
2604 | fprintf(stream: file, format: "}"); |
2605 | } |
2606 | |
2607 | static void print_completion_result(CXTranslationUnit translation_unit, |
2608 | CXCodeCompleteResults *completion_results, |
2609 | unsigned index, |
2610 | FILE *file) { |
2611 | CXCompletionResult *completion_result = completion_results->Results + index; |
2612 | CXString ks = clang_getCursorKindSpelling(Kind: completion_result->CursorKind); |
2613 | unsigned annotationCount; |
2614 | enum CXCursorKind ParentKind; |
2615 | CXString ParentName; |
2616 | CXString BriefComment; |
2617 | CXString Annotation; |
2618 | const char *BriefCommentCString; |
2619 | unsigned i; |
2620 | |
2621 | fprintf(stream: file, format: "%s:", clang_getCString(string: ks)); |
2622 | clang_disposeString(string: ks); |
2623 | |
2624 | print_completion_string(completion_string: completion_result->CompletionString, file); |
2625 | fprintf(stream: file, format: " (%u)", |
2626 | clang_getCompletionPriority(completion_string: completion_result->CompletionString)); |
2627 | switch (clang_getCompletionAvailability(completion_string: completion_result->CompletionString)){ |
2628 | case CXAvailability_Available: |
2629 | break; |
2630 | |
2631 | case CXAvailability_Deprecated: |
2632 | fprintf(stream: file, format: " (deprecated)"); |
2633 | break; |
2634 | |
2635 | case CXAvailability_NotAvailable: |
2636 | fprintf(stream: file, format: " (unavailable)"); |
2637 | break; |
2638 | |
2639 | case CXAvailability_NotAccessible: |
2640 | fprintf(stream: file, format: " (inaccessible)"); |
2641 | break; |
2642 | } |
2643 | |
2644 | annotationCount = clang_getCompletionNumAnnotations( |
2645 | completion_string: completion_result->CompletionString); |
2646 | if (annotationCount) { |
2647 | unsigned i; |
2648 | fprintf(stream: file, format: " ("); |
2649 | for (i = 0; i < annotationCount; ++i) { |
2650 | if (i != 0) |
2651 | fprintf(stream: file, format: ", "); |
2652 | Annotation = |
2653 | clang_getCompletionAnnotation(completion_string: completion_result->CompletionString, annotation_number: i); |
2654 | fprintf(stream: file, format: "\"%s\"", clang_getCString(string: Annotation)); |
2655 | clang_disposeString(string: Annotation); |
2656 | } |
2657 | fprintf(stream: file, format: ")"); |
2658 | } |
2659 | |
2660 | if (!getenv(name: "CINDEXTEST_NO_COMPLETION_PARENTS")) { |
2661 | ParentName = clang_getCompletionParent(completion_string: completion_result->CompletionString, |
2662 | kind: &ParentKind); |
2663 | if (ParentKind != CXCursor_NotImplemented) { |
2664 | CXString KindSpelling = clang_getCursorKindSpelling(Kind: ParentKind); |
2665 | fprintf(stream: file, format: " (parent: %s '%s')", |
2666 | clang_getCString(string: KindSpelling), |
2667 | clang_getCString(string: ParentName)); |
2668 | clang_disposeString(string: KindSpelling); |
2669 | } |
2670 | clang_disposeString(string: ParentName); |
2671 | } |
2672 | |
2673 | BriefComment = clang_getCompletionBriefComment( |
2674 | completion_string: completion_result->CompletionString); |
2675 | BriefCommentCString = clang_getCString(string: BriefComment); |
2676 | if (BriefCommentCString && *BriefCommentCString != '\0') { |
2677 | fprintf(stream: file, format: "(brief comment: %s)", BriefCommentCString); |
2678 | } |
2679 | clang_disposeString(string: BriefComment); |
2680 | |
2681 | for (i = 0; i < clang_getCompletionNumFixIts(results: completion_results, completion_index: index); |
2682 | ++i) { |
2683 | CXSourceRange correction_range; |
2684 | CXString FixIt = clang_getCompletionFixIt(results: completion_results, completion_index: index, fixit_index: i, |
2685 | replacement_range: &correction_range); |
2686 | fprintf(stream: file, format: " (requires fix-it: "); |
2687 | print_token_range(translation_unit, start: clang_getRangeStart(range: correction_range), |
2688 | file); |
2689 | fprintf(stream: file, format: " to \"%s\")", clang_getCString(string: FixIt)); |
2690 | clang_disposeString(string: FixIt); |
2691 | } |
2692 | |
2693 | fprintf(stream: file, format: "\n"); |
2694 | } |
2695 | |
2696 | void print_completion_contexts(unsigned long long contexts, FILE *file) { |
2697 | fprintf(stream: file, format: "Completion contexts:\n"); |
2698 | if (contexts == CXCompletionContext_Unknown) { |
2699 | fprintf(stream: file, format: "Unknown\n"); |
2700 | } |
2701 | if (contexts & CXCompletionContext_AnyType) { |
2702 | fprintf(stream: file, format: "Any type\n"); |
2703 | } |
2704 | if (contexts & CXCompletionContext_AnyValue) { |
2705 | fprintf(stream: file, format: "Any value\n"); |
2706 | } |
2707 | if (contexts & CXCompletionContext_ObjCObjectValue) { |
2708 | fprintf(stream: file, format: "Objective-C object value\n"); |
2709 | } |
2710 | if (contexts & CXCompletionContext_ObjCSelectorValue) { |
2711 | fprintf(stream: file, format: "Objective-C selector value\n"); |
2712 | } |
2713 | if (contexts & CXCompletionContext_CXXClassTypeValue) { |
2714 | fprintf(stream: file, format: "C++ class type value\n"); |
2715 | } |
2716 | if (contexts & CXCompletionContext_DotMemberAccess) { |
2717 | fprintf(stream: file, format: "Dot member access\n"); |
2718 | } |
2719 | if (contexts & CXCompletionContext_ArrowMemberAccess) { |
2720 | fprintf(stream: file, format: "Arrow member access\n"); |
2721 | } |
2722 | if (contexts & CXCompletionContext_ObjCPropertyAccess) { |
2723 | fprintf(stream: file, format: "Objective-C property access\n"); |
2724 | } |
2725 | if (contexts & CXCompletionContext_EnumTag) { |
2726 | fprintf(stream: file, format: "Enum tag\n"); |
2727 | } |
2728 | if (contexts & CXCompletionContext_UnionTag) { |
2729 | fprintf(stream: file, format: "Union tag\n"); |
2730 | } |
2731 | if (contexts & CXCompletionContext_StructTag) { |
2732 | fprintf(stream: file, format: "Struct tag\n"); |
2733 | } |
2734 | if (contexts & CXCompletionContext_ClassTag) { |
2735 | fprintf(stream: file, format: "Class name\n"); |
2736 | } |
2737 | if (contexts & CXCompletionContext_Namespace) { |
2738 | fprintf(stream: file, format: "Namespace or namespace alias\n"); |
2739 | } |
2740 | if (contexts & CXCompletionContext_NestedNameSpecifier) { |
2741 | fprintf(stream: file, format: "Nested name specifier\n"); |
2742 | } |
2743 | if (contexts & CXCompletionContext_ObjCInterface) { |
2744 | fprintf(stream: file, format: "Objective-C interface\n"); |
2745 | } |
2746 | if (contexts & CXCompletionContext_ObjCProtocol) { |
2747 | fprintf(stream: file, format: "Objective-C protocol\n"); |
2748 | } |
2749 | if (contexts & CXCompletionContext_ObjCCategory) { |
2750 | fprintf(stream: file, format: "Objective-C category\n"); |
2751 | } |
2752 | if (contexts & CXCompletionContext_ObjCInstanceMessage) { |
2753 | fprintf(stream: file, format: "Objective-C instance method\n"); |
2754 | } |
2755 | if (contexts & CXCompletionContext_ObjCClassMessage) { |
2756 | fprintf(stream: file, format: "Objective-C class method\n"); |
2757 | } |
2758 | if (contexts & CXCompletionContext_ObjCSelectorName) { |
2759 | fprintf(stream: file, format: "Objective-C selector name\n"); |
2760 | } |
2761 | if (contexts & CXCompletionContext_MacroName) { |
2762 | fprintf(stream: file, format: "Macro name\n"); |
2763 | } |
2764 | if (contexts & CXCompletionContext_NaturalLanguage) { |
2765 | fprintf(stream: file, format: "Natural language\n"); |
2766 | } |
2767 | } |
2768 | |
2769 | int perform_code_completion(int argc, const char **argv, int timing_only) { |
2770 | const char *input = argv[1]; |
2771 | char *filename = 0; |
2772 | unsigned line; |
2773 | unsigned column; |
2774 | CXIndex CIdx; |
2775 | int errorCode; |
2776 | struct CXUnsavedFile *unsaved_files = 0; |
2777 | int num_unsaved_files = 0; |
2778 | CXCodeCompleteResults *results = 0; |
2779 | enum CXErrorCode Err; |
2780 | CXTranslationUnit TU; |
2781 | unsigned I, Repeats = 1; |
2782 | unsigned completionOptions = clang_defaultCodeCompleteOptions(); |
2783 | |
2784 | if (getenv(name: "CINDEXTEST_CODE_COMPLETE_PATTERNS")) |
2785 | completionOptions |= CXCodeComplete_IncludeCodePatterns; |
2786 | if (getenv(name: "CINDEXTEST_COMPLETION_BRIEF_COMMENTS")) |
2787 | completionOptions |= CXCodeComplete_IncludeBriefComments; |
2788 | if (getenv(name: "CINDEXTEST_COMPLETION_SKIP_PREAMBLE")) |
2789 | completionOptions |= CXCodeComplete_SkipPreamble; |
2790 | if (getenv(name: "CINDEXTEST_COMPLETION_INCLUDE_FIXITS")) |
2791 | completionOptions |= CXCodeComplete_IncludeCompletionsWithFixIts; |
2792 | |
2793 | if (timing_only) |
2794 | input += strlen(s: "-code-completion-timing="); |
2795 | else |
2796 | input += strlen(s: "-code-completion-at="); |
2797 | |
2798 | if ((errorCode = parse_file_line_column(input, filename: &filename, line: &line, column: &column, |
2799 | second_line: 0, second_column: 0))) |
2800 | return errorCode; |
2801 | |
2802 | if (parse_remapped_files(argc, argv, start_arg: 2, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) |
2803 | return -1; |
2804 | |
2805 | CIdx = createIndexWithInvocationEmissionPath(ExcludeDeclarationsFromPCH: 0, DisplayDiagnostics: 0); |
2806 | if (!CIdx) |
2807 | return -1; |
2808 | |
2809 | if (getenv(name: "CINDEXTEST_EDITING")) |
2810 | Repeats = 5; |
2811 | |
2812 | Err = clang_parseTranslationUnit2(CIdx, source_filename: 0, |
2813 | command_line_args: argv + num_unsaved_files + 2, |
2814 | num_command_line_args: argc - num_unsaved_files - 2, |
2815 | unsaved_files: 0, num_unsaved_files: 0, options: getDefaultParsingOptions(), out_TU: &TU); |
2816 | if (Err != CXError_Success) { |
2817 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
2818 | describeLibclangFailure(Err); |
2819 | return 1; |
2820 | } |
2821 | |
2822 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files: 0, unsaved_files: 0, |
2823 | options: clang_defaultReparseOptions(TU)); |
2824 | |
2825 | if (Err != CXError_Success) { |
2826 | fprintf(stderr, format: "Unable to reparse translation unit!\n"); |
2827 | describeLibclangFailure(Err); |
2828 | clang_disposeTranslationUnit(TU); |
2829 | return 1; |
2830 | } |
2831 | |
2832 | for (I = 0; I != Repeats; ++I) { |
2833 | results = clang_codeCompleteAt(TU, complete_filename: filename, complete_line: line, complete_column: column, |
2834 | unsaved_files, num_unsaved_files, |
2835 | options: completionOptions); |
2836 | if (!results) { |
2837 | fprintf(stderr, format: "Unable to perform code completion!\n"); |
2838 | return 1; |
2839 | } |
2840 | if (I != Repeats-1) |
2841 | clang_disposeCodeCompleteResults(Results: results); |
2842 | } |
2843 | |
2844 | if (results) { |
2845 | unsigned i, n = results->NumResults, containerIsIncomplete = 0; |
2846 | unsigned long long contexts; |
2847 | enum CXCursorKind containerKind; |
2848 | CXString objCSelector; |
2849 | const char *selectorString; |
2850 | if (!timing_only) { |
2851 | /* Sort the code-completion results based on the typed text. */ |
2852 | clang_sortCodeCompletionResults(Results: results->Results, NumResults: results->NumResults); |
2853 | |
2854 | for (i = 0; i != n; ++i) |
2855 | print_completion_result(translation_unit: TU, completion_results: results, index: i, stdout); |
2856 | } |
2857 | n = clang_codeCompleteGetNumDiagnostics(Results: results); |
2858 | for (i = 0; i != n; ++i) { |
2859 | CXDiagnostic diag = clang_codeCompleteGetDiagnostic(Results: results, Index: i); |
2860 | PrintDiagnostic(Diagnostic: diag); |
2861 | clang_disposeDiagnostic(Diagnostic: diag); |
2862 | } |
2863 | |
2864 | contexts = clang_codeCompleteGetContexts(Results: results); |
2865 | print_completion_contexts(contexts, stdout); |
2866 | |
2867 | containerKind = clang_codeCompleteGetContainerKind(Results: results, |
2868 | IsIncomplete: &containerIsIncomplete); |
2869 | |
2870 | if (containerKind != CXCursor_InvalidCode) { |
2871 | /* We have found a container */ |
2872 | CXString containerUSR, containerKindSpelling; |
2873 | containerKindSpelling = clang_getCursorKindSpelling(Kind: containerKind); |
2874 | printf(format: "Container Kind: %s\n", clang_getCString(string: containerKindSpelling)); |
2875 | clang_disposeString(string: containerKindSpelling); |
2876 | |
2877 | if (containerIsIncomplete) { |
2878 | printf(format: "Container is incomplete\n"); |
2879 | } |
2880 | else { |
2881 | printf(format: "Container is complete\n"); |
2882 | } |
2883 | |
2884 | containerUSR = clang_codeCompleteGetContainerUSR(Results: results); |
2885 | printf(format: "Container USR: %s\n", clang_getCString(string: containerUSR)); |
2886 | clang_disposeString(string: containerUSR); |
2887 | } |
2888 | |
2889 | objCSelector = clang_codeCompleteGetObjCSelector(Results: results); |
2890 | selectorString = clang_getCString(string: objCSelector); |
2891 | if (selectorString && strlen(s: selectorString) > 0) { |
2892 | printf(format: "Objective-C selector: %s\n", selectorString); |
2893 | } |
2894 | clang_disposeString(string: objCSelector); |
2895 | |
2896 | clang_disposeCodeCompleteResults(Results: results); |
2897 | } |
2898 | clang_disposeTranslationUnit(TU); |
2899 | clang_disposeIndex(index: CIdx); |
2900 | free(ptr: filename); |
2901 | |
2902 | free_remapped_files(unsaved_files, num_unsaved_files); |
2903 | |
2904 | return 0; |
2905 | } |
2906 | |
2907 | typedef struct { |
2908 | char *filename; |
2909 | unsigned line; |
2910 | unsigned column; |
2911 | } CursorSourceLocation; |
2912 | |
2913 | typedef void (*cursor_handler_t)(CXCursor cursor); |
2914 | |
2915 | static int inspect_cursor_at(int argc, const char **argv, |
2916 | const char *locations_flag, |
2917 | cursor_handler_t handler) { |
2918 | CXIndex CIdx; |
2919 | int errorCode; |
2920 | struct CXUnsavedFile *unsaved_files = 0; |
2921 | int num_unsaved_files = 0; |
2922 | enum CXErrorCode Err; |
2923 | CXTranslationUnit TU; |
2924 | CXCursor Cursor; |
2925 | CursorSourceLocation *Locations = 0; |
2926 | unsigned NumLocations = 0, Loc; |
2927 | unsigned Repeats = 1; |
2928 | unsigned I; |
2929 | |
2930 | /* Count the number of locations. */ |
2931 | while (strstr(haystack: argv[NumLocations+1], needle: locations_flag) == argv[NumLocations+1]) |
2932 | ++NumLocations; |
2933 | |
2934 | /* Parse the locations. */ |
2935 | assert(NumLocations > 0 && "Unable to count locations?"); |
2936 | Locations = (CursorSourceLocation *)malloc( |
2937 | size: NumLocations * sizeof(CursorSourceLocation)); |
2938 | assert(Locations); |
2939 | for (Loc = 0; Loc < NumLocations; ++Loc) { |
2940 | const char *input = argv[Loc + 1] + strlen(s: locations_flag); |
2941 | if ((errorCode = parse_file_line_column(input, filename: &Locations[Loc].filename, |
2942 | line: &Locations[Loc].line, |
2943 | column: &Locations[Loc].column, second_line: 0, second_column: 0))) |
2944 | return errorCode; |
2945 | } |
2946 | |
2947 | if (parse_remapped_files(argc, argv, start_arg: NumLocations + 1, unsaved_files: &unsaved_files, |
2948 | num_unsaved_files: &num_unsaved_files)) |
2949 | return -1; |
2950 | |
2951 | if (getenv(name: "CINDEXTEST_EDITING")) |
2952 | Repeats = 5; |
2953 | |
2954 | /* Parse the translation unit. When we're testing clang_getCursor() after |
2955 | reparsing, don't remap unsaved files until the second parse. */ |
2956 | CIdx = clang_createIndex(excludeDeclarationsFromPCH: 1, displayDiagnostics: 1); |
2957 | Err = clang_parseTranslationUnit2(CIdx, source_filename: argv[argc - 1], |
2958 | command_line_args: argv + num_unsaved_files + 1 + NumLocations, |
2959 | num_command_line_args: argc - num_unsaved_files - 2 - NumLocations, |
2960 | unsaved_files, |
2961 | num_unsaved_files: Repeats > 1? 0 : num_unsaved_files, |
2962 | options: getDefaultParsingOptions(), out_TU: &TU); |
2963 | if (Err != CXError_Success) { |
2964 | fprintf(stderr, format: "unable to parse input\n"); |
2965 | describeLibclangFailure(Err); |
2966 | return -1; |
2967 | } |
2968 | |
2969 | if (checkForErrors(TU) != 0) |
2970 | return -1; |
2971 | |
2972 | for (I = 0; I != Repeats; ++I) { |
2973 | if (Repeats > 1) { |
2974 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, |
2975 | options: clang_defaultReparseOptions(TU)); |
2976 | if (Err != CXError_Success) { |
2977 | describeLibclangFailure(Err); |
2978 | clang_disposeTranslationUnit(TU); |
2979 | return 1; |
2980 | } |
2981 | } |
2982 | |
2983 | if (checkForErrors(TU) != 0) |
2984 | return -1; |
2985 | |
2986 | for (Loc = 0; Loc < NumLocations; ++Loc) { |
2987 | CXFile file = clang_getFile(tu: TU, file_name: Locations[Loc].filename); |
2988 | if (!file) |
2989 | continue; |
2990 | |
2991 | Cursor = clang_getCursor(TU, |
2992 | clang_getLocation(tu: TU, file, line: Locations[Loc].line, |
2993 | column: Locations[Loc].column)); |
2994 | |
2995 | if (checkForErrors(TU) != 0) |
2996 | return -1; |
2997 | |
2998 | if (I + 1 == Repeats) { |
2999 | handler(Cursor); |
3000 | free(ptr: Locations[Loc].filename); |
3001 | } |
3002 | } |
3003 | } |
3004 | |
3005 | PrintDiagnostics(TU); |
3006 | clang_disposeTranslationUnit(TU); |
3007 | clang_disposeIndex(index: CIdx); |
3008 | free(ptr: Locations); |
3009 | free_remapped_files(unsaved_files, num_unsaved_files); |
3010 | return 0; |
3011 | } |
3012 | |
3013 | static void inspect_print_cursor(CXCursor Cursor) { |
3014 | CXTranslationUnit TU = clang_Cursor_getTranslationUnit(Cursor); |
3015 | CXCompletionString completionString = clang_getCursorCompletionString( |
3016 | cursor: Cursor); |
3017 | CXSourceLocation CursorLoc = clang_getCursorLocation(Cursor); |
3018 | CXString Spelling; |
3019 | const char *cspell; |
3020 | unsigned line, column; |
3021 | clang_getFileLocation(location: CursorLoc, file: 0, line: &line, column: &column, offset: 0); |
3022 | printf(format: "%d:%d ", line, column); |
3023 | PrintCursor(Cursor, NULL); |
3024 | PrintCursorExtent(C: Cursor); |
3025 | Spelling = clang_getCursorSpelling(Cursor); |
3026 | cspell = clang_getCString(string: Spelling); |
3027 | if (cspell && strlen(s: cspell) != 0) { |
3028 | unsigned pieceIndex; |
3029 | printf(format: " Spelling=%s (", cspell); |
3030 | for (pieceIndex = 0; ; ++pieceIndex) { |
3031 | CXSourceRange range = |
3032 | clang_Cursor_getSpellingNameRange(Cursor, pieceIndex, options: 0); |
3033 | if (clang_Range_isNull(range)) |
3034 | break; |
3035 | PrintRange(R: range, str: 0); |
3036 | } |
3037 | printf(format: ")"); |
3038 | } |
3039 | clang_disposeString(string: Spelling); |
3040 | if (clang_Cursor_getObjCSelectorIndex(Cursor) != -1) |
3041 | printf(format: " Selector index=%d", |
3042 | clang_Cursor_getObjCSelectorIndex(Cursor)); |
3043 | if (clang_Cursor_isDynamicCall(C: Cursor)) |
3044 | printf(format: " Dynamic-call"); |
3045 | if (Cursor.kind == CXCursor_ObjCMessageExpr || |
3046 | Cursor.kind == CXCursor_MemberRefExpr) { |
3047 | CXType T = clang_Cursor_getReceiverType(C: Cursor); |
3048 | if (T.kind != CXType_Invalid) { |
3049 | CXString S = clang_getTypeKindSpelling(K: T.kind); |
3050 | printf(format: " Receiver-type=%s", clang_getCString(string: S)); |
3051 | clang_disposeString(string: S); |
3052 | } |
3053 | } |
3054 | |
3055 | { |
3056 | CXModule mod = clang_Cursor_getModule(C: Cursor); |
3057 | CXFile astFile; |
3058 | CXString name, astFilename; |
3059 | unsigned i, numHeaders; |
3060 | if (mod) { |
3061 | astFile = clang_Module_getASTFile(Module: mod); |
3062 | astFilename = clang_getFileName(SFile: astFile); |
3063 | name = clang_Module_getFullName(Module: mod); |
3064 | numHeaders = clang_Module_getNumTopLevelHeaders(TU, Module: mod); |
3065 | printf(format: " ModuleName=%s (%s) system=%d Headers(%d):", |
3066 | clang_getCString(string: name), clang_getCString(string: astFilename), |
3067 | clang_Module_isSystem(Module: mod), numHeaders); |
3068 | clang_disposeString(string: name); |
3069 | clang_disposeString(string: astFilename); |
3070 | for (i = 0; i < numHeaders; ++i) { |
3071 | CXFile file = clang_Module_getTopLevelHeader(TU, Module: mod, Index: i); |
3072 | CXString filename = clang_getFileName(SFile: file); |
3073 | printf(format: "\n%s", clang_getCString(string: filename)); |
3074 | clang_disposeString(string: filename); |
3075 | } |
3076 | } |
3077 | } |
3078 | |
3079 | if (completionString != NULL) { |
3080 | printf(format: "\nCompletion string: "); |
3081 | print_completion_string(completion_string: completionString, stdout); |
3082 | } |
3083 | printf(format: "\n"); |
3084 | } |
3085 | |
3086 | static void display_evaluate_results(CXEvalResult result) { |
3087 | switch (clang_EvalResult_getKind(E: result)) { |
3088 | case CXEval_Int: |
3089 | { |
3090 | printf(format: "Kind: Int, "); |
3091 | if (clang_EvalResult_isUnsignedInt(E: result)) { |
3092 | unsigned long long val = clang_EvalResult_getAsUnsigned(E: result); |
3093 | printf(format: "unsigned, Value: %llu", val); |
3094 | } else { |
3095 | long long val = clang_EvalResult_getAsLongLong(E: result); |
3096 | printf(format: "Value: %lld", val); |
3097 | } |
3098 | break; |
3099 | } |
3100 | case CXEval_Float: |
3101 | { |
3102 | double val = clang_EvalResult_getAsDouble(E: result); |
3103 | printf(format: "Kind: Float , Value: %f", val); |
3104 | break; |
3105 | } |
3106 | case CXEval_ObjCStrLiteral: |
3107 | { |
3108 | const char* str = clang_EvalResult_getAsStr(E: result); |
3109 | printf(format: "Kind: ObjCString , Value: %s", str); |
3110 | break; |
3111 | } |
3112 | case CXEval_StrLiteral: |
3113 | { |
3114 | const char* str = clang_EvalResult_getAsStr(E: result); |
3115 | printf(format: "Kind: CString , Value: %s", str); |
3116 | break; |
3117 | } |
3118 | case CXEval_CFStr: |
3119 | { |
3120 | const char* str = clang_EvalResult_getAsStr(E: result); |
3121 | printf(format: "Kind: CFString , Value: %s", str); |
3122 | break; |
3123 | } |
3124 | default: |
3125 | printf(format: "Unexposed"); |
3126 | break; |
3127 | } |
3128 | } |
3129 | |
3130 | static void inspect_evaluate_cursor(CXCursor Cursor) { |
3131 | CXSourceLocation CursorLoc = clang_getCursorLocation(Cursor); |
3132 | CXString Spelling; |
3133 | const char *cspell; |
3134 | unsigned line, column; |
3135 | CXEvalResult ER; |
3136 | |
3137 | clang_getFileLocation(location: CursorLoc, file: 0, line: &line, column: &column, offset: 0); |
3138 | printf(format: "%d:%d ", line, column); |
3139 | PrintCursor(Cursor, NULL); |
3140 | PrintCursorExtent(C: Cursor); |
3141 | Spelling = clang_getCursorSpelling(Cursor); |
3142 | cspell = clang_getCString(string: Spelling); |
3143 | if (cspell && strlen(s: cspell) != 0) { |
3144 | unsigned pieceIndex; |
3145 | printf(format: " Spelling=%s (", cspell); |
3146 | for (pieceIndex = 0; ; ++pieceIndex) { |
3147 | CXSourceRange range = |
3148 | clang_Cursor_getSpellingNameRange(Cursor, pieceIndex, options: 0); |
3149 | if (clang_Range_isNull(range)) |
3150 | break; |
3151 | PrintRange(R: range, str: 0); |
3152 | } |
3153 | printf(format: ")"); |
3154 | } |
3155 | clang_disposeString(string: Spelling); |
3156 | |
3157 | ER = clang_Cursor_Evaluate(C: Cursor); |
3158 | if (!ER) { |
3159 | printf(format: "Not Evaluatable"); |
3160 | } else { |
3161 | display_evaluate_results(result: ER); |
3162 | clang_EvalResult_dispose(E: ER); |
3163 | } |
3164 | printf(format: "\n"); |
3165 | } |
3166 | |
3167 | static void inspect_macroinfo_cursor(CXCursor Cursor) { |
3168 | CXSourceLocation CursorLoc = clang_getCursorLocation(Cursor); |
3169 | CXString Spelling; |
3170 | const char *cspell; |
3171 | unsigned line, column; |
3172 | clang_getFileLocation(location: CursorLoc, file: 0, line: &line, column: &column, offset: 0); |
3173 | printf(format: "%d:%d ", line, column); |
3174 | PrintCursor(Cursor, NULL); |
3175 | PrintCursorExtent(C: Cursor); |
3176 | Spelling = clang_getCursorSpelling(Cursor); |
3177 | cspell = clang_getCString(string: Spelling); |
3178 | if (cspell && strlen(s: cspell) != 0) { |
3179 | unsigned pieceIndex; |
3180 | printf(format: " Spelling=%s (", cspell); |
3181 | for (pieceIndex = 0; ; ++pieceIndex) { |
3182 | CXSourceRange range = |
3183 | clang_Cursor_getSpellingNameRange(Cursor, pieceIndex, options: 0); |
3184 | if (clang_Range_isNull(range)) |
3185 | break; |
3186 | PrintRange(R: range, str: 0); |
3187 | } |
3188 | printf(format: ")"); |
3189 | } |
3190 | clang_disposeString(string: Spelling); |
3191 | |
3192 | if (clang_Cursor_isMacroBuiltin(C: Cursor)) { |
3193 | printf(format: "[builtin macro]"); |
3194 | } else if (clang_Cursor_isMacroFunctionLike(C: Cursor)) { |
3195 | printf(format: "[function macro]"); |
3196 | } |
3197 | printf(format: "\n"); |
3198 | } |
3199 | |
3200 | static enum CXVisitorResult findFileRefsVisit(void *context, |
3201 | CXCursor cursor, CXSourceRange range) { |
3202 | if (clang_Range_isNull(range)) |
3203 | return CXVisit_Continue; |
3204 | |
3205 | PrintCursor(Cursor: cursor, NULL); |
3206 | PrintRange(R: range, str: ""); |
3207 | printf(format: "\n"); |
3208 | return CXVisit_Continue; |
3209 | } |
3210 | |
3211 | static int find_file_refs_at(int argc, const char **argv) { |
3212 | CXIndex CIdx; |
3213 | int errorCode; |
3214 | struct CXUnsavedFile *unsaved_files = 0; |
3215 | int num_unsaved_files = 0; |
3216 | enum CXErrorCode Err; |
3217 | CXTranslationUnit TU; |
3218 | CXCursor Cursor; |
3219 | CursorSourceLocation *Locations = 0; |
3220 | unsigned NumLocations = 0, Loc; |
3221 | unsigned Repeats = 1; |
3222 | unsigned I; |
3223 | |
3224 | /* Count the number of locations. */ |
3225 | while (strstr(haystack: argv[NumLocations+1], needle: "-file-refs-at=") == argv[NumLocations+1]) |
3226 | ++NumLocations; |
3227 | |
3228 | /* Parse the locations. */ |
3229 | assert(NumLocations > 0 && "Unable to count locations?"); |
3230 | Locations = (CursorSourceLocation *)malloc( |
3231 | size: NumLocations * sizeof(CursorSourceLocation)); |
3232 | assert(Locations); |
3233 | for (Loc = 0; Loc < NumLocations; ++Loc) { |
3234 | const char *input = argv[Loc + 1] + strlen(s: "-file-refs-at="); |
3235 | if ((errorCode = parse_file_line_column(input, filename: &Locations[Loc].filename, |
3236 | line: &Locations[Loc].line, |
3237 | column: &Locations[Loc].column, second_line: 0, second_column: 0))) |
3238 | return errorCode; |
3239 | } |
3240 | |
3241 | if (parse_remapped_files(argc, argv, start_arg: NumLocations + 1, unsaved_files: &unsaved_files, |
3242 | num_unsaved_files: &num_unsaved_files)) |
3243 | return -1; |
3244 | |
3245 | if (getenv(name: "CINDEXTEST_EDITING")) |
3246 | Repeats = 5; |
3247 | |
3248 | /* Parse the translation unit. When we're testing clang_getCursor() after |
3249 | reparsing, don't remap unsaved files until the second parse. */ |
3250 | CIdx = clang_createIndex(excludeDeclarationsFromPCH: 1, displayDiagnostics: 1); |
3251 | Err = clang_parseTranslationUnit2(CIdx, source_filename: argv[argc - 1], |
3252 | command_line_args: argv + num_unsaved_files + 1 + NumLocations, |
3253 | num_command_line_args: argc - num_unsaved_files - 2 - NumLocations, |
3254 | unsaved_files, |
3255 | num_unsaved_files: Repeats > 1? 0 : num_unsaved_files, |
3256 | options: getDefaultParsingOptions(), out_TU: &TU); |
3257 | if (Err != CXError_Success) { |
3258 | fprintf(stderr, format: "unable to parse input\n"); |
3259 | describeLibclangFailure(Err); |
3260 | clang_disposeTranslationUnit(TU); |
3261 | return -1; |
3262 | } |
3263 | |
3264 | if (checkForErrors(TU) != 0) |
3265 | return -1; |
3266 | |
3267 | for (I = 0; I != Repeats; ++I) { |
3268 | if (Repeats > 1) { |
3269 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, |
3270 | options: clang_defaultReparseOptions(TU)); |
3271 | if (Err != CXError_Success) { |
3272 | describeLibclangFailure(Err); |
3273 | clang_disposeTranslationUnit(TU); |
3274 | return 1; |
3275 | } |
3276 | } |
3277 | |
3278 | if (checkForErrors(TU) != 0) |
3279 | return -1; |
3280 | |
3281 | for (Loc = 0; Loc < NumLocations; ++Loc) { |
3282 | CXFile file = clang_getFile(tu: TU, file_name: Locations[Loc].filename); |
3283 | if (!file) |
3284 | continue; |
3285 | |
3286 | Cursor = clang_getCursor(TU, |
3287 | clang_getLocation(tu: TU, file, line: Locations[Loc].line, |
3288 | column: Locations[Loc].column)); |
3289 | |
3290 | if (checkForErrors(TU) != 0) |
3291 | return -1; |
3292 | |
3293 | if (I + 1 == Repeats) { |
3294 | CXCursorAndRangeVisitor visitor = { 0, findFileRefsVisit }; |
3295 | PrintCursor(Cursor, NULL); |
3296 | printf(format: "\n"); |
3297 | clang_findReferencesInFile(cursor: Cursor, file, visitor); |
3298 | free(ptr: Locations[Loc].filename); |
3299 | |
3300 | if (checkForErrors(TU) != 0) |
3301 | return -1; |
3302 | } |
3303 | } |
3304 | } |
3305 | |
3306 | PrintDiagnostics(TU); |
3307 | clang_disposeTranslationUnit(TU); |
3308 | clang_disposeIndex(index: CIdx); |
3309 | free(ptr: Locations); |
3310 | free_remapped_files(unsaved_files, num_unsaved_files); |
3311 | return 0; |
3312 | } |
3313 | |
3314 | static enum CXVisitorResult findFileIncludesVisit(void *context, |
3315 | CXCursor cursor, CXSourceRange range) { |
3316 | PrintCursor(Cursor: cursor, NULL); |
3317 | PrintRange(R: range, str: ""); |
3318 | printf(format: "\n"); |
3319 | return CXVisit_Continue; |
3320 | } |
3321 | |
3322 | static int find_file_includes_in(int argc, const char **argv) { |
3323 | CXIndex CIdx; |
3324 | struct CXUnsavedFile *unsaved_files = 0; |
3325 | int num_unsaved_files = 0; |
3326 | enum CXErrorCode Err; |
3327 | CXTranslationUnit TU; |
3328 | const char **Filenames = 0; |
3329 | unsigned NumFilenames = 0; |
3330 | unsigned Repeats = 1; |
3331 | unsigned I, FI; |
3332 | |
3333 | /* Count the number of locations. */ |
3334 | while (strstr(haystack: argv[NumFilenames+1], needle: "-file-includes-in=") == argv[NumFilenames+1]) |
3335 | ++NumFilenames; |
3336 | |
3337 | /* Parse the locations. */ |
3338 | assert(NumFilenames > 0 && "Unable to count filenames?"); |
3339 | Filenames = (const char **)malloc(size: NumFilenames * sizeof(const char *)); |
3340 | assert(Filenames); |
3341 | for (I = 0; I < NumFilenames; ++I) { |
3342 | const char *input = argv[I + 1] + strlen(s: "-file-includes-in="); |
3343 | /* Copy the file name. */ |
3344 | Filenames[I] = input; |
3345 | } |
3346 | |
3347 | if (parse_remapped_files(argc, argv, start_arg: NumFilenames + 1, unsaved_files: &unsaved_files, |
3348 | num_unsaved_files: &num_unsaved_files)) |
3349 | return -1; |
3350 | |
3351 | if (getenv(name: "CINDEXTEST_EDITING")) |
3352 | Repeats = 2; |
3353 | |
3354 | /* Parse the translation unit. When we're testing clang_getCursor() after |
3355 | reparsing, don't remap unsaved files until the second parse. */ |
3356 | CIdx = clang_createIndex(excludeDeclarationsFromPCH: 1, displayDiagnostics: 1); |
3357 | Err = clang_parseTranslationUnit2( |
3358 | CIdx, source_filename: argv[argc - 1], |
3359 | command_line_args: argv + num_unsaved_files + 1 + NumFilenames, |
3360 | num_command_line_args: argc - num_unsaved_files - 2 - NumFilenames, |
3361 | unsaved_files, |
3362 | num_unsaved_files: Repeats > 1 ? 0 : num_unsaved_files, options: getDefaultParsingOptions(), out_TU: &TU); |
3363 | |
3364 | if (Err != CXError_Success) { |
3365 | fprintf(stderr, format: "unable to parse input\n"); |
3366 | describeLibclangFailure(Err); |
3367 | clang_disposeTranslationUnit(TU); |
3368 | return -1; |
3369 | } |
3370 | |
3371 | if (checkForErrors(TU) != 0) |
3372 | return -1; |
3373 | |
3374 | for (I = 0; I != Repeats; ++I) { |
3375 | if (Repeats > 1) { |
3376 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, |
3377 | options: clang_defaultReparseOptions(TU)); |
3378 | if (Err != CXError_Success) { |
3379 | describeLibclangFailure(Err); |
3380 | clang_disposeTranslationUnit(TU); |
3381 | return 1; |
3382 | } |
3383 | } |
3384 | |
3385 | if (checkForErrors(TU) != 0) |
3386 | return -1; |
3387 | |
3388 | for (FI = 0; FI < NumFilenames; ++FI) { |
3389 | CXFile file = clang_getFile(tu: TU, file_name: Filenames[FI]); |
3390 | if (!file) |
3391 | continue; |
3392 | |
3393 | if (checkForErrors(TU) != 0) |
3394 | return -1; |
3395 | |
3396 | if (I + 1 == Repeats) { |
3397 | CXCursorAndRangeVisitor visitor = { 0, findFileIncludesVisit }; |
3398 | clang_findIncludesInFile(TU, file, visitor); |
3399 | |
3400 | if (checkForErrors(TU) != 0) |
3401 | return -1; |
3402 | } |
3403 | } |
3404 | } |
3405 | |
3406 | PrintDiagnostics(TU); |
3407 | clang_disposeTranslationUnit(TU); |
3408 | clang_disposeIndex(index: CIdx); |
3409 | free(ptr: (void *)Filenames); |
3410 | free_remapped_files(unsaved_files, num_unsaved_files); |
3411 | return 0; |
3412 | } |
3413 | |
3414 | #define MAX_IMPORTED_ASTFILES 200 |
3415 | |
3416 | typedef struct { |
3417 | char **filenames; |
3418 | unsigned num_files; |
3419 | } ImportedASTFilesData; |
3420 | |
3421 | static ImportedASTFilesData *importedASTs_create(void) { |
3422 | ImportedASTFilesData *p; |
3423 | p = malloc(size: sizeof(ImportedASTFilesData)); |
3424 | assert(p); |
3425 | p->filenames = malloc(MAX_IMPORTED_ASTFILES * sizeof(const char *)); |
3426 | assert(p->filenames); |
3427 | p->num_files = 0; |
3428 | return p; |
3429 | } |
3430 | |
3431 | static void importedASTs_dispose(ImportedASTFilesData *p) { |
3432 | unsigned i; |
3433 | if (!p) |
3434 | return; |
3435 | |
3436 | for (i = 0; i < p->num_files; ++i) |
3437 | free(ptr: p->filenames[i]); |
3438 | free(ptr: p->filenames); |
3439 | free(ptr: p); |
3440 | } |
3441 | |
3442 | static void importedASTS_insert(ImportedASTFilesData *p, const char *file) { |
3443 | unsigned i; |
3444 | assert(p && file); |
3445 | for (i = 0; i < p->num_files; ++i) |
3446 | if (strcmp(s1: file, s2: p->filenames[i]) == 0) |
3447 | return; |
3448 | assert(p->num_files + 1 < MAX_IMPORTED_ASTFILES); |
3449 | p->filenames[p->num_files++] = strdup(s: file); |
3450 | } |
3451 | |
3452 | typedef struct IndexDataStringList_ { |
3453 | struct IndexDataStringList_ *next; |
3454 | char data[1]; /* Dynamically sized. */ |
3455 | } IndexDataStringList; |
3456 | |
3457 | typedef struct { |
3458 | const char *check_prefix; |
3459 | int first_check_printed; |
3460 | int fail_for_error; |
3461 | int abort; |
3462 | CXString main_filename; |
3463 | ImportedASTFilesData *importedASTs; |
3464 | IndexDataStringList *strings; |
3465 | CXTranslationUnit TU; |
3466 | } IndexData; |
3467 | |
3468 | static void free_client_data(IndexData *index_data) { |
3469 | IndexDataStringList *node = index_data->strings; |
3470 | while (node) { |
3471 | IndexDataStringList *next = node->next; |
3472 | free(ptr: node); |
3473 | node = next; |
3474 | } |
3475 | index_data->strings = NULL; |
3476 | } |
3477 | |
3478 | static void printCheck(IndexData *data) { |
3479 | if (data->check_prefix) { |
3480 | if (data->first_check_printed) { |
3481 | printf(format: "// %s-NEXT: ", data->check_prefix); |
3482 | } else { |
3483 | printf(format: "// %s : ", data->check_prefix); |
3484 | data->first_check_printed = 1; |
3485 | } |
3486 | } |
3487 | } |
3488 | |
3489 | static void printCXIndexFile(CXIdxClientFile file) { |
3490 | CXString filename = clang_getFileName(SFile: (CXFile)file); |
3491 | printf(format: "%s", clang_getCString(string: filename)); |
3492 | clang_disposeString(string: filename); |
3493 | } |
3494 | |
3495 | static void printCXIndexLoc(CXIdxLoc loc, CXClientData client_data) { |
3496 | IndexData *index_data; |
3497 | CXString filename; |
3498 | const char *cname; |
3499 | CXIdxClientFile file; |
3500 | unsigned line, column; |
3501 | const char *main_filename; |
3502 | int isMainFile; |
3503 | |
3504 | index_data = (IndexData *)client_data; |
3505 | clang_indexLoc_getFileLocation(loc, indexFile: &file, file: 0, line: &line, column: &column, offset: 0); |
3506 | if (line == 0) { |
3507 | printf(format: "<invalid>"); |
3508 | return; |
3509 | } |
3510 | if (!file) { |
3511 | printf(format: "<no idxfile>"); |
3512 | return; |
3513 | } |
3514 | filename = clang_getFileName(SFile: (CXFile)file); |
3515 | cname = clang_getCString(string: filename); |
3516 | main_filename = clang_getCString(string: index_data->main_filename); |
3517 | if (strcmp(s1: cname, s2: main_filename) == 0) |
3518 | isMainFile = 1; |
3519 | else |
3520 | isMainFile = 0; |
3521 | clang_disposeString(string: filename); |
3522 | |
3523 | if (!isMainFile) { |
3524 | printCXIndexFile(file); |
3525 | printf(format: ":"); |
3526 | } |
3527 | printf(format: "%d:%d", line, column); |
3528 | } |
3529 | |
3530 | static unsigned digitCount(unsigned val) { |
3531 | unsigned c = 1; |
3532 | while (1) { |
3533 | if (val < 10) |
3534 | return c; |
3535 | ++c; |
3536 | val /= 10; |
3537 | } |
3538 | } |
3539 | |
3540 | static CXIdxClientContainer makeClientContainer(CXClientData *client_data, |
3541 | const CXIdxEntityInfo *info, |
3542 | CXIdxLoc loc) { |
3543 | IndexData *index_data; |
3544 | IndexDataStringList *node; |
3545 | const char *name; |
3546 | char *newStr; |
3547 | CXIdxClientFile file; |
3548 | unsigned line, column; |
3549 | size_t datalen; |
3550 | |
3551 | name = info->name; |
3552 | if (!name) |
3553 | name = "<anon-tag>"; |
3554 | |
3555 | clang_indexLoc_getFileLocation(loc, indexFile: &file, file: 0, line: &line, column: &column, offset: 0); |
3556 | |
3557 | datalen = strlen(s: name) + digitCount(val: line) + digitCount(val: column) + 3; |
3558 | node = (IndexDataStringList *)malloc(size: datalen + sizeof(IndexDataStringList)); |
3559 | assert(node); |
3560 | newStr = node->data; |
3561 | snprintf(s: newStr, maxlen: datalen, format: "%s:%d:%d", name, line, column); |
3562 | |
3563 | /* Remember string so it can be freed later. */ |
3564 | index_data = (IndexData *)client_data; |
3565 | node->next = index_data->strings; |
3566 | index_data->strings = node; |
3567 | |
3568 | return (CXIdxClientContainer)newStr; |
3569 | } |
3570 | |
3571 | static void printCXIndexContainer(const CXIdxContainerInfo *info) { |
3572 | CXIdxClientContainer container; |
3573 | container = clang_index_getClientContainer(info); |
3574 | if (!container) |
3575 | printf(format: "[<<NULL>>]"); |
3576 | else |
3577 | printf(format: "[%s]", (const char *)container); |
3578 | } |
3579 | |
3580 | static const char *getEntityKindString(CXIdxEntityKind kind) { |
3581 | switch (kind) { |
3582 | case CXIdxEntity_Unexposed: return "<<UNEXPOSED>>"; |
3583 | case CXIdxEntity_Typedef: return "typedef"; |
3584 | case CXIdxEntity_Function: return "function"; |
3585 | case CXIdxEntity_Variable: return "variable"; |
3586 | case CXIdxEntity_Field: return "field"; |
3587 | case CXIdxEntity_EnumConstant: return "enumerator"; |
3588 | case CXIdxEntity_ObjCClass: return "objc-class"; |
3589 | case CXIdxEntity_ObjCProtocol: return "objc-protocol"; |
3590 | case CXIdxEntity_ObjCCategory: return "objc-category"; |
3591 | case CXIdxEntity_ObjCInstanceMethod: return "objc-instance-method"; |
3592 | case CXIdxEntity_ObjCClassMethod: return "objc-class-method"; |
3593 | case CXIdxEntity_ObjCProperty: return "objc-property"; |
3594 | case CXIdxEntity_ObjCIvar: return "objc-ivar"; |
3595 | case CXIdxEntity_Enum: return "enum"; |
3596 | case CXIdxEntity_Struct: return "struct"; |
3597 | case CXIdxEntity_Union: return "union"; |
3598 | case CXIdxEntity_CXXClass: return "c++-class"; |
3599 | case CXIdxEntity_CXXNamespace: return "namespace"; |
3600 | case CXIdxEntity_CXXNamespaceAlias: return "namespace-alias"; |
3601 | case CXIdxEntity_CXXStaticVariable: return "c++-static-var"; |
3602 | case CXIdxEntity_CXXStaticMethod: return "c++-static-method"; |
3603 | case CXIdxEntity_CXXInstanceMethod: return "c++-instance-method"; |
3604 | case CXIdxEntity_CXXConstructor: return "constructor"; |
3605 | case CXIdxEntity_CXXDestructor: return "destructor"; |
3606 | case CXIdxEntity_CXXConversionFunction: return "conversion-func"; |
3607 | case CXIdxEntity_CXXTypeAlias: return "type-alias"; |
3608 | case CXIdxEntity_CXXInterface: return "c++-__interface"; |
3609 | case CXIdxEntity_CXXConcept: |
3610 | return "concept"; |
3611 | } |
3612 | assert(0 && "Garbage entity kind"); |
3613 | return 0; |
3614 | } |
3615 | |
3616 | static const char *getEntityTemplateKindString(CXIdxEntityCXXTemplateKind kind) { |
3617 | switch (kind) { |
3618 | case CXIdxEntity_NonTemplate: return ""; |
3619 | case CXIdxEntity_Template: return "-template"; |
3620 | case CXIdxEntity_TemplatePartialSpecialization: |
3621 | return "-template-partial-spec"; |
3622 | case CXIdxEntity_TemplateSpecialization: return "-template-spec"; |
3623 | } |
3624 | assert(0 && "Garbage entity kind"); |
3625 | return 0; |
3626 | } |
3627 | |
3628 | static const char *getEntityLanguageString(CXIdxEntityLanguage kind) { |
3629 | switch (kind) { |
3630 | case CXIdxEntityLang_None: return "<none>"; |
3631 | case CXIdxEntityLang_C: return "C"; |
3632 | case CXIdxEntityLang_ObjC: return "ObjC"; |
3633 | case CXIdxEntityLang_CXX: return "C++"; |
3634 | case CXIdxEntityLang_Swift: return "Swift"; |
3635 | } |
3636 | assert(0 && "Garbage language kind"); |
3637 | return 0; |
3638 | } |
3639 | |
3640 | static void printEntityInfo(const char *cb, |
3641 | CXClientData client_data, |
3642 | const CXIdxEntityInfo *info) { |
3643 | const char *name; |
3644 | IndexData *index_data; |
3645 | unsigned i; |
3646 | index_data = (IndexData *)client_data; |
3647 | printCheck(data: index_data); |
3648 | |
3649 | if (!info) { |
3650 | printf(format: "%s: <<NULL>>", cb); |
3651 | return; |
3652 | } |
3653 | |
3654 | name = info->name; |
3655 | if (!name) |
3656 | name = "<anon-tag>"; |
3657 | |
3658 | printf(format: "%s: kind: %s%s", cb, getEntityKindString(kind: info->kind), |
3659 | getEntityTemplateKindString(kind: info->templateKind)); |
3660 | printf(format: " | name: %s", name); |
3661 | printf(format: " | USR: %s", info->USR); |
3662 | printf(format: " | lang: %s", getEntityLanguageString(kind: info->lang)); |
3663 | |
3664 | for (i = 0; i != info->numAttributes; ++i) { |
3665 | const CXIdxAttrInfo *Attr = info->attributes[i]; |
3666 | printf(format: " <attribute>: "); |
3667 | PrintCursor(Cursor: Attr->cursor, NULL); |
3668 | } |
3669 | } |
3670 | |
3671 | static void printBaseClassInfo(CXClientData client_data, |
3672 | const CXIdxBaseClassInfo *info) { |
3673 | printEntityInfo(cb: " <base>", client_data, info: info->base); |
3674 | printf(format: " | cursor: "); |
3675 | PrintCursor(Cursor: info->cursor, NULL); |
3676 | printf(format: " | loc: "); |
3677 | printCXIndexLoc(loc: info->loc, client_data); |
3678 | } |
3679 | |
3680 | static void printProtocolList(const CXIdxObjCProtocolRefListInfo *ProtoInfo, |
3681 | CXClientData client_data) { |
3682 | unsigned i; |
3683 | for (i = 0; i < ProtoInfo->numProtocols; ++i) { |
3684 | printEntityInfo(cb: " <protocol>", client_data, |
3685 | info: ProtoInfo->protocols[i]->protocol); |
3686 | printf(format: " | cursor: "); |
3687 | PrintCursor(Cursor: ProtoInfo->protocols[i]->cursor, NULL); |
3688 | printf(format: " | loc: "); |
3689 | printCXIndexLoc(loc: ProtoInfo->protocols[i]->loc, client_data); |
3690 | printf(format: "\n"); |
3691 | } |
3692 | } |
3693 | |
3694 | static void printSymbolRole(CXSymbolRole role) { |
3695 | if (role & CXSymbolRole_Declaration) |
3696 | printf(format: " decl"); |
3697 | if (role & CXSymbolRole_Definition) |
3698 | printf(format: " def"); |
3699 | if (role & CXSymbolRole_Reference) |
3700 | printf(format: " ref"); |
3701 | if (role & CXSymbolRole_Read) |
3702 | printf(format: " read"); |
3703 | if (role & CXSymbolRole_Write) |
3704 | printf(format: " write"); |
3705 | if (role & CXSymbolRole_Call) |
3706 | printf(format: " call"); |
3707 | if (role & CXSymbolRole_Dynamic) |
3708 | printf(format: " dyn"); |
3709 | if (role & CXSymbolRole_AddressOf) |
3710 | printf(format: " addr"); |
3711 | if (role & CXSymbolRole_Implicit) |
3712 | printf(format: " implicit"); |
3713 | } |
3714 | |
3715 | static void index_diagnostic(CXClientData client_data, |
3716 | CXDiagnosticSet diagSet, void *reserved) { |
3717 | CXString str; |
3718 | const char *cstr; |
3719 | unsigned numDiags, i; |
3720 | CXDiagnostic diag; |
3721 | IndexData *index_data; |
3722 | index_data = (IndexData *)client_data; |
3723 | printCheck(data: index_data); |
3724 | |
3725 | numDiags = clang_getNumDiagnosticsInSet(Diags: diagSet); |
3726 | for (i = 0; i != numDiags; ++i) { |
3727 | diag = clang_getDiagnosticInSet(Diags: diagSet, Index: i); |
3728 | str = clang_formatDiagnostic(Diagnostic: diag, Options: clang_defaultDiagnosticDisplayOptions()); |
3729 | cstr = clang_getCString(string: str); |
3730 | printf(format: "[diagnostic]: %s\n", cstr); |
3731 | clang_disposeString(string: str); |
3732 | |
3733 | if (getenv(name: "CINDEXTEST_FAILONERROR") && |
3734 | clang_getDiagnosticSeverity(diag) >= CXDiagnostic_Error) { |
3735 | index_data->fail_for_error = 1; |
3736 | } |
3737 | } |
3738 | } |
3739 | |
3740 | static CXIdxClientFile index_enteredMainFile(CXClientData client_data, |
3741 | CXFile file, void *reserved) { |
3742 | IndexData *index_data; |
3743 | |
3744 | index_data = (IndexData *)client_data; |
3745 | printCheck(data: index_data); |
3746 | |
3747 | index_data->main_filename = clang_getFileName(SFile: file); |
3748 | |
3749 | printf(format: "[enteredMainFile]: "); |
3750 | printCXIndexFile(file: (CXIdxClientFile)file); |
3751 | printf(format: "\n"); |
3752 | |
3753 | return (CXIdxClientFile)file; |
3754 | } |
3755 | |
3756 | static CXIdxClientFile index_ppIncludedFile(CXClientData client_data, |
3757 | const CXIdxIncludedFileInfo *info) { |
3758 | IndexData *index_data; |
3759 | CXModule Mod; |
3760 | index_data = (IndexData *)client_data; |
3761 | printCheck(data: index_data); |
3762 | |
3763 | printf(format: "[ppIncludedFile]: "); |
3764 | printCXIndexFile(file: (CXIdxClientFile)info->file); |
3765 | printf(format: " | name: \"%s\"", info->filename); |
3766 | printf(format: " | hash loc: "); |
3767 | printCXIndexLoc(loc: info->hashLoc, client_data); |
3768 | printf(format: " | isImport: %d | isAngled: %d | isModule: %d", |
3769 | info->isImport, info->isAngled, info->isModuleImport); |
3770 | |
3771 | Mod = clang_getModuleForFile(index_data->TU, (CXFile)info->file); |
3772 | if (Mod) { |
3773 | CXString str = clang_Module_getFullName(Module: Mod); |
3774 | const char *cstr = clang_getCString(string: str); |
3775 | printf(format: " | module: %s", cstr); |
3776 | clang_disposeString(string: str); |
3777 | } |
3778 | |
3779 | printf(format: "\n"); |
3780 | |
3781 | return (CXIdxClientFile)info->file; |
3782 | } |
3783 | |
3784 | static CXIdxClientFile index_importedASTFile(CXClientData client_data, |
3785 | const CXIdxImportedASTFileInfo *info) { |
3786 | IndexData *index_data; |
3787 | index_data = (IndexData *)client_data; |
3788 | printCheck(data: index_data); |
3789 | |
3790 | if (index_data->importedASTs) { |
3791 | CXString filename = clang_getFileName(SFile: info->file); |
3792 | importedASTS_insert(p: index_data->importedASTs, file: clang_getCString(string: filename)); |
3793 | clang_disposeString(string: filename); |
3794 | } |
3795 | |
3796 | printf(format: "[importedASTFile]: "); |
3797 | printCXIndexFile(file: (CXIdxClientFile)info->file); |
3798 | if (info->module) { |
3799 | CXString name = clang_Module_getFullName(Module: info->module); |
3800 | printf(format: " | loc: "); |
3801 | printCXIndexLoc(loc: info->loc, client_data); |
3802 | printf(format: " | name: \"%s\"", clang_getCString(string: name)); |
3803 | printf(format: " | isImplicit: %d\n", info->isImplicit); |
3804 | clang_disposeString(string: name); |
3805 | } else { |
3806 | /* PCH file, the rest are not relevant. */ |
3807 | printf(format: "\n"); |
3808 | } |
3809 | |
3810 | return (CXIdxClientFile)info->file; |
3811 | } |
3812 | |
3813 | static CXIdxClientContainer |
3814 | index_startedTranslationUnit(CXClientData client_data, void *reserved) { |
3815 | IndexData *index_data; |
3816 | index_data = (IndexData *)client_data; |
3817 | printCheck(data: index_data); |
3818 | |
3819 | printf(format: "[startedTranslationUnit]\n"); |
3820 | #ifdef __GNUC__ |
3821 | #pragma GCC diagnostic push |
3822 | #pragma GCC diagnostic ignored "-Wcast-qual" |
3823 | #endif |
3824 | return (CXIdxClientContainer)"TU"; |
3825 | #ifdef __GNUC__ |
3826 | #pragma GCC diagnostic pop |
3827 | #endif |
3828 | } |
3829 | |
3830 | static void index_indexDeclaration(CXClientData client_data, |
3831 | const CXIdxDeclInfo *info) { |
3832 | IndexData *index_data; |
3833 | const CXIdxObjCCategoryDeclInfo *CatInfo; |
3834 | const CXIdxObjCInterfaceDeclInfo *InterInfo; |
3835 | const CXIdxObjCProtocolRefListInfo *ProtoInfo; |
3836 | const CXIdxObjCPropertyDeclInfo *PropInfo; |
3837 | const CXIdxCXXClassDeclInfo *CXXClassInfo; |
3838 | unsigned i; |
3839 | index_data = (IndexData *)client_data; |
3840 | |
3841 | printEntityInfo(cb: "[indexDeclaration]", client_data, info: info->entityInfo); |
3842 | printf(format: " | cursor: "); |
3843 | PrintCursor(Cursor: info->cursor, NULL); |
3844 | printf(format: " | loc: "); |
3845 | printCXIndexLoc(loc: info->loc, client_data); |
3846 | printf(format: " | semantic-container: "); |
3847 | printCXIndexContainer(info: info->semanticContainer); |
3848 | printf(format: " | lexical-container: "); |
3849 | printCXIndexContainer(info: info->lexicalContainer); |
3850 | printf(format: " | isRedecl: %d", info->isRedeclaration); |
3851 | printf(format: " | isDef: %d", info->isDefinition); |
3852 | if (info->flags & CXIdxDeclFlag_Skipped) { |
3853 | assert(!info->isContainer); |
3854 | printf(format: " | isContainer: skipped"); |
3855 | } else { |
3856 | printf(format: " | isContainer: %d", info->isContainer); |
3857 | } |
3858 | printf(format: " | isImplicit: %d\n", info->isImplicit); |
3859 | |
3860 | for (i = 0; i != info->numAttributes; ++i) { |
3861 | const CXIdxAttrInfo *Attr = info->attributes[i]; |
3862 | printf(format: " <attribute>: "); |
3863 | PrintCursor(Cursor: Attr->cursor, NULL); |
3864 | printf(format: "\n"); |
3865 | } |
3866 | |
3867 | if (clang_index_isEntityObjCContainerKind(info->entityInfo->kind)) { |
3868 | const char *kindName = 0; |
3869 | CXIdxObjCContainerKind K = clang_index_getObjCContainerDeclInfo(info)->kind; |
3870 | switch (K) { |
3871 | case CXIdxObjCContainer_ForwardRef: |
3872 | kindName = "forward-ref"; break; |
3873 | case CXIdxObjCContainer_Interface: |
3874 | kindName = "interface"; break; |
3875 | case CXIdxObjCContainer_Implementation: |
3876 | kindName = "implementation"; break; |
3877 | } |
3878 | printCheck(data: index_data); |
3879 | printf(format: " <ObjCContainerInfo>: kind: %s\n", kindName); |
3880 | } |
3881 | |
3882 | if ((CatInfo = clang_index_getObjCCategoryDeclInfo(info))) { |
3883 | printEntityInfo(cb: " <ObjCCategoryInfo>: class", client_data, |
3884 | info: CatInfo->objcClass); |
3885 | printf(format: " | cursor: "); |
3886 | PrintCursor(Cursor: CatInfo->classCursor, NULL); |
3887 | printf(format: " | loc: "); |
3888 | printCXIndexLoc(loc: CatInfo->classLoc, client_data); |
3889 | printf(format: "\n"); |
3890 | } |
3891 | |
3892 | if ((InterInfo = clang_index_getObjCInterfaceDeclInfo(info))) { |
3893 | if (InterInfo->superInfo) { |
3894 | printBaseClassInfo(client_data, info: InterInfo->superInfo); |
3895 | printf(format: "\n"); |
3896 | } |
3897 | } |
3898 | |
3899 | if ((ProtoInfo = clang_index_getObjCProtocolRefListInfo(info))) { |
3900 | printProtocolList(ProtoInfo, client_data); |
3901 | } |
3902 | |
3903 | if ((PropInfo = clang_index_getObjCPropertyDeclInfo(info))) { |
3904 | if (PropInfo->getter) { |
3905 | printEntityInfo(cb: " <getter>", client_data, info: PropInfo->getter); |
3906 | printf(format: "\n"); |
3907 | } |
3908 | if (PropInfo->setter) { |
3909 | printEntityInfo(cb: " <setter>", client_data, info: PropInfo->setter); |
3910 | printf(format: "\n"); |
3911 | } |
3912 | } |
3913 | |
3914 | if ((CXXClassInfo = clang_index_getCXXClassDeclInfo(info))) { |
3915 | for (i = 0; i != CXXClassInfo->numBases; ++i) { |
3916 | printBaseClassInfo(client_data, info: CXXClassInfo->bases[i]); |
3917 | printf(format: "\n"); |
3918 | } |
3919 | } |
3920 | |
3921 | if (info->declAsContainer) |
3922 | clang_index_setClientContainer( |
3923 | info->declAsContainer, |
3924 | makeClientContainer(client_data, info: info->entityInfo, loc: info->loc)); |
3925 | } |
3926 | |
3927 | static void index_indexEntityReference(CXClientData client_data, |
3928 | const CXIdxEntityRefInfo *info) { |
3929 | printEntityInfo(cb: "[indexEntityReference]", client_data, |
3930 | info: info->referencedEntity); |
3931 | printf(format: " | cursor: "); |
3932 | PrintCursor(Cursor: info->cursor, NULL); |
3933 | printf(format: " | loc: "); |
3934 | printCXIndexLoc(loc: info->loc, client_data); |
3935 | printEntityInfo(cb: " | <parent>:", client_data, info: info->parentEntity); |
3936 | printf(format: " | container: "); |
3937 | printCXIndexContainer(info: info->container); |
3938 | printf(format: " | refkind: "); |
3939 | switch (info->kind) { |
3940 | case CXIdxEntityRef_Direct: printf(format: "direct"); break; |
3941 | case CXIdxEntityRef_Implicit: printf(format: "implicit"); break; |
3942 | } |
3943 | printf(format: " | role:"); |
3944 | printSymbolRole(role: info->role); |
3945 | printf(format: "\n"); |
3946 | } |
3947 | |
3948 | static int index_abortQuery(CXClientData client_data, void *reserved) { |
3949 | IndexData *index_data; |
3950 | index_data = (IndexData *)client_data; |
3951 | return index_data->abort; |
3952 | } |
3953 | |
3954 | static IndexerCallbacks IndexCB = { |
3955 | index_abortQuery, |
3956 | index_diagnostic, |
3957 | index_enteredMainFile, |
3958 | index_ppIncludedFile, |
3959 | index_importedASTFile, |
3960 | index_startedTranslationUnit, |
3961 | index_indexDeclaration, |
3962 | index_indexEntityReference |
3963 | }; |
3964 | |
3965 | static unsigned getIndexOptions(void) { |
3966 | unsigned index_opts; |
3967 | index_opts = 0; |
3968 | if (getenv(name: "CINDEXTEST_SUPPRESSREFS")) |
3969 | index_opts |= CXIndexOpt_SuppressRedundantRefs; |
3970 | if (getenv(name: "CINDEXTEST_INDEXLOCALSYMBOLS")) |
3971 | index_opts |= CXIndexOpt_IndexFunctionLocalSymbols; |
3972 | if (!getenv(name: "CINDEXTEST_DISABLE_SKIPPARSEDBODIES")) |
3973 | index_opts |= CXIndexOpt_SkipParsedBodiesInSession; |
3974 | if (getenv(name: "CINDEXTEST_INDEXIMPLICITTEMPLATEINSTANTIATIONS")) |
3975 | index_opts |= CXIndexOpt_IndexImplicitTemplateInstantiations; |
3976 | |
3977 | return index_opts; |
3978 | } |
3979 | |
3980 | static int index_compile_args(int num_args, const char **args, |
3981 | CXIndexAction idxAction, |
3982 | ImportedASTFilesData *importedASTs, |
3983 | const char *check_prefix) { |
3984 | IndexData index_data; |
3985 | unsigned index_opts; |
3986 | int result; |
3987 | |
3988 | if (num_args == 0) { |
3989 | fprintf(stderr, format: "no compiler arguments\n"); |
3990 | return -1; |
3991 | } |
3992 | |
3993 | index_data.check_prefix = check_prefix; |
3994 | index_data.first_check_printed = 0; |
3995 | index_data.fail_for_error = 0; |
3996 | index_data.abort = 0; |
3997 | index_data.main_filename = createCXString(CS: ""); |
3998 | index_data.importedASTs = importedASTs; |
3999 | index_data.strings = NULL; |
4000 | index_data.TU = NULL; |
4001 | |
4002 | index_opts = getIndexOptions(); |
4003 | result = clang_indexSourceFile(idxAction, client_data: &index_data, |
4004 | index_callbacks: &IndexCB,index_callbacks_size: sizeof(IndexCB), index_options: index_opts, |
4005 | source_filename: 0, command_line_args: args, num_command_line_args: num_args, unsaved_files: 0, num_unsaved_files: 0, out_TU: 0, |
4006 | TU_options: getDefaultParsingOptions()); |
4007 | if (result != CXError_Success) |
4008 | describeLibclangFailure(Err: result); |
4009 | |
4010 | if (index_data.fail_for_error) |
4011 | result = -1; |
4012 | |
4013 | clang_disposeString(string: index_data.main_filename); |
4014 | free_client_data(index_data: &index_data); |
4015 | return result; |
4016 | } |
4017 | |
4018 | static int index_ast_file(const char *ast_file, |
4019 | CXIndex Idx, |
4020 | CXIndexAction idxAction, |
4021 | ImportedASTFilesData *importedASTs, |
4022 | const char *check_prefix) { |
4023 | CXTranslationUnit TU; |
4024 | IndexData index_data; |
4025 | unsigned index_opts; |
4026 | int result; |
4027 | |
4028 | if (!CreateTranslationUnit(Idx, file: ast_file, TU: &TU)) |
4029 | return -1; |
4030 | |
4031 | index_data.check_prefix = check_prefix; |
4032 | index_data.first_check_printed = 0; |
4033 | index_data.fail_for_error = 0; |
4034 | index_data.abort = 0; |
4035 | index_data.main_filename = createCXString(CS: ""); |
4036 | index_data.importedASTs = importedASTs; |
4037 | index_data.strings = NULL; |
4038 | index_data.TU = TU; |
4039 | |
4040 | index_opts = getIndexOptions(); |
4041 | result = clang_indexTranslationUnit(idxAction, client_data: &index_data, |
4042 | index_callbacks: &IndexCB,index_callbacks_size: sizeof(IndexCB), |
4043 | index_options: index_opts, TU); |
4044 | if (index_data.fail_for_error) |
4045 | result = -1; |
4046 | |
4047 | clang_disposeTranslationUnit(TU); |
4048 | clang_disposeString(string: index_data.main_filename); |
4049 | free_client_data(index_data: &index_data); |
4050 | return result; |
4051 | } |
4052 | |
4053 | static int index_file(int argc, const char **argv, int full) { |
4054 | const char *check_prefix; |
4055 | CXIndex Idx; |
4056 | CXIndexAction idxAction; |
4057 | ImportedASTFilesData *importedASTs; |
4058 | int result; |
4059 | |
4060 | check_prefix = 0; |
4061 | if (argc > 0) { |
4062 | if (strstr(haystack: argv[0], needle: "-check-prefix=") == argv[0]) { |
4063 | check_prefix = argv[0] + strlen(s: "-check-prefix="); |
4064 | ++argv; |
4065 | --argc; |
4066 | } |
4067 | } |
4068 | |
4069 | if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ excludeDeclarationsFromPCH: 1, |
4070 | /* displayDiagnostics=*/1))) { |
4071 | fprintf(stderr, format: "Could not create Index\n"); |
4072 | return 1; |
4073 | } |
4074 | idxAction = clang_IndexAction_create(CIdx: Idx); |
4075 | importedASTs = 0; |
4076 | if (full) |
4077 | importedASTs = importedASTs_create(); |
4078 | |
4079 | result = index_compile_args(num_args: argc, args: argv, idxAction, importedASTs, check_prefix); |
4080 | if (result != 0) |
4081 | goto finished; |
4082 | |
4083 | if (full) { |
4084 | unsigned i; |
4085 | for (i = 0; i < importedASTs->num_files && result == 0; ++i) { |
4086 | result = index_ast_file(ast_file: importedASTs->filenames[i], Idx, idxAction, |
4087 | importedASTs, check_prefix); |
4088 | } |
4089 | } |
4090 | |
4091 | finished: |
4092 | importedASTs_dispose(p: importedASTs); |
4093 | clang_IndexAction_dispose(idxAction); |
4094 | clang_disposeIndex(index: Idx); |
4095 | return result; |
4096 | } |
4097 | |
4098 | static int index_tu(int argc, const char **argv) { |
4099 | const char *check_prefix; |
4100 | CXIndex Idx; |
4101 | CXIndexAction idxAction; |
4102 | int result; |
4103 | |
4104 | check_prefix = 0; |
4105 | if (argc > 0) { |
4106 | if (strstr(haystack: argv[0], needle: "-check-prefix=") == argv[0]) { |
4107 | check_prefix = argv[0] + strlen(s: "-check-prefix="); |
4108 | ++argv; |
4109 | --argc; |
4110 | } |
4111 | } |
4112 | |
4113 | if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ excludeDeclarationsFromPCH: 1, |
4114 | /* displayDiagnostics=*/1))) { |
4115 | fprintf(stderr, format: "Could not create Index\n"); |
4116 | return 1; |
4117 | } |
4118 | idxAction = clang_IndexAction_create(CIdx: Idx); |
4119 | |
4120 | result = index_ast_file(ast_file: argv[0], Idx, idxAction, |
4121 | /*importedASTs=*/0, check_prefix); |
4122 | |
4123 | clang_IndexAction_dispose(idxAction); |
4124 | clang_disposeIndex(index: Idx); |
4125 | return result; |
4126 | } |
4127 | |
4128 | static int index_compile_db(int argc, const char **argv) { |
4129 | const char *check_prefix; |
4130 | CXIndex Idx; |
4131 | CXIndexAction idxAction; |
4132 | int errorCode = 0; |
4133 | |
4134 | check_prefix = 0; |
4135 | if (argc > 0) { |
4136 | if (strstr(haystack: argv[0], needle: "-check-prefix=") == argv[0]) { |
4137 | check_prefix = argv[0] + strlen(s: "-check-prefix="); |
4138 | ++argv; |
4139 | --argc; |
4140 | } |
4141 | } |
4142 | |
4143 | if (argc == 0) { |
4144 | fprintf(stderr, format: "no compilation database\n"); |
4145 | return -1; |
4146 | } |
4147 | |
4148 | if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ excludeDeclarationsFromPCH: 1, |
4149 | /* displayDiagnostics=*/1))) { |
4150 | fprintf(stderr, format: "Could not create Index\n"); |
4151 | return 1; |
4152 | } |
4153 | idxAction = clang_IndexAction_create(CIdx: Idx); |
4154 | |
4155 | { |
4156 | const char *database = argv[0]; |
4157 | CXCompilationDatabase db = 0; |
4158 | CXCompileCommands CCmds = 0; |
4159 | CXCompileCommand CCmd; |
4160 | CXCompilationDatabase_Error ec; |
4161 | CXString wd; |
4162 | #define MAX_COMPILE_ARGS 512 |
4163 | CXString cxargs[MAX_COMPILE_ARGS]; |
4164 | const char *args[MAX_COMPILE_ARGS]; |
4165 | char *tmp; |
4166 | unsigned len; |
4167 | char *buildDir; |
4168 | int i, a, numCmds, numArgs; |
4169 | |
4170 | len = strlen(s: database); |
4171 | tmp = (char *) malloc(size: len+1); |
4172 | assert(tmp); |
4173 | memcpy(dest: tmp, src: database, n: len+1); |
4174 | buildDir = dirname(tmp); |
4175 | |
4176 | db = clang_CompilationDatabase_fromDirectory(BuildDir: buildDir, ErrorCode: &ec); |
4177 | |
4178 | if (db) { |
4179 | |
4180 | if (ec!=CXCompilationDatabase_NoError) { |
4181 | printf(format: "unexpected error %d code while loading compilation database\n", ec); |
4182 | errorCode = -1; |
4183 | goto cdb_end; |
4184 | } |
4185 | |
4186 | if (chdir(path: buildDir) != 0) { |
4187 | printf(format: "Could not chdir to %s\n", buildDir); |
4188 | errorCode = -1; |
4189 | goto cdb_end; |
4190 | } |
4191 | |
4192 | CCmds = clang_CompilationDatabase_getAllCompileCommands(db); |
4193 | if (!CCmds) { |
4194 | printf(format: "compilation db is empty\n"); |
4195 | errorCode = -1; |
4196 | goto cdb_end; |
4197 | } |
4198 | |
4199 | numCmds = clang_CompileCommands_getSize(CCmds); |
4200 | |
4201 | if (numCmds==0) { |
4202 | fprintf(stderr, format: "should not get an empty compileCommand set\n"); |
4203 | errorCode = -1; |
4204 | goto cdb_end; |
4205 | } |
4206 | |
4207 | for (i=0; i<numCmds && errorCode == 0; ++i) { |
4208 | CCmd = clang_CompileCommands_getCommand(CCmds, I: i); |
4209 | |
4210 | wd = clang_CompileCommand_getDirectory(CCmd); |
4211 | if (chdir(path: clang_getCString(string: wd)) != 0) { |
4212 | printf(format: "Could not chdir to %s\n", clang_getCString(string: wd)); |
4213 | errorCode = -1; |
4214 | goto cdb_end; |
4215 | } |
4216 | clang_disposeString(string: wd); |
4217 | |
4218 | numArgs = clang_CompileCommand_getNumArgs(CCmd); |
4219 | if (numArgs > MAX_COMPILE_ARGS){ |
4220 | fprintf(stderr, format: "got more compile arguments than maximum\n"); |
4221 | errorCode = -1; |
4222 | goto cdb_end; |
4223 | } |
4224 | for (a=0; a<numArgs; ++a) { |
4225 | cxargs[a] = clang_CompileCommand_getArg(CCmd, I: a); |
4226 | args[a] = clang_getCString(string: cxargs[a]); |
4227 | } |
4228 | |
4229 | errorCode = index_compile_args(num_args: numArgs, args, idxAction, |
4230 | /*importedASTs=*/0, check_prefix); |
4231 | |
4232 | for (a=0; a<numArgs; ++a) |
4233 | clang_disposeString(string: cxargs[a]); |
4234 | } |
4235 | } else { |
4236 | printf(format: "database loading failed with error code %d.\n", ec); |
4237 | errorCode = -1; |
4238 | } |
4239 | |
4240 | cdb_end: |
4241 | clang_CompileCommands_dispose(CCmds); |
4242 | clang_CompilationDatabase_dispose(db); |
4243 | free(ptr: tmp); |
4244 | |
4245 | } |
4246 | |
4247 | clang_IndexAction_dispose(idxAction); |
4248 | clang_disposeIndex(index: Idx); |
4249 | return errorCode; |
4250 | } |
4251 | |
4252 | int perform_token_annotation(int argc, const char **argv) { |
4253 | const char *input = argv[1]; |
4254 | char *filename = 0; |
4255 | unsigned line, second_line; |
4256 | unsigned column, second_column; |
4257 | CXIndex CIdx; |
4258 | CXTranslationUnit TU = 0; |
4259 | int errorCode; |
4260 | struct CXUnsavedFile *unsaved_files = 0; |
4261 | int num_unsaved_files = 0; |
4262 | CXToken *tokens; |
4263 | unsigned num_tokens; |
4264 | CXSourceRange range; |
4265 | CXSourceLocation startLoc, endLoc; |
4266 | CXFile file = 0; |
4267 | CXCursor *cursors = 0; |
4268 | CXSourceRangeList *skipped_ranges = 0; |
4269 | enum CXErrorCode Err; |
4270 | unsigned i; |
4271 | |
4272 | input += strlen(s: "-test-annotate-tokens="); |
4273 | if ((errorCode = parse_file_line_column(input, filename: &filename, line: &line, column: &column, |
4274 | second_line: &second_line, second_column: &second_column))) |
4275 | return errorCode; |
4276 | |
4277 | if (parse_remapped_files(argc, argv, start_arg: 2, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
4278 | free(ptr: filename); |
4279 | return -1; |
4280 | } |
4281 | |
4282 | CIdx = clang_createIndex(excludeDeclarationsFromPCH: 0, displayDiagnostics: 1); |
4283 | Err = clang_parseTranslationUnit2(CIdx, source_filename: argv[argc - 1], |
4284 | command_line_args: argv + num_unsaved_files + 2, |
4285 | num_command_line_args: argc - num_unsaved_files - 3, |
4286 | unsaved_files, |
4287 | num_unsaved_files, |
4288 | options: getDefaultParsingOptions(), out_TU: &TU); |
4289 | if (Err != CXError_Success) { |
4290 | fprintf(stderr, format: "unable to parse input\n"); |
4291 | describeLibclangFailure(Err); |
4292 | clang_disposeIndex(index: CIdx); |
4293 | free(ptr: filename); |
4294 | free_remapped_files(unsaved_files, num_unsaved_files); |
4295 | return -1; |
4296 | } |
4297 | errorCode = 0; |
4298 | |
4299 | if (checkForErrors(TU) != 0) { |
4300 | errorCode = -1; |
4301 | goto teardown; |
4302 | } |
4303 | |
4304 | if (getenv(name: "CINDEXTEST_EDITING")) { |
4305 | for (i = 0; i < 5; ++i) { |
4306 | Err = clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files, |
4307 | options: clang_defaultReparseOptions(TU)); |
4308 | if (Err != CXError_Success) { |
4309 | fprintf(stderr, format: "Unable to reparse translation unit!\n"); |
4310 | describeLibclangFailure(Err); |
4311 | errorCode = -1; |
4312 | goto teardown; |
4313 | } |
4314 | } |
4315 | } |
4316 | |
4317 | if (checkForErrors(TU) != 0) { |
4318 | errorCode = -1; |
4319 | goto teardown; |
4320 | } |
4321 | |
4322 | file = clang_getFile(tu: TU, file_name: filename); |
4323 | if (!file) { |
4324 | fprintf(stderr, format: "file %s is not in this translation unit\n", filename); |
4325 | errorCode = -1; |
4326 | goto teardown; |
4327 | } |
4328 | |
4329 | startLoc = clang_getLocation(tu: TU, file, line, column); |
4330 | if (clang_equalLocations(loc1: clang_getNullLocation(), loc2: startLoc)) { |
4331 | fprintf(stderr, format: "invalid source location %s:%d:%d\n", filename, line, |
4332 | column); |
4333 | errorCode = -1; |
4334 | goto teardown; |
4335 | } |
4336 | |
4337 | endLoc = clang_getLocation(tu: TU, file, line: second_line, column: second_column); |
4338 | if (clang_equalLocations(loc1: clang_getNullLocation(), loc2: endLoc)) { |
4339 | fprintf(stderr, format: "invalid source location %s:%d:%d\n", filename, |
4340 | second_line, second_column); |
4341 | errorCode = -1; |
4342 | goto teardown; |
4343 | } |
4344 | |
4345 | range = clang_getRange(begin: startLoc, end: endLoc); |
4346 | clang_tokenize(TU, Range: range, Tokens: &tokens, NumTokens: &num_tokens); |
4347 | |
4348 | if (checkForErrors(TU) != 0) { |
4349 | errorCode = -1; |
4350 | goto teardown; |
4351 | } |
4352 | |
4353 | cursors = (CXCursor *)malloc(size: num_tokens * sizeof(CXCursor)); |
4354 | assert(cursors); |
4355 | clang_annotateTokens(TU, Tokens: tokens, NumTokens: num_tokens, Cursors: cursors); |
4356 | |
4357 | if (checkForErrors(TU) != 0) { |
4358 | errorCode = -1; |
4359 | goto teardown; |
4360 | } |
4361 | |
4362 | skipped_ranges = clang_getSkippedRanges(tu: TU, file); |
4363 | for (i = 0; i != skipped_ranges->count; ++i) { |
4364 | unsigned start_line, start_column, end_line, end_column; |
4365 | clang_getFileLocation(location: clang_getRangeStart(range: skipped_ranges->ranges[i]), file: 0, |
4366 | line: &start_line, column: &start_column, offset: 0); |
4367 | clang_getFileLocation(location: clang_getRangeEnd(range: skipped_ranges->ranges[i]), file: 0, |
4368 | line: &end_line, column: &end_column, offset: 0); |
4369 | printf(format: "Skipping: "); |
4370 | PrintExtent(stdout, begin_line: start_line, begin_column: start_column, end_line, end_column); |
4371 | printf(format: "\n"); |
4372 | } |
4373 | clang_disposeSourceRangeList(ranges: skipped_ranges); |
4374 | |
4375 | for (i = 0; i != num_tokens; ++i) { |
4376 | const char *kind = "<unknown>"; |
4377 | CXString spelling = clang_getTokenSpelling(TU, tokens[i]); |
4378 | CXSourceRange extent = clang_getTokenExtent(TU, tokens[i]); |
4379 | unsigned start_line, start_column, end_line, end_column; |
4380 | |
4381 | switch (clang_getTokenKind(tokens[i])) { |
4382 | case CXToken_Punctuation: kind = "Punctuation"; break; |
4383 | case CXToken_Keyword: kind = "Keyword"; break; |
4384 | case CXToken_Identifier: kind = "Identifier"; break; |
4385 | case CXToken_Literal: kind = "Literal"; break; |
4386 | case CXToken_Comment: kind = "Comment"; break; |
4387 | } |
4388 | clang_getFileLocation(location: clang_getRangeStart(range: extent), file: 0, line: &start_line, |
4389 | column: &start_column, offset: 0); |
4390 | clang_getFileLocation(location: clang_getRangeEnd(range: extent), file: 0, line: &end_line, column: &end_column, |
4391 | offset: 0); |
4392 | printf(format: "%s: \"%s\" ", kind, clang_getCString(string: spelling)); |
4393 | clang_disposeString(string: spelling); |
4394 | PrintExtent(stdout, begin_line: start_line, begin_column: start_column, end_line, end_column); |
4395 | if (!clang_isInvalid(cursors[i].kind)) { |
4396 | printf(format: " "); |
4397 | PrintCursor(Cursor: cursors[i], NULL); |
4398 | } |
4399 | printf(format: "\n"); |
4400 | } |
4401 | free(ptr: cursors); |
4402 | clang_disposeTokens(TU, Tokens: tokens, NumTokens: num_tokens); |
4403 | |
4404 | teardown: |
4405 | PrintDiagnostics(TU); |
4406 | clang_disposeTranslationUnit(TU); |
4407 | clang_disposeIndex(index: CIdx); |
4408 | free(ptr: filename); |
4409 | free_remapped_files(unsaved_files, num_unsaved_files); |
4410 | return errorCode; |
4411 | } |
4412 | |
4413 | static int |
4414 | perform_test_compilation_db(const char *database, int argc, const char **argv) { |
4415 | CXCompilationDatabase db; |
4416 | CXCompileCommands CCmds; |
4417 | CXCompileCommand CCmd; |
4418 | CXCompilationDatabase_Error ec; |
4419 | CXString wd; |
4420 | CXString arg; |
4421 | int errorCode = 0; |
4422 | char *tmp; |
4423 | unsigned len; |
4424 | char *buildDir; |
4425 | int i, j, a, numCmds, numArgs; |
4426 | |
4427 | len = strlen(s: database); |
4428 | tmp = (char *) malloc(size: len+1); |
4429 | assert(tmp); |
4430 | memcpy(dest: tmp, src: database, n: len+1); |
4431 | buildDir = dirname(tmp); |
4432 | |
4433 | db = clang_CompilationDatabase_fromDirectory(BuildDir: buildDir, ErrorCode: &ec); |
4434 | |
4435 | if (db) { |
4436 | |
4437 | if (ec!=CXCompilationDatabase_NoError) { |
4438 | printf(format: "unexpected error %d code while loading compilation database\n", ec); |
4439 | errorCode = -1; |
4440 | goto cdb_end; |
4441 | } |
4442 | |
4443 | for (i=0; i<argc && errorCode==0; ) { |
4444 | if (strcmp(s1: argv[i],s2: "lookup")==0){ |
4445 | CCmds = clang_CompilationDatabase_getCompileCommands(db, CompleteFileName: argv[i+1]); |
4446 | |
4447 | if (!CCmds) { |
4448 | printf(format: "file %s not found in compilation db\n", argv[i+1]); |
4449 | errorCode = -1; |
4450 | break; |
4451 | } |
4452 | |
4453 | numCmds = clang_CompileCommands_getSize(CCmds); |
4454 | |
4455 | if (numCmds==0) { |
4456 | fprintf(stderr, format: "should not get an empty compileCommand set for file" |
4457 | " '%s'\n", argv[i+1]); |
4458 | errorCode = -1; |
4459 | break; |
4460 | } |
4461 | |
4462 | for (j=0; j<numCmds; ++j) { |
4463 | CCmd = clang_CompileCommands_getCommand(CCmds, I: j); |
4464 | |
4465 | wd = clang_CompileCommand_getDirectory(CCmd); |
4466 | printf(format: "workdir:'%s'", clang_getCString(string: wd)); |
4467 | clang_disposeString(string: wd); |
4468 | |
4469 | printf(format: " cmdline:'"); |
4470 | numArgs = clang_CompileCommand_getNumArgs(CCmd); |
4471 | for (a=0; a<numArgs; ++a) { |
4472 | if (a) printf(format: " "); |
4473 | arg = clang_CompileCommand_getArg(CCmd, I: a); |
4474 | printf(format: "%s", clang_getCString(string: arg)); |
4475 | clang_disposeString(string: arg); |
4476 | } |
4477 | printf(format: "'\n"); |
4478 | } |
4479 | |
4480 | clang_CompileCommands_dispose(CCmds); |
4481 | |
4482 | i += 2; |
4483 | } |
4484 | } |
4485 | clang_CompilationDatabase_dispose(db); |
4486 | } else { |
4487 | printf(format: "database loading failed with error code %d.\n", ec); |
4488 | errorCode = -1; |
4489 | } |
4490 | |
4491 | cdb_end: |
4492 | free(ptr: tmp); |
4493 | |
4494 | return errorCode; |
4495 | } |
4496 | |
4497 | /******************************************************************************/ |
4498 | /* USR printing. */ |
4499 | /******************************************************************************/ |
4500 | |
4501 | static int insufficient_usr(const char *kind, const char *usage) { |
4502 | fprintf(stderr, format: "USR for '%s' requires: %s\n", kind, usage); |
4503 | return 1; |
4504 | } |
4505 | |
4506 | static unsigned isUSR(const char *s) { |
4507 | return s[0] == 'c' && s[1] == ':'; |
4508 | } |
4509 | |
4510 | static int not_usr(const char *s, const char *arg) { |
4511 | fprintf(stderr, format: "'%s' argument ('%s') is not a USR\n", s, arg); |
4512 | return 1; |
4513 | } |
4514 | |
4515 | static void print_usr(CXString usr) { |
4516 | const char *s = clang_getCString(string: usr); |
4517 | printf(format: "%s\n", s); |
4518 | clang_disposeString(string: usr); |
4519 | } |
4520 | |
4521 | static void display_usrs(void) { |
4522 | fprintf(stderr, format: "-print-usrs options:\n" |
4523 | " ObjCCategory <class name> <category name>\n" |
4524 | " ObjCClass <class name>\n" |
4525 | " ObjCIvar <ivar name> <class USR>\n" |
4526 | " ObjCMethod <selector> [0=class method|1=instance method] " |
4527 | "<class USR>\n" |
4528 | " ObjCProperty <property name> <class USR>\n" |
4529 | " ObjCProtocol <protocol name>\n"); |
4530 | } |
4531 | |
4532 | int print_usrs(const char **I, const char **E) { |
4533 | while (I != E) { |
4534 | const char *kind = *I; |
4535 | unsigned len = strlen(s: kind); |
4536 | switch (len) { |
4537 | case 8: |
4538 | if (memcmp(s1: kind, s2: "ObjCIvar", n: 8) == 0) { |
4539 | if (I + 2 >= E) |
4540 | return insufficient_usr(kind, usage: "<ivar name> <class USR>"); |
4541 | if (!isUSR(s: I[2])) |
4542 | return not_usr(s: "<class USR>", arg: I[2]); |
4543 | else { |
4544 | CXString x = createCXString(CS: I[2]); |
4545 | print_usr(usr: clang_constructUSR_ObjCIvar(name: I[1], classUSR: x)); |
4546 | } |
4547 | |
4548 | I += 3; |
4549 | continue; |
4550 | } |
4551 | break; |
4552 | case 9: |
4553 | if (memcmp(s1: kind, s2: "ObjCClass", n: 9) == 0) { |
4554 | if (I + 1 >= E) |
4555 | return insufficient_usr(kind, usage: "<class name>"); |
4556 | print_usr(usr: clang_constructUSR_ObjCClass(class_name: I[1])); |
4557 | I += 2; |
4558 | continue; |
4559 | } |
4560 | break; |
4561 | case 10: |
4562 | if (memcmp(s1: kind, s2: "ObjCMethod", n: 10) == 0) { |
4563 | if (I + 3 >= E) |
4564 | return insufficient_usr(kind, usage: "<method selector> " |
4565 | "[0=class method|1=instance method] <class USR>"); |
4566 | if (!isUSR(s: I[3])) |
4567 | return not_usr(s: "<class USR>", arg: I[3]); |
4568 | else { |
4569 | CXString x = createCXString(CS: I[3]); |
4570 | print_usr(usr: clang_constructUSR_ObjCMethod(name: I[1], isInstanceMethod: atoi(nptr: I[2]), classUSR: x)); |
4571 | } |
4572 | I += 4; |
4573 | continue; |
4574 | } |
4575 | break; |
4576 | case 12: |
4577 | if (memcmp(s1: kind, s2: "ObjCCategory", n: 12) == 0) { |
4578 | if (I + 2 >= E) |
4579 | return insufficient_usr(kind, usage: "<class name> <category name>"); |
4580 | print_usr(usr: clang_constructUSR_ObjCCategory(class_name: I[1], category_name: I[2])); |
4581 | I += 3; |
4582 | continue; |
4583 | } |
4584 | if (memcmp(s1: kind, s2: "ObjCProtocol", n: 12) == 0) { |
4585 | if (I + 1 >= E) |
4586 | return insufficient_usr(kind, usage: "<protocol name>"); |
4587 | print_usr(usr: clang_constructUSR_ObjCProtocol(protocol_name: I[1])); |
4588 | I += 2; |
4589 | continue; |
4590 | } |
4591 | if (memcmp(s1: kind, s2: "ObjCProperty", n: 12) == 0) { |
4592 | if (I + 2 >= E) |
4593 | return insufficient_usr(kind, usage: "<property name> <class USR>"); |
4594 | if (!isUSR(s: I[2])) |
4595 | return not_usr(s: "<class USR>", arg: I[2]); |
4596 | else { |
4597 | CXString x = createCXString(CS: I[2]); |
4598 | print_usr(usr: clang_constructUSR_ObjCProperty(property: I[1], classUSR: x)); |
4599 | } |
4600 | I += 3; |
4601 | continue; |
4602 | } |
4603 | break; |
4604 | default: |
4605 | break; |
4606 | } |
4607 | break; |
4608 | } |
4609 | |
4610 | if (I != E) { |
4611 | fprintf(stderr, format: "Invalid USR kind: %s\n", *I); |
4612 | display_usrs(); |
4613 | return 1; |
4614 | } |
4615 | return 0; |
4616 | } |
4617 | |
4618 | int print_usrs_file(const char *file_name) { |
4619 | char line[2048]; |
4620 | const char *args[128]; |
4621 | unsigned numChars = 0; |
4622 | |
4623 | FILE *fp = fopen(filename: file_name, modes: "r"); |
4624 | if (!fp) { |
4625 | fprintf(stderr, format: "error: cannot open '%s'\n", file_name); |
4626 | return 1; |
4627 | } |
4628 | |
4629 | /* This code is not really all that safe, but it works fine for testing. */ |
4630 | while (!feof(stream: fp)) { |
4631 | char c = fgetc(stream: fp); |
4632 | if (c == '\n') { |
4633 | unsigned i = 0; |
4634 | const char *s = 0; |
4635 | |
4636 | if (numChars == 0) |
4637 | continue; |
4638 | |
4639 | line[numChars] = '\0'; |
4640 | numChars = 0; |
4641 | |
4642 | if (line[0] == '/' && line[1] == '/') |
4643 | continue; |
4644 | |
4645 | s = strtok(s: line, delim: " "); |
4646 | while (s) { |
4647 | args[i] = s; |
4648 | ++i; |
4649 | s = strtok(s: 0, delim: " "); |
4650 | } |
4651 | if (print_usrs(I: &args[0], E: &args[i])) |
4652 | return 1; |
4653 | } |
4654 | else |
4655 | line[numChars++] = c; |
4656 | } |
4657 | |
4658 | fclose(stream: fp); |
4659 | return 0; |
4660 | } |
4661 | |
4662 | /******************************************************************************/ |
4663 | /* Command line processing. */ |
4664 | /******************************************************************************/ |
4665 | int write_pch_file(const char *filename, int argc, const char *argv[]) { |
4666 | CXIndex Idx; |
4667 | CXTranslationUnit TU; |
4668 | struct CXUnsavedFile *unsaved_files = 0; |
4669 | int num_unsaved_files = 0; |
4670 | enum CXErrorCode Err; |
4671 | int result = 0; |
4672 | |
4673 | Idx = clang_createIndex(/* excludeDeclsFromPCH */excludeDeclarationsFromPCH: 1, /* displayDiagnostics=*/1); |
4674 | |
4675 | if (parse_remapped_files(argc, argv, start_arg: 0, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
4676 | clang_disposeIndex(index: Idx); |
4677 | return -1; |
4678 | } |
4679 | |
4680 | Err = clang_parseTranslationUnit2( |
4681 | CIdx: Idx, source_filename: 0, command_line_args: argv + num_unsaved_files, num_command_line_args: argc - num_unsaved_files, |
4682 | unsaved_files, num_unsaved_files, |
4683 | options: CXTranslationUnit_Incomplete | |
4684 | CXTranslationUnit_DetailedPreprocessingRecord | |
4685 | CXTranslationUnit_ForSerialization, |
4686 | out_TU: &TU); |
4687 | if (Err != CXError_Success) { |
4688 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
4689 | describeLibclangFailure(Err); |
4690 | free_remapped_files(unsaved_files, num_unsaved_files); |
4691 | clang_disposeTranslationUnit(TU); |
4692 | clang_disposeIndex(index: Idx); |
4693 | return 1; |
4694 | } |
4695 | |
4696 | switch (clang_saveTranslationUnit(TU, FileName: filename, |
4697 | options: clang_defaultSaveOptions(TU))) { |
4698 | case CXSaveError_None: |
4699 | break; |
4700 | |
4701 | case CXSaveError_TranslationErrors: |
4702 | fprintf(stderr, format: "Unable to write PCH file %s: translation errors\n", |
4703 | filename); |
4704 | result = 2; |
4705 | break; |
4706 | |
4707 | case CXSaveError_InvalidTU: |
4708 | fprintf(stderr, format: "Unable to write PCH file %s: invalid translation unit\n", |
4709 | filename); |
4710 | result = 3; |
4711 | break; |
4712 | |
4713 | case CXSaveError_Unknown: |
4714 | default: |
4715 | fprintf(stderr, format: "Unable to write PCH file %s: unknown error \n", filename); |
4716 | result = 1; |
4717 | break; |
4718 | } |
4719 | |
4720 | clang_disposeTranslationUnit(TU); |
4721 | free_remapped_files(unsaved_files, num_unsaved_files); |
4722 | clang_disposeIndex(index: Idx); |
4723 | return result; |
4724 | } |
4725 | |
4726 | /******************************************************************************/ |
4727 | /* Serialized diagnostics. */ |
4728 | /******************************************************************************/ |
4729 | |
4730 | static const char *getDiagnosticCodeStr(enum CXLoadDiag_Error error) { |
4731 | switch (error) { |
4732 | case CXLoadDiag_CannotLoad: return "Cannot Load File"; |
4733 | case CXLoadDiag_None: break; |
4734 | case CXLoadDiag_Unknown: return "Unknown"; |
4735 | case CXLoadDiag_InvalidFile: return "Invalid File"; |
4736 | } |
4737 | return "None"; |
4738 | } |
4739 | |
4740 | static const char *getSeverityString(enum CXDiagnosticSeverity severity) { |
4741 | switch (severity) { |
4742 | case CXDiagnostic_Note: return "note"; |
4743 | case CXDiagnostic_Error: return "error"; |
4744 | case CXDiagnostic_Fatal: return "fatal"; |
4745 | case CXDiagnostic_Ignored: return "ignored"; |
4746 | case CXDiagnostic_Warning: return "warning"; |
4747 | } |
4748 | return "unknown"; |
4749 | } |
4750 | |
4751 | static void printIndent(unsigned indent) { |
4752 | if (indent == 0) |
4753 | return; |
4754 | fprintf(stderr, format: "+"); |
4755 | --indent; |
4756 | while (indent > 0) { |
4757 | fprintf(stderr, format: "-"); |
4758 | --indent; |
4759 | } |
4760 | } |
4761 | |
4762 | static void printLocation(CXSourceLocation L) { |
4763 | CXFile File; |
4764 | CXString FileName; |
4765 | unsigned line, column, offset; |
4766 | |
4767 | clang_getExpansionLocation(location: L, file: &File, line: &line, column: &column, offset: &offset); |
4768 | FileName = clang_getFileName(SFile: File); |
4769 | |
4770 | fprintf(stderr, format: "%s:%d:%d", clang_getCString(string: FileName), line, column); |
4771 | clang_disposeString(string: FileName); |
4772 | } |
4773 | |
4774 | static void printRanges(CXDiagnostic D, unsigned indent) { |
4775 | unsigned i, n = clang_getDiagnosticNumRanges(D); |
4776 | |
4777 | for (i = 0; i < n; ++i) { |
4778 | CXSourceLocation Start, End; |
4779 | CXSourceRange SR = clang_getDiagnosticRange(Diagnostic: D, Range: i); |
4780 | Start = clang_getRangeStart(range: SR); |
4781 | End = clang_getRangeEnd(range: SR); |
4782 | |
4783 | printIndent(indent); |
4784 | fprintf(stderr, format: "Range: "); |
4785 | printLocation(L: Start); |
4786 | fprintf(stderr, format: " "); |
4787 | printLocation(L: End); |
4788 | fprintf(stderr, format: "\n"); |
4789 | } |
4790 | } |
4791 | |
4792 | static void printFixIts(CXDiagnostic D, unsigned indent) { |
4793 | unsigned i, n = clang_getDiagnosticNumFixIts(Diagnostic: D); |
4794 | fprintf(stderr, format: "Number FIXITs = %d\n", n); |
4795 | for (i = 0 ; i < n; ++i) { |
4796 | CXSourceRange ReplacementRange; |
4797 | CXString text; |
4798 | text = clang_getDiagnosticFixIt(Diagnostic: D, FixIt: i, ReplacementRange: &ReplacementRange); |
4799 | |
4800 | printIndent(indent); |
4801 | fprintf(stderr, format: "FIXIT: ("); |
4802 | printLocation(L: clang_getRangeStart(range: ReplacementRange)); |
4803 | fprintf(stderr, format: " - "); |
4804 | printLocation(L: clang_getRangeEnd(range: ReplacementRange)); |
4805 | fprintf(stderr, format: "): \"%s\"\n", clang_getCString(string: text)); |
4806 | clang_disposeString(string: text); |
4807 | } |
4808 | } |
4809 | |
4810 | static void printDiagnosticSet(CXDiagnosticSet Diags, unsigned indent) { |
4811 | unsigned i, n; |
4812 | |
4813 | if (!Diags) |
4814 | return; |
4815 | |
4816 | n = clang_getNumDiagnosticsInSet(Diags); |
4817 | for (i = 0; i < n; ++i) { |
4818 | CXSourceLocation DiagLoc; |
4819 | CXDiagnostic D; |
4820 | CXFile File; |
4821 | CXString FileName, DiagSpelling, DiagOption, DiagCat; |
4822 | unsigned line, column, offset; |
4823 | const char *FileNameStr = 0, *DiagOptionStr = 0, *DiagCatStr = 0; |
4824 | |
4825 | D = clang_getDiagnosticInSet(Diags, Index: i); |
4826 | DiagLoc = clang_getDiagnosticLocation(D); |
4827 | clang_getExpansionLocation(location: DiagLoc, file: &File, line: &line, column: &column, offset: &offset); |
4828 | FileName = clang_getFileName(SFile: File); |
4829 | FileNameStr = clang_getCString(string: FileName); |
4830 | DiagSpelling = clang_getDiagnosticSpelling(D); |
4831 | |
4832 | printIndent(indent); |
4833 | |
4834 | fprintf(stderr, format: "%s:%d:%d: %s: %s", |
4835 | FileNameStr ? FileNameStr : "(null)", |
4836 | line, |
4837 | column, |
4838 | getSeverityString(severity: clang_getDiagnosticSeverity(D)), |
4839 | clang_getCString(string: DiagSpelling)); |
4840 | |
4841 | DiagOption = clang_getDiagnosticOption(Diag: D, Disable: 0); |
4842 | DiagOptionStr = clang_getCString(string: DiagOption); |
4843 | if (DiagOptionStr) { |
4844 | fprintf(stderr, format: " [%s]", DiagOptionStr); |
4845 | } |
4846 | |
4847 | DiagCat = clang_getDiagnosticCategoryText(D); |
4848 | DiagCatStr = clang_getCString(string: DiagCat); |
4849 | if (DiagCatStr) { |
4850 | fprintf(stderr, format: " [%s]", DiagCatStr); |
4851 | } |
4852 | |
4853 | fprintf(stderr, format: "\n"); |
4854 | |
4855 | printRanges(D, indent); |
4856 | printFixIts(D, indent); |
4857 | |
4858 | /* Print subdiagnostics. */ |
4859 | printDiagnosticSet(Diags: clang_getChildDiagnostics(D), indent: indent+2); |
4860 | |
4861 | clang_disposeString(string: FileName); |
4862 | clang_disposeString(string: DiagSpelling); |
4863 | clang_disposeString(string: DiagOption); |
4864 | clang_disposeString(string: DiagCat); |
4865 | } |
4866 | } |
4867 | |
4868 | static int read_diagnostics(const char *filename) { |
4869 | enum CXLoadDiag_Error error; |
4870 | CXString errorString; |
4871 | CXDiagnosticSet Diags = 0; |
4872 | |
4873 | Diags = clang_loadDiagnostics(file: filename, error: &error, errorString: &errorString); |
4874 | if (!Diags) { |
4875 | fprintf(stderr, format: "Trouble deserializing file (%s): %s\n", |
4876 | getDiagnosticCodeStr(error), |
4877 | clang_getCString(string: errorString)); |
4878 | clang_disposeString(string: errorString); |
4879 | return 1; |
4880 | } |
4881 | |
4882 | printDiagnosticSet(Diags, indent: 0); |
4883 | fprintf(stderr, format: "Number of diagnostics: %d\n", |
4884 | clang_getNumDiagnosticsInSet(Diags)); |
4885 | clang_disposeDiagnosticSet(Diags); |
4886 | return 0; |
4887 | } |
4888 | |
4889 | static int perform_print_build_session_timestamp(void) { |
4890 | printf(format: "%lld\n", clang_getBuildSessionTimestamp()); |
4891 | return 0; |
4892 | } |
4893 | |
4894 | static int perform_test_single_symbol_sgf(const char *input, int argc, |
4895 | const char *argv[]) { |
4896 | CXIndex Idx; |
4897 | CXTranslationUnit TU; |
4898 | CXAPISet API; |
4899 | struct CXUnsavedFile *unsaved_files = 0; |
4900 | int num_unsaved_files = 0; |
4901 | enum CXErrorCode Err; |
4902 | int result = 0; |
4903 | CXString SGF; |
4904 | const char *usr; |
4905 | |
4906 | usr = input + strlen(s: "-single-symbol-sgf-for="); |
4907 | |
4908 | Idx = createIndexWithInvocationEmissionPath(/* excludeDeclsFromPCH */ ExcludeDeclarationsFromPCH: 1, |
4909 | /* displayDiagnostics=*/DisplayDiagnostics: 0); |
4910 | if (!Idx) |
4911 | return -1; |
4912 | |
4913 | if (parse_remapped_files(argc, argv, start_arg: 0, unsaved_files: &unsaved_files, num_unsaved_files: &num_unsaved_files)) { |
4914 | result = -1; |
4915 | goto dispose_index; |
4916 | } |
4917 | |
4918 | Err = clang_parseTranslationUnit2( |
4919 | CIdx: Idx, source_filename: 0, command_line_args: argv + num_unsaved_files, num_command_line_args: argc - num_unsaved_files, unsaved_files, |
4920 | num_unsaved_files, options: getDefaultParsingOptions(), out_TU: &TU); |
4921 | if (Err != CXError_Success) { |
4922 | fprintf(stderr, format: "Unable to load translation unit!\n"); |
4923 | describeLibclangFailure(Err); |
4924 | result = 1; |
4925 | goto free_remapped_files; |
4926 | } |
4927 | |
4928 | Err = clang_createAPISet(tu: TU, out_api: &API); |
4929 | if (Err != CXError_Success) { |
4930 | fprintf(stderr, |
4931 | format: "Unable to create API Set for API information extraction!\n"); |
4932 | result = 2; |
4933 | goto dispose_tu; |
4934 | } |
4935 | |
4936 | SGF = clang_getSymbolGraphForUSR(usr, api: API); |
4937 | printf(format: "%s", clang_getCString(string: SGF)); |
4938 | |
4939 | clang_disposeString(string: SGF); |
4940 | clang_disposeAPISet(api: API); |
4941 | dispose_tu: |
4942 | clang_disposeTranslationUnit(TU); |
4943 | free_remapped_files: |
4944 | free_remapped_files(unsaved_files, num_unsaved_files); |
4945 | dispose_index: |
4946 | clang_disposeIndex(index: Idx); |
4947 | return result; |
4948 | } |
4949 | |
4950 | static void inspect_single_symbol_sgf_cursor(CXCursor Cursor) { |
4951 | CXSourceLocation CursorLoc; |
4952 | CXString SGFData; |
4953 | const char *SGF; |
4954 | unsigned line, column; |
4955 | CursorLoc = clang_getCursorLocation(Cursor); |
4956 | clang_getSpellingLocation(location: CursorLoc, file: 0, line: &line, column: &column, offset: 0); |
4957 | |
4958 | SGFData = clang_getSymbolGraphForCursor(cursor: Cursor); |
4959 | SGF = clang_getCString(string: SGFData); |
4960 | if (SGF) |
4961 | printf(format: "%d:%d: %s\n", line, column, SGF); |
4962 | |
4963 | clang_disposeString(string: SGFData); |
4964 | } |
4965 | |
4966 | /******************************************************************************/ |
4967 | /* Command line processing. */ |
4968 | /******************************************************************************/ |
4969 | |
4970 | static CXCursorVisitor GetVisitor(const char *s) { |
4971 | if (s[0] == '\0') |
4972 | return FilteredPrintingVisitor; |
4973 | if (strcmp(s1: s, s2: "-usrs") == 0) |
4974 | return USRVisitor; |
4975 | if (strncmp(s1: s, s2: "-memory-usage", n: 13) == 0) |
4976 | return GetVisitor(s: s + 13); |
4977 | return NULL; |
4978 | } |
4979 | |
4980 | static void print_usage(void) { |
4981 | fprintf(stderr, |
4982 | format: "usage: c-index-test -code-completion-at=<site> <compiler arguments>\n" |
4983 | " c-index-test -code-completion-timing=<site> <compiler arguments>\n" |
4984 | " c-index-test -cursor-at=<site> <compiler arguments>\n" |
4985 | " c-index-test -evaluate-cursor-at=<site> <compiler arguments>\n" |
4986 | " c-index-test -get-macro-info-cursor-at=<site> <compiler arguments>\n" |
4987 | " c-index-test -file-refs-at=<site> <compiler arguments>\n" |
4988 | " c-index-test -file-includes-in=<filename> <compiler arguments>\n"); |
4989 | fprintf(stderr, |
4990 | format: " c-index-test -index-file [-check-prefix=<FileCheck prefix>] <compiler arguments>\n" |
4991 | " c-index-test -index-file-full [-check-prefix=<FileCheck prefix>] <compiler arguments>\n" |
4992 | " c-index-test -index-tu [-check-prefix=<FileCheck prefix>] <AST file>\n" |
4993 | " c-index-test -index-compile-db [-check-prefix=<FileCheck prefix>] <compilation database>\n" |
4994 | " c-index-test -test-file-scan <AST file> <source file> " |
4995 | "[FileCheck prefix]\n"); |
4996 | fprintf(stderr, |
4997 | format: " c-index-test -test-load-tu <AST file> <symbol filter> " |
4998 | "[FileCheck prefix]\n" |
4999 | " c-index-test -test-load-tu-usrs <AST file> <symbol filter> " |
5000 | "[FileCheck prefix]\n" |
5001 | " c-index-test -test-load-source <symbol filter> {<args>}*\n"); |
5002 | fprintf(stderr, |
5003 | format: " c-index-test -test-load-source-memory-usage " |
5004 | "<symbol filter> {<args>}*\n" |
5005 | " c-index-test -test-load-source-reparse <trials> <symbol filter> " |
5006 | " {<args>}*\n" |
5007 | " c-index-test -test-load-source-usrs <symbol filter> {<args>}*\n" |
5008 | " c-index-test -test-load-source-usrs-memory-usage " |
5009 | "<symbol filter> {<args>}*\n" |
5010 | " c-index-test -test-annotate-tokens=<range> {<args>}*\n" |
5011 | " c-index-test -test-inclusion-stack-source {<args>}*\n" |
5012 | " c-index-test -test-inclusion-stack-tu <AST file>\n"); |
5013 | fprintf(stderr, |
5014 | format: " c-index-test -test-print-linkage-source {<args>}*\n" |
5015 | " c-index-test -test-print-visibility {<args>}*\n" |
5016 | " c-index-test -test-print-type {<args>}*\n" |
5017 | " c-index-test -test-print-type-size {<args>}*\n" |
5018 | " c-index-test -test-print-bitwidth {<args>}*\n" |
5019 | " c-index-test -test-print-target-info {<args>}*\n" |
5020 | " c-index-test -test-print-type-declaration {<args>}*\n" |
5021 | " c-index-test -print-usr [<CursorKind> {<args>}]*\n" |
5022 | " c-index-test -print-usr-file <file>\n"); |
5023 | fprintf(stderr, |
5024 | format: " c-index-test -single-symbol-sgfs <symbol filter> {<args>*}\n" |
5025 | " c-index-test -single-symbol-sgf-at=<site> {<args>*}\n" |
5026 | " c-index-test -single-symbol-sgf-for=<usr> {<args>}*\n"); |
5027 | fprintf(stderr, |
5028 | format: " c-index-test -write-pch <file> <compiler arguments>\n" |
5029 | " c-index-test -compilation-db [lookup <filename>] database\n"); |
5030 | fprintf(stderr, |
5031 | format: " c-index-test -print-build-session-timestamp\n"); |
5032 | fprintf(stderr, |
5033 | format: " c-index-test -read-diagnostics <file>\n\n"); |
5034 | fprintf(stderr, |
5035 | format: " <symbol filter> values:\n%s", |
5036 | " all - load all symbols, including those from PCH\n" |
5037 | " local - load all symbols except those in PCH\n" |
5038 | " category - only load ObjC categories (non-PCH)\n" |
5039 | " interface - only load ObjC interfaces (non-PCH)\n" |
5040 | " protocol - only load ObjC protocols (non-PCH)\n" |
5041 | " function - only load functions (non-PCH)\n" |
5042 | " typedef - only load typdefs (non-PCH)\n" |
5043 | " scan-function - scan function bodies (non-PCH)\n\n"); |
5044 | } |
5045 | |
5046 | /***/ |
5047 | |
5048 | int cindextest_main(int argc, const char **argv) { |
5049 | clang_enableStackTraces(); |
5050 | if (argc > 2 && strcmp(s1: argv[1], s2: "-read-diagnostics") == 0) |
5051 | return read_diagnostics(filename: argv[2]); |
5052 | if (argc > 2 && strstr(haystack: argv[1], needle: "-code-completion-at=") == argv[1]) |
5053 | return perform_code_completion(argc, argv, timing_only: 0); |
5054 | if (argc > 2 && strstr(haystack: argv[1], needle: "-code-completion-timing=") == argv[1]) |
5055 | return perform_code_completion(argc, argv, timing_only: 1); |
5056 | if (argc > 2 && strstr(haystack: argv[1], needle: "-cursor-at=") == argv[1]) |
5057 | return inspect_cursor_at(argc, argv, locations_flag: "-cursor-at=", handler: inspect_print_cursor); |
5058 | if (argc > 2 && strstr(haystack: argv[1], needle: "-evaluate-cursor-at=") == argv[1]) |
5059 | return inspect_cursor_at(argc, argv, locations_flag: "-evaluate-cursor-at=", |
5060 | handler: inspect_evaluate_cursor); |
5061 | if (argc > 2 && strstr(haystack: argv[1], needle: "-get-macro-info-cursor-at=") == argv[1]) |
5062 | return inspect_cursor_at(argc, argv, locations_flag: "-get-macro-info-cursor-at=", |
5063 | handler: inspect_macroinfo_cursor); |
5064 | if (argc > 2 && strstr(haystack: argv[1], needle: "-file-refs-at=") == argv[1]) |
5065 | return find_file_refs_at(argc, argv); |
5066 | if (argc > 2 && strstr(haystack: argv[1], needle: "-file-includes-in=") == argv[1]) |
5067 | return find_file_includes_in(argc, argv); |
5068 | if (argc > 2 && strcmp(s1: argv[1], s2: "-index-file") == 0) |
5069 | return index_file(argc: argc - 2, argv: argv + 2, /*full=*/0); |
5070 | if (argc > 2 && strcmp(s1: argv[1], s2: "-index-file-full") == 0) |
5071 | return index_file(argc: argc - 2, argv: argv + 2, /*full=*/1); |
5072 | if (argc > 2 && strcmp(s1: argv[1], s2: "-index-tu") == 0) |
5073 | return index_tu(argc: argc - 2, argv: argv + 2); |
5074 | if (argc > 2 && strcmp(s1: argv[1], s2: "-index-compile-db") == 0) |
5075 | return index_compile_db(argc: argc - 2, argv: argv + 2); |
5076 | else if (argc >= 4 && strncmp(s1: argv[1], s2: "-test-load-tu", n: 13) == 0) { |
5077 | CXCursorVisitor I = GetVisitor(s: argv[1] + 13); |
5078 | if (I) |
5079 | return perform_test_load_tu(file: argv[2], filter: argv[3], prefix: argc >= 5 ? argv[4] : 0, Visitor: I, |
5080 | NULL); |
5081 | } |
5082 | else if (argc >= 5 && strncmp(s1: argv[1], s2: "-test-load-source-reparse", n: 25) == 0){ |
5083 | CXCursorVisitor I = GetVisitor(s: argv[1] + 25); |
5084 | if (I) { |
5085 | int trials = atoi(nptr: argv[2]); |
5086 | return perform_test_reparse_source(argc: argc - 4, argv: argv + 4, trials, filter: argv[3], Visitor: I, |
5087 | NULL); |
5088 | } |
5089 | } |
5090 | else if (argc >= 4 && strncmp(s1: argv[1], s2: "-test-load-source", n: 17) == 0) { |
5091 | CXCursorVisitor I = GetVisitor(s: argv[1] + 17); |
5092 | |
5093 | PostVisitTU postVisit = 0; |
5094 | if (strstr(haystack: argv[1], needle: "-memory-usage")) |
5095 | postVisit = PrintMemoryUsage; |
5096 | |
5097 | if (I) |
5098 | return perform_test_load_source(argc: argc - 3, argv: argv + 3, filter: argv[2], Visitor: I, |
5099 | PV: postVisit); |
5100 | } |
5101 | else if (argc >= 3 && strcmp(s1: argv[1], s2: "-single-file-parse") == 0) |
5102 | return perform_single_file_parse(filename: argv[2]); |
5103 | else if (argc >= 3 && strcmp(s1: argv[1], s2: "-retain-excluded-conditional-blocks") == 0) |
5104 | return perform_file_retain_excluded_cb(filename: argv[2]); |
5105 | else if (argc >= 4 && strcmp(s1: argv[1], s2: "-test-file-scan") == 0) |
5106 | return perform_file_scan(ast_file: argv[2], source_file: argv[3], |
5107 | prefix: argc >= 5 ? argv[4] : 0); |
5108 | else if (argc > 2 && strstr(haystack: argv[1], needle: "-test-annotate-tokens=") == argv[1]) |
5109 | return perform_token_annotation(argc, argv); |
5110 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-inclusion-stack-source") == 0) |
5111 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", NULL, |
5112 | PV: PrintInclusionStack); |
5113 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-inclusion-stack-tu") == 0) |
5114 | return perform_test_load_tu(file: argv[2], filter: "all", NULL, NULL, |
5115 | PV: PrintInclusionStack); |
5116 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-linkage-source") == 0) |
5117 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", Visitor: PrintLinkage, |
5118 | NULL); |
5119 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-visibility") == 0) |
5120 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", Visitor: PrintVisibility, |
5121 | NULL); |
5122 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-type") == 0) |
5123 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", |
5124 | Visitor: PrintType, PV: 0); |
5125 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-type-size") == 0) |
5126 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", |
5127 | Visitor: PrintTypeSize, PV: 0); |
5128 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-type-declaration") == 0) |
5129 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", |
5130 | Visitor: PrintTypeDeclaration, PV: 0); |
5131 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-decl-attributes") == 0) |
5132 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", |
5133 | Visitor: PrintDeclAttributes, PV: 0); |
5134 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-bitwidth") == 0) |
5135 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", |
5136 | Visitor: PrintBitWidth, PV: 0); |
5137 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-binops") == 0) |
5138 | return perform_test_load_source(argc: argc - 2, argv: argv + 2, filter: "all", Visitor: PrintBinOps, PV: 0); |
5139 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-mangle") == 0) |
5140 | return perform_test_load_tu(file: argv[2], filter: "all", NULL, Visitor: PrintMangledName, NULL); |
5141 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-manglings") == 0) |
5142 | return perform_test_load_tu(file: argv[2], filter: "all", NULL, Visitor: PrintManglings, NULL); |
5143 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-test-print-target-info") == 0) |
5144 | return print_target_info(argc: argc - 2, argv: argv + 2); |
5145 | else if (argc > 1 && strcmp(s1: argv[1], s2: "-print-usr") == 0) { |
5146 | if (argc > 2) |
5147 | return print_usrs(I: argv + 2, E: argv + argc); |
5148 | else { |
5149 | display_usrs(); |
5150 | return 1; |
5151 | } |
5152 | } |
5153 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-print-usr-file") == 0) |
5154 | return print_usrs_file(file_name: argv[2]); |
5155 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-write-pch") == 0) |
5156 | return write_pch_file(filename: argv[2], argc: argc - 3, argv: argv + 3); |
5157 | else if (argc > 2 && strcmp(s1: argv[1], s2: "-compilation-db") == 0) |
5158 | return perform_test_compilation_db(database: argv[argc-1], argc: argc - 3, argv: argv + 2); |
5159 | else if (argc == 2 && strcmp(s1: argv[1], s2: "-print-build-session-timestamp") == 0) |
5160 | return perform_print_build_session_timestamp(); |
5161 | else if (argc > 3 && strcmp(s1: argv[1], s2: "-single-symbol-sgfs") == 0) |
5162 | return perform_test_load_source(argc: argc - 3, argv: argv + 3, filter: argv[2], |
5163 | Visitor: PrintSingleSymbolSGFs, NULL); |
5164 | else if (argc > 2 && strstr(haystack: argv[1], needle: "-single-symbol-sgf-at=") == argv[1]) |
5165 | return inspect_cursor_at( |
5166 | argc, argv, locations_flag: "-single-symbol-sgf-at=", handler: inspect_single_symbol_sgf_cursor); |
5167 | else if (argc > 2 && strstr(haystack: argv[1], needle: "-single-symbol-sgf-for=") == argv[1]) |
5168 | return perform_test_single_symbol_sgf(input: argv[1], argc: argc - 2, argv: argv + 2); |
5169 | |
5170 | print_usage(); |
5171 | return 1; |
5172 | } |
5173 | |
5174 | /***/ |
5175 | |
5176 | /* We intentionally run in a separate thread to ensure we at least minimal |
5177 | * testing of a multithreaded environment (for example, having a reduced stack |
5178 | * size). */ |
5179 | |
5180 | typedef struct thread_info { |
5181 | int (*main_func)(int argc, const char **argv); |
5182 | int argc; |
5183 | const char **argv; |
5184 | int result; |
5185 | } thread_info; |
5186 | void thread_runner(void *client_data_v) { |
5187 | thread_info *client_data = client_data_v; |
5188 | client_data->result = client_data->main_func(client_data->argc, |
5189 | client_data->argv); |
5190 | } |
5191 | |
5192 | static void flush_atexit(void) { |
5193 | /* stdout, and surprisingly even stderr, are not always flushed on process |
5194 | * and thread exit, particularly when the system is under heavy load. */ |
5195 | fflush(stdout); |
5196 | fflush(stderr); |
5197 | } |
5198 | |
5199 | int main(int argc, const char **argv) { |
5200 | thread_info client_data; |
5201 | |
5202 | #ifdef __MVS__ |
5203 | if (enablezOSAutoConversion(fileno(stdout)) == -1) |
5204 | fprintf(stderr, "Setting conversion on stdout failed\n"); |
5205 | |
5206 | if (enablezOSAutoConversion(fileno(stderr)) == -1) |
5207 | fprintf(stderr, "Setting conversion on stderr failed\n"); |
5208 | #endif |
5209 | |
5210 | atexit(func: flush_atexit); |
5211 | |
5212 | #ifdef CLANG_HAVE_LIBXML |
5213 | LIBXML_TEST_VERSION |
5214 | #endif |
5215 | |
5216 | if (argc > 1 && strcmp(s1: argv[1], s2: "core") == 0) |
5217 | return indextest_core_main(argc, argv); |
5218 | |
5219 | client_data.main_func = cindextest_main; |
5220 | client_data.argc = argc; |
5221 | client_data.argv = argv; |
5222 | |
5223 | if (getenv(name: "CINDEXTEST_NOTHREADS")) |
5224 | return client_data.main_func(client_data.argc, client_data.argv); |
5225 | |
5226 | clang_executeOnThread(fn: thread_runner, user_data: &client_data, stack_size: 0); |
5227 | return client_data.result; |
5228 | } |
5229 |
Definitions
- createIndexWithInvocationEmissionPath
- getDefaultParsingOptions
- ModifyPrintingPolicyAccordingToEnv
- describeLibclangFailure
- PrintExtent
- CreateTranslationUnit
- free_remapped_files
- parse_remapped_files_with_opt
- parse_remapped_files
- parse_remapped_files_with_try
- parse_comments_schema
- FileCheckPrefix
- PrintCString
- PrintCStringWithPrefix
- PrintCXStringAndDispose
- PrintCXStringWithPrefix
- PrintCXStringWithPrefixAndDispose
- PrintRange
- DisplayType
- wanted_display_type
- printVersion
- CommentASTDumpingContext
- DumpCXCommentInternal
- DumpCXComment
- ValidateCommentXML
- PrintCursorComments
- lineCol_cmp
- CursorToText
- PrintCursor
- createCXString
- duplicateCXString
- GetCursorSource
- PrintDiagnostic
- PrintDiagnosticSet
- PrintDiagnostics
- PrintMemoryUsage
- PrintCursorExtent
- FilteredPrintingVisitor
- FunctionScanVisitor
- USRVisitor
- InclusionVisitor
- PrintInclusionStack
- PrintLinkage
- PrintVisibility
- PrintTypeAndTypeKind
- FieldVisitor
- PrintTypeTemplateArgs
- PrintNullabilityKind
- PrintType
- PrintSingleTypeSize
- PrintTypeSize
- PrintBinOps
- PrintMangledName
- PrintManglings
- PrintSingleSymbolSGFs
- PrintBitWidth
- PrintTypeDeclaration
- PrintDeclAttributes
- print_target_info
- perform_test_load
- perform_test_load_tu
- perform_test_load_source
- perform_test_reparse_source
- perform_single_file_parse
- perform_file_retain_excluded_cb
- print_cursor_file_scan
- perform_file_scan
- parse_file_line_column
- clang_getCompletionChunkKindSpelling
- checkForErrors
- print_completion_string
- print_line_column
- print_token_range
- print_completion_result
- print_completion_contexts
- perform_code_completion
- inspect_cursor_at
- inspect_print_cursor
- display_evaluate_results
- inspect_evaluate_cursor
- inspect_macroinfo_cursor
- findFileRefsVisit
- find_file_refs_at
- findFileIncludesVisit
- find_file_includes_in
- importedASTs_create
- importedASTs_dispose
- importedASTS_insert
- IndexDataStringList_
- free_client_data
- printCheck
- printCXIndexFile
- printCXIndexLoc
- digitCount
- makeClientContainer
- printCXIndexContainer
- getEntityKindString
- getEntityTemplateKindString
- getEntityLanguageString
- printEntityInfo
- printBaseClassInfo
- printProtocolList
- printSymbolRole
- index_diagnostic
- index_enteredMainFile
- index_ppIncludedFile
- index_importedASTFile
- index_startedTranslationUnit
- index_indexDeclaration
- index_indexEntityReference
- index_abortQuery
- IndexCB
- getIndexOptions
- index_compile_args
- index_ast_file
- index_file
- index_tu
- index_compile_db
- perform_token_annotation
- perform_test_compilation_db
- insufficient_usr
- isUSR
- not_usr
- print_usr
- display_usrs
- print_usrs
- print_usrs_file
- write_pch_file
- getDiagnosticCodeStr
- getSeverityString
- printIndent
- printLocation
- printRanges
- printFixIts
- printDiagnosticSet
- read_diagnostics
- perform_print_build_session_timestamp
- perform_test_single_symbol_sgf
- inspect_single_symbol_sgf_cursor
- GetVisitor
- print_usage
- cindextest_main
- thread_info
- thread_runner
- flush_atexit
Improve your Profiling and Debugging skills
Find out more