llvm/lldb/source/Utility/Stream.cpp

//===-- Stream.cpp --------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "lldb/Utility/Stream.h"

#include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/VASPrintf.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/Regex.h"

#include <string>

#include <cinttypes>
#include <cstddef>

usingnamespacelldb;
usingnamespacelldb_private;

Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order,
               bool colors)
    : … { … }

Stream::Stream(bool colors)
    : … { … }

// Destructor
Stream::~Stream() = default;

ByteOrder Stream::SetByteOrder(ByteOrder 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) { … }

// Put an SLEB128 "uval" out to the stream using the printf format in "format".
size_t Stream::PutSLEB128(int64_t sval) { … }

// Put an ULEB128 "uval" out to the stream using the printf format in "format".
size_t Stream::PutULEB128(uint64_t uval) { … }

// Print a raw NULL terminated C string to the stream.
size_t Stream::PutCString(llvm::StringRef str) { … }

void Stream::PutCStringColorHighlighted(
    llvm::StringRef text, std::optional<HighlightSettings> pattern_info) { … }

// 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) { … }

// Put an address "addr" out to the stream with optional prefix and suffix
// strings.
void lldb_private::DumpAddress(llvm::raw_ostream &s, uint64_t addr,
                               uint32_t addr_size, const char *prefix,
                               const char *suffix) { … }

// Put an address range out to the stream with optional prefix and suffix
// strings.
void lldb_private::DumpAddressRange(llvm::raw_ostream &s, uint64_t lo_addr,
                                    uint64_t hi_addr, uint32_t addr_size,
                                    const char *prefix, const char *suffix) { … }

size_t Stream::PutChar(char ch) { … }

// Print some formatted output to the stream.
size_t Stream::Printf(const char *format, ...) { … }

// Print some formatted output to the stream.
size_t Stream::PrintfVarArg(const char *format, va_list args) { … }

// Print and End of Line character to the stream
size_t Stream::EOL() { … }

size_t Stream::Indent(llvm::StringRef str) { … }

// Stream a character "ch" out to this stream.
Stream &Stream::operator<<(char ch) { … }

// Stream the NULL terminated C string out to this stream.
Stream &Stream::operator<<(const char *s) { … }

Stream &Stream::operator<<(llvm::StringRef str) { … }

// Stream the pointer value out to this stream.
Stream &Stream::operator<<(const void *p) { … }

// Get the current indentation level
unsigned Stream::GetIndentLevel() const { … }

// Set the current indentation level
void Stream::SetIndentLevel(unsigned indent_level) { … }

// Increment the current indentation level
void Stream::IndentMore(unsigned amount) { … }

// Decrement the current indentation level
void Stream::IndentLess(unsigned amount) { … }

// Get the address size in bytes
uint32_t Stream::GetAddressByteSize() const { … }

// Set the address size in bytes
void Stream::SetAddressByteSize(uint32_t addr_size) { … }

// The flags get accessor
Flags &Stream::GetFlags() { … }

// The flags const get accessor
const Flags &Stream::GetFlags() const { … }

// The byte order get accessor

lldb::ByteOrder Stream::GetByteOrder() const { … }

size_t Stream::PrintfAsRawHex8(const char *format, ...) { … }

size_t Stream::PutNHex8(size_t n, uint8_t uvalue) { … }

void Stream::_PutHex8(uint8_t uvalue, bool add_prefix) { … }

size_t Stream::PutHex8(uint8_t uvalue) { … }

size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) { … }

size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) { … }

size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) { … }

size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
                           lldb::ByteOrder byte_order) { … }

size_t Stream::PutPointer(void *ptr) { … }

size_t Stream::PutFloat(float f, ByteOrder byte_order) { … }

size_t Stream::PutDouble(double d, ByteOrder byte_order) { … }

size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) { … }

size_t Stream::PutRawBytes(const void *s, size_t src_len,
                           ByteOrder src_byte_order, ByteOrder dst_byte_order) { … }

size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
                                 ByteOrder src_byte_order,
                                 ByteOrder dst_byte_order) { … }

size_t Stream::PutStringAsRawHex8(llvm::StringRef s) { … }