clang/include/clang-c/CXCompilationDatabase.h

   1 /*===-- clang-c/CXCompilationDatabase.h - Compilation database  ---*- C -*-===*\
   2 |*                                                                            *|
   3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
   4 |* Exceptions.                                                                *|
   5 |* See https://llvm.org/LICENSE.txt for license information.                  *|
   6 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
   7 |*                                                                            *|
   8 |*===----------------------------------------------------------------------===*|
   9 |*                                                                            *|
  10 |* This header provides a public interface to use CompilationDatabase without *|
  11 |* the full Clang C++ API.                                                    *|
  12 |*                                                                            *|
  13 \*===----------------------------------------------------------------------===*/
  14
  15 #ifndef LLVM_CLANG_C_CXCOMPILATIONDATABASE_H
  16 #define LLVM_CLANG_C_CXCOMPILATIONDATABASE_H
  17
  18 #include "clang-c/CXString.h"
  19 #include "clang-c/ExternC.h"
  20 #include "clang-c/Platform.h"
  21
  22 LLVM_CLANG_C_EXTERN_C_BEGIN
  23
  24 /** \defgroup COMPILATIONDB CompilationDatabase functions
  25  * \ingroup CINDEX
  26  *
  27  * @{
  28  */
  29
  30 /**
  31  * A compilation database holds all information used to compile files in a
  32  * project. For each file in the database, it can be queried for the working
  33  * directory or the command line used for the compiler invocation.
  34  *
  35  * Must be freed by \c clang_CompilationDatabase_dispose
  36  */
  37 typedef void * CXCompilationDatabase;
  38
  39 /**
  40  * Contains the results of a search in the compilation database
  41  *
  42  * When searching for the compile command for a file, the compilation db can
  43  * return several commands, as the file may have been compiled with
  44  * different options in different places of the project. This choice of compile
  45  * commands is wrapped in this opaque data structure. It must be freed by
  46  * \c clang_CompileCommands_dispose.
  47  */
  48 typedef void * CXCompileCommands;
  49
  50 /**
  51  * Represents the command line invocation to compile a specific file.
  52  */
  53 typedef void * CXCompileCommand;
  54
  55 /**
  56  * Error codes for Compilation Database
  57  */
  58 typedef enum  {
  59   /*
  60    * No error occurred
  61    */
  62   CXCompilationDatabase_NoError = 0,
  63
  64   /*
  65    * Database can not be loaded
  66    */
  67   CXCompilationDatabase_CanNotLoadDatabase = 1
  68
  69 } CXCompilationDatabase_Error;
  70
  71 /**
  72  * Creates a compilation database from the database found in directory
  73  * buildDir. For example, CMake can output a compile_commands.json which can
  74  * be used to build the database.
  75  *
  76  * It must be freed by \c clang_CompilationDatabase_dispose.
  77  */
  78 CINDEX_LINKAGE CXCompilationDatabase
  79 clang_CompilationDatabase_fromDirectory(const char *BuildDir,
  80                                         CXCompilationDatabase_Error *ErrorCode);
  81
  82 /**
  83  * Free the given compilation database
  84  */
  85 CINDEX_LINKAGE void
  86 clang_CompilationDatabase_dispose(CXCompilationDatabase);
  87
  88 /**
  89  * Find the compile commands used for a file. The compile commands
  90  * must be freed by \c clang_CompileCommands_dispose.
  91  */
  92 CINDEX_LINKAGE CXCompileCommands
  93 clang_CompilationDatabase_getCompileCommands(CXCompilationDatabase,
  94                                              const char *CompleteFileName);
  95
  96 /**
  97  * Get all the compile commands in the given compilation database.
  98  */
  99 CINDEX_LINKAGE CXCompileCommands
 100 clang_CompilationDatabase_getAllCompileCommands(CXCompilationDatabase);
 101
 102 /**
 103  * Free the given CompileCommands
 104  */
 105 CINDEX_LINKAGE void clang_CompileCommands_dispose(CXCompileCommands);
 106
 107 /**
 108  * Get the number of CompileCommand we have for a file
 109  */
 110 CINDEX_LINKAGE unsigned
 111 clang_CompileCommands_getSize(CXCompileCommands);
 112
 113 /**
 114  * Get the I'th CompileCommand for a file
 115  *
 116  * Note : 0 <= i < clang_CompileCommands_getSize(CXCompileCommands)
 117  */
 118 CINDEX_LINKAGE CXCompileCommand
 119 clang_CompileCommands_getCommand(CXCompileCommands, unsigned I);
 120
 121 /**
 122  * Get the working directory where the CompileCommand was executed from
 123  */
 124 CINDEX_LINKAGE CXString
 125 clang_CompileCommand_getDirectory(CXCompileCommand);
 126
 127 /**
 128  * Get the filename associated with the CompileCommand.
 129  */
 130 CINDEX_LINKAGE CXString
 131 clang_CompileCommand_getFilename(CXCompileCommand);
 132
 133 /**
 134  * Get the number of arguments in the compiler invocation.
 135  *
 136  */
 137 CINDEX_LINKAGE unsigned
 138 clang_CompileCommand_getNumArgs(CXCompileCommand);
 139
 140 /**
 141  * Get the I'th argument value in the compiler invocations
 142  *
 143  * Invariant :
 144  *  - argument 0 is the compiler executable
 145  */
 146 CINDEX_LINKAGE CXString
 147 clang_CompileCommand_getArg(CXCompileCommand, unsigned I);
 148
 149 /**
 150  * Get the number of source mappings for the compiler invocation.
 151  */
 152 CINDEX_LINKAGE unsigned
 153 clang_CompileCommand_getNumMappedSources(CXCompileCommand);
 154
 155 /**
 156  * Get the I'th mapped source path for the compiler invocation.
 157  */
 158 CINDEX_LINKAGE CXString
 159 clang_CompileCommand_getMappedSourcePath(CXCompileCommand, unsigned I);
 160
 161 /**
 162  * Get the I'th mapped source content for the compiler invocation.
 163  */
 164 CINDEX_LINKAGE CXString
 165 clang_CompileCommand_getMappedSourceContent(CXCompileCommand, unsigned I);
 166
 167 /**
 168  * @}
 169  */
 170
 171 LLVM_CLANG_C_EXTERN_C_END
 172
 173 #endif
 174