| //===-- Debugger.cpp --------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/lldb-private.h" |
| #include "lldb/Core/ConnectionFileDescriptor.h" |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/InputReader.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Core/StreamString.h" |
| #include "lldb/Core/Timer.h" |
| #include "lldb/Interpreter/CommandInterpreter.h" |
| #include "lldb/Target/TargetList.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/RegisterContext.h" |
| #include "lldb/Target/StopInfo.h" |
| #include "lldb/Target/Thread.h" |
| |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| |
| static uint32_t g_shared_debugger_refcount = 0; |
| static lldb::user_id_t g_unique_id = 1; |
| |
| #pragma mark Static Functions |
| |
| static Mutex & |
| GetDebuggerListMutex () |
| { |
| static Mutex g_mutex(Mutex::eMutexTypeRecursive); |
| return g_mutex; |
| } |
| |
| typedef std::vector<DebuggerSP> DebuggerList; |
| |
| static DebuggerList & |
| GetDebuggerList() |
| { |
| // hide the static debugger list inside a singleton accessor to avoid |
| // global init contructors |
| static DebuggerList g_list; |
| return g_list; |
| } |
| |
| |
| #pragma mark Debugger |
| |
| void |
| Debugger::Initialize () |
| { |
| if (g_shared_debugger_refcount == 0) |
| lldb_private::Initialize(); |
| g_shared_debugger_refcount++; |
| } |
| |
| void |
| Debugger::Terminate () |
| { |
| if (g_shared_debugger_refcount > 0) |
| { |
| g_shared_debugger_refcount--; |
| if (g_shared_debugger_refcount == 0) |
| { |
| lldb_private::WillTerminate(); |
| lldb_private::Terminate(); |
| } |
| } |
| } |
| |
| DebuggerSP |
| Debugger::CreateInstance () |
| { |
| DebuggerSP debugger_sp (new Debugger); |
| // Scope for locker |
| { |
| Mutex::Locker locker (GetDebuggerListMutex ()); |
| GetDebuggerList().push_back(debugger_sp); |
| } |
| return debugger_sp; |
| } |
| |
| lldb::DebuggerSP |
| Debugger::GetSP () |
| { |
| lldb::DebuggerSP debugger_sp; |
| |
| Mutex::Locker locker (GetDebuggerListMutex ()); |
| DebuggerList &debugger_list = GetDebuggerList(); |
| DebuggerList::iterator pos, end = debugger_list.end(); |
| for (pos = debugger_list.begin(); pos != end; ++pos) |
| { |
| if ((*pos).get() == this) |
| { |
| debugger_sp = *pos; |
| break; |
| } |
| } |
| return debugger_sp; |
| } |
| |
| lldb::DebuggerSP |
| Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name) |
| { |
| lldb::DebuggerSP debugger_sp; |
| |
| Mutex::Locker locker (GetDebuggerListMutex ()); |
| DebuggerList &debugger_list = GetDebuggerList(); |
| DebuggerList::iterator pos, end = debugger_list.end(); |
| |
| for (pos = debugger_list.begin(); pos != end; ++pos) |
| { |
| if ((*pos).get()->m_instance_name == instance_name) |
| { |
| debugger_sp = *pos; |
| break; |
| } |
| } |
| return debugger_sp; |
| } |
| |
| TargetSP |
| Debugger::FindTargetWithProcessID (lldb::pid_t pid) |
| { |
| lldb::TargetSP target_sp; |
| Mutex::Locker locker (GetDebuggerListMutex ()); |
| DebuggerList &debugger_list = GetDebuggerList(); |
| DebuggerList::iterator pos, end = debugger_list.end(); |
| for (pos = debugger_list.begin(); pos != end; ++pos) |
| { |
| target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid); |
| if (target_sp) |
| break; |
| } |
| return target_sp; |
| } |
| |
| |
| Debugger::Debugger () : |
| UserID (g_unique_id++), |
| DebuggerInstanceSettings (*(Debugger::GetSettingsController().get())), |
| m_input_comm("debugger.input"), |
| m_input_file (), |
| m_output_file (), |
| m_error_file (), |
| m_target_list (), |
| m_listener ("lldb.Debugger"), |
| m_source_manager (), |
| m_command_interpreter_ap (new CommandInterpreter (*this, eScriptLanguageDefault, false)), |
| m_exe_ctx (), |
| m_input_readers (), |
| m_input_reader_data () |
| { |
| m_command_interpreter_ap->Initialize (); |
| } |
| |
| Debugger::~Debugger () |
| { |
| int num_targets = m_target_list.GetNumTargets(); |
| for (int i = 0; i < num_targets; i++) |
| { |
| ProcessSP process_sp (m_target_list.GetTargetAtIndex (i)->GetProcessSP()); |
| if (process_sp) |
| process_sp->Destroy(); |
| } |
| DisconnectInput(); |
| } |
| |
| |
| bool |
| Debugger::GetAsyncExecution () |
| { |
| return !m_command_interpreter_ap->GetSynchronous(); |
| } |
| |
| void |
| Debugger::SetAsyncExecution (bool async_execution) |
| { |
| m_command_interpreter_ap->SetSynchronous (!async_execution); |
| } |
| |
| void |
| Debugger::DisconnectInput() |
| { |
| m_input_comm.Clear (); |
| } |
| |
| void |
| Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership) |
| { |
| m_input_file.SetFileHandle (fh, tranfer_ownership); |
| if (m_input_file.GetFileHandle() == NULL) |
| m_input_file.SetFileHandle (stdin, false); |
| |
| // Disconnect from any old connection if we had one |
| m_input_comm.Disconnect (); |
| m_input_comm.SetConnection (new ConnectionFileDescriptor (::fileno (GetInputFileHandle()), true)); |
| m_input_comm.SetReadThreadBytesReceivedCallback (Debugger::DispatchInputCallback, this); |
| |
| Error error; |
| if (m_input_comm.StartReadThread (&error) == false) |
| { |
| FILE *err_fh = GetErrorFileHandle(); |
| if (err_fh) |
| { |
| ::fprintf (err_fh, "error: failed to main input read thread: %s", error.AsCString() ? error.AsCString() : "unkown error"); |
| exit(1); |
| } |
| } |
| |
| } |
| |
| FILE * |
| Debugger::GetInputFileHandle () |
| { |
| return m_input_file.GetFileHandle(); |
| } |
| |
| |
| void |
| Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership) |
| { |
| m_output_file.SetFileHandle (fh, tranfer_ownership); |
| if (m_output_file.GetFileHandle() == NULL) |
| m_output_file.SetFileHandle (stdin, false); |
| } |
| |
| FILE * |
| Debugger::GetOutputFileHandle () |
| { |
| return m_output_file.GetFileHandle(); |
| } |
| |
| void |
| Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership) |
| { |
| m_error_file.SetFileHandle (fh, tranfer_ownership); |
| if (m_error_file.GetFileHandle() == NULL) |
| m_error_file.SetFileHandle (stdin, false); |
| } |
| |
| |
| FILE * |
| Debugger::GetErrorFileHandle () |
| { |
| return m_error_file.GetFileHandle(); |
| } |
| |
| CommandInterpreter & |
| Debugger::GetCommandInterpreter () |
| { |
| assert (m_command_interpreter_ap.get()); |
| return *m_command_interpreter_ap; |
| } |
| |
| Listener & |
| Debugger::GetListener () |
| { |
| return m_listener; |
| } |
| |
| |
| TargetSP |
| Debugger::GetSelectedTarget () |
| { |
| return m_target_list.GetSelectedTarget (); |
| } |
| |
| ExecutionContext |
| Debugger::GetSelectedExecutionContext () |
| { |
| ExecutionContext exe_ctx; |
| exe_ctx.Clear(); |
| |
| lldb::TargetSP target_sp = GetSelectedTarget(); |
| exe_ctx.target = target_sp.get(); |
| |
| if (target_sp) |
| { |
| exe_ctx.process = target_sp->GetProcessSP().get(); |
| if (exe_ctx.process && exe_ctx.process->IsRunning() == false) |
| { |
| exe_ctx.thread = exe_ctx.process->GetThreadList().GetSelectedThread().get(); |
| if (exe_ctx.thread == NULL) |
| exe_ctx.thread = exe_ctx.process->GetThreadList().GetThreadAtIndex(0).get(); |
| if (exe_ctx.thread) |
| { |
| exe_ctx.frame = exe_ctx.thread->GetSelectedFrame().get(); |
| if (exe_ctx.frame == NULL) |
| exe_ctx.frame = exe_ctx.thread->GetStackFrameAtIndex (0).get(); |
| } |
| } |
| } |
| return exe_ctx; |
| |
| } |
| |
| SourceManager & |
| Debugger::GetSourceManager () |
| { |
| return m_source_manager; |
| } |
| |
| |
| TargetList& |
| Debugger::GetTargetList () |
| { |
| return m_target_list; |
| } |
| |
| void |
| Debugger::DispatchInputCallback (void *baton, const void *bytes, size_t bytes_len) |
| { |
| ((Debugger *)baton)->DispatchInput ((char *)bytes, bytes_len); |
| } |
| |
| |
| void |
| Debugger::DispatchInput (const char *bytes, size_t bytes_len) |
| { |
| if (bytes == NULL || bytes_len == 0) |
| return; |
| |
| // TODO: implement the STDIO to the process as an input reader... |
| TargetSP target = GetSelectedTarget(); |
| if (target.get() != NULL) |
| { |
| ProcessSP process_sp = target->GetProcessSP(); |
| if (process_sp.get() != NULL |
| && StateIsRunningState (process_sp->GetState())) |
| { |
| Error error; |
| if (process_sp->PutSTDIN (bytes, bytes_len, error) == bytes_len) |
| return; |
| } |
| } |
| |
| WriteToDefaultReader (bytes, bytes_len); |
| } |
| |
| void |
| Debugger::WriteToDefaultReader (const char *bytes, size_t bytes_len) |
| { |
| if (bytes && bytes_len) |
| m_input_reader_data.append (bytes, bytes_len); |
| |
| if (m_input_reader_data.empty()) |
| return; |
| |
| while (!m_input_readers.empty() && !m_input_reader_data.empty()) |
| { |
| while (CheckIfTopInputReaderIsDone ()) |
| /* Do nothing. */; |
| |
| // Get the input reader from the top of the stack |
| InputReaderSP reader_sp(m_input_readers.top()); |
| |
| if (!reader_sp) |
| break; |
| |
| size_t bytes_handled = reader_sp->HandleRawBytes (m_input_reader_data.c_str(), |
| m_input_reader_data.size()); |
| if (bytes_handled) |
| { |
| m_input_reader_data.erase (0, bytes_handled); |
| } |
| else |
| { |
| // No bytes were handled, we might not have reached our |
| // granularity, just return and wait for more data |
| break; |
| } |
| } |
| |
| // Flush out any input readers that are donesvn |
| while (CheckIfTopInputReaderIsDone ()) |
| /* Do nothing. */; |
| |
| } |
| |
| void |
| Debugger::PushInputReader (const InputReaderSP& reader_sp) |
| { |
| if (!reader_sp) |
| return; |
| if (!m_input_readers.empty()) |
| { |
| // Deactivate the old top reader |
| InputReaderSP top_reader_sp (m_input_readers.top()); |
| if (top_reader_sp) |
| top_reader_sp->Notify (eInputReaderDeactivate); |
| } |
| m_input_readers.push (reader_sp); |
| reader_sp->Notify (eInputReaderActivate); |
| ActivateInputReader (reader_sp); |
| } |
| |
| bool |
| Debugger::PopInputReader (const lldb::InputReaderSP& pop_reader_sp) |
| { |
| bool result = false; |
| |
| // The reader on the stop of the stack is done, so let the next |
| // read on the stack referesh its prompt and if there is one... |
| if (!m_input_readers.empty()) |
| { |
| InputReaderSP reader_sp(m_input_readers.top()); |
| |
| if (!pop_reader_sp || pop_reader_sp.get() == reader_sp.get()) |
| { |
| m_input_readers.pop (); |
| reader_sp->Notify (eInputReaderDeactivate); |
| reader_sp->Notify (eInputReaderDone); |
| result = true; |
| |
| if (!m_input_readers.empty()) |
| { |
| reader_sp = m_input_readers.top(); |
| if (reader_sp) |
| { |
| ActivateInputReader (reader_sp); |
| reader_sp->Notify (eInputReaderReactivate); |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| bool |
| Debugger::CheckIfTopInputReaderIsDone () |
| { |
| bool result = false; |
| if (!m_input_readers.empty()) |
| { |
| InputReaderSP reader_sp(m_input_readers.top()); |
| |
| if (reader_sp && reader_sp->IsDone()) |
| { |
| result = true; |
| PopInputReader (reader_sp); |
| } |
| } |
| return result; |
| } |
| |
| void |
| Debugger::ActivateInputReader (const InputReaderSP &reader_sp) |
| { |
| FILE *in_fh = GetInputFileHandle(); |
| |
| if (in_fh) |
| { |
| struct termios in_fh_termios; |
| int in_fd = fileno (in_fh); |
| if (::tcgetattr(in_fd, &in_fh_termios) == 0) |
| { |
| if (reader_sp->GetEcho()) |
| in_fh_termios.c_lflag |= ECHO; // Turn on echoing |
| else |
| in_fh_termios.c_lflag &= ~ECHO; // Turn off echoing |
| |
| switch (reader_sp->GetGranularity()) |
| { |
| case eInputReaderGranularityByte: |
| case eInputReaderGranularityWord: |
| in_fh_termios.c_lflag &= ~ICANON; // Get one char at a time |
| break; |
| |
| case eInputReaderGranularityLine: |
| case eInputReaderGranularityAll: |
| in_fh_termios.c_lflag |= ICANON; // Get lines at a time |
| break; |
| |
| default: |
| break; |
| } |
| ::tcsetattr (in_fd, TCSANOW, &in_fh_termios); |
| } |
| } |
| } |
| |
| void |
| Debugger::UpdateExecutionContext (ExecutionContext *override_context) |
| { |
| m_exe_ctx.Clear(); |
| |
| if (override_context != NULL) |
| { |
| m_exe_ctx.target = override_context->target; |
| m_exe_ctx.process = override_context->process; |
| m_exe_ctx.thread = override_context->thread; |
| m_exe_ctx.frame = override_context->frame; |
| } |
| else |
| { |
| TargetSP target_sp (GetSelectedTarget()); |
| if (target_sp) |
| { |
| m_exe_ctx.target = target_sp.get(); |
| m_exe_ctx.process = target_sp->GetProcessSP().get(); |
| if (m_exe_ctx.process && m_exe_ctx.process->IsAlive() && !m_exe_ctx.process->IsRunning()) |
| { |
| m_exe_ctx.thread = m_exe_ctx.process->GetThreadList().GetSelectedThread().get(); |
| if (m_exe_ctx.thread == NULL) |
| { |
| m_exe_ctx.thread = m_exe_ctx.process->GetThreadList().GetThreadAtIndex(0).get(); |
| // If we didn't have a selected thread, select one here. |
| if (m_exe_ctx.thread != NULL) |
| m_exe_ctx.process->GetThreadList().SetSelectedThreadByID(m_exe_ctx.thread->GetID()); |
| } |
| if (m_exe_ctx.thread) |
| { |
| m_exe_ctx.frame = m_exe_ctx.thread->GetSelectedFrame().get(); |
| if (m_exe_ctx.frame == NULL) |
| { |
| m_exe_ctx.frame = m_exe_ctx.thread->GetStackFrameAtIndex (0).get(); |
| // If we didn't have a selected frame select one here. |
| if (m_exe_ctx.frame != NULL) |
| m_exe_ctx.thread->SetSelectedFrame(m_exe_ctx.frame); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| DebuggerSP |
| Debugger::FindDebuggerWithID (lldb::user_id_t id) |
| { |
| lldb::DebuggerSP debugger_sp; |
| |
| Mutex::Locker locker (GetDebuggerListMutex ()); |
| DebuggerList &debugger_list = GetDebuggerList(); |
| DebuggerList::iterator pos, end = debugger_list.end(); |
| for (pos = debugger_list.begin(); pos != end; ++pos) |
| { |
| if ((*pos).get()->GetID() == id) |
| { |
| debugger_sp = *pos; |
| break; |
| } |
| } |
| return debugger_sp; |
| } |
| |
| lldb::UserSettingsControllerSP & |
| Debugger::GetSettingsController (bool finish) |
| { |
| static lldb::UserSettingsControllerSP g_settings_controller (new SettingsController); |
| static bool initialized = false; |
| |
| if (!initialized) |
| { |
| initialized = UserSettingsController::InitializeSettingsController (g_settings_controller, |
| Debugger::SettingsController::global_settings_table, |
| Debugger::SettingsController::instance_settings_table); |
| } |
| |
| if (finish) |
| { |
| UserSettingsControllerSP parent = g_settings_controller->GetParent(); |
| if (parent) |
| parent->RemoveChild (g_settings_controller); |
| g_settings_controller.reset(); |
| } |
| return g_settings_controller; |
| } |
| |
| static void |
| TestPromptFormats (StackFrame *frame) |
| { |
| if (frame == NULL) |
| return; |
| |
| StreamString s; |
| const char *prompt_format = |
| "{addr = '${addr}'\n}" |
| "{process.id = '${process.id}'\n}" |
| "{process.name = '${process.name}'\n}" |
| "{process.file.basename = '${process.file.basename}'\n}" |
| "{process.file.fullpath = '${process.file.fullpath}'\n}" |
| "{thread.id = '${thread.id}'\n}" |
| "{thread.index = '${thread.index}'\n}" |
| "{thread.name = '${thread.name}'\n}" |
| "{thread.queue = '${thread.queue}'\n}" |
| "{thread.stop-reason = '${thread.stop-reason}'\n}" |
| "{target.arch = '${target.arch}'\n}" |
| "{module.file.basename = '${module.file.basename}'\n}" |
| "{module.file.fullpath = '${module.file.fullpath}'\n}" |
| "{file.basename = '${file.basename}'\n}" |
| "{file.fullpath = '${file.fullpath}'\n}" |
| "{frame.index = '${frame.index}'\n}" |
| "{frame.pc = '${frame.pc}'\n}" |
| "{frame.sp = '${frame.sp}'\n}" |
| "{frame.fp = '${frame.fp}'\n}" |
| "{frame.flags = '${frame.flags}'\n}" |
| "{frame.reg.rdi = '${frame.reg.rdi}'\n}" |
| "{frame.reg.rip = '${frame.reg.rip}'\n}" |
| "{frame.reg.rsp = '${frame.reg.rsp}'\n}" |
| "{frame.reg.rbp = '${frame.reg.rbp}'\n}" |
| "{frame.reg.rflags = '${frame.reg.rflags}'\n}" |
| "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}" |
| "{frame.reg.carp = '${frame.reg.carp}'\n}" |
| "{function.id = '${function.id}'\n}" |
| "{function.name = '${function.name}'\n}" |
| "{function.addr-offset = '${function.addr-offset}'\n}" |
| "{function.line-offset = '${function.line-offset}'\n}" |
| "{function.pc-offset = '${function.pc-offset}'\n}" |
| "{line.file.basename = '${line.file.basename}'\n}" |
| "{line.file.fullpath = '${line.file.fullpath}'\n}" |
| "{line.number = '${line.number}'\n}" |
| "{line.start-addr = '${line.start-addr}'\n}" |
| "{line.end-addr = '${line.end-addr}'\n}" |
| ; |
| |
| SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything)); |
| ExecutionContext exe_ctx; |
| frame->CalculateExecutionContext(exe_ctx); |
| const char *end = NULL; |
| if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s, &end)) |
| { |
| printf("%s\n", s.GetData()); |
| } |
| else |
| { |
| printf ("error: at '%s'\n", end); |
| printf ("what we got: %s\n", s.GetData()); |
| } |
| } |
| |
| bool |
| Debugger::FormatPrompt |
| ( |
| const char *format, |
| const SymbolContext *sc, |
| const ExecutionContext *exe_ctx, |
| const Address *addr, |
| Stream &s, |
| const char **end |
| ) |
| { |
| bool success = true; |
| const char *p; |
| for (p = format; *p != '\0'; ++p) |
| { |
| size_t non_special_chars = ::strcspn (p, "${}\\"); |
| if (non_special_chars > 0) |
| { |
| if (success) |
| s.Write (p, non_special_chars); |
| p += non_special_chars; |
| } |
| |
| if (*p == '\0') |
| { |
| break; |
| } |
| else if (*p == '{') |
| { |
| // Start a new scope that must have everything it needs if it is to |
| // to make it into the final output stream "s". If you want to make |
| // a format that only prints out the function or symbol name if there |
| // is one in the symbol context you can use: |
| // "{function =${function.name}}" |
| // The first '{' starts a new scope that end with the matching '}' at |
| // the end of the string. The contents "function =${function.name}" |
| // will then be evaluated and only be output if there is a function |
| // or symbol with a valid name. |
| StreamString sub_strm; |
| |
| ++p; // Skip the '{' |
| |
| if (FormatPrompt (p, sc, exe_ctx, addr, sub_strm, &p)) |
| { |
| // The stream had all it needed |
| s.Write(sub_strm.GetData(), sub_strm.GetSize()); |
| } |
| if (*p != '}') |
| { |
| success = false; |
| break; |
| } |
| } |
| else if (*p == '}') |
| { |
| // End of a enclosing scope |
| break; |
| } |
| else if (*p == '$') |
| { |
| // We have a prompt variable to print |
| ++p; |
| if (*p == '{') |
| { |
| ++p; |
| const char *var_name_begin = p; |
| const char *var_name_end = ::strchr (p, '}'); |
| |
| if (var_name_end && var_name_begin < var_name_end) |
| { |
| // if we have already failed to parse, skip this variable |
| if (success) |
| { |
| const char *cstr = NULL; |
| Address format_addr; |
| bool calculate_format_addr_function_offset = false; |
| // Set reg_kind and reg_num to invalid values |
| RegisterKind reg_kind = kNumRegisterKinds; |
| uint32_t reg_num = LLDB_INVALID_REGNUM; |
| FileSpec format_file_spec; |
| const lldb::RegisterInfo *reg_info = NULL; |
| RegisterContext *reg_ctx = NULL; |
| |
| // Each variable must set success to true below... |
| bool var_success = false; |
| switch (var_name_begin[0]) |
| { |
| case 'a': |
| if (::strncmp (var_name_begin, "addr}", strlen("addr}")) == 0) |
| { |
| if (addr && addr->IsValid()) |
| { |
| var_success = true; |
| format_addr = *addr; |
| } |
| } |
| break; |
| |
| case 'p': |
| if (::strncmp (var_name_begin, "process.", strlen("process.")) == 0) |
| { |
| if (exe_ctx && exe_ctx->process != NULL) |
| { |
| var_name_begin += ::strlen ("process."); |
| if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) |
| { |
| s.Printf("%i", exe_ctx->process->GetID()); |
| var_success = true; |
| } |
| else if ((::strncmp (var_name_begin, "name}", strlen("name}")) == 0) || |
| (::strncmp (var_name_begin, "file.basename}", strlen("file.basename}")) == 0) || |
| (::strncmp (var_name_begin, "file.fullpath}", strlen("file.fullpath}")) == 0)) |
| { |
| ModuleSP exe_module_sp (exe_ctx->process->GetTarget().GetExecutableModule()); |
| if (exe_module_sp) |
| { |
| if (var_name_begin[0] == 'n' || var_name_begin[5] == 'f') |
| { |
| format_file_spec.GetFilename() = exe_module_sp->GetFileSpec().GetFilename(); |
| var_success = format_file_spec; |
| } |
| else |
| { |
| format_file_spec = exe_module_sp->GetFileSpec(); |
| var_success = format_file_spec; |
| } |
| } |
| } |
| } |
| } |
| break; |
| |
| case 't': |
| if (::strncmp (var_name_begin, "thread.", strlen("thread.")) == 0) |
| { |
| if (exe_ctx && exe_ctx->thread) |
| { |
| var_name_begin += ::strlen ("thread."); |
| if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) |
| { |
| s.Printf("0x%4.4x", exe_ctx->thread->GetID()); |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0) |
| { |
| s.Printf("%u", exe_ctx->thread->GetIndexID()); |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0) |
| { |
| cstr = exe_ctx->thread->GetName(); |
| var_success = cstr && cstr[0]; |
| if (var_success) |
| s.PutCString(cstr); |
| } |
| else if (::strncmp (var_name_begin, "queue}", strlen("queue}")) == 0) |
| { |
| cstr = exe_ctx->thread->GetQueueName(); |
| var_success = cstr && cstr[0]; |
| if (var_success) |
| s.PutCString(cstr); |
| } |
| else if (::strncmp (var_name_begin, "stop-reason}", strlen("stop-reason}")) == 0) |
| { |
| lldb_private::StopInfo *stop_info = exe_ctx->thread->GetStopInfo (); |
| if (stop_info) |
| { |
| cstr = stop_info->GetDescription(); |
| if (cstr && cstr[0]) |
| { |
| s.PutCString(cstr); |
| var_success = true; |
| } |
| } |
| } |
| } |
| } |
| else if (::strncmp (var_name_begin, "target.", strlen("target.")) == 0) |
| { |
| Target *target = Target::GetTargetFromContexts (exe_ctx, sc); |
| if (target) |
| { |
| var_name_begin += ::strlen ("target."); |
| if (::strncmp (var_name_begin, "arch}", strlen("arch}")) == 0) |
| { |
| ArchSpec arch (target->GetArchitecture ()); |
| if (arch.IsValid()) |
| { |
| s.PutCString (arch.AsCString()); |
| var_success = true; |
| } |
| } |
| } |
| } |
| break; |
| |
| |
| case 'm': |
| if (::strncmp (var_name_begin, "module.", strlen("module.")) == 0) |
| { |
| if (sc && sc->module_sp.get()) |
| { |
| Module *module = sc->module_sp.get(); |
| var_name_begin += ::strlen ("module."); |
| |
| if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) |
| { |
| if (module->GetFileSpec()) |
| { |
| var_name_begin += ::strlen ("file."); |
| |
| if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) |
| { |
| format_file_spec.GetFilename() = module->GetFileSpec().GetFilename(); |
| var_success = format_file_spec; |
| } |
| else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) |
| { |
| format_file_spec = module->GetFileSpec(); |
| var_success = format_file_spec; |
| } |
| } |
| } |
| } |
| } |
| break; |
| |
| |
| case 'f': |
| if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) |
| { |
| if (sc && sc->comp_unit != NULL) |
| { |
| var_name_begin += ::strlen ("file."); |
| |
| if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) |
| { |
| format_file_spec.GetFilename() = sc->comp_unit->GetFilename(); |
| var_success = format_file_spec; |
| } |
| else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) |
| { |
| format_file_spec = *sc->comp_unit; |
| var_success = format_file_spec; |
| } |
| } |
| } |
| else if (::strncmp (var_name_begin, "frame.", strlen("frame.")) == 0) |
| { |
| if (exe_ctx && exe_ctx->frame) |
| { |
| var_name_begin += ::strlen ("frame."); |
| if (::strncmp (var_name_begin, "index}", strlen("index}")) == 0) |
| { |
| s.Printf("%u", exe_ctx->frame->GetFrameIndex()); |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "pc}", strlen("pc}")) == 0) |
| { |
| reg_kind = eRegisterKindGeneric; |
| reg_num = LLDB_REGNUM_GENERIC_PC; |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "sp}", strlen("sp}")) == 0) |
| { |
| reg_kind = eRegisterKindGeneric; |
| reg_num = LLDB_REGNUM_GENERIC_SP; |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "fp}", strlen("fp}")) == 0) |
| { |
| reg_kind = eRegisterKindGeneric; |
| reg_num = LLDB_REGNUM_GENERIC_FP; |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "flags}", strlen("flags}")) == 0) |
| { |
| reg_kind = eRegisterKindGeneric; |
| reg_num = LLDB_REGNUM_GENERIC_FLAGS; |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "reg.", strlen ("reg.")) == 0) |
| { |
| reg_ctx = exe_ctx->frame->GetRegisterContext(); |
| if (reg_ctx) |
| { |
| var_name_begin += ::strlen ("reg."); |
| if (var_name_begin < var_name_end) |
| { |
| std::string reg_name (var_name_begin, var_name_end); |
| reg_info = reg_ctx->GetRegisterInfoByName (reg_name.c_str()); |
| if (reg_info) |
| var_success = true; |
| } |
| } |
| } |
| } |
| } |
| else if (::strncmp (var_name_begin, "function.", strlen("function.")) == 0) |
| { |
| if (sc && (sc->function != NULL || sc->symbol != NULL)) |
| { |
| var_name_begin += ::strlen ("function."); |
| if (::strncmp (var_name_begin, "id}", strlen("id}")) == 0) |
| { |
| if (sc->function) |
| s.Printf("function{0x%8.8x}", sc->function->GetID()); |
| else |
| s.Printf("symbol[%u]", sc->symbol->GetID()); |
| |
| var_success = true; |
| } |
| else if (::strncmp (var_name_begin, "name}", strlen("name}")) == 0) |
| { |
| if (sc->function) |
| cstr = sc->function->GetName().AsCString (NULL); |
| else if (sc->symbol) |
| cstr = sc->symbol->GetName().AsCString (NULL); |
| if (cstr) |
| { |
| s.PutCString(cstr); |
| |
| if (sc->block) |
| { |
| Block *inline_block = sc->block->GetContainingInlinedBlock (); |
| if (inline_block) |
| { |
| const InlineFunctionInfo *inline_info = sc->block->GetInlinedFunctionInfo(); |
| if (inline_info) |
| { |
| s.PutCString(" [inlined] "); |
| inline_info->GetName().Dump(&s); |
| } |
| } |
| } |
| var_success = true; |
| } |
| } |
| else if (::strncmp (var_name_begin, "addr-offset}", strlen("addr-offset}")) == 0) |
| { |
| var_success = addr != NULL; |
| if (var_success) |
| { |
| format_addr = *addr; |
| calculate_format_addr_function_offset = true; |
| } |
| } |
| else if (::strncmp (var_name_begin, "line-offset}", strlen("line-offset}")) == 0) |
| { |
| var_success = sc->line_entry.range.GetBaseAddress().IsValid(); |
| if (var_success) |
| { |
| format_addr = sc->line_entry.range.GetBaseAddress(); |
| calculate_format_addr_function_offset = true; |
| } |
| } |
| else if (::strncmp (var_name_begin, "pc-offset}", strlen("pc-offset}")) == 0) |
| { |
| var_success = exe_ctx->frame; |
| if (var_success) |
| { |
| format_addr = exe_ctx->frame->GetFrameCodeAddress(); |
| calculate_format_addr_function_offset = true; |
| } |
| } |
| } |
| } |
| break; |
| |
| case 'l': |
| if (::strncmp (var_name_begin, "line.", strlen("line.")) == 0) |
| { |
| if (sc && sc->line_entry.IsValid()) |
| { |
| var_name_begin += ::strlen ("line."); |
| if (::strncmp (var_name_begin, "file.", strlen("file.")) == 0) |
| { |
| var_name_begin += ::strlen ("file."); |
| |
| if (::strncmp (var_name_begin, "basename}", strlen("basename}")) == 0) |
| { |
| format_file_spec.GetFilename() = sc->line_entry.file.GetFilename(); |
| var_success = format_file_spec; |
| } |
| else if (::strncmp (var_name_begin, "fullpath}", strlen("fullpath}")) == 0) |
| { |
| format_file_spec = sc->line_entry.file; |
| var_success = format_file_spec; |
| } |
| } |
| else if (::strncmp (var_name_begin, "number}", strlen("number}")) == 0) |
| { |
| var_success = true; |
| s.Printf("%u", sc->line_entry.line); |
| } |
| else if ((::strncmp (var_name_begin, "start-addr}", strlen("start-addr}")) == 0) || |
| (::strncmp (var_name_begin, "end-addr}", strlen("end-addr}")) == 0)) |
| { |
| var_success = sc && sc->line_entry.range.GetBaseAddress().IsValid(); |
| if (var_success) |
| { |
| format_addr = sc->line_entry.range.GetBaseAddress(); |
| if (var_name_begin[0] == 'e') |
| format_addr.Slide (sc->line_entry.range.GetByteSize()); |
| } |
| } |
| } |
| } |
| break; |
| } |
| |
| if (var_success) |
| { |
| // If format addr is valid, then we need to print an address |
| if (reg_num != LLDB_INVALID_REGNUM) |
| { |
| // We have a register value to display... |
| if (reg_num == LLDB_REGNUM_GENERIC_PC && reg_kind == eRegisterKindGeneric) |
| { |
| format_addr = exe_ctx->frame->GetFrameCodeAddress(); |
| } |
| else |
| { |
| if (reg_ctx == NULL) |
| reg_ctx = exe_ctx->frame->GetRegisterContext(); |
| |
| if (reg_ctx) |
| { |
| if (reg_kind != kNumRegisterKinds) |
| reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num); |
| reg_info = reg_ctx->GetRegisterInfoAtIndex (reg_num); |
| var_success = reg_info != NULL; |
| } |
| } |
| } |
| |
| if (reg_info != NULL) |
| { |
| DataExtractor reg_data; |
| var_success = reg_ctx->ReadRegisterBytes (reg_info->kinds[eRegisterKindLLDB], reg_data); |
| { |
| reg_data.Dump(&s, 0, reg_info->format, reg_info->byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); |
| } |
| } |
| |
| if (format_file_spec) |
| { |
| s << format_file_spec; |
| } |
| |
| // If format addr is valid, then we need to print an address |
| if (format_addr.IsValid()) |
| { |
| var_success = false; |
| |
| if (calculate_format_addr_function_offset) |
| { |
| Address func_addr; |
| |
| if (sc) |
| { |
| if (sc->function) |
| { |
| func_addr = sc->function->GetAddressRange().GetBaseAddress(); |
| if (sc->block) |
| { |
| // Check to make sure we aren't in an inline |
| // function. If we are, use the inline block |
| // range that contains "format_addr" since |
| // blocks can be discontiguous. |
| Block *inline_block = sc->block->GetContainingInlinedBlock (); |
| AddressRange inline_range; |
| if (inline_block && inline_block->GetRangeContainingAddress (format_addr, inline_range)) |
| func_addr = inline_range.GetBaseAddress(); |
| } |
| } |
| else if (sc->symbol && sc->symbol->GetAddressRangePtr()) |
| func_addr = sc->symbol->GetAddressRangePtr()->GetBaseAddress(); |
| } |
| |
| if (func_addr.IsValid()) |
| { |
| if (func_addr.GetSection() == format_addr.GetSection()) |
| { |
| addr_t func_file_addr = func_addr.GetFileAddress(); |
| addr_t addr_file_addr = format_addr.GetFileAddress(); |
| if (addr_file_addr > func_file_addr) |
| s.Printf(" + %llu", addr_file_addr - func_file_addr); |
| else if (addr_file_addr < func_file_addr) |
| s.Printf(" - %llu", func_file_addr - addr_file_addr); |
| var_success = true; |
| } |
| else |
| { |
| Target *target = Target::GetTargetFromContexts (exe_ctx, sc); |
| if (target) |
| { |
| addr_t func_load_addr = func_addr.GetLoadAddress (target); |
| addr_t addr_load_addr = format_addr.GetLoadAddress (target); |
| if (addr_load_addr > func_load_addr) |
| s.Printf(" + %llu", addr_load_addr - func_load_addr); |
| else if (addr_load_addr < func_load_addr) |
| s.Printf(" - %llu", func_load_addr - addr_load_addr); |
| var_success = true; |
| } |
| } |
| } |
| } |
| else |
| { |
| Target *target = Target::GetTargetFromContexts (exe_ctx, sc); |
| addr_t vaddr = LLDB_INVALID_ADDRESS; |
| if (exe_ctx && !target->GetSectionLoadList().IsEmpty()) |
| vaddr = format_addr.GetLoadAddress (target); |
| if (vaddr == LLDB_INVALID_ADDRESS) |
| vaddr = format_addr.GetFileAddress (); |
| |
| if (vaddr != LLDB_INVALID_ADDRESS) |
| { |
| s.Printf("0x%16.16llx", vaddr); |
| var_success = true; |
| } |
| } |
| } |
| } |
| |
| if (var_success == false) |
| success = false; |
| } |
| p = var_name_end; |
| } |
| else |
| break; |
| } |
| else |
| { |
| // We got a dollar sign with no '{' after it, it must just be a dollar sign |
| s.PutChar(*p); |
| } |
| } |
| else if (*p == '\\') |
| { |
| ++p; // skip the slash |
| switch (*p) |
| { |
| case 'a': s.PutChar ('\a'); break; |
| case 'b': s.PutChar ('\b'); break; |
| case 'f': s.PutChar ('\f'); break; |
| case 'n': s.PutChar ('\n'); break; |
| case 'r': s.PutChar ('\r'); break; |
| case 't': s.PutChar ('\t'); break; |
| case 'v': s.PutChar ('\v'); break; |
| case '\'': s.PutChar ('\''); break; |
| case '\\': s.PutChar ('\\'); break; |
| case '0': |
| // 1 to 3 octal chars |
| { |
| // Make a string that can hold onto the initial zero char, |
| // up to 3 octal digits, and a terminating NULL. |
| char oct_str[5] = { 0, 0, 0, 0, 0 }; |
| |
| int i; |
| for (i=0; (p[i] >= '0' && p[i] <= '7') && i<4; ++i) |
| oct_str[i] = p[i]; |
| |
| // We don't want to consume the last octal character since |
| // the main for loop will do this for us, so we advance p by |
| // one less than i (even if i is zero) |
| p += i - 1; |
| unsigned long octal_value = ::strtoul (oct_str, NULL, 8); |
| if (octal_value <= UINT8_MAX) |
| { |
| char octal_char = octal_value; |
| s.Write (&octal_char, 1); |
| } |
| } |
| break; |
| |
| case 'x': |
| // hex number in the format |
| if (isxdigit(p[1])) |
| { |
| ++p; // Skip the 'x' |
| |
| // Make a string that can hold onto two hex chars plus a |
| // NULL terminator |
| char hex_str[3] = { 0,0,0 }; |
| hex_str[0] = *p; |
| if (isxdigit(p[1])) |
| { |
| ++p; // Skip the first of the two hex chars |
| hex_str[1] = *p; |
| } |
| |
| unsigned long hex_value = strtoul (hex_str, NULL, 16); |
| if (hex_value <= UINT8_MAX) |
| s.PutChar (hex_value); |
| } |
| else |
| { |
| s.PutChar('x'); |
| } |
| break; |
| |
| default: |
| // Just desensitize any other character by just printing what |
| // came after the '\' |
| s << *p; |
| break; |
| |
| } |
| |
| } |
| } |
| if (end) |
| *end = p; |
| return success; |
| } |
| |
| #pragma mark Debugger::SettingsController |
| |
| //-------------------------------------------------- |
| // class Debugger::SettingsController |
| //-------------------------------------------------- |
| |
| Debugger::SettingsController::SettingsController () : |
| UserSettingsController ("", lldb::UserSettingsControllerSP()) |
| { |
| m_default_settings.reset (new DebuggerInstanceSettings (*this, false, |
| InstanceSettings::GetDefaultName().AsCString())); |
| } |
| |
| Debugger::SettingsController::~SettingsController () |
| { |
| } |
| |
| |
| lldb::InstanceSettingsSP |
| Debugger::SettingsController::CreateInstanceSettings (const char *instance_name) |
| { |
| DebuggerInstanceSettings *new_settings = new DebuggerInstanceSettings (*(Debugger::GetSettingsController().get()), |
| false, instance_name); |
| lldb::InstanceSettingsSP new_settings_sp (new_settings); |
| return new_settings_sp; |
| } |
| |
| #pragma mark DebuggerInstanceSettings |
| //-------------------------------------------------- |
| // class DebuggerInstanceSettings |
| //-------------------------------------------------- |
| |
| DebuggerInstanceSettings::DebuggerInstanceSettings |
| ( |
| UserSettingsController &owner, |
| bool live_instance, |
| const char *name |
| ) : |
| InstanceSettings (owner, (name == NULL ? InstanceSettings::InvalidName().AsCString() : name), live_instance), |
| m_term_width (80), |
| m_prompt (), |
| m_frame_format (), |
| m_thread_format (), |
| m_script_lang (), |
| m_use_external_editor (false) |
| { |
| // CopyInstanceSettings is a pure virtual function in InstanceSettings; it therefore cannot be called |
| // until the vtables for DebuggerInstanceSettings are properly set up, i.e. AFTER all the initializers. |
| // For this reason it has to be called here, rather than in the initializer or in the parent constructor. |
| // The same is true of CreateInstanceName(). |
| |
| if (GetInstanceName() == InstanceSettings::InvalidName()) |
| { |
| ChangeInstanceName (std::string (CreateInstanceName().AsCString())); |
| m_owner.RegisterInstanceSettings (this); |
| } |
| |
| if (live_instance) |
| { |
| const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); |
| CopyInstanceSettings (pending_settings, false); |
| } |
| } |
| |
| DebuggerInstanceSettings::DebuggerInstanceSettings (const DebuggerInstanceSettings &rhs) : |
| InstanceSettings (*(Debugger::GetSettingsController().get()), CreateInstanceName ().AsCString()), |
| m_prompt (rhs.m_prompt), |
| m_frame_format (rhs.m_frame_format), |
| m_thread_format (rhs.m_thread_format), |
| m_script_lang (rhs.m_script_lang), |
| m_use_external_editor (rhs.m_use_external_editor) |
| { |
| const lldb::InstanceSettingsSP &pending_settings = m_owner.FindPendingSettings (m_instance_name); |
| CopyInstanceSettings (pending_settings, false); |
| m_owner.RemovePendingSettings (m_instance_name); |
| } |
| |
| DebuggerInstanceSettings::~DebuggerInstanceSettings () |
| { |
| } |
| |
| DebuggerInstanceSettings& |
| DebuggerInstanceSettings::operator= (const DebuggerInstanceSettings &rhs) |
| { |
| if (this != &rhs) |
| { |
| m_term_width = rhs.m_term_width; |
| m_prompt = rhs.m_prompt; |
| m_frame_format = rhs.m_frame_format; |
| m_thread_format = rhs.m_thread_format; |
| m_script_lang = rhs.m_script_lang; |
| m_use_external_editor = rhs.m_use_external_editor; |
| } |
| |
| return *this; |
| } |
| |
| bool |
| DebuggerInstanceSettings::ValidTermWidthValue (const char *value, Error err) |
| { |
| bool valid = false; |
| |
| // Verify we have a value string. |
| if (value == NULL || value[0] == '\0') |
| { |
| err.SetErrorString ("Missing value. Can't set terminal width without a value.\n"); |
| } |
| else |
| { |
| char *end = NULL; |
| const uint32_t width = ::strtoul (value, &end, 0); |
| |
| if (end && end[0] == '\0') |
| { |
| if (width >= 10 && width <= 1024) |
| valid = true; |
| else |
| err.SetErrorString ("Invalid term-width value; value must be between 10 and 1024.\n"); |
| } |
| else |
| err.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string.\n", value); |
| } |
| |
| return valid; |
| } |
| |
| |
| void |
| DebuggerInstanceSettings::UpdateInstanceSettingsVariable (const ConstString &var_name, |
| const char *index_value, |
| const char *value, |
| const ConstString &instance_name, |
| const SettingEntry &entry, |
| lldb::VarSetOperationType op, |
| Error &err, |
| bool pending) |
| { |
| |
| if (var_name == TermWidthVarName()) |
| { |
| if (ValidTermWidthValue (value, err)) |
| { |
| m_term_width = ::strtoul (value, NULL, 0); |
| } |
| } |
| else if (var_name == PromptVarName()) |
| { |
| UserSettingsController::UpdateStringVariable (op, m_prompt, value, err); |
| if (!pending) |
| { |
| // 'instance_name' is actually (probably) in the form '[<instance_name>]'; if so, we need to |
| // strip off the brackets before passing it to BroadcastPromptChange. |
| |
| std::string tmp_instance_name (instance_name.AsCString()); |
| if ((tmp_instance_name[0] == '[') |
| && (tmp_instance_name[instance_name.GetLength() - 1] == ']')) |
| tmp_instance_name = tmp_instance_name.substr (1, instance_name.GetLength() - 2); |
| ConstString new_name (tmp_instance_name.c_str()); |
| |
| BroadcastPromptChange (new_name, m_prompt.c_str()); |
| } |
| } |
| else if (var_name == GetFrameFormatName()) |
| { |
| UserSettingsController::UpdateStringVariable (op, m_frame_format, value, err); |
| } |
| else if (var_name == GetThreadFormatName()) |
| { |
| UserSettingsController::UpdateStringVariable (op, m_thread_format, value, err); |
| } |
| else if (var_name == ScriptLangVarName()) |
| { |
| bool success; |
| m_script_lang = Args::StringToScriptLanguage (value, eScriptLanguageDefault, |
| &success); |
| } |
| else if (var_name == UseExternalEditorVarName ()) |
| { |
| UserSettingsController::UpdateBooleanVariable (op, m_use_external_editor, value, err); |
| } |
| } |
| |
| bool |
| DebuggerInstanceSettings::GetInstanceSettingsValue (const SettingEntry &entry, |
| const ConstString &var_name, |
| StringList &value, |
| Error *err) |
| { |
| if (var_name == PromptVarName()) |
| { |
| value.AppendString (m_prompt.c_str(), m_prompt.size()); |
| |
| } |
| else if (var_name == ScriptLangVarName()) |
| { |
| value.AppendString (ScriptInterpreter::LanguageToString (m_script_lang).c_str()); |
| } |
| else if (var_name == TermWidthVarName()) |
| { |
| StreamString width_str; |
| width_str.Printf ("%d", m_term_width); |
| value.AppendString (width_str.GetData()); |
| } |
| else if (var_name == GetFrameFormatName ()) |
| { |
| value.AppendString(m_frame_format.c_str(), m_frame_format.size()); |
| } |
| else if (var_name == GetThreadFormatName ()) |
| { |
| value.AppendString(m_thread_format.c_str(), m_thread_format.size()); |
| } |
| else if (var_name == UseExternalEditorVarName()) |
| { |
| if (m_use_external_editor) |
| value.AppendString ("true"); |
| else |
| value.AppendString ("false"); |
| } |
| else |
| { |
| if (err) |
| err->SetErrorStringWithFormat ("unrecognized variable name '%s'", var_name.AsCString()); |
| return false; |
| } |
| return true; |
| } |
| |
| void |
| DebuggerInstanceSettings::CopyInstanceSettings (const lldb::InstanceSettingsSP &new_settings, |
| bool pending) |
| { |
| if (new_settings.get() == NULL) |
| return; |
| |
| DebuggerInstanceSettings *new_debugger_settings = (DebuggerInstanceSettings *) new_settings.get(); |
| |
| m_prompt = new_debugger_settings->m_prompt; |
| if (!pending) |
| { |
| // 'instance_name' is actually (probably) in the form '[<instance_name>]'; if so, we need to |
| // strip off the brackets before passing it to BroadcastPromptChange. |
| |
| std::string tmp_instance_name (m_instance_name.AsCString()); |
| if ((tmp_instance_name[0] == '[') |
| && (tmp_instance_name[m_instance_name.GetLength() - 1] == ']')) |
| tmp_instance_name = tmp_instance_name.substr (1, m_instance_name.GetLength() - 2); |
| ConstString new_name (tmp_instance_name.c_str()); |
| |
| BroadcastPromptChange (new_name, m_prompt.c_str()); |
| } |
| m_frame_format = new_debugger_settings->m_frame_format; |
| m_thread_format = new_debugger_settings->m_thread_format; |
| m_term_width = new_debugger_settings->m_term_width; |
| m_script_lang = new_debugger_settings->m_script_lang; |
| m_use_external_editor = new_debugger_settings->m_use_external_editor; |
| } |
| |
| |
| bool |
| DebuggerInstanceSettings::BroadcastPromptChange (const ConstString &instance_name, const char *new_prompt) |
| { |
| std::string tmp_prompt; |
| |
| if (new_prompt != NULL) |
| { |
| tmp_prompt = new_prompt ; |
| int len = tmp_prompt.size(); |
| if (len > 1 |
| && (tmp_prompt[0] == '\'' || tmp_prompt[0] == '"') |
| && (tmp_prompt[len-1] == tmp_prompt[0])) |
| { |
| tmp_prompt = tmp_prompt.substr(1,len-2); |
| } |
| len = tmp_prompt.size(); |
| if (tmp_prompt[len-1] != ' ') |
| tmp_prompt.append(" "); |
| } |
| EventSP new_event_sp; |
| new_event_sp.reset (new Event(CommandInterpreter::eBroadcastBitResetPrompt, |
| new EventDataBytes (tmp_prompt.c_str()))); |
| |
| if (instance_name.GetLength() != 0) |
| { |
| // Set prompt for a particular instance. |
| Debugger *dbg = Debugger::FindDebuggerWithInstanceName (instance_name).get(); |
| if (dbg != NULL) |
| { |
| dbg->GetCommandInterpreter().BroadcastEvent (new_event_sp); |
| } |
| } |
| |
| return true; |
| } |
| |
| const ConstString |
| DebuggerInstanceSettings::CreateInstanceName () |
| { |
| static int instance_count = 1; |
| StreamString sstr; |
| |
| sstr.Printf ("debugger_%d", instance_count); |
| ++instance_count; |
| |
| const ConstString ret_val (sstr.GetData()); |
| |
| return ret_val; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::PromptVarName () |
| { |
| static ConstString prompt_var_name ("prompt"); |
| |
| return prompt_var_name; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::GetFrameFormatName () |
| { |
| static ConstString prompt_var_name ("frame-format"); |
| |
| return prompt_var_name; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::GetThreadFormatName () |
| { |
| static ConstString prompt_var_name ("thread-format"); |
| |
| return prompt_var_name; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::ScriptLangVarName () |
| { |
| static ConstString script_lang_var_name ("script-lang"); |
| |
| return script_lang_var_name; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::TermWidthVarName () |
| { |
| static ConstString term_width_var_name ("term-width"); |
| |
| return term_width_var_name; |
| } |
| |
| const ConstString & |
| DebuggerInstanceSettings::UseExternalEditorVarName () |
| { |
| static ConstString use_external_editor_var_name ("use-external-editor"); |
| |
| return use_external_editor_var_name; |
| } |
| |
| //-------------------------------------------------- |
| // SettingsController Variable Tables |
| //-------------------------------------------------- |
| |
| |
| SettingEntry |
| Debugger::SettingsController::global_settings_table[] = |
| { |
| //{ "var-name", var-type, "default", enum-table, init'd, hidden, "help-text"}, |
| // The Debugger level global table should always be empty; all Debugger settable variables should be instance |
| // variables. |
| { NULL, eSetVarTypeNone, NULL, NULL, 0, 0, NULL } |
| }; |
| |
| #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name}${function.pc-offset}}}" |
| #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}" |
| |
| #define DEFAULT_THREAD_FORMAT "thread #${thread.index}: tid = ${thread.id}"\ |
| "{, ${frame.pc}}"\ |
| MODULE_WITH_FUNC\ |
| FILE_AND_LINE\ |
| "{, stop reason = ${thread.stop-reason}}"\ |
| "{, name = ${thread.name}}"\ |
| "{, queue = ${thread.queue}}"\ |
| "\\n" |
| |
| #define DEFAULT_FRAME_FORMAT "frame #${frame.index}: ${frame.pc}"\ |
| MODULE_WITH_FUNC\ |
| FILE_AND_LINE\ |
| "\\n" |
| |
| SettingEntry |
| Debugger::SettingsController::instance_settings_table[] = |
| { |
| // NAME Setting variable type Default Enum Init'd Hidden Help |
| // ======================= ======================= ====================== ==== ====== ====== ====================== |
| { "term-width", eSetVarTypeInt, "80" , NULL, false, false, "The maximum number of columns to use for displaying text." }, |
| { "script-lang", eSetVarTypeString, "python", NULL, false, false, "The script language to be used for evaluating user-written scripts." }, |
| { "prompt", eSetVarTypeString, "(lldb)", NULL, false, false, "The debugger command line prompt displayed for the user." }, |
| { "frame-format", eSetVarTypeString, DEFAULT_FRAME_FORMAT, NULL, false, false, "The default frame format string to use when displaying thread information." }, |
| { "thread-format", eSetVarTypeString, DEFAULT_THREAD_FORMAT, NULL, false, false, "The default thread format string to use when displaying thread information." }, |
| { "use-external-editor", eSetVarTypeBool, "false", NULL, false, false, "Whether to use an external editor or not." }, |
| { NULL, eSetVarTypeNone, NULL, NULL, false, false, NULL } |
| }; |