c-index-test.c revision b83d4d7071cea43a3f7b8afc3cda6203c345aa0f 
1/* c-index-test.c */
2
3#include "clang-c/Index.h"
4#include <ctype.h>
5#include <stdlib.h>
6#include <stdio.h>
7#include <string.h>
8#include <assert.h>
9
10/******************************************************************************/
11/* Utility functions.                                                         */
12/******************************************************************************/
13
14#ifdef _MSC_VER
15char *basename(const char* path)
16{
17    char* base1 = (char*)strrchr(path, '/');
18    char* base2 = (char*)strrchr(path, '\\');
19    if (base1 && base2)
20        return((base1 > base2) ? base1 + 1 : base2 + 1);
21    else if (base1)
22        return(base1 + 1);
23    else if (base2)
24        return(base2 + 1);
25
26    return((char*)path);
27}
28#else
29extern char *basename(const char *);
30#endif
31
32/** \brief Return the default parsing options. */
33static unsigned getDefaultParsingOptions() {
34  unsigned options = CXTranslationUnit_DetailedPreprocessingRecord;
35
36  if (getenv("CINDEXTEST_EDITING"))
37    options |= clang_defaultEditingTranslationUnitOptions();
38  if (getenv("CINDEXTEST_COMPLETION_CACHING"))
39    options |= CXTranslationUnit_CacheCompletionResults;
40  if (getenv("CINDEXTEST_NESTED_MACROS"))
41    options |= CXTranslationUnit_NestedMacroInstantiations;
42
43  return options;
44}
45
46static void PrintExtent(FILE *out, unsigned begin_line, unsigned begin_column,
47                        unsigned end_line, unsigned end_column) {
48  fprintf(out, "[%d:%d - %d:%d]", begin_line, begin_column,
49          end_line, end_column);
50}
51
52static unsigned CreateTranslationUnit(CXIndex Idx, const char *file,
53                                      CXTranslationUnit *TU) {
54
55  *TU = clang_createTranslationUnit(Idx, file);
56  if (!*TU) {
57    fprintf(stderr, "Unable to load translation unit from '%s'!\n", file);
58    return 0;
59  }
60  return 1;
61}
62
63void free_remapped_files(struct CXUnsavedFile *unsaved_files,
64                         int num_unsaved_files) {
65  int i;
66  for (i = 0; i != num_unsaved_files; ++i) {
67    free((char *)unsaved_files[i].Filename);
68    free((char *)unsaved_files[i].Contents);
69  }
70  free(unsaved_files);
71}
72
73int parse_remapped_files(int argc, const char **argv, int start_arg,
74                         struct CXUnsavedFile **unsaved_files,
75                         int *num_unsaved_files) {
76  int i;
77  int arg;
78  int prefix_len = strlen("-remap-file=");
79  *unsaved_files = 0;
80  *num_unsaved_files = 0;
81
82  /* Count the number of remapped files. */
83  for (arg = start_arg; arg < argc; ++arg) {
84    if (strncmp(argv[arg], "-remap-file=", prefix_len))
85      break;
86
87    ++*num_unsaved_files;
88  }
89
90  if (*num_unsaved_files == 0)
91    return 0;
92
93  *unsaved_files
94    = (struct CXUnsavedFile *)malloc(sizeof(struct CXUnsavedFile) *
95                                     *num_unsaved_files);
96  for (arg = start_arg, i = 0; i != *num_unsaved_files; ++i, ++arg) {
97    struct CXUnsavedFile *unsaved = *unsaved_files + i;
98    const char *arg_string = argv[arg] + prefix_len;
99    int filename_len;
100    char *filename;
101    char *contents;
102    FILE *to_file;
103    const char *semi = strchr(arg_string, ';');
104    if (!semi) {
105      fprintf(stderr,
106              "error: -remap-file=from;to argument is missing semicolon\n");
107      free_remapped_files(*unsaved_files, i);
108      *unsaved_files = 0;
109      *num_unsaved_files = 0;
110      return -1;
111    }
112
113    /* Open the file that we're remapping to. */
114    to_file = fopen(semi + 1, "rb");
115    if (!to_file) {
116      fprintf(stderr, "error: cannot open file %s that we are remapping to\n",
117              semi + 1);
118      free_remapped_files(*unsaved_files, i);
119      *unsaved_files = 0;
120      *num_unsaved_files = 0;
121      return -1;
122    }
123
124    /* Determine the length of the file we're remapping to. */
125    fseek(to_file, 0, SEEK_END);
126    unsaved->Length = ftell(to_file);
127    fseek(to_file, 0, SEEK_SET);
128
129    /* Read the contents of the file we're remapping to. */
130    contents = (char *)malloc(unsaved->Length + 1);
131    if (fread(contents, 1, unsaved->Length, to_file) != unsaved->Length) {
132      fprintf(stderr, "error: unexpected %s reading 'to' file %s\n",
133              (feof(to_file) ? "EOF" : "error"), semi + 1);
134      fclose(to_file);
135      free_remapped_files(*unsaved_files, i);
136      *unsaved_files = 0;
137      *num_unsaved_files = 0;
138      return -1;
139    }
140    contents[unsaved->Length] = 0;
141    unsaved->Contents = contents;
142
143    /* Close the file. */
144    fclose(to_file);
145
146    /* Copy the file name that we're remapping from. */
147    filename_len = semi - arg_string;
148    filename = (char *)malloc(filename_len + 1);
149    memcpy(filename, arg_string, filename_len);
150    filename[filename_len] = 0;
151    unsaved->Filename = filename;
152  }
153
154  return 0;
155}
156
157/******************************************************************************/
158/* Pretty-printing.                                                           */
159/******************************************************************************/
160
161int want_display_name = 0;
162
163static void PrintCursor(CXTranslationUnit TU, CXCursor Cursor) {
164  if (clang_isInvalid(Cursor.kind)) {
165    CXString ks = clang_getCursorKindSpelling(Cursor.kind);
166    printf("Invalid Cursor => %s", clang_getCString(ks));
167    clang_disposeString(ks);
168  }
169  else {
170    CXString string, ks;
171    CXCursor Referenced;
172    unsigned line, column;
173    CXCursor SpecializationOf;
174    CXCursor *overridden;
175    unsigned num_overridden;
176
177    ks = clang_getCursorKindSpelling(Cursor.kind);
178    string = want_display_name? clang_getCursorDisplayName(Cursor)
179                              : clang_getCursorSpelling(Cursor);
180    printf("%s=%s", clang_getCString(ks),
181                    clang_getCString(string));
182    clang_disposeString(ks);
183    clang_disposeString(string);
184
185    Referenced = clang_getCursorReferenced(Cursor);
186    if (!clang_equalCursors(Referenced, clang_getNullCursor())) {
187      if (clang_getCursorKind(Referenced) == CXCursor_OverloadedDeclRef) {
188        unsigned I, N = clang_getNumOverloadedDecls(Referenced);
189        printf("[");
190        for (I = 0; I != N; ++I) {
191          CXCursor Ovl = clang_getOverloadedDecl(Referenced, I);
192          CXSourceLocation Loc;
193          if (I)
194            printf(", ");
195
196          Loc = clang_getCursorLocation(Ovl);
197          clang_getSpellingLocation(Loc, 0, &line, &column, 0);
198          printf("%d:%d", line, column);
199        }
200        printf("]");
201      } else {
202        CXSourceLocation Loc = clang_getCursorLocation(Referenced);
203        clang_getSpellingLocation(Loc, 0, &line, &column, 0);
204        printf(":%d:%d", line, column);
205      }
206    }
207
208    if (clang_isCursorDefinition(Cursor))
209      printf(" (Definition)");
210
211    switch (clang_getCursorAvailability(Cursor)) {
212      case CXAvailability_Available:
213        break;
214
215      case CXAvailability_Deprecated:
216        printf(" (deprecated)");
217        break;
218
219      case CXAvailability_NotAvailable:
220        printf(" (unavailable)");
221        break;
222    }
223
224    if (clang_CXXMethod_isStatic(Cursor))
225      printf(" (static)");
226    if (clang_CXXMethod_isVirtual(Cursor))
227      printf(" (virtual)");
228
229    if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
230      CXType T =
231        clang_getCanonicalType(clang_getIBOutletCollectionType(Cursor));
232      CXString S = clang_getTypeKindSpelling(T.kind);
233      printf(" [IBOutletCollection=%s]", clang_getCString(S));
234      clang_disposeString(S);
235    }
236
237    if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
238      enum CX_CXXAccessSpecifier access = clang_getCXXAccessSpecifier(Cursor);
239      unsigned isVirtual = clang_isVirtualBase(Cursor);
240      const char *accessStr = 0;
241
242      switch (access) {
243        case CX_CXXInvalidAccessSpecifier:
244          accessStr = "invalid"; break;
245        case CX_CXXPublic:
246          accessStr = "public"; break;
247        case CX_CXXProtected:
248          accessStr = "protected"; break;
249        case CX_CXXPrivate:
250          accessStr = "private"; break;
251      }
252
253      printf(" [access=%s isVirtual=%s]", accessStr,
254             isVirtual ? "true" : "false");
255    }
256
257    SpecializationOf = clang_getSpecializedCursorTemplate(Cursor);
258    if (!clang_equalCursors(SpecializationOf, clang_getNullCursor())) {
259      CXSourceLocation Loc = clang_getCursorLocation(SpecializationOf);
260      CXString Name = clang_getCursorSpelling(SpecializationOf);
261      clang_getSpellingLocation(Loc, 0, &line, &column, 0);
262      printf(" [Specialization of %s:%d:%d]",
263             clang_getCString(Name), line, column);
264      clang_disposeString(Name);
265    }
266
267    clang_getOverriddenCursors(Cursor, &overridden, &num_overridden);
268    if (num_overridden) {
269      unsigned I;
270      printf(" [Overrides ");
271      for (I = 0; I != num_overridden; ++I) {
272        CXSourceLocation Loc = clang_getCursorLocation(overridden[I]);
273        clang_getSpellingLocation(Loc, 0, &line, &column, 0);
274        if (I)
275          printf(", ");
276        printf("@%d:%d", line, column);
277      }
278      printf("]");
279      clang_disposeOverriddenCursors(overridden);
280    }
281
282    if (Cursor.kind == CXCursor_InclusionDirective) {
283      CXFile File = clang_getIncludedFile(Cursor);
284      CXString Included = clang_getFileName(File);
285      printf(" (%s)", clang_getCString(Included));
286      clang_disposeString(Included);
287
288      if (clang_isFileMultipleIncludeGuarded(TU, File))
289        printf("  [multi-include guarded]");
290    }
291  }
292}
293
294static const char* GetCursorSource(CXCursor Cursor) {
295  CXSourceLocation Loc = clang_getCursorLocation(Cursor);
296  CXString source;
297  CXFile file;
298  clang_getSpellingLocation(Loc, &file, 0, 0, 0);
299  source = clang_getFileName(file);
300  if (!clang_getCString(source)) {
301    clang_disposeString(source);
302    return "<invalid loc>";
303  }
304  else {
305    const char *b = basename(clang_getCString(source));
306    clang_disposeString(source);
307    return b;
308  }
309}
310
311/******************************************************************************/
312/* Callbacks.                                                                 */
313/******************************************************************************/
314
315typedef void (*PostVisitTU)(CXTranslationUnit);
316
317void PrintDiagnostic(CXDiagnostic Diagnostic) {
318  FILE *out = stderr;
319  CXFile file;
320  CXString Msg;
321  unsigned display_opts = CXDiagnostic_DisplaySourceLocation
322    | CXDiagnostic_DisplayColumn | CXDiagnostic_DisplaySourceRanges
323    | CXDiagnostic_DisplayOption;
324  unsigned i, num_fixits;
325
326  if (clang_getDiagnosticSeverity(Diagnostic) == CXDiagnostic_Ignored)
327    return;
328
329  Msg = clang_formatDiagnostic(Diagnostic, display_opts);
330  fprintf(stderr, "%s\n", clang_getCString(Msg));
331  clang_disposeString(Msg);
332
333  clang_getSpellingLocation(clang_getDiagnosticLocation(Diagnostic),
334                            &file, 0, 0, 0);
335  if (!file)
336    return;
337
338  num_fixits = clang_getDiagnosticNumFixIts(Diagnostic);
339  for (i = 0; i != num_fixits; ++i) {
340    CXSourceRange range;
341    CXString insertion_text = clang_getDiagnosticFixIt(Diagnostic, i, &range);
342    CXSourceLocation start = clang_getRangeStart(range);
343    CXSourceLocation end = clang_getRangeEnd(range);
344    unsigned start_line, start_column, end_line, end_column;
345    CXFile start_file, end_file;
346    clang_getSpellingLocation(start, &start_file, &start_line,
347                              &start_column, 0);
348    clang_getSpellingLocation(end, &end_file, &end_line, &end_column, 0);
349    if (clang_equalLocations(start, end)) {
350      /* Insertion. */
351      if (start_file == file)
352        fprintf(out, "FIX-IT: Insert \"%s\" at %d:%d\n",
353                clang_getCString(insertion_text), start_line, start_column);
354    } else if (strcmp(clang_getCString(insertion_text), "") == 0) {
355      /* Removal. */
356      if (start_file == file && end_file == file) {
357        fprintf(out, "FIX-IT: Remove ");
358        PrintExtent(out, start_line, start_column, end_line, end_column);
359        fprintf(out, "\n");
360      }
361    } else {
362      /* Replacement. */
363      if (start_file == end_file) {
364        fprintf(out, "FIX-IT: Replace ");
365        PrintExtent(out, start_line, start_column, end_line, end_column);
366        fprintf(out, " with \"%s\"\n", clang_getCString(insertion_text));
367      }
368      break;
369    }
370    clang_disposeString(insertion_text);
371  }
372}
373
374void PrintDiagnostics(CXTranslationUnit TU) {
375  int i, n = clang_getNumDiagnostics(TU);
376  for (i = 0; i != n; ++i) {
377    CXDiagnostic Diag = clang_getDiagnostic(TU, i);
378    PrintDiagnostic(Diag);
379    clang_disposeDiagnostic(Diag);
380  }
381}
382
383void PrintMemoryUsage(CXTranslationUnit TU) {
384  unsigned long total = 0.0;
385  unsigned i = 0;
386  CXTUResourceUsage usage = clang_getCXTUResourceUsage(TU);
387  fprintf(stderr, "Memory usage:\n");
388  for (i = 0 ; i != usage.numEntries; ++i) {
389    const char *name = clang_getTUResourceUsageName(usage.entries[i].kind);
390    unsigned long amount = usage.entries[i].amount;
391    total += amount;
392    fprintf(stderr, "  %s : %ld bytes (%f MBytes)\n", name, amount,
393            ((double) amount)/(1024*1024));
394  }
395  fprintf(stderr, "  TOTAL = %ld bytes (%f MBytes)\n", total,
396          ((double) total)/(1024*1024));
397  clang_disposeCXTUResourceUsage(usage);
398}
399
400/******************************************************************************/
401/* Logic for testing traversal.                                               */
402/******************************************************************************/
403
404static const char *FileCheckPrefix = "CHECK";
405
406static void PrintCursorExtent(CXCursor C) {
407  CXSourceRange extent = clang_getCursorExtent(C);
408  CXFile begin_file, end_file;
409  unsigned begin_line, begin_column, end_line, end_column;
410
411  clang_getSpellingLocation(clang_getRangeStart(extent),
412                            &begin_file, &begin_line, &begin_column, 0);
413  clang_getSpellingLocation(clang_getRangeEnd(extent),
414                            &end_file, &end_line, &end_column, 0);
415  if (!begin_file || !end_file)
416    return;
417
418  printf(" Extent=");
419  PrintExtent(stdout, begin_line, begin_column, end_line, end_column);
420}
421
422/* Data used by all of the visitors. */
423typedef struct  {
424  CXTranslationUnit TU;
425  enum CXCursorKind *Filter;
426} VisitorData;
427
428
429enum CXChildVisitResult FilteredPrintingVisitor(CXCursor Cursor,
430                                                CXCursor Parent,
431                                                CXClientData ClientData) {
432  VisitorData *Data = (VisitorData *)ClientData;
433  if (!Data->Filter || (Cursor.kind == *(enum CXCursorKind *)Data->Filter)) {
434    CXSourceLocation Loc = clang_getCursorLocation(Cursor);
435    unsigned line, column;
436    clang_getSpellingLocation(Loc, 0, &line, &column, 0);
437    printf("// %s: %s:%d:%d: ", FileCheckPrefix,
438           GetCursorSource(Cursor), line, column);
439    PrintCursor(Data->TU, Cursor);
440    PrintCursorExtent(Cursor);
441    printf("\n");
442    return CXChildVisit_Recurse;
443  }
444
445  return CXChildVisit_Continue;
446}
447
448static enum CXChildVisitResult FunctionScanVisitor(CXCursor Cursor,
449                                                   CXCursor Parent,
450                                                   CXClientData ClientData) {
451  const char *startBuf, *endBuf;
452  unsigned startLine, startColumn, endLine, endColumn, curLine, curColumn;
453  CXCursor Ref;
454  VisitorData *Data = (VisitorData *)ClientData;
455
456  if (Cursor.kind != CXCursor_FunctionDecl ||
457      !clang_isCursorDefinition(Cursor))
458    return CXChildVisit_Continue;
459
460  clang_getDefinitionSpellingAndExtent(Cursor, &startBuf, &endBuf,
461                                       &startLine, &startColumn,
462                                       &endLine, &endColumn);
463  /* Probe the entire body, looking for both decls and refs. */
464  curLine = startLine;
465  curColumn = startColumn;
466
467  while (startBuf < endBuf) {
468    CXSourceLocation Loc;
469    CXFile file;
470    CXString source;
471
472    if (*startBuf == '\n') {
473      startBuf++;
474      curLine++;
475      curColumn = 1;
476    } else if (*startBuf != '\t')
477      curColumn++;
478
479    Loc = clang_getCursorLocation(Cursor);
480    clang_getSpellingLocation(Loc, &file, 0, 0, 0);
481
482    source = clang_getFileName(file);
483    if (clang_getCString(source)) {
484      CXSourceLocation RefLoc
485        = clang_getLocation(Data->TU, file, curLine, curColumn);
486      Ref = clang_getCursor(Data->TU, RefLoc);
487      if (Ref.kind == CXCursor_NoDeclFound) {
488        /* Nothing found here; that's fine. */
489      } else if (Ref.kind != CXCursor_FunctionDecl) {
490        printf("// %s: %s:%d:%d: ", FileCheckPrefix, GetCursorSource(Ref),
491               curLine, curColumn);
492        PrintCursor(Data->TU, Ref);
493        printf("\n");
494      }
495    }
496    clang_disposeString(source);
497    startBuf++;
498  }
499
500  return CXChildVisit_Continue;
501}
502
503/******************************************************************************/
504/* USR testing.                                                               */
505/******************************************************************************/
506
507enum CXChildVisitResult USRVisitor(CXCursor C, CXCursor parent,
508                                   CXClientData ClientData) {
509  VisitorData *Data = (VisitorData *)ClientData;
510  if (!Data->Filter || (C.kind == *(enum CXCursorKind *)Data->Filter)) {
511    CXString USR = clang_getCursorUSR(C);
512    const char *cstr = clang_getCString(USR);
513    if (!cstr || cstr[0] == '\0') {
514      clang_disposeString(USR);
515      return CXChildVisit_Recurse;
516    }
517    printf("// %s: %s %s", FileCheckPrefix, GetCursorSource(C), cstr);
518
519    PrintCursorExtent(C);
520    printf("\n");
521    clang_disposeString(USR);
522
523    return CXChildVisit_Recurse;
524  }
525
526  return CXChildVisit_Continue;
527}
528
529/******************************************************************************/
530/* Inclusion stack testing.                                                   */
531/******************************************************************************/
532
533void InclusionVisitor(CXFile includedFile, CXSourceLocation *includeStack,
534                      unsigned includeStackLen, CXClientData data) {
535
536  unsigned i;
537  CXString fname;
538
539  fname = clang_getFileName(includedFile);
540  printf("file: %s\nincluded by:\n", clang_getCString(fname));
541  clang_disposeString(fname);
542
543  for (i = 0; i < includeStackLen; ++i) {
544    CXFile includingFile;
545    unsigned line, column;
546    clang_getSpellingLocation(includeStack[i], &includingFile, &line,
547                              &column, 0);
548    fname = clang_getFileName(includingFile);
549    printf("  %s:%d:%d\n", clang_getCString(fname), line, column);
550    clang_disposeString(fname);
551  }
552  printf("\n");
553}
554
555void PrintInclusionStack(CXTranslationUnit TU) {
556  clang_getInclusions(TU, InclusionVisitor, NULL);
557}
558
559/******************************************************************************/
560/* Linkage testing.                                                           */
561/******************************************************************************/
562
563static enum CXChildVisitResult PrintLinkage(CXCursor cursor, CXCursor p,
564                                            CXClientData d) {
565  const char *linkage = 0;
566
567  VisitorData *Data = (VisitorData *)d;
568
569  if (clang_isInvalid(clang_getCursorKind(cursor)))
570    return CXChildVisit_Recurse;
571
572  switch (clang_getCursorLinkage(cursor)) {
573    case CXLinkage_Invalid: break;
574    case CXLinkage_NoLinkage: linkage = "NoLinkage"; break;
575    case CXLinkage_Internal: linkage = "Internal"; break;
576    case CXLinkage_UniqueExternal: linkage = "UniqueExternal"; break;
577    case CXLinkage_External: linkage = "External"; break;
578  }
579
580  if (linkage) {
581    PrintCursor(Data->TU, cursor);
582    printf("linkage=%s\n", linkage);
583  }
584
585  return CXChildVisit_Recurse;
586}
587
588/******************************************************************************/
589/* Typekind testing.                                                          */
590/******************************************************************************/
591
592static enum CXChildVisitResult PrintTypeKind(CXCursor cursor, CXCursor p,
593                                             CXClientData d) {
594  VisitorData *Data = (VisitorData *)d;
595
596  if (!clang_isInvalid(clang_getCursorKind(cursor))) {
597    CXType T = clang_getCursorType(cursor);
598    CXString S = clang_getTypeKindSpelling(T.kind);
599    PrintCursor(Data->TU, cursor);
600    printf(" typekind=%s", clang_getCString(S));
601    if (clang_isConstQualifiedType(T))
602      printf(" const");
603    if (clang_isVolatileQualifiedType(T))
604      printf(" volatile");
605    if (clang_isRestrictQualifiedType(T))
606      printf(" restrict");
607    clang_disposeString(S);
608    /* Print the canonical type if it is different. */
609    {
610      CXType CT = clang_getCanonicalType(T);
611      if (!clang_equalTypes(T, CT)) {
612        CXString CS = clang_getTypeKindSpelling(CT.kind);
613        printf(" [canonical=%s]", clang_getCString(CS));
614        clang_disposeString(CS);
615      }
616    }
617    /* Print the return type if it exists. */
618    {
619      CXType RT = clang_getCursorResultType(cursor);
620      if (RT.kind != CXType_Invalid) {
621        CXString RS = clang_getTypeKindSpelling(RT.kind);
622        printf(" [result=%s]", clang_getCString(RS));
623        clang_disposeString(RS);
624      }
625    }
626    /* Print if this is a non-POD type. */
627    printf(" [isPOD=%d]", clang_isPODType(T));
628
629    printf("\n");
630  }
631  return CXChildVisit_Recurse;
632}
633
634
635/******************************************************************************/
636/* Loading ASTs/source.                                                       */
637/******************************************************************************/
638
639static int perform_test_load(CXIndex Idx, CXTranslationUnit TU,
640                             const char *filter, const char *prefix,
641                             CXCursorVisitor Visitor,
642                             PostVisitTU PV) {
643
644  if (prefix)
645    FileCheckPrefix = prefix;
646
647  if (Visitor) {
648    enum CXCursorKind K = CXCursor_NotImplemented;
649    enum CXCursorKind *ck = &K;
650    VisitorData Data;
651
652    /* Perform some simple filtering. */
653    if (!strcmp(filter, "all") || !strcmp(filter, "local")) ck = NULL;
654    else if (!strcmp(filter, "all-display") ||
655             !strcmp(filter, "local-display")) {
656      ck = NULL;
657      want_display_name = 1;
658    }
659    else if (!strcmp(filter, "none")) K = (enum CXCursorKind) ~0;
660    else if (!strcmp(filter, "category")) K = CXCursor_ObjCCategoryDecl;
661    else if (!strcmp(filter, "interface")) K = CXCursor_ObjCInterfaceDecl;
662    else if (!strcmp(filter, "protocol")) K = CXCursor_ObjCProtocolDecl;
663    else if (!strcmp(filter, "function")) K = CXCursor_FunctionDecl;
664    else if (!strcmp(filter, "typedef")) K = CXCursor_TypedefDecl;
665    else if (!strcmp(filter, "scan-function")) Visitor = FunctionScanVisitor;
666    else {
667      fprintf(stderr, "Unknown filter for -test-load-tu: %s\n", filter);
668      return 1;
669    }
670
671    Data.TU = TU;
672    Data.Filter = ck;
673    clang_visitChildren(clang_getTranslationUnitCursor(TU), Visitor, &Data);
674  }
675
676  if (PV)
677    PV(TU);
678
679  PrintDiagnostics(TU);
680  clang_disposeTranslationUnit(TU);
681  return 0;
682}
683
684int perform_test_load_tu(const char *file, const char *filter,
685                         const char *prefix, CXCursorVisitor Visitor,
686                         PostVisitTU PV) {
687  CXIndex Idx;
688  CXTranslationUnit TU;
689  int result;
690  Idx = clang_createIndex(/* excludeDeclsFromPCH */
691                          !strcmp(filter, "local") ? 1 : 0,
692                          /* displayDiagnosics=*/1);
693
694  if (!CreateTranslationUnit(Idx, file, &TU)) {
695    clang_disposeIndex(Idx);
696    return 1;
697  }
698
699  result = perform_test_load(Idx, TU, filter, prefix, Visitor, PV);
700  clang_disposeIndex(Idx);
701  return result;
702}
703
704int perform_test_load_source(int argc, const char **argv,
705                             const char *filter, CXCursorVisitor Visitor,
706                             PostVisitTU PV) {
707  CXIndex Idx;
708  CXTranslationUnit TU;
709  struct CXUnsavedFile *unsaved_files = 0;
710  int num_unsaved_files = 0;
711  int result;
712
713  Idx = clang_createIndex(/* excludeDeclsFromPCH */
714                          (!strcmp(filter, "local") ||
715                           !strcmp(filter, "local-display"))? 1 : 0,
716                          /* displayDiagnosics=*/0);
717
718  if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
719    clang_disposeIndex(Idx);
720    return -1;
721  }
722
723  TU = clang_parseTranslationUnit(Idx, 0,
724                                  argv + num_unsaved_files,
725                                  argc - num_unsaved_files,
726                                  unsaved_files, num_unsaved_files,
727                                  getDefaultParsingOptions());
728  if (!TU) {
729    fprintf(stderr, "Unable to load translation unit!\n");
730    free_remapped_files(unsaved_files, num_unsaved_files);
731    clang_disposeIndex(Idx);
732    return 1;
733  }
734
735  result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV);
736  free_remapped_files(unsaved_files, num_unsaved_files);
737  clang_disposeIndex(Idx);
738  return result;
739}
740
741int perform_test_reparse_source(int argc, const char **argv, int trials,
742                                const char *filter, CXCursorVisitor Visitor,
743                                PostVisitTU PV) {
744  CXIndex Idx;
745  CXTranslationUnit TU;
746  struct CXUnsavedFile *unsaved_files = 0;
747  int num_unsaved_files = 0;
748  int result;
749  int trial;
750
751  Idx = clang_createIndex(/* excludeDeclsFromPCH */
752                          !strcmp(filter, "local") ? 1 : 0,
753                          /* displayDiagnosics=*/0);
754
755  if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
756    clang_disposeIndex(Idx);
757    return -1;
758  }
759
760  /* Load the initial translation unit -- we do this without honoring remapped
761   * files, so that we have a way to test results after changing the source. */
762  TU = clang_parseTranslationUnit(Idx, 0,
763                                  argv + num_unsaved_files,
764                                  argc - num_unsaved_files,
765                                  0, 0, getDefaultParsingOptions());
766  if (!TU) {
767    fprintf(stderr, "Unable to load translation unit!\n");
768    free_remapped_files(unsaved_files, num_unsaved_files);
769    clang_disposeIndex(Idx);
770    return 1;
771  }
772
773  for (trial = 0; trial < trials; ++trial) {
774    if (clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files,
775                                     clang_defaultReparseOptions(TU))) {
776      fprintf(stderr, "Unable to reparse translation unit!\n");
777      clang_disposeTranslationUnit(TU);
778      free_remapped_files(unsaved_files, num_unsaved_files);
779      clang_disposeIndex(Idx);
780      return -1;
781    }
782  }
783
784  result = perform_test_load(Idx, TU, filter, NULL, Visitor, PV);
785  free_remapped_files(unsaved_files, num_unsaved_files);
786  clang_disposeIndex(Idx);
787  return result;
788}
789
790/******************************************************************************/
791/* Logic for testing clang_getCursor().                                       */
792/******************************************************************************/
793
794static void print_cursor_file_scan(CXTranslationUnit TU, CXCursor cursor,
795                                   unsigned start_line, unsigned start_col,
796                                   unsigned end_line, unsigned end_col,
797                                   const char *prefix) {
798  printf("// %s: ", FileCheckPrefix);
799  if (prefix)
800    printf("-%s", prefix);
801  PrintExtent(stdout, start_line, start_col, end_line, end_col);
802  printf(" ");
803  PrintCursor(TU, cursor);
804  printf("\n");
805}
806
807static int perform_file_scan(const char *ast_file, const char *source_file,
808                             const char *prefix) {
809  CXIndex Idx;
810  CXTranslationUnit TU;
811  FILE *fp;
812  CXCursor prevCursor = clang_getNullCursor();
813  CXFile file;
814  unsigned line = 1, col = 1;
815  unsigned start_line = 1, start_col = 1;
816
817  if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ 1,
818                                /* displayDiagnosics=*/1))) {
819    fprintf(stderr, "Could not create Index\n");
820    return 1;
821  }
822
823  if (!CreateTranslationUnit(Idx, ast_file, &TU))
824    return 1;
825
826  if ((fp = fopen(source_file, "r")) == NULL) {
827    fprintf(stderr, "Could not open '%s'\n", source_file);
828    return 1;
829  }
830
831  file = clang_getFile(TU, source_file);
832  for (;;) {
833    CXCursor cursor;
834    int c = fgetc(fp);
835
836    if (c == '\n') {
837      ++line;
838      col = 1;
839    } else
840      ++col;
841
842    /* Check the cursor at this position, and dump the previous one if we have
843     * found something new.
844     */
845    cursor = clang_getCursor(TU, clang_getLocation(TU, file, line, col));
846    if ((c == EOF || !clang_equalCursors(cursor, prevCursor)) &&
847        prevCursor.kind != CXCursor_InvalidFile) {
848      print_cursor_file_scan(TU, prevCursor, start_line, start_col,
849                             line, col, prefix);
850      start_line = line;
851      start_col = col;
852    }
853    if (c == EOF)
854      break;
855
856    prevCursor = cursor;
857  }
858
859  fclose(fp);
860  clang_disposeTranslationUnit(TU);
861  clang_disposeIndex(Idx);
862  return 0;
863}
864
865/******************************************************************************/
866/* Logic for testing clang code completion.                                   */
867/******************************************************************************/
868
869/* Parse file:line:column from the input string. Returns 0 on success, non-zero
870   on failure. If successful, the pointer *filename will contain newly-allocated
871   memory (that will be owned by the caller) to store the file name. */
872int parse_file_line_column(const char *input, char **filename, unsigned *line,
873                           unsigned *column, unsigned *second_line,
874                           unsigned *second_column) {
875  /* Find the second colon. */
876  const char *last_colon = strrchr(input, ':');
877  unsigned values[4], i;
878  unsigned num_values = (second_line && second_column)? 4 : 2;
879
880  char *endptr = 0;
881  if (!last_colon || last_colon == input) {
882    if (num_values == 4)
883      fprintf(stderr, "could not parse filename:line:column:line:column in "
884              "'%s'\n", input);
885    else
886      fprintf(stderr, "could not parse filename:line:column in '%s'\n", input);
887    return 1;
888  }
889
890  for (i = 0; i != num_values; ++i) {
891    const char *prev_colon;
892
893    /* Parse the next line or column. */
894    values[num_values - i - 1] = strtol(last_colon + 1, &endptr, 10);
895    if (*endptr != 0 && *endptr != ':') {
896      fprintf(stderr, "could not parse %s in '%s'\n",
897              (i % 2 ? "column" : "line"), input);
898      return 1;
899    }
900
901    if (i + 1 == num_values)
902      break;
903
904    /* Find the previous colon. */
905    prev_colon = last_colon - 1;
906    while (prev_colon != input && *prev_colon != ':')
907      --prev_colon;
908    if (prev_colon == input) {
909      fprintf(stderr, "could not parse %s in '%s'\n",
910              (i % 2 == 0? "column" : "line"), input);
911      return 1;
912    }
913
914    last_colon = prev_colon;
915  }
916
917  *line = values[0];
918  *column = values[1];
919
920  if (second_line && second_column) {
921    *second_line = values[2];
922    *second_column = values[3];
923  }
924
925  /* Copy the file name. */
926  *filename = (char*)malloc(last_colon - input + 1);
927  memcpy(*filename, input, last_colon - input);
928  (*filename)[last_colon - input] = 0;
929  return 0;
930}
931
932const char *
933clang_getCompletionChunkKindSpelling(enum CXCompletionChunkKind Kind) {
934  switch (Kind) {
935  case CXCompletionChunk_Optional: return "Optional";
936  case CXCompletionChunk_TypedText: return "TypedText";
937  case CXCompletionChunk_Text: return "Text";
938  case CXCompletionChunk_Placeholder: return "Placeholder";
939  case CXCompletionChunk_Informative: return "Informative";
940  case CXCompletionChunk_CurrentParameter: return "CurrentParameter";
941  case CXCompletionChunk_LeftParen: return "LeftParen";
942  case CXCompletionChunk_RightParen: return "RightParen";
943  case CXCompletionChunk_LeftBracket: return "LeftBracket";
944  case CXCompletionChunk_RightBracket: return "RightBracket";
945  case CXCompletionChunk_LeftBrace: return "LeftBrace";
946  case CXCompletionChunk_RightBrace: return "RightBrace";
947  case CXCompletionChunk_LeftAngle: return "LeftAngle";
948  case CXCompletionChunk_RightAngle: return "RightAngle";
949  case CXCompletionChunk_Comma: return "Comma";
950  case CXCompletionChunk_ResultType: return "ResultType";
951  case CXCompletionChunk_Colon: return "Colon";
952  case CXCompletionChunk_SemiColon: return "SemiColon";
953  case CXCompletionChunk_Equal: return "Equal";
954  case CXCompletionChunk_HorizontalSpace: return "HorizontalSpace";
955  case CXCompletionChunk_VerticalSpace: return "VerticalSpace";
956  }
957
958  return "Unknown";
959}
960
961void print_completion_string(CXCompletionString completion_string, FILE *file) {
962  int I, N;
963
964  N = clang_getNumCompletionChunks(completion_string);
965  for (I = 0; I != N; ++I) {
966    CXString text;
967    const char *cstr;
968    enum CXCompletionChunkKind Kind
969      = clang_getCompletionChunkKind(completion_string, I);
970
971    if (Kind == CXCompletionChunk_Optional) {
972      fprintf(file, "{Optional ");
973      print_completion_string(
974                clang_getCompletionChunkCompletionString(completion_string, I),
975                              file);
976      fprintf(file, "}");
977      continue;
978    }
979
980    if (Kind == CXCompletionChunk_VerticalSpace) {
981      fprintf(file, "{VerticalSpace  }");
982      continue;
983    }
984
985    text = clang_getCompletionChunkText(completion_string, I);
986    cstr = clang_getCString(text);
987    fprintf(file, "{%s %s}",
988            clang_getCompletionChunkKindSpelling(Kind),
989            cstr ? cstr : "");
990    clang_disposeString(text);
991  }
992
993}
994
995void print_completion_result(CXCompletionResult *completion_result,
996                             CXClientData client_data) {
997  FILE *file = (FILE *)client_data;
998  CXString ks = clang_getCursorKindSpelling(completion_result->CursorKind);
999
1000  fprintf(file, "%s:", clang_getCString(ks));
1001  clang_disposeString(ks);
1002
1003  print_completion_string(completion_result->CompletionString, file);
1004  fprintf(file, " (%u)",
1005          clang_getCompletionPriority(completion_result->CompletionString));
1006  switch (clang_getCompletionAvailability(completion_result->CompletionString)){
1007  case CXAvailability_Available:
1008    break;
1009
1010  case CXAvailability_Deprecated:
1011    fprintf(file, " (deprecated)");
1012    break;
1013
1014  case CXAvailability_NotAvailable:
1015    fprintf(file, " (unavailable)");
1016    break;
1017  }
1018  fprintf(file, "\n");
1019}
1020
1021int my_stricmp(const char *s1, const char *s2) {
1022  while (*s1 && *s2) {
1023    int c1 = tolower((unsigned char)*s1), c2 = tolower((unsigned char)*s2);
1024    if (c1 < c2)
1025      return -1;
1026    else if (c1 > c2)
1027      return 1;
1028
1029    ++s1;
1030    ++s2;
1031  }
1032
1033  if (*s1)
1034    return 1;
1035  else if (*s2)
1036    return -1;
1037  return 0;
1038}
1039
1040int perform_code_completion(int argc, const char **argv, int timing_only) {
1041  const char *input = argv[1];
1042  char *filename = 0;
1043  unsigned line;
1044  unsigned column;
1045  CXIndex CIdx;
1046  int errorCode;
1047  struct CXUnsavedFile *unsaved_files = 0;
1048  int num_unsaved_files = 0;
1049  CXCodeCompleteResults *results = 0;
1050  CXTranslationUnit TU = 0;
1051  unsigned I, Repeats = 1;
1052  unsigned completionOptions = clang_defaultCodeCompleteOptions();
1053
1054  if (getenv("CINDEXTEST_CODE_COMPLETE_PATTERNS"))
1055    completionOptions |= CXCodeComplete_IncludeCodePatterns;
1056
1057  if (timing_only)
1058    input += strlen("-code-completion-timing=");
1059  else
1060    input += strlen("-code-completion-at=");
1061
1062  if ((errorCode = parse_file_line_column(input, &filename, &line, &column,
1063                                          0, 0)))
1064    return errorCode;
1065
1066  if (parse_remapped_files(argc, argv, 2, &unsaved_files, &num_unsaved_files))
1067    return -1;
1068
1069  CIdx = clang_createIndex(0, 0);
1070
1071  if (getenv("CINDEXTEST_EDITING"))
1072    Repeats = 5;
1073
1074  TU = clang_parseTranslationUnit(CIdx, 0,
1075                                  argv + num_unsaved_files + 2,
1076                                  argc - num_unsaved_files - 2,
1077                                  0, 0, getDefaultParsingOptions());
1078  if (!TU) {
1079    fprintf(stderr, "Unable to load translation unit!\n");
1080    return 1;
1081  }
1082
1083  if (clang_reparseTranslationUnit(TU, 0, 0, clang_defaultReparseOptions(TU))) {
1084    fprintf(stderr, "Unable to reparse translation init!\n");
1085    return 1;
1086  }
1087
1088  for (I = 0; I != Repeats; ++I) {
1089    results = clang_codeCompleteAt(TU, filename, line, column,
1090                                   unsaved_files, num_unsaved_files,
1091                                   completionOptions);
1092    if (!results) {
1093      fprintf(stderr, "Unable to perform code completion!\n");
1094      return 1;
1095    }
1096    if (I != Repeats-1)
1097      clang_disposeCodeCompleteResults(results);
1098  }
1099
1100  if (results) {
1101    unsigned i, n = results->NumResults;
1102    if (!timing_only) {
1103      /* Sort the code-completion results based on the typed text. */
1104      clang_sortCodeCompletionResults(results->Results, results->NumResults);
1105
1106      for (i = 0; i != n; ++i)
1107        print_completion_result(results->Results + i, stdout);
1108    }
1109    n = clang_codeCompleteGetNumDiagnostics(results);
1110    for (i = 0; i != n; ++i) {
1111      CXDiagnostic diag = clang_codeCompleteGetDiagnostic(results, i);
1112      PrintDiagnostic(diag);
1113      clang_disposeDiagnostic(diag);
1114    }
1115    clang_disposeCodeCompleteResults(results);
1116  }
1117  clang_disposeTranslationUnit(TU);
1118  clang_disposeIndex(CIdx);
1119  free(filename);
1120
1121  free_remapped_files(unsaved_files, num_unsaved_files);
1122
1123  return 0;
1124}
1125
1126typedef struct {
1127  char *filename;
1128  unsigned line;
1129  unsigned column;
1130} CursorSourceLocation;
1131
1132int inspect_cursor_at(int argc, const char **argv) {
1133  CXIndex CIdx;
1134  int errorCode;
1135  struct CXUnsavedFile *unsaved_files = 0;
1136  int num_unsaved_files = 0;
1137  CXTranslationUnit TU;
1138  CXCursor Cursor;
1139  CursorSourceLocation *Locations = 0;
1140  unsigned NumLocations = 0, Loc;
1141  unsigned Repeats = 1;
1142  unsigned I;
1143
1144  /* Count the number of locations. */
1145  while (strstr(argv[NumLocations+1], "-cursor-at=") == argv[NumLocations+1])
1146    ++NumLocations;
1147
1148  /* Parse the locations. */
1149  assert(NumLocations > 0 && "Unable to count locations?");
1150  Locations = (CursorSourceLocation *)malloc(
1151                                  NumLocations * sizeof(CursorSourceLocation));
1152  for (Loc = 0; Loc < NumLocations; ++Loc) {
1153    const char *input = argv[Loc + 1] + strlen("-cursor-at=");
1154    if ((errorCode = parse_file_line_column(input, &Locations[Loc].filename,
1155                                            &Locations[Loc].line,
1156                                            &Locations[Loc].column, 0, 0)))
1157      return errorCode;
1158  }
1159
1160  if (parse_remapped_files(argc, argv, NumLocations + 1, &unsaved_files,
1161                           &num_unsaved_files))
1162    return -1;
1163
1164  if (getenv("CINDEXTEST_EDITING"))
1165    Repeats = 5;
1166
1167  /* Parse the translation unit. When we're testing clang_getCursor() after
1168     reparsing, don't remap unsaved files until the second parse. */
1169  CIdx = clang_createIndex(1, 1);
1170  TU = clang_parseTranslationUnit(CIdx, argv[argc - 1],
1171                                  argv + num_unsaved_files + 1 + NumLocations,
1172                                  argc - num_unsaved_files - 2 - NumLocations,
1173                                  unsaved_files,
1174                                  Repeats > 1? 0 : num_unsaved_files,
1175                                  getDefaultParsingOptions());
1176
1177  if (!TU) {
1178    fprintf(stderr, "unable to parse input\n");
1179    return -1;
1180  }
1181
1182  for (I = 0; I != Repeats; ++I) {
1183    if (Repeats > 1 &&
1184        clang_reparseTranslationUnit(TU, num_unsaved_files, unsaved_files,
1185                                     clang_defaultReparseOptions(TU))) {
1186      clang_disposeTranslationUnit(TU);
1187      return 1;
1188    }
1189
1190    for (Loc = 0; Loc < NumLocations; ++Loc) {
1191      CXFile file = clang_getFile(TU, Locations[Loc].filename);
1192      if (!file)
1193        continue;
1194
1195      Cursor = clang_getCursor(TU,
1196                               clang_getLocation(TU, file, Locations[Loc].line,
1197                                                 Locations[Loc].column));
1198      if (I + 1 == Repeats) {
1199        PrintCursor(TU, Cursor);
1200        printf("\n");
1201        free(Locations[Loc].filename);
1202      }
1203    }
1204  }
1205
1206  PrintDiagnostics(TU);
1207  clang_disposeTranslationUnit(TU);
1208  clang_disposeIndex(CIdx);
1209  free(Locations);
1210  free_remapped_files(unsaved_files, num_unsaved_files);
1211  return 0;
1212}
1213
1214int perform_token_annotation(int argc, const char **argv) {
1215  const char *input = argv[1];
1216  char *filename = 0;
1217  unsigned line, second_line;
1218  unsigned column, second_column;
1219  CXIndex CIdx;
1220  CXTranslationUnit TU = 0;
1221  int errorCode;
1222  struct CXUnsavedFile *unsaved_files = 0;
1223  int num_unsaved_files = 0;
1224  CXToken *tokens;
1225  unsigned num_tokens;
1226  CXSourceRange range;
1227  CXSourceLocation startLoc, endLoc;
1228  CXFile file = 0;
1229  CXCursor *cursors = 0;
1230  unsigned i;
1231
1232  input += strlen("-test-annotate-tokens=");
1233  if ((errorCode = parse_file_line_column(input, &filename, &line, &column,
1234                                          &second_line, &second_column)))
1235    return errorCode;
1236
1237  if (parse_remapped_files(argc, argv, 2, &unsaved_files, &num_unsaved_files))
1238    return -1;
1239
1240  CIdx = clang_createIndex(0, 1);
1241  TU = clang_parseTranslationUnit(CIdx, argv[argc - 1],
1242                                  argv + num_unsaved_files + 2,
1243                                  argc - num_unsaved_files - 3,
1244                                  unsaved_files,
1245                                  num_unsaved_files,
1246                                  getDefaultParsingOptions());
1247  if (!TU) {
1248    fprintf(stderr, "unable to parse input\n");
1249    clang_disposeIndex(CIdx);
1250    free(filename);
1251    free_remapped_files(unsaved_files, num_unsaved_files);
1252    return -1;
1253  }
1254  errorCode = 0;
1255
1256  file = clang_getFile(TU, filename);
1257  if (!file) {
1258    fprintf(stderr, "file %s is not in this translation unit\n", filename);
1259    errorCode = -1;
1260    goto teardown;
1261  }
1262
1263  startLoc = clang_getLocation(TU, file, line, column);
1264  if (clang_equalLocations(clang_getNullLocation(), startLoc)) {
1265    fprintf(stderr, "invalid source location %s:%d:%d\n", filename, line,
1266            column);
1267    errorCode = -1;
1268    goto teardown;
1269  }
1270
1271  endLoc = clang_getLocation(TU, file, second_line, second_column);
1272  if (clang_equalLocations(clang_getNullLocation(), endLoc)) {
1273    fprintf(stderr, "invalid source location %s:%d:%d\n", filename,
1274            second_line, second_column);
1275    errorCode = -1;
1276    goto teardown;
1277  }
1278
1279  range = clang_getRange(startLoc, endLoc);
1280  clang_tokenize(TU, range, &tokens, &num_tokens);
1281  cursors = (CXCursor *)malloc(num_tokens * sizeof(CXCursor));
1282  clang_annotateTokens(TU, tokens, num_tokens, cursors);
1283  for (i = 0; i != num_tokens; ++i) {
1284    const char *kind = "<unknown>";
1285    CXString spelling = clang_getTokenSpelling(TU, tokens[i]);
1286    CXSourceRange extent = clang_getTokenExtent(TU, tokens[i]);
1287    unsigned start_line, start_column, end_line, end_column;
1288
1289    switch (clang_getTokenKind(tokens[i])) {
1290    case CXToken_Punctuation: kind = "Punctuation"; break;
1291    case CXToken_Keyword: kind = "Keyword"; break;
1292    case CXToken_Identifier: kind = "Identifier"; break;
1293    case CXToken_Literal: kind = "Literal"; break;
1294    case CXToken_Comment: kind = "Comment"; break;
1295    }
1296    clang_getSpellingLocation(clang_getRangeStart(extent),
1297                              0, &start_line, &start_column, 0);
1298    clang_getSpellingLocation(clang_getRangeEnd(extent),
1299                              0, &end_line, &end_column, 0);
1300    printf("%s: \"%s\" ", kind, clang_getCString(spelling));
1301    PrintExtent(stdout, start_line, start_column, end_line, end_column);
1302    if (!clang_isInvalid(cursors[i].kind)) {
1303      printf(" ");
1304      PrintCursor(TU, cursors[i]);
1305    }
1306    printf("\n");
1307  }
1308  free(cursors);
1309  clang_disposeTokens(TU, tokens, num_tokens);
1310
1311 teardown:
1312  PrintDiagnostics(TU);
1313  clang_disposeTranslationUnit(TU);
1314  clang_disposeIndex(CIdx);
1315  free(filename);
1316  free_remapped_files(unsaved_files, num_unsaved_files);
1317  return errorCode;
1318}
1319
1320/******************************************************************************/
1321/* USR printing.                                                              */
1322/******************************************************************************/
1323
1324static int insufficient_usr(const char *kind, const char *usage) {
1325  fprintf(stderr, "USR for '%s' requires: %s\n", kind, usage);
1326  return 1;
1327}
1328
1329static unsigned isUSR(const char *s) {
1330  return s[0] == 'c' && s[1] == ':';
1331}
1332
1333static int not_usr(const char *s, const char *arg) {
1334  fprintf(stderr, "'%s' argument ('%s') is not a USR\n", s, arg);
1335  return 1;
1336}
1337
1338static void print_usr(CXString usr) {
1339  const char *s = clang_getCString(usr);
1340  printf("%s\n", s);
1341  clang_disposeString(usr);
1342}
1343
1344static void display_usrs() {
1345  fprintf(stderr, "-print-usrs options:\n"
1346        " ObjCCategory <class name> <category name>\n"
1347        " ObjCClass <class name>\n"
1348        " ObjCIvar <ivar name> <class USR>\n"
1349        " ObjCMethod <selector> [0=class method|1=instance method] "
1350            "<class USR>\n"
1351          " ObjCProperty <property name> <class USR>\n"
1352          " ObjCProtocol <protocol name>\n");
1353}
1354
1355int print_usrs(const char **I, const char **E) {
1356  while (I != E) {
1357    const char *kind = *I;
1358    unsigned len = strlen(kind);
1359    switch (len) {
1360      case 8:
1361        if (memcmp(kind, "ObjCIvar", 8) == 0) {
1362          if (I + 2 >= E)
1363            return insufficient_usr(kind, "<ivar name> <class USR>");
1364          if (!isUSR(I[2]))
1365            return not_usr("<class USR>", I[2]);
1366          else {
1367            CXString x;
1368            x.data = (void*) I[2];
1369            x.private_flags = 0;
1370            print_usr(clang_constructUSR_ObjCIvar(I[1], x));
1371          }
1372
1373          I += 3;
1374          continue;
1375        }
1376        break;
1377      case 9:
1378        if (memcmp(kind, "ObjCClass", 9) == 0) {
1379          if (I + 1 >= E)
1380            return insufficient_usr(kind, "<class name>");
1381          print_usr(clang_constructUSR_ObjCClass(I[1]));
1382          I += 2;
1383          continue;
1384        }
1385        break;
1386      case 10:
1387        if (memcmp(kind, "ObjCMethod", 10) == 0) {
1388          if (I + 3 >= E)
1389            return insufficient_usr(kind, "<method selector> "
1390                "[0=class method|1=instance method] <class USR>");
1391          if (!isUSR(I[3]))
1392            return not_usr("<class USR>", I[3]);
1393          else {
1394            CXString x;
1395            x.data = (void*) I[3];
1396            x.private_flags = 0;
1397            print_usr(clang_constructUSR_ObjCMethod(I[1], atoi(I[2]), x));
1398          }
1399          I += 4;
1400          continue;
1401        }
1402        break;
1403      case 12:
1404        if (memcmp(kind, "ObjCCategory", 12) == 0) {
1405          if (I + 2 >= E)
1406            return insufficient_usr(kind, "<class name> <category name>");
1407          print_usr(clang_constructUSR_ObjCCategory(I[1], I[2]));
1408          I += 3;
1409          continue;
1410        }
1411        if (memcmp(kind, "ObjCProtocol", 12) == 0) {
1412          if (I + 1 >= E)
1413            return insufficient_usr(kind, "<protocol name>");
1414          print_usr(clang_constructUSR_ObjCProtocol(I[1]));
1415          I += 2;
1416          continue;
1417        }
1418        if (memcmp(kind, "ObjCProperty", 12) == 0) {
1419          if (I + 2 >= E)
1420            return insufficient_usr(kind, "<property name> <class USR>");
1421          if (!isUSR(I[2]))
1422            return not_usr("<class USR>", I[2]);
1423          else {
1424            CXString x;
1425            x.data = (void*) I[2];
1426            x.private_flags = 0;
1427            print_usr(clang_constructUSR_ObjCProperty(I[1], x));
1428          }
1429          I += 3;
1430          continue;
1431        }
1432        break;
1433      default:
1434        break;
1435    }
1436    break;
1437  }
1438
1439  if (I != E) {
1440    fprintf(stderr, "Invalid USR kind: %s\n", *I);
1441    display_usrs();
1442    return 1;
1443  }
1444  return 0;
1445}
1446
1447int print_usrs_file(const char *file_name) {
1448  char line[2048];
1449  const char *args[128];
1450  unsigned numChars = 0;
1451
1452  FILE *fp = fopen(file_name, "r");
1453  if (!fp) {
1454    fprintf(stderr, "error: cannot open '%s'\n", file_name);
1455    return 1;
1456  }
1457
1458  /* This code is not really all that safe, but it works fine for testing. */
1459  while (!feof(fp)) {
1460    char c = fgetc(fp);
1461    if (c == '\n') {
1462      unsigned i = 0;
1463      const char *s = 0;
1464
1465      if (numChars == 0)
1466        continue;
1467
1468      line[numChars] = '\0';
1469      numChars = 0;
1470
1471      if (line[0] == '/' && line[1] == '/')
1472        continue;
1473
1474      s = strtok(line, " ");
1475      while (s) {
1476        args[i] = s;
1477        ++i;
1478        s = strtok(0, " ");
1479      }
1480      if (print_usrs(&args[0], &args[i]))
1481        return 1;
1482    }
1483    else
1484      line[numChars++] = c;
1485  }
1486
1487  fclose(fp);
1488  return 0;
1489}
1490
1491/******************************************************************************/
1492/* Command line processing.                                                   */
1493/******************************************************************************/
1494int write_pch_file(const char *filename, int argc, const char *argv[]) {
1495  CXIndex Idx;
1496  CXTranslationUnit TU;
1497  struct CXUnsavedFile *unsaved_files = 0;
1498  int num_unsaved_files = 0;
1499
1500  Idx = clang_createIndex(/* excludeDeclsFromPCH */1, /* displayDiagnosics=*/1);
1501
1502  if (parse_remapped_files(argc, argv, 0, &unsaved_files, &num_unsaved_files)) {
1503    clang_disposeIndex(Idx);
1504    return -1;
1505  }
1506
1507  TU = clang_parseTranslationUnit(Idx, 0,
1508                                  argv + num_unsaved_files,
1509                                  argc - num_unsaved_files,
1510                                  unsaved_files,
1511                                  num_unsaved_files,
1512                                  CXTranslationUnit_Incomplete);
1513  if (!TU) {
1514    fprintf(stderr, "Unable to load translation unit!\n");
1515    free_remapped_files(unsaved_files, num_unsaved_files);
1516    clang_disposeIndex(Idx);
1517    return 1;
1518  }
1519
1520  if (clang_saveTranslationUnit(TU, filename, clang_defaultSaveOptions(TU)))
1521    fprintf(stderr, "Unable to write PCH file %s\n", filename);
1522  clang_disposeTranslationUnit(TU);
1523  free_remapped_files(unsaved_files, num_unsaved_files);
1524  clang_disposeIndex(Idx);
1525  return 0;
1526}
1527
1528/******************************************************************************/
1529/* Command line processing.                                                   */
1530/******************************************************************************/
1531
1532static CXCursorVisitor GetVisitor(const char *s) {
1533  if (s[0] == '\0')
1534    return FilteredPrintingVisitor;
1535  if (strcmp(s, "-usrs") == 0)
1536    return USRVisitor;
1537  if (strncmp(s, "-memory-usage", 13) == 0)
1538    return GetVisitor(s + 13);
1539  return NULL;
1540}
1541
1542static void print_usage(void) {
1543  fprintf(stderr,
1544    "usage: c-index-test -code-completion-at=<site> <compiler arguments>\n"
1545    "       c-index-test -code-completion-timing=<site> <compiler arguments>\n"
1546    "       c-index-test -cursor-at=<site> <compiler arguments>\n"
1547    "       c-index-test -test-file-scan <AST file> <source file> "
1548          "[FileCheck prefix]\n"
1549    "       c-index-test -test-load-tu <AST file> <symbol filter> "
1550          "[FileCheck prefix]\n"
1551    "       c-index-test -test-load-tu-usrs <AST file> <symbol filter> "
1552           "[FileCheck prefix]\n"
1553    "       c-index-test -test-load-source <symbol filter> {<args>}*\n");
1554  fprintf(stderr,
1555    "       c-index-test -test-load-source-memory-usage "
1556    "<symbol filter> {<args>}*\n"
1557    "       c-index-test -test-load-source-reparse <trials> <symbol filter> "
1558    "          {<args>}*\n"
1559    "       c-index-test -test-load-source-usrs <symbol filter> {<args>}*\n"
1560    "       c-index-test -test-load-source-usrs-memory-usage "
1561          "<symbol filter> {<args>}*\n"
1562    "       c-index-test -test-annotate-tokens=<range> {<args>}*\n"
1563    "       c-index-test -test-inclusion-stack-source {<args>}*\n"
1564    "       c-index-test -test-inclusion-stack-tu <AST file>\n");
1565  fprintf(stderr,
1566    "       c-index-test -test-print-linkage-source {<args>}*\n"
1567    "       c-index-test -test-print-typekind {<args>}*\n"
1568    "       c-index-test -print-usr [<CursorKind> {<args>}]*\n"
1569    "       c-index-test -print-usr-file <file>\n"
1570    "       c-index-test -write-pch <file> <compiler arguments>\n\n");
1571  fprintf(stderr,
1572    " <symbol filter> values:\n%s",
1573    "   all - load all symbols, including those from PCH\n"
1574    "   local - load all symbols except those in PCH\n"
1575    "   category - only load ObjC categories (non-PCH)\n"
1576    "   interface - only load ObjC interfaces (non-PCH)\n"
1577    "   protocol - only load ObjC protocols (non-PCH)\n"
1578    "   function - only load functions (non-PCH)\n"
1579    "   typedef - only load typdefs (non-PCH)\n"
1580    "   scan-function - scan function bodies (non-PCH)\n\n");
1581}
1582
1583/***/
1584
1585int cindextest_main(int argc, const char **argv) {
1586  clang_enableStackTraces();
1587  if (argc > 2 && strstr(argv[1], "-code-completion-at=") == argv[1])
1588    return perform_code_completion(argc, argv, 0);
1589  if (argc > 2 && strstr(argv[1], "-code-completion-timing=") == argv[1])
1590    return perform_code_completion(argc, argv, 1);
1591  if (argc > 2 && strstr(argv[1], "-cursor-at=") == argv[1])
1592    return inspect_cursor_at(argc, argv);
1593  else if (argc >= 4 && strncmp(argv[1], "-test-load-tu", 13) == 0) {
1594    CXCursorVisitor I = GetVisitor(argv[1] + 13);
1595    if (I)
1596      return perform_test_load_tu(argv[2], argv[3], argc >= 5 ? argv[4] : 0, I,
1597                                  NULL);
1598  }
1599  else if (argc >= 5 && strncmp(argv[1], "-test-load-source-reparse", 25) == 0){
1600    CXCursorVisitor I = GetVisitor(argv[1] + 25);
1601    if (I) {
1602      int trials = atoi(argv[2]);
1603      return perform_test_reparse_source(argc - 4, argv + 4, trials, argv[3], I,
1604                                         NULL);
1605    }
1606  }
1607  else if (argc >= 4 && strncmp(argv[1], "-test-load-source", 17) == 0) {
1608    CXCursorVisitor I = GetVisitor(argv[1] + 17);
1609
1610    PostVisitTU postVisit = 0;
1611    if (strstr(argv[1], "-memory-usage"))
1612      postVisit = PrintMemoryUsage;
1613
1614    if (I)
1615      return perform_test_load_source(argc - 3, argv + 3, argv[2], I,
1616                                      postVisit);
1617  }
1618  else if (argc >= 4 && strcmp(argv[1], "-test-file-scan") == 0)
1619    return perform_file_scan(argv[2], argv[3],
1620                             argc >= 5 ? argv[4] : 0);
1621  else if (argc > 2 && strstr(argv[1], "-test-annotate-tokens=") == argv[1])
1622    return perform_token_annotation(argc, argv);
1623  else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-source") == 0)
1624    return perform_test_load_source(argc - 2, argv + 2, "all", NULL,
1625                                    PrintInclusionStack);
1626  else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-tu") == 0)
1627    return perform_test_load_tu(argv[2], "all", NULL, NULL,
1628                                PrintInclusionStack);
1629  else if (argc > 2 && strcmp(argv[1], "-test-print-linkage-source") == 0)
1630    return perform_test_load_source(argc - 2, argv + 2, "all", PrintLinkage,
1631                                    NULL);
1632  else if (argc > 2 && strcmp(argv[1], "-test-print-typekind") == 0)
1633    return perform_test_load_source(argc - 2, argv + 2, "all",
1634                                    PrintTypeKind, 0);
1635  else if (argc > 1 && strcmp(argv[1], "-print-usr") == 0) {
1636    if (argc > 2)
1637      return print_usrs(argv + 2, argv + argc);
1638    else {
1639      display_usrs();
1640      return 1;
1641    }
1642  }
1643  else if (argc > 2 && strcmp(argv[1], "-print-usr-file") == 0)
1644    return print_usrs_file(argv[2]);
1645  else if (argc > 2 && strcmp(argv[1], "-write-pch") == 0)
1646    return write_pch_file(argv[2], argc - 3, argv + 3);
1647
1648  print_usage();
1649  return 1;
1650}
1651
1652/***/
1653
1654/* We intentionally run in a separate thread to ensure we at least minimal
1655 * testing of a multithreaded environment (for example, having a reduced stack
1656 * size). */
1657
1658typedef struct thread_info {
1659  int argc;
1660  const char **argv;
1661  int result;
1662} thread_info;
1663void thread_runner(void *client_data_v) {
1664  thread_info *client_data = client_data_v;
1665  client_data->result = cindextest_main(client_data->argc, client_data->argv);
1666}
1667
1668int main(int argc, const char **argv) {
1669  thread_info client_data;
1670
1671  if (getenv("CINDEXTEST_NOTHREADS"))
1672    return cindextest_main(argc, argv);
1673
1674  client_data.argc = argc;
1675  client_data.argv = argv;
1676  clang_executeOnThread(thread_runner, &client_data, 0);
1677  return client_data.result;
1678}
1679