llvm/lldb/source/Utility/ConstString.cpp

//===-- ConstString.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/ConstString.h"

#include "lldb/Utility/Stream.h"

#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/iterator.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/DJB.h"
#include "llvm/Support/FormatProviders.h"
#include "llvm/Support/RWMutex.h"
#include "llvm/Support/Threading.h"

#include <array>
#include <utility>

#include <cinttypes>
#include <cstdint>
#include <cstring>

usingnamespacelldb_private;

class Pool { … };

// Frameworks and dylibs aren't supposed to have global C++ initializers so we
// hide the string pool in a static function so that it will get initialized on
// the first call to this static function.
//
// Note, for now we make the string pool a pointer to the pool, because we
// can't guarantee that some objects won't get destroyed after the global
// destructor chain is run, and trying to make sure no destructors touch
// ConstStrings is difficult.  So we leak the pool instead.
static Pool &StringPool() { … }

ConstString::ConstString(const char *cstr)
    : … { … }

ConstString::ConstString(const char *cstr, size_t cstr_len)
    : … { … }

ConstString::ConstString(llvm::StringRef s)
    : … { … }

bool ConstString::operator<(ConstString rhs) const { … }

Stream &lldb_private::operator<<(Stream &s, ConstString str) { … }

size_t ConstString::GetLength() const { … }

bool ConstString::Equals(ConstString lhs, ConstString rhs,
                         const bool case_sensitive) { … }

int ConstString::Compare(ConstString lhs, ConstString rhs,
                         const bool case_sensitive) { … }

void ConstString::Dump(Stream *s, const char *fail_value) const { … }

void ConstString::DumpDebug(Stream *s) const { … }

void ConstString::SetCString(const char *cstr) { … }

void ConstString::SetString(llvm::StringRef s) { … }

void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled,
                                                  ConstString mangled) { … }

bool ConstString::GetMangledCounterpart(ConstString &counterpart) const { … }

void ConstString::SetCStringWithLength(const char *cstr, size_t cstr_len) { … }

void ConstString::SetTrimmedCStringWithLength(const char *cstr,
                                              size_t cstr_len) { … }

ConstString::MemoryStats ConstString::GetMemoryStats() { … }

void llvm::format_provider<ConstString>::format(const ConstString &CS,
                                                llvm::raw_ostream &OS,
                                                llvm::StringRef Options) { … }