include/llvm/Support/system_error.h

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