diff options
Diffstat (limited to 'libstdc++-v3/include/std/system_error')
-rw-r--r-- | libstdc++-v3/include/std/system_error | 244 |
1 files changed, 244 insertions, 0 deletions
diff --git a/libstdc++-v3/include/std/system_error b/libstdc++-v3/include/std/system_error new file mode 100644 index 00000000000..3f13622b485 --- /dev/null +++ b/libstdc++-v3/include/std/system_error @@ -0,0 +1,244 @@ +// <system_error> -*- C++ -*- + +// Copyright (C) 2007 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02110-1301, USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/** @file include/system_error + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_SYSTEM_ERROR +#define _GLIBCXX_SYSTEM_ERROR 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include <c++0x_warning.h> +#endif + +#include <bits/c++config.h> +#include <cerrno> +#include <iosfwd> +#include <stdexcept> + +_GLIBCXX_BEGIN_NAMESPACE(std) + + class system_error; + class error_code; + class error_category; + + extern const error_category& system_category; + + enum posix_errno + { + address_family_not_supported = EAFNOSUPPORT, + address_in_use = EADDRINUSE, + address_not_available = EADDRNOTAVAIL, + already_connected = EISCONN, + argument_list_too_long = E2BIG, + argument_out_of_domain = EDOM, + bad_address = EFAULT, + bad_file_descriptor = EBADF, + bad_message = EBADMSG, + broken_pipe = EPIPE, + connection_aborted = ECONNABORTED, + connection_already_in_progress = EALREADY, + connection_refused = ECONNREFUSED, + connection_reset = ECONNRESET, + cross_device_link = EXDEV, + destination_address_required = EDESTADDRREQ, + device_or_resource_busy = EBUSY, + directory_not_empty = ENOTEMPTY, + executable_format_error = ENOEXEC, + file_exists = EEXIST, + file_too_large = EFBIG, + filename_too_long = ENAMETOOLONG, + function_not_supported = ENOSYS, + host_unreachable = EHOSTUNREACH, + identifier_removed = EIDRM, + illegal_byte_sequence = EILSEQ, + inappropriate_io_control_operation = ENOTTY, + interrupted = EINTR, + invalid_argument = EINVAL, + invalid_seek = ESPIPE, + io_error = EIO, + is_a_directory = EISDIR, + message_size = EMSGSIZE, + network_down = ENETDOWN, + network_reset = ENETRESET, + network_unreachable = ENETUNREACH, + no_buffer_space = ENOBUFS, + no_child_process = ECHILD, + no_link = ENOLINK, + no_lock_available = ENOLCK, + no_message_available = ENODATA, + no_message = ENOMSG, + no_protocol_option = ENOPROTOOPT, + no_space_on_device = ENOSPC, + no_stream_resources = ENOSR, + no_such_device_or_address = ENXIO, + no_such_device = ENODEV, + no_such_file_or_directory = ENOENT, + no_such_process = ESRCH, + not_a_directory = ENOTDIR, + not_a_socket = ENOTSOCK, + not_a_stream = ENOSTR, + not_connected = ENOTCONN, + not_enough_memory = ENOMEM, + not_supported = ENOTSUP, + operation_canceled = ECANCELED, + operation_in_progress = EINPROGRESS, + operation_not_permitted = EPERM, + operation_not_supported = EOPNOTSUPP, + operation_would_block = EWOULDBLOCK, +#ifdef _GLIBCXX_HAVE_EOWNERDEAD + owner_dead = EOWNERDEAD, +#endif + permission_denied = EACCES, + protocol_error = EPROTO, + protocol_not_supported = EPROTONOSUPPORT, + read_only_file_system = EROFS, + resource_deadlock_would_occur = EDEADLK, + resource_unavailable_try_again = EAGAIN, + result_out_of_range = ERANGE, +#ifdef _GLIBCXX_HAVE_ENOTRECOVERABLE + state_not_recoverable = ENOTRECOVERABLE, +#endif + stream_timeout = ETIME, + text_file_busy = ETXTBSY, + timed_out = ETIMEDOUT, + too_many_files_open_in_system = ENFILE, + too_many_files_open = EMFILE, + too_many_links = EMLINK, + too_many_synbolic_link_levels = ELOOP, + value_too_large = EOVERFLOW, + wrong_protocol_type = EPROTOTYPE, + no_posix_equivalent = 1L << 16 + }; + + struct error_category + { + error_category() { } + + bool + operator==(const error_category& __other) const + { return this == &__other; } + + bool + operator!=(const error_category& __other) const + { return this != &__other; } + + virtual posix_errno + posix(int __v) const = 0; + + virtual const string& + name() const = 0; + + private: + error_category(const error_category&); + + error_category& + operator=(const error_category&); + }; + + struct error_code + { + error_code() throw() + : _M_value(0), _M_cat(&system_category) { } + + error_code(int __v, const error_category& __cat) throw() + : _M_value(__v), _M_cat(&__cat) { } + + error_code(posix_errno __v) + : _M_value(__v), _M_cat(&system_category) { } + + void + assign(int __v, const error_category& __cat) throw() + { + _M_value = __v; + _M_cat = &__cat; + } + + void + clear() throw() + { + _M_value = 0; + _M_cat = &system_category; + } + + int + value() const throw() { return _M_value; } + + const error_category& + category() const { return *_M_cat; } + + posix_errno + posix() const throw() { return this->category().posix(_M_value); } + + // Safe bool idiom. + // explicit operator bool() const throw() + // { return _M_value != 0; } + typedef void (*__bool_type)(); + + static void __not_bool_type() { } + + operator __bool_type() const throw() + { return _M_value != 0 ? &__not_bool_type : false; } + + bool operator==(const error_code& __other) const + { return value() == __other.value() && category() == __other.category(); } + + bool operator!=(const error_code& __other) const + { return !(this == &__other); } + + private: + int _M_value; + const error_category* _M_cat; + }; + + class system_error : public std::runtime_error + { + private: + error_code _M_code; + + public: + system_error(const string& __what, error_code __ec = error_code()) + : runtime_error(__what), _M_code(__ec) { } + + system_error(const string& __what, int __v, const error_category& __ecat) + : runtime_error(__what), _M_code(error_code(__v, __ecat)) { } + + virtual ~system_error() throw(); + + const error_code& + code() const throw() { return _M_code; } + }; + +_GLIBCXX_END_NAMESPACE + +#endif + |