LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
system_error.h
Go to the documentation of this file.
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"
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,
491  address_in_use = EADDRINUSE,
492  address_not_available = EADDRNOTAVAIL,
493  already_connected = EISCONN,
496  bad_address = EFAULT,
498 #ifdef EBADMSG
499  bad_message = EBADMSG,
500 #else
501  bad_message = EINVAL,
502 #endif
503  broken_pipe = EPIPE,
504  connection_aborted = ECONNABORTED,
506  connection_refused = ECONNREFUSED,
507  connection_reset = ECONNRESET,
511  directory_not_empty = ENOTEMPTY,
513  file_exists = EEXIST,
514  file_too_large = EFBIG,
515  filename_too_long = ENAMETOOLONG,
517  host_unreachable = EHOSTUNREACH,
521  interrupted = EINTR,
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,
532 #ifdef ENOLINK
533  no_link = ENOLINK,
534 #else
535  no_link = EINVAL,
536 #endif
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,
546 #ifdef ENOSR
547  no_stream_resources = ENOSR,
548 #else
549  no_stream_resources = ENOMEM,
550 #endif
552  no_such_device = ENODEV,
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,
564  not_supported = ENOTSUP,
565 #ifdef ECANCELED
566  operation_canceled = ECANCELED,
567 #else
568  operation_canceled = EINVAL,
569 #endif
570  operation_in_progress = EINPROGRESS,
573  operation_would_block = EWOULDBLOCK,
574 #ifdef EOWNERDEAD
575  owner_dead = EOWNERDEAD,
576 #else
577  owner_dead = EINVAL,
578 #endif
580 #ifdef EPROTO
581  protocol_error = EPROTO,
582 #else
583  protocol_error = EINVAL,
584 #endif
585  protocol_not_supported = EPROTONOSUPPORT,
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,
604  too_many_links = EMLINK,
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 
628 {
629 public:
630  virtual ~error_category();
631 
632 private:
633  error_category();
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 
654 {
655 public:
656  virtual std::string message(int ev) const LLVM_OVERRIDE;
657 };
658 
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.
666 
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<
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  <
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 
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<
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  <
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 
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 
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() )
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 
900  return error_code(static_cast<int>(e), system_category());
901 }
902 
903 } // end namespace llvm
904 
905 #endif
const error_category & system_category()
bool operator==(const error_category &_rhs) const
Definition: system_error.h:644
void operator<(const Optional< T > &X, const Optional< U > &Y)
Poison comparison between two Optional objects. Clients needs to explicitly compare the underlying va...
bool operator!=(const error_category &_rhs) const
Definition: system_error.h:646
const error_category & category() const
Definition: system_error.h:767
void assign(int _val, const error_category &_cat)
Definition: system_error.h:746
static void unspecified_bool_true()
Definition: system_error.h:775
const error_category & posix_category()
void(* unspecified_bool_type)()
Definition: system_error.h:707
virtual const char * name() const =0
error_condition default_error_condition() const
Definition: system_error.h:769
const error_category & category() const
Definition: system_error.h:704
void assign(int _val, const error_category &_cat)
Definition: system_error.h:683
virtual error_condition default_error_condition(int _ev) const
virtual bool equivalent(int _code, const error_condition &_condition) const
std::string message() const
static void unspecified_bool_true()
Definition: system_error.h:708
bool operator<(const error_category &_rhs) const
Definition: system_error.h:648
enable_if_c< is_error_code_enum< E >::value, error_code & >::type operator=(E _e)
Definition: system_error.h:757
virtual std::string message(int _ev) const =0
error_condition(E _e, typename enable_if_c< is_error_condition_enum< E >::value >::type *=0)
Definition: system_error.h:678
#define LLVM_DELETED_FUNCTION
Definition: Compiler.h:137
std::string message() const
int value() const
Definition: system_error.h:765
bool operator!=(uint64_t V1, const APInt &V2)
Definition: APInt.h:1686
static error_code success()
Definition: system_error.h:732
const error_category & generic_category()
error_condition make_error_condition(errc _e)
Definition: system_error.h:715
void(* unspecified_bool_type)()
Definition: system_error.h:774
error_code(int _val, const error_category &_cat)
Definition: system_error.h:736
virtual std::string message(int ev) const LLVM_OVERRIDE
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1684
error_code(E _e, typename enable_if_c< is_error_code_enum< E >::value >::type *=0)
Definition: system_error.h:740
error_code make_error_code(errc _e)
Definition: system_error.h:782
enable_if_c< is_error_condition_enum< E >::value, error_condition & >::type operator=(E _e)
Definition: system_error.h:694
#define LLVM_OVERRIDE
Definition: Compiler.h:155
error_condition(int _val, const error_category &_cat)
Definition: system_error.h:674