mirror of https://github.com/GOSTSec/ccminer
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
234 lines
9.3 KiB
234 lines
9.3 KiB
/* |
|
* Copyright 2008-2012 NVIDIA Corporation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
*/ |
|
|
|
|
|
#pragma once |
|
|
|
#include <thrust/system/error_code.h> |
|
#include <thrust/system/detail/errno.h> |
|
#include <thrust/functional.h> |
|
#include <cstring> |
|
|
|
namespace thrust |
|
{ |
|
|
|
namespace system |
|
{ |
|
|
|
error_category |
|
::~error_category(void) |
|
{ |
|
; |
|
} // end error_category::~error_category() |
|
|
|
|
|
error_condition error_category |
|
::default_error_condition(int ev) const |
|
{ |
|
return error_condition(ev, *this); |
|
} // end error_category::default_error_condition() |
|
|
|
|
|
bool error_category |
|
::equivalent(int code, const error_condition &condition) const |
|
{ |
|
return default_error_condition(code) == condition; |
|
} // end error_condition::equivalent() |
|
|
|
|
|
bool error_category |
|
::equivalent(const error_code &code, int condition) const |
|
{ |
|
bool result = (this->operator==(code.category())) && (code.value() == condition); |
|
return result; |
|
} // end error_code::equivalent() |
|
|
|
|
|
bool error_category |
|
::operator==(const error_category &rhs) const |
|
{ |
|
return this == &rhs; |
|
} // end error_category::operator==() |
|
|
|
|
|
bool error_category |
|
::operator!=(const error_category &rhs) const |
|
{ |
|
return !this->operator==(rhs); |
|
} // end error_category::operator!=() |
|
|
|
|
|
bool error_category |
|
::operator<(const error_category &rhs) const |
|
{ |
|
return thrust::less<const error_category*>()(this,&rhs); |
|
} // end error_category::operator<() |
|
|
|
|
|
namespace detail |
|
{ |
|
|
|
|
|
class generic_error_category |
|
: public error_category |
|
{ |
|
public: |
|
inline generic_error_category(void) {} |
|
|
|
inline virtual const char *name(void) const |
|
{ |
|
return "generic"; |
|
} |
|
|
|
inline virtual std::string message(int ev) const |
|
{ |
|
static const std::string unknown_err("Unknown error"); |
|
|
|
// XXX strerror is not thread-safe: |
|
// prefer strerror_r (which is not provided on windows) |
|
const char *c_str = std::strerror(ev); |
|
return c_str ? std::string(c_str) : unknown_err; |
|
} |
|
}; // end generic_category_result |
|
|
|
|
|
class system_error_category |
|
: public error_category |
|
{ |
|
public: |
|
inline system_error_category(void) {} |
|
|
|
inline virtual const char *name(void) const |
|
{ |
|
return "system"; |
|
} |
|
|
|
inline virtual std::string message(int ev) const |
|
{ |
|
return generic_category().message(ev); |
|
} |
|
|
|
inline virtual error_condition default_error_condition(int ev) const |
|
{ |
|
using namespace errc; |
|
|
|
switch(ev) |
|
{ |
|
case eafnosupport: return make_error_condition(address_family_not_supported); |
|
case eaddrinuse: return make_error_condition(address_in_use); |
|
case eaddrnotavail: return make_error_condition(address_not_available); |
|
case eisconn: return make_error_condition(already_connected); |
|
case e2big: return make_error_condition(argument_list_too_long); |
|
case edom: return make_error_condition(argument_out_of_domain); |
|
case efault: return make_error_condition(bad_address); |
|
case ebadf: return make_error_condition(bad_file_descriptor); |
|
case ebadmsg: return make_error_condition(bad_message); |
|
case epipe: return make_error_condition(broken_pipe); |
|
case econnaborted: return make_error_condition(connection_aborted); |
|
case ealready: return make_error_condition(connection_already_in_progress); |
|
case econnrefused: return make_error_condition(connection_refused); |
|
case econnreset: return make_error_condition(connection_reset); |
|
case exdev: return make_error_condition(cross_device_link); |
|
case edestaddrreq: return make_error_condition(destination_address_required); |
|
case ebusy: return make_error_condition(device_or_resource_busy); |
|
case enotempty: return make_error_condition(directory_not_empty); |
|
case enoexec: return make_error_condition(executable_format_error); |
|
case eexist: return make_error_condition(file_exists); |
|
case efbig: return make_error_condition(file_too_large); |
|
case enametoolong: return make_error_condition(filename_too_long); |
|
case enosys: return make_error_condition(function_not_supported); |
|
case ehostunreach: return make_error_condition(host_unreachable); |
|
case eidrm: return make_error_condition(identifier_removed); |
|
case eilseq: return make_error_condition(illegal_byte_sequence); |
|
case enotty: return make_error_condition(inappropriate_io_control_operation); |
|
case eintr: return make_error_condition(interrupted); |
|
case einval: return make_error_condition(invalid_argument); |
|
case espipe: return make_error_condition(invalid_seek); |
|
case eio: return make_error_condition(io_error); |
|
case eisdir: return make_error_condition(is_a_directory); |
|
case emsgsize: return make_error_condition(message_size); |
|
case enetdown: return make_error_condition(network_down); |
|
case enetreset: return make_error_condition(network_reset); |
|
case enetunreach: return make_error_condition(network_unreachable); |
|
case enobufs: return make_error_condition(no_buffer_space); |
|
case echild: return make_error_condition(no_child_process); |
|
case enolink: return make_error_condition(no_link); |
|
case enolck: return make_error_condition(no_lock_available); |
|
case enodata: return make_error_condition(no_message_available); |
|
case enomsg: return make_error_condition(no_message); |
|
case enoprotoopt: return make_error_condition(no_protocol_option); |
|
case enospc: return make_error_condition(no_space_on_device); |
|
case enosr: return make_error_condition(no_stream_resources); |
|
case enxio: return make_error_condition(no_such_device_or_address); |
|
case enodev: return make_error_condition(no_such_device); |
|
case enoent: return make_error_condition(no_such_file_or_directory); |
|
case esrch: return make_error_condition(no_such_process); |
|
case enotdir: return make_error_condition(not_a_directory); |
|
case enotsock: return make_error_condition(not_a_socket); |
|
case enostr: return make_error_condition(not_a_stream); |
|
case enotconn: return make_error_condition(not_connected); |
|
case enomem: return make_error_condition(not_enough_memory); |
|
case enotsup: return make_error_condition(not_supported); |
|
case ecanceled: return make_error_condition(operation_canceled); |
|
case einprogress: return make_error_condition(operation_in_progress); |
|
case eperm: return make_error_condition(operation_not_permitted); |
|
case eopnotsupp: return make_error_condition(operation_not_supported); |
|
case ewouldblock: return make_error_condition(operation_would_block); |
|
case eownerdead: return make_error_condition(owner_dead); |
|
case eacces: return make_error_condition(permission_denied); |
|
case eproto: return make_error_condition(protocol_error); |
|
case eprotonosupport: return make_error_condition(protocol_not_supported); |
|
case erofs: return make_error_condition(read_only_file_system); |
|
case edeadlk: return make_error_condition(resource_deadlock_would_occur); |
|
case eagain: return make_error_condition(resource_unavailable_try_again); |
|
case erange: return make_error_condition(result_out_of_range); |
|
case enotrecoverable: return make_error_condition(state_not_recoverable); |
|
case etime: return make_error_condition(stream_timeout); |
|
case etxtbsy: return make_error_condition(text_file_busy); |
|
case etimedout: return make_error_condition(timed_out); |
|
case enfile: return make_error_condition(too_many_files_open_in_system); |
|
case emfile: return make_error_condition(too_many_files_open); |
|
case emlink: return make_error_condition(too_many_links); |
|
case eloop: return make_error_condition(too_many_symbolic_link_levels); |
|
case eoverflow: return make_error_condition(value_too_large); |
|
case eprototype: return make_error_condition(wrong_protocol_type); |
|
default: return error_condition(ev,system_category()); |
|
} |
|
} |
|
}; // end system_category_result |
|
|
|
|
|
} // end detail |
|
|
|
|
|
const error_category &generic_category(void) |
|
{ |
|
static const detail::generic_error_category result; |
|
return result; |
|
} |
|
|
|
|
|
const error_category &system_category(void) |
|
{ |
|
static const detail::system_error_category result; |
|
return result; |
|
} |
|
|
|
|
|
} // end system |
|
|
|
} // end thrust |
|
|
|
|