contrib/libc++/src/system_error.cpp

   1 //===---------------------- system_error.cpp ------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "__config"
  11
  12 #define _LIBCPP_BUILDING_SYSTEM_ERROR
  13 #include "system_error"
  14
  15 #include "include/config_elast.h"
  16 #include "cerrno"
  17 #include "cstring"
  18 #include "cstdio"
  19 #include "cstdlib"
  20 #include "string"
  21 #include "string.h"
  22 #include "__debug"
  23
  24 #if defined(__ANDROID__)
  25 #include <android/api-level.h>
  26 #endif
  27
  28 _LIBCPP_BEGIN_NAMESPACE_STD
  29
  30 // class error_category
  31
  32 #if defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
  33 error_category::error_category() _NOEXCEPT
  34 {
  35 }
  36 #endif
  37
  38 error_category::~error_category() _NOEXCEPT
  39 {
  40 }
  41
  42 error_condition
  43 error_category::default_error_condition(int ev) const _NOEXCEPT
  44 {
  45     return error_condition(ev, *this);
  46 }
  47
  48 bool
  49 error_category::equivalent(int code, const error_condition& condition) const _NOEXCEPT
  50 {
  51     return default_error_condition(code) == condition;
  52 }
  53
  54 bool
  55 error_category::equivalent(const error_code& code, int condition) const _NOEXCEPT
  56 {
  57     return *this == code.category() && code.value() == condition;
  58 }
  59
  60 #if !defined(_LIBCPP_HAS_NO_THREADS)
  61 namespace {
  62
  63 //  GLIBC also uses 1024 as the maximum buffer size internally.
  64 constexpr size_t strerror_buff_size = 1024;
  65
  66 string do_strerror_r(int ev);
  67
  68 #if defined(_LIBCPP_MSVCRT_LIKE)
  69 string do_strerror_r(int ev) {
  70   char buffer[strerror_buff_size];
  71   if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
  72     return string(buffer);
  73   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
  74   return string(buffer);
  75 }
  76 #else
  77
  78 // Only one of the two following functions will be used, depending on
  79 // the return type of strerror_r:
  80
  81 // For the GNU variant, a char* return value:
  82 __attribute__((unused)) const char *
  83 handle_strerror_r_return(char *strerror_return, char *buffer) {
  84   // GNU always returns a string pointer in its return value. The
  85   // string might point to either the input buffer, or a static
  86   // buffer, but we don't care which.
  87   return strerror_return;
  88 }
  89
  90 // For the POSIX variant: an int return value.
  91 __attribute__((unused)) const char *
  92 handle_strerror_r_return(int strerror_return, char *buffer) {
  93   // The POSIX variant either:
  94   // - fills in the provided buffer and returns 0
  95   // - returns a positive error value, or
  96   // - returns -1 and fills in errno with an error value.
  97   if (strerror_return == 0)
  98     return buffer;
  99
 100   // Only handle EINVAL. Other errors abort.
 101   int new_errno = strerror_return == -1 ? errno : strerror_return;
 102   if (new_errno == EINVAL)
 103     return "";
 104
 105   _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
 106   // FIXME maybe? 'strerror_buff_size' is likely to exceed the
 107   // maximum error size so ERANGE shouldn't be returned.
 108   std::abort();
 109 }
 110
 111 // This function handles both GNU and POSIX variants, dispatching to
 112 // one of the two above functions.
 113 string do_strerror_r(int ev) {
 114     char buffer[strerror_buff_size];
 115     // Preserve errno around the call. (The C++ standard requires that
 116     // system_error functions not modify errno).
 117     const int old_errno = errno;
 118     const char *error_message = handle_strerror_r_return(
 119         ::strerror_r(ev, buffer, strerror_buff_size), buffer);
 120     // If we didn't get any message, print one now.
 121     if (!error_message[0]) {
 122       std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
 123       error_message = buffer;
 124     }
 125     errno = old_errno;
 126     return string(error_message);
 127 }
 128 #endif
 129 } // end namespace
 130 #endif
 131
 132 string
 133 __do_message::message(int ev) const
 134 {
 135 #if defined(_LIBCPP_HAS_NO_THREADS)
 136     return string(::strerror(ev));
 137 #else
 138     return do_strerror_r(ev);
 139 #endif
 140 }
 141
 142 class _LIBCPP_HIDDEN __generic_error_category
 143     : public __do_message
 144 {
 145 public:
 146     virtual const char* name() const _NOEXCEPT;
 147     virtual string message(int ev) const;
 148 };
 149
 150 const char*
 151 __generic_error_category::name() const _NOEXCEPT
 152 {
 153     return "generic";
 154 }
 155
 156 string
 157 __generic_error_category::message(int ev) const
 158 {
 159 #ifdef _LIBCPP_ELAST
 160     if (ev > _LIBCPP_ELAST)
 161       return string("unspecified generic_category error");
 162 #endif  // _LIBCPP_ELAST
 163     return __do_message::message(ev);
 164 }
 165
 166 const error_category&
 167 generic_category() _NOEXCEPT
 168 {
 169     static __generic_error_category s;
 170     return s;
 171 }
 172
 173 class _LIBCPP_HIDDEN __system_error_category
 174     : public __do_message
 175 {
 176 public:
 177     virtual const char* name() const _NOEXCEPT;
 178     virtual string message(int ev) const;
 179     virtual error_condition default_error_condition(int ev) const _NOEXCEPT;
 180 };
 181
 182 const char*
 183 __system_error_category::name() const _NOEXCEPT
 184 {
 185     return "system";
 186 }
 187
 188 string
 189 __system_error_category::message(int ev) const
 190 {
 191 #ifdef _LIBCPP_ELAST
 192     if (ev > _LIBCPP_ELAST)
 193       return string("unspecified system_category error");
 194 #endif  // _LIBCPP_ELAST
 195     return __do_message::message(ev);
 196 }
 197
 198 error_condition
 199 __system_error_category::default_error_condition(int ev) const _NOEXCEPT
 200 {
 201 #ifdef _LIBCPP_ELAST
 202     if (ev > _LIBCPP_ELAST)
 203       return error_condition(ev, system_category());
 204 #endif  // _LIBCPP_ELAST
 205     return error_condition(ev, generic_category());
 206 }
 207
 208 const error_category&
 209 system_category() _NOEXCEPT
 210 {
 211     static __system_error_category s;
 212     return s;
 213 }
 214
 215 // error_condition
 216
 217 string
 218 error_condition::message() const
 219 {
 220     return __cat_->message(__val_);
 221 }
 222
 223 // error_code
 224
 225 string
 226 error_code::message() const
 227 {
 228     return __cat_->message(__val_);
 229 }
 230
 231 // system_error
 232
 233 string
 234 system_error::__init(const error_code& ec, string what_arg)
 235 {
 236     if (ec)
 237     {
 238         if (!what_arg.empty())
 239             what_arg += ": ";
 240         what_arg += ec.message();
 241     }
 242     return what_arg;
 243 }
 244
 245 system_error::system_error(error_code ec, const string& what_arg)
 246     : runtime_error(__init(ec, what_arg)),
 247       __ec_(ec)
 248 {
 249 }
 250
 251 system_error::system_error(error_code ec, const char* what_arg)
 252     : runtime_error(__init(ec, what_arg)),
 253       __ec_(ec)
 254 {
 255 }
 256
 257 system_error::system_error(error_code ec)
 258     : runtime_error(__init(ec, "")),
 259       __ec_(ec)
 260 {
 261 }
 262
 263 system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
 264     : runtime_error(__init(error_code(ev, ecat), what_arg)),
 265       __ec_(error_code(ev, ecat))
 266 {
 267 }
 268
 269 system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
 270     : runtime_error(__init(error_code(ev, ecat), what_arg)),
 271       __ec_(error_code(ev, ecat))
 272 {
 273 }
 274
 275 system_error::system_error(int ev, const error_category& ecat)
 276     : runtime_error(__init(error_code(ev, ecat), "")),
 277       __ec_(error_code(ev, ecat))
 278 {
 279 }
 280
 281 system_error::~system_error() _NOEXCEPT
 282 {
 283 }
 284
 285 void
 286 __throw_system_error(int ev, const char* what_arg)
 287 {
 288 #ifndef _LIBCPP_NO_EXCEPTIONS
 289     throw system_error(error_code(ev, system_category()), what_arg);
 290 #else
 291     (void)ev;
 292     (void)what_arg;
 293     _VSTD::abort();
 294 #endif
 295 }
 296
 297 _LIBCPP_END_NAMESPACE_STD