summaryrefslogtreecommitdiff
path: root/source/API/SBVariablesOptions.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/API/SBVariablesOptions.cpp')
-rw-r--r--source/API/SBVariablesOptions.cpp158
1 files changed, 128 insertions, 30 deletions
diff --git a/source/API/SBVariablesOptions.cpp b/source/API/SBVariablesOptions.cpp
index 2651ce11d02a..bf0197cd960b 100644
--- a/source/API/SBVariablesOptions.cpp
+++ b/source/API/SBVariablesOptions.cpp
@@ -1,14 +1,14 @@
//===-- SBVariablesOptions.cpp --------------------------------------*- C++
//-*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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 "SBReproducerPrivate.h"
#include "lldb/API/SBTarget.h"
#include "lldb/Target/Target.h"
@@ -81,98 +81,196 @@ private:
};
SBVariablesOptions::SBVariablesOptions()
- : m_opaque_ap(new VariablesOptionsImpl()) {}
+ : m_opaque_up(new VariablesOptionsImpl()) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
+}
SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
- : m_opaque_ap(new VariablesOptionsImpl(options.ref())) {}
+ : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
+ LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
+ (const lldb::SBVariablesOptions &), options);
+}
SBVariablesOptions &SBVariablesOptions::
operator=(const SBVariablesOptions &options) {
- m_opaque_ap.reset(new VariablesOptionsImpl(options.ref()));
- return *this;
+ LLDB_RECORD_METHOD(
+ lldb::SBVariablesOptions &,
+ SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
+ options);
+
+ m_opaque_up.reset(new VariablesOptionsImpl(options.ref()));
+ return LLDB_RECORD_RESULT(*this);
}
SBVariablesOptions::~SBVariablesOptions() = default;
-bool SBVariablesOptions::IsValid() const { return m_opaque_ap != nullptr; }
+bool SBVariablesOptions::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+ return this->operator bool();
+}
+SBVariablesOptions::operator bool() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
+
+ return m_opaque_up != nullptr;
+}
bool SBVariablesOptions::GetIncludeArguments() const {
- return m_opaque_ap->GetIncludeArguments();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+ GetIncludeArguments);
+
+ return m_opaque_up->GetIncludeArguments();
}
void SBVariablesOptions::SetIncludeArguments(bool arguments) {
- m_opaque_ap->SetIncludeArguments(arguments);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
+ arguments);
+
+ m_opaque_up->SetIncludeArguments(arguments);
}
bool SBVariablesOptions::GetIncludeRecognizedArguments(
const lldb::SBTarget &target) const {
- return m_opaque_ap->GetIncludeRecognizedArguments(target.GetSP());
+ LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRecognizedArguments,
+ (const lldb::SBTarget &), target);
+
+ return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
}
void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
- m_opaque_ap->SetIncludeRecognizedArguments(arguments);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
+ (bool), arguments);
+
+ m_opaque_up->SetIncludeRecognizedArguments(arguments);
}
bool SBVariablesOptions::GetIncludeLocals() const {
- return m_opaque_ap->GetIncludeLocals();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
+
+ return m_opaque_up->GetIncludeLocals();
}
void SBVariablesOptions::SetIncludeLocals(bool locals) {
- m_opaque_ap->SetIncludeLocals(locals);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
+ locals);
+
+ m_opaque_up->SetIncludeLocals(locals);
}
bool SBVariablesOptions::GetIncludeStatics() const {
- return m_opaque_ap->GetIncludeStatics();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
+
+ return m_opaque_up->GetIncludeStatics();
}
void SBVariablesOptions::SetIncludeStatics(bool statics) {
- m_opaque_ap->SetIncludeStatics(statics);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
+ statics);
+
+ m_opaque_up->SetIncludeStatics(statics);
}
bool SBVariablesOptions::GetInScopeOnly() const {
- return m_opaque_ap->GetInScopeOnly();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
+
+ return m_opaque_up->GetInScopeOnly();
}
void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
- m_opaque_ap->SetInScopeOnly(in_scope_only);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
+ in_scope_only);
+
+ m_opaque_up->SetInScopeOnly(in_scope_only);
}
bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
- return m_opaque_ap->GetIncludeRuntimeSupportValues();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
+ GetIncludeRuntimeSupportValues);
+
+ return m_opaque_up->GetIncludeRuntimeSupportValues();
}
void SBVariablesOptions::SetIncludeRuntimeSupportValues(
bool runtime_support_values) {
- m_opaque_ap->SetIncludeRuntimeSupportValues(runtime_support_values);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
+ (bool), runtime_support_values);
+
+ m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
}
lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
- return m_opaque_ap->GetUseDynamic();
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
+ GetUseDynamic);
+
+ return m_opaque_up->GetUseDynamic();
}
void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
- m_opaque_ap->SetUseDynamic(dynamic);
+ LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
+ (lldb::DynamicValueType), dynamic);
+
+ m_opaque_up->SetUseDynamic(dynamic);
}
VariablesOptionsImpl *SBVariablesOptions::operator->() {
- return m_opaque_ap.operator->();
+ return m_opaque_up.operator->();
}
const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
- return m_opaque_ap.operator->();
+ return m_opaque_up.operator->();
}
-VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_ap.get(); }
+VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }
-VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_ap; }
+VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; }
const VariablesOptionsImpl &SBVariablesOptions::ref() const {
- return *m_opaque_ap;
+ return *m_opaque_up;
}
SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
- : m_opaque_ap(std::move(lldb_object_ptr)) {}
+ : m_opaque_up(std::move(lldb_object_ptr)) {}
void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
- m_opaque_ap.reset(std::move(lldb_object_ptr));
+ m_opaque_up.reset(std::move(lldb_object_ptr));
+}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBVariablesOptions>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
+ (const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD(
+ lldb::SBVariablesOptions &,
+ SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
+ ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRecognizedArguments,
+ (const lldb::SBTarget &));
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRecognizedArguments, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
+ LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
+ GetIncludeRuntimeSupportValues, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions,
+ SetIncludeRuntimeSupportValues, (bool));
+ LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
+ GetUseDynamic, ());
+ LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
+ (lldb::DynamicValueType));
+}
+
+}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-04 17:37:47 +0000