[lldb][gui] use names for color pairs, instead of magic numbers

[llunak]

Change also SetBackground() calls.

lldb/source/Core/IOHandlerCursesGUI.cpp

enum class MenuActionResult {
   Quit // Exit all menus and quit
 };
 
 struct KeyHelp {
   int ch;
   const char *description;
 };
 
+// COLOR_PAIR index names
+enum {
+  // First 16 colors are 8 black background and 8 blue background colors,
+  // needed by OutputColoredStringTruncated().
+  BlackOnBlack = 1,
+  RedOnBlack,
+  GreenOnBlack,
+  YellowOnBlack,
+  BlueOnBlack,
+  MagentaOnBlack,
+  CyanOnBlack,
+  WhiteOnBlack,
+  BlackOnBlue,
+  RedOnBlue,
+  GreenOnBlue,
+  YellowOnBlue,
+  BlueOnBlue,
+  MagentaOnBlue,
+  CyanOnBlue,
+  WhiteOnBlue,
+  // Other colors, as needed.
+  BlackOnWhite,
+  MagentaOnWhite,
+  LastColorPairIndex = MagentaOnWhite
+};
+
 class WindowDelegate {
 public:
   virtual ~WindowDelegate() = default;
 
   virtual bool WindowDelegateDraw(Window &window, bool force) {
     return false; // Drawing not handled
   }
 
public:
   // convert color escape sequences to curses color attributes.
   void OutputColoredStringTruncated(int right_pad, StringRef string,
                                     bool use_blue_background) {
     attr_t saved_attr;
     short saved_pair;
     int saved_opts;
     ::wattr_get(m_window, &saved_attr, &saved_pair, &saved_opts);
     if (use_blue_background)
-      ::wattron(m_window, COLOR_PAIR(16));
+      ::wattron(m_window, COLOR_PAIR(WhiteOnBlue));
     while (!string.empty()) {
       size_t esc_pos = string.find('\x1b');
       if (esc_pos == StringRef::npos) {
         PutCStringTruncated(right_pad, string.data(), string.size());
         break;
       }
       if (esc_pos > 0) {
         PutCStringTruncated(right_pad, string.data(), esc_pos);
while (!string.empty()) {
       }
       if (!string.consume_front("m")) {
         llvm::errs() << "Missing 'm' in color escape sequence.\n";
         continue;
       }
       if (value == 0) { // Reset.
         ::wattr_set(m_window, saved_attr, saved_pair, &saved_opts);
         if (use_blue_background)
-          ::wattron(m_window, COLOR_PAIR(16));
+          ::wattron(m_window, COLOR_PAIR(WhiteOnBlue));
       } else {
         // Mapped directly to first 16 color pairs (black/blue background).
         ::wattron(m_window,
                   COLOR_PAIR(value - 30 + 1 + (use_blue_background ? 8 : 0)));
       }
     }
     ::wattr_set(m_window, saved_attr, saved_pair, &saved_opts);
   }
public:
   WINDOW *get() { return m_window; }
 
   operator WINDOW *() { return m_window; }
 
   // Window drawing utilities
   void DrawTitleBox(const char *title, const char *bottom_message = nullptr) {
     attr_t attr = 0;
     if (IsActive())
-      attr = A_BOLD | COLOR_PAIR(18);
+      attr = A_BOLD | COLOR_PAIR(BlackOnWhite);
     else
       attr = 0;
     if (attr)
       AttributeOn(attr);
 
     Box();
     MoveCursor(3, 0);
 
if (!underlined_shortcut) {
       window.PutCString(m_name.c_str());
     }
 
     if (highlight)
       window.AttributeOff(highlight_attr);
 
     if (m_key_name.empty()) {
       if (!underlined_shortcut && llvm::isPrint(m_key_value)) {
-        window.AttributeOn(COLOR_PAIR(19));
+        window.AttributeOn(COLOR_PAIR(MagentaOnWhite));
         window.Printf(" (%c)", m_key_value);
-        window.AttributeOff(COLOR_PAIR(19));
+        window.AttributeOff(COLOR_PAIR(MagentaOnWhite));
       }
     } else {
-      window.AttributeOn(COLOR_PAIR(19));
+      window.AttributeOn(COLOR_PAIR(MagentaOnWhite));
       window.Printf(" (%s)", m_key_name.c_str());
-      window.AttributeOff(COLOR_PAIR(19));
+      window.AttributeOff(COLOR_PAIR(MagentaOnWhite));
     }
   }
 }
 
 bool Menu::WindowDelegateDraw(Window &window, bool force) {
   Menus &submenus = GetSubmenus();
   const size_t num_submenus = submenus.size();
   const int selected_idx = GetSelectedSubmenuIndex();
   Menu::Type menu_type = GetType();
   switch (menu_type) {
   case Menu::Type::Bar: {
-    window.SetBackground(18);
+    window.SetBackground(BlackOnWhite);
     window.MoveCursor(0, 0);
     for (size_t i = 0; i < num_submenus; ++i) {
       Menu *menu = submenus[i].get();
       if (i > 0)
         window.PutChar(' ');
       menu->SetStartingColumn(window.GetCursorX());
       window.PutCString("| ");
       menu->DrawMenuTitle(window, false);
     }
     window.PutCString(" |");
   } break;
 
   case Menu::Type::Item: {
     int y = 1;
     int x = 3;
     // Draw the menu
     int cursor_x = 0;
     int cursor_y = 0;
     window.Erase();
-    window.SetBackground(18);
+    window.SetBackground(BlackOnWhite);
     window.Box();
     for (size_t i = 0; i < num_submenus; ++i) {
       const bool is_selected = (i == static_cast<size_t>(selected_idx));
       window.MoveCursor(x, y + i);
       if (is_selected) {
         // Remember where we want the cursor to be
         cursor_x = x - 1;
         cursor_y = y + i;
bool DisplayRowObject(Window &window, Row &row, DisplayOptions &options,
     if (type_name && type_name[0])
       window.PrintfTruncated(1, "(%s) ", type_name);
 
     if (name && name[0])
       window.PutCStringTruncated(1, name);
 
     attr_t changd_attr = 0;
     if (valobj->GetValueDidChange())
-      changd_attr = COLOR_PAIR(2) | A_BOLD;
+      changd_attr = COLOR_PAIR(RedOnBlack) | A_BOLD;
 
     if (value && value[0]) {
       window.PutCStringTruncated(1, " = ");
       if (changd_attr)
         window.AttributeOn(changd_attr);
       window.PutCStringTruncated(1, value);
       if (changd_attr)
         window.AttributeOff(changd_attr);
public:
 
   bool WindowDelegateDraw(Window &window, bool force) override {
     ExecutionContext exe_ctx =
         m_debugger.GetCommandInterpreter().GetExecutionContext();
     Process *process = exe_ctx.GetProcessPtr();
     Thread *thread = exe_ctx.GetThreadPtr();
     StackFrame *frame = exe_ctx.GetFramePtr();
     window.Erase();
-    window.SetBackground(18);
+    window.SetBackground(BlackOnWhite);
     window.MoveCursor(0, 0);
     if (process) {
       const StateType state = process->GetState();
       window.Printf("Process: %5" PRIu64 " %10s", process->GetID(),
                     StateAsCString(state));
 
       if (StateIsStoppedState(state, true)) {
         StreamString strm;
if (num_source_lines > 0) {
                 bp_lines.insert(bp_loc_line_entry.line);
               }
             }
           }
         }
       }
 
       const attr_t selected_highlight_attr = A_REVERSE;
-      const attr_t pc_highlight_attr = COLOR_PAIR(9);
+      const attr_t pc_highlight_attr = COLOR_PAIR(BlackOnBlue);
 
       for (size_t i = 0; i < num_visible_lines; ++i) {
         const uint32_t curr_line = m_first_visible_line + i;
         if (curr_line < num_source_lines) {
           const int line_y = m_min_y + i;
           window.MoveCursor(1, line_y);
           const bool is_pc_line = curr_line == m_pc_line;
           const bool line_is_selected = m_selected_line == curr_line;
           // Highlight the line as the PC line first, then if the selected line
           // isn't the same as the PC line, highlight it differently
           attr_t highlight_attr = 0;
           attr_t bp_attr = 0;
           if (is_pc_line)
             highlight_attr = pc_highlight_attr;
           else if (line_is_selected)
             highlight_attr = selected_highlight_attr;
 
           if (bp_lines.find(curr_line + 1) != bp_lines.end())
-            bp_attr = COLOR_PAIR(18);
+            bp_attr = COLOR_PAIR(BlackOnWhite);
 
           if (bp_attr)
             window.AttributeOn(bp_attr);
 
           window.Printf(" %*u ", m_line_width, curr_line + 1);
 
           if (bp_attr)
             window.AttributeOff(bp_attr);
if (num_source_lines > 0) {
               const char *stop_description = stop_info_sp->GetDescription();
               if (stop_description && stop_description[0]) {
                 size_t stop_description_len = strlen(stop_description);
                 int desc_x = window_width - stop_description_len - 16;
                 if (desc_x - window.GetCursorX() > 0)
                   window.Printf("%*s", desc_x - window.GetCursorX(), "");
                 window.MoveCursor(window_width - stop_description_len - 16,
                                   line_y);
-                const attr_t stop_reason_attr = COLOR_PAIR(17);
+                const attr_t stop_reason_attr = COLOR_PAIR(WhiteOnBlue);
                 window.AttributeOn(stop_reason_attr);
                 window.PrintfTruncated(1, " <<< Thread %u: %s ",
                                        thread->GetIndexID(), stop_description);
                 window.AttributeOff(stop_reason_attr);
               }
             } else {
               window.Printf("%*s", window_width - window.GetCursorX() - 1, "");
             }
if (num_source_lines > 0) {
                 if (m_disassembly_range.ContainsFileAddress(file_addr))
                   bp_file_addrs.insert(file_addr);
               }
             }
           }
         }
 
         const attr_t selected_highlight_attr = A_REVERSE;
-        const attr_t pc_highlight_attr = COLOR_PAIR(17);
+        const attr_t pc_highlight_attr = COLOR_PAIR(WhiteOnBlue);
 
         StreamString strm;
 
         InstructionList &insts = m_disassembly_sp->GetInstructionList();
         Address pc_address;
 
         if (frame_sp)
           pc_address = frame_sp->GetFrameCodeAddress();
if (num_source_lines > 0) {
           attr_t bp_attr = 0;
           if (is_pc_line)
             highlight_attr = pc_highlight_attr;
           else if (line_is_selected)
             highlight_attr = selected_highlight_attr;
 
           if (bp_file_addrs.find(inst->GetAddress().GetFileAddress()) !=
               bp_file_addrs.end())
-            bp_attr = COLOR_PAIR(18);
+            bp_attr = COLOR_PAIR(BlackOnWhite);
 
           if (bp_attr)
             window.AttributeOn(bp_attr);
 
           window.Printf(" 0x%16.16llx ",
                         static_cast<unsigned long long>(
                             inst->GetAddress().GetLoadAddress(target)));
 
if (!m_app_ap) {
     init_pair(9, COLOR_BLACK, COLOR_BLUE);
     init_pair(10, COLOR_RED, COLOR_BLUE);
     init_pair(11, COLOR_GREEN, COLOR_BLUE);
     init_pair(12, COLOR_YELLOW, COLOR_BLUE);
     init_pair(13, COLOR_BLUE, COLOR_BLUE);
     init_pair(14, COLOR_MAGENTA, COLOR_BLUE);
     init_pair(15, COLOR_CYAN, COLOR_BLUE);
     init_pair(16, COLOR_WHITE, COLOR_BLUE);
-
-    init_pair(17, COLOR_WHITE, COLOR_BLUE);
-    init_pair(18, COLOR_BLACK, COLOR_WHITE);
-    init_pair(19, COLOR_MAGENTA, COLOR_WHITE);
+    // These must match the order in the color indexes enum.
+    init_pair(17, COLOR_BLACK, COLOR_WHITE);
+    init_pair(18, COLOR_MAGENTA, COLOR_WHITE);
+    static_assert(LastColorPairIndex == 18, "Color indexes do not match.");
   }
 }
 
 void IOHandlerCursesGUI::Deactivate() { m_app_ap->Terminate(); }
 
 void IOHandlerCursesGUI::Run() {
   m_app_ap->Run(m_debugger);
   SetIsDone(true);