source/DataFormatters/StringPrinter.cpp

   1 //===-- StringPrinter.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/DataFormatters/StringPrinter.h"
  11
  12 #include "lldb/Core/Debugger.h"
  13 #include "lldb/Core/Error.h"
  14 #include "lldb/Core/ValueObject.h"
  15 #include "lldb/Target/Language.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Target/Target.h"
  18
  19 #include "llvm/Support/ConvertUTF.h"
  20
  21 #include <ctype.h>
  22 #include <locale>
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26 using namespace lldb_private::formatters;
  27
  28 // we define this for all values of type but only implement it for those we care about
  29 // that's good because we get linker errors for any unsupported type
  30 template <lldb_private::formatters::StringPrinter::StringElementType type>
  31 static StringPrinter::StringPrinterBufferPointer<>
  32 GetPrintableImpl(uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next);
  33
  34 // mimic isprint() for Unicode codepoints
  35 static bool
  36 isprint(char32_t codepoint)
  37 {
  38     if (codepoint <= 0x1F || codepoint == 0x7F) // C0
  39     {
  40         return false;
  41     }
  42     if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
  43     {
  44         return false;
  45     }
  46     if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators
  47     {
  48         return false;
  49     }
  50     if (codepoint == 0x200E || codepoint == 0x200F || (codepoint >= 0x202A && codepoint <= 0x202E)) // bidirectional text control
  51     {
  52         return false;
  53     }
  54     if (codepoint >= 0xFFF9 && codepoint <= 0xFFFF) // interlinears and generally specials
  55     {
  56         return false;
  57     }
  58     return true;
  59 }
  60
  61 template <>
  62 StringPrinter::StringPrinterBufferPointer<>
  63 GetPrintableImpl<StringPrinter::StringElementType::ASCII> (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
  64 {
  65     StringPrinter::StringPrinterBufferPointer<> retval = {nullptr};
  66
  67     switch (*buffer)
  68     {
  69         case 0:
  70             retval = {"\\0",2};
  71             break;
  72         case '\a':
  73             retval = {"\\a",2};
  74             break;
  75         case '\b':
  76             retval = {"\\b",2};
  77             break;
  78         case '\f':
  79             retval = {"\\f",2};
  80             break;
  81         case '\n':
  82             retval = {"\\n",2};
  83             break;
  84         case '\r':
  85             retval = {"\\r",2};
  86             break;
  87         case '\t':
  88             retval = {"\\t",2};
  89             break;
  90         case '\v':
  91             retval = {"\\v",2};
  92             break;
  93         case '\"':
  94             retval = {"\\\"",2};
  95             break;
  96         case '\\':
  97             retval = {"\\\\",2};
  98             break;
  99         default:
 100           if (isprint(*buffer))
 101               retval = {buffer,1};
 102           else
 103           {
 104               uint8_t* data = new uint8_t[5];
 105               sprintf((char*)data,"\\x%02x",*buffer);
 106               retval = {data, 4, [] (const uint8_t* c) {delete[] c;} };
 107               break;
 108           }
 109     }
 110
 111     next = buffer + 1;
 112     return retval;
 113 }
 114
 115 static char32_t
 116 ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1)
 117 {
 118     return (c0-192)*64+(c1-128);
 119 }
 120 static char32_t
 121 ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1, unsigned char c2)
 122 {
 123     return (c0-224)*4096+(c1-128)*64+(c2-128);
 124 }
 125 static char32_t
 126 ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1, unsigned char c2, unsigned char c3)
 127 {
 128     return (c0-240)*262144+(c2-128)*4096+(c2-128)*64+(c3-128);
 129 }
 130
 131 template <>
 132 StringPrinter::StringPrinterBufferPointer<>
 133 GetPrintableImpl<StringPrinter::StringElementType::UTF8> (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
 134 {
 135     StringPrinter::StringPrinterBufferPointer<> retval {nullptr};
 136
 137     unsigned utf8_encoded_len = getNumBytesForUTF8(*buffer);
 138
 139     if (1+buffer_end-buffer < utf8_encoded_len)
 140     {
 141         // I don't have enough bytes - print whatever I have left
 142         retval = {buffer,static_cast<size_t>(1+buffer_end-buffer)};
 143         next = buffer_end+1;
 144         return retval;
 145     }
 146
 147     char32_t codepoint = 0;
 148     switch (utf8_encoded_len)
 149     {
 150         case 1:
 151             // this is just an ASCII byte - ask ASCII
 152             return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(buffer, buffer_end, next);
 153         case 2:
 154             codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1));
 155             break;
 156         case 3:
 157             codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1), (unsigned char)*(buffer+2));
 158             break;
 159         case 4:
 160             codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1), (unsigned char)*(buffer+2), (unsigned char)*(buffer+3));
 161             break;
 162         default:
 163             // this is probably some bogus non-character thing
 164             // just print it as-is and hope to sync up again soon
 165             retval = {buffer,1};
 166             next = buffer+1;
 167             return retval;
 168     }
 169
 170     if (codepoint)
 171     {
 172         switch (codepoint)
 173         {
 174             case 0:
 175                 retval = {"\\0",2};
 176                 break;
 177             case '\a':
 178                 retval = {"\\a",2};
 179                 break;
 180             case '\b':
 181                 retval = {"\\b",2};
 182                 break;
 183             case '\f':
 184                 retval = {"\\f",2};
 185                 break;
 186             case '\n':
 187                 retval = {"\\n",2};
 188                 break;
 189             case '\r':
 190                 retval = {"\\r",2};
 191                 break;
 192             case '\t':
 193                 retval = {"\\t",2};
 194                 break;
 195             case '\v':
 196                 retval = {"\\v",2};
 197                 break;
 198             case '\"':
 199                 retval = {"\\\"",2};
 200                 break;
 201             case '\\':
 202                 retval = {"\\\\",2};
 203                 break;
 204             default:
 205                 if (isprint(codepoint))
 206                     retval = {buffer,utf8_encoded_len};
 207                 else
 208                 {
 209                     uint8_t* data = new uint8_t[11];
 210                     sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
 211                     retval = { data,10,[] (const uint8_t* c) {delete[] c;} };
 212                     break;
 213                 }
 214         }
 215
 216         next = buffer + utf8_encoded_len;
 217         return retval;
 218     }
 219
 220     // this should not happen - but just in case.. try to resync at some point
 221     retval = {buffer,1};
 222     next = buffer+1;
 223     return retval;
 224 }
 225
 226 // Given a sequence of bytes, this function returns:
 227 // a sequence of bytes to actually print out + a length
 228 // the following unscanned position of the buffer is in next
 229 static StringPrinter::StringPrinterBufferPointer<>
 230 GetPrintable(StringPrinter::StringElementType type, uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
 231 {
 232     if (!buffer)
 233         return {nullptr};
 234
 235     switch (type)
 236     {
 237         case StringPrinter::StringElementType::ASCII:
 238             return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(buffer, buffer_end, next);
 239         case StringPrinter::StringElementType::UTF8:
 240             return GetPrintableImpl<StringPrinter::StringElementType::UTF8>(buffer, buffer_end, next);
 241         default:
 242             return {nullptr};
 243     }
 244 }
 245
 246 StringPrinter::EscapingHelper
 247 StringPrinter::GetDefaultEscapingHelper (GetPrintableElementType elem_type)
 248 {
 249     switch (elem_type)
 250     {
 251         case GetPrintableElementType::UTF8:
 252             return [] (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next) -> StringPrinter::StringPrinterBufferPointer<> {
 253                 return GetPrintable(StringPrinter::StringElementType::UTF8, buffer, buffer_end, next);
 254             };
 255         case GetPrintableElementType::ASCII:
 256             return [] (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next) -> StringPrinter::StringPrinterBufferPointer<> {
 257                 return GetPrintable(StringPrinter::StringElementType::ASCII, buffer, buffer_end, next);
 258             };
 259     }
 260     llvm_unreachable("bad element type");
 261 }
 262
 263 // use this call if you already have an LLDB-side buffer for the data
 264 template<typename SourceDataType>
 265 static bool
 266 DumpUTFBufferToStream (ConversionResult (*ConvertFunction) (const SourceDataType**,
 267                                                             const SourceDataType*,
 268                                                             UTF8**,
 269                                                             UTF8*,
 270                                                             ConversionFlags),
 271                        const StringPrinter::ReadBufferAndDumpToStreamOptions& dump_options)
 272 {
 273     Stream &stream(*dump_options.GetStream());
 274     if (dump_options.GetPrefixToken() != 0)
 275         stream.Printf("%s",dump_options.GetPrefixToken());
 276     if (dump_options.GetQuote() != 0)
 277         stream.Printf("%c",dump_options.GetQuote());
 278     auto data(dump_options.GetData());
 279     auto source_size(dump_options.GetSourceSize());
 280     if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd())
 281     {
 282         const int bufferSPSize = data.GetByteSize();
 283         if (dump_options.GetSourceSize() == 0)
 284         {
 285             const int origin_encoding = 8*sizeof(SourceDataType);
 286             source_size = bufferSPSize/(origin_encoding / 4);
 287         }
 288
 289         const SourceDataType *data_ptr = (const SourceDataType*)data.GetDataStart();
 290         const SourceDataType *data_end_ptr = data_ptr + source_size;
 291
 292         const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator();
 293
 294         if (zero_is_terminator)
 295         {
 296             while (data_ptr < data_end_ptr)
 297             {
 298                 if (!*data_ptr)
 299                 {
 300                     data_end_ptr = data_ptr;
 301                     break;
 302                 }
 303                 data_ptr++;
 304             }
 305
 306             data_ptr = (const SourceDataType*)data.GetDataStart();
 307         }
 308
 309         lldb::DataBufferSP utf8_data_buffer_sp;
 310         UTF8* utf8_data_ptr = nullptr;
 311         UTF8* utf8_data_end_ptr = nullptr;
 312
 313         if (ConvertFunction)
 314         {
 315             utf8_data_buffer_sp.reset(new DataBufferHeap(4*bufferSPSize,0));
 316             utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes();
 317             utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
 318             ConvertFunction ( &data_ptr, data_end_ptr, &utf8_data_ptr, utf8_data_end_ptr, lenientConversion );
 319             if (false == zero_is_terminator)
 320                 utf8_data_end_ptr = utf8_data_ptr;
 321             utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes(); // needed because the ConvertFunction will change the value of the data_ptr
 322         }
 323         else
 324         {
 325             // just copy the pointers - the cast is necessary to make the compiler happy
 326             // but this should only happen if we are reading UTF8 data
 327             utf8_data_ptr = const_cast<UTF8 *>(reinterpret_cast<const UTF8*>(data_ptr));
 328             utf8_data_end_ptr = const_cast<UTF8 *>(reinterpret_cast<const UTF8*>(data_end_ptr));
 329         }
 330
 331         const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
 332         lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
 333         if (escape_non_printables)
 334         {
 335             if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
 336                 escaping_callback = language->GetStringPrinterEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::UTF8);
 337             else
 338                 escaping_callback = lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::UTF8);
 339         }
 340
 341         // since we tend to accept partial data (and even partially malformed data)
 342         // we might end up with no NULL terminator before the end_ptr
 343         // hence we need to take a slower route and ensure we stay within boundaries
 344         for (;utf8_data_ptr < utf8_data_end_ptr;)
 345         {
 346             if (zero_is_terminator && !*utf8_data_ptr)
 347                 break;
 348
 349             if (escape_non_printables)
 350             {
 351                 uint8_t* next_data = nullptr;
 352                 auto printable = escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data);
 353                 auto printable_bytes = printable.GetBytes();
 354                 auto printable_size = printable.GetSize();
 355                 if (!printable_bytes || !next_data)
 356                 {
 357                     // GetPrintable() failed on us - print one byte in a desperate resync attempt
 358                     printable_bytes = utf8_data_ptr;
 359                     printable_size = 1;
 360                     next_data = utf8_data_ptr+1;
 361                 }
 362                 for (unsigned c = 0; c < printable_size; c++)
 363                     stream.Printf("%c", *(printable_bytes+c));
 364                 utf8_data_ptr = (uint8_t*)next_data;
 365             }
 366             else
 367             {
 368                 stream.Printf("%c",*utf8_data_ptr);
 369                 utf8_data_ptr++;
 370             }
 371         }
 372     }
 373     if (dump_options.GetQuote() != 0)
 374         stream.Printf("%c",dump_options.GetQuote());
 375     if (dump_options.GetSuffixToken() != 0)
 376         stream.Printf("%s",dump_options.GetSuffixToken());
 377     if (dump_options.GetIsTruncated())
 378         stream.Printf("...");
 379     return true;
 380 }
 381
 382 lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions::ReadStringAndDumpToStreamOptions (ValueObject& valobj) :
 383     ReadStringAndDumpToStreamOptions()
 384 {
 385     SetEscapeNonPrintables(valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
 386 }
 387
 388 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::ReadBufferAndDumpToStreamOptions (ValueObject& valobj) :
 389     ReadBufferAndDumpToStreamOptions()
 390 {
 391     SetEscapeNonPrintables(valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
 392 }
 393
 394 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::ReadBufferAndDumpToStreamOptions (const ReadStringAndDumpToStreamOptions& options) :
 395     ReadBufferAndDumpToStreamOptions()
 396 {
 397     SetStream(options.GetStream());
 398     SetPrefixToken(options.GetPrefixToken());
 399     SetSuffixToken(options.GetSuffixToken());
 400     SetQuote(options.GetQuote());
 401     SetEscapeNonPrintables(options.GetEscapeNonPrintables());
 402     SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
 403     SetLanguage(options.GetLanguage());
 404 }
 405
 406
 407 namespace lldb_private
 408 {
 409
 410 namespace formatters
 411 {
 412
 413 template <>
 414 bool
 415 StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII> (const ReadStringAndDumpToStreamOptions& options)
 416 {
 417     assert(options.GetStream() && "need a Stream to print the string to");
 418     Error my_error;
 419
 420     ProcessSP process_sp(options.GetProcessSP());
 421
 422     if (process_sp.get() == nullptr || options.GetLocation() == 0)
 423         return false;
 424
 425     size_t size;
 426     const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
 427     bool is_truncated = false;
 428
 429     if (options.GetSourceSize() == 0)
 430         size = max_size;
 431     else if (!options.GetIgnoreMaxLength())
 432     {
 433         size = options.GetSourceSize();
 434         if (size > max_size)
 435         {
 436             size = max_size;
 437             is_truncated = true;
 438         }
 439     }
 440     else
 441         size = options.GetSourceSize();
 442
 443     lldb::DataBufferSP buffer_sp(new DataBufferHeap(size,0));
 444
 445     process_sp->ReadCStringFromMemory(options.GetLocation(), (char*)buffer_sp->GetBytes(), size, my_error);
 446
 447     if (my_error.Fail())
 448         return false;
 449
 450     const char* prefix_token = options.GetPrefixToken();
 451     char quote = options.GetQuote();
 452
 453     if (prefix_token != 0)
 454         options.GetStream()->Printf("%s%c",prefix_token,quote);
 455     else if (quote != 0)
 456         options.GetStream()->Printf("%c",quote);
 457
 458     uint8_t* data_end = buffer_sp->GetBytes()+buffer_sp->GetByteSize();
 459
 460     const bool escape_non_printables = options.GetEscapeNonPrintables();
 461     lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
 462     if (escape_non_printables)
 463     {
 464         if (Language *language = Language::FindPlugin(options.GetLanguage()))
 465             escaping_callback = language->GetStringPrinterEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::ASCII);
 466         else
 467             escaping_callback = lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::ASCII);
 468     }
 469
 470     // since we tend to accept partial data (and even partially malformed data)
 471     // we might end up with no NULL terminator before the end_ptr
 472     // hence we need to take a slower route and ensure we stay within boundaries
 473     for (uint8_t* data = buffer_sp->GetBytes(); *data && (data < data_end);)
 474     {
 475         if (escape_non_printables)
 476         {
 477             uint8_t* next_data = nullptr;
 478             auto printable = escaping_callback(data, data_end, next_data);
 479             auto printable_bytes = printable.GetBytes();
 480             auto printable_size = printable.GetSize();
 481             if (!printable_bytes || !next_data)
 482             {
 483                 // GetPrintable() failed on us - print one byte in a desperate resync attempt
 484                 printable_bytes = data;
 485                 printable_size = 1;
 486                 next_data = data+1;
 487             }
 488             for (unsigned c = 0; c < printable_size; c++)
 489                 options.GetStream()->Printf("%c", *(printable_bytes+c));
 490             data = (uint8_t*)next_data;
 491         }
 492         else
 493         {
 494             options.GetStream()->Printf("%c",*data);
 495             data++;
 496         }
 497     }
 498
 499     const char* suffix_token = options.GetSuffixToken();
 500
 501     if (suffix_token != 0)
 502         options.GetStream()->Printf("%c%s",quote, suffix_token);
 503     else if (quote != 0)
 504         options.GetStream()->Printf("%c",quote);
 505
 506     if (is_truncated)
 507         options.GetStream()->Printf("...");
 508
 509     return true;
 510 }
 511
 512 template<typename SourceDataType>
 513 static bool
 514 ReadUTFBufferAndDumpToStream (const StringPrinter::ReadStringAndDumpToStreamOptions& options,
 515                               ConversionResult (*ConvertFunction) (const SourceDataType**,
 516                                                                    const SourceDataType*,
 517                                                                    UTF8**,
 518                                                                    UTF8*,
 519                                                                    ConversionFlags))
 520 {
 521     assert(options.GetStream() && "need a Stream to print the string to");
 522
 523     if (options.GetLocation() == 0 || options.GetLocation() == LLDB_INVALID_ADDRESS)
 524         return false;
 525
 526     lldb::ProcessSP process_sp(options.GetProcessSP());
 527
 528     if (!process_sp)
 529         return false;
 530
 531     const int type_width = sizeof(SourceDataType);
 532     const int origin_encoding = 8 * type_width ;
 533     if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
 534         return false;
 535     // if not UTF8, I need a conversion function to return proper UTF8
 536     if (origin_encoding != 8 && !ConvertFunction)
 537         return false;
 538
 539     if (!options.GetStream())
 540         return false;
 541
 542     uint32_t sourceSize = options.GetSourceSize();
 543     bool needs_zero_terminator = options.GetNeedsZeroTermination();
 544
 545     bool is_truncated = false;
 546     const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
 547
 548     if (!sourceSize)
 549     {
 550         sourceSize = max_size;
 551         needs_zero_terminator = true;
 552     }
 553     else if (!options.GetIgnoreMaxLength())
 554     {
 555         if (sourceSize > max_size)
 556         {
 557             sourceSize = max_size;
 558             is_truncated = true;
 559         }
 560     }
 561
 562     const int bufferSPSize = sourceSize * type_width;
 563
 564     lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize,0));
 565
 566     if (!buffer_sp->GetBytes())
 567         return false;
 568
 569     Error error;
 570     char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
 571
 572     if (needs_zero_terminator)
 573         process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
 574     else
 575         process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
 576
 577     if (error.Fail())
 578     {
 579         options.GetStream()->Printf("unable to read data");
 580         return true;
 581     }
 582
 583     DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
 584
 585     StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options);
 586     dump_options.SetData(data);
 587     dump_options.SetSourceSize(sourceSize);
 588     dump_options.SetIsTruncated(is_truncated);
 589
 590     return DumpUTFBufferToStream(ConvertFunction, dump_options);
 591 }
 592
 593 template <>
 594 bool
 595 StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8> (const ReadStringAndDumpToStreamOptions& options)
 596 {
 597     return ReadUTFBufferAndDumpToStream<UTF8>(options,
 598                                               nullptr);
 599 }
 600
 601 template <>
 602 bool
 603 StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16> (const ReadStringAndDumpToStreamOptions& options)
 604 {
 605     return ReadUTFBufferAndDumpToStream<UTF16>(options,
 606                                                ConvertUTF16toUTF8);
 607 }
 608
 609 template <>
 610 bool
 611 StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32> (const ReadStringAndDumpToStreamOptions& options)
 612 {
 613     return ReadUTFBufferAndDumpToStream<UTF32>(options,
 614                                                ConvertUTF32toUTF8);
 615 }
 616
 617 template <>
 618 bool
 619 StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF8> (const ReadBufferAndDumpToStreamOptions& options)
 620 {
 621     assert(options.GetStream() && "need a Stream to print the string to");
 622
 623     return DumpUTFBufferToStream<UTF8>(nullptr, options);
 624 }
 625
 626 template <>
 627 bool
 628 StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::ASCII> (const ReadBufferAndDumpToStreamOptions& options)
 629 {
 630     // treat ASCII the same as UTF8
 631     // FIXME: can we optimize ASCII some more?
 632     return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
 633 }
 634
 635 template <>
 636 bool
 637 StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16> (const ReadBufferAndDumpToStreamOptions& options)
 638 {
 639     assert(options.GetStream() && "need a Stream to print the string to");
 640
 641     return DumpUTFBufferToStream(ConvertUTF16toUTF8, options);
 642 }
 643
 644 template <>
 645 bool
 646 StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF32> (const ReadBufferAndDumpToStreamOptions& options)
 647 {
 648     assert(options.GetStream() && "need a Stream to print the string to");
 649
 650     return DumpUTFBufferToStream(ConvertUTF32toUTF8, options);
 651 }
 652
 653 } // namespace formatters
 654
 655 } // namespace lldb_private