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