1 //===-- SBVariablesOptions.cpp --------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/API/SBVariablesOptions.h" 10 #include "lldb/API/SBTarget.h" 11 #include "lldb/Target/Target.h" 12 #include "lldb/Utility/Instrumentation.h" 13 14 #include "lldb/lldb-private.h" 15 16 using namespace lldb; 17 using namespace lldb_private; 18 19 class VariablesOptionsImpl { 20 public: 21 VariablesOptionsImpl() 22 : m_include_arguments(false), m_include_locals(false), 23 m_include_statics(false), m_in_scope_only(false), 24 m_include_runtime_support_values(false) {} 25 26 VariablesOptionsImpl(const VariablesOptionsImpl &) = default; 27 28 ~VariablesOptionsImpl() = default; 29 30 VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default; 31 32 bool GetIncludeArguments() const { return m_include_arguments; } 33 34 void SetIncludeArguments(bool b) { m_include_arguments = b; } 35 36 bool GetIncludeRecognizedArguments(const lldb::TargetSP &target_sp) const { 37 if (m_include_recognized_arguments != eLazyBoolCalculate) 38 return m_include_recognized_arguments; 39 return target_sp ? target_sp->GetDisplayRecognizedArguments() : false; 40 } 41 42 void SetIncludeRecognizedArguments(bool b) { 43 m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo; 44 } 45 46 bool GetIncludeLocals() const { return m_include_locals; } 47 48 void SetIncludeLocals(bool b) { m_include_locals = b; } 49 50 bool GetIncludeStatics() const { return m_include_statics; } 51 52 void SetIncludeStatics(bool b) { m_include_statics = b; } 53 54 bool GetInScopeOnly() const { return m_in_scope_only; } 55 56 void SetInScopeOnly(bool b) { m_in_scope_only = b; } 57 58 bool GetIncludeRuntimeSupportValues() const { 59 return m_include_runtime_support_values; 60 } 61 62 void SetIncludeRuntimeSupportValues(bool b) { 63 m_include_runtime_support_values = b; 64 } 65 66 lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; } 67 68 void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; } 69 70 private: 71 bool m_include_arguments : 1; 72 bool m_include_locals : 1; 73 bool m_include_statics : 1; 74 bool m_in_scope_only : 1; 75 bool m_include_runtime_support_values : 1; 76 LazyBool m_include_recognized_arguments = 77 eLazyBoolCalculate; // can be overridden with a setting 78 lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues; 79 }; 80 81 SBVariablesOptions::SBVariablesOptions() 82 : m_opaque_up(new VariablesOptionsImpl()) { 83 LLDB_INSTRUMENT_VA(this); 84 } 85 86 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) 87 : m_opaque_up(new VariablesOptionsImpl(options.ref())) { 88 LLDB_INSTRUMENT_VA(this, options); 89 } 90 91 SBVariablesOptions &SBVariablesOptions:: 92 operator=(const SBVariablesOptions &options) { 93 LLDB_INSTRUMENT_VA(this, options); 94 95 m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref()); 96 return *this; 97 } 98 99 SBVariablesOptions::~SBVariablesOptions() = default; 100 101 bool SBVariablesOptions::IsValid() const { 102 LLDB_INSTRUMENT_VA(this); 103 return this->operator bool(); 104 } 105 SBVariablesOptions::operator bool() const { 106 LLDB_INSTRUMENT_VA(this); 107 108 return m_opaque_up != nullptr; 109 } 110 111 bool SBVariablesOptions::GetIncludeArguments() const { 112 LLDB_INSTRUMENT_VA(this); 113 114 return m_opaque_up->GetIncludeArguments(); 115 } 116 117 void SBVariablesOptions::SetIncludeArguments(bool arguments) { 118 LLDB_INSTRUMENT_VA(this, arguments); 119 120 m_opaque_up->SetIncludeArguments(arguments); 121 } 122 123 bool SBVariablesOptions::GetIncludeRecognizedArguments( 124 const lldb::SBTarget &target) const { 125 LLDB_INSTRUMENT_VA(this, target); 126 127 return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP()); 128 } 129 130 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { 131 LLDB_INSTRUMENT_VA(this, arguments); 132 133 m_opaque_up->SetIncludeRecognizedArguments(arguments); 134 } 135 136 bool SBVariablesOptions::GetIncludeLocals() const { 137 LLDB_INSTRUMENT_VA(this); 138 139 return m_opaque_up->GetIncludeLocals(); 140 } 141 142 void SBVariablesOptions::SetIncludeLocals(bool locals) { 143 LLDB_INSTRUMENT_VA(this, locals); 144 145 m_opaque_up->SetIncludeLocals(locals); 146 } 147 148 bool SBVariablesOptions::GetIncludeStatics() const { 149 LLDB_INSTRUMENT_VA(this); 150 151 return m_opaque_up->GetIncludeStatics(); 152 } 153 154 void SBVariablesOptions::SetIncludeStatics(bool statics) { 155 LLDB_INSTRUMENT_VA(this, statics); 156 157 m_opaque_up->SetIncludeStatics(statics); 158 } 159 160 bool SBVariablesOptions::GetInScopeOnly() const { 161 LLDB_INSTRUMENT_VA(this); 162 163 return m_opaque_up->GetInScopeOnly(); 164 } 165 166 void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { 167 LLDB_INSTRUMENT_VA(this, in_scope_only); 168 169 m_opaque_up->SetInScopeOnly(in_scope_only); 170 } 171 172 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { 173 LLDB_INSTRUMENT_VA(this); 174 175 return m_opaque_up->GetIncludeRuntimeSupportValues(); 176 } 177 178 void SBVariablesOptions::SetIncludeRuntimeSupportValues( 179 bool runtime_support_values) { 180 LLDB_INSTRUMENT_VA(this, runtime_support_values); 181 182 m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values); 183 } 184 185 lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { 186 LLDB_INSTRUMENT_VA(this); 187 188 return m_opaque_up->GetUseDynamic(); 189 } 190 191 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { 192 LLDB_INSTRUMENT_VA(this, dynamic); 193 194 m_opaque_up->SetUseDynamic(dynamic); 195 } 196 197 VariablesOptionsImpl *SBVariablesOptions::operator->() { 198 return m_opaque_up.operator->(); 199 } 200 201 const VariablesOptionsImpl *SBVariablesOptions::operator->() const { 202 return m_opaque_up.operator->(); 203 } 204 205 VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); } 206 207 VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; } 208 209 const VariablesOptionsImpl &SBVariablesOptions::ref() const { 210 return *m_opaque_up; 211 } 212 213 SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr) 214 : m_opaque_up(std::move(lldb_object_ptr)) {} 215 216 void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) { 217 m_opaque_up.reset(std::move(lldb_object_ptr)); 218 } 219