Preliminary patch to support prompt interpolation

[nealsid]

Summary

The infrastructure for interpolating format strings for the stacks and frames is very useful, so I thought it would also be useful to support this in interpolating the prompt string. So you can define a prompt like this:

(lldb) settings set prompt "${process.file.basename} T:${thread.index}/${thread.count} F:${frame.index1based}/${frame.count}) "

And the next prompt would be something like this:

casn T:1/1 F:1/1)

This is very preliminary as I am new to the LLDB code base, so I would welcome any and all feedback and suggestions. I plan to write tests and flesh out the error handling but wanted to get some eyes on this to help guide the remainder of the work, if people think it's useful. If not, I'm happy to tackle something else that could be more useful to the project.

[zturner]

include/lldb/Host/Editline.h

187

I'd love to stop using the baton idiom if possible. can you make this function take an llvm::function_ref<StringRef (EditLine*)> instead? Then, in the class, store a std::function<StringRef (EditLine*)>. When you call SetPromptCallback, write SetPromptCallback([this](EditLine* L) { return this->PromptCallback(L); });

include/lldb/Interpreter/PromptInterpolation.h

27

As it stands, the class doesn't really do much. It's basically just one function, and the only purpose of the m_debugger member is to avoid having to pass the Debugger object as an argument to the function. It seems this could just be turned into a free function. And while we're at it, since that free function is only ever used inside of IOHandler.cpp, it can probably just be marked static and be a global function defined in that particular TU.

source/Core/IOHandler.cpp

451

This can return a StringRef

[clayborg]

This will be very cool. Biggest issues to watch out for is to make sure it doesn't return incorrect values when running for things like the thread count. If you switch to use the "m_debugger.GetCommandInterpreter().GetExecutionContext()" it should solve this by making sure the frame and thread are not filled in when the process is running. It might also be racy. For example if you say "continue", hopefully the process will be resumed by the time the prompt is asked to refresh itself. Since we get events asynchronously this might be a problem.

include/lldb/Core/FormatEntity.h

86

Rename to FrameIndexID. It is similar to the thread index ID which is one based.

include/lldb/Core/IOHandler.h

456

If this will only contain a prompt that is a format string, you should store the compiled format so we don't have to parse it each time the prompt is displayed. Maybe this should be:

FormatEntity::Entry m_prompt_format;

include/lldb/Host/Editline.h

93

Remove whitespace

source/Core/FormatEntity.cpp

125

rename to "index_id" and fix enum to FrameIndexID

357

FrameIndexID

1443

FrameIndexID

source/Interpreter/PromptInterpolation.cpp

1

Not sure this file is needed?

33–46

Remove all of this and just call:

ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();

It will do the right thing and leave the thread and frame out of the context if we are running. There is no need to fallback to using kFallbackPrompt. You can make your prompt hardened against values not being available. Lets say the thread count isn't available: you can just put extra {} around the string that contains the thread count like:

"{num threads = ${thread.count}}"

If any variable inside the extra scope is not available, it will be left out. So there should be no need to use a fallback if the prompt is made correctly.

50

This should be parsed once and kept around. Not parsed every time the prompt is displayed.

[labath]

Sounds like a nice feature to have. In addition to the other feedback you've received, I'd suggest splitting out the addition of new format entities (frame count and friends) and the core interpolation feature into separate patches.

[nealsid]

include/lldb/Host/Editline.h

187

Sounds good to me. I'll split up the changes and sent a patch that migrates to std::function & removes baton from all callbacks in Editline first and then rebase this one on top of that.

[nealsid]

In D49963#1183036, @clayborg wrote:

This will be very cool. Biggest issues to watch out for is to make sure it doesn't return incorrect values when running for things like the thread count. If you switch to use the "m_debugger.GetCommandInterpreter().GetExecutionContext()" it should solve this by making sure the frame and thread are not filled in when the process is running. It might also be racy. For example if you say "continue", hopefully the process will be resumed by the time the prompt is asked to refresh itself. Since we get events asynchronously this might be a problem.

Nice - TBH, I haven't used LLDB in awhile so having the prompt displayed while the target is running wasn't on my list of test cases, but I'll definitely add it.
Perhaps there could also be an indicator like '*' in the prompt when the process is currently running so the user will know it's potentially out of date.

include/lldb/Core/FormatEntity.h

       ThreadID,
       ThreadProtocolID,
       ThreadIndexID,
+      ThreadCount,
       ThreadName,
       ThreadQueue,
       ThreadStopReason,

       File,
       Lang,
       FrameIndex,
+      FrameIndex1Based,
+      FrameCount,
       FrameNoDebug,
       FrameRegisterPC,
       FrameRegisterSP,

include/lldb/Core/IOHandler.h

 
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Host/Predicate.h"
+#include "lldb/Interpreter/PromptInterpolation.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Stream.h"

                                   const char *last_char,
                                   int skip_first_n_matches, int max_matches,
                                   StringList &matches, void *baton);
+
+  static const char* PromptCallback(Editline *editline, void *baton);
 #endif
 
 protected:

   std::unique_ptr<Editline> m_editline_ap;
 #endif
   IOHandlerDelegate &m_delegate;
+  PromptInterpolation m_prompt_interpolator;
   std::string m_prompt;
   std::string m_continuation_prompt;
   StringList *m_current_lines_ptr;

   bool m_interrupt_exits;
   bool m_editing; // Set to true when fetching a line manually (not using
                   // libedit)
+private:
+  std::string m_prompt_string;
 };
 
 // The order of base classes is important. Look at the constructor of

include/lldb/Host/Editline.h

 class EditlineHistory;
 
 typedef std::shared_ptr<EditlineHistory> EditlineHistorySP;
   
 typedef bool (*IsInputCompleteCallbackType)(Editline *editline,
                                             StringList &lines, void *baton);
 

                                     int skip_first_n_matches, int max_matches,
                                     StringList &matches, void *baton);
 
+typedef const char *(*PromptCallbackType)(Editline *editline,
+                                          void *baton);
+
 /// Status used to decide when and how to start editing another line in
 /// multi-line sessions
 enum class EditorStatus {

   /// Cancel this edit and oblitarate all trace of it
   bool Cancel();
 
+  /// Register a callback to retrieve the prompt.
+  void SetPromptCallback(PromptCallbackType callback, void *baton);
+  
   /// Register a callback for the tab key
   void SetAutoCompleteCallback(CompleteCallbackType callback, void *baton);
 

 
   bool CompleteCharacter(char ch, EditLineGetCharType &out);
 
+  const char* InvokePromptCallback();
+
 private:
 #if LLDB_EDITLINE_USE_WCHAR
   std::wstring_convert<std::codecvt_utf8<wchar_t>> m_utf8conv;

   const char *m_fix_indentation_callback_chars = nullptr;
   CompleteCallbackType m_completion_callback = nullptr;
   void *m_completion_callback_baton = nullptr;
-
+  PromptCallbackType m_prompt_callback = nullptr;
+  void *m_prompt_callback_baton = nullptr;
   std::mutex m_output_mutex;
 };
 }

include/lldb/Interpreter/PromptInterpolation.h

+//===-- PromptInterpolation.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_PromptInterpolation_h_
+#define liblldb_PromptInterpolation_h_
+
+#include <string>
+
+namespace lldb_private {
+class Debugger;
+}
+
+namespace lldb_private {
+
+class PromptInterpolation {
+public:
+  PromptInterpolation(Debugger& debugger) :
+    m_debugger(debugger) {
+  }
+
+  std::string InterpolatePrompt(const std::string& prompt_format);
+private:
+  Debugger &m_debugger;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_PromptInterpolation_h_
+

source/Core/FormatEntity.cpp

 
 static FormatEntity::Entry::Definition g_frame_child_entries[] = {
     ENTRY("index", FrameIndex, UInt32),
+    ENTRY("index1based", FrameIndex1Based, UInt32),
+    ENTRY("count", FrameCount, UInt32),
     ENTRY("pc", FrameRegisterPC, UInt64),
     ENTRY("fp", FrameRegisterFP, UInt64),
     ENTRY("sp", FrameRegisterSP, UInt64),

     ENTRY("id", ThreadID, UInt64),
     ENTRY("protocol_id", ThreadProtocolID, UInt64),
     ENTRY("index", ThreadIndexID, UInt32),
+    ENTRY("count", ThreadCount, UInt32),
     ENTRY_CHILDREN("info", ThreadInfo, None, g_string_entry),
     ENTRY("queue", ThreadQueue, CString),
     ENTRY("name", ThreadName, CString),

     ENUM_TO_CSTR(ThreadID);
     ENUM_TO_CSTR(ThreadProtocolID);
     ENUM_TO_CSTR(ThreadIndexID);
+    ENUM_TO_CSTR(ThreadCount);
     ENUM_TO_CSTR(ThreadName);
     ENUM_TO_CSTR(ThreadQueue);
     ENUM_TO_CSTR(ThreadStopReason);

     ENUM_TO_CSTR(File);
     ENUM_TO_CSTR(Lang);
     ENUM_TO_CSTR(FrameIndex);
+    ENUM_TO_CSTR(FrameIndex1Based);
+    ENUM_TO_CSTR(FrameCount);
     ENUM_TO_CSTR(FrameNoDebug);
     ENUM_TO_CSTR(FrameRegisterPC);
     ENUM_TO_CSTR(FrameRegisterSP);

     }
     return false;
 
+  case Entry::Type::ThreadCount:
+    if (exe_ctx) {
+      if (exe_ctx->HasProcessScope()) {
+        auto thread_count = exe_ctx->GetProcessSP()->GetThreadList().GetSize();
+        const char *format = "%" PRIu32;
+        if (!entry.printf_format.empty())
+          format = entry.printf_format.c_str();
+        s.Printf(format, thread_count);
+        return true;
+      }
+    }
+    return false;
+
   case Entry::Type::ThreadIndexID:
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();

     }
     return false;
 
+  case Entry::Type::FrameIndex1Based:
+    if (exe_ctx) {
+      StackFrame *frame = exe_ctx->GetFramePtr();
+      if (frame) {
+        const char *format = "%" PRIu32;
+        if (!entry.printf_format.empty())
+          format = entry.printf_format.c_str();
+        s.Printf(format, frame->GetFrameIndex() + 1);
+        return true;
+      }
+    }
+    return false;
+    
+  case Entry::Type::FrameCount:
+    if (exe_ctx) {
+      Thread* thread = exe_ctx->GetThreadPtr();
+      if (thread) {
+        const char *format = "%" PRIu32;
+        if (!entry.printf_format.empty())
+          format = entry.printf_format.c_str();
+        s.Printf(format, thread->GetStackFrameCount());
+        return true;
+      }
+    }
+    return false;
+    
   case Entry::Type::FrameRegisterPC:
     if (exe_ctx) {
       StackFrame *frame = exe_ctx->GetFramePtr();

source/Core/IOHandler.cpp

 #ifndef LLDB_DISABLE_LIBEDIT
       m_editline_ap(),
 #endif
-      m_delegate(delegate), m_prompt(), m_continuation_prompt(),
+      m_delegate(delegate), m_prompt_interpolator(m_debugger),
+      m_prompt(), m_continuation_prompt(),
       m_current_lines_ptr(nullptr), m_base_line_number(line_number_start),
       m_curr_line_idx(UINT32_MAX), m_multi_line(multi_line),
       m_color_prompts(color_prompts), m_interrupt_exits(true),

                                      m_color_prompts));
     m_editline_ap->SetIsInputCompleteCallback(IsInputCompleteCallback, this);
     m_editline_ap->SetAutoCompleteCallback(AutoCompleteCallback, this);
+    m_editline_ap->SetPromptCallback(PromptCallback, this);
     // See if the delegate supports fixing indentation
     const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
     if (indent_chars) {

         max_matches, matches);
   return 0;
 }
+
+const char* IOHandlerEditline::PromptCallback(Editline *editline, void *baton) {
+  IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
+  editline_reader->m_prompt_string =
+      editline_reader->m_prompt_interpolator.InterpolatePrompt(
+          editline_reader->m_prompt);
+  return editline_reader->m_prompt_string.c_str();
+}
+
 #endif
 
 const char *IOHandlerEditline::GetPrompt() {

 
 bool IOHandlerEditline::SetPrompt(llvm::StringRef prompt) {
   m_prompt = prompt;
-
 #ifndef LLDB_DISABLE_LIBEDIT
   if (m_editline_ap)
     m_editline_ap->SetPrompt(m_prompt.empty() ? nullptr : m_prompt.c_str());

source/Host/common/Editline.cpp

   el_set(m_editline, EL_CLIENTDATA, this);
   el_set(m_editline, EL_SIGNAL, 0);
   el_set(m_editline, EL_EDITOR, "emacs");
-  el_set(m_editline, EL_PROMPT,
-         (EditlinePromptCallbackType)([](EditLine *editline) {
-           return Editline::InstanceFor(editline)->Prompt();
-         }));
+  if (m_prompt_callback) {
+    el_set(m_editline, EL_PROMPT,
+         (EditlinePromptCallbackType)([](EditLine *editline) {
+            return Editline::InstanceFor(editline)->InvokePromptCallback();
+              }));
+  } else {
+    el_set(m_editline, EL_PROMPT,
+     (EditlinePromptCallbackType)([](EditLine *editline) {
+            return Editline::InstanceFor(editline)->Prompt();
+          }));
+  }
 
   el_wset(m_editline, EL_GETCFN, (EditlineGetCharCallbackType)([](
                                      EditLine *editline, EditLineGetCharType *c) {

   return result;
 }
 
+void Editline::SetPromptCallback(PromptCallbackType callback, void *baton) {
+  m_prompt_callback = callback;
+  m_prompt_callback_baton = baton;
+}
+
 void Editline::SetAutoCompleteCallback(CompleteCallbackType callback,
                                        void *baton) {
   m_completion_callback = callback;

   }
 #endif
 }
+
+const char* Editline::InvokePromptCallback() {
+  return m_prompt_callback(this, m_prompt_callback_baton);
+}
+

source/Interpreter/CMakeLists.txt

   OptionGroupVariable.cpp
   OptionGroupWatchpoint.cpp
   Options.cpp
+  PromptInterpolation.cpp
   Property.cpp
   ScriptInterpreter.cpp
 

source/Interpreter/PromptInterpolation.cpp

+//===-- PromptInterpolation.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/Interpreter/PromptInterpolation.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+#include <sstream>
+
+using namespace lldb;
+using namespace lldb_private;
+
+const std::string kFallbackPrompt = "(lldb) ";
+
+namespace lldb_private {
+
+std::string PromptInterpolation::InterpolatePrompt(
+    const std::string& prompt_format) {
+  std::stringstream interpolated_prompt;
+  
+  TargetSP target = m_debugger.GetSelectedTarget();
+
+  if (!target) {
+    interpolated_prompt << kFallbackPrompt;
+    return interpolated_prompt.str();
+  }
+
+  StackFrameSP frame_sp;
+  const SymbolContext *sc = nullptr;
+  if (target->GetProcessSP()) {
+    ThreadList& thread_list = target->GetProcessSP()->GetThreadList();
+    frame_sp = thread_list.GetSelectedThread()->GetSelectedFrame();
+    sc = &frame_sp->GetSymbolContext(eSymbolContextEverything);
+  }
+  ExecutionContext exe_ctx(frame_sp);
+
+  FormatEntity::Entry root;
+  Status parse_status = FormatEntity::Parse(prompt_format, root);
+  bool formatted = false;
+  StreamString strm;
+  if (parse_status.Success()) {
+    formatted = FormatEntity::Format(root, strm, sc, &exe_ctx,
+                                     nullptr, nullptr, false, false);
+    if (formatted) {
+      interpolated_prompt << strm.GetData();
+      return interpolated_prompt.str();
+    } 
+  }
+  interpolated_prompt << kFallbackPrompt;
+  return interpolated_prompt.str();
+}
+
+} // namespace lldb_private