gdb/tui/tui-data.c

   1 /* TUI data manipulation routines.
   2
   3    Copyright (C) 1998-2019 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 "symtab.h"
  24 #include "tui/tui.h"
  25 #include "tui/tui-data.h"
  26 #include "tui/tui-wingeneral.h"
  27 #include "gdb_curses.h"
  28
  29 /****************************
  30 ** GLOBAL DECLARATIONS
  31 ****************************/
  32 struct tui_win_info *tui_win_list[MAX_MAJOR_WINDOWS];
  33
  34 /***************************
  35 ** Private data
  36 ****************************/
  37 static enum tui_layout_type current_layout = UNDEFINED_LAYOUT;
  38 static int term_height, term_width;
  39 static struct tui_gen_win_info _locator (LOCATOR_WIN);
  40 static struct tui_gen_win_info source_win (EXEC_INFO_WIN);
  41 static struct tui_gen_win_info disasm_win (EXEC_INFO_WIN);
  42 static std::vector<tui_source_window_base *> source_windows;
  43 static struct tui_win_info *win_with_focus = NULL;
  44 static struct tui_layout_def layout_def = {
  45   SRC_WIN,                      /* DISPLAY_MODE */
  46   FALSE};                       /* SPLIT */
  47
  48 static int win_resized = FALSE;
  49
  50
  51 /*********************************
  52 ** Static function forward decls
  53 **********************************/
  54 static void free_content (tui_win_content,
  55                           int,
  56                           enum tui_win_type);
  57 static void free_content_elements (tui_win_content,
  58                                    int,
  59                                    enum tui_win_type);
  60
  61
  62
  63 /*********************************
  64 ** PUBLIC FUNCTIONS
  65 **********************************/
  66
  67 int
  68 tui_win_is_auxillary (enum tui_win_type win_type)
  69 {
  70   return (win_type > MAX_MAJOR_WINDOWS);
  71 }
  72
  73 /******************************************
  74 ** ACCESSORS & MUTATORS FOR PRIVATE DATA
  75 ******************************************/
  76
  77 /* Answer a whether the terminal window has been resized or not.  */
  78 int
  79 tui_win_resized (void)
  80 {
  81   return win_resized;
  82 }
  83
  84
  85 /* Set a whether the terminal window has been resized or not.  */
  86 void
  87 tui_set_win_resized_to (int resized)
  88 {
  89   win_resized = resized;
  90 }
  91
  92
  93 /* Answer a pointer to the current layout definition.  */
  94 struct tui_layout_def *
  95 tui_layout_def (void)
  96 {
  97   return &layout_def;
  98 }
  99
 100
 101 /* Answer the window with the logical focus.  */
 102 struct tui_win_info *
 103 tui_win_with_focus (void)
 104 {
 105   return win_with_focus;
 106 }
 107
 108
 109 /* Set the window that has the logical focus.  */
 110 void
 111 tui_set_win_with_focus (struct tui_win_info *win_info)
 112 {
 113   win_with_focus = win_info;
 114 }
 115
 116
 117 /* Accessor for the current source window.  Usually there is only one
 118    source window (either source or disassembly), but both can be
 119    displayed at the same time.  */
 120 std::vector<tui_source_window_base *> &
 121 tui_source_windows ()
 122 {
 123   return source_windows;
 124 }
 125
 126
 127 /* Clear the list of source windows.  Usually there is only one source
 128    window (either source or disassembly), but both can be displayed at
 129    the same time.  */
 130 void
 131 tui_clear_source_windows ()
 132 {
 133   source_windows.clear ();
 134 }
 135
 136
 137 /* Clear the pertinant detail in the source windows.  */
 138 void
 139 tui_clear_source_windows_detail ()
 140 {
 141   for (tui_source_window_base *win : tui_source_windows ())
 142     win->clear_detail ();
 143 }
 144
 145
 146 /* Add a window to the list of source windows.  Usually there is only
 147    one source window (either source or disassembly), but both can be
 148    displayed at the same time.  */
 149 void
 150 tui_add_to_source_windows (struct tui_source_window_base *win_info)
 151 {
 152   if (source_windows.size () < 2)
 153     source_windows.push_back (win_info);
 154 }
 155
 156 /* See tui-data.h.  */
 157
 158 void
 159 tui_source_window_base::clear_detail ()
 160 {
 161   gdbarch = NULL;
 162   start_line_or_addr.loa = LOA_ADDRESS;
 163   start_line_or_addr.u.addr = 0;
 164   horizontal_offset = 0;
 165 }
 166
 167 /* See tui-data.h.  */
 168
 169 void
 170 tui_cmd_window::clear_detail ()
 171 {
 172   wmove (handle, 0, 0);
 173 }
 174
 175 /* See tui-data.h.  */
 176
 177 void
 178 tui_data_window::clear_detail ()
 179 {
 180   data_content = NULL;
 181   data_content_count = 0;
 182   regs_content = NULL;
 183   regs_content_count = 0;
 184   regs_column_count = 1;
 185   display_regs = false;
 186 }
 187
 188 /* Accessor for the source execution info ptr.  */
 189 struct tui_gen_win_info *
 190 tui_source_exec_info_win_ptr (void)
 191 {
 192   return &source_win;
 193 }
 194
 195
 196 /* Accessor for the disassem execution info ptr.  */
 197 struct tui_gen_win_info *
 198 tui_disassem_exec_info_win_ptr (void)
 199 {
 200   return &disasm_win;
 201 }
 202
 203
 204 /* Accessor for the locator win info.  Answers a pointer to the static
 205    locator win info struct.  */
 206 struct tui_gen_win_info *
 207 tui_locator_win_info_ptr (void)
 208 {
 209   return &_locator;
 210 }
 211
 212
 213 /* Accessor for the term_height.  */
 214 int
 215 tui_term_height (void)
 216 {
 217   return term_height;
 218 }
 219
 220
 221 /* Mutator for the term height.  */
 222 void
 223 tui_set_term_height_to (int h)
 224 {
 225   term_height = h;
 226 }
 227
 228
 229 /* Accessor for the term_width.  */
 230 int
 231 tui_term_width (void)
 232 {
 233   return term_width;
 234 }
 235
 236
 237 /* Mutator for the term_width.  */
 238 void
 239 tui_set_term_width_to (int w)
 240 {
 241   term_width = w;
 242 }
 243
 244
 245 /* Accessor for the current layout.  */
 246 enum tui_layout_type
 247 tui_current_layout (void)
 248 {
 249   return current_layout;
 250 }
 251
 252
 253 /* Mutator for the current layout.  */
 254 void
 255 tui_set_current_layout_to (enum tui_layout_type new_layout)
 256 {
 257   current_layout = new_layout;
 258 }
 259
 260
 261 /*****************************
 262 ** OTHER PUBLIC FUNCTIONS
 263 *****************************/
 264
 265
 266 /* Answer the next window in the list, cycling back to the top if
 267    necessary.  */
 268 struct tui_win_info *
 269 tui_next_win (struct tui_win_info *cur_win)
 270 {
 271   int type = cur_win->type;
 272   struct tui_win_info *next_win = NULL;
 273
 274   if (cur_win->type == CMD_WIN)
 275     type = SRC_WIN;
 276   else
 277     type = cur_win->type + 1;
 278   while (type != cur_win->type && (next_win == NULL))
 279     {
 280       if (tui_win_list[type]
 281           && tui_win_list[type]->is_visible)
 282         next_win = tui_win_list[type];
 283       else
 284         {
 285           if (type == CMD_WIN)
 286             type = SRC_WIN;
 287           else
 288             type++;
 289         }
 290     }
 291
 292   return next_win;
 293 }
 294
 295
 296 /* Answer the prev window in the list, cycling back to the bottom if
 297    necessary.  */
 298 struct tui_win_info *
 299 tui_prev_win (struct tui_win_info *cur_win)
 300 {
 301   int type = cur_win->type;
 302   struct tui_win_info *prev = NULL;
 303
 304   if (cur_win->type == SRC_WIN)
 305     type = CMD_WIN;
 306   else
 307     type = cur_win->type - 1;
 308   while (type != cur_win->type && (prev == NULL))
 309     {
 310       if (tui_win_list[type]
 311           && tui_win_list[type]->is_visible)
 312         prev = tui_win_list[type];
 313       else
 314         {
 315           if (type == SRC_WIN)
 316             type = CMD_WIN;
 317           else
 318             type--;
 319         }
 320     }
 321
 322   return prev;
 323 }
 324
 325
 326 /* Answer the window represented by name.  */
 327 struct tui_win_info *
 328 tui_partial_win_by_name (const char *name)
 329 {
 330   struct tui_win_info *win_info = NULL;
 331
 332   if (name != NULL)
 333     {
 334       int i = 0;
 335
 336       while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
 337         {
 338           if (tui_win_list[i] != 0)
 339             {
 340               const char *cur_name = tui_win_name (tui_win_list[i]);
 341
 342               if (strlen (name) <= strlen (cur_name)
 343                   && startswith (cur_name, name))
 344                 win_info = tui_win_list[i];
 345             }
 346           i++;
 347         }
 348     }
 349
 350   return win_info;
 351 }
 352
 353
 354 /* Answer the name of the window.  */
 355 const char *
 356 tui_win_name (const struct tui_gen_win_info *win_info)
 357 {
 358   const char *name = NULL;
 359
 360   switch (win_info->type)
 361     {
 362     case SRC_WIN:
 363       name = SRC_NAME;
 364       break;
 365     case CMD_WIN:
 366       name = CMD_NAME;
 367       break;
 368     case DISASSEM_WIN:
 369       name = DISASSEM_NAME;
 370       break;
 371     case DATA_WIN:
 372       name = DATA_NAME;
 373       break;
 374     default:
 375       name = "";
 376       break;
 377     }
 378
 379   return name;
 380 }
 381
 382
 383 void
 384 tui_initialize_static_data (void)
 385 {
 386   tui_init_generic_part (tui_source_exec_info_win_ptr ());
 387   tui_init_generic_part (tui_disassem_exec_info_win_ptr ());
 388   tui_init_generic_part (tui_locator_win_info_ptr ());
 389 }
 390
 391
 392 void
 393 tui_init_generic_part (struct tui_gen_win_info *win)
 394 {
 395   win->width =
 396     win->height =
 397     win->origin.x =
 398     win->origin.y =
 399     win->viewport_height =
 400     win->content_size =
 401     win->last_visible_line = 0;
 402   win->handle = NULL;
 403   win->content = NULL;
 404   win->content_in_use = FALSE;
 405   win->is_visible = false;
 406   win->title = 0;
 407 }
 408
 409
 410 /* init_content_element().
 411  */
 412 static void
 413 init_content_element (struct tui_win_element *element,
 414                       enum tui_win_type type)
 415 {
 416   switch (type)
 417     {
 418     case SRC_WIN:
 419     case DISASSEM_WIN:
 420       element->which_element.source.line = NULL;
 421       element->which_element.source.line_or_addr.loa = LOA_LINE;
 422       element->which_element.source.line_or_addr.u.line_no = 0;
 423       element->which_element.source.is_exec_point = FALSE;
 424       element->which_element.source.has_break = FALSE;
 425       break;
 426     case DATA_WIN:
 427       element->which_element.data_window = new struct tui_gen_win_info (DATA_ITEM_WIN);
 428       element->which_element.data_window->content =
 429         tui_alloc_content (1, DATA_ITEM_WIN);
 430       element->which_element.data_window->content_size = 1;
 431       break;
 432     case CMD_WIN:
 433       element->which_element.command.line = NULL;
 434       break;
 435     case DATA_ITEM_WIN:
 436       element->which_element.data.name = NULL;
 437       element->which_element.data.type = TUI_REGISTER;
 438       element->which_element.data.item_no = UNDEFINED_ITEM;
 439       element->which_element.data.value = NULL;
 440       element->which_element.data.highlight = FALSE;
 441       element->which_element.data.content = NULL;
 442       break;
 443     case LOCATOR_WIN:
 444       element->which_element.locator.full_name[0] =
 445         element->which_element.locator.proc_name[0] = (char) 0;
 446       element->which_element.locator.line_no = 0;
 447       element->which_element.locator.addr = 0;
 448       break;
 449     case EXEC_INFO_WIN:
 450       memset(element->which_element.simple_string, ' ',
 451              sizeof(element->which_element.simple_string));
 452       break;
 453     default:
 454       break;
 455     }
 456 }
 457
 458 tui_win_info::tui_win_info (enum tui_win_type type)
 459   : tui_gen_win_info (type)
 460 {
 461 }
 462
 463 tui_source_window_base::tui_source_window_base (enum tui_win_type type)
 464   : tui_win_info (type)
 465 {
 466   gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
 467   start_line_or_addr.loa = LOA_ADDRESS;
 468   start_line_or_addr.u.addr = 0;
 469 }
 470
 471 struct tui_win_info *
 472 tui_alloc_win_info (enum tui_win_type type)
 473 {
 474   switch (type)
 475     {
 476     case SRC_WIN:
 477       return new tui_source_window ();
 478
 479     case DISASSEM_WIN:
 480       return new tui_disasm_window ();
 481
 482     case DATA_WIN:
 483       return new tui_data_window ();
 484
 485     case CMD_WIN:
 486       return new tui_cmd_window ();
 487     }
 488
 489   gdb_assert_not_reached (_("Unhandled window type"));
 490 }
 491
 492
 493 /* Allocates the content and elements in a block.  */
 494 tui_win_content
 495 tui_alloc_content (int num_elements, enum tui_win_type type)
 496 {
 497   tui_win_content content;
 498   struct tui_win_element *element_block_ptr;
 499   int i;
 500
 501   content = XNEWVEC (struct tui_win_element *, num_elements);
 502
 503   /*
 504    * All windows, except the data window, can allocate the
 505    * elements in a chunk.  The data window cannot because items
 506    * can be added/removed from the data display by the user at any
 507    * time.
 508    */
 509   if (type != DATA_WIN)
 510     {
 511       element_block_ptr = XNEWVEC (struct tui_win_element, num_elements);
 512       for (i = 0; i < num_elements; i++)
 513         {
 514           content[i] = element_block_ptr;
 515           init_content_element (content[i], type);
 516           element_block_ptr++;
 517         }
 518     }
 519
 520   return content;
 521 }
 522
 523
 524 /* Adds the input number of elements to the windows's content.  If no
 525    content has been allocated yet, alloc_content() is called to do
 526    this.  The index of the first element added is returned, unless
 527    there is a memory allocation error, in which case, (-1) is
 528    returned.  */
 529 int
 530 tui_add_content_elements (struct tui_gen_win_info *win_info,
 531                           int num_elements)
 532 {
 533   struct tui_win_element *element_ptr;
 534   int i, index_start;
 535
 536   if (win_info->content == NULL)
 537     {
 538       win_info->content = tui_alloc_content (num_elements, win_info->type);
 539       index_start = 0;
 540     }
 541   else
 542     index_start = win_info->content_size;
 543   if (win_info->content != NULL)
 544     {
 545       for (i = index_start; (i < num_elements + index_start); i++)
 546         {
 547           element_ptr = XNEW (struct tui_win_element);
 548           win_info->content[i] = element_ptr;
 549           init_content_element (element_ptr, win_info->type);
 550           win_info->content_size++;
 551         }
 552     }
 553
 554   return index_start;
 555 }
 556
 557 tui_source_window_base::~tui_source_window_base ()
 558 {
 559   xfree (fullname);
 560   struct tui_gen_win_info *generic_win = execution_info;
 561   if (generic_win != NULL)
 562     {
 563       tui_delete_win (generic_win->handle);
 564       generic_win->handle = NULL;
 565       tui_free_win_content (generic_win);
 566     }
 567 }
 568
 569 tui_data_window::~tui_data_window ()
 570 {
 571   if (content != NULL)
 572     {
 573       tui_free_data_content (regs_content, regs_content_count);
 574       regs_content = NULL;
 575       regs_content_count = 0;
 576       tui_free_data_content (data_content, data_content_count);
 577       data_content = NULL;
 578       data_content_count = 0;
 579       regs_column_count = 1;
 580       display_regs = false;
 581       content = NULL;
 582       content_size = 0;
 583     }
 584 }
 585
 586 tui_win_info::~tui_win_info ()
 587 {
 588   if (handle != NULL)
 589     {
 590       tui_delete_win (handle);
 591       handle = NULL;
 592       tui_free_win_content (this);
 593     }
 594   if (title)
 595     xfree (title);
 596 }
 597
 598
 599 void
 600 tui_free_all_source_wins_content ()
 601 {
 602   for (tui_source_window_base *win_info : tui_source_windows ())
 603     {
 604       tui_free_win_content (win_info);
 605       tui_free_win_content (win_info->execution_info);
 606     }
 607 }
 608
 609
 610 void
 611 tui_free_win_content (struct tui_gen_win_info *win_info)
 612 {
 613   if (win_info->content != NULL)
 614     {
 615       free_content (win_info->content,
 616                    win_info->content_size,
 617                    win_info->type);
 618       win_info->content = NULL;
 619     }
 620   win_info->content_size = 0;
 621 }
 622
 623
 624 void
 625 tui_free_data_content (tui_win_content content,
 626                        int content_size)
 627 {
 628   int i;
 629
 630   /* Remember that data window content elements are of type struct
 631      tui_gen_win_info *, each of which whose single element is a data
 632      element.  */
 633   for (i = 0; i < content_size; i++)
 634     {
 635       struct tui_gen_win_info *generic_win
 636         = content[i]->which_element.data_window;
 637
 638       if (generic_win != NULL)
 639         {
 640           tui_delete_win (generic_win->handle);
 641           generic_win->handle = NULL;
 642           tui_free_win_content (generic_win);
 643         }
 644     }
 645   free_content (content,
 646                 content_size,
 647                 DATA_WIN);
 648 }
 649
 650
 651 /**********************************
 652 ** LOCAL STATIC FUNCTIONS        **
 653 **********************************/
 654
 655
 656 static void
 657 free_content (tui_win_content content,
 658               int content_size,
 659               enum tui_win_type win_type)
 660 {
 661   if (content != NULL)
 662     {
 663       free_content_elements (content, content_size, win_type);
 664       xfree (content);
 665     }
 666 }
 667
 668
 669 /* free_content_elements().
 670  */
 671 static void
 672 free_content_elements (tui_win_content content,
 673                        int content_size,
 674                        enum tui_win_type type)
 675 {
 676   if (content != NULL)
 677     {
 678       int i;
 679
 680       if (type == DISASSEM_WIN)
 681         {
 682           /* Free whole source block.  */
 683           xfree (content[0]->which_element.source.line);
 684         }
 685       else
 686         {
 687           for (i = 0; i < content_size; i++)
 688             {
 689               struct tui_win_element *element;
 690
 691               element = content[i];
 692               if (element != NULL)
 693                 {
 694                   switch (type)
 695                     {
 696                     case SRC_WIN:
 697                       xfree (element->which_element.source.line);
 698                       break;
 699                     case DATA_WIN:
 700                       delete element->which_element.data_window;
 701                       xfree (element);
 702                       break;
 703                     case DATA_ITEM_WIN:
 704                       /* Note that data elements are not allocated in
 705                          a single block, but individually, as
 706                          needed.  */
 707                       if (element->which_element.data.type != TUI_REGISTER)
 708                         xfree ((void *)element->which_element.data.name);
 709                       xfree (element->which_element.data.value);
 710                       xfree (element->which_element.data.content);
 711                       xfree (element);
 712                       break;
 713                     case CMD_WIN:
 714                       xfree (element->which_element.command.line);
 715                       break;
 716                     default:
 717                       break;
 718                     }
 719                 }
 720             }
 721         }
 722       if (type != DATA_WIN && type != DATA_ITEM_WIN)
 723         xfree (content[0]);     /* Free the element block.  */
 724     }
 725 }