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