From b9c1b51e45b845debb76d8658edabca70ca56079 Mon Sep 17 00:00:00 2001 From: Kate Stone Date: Tue, 6 Sep 2016 20:57:50 +0000 Subject: *** This commit represents a complete reformatting of the LLDB source code *** to conform to clang-format’s LLVM style. This kind of mass change has *** two obvious implications: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- lldb/source/Core/Error.cpp | 448 +++++++++++++++++++-------------------------- 1 file changed, 185 insertions(+), 263 deletions(-) (limited to 'lldb/source/Core/Error.cpp') diff --git a/lldb/source/Core/Error.cpp b/lldb/source/Core/Error.cpp index cc27a2d91b8..d91f16d6b7e 100644 --- a/lldb/source/Core/Error.cpp +++ b/lldb/source/Core/Error.cpp @@ -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; - - if (m_string.empty()) - { - const char *s = nullptr; - switch (m_type) - { - case eErrorTypeMachKernel: -#if defined (__APPLE__) - s = ::mach_error_string (m_code); +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); #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); - - 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); +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 = "???"; + + 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); - - 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()); - - ::free (arg_msg); - } +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 = "???"; + + 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); } + } } //---------------------------------------------------------------------- // 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; - m_string.clear(); +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; +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; +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; } //---------------------------------------------------------------------- // 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(); - - // Try and fit our error into a 1024 byte buffer first... - llvm::SmallVector 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; - } - else - { - m_string.clear(); +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 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()); } - 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); } -- cgit v1.2.3