1 //===-- TypeFormat.h ----------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef lldb_TypeFormat_h_ 11 #define lldb_TypeFormat_h_ 12 13 // C Includes 14 15 // C++ Includes 16 #include <string> 17 18 // Other libraries and framework includes 19 20 // Project includes 21 #include "lldb/lldb-public.h" 22 #include "lldb/lldb-enumerations.h" 23 24 #include "lldb/Core/ValueObject.h" 25 26 namespace lldb_private { 27 class TypeFormatImpl 28 { 29 public: 30 class Flags 31 { 32 public: 33 Flags()34 Flags () : 35 m_flags (lldb::eTypeOptionCascade) 36 {} 37 Flags(const Flags & other)38 Flags (const Flags& other) : 39 m_flags (other.m_flags) 40 {} 41 Flags(uint32_t value)42 Flags (uint32_t value) : 43 m_flags (value) 44 {} 45 46 Flags& 47 operator = (const Flags& rhs) 48 { 49 if (&rhs != this) 50 m_flags = rhs.m_flags; 51 52 return *this; 53 } 54 55 Flags& 56 operator = (const uint32_t& rhs) 57 { 58 m_flags = rhs; 59 return *this; 60 } 61 62 Flags& Clear()63 Clear() 64 { 65 m_flags = 0; 66 return *this; 67 } 68 69 bool GetCascades()70 GetCascades () const 71 { 72 return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade; 73 } 74 75 Flags& 76 SetCascades (bool value = true) 77 { 78 if (value) 79 m_flags |= lldb::eTypeOptionCascade; 80 else 81 m_flags &= ~lldb::eTypeOptionCascade; 82 return *this; 83 } 84 85 bool GetSkipPointers()86 GetSkipPointers () const 87 { 88 return (m_flags & lldb::eTypeOptionSkipPointers) == lldb::eTypeOptionSkipPointers; 89 } 90 91 Flags& 92 SetSkipPointers (bool value = true) 93 { 94 if (value) 95 m_flags |= lldb::eTypeOptionSkipPointers; 96 else 97 m_flags &= ~lldb::eTypeOptionSkipPointers; 98 return *this; 99 } 100 101 bool GetSkipReferences()102 GetSkipReferences () const 103 { 104 return (m_flags & lldb::eTypeOptionSkipReferences) == lldb::eTypeOptionSkipReferences; 105 } 106 107 Flags& 108 SetSkipReferences (bool value = true) 109 { 110 if (value) 111 m_flags |= lldb::eTypeOptionSkipReferences; 112 else 113 m_flags &= ~lldb::eTypeOptionSkipReferences; 114 return *this; 115 } 116 117 uint32_t GetValue()118 GetValue () 119 { 120 return m_flags; 121 } 122 123 void SetValue(uint32_t value)124 SetValue (uint32_t value) 125 { 126 m_flags = value; 127 } 128 129 private: 130 uint32_t m_flags; 131 }; 132 133 TypeFormatImpl (const Flags& flags = Flags()); 134 135 typedef std::shared_ptr<TypeFormatImpl> SharedPointer; 136 typedef bool(*ValueCallback)(void*, ConstString, const lldb::TypeFormatImplSP&); 137 138 virtual ~TypeFormatImpl () = default; 139 140 bool Cascades()141 Cascades () const 142 { 143 return m_flags.GetCascades(); 144 } 145 bool SkipsPointers()146 SkipsPointers () const 147 { 148 return m_flags.GetSkipPointers(); 149 } 150 bool SkipsReferences()151 SkipsReferences () const 152 { 153 return m_flags.GetSkipReferences(); 154 } 155 156 void SetCascades(bool value)157 SetCascades (bool value) 158 { 159 m_flags.SetCascades(value); 160 } 161 162 void SetSkipsPointers(bool value)163 SetSkipsPointers (bool value) 164 { 165 m_flags.SetSkipPointers(value); 166 } 167 168 void SetSkipsReferences(bool value)169 SetSkipsReferences (bool value) 170 { 171 m_flags.SetSkipReferences(value); 172 } 173 174 uint32_t GetOptions()175 GetOptions () 176 { 177 return m_flags.GetValue(); 178 } 179 180 void SetOptions(uint32_t value)181 SetOptions (uint32_t value) 182 { 183 m_flags.SetValue(value); 184 } 185 186 uint32_t& GetRevision()187 GetRevision () 188 { 189 return m_my_revision; 190 } 191 192 enum class Type 193 { 194 eTypeUnknown, 195 eTypeFormat, 196 eTypeEnum 197 }; 198 199 virtual Type GetType()200 GetType () 201 { 202 return Type::eTypeUnknown; 203 } 204 205 // we are using a ValueObject* instead of a ValueObjectSP because we do not need to hold on to this for 206 // extended periods of time and we trust the ValueObject to stay around for as long as it is required 207 // for us to generate its value 208 virtual bool 209 FormatObject (ValueObject *valobj, 210 std::string& dest) const = 0; 211 212 virtual std::string 213 GetDescription() = 0; 214 215 protected: 216 Flags m_flags; 217 uint32_t m_my_revision; 218 219 private: 220 DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl); 221 }; 222 223 class TypeFormatImpl_Format : public TypeFormatImpl 224 { 225 public: 226 TypeFormatImpl_Format (lldb::Format f = lldb::eFormatInvalid, 227 const TypeFormatImpl::Flags& flags = Flags()); 228 229 typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer; 230 typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_Format::SharedPointer&); 231 232 virtual ~TypeFormatImpl_Format () = default; 233 234 lldb::Format GetFormat()235 GetFormat () const 236 { 237 return m_format; 238 } 239 240 void SetFormat(lldb::Format fmt)241 SetFormat (lldb::Format fmt) 242 { 243 m_format = fmt; 244 } 245 246 virtual TypeFormatImpl::Type GetType()247 GetType () 248 { 249 return TypeFormatImpl::Type::eTypeFormat; 250 } 251 252 virtual bool 253 FormatObject (ValueObject *valobj, 254 std::string& dest) const; 255 256 virtual std::string 257 GetDescription(); 258 259 protected: 260 lldb::Format m_format; 261 262 private: 263 DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format); 264 }; 265 266 class TypeFormatImpl_EnumType : public TypeFormatImpl 267 { 268 public: 269 TypeFormatImpl_EnumType (ConstString type_name = ConstString(""), 270 const TypeFormatImpl::Flags& flags = Flags()); 271 272 typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer; 273 typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_EnumType::SharedPointer&); 274 275 ~TypeFormatImpl_EnumType () = default; 276 277 ConstString GetTypeName()278 GetTypeName () 279 { 280 return m_enum_type; 281 } 282 283 void SetTypeName(ConstString enum_type)284 SetTypeName (ConstString enum_type) 285 { 286 m_enum_type = enum_type; 287 } 288 289 virtual TypeFormatImpl::Type GetType()290 GetType () 291 { 292 return TypeFormatImpl::Type::eTypeEnum; 293 } 294 295 virtual bool 296 FormatObject (ValueObject *valobj, 297 std::string& dest) const; 298 299 virtual std::string 300 GetDescription(); 301 302 protected: 303 ConstString m_enum_type; 304 mutable std::map<void*,ClangASTType> m_types; 305 306 private: 307 DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType); 308 }; 309 } // namespace lldb_private 310 311 #endif // lldb_TypeFormat_h_ 312