[LLDB][GUI] Add Environment Variable Field

[OmarEmaraDev]

Summary

This patch adds an environment variable field. This is usually used as
the basic type of a List field. This is needed to create the process
launch form.

[OmarEmaraDev]

Example list of environment fields:

[clayborg]

lldb/source/Core/IOHandlerCursesGUI.cpp

1924

There are other things that could benefit from having two text fields, like source mapping:

(lldb) apropos target.source-map
No commands found pertaining to 'target.source-map'. Try 'help' to see a complete list of debugger commands.

The following settings variables may relate to 'target.source-map':
  target.source-map -- Source path remappings apply substitutions to the paths of source files, typically needed to debug from a different host than the one that built the
                       target.  The source-map property consists of an array of pairs, the first element is a path prefix, and the second is its replacement.  The syntax is
                       `prefix1 replacement1 prefix2 replacement2...`.  The pairs are checked in order, the first prefix that matches is used, and that prefix is substituted
                       with the replacement.  A common pattern is to use source-map in conjunction with the clang -fdebug-prefix-map flag.  In the build, use
                       `-fdebug-prefix-map=/path/to/build_dir=.` to rewrite the host specific build directory to `.`.  Then for debugging, use `settings set target.source-map .
                       /path/to/local_dir` to convert `.` to a valid local path.

This would be very close to the EnvironmentVariableFieldDelegate class, but instead of "Name" and "Value" the fields would be "Prefix" and "Replacement". In the source map case the two fields would be a DirectoryFieldDelegate objects. So we could make a base class like PairFieldDelegate that much of the functionality in this class could be moved to. The constructor for the PairFieldDelegate could take two "FieldDelegate *" arguments. So then EnvironmentVariableFieldDelegate could inherit from PairFieldDelegate and this constructor would look like:

EnvironmentVariableFieldDelegate(): 
  PairFieldDelegate(new EnvironmentVariableNameFieldDelegate("Name", ""),
                               new TextFieldDelegate("Value", "", /*required=*/false))

Not required, but it might make it a more useful set of reusable classes for this curses field stuff. Let me know if you are up for doing an approach like this or not

[OmarEmaraDev]

• Generalize the implementation to any Mapping field

[OmarEmaraDev]

I generalized the implementation as suggested and added a ready to use list version of the field.

[clayborg]

Very nice! Looks great.

lldb/source/Core/IOHandlerCursesGUI.cpp

 //===-- IOHandlerCursesGUI.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/IOHandlerCursesGUI.h"
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_CURSES
 #if CURSES_HAVE_NCURSES_CURSES_H
 #include <ncurses/curses.h>
 #include <ncurses/panel.h>
 #else
 #include <curses.h>
protected:
   // created though a copy.
   T m_default_field;
   std::vector<T> m_fields;
   int m_selection_index;
   // See SelectionType class enum.
   SelectionType m_selection_type;
 };
 
+class EnvironmentVariableNameFieldDelegate : public TextFieldDelegate {
+public:
+  EnvironmentVariableNameFieldDelegate(const char *label, const char *content)
+      : TextFieldDelegate(label, content, true) {}
+
+  // Environment variable names can't contain an equal sign.
+  bool IsAcceptableChar(int key) override {
+    return TextFieldDelegate::IsAcceptableChar(key) && key != '=';
+  }
+
+  const std::string &GetName() { return m_content; }
+};
+
+class EnvironmentVariableFieldDelegate : public FieldDelegate {
+public:
+  EnvironmentVariableFieldDelegate()
+      : m_name_field(EnvironmentVariableNameFieldDelegate("Name", "")),
+        m_value_field(TextFieldDelegate("Value", "", /*required=*/false)),
+        m_selection_type(SelectionType::Name) {}
+
+  // Signify which element is selected. The variable name field or its value
+  // field.
+  enum class SelectionType { Name, Value };
+
+  // An environment variable field is drawn as two text fields with a right
+  // arrow in between. The first text field stores the name of the variable and
+  // the second stores the value if the variable.
+  //
+  // __[Name]____________   __[Value]___________
+  // |                  | > |                  |
+  // |__________________|   |__________________|
+  // - Error message if it exists.
+
+  // The environment variable field has a height that is equal to the maximum
+  // height between the name and value fields.
+  int FieldDelegateGetHeight() override {
+    return std::max(m_name_field.FieldDelegateGetHeight(),
+                    m_value_field.FieldDelegateGetHeight());
+  }
+
+  void DrawArrow(SubPad &surface) {
+    surface.MoveCursor(0, 1);
+    surface.PutChar(ACS_RARROW);
+  }
+
+  void FieldDelegateDraw(SubPad &surface, bool is_selected) override {
+    Rect bounds = surface.GetFrame();
+    Rect name_field_bounds, arrow_and_value_field_bounds;
+    bounds.VerticalSplit(bounds.size.width / 2, name_field_bounds,
+                         arrow_and_value_field_bounds);
+    Rect arrow_bounds, value_field_bounds;
+    arrow_and_value_field_bounds.VerticalSplit(1, arrow_bounds,
+                                               value_field_bounds);
+
+    SubPad name_field_surface = SubPad(surface, name_field_bounds);
+    SubPad arrow_surface = SubPad(surface, arrow_bounds);
+    SubPad value_field_surface = SubPad(surface, value_field_bounds);
+
+    bool name_is_selected =
+        m_selection_type == SelectionType::Name && is_selected;
+    m_name_field.FieldDelegateDraw(name_field_surface, name_is_selected);
+    DrawArrow(arrow_surface);
+    bool value_is_selected =
+        m_selection_type == SelectionType::Value && is_selected;
+    m_value_field.FieldDelegateDraw(value_field_surface, value_is_selected);
+  }
+
+  HandleCharResult SelectNext(int key) {
+    if (FieldDelegateOnLastOrOnlyElement())
+      return eKeyNotHandled;
+
+    m_selection_type = SelectionType::Value;
+    m_name_field.FieldDelegateExitCallback();
+    return eKeyHandled;
+  }
+
+  HandleCharResult SelectPrevious(int key) {
+    if (FieldDelegateOnFirstOrOnlyElement())
+      return eKeyNotHandled;
+
+    m_selection_type = SelectionType::Name;
+    m_value_field.FieldDelegateExitCallback();
+    return eKeyHandled;
+  }
+
+  HandleCharResult FieldDelegateHandleChar(int key) override {
+    switch (key) {
+    case '\t':
+      SelectNext(key);
+      return eKeyHandled;
+    case KEY_SHIFT_TAB:
+      SelectPrevious(key);
+      return eKeyHandled;
+    default:
+      break;
+    }
+
+    // If the key wasn't handled, pass the key to the selected field.
+    if (m_selection_type == SelectionType::Name)
+      return m_name_field.FieldDelegateHandleChar(key);
+    else
+      return m_value_field.FieldDelegateHandleChar(key);
+
+    return eKeyNotHandled;
+  }
+
+  bool FieldDelegateOnFirstOrOnlyElement() override {
+    return m_selection_type == SelectionType::Name;
+  }
+
+  bool FieldDelegateOnLastOrOnlyElement() override {
+    return m_selection_type == SelectionType::Value;
+  }
+
+  void FieldDelegateSelectFirstElement() override {
+    m_selection_type = SelectionType::Name;
+  }
+
+  void FieldDelegateSelectLastElement() override {
+    m_selection_type = SelectionType::Value;
+  }
+
+  bool FieldDelegateHasError() override {
+    return m_name_field.FieldDelegateHasError() ||
+           m_value_field.FieldDelegateHasError();
+  }
+
+  const std::string &GetName() { return m_name_field.GetName(); }
+
+  const std::string &GetValue() { return m_value_field.GetText(); }
+
+protected:
+  EnvironmentVariableNameFieldDelegate m_name_field;
+  TextFieldDelegate m_value_field;
+  // See SelectionType class enum.
+  SelectionType m_selection_type;
+};
+
 class FormAction {
 public:
   FormAction(const char *label, std::function<void(Window &)> action)
       : m_action(action) {
     if (label)
       m_label = label;
   }
 
public:
   template <class T>
   ListFieldDelegate<T> *AddListField(const char *label, T default_field) {
     ListFieldDelegate<T> *delegate =
         new ListFieldDelegate<T>(label, default_field);
     m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
+  EnvironmentVariableFieldDelegate *AddEnvironmentVariableField() {
+    EnvironmentVariableFieldDelegate *delegate =
+        new EnvironmentVariableFieldDelegate();
+    m_fields.push_back(FieldDelegateUP(delegate));
+    return delegate;
+  }
+
   // Factory methods for adding actions.
 
   void AddAction(const char *label, std::function<void(Window &)> action) {
     m_actions.push_back(FormAction(label, action));
   }
 
 protected:
   std::vector<FieldDelegateUP> m_fields;