1 //===-- StringPrinter.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/DataFormatters/StringPrinter.h"
10
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/Target/Language.h"
14 #include "lldb/Target/Process.h"
15 #include "lldb/Target/Target.h"
16 #include "lldb/Utility/Status.h"
17
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/Support/ConvertUTF.h"
20
21 #include <ctype.h>
22 #include <locale>
23 #include <memory>
24
25 using namespace lldb;
26 using namespace lldb_private;
27 using namespace lldb_private::formatters;
28 using GetPrintableElementType = StringPrinter::GetPrintableElementType;
29 using StringElementType = StringPrinter::StringElementType;
30
31 /// DecodedCharBuffer stores the decoded contents of a single character. It
32 /// avoids managing memory on the heap by copying decoded bytes into an in-line
33 /// buffer.
34 class DecodedCharBuffer {
35 public:
DecodedCharBuffer(std::nullptr_t)36 DecodedCharBuffer(std::nullptr_t) {}
37
DecodedCharBuffer(const uint8_t * bytes,size_t size)38 DecodedCharBuffer(const uint8_t *bytes, size_t size) : m_size(size) {
39 if (size > MaxLength)
40 llvm_unreachable("unsupported length");
41 memcpy(m_data, bytes, size);
42 }
43
DecodedCharBuffer(const char * bytes,size_t size)44 DecodedCharBuffer(const char *bytes, size_t size)
45 : DecodedCharBuffer(reinterpret_cast<const uint8_t *>(bytes), size) {}
46
GetBytes() const47 const uint8_t *GetBytes() const { return m_data; }
48
GetSize() const49 size_t GetSize() const { return m_size; }
50
51 private:
52 static constexpr unsigned MaxLength = 16;
53
54 size_t m_size = 0;
55 uint8_t m_data[MaxLength] = {0};
56 };
57
58 using EscapingHelper =
59 std::function<DecodedCharBuffer(uint8_t *, uint8_t *, uint8_t *&)>;
60
61 // we define this for all values of type but only implement it for those we
62 // care about that's good because we get linker errors for any unsupported type
63 template <StringElementType type>
64 static DecodedCharBuffer
65 GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
66 StringPrinter::EscapeStyle escape_style);
67
68 // Mimic isprint() for Unicode codepoints.
isprint32(char32_t codepoint)69 static bool isprint32(char32_t codepoint) {
70 if (codepoint <= 0x1F || codepoint == 0x7F) // C0
71 {
72 return false;
73 }
74 if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
75 {
76 return false;
77 }
78 if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators
79 {
80 return false;
81 }
82 if (codepoint == 0x200E || codepoint == 0x200F ||
83 (codepoint >= 0x202A &&
84 codepoint <= 0x202E)) // bidirectional text control
85 {
86 return false;
87 }
88 if (codepoint >= 0xFFF9 &&
89 codepoint <= 0xFFFF) // interlinears and generally specials
90 {
91 return false;
92 }
93 return true;
94 }
95
attemptASCIIEscape(llvm::UTF32 c,StringPrinter::EscapeStyle escape_style)96 DecodedCharBuffer attemptASCIIEscape(llvm::UTF32 c,
97 StringPrinter::EscapeStyle escape_style) {
98 const bool is_swift_escape_style =
99 escape_style == StringPrinter::EscapeStyle::Swift;
100 switch (c) {
101 case 0:
102 return {"\\0", 2};
103 case '\a':
104 return {"\\a", 2};
105 case '\b':
106 if (is_swift_escape_style)
107 return nullptr;
108 return {"\\b", 2};
109 case '\f':
110 if (is_swift_escape_style)
111 return nullptr;
112 return {"\\f", 2};
113 case '\n':
114 return {"\\n", 2};
115 case '\r':
116 return {"\\r", 2};
117 case '\t':
118 return {"\\t", 2};
119 case '\v':
120 if (is_swift_escape_style)
121 return nullptr;
122 return {"\\v", 2};
123 case '\"':
124 return {"\\\"", 2};
125 case '\'':
126 if (is_swift_escape_style)
127 return {"\\'", 2};
128 return nullptr;
129 case '\\':
130 return {"\\\\", 2};
131 }
132 return nullptr;
133 }
134
135 template <>
GetPrintableImpl(uint8_t * buffer,uint8_t * buffer_end,uint8_t * & next,StringPrinter::EscapeStyle escape_style)136 DecodedCharBuffer GetPrintableImpl<StringElementType::ASCII>(
137 uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
138 StringPrinter::EscapeStyle escape_style) {
139 // The ASCII helper always advances 1 byte at a time.
140 next = buffer + 1;
141
142 DecodedCharBuffer retval = attemptASCIIEscape(*buffer, escape_style);
143 if (retval.GetSize())
144 return retval;
145
146 // Use llvm's locale-independent isPrint(char), instead of the libc
147 // implementation which may give different results on different platforms.
148 if (llvm::isPrint(*buffer))
149 return {buffer, 1};
150
151 unsigned escaped_len;
152 constexpr unsigned max_buffer_size = 7;
153 uint8_t data[max_buffer_size];
154 switch (escape_style) {
155 case StringPrinter::EscapeStyle::CXX:
156 // Prints 4 characters, then a \0 terminator.
157 escaped_len = sprintf((char *)data, "\\x%02x", *buffer);
158 break;
159 case StringPrinter::EscapeStyle::Swift:
160 // Prints up to 6 characters, then a \0 terminator.
161 escaped_len = sprintf((char *)data, "\\u{%x}", *buffer);
162 break;
163 }
164 lldbassert(escaped_len > 0 && "unknown string escape style");
165 return {data, escaped_len};
166 }
167
168 template <>
GetPrintableImpl(uint8_t * buffer,uint8_t * buffer_end,uint8_t * & next,StringPrinter::EscapeStyle escape_style)169 DecodedCharBuffer GetPrintableImpl<StringElementType::UTF8>(
170 uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
171 StringPrinter::EscapeStyle escape_style) {
172 // If the utf8 encoded length is invalid (i.e., not in the closed interval
173 // [1;4]), or if there aren't enough bytes to print, or if the subsequence
174 // isn't valid utf8, fall back to printing an ASCII-escaped subsequence.
175 if (!llvm::isLegalUTF8Sequence(buffer, buffer_end))
176 return GetPrintableImpl<StringElementType::ASCII>(buffer, buffer_end, next,
177 escape_style);
178
179 // Convert the valid utf8 sequence to a utf32 codepoint. This cannot fail.
180 llvm::UTF32 codepoint = 0;
181 const llvm::UTF8 *buffer_for_conversion = buffer;
182 llvm::ConversionResult result = llvm::convertUTF8Sequence(
183 &buffer_for_conversion, buffer_end, &codepoint, llvm::strictConversion);
184 assert(result == llvm::conversionOK &&
185 "Failed to convert legal utf8 sequence");
186 (void)result;
187
188 // The UTF8 helper always advances by the utf8 encoded length.
189 const unsigned utf8_encoded_len = buffer_for_conversion - buffer;
190 next = buffer + utf8_encoded_len;
191
192 DecodedCharBuffer retval = attemptASCIIEscape(codepoint, escape_style);
193 if (retval.GetSize())
194 return retval;
195 if (isprint32(codepoint))
196 return {buffer, utf8_encoded_len};
197
198 unsigned escaped_len;
199 constexpr unsigned max_buffer_size = 13;
200 uint8_t data[max_buffer_size];
201 switch (escape_style) {
202 case StringPrinter::EscapeStyle::CXX:
203 // Prints 10 characters, then a \0 terminator.
204 escaped_len = sprintf((char *)data, "\\U%08x", codepoint);
205 break;
206 case StringPrinter::EscapeStyle::Swift:
207 // Prints up to 12 characters, then a \0 terminator.
208 escaped_len = sprintf((char *)data, "\\u{%x}", codepoint);
209 break;
210 }
211 lldbassert(escaped_len > 0 && "unknown string escape style");
212 return {data, escaped_len};
213 }
214
215 // Given a sequence of bytes, this function returns: a sequence of bytes to
216 // actually print out + a length the following unscanned position of the buffer
217 // is in next
GetPrintable(StringElementType type,uint8_t * buffer,uint8_t * buffer_end,uint8_t * & next,StringPrinter::EscapeStyle escape_style)218 static DecodedCharBuffer GetPrintable(StringElementType type, uint8_t *buffer,
219 uint8_t *buffer_end, uint8_t *&next,
220 StringPrinter::EscapeStyle escape_style) {
221 if (!buffer || buffer >= buffer_end)
222 return {nullptr};
223
224 switch (type) {
225 case StringElementType::ASCII:
226 return GetPrintableImpl<StringElementType::ASCII>(buffer, buffer_end, next,
227 escape_style);
228 case StringElementType::UTF8:
229 return GetPrintableImpl<StringElementType::UTF8>(buffer, buffer_end, next,
230 escape_style);
231 default:
232 return {nullptr};
233 }
234 }
235
236 static EscapingHelper
GetDefaultEscapingHelper(GetPrintableElementType elem_type,StringPrinter::EscapeStyle escape_style)237 GetDefaultEscapingHelper(GetPrintableElementType elem_type,
238 StringPrinter::EscapeStyle escape_style) {
239 switch (elem_type) {
240 case GetPrintableElementType::UTF8:
241 case GetPrintableElementType::ASCII:
242 return [escape_style, elem_type](uint8_t *buffer, uint8_t *buffer_end,
243 uint8_t *&next) -> DecodedCharBuffer {
244 return GetPrintable(elem_type == GetPrintableElementType::UTF8
245 ? StringElementType::UTF8
246 : StringElementType::ASCII,
247 buffer, buffer_end, next, escape_style);
248 };
249 }
250 llvm_unreachable("bad element type");
251 }
252
253 /// Read a string encoded in accordance with \tparam SourceDataType from a
254 /// host-side LLDB buffer, then pretty-print it to a stream using \p style.
255 template <typename SourceDataType>
DumpEncodedBufferToStream(GetPrintableElementType style,llvm::ConversionResult (* ConvertFunction)(const SourceDataType **,const SourceDataType *,llvm::UTF8 **,llvm::UTF8 *,llvm::ConversionFlags),const StringPrinter::ReadBufferAndDumpToStreamOptions & dump_options)256 static bool DumpEncodedBufferToStream(
257 GetPrintableElementType style,
258 llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
259 const SourceDataType *,
260 llvm::UTF8 **, llvm::UTF8 *,
261 llvm::ConversionFlags),
262 const StringPrinter::ReadBufferAndDumpToStreamOptions &dump_options) {
263 assert(dump_options.GetStream() && "need a Stream to print the string to");
264 Stream &stream(*dump_options.GetStream());
265 if (dump_options.GetPrefixToken() != nullptr)
266 stream.Printf("%s", dump_options.GetPrefixToken());
267 if (dump_options.GetQuote() != 0)
268 stream.Printf("%c", dump_options.GetQuote());
269 auto data(dump_options.GetData());
270 auto source_size(dump_options.GetSourceSize());
271 if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd()) {
272 const int bufferSPSize = data.GetByteSize();
273 if (dump_options.GetSourceSize() == 0) {
274 const int origin_encoding = 8 * sizeof(SourceDataType);
275 source_size = bufferSPSize / (origin_encoding / 4);
276 }
277
278 const SourceDataType *data_ptr =
279 (const SourceDataType *)data.GetDataStart();
280 const SourceDataType *data_end_ptr = data_ptr + source_size;
281
282 const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator();
283
284 if (zero_is_terminator) {
285 while (data_ptr < data_end_ptr) {
286 if (!*data_ptr) {
287 data_end_ptr = data_ptr;
288 break;
289 }
290 data_ptr++;
291 }
292
293 data_ptr = (const SourceDataType *)data.GetDataStart();
294 }
295
296 lldb::DataBufferSP utf8_data_buffer_sp;
297 llvm::UTF8 *utf8_data_ptr = nullptr;
298 llvm::UTF8 *utf8_data_end_ptr = nullptr;
299
300 if (ConvertFunction) {
301 utf8_data_buffer_sp =
302 std::make_shared<DataBufferHeap>(4 * bufferSPSize, 0);
303 utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
304 utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
305 ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
306 utf8_data_end_ptr, llvm::lenientConversion);
307 if (!zero_is_terminator)
308 utf8_data_end_ptr = utf8_data_ptr;
309 // needed because the ConvertFunction will change the value of the
310 // data_ptr.
311 utf8_data_ptr =
312 (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
313 } else {
314 // just copy the pointers - the cast is necessary to make the compiler
315 // happy but this should only happen if we are reading UTF8 data
316 utf8_data_ptr = const_cast<llvm::UTF8 *>(
317 reinterpret_cast<const llvm::UTF8 *>(data_ptr));
318 utf8_data_end_ptr = const_cast<llvm::UTF8 *>(
319 reinterpret_cast<const llvm::UTF8 *>(data_end_ptr));
320 }
321
322 const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
323 EscapingHelper escaping_callback;
324 if (escape_non_printables)
325 escaping_callback =
326 GetDefaultEscapingHelper(style, dump_options.GetEscapeStyle());
327
328 // since we tend to accept partial data (and even partially malformed data)
329 // we might end up with no NULL terminator before the end_ptr hence we need
330 // to take a slower route and ensure we stay within boundaries
331 for (; utf8_data_ptr < utf8_data_end_ptr;) {
332 if (zero_is_terminator && !*utf8_data_ptr)
333 break;
334
335 if (escape_non_printables) {
336 uint8_t *next_data = nullptr;
337 auto printable =
338 escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data);
339 auto printable_bytes = printable.GetBytes();
340 auto printable_size = printable.GetSize();
341
342 // We failed to figure out how to print this string.
343 if (!printable_bytes || !next_data)
344 return false;
345
346 for (unsigned c = 0; c < printable_size; c++)
347 stream.Printf("%c", *(printable_bytes + c));
348 utf8_data_ptr = (uint8_t *)next_data;
349 } else {
350 stream.Printf("%c", *utf8_data_ptr);
351 utf8_data_ptr++;
352 }
353 }
354 }
355 if (dump_options.GetQuote() != 0)
356 stream.Printf("%c", dump_options.GetQuote());
357 if (dump_options.GetSuffixToken() != nullptr)
358 stream.Printf("%s", dump_options.GetSuffixToken());
359 if (dump_options.GetIsTruncated())
360 stream.Printf("...");
361 return true;
362 }
363
364 lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions::
ReadStringAndDumpToStreamOptions(ValueObject & valobj)365 ReadStringAndDumpToStreamOptions(ValueObject &valobj)
366 : ReadStringAndDumpToStreamOptions() {
367 SetEscapeNonPrintables(
368 valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
369 }
370
371 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
ReadBufferAndDumpToStreamOptions(ValueObject & valobj)372 ReadBufferAndDumpToStreamOptions(ValueObject &valobj)
373 : ReadBufferAndDumpToStreamOptions() {
374 SetEscapeNonPrintables(
375 valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
376 }
377
378 lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
ReadBufferAndDumpToStreamOptions(const ReadStringAndDumpToStreamOptions & options)379 ReadBufferAndDumpToStreamOptions(
380 const ReadStringAndDumpToStreamOptions &options)
381 : ReadBufferAndDumpToStreamOptions() {
382 SetStream(options.GetStream());
383 SetPrefixToken(options.GetPrefixToken());
384 SetSuffixToken(options.GetSuffixToken());
385 SetQuote(options.GetQuote());
386 SetEscapeNonPrintables(options.GetEscapeNonPrintables());
387 SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
388 SetEscapeStyle(options.GetEscapeStyle());
389 }
390
391 namespace lldb_private {
392
393 namespace formatters {
394
395 template <typename SourceDataType>
ReadEncodedBufferAndDumpToStream(StringElementType elem_type,const StringPrinter::ReadStringAndDumpToStreamOptions & options,llvm::ConversionResult (* ConvertFunction)(const SourceDataType **,const SourceDataType *,llvm::UTF8 **,llvm::UTF8 *,llvm::ConversionFlags))396 static bool ReadEncodedBufferAndDumpToStream(
397 StringElementType elem_type,
398 const StringPrinter::ReadStringAndDumpToStreamOptions &options,
399 llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
400 const SourceDataType *,
401 llvm::UTF8 **, llvm::UTF8 *,
402 llvm::ConversionFlags)) {
403 assert(options.GetStream() && "need a Stream to print the string to");
404 if (!options.GetStream())
405 return false;
406
407 if (options.GetLocation() == 0 ||
408 options.GetLocation() == LLDB_INVALID_ADDRESS)
409 return false;
410
411 lldb::ProcessSP process_sp(options.GetProcessSP());
412 if (!process_sp)
413 return false;
414
415 constexpr int type_width = sizeof(SourceDataType);
416 constexpr int origin_encoding = 8 * type_width;
417 if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
418 return false;
419 // If not UTF8 or ASCII, conversion to UTF8 is necessary.
420 if (origin_encoding != 8 && !ConvertFunction)
421 return false;
422
423 bool needs_zero_terminator = options.GetNeedsZeroTermination();
424
425 bool is_truncated = false;
426 const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
427
428 uint32_t sourceSize;
429 if (elem_type == StringElementType::ASCII && !options.GetSourceSize()) {
430 // FIXME: The NSString formatter sets HasSourceSize(true) when the size is
431 // actually unknown, as well as SetBinaryZeroIsTerminator(false). IIUC the
432 // C++ formatter also sets SetBinaryZeroIsTerminator(false) when it doesn't
433 // mean to. I don't see how this makes sense: we should fix the formatters.
434 //
435 // Until then, the behavior that's expected for ASCII strings with unknown
436 // lengths is to read up to the max size and then null-terminate. Do that.
437 sourceSize = max_size;
438 needs_zero_terminator = true;
439 } else if (options.HasSourceSize()) {
440 sourceSize = options.GetSourceSize();
441 if (!options.GetIgnoreMaxLength()) {
442 if (sourceSize > max_size) {
443 sourceSize = max_size;
444 is_truncated = true;
445 }
446 }
447 } else {
448 sourceSize = max_size;
449 needs_zero_terminator = true;
450 }
451
452 const int bufferSPSize = sourceSize * type_width;
453 lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0));
454
455 // Check if we got bytes. We never get any bytes if we have an empty
456 // string, but we still continue so that we end up actually printing
457 // an empty string ("").
458 if (sourceSize != 0 && !buffer_sp->GetBytes())
459 return false;
460
461 Status error;
462 char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
463
464 if (elem_type == StringElementType::ASCII)
465 process_sp->ReadCStringFromMemory(options.GetLocation(), buffer,
466 bufferSPSize, error);
467 else if (needs_zero_terminator)
468 process_sp->ReadStringFromMemory(options.GetLocation(), buffer,
469 bufferSPSize, error, type_width);
470 else
471 process_sp->ReadMemoryFromInferior(options.GetLocation(), buffer,
472 bufferSPSize, error);
473 if (error.Fail()) {
474 options.GetStream()->Printf("unable to read data");
475 return true;
476 }
477
478 DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
479 process_sp->GetAddressByteSize());
480
481 StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options);
482 dump_options.SetData(data);
483 dump_options.SetSourceSize(sourceSize);
484 dump_options.SetIsTruncated(is_truncated);
485 dump_options.SetNeedsZeroTermination(needs_zero_terminator);
486 if (needs_zero_terminator)
487 dump_options.SetBinaryZeroIsTerminator(true);
488
489 GetPrintableElementType print_style = (elem_type == StringElementType::ASCII)
490 ? GetPrintableElementType::ASCII
491 : GetPrintableElementType::UTF8;
492 return DumpEncodedBufferToStream(print_style, ConvertFunction, dump_options);
493 }
494
495 template <>
ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions & options)496 bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF8>(
497 const ReadStringAndDumpToStreamOptions &options) {
498 return ReadEncodedBufferAndDumpToStream<llvm::UTF8>(StringElementType::UTF8,
499 options, nullptr);
500 }
501
502 template <>
ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions & options)503 bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF16>(
504 const ReadStringAndDumpToStreamOptions &options) {
505 return ReadEncodedBufferAndDumpToStream<llvm::UTF16>(
506 StringElementType::UTF16, options, llvm::ConvertUTF16toUTF8);
507 }
508
509 template <>
ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions & options)510 bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF32>(
511 const ReadStringAndDumpToStreamOptions &options) {
512 return ReadEncodedBufferAndDumpToStream<llvm::UTF32>(
513 StringElementType::UTF32, options, llvm::ConvertUTF32toUTF8);
514 }
515
516 template <>
ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions & options)517 bool StringPrinter::ReadStringAndDumpToStream<StringElementType::ASCII>(
518 const ReadStringAndDumpToStreamOptions &options) {
519 return ReadEncodedBufferAndDumpToStream<char>(StringElementType::ASCII,
520 options, nullptr);
521 }
522
523 template <>
ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions & options)524 bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF8>(
525 const ReadBufferAndDumpToStreamOptions &options) {
526 return DumpEncodedBufferToStream<llvm::UTF8>(GetPrintableElementType::UTF8,
527 nullptr, options);
528 }
529
530 template <>
ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions & options)531 bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF16>(
532 const ReadBufferAndDumpToStreamOptions &options) {
533 return DumpEncodedBufferToStream(GetPrintableElementType::UTF8,
534 llvm::ConvertUTF16toUTF8, options);
535 }
536
537 template <>
ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions & options)538 bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF32>(
539 const ReadBufferAndDumpToStreamOptions &options) {
540 return DumpEncodedBufferToStream(GetPrintableElementType::UTF8,
541 llvm::ConvertUTF32toUTF8, options);
542 }
543
544 template <>
ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions & options)545 bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::ASCII>(
546 const ReadBufferAndDumpToStreamOptions &options) {
547 // Treat ASCII the same as UTF8.
548 //
549 // FIXME: This is probably not the right thing to do (well, it's debatable).
550 // If an ASCII-encoded string happens to contain a sequence of invalid bytes
551 // that forms a valid UTF8 character, we'll print out that character. This is
552 // good if you're playing fast and loose with encodings (probably good for
553 // std::string users), but maybe not so good if you care about your string
554 // formatter respecting the semantics of your selected string encoding. In
555 // the latter case you'd want to see the character byte sequence ('\x..'), not
556 // the UTF8 character itself.
557 return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
558 }
559
560 } // namespace formatters
561
562 } // namespace lldb_private
563