File: | src/gnu/usr.bin/binutils/gdb/tui/tui-winsource.c |
Warning: | line 589, column 3 Array access (via field 'content') results in a null pointer dereference |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* TUI display source/assembly window. | |||
2 | ||||
3 | Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software | |||
4 | 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 2 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, write to the Free Software | |||
22 | Foundation, Inc., 59 Temple Place - Suite 330, | |||
23 | Boston, MA 02111-1307, USA. */ | |||
24 | ||||
25 | #include "defs.h" | |||
26 | #include <ctype.h> | |||
27 | #include "symtab.h" | |||
28 | #include "frame.h" | |||
29 | #include "breakpoint.h" | |||
30 | #include "value.h" | |||
31 | #include "source.h" | |||
32 | ||||
33 | #include "tui/tui.h" | |||
34 | #include "tui/tui-data.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 | ||||
42 | #include "gdb_string.h" | |||
43 | #include "gdb_curses.h" | |||
44 | ||||
45 | /* Function to display the "main" routine. */ | |||
46 | void | |||
47 | tui_display_main (void) | |||
48 | { | |||
49 | if ((tui_source_windows ())->count > 0) | |||
50 | { | |||
51 | CORE_ADDR addr; | |||
52 | ||||
53 | addr = tui_get_begin_asm_address (); | |||
54 | if (addr != (CORE_ADDR) 0) | |||
55 | { | |||
56 | struct symtab_and_line sal; | |||
57 | ||||
58 | tui_update_source_windows_with_addr (addr); | |||
59 | sal = find_pc_line (addr, 0); | |||
60 | if (sal.symtab) | |||
61 | tui_update_locator_filename (sal.symtab->filename); | |||
62 | else | |||
63 | tui_update_locator_filename ("??"); | |||
64 | } | |||
65 | } | |||
66 | } | |||
67 | ||||
68 | ||||
69 | ||||
70 | /* Function to display source in the source window. This function | |||
71 | initializes the horizontal scroll to 0. */ | |||
72 | void | |||
73 | tui_update_source_window (struct tui_win_info * win_info, struct symtab *s, | |||
74 | union tui_line_or_address line_or_addr, int noerror) | |||
75 | { | |||
76 | win_info->detail.source_info.horizontal_offset = 0; | |||
77 | tui_update_source_window_as_is (win_info, s, line_or_addr, noerror); | |||
78 | ||||
79 | return; | |||
80 | } | |||
81 | ||||
82 | ||||
83 | /* Function to display source in the source/asm window. This function | |||
84 | shows the source as specified by the horizontal offset. */ | |||
85 | void | |||
86 | tui_update_source_window_as_is (struct tui_win_info * win_info, struct symtab *s, | |||
87 | union tui_line_or_address line_or_addr, int noerror) | |||
88 | { | |||
89 | enum tui_status ret; | |||
90 | ||||
91 | if (win_info->generic.type == SRC_WIN) | |||
92 | ret = tui_set_source_content (s, line_or_addr.line_no, noerror); | |||
93 | else | |||
94 | ret = tui_set_disassem_content (line_or_addr.addr); | |||
95 | ||||
96 | if (ret == TUI_FAILURE) | |||
97 | { | |||
98 | tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT1); | |||
99 | tui_clear_exec_info_content (win_info); | |||
100 | } | |||
101 | else | |||
102 | { | |||
103 | tui_update_breakpoint_info (win_info, 0); | |||
104 | tui_show_source_content (win_info); | |||
105 | tui_update_exec_info (win_info); | |||
106 | if (win_info->generic.type == SRC_WIN) | |||
107 | { | |||
108 | struct symtab_and_line sal; | |||
109 | ||||
110 | sal.line = line_or_addr.line_no + | |||
111 | (win_info->generic.content_size - 2); | |||
112 | sal.symtab = s; | |||
113 | set_current_source_symtab_and_line (&sal); | |||
114 | /* | |||
115 | ** If the focus was in the asm win, put it in the src | |||
116 | ** win if we don't have a split layout | |||
117 | */ | |||
118 | if (tui_win_with_focus () == TUI_DISASM_WINtui_win_list[DISASSEM_WIN] && | |||
119 | tui_current_layout () != SRC_DISASSEM_COMMAND) | |||
120 | tui_set_win_focus_to (TUI_SRC_WINtui_win_list[SRC_WIN]); | |||
121 | } | |||
122 | } | |||
123 | ||||
124 | ||||
125 | return; | |||
126 | } | |||
127 | ||||
128 | ||||
129 | /* Function to ensure that the source and/or disassemly windows | |||
130 | reflect the input address. */ | |||
131 | void | |||
132 | tui_update_source_windows_with_addr (CORE_ADDR addr) | |||
133 | { | |||
134 | if (addr != 0) | |||
135 | { | |||
136 | struct symtab_and_line sal; | |||
137 | union tui_line_or_address l; | |||
138 | ||||
139 | switch (tui_current_layout ()) | |||
140 | { | |||
141 | case DISASSEM_COMMAND: | |||
142 | case DISASSEM_DATA_COMMAND: | |||
143 | tui_show_disassem (addr); | |||
144 | break; | |||
145 | case SRC_DISASSEM_COMMAND: | |||
146 | tui_show_disassem_and_update_source (addr); | |||
147 | break; | |||
148 | default: | |||
149 | sal = find_pc_line (addr, 0); | |||
150 | l.line_no = sal.line; | |||
151 | tui_show_symtab_source (sal.symtab, l, FALSE0); | |||
152 | break; | |||
153 | } | |||
154 | } | |||
155 | else | |||
156 | { | |||
157 | int i; | |||
158 | ||||
159 | for (i = 0; i < (tui_source_windows ())->count; i++) | |||
160 | { | |||
161 | struct tui_win_info * win_info = (struct tui_win_info *) (tui_source_windows ())->list[i]; | |||
162 | ||||
163 | tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT1); | |||
164 | tui_clear_exec_info_content (win_info); | |||
165 | } | |||
166 | } | |||
167 | } | |||
168 | ||||
169 | /* Function to ensure that the source and/or disassemly windows | |||
170 | reflect the input address. */ | |||
171 | void | |||
172 | tui_update_source_windows_with_line (struct symtab *s, int line) | |||
173 | { | |||
174 | CORE_ADDR pc; | |||
175 | union tui_line_or_address l; | |||
176 | ||||
177 | switch (tui_current_layout ()) | |||
178 | { | |||
179 | case DISASSEM_COMMAND: | |||
180 | case DISASSEM_DATA_COMMAND: | |||
181 | find_line_pc (s, line, &pc); | |||
182 | tui_update_source_windows_with_addr (pc); | |||
183 | break; | |||
184 | default: | |||
185 | l.line_no = line; | |||
186 | tui_show_symtab_source (s, l, FALSE0); | |||
187 | if (tui_current_layout () == SRC_DISASSEM_COMMAND) | |||
188 | { | |||
189 | find_line_pc (s, line, &pc); | |||
190 | tui_show_disassem (pc); | |||
191 | } | |||
192 | break; | |||
193 | } | |||
194 | ||||
195 | return; | |||
196 | } | |||
197 | ||||
198 | void | |||
199 | tui_clear_source_content (struct tui_win_info * win_info, int display_prompt) | |||
200 | { | |||
201 | if (win_info != NULL((void*)0)) | |||
202 | { | |||
203 | int i; | |||
204 | ||||
205 | win_info->generic.content_in_use = FALSE0; | |||
206 | tui_erase_source_content (win_info, display_prompt); | |||
207 | for (i = 0; i < win_info->generic.content_size; i++) | |||
208 | { | |||
209 | struct tui_win_element * element = | |||
210 | (struct tui_win_element *) win_info->generic.content[i]; | |||
211 | element->which_element.source.has_break = FALSE0; | |||
212 | element->which_element.source.is_exec_point = FALSE0; | |||
213 | } | |||
214 | } | |||
215 | } | |||
216 | ||||
217 | ||||
218 | void | |||
219 | tui_erase_source_content (struct tui_win_info * win_info, int display_prompt) | |||
220 | { | |||
221 | int x_pos; | |||
222 | int half_width = (win_info->generic.width - 2) / 2; | |||
223 | ||||
224 | if (win_info->generic.handle != (WINDOW *) NULL((void*)0)) | |||
225 | { | |||
226 | werase (win_info->generic.handle); | |||
227 | tui_check_and_display_highlight_if_needed (win_info); | |||
228 | if (display_prompt == EMPTY_SOURCE_PROMPT1) | |||
229 | { | |||
230 | char *no_src_str; | |||
231 | ||||
232 | if (win_info->generic.type == SRC_WIN) | |||
233 | no_src_str = NO_SRC_STRING"[ No Source Available ]"; | |||
234 | else | |||
235 | no_src_str = NO_DISASSEM_STRING"[ No Assembly Available ]"; | |||
236 | if (strlen (no_src_str) >= half_width) | |||
237 | x_pos = 1; | |||
238 | else | |||
239 | x_pos = half_width - strlen (no_src_str); | |||
240 | mvwaddstr (win_info->generic.handle,(wmove(win_info->generic.handle,(win_info->generic.height / 2),x_pos) == (-1) ? (-1) : waddnstr(win_info->generic.handle ,no_src_str,-1)) | |||
241 | (win_info->generic.height / 2),(wmove(win_info->generic.handle,(win_info->generic.height / 2),x_pos) == (-1) ? (-1) : waddnstr(win_info->generic.handle ,no_src_str,-1)) | |||
242 | x_pos,(wmove(win_info->generic.handle,(win_info->generic.height / 2),x_pos) == (-1) ? (-1) : waddnstr(win_info->generic.handle ,no_src_str,-1)) | |||
243 | no_src_str)(wmove(win_info->generic.handle,(win_info->generic.height / 2),x_pos) == (-1) ? (-1) : waddnstr(win_info->generic.handle ,no_src_str,-1)); | |||
244 | ||||
245 | /* elz: added this function call to set the real contents of | |||
246 | the window to what is on the screen, so that later calls | |||
247 | to refresh, do display | |||
248 | the correct stuff, and not the old image */ | |||
249 | ||||
250 | tui_set_source_content_nil (win_info, no_src_str); | |||
251 | } | |||
252 | tui_refresh_win (&win_info->generic); | |||
253 | } | |||
254 | } | |||
255 | ||||
256 | ||||
257 | /* Redraw the complete line of a source or disassembly window. */ | |||
258 | static void | |||
259 | tui_show_source_line (struct tui_win_info * win_info, int lineno) | |||
260 | { | |||
261 | struct tui_win_element * line; | |||
262 | int x, y; | |||
263 | ||||
264 | line = (struct tui_win_element *) win_info->generic.content[lineno - 1]; | |||
265 | if (line->which_element.source.is_exec_point) | |||
266 | wattron (win_info->generic.handle, A_STANDOUT)wattr_on(win_info->generic.handle, (attr_t)(((1U) << ((8) + 8))), ((void*)0)); | |||
267 | ||||
268 | mvwaddstr (win_info->generic.handle, lineno, 1,(wmove(win_info->generic.handle,lineno,1) == (-1) ? (-1) : waddnstr(win_info->generic.handle,line->which_element. source.line,-1)) | |||
269 | line->which_element.source.line)(wmove(win_info->generic.handle,lineno,1) == (-1) ? (-1) : waddnstr(win_info->generic.handle,line->which_element. source.line,-1)); | |||
270 | if (line->which_element.source.is_exec_point) | |||
271 | wattroff (win_info->generic.handle, A_STANDOUT)wattr_off(win_info->generic.handle, (attr_t)(((1U) << ((8) + 8))), ((void*)0)); | |||
272 | ||||
273 | /* Clear to end of line but stop before the border. */ | |||
274 | getyx (win_info->generic.handle, y, x)(y = ((win_info->generic.handle) ? (win_info->generic.handle )->_cury : (-1)), x = ((win_info->generic.handle) ? (win_info ->generic.handle)->_curx : (-1))); | |||
275 | while (x + 1 < win_info->generic.width) | |||
276 | { | |||
277 | waddch (win_info->generic.handle, ' '); | |||
278 | getyx (win_info->generic.handle, y, x)(y = ((win_info->generic.handle) ? (win_info->generic.handle )->_cury : (-1)), x = ((win_info->generic.handle) ? (win_info ->generic.handle)->_curx : (-1))); | |||
279 | } | |||
280 | } | |||
281 | ||||
282 | void | |||
283 | tui_show_source_content (struct tui_win_info * win_info) | |||
284 | { | |||
285 | if (win_info->generic.content_size > 0) | |||
286 | { | |||
287 | int lineno; | |||
288 | ||||
289 | for (lineno = 1; lineno <= win_info->generic.content_size; lineno++) | |||
290 | tui_show_source_line (win_info, lineno); | |||
291 | } | |||
292 | else | |||
293 | tui_erase_source_content (win_info, TRUE1); | |||
294 | ||||
295 | tui_check_and_display_highlight_if_needed (win_info); | |||
296 | tui_refresh_win (&win_info->generic); | |||
297 | win_info->generic.content_in_use = TRUE1; | |||
298 | } | |||
299 | ||||
300 | ||||
301 | /* Scroll the source forward or backward horizontally. */ | |||
302 | void | |||
303 | tui_horizontal_source_scroll (struct tui_win_info * win_info, | |||
304 | enum tui_scroll_direction direction, | |||
305 | int num_to_scroll) | |||
306 | { | |||
307 | if (win_info->generic.content != NULL((void*)0)) | |||
308 | { | |||
309 | int offset; | |||
310 | struct symtab *s; | |||
311 | struct symtab_and_line cursal = get_current_source_symtab_and_line (); | |||
312 | ||||
313 | if (cursal.symtab == (struct symtab *) NULL((void*)0)) | |||
314 | s = find_pc_symtab (get_frame_pc (deprecated_selected_frame)); | |||
315 | else | |||
316 | s = cursal.symtab; | |||
317 | ||||
318 | if (direction == LEFT_SCROLL) | |||
319 | offset = win_info->detail.source_info.horizontal_offset + num_to_scroll; | |||
320 | else | |||
321 | { | |||
322 | if ((offset = | |||
323 | win_info->detail.source_info.horizontal_offset - num_to_scroll) < 0) | |||
324 | offset = 0; | |||
325 | } | |||
326 | win_info->detail.source_info.horizontal_offset = offset; | |||
327 | tui_update_source_window_as_is (win_info, s, | |||
328 | ((struct tui_win_element *) | |||
329 | win_info->generic.content[0])->which_element.source.line_or_addr, | |||
330 | FALSE0); | |||
331 | } | |||
332 | ||||
333 | return; | |||
334 | } | |||
335 | ||||
336 | ||||
337 | /* Set or clear the has_break flag in the line whose line is line_no. */ | |||
338 | void | |||
339 | tui_set_is_exec_point_at (union tui_line_or_address l, struct tui_win_info * win_info) | |||
340 | { | |||
341 | int changed = 0; | |||
342 | int i; | |||
343 | tui_win_content content = (tui_win_content) win_info->generic.content; | |||
344 | ||||
345 | i = 0; | |||
346 | while (i < win_info->generic.content_size) | |||
347 | { | |||
348 | int new_state; | |||
349 | ||||
350 | if (content[i]->which_element.source.line_or_addr.addr == l.addr) | |||
351 | new_state = TRUE1; | |||
352 | else | |||
353 | new_state = FALSE0; | |||
354 | if (new_state != content[i]->which_element.source.is_exec_point) | |||
355 | { | |||
356 | changed++; | |||
357 | content[i]->which_element.source.is_exec_point = new_state; | |||
358 | tui_show_source_line (win_info, i + 1); | |||
359 | } | |||
360 | i++; | |||
361 | } | |||
362 | if (changed) | |||
363 | tui_refresh_win (&win_info->generic); | |||
364 | } | |||
365 | ||||
366 | /* Update the execution windows to show the active breakpoints. | |||
367 | This is called whenever a breakpoint is inserted, removed or | |||
368 | has its state changed. */ | |||
369 | void | |||
370 | tui_update_all_breakpoint_info (void) | |||
371 | { | |||
372 | struct tui_list *list = tui_source_windows (); | |||
373 | int i; | |||
374 | ||||
375 | for (i = 0; i < list->count; i++) | |||
376 | { | |||
377 | struct tui_win_info * win = (struct tui_win_info *) list->list[i]; | |||
378 | ||||
379 | if (tui_update_breakpoint_info (win, FALSE0)) | |||
380 | { | |||
381 | tui_update_exec_info (win); | |||
382 | } | |||
383 | } | |||
384 | } | |||
385 | ||||
386 | ||||
387 | /* Scan the source window and the breakpoints to update the | |||
388 | has_break information for each line. | |||
389 | Returns 1 if something changed and the execution window | |||
390 | must be refreshed. */ | |||
391 | int | |||
392 | tui_update_breakpoint_info (struct tui_win_info * win, int current_only) | |||
393 | { | |||
394 | int i; | |||
395 | int need_refresh = 0; | |||
396 | struct tui_source_info * src = &win->detail.source_info; | |||
397 | ||||
398 | for (i = 0; i < win->generic.content_size; i++) | |||
399 | { | |||
400 | struct breakpoint *bp; | |||
401 | extern struct breakpoint *breakpoint_chain; | |||
402 | int mode; | |||
403 | struct tui_source_element* line; | |||
404 | ||||
405 | line = &((struct tui_win_element *) win->generic.content[i])->which_element.source; | |||
406 | if (current_only && !line->is_exec_point) | |||
407 | continue; | |||
408 | ||||
409 | /* Scan each breakpoint to see if the current line has something to | |||
410 | do with it. Identify enable/disabled breakpoints as well as | |||
411 | those that we already hit. */ | |||
412 | mode = 0; | |||
413 | for (bp = breakpoint_chain; | |||
414 | bp != (struct breakpoint *) NULL((void*)0); | |||
415 | bp = bp->next) | |||
416 | { | |||
417 | if ((win == TUI_SRC_WINtui_win_list[SRC_WIN] | |||
418 | && bp->source_file | |||
419 | && (strcmp (src->filename, bp->source_file) == 0) | |||
420 | && bp->line_number == line->line_or_addr.line_no) | |||
421 | || (win == TUI_DISASM_WINtui_win_list[DISASSEM_WIN] | |||
422 | && bp->loc->address == line->line_or_addr.addr)) | |||
423 | { | |||
424 | if (bp->enable_state == bp_disabled) | |||
425 | mode |= TUI_BP_DISABLED0x02; | |||
426 | else | |||
427 | mode |= TUI_BP_ENABLED0x01; | |||
428 | if (bp->hit_count) | |||
429 | mode |= TUI_BP_HIT0x04; | |||
430 | if (bp->cond) | |||
431 | mode |= TUI_BP_CONDITIONAL0x08; | |||
432 | if (bp->type == bp_hardware_breakpoint) | |||
433 | mode |= TUI_BP_HARDWARE0x10; | |||
434 | } | |||
435 | } | |||
436 | if (line->has_break != mode) | |||
437 | { | |||
438 | line->has_break = mode; | |||
439 | need_refresh = 1; | |||
440 | } | |||
441 | } | |||
442 | return need_refresh; | |||
443 | } | |||
444 | ||||
445 | ||||
446 | /* Function to initialize the content of the execution info window, | |||
447 | based upon the input window which is either the source or | |||
448 | disassembly window. */ | |||
449 | enum tui_status | |||
450 | tui_set_exec_info_content (struct tui_win_info * win_info) | |||
451 | { | |||
452 | enum tui_status ret = TUI_SUCCESS; | |||
453 | ||||
454 | if (win_info->detail.source_info.execution_info != (struct tui_gen_win_info *) NULL((void*)0)) | |||
455 | { | |||
456 | struct tui_gen_win_info * exec_info_ptr = win_info->detail.source_info.execution_info; | |||
457 | ||||
458 | if (exec_info_ptr->content == NULL((void*)0)) | |||
459 | exec_info_ptr->content = | |||
460 | (void **) tui_alloc_content (win_info->generic.height, | |||
461 | exec_info_ptr->type); | |||
462 | if (exec_info_ptr->content != NULL((void*)0)) | |||
463 | { | |||
464 | int i; | |||
465 | ||||
466 | tui_update_breakpoint_info (win_info, 1); | |||
467 | for (i = 0; i < win_info->generic.content_size; i++) | |||
468 | { | |||
469 | struct tui_win_element * element; | |||
470 | struct tui_win_element * src_element; | |||
471 | int mode; | |||
472 | ||||
473 | element = (struct tui_win_element *) exec_info_ptr->content[i]; | |||
474 | src_element = (struct tui_win_element *) win_info->generic.content[i]; | |||
475 | ||||
476 | memset(element->which_element.simple_string, ' ', | |||
477 | sizeof(element->which_element.simple_string)); | |||
478 | element->which_element.simple_string[TUI_EXECINFO_SIZE4 - 1] = 0; | |||
479 | ||||
480 | /* Now update the exec info content based upon the state | |||
481 | of each line as indicated by the source content. */ | |||
482 | mode = src_element->which_element.source.has_break; | |||
483 | if (mode & TUI_BP_HIT0x04) | |||
484 | element->which_element.simple_string[TUI_BP_HIT_POS0] = | |||
485 | (mode & TUI_BP_HARDWARE0x10) ? 'H' : 'B'; | |||
486 | else if (mode & (TUI_BP_ENABLED0x01 | TUI_BP_DISABLED0x02)) | |||
487 | element->which_element.simple_string[TUI_BP_HIT_POS0] = | |||
488 | (mode & TUI_BP_HARDWARE0x10) ? 'h' : 'b'; | |||
489 | ||||
490 | if (mode & TUI_BP_ENABLED0x01) | |||
491 | element->which_element.simple_string[TUI_BP_BREAK_POS1] = '+'; | |||
492 | else if (mode & TUI_BP_DISABLED0x02) | |||
493 | element->which_element.simple_string[TUI_BP_BREAK_POS1] = '-'; | |||
494 | ||||
495 | if (src_element->which_element.source.is_exec_point) | |||
496 | element->which_element.simple_string[TUI_EXEC_POS2] = '>'; | |||
497 | } | |||
498 | exec_info_ptr->content_size = win_info->generic.content_size; | |||
499 | } | |||
500 | else | |||
501 | ret = TUI_FAILURE; | |||
502 | } | |||
503 | ||||
504 | return ret; | |||
505 | } | |||
506 | ||||
507 | ||||
508 | void | |||
509 | tui_show_exec_info_content (struct tui_win_info * win_info) | |||
510 | { | |||
511 | struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info; | |||
512 | int cur_line; | |||
513 | ||||
514 | werase (exec_info->handle); | |||
515 | tui_refresh_win (exec_info); | |||
516 | for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++) | |||
517 | mvwaddstr (exec_info->handle,(wmove(exec_info->handle,cur_line,0) == (-1) ? (-1) : waddnstr (exec_info->handle,((struct tui_win_element *) exec_info-> content[cur_line - 1])->which_element.simple_string,-1)) | |||
518 | cur_line,(wmove(exec_info->handle,cur_line,0) == (-1) ? (-1) : waddnstr (exec_info->handle,((struct tui_win_element *) exec_info-> content[cur_line - 1])->which_element.simple_string,-1)) | |||
519 | 0,(wmove(exec_info->handle,cur_line,0) == (-1) ? (-1) : waddnstr (exec_info->handle,((struct tui_win_element *) exec_info-> content[cur_line - 1])->which_element.simple_string,-1)) | |||
520 | ((struct tui_win_element *)(wmove(exec_info->handle,cur_line,0) == (-1) ? (-1) : waddnstr (exec_info->handle,((struct tui_win_element *) exec_info-> content[cur_line - 1])->which_element.simple_string,-1)) | |||
521 | exec_info->content[cur_line - 1])->which_element.simple_string)(wmove(exec_info->handle,cur_line,0) == (-1) ? (-1) : waddnstr (exec_info->handle,((struct tui_win_element *) exec_info-> content[cur_line - 1])->which_element.simple_string,-1)); | |||
522 | tui_refresh_win (exec_info); | |||
523 | exec_info->content_in_use = TRUE1; | |||
524 | } | |||
525 | ||||
526 | ||||
527 | void | |||
528 | tui_erase_exec_info_content (struct tui_win_info * win_info) | |||
529 | { | |||
530 | struct tui_gen_win_info * exec_info = win_info->detail.source_info.execution_info; | |||
531 | ||||
532 | werase (exec_info->handle); | |||
533 | tui_refresh_win (exec_info); | |||
534 | } | |||
535 | ||||
536 | void | |||
537 | tui_clear_exec_info_content (struct tui_win_info * win_info) | |||
538 | { | |||
539 | win_info->detail.source_info.execution_info->content_in_use = FALSE0; | |||
540 | tui_erase_exec_info_content (win_info); | |||
541 | ||||
542 | return; | |||
543 | } | |||
544 | ||||
545 | /* Function to update the execution info window. */ | |||
546 | void | |||
547 | tui_update_exec_info (struct tui_win_info * win_info) | |||
548 | { | |||
549 | tui_set_exec_info_content (win_info); | |||
550 | tui_show_exec_info_content (win_info); | |||
551 | } | |||
552 | ||||
553 | enum tui_status | |||
554 | tui_alloc_source_buffer (struct tui_win_info *win_info) | |||
555 | { | |||
556 | char *src_line_buf; | |||
557 | int i, line_width, max_lines; | |||
558 | enum tui_status ret = TUI_FAILURE; | |||
559 | ||||
560 | max_lines = win_info->generic.height; /* less the highlight box */ | |||
561 | line_width = win_info->generic.width - 1; | |||
562 | /* | |||
563 | ** Allocate the buffer for the source lines. Do this only once since they | |||
564 | ** will be re-used for all source displays. The only other time this will | |||
565 | ** be done is when a window's size changes. | |||
566 | */ | |||
567 | if (win_info->generic.content == NULL((void*)0)) | |||
| ||||
568 | { | |||
569 | src_line_buf = (char *) xmalloc ((max_lines * line_width) * sizeof (char)); | |||
570 | if (src_line_buf == (char *) NULL((void*)0)) | |||
571 | fputs_unfiltered ( | |||
572 | "Unable to Allocate Memory for Source or Disassembly Display.\n", | |||
573 | gdb_stderr); | |||
574 | else | |||
575 | { | |||
576 | /* allocate the content list */ | |||
577 | if ((win_info->generic.content = | |||
578 | (void **) tui_alloc_content (max_lines, SRC_WIN)) == NULL((void*)0)) | |||
579 | { | |||
580 | xfree (src_line_buf); | |||
581 | src_line_buf = (char *) NULL((void*)0); | |||
582 | fputs_unfiltered ( | |||
583 | "Unable to Allocate Memory for Source or Disassembly Display.\n", | |||
584 | gdb_stderr); | |||
585 | } | |||
586 | } | |||
587 | for (i = 0; i < max_lines; i++) | |||
588 | ((struct tui_win_element *) | |||
589 | win_info->generic.content[i])->which_element.source.line = | |||
| ||||
590 | src_line_buf + (line_width * i); | |||
591 | ret = TUI_SUCCESS; | |||
592 | } | |||
593 | else | |||
594 | ret = TUI_SUCCESS; | |||
595 | ||||
596 | return ret; | |||
597 | } | |||
598 | ||||
599 | ||||
600 | /* Answer whether the a particular line number or address is displayed | |||
601 | in the current source window. */ | |||
602 | int | |||
603 | tui_line_is_displayed (int line, struct tui_win_info * win_info, | |||
604 | int check_threshold) | |||
605 | { | |||
606 | int is_displayed = FALSE0; | |||
607 | int i, threshold; | |||
608 | ||||
609 | if (check_threshold) | |||
610 | threshold = SCROLL_THRESHOLD2; | |||
611 | else | |||
612 | threshold = 0; | |||
613 | i = 0; | |||
614 | while (i < win_info->generic.content_size - threshold && !is_displayed) | |||
615 | { | |||
616 | is_displayed = (((struct tui_win_element *) | |||
617 | win_info->generic.content[i])->which_element.source.line_or_addr.line_no | |||
618 | == (int) line); | |||
619 | i++; | |||
620 | } | |||
621 | ||||
622 | return is_displayed; | |||
623 | } | |||
624 | ||||
625 | ||||
626 | /* Answer whether the a particular line number or address is displayed | |||
627 | in the current source window. */ | |||
628 | int | |||
629 | tui_addr_is_displayed (CORE_ADDR addr, struct tui_win_info * win_info, | |||
630 | int check_threshold) | |||
631 | { | |||
632 | int is_displayed = FALSE0; | |||
633 | int i, threshold; | |||
634 | ||||
635 | if (check_threshold) | |||
636 | threshold = SCROLL_THRESHOLD2; | |||
637 | else | |||
638 | threshold = 0; | |||
639 | i = 0; | |||
640 | while (i < win_info->generic.content_size - threshold && !is_displayed) | |||
641 | { | |||
642 | is_displayed = (((struct tui_win_element *) | |||
643 | win_info->generic.content[i])->which_element.source.line_or_addr.addr | |||
644 | == addr); | |||
645 | i++; | |||
646 | } | |||
647 | ||||
648 | return is_displayed; | |||
649 | } | |||
650 | ||||
651 | ||||
652 | /***************************************** | |||
653 | ** STATIC LOCAL FUNCTIONS ** | |||
654 | ******************************************/ |