gdb/tui/tui-winsource.c

   1 /* TUI display source/assembly window.
   2
   3    Copyright (C) 1998-2020 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include <ctype.h>
  24 #include "symtab.h"
  25 #include "frame.h"
  26 #include "breakpoint.h"
  27 #include "value.h"
  28 #include "source.h"
  29 #include "objfiles.h"
  30 #include "filenames.h"
  31
  32 #include "tui/tui.h"
  33 #include "tui/tui-data.h"
  34 #include "tui/tui-io.h"
  35 #include "tui/tui-stack.h"
  36 #include "tui/tui-win.h"
  37 #include "tui/tui-wingeneral.h"
  38 #include "tui/tui-winsource.h"
  39 #include "tui/tui-source.h"
  40 #include "tui/tui-disasm.h"
  41 #include "gdb_curses.h"
  42
  43 /* Function to display the "main" routine.  */
  44 void
  45 tui_display_main ()
  46 {
  47   auto adapter = tui_source_windows ();
  48   if (adapter.begin () != adapter.end ())
  49     {
  50       struct gdbarch *gdbarch;
  51       CORE_ADDR addr;
  52
  53       tui_get_begin_asm_address (&gdbarch, &addr);
  54       if (addr != (CORE_ADDR) 0)
  55         {
  56           struct symtab *s;
  57
  58           tui_update_source_windows_with_addr (gdbarch, addr);
  59           s = find_pc_line_symtab (addr);
  60           tui_update_locator_fullname (s);
  61         }
  62     }
  63 }
  64
  65 /* See tui-winsource.h.  */
  66
  67 std::string
  68 tui_copy_source_line (const char **ptr, int line_no, int first_col,
  69                       int line_width, int ndigits)
  70 {
  71   const char *lineptr = *ptr;
  72
  73   /* Init the line with the line number.  */
  74   std::string result;
  75
  76   if (line_no > 0)
  77     {
  78       if (ndigits > 0)
  79         result = string_printf ("%*d ", ndigits, line_no);
  80       else
  81         {
  82           result = string_printf ("%-6d", line_no);
  83           int len = result.size ();
  84           len = len - ((len / tui_tab_width) * tui_tab_width);
  85           result.append (len, ' ');
  86         }
  87     }
  88
  89   int column = 0;
  90   char c;
  91   do
  92     {
  93       int skip_bytes;
  94
  95       c = *lineptr;
  96       if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
  97         {
  98           /* We always have to preserve escapes.  */
  99           result.append (lineptr, lineptr + skip_bytes);
 100           lineptr += skip_bytes;
 101           continue;
 102         }
 103       if (c == '\0')
 104         break;
 105
 106       ++lineptr;
 107       ++column;
 108
 109       auto process_tab = [&] ()
 110         {
 111           int max_tab_len = tui_tab_width;
 112
 113           --column;
 114           for (int j = column % max_tab_len;
 115                j < max_tab_len && column < first_col + line_width;
 116                column++, j++)
 117             if (column >= first_col)
 118               result.push_back (' ');
 119         };
 120
 121       /* We have to process all the text in order to pick up all the
 122          escapes.  */
 123       if (column <= first_col || column > first_col + line_width)
 124         {
 125           if (c == '\t')
 126             process_tab ();
 127           continue;
 128         }
 129
 130       if (c == '\n' || c == '\r' || c == '\0')
 131         {
 132           /* Nothing.  */
 133         }
 134       else if (c < 040 && c != '\t')
 135         {
 136           result.push_back ('^');
 137           result.push_back (c + 0100);
 138         }
 139       else if (c == 0177)
 140         {
 141           result.push_back ('^');
 142           result.push_back ('?');
 143         }
 144       else if (c == '\t')
 145         process_tab ();
 146       else
 147         result.push_back (c);
 148     }
 149   while (c != '\0' && c != '\n' && c != '\r');
 150
 151   if (c == '\r' && *lineptr == '\n')
 152     ++lineptr;
 153   *ptr = lineptr;
 154
 155   return result;
 156 }
 157
 158 void
 159 tui_source_window_base::style_changed ()
 160 {
 161   if (tui_active && is_visible ())
 162     refill ();
 163 }
 164
 165 /* Function to display source in the source window.  This function
 166    initializes the horizontal scroll to 0.  */
 167 void
 168 tui_source_window_base::update_source_window
 169   (struct gdbarch *gdbarch,
 170    const struct symtab_and_line &sal)
 171 {
 172   m_horizontal_offset = 0;
 173   update_source_window_as_is (gdbarch, sal);
 174 }
 175
 176
 177 /* Function to display source in the source/asm window.  This function
 178    shows the source as specified by the horizontal offset.  */
 179 void
 180 tui_source_window_base::update_source_window_as_is
 181   (struct gdbarch *gdbarch,
 182    const struct symtab_and_line &sal)
 183 {
 184   bool ret = set_contents (gdbarch, sal);
 185
 186   if (!ret)
 187     erase_source_content ();
 188   else
 189     {
 190       update_breakpoint_info (nullptr, false);
 191       show_source_content ();
 192       update_exec_info ();
 193     }
 194 }
 195
 196
 197 /* Function to ensure that the source and/or disassemly windows
 198    reflect the input address.  */
 199 void
 200 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 201 {
 202   struct symtab_and_line sal {};
 203   if (addr != 0)
 204     sal = find_pc_line (addr, 0);
 205
 206   for (struct tui_source_window_base *win_info : tui_source_windows ())
 207     win_info->update_source_window (gdbarch, sal);
 208 }
 209
 210 /* Function to ensure that the source and/or disassembly windows
 211    reflect the symtab and line.  */
 212 void
 213 tui_update_source_windows_with_line (struct symtab_and_line sal)
 214 {
 215   struct gdbarch *gdbarch = nullptr;
 216   if (sal.symtab != nullptr)
 217     {
 218       find_line_pc (sal.symtab, sal.line, &sal.pc);
 219       gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
 220     }
 221
 222   for (struct tui_source_window_base *win_info : tui_source_windows ())
 223     win_info->update_source_window (gdbarch, sal);
 224 }
 225
 226 void
 227 tui_source_window_base::do_erase_source_content (const char *str)
 228 {
 229   int x_pos;
 230   int half_width = (width - 2) / 2;
 231
 232   m_content.clear ();
 233   if (handle != NULL)
 234     {
 235       werase (handle.get ());
 236       check_and_display_highlight_if_needed ();
 237
 238       if (strlen (str) >= half_width)
 239         x_pos = 1;
 240       else
 241         x_pos = half_width - strlen (str);
 242       mvwaddstr (handle.get (),
 243                  (height / 2),
 244                  x_pos,
 245                  (char *) str);
 246
 247       refresh_window ();
 248     }
 249 }
 250
 251
 252 /* Redraw the complete line of a source or disassembly window.  */
 253 void
 254 tui_source_window_base::show_source_line (int lineno)
 255 {
 256   struct tui_source_element *line;
 257   int x;
 258
 259   line = &m_content[lineno - 1];
 260   if (line->is_exec_point)
 261     tui_set_reverse_mode (handle.get (), true);
 262
 263   wmove (handle.get (), lineno, TUI_EXECINFO_SIZE);
 264   tui_puts (line->line.c_str (), handle.get ());
 265   if (line->is_exec_point)
 266     tui_set_reverse_mode (handle.get (), false);
 267
 268   /* Clear to end of line but stop before the border.  */
 269   x = getcurx (handle.get ());
 270   while (x + 1 < width)
 271     {
 272       waddch (handle.get (), ' ');
 273       x = getcurx (handle.get ());
 274     }
 275 }
 276
 277 void
 278 tui_source_window_base::show_source_content ()
 279 {
 280   gdb_assert (!m_content.empty ());
 281
 282   for (int lineno = 1; lineno <= m_content.size (); lineno++)
 283     show_source_line (lineno);
 284
 285   check_and_display_highlight_if_needed ();
 286   refresh_window ();
 287 }
 288
 289 tui_source_window_base::tui_source_window_base ()
 290 {
 291   m_start_line_or_addr.loa = LOA_ADDRESS;
 292   m_start_line_or_addr.u.addr = 0;
 293
 294   gdb::observers::source_styling_changed.attach
 295     (std::bind (&tui_source_window::style_changed, this),
 296      m_observable);
 297 }
 298
 299 tui_source_window_base::~tui_source_window_base ()
 300 {
 301   gdb::observers::source_styling_changed.detach (m_observable);
 302 }
 303
 304 /* See tui-data.h.  */
 305
 306 void
 307 tui_source_window_base::update_tab_width ()
 308 {
 309   werase (handle.get ());
 310   rerender ();
 311 }
 312
 313 void
 314 tui_source_window_base::rerender ()
 315 {
 316   if (!m_content.empty ())
 317     {
 318       struct symtab_and_line cursal
 319         = get_current_source_symtab_and_line ();
 320
 321       if (m_start_line_or_addr.loa == LOA_LINE)
 322         cursal.line = m_start_line_or_addr.u.line_no;
 323       else
 324         cursal.pc = m_start_line_or_addr.u.addr;
 325       update_source_window (m_gdbarch, cursal);
 326     }
 327   else if (deprecated_safe_get_selected_frame () != NULL)
 328     {
 329       struct symtab_and_line cursal
 330         = get_current_source_symtab_and_line ();
 331       struct frame_info *frame = deprecated_safe_get_selected_frame ();
 332       struct gdbarch *gdbarch = get_frame_arch (frame);
 333
 334       struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
 335       if (this != TUI_SRC_WIN)
 336         find_line_pc (s, cursal.line, &cursal.pc);
 337       update_source_window (gdbarch, cursal);
 338     }
 339   else
 340     erase_source_content ();
 341 }
 342
 343 /* See tui-data.h.  */
 344
 345 void
 346 tui_source_window_base::refill ()
 347 {
 348   symtab_and_line sal {};
 349
 350   if (this == TUI_SRC_WIN)
 351     {
 352       sal = get_current_source_symtab_and_line ();
 353       if (sal.symtab == NULL)
 354         {
 355           struct frame_info *fi = deprecated_safe_get_selected_frame ();
 356           if (fi != nullptr)
 357             sal = find_pc_line (get_frame_pc (fi), 0);
 358         }
 359     }
 360
 361   if (sal.pspace == nullptr)
 362     sal.pspace = current_program_space;
 363
 364   if (m_start_line_or_addr.loa == LOA_LINE)
 365     sal.line = m_start_line_or_addr.u.line_no;
 366   else
 367     sal.pc = m_start_line_or_addr.u.addr;
 368
 369   update_source_window_as_is (m_gdbarch, sal);
 370 }
 371
 372 /* Scroll the source forward or backward horizontally.  */
 373
 374 void
 375 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
 376 {
 377   if (!m_content.empty ())
 378     {
 379       int offset = m_horizontal_offset + num_to_scroll;
 380       if (offset < 0)
 381         offset = 0;
 382       m_horizontal_offset = offset;
 383       refill ();
 384     }
 385 }
 386
 387
 388 /* Set or clear the is_exec_point flag in the line whose line is
 389    line_no.  */
 390
 391 void
 392 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 393 {
 394   bool changed = false;
 395   int i;
 396
 397   i = 0;
 398   while (i < m_content.size ())
 399     {
 400       bool new_state;
 401       struct tui_line_or_address content_loa =
 402         m_content[i].line_or_addr;
 403
 404       if (content_loa.loa == l.loa
 405           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 406               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 407         new_state = true;
 408       else
 409         new_state = false;
 410       if (new_state != m_content[i].is_exec_point)
 411         {
 412           changed = true;
 413           m_content[i].is_exec_point = new_state;
 414           show_source_line (i + 1);
 415         }
 416       i++;
 417     }
 418   if (changed)
 419     refill ();
 420 }
 421
 422 /* See tui-winsource.h.  */
 423
 424 void
 425 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 426 {
 427   for (tui_source_window_base *win : tui_source_windows ())
 428     {
 429       if (win->update_breakpoint_info (being_deleted, false))
 430         win->update_exec_info ();
 431     }
 432 }
 433
 434
 435 /* Scan the source window and the breakpoints to update the break_mode
 436    information for each line.
 437
 438    Returns true if something changed and the execution window must be
 439    refreshed.  */
 440
 441 bool
 442 tui_source_window_base::update_breakpoint_info
 443   (struct breakpoint *being_deleted, bool current_only)
 444 {
 445   int i;
 446   bool need_refresh = false;
 447
 448   for (i = 0; i < m_content.size (); i++)
 449     {
 450       struct tui_source_element *line;
 451
 452       line = &m_content[i];
 453       if (current_only && !line->is_exec_point)
 454          continue;
 455
 456       /* Scan each breakpoint to see if the current line has something to
 457          do with it.  Identify enable/disabled breakpoints as well as
 458          those that we already hit.  */
 459       tui_bp_flags mode = 0;
 460       iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
 461         {
 462           struct bp_location *loc;
 463
 464           if (bp == being_deleted)
 465             return false;
 466
 467           for (loc = bp->loc; loc != NULL; loc = loc->next)
 468             {
 469               if (location_matches_p (loc, i))
 470                 {
 471                   if (bp->enable_state == bp_disabled)
 472                     mode |= TUI_BP_DISABLED;
 473                   else
 474                     mode |= TUI_BP_ENABLED;
 475                   if (bp->hit_count)
 476                     mode |= TUI_BP_HIT;
 477                   if (bp->loc->cond)
 478                     mode |= TUI_BP_CONDITIONAL;
 479                   if (bp->type == bp_hardware_breakpoint)
 480                     mode |= TUI_BP_HARDWARE;
 481                 }
 482             }
 483           return false;
 484         });
 485       if (line->break_mode != mode)
 486         {
 487           line->break_mode = mode;
 488           need_refresh = true;
 489         }
 490     }
 491   return need_refresh;
 492 }
 493
 494 /* Function to initialize the content of the execution info window,
 495    based upon the input window which is either the source or
 496    disassembly window.  */
 497 void
 498 tui_source_window_base::update_exec_info ()
 499 {
 500   update_breakpoint_info (nullptr, true);
 501   for (int i = 0; i < m_content.size (); i++)
 502     {
 503       struct tui_source_element *src_element = &m_content[i];
 504       char element[TUI_EXECINFO_SIZE] = "   ";
 505
 506       /* Now update the exec info content based upon the state
 507          of each line as indicated by the source content.  */
 508       tui_bp_flags mode = src_element->break_mode;
 509       if (mode & TUI_BP_HIT)
 510         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 511       else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 512         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 513
 514       if (mode & TUI_BP_ENABLED)
 515         element[TUI_BP_BREAK_POS] = '+';
 516       else if (mode & TUI_BP_DISABLED)
 517         element[TUI_BP_BREAK_POS] = '-';
 518
 519       if (src_element->is_exec_point)
 520         element[TUI_EXEC_POS] = '>';
 521
 522       mvwaddstr (handle.get (), i + 1, 1, element);
 523     }
 524   refresh_window ();
 525 }