};
void SetNextEventAction(Process::NextEventAction *next_event_action) {
- if (m_next_event_action_up)
+ if (m_next_event_action_up.get())
m_next_event_action_up->HandleBeingUnshipped();
m_next_event_action_up.reset(next_event_action);
return;
} else if (len > 0) {
std::string buffer(string, len);
- ref().AppendMessage(buffer);
+ ref().AppendMessage(buffer.c_str());
} else
ref().AppendMessage(string);
}
}
EvaluateExpressionOptions &SBExpressionOptions::ref() const {
- return *m_opaque_up;
+ return *(m_opaque_up.get());
}
if (&rhs == this)
return;
- m_opaque_up = std::make_unique<SourceManagerImpl>(*rhs.m_opaque_up);
+ m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
}
const lldb::SBSourceManager &SBSourceManager::
operator=(const lldb::SBSourceManager &rhs) {
LLDB_INSTRUMENT_VA(this, rhs);
- m_opaque_up = std::make_unique<SourceManagerImpl>(*rhs.m_opaque_up);
+ m_opaque_up = std::make_unique<SourceManagerImpl>(*(rhs.m_opaque_up.get()));
return *this;
}
short_help);
}
if (!short_help.empty())
- s->PutCString(short_help);
+ s->PutCString(short_help.c_str());
else
s->Printf("python class = %s", m_class_name.c_str());
}
m_bp_opts.SetThreadID(thread_id);
} break;
case 'T':
- m_bp_opts.GetThreadSpec()->SetName(option_arg.str());
+ m_bp_opts.GetThreadSpec()->SetName(option_arg.str().c_str());
break;
case 'q':
- m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str());
+ m_bp_opts.GetThreadSpec()->SetQueueName(option_arg.str().c_str());
break;
case 'x': {
uint32_t thread_index = UINT32_MAX;
CommandReturnObject return_obj(
GetCommandInterpreter().GetDebugger().GetUseColor());
- EvaluateExpression(line, *output_sp, *error_sp, return_obj);
+ EvaluateExpression(line.c_str(), *output_sp, *error_sp, return_obj);
if (output_sp)
output_sp->Flush();
if (error_sp)
return false;
} else if (!sub_cmd_obj) {
StreamString error_msg_stream;
- GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, cmd_string,
- m_interpreter.GetCommandPrefix(),
- sub_command);
+ GenerateAdditionalHelpAvenuesMessage(
+ &error_msg_stream, cmd_string.c_str(),
+ m_interpreter.GetCommandPrefix(), sub_command.c_str());
result.AppendError(error_msg_stream.GetString());
return false;
} else {
GenerateAdditionalHelpAvenuesMessage(
- &result.GetOutputStream(), cmd_string,
- m_interpreter.GetCommandPrefix(), sub_command);
+ &result.GetOutputStream(), cmd_string.c_str(),
+ m_interpreter.GetCommandPrefix(), sub_command.c_str());
result.GetOutputStream().Printf(
"\nThe closest match is '%s'. Help on it follows.\n\n",
sub_cmd_obj->GetCommandName().str().c_str());
}
}
error_msg.append("\n");
- result.AppendRawError(error_msg);
+ result.AppendRawError(error_msg.c_str());
return false;
}
module_sp->SetSymbolFileFileSpec(symfile);
if (remote_file) {
std::string remote_path = remote_file.GetPath();
- target_sp->SetArg0(remote_path);
+ target_sp->SetArg0(remote_path.c_str());
module_sp->SetPlatformFileSpec(remote_file);
}
}
}
if (!warnings.empty())
- result.AppendWarning(warnings);
+ result.AppendWarning(warnings.c_str());
}
result.SetStatus(eReturnStatusSuccessFinishResult);
thumb_arch_name.erase(0, 3);
thumb_arch_name.insert(0, "thumb");
}
- m_arch.SetTriple(thumb_arch_name);
+ m_arch.SetTriple(thumb_arch_name.c_str());
}
}
ValueObject::ExpressionPathAftermath what_next =
(deref_pointer ? ValueObject::eExpressionPathAftermathDereference
: ValueObject::eExpressionPathAftermathNothing);
- ValueObjectSP item =
- valobj->GetValueForExpressionPath(ptr_deref_buffer, &reason_to_stop,
- &final_value_type, options, &what_next);
+ ValueObjectSP item = valobj->GetValueForExpressionPath(
+ ptr_deref_buffer.c_str(), &reason_to_stop, &final_value_type, options,
+ &what_next);
if (!item) {
LLDB_LOGF(log,
"[ExpandIndexedExpression] ERROR: why stopping = %d,"
target =
valobj
- ->GetValueForExpressionPath(expr_path, &reason_to_stop,
+ ->GetValueForExpressionPath(expr_path.c_str(), &reason_to_stop,
&final_value_type, options, &what_next)
.get();
void UpdateMatches(const std::string &text) override {
CompletionResult result;
- CompletionRequest request(text, text.size(), result);
+ CompletionRequest request(text.c_str(), text.size(), result);
CommandCompletions::InvokeCommonCompletionCallbacks(
m_debugger.GetCommandInterpreter(), m_completion_mask, request,
nullptr);
const char *expr_prefix = nullptr;
lldb::ValueObjectSP result_valobj_sp;
Status error;
- lldb::ExpressionResults execution_results = UserExpression::Evaluate(
- exe_ctx, expr_options, code, expr_prefix, result_valobj_sp, error,
- nullptr); // fixed expression
+ lldb::ExpressionResults execution_results =
+ UserExpression::Evaluate(exe_ctx, expr_options, code.c_str(),
+ expr_prefix, result_valobj_sp, error,
+ nullptr); // fixed expression
// CommandInterpreter &ci = debugger.GetCommandInterpreter();
else if (cmd_obj->IsMultiwordObject()) {
// Our current object is a multi-word object; see if the cmd_word is a
// valid sub-command for our object.
- CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject(cmd_word);
+ CommandObject *sub_cmd_obj =
+ cmd_obj->GetSubcommandObject(cmd_word.c_str());
if (sub_cmd_obj)
cmd_obj = sub_cmd_obj;
else // cmd_word was not a valid sub-command word, so we are done
options.SetTryAllThreads(true);
options.SetTimeout(std::nullopt);
- ExpressionResults expr_result = target.EvaluateExpression(
- expr_str, exe_ctx.GetFramePtr(), expr_result_valobj_sp, options);
+ ExpressionResults expr_result =
+ target.EvaluateExpression(expr_str.c_str(), exe_ctx.GetFramePtr(),
+ expr_result_valobj_sp, options);
if (expr_result == eExpressionCompleted) {
Scalar scalar;
}
} else {
if (cmd_obj->IsMultiwordObject()) {
- CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject(next_word);
+ CommandObject *sub_cmd_obj =
+ cmd_obj->GetSubcommandObject(next_word.c_str());
if (sub_cmd_obj) {
// The subcommand's name includes the parent command's name, so
// restart rather than append to the revised_command_line.
std::string str_offset = matches[3].str();
if (!llvm::StringRef(str_offset).getAsInteger(0, offset)) {
Status error;
- addr = ToAddress(exe_ctx, name, LLDB_INVALID_ADDRESS, &error);
+ addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS, &error);
if (addr != LLDB_INVALID_ADDRESS) {
if (sign[0] == '+')
return addr + offset;
case eVarSetOperationReplace:
case eVarSetOperationAssign: {
std::string value_str = value.trim().str();
- if (m_current_value.SetTriple(value_str)) {
+ if (m_current_value.SetTriple(value_str.c_str())) {
m_value_was_set = true;
NotifyValueChanged();
} else
Status
ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
if (error.m_opaque_up)
- return *error.m_opaque_up;
+ return *error.m_opaque_up.get();
return Status();
}
if (m_load_address == LLDB_INVALID_ADDRESS)
return false;
- FileSpec file_spec(m_name);
+ FileSpec file_spec(m_name.c_str());
llvm::MachO::mach_header mh;
size_t size_to_read = 512;
PlatformDarwinKernel::GetPluginNameStatic());
if (platform_sp->GetPluginName() == g_platform_name.GetStringRef()) {
ModuleSpec kext_bundle_module_spec(module_spec);
- FileSpec kext_filespec(m_name);
+ FileSpec kext_filespec(m_name.c_str());
FileSpecList search_paths = target.GetExecutableSearchPaths();
kext_bundle_module_spec.GetFileSpec() = kext_filespec;
platform_sp->GetSharedModule(kext_bundle_module_spec, process,
ClangPersistentVariables::GetClangModulesDeclVendor() {
if (!m_modules_decl_vendor_sp) {
m_modules_decl_vendor_sp.reset(
- ClangModulesDeclVendor::Create(*m_target_sp));
+ ClangModulesDeclVendor::Create(*m_target_sp.get()));
}
return m_modules_decl_vendor_sp;
}
// will crash in clang.
clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
if (func_proto_type &&
- TypeSystemClang::IsOperator(decl_name.getAsString(), op_kind)) {
+ TypeSystemClang::IsOperator(decl_name.getAsString().c_str(), op_kind)) {
if (!TypeSystemClang::CheckOverloadedOperatorKindParameterCount(
false, op_kind, func_proto_type->getNumParams()))
return nullptr;
const std::string &trace_item_name = ".trace") {
auto trace_sp = std::make_shared<StructuredData::Array>();
ValueObjectSP trace_value_object =
- o->GetValueForExpressionPath(trace_item_name);
+ o->GetValueForExpressionPath(trace_item_name.c_str());
size_t count = trace_value_object->GetNumChildren();
for (size_t j = 0; j < count; j++) {
addr_t trace_addr =
const StructuredData::DictionarySP &dict)> const
&callback) {
auto array_sp = std::make_shared<StructuredData::Array>();
- unsigned int count = return_value_sp->GetValueForExpressionPath(count_name)
- ->GetValueAsUnsigned(0);
+ unsigned int count =
+ return_value_sp->GetValueForExpressionPath(count_name.c_str())
+ ->GetValueAsUnsigned(0);
ValueObjectSP objects =
- return_value_sp->GetValueForExpressionPath(items_name);
+ return_value_sp->GetValueForExpressionPath(items_name.c_str());
for (unsigned int i = 0; i < count; i++) {
ValueObjectSP o = objects->GetChildAtIndex(i, true);
auto dict_sp = std::make_shared<StructuredData::Dictionary>();
static std::string RetrieveString(ValueObjectSP return_value_sp,
ProcessSP process_sp,
const std::string &expression_path) {
- addr_t ptr = return_value_sp->GetValueForExpressionPath(expression_path)
- ->GetValueAsUnsigned(0);
+ addr_t ptr =
+ return_value_sp->GetValueForExpressionPath(expression_path.c_str())
+ ->GetValueAsUnsigned(0);
std::string str;
Status error;
process_sp->ReadCStringFromMemory(ptr, str, error);
static addr_t RetrieveUnsigned(ValueObjectSP return_value_sp,
ProcessSP process_sp,
const std::string &expression_path) {
- return return_value_sp->GetValueForExpressionPath(expression_path)
+ return return_value_sp->GetValueForExpressionPath(expression_path.c_str())
->GetValueAsUnsigned(0);
}
}
}
- stream.PutCString(prefix);
+ stream.PutCString(prefix.c_str());
const int radix = 10;
const bool isSigned = true;
std::string str = llvm::toString(value, radix, isSigned);
- stream.PutCString(str);
- stream.PutCString(suffix);
+ stream.PutCString(str.c_str());
+ stream.PutCString(suffix.c_str());
}
static void NSNumber_FormatFloat(ValueObject &valobj, Stream &stream,
std::string trace_path = "." + std::string(type) + "_trace";
ValueObjectSP count_sp =
- return_value_sp->GetValueForExpressionPath(count_path);
- ValueObjectSP tid_sp = return_value_sp->GetValueForExpressionPath(tid_path);
+ return_value_sp->GetValueForExpressionPath(count_path.c_str());
+ ValueObjectSP tid_sp =
+ return_value_sp->GetValueForExpressionPath(tid_path.c_str());
if (!count_sp || !tid_sp)
return;
return;
ValueObjectSP trace_sp =
- return_value_sp->GetValueForExpressionPath(trace_path);
+ return_value_sp->GetValueForExpressionPath(trace_path.c_str());
if (!trace_sp)
return;
port = env_port;
}
std::string uri = "connect://127.0.0.1:" + port;
- m_conn->Connect(uri, &error);
+ m_conn->Connect(uri.c_str(), &error);
return error;
}
std::vector<char> error_message;
auto error = ReadMessage(error_message);
if (error.Success())
- error.SetErrorString(std::string(&error_message[0], error_message.size()));
+ error.SetErrorString(
+ std::string(&error_message[0], error_message.size()).c_str());
return error;
}
if (gdbstub_port)
local_port = std::stoi(gdbstub_port);
- auto error =
- MakeConnectURL(pid, local_port, remote_port, socket_name, connect_url);
+ auto error = MakeConnectURL(pid, local_port, remote_port, socket_name.c_str(),
+ connect_url);
if (error.Success() && log)
LLDB_LOGF(log, "gdbserver connect URL: %s", connect_url.c_str());
llvm::StringRef dirname = GetDeviceSupportDirectoryName();
std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
local_sdk_cache_str += std::string(dirname);
- FileSpec local_sdk_cache(local_sdk_cache_str);
+ FileSpec local_sdk_cache(local_sdk_cache_str.c_str());
FileSystem::Instance().Resolve(local_sdk_cache);
if (FileSystem::Instance().Exists(local_sdk_cache)) {
if (log) {
if (m_device_support_directory.empty()) {
if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
m_device_support_directory = fspec.GetPath();
- m_device_support_directory.append(platform_dir);
+ m_device_support_directory.append(platform_dir.c_str());
} else {
// Assign a single NULL character so we know we tried to find the device
// support directory and we don't keep trying to find it over and over.
const bool find_files = false;
const bool find_other = false;
FileSystem::Instance().EnumerateDirectory(
- dir, find_directories, find_files, find_other,
+ dir.c_str(), find_directories, find_files, find_other,
FindKDKandSDKDirectoriesInDirectory, this);
}
const bool find_files = true;
const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
FileSystem::Instance().EnumerateDirectory(
- dir.GetPath(), find_directories, find_files, find_other,
+ dir.GetPath().c_str(), find_directories, find_files, find_other,
GetKernelsAndKextsInDirectoryWithRecursion, this);
}
const uint32_t num_dirs_no_recurse = m_search_directories_no_recursing.size();
const bool find_files = true;
const bool find_other = true; // I think eFileTypeSymbolicLink are "other"s.
FileSystem::Instance().EnumerateDirectory(
- dir.GetPath(), find_directories, find_files, find_other,
+ dir.GetPath().c_str(), find_directories, find_files, find_other,
GetKernelsAndKextsInDirectoryNoRecursion, this);
}
}
const bool find_files = false;
const bool find_other = false;
FileSystem::Instance().EnumerateDirectory(
- search_here_too, find_directories, find_files, find_other,
+ search_here_too.c_str(), find_directories, find_files, find_other,
recurse ? GetKernelsAndKextsInDirectoryWithRecursion
: GetKernelsAndKextsInDirectoryNoRecursion,
baton);
PlatformDarwinKernel::SearchForExecutablesRecursively(const std::string &dir) {
std::vector<FileSpec> executables;
std::error_code EC;
- for (llvm::sys::fs::recursive_directory_iterator it(dir, EC), end;
+ for (llvm::sys::fs::recursive_directory_iterator it(dir.c_str(), EC),
+ end;
it != end && !EC; it.increment(EC)) {
auto status = it->status();
if (!status)
unsigned int GetVersionAtIndex(size_t idx) const { return m_versions[idx]; }
- std::string GetFamily() const { return m_family; }
+ std::string GetFamily() const { return m_family.c_str(); }
private:
std::string m_family;
}
if (!m_platform_description.empty())
- return m_platform_description;
+ return m_platform_description.c_str();
return GetDescriptionStatic();
}
if (process_sp) {
process_sp->HijackProcessEvents(launch_info.GetHijackListener());
- error = process_sp->ConnectRemote(connect_url);
+ error = process_sp->ConnectRemote(connect_url.c_str());
// Retry the connect remote one time...
if (error.Fail())
- error = process_sp->ConnectRemote(connect_url);
+ error = process_sp->ConnectRemote(connect_url.c_str());
if (error.Success())
error = process_sp->Launch(launch_info);
else if (debugserver_pid != LLDB_INVALID_PROCESS_ID) {
target->CreateProcess(attach_info.GetListenerForProcess(debugger),
"gdb-remote", nullptr, true);
if (process_sp) {
- error = process_sp->ConnectRemote(connect_url);
+ error = process_sp->ConnectRemote(connect_url.c_str());
if (error.Success()) {
ListenerSP listener_sp = attach_info.GetHijackListener();
if (listener_sp)
GetPendingGdbServerList(connection_urls);
for (size_t i = 0; i < connection_urls.size(); ++i) {
- ConnectProcess(connection_urls[i], "gdb-remote", debugger, nullptr, error);
+ ConnectProcess(connection_urls[i].c_str(), "gdb-remote", debugger, nullptr, error);
if (error.Fail())
return i; // We already connected to i process successfully
}
if (connection) {
// Do the listen on another thread so we can continue on...
if (connection->Connect(
- m_listen_url,
+ m_listen_url.c_str(),
[this](llvm::StringRef port_str) {
uint16_t port = 0;
llvm::to_integer(port_str, port, 10);
else
triple += os_name;
}
- m_host_arch.SetTriple(triple);
+ m_host_arch.SetTriple(triple.c_str());
llvm::Triple &host_triple = m_host_arch.GetTriple();
if (host_triple.getVendor() == llvm::Triple::Apple &&
}
}
} else {
- m_host_arch.SetTriple(triple);
+ m_host_arch.SetTriple(triple.c_str());
if (pointer_byte_size) {
assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
}
std::string error_string;
// Now convert the HEX bytes into a string value
error_extractor.GetHexByteString(error_string);
- error.SetErrorString(error_string);
+ error.SetErrorString(error_string.c_str());
} else if (name.equals("dirty-pages")) {
std::vector<addr_t> dirty_page_list;
for (llvm::StringRef x : llvm::split(value, ',')) {
StringExtractor extractor(value);
std::string triple;
extractor.GetHexByteString(triple);
- process_info.GetArchitecture().SetTriple(triple);
+ process_info.GetArchitecture().SetTriple(triple.c_str());
} else if (name.equals("name")) {
StringExtractor extractor(value);
// The process name from ASCII hex bytes since we can't control the
// Set the ArchSpec from the triple if we have it.
if (!triple.empty()) {
- m_process_arch.SetTriple(triple);
+ m_process_arch.SetTriple(triple.c_str());
m_process_arch.SetFlags(elf_abi);
if (pointer_byte_size) {
assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
StringExtractor extractor(value);
std::string triple;
extractor.GetHexByteString(triple);
- module_spec.GetArchitecture().SetTriple(triple);
+ module_spec.GetArchitecture().SetTriple(triple.c_str());
} else if (name == "file_offset") {
uint64_t ival = 0;
if (!value.getAsInteger(16, ival))
std::string output;
FileSpec working_spec(working_dir);
FileSystem::Instance().Resolve(working_spec);
- Status err = Host::RunShellCommand(path, working_spec, &status, &signo,
- &output, std::chrono::seconds(10));
+ Status err =
+ Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
+ &output, std::chrono::seconds(10));
StreamGDBRemote response;
if (err.Fail()) {
response.PutCString("F,");
response.PutChar(';');
response.PutCString("file_path:");
- response.PutStringAsRawHex8(matched_module_spec.GetFileSpec().GetPath());
+ response.PutStringAsRawHex8(
+ matched_module_spec.GetFileSpec().GetPath().c_str());
response.PutChar(';');
response.PutCString("file_offset:");
response.PutHex64(file_offset);
proc_info.GetUserID(), proc_info.GetGroupID(),
proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
response.PutCString("name:");
- response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath());
+ response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath().c_str());
response.PutChar(';');
response.PutCString("args:");
FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
if (working_dir) {
StreamString response;
- response.PutStringAsRawHex8(working_dir.GetPath());
+ response.PutStringAsRawHex8(working_dir.GetPath().c_str());
return SendPacketNoLock(response.GetString());
}
response.Printf("<library-list-svr4 version=\"1.0\">");
for (auto const &library : *library_list) {
response.Printf("<library name=\"%s\" ",
- XMLEncodeAttributeValue(library.name).c_str());
+ XMLEncodeAttributeValue(library.name.c_str()).c_str());
response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map);
response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr);
response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr);
separator = ",";
// encode result strings into hex bytes to avoid unexpected error caused by
// special characters like '$'.
- response.PutStringAsRawHex8(match);
+ response.PutStringAsRawHex8(match.c_str());
}
return SendPacketNoLock(response.GetString());
FileSpec socket_path_spec(GetDomainSocketDir());
socket_path_spec.AppendPathComponent(socket_name.c_str());
- llvm::sys::fs::createUniqueFile(socket_path_spec.GetPath(), socket_path);
+ llvm::sys::fs::createUniqueFile(socket_path_spec.GetPath().c_str(),
+ socket_path);
return FileSpec(socket_path.c_str());
}
ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
- m_scripted_process_info.GetClassName(), exe_ctx,
+ m_scripted_process_info.GetClassName().c_str(), exe_ctx,
m_scripted_process_info.GetArgsSP());
if (!object_sp || !object_sp->IsValid()) {
->GetArchitecture()
.GetTriple()
.getArchName()
- .str());
+ .str()
+ .c_str());
comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
oso_arch, oso_object ? &oso_object : nullptr, 0,
// TODO: get mangled name for the method.
return m_ast.AddMethodToCXXRecordType(
- record_type.GetOpaqueQualType(), name,
+ record_type.GetOpaqueQualType(), name.c_str(),
/*mangled_name*/ nullptr, method_comp_type, access, method.isVirtual(),
method.isStatic(), method.hasInlineAttribute(),
/*is_explicit*/ false, // FIXME: Need this field in CodeView.
// the full source path remap.
if (do_truncate_remapping_names) {
FileSpec build_path(key.AsCString());
- FileSpec source_path(DBGSourcePath);
+ FileSpec source_path(DBGSourcePath.c_str());
build_path.RemoveLastPathComponent();
build_path.RemoveLastPathComponent();
source_path.RemoveLastPathComponent();
m_initial_sp(0), m_cfa_reg_info(), m_fp_is_cfa(false),
m_register_values(), m_pushed_regs(), m_curr_row_modified(false),
m_forward_branch_offset(0) {
- if (m_inst_emulator_up) {
+ if (m_inst_emulator_up.get()) {
m_inst_emulator_up->SetBaton(this);
m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister,
WriteRegister);
(CFDictionaryRef)uuid_dict, CFSTR("DBGSymbolRichExecutable"));
if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
if (CFCString::FileSystemRepresentation(cf_str, str)) {
- module_spec.GetFileSpec().SetFile(str, FileSpec::Style::native);
+ module_spec.GetFileSpec().SetFile(str.c_str(), FileSpec::Style::native);
FileSystem::Instance().Resolve(module_spec.GetFileSpec());
LLDB_LOGF(log,
"From dsymForUUID plist: Symbol rich executable is at '%s'",
CFSTR("DBGDSYMPath"));
if (cf_str && CFGetTypeID(cf_str) == CFStringGetTypeID()) {
if (CFCString::FileSystemRepresentation(cf_str, str)) {
- module_spec.GetSymbolFileSpec().SetFile(str, FileSpec::Style::native);
+ module_spec.GetSymbolFileSpec().SetFile(str.c_str(),
+ FileSpec::Style::native);
FileSystem::Instance().Resolve(module_spec.GetFileSpec());
success = true;
LLDB_LOGF(log, "From dsymForUUID plist: dSYM is at '%s'", str.c_str());
DBGSourcePath = original_DBGSourcePath_value;
}
if (DBGSourcePath[0] == '~') {
- FileSpec resolved_source_path(DBGSourcePath);
+ FileSpec resolved_source_path(DBGSourcePath.c_str());
FileSystem::Instance().Resolve(resolved_source_path);
DBGSourcePath = resolved_source_path.GetPath();
}
module_spec.GetSourceMappingList().Append(DBGBuildSourcePath,
DBGSourcePath, true);
if (do_truncate_remapping_names) {
- FileSpec build_path(DBGBuildSourcePath);
- FileSpec source_path(DBGSourcePath);
+ FileSpec build_path(DBGBuildSourcePath.c_str());
+ FileSpec source_path(DBGSourcePath.c_str());
build_path.RemoveLastPathComponent();
build_path.RemoveLastPathComponent();
source_path.RemoveLastPathComponent();
if (!DBGBuildSourcePath.empty() && !DBGSourcePath.empty()) {
if (DBGSourcePath[0] == '~') {
- FileSpec resolved_source_path(DBGSourcePath);
+ FileSpec resolved_source_path(DBGSourcePath.c_str());
FileSystem::Instance().Resolve(resolved_source_path);
DBGSourcePath = resolved_source_path.GetPath();
}
// and cached because we may create multiple debuggers and need one
// instance of the command each - the implementing function is meant to
// create a new instance of the command each time it is invoked.
- parent->LoadSubCommand(command->GetCommandName().str(), command);
+ parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);
}
}
}
target_sp->SetArg0(resolved_bundle_exe_path);
} else {
// Use resolved path
- target_sp->SetArg0(file.GetPath());
+ target_sp->SetArg0(file.GetPath().c_str());
}
}
if (file.GetDirectory()) {
// queries GetDescription makes, and only assert if you try to run the thread.
if (!m_null_plan_stack_up)
m_null_plan_stack_up = std::make_unique<ThreadPlanStack>(*this, true);
- return *(m_null_plan_stack_up);
+ return *(m_null_plan_stack_up.get());
}
void Thread::PushPlan(ThreadPlanSP thread_plan_sp) {
for (auto thread : current_threads.Threads()) {
lldb::tid_t cur_tid = thread->GetID();
if (!Find(cur_tid)) {
- AddThread(*thread);
+ AddThread(*thread.get());
thread->QueueBasePlan(true);
}
}
~DNBTimer() {}
- bool IsThreadSafe() const { return m_mutexAP != NULL; }
+ bool IsThreadSafe() const { return m_mutexAP.get() != NULL; }
// Reset the time value to now
void Reset() {
PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
}
if (!output.empty() && output.back() != '\n')
output.push_back('\n'); // Ensure log message has line break.
- g_vsc.SendOutput(OutputType::Console, output);
+ g_vsc.SendOutput(OutputType::Console, output.c_str());
// Do not stop.
return false;