contrib/llvm/tools/lldb/source/Core/Stream.cpp

   1 //===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Stream.h"
  11 #include "lldb/Host/Endian.h"
  12 #include <stddef.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16
  17 #include <inttypes.h>
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 Stream::Stream (uint32_t flags, uint32_t addr_size, ByteOrder byte_order) :
  23     m_flags (flags),
  24     m_addr_size (addr_size),
  25     m_byte_order (byte_order),
  26     m_indent_level(0)
  27 {
  28 }
  29
  30 Stream::Stream () :
  31     m_flags (0),
  32     m_addr_size (4),
  33     m_byte_order (lldb::endian::InlHostByteOrder()),
  34     m_indent_level(0)
  35 {
  36 }
  37
  38 //------------------------------------------------------------------
  39 // Destructor
  40 //------------------------------------------------------------------
  41 Stream::~Stream ()
  42 {
  43 }
  44
  45 ByteOrder
  46 Stream::SetByteOrder (ByteOrder byte_order)
  47 {
  48     ByteOrder old_byte_order = m_byte_order;
  49     m_byte_order = byte_order;
  50     return old_byte_order;
  51 }
  52
  53 //------------------------------------------------------------------
  54 // Put an offset "uval" out to the stream using the printf format
  55 // in "format".
  56 //------------------------------------------------------------------
  57 void
  58 Stream::Offset (uint32_t uval, const char *format)
  59 {
  60     Printf (format, uval);
  61 }
  62
  63 //------------------------------------------------------------------
  64 // Put an SLEB128 "uval" out to the stream using the printf format
  65 // in "format".
  66 //------------------------------------------------------------------
  67 size_t
  68 Stream::PutSLEB128 (int64_t sval)
  69 {
  70     size_t bytes_written = 0;
  71     if (m_flags.Test(eBinary))
  72     {
  73         bool more = true;
  74         while (more)
  75         {
  76             uint8_t byte = sval & 0x7fu;
  77             sval >>= 7;
  78             /* sign bit of byte is 2nd high order bit (0x40) */
  79             if ((sval ==  0 && !(byte & 0x40)) ||
  80                 (sval == -1 &&  (byte & 0x40)) )
  81                 more = false;
  82             else
  83                 // more bytes to come
  84                 byte |= 0x80u;
  85             bytes_written += Write(&byte, 1);
  86         }
  87     }
  88     else
  89     {
  90         bytes_written = Printf ("0x%" PRIi64, sval);
  91     }
  92
  93     return bytes_written;
  94
  95 }
  96
  97 //------------------------------------------------------------------
  98 // Put an ULEB128 "uval" out to the stream using the printf format
  99 // in "format".
 100 //------------------------------------------------------------------
 101 size_t
 102 Stream::PutULEB128 (uint64_t uval)
 103 {
 104     size_t bytes_written = 0;
 105     if (m_flags.Test(eBinary))
 106     {
 107         do
 108         {
 109
 110             uint8_t byte = uval & 0x7fu;
 111             uval >>= 7;
 112             if (uval != 0)
 113             {
 114                 // more bytes to come
 115                 byte |= 0x80u;
 116             }
 117             bytes_written += Write(&byte, 1);
 118         } while (uval != 0);
 119     }
 120     else
 121     {
 122         bytes_written = Printf ("0x%" PRIx64, uval);
 123     }
 124     return bytes_written;
 125 }
 126
 127 //------------------------------------------------------------------
 128 // Print a raw NULL terminated C string to the stream.
 129 //------------------------------------------------------------------
 130 size_t
 131 Stream::PutCString (const char *cstr)
 132 {
 133     size_t cstr_len = strlen(cstr);
 134     // when in binary mode, emit the NULL terminator
 135     if (m_flags.Test(eBinary))
 136         ++cstr_len;
 137     return Write (cstr, cstr_len);
 138 }
 139
 140 //------------------------------------------------------------------
 141 // Print a double quoted NULL terminated C string to the stream
 142 // using the printf format in "format".
 143 //------------------------------------------------------------------
 144 void
 145 Stream::QuotedCString (const char *cstr, const char *format)
 146 {
 147     Printf (format, cstr);
 148 }
 149
 150 //------------------------------------------------------------------
 151 // Put an address "addr" out to the stream with optional prefix
 152 // and suffix strings.
 153 //------------------------------------------------------------------
 154 void
 155 Stream::Address (uint64_t addr, uint32_t addr_size, const char *prefix, const char *suffix)
 156 {
 157     if (prefix == NULL)
 158         prefix = "";
 159     if (suffix == NULL)
 160         suffix = "";
 161 //    int addr_width = m_addr_size << 1;
 162 //    Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
 163     Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix);
 164 }
 165
 166 //------------------------------------------------------------------
 167 // Put an address range out to the stream with optional prefix
 168 // and suffix strings.
 169 //------------------------------------------------------------------
 170 void
 171 Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix, const char *suffix)
 172 {
 173     if (prefix && prefix[0])
 174         PutCString (prefix);
 175     Address (lo_addr, addr_size, "[");
 176     Address (hi_addr, addr_size, "-", ")");
 177     if (suffix && suffix[0])
 178         PutCString (suffix);
 179 }
 180
 181
 182 size_t
 183 Stream::PutChar (char ch)
 184 {
 185     return Write (&ch, 1);
 186 }
 187
 188
 189 //------------------------------------------------------------------
 190 // Print some formatted output to the stream.
 191 //------------------------------------------------------------------
 192 size_t
 193 Stream::Printf (const char *format, ...)
 194 {
 195     va_list args;
 196     va_start (args, format);
 197     size_t result = PrintfVarArg(format, args);
 198     va_end (args);
 199     return result;
 200 }
 201
 202 //------------------------------------------------------------------
 203 // Print some formatted output to the stream.
 204 //------------------------------------------------------------------
 205 size_t
 206 Stream::PrintfVarArg (const char *format, va_list args)
 207 {
 208     char str[1024];
 209     va_list args_copy;
 210
 211     va_copy (args_copy, args);
 212
 213     size_t bytes_written = 0;
 214     // Try and format our string into a fixed buffer first and see if it fits
 215     size_t length = ::vsnprintf (str, sizeof(str), format, args);
 216     if (length < sizeof(str))
 217     {
 218         // Include the NULL termination byte for binary output
 219         if (m_flags.Test(eBinary))
 220             length += 1;
 221         // The formatted string fit into our stack based buffer, so we can just
 222         // append that to our packet
 223         bytes_written = Write (str, length);
 224     }
 225     else
 226     {
 227         // Our stack buffer wasn't big enough to contain the entire formatted
 228         // string, so lets let vasprintf create the string for us!
 229         char *str_ptr = NULL;
 230         length = ::vasprintf (&str_ptr, format, args_copy);
 231         if (str_ptr)
 232         {
 233             // Include the NULL termination byte for binary output
 234             if (m_flags.Test(eBinary))
 235                 length += 1;
 236             bytes_written = Write (str_ptr, length);
 237             ::free (str_ptr);
 238         }
 239     }
 240     va_end (args_copy);
 241     return bytes_written;
 242 }
 243
 244 //------------------------------------------------------------------
 245 // Print and End of Line character to the stream
 246 //------------------------------------------------------------------
 247 size_t
 248 Stream::EOL()
 249 {
 250     return PutChar ('\n');
 251 }
 252
 253 //------------------------------------------------------------------
 254 // Indent the current line using the current indentation level and
 255 // print an optional string following the idenatation spaces.
 256 //------------------------------------------------------------------
 257 size_t
 258 Stream::Indent(const char *s)
 259 {
 260     return Printf ("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : "");
 261 }
 262
 263 //------------------------------------------------------------------
 264 // Stream a character "ch" out to this stream.
 265 //------------------------------------------------------------------
 266 Stream&
 267 Stream::operator<< (char ch)
 268 {
 269     PutChar (ch);
 270     return *this;
 271 }
 272
 273 //------------------------------------------------------------------
 274 // Stream the NULL terminated C string out to this stream.
 275 //------------------------------------------------------------------
 276 Stream&
 277 Stream::operator<<  (const char *s)
 278 {
 279     Printf ("%s", s);
 280     return *this;
 281 }
 282
 283 //------------------------------------------------------------------
 284 // Stream the pointer value out to this stream.
 285 //------------------------------------------------------------------
 286 Stream&
 287 Stream::operator<< (void *p)
 288 {
 289     Printf ("0x%.*tx", (int)sizeof(void*) * 2, (ptrdiff_t)p);
 290     return *this;
 291 }
 292
 293 //------------------------------------------------------------------
 294 // Stream a uint8_t "uval" out to this stream.
 295 //------------------------------------------------------------------
 296 Stream&
 297 Stream::operator<< (uint8_t uval)
 298 {
 299     PutHex8(uval);
 300     return *this;
 301 }
 302
 303 //------------------------------------------------------------------
 304 // Stream a uint16_t "uval" out to this stream.
 305 //------------------------------------------------------------------
 306 Stream&
 307 Stream::operator<< (uint16_t uval)
 308 {
 309     PutHex16(uval, m_byte_order);
 310     return *this;
 311 }
 312
 313 //------------------------------------------------------------------
 314 // Stream a uint32_t "uval" out to this stream.
 315 //------------------------------------------------------------------
 316 Stream&
 317 Stream::operator<< (uint32_t uval)
 318 {
 319     PutHex32(uval, m_byte_order);
 320     return *this;
 321 }
 322
 323 //------------------------------------------------------------------
 324 // Stream a uint64_t "uval" out to this stream.
 325 //------------------------------------------------------------------
 326 Stream&
 327 Stream::operator<< (uint64_t uval)
 328 {
 329     PutHex64(uval, m_byte_order);
 330     return *this;
 331 }
 332
 333 //------------------------------------------------------------------
 334 // Stream a int8_t "sval" out to this stream.
 335 //------------------------------------------------------------------
 336 Stream&
 337 Stream::operator<< (int8_t sval)
 338 {
 339     Printf ("%i", (int)sval);
 340     return *this;
 341 }
 342
 343 //------------------------------------------------------------------
 344 // Stream a int16_t "sval" out to this stream.
 345 //------------------------------------------------------------------
 346 Stream&
 347 Stream::operator<< (int16_t sval)
 348 {
 349     Printf ("%i", (int)sval);
 350     return *this;
 351 }
 352
 353 //------------------------------------------------------------------
 354 // Stream a int32_t "sval" out to this stream.
 355 //------------------------------------------------------------------
 356 Stream&
 357 Stream::operator<< (int32_t sval)
 358 {
 359     Printf ("%i", (int)sval);
 360     return *this;
 361 }
 362
 363 //------------------------------------------------------------------
 364 // Stream a int64_t "sval" out to this stream.
 365 //------------------------------------------------------------------
 366 Stream&
 367 Stream::operator<< (int64_t sval)
 368 {
 369     Printf ("%" PRIi64, sval);
 370     return *this;
 371 }
 372
 373 //------------------------------------------------------------------
 374 // Get the current indentation level
 375 //------------------------------------------------------------------
 376 int
 377 Stream::GetIndentLevel() const
 378 {
 379     return m_indent_level;
 380 }
 381
 382 //------------------------------------------------------------------
 383 // Set the current indentation level
 384 //------------------------------------------------------------------
 385 void
 386 Stream::SetIndentLevel(int indent_level)
 387 {
 388     m_indent_level = indent_level;
 389 }
 390
 391 //------------------------------------------------------------------
 392 // Increment the current indentation level
 393 //------------------------------------------------------------------
 394 void
 395 Stream::IndentMore(int amount)
 396 {
 397     m_indent_level += amount;
 398 }
 399
 400 //------------------------------------------------------------------
 401 // Decrement the current indentation level
 402 //------------------------------------------------------------------
 403 void
 404 Stream::IndentLess (int amount)
 405 {
 406     if (m_indent_level >= amount)
 407         m_indent_level -= amount;
 408     else
 409         m_indent_level = 0;
 410 }
 411
 412 //------------------------------------------------------------------
 413 // Get the address size in bytes
 414 //------------------------------------------------------------------
 415 uint32_t
 416 Stream::GetAddressByteSize() const
 417 {
 418     return m_addr_size;
 419 }
 420
 421 //------------------------------------------------------------------
 422 // Set the address size in bytes
 423 //------------------------------------------------------------------
 424 void
 425 Stream::SetAddressByteSize(uint32_t addr_size)
 426 {
 427     m_addr_size = addr_size;
 428 }
 429
 430 //------------------------------------------------------------------
 431 // Returns true if the verbose flag bit is set in this stream.
 432 //------------------------------------------------------------------
 433 bool
 434 Stream::GetVerbose() const
 435 {
 436     return m_flags.Test(eVerbose);
 437 }
 438
 439 //------------------------------------------------------------------
 440 // Returns true if the debug flag bit is set in this stream.
 441 //------------------------------------------------------------------
 442 bool
 443 Stream::GetDebug() const
 444 {
 445     return m_flags.Test(eDebug);
 446 }
 447
 448 //------------------------------------------------------------------
 449 // The flags get accessor
 450 //------------------------------------------------------------------
 451 Flags&
 452 Stream::GetFlags()
 453 {
 454     return m_flags;
 455 }
 456
 457 //------------------------------------------------------------------
 458 // The flags const get accessor
 459 //------------------------------------------------------------------
 460 const Flags&
 461 Stream::GetFlags() const
 462 {
 463     return m_flags;
 464 }
 465
 466 //------------------------------------------------------------------
 467 // The byte order get accessor
 468 //------------------------------------------------------------------
 469
 470 lldb::ByteOrder
 471 Stream::GetByteOrder() const
 472 {
 473     return m_byte_order;
 474 }
 475
 476 size_t
 477 Stream::PrintfAsRawHex8 (const char *format, ...)
 478 {
 479     va_list args;
 480     va_list args_copy;
 481     va_start (args, format);
 482     va_copy (args, args_copy); // Copy this so we
 483
 484     char str[1024];
 485     size_t bytes_written = 0;
 486     // Try and format our string into a fixed buffer first and see if it fits
 487     size_t length = ::vsnprintf (str, sizeof(str), format, args);
 488     if (length < sizeof(str))
 489     {
 490         // The formatted string fit into our stack based buffer, so we can just
 491         // append that to our packet
 492         for (size_t i=0; i<length; ++i)
 493             bytes_written += _PutHex8 (str[i], false);
 494     }
 495     else
 496     {
 497         // Our stack buffer wasn't big enough to contain the entire formatted
 498         // string, so lets let vasprintf create the string for us!
 499         char *str_ptr = NULL;
 500         length = ::vasprintf (&str_ptr, format, args_copy);
 501         if (str_ptr)
 502         {
 503             for (size_t i=0; i<length; ++i)
 504                 bytes_written += _PutHex8 (str_ptr[i], false);
 505             ::free (str_ptr);
 506         }
 507     }
 508     va_end (args);
 509     va_end (args_copy);
 510
 511     return bytes_written;
 512 }
 513
 514 size_t
 515 Stream::PutNHex8 (size_t n, uint8_t uvalue)
 516 {
 517     size_t bytes_written = 0;
 518     for (size_t i=0; i<n; ++i)
 519         bytes_written += _PutHex8 (uvalue, m_flags.Test(eAddPrefix));
 520     return bytes_written;
 521 }
 522
 523 size_t
 524 Stream::_PutHex8 (uint8_t uvalue, bool add_prefix)
 525 {
 526     size_t bytes_written = 0;
 527     if (m_flags.Test(eBinary))
 528     {
 529         bytes_written = Write (&uvalue, 1);
 530     }
 531     else
 532     {
 533         if (add_prefix)
 534             PutCString("0x");
 535
 536         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' };
 537         char nibble_chars[2];
 538         nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
 539         nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
 540         bytes_written = Write (nibble_chars, sizeof(nibble_chars));
 541     }
 542     return bytes_written;
 543 }
 544
 545 size_t
 546 Stream::PutHex8 (uint8_t uvalue)
 547 {
 548     return _PutHex8 (uvalue, m_flags.Test(eAddPrefix));
 549 }
 550
 551 size_t
 552 Stream::PutHex16 (uint16_t uvalue, ByteOrder byte_order)
 553 {
 554     if (byte_order == eByteOrderInvalid)
 555         byte_order = m_byte_order;
 556
 557     bool add_prefix = m_flags.Test(eAddPrefix);
 558     size_t bytes_written = 0;
 559     if (byte_order == eByteOrderLittle)
 560     {
 561         for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
 562             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 563     }
 564     else
 565     {
 566         for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false)
 567             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 568     }
 569     return bytes_written;
 570 }
 571
 572 size_t
 573 Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order)
 574 {
 575     if (byte_order == eByteOrderInvalid)
 576         byte_order = m_byte_order;
 577
 578     bool add_prefix = m_flags.Test(eAddPrefix);
 579     size_t bytes_written = 0;
 580     if (byte_order == eByteOrderLittle)
 581     {
 582         for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
 583             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 584     }
 585     else
 586     {
 587         for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false)
 588             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 589     }
 590     return bytes_written;
 591 }
 592
 593 size_t
 594 Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order)
 595 {
 596     if (byte_order == eByteOrderInvalid)
 597         byte_order = m_byte_order;
 598
 599     bool add_prefix = m_flags.Test(eAddPrefix);
 600     size_t bytes_written = 0;
 601     if (byte_order == eByteOrderLittle)
 602     {
 603         for (size_t byte = 0; byte < sizeof(uvalue); ++byte, add_prefix = false)
 604             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 605     }
 606     else
 607     {
 608         for (size_t byte = sizeof(uvalue)-1; byte < sizeof(uvalue); --byte, add_prefix = false)
 609             bytes_written += _PutHex8 ((uint8_t)(uvalue >> (byte * 8)), add_prefix);
 610     }
 611     return bytes_written;
 612 }
 613
 614 size_t
 615 Stream::PutMaxHex64
 616 (
 617     uint64_t uvalue,
 618     size_t byte_size,
 619     lldb::ByteOrder byte_order
 620 )
 621 {
 622     switch (byte_size)
 623     {
 624     case 1: return PutHex8  ((uint8_t)uvalue);
 625     case 2: return PutHex16 ((uint16_t)uvalue);
 626     case 4: return PutHex32 ((uint32_t)uvalue);
 627     case 8: return PutHex64 (uvalue);
 628     }
 629     return 0;
 630 }
 631
 632 size_t
 633 Stream::PutPointer (void *ptr)
 634 {
 635     return PutRawBytes (&ptr, sizeof(ptr), lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
 636 }
 637
 638 size_t
 639 Stream::PutFloat(float f, ByteOrder byte_order)
 640 {
 641     if (byte_order == eByteOrderInvalid)
 642         byte_order = m_byte_order;
 643
 644     return PutRawBytes (&f, sizeof(f), lldb::endian::InlHostByteOrder(), byte_order);
 645 }
 646
 647 size_t
 648 Stream::PutDouble(double d, ByteOrder byte_order)
 649 {
 650     if (byte_order == eByteOrderInvalid)
 651         byte_order = m_byte_order;
 652
 653     return PutRawBytes (&d, sizeof(d), lldb::endian::InlHostByteOrder(), byte_order);
 654 }
 655
 656 size_t
 657 Stream::PutLongDouble(long double ld, ByteOrder byte_order)
 658 {
 659     if (byte_order == eByteOrderInvalid)
 660         byte_order = m_byte_order;
 661
 662     return PutRawBytes (&ld, sizeof(ld), lldb::endian::InlHostByteOrder(), byte_order);
 663 }
 664
 665 size_t
 666 Stream::PutRawBytes (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order)
 667 {
 668     if (src_byte_order == eByteOrderInvalid)
 669         src_byte_order = m_byte_order;
 670
 671     if (dst_byte_order == eByteOrderInvalid)
 672         dst_byte_order = m_byte_order;
 673
 674     size_t bytes_written = 0;
 675     const uint8_t *src = (const uint8_t *)s;
 676     bool binary_was_set = m_flags.Test (eBinary);
 677     if (!binary_was_set)
 678         m_flags.Set (eBinary);
 679     if (src_byte_order == dst_byte_order)
 680     {
 681         for (size_t i = 0; i < src_len; ++i)
 682             bytes_written += _PutHex8 (src[i], false);
 683     }
 684     else
 685     {
 686         for (size_t i = src_len-1; i < src_len; --i)
 687             bytes_written += _PutHex8 (src[i], false);
 688     }
 689     if (!binary_was_set)
 690         m_flags.Clear (eBinary);
 691
 692     return bytes_written;
 693 }
 694
 695 size_t
 696 Stream::PutBytesAsRawHex8 (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order)
 697 {
 698     if (src_byte_order == eByteOrderInvalid)
 699         src_byte_order = m_byte_order;
 700
 701     if (dst_byte_order == eByteOrderInvalid)
 702         dst_byte_order = m_byte_order;
 703
 704     size_t bytes_written = 0;
 705     const uint8_t *src = (const uint8_t *)s;
 706     bool binary_is_set = m_flags.Test(eBinary);
 707     m_flags.Clear(eBinary);
 708     if (src_byte_order == dst_byte_order)
 709     {
 710         for (size_t i = 0; i < src_len; ++i)
 711             bytes_written += _PutHex8 (src[i], false);
 712     }
 713     else
 714     {
 715         for (size_t i = src_len-1; i < src_len; --i)
 716             bytes_written += _PutHex8 (src[i], false);
 717     }
 718     if (binary_is_set)
 719         m_flags.Set(eBinary);
 720
 721     return bytes_written;
 722 }
 723
 724 size_t
 725 Stream::PutCStringAsRawHex8 (const char *s)
 726 {
 727     size_t bytes_written = 0;
 728     bool binary_is_set = m_flags.Test(eBinary);
 729     m_flags.Clear(eBinary);
 730     do
 731     {
 732         bytes_written += _PutHex8 (*s, false);
 733         ++s;
 734     } while (*s);
 735     if (binary_is_set)
 736         m_flags.Set(eBinary);
 737     return bytes_written;
 738 }
 739
 740 void
 741 Stream::UnitTest(Stream *s)
 742 {
 743     s->PutHex8(0x12);
 744
 745     s->PutChar(' ');
 746     s->PutHex16(0x3456, lldb::endian::InlHostByteOrder());
 747     s->PutChar(' ');
 748     s->PutHex16(0x3456, eByteOrderBig);
 749     s->PutChar(' ');
 750     s->PutHex16(0x3456, eByteOrderLittle);
 751
 752     s->PutChar(' ');
 753     s->PutHex32(0x789abcde, lldb::endian::InlHostByteOrder());
 754     s->PutChar(' ');
 755     s->PutHex32(0x789abcde, eByteOrderBig);
 756     s->PutChar(' ');
 757     s->PutHex32(0x789abcde, eByteOrderLittle);
 758
 759     s->PutChar(' ');
 760     s->PutHex64(0x1122334455667788ull, lldb::endian::InlHostByteOrder());
 761     s->PutChar(' ');
 762     s->PutHex64(0x1122334455667788ull, eByteOrderBig);
 763     s->PutChar(' ');
 764     s->PutHex64(0x1122334455667788ull, eByteOrderLittle);
 765
 766     const char *hola = "Hello World!!!";
 767     s->PutChar(' ');
 768     s->PutCString (hola);
 769
 770     s->PutChar(' ');
 771     s->Write (hola, 5);
 772
 773     s->PutChar(' ');
 774     s->PutCStringAsRawHex8 (hola);
 775
 776     s->PutChar(' ');
 777     s->PutCStringAsRawHex8 ("01234");
 778
 779     s->PutChar(' ');
 780     s->Printf ("pid=%i", 12733);
 781
 782     s->PutChar(' ');
 783     s->PrintfAsRawHex8 ("pid=%i", 12733);
 784     s->PutChar('\n');
 785 }
 786