Stream.cpp revision 317027
1317027Sdim//===-- Stream.cpp ----------------------------------------------*- C++ -*-===// 2317027Sdim// 3317027Sdim// The LLVM Compiler Infrastructure 4317027Sdim// 5317027Sdim// This file is distributed under the University of Illinois Open Source 6317027Sdim// License. See LICENSE.TXT for details. 7317027Sdim// 8317027Sdim//===----------------------------------------------------------------------===// 9317027Sdim 10317027Sdim#include "lldb/Utility/Stream.h" 11317027Sdim 12317027Sdim#include "lldb/Utility/Endian.h" 13317027Sdim#include "lldb/Utility/VASPrintf.h" 14317027Sdim#include "llvm/ADT/SmallString.h" // for SmallString 15317027Sdim 16317027Sdim#include <string> 17317027Sdim 18317027Sdim#include <inttypes.h> 19317027Sdim#include <stddef.h> 20317027Sdim 21317027Sdimusing namespace lldb; 22317027Sdimusing namespace lldb_private; 23317027Sdim 24317027SdimStream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order) 25317027Sdim : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order), 26317027Sdim m_indent_level(0) {} 27317027Sdim 28317027SdimStream::Stream() 29317027Sdim : m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()), 30317027Sdim m_indent_level(0) {} 31317027Sdim 32317027Sdim//------------------------------------------------------------------ 33317027Sdim// Destructor 34317027Sdim//------------------------------------------------------------------ 35317027SdimStream::~Stream() {} 36317027Sdim 37317027SdimByteOrder Stream::SetByteOrder(ByteOrder byte_order) { 38317027Sdim ByteOrder old_byte_order = m_byte_order; 39317027Sdim m_byte_order = byte_order; 40317027Sdim return old_byte_order; 41317027Sdim} 42317027Sdim 43317027Sdim//------------------------------------------------------------------ 44317027Sdim// Put an offset "uval" out to the stream using the printf format 45317027Sdim// in "format". 46317027Sdim//------------------------------------------------------------------ 47317027Sdimvoid Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); } 48317027Sdim 49317027Sdim//------------------------------------------------------------------ 50317027Sdim// Put an SLEB128 "uval" out to the stream using the printf format 51317027Sdim// in "format". 52317027Sdim//------------------------------------------------------------------ 53317027Sdimsize_t Stream::PutSLEB128(int64_t sval) { 54317027Sdim size_t bytes_written = 0; 55317027Sdim if (m_flags.Test(eBinary)) { 56317027Sdim bool more = true; 57317027Sdim while (more) { 58317027Sdim uint8_t byte = sval & 0x7fu; 59317027Sdim sval >>= 7; 60317027Sdim /* sign bit of byte is 2nd high order bit (0x40) */ 61317027Sdim if ((sval == 0 && !(byte & 0x40)) || (sval == -1 && (byte & 0x40))) 62317027Sdim more = false; 63317027Sdim else 64317027Sdim // more bytes to come 65317027Sdim byte |= 0x80u; 66317027Sdim bytes_written += Write(&byte, 1); 67317027Sdim } 68317027Sdim } else { 69317027Sdim bytes_written = Printf("0x%" PRIi64, sval); 70317027Sdim } 71317027Sdim 72317027Sdim return bytes_written; 73317027Sdim} 74317027Sdim 75317027Sdim//------------------------------------------------------------------ 76317027Sdim// Put an ULEB128 "uval" out to the stream using the printf format 77317027Sdim// in "format". 78317027Sdim//------------------------------------------------------------------ 79317027Sdimsize_t Stream::PutULEB128(uint64_t uval) { 80317027Sdim size_t bytes_written = 0; 81317027Sdim if (m_flags.Test(eBinary)) { 82317027Sdim do { 83317027Sdim 84317027Sdim uint8_t byte = uval & 0x7fu; 85317027Sdim uval >>= 7; 86317027Sdim if (uval != 0) { 87317027Sdim // more bytes to come 88317027Sdim byte |= 0x80u; 89317027Sdim } 90317027Sdim bytes_written += Write(&byte, 1); 91317027Sdim } while (uval != 0); 92317027Sdim } else { 93317027Sdim bytes_written = Printf("0x%" PRIx64, uval); 94317027Sdim } 95317027Sdim return bytes_written; 96317027Sdim} 97317027Sdim 98317027Sdim//------------------------------------------------------------------ 99317027Sdim// Print a raw NULL terminated C string to the stream. 100317027Sdim//------------------------------------------------------------------ 101317027Sdimsize_t Stream::PutCString(llvm::StringRef str) { 102317027Sdim size_t bytes_written = 0; 103317027Sdim bytes_written = Write(str.data(), str.size()); 104317027Sdim 105317027Sdim // when in binary mode, emit the NULL terminator 106317027Sdim if (m_flags.Test(eBinary)) 107317027Sdim bytes_written += PutChar('\0'); 108317027Sdim return bytes_written; 109317027Sdim} 110317027Sdim 111317027Sdim//------------------------------------------------------------------ 112317027Sdim// Print a double quoted NULL terminated C string to the stream 113317027Sdim// using the printf format in "format". 114317027Sdim//------------------------------------------------------------------ 115317027Sdimvoid Stream::QuotedCString(const char *cstr, const char *format) { 116317027Sdim Printf(format, cstr); 117317027Sdim} 118317027Sdim 119317027Sdim//------------------------------------------------------------------ 120317027Sdim// Put an address "addr" out to the stream with optional prefix 121317027Sdim// and suffix strings. 122317027Sdim//------------------------------------------------------------------ 123317027Sdimvoid Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix, 124317027Sdim const char *suffix) { 125317027Sdim if (prefix == NULL) 126317027Sdim prefix = ""; 127317027Sdim if (suffix == NULL) 128317027Sdim suffix = ""; 129317027Sdim // int addr_width = m_addr_size << 1; 130317027Sdim // Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix); 131317027Sdim Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix); 132317027Sdim} 133317027Sdim 134317027Sdim//------------------------------------------------------------------ 135317027Sdim// Put an address range out to the stream with optional prefix 136317027Sdim// and suffix strings. 137317027Sdim//------------------------------------------------------------------ 138317027Sdimvoid Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr, 139317027Sdim uint32_t addr_size, const char *prefix, 140317027Sdim const char *suffix) { 141317027Sdim if (prefix && prefix[0]) 142317027Sdim PutCString(prefix); 143317027Sdim Address(lo_addr, addr_size, "["); 144317027Sdim Address(hi_addr, addr_size, "-", ")"); 145317027Sdim if (suffix && suffix[0]) 146317027Sdim PutCString(suffix); 147317027Sdim} 148317027Sdim 149317027Sdimsize_t Stream::PutChar(char ch) { return Write(&ch, 1); } 150317027Sdim 151317027Sdim//------------------------------------------------------------------ 152317027Sdim// Print some formatted output to the stream. 153317027Sdim//------------------------------------------------------------------ 154317027Sdimsize_t Stream::Printf(const char *format, ...) { 155317027Sdim va_list args; 156317027Sdim va_start(args, format); 157317027Sdim size_t result = PrintfVarArg(format, args); 158317027Sdim va_end(args); 159317027Sdim return result; 160317027Sdim} 161317027Sdim 162317027Sdim//------------------------------------------------------------------ 163317027Sdim// Print some formatted output to the stream. 164317027Sdim//------------------------------------------------------------------ 165317027Sdimsize_t Stream::PrintfVarArg(const char *format, va_list args) { 166317027Sdim llvm::SmallString<1024> buf; 167317027Sdim VASprintf(buf, format, args); 168317027Sdim 169317027Sdim // Include the NULL termination byte for binary output 170317027Sdim size_t length = buf.size(); 171317027Sdim if (m_flags.Test(eBinary)) 172317027Sdim ++length; 173317027Sdim return Write(buf.c_str(), length); 174317027Sdim} 175317027Sdim 176317027Sdim//------------------------------------------------------------------ 177317027Sdim// Print and End of Line character to the stream 178317027Sdim//------------------------------------------------------------------ 179317027Sdimsize_t Stream::EOL() { return PutChar('\n'); } 180317027Sdim 181317027Sdim//------------------------------------------------------------------ 182317027Sdim// Indent the current line using the current indentation level and 183317027Sdim// print an optional string following the indentation spaces. 184317027Sdim//------------------------------------------------------------------ 185317027Sdimsize_t Stream::Indent(const char *s) { 186317027Sdim return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : ""); 187317027Sdim} 188317027Sdim 189317027Sdimsize_t Stream::Indent(llvm::StringRef str) { 190317027Sdim return Printf("%*.*s%s", m_indent_level, m_indent_level, "", 191317027Sdim str.str().c_str()); 192317027Sdim} 193317027Sdim 194317027Sdim//------------------------------------------------------------------ 195317027Sdim// Stream a character "ch" out to this stream. 196317027Sdim//------------------------------------------------------------------ 197317027SdimStream &Stream::operator<<(char ch) { 198317027Sdim PutChar(ch); 199317027Sdim return *this; 200317027Sdim} 201317027Sdim 202317027Sdim//------------------------------------------------------------------ 203317027Sdim// Stream the NULL terminated C string out to this stream. 204317027Sdim//------------------------------------------------------------------ 205317027SdimStream &Stream::operator<<(const char *s) { 206317027Sdim Printf("%s", s); 207317027Sdim return *this; 208317027Sdim} 209317027Sdim 210317027SdimStream &Stream::operator<<(llvm::StringRef str) { 211317027Sdim Write(str.data(), str.size()); 212317027Sdim return *this; 213317027Sdim} 214317027Sdim 215317027Sdim//------------------------------------------------------------------ 216317027Sdim// Stream the pointer value out to this stream. 217317027Sdim//------------------------------------------------------------------ 218317027SdimStream &Stream::operator<<(const void *p) { 219317027Sdim Printf("0x%.*tx", (int)sizeof(const void *) * 2, (ptrdiff_t)p); 220317027Sdim return *this; 221317027Sdim} 222317027Sdim 223317027Sdim//------------------------------------------------------------------ 224317027Sdim// Stream a uint8_t "uval" out to this stream. 225317027Sdim//------------------------------------------------------------------ 226317027SdimStream &Stream::operator<<(uint8_t uval) { 227317027Sdim PutHex8(uval); 228317027Sdim return *this; 229317027Sdim} 230317027Sdim 231317027Sdim//------------------------------------------------------------------ 232317027Sdim// Stream a uint16_t "uval" out to this stream. 233317027Sdim//------------------------------------------------------------------ 234317027SdimStream &Stream::operator<<(uint16_t uval) { 235317027Sdim PutHex16(uval, m_byte_order); 236317027Sdim return *this; 237317027Sdim} 238317027Sdim 239317027Sdim//------------------------------------------------------------------ 240317027Sdim// Stream a uint32_t "uval" out to this stream. 241317027Sdim//------------------------------------------------------------------ 242317027SdimStream &Stream::operator<<(uint32_t uval) { 243317027Sdim PutHex32(uval, m_byte_order); 244317027Sdim return *this; 245317027Sdim} 246317027Sdim 247317027Sdim//------------------------------------------------------------------ 248317027Sdim// Stream a uint64_t "uval" out to this stream. 249317027Sdim//------------------------------------------------------------------ 250317027SdimStream &Stream::operator<<(uint64_t uval) { 251317027Sdim PutHex64(uval, m_byte_order); 252317027Sdim return *this; 253317027Sdim} 254317027Sdim 255317027Sdim//------------------------------------------------------------------ 256317027Sdim// Stream a int8_t "sval" out to this stream. 257317027Sdim//------------------------------------------------------------------ 258317027SdimStream &Stream::operator<<(int8_t sval) { 259317027Sdim Printf("%i", (int)sval); 260317027Sdim return *this; 261317027Sdim} 262317027Sdim 263317027Sdim//------------------------------------------------------------------ 264317027Sdim// Stream a int16_t "sval" out to this stream. 265317027Sdim//------------------------------------------------------------------ 266317027SdimStream &Stream::operator<<(int16_t sval) { 267317027Sdim Printf("%i", (int)sval); 268317027Sdim return *this; 269317027Sdim} 270317027Sdim 271317027Sdim//------------------------------------------------------------------ 272317027Sdim// Stream a int32_t "sval" out to this stream. 273317027Sdim//------------------------------------------------------------------ 274317027SdimStream &Stream::operator<<(int32_t sval) { 275317027Sdim Printf("%i", (int)sval); 276317027Sdim return *this; 277317027Sdim} 278317027Sdim 279317027Sdim//------------------------------------------------------------------ 280317027Sdim// Stream a int64_t "sval" out to this stream. 281317027Sdim//------------------------------------------------------------------ 282317027SdimStream &Stream::operator<<(int64_t sval) { 283317027Sdim Printf("%" PRIi64, sval); 284317027Sdim return *this; 285317027Sdim} 286317027Sdim 287317027Sdim//------------------------------------------------------------------ 288317027Sdim// Get the current indentation level 289317027Sdim//------------------------------------------------------------------ 290317027Sdimint Stream::GetIndentLevel() const { return m_indent_level; } 291317027Sdim 292317027Sdim//------------------------------------------------------------------ 293317027Sdim// Set the current indentation level 294317027Sdim//------------------------------------------------------------------ 295317027Sdimvoid Stream::SetIndentLevel(int indent_level) { m_indent_level = indent_level; } 296317027Sdim 297317027Sdim//------------------------------------------------------------------ 298317027Sdim// Increment the current indentation level 299317027Sdim//------------------------------------------------------------------ 300317027Sdimvoid Stream::IndentMore(int amount) { m_indent_level += amount; } 301317027Sdim 302317027Sdim//------------------------------------------------------------------ 303317027Sdim// Decrement the current indentation level 304317027Sdim//------------------------------------------------------------------ 305317027Sdimvoid Stream::IndentLess(int amount) { 306317027Sdim if (m_indent_level >= amount) 307317027Sdim m_indent_level -= amount; 308317027Sdim else 309317027Sdim m_indent_level = 0; 310317027Sdim} 311317027Sdim 312317027Sdim//------------------------------------------------------------------ 313317027Sdim// Get the address size in bytes 314317027Sdim//------------------------------------------------------------------ 315317027Sdimuint32_t Stream::GetAddressByteSize() const { return m_addr_size; } 316317027Sdim 317317027Sdim//------------------------------------------------------------------ 318317027Sdim// Set the address size in bytes 319317027Sdim//------------------------------------------------------------------ 320317027Sdimvoid Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; } 321317027Sdim 322317027Sdim//------------------------------------------------------------------ 323317027Sdim// The flags get accessor 324317027Sdim//------------------------------------------------------------------ 325317027SdimFlags &Stream::GetFlags() { return m_flags; } 326317027Sdim 327317027Sdim//------------------------------------------------------------------ 328317027Sdim// The flags const get accessor 329317027Sdim//------------------------------------------------------------------ 330317027Sdimconst Flags &Stream::GetFlags() const { return m_flags; } 331317027Sdim 332317027Sdim//------------------------------------------------------------------ 333317027Sdim// The byte order get accessor 334317027Sdim//------------------------------------------------------------------ 335317027Sdim 336317027Sdimlldb::ByteOrder Stream::GetByteOrder() const { return m_byte_order; } 337317027Sdim 338317027Sdimsize_t Stream::PrintfAsRawHex8(const char *format, ...) { 339317027Sdim va_list args; 340317027Sdim va_start(args, format); 341317027Sdim 342317027Sdim llvm::SmallString<1024> buf; 343317027Sdim VASprintf(buf, format, args); 344317027Sdim 345317027Sdim size_t length = 0; 346317027Sdim for (char C : buf) 347317027Sdim length += _PutHex8(C, false); 348317027Sdim 349317027Sdim va_end(args); 350317027Sdim 351317027Sdim return length; 352317027Sdim} 353317027Sdim 354317027Sdimsize_t Stream::PutNHex8(size_t n, uint8_t uvalue) { 355317027Sdim size_t bytes_written = 0; 356317027Sdim for (size_t i = 0; i < n; ++i) 357317027Sdim bytes_written += _PutHex8(uvalue, false); 358317027Sdim return bytes_written; 359317027Sdim} 360317027Sdim 361317027Sdimsize_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) { 362317027Sdim size_t bytes_written = 0; 363317027Sdim if (m_flags.Test(eBinary)) { 364317027Sdim bytes_written = Write(&uvalue, 1); 365317027Sdim } else { 366317027Sdim if (add_prefix) 367317027Sdim PutCString("0x"); 368317027Sdim 369317027Sdim static char g_hex_to_ascii_hex_char[16] = {'0', '1', '2', '3', '4', '5', 370317027Sdim '6', '7', '8', '9', 'a', 'b', 371317027Sdim 'c', 'd', 'e', 'f'}; 372317027Sdim char nibble_chars[2]; 373317027Sdim nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf]; 374317027Sdim nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf]; 375317027Sdim bytes_written = Write(nibble_chars, sizeof(nibble_chars)); 376317027Sdim } 377317027Sdim return bytes_written; 378317027Sdim} 379317027Sdim 380317027Sdimsize_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); } 381317027Sdim 382317027Sdimsize_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) { 383317027Sdim if (byte_order == eByteOrderInvalid) 384317027Sdim byte_order = m_byte_order; 385317027Sdim 386317027Sdim size_t bytes_written = 0; 387317027Sdim if (byte_order == eByteOrderLittle) { 388317027Sdim for (size_t byte = 0; byte < sizeof(uvalue); ++byte) 389317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 390317027Sdim } else { 391317027Sdim for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte) 392317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 393317027Sdim } 394317027Sdim return bytes_written; 395317027Sdim} 396317027Sdim 397317027Sdimsize_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) { 398317027Sdim if (byte_order == eByteOrderInvalid) 399317027Sdim byte_order = m_byte_order; 400317027Sdim 401317027Sdim size_t bytes_written = 0; 402317027Sdim if (byte_order == eByteOrderLittle) { 403317027Sdim for (size_t byte = 0; byte < sizeof(uvalue); ++byte) 404317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 405317027Sdim } else { 406317027Sdim for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte) 407317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 408317027Sdim } 409317027Sdim return bytes_written; 410317027Sdim} 411317027Sdim 412317027Sdimsize_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) { 413317027Sdim if (byte_order == eByteOrderInvalid) 414317027Sdim byte_order = m_byte_order; 415317027Sdim 416317027Sdim size_t bytes_written = 0; 417317027Sdim if (byte_order == eByteOrderLittle) { 418317027Sdim for (size_t byte = 0; byte < sizeof(uvalue); ++byte) 419317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 420317027Sdim } else { 421317027Sdim for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte) 422317027Sdim bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false); 423317027Sdim } 424317027Sdim return bytes_written; 425317027Sdim} 426317027Sdim 427317027Sdimsize_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size, 428317027Sdim lldb::ByteOrder byte_order) { 429317027Sdim switch (byte_size) { 430317027Sdim case 1: 431317027Sdim return PutHex8((uint8_t)uvalue); 432317027Sdim case 2: 433317027Sdim return PutHex16((uint16_t)uvalue); 434317027Sdim case 4: 435317027Sdim return PutHex32((uint32_t)uvalue); 436317027Sdim case 8: 437317027Sdim return PutHex64(uvalue); 438317027Sdim } 439317027Sdim return 0; 440317027Sdim} 441317027Sdim 442317027Sdimsize_t Stream::PutPointer(void *ptr) { 443317027Sdim return PutRawBytes(&ptr, sizeof(ptr), endian::InlHostByteOrder(), 444317027Sdim endian::InlHostByteOrder()); 445317027Sdim} 446317027Sdim 447317027Sdimsize_t Stream::PutFloat(float f, ByteOrder byte_order) { 448317027Sdim if (byte_order == eByteOrderInvalid) 449317027Sdim byte_order = m_byte_order; 450317027Sdim 451317027Sdim return PutRawBytes(&f, sizeof(f), endian::InlHostByteOrder(), byte_order); 452317027Sdim} 453317027Sdim 454317027Sdimsize_t Stream::PutDouble(double d, ByteOrder byte_order) { 455317027Sdim if (byte_order == eByteOrderInvalid) 456317027Sdim byte_order = m_byte_order; 457317027Sdim 458317027Sdim return PutRawBytes(&d, sizeof(d), endian::InlHostByteOrder(), byte_order); 459317027Sdim} 460317027Sdim 461317027Sdimsize_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) { 462317027Sdim if (byte_order == eByteOrderInvalid) 463317027Sdim byte_order = m_byte_order; 464317027Sdim 465317027Sdim return PutRawBytes(&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order); 466317027Sdim} 467317027Sdim 468317027Sdimsize_t Stream::PutRawBytes(const void *s, size_t src_len, 469317027Sdim ByteOrder src_byte_order, ByteOrder dst_byte_order) { 470317027Sdim if (src_byte_order == eByteOrderInvalid) 471317027Sdim src_byte_order = m_byte_order; 472317027Sdim 473317027Sdim if (dst_byte_order == eByteOrderInvalid) 474317027Sdim dst_byte_order = m_byte_order; 475317027Sdim 476317027Sdim size_t bytes_written = 0; 477317027Sdim const uint8_t *src = (const uint8_t *)s; 478317027Sdim bool binary_was_set = m_flags.Test(eBinary); 479317027Sdim if (!binary_was_set) 480317027Sdim m_flags.Set(eBinary); 481317027Sdim if (src_byte_order == dst_byte_order) { 482317027Sdim for (size_t i = 0; i < src_len; ++i) 483317027Sdim bytes_written += _PutHex8(src[i], false); 484317027Sdim } else { 485317027Sdim for (size_t i = src_len - 1; i < src_len; --i) 486317027Sdim bytes_written += _PutHex8(src[i], false); 487317027Sdim } 488317027Sdim if (!binary_was_set) 489317027Sdim m_flags.Clear(eBinary); 490317027Sdim 491317027Sdim return bytes_written; 492317027Sdim} 493317027Sdim 494317027Sdimsize_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len, 495317027Sdim ByteOrder src_byte_order, 496317027Sdim ByteOrder dst_byte_order) { 497317027Sdim if (src_byte_order == eByteOrderInvalid) 498317027Sdim src_byte_order = m_byte_order; 499317027Sdim 500317027Sdim if (dst_byte_order == eByteOrderInvalid) 501317027Sdim dst_byte_order = m_byte_order; 502317027Sdim 503317027Sdim size_t bytes_written = 0; 504317027Sdim const uint8_t *src = (const uint8_t *)s; 505317027Sdim bool binary_is_set = m_flags.Test(eBinary); 506317027Sdim m_flags.Clear(eBinary); 507317027Sdim if (src_byte_order == dst_byte_order) { 508317027Sdim for (size_t i = 0; i < src_len; ++i) 509317027Sdim bytes_written += _PutHex8(src[i], false); 510317027Sdim } else { 511317027Sdim for (size_t i = src_len - 1; i < src_len; --i) 512317027Sdim bytes_written += _PutHex8(src[i], false); 513317027Sdim } 514317027Sdim if (binary_is_set) 515317027Sdim m_flags.Set(eBinary); 516317027Sdim 517317027Sdim return bytes_written; 518317027Sdim} 519317027Sdim 520317027Sdimsize_t Stream::PutCStringAsRawHex8(const char *s) { 521317027Sdim size_t bytes_written = 0; 522317027Sdim bool binary_is_set = m_flags.Test(eBinary); 523317027Sdim m_flags.Clear(eBinary); 524317027Sdim do { 525317027Sdim bytes_written += _PutHex8(*s, false); 526317027Sdim ++s; 527317027Sdim } while (*s); 528317027Sdim if (binary_is_set) 529317027Sdim m_flags.Set(eBinary); 530317027Sdim return bytes_written; 531317027Sdim} 532317027Sdim 533317027Sdimvoid Stream::UnitTest(Stream *s) { 534317027Sdim s->PutHex8(0x12); 535317027Sdim 536317027Sdim s->PutChar(' '); 537317027Sdim s->PutHex16(0x3456, endian::InlHostByteOrder()); 538317027Sdim s->PutChar(' '); 539317027Sdim s->PutHex16(0x3456, eByteOrderBig); 540317027Sdim s->PutChar(' '); 541317027Sdim s->PutHex16(0x3456, eByteOrderLittle); 542317027Sdim 543317027Sdim s->PutChar(' '); 544317027Sdim s->PutHex32(0x789abcde, endian::InlHostByteOrder()); 545317027Sdim s->PutChar(' '); 546317027Sdim s->PutHex32(0x789abcde, eByteOrderBig); 547317027Sdim s->PutChar(' '); 548317027Sdim s->PutHex32(0x789abcde, eByteOrderLittle); 549317027Sdim 550317027Sdim s->PutChar(' '); 551317027Sdim s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder()); 552317027Sdim s->PutChar(' '); 553317027Sdim s->PutHex64(0x1122334455667788ull, eByteOrderBig); 554317027Sdim s->PutChar(' '); 555317027Sdim s->PutHex64(0x1122334455667788ull, eByteOrderLittle); 556317027Sdim 557317027Sdim const char *hola = "Hello World!!!"; 558317027Sdim s->PutChar(' '); 559317027Sdim s->PutCString(hola); 560317027Sdim 561317027Sdim s->PutChar(' '); 562317027Sdim s->Write(hola, 5); 563317027Sdim 564317027Sdim s->PutChar(' '); 565317027Sdim s->PutCStringAsRawHex8(hola); 566317027Sdim 567317027Sdim s->PutChar(' '); 568317027Sdim s->PutCStringAsRawHex8("01234"); 569317027Sdim 570317027Sdim s->PutChar(' '); 571317027Sdim s->Printf("pid=%i", 12733); 572317027Sdim 573317027Sdim s->PutChar(' '); 574317027Sdim s->PrintfAsRawHex8("pid=%i", 12733); 575317027Sdim s->PutChar('\n'); 576317027Sdim} 577