OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [tui/] [tui-data.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* TUI data manipulation routines.
2
 
3
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Hewlett-Packard Company.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#include "defs.h"
24
#include "symtab.h"
25
#include "tui/tui.h"
26
#include "tui/tui-data.h"
27
#include "tui/tui-wingeneral.h"
28
 
29
#include "gdb_string.h"
30
#include "gdb_curses.h"
31
 
32
/****************************
33
** GLOBAL DECLARATIONS
34
****************************/
35
struct tui_win_info *(tui_win_list[MAX_MAJOR_WINDOWS]);
36
 
37
/***************************
38
** Private data
39
****************************/
40
static enum tui_layout_type current_layout = UNDEFINED_LAYOUT;
41
static int term_height, term_width;
42
static struct tui_gen_win_info _locator;
43
static struct tui_gen_win_info exec_info[2];
44
static struct tui_win_info *src_win_list[2];
45
static struct tui_list source_windows = {src_win_list, 0};
46
static int default_tab_len = DEFAULT_TAB_LEN;
47
static struct tui_win_info *win_with_focus = (struct tui_win_info *) NULL;
48
static struct tui_layout_def layout_def = {
49
  SRC_WIN,                      /* DISPLAY_MODE */
50
  FALSE,                        /* SPLIT */
51
  TUI_UNDEFINED_REGS,           /* REGS_DISPLAY_TYPE */
52
  TUI_SFLOAT_REGS};             /* FLOAT_REGS_DISPLAY_TYPE */
53
 
54
static int win_resized = FALSE;
55
 
56
 
57
/*********************************
58
** Static function forward decls
59
**********************************/
60
static void free_content (tui_win_content,
61
                          int,
62
                          enum tui_win_type);
63
static void free_content_elements (tui_win_content,
64
                                   int,
65
                                   enum tui_win_type);
66
 
67
 
68
 
69
/*********************************
70
** PUBLIC FUNCTIONS
71
**********************************/
72
 
73
int
74
tui_win_is_source_type (enum tui_win_type win_type)
75
{
76
  return (win_type == SRC_WIN || win_type == DISASSEM_WIN);
77
}
78
 
79
int
80
tui_win_is_auxillary (enum tui_win_type win_type)
81
{
82
  return (win_type > MAX_MAJOR_WINDOWS);
83
}
84
 
85
int
86
tui_win_has_locator (struct tui_win_info *win_info)
87
{
88
  return (win_info != NULL
89
          && win_info->detail.source_info.has_locator);
90
}
91
 
92
void
93
tui_set_win_highlight (struct tui_win_info *win_info,
94
                       int highlight)
95
{
96
  if (win_info != NULL)
97
    win_info->is_highlighted = highlight;
98
}
99
 
100
/******************************************
101
** ACCESSORS & MUTATORS FOR PRIVATE DATA
102
******************************************/
103
 
104
/* Answer a whether the terminal window has been resized or not.  */
105
int
106
tui_win_resized (void)
107
{
108
  return win_resized;
109
}
110
 
111
 
112
/* Set a whether the terminal window has been resized or not.  */
113
void
114
tui_set_win_resized_to (int resized)
115
{
116
  win_resized = resized;
117
}
118
 
119
 
120
/* Answer a pointer to the current layout definition.  */
121
struct tui_layout_def *
122
tui_layout_def (void)
123
{
124
  return &layout_def;
125
}
126
 
127
 
128
/* Answer the window with the logical focus.  */
129
struct tui_win_info *
130
tui_win_with_focus (void)
131
{
132
  return win_with_focus;
133
}
134
 
135
 
136
/* Set the window that has the logical focus.  */
137
void
138
tui_set_win_with_focus (struct tui_win_info *win_info)
139
{
140
  win_with_focus = win_info;
141
}
142
 
143
 
144
/* Answer the length in chars, of tabs.  */
145
int
146
tui_default_tab_len (void)
147
{
148
  return default_tab_len;
149
}
150
 
151
 
152
/* Set the length in chars, of tabs.  */
153
void
154
tui_set_default_tab_len (int len)
155
{
156
  default_tab_len = len;
157
}
158
 
159
 
160
/* Accessor for the current source window.  Usually there is only one
161
   source window (either source or disassembly), but both can be
162
   displayed at the same time.  */
163
struct tui_list *
164
tui_source_windows (void)
165
{
166
  return &source_windows;
167
}
168
 
169
 
170
/* Clear the list of source windows.  Usually there is only one source
171
   window (either source or disassembly), but both can be displayed at
172
   the same time.  */
173
void
174
tui_clear_source_windows (void)
175
{
176
  source_windows.list[0] = NULL;
177
  source_windows.list[1] = NULL;
178
  source_windows.count = 0;
179
}
180
 
181
 
182
/* Clear the pertinant detail in the source windows.  */
183
void
184
tui_clear_source_windows_detail (void)
185
{
186
  int i;
187
 
188
  for (i = 0; i < (tui_source_windows ())->count; i++)
189
    tui_clear_win_detail ((tui_source_windows ())->list[i]);
190
}
191
 
192
 
193
/* Add a window to the list of source windows.  Usually there is only
194
   one source window (either source or disassembly), but both can be
195
   displayed at the same time.  */
196
void
197
tui_add_to_source_windows (struct tui_win_info *win_info)
198
{
199
  if (source_windows.count < 2)
200
    source_windows.list[source_windows.count++] = (void *) win_info;
201
}
202
 
203
 
204
/* Clear the pertinant detail in the windows.  */
205
void
206
tui_clear_win_detail (struct tui_win_info *win_info)
207
{
208
  if (win_info != NULL)
209
    {
210
      switch (win_info->generic.type)
211
        {
212
        case SRC_WIN:
213
        case DISASSEM_WIN:
214
          win_info->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS;
215
          win_info->detail.source_info.start_line_or_addr.u.addr = 0;
216
          win_info->detail.source_info.horizontal_offset = 0;
217
          break;
218
        case CMD_WIN:
219
          win_info->detail.command_info.cur_line =
220
            win_info->detail.command_info.curch = 0;
221
          break;
222
        case DATA_WIN:
223
          win_info->detail.data_display_info.data_content =
224
            (tui_win_content) NULL;
225
          win_info->detail.data_display_info.data_content_count = 0;
226
          win_info->detail.data_display_info.regs_content =
227
            (tui_win_content) NULL;
228
          win_info->detail.data_display_info.regs_content_count = 0;
229
          win_info->detail.data_display_info.regs_display_type =
230
            TUI_UNDEFINED_REGS;
231
          win_info->detail.data_display_info.regs_column_count = 1;
232
          win_info->detail.data_display_info.display_regs = FALSE;
233
          break;
234
        default:
235
          break;
236
        }
237
    }
238
}
239
 
240
 
241
/* Accessor for the source execution info ptr.  */
242
struct tui_gen_win_info *
243
tui_source_exec_info_win_ptr (void)
244
{
245
  return &exec_info[0];
246
}
247
 
248
 
249
/* Accessor for the disassem execution info ptr.  */
250
struct tui_gen_win_info *
251
tui_disassem_exec_info_win_ptr (void)
252
{
253
  return &exec_info[1];
254
}
255
 
256
 
257
/* Accessor for the locator win info.  Answers a pointer to the static
258
   locator win info struct.  */
259
struct tui_gen_win_info *
260
tui_locator_win_info_ptr (void)
261
{
262
  return &_locator;
263
}
264
 
265
 
266
/* Accessor for the term_height.  */
267
int
268
tui_term_height (void)
269
{
270
  return term_height;
271
}
272
 
273
 
274
/* Mutator for the term height.  */
275
void
276
tui_set_term_height_to (int h)
277
{
278
  term_height = h;
279
}
280
 
281
 
282
/* Accessor for the term_width.  */
283
int
284
tui_term_width (void)
285
{
286
  return term_width;
287
}
288
 
289
 
290
/* Mutator for the term_width.  */
291
void
292
tui_set_term_width_to (int w)
293
{
294
  term_width = w;
295
}
296
 
297
 
298
/* Accessor for the current layout.  */
299
enum tui_layout_type
300
tui_current_layout (void)
301
{
302
  return current_layout;
303
}
304
 
305
 
306
/* Mutator for the current layout.  */
307
void
308
tui_set_current_layout_to (enum tui_layout_type new_layout)
309
{
310
  current_layout = new_layout;
311
}
312
 
313
 
314
/* Set the origin of the window.  */
315
void
316
set_gen_win_origin (struct tui_gen_win_info *win_info,
317
                    int x, int y)
318
{
319
  win_info->origin.x = x;
320
  win_info->origin.y = y;
321
}
322
 
323
 
324
/*****************************
325
** OTHER PUBLIC FUNCTIONS
326
*****************************/
327
 
328
 
329
/* Answer the next window in the list, cycling back to the top if
330
   necessary.  */
331
struct tui_win_info *
332
tui_next_win (struct tui_win_info *cur_win)
333
{
334
  enum tui_win_type type = cur_win->generic.type;
335
  struct tui_win_info *next_win = (struct tui_win_info *) NULL;
336
 
337
  if (cur_win->generic.type == CMD_WIN)
338
    type = SRC_WIN;
339
  else
340
    type = cur_win->generic.type + 1;
341
  while (type != cur_win->generic.type && (next_win == NULL))
342
    {
343
      if (tui_win_list[type]
344
          && tui_win_list[type]->generic.is_visible)
345
        next_win = tui_win_list[type];
346
      else
347
        {
348
          if (type == CMD_WIN)
349
            type = SRC_WIN;
350
          else
351
            type++;
352
        }
353
    }
354
 
355
  return next_win;
356
}
357
 
358
 
359
/* Answer the prev window in the list, cycling back to the bottom if
360
   necessary.  */
361
struct tui_win_info *
362
tui_prev_win (struct tui_win_info *cur_win)
363
{
364
  enum tui_win_type type = cur_win->generic.type;
365
  struct tui_win_info *prev = (struct tui_win_info *) NULL;
366
 
367
  if (cur_win->generic.type == SRC_WIN)
368
    type = CMD_WIN;
369
  else
370
    type = cur_win->generic.type - 1;
371
  while (type != cur_win->generic.type && (prev == NULL))
372
    {
373
      if (tui_win_list[type]
374
          && tui_win_list[type]->generic.is_visible)
375
        prev = tui_win_list[type];
376
      else
377
        {
378
          if (type == SRC_WIN)
379
            type = CMD_WIN;
380
          else
381
            type--;
382
        }
383
    }
384
 
385
  return prev;
386
}
387
 
388
 
389
/* Answer the window represented by name.  */
390
struct tui_win_info *
391
tui_partial_win_by_name (char *name)
392
{
393
  struct tui_win_info *win_info = (struct tui_win_info *) NULL;
394
 
395
  if (name != (char *) NULL)
396
    {
397
      int i = 0;
398
 
399
      while (i < MAX_MAJOR_WINDOWS && win_info == NULL)
400
        {
401
          if (tui_win_list[i] != 0)
402
            {
403
              char *cur_name = tui_win_name (&tui_win_list[i]->generic);
404
              if (strlen (name) <= strlen (cur_name)
405
                  && strncmp (name, cur_name, strlen (name)) == 0)
406
                win_info = tui_win_list[i];
407
            }
408
          i++;
409
        }
410
    }
411
 
412
  return win_info;
413
}
414
 
415
 
416
/* Answer the name of the window.  */
417
char *
418
tui_win_name (struct tui_gen_win_info *win_info)
419
{
420
  char *name = (char *) NULL;
421
 
422
  switch (win_info->type)
423
    {
424
    case SRC_WIN:
425
      name = SRC_NAME;
426
      break;
427
    case CMD_WIN:
428
      name = CMD_NAME;
429
      break;
430
    case DISASSEM_WIN:
431
      name = DISASSEM_NAME;
432
      break;
433
    case DATA_WIN:
434
      name = DATA_NAME;
435
      break;
436
    default:
437
      name = "";
438
      break;
439
    }
440
 
441
  return name;
442
}
443
 
444
 
445
void
446
tui_initialize_static_data (void)
447
{
448
  tui_init_generic_part (tui_source_exec_info_win_ptr ());
449
  tui_init_generic_part (tui_disassem_exec_info_win_ptr ());
450
  tui_init_generic_part (tui_locator_win_info_ptr ());
451
}
452
 
453
 
454
struct tui_gen_win_info *
455
tui_alloc_generic_win_info (void)
456
{
457
  struct tui_gen_win_info *win;
458
 
459
  if ((win = XMALLOC (struct tui_gen_win_info)) != NULL)
460
    tui_init_generic_part (win);
461
 
462
  return win;
463
}
464
 
465
 
466
void
467
tui_init_generic_part (struct tui_gen_win_info *win)
468
{
469
  win->width =
470
    win->height =
471
    win->origin.x =
472
    win->origin.y =
473
    win->viewport_height =
474
    win->content_size =
475
    win->last_visible_line = 0;
476
  win->handle = (WINDOW *) NULL;
477
  win->content = NULL;
478
  win->content_in_use =
479
    win->is_visible = FALSE;
480
  win->title = 0;
481
}
482
 
483
 
484
/* init_content_element().
485
 */
486
void
487
init_content_element (struct tui_win_element *element,
488
                      enum tui_win_type type)
489
{
490
  element->highlight = FALSE;
491
  switch (type)
492
    {
493
    case SRC_WIN:
494
    case DISASSEM_WIN:
495
      element->which_element.source.line = (char *) NULL;
496
      element->which_element.source.line_or_addr.loa = LOA_LINE;
497
      element->which_element.source.line_or_addr.u.line_no = 0;
498
      element->which_element.source.is_exec_point = FALSE;
499
      element->which_element.source.has_break = FALSE;
500
      break;
501
    case DATA_WIN:
502
      tui_init_generic_part (&element->which_element.data_window);
503
      element->which_element.data_window.type = DATA_ITEM_WIN;
504
      ((struct tui_gen_win_info *) & element->which_element.data_window)->content =
505
        (void **) tui_alloc_content (1, DATA_ITEM_WIN);
506
      ((struct tui_gen_win_info *)
507
       & element->which_element.data_window)->content_size = 1;
508
      break;
509
    case CMD_WIN:
510
      element->which_element.command.line = (char *) NULL;
511
      break;
512
    case DATA_ITEM_WIN:
513
      element->which_element.data.name = (char *) NULL;
514
      element->which_element.data.type = TUI_REGISTER;
515
      element->which_element.data.item_no = UNDEFINED_ITEM;
516
      element->which_element.data.value = NULL;
517
      element->which_element.data.highlight = FALSE;
518
      element->which_element.data.content = (char*) NULL;
519
      break;
520
    case LOCATOR_WIN:
521
      element->which_element.locator.file_name[0] =
522
        element->which_element.locator.proc_name[0] = (char) 0;
523
      element->which_element.locator.line_no = 0;
524
      element->which_element.locator.addr = 0;
525
      break;
526
    case EXEC_INFO_WIN:
527
      memset(element->which_element.simple_string, ' ',
528
             sizeof(element->which_element.simple_string));
529
      break;
530
    default:
531
      break;
532
    }
533
}
534
 
535
void
536
init_win_info (struct tui_win_info *win_info)
537
{
538
  tui_init_generic_part (&win_info->generic);
539
  win_info->can_highlight =
540
    win_info->is_highlighted = FALSE;
541
  switch (win_info->generic.type)
542
    {
543
    case SRC_WIN:
544
    case DISASSEM_WIN:
545
      win_info->detail.source_info.execution_info = (struct tui_gen_win_info *) NULL;
546
      win_info->detail.source_info.has_locator = FALSE;
547
      win_info->detail.source_info.horizontal_offset = 0;
548
      win_info->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS;
549
      win_info->detail.source_info.start_line_or_addr.u.addr = 0;
550
      win_info->detail.source_info.filename = 0;
551
      break;
552
    case DATA_WIN:
553
      win_info->detail.data_display_info.data_content = (tui_win_content) NULL;
554
      win_info->detail.data_display_info.data_content_count = 0;
555
      win_info->detail.data_display_info.regs_content = (tui_win_content) NULL;
556
      win_info->detail.data_display_info.regs_content_count = 0;
557
      win_info->detail.data_display_info.regs_display_type =
558
        TUI_UNDEFINED_REGS;
559
      win_info->detail.data_display_info.regs_column_count = 1;
560
      win_info->detail.data_display_info.display_regs = FALSE;
561
      win_info->detail.data_display_info.current_group = 0;
562
      break;
563
    case CMD_WIN:
564
      win_info->detail.command_info.cur_line = 0;
565
      win_info->detail.command_info.curch = 0;
566
      break;
567
    default:
568
      win_info->detail.opaque = NULL;
569
      break;
570
    }
571
}
572
 
573
 
574
struct tui_win_info *
575
tui_alloc_win_info (enum tui_win_type type)
576
{
577
  struct tui_win_info *win_info;
578
 
579
  win_info = XMALLOC (struct tui_win_info);
580
  if (win_info != NULL)
581
    {
582
      win_info->generic.type = type;
583
      init_win_info (win_info);
584
    }
585
 
586
  return win_info;
587
}
588
 
589
 
590
/* Allocates the content and elements in a block.  */
591
tui_win_content
592
tui_alloc_content (int num_elements, enum tui_win_type type)
593
{
594
  tui_win_content content;
595
  char *element_block_ptr;
596
  int i;
597
 
598
  content = xmalloc (sizeof (struct tui_win_element *) *num_elements);
599
  if (content != NULL)
600
    {
601
      /*
602
       * All windows, except the data window, can allocate the
603
       * elements in a chunk.  The data window cannot because items
604
       * can be added/removed from the data display by the user at any
605
       * time.
606
       */
607
      if (type != DATA_WIN)
608
        {
609
          element_block_ptr =
610
            xmalloc (sizeof (struct tui_win_element) * num_elements);
611
          if (element_block_ptr != NULL)
612
            {
613
              for (i = 0; i < num_elements; i++)
614
                {
615
                  content[i] = (struct tui_win_element *) element_block_ptr;
616
                  init_content_element (content[i], type);
617
                  element_block_ptr += sizeof (struct tui_win_element);
618
                }
619
            }
620
          else
621
            {
622
              xfree (content);
623
              content = (tui_win_content) NULL;
624
            }
625
        }
626
    }
627
 
628
  return content;
629
}
630
 
631
 
632
/* Adds the input number of elements to the windows's content.  If no
633
   content has been allocated yet, alloc_content() is called to do
634
   this.  The index of the first element added is returned, unless
635
   there is a memory allocation error, in which case, (-1) is
636
   returned.  */
637
int
638
tui_add_content_elements (struct tui_gen_win_info *win_info,
639
                          int num_elements)
640
{
641
  struct tui_win_element *element_ptr;
642
  int i, index_start;
643
 
644
  if (win_info->content == NULL)
645
    {
646
      win_info->content = (void **) tui_alloc_content (num_elements, win_info->type);
647
      index_start = 0;
648
    }
649
  else
650
    index_start = win_info->content_size;
651
  if (win_info->content != NULL)
652
    {
653
      for (i = index_start; (i < num_elements + index_start); i++)
654
        {
655
          if ((element_ptr = XMALLOC (struct tui_win_element)) != NULL)
656
            {
657
              win_info->content[i] = (void *) element_ptr;
658
              init_content_element (element_ptr, win_info->type);
659
              win_info->content_size++;
660
            }
661
          else  /* Things must be really hosed now!  We ran out of
662
                   memory!?  */
663
            return (-1);
664
        }
665
    }
666
 
667
  return index_start;
668
}
669
 
670
 
671
/* Delete all curses windows associated with win_info, leaving
672
   everything else intact.  */
673
void
674
tui_del_window (struct tui_win_info *win_info)
675
{
676
  struct tui_gen_win_info *generic_win;
677
 
678
  switch (win_info->generic.type)
679
    {
680
    case SRC_WIN:
681
    case DISASSEM_WIN:
682
      generic_win = tui_locator_win_info_ptr ();
683
      if (generic_win != (struct tui_gen_win_info *) NULL)
684
        {
685
          tui_delete_win (generic_win->handle);
686
          generic_win->handle = (WINDOW *) NULL;
687
          generic_win->is_visible = FALSE;
688
        }
689
      if (win_info->detail.source_info.filename)
690
        {
691
          xfree (win_info->detail.source_info.filename);
692
          win_info->detail.source_info.filename = 0;
693
        }
694
      generic_win = win_info->detail.source_info.execution_info;
695
      if (generic_win != (struct tui_gen_win_info *) NULL)
696
        {
697
          tui_delete_win (generic_win->handle);
698
          generic_win->handle = (WINDOW *) NULL;
699
          generic_win->is_visible = FALSE;
700
        }
701
      break;
702
    case DATA_WIN:
703
      if (win_info->generic.content != NULL)
704
        {
705
          tui_del_data_windows (win_info->detail.data_display_info.regs_content,
706
                                win_info->detail.data_display_info.regs_content_count);
707
          tui_del_data_windows (win_info->detail.data_display_info.data_content,
708
                                win_info->detail.data_display_info.data_content_count);
709
        }
710
      break;
711
    default:
712
      break;
713
    }
714
  if (win_info->generic.handle != (WINDOW *) NULL)
715
    {
716
      tui_delete_win (win_info->generic.handle);
717
      win_info->generic.handle = (WINDOW *) NULL;
718
      win_info->generic.is_visible = FALSE;
719
    }
720
}
721
 
722
 
723
void
724
tui_free_window (struct tui_win_info *win_info)
725
{
726
  struct tui_gen_win_info *generic_win;
727
 
728
  switch (win_info->generic.type)
729
    {
730
    case SRC_WIN:
731
    case DISASSEM_WIN:
732
      generic_win = tui_locator_win_info_ptr ();
733
      if (generic_win != (struct tui_gen_win_info *) NULL)
734
        {
735
          tui_delete_win (generic_win->handle);
736
          generic_win->handle = (WINDOW *) NULL;
737
        }
738
      tui_free_win_content (generic_win);
739
      if (win_info->detail.source_info.filename)
740
        {
741
          xfree (win_info->detail.source_info.filename);
742
          win_info->detail.source_info.filename = 0;
743
        }
744
      generic_win = win_info->detail.source_info.execution_info;
745
      if (generic_win != (struct tui_gen_win_info *) NULL)
746
        {
747
          tui_delete_win (generic_win->handle);
748
          generic_win->handle = (WINDOW *) NULL;
749
          tui_free_win_content (generic_win);
750
        }
751
      break;
752
    case DATA_WIN:
753
      if (win_info->generic.content != NULL)
754
        {
755
          tui_free_data_content (win_info->detail.data_display_info.regs_content,
756
                                 win_info->detail.data_display_info.regs_content_count);
757
          win_info->detail.data_display_info.regs_content =
758
            (tui_win_content) NULL;
759
          win_info->detail.data_display_info.regs_content_count = 0;
760
          tui_free_data_content (win_info->detail.data_display_info.data_content,
761
                                 win_info->detail.data_display_info.data_content_count);
762
          win_info->detail.data_display_info.data_content =
763
            (tui_win_content) NULL;
764
          win_info->detail.data_display_info.data_content_count = 0;
765
          win_info->detail.data_display_info.regs_display_type =
766
            TUI_UNDEFINED_REGS;
767
          win_info->detail.data_display_info.regs_column_count = 1;
768
          win_info->detail.data_display_info.display_regs = FALSE;
769
          win_info->generic.content = NULL;
770
          win_info->generic.content_size = 0;
771
        }
772
      break;
773
    default:
774
      break;
775
    }
776
  if (win_info->generic.handle != (WINDOW *) NULL)
777
    {
778
      tui_delete_win (win_info->generic.handle);
779
      win_info->generic.handle = (WINDOW *) NULL;
780
      tui_free_win_content (&win_info->generic);
781
    }
782
  if (win_info->generic.title)
783
    xfree (win_info->generic.title);
784
  xfree (win_info);
785
}
786
 
787
 
788
void
789
tui_free_all_source_wins_content (void)
790
{
791
  int i;
792
 
793
  for (i = 0; i < (tui_source_windows ())->count; i++)
794
    {
795
      struct tui_win_info *win_info = (tui_source_windows ())->list[i];
796
 
797
      if (win_info != NULL)
798
        {
799
          tui_free_win_content (&(win_info->generic));
800
          tui_free_win_content (win_info->detail.source_info.execution_info);
801
        }
802
    }
803
}
804
 
805
 
806
void
807
tui_free_win_content (struct tui_gen_win_info *win_info)
808
{
809
  if (win_info->content != NULL)
810
    {
811
      free_content ((tui_win_content) win_info->content,
812
                   win_info->content_size,
813
                   win_info->type);
814
      win_info->content = NULL;
815
    }
816
  win_info->content_size = 0;
817
}
818
 
819
 
820
void
821
tui_del_data_windows (tui_win_content content,
822
                      int content_size)
823
{
824
  int i;
825
 
826
  /* Remember that data window content elements are of type struct
827
     tui_gen_win_info *, each of which whose single element is a data
828
     element.  */
829
  for (i = 0; i < content_size; i++)
830
    {
831
      struct tui_gen_win_info *generic_win = &content[i]->which_element.data_window;
832
 
833
      if (generic_win != (struct tui_gen_win_info *) NULL)
834
        {
835
          tui_delete_win (generic_win->handle);
836
          generic_win->handle = (WINDOW *) NULL;
837
          generic_win->is_visible = FALSE;
838
        }
839
    }
840
}
841
 
842
 
843
void
844
tui_free_data_content (tui_win_content content,
845
                       int content_size)
846
{
847
  int i;
848
 
849
  /* Remember that data window content elements are of type struct
850
     tui_gen_win_info *, each of which whose single element is a data
851
     element.  */
852
  for (i = 0; i < content_size; i++)
853
    {
854
      struct tui_gen_win_info *generic_win = &content[i]->which_element.data_window;
855
 
856
      if (generic_win != (struct tui_gen_win_info *) NULL)
857
        {
858
          tui_delete_win (generic_win->handle);
859
          generic_win->handle = (WINDOW *) NULL;
860
          tui_free_win_content (generic_win);
861
        }
862
    }
863
  free_content (content,
864
                content_size,
865
                DATA_WIN);
866
}
867
 
868
 
869
/**********************************
870
** LOCAL STATIC FUNCTIONS        **
871
**********************************/
872
 
873
 
874
static void
875
free_content (tui_win_content content,
876
              int content_size,
877
              enum tui_win_type win_type)
878
{
879
  if (content != (tui_win_content) NULL)
880
    {
881
      free_content_elements (content, content_size, win_type);
882
      xfree (content);
883
    }
884
}
885
 
886
 
887
/* free_content_elements().
888
 */
889
static void
890
free_content_elements (tui_win_content content,
891
                       int content_size,
892
                       enum tui_win_type type)
893
{
894
  if (content != (tui_win_content) NULL)
895
    {
896
      int i;
897
 
898
      if (type == SRC_WIN || type == DISASSEM_WIN)
899
        {
900
          /* Free whole source block.  */
901
          xfree (content[0]->which_element.source.line);
902
        }
903
      else
904
        {
905
          for (i = 0; i < content_size; i++)
906
            {
907
              struct tui_win_element *element;
908
 
909
              element = content[i];
910
              if (element != (struct tui_win_element *) NULL)
911
                {
912
                  switch (type)
913
                    {
914
                    case DATA_WIN:
915
                      xfree (element);
916
                      break;
917
                    case DATA_ITEM_WIN:
918
                      /* Note that data elements are not allocated in
919
                         a single block, but individually, as
920
                         needed.  */
921
                      if (element->which_element.data.type != TUI_REGISTER)
922
                        xfree ((void *)element->which_element.data.name);
923
                      xfree (element->which_element.data.value);
924
                      xfree (element->which_element.data.content);
925
                      xfree (element);
926
                      break;
927
                    case CMD_WIN:
928
                      xfree (element->which_element.command.line);
929
                      break;
930
                    default:
931
                      break;
932
                    }
933
                }
934
            }
935
        }
936
      if (type != DATA_WIN && type != DATA_ITEM_WIN)
937
        xfree (content[0]);      /* Free the element block.  */
938
    }
939
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.