lib/Support/Windows/Windows.h

   1 //===- Win32/Win32.h - Common Win32 Include File ----------------*- 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 file defines things specific to Win32 implementations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 //=== WARNING: Implementation here must contain only generic Win32 code that
  16 //===          is guaranteed to work on *all* Win32 variants.
  17 //===----------------------------------------------------------------------===//
  18
  19 // Require at least Windows 2000 API.
  20 #define _WIN32_WINNT 0x0500
  21 #define _WIN32_IE    0x0500 // MinGW at it again.
  22 #define WIN32_LEAN_AND_MEAN
  23
  24 #include "llvm/Config/config.h" // Get build system configuration settings
  25 #include <Windows.h>
  26 #include <ShlObj.h>
  27 #include <cassert>
  28 #include <string>
  29
  30 inline bool MakeErrMsg(std::string* ErrMsg, const std::string& prefix) {
  31   if (!ErrMsg)
  32     return true;
  33   char *buffer = NULL;
  34   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
  35       NULL, GetLastError(), 0, (LPSTR)&buffer, 1, NULL);
  36   *ErrMsg = prefix + buffer;
  37   LocalFree(buffer);
  38   return true;
  39 }
  40
  41 class AutoHandle {
  42   HANDLE handle;
  43
  44 public:
  45   AutoHandle(HANDLE h) : handle(h) {}
  46
  47   ~AutoHandle() {
  48     if (handle)
  49       CloseHandle(handle);
  50   }
  51
  52   operator HANDLE() {
  53     return handle;
  54   }
  55
  56   AutoHandle &operator=(HANDLE h) {
  57     handle = h;
  58     return *this;
  59   }
  60 };
  61
  62 template <class HandleType, uintptr_t InvalidHandle,
  63           class DeleterType, DeleterType D>
  64 class ScopedHandle {
  65   HandleType Handle;
  66
  67 public:
  68   ScopedHandle() : Handle(InvalidHandle) {}
  69   ScopedHandle(HandleType handle) : Handle(handle) {}
  70
  71   ~ScopedHandle() {
  72     if (Handle != HandleType(InvalidHandle))
  73       D(Handle);
  74   }
  75
  76   HandleType take() {
  77     HandleType temp = Handle;
  78     Handle = HandleType(InvalidHandle);
  79     return temp;
  80   }
  81
  82   operator HandleType() const { return Handle; }
  83
  84   ScopedHandle &operator=(HandleType handle) {
  85     Handle = handle;
  86     return *this;
  87   }
  88
  89   typedef void (*unspecified_bool_type)();
  90   static void unspecified_bool_true() {}
  91
  92   // True if Handle is valid.
  93   operator unspecified_bool_type() const {
  94     return Handle == HandleType(InvalidHandle) ? 0 : unspecified_bool_true;
  95   }
  96
  97   bool operator!() const {
  98     return Handle == HandleType(InvalidHandle);
  99   }
 100 };
 101
 102 typedef ScopedHandle<HANDLE, uintptr_t(-1),
 103                       BOOL (WINAPI*)(HANDLE), ::FindClose>
 104   ScopedFindHandle;
 105
 106 namespace llvm {
 107 template <class T>
 108 class SmallVectorImpl;
 109
 110 template <class T>
 111 typename SmallVectorImpl<T>::const_pointer
 112 c_str(SmallVectorImpl<T> &str) {
 113   str.push_back(0);
 114   str.pop_back();
 115   return str.data();
 116 }
 117 } // end namespace llvm.