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