This is the first step in adding sane error handling support to LLVMSystem.

The system API's will be shifted over to returning an error_code, and returning
other return values as out parameters to the function.

Code that needs to check error conditions will use the errc enum values which
are the same as the posix_errno defines (EBADF, E2BIG, etc...), and are
compatable with the error codes in WinError.h due to some magic in system_error.

An example would be:

if (error_code ec = KillEvil("Java")) { // error_code can be converted to bool.
  handle_error(ec);
}

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119360 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 1 insertions, 1192 deletions

diff --git a/utils/KillTheDoctor/CMakeLists.txt b/utils/KillTheDoctor/CMakeLists.txt
index 32e481cbea..fc6fa9b508 100644
--- a/utils/KillTheDoctor/CMakeLists.txt
+++ b/utils/KillTheDoctor/CMakeLists.txt
@@ -1,6 +1,5 @@
 add_executable(KillTheDoctor
   KillTheDoctor.cpp
-  system_error.cpp
   )
 
 target_link_libraries(KillTheDoctor LLVMSupport LLVMSystem)
diff --git a/utils/KillTheDoctor/KillTheDoctor.cpp b/utils/KillTheDoctor/KillTheDoctor.cpp
index c0bf437a72..28b1c0ad38 100644
--- a/utils/KillTheDoctor/KillTheDoctor.cpp
+++ b/utils/KillTheDoctor/KillTheDoctor.cpp
@@ -42,7 +42,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/type_traits.h"
 #include "llvm/System/Signals.h"
-#include "system_error.h"
+#include "llvm/System/system_error.h"
 #include <algorithm>
 #include <cerrno>
 #include <cstdlib>
diff --git a/utils/KillTheDoctor/system_error.cpp b/utils/KillTheDoctor/system_error.cpp
deleted file mode 100644
index 0e78fb379e..0000000000
--- a/utils/KillTheDoctor/system_error.cpp
+++ /dev/null
@@ -1,287 +0,0 @@
-//===---------------------- system_error.cpp ------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This was lifted from libc++ and modified for C++03.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Config/config.h"
-#include "system_error.h"
-#include <string>
-#include <cstring>
-
-namespace llvm {
-
-// class error_category
-
-error_category::error_category() {
-}
-
-error_category::~error_category() {
-}
-
-error_condition
-error_category::default_error_condition(int ev) const {
-  return error_condition(ev, *this);
-}
-
-bool
-error_category::equivalent(int code, const error_condition& condition) const {
-  return default_error_condition(code) == condition;
-}
-
-bool
-error_category::equivalent(const error_code& code, int condition) const {
-  return *this == code.category() && code.value() == condition;
-}
-
-std::string
-_do_message::message(int ev) const {
-  return std::string(std::strerror(ev));
-}
-
-class _generic_error_category : public _do_message {
-public:
-  virtual const char* name() const;
-  virtual std::string message(int ev) const;
-};
-
-const char*
-_generic_error_category::name() const {
-  return "generic";
-}
-
-std::string
-_generic_error_category::message(int ev) const {
-#ifdef ELAST
-  if (ev > ELAST)
-    return std::string("unspecified generic_category error");
-#endif  // ELAST
-  return _do_message::message(ev);
-}
-
-const error_category&
-generic_category() {
-  static _generic_error_category s;
-  return s;
-}
-
-class _system_error_category : public _do_message {
-public:
-  virtual const char* name() const;
-  virtual std::string message(int ev) const;
-  virtual error_condition default_error_condition(int ev) const;
-};
-
-const char*
-_system_error_category::name() const {
-  return "system";
-}
-
-// std::string _system_error_category::message(int ev) const {
-// Is in Platform/system_error.inc
-
-// error_condition _system_error_category::default_error_condition(int ev) const
-// Is in Platform/system_error.inc
-
-const error_category&
-system_category() {
-  static _system_error_category s;
-  return s;
-}
-
-// error_condition
-
-std::string
-error_condition::message() const {
-  return _cat_->message(_val_);
-}
-
-// error_code
-
-std::string
-error_code::message() const {
-  return _cat_->message(_val_);
-}
-
-// system_error
-
-std::string
-system_error::_init(const error_code& ec, std::string what_arg) {
-  if (ec)
-  {
-    if (!what_arg.empty())
-      what_arg += ": ";
-    what_arg += ec.message();
-  }
-  return what_arg;
-}
-
-system_error::system_error(error_code ec, const std::string& what_arg)
-  : runtime_error(_init(ec, what_arg)), _ec_(ec) {
-}
-
-system_error::system_error(error_code ec, const char* what_arg)
-  : runtime_error(_init(ec, what_arg)), _ec_(ec) {
-}
-
-system_error::system_error(error_code ec)
-  : runtime_error(_init(ec, "")), _ec_(ec) {
-}
-
-system_error::system_error(int ev, const error_category& ecat,
-                           const std::string& what_arg)
-  : runtime_error(_init(error_code(ev, ecat), what_arg))
-  , _ec_(error_code(ev, ecat)) {
-}
-
-system_error::system_error(int ev, const error_category& ecat,
-                           const char* what_arg)
-  : runtime_error(_init(error_code(ev, ecat), what_arg))
-  , _ec_(error_code(ev, ecat)) {
-}
-
-system_error::system_error(int ev, const error_category& ecat)
-  : runtime_error(_init(error_code(ev, ecat), "")), _ec_(error_code(ev, ecat)) {
-}
-
-system_error::~system_error() throw() {
-}
-
-void
-_throw_system_error(int ev, const char* what_arg) {
-  throw system_error(error_code(ev, system_category()), what_arg);
-}
-
-} // end namespace llvm
-
-#ifdef LLVM_ON_WIN32
-#include <Windows.h>
-#include <WinError.h>
-
-namespace llvm {
-
-std::string
-_system_error_category::message(int ev) const {
-  LPVOID lpMsgBuf = 0;
-  DWORD retval = ::FormatMessageA(
-    FORMAT_MESSAGE_ALLOCATE_BUFFER |
-    FORMAT_MESSAGE_FROM_SYSTEM |
-    FORMAT_MESSAGE_IGNORE_INSERTS,
-    NULL,
-    ev,
-    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-    (LPSTR) &lpMsgBuf,
-    0,
-    NULL);
-  if (retval == 0) {
-    ::LocalFree(lpMsgBuf);
-    return std::string("Unknown error");
-  }
-
-  std::string str( static_cast<LPCSTR>(lpMsgBuf) );
-  ::LocalFree(lpMsgBuf);
-
-  while (str.size()
-     && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r'))
-    str.erase( str.size()-1 );
-  if (str.size() && str[str.size()-1] == '.')
-    str.erase( str.size()-1 );
-  return str;
-}
-
-error_condition
-_system_error_category::default_error_condition(int ev) const {
-  switch (ev)
-  {
-  case 0: return make_error_condition(errc::success);
-  // Windows system -> posix_errno decode table  ---------------------------//
-  // see WinError.h comments for descriptions of errors
-  case ERROR_ACCESS_DENIED: return make_error_condition(errc::permission_denied);
-  case ERROR_ALREADY_EXISTS: return make_error_condition(errc::file_exists);
-  case ERROR_BAD_UNIT: return make_error_condition(errc::no_such_device);
-  case ERROR_BUFFER_OVERFLOW: return make_error_condition(errc::filename_too_long);
-  case ERROR_BUSY: return make_error_condition(errc::device_or_resource_busy);
-  case ERROR_BUSY_DRIVE: return make_error_condition(errc::device_or_resource_busy);
-  case ERROR_CANNOT_MAKE: return make_error_condition(errc::permission_denied);
-  case ERROR_CANTOPEN: return make_error_condition(errc::io_error);
-  case ERROR_CANTREAD: return make_error_condition(errc::io_error);
-  case ERROR_CANTWRITE: return make_error_condition(errc::io_error);
-  case ERROR_CURRENT_DIRECTORY: return make_error_condition(errc::permission_denied);
-  case ERROR_DEV_NOT_EXIST: return make_error_condition(errc::no_such_device);
-  case ERROR_DEVICE_IN_USE: return make_error_condition(errc::device_or_resource_busy);
-  case ERROR_DIR_NOT_EMPTY: return make_error_condition(errc::directory_not_empty);
-  case ERROR_DIRECTORY: return make_error_condition(errc::invalid_argument);
-  case ERROR_DISK_FULL: return make_error_condition(errc::no_space_on_device);
-  case ERROR_FILE_EXISTS: return make_error_condition(errc::file_exists);
-  case ERROR_FILE_NOT_FOUND: return make_error_condition(errc::no_such_file_or_directory);
-  case ERROR_HANDLE_DISK_FULL: return make_error_condition(errc::no_space_on_device);
-  case ERROR_INVALID_ACCESS: return make_error_condition(errc::permission_denied);
-  case ERROR_INVALID_DRIVE: return make_error_condition(errc::no_such_device);
-  case ERROR_INVALID_FUNCTION: return make_error_condition(errc::function_not_supported);
-  case ERROR_INVALID_HANDLE: return make_error_condition(errc::invalid_argument);
-  case ERROR_INVALID_NAME: return make_error_condition(errc::invalid_argument);
-  case ERROR_LOCK_VIOLATION: return make_error_condition(errc::no_lock_available);
-  case ERROR_LOCKED: return make_error_condition(errc::no_lock_available);
-  case ERROR_NEGATIVE_SEEK: return make_error_condition(errc::invalid_argument);
-  case ERROR_NOACCESS: return make_error_condition(errc::permission_denied);
-  case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition(errc::not_enough_memory);
-  case ERROR_NOT_READY: return make_error_condition(errc::resource_unavailable_try_again);
-  case ERROR_NOT_SAME_DEVICE: return make_error_condition(errc::cross_device_link);
-  case ERROR_OPEN_FAILED: return make_error_condition(errc::io_error);
-  case ERROR_OPEN_FILES: return make_error_condition(errc::device_or_resource_busy);
-  case ERROR_OPERATION_ABORTED: return make_error_condition(errc::operation_canceled);
-  case ERROR_OUTOFMEMORY: return make_error_condition(errc::not_enough_memory);
-  case ERROR_PATH_NOT_FOUND: return make_error_condition(errc::no_such_file_or_directory);
-  case ERROR_READ_FAULT: return make_error_condition(errc::io_error);
-  case ERROR_RETRY: return make_error_condition(errc::resource_unavailable_try_again);
-  case ERROR_SEEK: return make_error_condition(errc::io_error);
-  case ERROR_SHARING_VIOLATION: return make_error_condition(errc::permission_denied);
-  case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition(errc::too_many_files_open);
-  case ERROR_WRITE_FAULT: return make_error_condition(errc::io_error);
-  case ERROR_WRITE_PROTECT: return make_error_condition(errc::permission_denied);
-  case ERROR_SEM_TIMEOUT: return make_error_condition(errc::timed_out);
-  case WSAEACCES: return make_error_condition(errc::permission_denied);
-  case WSAEADDRINUSE: return make_error_condition(errc::address_in_use);
-  case WSAEADDRNOTAVAIL: return make_error_condition(errc::address_not_available);
-  case WSAEAFNOSUPPORT: return make_error_condition(errc::address_family_not_supported);
-  case WSAEALREADY: return make_error_condition(errc::connection_already_in_progress);
-  case WSAEBADF: return make_error_condition(errc::bad_file_descriptor);
-  case WSAECONNABORTED: return make_error_condition(errc::connection_aborted);
-  case WSAECONNREFUSED: return make_error_condition(errc::connection_refused);
-  case WSAECONNRESET: return make_error_condition(errc::connection_reset);
-  case WSAEDESTADDRREQ: return make_error_condition(errc::destination_address_required);
-  case WSAEFAULT: return make_error_condition(errc::bad_address);
-  case WSAEHOSTUNREACH: return make_error_condition(errc::host_unreachable);
-  case WSAEINPROGRESS: return make_error_condition(errc::operation_in_progress);
-  case WSAEINTR: return make_error_condition(errc::interrupted);
-  case WSAEINVAL: return make_error_condition(errc::invalid_argument);
-  case WSAEISCONN: return make_error_condition(errc::already_connected);
-  case WSAEMFILE: return make_error_condition(errc::too_many_files_open);
-  case WSAEMSGSIZE: return make_error_condition(errc::message_size);
-  case WSAENAMETOOLONG: return make_error_condition(errc::filename_too_long);
-  case WSAENETDOWN: return make_error_condition(errc::network_down);
-  case WSAENETRESET: return make_error_condition(errc::network_reset);
-  case WSAENETUNREACH: return make_error_condition(errc::network_unreachable);
-  case WSAENOBUFS: return make_error_condition(errc::no_buffer_space);
-  case WSAENOPROTOOPT: return make_error_condition(errc::no_protocol_option);
-  case WSAENOTCONN: return make_error_condition(errc::not_connected);
-  case WSAENOTSOCK: return make_error_condition(errc::not_a_socket);
-  case WSAEOPNOTSUPP: return make_error_condition(errc::operation_not_supported);
-  case WSAEPROTONOSUPPORT: return make_error_condition(errc::protocol_not_supported);
-  case WSAEPROTOTYPE: return make_error_condition(errc::wrong_protocol_type);
-  case WSAETIMEDOUT: return make_error_condition(errc::timed_out);
-  case WSAEWOULDBLOCK: return make_error_condition(errc::operation_would_block);
-  default: return error_condition(ev, system_category());
-  }
-}
-
-} // end namespace llvm
-
-#endif // LLVM_ON_WIN32
diff --git a/utils/KillTheDoctor/system_error.h b/utils/KillTheDoctor/system_error.h
deleted file mode 100644
index 55faa1baef..0000000000
--- a/utils/KillTheDoctor/system_error.h
+++ /dev/null
@@ -1,903 +0,0 @@
-//===---------------------------- system_error ----------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This was lifted from libc++ and modified for C++03.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SYSTEM_SYSTEM_ERROR_H
-#define LLVM_SYSTEM_SYSTEM_ERROR_H
-
-/*
-    system_error synopsis
-
-namespace std
-{
-
-class error_category
-{
-public:
-    virtual ~error_category();
-
-    error_category(const error_category&) = delete;
-    error_category& operator=(const error_category&) = delete;
-
-    virtual const char* name() const = 0;
-    virtual error_condition default_error_condition(int ev) const;
-    virtual bool equivalent(int code, const error_condition& condition) const;
-    virtual bool equivalent(const error_code& code, int condition) const;
-    virtual std::string message(int ev) const = 0;
-
-    bool operator==(const error_category& rhs) const;
-    bool operator!=(const error_category& rhs) const;
-    bool operator<(const error_category& rhs) const;
-};
-
-const error_category& generic_category();
-const error_category& system_category();
-
-template <class T> struct is_error_code_enum
-    : public false_type {};
-
-template <class T> struct is_error_condition_enum
-    : public false_type {};
-
-class error_code
-{
-public:
-    // constructors:
-    error_code();
-    error_code(int val, const error_category& cat);
-    template <class ErrorCodeEnum>
-        error_code(ErrorCodeEnum e);
-
-    // modifiers:
-    void assign(int val, const error_category& cat);
-    template <class ErrorCodeEnum>
-        error_code& operator=(ErrorCodeEnum e);
-    void clear();
-
-    // observers:
-    int value() const;
-    const error_category& category() const;
-    error_condition default_error_condition() const;
-    std::string message() const;
-    explicit operator bool() const;
-};
-
-// non-member functions:
-bool operator<(const error_code& lhs, const error_code& rhs);
-template <class charT, class traits>
-    basic_ostream<charT,traits>&
-    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
-
-class error_condition
-{
-public:
-    // constructors:
-    error_condition();
-    error_condition(int val, const error_category& cat);
-    template <class ErrorConditionEnum>
-        error_condition(ErrorConditionEnum e);
-
-    // modifiers:
-    void assign(int val, const error_category& cat);
-    template <class ErrorConditionEnum>
-        error_condition& operator=(ErrorConditionEnum e);
-    void clear();
-
-    // observers:
-    int value() const;
-    const error_category& category() const;
-    std::string message() const;
-    explicit operator bool() const;
-};
-
-bool operator<(const error_condition& lhs, const error_condition& rhs);
-
-class system_error
-    : public runtime_error
-{
-public:
-    system_error(error_code ec, const std::string& what_arg);
-    system_error(error_code ec, const char* what_arg);
-    system_error(error_code ec);
-    system_error(int ev, const error_category& ecat, const std::string& what_arg);
-    system_error(int ev, const error_category& ecat, const char* what_arg);
-    system_error(int ev, const error_category& ecat);
-
-    const error_code& code() const throw();
-    const char* what() const throw();
-};
-
-enum class errc
-{
-    address_family_not_supported,       // EAFNOSUPPORT
-    address_in_use,                     // EADDRINUSE
-    address_not_available,              // EADDRNOTAVAIL
-    already_connected,                  // EISCONN
-    argument_list_too_long,             // E2BIG
-    argument_out_of_domain,             // EDOM
-    bad_address,                        // EFAULT
-    bad_file_descriptor,                // EBADF
-    bad_message,                        // EBADMSG
-    broken_pipe,                        // EPIPE
-    connection_aborted,                 // ECONNABORTED
-    connection_already_in_progress,     // EALREADY
-    connection_refused,                 // ECONNREFUSED
-    connection_reset,                   // ECONNRESET
-    cross_device_link,                  // EXDEV
-    destination_address_required,       // EDESTADDRREQ
-    device_or_resource_busy,            // EBUSY
-    directory_not_empty,                // ENOTEMPTY
-    executable_format_error,            // ENOEXEC
-    file_exists,                        // EEXIST
-    file_too_large,                     // EFBIG
-    filename_too_long,                  // ENAMETOOLONG
-    function_not_supported,             // ENOSYS
-    host_unreachable,                   // EHOSTUNREACH
-    identifier_removed,                 // EIDRM
-    illegal_byte_sequence,              // EILSEQ
-    inappropriate_io_control_operation, // ENOTTY
-    interrupted,                        // EINTR
-    invalid_argument,                   // EINVAL
-    invalid_seek,                       // ESPIPE
-    io_error,                           // EIO
-    is_a_directory,                     // EISDIR
-    message_size,                       // EMSGSIZE
-    network_down,                       // ENETDOWN
-    network_reset,                      // ENETRESET
-    network_unreachable,                // ENETUNREACH
-    no_buffer_space,                    // ENOBUFS
-    no_child_process,                   // ECHILD
-    no_link,                            // ENOLINK
-    no_lock_available,                  // ENOLCK
-    no_message_available,               // ENODATA
-    no_message,                         // ENOMSG
-    no_protocol_option,                 // ENOPROTOOPT
-    no_space_on_device,                 // ENOSPC
-    no_stream_resources,                // ENOSR
-    no_such_device_or_address,          // ENXIO
-    no_such_device,                     // ENODEV
-    no_such_file_or_directory,          // ENOENT
-    no_such_process,                    // ESRCH
-    not_a_directory,                    // ENOTDIR
-    not_a_socket,                       // ENOTSOCK
-    not_a_stream,                       // ENOSTR
-    not_connected,                      // ENOTCONN
-    not_enough_memory,                  // ENOMEM
-    not_supported,                      // ENOTSUP
-    operation_canceled,                 // ECANCELED
-    operation_in_progress,              // EINPROGRESS
-    operation_not_permitted,            // EPERM
-    operation_not_supported,            // EOPNOTSUPP
-    operation_would_block,              // EWOULDBLOCK
-    owner_dead,                         // EOWNERDEAD
-    permission_denied,                  // EACCES
-    protocol_error,                     // EPROTO
-    protocol_not_supported,             // EPROTONOSUPPORT
-    read_only_file_system,              // EROFS
-    resource_deadlock_would_occur,      // EDEADLK
-    resource_unavailable_try_again,     // EAGAIN
-    result_out_of_range,                // ERANGE
-    state_not_recoverable,              // ENOTRECOVERABLE
-    stream_timeout,                     // ETIME
-    text_file_busy,                     // ETXTBSY
-    timed_out,                          // ETIMEDOUT
-    too_many_files_open_in_system,      // ENFILE
-    too_many_files_open,                // EMFILE
-    too_many_links,                     // EMLINK
-    too_many_symbolic_link_levels,      // ELOOP
-    value_too_large,                    // EOVERFLOW
-    wrong_protocol_type                 // EPROTOTYPE
-};
-
-template <> struct is_error_condition_enum<errc> : true_type { }
-
-error_code make_error_code(errc e);
-error_condition make_error_condition(errc e);
-
-// Comparison operators:
-bool operator==(const error_code& lhs, const error_code& rhs);
-bool operator==(const error_code& lhs, const error_condition& rhs);
-bool operator==(const error_condition& lhs, const error_code& rhs);
-bool operator==(const error_condition& lhs, const error_condition& rhs);
-bool operator!=(const error_code& lhs, const error_code& rhs);
-bool operator!=(const error_code& lhs, const error_condition& rhs);
-bool operator!=(const error_condition& lhs, const error_code& rhs);
-bool operator!=(const error_condition& lhs, const error_condition& rhs);
-
-template <> struct hash<std::error_code>;
-
-}  // std
-
-*/
-
-#include "llvm/Config/config.h"
-#include "llvm/Support/type_traits.h"
-#include <cerrno>
-#include <string>
-
-#ifdef LLVM_ON_WIN32
-  // VS 2008 needs this for some of the defines below.
-# include <WinSock2.h>
-
-  // The following numbers were taken from VS2010.
-# ifndef EAFNOSUPPORT
-#   define EAFNOSUPPORT WSAEAFNOSUPPORT
-# endif
-# ifndef EADDRINUSE
-#   define EADDRINUSE WSAEADDRINUSE
-# endif
-# ifndef EADDRNOTAVAIL
-#   define EADDRNOTAVAIL WSAEADDRNOTAVAIL
-# endif
-# ifndef EISCONN
-#   define EISCONN WSAEISCONN
-# endif
-# ifndef E2BIG
-#   define E2BIG WSAE2BIG
-# endif
-# ifndef EDOM
-#   define EDOM WSAEDOM
-# endif
-# ifndef EFAULT
-#   define EFAULT WSAEFAULT
-# endif
-# ifndef EBADF
-#   define EBADF WSAEBADF
-# endif
-# ifndef EBADMSG
-#   define EBADMSG 104
-# endif
-# ifndef EPIPE
-#   define EPIPE WSAEPIPE
-# endif
-# ifndef ECONNABORTED
-#   define ECONNABORTED WSAECONNABORTED
-# endif
-# ifndef EALREADY
-#   define EALREADY WSAEALREADY
-# endif
-# ifndef ECONNREFUSED
-#   define ECONNREFUSED WSAECONNREFUSED
-# endif
-# ifndef ECONNRESET
-#   define ECONNRESET WSAECONNRESET
-# endif
-# ifndef EXDEV
-#   define EXDEV WSAEXDEV
-# endif
-# ifndef EDESTADDRREQ
-#   define EDESTADDRREQ WSAEDESTADDRREQ
-# endif
-# ifndef EBUSY
-#   define EBUSY WSAEBUSY
-# endif
-# ifndef ENOTEMPTY
-#   define ENOTEMPTY WSAENOTEMPTY
-# endif
-# ifndef ENOEXEC
-#   define ENOEXEC WSAENOEXEC
-# endif
-# ifndef EEXIST
-#   define EEXIST WSAEEXIST
-# endif
-# ifndef EFBIG
-#   define EFBIG WSAEFBIG
-# endif
-# ifndef ENAMETOOLONG
-#   define ENAMETOOLONG WSAENAMETOOLONG
-# endif
-# ifndef ENOSYS
-#   define ENOSYS WSAENOSYS
-# endif
-# ifndef EHOSTUNREACH
-#   define EHOSTUNREACH WSAEHOSTUNREACH
-# endif
-# ifndef EIDRM
-#   define EIDRM 111
-# endif
-# ifndef EILSEQ
-#   define EILSEQ WSAEILSEQ
-# endif
-# ifndef ENOTTY
-#   define ENOTTY WSAENOTTY
-# endif
-# ifndef EINTR
-#   define EINTR WSAEINTR
-# endif
-# ifndef EINVAL
-#   define EINVAL WSAEINVAL
-# endif
-# ifndef ESPIPE
-#   define ESPIPE WSAESPIPE
-# endif
-# ifndef EIO
-#   define EIO WSAEIO
-# endif
-# ifndef EISDIR
-#   define EISDIR WSAEISDIR
-# endif
-# ifndef EMSGSIZE
-#   define EMSGSIZE WSAEMSGSIZE
-# endif
-# ifndef ENETDOWN
-#   define ENETDOWN WSAENETDOWN
-# endif
-# ifndef ENETRESET
-#   define ENETRESET WSAENETRESET
-# endif
-# ifndef ENETUNREACH
-#   define ENETUNREACH WSAENETUNREACH
-# endif
-# ifndef ENOBUFS
-#   define ENOBUFS WSAENOBUFS
-# endif
-# ifndef ECHILD
-#   define ECHILD WSAECHILD
-# endif
-# ifndef ENOLINK
-#   define ENOLINK 121
-# endif
-# ifndef ENOLCK
-#   define ENOLCK WSAENOLCK
-# endif
-# ifndef ENODATA
-#   define ENODATA 120
-# endif
-# ifndef ENOMSG
-#   define ENOMSG 122
-# endif
-# ifndef ENOPROTOOPT
-#   define ENOPROTOOPT WSAENOPROTOOPT
-# endif
-# ifndef ENOSPC
-#   define ENOSPC WSAENOSPC
-# endif
-# ifndef ENOSR
-#   define ENOSR 124
-# endif
-# ifndef ENXIO
-#   define ENXIO WSAENXIO
-# endif
-# ifndef ENODEV
-#   define ENODEV WSAENODEV
-# endif
-# ifndef ENOENT
-#   define ENOENT WSAENOENT
-# endif
-# ifndef ESRCH
-#   define ESRCH WSAESRCH
-# endif
-# ifndef ENOTDIR
-#   define ENOTDIR WSAENOTDIR
-# endif
-# ifndef ENOTSOCK
-#   define ENOTSOCK WSAENOTSOCK
-# endif
-# ifndef ENOSTR
-#   define ENOSTR 125
-# endif
-# ifndef ENOTCONN
-#   define ENOTCONN WSAENOTCONN
-# endif
-# ifndef ENOMEM
-#   define ENOMEM WSAENOMEM
-# endif
-# ifndef ENOTSUP
-#   define ENOTSUP 129
-# endif
-# ifndef ECANCELED
-#   define ECANCELED 105
-# endif
-# ifndef EINPROGRESS
-#   define EINPROGRESS WSAEINPROGRESS
-# endif
-# ifndef EPERM
-#   define EPERM WSAEPERM
-# endif
-# ifndef EOPNOTSUPP
-#   define EOPNOTSUPP WSAEOPNOTSUPP
-# endif
-# ifndef EWOULDBLOCK
-#   define EWOULDBLOCK WSAEWOULDBLOCK
-# endif
-# ifndef EOWNERDEAD
-#   define EOWNERDEAD 133
-# endif
-# ifndef EACCES
-#   define EACCES WSAEACCES
-# endif
-# ifndef EPROTO
-#   define EPROTO 134
-# endif
-# ifndef EPROTONOSUPPORT
-#   define EPROTONOSUPPORT WSAEPROTONOSUPPORT
-# endif
-# ifndef EROFS
-#   define EROFS WSAEROFS
-# endif
-# ifndef EDEADLK
-#   define EDEADLK WSAEDEADLK
-# endif
-# ifndef EAGAIN
-#   define EAGAIN WSAEAGAIN
-# endif
-# ifndef ERANGE
-#   define ERANGE WSAERANGE
-# endif
-# ifndef ENOTRECOVERABLE
-#   define ENOTRECOVERABLE 127
-# endif
-# ifndef ETIME
-#   define ETIME 137
-# endif
-# ifndef ETXTBSY
-#   define ETXTBSY 139
-# endif
-# ifndef ETIMEDOUT
-#   define ETIMEDOUT WSAETIMEDOUT
-# endif
-# ifndef ENFILE
-#   define ENFILE WSAENFILE
-# endif
-# ifndef EMFILE
-#   define EMFILE WSAEMFILE
-# endif
-# ifndef EMLINK
-#   define EMLINK WSAEMLINK
-# endif
-# ifndef ELOOP
-#   define ELOOP WSAELOOP
-# endif
-# ifndef EOVERFLOW
-#   define EOVERFLOW 132
-# endif
-# ifndef EPROTOTYPE
-#   define EPROTOTYPE WSAEPROTOTYPE
-# endif
-#endif
-
-namespace llvm {
-
-template <class T, T v>
-struct integral_constant {
-  typedef T value_type;
-  static const value_type value = v;
-  typedef integral_constant<T,v> type;
-  operator value_type() { return value; }
-};
-
-typedef integral_constant<bool, true> true_type;
-typedef integral_constant<bool, false> false_type;
-
-// is_error_code_enum
-
-template <class Tp> struct is_error_code_enum : public false_type {};
-
-// is_error_condition_enum
-
-template <class Tp> struct is_error_condition_enum : public false_type {};
-
-// Some error codes are not present on all platforms, so we provide equivalents
-// for them:
-
-//enum class errc
-struct errc {
-enum _ {
-  success                             = 0,
-  address_family_not_supported        = EAFNOSUPPORT,
-  address_in_use                      = EADDRINUSE,
-  address_not_available               = EADDRNOTAVAIL,
-  already_connected                   = EISCONN,
-  argument_list_too_long              = E2BIG,
-  argument_out_of_domain              = EDOM,
-  bad_address                         = EFAULT,
-  bad_file_descriptor                 = EBADF,
-  bad_message                         = EBADMSG,
-  broken_pipe                         = EPIPE,
-  connection_aborted                  = ECONNABORTED,
-  connection_already_in_progress      = EALREADY,
-  connection_refused                  = ECONNREFUSED,
-  connection_reset                    = ECONNRESET,
-  cross_device_link                   = EXDEV,
-  destination_address_required        = EDESTADDRREQ,
-  device_or_resource_busy             = EBUSY,
-  directory_not_empty                 = ENOTEMPTY,
-  executable_format_error             = ENOEXEC,
-  file_exists                         = EEXIST,
-  file_too_large                      = EFBIG,
-  filename_too_long                   = ENAMETOOLONG,
-  function_not_supported              = ENOSYS,
-  host_unreachable                    = EHOSTUNREACH,
-  identifier_removed                  = EIDRM,
-  illegal_byte_sequence               = EILSEQ,
-  inappropriate_io_control_operation  = ENOTTY,
-  interrupted                         = EINTR,
-  invalid_argument                    = EINVAL,
-  invalid_seek                        = ESPIPE,
-  io_error                            = EIO,
-  is_a_directory                      = EISDIR,
-  message_size                        = EMSGSIZE,
-  network_down                        = ENETDOWN,
-  network_reset                       = ENETRESET,
-  network_unreachable                 = ENETUNREACH,
-  no_buffer_space                     = ENOBUFS,
-  no_child_process                    = ECHILD,
-  no_link                             = ENOLINK,
-  no_lock_available                   = ENOLCK,
-#ifdef ENODATA
-  no_message_available                = ENODATA,
-#else
-  no_message_available                = ENOMSG,
-#endif
-  no_message                          = ENOMSG,
-  no_protocol_option                  = ENOPROTOOPT,
-  no_space_on_device                  = ENOSPC,
-#ifdef ENOSR
-  no_stream_resources                 = ENOSR,
-#else
-  no_stream_resources                 = ENOMEM,
-#endif
-  no_such_device_or_address           = ENXIO,
-  no_such_device                      = ENODEV,
-  no_such_file_or_directory           = ENOENT,
-  no_such_process                     = ESRCH,
-  not_a_directory                     = ENOTDIR,
-  not_a_socket                        = ENOTSOCK,
-#ifdef ENOSTR
-  not_a_stream                        = ENOSTR,
-#else
-  not_a_stream                        = EINVAL,
-#endif
-  not_connected                       = ENOTCONN,
-  not_enough_memory                   = ENOMEM,
-  not_supported                       = ENOTSUP,
-  operation_canceled                  = ECANCELED,
-  operation_in_progress               = EINPROGRESS,
-  operation_not_permitted             = EPERM,
-  operation_not_supported             = EOPNOTSUPP,
-  operation_would_block               = EWOULDBLOCK,
-  owner_dead                          = EOWNERDEAD,
-  permission_denied                   = EACCES,
-  protocol_error                      = EPROTO,
-  protocol_not_supported              = EPROTONOSUPPORT,
-  read_only_file_system               = EROFS,
-  resource_deadlock_would_occur       = EDEADLK,
-  resource_unavailable_try_again      = EAGAIN,
-  result_out_of_range                 = ERANGE,
-  state_not_recoverable               = ENOTRECOVERABLE,
-#ifdef ETIME
-  stream_timeout                      = ETIME,
-#else
-  stream_timeout                      = ETIMEDOUT,
-#endif
-  text_file_busy                      = ETXTBSY,
-  timed_out                           = ETIMEDOUT,
-  too_many_files_open_in_system       = ENFILE,
-  too_many_files_open                 = EMFILE,
-  too_many_links                      = EMLINK,
-  too_many_symbolic_link_levels       = ELOOP,
-  value_too_large                     = EOVERFLOW,
-  wrong_protocol_type                 = EPROTOTYPE
-};
-
-  _ v_;
-
-  errc(_ v) : v_(v) {}
-  operator int() const {return v_;}
-};
-
-template <> struct is_error_condition_enum<errc> : true_type { };
-
-template <> struct is_error_condition_enum<errc::_> : true_type { };
-
-class error_condition;
-class error_code;
-
-// class error_category
-
-class _do_message;
-
-class error_category
-{
-public:
-  virtual ~error_category();
-
-private:
-  error_category();
-  error_category(const error_category&);// = delete;
-  error_category& operator=(const error_category&);// = delete;
-
-public:
-  virtual const char* name() const = 0;
-  virtual error_condition default_error_condition(int _ev) const;
-  virtual bool equivalent(int _code, const error_condition& _condition) const;
-  virtual bool equivalent(const error_code& _code, int _condition) const;
-  virtual std::string message(int _ev) const = 0;
-
-  bool operator==(const error_category& _rhs) const {return this == &_rhs;}
-
-  bool operator!=(const error_category& _rhs) const {return !(*this == _rhs);}
-
-  bool operator< (const error_category& _rhs) const {return this < &_rhs;}
-
-  friend class _do_message;
-};
-
-class _do_message : public error_category
-{
-public:
-  virtual std::string message(int ev) const;
-};
-
-const error_category& generic_category();
-const error_category& system_category();
-
-class error_condition
-{
-  int _val_;
-  const error_category* _cat_;
-public:
-  error_condition() : _val_(0), _cat_(&generic_category()) {}
-
-  error_condition(int _val, const error_category& _cat)
-    : _val_(_val), _cat_(&_cat) {}
-
-  template <class E>
-  error_condition(E _e, typename enable_if_c<
-                          is_error_condition_enum<E>::value
-                        >::type* = 0)
-    {*this = make_error_condition(_e);}
-
-  void assign(int _val, const error_category& _cat) {
-    _val_ = _val;
-    _cat_ = &_cat;
-  }
-
-  template <class E>
-    typename enable_if_c
-    <
-      is_error_condition_enum<E>::value,
-      error_condition&
-    >::type
-    operator=(E _e)
-      {*this = make_error_condition(_e); return *this;}
-
-  void clear() {
-    _val_ = 0;
-    _cat_ = &generic_category();
-  }
-
-  int value() const {return _val_;}
-
-  const error_category& category() const {return *_cat_;}
-  std::string message() const;
-
-  // explicit
-  operator bool() const {return _val_ != 0;}
-};
-
-inline error_condition make_error_condition(errc _e) {
-  return error_condition(static_cast<int>(_e), generic_category());
-}
-
-inline bool operator<(const error_condition& _x, const error_condition& _y) {
-  return _x.category() < _y.category()
-      || _x.category() == _y.category() && _x.value() < _y.value();
-}
-
-// error_code
-
-class error_code {
-  int _val_;
-  const error_category* _cat_;
-public:
-  error_code() : _val_(0), _cat_(&system_category()) {}
-
-  error_code(int _val, const error_category& _cat)
-    : _val_(_val), _cat_(&_cat) {}
-
-  template <class E>
-  error_code(E _e, typename enable_if_c<
-                     is_error_code_enum<E>::value
-                   >::type* = 0) {
-    *this = make_error_code(_e);
-  }
-
-  void assign(int _val, const error_category& _cat) {
-      _val_ = _val;
-      _cat_ = &_cat;
-  }
-
-  template <class E>
-    typename enable_if_c
-    <
-      is_error_code_enum<E>::value,
-      error_code&
-    >::type
-    operator=(E _e)
-      {*this = make_error_code(_e); return *this;}
-
-  void clear() {
-    _val_ = 0;
-    _cat_ = &system_category();
-  }
-
-  int value() const {return _val_;}
-
-  const error_category& category() const {return *_cat_;}
-
-  error_condition default_error_condition() const
-    {return _cat_->default_error_condition(_val_);}
-
-  std::string message() const;
-
-  // explicit
-  operator bool() const {return _val_ != 0;}
-};
-
-inline error_code make_error_code(errc _e) {
-  return error_code(static_cast<int>(_e), generic_category());
-}
-
-inline bool operator<(const error_code& _x, const error_code& _y) {
-  return _x.category() < _y.category()
-      || _x.category() == _y.category() && _x.value() < _y.value();
-}
-
-inline bool operator==(const error_code& _x, const error_code& _y) {
-  return _x.category() == _y.category() && _x.value() == _y.value();
-}
-
-inline bool operator==(const error_code& _x, const error_condition& _y) {
-  return _x.category().equivalent(_x.value(), _y)
-      || _y.category().equivalent(_x, _y.value());
-}
-
-inline bool operator==(const error_condition& _x, const error_code& _y) {
-  return _y == _x;
-}
-
-inline bool operator==(const error_condition& _x, const error_condition& _y) {
-   return _x.category() == _y.category() && _x.value() == _y.value();
-}
-
-inline bool operator!=(const error_code& _x, const error_code& _y) {
-  return !(_x == _y);
-}
-
-inline bool operator!=(const error_code& _x, const error_condition& _y) {
-  return !(_x == _y);
-}
-
-inline bool operator!=(const error_condition& _x, const error_code& _y) {
-  return !(_x == _y);
-}
-
-inline bool operator!=(const error_condition& _x, const error_condition& _y) {
-  return !(_x == _y);
-}
-
-// system_error
-
-class system_error : public std::runtime_error {
-  error_code _ec_;
-public:
-  system_error(error_code _ec, const std::string& _what_arg);
-  system_error(error_code _ec, const char* _what_arg);
-  system_error(error_code _ec);
-  system_error(int _ev, const error_category& _ecat,
-               const std::string& _what_arg);
-  system_error(int _ev, const error_category& _ecat, const char* _what_arg);
-  system_error(int _ev, const error_category& _ecat);
-  ~system_error() throw();
-
-  const error_code& code() const throw() {return _ec_;}
-
-private:
-  static std::string _init(const error_code&, std::string);
-};
-
-void _throw_system_error(int ev, const char* what_arg);
-
-} // end namespace llvm
-
-#ifdef LLVM_ON_WIN32
-#include <Windows.h>
-#include <WinError.h>
-
-namespace llvm {
-
-//  To construct an error_code after a API error:
-//
-//      error_code( ::GetLastError(), system_category() )
-struct windows_error {
-enum _ {
-  success = 0,
-  // These names and values are based on Windows winerror.h
-  invalid_function = ERROR_INVALID_FUNCTION,
-  file_not_found = ERROR_FILE_NOT_FOUND,
-  path_not_found = ERROR_PATH_NOT_FOUND,
-  too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
-  access_denied = ERROR_ACCESS_DENIED,
-  invalid_handle = ERROR_INVALID_HANDLE,
-  arena_trashed = ERROR_ARENA_TRASHED,
-  not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
-  invalid_block = ERROR_INVALID_BLOCK,
-  bad_environment = ERROR_BAD_ENVIRONMENT,
-  bad_format = ERROR_BAD_FORMAT,
-  invalid_access = ERROR_INVALID_ACCESS,
-  outofmemory = ERROR_OUTOFMEMORY,
-  invalid_drive = ERROR_INVALID_DRIVE,
-  current_directory = ERROR_CURRENT_DIRECTORY,
-  not_same_device = ERROR_NOT_SAME_DEVICE,
-  no_more_files = ERROR_NO_MORE_FILES,
-  write_protect = ERROR_WRITE_PROTECT,
-  bad_unit = ERROR_BAD_UNIT,
-  not_ready = ERROR_NOT_READY,
-  bad_command = ERROR_BAD_COMMAND,
-  crc = ERROR_CRC,
-  bad_length = ERROR_BAD_LENGTH,
-  seek = ERROR_SEEK,
-  not_dos_disk = ERROR_NOT_DOS_DISK,
-  sector_not_found = ERROR_SECTOR_NOT_FOUND,
-  out_of_paper = ERROR_OUT_OF_PAPER,
-  write_fault = ERROR_WRITE_FAULT,
-  read_fault = ERROR_READ_FAULT,
-  gen_failure = ERROR_GEN_FAILURE,
-  sharing_violation = ERROR_SHARING_VIOLATION,
-  lock_violation = ERROR_LOCK_VIOLATION,
-  wrong_disk = ERROR_WRONG_DISK,
-  sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
-  handle_eof = ERROR_HANDLE_EOF,
-  handle_disk_full= ERROR_HANDLE_DISK_FULL,
-  rem_not_list = ERROR_REM_NOT_LIST,
-  dup_name = ERROR_DUP_NAME,
-  bad_net_path = ERROR_BAD_NETPATH,
-  network_busy = ERROR_NETWORK_BUSY,
-  // ...
-  file_exists = ERROR_FILE_EXISTS,
-  cannot_make = ERROR_CANNOT_MAKE,
-  // ...
-  broken_pipe = ERROR_BROKEN_PIPE,
-  open_failed = ERROR_OPEN_FAILED,
-  buffer_overflow = ERROR_BUFFER_OVERFLOW,
-  disk_full= ERROR_DISK_FULL,
-  // ...
-  lock_failed = ERROR_LOCK_FAILED,
-  busy = ERROR_BUSY,
-  cancel_violation = ERROR_CANCEL_VIOLATION,
-  already_exists = ERROR_ALREADY_EXISTS
-  // ...
-
-  // TODO: add more Windows errors
-};
-  _ v_;
-
-  windows_error(_ v) : v_(v) {}
-  explicit windows_error(DWORD v) : v_(_(v)) {}
-  operator int() const {return v_;}
-};
-
-
-template <> struct is_error_code_enum<windows_error> : true_type { };
-
-template <> struct is_error_code_enum<windows_error::_> : true_type { };
-
-inline error_code make_error_code(windows_error e) {
-  return error_code(static_cast<int>(e), system_category());
-}
-
-} // end namespace llvm
-
-#endif // LLVM_ON_WINDOWS
-
-#endif