| //===-- StringPrinter.cpp ----------------------------------------*- C++ |
| //-*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/DataFormatters/StringPrinter.h" |
| |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/ValueObject.h" |
| #include "lldb/Target/Language.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Utility/Status.h" |
| |
| #include "llvm/Support/ConvertUTF.h" |
| |
| #include <ctype.h> |
| #include <locale> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| using namespace lldb_private::formatters; |
| |
| // we define this for all values of type but only implement it for those we |
| // care about that's good because we get linker errors for any unsupported type |
| template <lldb_private::formatters::StringPrinter::StringElementType type> |
| static StringPrinter::StringPrinterBufferPointer<> |
| GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next); |
| |
| // mimic isprint() for Unicode codepoints |
| static bool isprint(char32_t codepoint) { |
| if (codepoint <= 0x1F || codepoint == 0x7F) // C0 |
| { |
| return false; |
| } |
| if (codepoint >= 0x80 && codepoint <= 0x9F) // C1 |
| { |
| return false; |
| } |
| if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators |
| { |
| return false; |
| } |
| if (codepoint == 0x200E || codepoint == 0x200F || |
| (codepoint >= 0x202A && |
| codepoint <= 0x202E)) // bidirectional text control |
| { |
| return false; |
| } |
| if (codepoint >= 0xFFF9 && |
| codepoint <= 0xFFFF) // interlinears and generally specials |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| StringPrinter::StringPrinterBufferPointer<> |
| GetPrintableImpl<StringPrinter::StringElementType::ASCII>(uint8_t *buffer, |
| uint8_t *buffer_end, |
| uint8_t *&next) { |
| StringPrinter::StringPrinterBufferPointer<> retval = {nullptr}; |
| |
| switch (*buffer) { |
| case 0: |
| retval = {"\\0", 2}; |
| break; |
| case '\a': |
| retval = {"\\a", 2}; |
| break; |
| case '\b': |
| retval = {"\\b", 2}; |
| break; |
| case '\f': |
| retval = {"\\f", 2}; |
| break; |
| case '\n': |
| retval = {"\\n", 2}; |
| break; |
| case '\r': |
| retval = {"\\r", 2}; |
| break; |
| case '\t': |
| retval = {"\\t", 2}; |
| break; |
| case '\v': |
| retval = {"\\v", 2}; |
| break; |
| case '\"': |
| retval = {"\\\"", 2}; |
| break; |
| case '\\': |
| retval = {"\\\\", 2}; |
| break; |
| default: |
| if (isprint(*buffer)) |
| retval = {buffer, 1}; |
| else { |
| uint8_t *data = new uint8_t[5]; |
| sprintf((char *)data, "\\x%02x", *buffer); |
| retval = {data, 4, [](const uint8_t *c) { delete[] c; }}; |
| break; |
| } |
| } |
| |
| next = buffer + 1; |
| return retval; |
| } |
| |
| static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1) { |
| return (c0 - 192) * 64 + (c1 - 128); |
| } |
| static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1, |
| unsigned char c2) { |
| return (c0 - 224) * 4096 + (c1 - 128) * 64 + (c2 - 128); |
| } |
| static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1, |
| unsigned char c2, unsigned char c3) { |
| return (c0 - 240) * 262144 + (c2 - 128) * 4096 + (c2 - 128) * 64 + (c3 - 128); |
| } |
| |
| template <> |
| StringPrinter::StringPrinterBufferPointer<> |
| GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer, |
| uint8_t *buffer_end, |
| uint8_t *&next) { |
| StringPrinter::StringPrinterBufferPointer<> retval{nullptr}; |
| |
| unsigned utf8_encoded_len = llvm::getNumBytesForUTF8(*buffer); |
| |
| if (1u + std::distance(buffer, buffer_end) < utf8_encoded_len) { |
| // I don't have enough bytes - print whatever I have left |
| retval = {buffer, static_cast<size_t>(1 + buffer_end - buffer)}; |
| next = buffer_end + 1; |
| return retval; |
| } |
| |
| char32_t codepoint = 0; |
| switch (utf8_encoded_len) { |
| case 1: |
| // this is just an ASCII byte - ask ASCII |
| return GetPrintableImpl<StringPrinter::StringElementType::ASCII>( |
| buffer, buffer_end, next); |
| case 2: |
| codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, |
| (unsigned char)*(buffer + 1)); |
| break; |
| case 3: |
| codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, |
| (unsigned char)*(buffer + 1), |
| (unsigned char)*(buffer + 2)); |
| break; |
| case 4: |
| codepoint = ConvertUTF8ToCodePoint( |
| (unsigned char)*buffer, (unsigned char)*(buffer + 1), |
| (unsigned char)*(buffer + 2), (unsigned char)*(buffer + 3)); |
| break; |
| default: |
| // this is probably some bogus non-character thing just print it as-is and |
| // hope to sync up again soon |
| retval = {buffer, 1}; |
| next = buffer + 1; |
| return retval; |
| } |
| |
| if (codepoint) { |
| switch (codepoint) { |
| case 0: |
| retval = {"\\0", 2}; |
| break; |
| case '\a': |
| retval = {"\\a", 2}; |
| break; |
| case '\b': |
| retval = {"\\b", 2}; |
| break; |
| case '\f': |
| retval = {"\\f", 2}; |
| break; |
| case '\n': |
| retval = {"\\n", 2}; |
| break; |
| case '\r': |
| retval = {"\\r", 2}; |
| break; |
| case '\t': |
| retval = {"\\t", 2}; |
| break; |
| case '\v': |
| retval = {"\\v", 2}; |
| break; |
| case '\"': |
| retval = {"\\\"", 2}; |
| break; |
| case '\\': |
| retval = {"\\\\", 2}; |
| break; |
| default: |
| if (isprint(codepoint)) |
| retval = {buffer, utf8_encoded_len}; |
| else { |
| uint8_t *data = new uint8_t[11]; |
| sprintf((char *)data, "\\U%08x", (unsigned)codepoint); |
| retval = {data, 10, [](const uint8_t *c) { delete[] c; }}; |
| break; |
| } |
| } |
| |
| next = buffer + utf8_encoded_len; |
| return retval; |
| } |
| |
| // this should not happen - but just in case.. try to resync at some point |
| retval = {buffer, 1}; |
| next = buffer + 1; |
| return retval; |
| } |
| |
| // Given a sequence of bytes, this function returns: a sequence of bytes to |
| // actually print out + a length the following unscanned position of the buffer |
| // is in next |
| static StringPrinter::StringPrinterBufferPointer<> |
| GetPrintable(StringPrinter::StringElementType type, uint8_t *buffer, |
| uint8_t *buffer_end, uint8_t *&next) { |
| if (!buffer) |
| return {nullptr}; |
| |
| switch (type) { |
| case StringPrinter::StringElementType::ASCII: |
| return GetPrintableImpl<StringPrinter::StringElementType::ASCII>( |
| buffer, buffer_end, next); |
| case StringPrinter::StringElementType::UTF8: |
| return GetPrintableImpl<StringPrinter::StringElementType::UTF8>( |
| buffer, buffer_end, next); |
| default: |
| return {nullptr}; |
| } |
| } |
| |
| StringPrinter::EscapingHelper |
| StringPrinter::GetDefaultEscapingHelper(GetPrintableElementType elem_type) { |
| switch (elem_type) { |
| case GetPrintableElementType::UTF8: |
| return [](uint8_t *buffer, uint8_t *buffer_end, |
| uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> { |
| return GetPrintable(StringPrinter::StringElementType::UTF8, buffer, |
| buffer_end, next); |
| }; |
| case GetPrintableElementType::ASCII: |
| return [](uint8_t *buffer, uint8_t *buffer_end, |
| uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> { |
| return GetPrintable(StringPrinter::StringElementType::ASCII, buffer, |
| buffer_end, next); |
| }; |
| } |
| llvm_unreachable("bad element type"); |
| } |
| |
| // use this call if you already have an LLDB-side buffer for the data |
| template <typename SourceDataType> |
| static bool DumpUTFBufferToStream( |
| llvm::ConversionResult (*ConvertFunction)(const SourceDataType **, |
| const SourceDataType *, |
| llvm::UTF8 **, llvm::UTF8 *, |
| llvm::ConversionFlags), |
| const StringPrinter::ReadBufferAndDumpToStreamOptions &dump_options) { |
| Stream &stream(*dump_options.GetStream()); |
| if (dump_options.GetPrefixToken() != 0) |
| stream.Printf("%s", dump_options.GetPrefixToken()); |
| if (dump_options.GetQuote() != 0) |
| stream.Printf("%c", dump_options.GetQuote()); |
| auto data(dump_options.GetData()); |
| auto source_size(dump_options.GetSourceSize()); |
| if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd()) { |
| const int bufferSPSize = data.GetByteSize(); |
| if (dump_options.GetSourceSize() == 0) { |
| const int origin_encoding = 8 * sizeof(SourceDataType); |
| source_size = bufferSPSize / (origin_encoding / 4); |
| } |
| |
| const SourceDataType *data_ptr = |
| (const SourceDataType *)data.GetDataStart(); |
| const SourceDataType *data_end_ptr = data_ptr + source_size; |
| |
| const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator(); |
| |
| if (zero_is_terminator) { |
| while (data_ptr < data_end_ptr) { |
| if (!*data_ptr) { |
| data_end_ptr = data_ptr; |
| break; |
| } |
| data_ptr++; |
| } |
| |
| data_ptr = (const SourceDataType *)data.GetDataStart(); |
| } |
| |
| lldb::DataBufferSP utf8_data_buffer_sp; |
| llvm::UTF8 *utf8_data_ptr = nullptr; |
| llvm::UTF8 *utf8_data_end_ptr = nullptr; |
| |
| if (ConvertFunction) { |
| utf8_data_buffer_sp.reset(new DataBufferHeap(4 * bufferSPSize, 0)); |
| utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes(); |
| utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize(); |
| ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr, |
| utf8_data_end_ptr, llvm::lenientConversion); |
| if (false == zero_is_terminator) |
| utf8_data_end_ptr = utf8_data_ptr; |
| // needed because the ConvertFunction will change the value of the |
| // data_ptr. |
| utf8_data_ptr = |
| (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes(); |
| } else { |
| // just copy the pointers - the cast is necessary to make the compiler |
| // happy but this should only happen if we are reading UTF8 data |
| utf8_data_ptr = const_cast<llvm::UTF8 *>( |
| reinterpret_cast<const llvm::UTF8 *>(data_ptr)); |
| utf8_data_end_ptr = const_cast<llvm::UTF8 *>( |
| reinterpret_cast<const llvm::UTF8 *>(data_end_ptr)); |
| } |
| |
| const bool escape_non_printables = dump_options.GetEscapeNonPrintables(); |
| lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback; |
| if (escape_non_printables) { |
| if (Language *language = Language::FindPlugin(dump_options.GetLanguage())) |
| escaping_callback = language->GetStringPrinterEscapingHelper( |
| lldb_private::formatters::StringPrinter::GetPrintableElementType:: |
| UTF8); |
| else |
| escaping_callback = |
| lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper( |
| lldb_private::formatters::StringPrinter:: |
| GetPrintableElementType::UTF8); |
| } |
| |
| // since we tend to accept partial data (and even partially malformed data) |
| // we might end up with no NULL terminator before the end_ptr hence we need |
| // to take a slower route and ensure we stay within boundaries |
| for (; utf8_data_ptr < utf8_data_end_ptr;) { |
| if (zero_is_terminator && !*utf8_data_ptr) |
| break; |
| |
| if (escape_non_printables) { |
| uint8_t *next_data = nullptr; |
| auto printable = |
| escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data); |
| auto printable_bytes = printable.GetBytes(); |
| auto printable_size = printable.GetSize(); |
| if (!printable_bytes || !next_data) { |
| // GetPrintable() failed on us - print one byte in a desperate resync |
| // attempt |
| printable_bytes = utf8_data_ptr; |
| printable_size = 1; |
| next_data = utf8_data_ptr + 1; |
| } |
| for (unsigned c = 0; c < printable_size; c++) |
| stream.Printf("%c", *(printable_bytes + c)); |
| utf8_data_ptr = (uint8_t *)next_data; |
| } else { |
| stream.Printf("%c", *utf8_data_ptr); |
| utf8_data_ptr++; |
| } |
| } |
| } |
| if (dump_options.GetQuote() != 0) |
| stream.Printf("%c", dump_options.GetQuote()); |
| if (dump_options.GetSuffixToken() != 0) |
| stream.Printf("%s", dump_options.GetSuffixToken()); |
| if (dump_options.GetIsTruncated()) |
| stream.Printf("..."); |
| return true; |
| } |
| |
| lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions:: |
| ReadStringAndDumpToStreamOptions(ValueObject &valobj) |
| : ReadStringAndDumpToStreamOptions() { |
| SetEscapeNonPrintables( |
| valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables()); |
| } |
| |
| lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions:: |
| ReadBufferAndDumpToStreamOptions(ValueObject &valobj) |
| : ReadBufferAndDumpToStreamOptions() { |
| SetEscapeNonPrintables( |
| valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables()); |
| } |
| |
| lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions:: |
| ReadBufferAndDumpToStreamOptions( |
| const ReadStringAndDumpToStreamOptions &options) |
| : ReadBufferAndDumpToStreamOptions() { |
| SetStream(options.GetStream()); |
| SetPrefixToken(options.GetPrefixToken()); |
| SetSuffixToken(options.GetSuffixToken()); |
| SetQuote(options.GetQuote()); |
| SetEscapeNonPrintables(options.GetEscapeNonPrintables()); |
| SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator()); |
| SetLanguage(options.GetLanguage()); |
| } |
| |
| namespace lldb_private { |
| |
| namespace formatters { |
| |
| template <> |
| bool StringPrinter::ReadStringAndDumpToStream< |
| StringPrinter::StringElementType::ASCII>( |
| const ReadStringAndDumpToStreamOptions &options) { |
| assert(options.GetStream() && "need a Stream to print the string to"); |
| Status my_error; |
| |
| ProcessSP process_sp(options.GetProcessSP()); |
| |
| if (process_sp.get() == nullptr || options.GetLocation() == 0) |
| return false; |
| |
| size_t size; |
| const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary(); |
| bool is_truncated = false; |
| |
| if (options.GetSourceSize() == 0) |
| size = max_size; |
| else if (!options.GetIgnoreMaxLength()) { |
| size = options.GetSourceSize(); |
| if (size > max_size) { |
| size = max_size; |
| is_truncated = true; |
| } |
| } else |
| size = options.GetSourceSize(); |
| |
| lldb::DataBufferSP buffer_sp(new DataBufferHeap(size, 0)); |
| |
| process_sp->ReadCStringFromMemory( |
| options.GetLocation(), (char *)buffer_sp->GetBytes(), size, my_error); |
| |
| if (my_error.Fail()) |
| return false; |
| |
| const char *prefix_token = options.GetPrefixToken(); |
| char quote = options.GetQuote(); |
| |
| if (prefix_token != 0) |
| options.GetStream()->Printf("%s%c", prefix_token, quote); |
| else if (quote != 0) |
| options.GetStream()->Printf("%c", quote); |
| |
| uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize(); |
| |
| const bool escape_non_printables = options.GetEscapeNonPrintables(); |
| lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback; |
| if (escape_non_printables) { |
| if (Language *language = Language::FindPlugin(options.GetLanguage())) |
| escaping_callback = language->GetStringPrinterEscapingHelper( |
| lldb_private::formatters::StringPrinter::GetPrintableElementType:: |
| ASCII); |
| else |
| escaping_callback = |
| lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper( |
| lldb_private::formatters::StringPrinter::GetPrintableElementType:: |
| ASCII); |
| } |
| |
| // since we tend to accept partial data (and even partially malformed data) |
| // we might end up with no NULL terminator before the end_ptr hence we need |
| // to take a slower route and ensure we stay within boundaries |
| for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) { |
| if (escape_non_printables) { |
| uint8_t *next_data = nullptr; |
| auto printable = escaping_callback(data, data_end, next_data); |
| auto printable_bytes = printable.GetBytes(); |
| auto printable_size = printable.GetSize(); |
| if (!printable_bytes || !next_data) { |
| // GetPrintable() failed on us - print one byte in a desperate resync |
| // attempt |
| printable_bytes = data; |
| printable_size = 1; |
| next_data = data + 1; |
| } |
| for (unsigned c = 0; c < printable_size; c++) |
| options.GetStream()->Printf("%c", *(printable_bytes + c)); |
| data = (uint8_t *)next_data; |
| } else { |
| options.GetStream()->Printf("%c", *data); |
| data++; |
| } |
| } |
| |
| const char *suffix_token = options.GetSuffixToken(); |
| |
| if (suffix_token != 0) |
| options.GetStream()->Printf("%c%s", quote, suffix_token); |
| else if (quote != 0) |
| options.GetStream()->Printf("%c", quote); |
| |
| if (is_truncated) |
| options.GetStream()->Printf("..."); |
| |
| return true; |
| } |
| |
| template <typename SourceDataType> |
| static bool ReadUTFBufferAndDumpToStream( |
| const StringPrinter::ReadStringAndDumpToStreamOptions &options, |
| llvm::ConversionResult (*ConvertFunction)(const SourceDataType **, |
| const SourceDataType *, |
| llvm::UTF8 **, llvm::UTF8 *, |
| llvm::ConversionFlags)) { |
| assert(options.GetStream() && "need a Stream to print the string to"); |
| |
| if (options.GetLocation() == 0 || |
| options.GetLocation() == LLDB_INVALID_ADDRESS) |
| return false; |
| |
| lldb::ProcessSP process_sp(options.GetProcessSP()); |
| |
| if (!process_sp) |
| return false; |
| |
| const int type_width = sizeof(SourceDataType); |
| const int origin_encoding = 8 * type_width; |
| if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32) |
| return false; |
| // if not UTF8, I need a conversion function to return proper UTF8 |
| if (origin_encoding != 8 && !ConvertFunction) |
| return false; |
| |
| if (!options.GetStream()) |
| return false; |
| |
| uint32_t sourceSize = options.GetSourceSize(); |
| bool needs_zero_terminator = options.GetNeedsZeroTermination(); |
| |
| bool is_truncated = false; |
| const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary(); |
| |
| if (!sourceSize) { |
| sourceSize = max_size; |
| needs_zero_terminator = true; |
| } else if (!options.GetIgnoreMaxLength()) { |
| if (sourceSize > max_size) { |
| sourceSize = max_size; |
| is_truncated = true; |
| } |
| } |
| |
| const int bufferSPSize = sourceSize * type_width; |
| |
| lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0)); |
| |
| if (!buffer_sp->GetBytes()) |
| return false; |
| |
| Status error; |
| char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes()); |
| |
| if (needs_zero_terminator) |
| process_sp->ReadStringFromMemory(options.GetLocation(), buffer, |
| bufferSPSize, error, type_width); |
| else |
| process_sp->ReadMemoryFromInferior(options.GetLocation(), |
| (char *)buffer_sp->GetBytes(), |
| bufferSPSize, error); |
| |
| if (error.Fail()) { |
| options.GetStream()->Printf("unable to read data"); |
| return true; |
| } |
| |
| DataExtractor data(buffer_sp, process_sp->GetByteOrder(), |
| process_sp->GetAddressByteSize()); |
| |
| StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options); |
| dump_options.SetData(data); |
| dump_options.SetSourceSize(sourceSize); |
| dump_options.SetIsTruncated(is_truncated); |
| |
| return DumpUTFBufferToStream(ConvertFunction, dump_options); |
| } |
| |
| template <> |
| bool StringPrinter::ReadStringAndDumpToStream< |
| StringPrinter::StringElementType::UTF8>( |
| const ReadStringAndDumpToStreamOptions &options) { |
| return ReadUTFBufferAndDumpToStream<llvm::UTF8>(options, nullptr); |
| } |
| |
| template <> |
| bool StringPrinter::ReadStringAndDumpToStream< |
| StringPrinter::StringElementType::UTF16>( |
| const ReadStringAndDumpToStreamOptions &options) { |
| return ReadUTFBufferAndDumpToStream<llvm::UTF16>(options, |
| llvm::ConvertUTF16toUTF8); |
| } |
| |
| template <> |
| bool StringPrinter::ReadStringAndDumpToStream< |
| StringPrinter::StringElementType::UTF32>( |
| const ReadStringAndDumpToStreamOptions &options) { |
| return ReadUTFBufferAndDumpToStream<llvm::UTF32>(options, |
| llvm::ConvertUTF32toUTF8); |
| } |
| |
| template <> |
| bool StringPrinter::ReadBufferAndDumpToStream< |
| StringPrinter::StringElementType::UTF8>( |
| const ReadBufferAndDumpToStreamOptions &options) { |
| assert(options.GetStream() && "need a Stream to print the string to"); |
| |
| return DumpUTFBufferToStream<llvm::UTF8>(nullptr, options); |
| } |
| |
| template <> |
| bool StringPrinter::ReadBufferAndDumpToStream< |
| StringPrinter::StringElementType::ASCII>( |
| const ReadBufferAndDumpToStreamOptions &options) { |
| // treat ASCII the same as UTF8 |
| // FIXME: can we optimize ASCII some more? |
| return ReadBufferAndDumpToStream<StringElementType::UTF8>(options); |
| } |
| |
| template <> |
| bool StringPrinter::ReadBufferAndDumpToStream< |
| StringPrinter::StringElementType::UTF16>( |
| const ReadBufferAndDumpToStreamOptions &options) { |
| assert(options.GetStream() && "need a Stream to print the string to"); |
| |
| return DumpUTFBufferToStream(llvm::ConvertUTF16toUTF8, options); |
| } |
| |
| template <> |
| bool StringPrinter::ReadBufferAndDumpToStream< |
| StringPrinter::StringElementType::UTF32>( |
| const ReadBufferAndDumpToStreamOptions &options) { |
| assert(options.GetStream() && "need a Stream to print the string to"); |
| |
| return DumpUTFBufferToStream(llvm::ConvertUTF32toUTF8, options); |
| } |
| |
| } // namespace formatters |
| |
| } // namespace lldb_private |
