summaryrefslogtreecommitdiff
path: root/source/Utility/Stream.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/Utility/Stream.cpp')
-rw-r--r--source/Utility/Stream.cpp111
1 files changed, 22 insertions, 89 deletions
diff --git a/source/Utility/Stream.cpp b/source/Utility/Stream.cpp
index 54691c7066db..c48a12acd906 100644
--- a/source/Utility/Stream.cpp
+++ b/source/Utility/Stream.cpp
@@ -1,9 +1,8 @@
//===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
@@ -30,9 +29,7 @@ Stream::Stream()
: m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
m_indent_level(0), m_forwarder(*this) {}
-//------------------------------------------------------------------
// Destructor
-//------------------------------------------------------------------
Stream::~Stream() {}
ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
@@ -41,14 +38,10 @@ ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
return old_byte_order;
}
-//------------------------------------------------------------------
// Put an offset "uval" out to the stream using the printf format in "format".
-//------------------------------------------------------------------
void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); }
-//------------------------------------------------------------------
// Put an SLEB128 "uval" out to the stream using the printf format in "format".
-//------------------------------------------------------------------
size_t Stream::PutSLEB128(int64_t sval) {
if (m_flags.Test(eBinary))
return llvm::encodeSLEB128(sval, m_forwarder);
@@ -56,9 +49,7 @@ size_t Stream::PutSLEB128(int64_t sval) {
return Printf("0x%" PRIi64, sval);
}
-//------------------------------------------------------------------
// Put an ULEB128 "uval" out to the stream using the printf format in "format".
-//------------------------------------------------------------------
size_t Stream::PutULEB128(uint64_t uval) {
if (m_flags.Test(eBinary))
return llvm::encodeULEB128(uval, m_forwarder);
@@ -66,9 +57,7 @@ size_t Stream::PutULEB128(uint64_t uval) {
return Printf("0x%" PRIx64, uval);
}
-//------------------------------------------------------------------
// Print a raw NULL terminated C string to the stream.
-//------------------------------------------------------------------
size_t Stream::PutCString(llvm::StringRef str) {
size_t bytes_written = 0;
bytes_written = Write(str.data(), str.size());
@@ -79,18 +68,14 @@ size_t Stream::PutCString(llvm::StringRef str) {
return bytes_written;
}
-//------------------------------------------------------------------
// Print a double quoted NULL terminated C string to the stream using the
// printf format in "format".
-//------------------------------------------------------------------
void Stream::QuotedCString(const char *cstr, const char *format) {
Printf(format, cstr);
}
-//------------------------------------------------------------------
// Put an address "addr" out to the stream with optional prefix and suffix
// strings.
-//------------------------------------------------------------------
void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
const char *suffix) {
if (prefix == nullptr)
@@ -99,13 +84,11 @@ void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
suffix = "";
// int addr_width = m_addr_size << 1;
// Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
- Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, (uint64_t)addr, suffix);
+ Printf("%s0x%0*" PRIx64 "%s", prefix, addr_size * 2, addr, suffix);
}
-//------------------------------------------------------------------
// Put an address range out to the stream with optional prefix and suffix
// strings.
-//------------------------------------------------------------------
void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
uint32_t addr_size, const char *prefix,
const char *suffix) {
@@ -119,9 +102,7 @@ void Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr,
size_t Stream::PutChar(char ch) { return Write(&ch, 1); }
-//------------------------------------------------------------------
// Print some formatted output to the stream.
-//------------------------------------------------------------------
size_t Stream::Printf(const char *format, ...) {
va_list args;
va_start(args, format);
@@ -130,9 +111,7 @@ size_t Stream::Printf(const char *format, ...) {
return result;
}
-//------------------------------------------------------------------
// Print some formatted output to the stream.
-//------------------------------------------------------------------
size_t Stream::PrintfVarArg(const char *format, va_list args) {
llvm::SmallString<1024> buf;
VASprintf(buf, format, args);
@@ -144,15 +123,11 @@ size_t Stream::PrintfVarArg(const char *format, va_list args) {
return Write(buf.c_str(), length);
}
-//------------------------------------------------------------------
// Print and End of Line character to the stream
-//------------------------------------------------------------------
size_t Stream::EOL() { return PutChar('\n'); }
-//------------------------------------------------------------------
// Indent the current line using the current indentation level and print an
// optional string following the indentation spaces.
-//------------------------------------------------------------------
size_t Stream::Indent(const char *s) {
return Printf("%*.*s%s", m_indent_level, m_indent_level, "", s ? s : "");
}
@@ -162,17 +137,13 @@ size_t Stream::Indent(llvm::StringRef str) {
str.str().c_str());
}
-//------------------------------------------------------------------
// Stream a character "ch" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(char ch) {
PutChar(ch);
return *this;
}
-//------------------------------------------------------------------
// Stream the NULL terminated C string out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(const char *s) {
Printf("%s", s);
return *this;
@@ -183,96 +154,70 @@ Stream &Stream::operator<<(llvm::StringRef str) {
return *this;
}
-//------------------------------------------------------------------
// Stream the pointer value out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(const void *p) {
- Printf("0x%.*tx", (int)sizeof(const void *) * 2, (ptrdiff_t)p);
+ Printf("0x%.*tx", static_cast<int>(sizeof(const void *)) * 2, (ptrdiff_t)p);
return *this;
}
-//------------------------------------------------------------------
// Stream a uint8_t "uval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(uint8_t uval) {
PutHex8(uval);
return *this;
}
-//------------------------------------------------------------------
// Stream a uint16_t "uval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(uint16_t uval) {
PutHex16(uval, m_byte_order);
return *this;
}
-//------------------------------------------------------------------
// Stream a uint32_t "uval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(uint32_t uval) {
PutHex32(uval, m_byte_order);
return *this;
}
-//------------------------------------------------------------------
// Stream a uint64_t "uval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(uint64_t uval) {
PutHex64(uval, m_byte_order);
return *this;
}
-//------------------------------------------------------------------
// Stream a int8_t "sval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(int8_t sval) {
- Printf("%i", (int)sval);
+ Printf("%i", static_cast<int>(sval));
return *this;
}
-//------------------------------------------------------------------
// Stream a int16_t "sval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(int16_t sval) {
- Printf("%i", (int)sval);
+ Printf("%i", static_cast<int>(sval));
return *this;
}
-//------------------------------------------------------------------
// Stream a int32_t "sval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(int32_t sval) {
- Printf("%i", (int)sval);
+ Printf("%i", static_cast<int>(sval));
return *this;
}
-//------------------------------------------------------------------
// Stream a int64_t "sval" out to this stream.
-//------------------------------------------------------------------
Stream &Stream::operator<<(int64_t sval) {
Printf("%" PRIi64, sval);
return *this;
}
-//------------------------------------------------------------------
// Get the current indentation level
-//------------------------------------------------------------------
int Stream::GetIndentLevel() const { return m_indent_level; }
-//------------------------------------------------------------------
// Set the current indentation level
-//------------------------------------------------------------------
void Stream::SetIndentLevel(int indent_level) { m_indent_level = indent_level; }
-//------------------------------------------------------------------
// Increment the current indentation level
-//------------------------------------------------------------------
void Stream::IndentMore(int amount) { m_indent_level += amount; }
-//------------------------------------------------------------------
// Decrement the current indentation level
-//------------------------------------------------------------------
void Stream::IndentLess(int amount) {
if (m_indent_level >= amount)
m_indent_level -= amount;
@@ -280,29 +225,19 @@ void Stream::IndentLess(int amount) {
m_indent_level = 0;
}
-//------------------------------------------------------------------
// Get the address size in bytes
-//------------------------------------------------------------------
uint32_t Stream::GetAddressByteSize() const { return m_addr_size; }
-//------------------------------------------------------------------
// Set the address size in bytes
-//------------------------------------------------------------------
void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; }
-//------------------------------------------------------------------
// The flags get accessor
-//------------------------------------------------------------------
Flags &Stream::GetFlags() { return m_flags; }
-//------------------------------------------------------------------
// The flags const get accessor
-//------------------------------------------------------------------
const Flags &Stream::GetFlags() const { return m_flags; }
-//------------------------------------------------------------------
// The byte order get accessor
-//------------------------------------------------------------------
lldb::ByteOrder Stream::GetByteOrder() const { return m_byte_order; }
@@ -360,10 +295,10 @@ size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
}
return *delta;
}
@@ -376,10 +311,10 @@ size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
}
return *delta;
}
@@ -392,10 +327,10 @@ size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8(static_cast<uint8_t>(uvalue >> (byte * 8)), false);
}
return *delta;
}
@@ -404,11 +339,11 @@ size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
lldb::ByteOrder byte_order) {
switch (byte_size) {
case 1:
- return PutHex8((uint8_t)uvalue);
+ return PutHex8(static_cast<uint8_t>(uvalue));
case 2:
- return PutHex16((uint16_t)uvalue, byte_order);
+ return PutHex16(static_cast<uint16_t>(uvalue), byte_order);
case 4:
- return PutHex32((uint32_t)uvalue, byte_order);
+ return PutHex32(static_cast<uint32_t>(uvalue), byte_order);
case 8:
return PutHex64(uvalue, byte_order);
}
@@ -451,7 +386,7 @@ size_t Stream::PutRawBytes(const void *s, size_t src_len,
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
- const uint8_t *src = (const uint8_t *)s;
+ const uint8_t *src = static_cast<const uint8_t *>(s);
bool binary_was_set = m_flags.Test(eBinary);
if (!binary_was_set)
m_flags.Set(eBinary);
@@ -478,7 +413,7 @@ size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
- const uint8_t *src = (const uint8_t *)s;
+ const uint8_t *src = static_cast<const uint8_t *>(s);
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
if (src_byte_order == dst_byte_order) {
@@ -494,14 +429,12 @@ size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
return *delta;
}
-size_t Stream::PutCStringAsRawHex8(const char *s) {
+size_t Stream::PutStringAsRawHex8(llvm::StringRef s) {
ByteDelta delta(*this);
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
- while(*s) {
- _PutHex8(*s, false);
- ++s;
- }
+ for (char c : s)
+ _PutHex8(c, false);
if (binary_is_set)
m_flags.Set(eBinary);
return *delta;
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-05 20:57:39 +0000