File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/include/lldb/DataFormatters

usr / src / contrib / llvm-project / lldb / include / lldb / DataFormatters /

📁 ..
📄 CXXFunctionPointer.h(806 B)
📄 DataVisualization.h(3.96 KB)
📄 DumpValueObjectOptions.h(4.82 KB)
📄 FormatCache.h(1.95 KB)
📄 FormatClasses.h(4.7 KB)
📄 FormatManager.h(8.16 KB)
📄 FormattersContainer.h(9.77 KB)
📄 FormattersHelpers.h(5.69 KB)
📄 LanguageCategory.h(1.59 KB)
📄 StringPrinter.h(5.01 KB)
📄 TypeCategory.h(12.06 KB)
📄 TypeCategoryMap.h(3 KB)
📄 TypeFormat.h(5.87 KB)
📄 TypeSummary.h(10.88 KB)
📄 TypeSynthetic.h(13.9 KB)
📄 ValueObjectPrinter.h(4.29 KB)
📄 VectorIterator.h(1.3 KB)
📄 VectorType.h(849 B)

Editing: TypeFormat.h

//===-- TypeFormat.h ----------------------------------------------*- C++
//-*-===//
//
// 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
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H
#define LLDB_DATAFORMATTERS_TYPEFORMAT_H

#include <functional>
#include <string>
#include <unordered_map>

#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-public.h"

#include "lldb/Core/ValueObject.h"

namespace lldb_private {
class TypeFormatImpl {
public:
  class Flags {
  public:
    Flags() : m_flags(lldb::eTypeOptionCascade) {}

Flags(const Flags &other) : m_flags(other.m_flags) {}

Flags(uint32_t value) : m_flags(value) {}

Flags &operator=(const Flags &rhs) {
      if (&rhs != this)
        m_flags = rhs.m_flags;

return *this;
    }

Flags &operator=(const uint32_t &rhs) {
      m_flags = rhs;
      return *this;
    }

Flags &Clear() {
      m_flags = 0;
      return *this;
    }

bool GetCascades() const {
      return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade;
    }

Flags &SetCascades(bool value = true) {
      if (value)
        m_flags |= lldb::eTypeOptionCascade;
      else
        m_flags &= ~lldb::eTypeOptionCascade;
      return *this;
    }

bool GetSkipPointers() const {
      return (m_flags & lldb::eTypeOptionSkipPointers) ==
             lldb::eTypeOptionSkipPointers;
    }

Flags &SetSkipPointers(bool value = true) {
      if (value)
        m_flags |= lldb::eTypeOptionSkipPointers;
      else
        m_flags &= ~lldb::eTypeOptionSkipPointers;
      return *this;
    }

bool GetSkipReferences() const {
      return (m_flags & lldb::eTypeOptionSkipReferences) ==
             lldb::eTypeOptionSkipReferences;
    }

Flags &SetSkipReferences(bool value = true) {
      if (value)
        m_flags |= lldb::eTypeOptionSkipReferences;
      else
        m_flags &= ~lldb::eTypeOptionSkipReferences;
      return *this;
    }

bool GetNonCacheable() const {
      return (m_flags & lldb::eTypeOptionNonCacheable) ==
             lldb::eTypeOptionNonCacheable;
    }

Flags &SetNonCacheable(bool value = true) {
      if (value)
        m_flags |= lldb::eTypeOptionNonCacheable;
      else
        m_flags &= ~lldb::eTypeOptionNonCacheable;
      return *this;
    }

uint32_t GetValue() { return m_flags; }

void SetValue(uint32_t value) { m_flags = value; }

private:
    uint32_t m_flags;
  };

TypeFormatImpl(const Flags &flags = Flags());

typedef std::shared_ptr<TypeFormatImpl> SharedPointer;

virtual ~TypeFormatImpl();

bool Cascades() const { return m_flags.GetCascades(); }

bool SkipsPointers() const { return m_flags.GetSkipPointers(); }

bool SkipsReferences() const { return m_flags.GetSkipReferences(); }

bool NonCacheable() const { return m_flags.GetNonCacheable(); }

void SetCascades(bool value) { m_flags.SetCascades(value); }

void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }

void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }

void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }

uint32_t GetOptions() { return m_flags.GetValue(); }

void SetOptions(uint32_t value) { m_flags.SetValue(value); }

uint32_t &GetRevision() { return m_my_revision; }

enum class Type { eTypeUnknown, eTypeFormat, eTypeEnum };

virtual Type GetType() { return Type::eTypeUnknown; }

// we are using a ValueObject* instead of a ValueObjectSP because we do not
  // need to hold on to this for extended periods of time and we trust the
  // ValueObject to stay around for as long as it is required for us to
  // generate its value
  virtual bool FormatObject(ValueObject *valobj, std::string &dest) const = 0;

virtual std::string GetDescription() = 0;

protected:
  Flags m_flags;
  uint32_t m_my_revision;

private:
  TypeFormatImpl(const TypeFormatImpl &) = delete;
  const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
};

class TypeFormatImpl_Format : public TypeFormatImpl {
public:
  TypeFormatImpl_Format(lldb::Format f = lldb::eFormatInvalid,
                        const TypeFormatImpl::Flags &flags = Flags());

typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;

~TypeFormatImpl_Format() override;

lldb::Format GetFormat() const { return m_format; }

void SetFormat(lldb::Format fmt) { m_format = fmt; }

TypeFormatImpl::Type GetType() override {
    return TypeFormatImpl::Type::eTypeFormat;
  }

bool FormatObject(ValueObject *valobj, std::string &dest) const override;

std::string GetDescription() override;

protected:
  lldb::Format m_format;

private:
  TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete;
  const TypeFormatImpl_Format &
  operator=(const TypeFormatImpl_Format &) = delete;
};

class TypeFormatImpl_EnumType : public TypeFormatImpl {
public:
  TypeFormatImpl_EnumType(ConstString type_name = ConstString(""),
                          const TypeFormatImpl::Flags &flags = Flags());

typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;

~TypeFormatImpl_EnumType() override;

ConstString GetTypeName() { return m_enum_type; }

void SetTypeName(ConstString enum_type) { m_enum_type = enum_type; }

TypeFormatImpl::Type GetType() override {
    return TypeFormatImpl::Type::eTypeEnum;
  }

bool FormatObject(ValueObject *valobj, std::string &dest) const override;

std::string GetDescription() override;

protected:
  ConstString m_enum_type;
  mutable std::unordered_map<void *, CompilerType> m_types;

private:
  TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete;
  const TypeFormatImpl_EnumType &
  operator=(const TypeFormatImpl_EnumType &) = delete;
};
} // namespace lldb_private

#endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H

003 File Manager

Editing: TypeFormat.h

Upload File

Create Folder