diff options
Diffstat (limited to 'lldb/source/Core/Stream.cpp')
| -rw-r--r-- | lldb/source/Core/Stream.cpp | 1010 |
1 files changed, 421 insertions, 589 deletions
diff --git a/lldb/source/Core/Stream.cpp b/lldb/source/Core/Stream.cpp index 172be772792..f8d78c33b42 100644 --- a/lldb/source/Core/Stream.cpp +++ b/lldb/source/Core/Stream.cpp @@ -12,776 +12,608 @@ #include "lldb/Host/PosixApi.h" #include <stddef.h> #include <stdio.h> -#include <string.h> #include <stdlib.h> +#include <string.h> #include <inttypes.h> using namespace lldb; using namespace lldb_private; -Stream::Stream (uint32_t flags, uint32_t addr_size, ByteOrder byte_order) : - m_flags (flags), - m_addr_size (addr_size), - m_byte_order (byte_order), - m_indent_level(0) -{ -} +Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order) + : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order), + m_indent_level(0) {} -Stream::Stream () : - m_flags (0), - m_addr_size (4), - m_byte_order (endian::InlHostByteOrder()), - m_indent_level(0) -{ -} +Stream::Stream() + : m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()), + m_indent_level(0) {} //------------------------------------------------------------------ // Destructor //------------------------------------------------------------------ -Stream::~Stream () -{ -} +Stream::~Stream() {} -ByteOrder -Stream::SetByteOrder (ByteOrder byte_order) -{ - ByteOrder old_byte_order = m_byte_order; - m_byte_order = byte_order; - return old_byte_order; +ByteOrder Stream::SetByteOrder(ByteOrder byte_order) { + ByteOrder old_byte_order = m_byte_order; + m_byte_order = byte_order; + return old_byte_order; } //------------------------------------------------------------------ // Put an offset "uval" out to the stream using the printf format // in "format". //------------------------------------------------------------------ -void -Stream::Offset (uint32_t uval, const char *format) -{ - Printf (format, uval); -} +void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); } //------------------------------------------------------------------ // Put an SLEB128 "uval" out to the stream using the printf format // in "format". //------------------------------------------------------------------ -size_t -Stream::PutSLEB128 (int64_t sval) -{ - size_t bytes_written = 0; - if (m_flags.Test(eBinary)) - { - bool more = true; - while (more) - { - uint8_t byte = sval & 0x7fu; - sval >>= 7; - /* sign bit of byte is 2nd high order bit (0x40) */ - if ((sval == 0 && !(byte & 0x40)) || - (sval == -1 && (byte & 0x40)) ) - more = false; - else - // more bytes to come - byte |= 0x80u; - bytes_written += Write(&byte, 1); - } - } - else - { - bytes_written = Printf ("0x%" PRIi64, sval); +size_t Stream::PutSLEB128(int64_t sval) { + size_t bytes_written = 0; + if (m_flags.Test(eBinary)) { + bool more = true; + while (more) { + uint8_t byte = sval & 0x7fu; + sval >>= 7; + /* sign bit of byte is 2nd high order bit (0x40) */ + if ((sval == 0 && !(byte & 0x40)) || (sval == -1 && (byte & 0x40))) + more = false; + else + // more bytes to come + byte |= 0x80u; + bytes_written += Write(&byte, 1); } + } else { + bytes_written = Printf("0x%" PRIi64, sval); + } - return bytes_written; - + return bytes_written; } //------------------------------------------------------------------ // Put an ULEB128 "uval" out to the stream using the printf format // in "format". //------------------------------------------------------------------ -size_t -Stream::PutULEB128 (uint64_t uval) -{ - size_t bytes_written = 0; - if (m_flags.Test(eBinary)) - { - do - { - - uint8_t byte = uval & 0x7fu; - uval >>= 7; - if (uval != 0) - { - // more bytes to come - byte |= 0x80u; - } - bytes_written += Write(&byte, 1); - } while (uval != 0); - } - else - { - bytes_written = Printf ("0x%" PRIx64, uval); - } - return bytes_written; +size_t Stream::PutULEB128(uint64_t uval) { + size_t bytes_written = 0; + if (m_flags.Test(eBinary)) { + do { + + uint8_t byte = uval & 0x7fu; + uval >>= 7; + if (uval != 0) { + // more bytes to come + byte |= 0x80u; + } + bytes_written += Write(&byte, 1); + } while (uval != 0); + } else { + bytes_written = Printf("0x%" PRIx64, uval); + } + return bytes_written; } //------------------------------------------------------------------ // Print a raw NULL terminated C string to the stream. //------------------------------------------------------------------ -size_t -Stream::PutCString (const char *cstr) -{ - size_t cstr_len = strlen(cstr); - // when in binary mode, emit the NULL terminator - if (m_flags.Test(eBinary)) - ++cstr_len; - return Write (cstr, cstr_len); +size_t Stream::PutCString(const char *cstr) { + size_t cstr_len = strlen(cstr); + // when in binary mode, emit the NULL terminator + if (m_flags.Test(eBinary)) + ++cstr_len; + return Write(cstr, cstr_len); } //------------------------------------------------------------------ // Print a double quoted NULL terminated C string to the stream // using the printf format in "format". //------------------------------------------------------------------ -void -Stream::QuotedCString (const char *cstr, const char *format) -{ - Printf (format, cstr); +void Stream::QuotedCString(const char *cstr, const char *format) { + Printf(format, cstr); } //------------------------------------------------------------------ // Put an address "addr" out to the stream with optional prefix // and suffix strings. //------------------------------------------------------------------ -void -Stream::Address (uint64_t addr, uint32_t addr_size, const char *prefix, const char *suffix) -{ - if (prefix == NULL) - prefix = ""; - if (suffix == NULL) - suffix = ""; -// int addr_width = m_addr_size << 1; -// Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix); - Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix); +void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix, + const char *suffix) { + if (prefix == NULL) + prefix = ""; + if (suffix == NULL) + suffix = ""; + // int addr_width = m_addr_size << 1; + // Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix); + Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix); } //------------------------------------------------------------------ // Put an address range out to the stream with optional prefix // and suffix strings. //------------------------------------------------------------------ -void -Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix, const char *suffix) -{ - if (prefix && prefix[0]) - PutCString (prefix); - Address (lo_addr, addr_size, "["); - Address (hi_addr, addr_size, "-", ")"); - if (suffix && suffix[0]) - PutCString (suffix); -} - - -size_t -Stream::PutChar (char ch) -{ - return Write (&ch, 1); +void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr, + uint32_t addr_size, const char *prefix, + const char *suffix) { + if (prefix && prefix[0]) + PutCString(prefix); + Address(lo_addr, addr_size, "["); + Address(hi_addr, addr_size, "-", ")"); + if (suffix && suffix[0]) + PutCString(suffix); } +size_t Stream::PutChar(char ch) { return Write(&ch, 1); } //------------------------------------------------------------------ // Print some formatted output to the stream. //------------------------------------------------------------------ -size_t -Stream::Printf (const char *format, ...) -{ - va_list args; - va_start (args, format); - size_t result = PrintfVarArg(format, args); - va_end (args); - return result; +size_t Stream::Printf(const char *format, ...) { + va_list args; + va_start(args, format); + size_t result = PrintfVarArg(format, args); + va_end(args); + return result; } //------------------------------------------------------------------ // Print some formatted output to the stream. //------------------------------------------------------------------ -size_t -Stream::PrintfVarArg (const char *format, va_list args) -{ - char str[1024]; - va_list args_copy; - - va_copy (args_copy, args); - - size_t bytes_written = 0; - // Try and format our string into a fixed buffer first and see if it fits - size_t length = ::vsnprintf (str, sizeof(str), format, args); - if (length < sizeof(str)) - { - // Include the NULL termination byte for binary output - if (m_flags.Test(eBinary)) - length += 1; - // The formatted string fit into our stack based buffer, so we can just - // append that to our packet - bytes_written = Write (str, length); - } - else - { - // Our stack buffer wasn't big enough to contain the entire formatted - // string, so lets let vasprintf create the string for us! - char *str_ptr = NULL; - length = ::vasprintf (&str_ptr, format, args_copy); - if (str_ptr) - { - // Include the NULL termination byte for binary output - if (m_flags.Test(eBinary)) - length += 1; - bytes_written = Write (str_ptr, length); - ::free (str_ptr); - } +size_t Stream::PrintfVarArg(const char *format, va_list args) { + char str[1024]; + va_list args_copy; + + va_copy(args_copy, args); + + size_t bytes_written = 0; + // Try and format our string into a fixed buffer first and see if it fits + size_t length = ::vsnprintf(str, sizeof(str), format, args); + if (length < sizeof(str)) { + // Include the NULL termination byte for binary output + if (m_flags.Test(eBinary)) + length += 1; + // The formatted string fit into our stack based buffer, so we can just + // append that to our packet + bytes_written = Write(str, length); + } else { + // Our stack buffer wasn't big enough to contain the entire formatted + // string, so lets let vasprintf create the string for us! + char *str_ptr = NULL; + length = ::vasprintf(&str_ptr, format, args_copy); + if (str_ptr) { + // Include the NULL termination byte for binary output + if (m_flags.Test(eBinary)) + length += 1; + bytes_written = Write(str_ptr, length); + ::free(str_ptr); } - va_end (args_copy); - return bytes_written; + } + va_end(args_copy); + return bytes_written; } //------------------------------------------------------------------ // Print and End of Line character to the stream //------------------------------------------------------------------ -size_t -Stream::EOL() -{ - return PutChar ('\n'); -} +size_t Stream::EOL() { return PutChar('\n'); } //------------------------------------------------------------------ // Indent the current line using the current indentation level and // print an optional string following the indentation spaces. //------------------------------------------------------------------ -size_t -Stream::Indent(const char *s) -{ - return Printf ("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : ""); +size_t Stream::Indent(const char *s) { + return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : ""); } //------------------------------------------------------------------ // Stream a character "ch" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (char ch) -{ - PutChar (ch); - return *this; +Stream &Stream::operator<<(char ch) { + PutChar(ch); + return *this; } //------------------------------------------------------------------ // Stream the NULL terminated C string out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (const char *s) -{ - Printf ("%s", s); - return *this; +Stream &Stream::operator<<(const char *s) { + Printf("%s", s); + return *this; } //------------------------------------------------------------------ // Stream the pointer value out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (const void *p) -{ - Printf ("0x%.*tx", (int)sizeof(const void*) * 2, (ptrdiff_t)p); - return *this; +Stream &Stream::operator<<(const void *p) { + Printf("0x%.*tx", (int)sizeof(const void *) * 2, (ptrdiff_t)p); + return *this; } //------------------------------------------------------------------ // Stream a uint8_t "uval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (uint8_t uval) -{ - PutHex8(uval); - return *this; +Stream &Stream::operator<<(uint8_t uval) { + PutHex8(uval); + return *this; } //------------------------------------------------------------------ // Stream a uint16_t "uval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (uint16_t uval) -{ - PutHex16(uval, m_byte_order); - return *this; +Stream &Stream::operator<<(uint16_t uval) { + PutHex16(uval, m_byte_order); + return *this; } //------------------------------------------------------------------ // Stream a uint32_t "uval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (uint32_t uval) -{ - PutHex32(uval, m_byte_order); - return *this; +Stream &Stream::operator<<(uint32_t uval) { + PutHex32(uval, m_byte_order); + return *this; } //------------------------------------------------------------------ // Stream a uint64_t "uval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (uint64_t uval) -{ - PutHex64(uval, m_byte_order); - return *this; +Stream &Stream::operator<<(uint64_t uval) { + PutHex64(uval, m_byte_order); + return *this; } //------------------------------------------------------------------ // Stream a int8_t "sval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (int8_t sval) -{ - Printf ("%i", (int)sval); - return *this; +Stream &Stream::operator<<(int8_t sval) { + Printf("%i", (int)sval); + return *this; } //------------------------------------------------------------------ // Stream a int16_t "sval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (int16_t sval) -{ - Printf ("%i", (int)sval); - return *this; +Stream &Stream::operator<<(int16_t sval) { + Printf("%i", (int)sval); + return *this; } //------------------------------------------------------------------ // Stream a int32_t "sval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (int32_t sval) -{ - Printf ("%i", (int)sval); - return *this; +Stream &Stream::operator<<(int32_t sval) { + Printf("%i", (int)sval); + return *this; } //------------------------------------------------------------------ // Stream a int64_t "sval" out to this stream. //------------------------------------------------------------------ -Stream& -Stream::operator<< (int64_t sval) -{ - Printf ("%" PRIi64, sval); - return *this; +Stream &Stream::operator<<(int64_t sval) { + Printf("%" PRIi64, sval); + return *this; } //------------------------------------------------------------------ // Get the current indentation level //------------------------------------------------------------------ -int -Stream::GetIndentLevel() const -{ - return m_indent_level; -} +int Stream::GetIndentLevel() const { return m_indent_level; } //------------------------------------------------------------------ // Set the current indentation level //------------------------------------------------------------------ -void -Stream::SetIndentLevel(int indent_level) -{ - m_indent_level = indent_level; -} +void Stream::SetIndentLevel(int indent_level) { m_indent_level = indent_level; } //------------------------------------------------------------------ // Increment the current indentation level //------------------------------------------------------------------ -void -Stream::IndentMore(int amount) -{ - m_indent_level += amount; -} +void Stream::IndentMore(int amount) { m_indent_level += amount; } //------------------------------------------------------------------ // Decrement the current indentation level //------------------------------------------------------------------ -void -Stream::IndentLess (int amount) -{ - if (m_indent_level >= amount) - m_indent_level -= amount; - else - m_indent_level = 0; +void Stream::IndentLess(int amount) { + if (m_indent_level >= amount) + m_indent_level -= amount; + else + m_indent_level = 0; } //------------------------------------------------------------------ // Get the address size in bytes //------------------------------------------------------------------ -uint32_t -Stream::GetAddressByteSize() const -{ - return m_addr_size; -} +uint32_t Stream::GetAddressByteSize() const { return m_addr_size; } //------------------------------------------------------------------ // Set the address size in bytes //------------------------------------------------------------------ -void -Stream::SetAddressByteSize(uint32_t addr_size) -{ - m_addr_size = addr_size; -} +void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; } //------------------------------------------------------------------ // Returns true if the verbose flag bit is set in this stream. //------------------------------------------------------------------ -bool -Stream::GetVerbose() const -{ - return m_flags.Test(eVerbose); -} +bool Stream::GetVerbose() const { return m_flags.Test(eVerbose); } //------------------------------------------------------------------ // Returns true if the debug flag bit is set in this stream. //------------------------------------------------------------------ -bool -Stream::GetDebug() const -{ - return m_flags.Test(eDebug); -} +bool Stream::GetDebug() const { return m_flags.Test(eDebug); } //------------------------------------------------------------------ // The flags get accessor //------------------------------------------------------------------ -Flags& -Stream::GetFlags() -{ - return m_flags; -} +Flags &Stream::GetFlags() { return m_flags; } //------------------------------------------------------------------ // The flags const get accessor //------------------------------------------------------------------ -const Flags& -Stream::GetFlags() const -{ - return m_flags; -} +const Flags &Stream::GetFlags() const { return m_flags; } //------------------------------------------------------------------ // The byte order get accessor //------------------------------------------------------------------ -lldb::ByteOrder -Stream::GetByteOrder() const -{ - return m_byte_order; -} - -size_t -Stream::PrintfAsRawHex8 (const char *format, ...) -{ - va_list args; - va_list args_copy; - va_start (args, format); - va_copy (args_copy,args); // Copy this so we - - char str[1024]; - size_t bytes_written = 0; - // Try and format our string into a fixed buffer first and see if it fits - size_t length = ::vsnprintf (str, sizeof(str), format, args); - if (length < sizeof(str)) - { - // The formatted string fit into our stack based buffer, so we can just - // append that to our packet - for (size_t i=0; i<length; ++i) - bytes_written += _PutHex8 (str[i], false); +lldb::ByteOrder Stream::GetByteOrder() const { return m_byte_order; } + +size_t Stream::PrintfAsRawHex8(const char *format, ...) { + va_list args; + va_list args_copy; + va_start(args, format); + va_copy(args_copy, args); // Copy this so we + + char str[1024]; + size_t bytes_written = 0; + // Try and format our string into a fixed buffer first and see if it fits + size_t length = ::vsnprintf(str, sizeof(str), format, args); + if (length < sizeof(str)) { + // The formatted string fit into our stack based buffer, so we can just + // append that to our packet + for (size_t i = 0; i < length; ++i) + bytes_written += _PutHex8(str[i], false); + } else { + // Our stack buffer wasn't big enough to contain the entire formatted + // string, so lets let vasprintf create the string for us! + char *str_ptr = NULL; + length = ::vasprintf(&str_ptr, format, args_copy); + if (str_ptr) { + for (size_t i = 0; i < length; ++i) + bytes_written += _PutHex8(str_ptr[i], false); + ::free(str_ptr); } - else - { - // Our stack buffer wasn't big enough to contain the entire formatted - // string, so lets let vasprintf create the string for us! - char *str_ptr = NULL; - length = ::vasprintf (&str_ptr, format, args_copy); - if (str_ptr) - { - for (size_t i=0; i<length; ++i) - bytes_written += _PutHex8 (str_ptr[i], false); - ::free (str_ptr); - } - } - va_end (args); - va_end (args_copy); - - return bytes_written; -} - -size_t -Stream::PutNHex8 (size_t n, uint8_t uvalue) -{ - size_t bytes_written = 0; - for (size_t i=0; i<n; ++i) - bytes_written += _PutHex8 (uvalue, m_flags.Test(eAddPrefix)); - return bytes_written; -} - -size_t -Stream::_PutHex8 (uint8_t uvalue, bool add_prefix) -{ - size_t bytes_written = 0; - if (m_flags.Test(eBinary)) - { - bytes_written = Write (&uvalue, 1); - } - else - { - if (add_prefix) - PutCString("0x"); - - static char g_hex_to_ascii_hex_char[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; - char nibble_chars[2]; - nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf]; - nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf]; - bytes_written = Write (nibble_chars, sizeof(nibble_chars)); - } - return bytes_written; -} - -size_t -Stream::PutHex8 (uint8_t uvalue) -{ - return _PutHex8 (uvalue, m_flags.Test(eAddPrefix)); -} + } + va_end(args); + va_end(args_copy); + + return bytes_written; +} + +size_t Stream::PutNHex8(size_t n, uint8_t uvalue) { + size_t bytes_written = 0; + for (size_t i = 0; i < n; ++i) + bytes_written += _PutHex8(uvalue, m_flags.Test(eAddPrefix)); + return bytes_written; +} + +size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) { + size_t bytes_written = 0; + if (m_flags.Test(eBinary)) { + bytes_written = Write(&uvalue, 1); + } else { + if (add_prefix) + PutCString("0x"); + + static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5', + '6', '7', '8', '9', 'a', 'b', + 'c', 'd', 'e', 'f'}; + char nibble_chars[2]; + nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf]; + nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf]; + bytes_written = Write(nibble_chars, sizeof(nibble_chars)); + } + return bytes_written; +} + +size_t Stream::PutHex8(uint8_t uvalue) { + return _PutHex8(uvalue, m_flags.Test(eAddPrefix)); +} -size_t -Stream::PutHex16 (uint16_t uvalue, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - bool add_prefix = m_flags.Test(eAddPrefix); - size_t bytes_written = 0; - if (byte_order == eByteOrderLittle) - { - for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - else - { - for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - return bytes_written; -} - -size_t -Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - bool add_prefix = m_flags.Test(eAddPrefix); - size_t bytes_written = 0; - if (byte_order == eByteOrderLittle) - { - for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - else - { - for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - return bytes_written; -} - -size_t -Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - bool add_prefix = m_flags.Test(eAddPrefix); - size_t bytes_written = 0; - if (byte_order == eByteOrderLittle) - { - for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - else - { - for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false) - bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix); - } - return bytes_written; -} - -size_t -Stream::PutMaxHex64 -( - uint64_t uvalue, - size_t byte_size, - lldb::ByteOrder byte_order -) -{ - switch (byte_size) - { - case 1: return PutHex8 ((uint8_t)uvalue); - case 2: return PutHex16 ((uint16_t)uvalue); - case 4: return PutHex32 ((uint32_t)uvalue); - case 8: return PutHex64 (uvalue); - } - return 0; -} - -size_t -Stream::PutPointer (void *ptr) -{ - return PutRawBytes (&ptr, sizeof(ptr), endian::InlHostByteOrder(), endian::InlHostByteOrder()); -} - -size_t -Stream::PutFloat(float f, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - return PutRawBytes (&f, sizeof(f), endian::InlHostByteOrder(), byte_order); -} - -size_t -Stream::PutDouble(double d, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - return PutRawBytes (&d, sizeof(d), endian::InlHostByteOrder(), byte_order); -} - -size_t -Stream::PutLongDouble(long double ld, ByteOrder byte_order) -{ - if (byte_order == eByteOrderInvalid) - byte_order = m_byte_order; - - return PutRawBytes (&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order); -} - -size_t -Stream::PutRawBytes (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order) -{ - if (src_byte_order == eByteOrderInvalid) - src_byte_order = m_byte_order; - - if (dst_byte_order == eByteOrderInvalid) - dst_byte_order = m_byte_order; - - size_t bytes_written = 0; - const uint8_t *src = (const uint8_t *)s; - bool binary_was_set = m_flags.Test (eBinary); - if (!binary_was_set) - m_flags.Set (eBinary); - if (src_byte_order == dst_byte_order) - { - for (size_t i = 0; i < src_len; ++i) - bytes_written += _PutHex8 (src[i], false); - } - else - { - for (size_t i = src_len-1; i < src_len; --i) - bytes_written += _PutHex8 (src[i], false); - } - if (!binary_was_set) - m_flags.Clear (eBinary); - - return bytes_written; -} - -size_t -Stream::PutBytesAsRawHex8 (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order) -{ - if (src_byte_order == eByteOrderInvalid) - src_byte_order = m_byte_order; - - if (dst_byte_order == eByteOrderInvalid) - dst_byte_order = m_byte_order; - - size_t bytes_written = 0; - const uint8_t *src = (const uint8_t *)s; - bool binary_is_set = m_flags.Test(eBinary); +size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + bool add_prefix = m_flags.Test(eAddPrefix); + size_t bytes_written = 0; + if (byte_order == eByteOrderLittle) { + for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } else { + for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); + --byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } + return bytes_written; +} + +size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + bool add_prefix = m_flags.Test(eAddPrefix); + size_t bytes_written = 0; + if (byte_order == eByteOrderLittle) { + for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } else { + for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); + --byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } + return bytes_written; +} + +size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + bool add_prefix = m_flags.Test(eAddPrefix); + size_t bytes_written = 0; + if (byte_order == eByteOrderLittle) { + for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } else { + for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); + --byte, add_prefix = false) + bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), add_prefix); + } + return bytes_written; +} + +size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size, + lldb::ByteOrder byte_order) { + switch (byte_size) { + case 1: + return PutHex8((uint8_t)uvalue); + case 2: + return PutHex16((uint16_t)uvalue); + case 4: + return PutHex32((uint32_t)uvalue); + case 8: + return PutHex64(uvalue); + } + return 0; +} + +size_t Stream::PutPointer(void *ptr) { + return PutRawBytes(&ptr, sizeof(ptr), endian::InlHostByteOrder(), + endian::InlHostByteOrder()); +} + +size_t Stream::PutFloat(float f, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + return PutRawBytes(&f, sizeof(f), endian::InlHostByteOrder(), byte_order); +} + +size_t Stream::PutDouble(double d, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + return PutRawBytes(&d, sizeof(d), endian::InlHostByteOrder(), byte_order); +} + +size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) { + if (byte_order == eByteOrderInvalid) + byte_order = m_byte_order; + + return PutRawBytes(&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order); +} + +size_t Stream::PutRawBytes(const void *s, size_t src_len, + ByteOrder src_byte_order, ByteOrder dst_byte_order) { + if (src_byte_order == eByteOrderInvalid) + src_byte_order = m_byte_order; + + if (dst_byte_order == eByteOrderInvalid) + dst_byte_order = m_byte_order; + + size_t bytes_written = 0; + const uint8_t *src = (const uint8_t *)s; + bool binary_was_set = m_flags.Test(eBinary); + if (!binary_was_set) + m_flags.Set(eBinary); + if (src_byte_order == dst_byte_order) { + for (size_t i = 0; i < src_len; ++i) + bytes_written += _PutHex8(src[i], false); + } else { + for (size_t i = src_len - 1; i < src_len; --i) + bytes_written += _PutHex8(src[i], false); + } + if (!binary_was_set) m_flags.Clear(eBinary); - if (src_byte_order == dst_byte_order) - { - for (size_t i = 0; i < src_len; ++i) - bytes_written += _PutHex8 (src[i], false); - } - else - { - for (size_t i = src_len-1; i < src_len; --i) - bytes_written += _PutHex8 (src[i], false); - } - if (binary_is_set) - m_flags.Set(eBinary); - return bytes_written; + return bytes_written; +} + +size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len, + ByteOrder src_byte_order, + ByteOrder dst_byte_order) { + if (src_byte_order == eByteOrderInvalid) + src_byte_order = m_byte_order; + + if (dst_byte_order == eByteOrderInvalid) + dst_byte_order = m_byte_order; + + size_t bytes_written = 0; + const uint8_t *src = (const uint8_t *)s; + bool binary_is_set = m_flags.Test(eBinary); + m_flags.Clear(eBinary); + if (src_byte_order == dst_byte_order) { + for (size_t i = 0; i < src_len; ++i) + bytes_written += _PutHex8(src[i], false); + } else { + for (size_t i = src_len - 1; i < src_len; --i) + bytes_written += _PutHex8(src[i], false); + } + if (binary_is_set) + m_flags.Set(eBinary); + + return bytes_written; +} + +size_t Stream::PutCStringAsRawHex8(const char *s) { + size_t bytes_written = 0; + bool binary_is_set = m_flags.Test(eBinary); + m_flags.Clear(eBinary); + do { + bytes_written += _PutHex8(*s, false); + ++s; + } while (*s); + if (binary_is_set) + m_flags.Set(eBinary); + return bytes_written; +} + +void Stream::UnitTest(Stream *s) { + s->PutHex8(0x12); + + s->PutChar(' '); + s->PutHex16(0x3456, endian::InlHostByteOrder()); + s->PutChar(' '); + s->PutHex16(0x3456, eByteOrderBig); + s->PutChar(' '); + s->PutHex16(0x3456, eByteOrderLittle); + + s->PutChar(' '); + s->PutHex32(0x789abcde, endian::InlHostByteOrder()); + s->PutChar(' '); + s->PutHex32(0x789abcde, eByteOrderBig); + s->PutChar(' '); + s->PutHex32(0x789abcde, eByteOrderLittle); + + s->PutChar(' '); + s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder()); + s->PutChar(' '); + s->PutHex64(0x1122334455667788ull, eByteOrderBig); + s->PutChar(' '); + s->PutHex64(0x1122334455667788ull, eByteOrderLittle); + + const char *hola = "Hello World!!!"; + s->PutChar(' '); + s->PutCString(hola); + + s->PutChar(' '); + s->Write(hola, 5); + + s->PutChar(' '); + s->PutCStringAsRawHex8(hola); + + s->PutChar(' '); + s->PutCStringAsRawHex8("01234"); + + s->PutChar(' '); + s->Printf("pid=%i", 12733); + + s->PutChar(' '); + s->PrintfAsRawHex8("pid=%i", 12733); + s->PutChar('\n'); } - -size_t -Stream::PutCStringAsRawHex8 (const char *s) -{ - size_t bytes_written = 0; - bool binary_is_set = m_flags.Test(eBinary); - m_flags.Clear(eBinary); - do - { - bytes_written += _PutHex8 (*s, false); - ++s; - } while (*s); - if (binary_is_set) - m_flags.Set(eBinary); - return bytes_written; -} - -void -Stream::UnitTest(Stream *s) -{ - s->PutHex8(0x12); - - s->PutChar(' '); - s->PutHex16(0x3456, endian::InlHostByteOrder()); - s->PutChar(' '); - s->PutHex16(0x3456, eByteOrderBig); - s->PutChar(' '); - s->PutHex16(0x3456, eByteOrderLittle); - - s->PutChar(' '); - s->PutHex32(0x789abcde, endian::InlHostByteOrder()); - s->PutChar(' '); - s->PutHex32(0x789abcde, eByteOrderBig); - s->PutChar(' '); - s->PutHex32(0x789abcde, eByteOrderLittle); - - s->PutChar(' '); - s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder()); - s->PutChar(' '); - s->PutHex64(0x1122334455667788ull, eByteOrderBig); - s->PutChar(' '); - s->PutHex64(0x1122334455667788ull, eByteOrderLittle); - - const char *hola = "Hello World!!!"; - s->PutChar(' '); - s->PutCString (hola); - - s->PutChar(' '); - s->Write (hola, 5); - - s->PutChar(' '); - s->PutCStringAsRawHex8 (hola); - - s->PutChar(' '); - s->PutCStringAsRawHex8 ("01234"); - - s->PutChar(' '); - s->Printf ("pid=%i", 12733); - - s->PutChar(' '); - s->PrintfAsRawHex8 ("pid=%i", 12733); - s->PutChar('\n'); -} - |
