c-index-test: small fix to CXString handling and disposal

[elsteveogrande]

Summary

(Separating some unrelated changes out of D42043)

[vsk]

LGTM, for the record

tools/c-index-test/c-index-test.c

static const char* GetCursorSource(CXCursor Cursor) {
   }
   else {
     const char *b = basename(clang_getCString(source));
     clang_disposeString(source);
     return b;
   }
 }
 
+static CXString createCXString(const char *CS) {
+  CXString Str;
+  Str.data = (const void *) CS;
+  Str.private_flags = 0;
+  return Str;
+}
+
 /******************************************************************************/
 /* Callbacks.                                                                 */
 /******************************************************************************/
 
 typedef void (*PostVisitTU)(CXTranslationUnit);
 
 void PrintDiagnostic(CXDiagnostic Diagnostic) {
   FILE *out = stderr;
typedef struct IndexDataStringList_ {
   char data[1]; /* Dynamically sized. */
 } IndexDataStringList;
 
 typedef struct {
   const char *check_prefix;
   int first_check_printed;
   int fail_for_error;
   int abort;
-  const char *main_filename;
+  CXString main_filename;
   ImportedASTFilesData *importedASTs;
   IndexDataStringList *strings;
   CXTranslationUnit TU;
 } IndexData;
 
 static void free_client_data(IndexData *index_data) {
   IndexDataStringList *node = index_data->strings;
   while (node) {

 }
 
 static void printCXIndexLoc(CXIdxLoc loc, CXClientData client_data) {
   IndexData *index_data;
   CXString filename;
   const char *cname;
   CXIdxClientFile file;
   unsigned line, column;
+  const char *main_filename;
   int isMainFile;
   
   index_data = (IndexData *)client_data;
   clang_indexLoc_getFileLocation(loc, &file, 0, &line, &column, 0);
   if (line == 0) {
     printf("<invalid>");
     return;
   }
   if (!file) {
     printf("<no idxfile>");
     return;
   }
   filename = clang_getFileName((CXFile)file);
   cname = clang_getCString(filename);
-  if (strcmp(cname, index_data->main_filename) == 0)
+  main_filename = clang_getCString(index_data->main_filename);
+  if (strcmp(cname, main_filename) == 0)
     isMainFile = 1;
   else
     isMainFile = 0;
   clang_disposeString(filename);
 
   if (!isMainFile) {
     printCXIndexFile(file);
     printf(":");
if (getenv("CINDEXTEST_FAILONERROR") &&
       index_data->fail_for_error = 1;
     }
   }
 }
 
 static CXIdxClientFile index_enteredMainFile(CXClientData client_data,
                                        CXFile file, void *reserved) {
   IndexData *index_data;
-  CXString filename;
 
   index_data = (IndexData *)client_data;
   printCheck(index_data);
 
-  filename = clang_getFileName(file);
-  index_data->main_filename = clang_getCString(filename);
-  clang_disposeString(filename);
+  index_data->main_filename = clang_getFileName(file);
 
   printf("[enteredMainFile]: ");
   printCXIndexFile((CXIdxClientFile)file);
   printf("\n");
 
   return (CXIdxClientFile)file;
 }
 
if (num_args == 0) {
     fprintf(stderr, "no compiler arguments\n");
     return -1;
   }
 
   index_data.check_prefix = check_prefix;
   index_data.first_check_printed = 0;
   index_data.fail_for_error = 0;
   index_data.abort = 0;
-  index_data.main_filename = "";
+  index_data.main_filename = createCXString("");
   index_data.importedASTs = importedASTs;
   index_data.strings = NULL;
   index_data.TU = NULL;
 
   index_opts = getIndexOptions();
   result = clang_indexSourceFile(idxAction, &index_data,
                                  &IndexCB,sizeof(IndexCB), index_opts,
                                  0, args, num_args, 0, 0, 0,
                                  getDefaultParsingOptions());
   if (result != CXError_Success)
     describeLibclangFailure(result);
 
   if (index_data.fail_for_error)
     result = -1;
 
+  clang_disposeString(index_data.main_filename);
   free_client_data(&index_data);
   return result;
 }
 
 static int index_ast_file(const char *ast_file,
                           CXIndex Idx,
                           CXIndexAction idxAction,
                           ImportedASTFilesData *importedASTs,
                           const char *check_prefix) {
   CXTranslationUnit TU;
   IndexData index_data;
   unsigned index_opts;
   int result;
 
   if (!CreateTranslationUnit(Idx, ast_file, &TU))
     return -1;
 
   index_data.check_prefix = check_prefix;
   index_data.first_check_printed = 0;
   index_data.fail_for_error = 0;
   index_data.abort = 0;
-  index_data.main_filename = "";
+  index_data.main_filename = createCXString("");
   index_data.importedASTs = importedASTs;
   index_data.strings = NULL;
   index_data.TU = TU;
 
   index_opts = getIndexOptions();
   result = clang_indexTranslationUnit(idxAction, &index_data,
                                       &IndexCB,sizeof(IndexCB),
                                       index_opts, TU);
   if (index_data.fail_for_error)
     result = -1;
 
   clang_disposeTranslationUnit(TU);
+  clang_disposeString(index_data.main_filename);
   free_client_data(&index_data);
   return result;
 }
 
 static int index_file(int argc, const char **argv, int full) {
   const char *check_prefix;
   CXIndex Idx;
   CXIndexAction idxAction;
while (I != E) {
     switch (len) {
       case 8:
         if (memcmp(kind, "ObjCIvar", 8) == 0) {
           if (I + 2 >= E)
             return insufficient_usr(kind, "<ivar name> <class USR>");
           if (!isUSR(I[2]))
             return not_usr("<class USR>", I[2]);
           else {
-            CXString x;
-            x.data = (void*) I[2];
-            x.private_flags = 0;
+            CXString x = createCXString(I[2]);
             print_usr(clang_constructUSR_ObjCIvar(I[1], x));
           }
 
           I += 3;
           continue;
         }
         break;
       case 9:
         if (memcmp(kind, "ObjCClass", 9) == 0) {
           if (I + 1 >= E)
             return insufficient_usr(kind, "<class name>");
           print_usr(clang_constructUSR_ObjCClass(I[1]));
           I += 2;
           continue;
         }
         break;
       case 10:
         if (memcmp(kind, "ObjCMethod", 10) == 0) {
           if (I + 3 >= E)
             return insufficient_usr(kind, "<method selector> "
                 "[0=class method|1=instance method] <class USR>");
           if (!isUSR(I[3]))
             return not_usr("<class USR>", I[3]);
           else {
-            CXString x;
-            x.data = (void*) I[3];
-            x.private_flags = 0;
+            CXString x = createCXString(I[3]);
             print_usr(clang_constructUSR_ObjCMethod(I[1], atoi(I[2]), x));
           }
           I += 4;
           continue;
         }
         break;
       case 12:
         if (memcmp(kind, "ObjCCategory", 12) == 0) {
switch (len) {
           continue;
         }
         if (memcmp(kind, "ObjCProperty", 12) == 0) {
           if (I + 2 >= E)
             return insufficient_usr(kind, "<property name> <class USR>");
           if (!isUSR(I[2]))
             return not_usr("<class USR>", I[2]);
           else {
-            CXString x;
-            x.data = (void*) I[2];
-            x.private_flags = 0;
+            CXString x = createCXString(I[2]);
             print_usr(clang_constructUSR_ObjCProperty(I[1], x));
           }
           I += 3;
           continue;
         }
         break;
       default:
         break;