include/llvm/Support/system_error.h

   1 //===---------------------------- system_error ----------------------------===//
   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 was lifted from libc++ and modified for C++03. This is called
  11 // system_error even though it does not define that class because that's what
  12 // it's called in C++0x. We don't define system_error because it is only used
  13 // for exception handling, which we don't use in LLVM.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_SYSTEM_SYSTEM_ERROR_H
  18 #define LLVM_SYSTEM_SYSTEM_ERROR_H
  19
  20 /*
  21     system_error synopsis
  22
  23 namespace std
  24 {
  25
  26 class error_category
  27 {
  28 public:
  29     virtual ~error_category();
  30
  31     error_category(const error_category&) = delete;
  32     error_category& operator=(const error_category&) = delete;
  33
  34     virtual const char* name() const = 0;
  35     virtual error_condition default_error_condition(int ev) const;
  36     virtual bool equivalent(int code, const error_condition& condition) const;
  37     virtual bool equivalent(const error_code& code, int condition) const;
  38     virtual std::string message(int ev) const = 0;
  39
  40     bool operator==(const error_category& rhs) const;
  41     bool operator!=(const error_category& rhs) const;
  42     bool operator<(const error_category& rhs) const;
  43 };
  44
  45 const error_category& generic_category();
  46 const error_category& system_category();
  47
  48 template <class T> struct is_error_code_enum
  49     : public false_type {};
  50
  51 template <class T> struct is_error_condition_enum
  52     : public false_type {};
  53
  54 class error_code
  55 {
  56 public:
  57     // constructors:
  58     error_code();
  59     error_code(int val, const error_category& cat);
  60     template <class ErrorCodeEnum>
  61         error_code(ErrorCodeEnum e);
  62
  63     // modifiers:
  64     void assign(int val, const error_category& cat);
  65     template <class ErrorCodeEnum>
  66         error_code& operator=(ErrorCodeEnum e);
  67     void clear();
  68
  69     // observers:
  70     int value() const;
  71     const error_category& category() const;
  72     error_condition default_error_condition() const;
  73     std::string message() const;
  74     explicit operator bool() const;
  75 };
  76
  77 // non-member functions:
  78 bool operator<(const error_code& lhs, const error_code& rhs);
  79 template <class charT, class traits>
  80     basic_ostream<charT,traits>&
  81     operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
  82
  83 class error_condition
  84 {
  85 public:
  86     // constructors:
  87     error_condition();
  88     error_condition(int val, const error_category& cat);
  89     template <class ErrorConditionEnum>
  90         error_condition(ErrorConditionEnum e);
  91
  92     // modifiers:
  93     void assign(int val, const error_category& cat);
  94     template <class ErrorConditionEnum>
  95         error_condition& operator=(ErrorConditionEnum e);
  96     void clear();
  97
  98     // observers:
  99     int value() const;
 100     const error_category& category() const;
 101     std::string message() const;
 102     explicit operator bool() const;
 103 };
 104
 105 bool operator<(const error_condition& lhs, const error_condition& rhs);
 106
 107 class system_error
 108     : public runtime_error
 109 {
 110 public:
 111     system_error(error_code ec, const std::string& what_arg);
 112     system_error(error_code ec, const char* what_arg);
 113     system_error(error_code ec);
 114     system_error(int ev, const error_category& ecat, const std::string& what_arg);
 115     system_error(int ev, const error_category& ecat, const char* what_arg);
 116     system_error(int ev, const error_category& ecat);
 117
 118     const error_code& code() const throw();
 119     const char* what() const throw();
 120 };
 121
 122 enum class errc
 123 {
 124     address_family_not_supported,       // EAFNOSUPPORT
 125     address_in_use,                     // EADDRINUSE
 126     address_not_available,              // EADDRNOTAVAIL
 127     already_connected,                  // EISCONN
 128     argument_list_too_long,             // E2BIG
 129     argument_out_of_domain,             // EDOM
 130     bad_address,                        // EFAULT
 131     bad_file_descriptor,                // EBADF
 132     bad_message,                        // EBADMSG
 133     broken_pipe,                        // EPIPE
 134     connection_aborted,                 // ECONNABORTED
 135     connection_already_in_progress,     // EALREADY
 136     connection_refused,                 // ECONNREFUSED
 137     connection_reset,                   // ECONNRESET
 138     cross_device_link,                  // EXDEV
 139     destination_address_required,       // EDESTADDRREQ
 140     device_or_resource_busy,            // EBUSY
 141     directory_not_empty,                // ENOTEMPTY
 142     executable_format_error,            // ENOEXEC
 143     file_exists,                        // EEXIST
 144     file_too_large,                     // EFBIG
 145     filename_too_long,                  // ENAMETOOLONG
 146     function_not_supported,             // ENOSYS
 147     host_unreachable,                   // EHOSTUNREACH
 148     identifier_removed,                 // EIDRM
 149     illegal_byte_sequence,              // EILSEQ
 150     inappropriate_io_control_operation, // ENOTTY
 151     interrupted,                        // EINTR
 152     invalid_argument,                   // EINVAL
 153     invalid_seek,                       // ESPIPE
 154     io_error,                           // EIO
 155     is_a_directory,                     // EISDIR
 156     message_size,                       // EMSGSIZE
 157     network_down,                       // ENETDOWN
 158     network_reset,                      // ENETRESET
 159     network_unreachable,                // ENETUNREACH
 160     no_buffer_space,                    // ENOBUFS
 161     no_child_process,                   // ECHILD
 162     no_link,                            // ENOLINK
 163     no_lock_available,                  // ENOLCK
 164     no_message_available,               // ENODATA
 165     no_message,                         // ENOMSG
 166     no_protocol_option,                 // ENOPROTOOPT
 167     no_space_on_device,                 // ENOSPC
 168     no_stream_resources,                // ENOSR
 169     no_such_device_or_address,          // ENXIO
 170     no_such_device,                     // ENODEV
 171     no_such_file_or_directory,          // ENOENT
 172     no_such_process,                    // ESRCH
 173     not_a_directory,                    // ENOTDIR
 174     not_a_socket,                       // ENOTSOCK
 175     not_a_stream,                       // ENOSTR
 176     not_connected,                      // ENOTCONN
 177     not_enough_memory,                  // ENOMEM
 178     not_supported,                      // ENOTSUP
 179     operation_canceled,                 // ECANCELED
 180     operation_in_progress,              // EINPROGRESS
 181     operation_not_permitted,            // EPERM
 182     operation_not_supported,            // EOPNOTSUPP
 183     operation_would_block,              // EWOULDBLOCK
 184     owner_dead,                         // EOWNERDEAD
 185     permission_denied,                  // EACCES
 186     protocol_error,                     // EPROTO
 187     protocol_not_supported,             // EPROTONOSUPPORT
 188     read_only_file_system,              // EROFS
 189     resource_deadlock_would_occur,      // EDEADLK
 190     resource_unavailable_try_again,     // EAGAIN
 191     result_out_of_range,                // ERANGE
 192     state_not_recoverable,              // ENOTRECOVERABLE
 193     stream_timeout,                     // ETIME
 194     text_file_busy,                     // ETXTBSY
 195     timed_out,                          // ETIMEDOUT
 196     too_many_files_open_in_system,      // ENFILE
 197     too_many_files_open,                // EMFILE
 198     too_many_links,                     // EMLINK
 199     too_many_symbolic_link_levels,      // ELOOP
 200     value_too_large,                    // EOVERFLOW
 201     wrong_protocol_type                 // EPROTOTYPE
 202 };
 203
 204 template <> struct is_error_condition_enum<errc> : true_type { }
 205
 206 error_code make_error_code(errc e);
 207 error_condition make_error_condition(errc e);
 208
 209 // Comparison operators:
 210 bool operator==(const error_code& lhs, const error_code& rhs);
 211 bool operator==(const error_code& lhs, const error_condition& rhs);
 212 bool operator==(const error_condition& lhs, const error_code& rhs);
 213 bool operator==(const error_condition& lhs, const error_condition& rhs);
 214 bool operator!=(const error_code& lhs, const error_code& rhs);
 215 bool operator!=(const error_code& lhs, const error_condition& rhs);
 216 bool operator!=(const error_condition& lhs, const error_code& rhs);
 217 bool operator!=(const error_condition& lhs, const error_condition& rhs);
 218
 219 template <> struct hash<std::error_code>;
 220
 221 }  // std
 222
 223 */
 224
 225 #include "llvm/Config/config.h"
 226 #include "llvm/Support/type_traits.h"
 227 #include <cerrno>
 228 #include <string>
 229
 230 // This must be here instead of a .inc file because it is used in the definition
 231 // of the enum values below.
 232 #ifdef LLVM_ON_WIN32
 233
 234   // The following numbers were taken from VS2010.
 235 # ifndef EAFNOSUPPORT
 236 #   define EAFNOSUPPORT 102
 237 # endif
 238 # ifndef EADDRINUSE
 239 #   define EADDRINUSE 100
 240 # endif
 241 # ifndef EADDRNOTAVAIL
 242 #   define EADDRNOTAVAIL 101
 243 # endif
 244 # ifndef EISCONN
 245 #   define EISCONN 113
 246 # endif
 247 # ifndef E2BIG
 248 #   define E2BIG 7
 249 # endif
 250 # ifndef EDOM
 251 #   define EDOM 33
 252 # endif
 253 # ifndef EFAULT
 254 #   define EFAULT 14
 255 # endif
 256 # ifndef EBADF
 257 #   define EBADF 9
 258 # endif
 259 # ifndef EBADMSG
 260 #   define EBADMSG 104
 261 # endif
 262 # ifndef EPIPE
 263 #   define EPIPE 32
 264 # endif
 265 # ifndef ECONNABORTED
 266 #   define ECONNABORTED 106
 267 # endif
 268 # ifndef EALREADY
 269 #   define EALREADY 103
 270 # endif
 271 # ifndef ECONNREFUSED
 272 #   define ECONNREFUSED 107
 273 # endif
 274 # ifndef ECONNRESET
 275 #   define ECONNRESET 108
 276 # endif
 277 # ifndef EXDEV
 278 #   define EXDEV 18
 279 # endif
 280 # ifndef EDESTADDRREQ
 281 #   define EDESTADDRREQ 109
 282 # endif
 283 # ifndef EBUSY
 284 #   define EBUSY 16
 285 # endif
 286 # ifndef ENOTEMPTY
 287 #   define ENOTEMPTY 41
 288 # endif
 289 # ifndef ENOEXEC
 290 #   define ENOEXEC 8
 291 # endif
 292 # ifndef EEXIST
 293 #   define EEXIST 17
 294 # endif
 295 # ifndef EFBIG
 296 #   define EFBIG 27
 297 # endif
 298 # ifndef ENAMETOOLONG
 299 #   define ENAMETOOLONG 38
 300 # endif
 301 # ifndef ENOSYS
 302 #   define ENOSYS 40
 303 # endif
 304 # ifndef EHOSTUNREACH
 305 #   define EHOSTUNREACH 110
 306 # endif
 307 # ifndef EIDRM
 308 #   define EIDRM 111
 309 # endif
 310 # ifndef EILSEQ
 311 #   define EILSEQ 42
 312 # endif
 313 # ifndef ENOTTY
 314 #   define ENOTTY 25
 315 # endif
 316 # ifndef EINTR
 317 #   define EINTR 4
 318 # endif
 319 # ifndef EINVAL
 320 #   define EINVAL 22
 321 # endif
 322 # ifndef ESPIPE
 323 #   define ESPIPE 29
 324 # endif
 325 # ifndef EIO
 326 #   define EIO 5
 327 # endif
 328 # ifndef EISDIR
 329 #   define EISDIR 21
 330 # endif
 331 # ifndef EMSGSIZE
 332 #   define EMSGSIZE 115
 333 # endif
 334 # ifndef ENETDOWN
 335 #   define ENETDOWN 116
 336 # endif
 337 # ifndef ENETRESET
 338 #   define ENETRESET 117
 339 # endif
 340 # ifndef ENETUNREACH
 341 #   define ENETUNREACH 118
 342 # endif
 343 # ifndef ENOBUFS
 344 #   define ENOBUFS 119
 345 # endif
 346 # ifndef ECHILD
 347 #   define ECHILD 10
 348 # endif
 349 # ifndef ENOLINK
 350 #   define ENOLINK 121
 351 # endif
 352 # ifndef ENOLCK
 353 #   define ENOLCK 39
 354 # endif
 355 # ifndef ENODATA
 356 #   define ENODATA 120
 357 # endif
 358 # ifndef ENOMSG
 359 #   define ENOMSG 122
 360 # endif
 361 # ifndef ENOPROTOOPT
 362 #   define ENOPROTOOPT 123
 363 # endif
 364 # ifndef ENOSPC
 365 #   define ENOSPC 28
 366 # endif
 367 # ifndef ENOSR
 368 #   define ENOSR 124
 369 # endif
 370 # ifndef ENXIO
 371 #   define ENXIO 6
 372 # endif
 373 # ifndef ENODEV
 374 #   define ENODEV 19
 375 # endif
 376 # ifndef ENOENT
 377 #   define ENOENT 2
 378 # endif
 379 # ifndef ESRCH
 380 #   define ESRCH 3
 381 # endif
 382 # ifndef ENOTDIR
 383 #   define ENOTDIR 20
 384 # endif
 385 # ifndef ENOTSOCK
 386 #   define ENOTSOCK 128
 387 # endif
 388 # ifndef ENOSTR
 389 #   define ENOSTR 125
 390 # endif
 391 # ifndef ENOTCONN
 392 #   define ENOTCONN 126
 393 # endif
 394 # ifndef ENOMEM
 395 #   define ENOMEM 12
 396 # endif
 397 # ifndef ENOTSUP
 398 #   define ENOTSUP 129
 399 # endif
 400 # ifndef ECANCELED
 401 #   define ECANCELED 105
 402 # endif
 403 # ifndef EINPROGRESS
 404 #   define EINPROGRESS 112
 405 # endif
 406 # ifndef EPERM
 407 #   define EPERM 1
 408 # endif
 409 # ifndef EOPNOTSUPP
 410 #   define EOPNOTSUPP 130
 411 # endif
 412 # ifndef EWOULDBLOCK
 413 #   define EWOULDBLOCK 140
 414 # endif
 415 # ifndef EOWNERDEAD
 416 #   define EOWNERDEAD 133
 417 # endif
 418 # ifndef EACCES
 419 #   define EACCES 13
 420 # endif
 421 # ifndef EPROTO
 422 #   define EPROTO 134
 423 # endif
 424 # ifndef EPROTONOSUPPORT
 425 #   define EPROTONOSUPPORT 135
 426 # endif
 427 # ifndef EROFS
 428 #   define EROFS 30
 429 # endif
 430 # ifndef EDEADLK
 431 #   define EDEADLK 36
 432 # endif
 433 # ifndef EAGAIN
 434 #   define EAGAIN 11
 435 # endif
 436 # ifndef ERANGE
 437 #   define ERANGE 34
 438 # endif
 439 # ifndef ENOTRECOVERABLE
 440 #   define ENOTRECOVERABLE 127
 441 # endif
 442 # ifndef ETIME
 443 #   define ETIME 137
 444 # endif
 445 # ifndef ETXTBSY
 446 #   define ETXTBSY 139
 447 # endif
 448 # ifndef ETIMEDOUT
 449 #   define ETIMEDOUT 138
 450 # endif
 451 # ifndef ENFILE
 452 #   define ENFILE 23
 453 # endif
 454 # ifndef EMFILE
 455 #   define EMFILE 24
 456 # endif
 457 # ifndef EMLINK
 458 #   define EMLINK 31
 459 # endif
 460 # ifndef ELOOP
 461 #   define ELOOP 114
 462 # endif
 463 # ifndef EOVERFLOW
 464 #   define EOVERFLOW 132
 465 # endif
 466 # ifndef EPROTOTYPE
 467 #   define EPROTOTYPE 136
 468 # endif
 469 #endif
 470
 471 namespace llvm {
 472
 473 template <class T, T v>
 474 struct integral_constant {
 475   typedef T value_type;
 476   static const value_type value = v;
 477   typedef integral_constant<T,v> type;
 478   operator value_type() { return value; }
 479 };
 480
 481 typedef integral_constant<bool, true> true_type;
 482 typedef integral_constant<bool, false> false_type;
 483
 484 // is_error_code_enum
 485
 486 template <class Tp> struct is_error_code_enum : public false_type {};
 487
 488 // is_error_condition_enum
 489
 490 template <class Tp> struct is_error_condition_enum : public false_type {};
 491
 492 // Some error codes are not present on all platforms, so we provide equivalents
 493 // for them:
 494
 495 //enum class errc
 496 struct errc {
 497 enum _ {
 498   success                             = 0,
 499   address_family_not_supported        = EAFNOSUPPORT,
 500   address_in_use                      = EADDRINUSE,
 501   address_not_available               = EADDRNOTAVAIL,
 502   already_connected                   = EISCONN,
 503   argument_list_too_long              = E2BIG,
 504   argument_out_of_domain              = EDOM,
 505   bad_address                         = EFAULT,
 506   bad_file_descriptor                 = EBADF,
 507 #ifdef EBADMSG
 508   bad_message                         = EBADMSG,
 509 #else
 510   bad_message                         = EINVAL,
 511 #endif
 512   broken_pipe                         = EPIPE,
 513   connection_aborted                  = ECONNABORTED,
 514   connection_already_in_progress      = EALREADY,
 515   connection_refused                  = ECONNREFUSED,
 516   connection_reset                    = ECONNRESET,
 517   cross_device_link                   = EXDEV,
 518   destination_address_required        = EDESTADDRREQ,
 519   device_or_resource_busy             = EBUSY,
 520   directory_not_empty                 = ENOTEMPTY,
 521   executable_format_error             = ENOEXEC,
 522   file_exists                         = EEXIST,
 523   file_too_large                      = EFBIG,
 524   filename_too_long                   = ENAMETOOLONG,
 525   function_not_supported              = ENOSYS,
 526   host_unreachable                    = EHOSTUNREACH,
 527   identifier_removed                  = EIDRM,
 528   illegal_byte_sequence               = EILSEQ,
 529   inappropriate_io_control_operation  = ENOTTY,
 530   interrupted                         = EINTR,
 531   invalid_argument                    = EINVAL,
 532   invalid_seek                        = ESPIPE,
 533   io_error                            = EIO,
 534   is_a_directory                      = EISDIR,
 535   message_size                        = EMSGSIZE,
 536   network_down                        = ENETDOWN,
 537   network_reset                       = ENETRESET,
 538   network_unreachable                 = ENETUNREACH,
 539   no_buffer_space                     = ENOBUFS,
 540   no_child_process                    = ECHILD,
 541 #ifdef ENOLINK
 542   no_link                             = ENOLINK,
 543 #else
 544   no_link                             = EINVAL,
 545 #endif
 546   no_lock_available                   = ENOLCK,
 547 #ifdef ENODATA
 548   no_message_available                = ENODATA,
 549 #else
 550   no_message_available                = ENOMSG,
 551 #endif
 552   no_message                          = ENOMSG,
 553   no_protocol_option                  = ENOPROTOOPT,
 554   no_space_on_device                  = ENOSPC,
 555 #ifdef ENOSR
 556   no_stream_resources                 = ENOSR,
 557 #else
 558   no_stream_resources                 = ENOMEM,
 559 #endif
 560   no_such_device_or_address           = ENXIO,
 561   no_such_device                      = ENODEV,
 562   no_such_file_or_directory           = ENOENT,
 563   no_such_process                     = ESRCH,
 564   not_a_directory                     = ENOTDIR,
 565   not_a_socket                        = ENOTSOCK,
 566 #ifdef ENOSTR
 567   not_a_stream                        = ENOSTR,
 568 #else
 569   not_a_stream                        = EINVAL,
 570 #endif
 571   not_connected                       = ENOTCONN,
 572   not_enough_memory                   = ENOMEM,
 573   not_supported                       = ENOTSUP,
 574 #ifdef ECANCELED
 575   operation_canceled                  = ECANCELED,
 576 #else
 577   operation_canceled                  = EINVAL,
 578 #endif
 579   operation_in_progress               = EINPROGRESS,
 580   operation_not_permitted             = EPERM,
 581   operation_not_supported             = EOPNOTSUPP,
 582   operation_would_block               = EWOULDBLOCK,
 583 #ifdef EOWNERDEAD
 584   owner_dead                          = EOWNERDEAD,
 585 #else
 586   owner_dead                          = EINVAL,
 587 #endif
 588   permission_denied                   = EACCES,
 589 #ifdef EPROTO
 590   protocol_error                      = EPROTO,
 591 #else
 592   protocol_error                      = EINVAL,
 593 #endif
 594   protocol_not_supported              = EPROTONOSUPPORT,
 595   read_only_file_system               = EROFS,
 596   resource_deadlock_would_occur       = EDEADLK,
 597   resource_unavailable_try_again      = EAGAIN,
 598   result_out_of_range                 = ERANGE,
 599 #ifdef ENOTRECOVERABLE
 600   state_not_recoverable               = ENOTRECOVERABLE,
 601 #else
 602   state_not_recoverable               = EINVAL,
 603 #endif
 604 #ifdef ETIME
 605   stream_timeout                      = ETIME,
 606 #else
 607   stream_timeout                      = ETIMEDOUT,
 608 #endif
 609   text_file_busy                      = ETXTBSY,
 610   timed_out                           = ETIMEDOUT,
 611   too_many_files_open_in_system       = ENFILE,
 612   too_many_files_open                 = EMFILE,
 613   too_many_links                      = EMLINK,
 614   too_many_symbolic_link_levels       = ELOOP,
 615   value_too_large                     = EOVERFLOW,
 616   wrong_protocol_type                 = EPROTOTYPE
 617 };
 618
 619   _ v_;
 620
 621   errc(_ v) : v_(v) {}
 622   operator int() const {return v_;}
 623 };
 624
 625 template <> struct is_error_condition_enum<errc> : true_type { };
 626
 627 template <> struct is_error_condition_enum<errc::_> : true_type { };
 628
 629 class error_condition;
 630 class error_code;
 631
 632 // class error_category
 633
 634 class _do_message;
 635
 636 class error_category
 637 {
 638 public:
 639   virtual ~error_category();
 640
 641 private:
 642   error_category();
 643   error_category(const error_category&);// = delete;
 644   error_category& operator=(const error_category&);// = delete;
 645
 646 public:
 647   virtual const char* name() const = 0;
 648   virtual error_condition default_error_condition(int _ev) const;
 649   virtual bool equivalent(int _code, const error_condition& _condition) const;
 650   virtual bool equivalent(const error_code& _code, int _condition) const;
 651   virtual std::string message(int _ev) const = 0;
 652
 653   bool operator==(const error_category& _rhs) const {return this == &_rhs;}
 654
 655   bool operator!=(const error_category& _rhs) const {return !(*this == _rhs);}
 656
 657   bool operator< (const error_category& _rhs) const {return this < &_rhs;}
 658
 659   friend class _do_message;
 660 };
 661
 662 class _do_message : public error_category
 663 {
 664 public:
 665   virtual std::string message(int ev) const;
 666 };
 667
 668 const error_category& generic_category();
 669 const error_category& system_category();
 670
 671 /// Get the error_category used for errno values from POSIX functions. This is
 672 /// the same as the system_category on POISIX systems, but is the same as the
 673 /// generic_category on Windows.
 674 const error_category& posix_category();
 675
 676 class error_condition
 677 {
 678   int _val_;
 679   const error_category* _cat_;
 680 public:
 681   error_condition() : _val_(0), _cat_(&generic_category()) {}
 682
 683   error_condition(int _val, const error_category& _cat)
 684     : _val_(_val), _cat_(&_cat) {}
 685
 686   template <class E>
 687   error_condition(E _e, typename enable_if_c<
 688                           is_error_condition_enum<E>::value
 689                         >::type* = 0)
 690     {*this = make_error_condition(_e);}
 691
 692   void assign(int _val, const error_category& _cat) {
 693     _val_ = _val;
 694     _cat_ = &_cat;
 695   }
 696
 697   template <class E>
 698     typename enable_if_c
 699     <
 700       is_error_condition_enum<E>::value,
 701       error_condition&
 702     >::type
 703     operator=(E _e)
 704       {*this = make_error_condition(_e); return *this;}
 705
 706   void clear() {
 707     _val_ = 0;
 708     _cat_ = &generic_category();
 709   }
 710
 711   int value() const {return _val_;}
 712
 713   const error_category& category() const {return *_cat_;}
 714   std::string message() const;
 715
 716   typedef void (*unspecified_bool_type)();
 717   static void unspecified_bool_true() {}
 718
 719   operator unspecified_bool_type() const { // true if error
 720     return _val_ == 0 ? 0 : unspecified_bool_true;
 721   }
 722 };
 723
 724 inline error_condition make_error_condition(errc _e) {
 725   return error_condition(static_cast<int>(_e), generic_category());
 726 }
 727
 728 inline bool operator<(const error_condition& _x, const error_condition& _y) {
 729   return _x.category() < _y.category()
 730       || (_x.category() == _y.category() && _x.value() < _y.value());
 731 }
 732
 733 // error_code
 734
 735 class error_code {
 736   int _val_;
 737   const error_category* _cat_;
 738 public:
 739   error_code() : _val_(0), _cat_(&system_category()) {}
 740
 741   error_code(int _val, const error_category& _cat)
 742     : _val_(_val), _cat_(&_cat) {}
 743
 744   template <class E>
 745   error_code(E _e, typename enable_if_c<
 746                      is_error_code_enum<E>::value
 747                    >::type* = 0) {
 748     *this = make_error_code(_e);
 749   }
 750
 751   void assign(int _val, const error_category& _cat) {
 752       _val_ = _val;
 753       _cat_ = &_cat;
 754   }
 755
 756   template <class E>
 757     typename enable_if_c
 758     <
 759       is_error_code_enum<E>::value,
 760       error_code&
 761     >::type
 762     operator=(E _e)
 763       {*this = make_error_code(_e); return *this;}
 764
 765   void clear() {
 766     _val_ = 0;
 767     _cat_ = &system_category();
 768   }
 769
 770   int value() const {return _val_;}
 771
 772   const error_category& category() const {return *_cat_;}
 773
 774   error_condition default_error_condition() const
 775     {return _cat_->default_error_condition(_val_);}
 776
 777   std::string message() const;
 778
 779   typedef void (*unspecified_bool_type)();
 780   static void unspecified_bool_true() {}
 781
 782   operator unspecified_bool_type() const { // true if error
 783     return _val_ == 0 ? 0 : unspecified_bool_true;
 784   }
 785 };
 786
 787 inline error_code make_error_code(errc _e) {
 788   return error_code(static_cast<int>(_e), generic_category());
 789 }
 790
 791 inline bool operator<(const error_code& _x, const error_code& _y) {
 792   return _x.category() < _y.category()
 793       || (_x.category() == _y.category() && _x.value() < _y.value());
 794 }
 795
 796 inline bool operator==(const error_code& _x, const error_code& _y) {
 797   return _x.category() == _y.category() && _x.value() == _y.value();
 798 }
 799
 800 inline bool operator==(const error_code& _x, const error_condition& _y) {
 801   return _x.category().equivalent(_x.value(), _y)
 802       || _y.category().equivalent(_x, _y.value());
 803 }
 804
 805 inline bool operator==(const error_condition& _x, const error_code& _y) {
 806   return _y == _x;
 807 }
 808
 809 inline bool operator==(const error_condition& _x, const error_condition& _y) {
 810    return _x.category() == _y.category() && _x.value() == _y.value();
 811 }
 812
 813 inline bool operator!=(const error_code& _x, const error_code& _y) {
 814   return !(_x == _y);
 815 }
 816
 817 inline bool operator!=(const error_code& _x, const error_condition& _y) {
 818   return !(_x == _y);
 819 }
 820
 821 inline bool operator!=(const error_condition& _x, const error_code& _y) {
 822   return !(_x == _y);
 823 }
 824
 825 inline bool operator!=(const error_condition& _x, const error_condition& _y) {
 826   return !(_x == _y);
 827 }
 828
 829 // Windows errors.
 830
 831 //  To construct an error_code after an API error:
 832 //
 833 //      error_code( ::GetLastError(), system_category() )
 834 struct windows_error {
 835 enum _ {
 836   success = 0,
 837   // These names and values are based on Windows WinError.h
 838   // This is not a complete list. Add to this list if you need to explicitly
 839   // check for it.
 840   invalid_function        = 1, // ERROR_INVALID_FUNCTION,
 841   file_not_found          = 2, // ERROR_FILE_NOT_FOUND,
 842   path_not_found          = 3, // ERROR_PATH_NOT_FOUND,
 843   too_many_open_files     = 4, // ERROR_TOO_MANY_OPEN_FILES,
 844   access_denied           = 5, // ERROR_ACCESS_DENIED,
 845   invalid_handle          = 6, // ERROR_INVALID_HANDLE,
 846   arena_trashed           = 7, // ERROR_ARENA_TRASHED,
 847   not_enough_memory       = 8, // ERROR_NOT_ENOUGH_MEMORY,
 848   invalid_block           = 9, // ERROR_INVALID_BLOCK,
 849   bad_environment         = 10, // ERROR_BAD_ENVIRONMENT,
 850   bad_format              = 11, // ERROR_BAD_FORMAT,
 851   invalid_access          = 12, // ERROR_INVALID_ACCESS,
 852   outofmemory             = 14, // ERROR_OUTOFMEMORY,
 853   invalid_drive           = 15, // ERROR_INVALID_DRIVE,
 854   current_directory       = 16, // ERROR_CURRENT_DIRECTORY,
 855   not_same_device         = 17, // ERROR_NOT_SAME_DEVICE,
 856   no_more_files           = 18, // ERROR_NO_MORE_FILES,
 857   write_protect           = 19, // ERROR_WRITE_PROTECT,
 858   bad_unit                = 20, // ERROR_BAD_UNIT,
 859   not_ready               = 21, // ERROR_NOT_READY,
 860   bad_command             = 22, // ERROR_BAD_COMMAND,
 861   crc                     = 23, // ERROR_CRC,
 862   bad_length              = 24, // ERROR_BAD_LENGTH,
 863   seek                    = 25, // ERROR_SEEK,
 864   not_dos_disk            = 26, // ERROR_NOT_DOS_DISK,
 865   sector_not_found        = 27, // ERROR_SECTOR_NOT_FOUND,
 866   out_of_paper            = 28, // ERROR_OUT_OF_PAPER,
 867   write_fault             = 29, // ERROR_WRITE_FAULT,
 868   read_fault              = 30, // ERROR_READ_FAULT,
 869   gen_failure             = 31, // ERROR_GEN_FAILURE,
 870   sharing_violation       = 32, // ERROR_SHARING_VIOLATION,
 871   lock_violation          = 33, // ERROR_LOCK_VIOLATION,
 872   wrong_disk              = 34, // ERROR_WRONG_DISK,
 873   sharing_buffer_exceeded = 36, // ERROR_SHARING_BUFFER_EXCEEDED,
 874   handle_eof              = 38, // ERROR_HANDLE_EOF,
 875   handle_disk_full        = 39, // ERROR_HANDLE_DISK_FULL,
 876   rem_not_list            = 51, // ERROR_REM_NOT_LIST,
 877   dup_name                = 52, // ERROR_DUP_NAME,
 878   bad_net_path            = 53, // ERROR_BAD_NETPATH,
 879   network_busy            = 54, // ERROR_NETWORK_BUSY,
 880   file_exists             = 80, // ERROR_FILE_EXISTS,
 881   cannot_make             = 82, // ERROR_CANNOT_MAKE,
 882   broken_pipe             = 109, // ERROR_BROKEN_PIPE,
 883   open_failed             = 110, // ERROR_OPEN_FAILED,
 884   buffer_overflow         = 111, // ERROR_BUFFER_OVERFLOW,
 885   disk_full               = 112, // ERROR_DISK_FULL,
 886   insufficient_buffer     = 122, // ERROR_INSUFFICIENT_BUFFER,
 887   lock_failed             = 167, // ERROR_LOCK_FAILED,
 888   busy                    = 170, // ERROR_BUSY,
 889   cancel_violation        = 173, // ERROR_CANCEL_VIOLATION,
 890   already_exists          = 183  // ERROR_ALREADY_EXISTS
 891 };
 892   _ v_;
 893
 894   windows_error(_ v) : v_(v) {}
 895   explicit windows_error(int v) : v_(_(v)) {}
 896   operator int() const {return v_;}
 897 };
 898
 899
 900 template <> struct is_error_code_enum<windows_error> : true_type { };
 901
 902 template <> struct is_error_code_enum<windows_error::_> : true_type { };
 903
 904 inline error_code make_error_code(windows_error e) {
 905   return error_code(static_cast<int>(e), system_category());
 906 }
 907
 908 } // end namespace llvm
 909
 910 #endif