1 files changed, 218 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp b/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp
new file mode 100644
index 000000000000..989d159139cc
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/API/SBVariablesOptions.cpp
@@ -0,0 +1,218 @@
+//===-- SBVariablesOptions.cpp --------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBVariablesOptions.h"
+#include "lldb/API/SBTarget.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/Instrumentation.h"
+
+#include "lldb/lldb-private.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+class VariablesOptionsImpl {
+public:
+  VariablesOptionsImpl()
+      : m_include_arguments(false), m_include_locals(false),
+        m_include_statics(false), m_in_scope_only(false),
+        m_include_runtime_support_values(false) {}
+
+  VariablesOptionsImpl(const VariablesOptionsImpl &) = default;
+
+  ~VariablesOptionsImpl() = default;
+
+  VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default;
+
+  bool GetIncludeArguments() const { return m_include_arguments; }
+
+  void SetIncludeArguments(bool b) { m_include_arguments = b; }
+
+  bool GetIncludeRecognizedArguments(const lldb::TargetSP &target_sp) const {
+    if (m_include_recognized_arguments != eLazyBoolCalculate)
+        return m_include_recognized_arguments;
+    return target_sp ? target_sp->GetDisplayRecognizedArguments() : false;
+  }
+
+  void SetIncludeRecognizedArguments(bool b) {
+    m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo;
+  }
+
+  bool GetIncludeLocals() const { return m_include_locals; }
+
+  void SetIncludeLocals(bool b) { m_include_locals = b; }
+
+  bool GetIncludeStatics() const { return m_include_statics; }
+
+  void SetIncludeStatics(bool b) { m_include_statics = b; }
+
+  bool GetInScopeOnly() const { return m_in_scope_only; }
+
+  void SetInScopeOnly(bool b) { m_in_scope_only = b; }
+
+  bool GetIncludeRuntimeSupportValues() const {
+    return m_include_runtime_support_values;
+  }
+
+  void SetIncludeRuntimeSupportValues(bool b) {
+    m_include_runtime_support_values = b;
+  }
+
+  lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
+
+  void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
+
+private:
+  bool m_include_arguments : 1;
+  bool m_include_locals : 1;
+  bool m_include_statics : 1;
+  bool m_in_scope_only : 1;
+  bool m_include_runtime_support_values : 1;
+  LazyBool m_include_recognized_arguments =
+      eLazyBoolCalculate; // can be overridden with a setting
+  lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
+};
+
+SBVariablesOptions::SBVariablesOptions()
+    : m_opaque_up(new VariablesOptionsImpl()) {
+  LLDB_INSTRUMENT_VA(this);
+}
+
+SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
+    : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
+  LLDB_INSTRUMENT_VA(this, options);
+}
+
+SBVariablesOptions &SBVariablesOptions::
+operator=(const SBVariablesOptions &options) {
+  LLDB_INSTRUMENT_VA(this, options);
+
+  m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref());
+  return *this;
+}
+
+SBVariablesOptions::~SBVariablesOptions() = default;
+
+bool SBVariablesOptions::IsValid() const {
+  LLDB_INSTRUMENT_VA(this);
+  return this->operator bool();
+}
+SBVariablesOptions::operator bool() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up != nullptr;
+}
+
+bool SBVariablesOptions::GetIncludeArguments() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetIncludeArguments();
+}
+
+void SBVariablesOptions::SetIncludeArguments(bool arguments) {
+  LLDB_INSTRUMENT_VA(this, arguments);
+
+  m_opaque_up->SetIncludeArguments(arguments);
+}
+
+bool SBVariablesOptions::GetIncludeRecognizedArguments(
+    const lldb::SBTarget &target) const {
+  LLDB_INSTRUMENT_VA(this, target);
+
+  return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
+}
+
+void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
+  LLDB_INSTRUMENT_VA(this, arguments);
+
+  m_opaque_up->SetIncludeRecognizedArguments(arguments);
+}
+
+bool SBVariablesOptions::GetIncludeLocals() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetIncludeLocals();
+}
+
+void SBVariablesOptions::SetIncludeLocals(bool locals) {
+  LLDB_INSTRUMENT_VA(this, locals);
+
+  m_opaque_up->SetIncludeLocals(locals);
+}
+
+bool SBVariablesOptions::GetIncludeStatics() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetIncludeStatics();
+}
+
+void SBVariablesOptions::SetIncludeStatics(bool statics) {
+  LLDB_INSTRUMENT_VA(this, statics);
+
+  m_opaque_up->SetIncludeStatics(statics);
+}
+
+bool SBVariablesOptions::GetInScopeOnly() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetInScopeOnly();
+}
+
+void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
+  LLDB_INSTRUMENT_VA(this, in_scope_only);
+
+  m_opaque_up->SetInScopeOnly(in_scope_only);
+}
+
+bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetIncludeRuntimeSupportValues();
+}
+
+void SBVariablesOptions::SetIncludeRuntimeSupportValues(
+    bool runtime_support_values) {
+  LLDB_INSTRUMENT_VA(this, runtime_support_values);
+
+  m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
+}
+
+lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  return m_opaque_up->GetUseDynamic();
+}
+
+void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
+  LLDB_INSTRUMENT_VA(this, dynamic);
+
+  m_opaque_up->SetUseDynamic(dynamic);
+}
+
+VariablesOptionsImpl *SBVariablesOptions::operator->() {
+  return m_opaque_up.operator->();
+}
+
+const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
+  return m_opaque_up.operator->();
+}
+
+VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }
+
+VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; }
+
+const VariablesOptionsImpl &SBVariablesOptions::ref() const {
+  return *m_opaque_up;
+}
+
+SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
+    : m_opaque_up(std::move(lldb_object_ptr)) {}
+
+void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
+  m_opaque_up.reset(std::move(lldb_object_ptr));
+}