lldb/source/API/SBVariablesOptions.cpp

   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
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 class VariablesOptionsImpl {
  21 public:
  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
  73 private:
  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
  83 SBVariablesOptions::SBVariablesOptions()
  84     : m_opaque_up(new VariablesOptionsImpl()) {
  85   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
  86 }
  87
  88 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
  89     : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
  90   LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
  91                           (const lldb::SBVariablesOptions &), options);
  92 }
  93
  94 SBVariablesOptions &SBVariablesOptions::
  95 operator=(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
 105 SBVariablesOptions::~SBVariablesOptions() = default;
 106
 107 bool SBVariablesOptions::IsValid() const {
 108   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
 109   return this->operator bool();
 110 }
 111 SBVariablesOptions::operator bool() const {
 112   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
 113
 114   return m_opaque_up != nullptr;
 115 }
 116
 117 bool SBVariablesOptions::GetIncludeArguments() const {
 118   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
 119                                    GetIncludeArguments);
 120
 121   return m_opaque_up->GetIncludeArguments();
 122 }
 123
 124 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
 125   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
 126                      arguments);
 127
 128   m_opaque_up->SetIncludeArguments(arguments);
 129 }
 130
 131 bool 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
 140 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
 141   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
 142                      (bool), arguments);
 143
 144   m_opaque_up->SetIncludeRecognizedArguments(arguments);
 145 }
 146
 147 bool SBVariablesOptions::GetIncludeLocals() const {
 148   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
 149
 150   return m_opaque_up->GetIncludeLocals();
 151 }
 152
 153 void SBVariablesOptions::SetIncludeLocals(bool locals) {
 154   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
 155                      locals);
 156
 157   m_opaque_up->SetIncludeLocals(locals);
 158 }
 159
 160 bool SBVariablesOptions::GetIncludeStatics() const {
 161   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
 162
 163   return m_opaque_up->GetIncludeStatics();
 164 }
 165
 166 void SBVariablesOptions::SetIncludeStatics(bool statics) {
 167   LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
 168                      statics);
 169
 170   m_opaque_up->SetIncludeStatics(statics);
 171 }
 172
 173 bool SBVariablesOptions::GetInScopeOnly() const {
 174   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
 175
 176   return m_opaque_up->GetInScopeOnly();
 177 }
 178
 179 void 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
 186 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
 187   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
 188                                    GetIncludeRuntimeSupportValues);
 189
 190   return m_opaque_up->GetIncludeRuntimeSupportValues();
 191 }
 192
 193 void 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
 201 lldb::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
 208 void 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
 215 VariablesOptionsImpl *SBVariablesOptions::operator->() {
 216   return m_opaque_up.operator->();
 217 }
 218
 219 const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
 220   return m_opaque_up.operator->();
 221 }
 222
 223 VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }
 224
 225 VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; }
 226
 227 const VariablesOptionsImpl &SBVariablesOptions::ref() const {
 228   return *m_opaque_up;
 229 }
 230
 231 SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
 232     : m_opaque_up(std::move(lldb_object_ptr)) {}
 233
 234 void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
 235   m_opaque_up.reset(std::move(lldb_object_ptr));
 236 }
 237
 238 namespace lldb_private {
 239 namespace repro {
 240
 241 template <>
 242 void 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 }