system_error.h revision 224145 
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_SYSTEM_SYSTEM_ERROR_H
18#define LLVM_SYSTEM_SYSTEM_ERROR_H
19
20/*
21    system_error synopsis
22
23namespace std
24{
25
26class error_category
27{
28public:
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
45const error_category& generic_category();
46const error_category& system_category();
47
48template <class T> struct is_error_code_enum
49    : public false_type {};
50
51template <class T> struct is_error_condition_enum
52    : public false_type {};
53
54class error_code
55{
56public:
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:
78bool operator<(const error_code& lhs, const error_code& rhs);
79template <class charT, class traits>
80    basic_ostream<charT,traits>&
81    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
82
83class error_condition
84{
85public:
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
105bool operator<(const error_condition& lhs, const error_condition& rhs);
106
107class system_error
108    : public runtime_error
109{
110public:
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
122enum 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
204template <> struct is_error_condition_enum<errc> : true_type { }
205
206error_code make_error_code(errc e);
207error_condition make_error_condition(errc e);
208
209// Comparison operators:
210bool operator==(const error_code& lhs, const error_code& rhs);
211bool operator==(const error_code& lhs, const error_condition& rhs);
212bool operator==(const error_condition& lhs, const error_code& rhs);
213bool operator==(const error_condition& lhs, const error_condition& rhs);
214bool operator!=(const error_code& lhs, const error_code& rhs);
215bool operator!=(const error_code& lhs, const error_condition& rhs);
216bool operator!=(const error_condition& lhs, const error_code& rhs);
217bool operator!=(const error_condition& lhs, const error_condition& rhs);
218
219template <> struct hash<std::error_code>;
220
221}  // std
222
223*/
224
225#include "llvm/Config/llvm-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
471namespace llvm {
472
473template <class T, T v>
474struct 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
481typedef integral_constant<bool, true> true_type;
482typedef integral_constant<bool, false> false_type;
483
484// is_error_code_enum
485
486template <class Tp> struct is_error_code_enum : public false_type {};
487
488// is_error_condition_enum
489
490template <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
496struct errc {
497enum _ {
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
625template <> struct is_error_condition_enum<errc> : true_type { };
626
627template <> struct is_error_condition_enum<errc::_> : true_type { };
628
629class error_condition;
630class error_code;
631
632// class error_category
633
634class _do_message;
635
636class error_category
637{
638public:
639  virtual ~error_category();
640
641private:
642  error_category();
643  error_category(const error_category&);// = delete;
644  error_category& operator=(const error_category&);// = delete;
645
646public:
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
662class _do_message : public error_category
663{
664public:
665  virtual std::string message(int ev) const;
666};
667
668const error_category& generic_category();
669const 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 POSIX systems, but is the same as the
673/// generic_category on Windows.
674const error_category& posix_category();
675
676class error_condition
677{
678  int _val_;
679  const error_category* _cat_;
680public:
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
724inline error_condition make_error_condition(errc _e) {
725  return error_condition(static_cast<int>(_e), generic_category());
726}
727
728inline 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
735class error_code {
736  int _val_;
737  const error_category* _cat_;
738public:
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
787inline error_code make_error_code(errc _e) {
788  return error_code(static_cast<int>(_e), generic_category());
789}
790
791inline 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
796inline bool operator==(const error_code& _x, const error_code& _y) {
797  return _x.category() == _y.category() && _x.value() == _y.value();
798}
799
800inline 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
805inline bool operator==(const error_condition& _x, const error_code& _y) {
806  return _y == _x;
807}
808
809inline bool operator==(const error_condition& _x, const error_condition& _y) {
810   return _x.category() == _y.category() && _x.value() == _y.value();
811}
812
813inline bool operator!=(const error_code& _x, const error_code& _y) {
814  return !(_x == _y);
815}
816
817inline bool operator!=(const error_code& _x, const error_condition& _y) {
818  return !(_x == _y);
819}
820
821inline bool operator!=(const error_condition& _x, const error_code& _y) {
822  return !(_x == _y);
823}
824
825inline 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() )
834struct windows_error {
835enum _ {
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
900template <> struct is_error_code_enum<windows_error> : true_type { };
901
902template <> struct is_error_code_enum<windows_error::_> : true_type { };
903
904inline 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
911