nicolas/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*** This commit represents a complete reformatting of the LLDB source code

Browse Source 
*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751
This commit is contained in:
Kate Stone
2016-09-06 20:57:50 +00:00
parent d5aa733769
commit b9c1b51e45
2780 changed files with 556690 additions and 597060 deletions
Download Patch File Download Diff File Expand all files Collapse all files

440
lldb/source/Core/Error.cpp
View File

@@ -27,59 +27,42 @@
using namespace lldb;
using namespace lldb_private;
Error::Error ():
m_code (0),
m_type (eErrorTypeInvalid),
m_string ()
{
}
Error::Error() : m_code(0), m_type(eErrorTypeInvalid), m_string() {}
Error::Error(ValueType err, ErrorType type) :
m_code (err),
m_type (type),
m_string ()
{
}
Error::Error(ValueType err, ErrorType type)
: m_code(err), m_type(type), m_string() {}
Error::Error(const Error &rhs) = default;
Error::Error (const char* format, ...):
m_code (0),
m_type (eErrorTypeInvalid),
m_string ()
{
va_list args;
va_start (args, format);
SetErrorToGenericError ();
SetErrorStringWithVarArg (format, args);
va_end (args);
Error::Error(const char *format, ...)
: m_code(0), m_type(eErrorTypeInvalid), m_string() {
va_list args;
va_start(args, format);
SetErrorToGenericError();
SetErrorStringWithVarArg(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error&
Error::operator = (const Error& rhs)
{
if (this != &rhs)
{
m_code = rhs.m_code;
m_type = rhs.m_type;
m_string = rhs.m_string;
}
return *this;
const Error &Error::operator=(const Error &rhs) {
if (this != &rhs) {
m_code = rhs.m_code;
m_type = rhs.m_type;
m_string = rhs.m_string;
}
return *this;
}
//----------------------------------------------------------------------
// Assignment operator
//----------------------------------------------------------------------
const Error&
Error::operator = (uint32_t err)
{
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
return *this;
const Error &Error::operator=(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
return *this;
}
Error::~Error() = default;
@@ -89,81 +72,62 @@ Error::~Error() = default;
// fetched and cached on demand. The cached error string value will
// remain until the error value is changed or cleared.
//----------------------------------------------------------------------
const char *
Error::AsCString(const char *default_error_str) const
{
if (Success())
return nullptr;
const char *Error::AsCString(const char *default_error_str) const {
if (Success())
return nullptr;
if (m_string.empty())
{
const char *s = nullptr;
switch (m_type)
{
case eErrorTypeMachKernel:
#if defined (__APPLE__)
s = ::mach_error_string (m_code);
if (m_string.empty()) {
const char *s = nullptr;
switch (m_type) {
case eErrorTypeMachKernel:
#if defined(__APPLE__)
s = ::mach_error_string(m_code);
#endif
break;
break;
case eErrorTypePOSIX:
s = ::strerror (m_code);
break;
case eErrorTypePOSIX:
s = ::strerror(m_code);
break;
default:
break;
}
if (s != nullptr)
m_string.assign(s);
default:
break;
}
if (m_string.empty())
{
if (default_error_str)
m_string.assign(default_error_str);
else
return nullptr; // User wanted a nullptr string back...
}
return m_string.c_str();
if (s != nullptr)
m_string.assign(s);
}
if (m_string.empty()) {
if (default_error_str)
m_string.assign(default_error_str);
else
return nullptr; // User wanted a nullptr string back...
}
return m_string.c_str();
}
//----------------------------------------------------------------------
// Clear the error and any cached error string that it might contain.
//----------------------------------------------------------------------
void
Error::Clear ()
{
m_code = 0;
m_type = eErrorTypeInvalid;
m_string.clear();
void Error::Clear() {
m_code = 0;
m_type = eErrorTypeInvalid;
m_string.clear();
}
//----------------------------------------------------------------------
// Access the error value.
//----------------------------------------------------------------------
Error::ValueType
Error::GetError () const
{
return m_code;
}
Error::ValueType Error::GetError() const { return m_code; }
//----------------------------------------------------------------------
// Access the error type.
//----------------------------------------------------------------------
ErrorType
Error::GetType () const
{
return m_type;
}
ErrorType Error::GetType() const { return m_type; }
//----------------------------------------------------------------------
// Returns true if this object contains a value that describes an
// error or otherwise non-success result.
//----------------------------------------------------------------------
bool
Error::Fail () const
{
return m_code != 0;
}
bool Error::Fail() const { return m_code != 0; }
//----------------------------------------------------------------------
// Log the error given a string with format. If the this object
@@ -174,34 +138,29 @@ Error::Fail () const
// cached in this object. Logging always occurs even when the error
// code contains a non-error value.
//----------------------------------------------------------------------
void
Error::PutToLog (Log *log, const char *format, ...)
{
char *arg_msg = nullptr;
va_list args;
va_start (args, format);
::vasprintf (&arg_msg, format, args);
va_end (args);
void Error::PutToLog(Log *log, const char *format, ...) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr)
{
if (Fail())
{
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
if (arg_msg != nullptr) {
if (Fail()) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("error: %s err = %s (0x%8.8x)", arg_msg, err_str, m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
}
else
{
if (log != nullptr)
log->Printf("%s err = 0x%8.8x", arg_msg, m_code);
}
::free (arg_msg);
SetErrorStringWithFormat("error: %s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
} else {
if (log != nullptr)
log->Printf("%s err = 0x%8.8x", arg_msg, m_code);
}
::free(arg_msg);
}
}
//----------------------------------------------------------------------
@@ -213,106 +172,90 @@ Error::PutToLog (Log *log, const char *format, ...)
// cached in this object. Logging only occurs even when the error
// code contains a error value.
//----------------------------------------------------------------------
void
Error::LogIfError (Log *log, const char *format, ...)
{
if (Fail())
{
char *arg_msg = nullptr;
va_list args;
va_start (args, format);
::vasprintf (&arg_msg, format, args);
va_end (args);
void Error::LogIfError(Log *log, const char *format, ...) {
if (Fail()) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr)
{
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
if (arg_msg != nullptr) {
const char *err_str = AsCString();
if (err_str == nullptr)
err_str = "???";
SetErrorStringWithFormat("%s err = %s (0x%8.8x)", arg_msg, err_str, m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
SetErrorStringWithFormat("%s err = %s (0x%8.8x)", arg_msg, err_str,
m_code);
if (log != nullptr)
log->Error("%s", m_string.c_str());
::free (arg_msg);
}
::free(arg_msg);
}
}
}
//----------------------------------------------------------------------
// Set accesssor for the error value to "err" and the type to
// "eErrorTypeMachKernel"
//----------------------------------------------------------------------
void
Error::SetMachError (uint32_t err)
{
m_code = err;
m_type = eErrorTypeMachKernel;
void Error::SetMachError(uint32_t err) {
m_code = err;
m_type = eErrorTypeMachKernel;
m_string.clear();
}
void Error::SetExpressionError(lldb::ExpressionResults result,
const char *mssg) {
m_code = result;
m_type = eErrorTypeExpression;
m_string = mssg;
}
int Error::SetExpressionErrorWithFormat(lldb::ExpressionResults result,
const char *format, ...) {
int length = 0;
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
length = SetErrorStringWithVarArg(format, args);
va_end(args);
} else {
m_string.clear();
}
void
Error::SetExpressionError (lldb::ExpressionResults result, const char *mssg)
{
m_code = result;
m_type = eErrorTypeExpression;
m_string = mssg;
}
int
Error::SetExpressionErrorWithFormat (lldb::ExpressionResults result, const char *format, ...)
{
int length = 0;
if (format != nullptr && format[0])
{
va_list args;
va_start (args, format);
length = SetErrorStringWithVarArg (format, args);
va_end (args);
}
else
{
m_string.clear();
}
m_code = result;
m_type = eErrorTypeExpression;
return length;
}
m_code = result;
m_type = eErrorTypeExpression;
return length;
}
//----------------------------------------------------------------------
// Set accesssor for the error value and type.
//----------------------------------------------------------------------
void
Error::SetError (ValueType err, ErrorType type)
{
m_code = err;
m_type = type;
m_string.clear();
void Error::SetError(ValueType err, ErrorType type) {
m_code = err;
m_type = type;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be "errno" and update the type to
// be "POSIX".
//----------------------------------------------------------------------
void
Error::SetErrorToErrno()
{
m_code = errno;
m_type = eErrorTypePOSIX;
m_string.clear();
void Error::SetErrorToErrno() {
m_code = errno;
m_type = eErrorTypePOSIX;
m_string.clear();
}
//----------------------------------------------------------------------
// Update the error value to be LLDB_GENERIC_ERROR and update the type
// to be "Generic".
//----------------------------------------------------------------------
void
Error::SetErrorToGenericError ()
{
m_code = LLDB_GENERIC_ERROR;
m_type = eErrorTypeGeneric;
m_string.clear();
void Error::SetErrorToGenericError() {
m_code = LLDB_GENERIC_ERROR;
m_type = eErrorTypeGeneric;
m_string.clear();
}
//----------------------------------------------------------------------
@@ -321,19 +264,15 @@ Error::SetErrorToGenericError ()
// The error string value will remain until the error value is
// cleared or a new error value/type is assigned.
//----------------------------------------------------------------------
void
Error::SetErrorString (const char *err_str)
{
if (err_str != nullptr && err_str[0])
{
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
m_string = err_str;
}
else
m_string.clear();
void Error::SetErrorString(const char *err_str) {
if (err_str != nullptr && err_str[0]) {
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
m_string = err_str;
} else
m_string.clear();
}
//------------------------------------------------------------------
@@ -342,74 +281,57 @@ Error::SetErrorString (const char *err_str)
/// @param format
/// A printf style format string
//------------------------------------------------------------------
int
Error::SetErrorStringWithFormat (const char *format, ...)
{
if (format != nullptr && format[0])
{
va_list args;
va_start (args, format);
int length = SetErrorStringWithVarArg (format, args);
va_end (args);
return length;
}
else
{
m_string.clear();
}
return 0;
int Error::SetErrorStringWithFormat(const char *format, ...) {
if (format != nullptr && format[0]) {
va_list args;
va_start(args, format);
int length = SetErrorStringWithVarArg(format, args);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
int
Error::SetErrorStringWithVarArg (const char *format, va_list args)
{
if (format != nullptr && format[0])
{
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
int Error::SetErrorStringWithVarArg(const char *format, va_list args) {
if (format != nullptr && format[0]) {
// If we have an error string, we should always at least have
// an error set to a generic value.
if (Success())
SetErrorToGenericError();
// Try and fit our error into a 1024 byte buffer first...
llvm::SmallVector<char, 1024> buf;
buf.resize(1024);
// Copy in case our first call to vsnprintf doesn't fit into our
// allocated buffer above
va_list copy_args;
va_copy (copy_args, args);
unsigned length = ::vsnprintf (buf.data(), buf.size(), format, args);
if (length >= buf.size())
{
// The error formatted string didn't fit into our buffer, resize it
// to the exact needed size, and retry
buf.resize(length + 1);
length = ::vsnprintf (buf.data(), buf.size(), format, copy_args);
va_end (copy_args);
assert (length < buf.size());
}
m_string.assign(buf.data(), length);
va_end (args);
return length;
// Try and fit our error into a 1024 byte buffer first...
llvm::SmallVector<char, 1024> buf;
buf.resize(1024);
// Copy in case our first call to vsnprintf doesn't fit into our
// allocated buffer above
va_list copy_args;
va_copy(copy_args, args);
unsigned length = ::vsnprintf(buf.data(), buf.size(), format, args);
if (length >= buf.size()) {
// The error formatted string didn't fit into our buffer, resize it
// to the exact needed size, and retry
buf.resize(length + 1);
length = ::vsnprintf(buf.data(), buf.size(), format, copy_args);
va_end(copy_args);
assert(length < buf.size());
}
else
{
m_string.clear();
}
return 0;
m_string.assign(buf.data(), length);
va_end(args);
return length;
} else {
m_string.clear();
}
return 0;
}
//----------------------------------------------------------------------
// Returns true if the error code in this object is considered a
// successful return value.
//----------------------------------------------------------------------
bool
Error::Success() const
{
return m_code == 0;
}
bool Error::Success() const { return m_code == 0; }
bool
Error::WasInterrupted() const
{
return (m_type == eErrorTypePOSIX && m_code == EINTR);
bool Error::WasInterrupted() const {
return (m_type == eErrorTypePOSIX && m_code == EINTR);
}