Home | History | Annotate | Download | only in libclang 
      1 //===- BuildSystem.cpp - Utilities for use by build systems ---------------===//
      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 file implements various utilities for use by build systems.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang-c/BuildSystem.h"
     15 #include "CXString.h"
     16 #include "clang/Basic/VirtualFileSystem.h"
     17 #include "llvm/ADT/SmallString.h"
     18 #include "llvm/Support/CBindingWrapping.h"
     19 #include "llvm/Support/Path.h"
     20 #include "llvm/Support/TimeValue.h"
     21 #include "llvm/Support/raw_ostream.h"
     22 
     23 using namespace clang;
     24 using namespace llvm::sys;
     25 
     26 unsigned long long clang_getBuildSessionTimestamp(void) {
     27   return llvm::sys::TimeValue::now().toEpochTime();
     28 }
     29 
     30 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(clang::vfs::YAMLVFSWriter,
     31                                    CXVirtualFileOverlay)
     32 
     33 CXVirtualFileOverlay clang_VirtualFileOverlay_create(unsigned) {
     34   return wrap(new clang::vfs::YAMLVFSWriter());
     35 }
     36 
     37 enum CXErrorCode
     38 clang_VirtualFileOverlay_addFileMapping(CXVirtualFileOverlay VFO,
     39                                         const char *virtualPath,
     40                                         const char *realPath) {
     41   if (!VFO || !virtualPath || !realPath)
     42     return CXError_InvalidArguments;
     43   if (!path::is_absolute(virtualPath))
     44     return CXError_InvalidArguments;
     45   if (!path::is_absolute(realPath))
     46     return CXError_InvalidArguments;
     47 
     48   for (path::const_iterator
     49          PI = path::begin(virtualPath),
     50          PE = path::end(virtualPath); PI != PE; ++PI) {
     51     StringRef Comp = *PI;
     52     if (Comp == "." || Comp == "..")
     53       return CXError_InvalidArguments;
     54   }
     55 
     56   unwrap(VFO)->addFileMapping(virtualPath, realPath);
     57   return CXError_Success;
     58 }
     59 
     60 enum CXErrorCode
     61 clang_VirtualFileOverlay_setCaseSensitivity(CXVirtualFileOverlay VFO,
     62                                             int caseSensitive) {
     63   if (!VFO)
     64     return CXError_InvalidArguments;
     65   unwrap(VFO)->setCaseSensitivity(caseSensitive);
     66   return CXError_Success;
     67 }
     68 
     69 enum CXErrorCode
     70 clang_VirtualFileOverlay_writeToBuffer(CXVirtualFileOverlay VFO, unsigned,
     71                                        char **out_buffer_ptr,
     72                                        unsigned *out_buffer_size) {
     73   if (!VFO || !out_buffer_ptr || !out_buffer_size)
     74     return CXError_InvalidArguments;
     75 
     76   llvm::SmallString<256> Buf;
     77   llvm::raw_svector_ostream OS(Buf);
     78   unwrap(VFO)->write(OS);
     79 
     80   StringRef Data = OS.str();
     81   *out_buffer_ptr = (char*)malloc(Data.size());
     82   *out_buffer_size = Data.size();
     83   memcpy(*out_buffer_ptr, Data.data(), Data.size());
     84   return CXError_Success;
     85 }
     86 
     87 void clang_free(void *buffer) {
     88   free(buffer);
     89 }
     90 
     91 void clang_VirtualFileOverlay_dispose(CXVirtualFileOverlay VFO) {
     92   delete unwrap(VFO);
     93 }
     94 
     95 
     96 struct CXModuleMapDescriptorImpl {
     97   std::string ModuleName;
     98   std::string UmbrellaHeader;
     99 };
    100 
    101 CXModuleMapDescriptor clang_ModuleMapDescriptor_create(unsigned) {
    102   return new CXModuleMapDescriptorImpl();
    103 }
    104 
    105 enum CXErrorCode
    106 clang_ModuleMapDescriptor_setFrameworkModuleName(CXModuleMapDescriptor MMD,
    107                                                  const char *name) {
    108   if (!MMD || !name)
    109     return CXError_InvalidArguments;
    110 
    111   MMD->ModuleName = name;
    112   return CXError_Success;
    113 }
    114 
    115 enum CXErrorCode
    116 clang_ModuleMapDescriptor_setUmbrellaHeader(CXModuleMapDescriptor MMD,
    117                                             const char *name) {
    118   if (!MMD || !name)
    119     return CXError_InvalidArguments;
    120 
    121   MMD->UmbrellaHeader = name;
    122   return CXError_Success;
    123 }
    124 
    125 enum CXErrorCode
    126 clang_ModuleMapDescriptor_writeToBuffer(CXModuleMapDescriptor MMD, unsigned,
    127                                        char **out_buffer_ptr,
    128                                        unsigned *out_buffer_size) {
    129   if (!MMD || !out_buffer_ptr || !out_buffer_size)
    130     return CXError_InvalidArguments;
    131 
    132   llvm::SmallString<256> Buf;
    133   llvm::raw_svector_ostream OS(Buf);
    134   OS << "framework module " << MMD->ModuleName << " {\n";
    135   OS << "  umbrella header \"";
    136   OS.write_escaped(MMD->UmbrellaHeader) << "\"\n";
    137   OS << '\n';
    138   OS << "  export *\n";
    139   OS << "  module * { export * }\n";
    140   OS << "}\n";
    141 
    142   StringRef Data = OS.str();
    143   *out_buffer_ptr = (char*)malloc(Data.size());
    144   *out_buffer_size = Data.size();
    145   memcpy(*out_buffer_ptr, Data.data(), Data.size());
    146   return CXError_Success;
    147 }
    148 
    149 void clang_ModuleMapDescriptor_dispose(CXModuleMapDescriptor MMD) {
    150   delete MMD;
    151 }
    152