Bug Summary

File:src/gnu/usr.bin/texinfo/info/display.c
Warning:line 275, column 42
Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name display.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/texinfo/obj/info -resource-dir /usr/local/lib/clang/13.0.0 -D HAVE_CONFIG_H -D LOCALEDIR="/usr/share/locale" -D INFODIR="/usr/share/info" -D INFODIR2="/usr/share/info" -I . -I /usr/src/gnu/usr.bin/texinfo/info -I .. -I . -I /usr/src/gnu/usr.bin/texinfo/lib -I ../intl -I .. -I /usr/src/gnu/usr.bin/texinfo/info -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/texinfo/obj/info -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/texinfo/info/display.c
1/* display.c -- How to display Info windows.
2 $Id: display.c,v 1.4 2006/07/17 16:12:36 espie Exp $
3
4 Copyright (C) 1993, 1997, 2003, 2004 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 Originally written by Brian Fox (bfox@ai.mit.edu). */
21
22#include "info.h"
23#include "display.h"
24
25extern int info_any_buffered_input_p (void); /* Found in session.c. */
26
27static void free_display (DISPLAY_LINE **display);
28static DISPLAY_LINE **make_display (int width, int height);
29
30void handle_tag (char *tag);
31void handle_tag_start (char *tag);
32void handle_tag_end (char *tag);
33
34/* An array of display lines which tell us what is currently visible on
35 the display. */
36DISPLAY_LINE **the_display = (DISPLAY_LINE **)NULL((void *)0);
37
38/* Non-zero means do no output. */
39int display_inhibited = 0;
40
41/* Initialize THE_DISPLAY to WIDTH and HEIGHT, with nothing in it. */
42void
43display_initialize_display (int width, int height)
44{
45 free_display (the_display);
46 the_display = make_display (width, height);
47 display_clear_display (the_display);
48}
49
50/* Clear all of the lines in DISPLAY making the screen blank. */
51void
52display_clear_display (DISPLAY_LINE **display)
53{
54 register int i;
55
56 for (i = 0; display[i]; i++)
57 {
58 display[i]->text[0] = '\0';
59 display[i]->textlen = 0;
60 display[i]->inverse = 0;
61 }
62}
63
64/* Non-zero if we didn't completely redisplay a window. */
65int display_was_interrupted_p = 0;
66
67/* Update the windows pointed to by WINDOW in the_display. This actually
68 writes the text on the screen. */
69void
70display_update_display (WINDOW *window)
71{
72 register WINDOW *win;
73
74 display_was_interrupted_p = 0;
75
76 /* For every window in the list, check contents against the display. */
77 for (win = window; win; win = win->next)
78 {
79 /* Only re-display visible windows which need updating. */
80 if (((win->flags & W_WindowVisible0x04) == 0) ||
81 ((win->flags & W_UpdateWindow0x01) == 0) ||
82 (win->height == 0))
83 continue;
84
85 display_update_one_window (win);
86 if (display_was_interrupted_p)
87 break;
88 }
89
90 /* Always update the echo area. */
91 display_update_one_window (the_echo_area);
92}
93
94void
95handle_tag_start (char *tag)
96{
97 /* TODO really handle this tag. */
98 return;
99}
100
101void
102handle_tag_end (char *tag)
103{
104 /* TODO really handle this tag. */
105 return;
106}
107
108void
109handle_tag (char *tag)
110{
111 if (tag[0] == '/')
112 {
113 tag++;
114 handle_tag_end (tag);
115 }
116 else
117 handle_tag_start (tag);
118}
119
120/* Display WIN on the_display. Unlike display_update_display (), this
121 function only does one window. */
122void
123display_update_one_window (WINDOW *win)
124{
125 register char *nodetext; /* Current character to display. */
126 register char *last_node_char; /* Position of the last character in node. */
127 register int i; /* General use index. */
128 char *printed_line; /* Buffer for a printed line. */
129 int pl_index = 0; /* Index into PRINTED_LINE. */
130 int line_index = 0; /* Number of lines done so far. */
131 int pl_ignore = 0; /* How many chars use zero width on screen. */
132 int allocated_win_width;
133 DISPLAY_LINE **display = the_display;
134
135 /* If display is inhibited, that counts as an interrupted display. */
136 if (display_inhibited)
1
Assuming 'display_inhibited' is 0
2
Taking false branch
137 display_was_interrupted_p = 1;
138
139 /* If the window has no height, or display is inhibited, quit now. */
140 if (!win->height || display_inhibited
3.1
'display_inhibited' is 0
)
3
Assuming field 'height' is not equal to 0
4
Taking false branch
141 return;
142
143 /* If the window's first row doesn't appear in the_screen, then it
144 cannot be displayed. This can happen when the_echo_area is the
145 window to be displayed, and the screen has shrunk to less than one
146 line. */
147 if ((win->first_row < 0) || (win->first_row > the_screen->height))
5
Assuming field 'first_row' is >= 0
6
Assuming field 'first_row' is <= field 'height'
7
Taking false branch
148 return;
149
150 /* Print each line in the window into our local buffer, and then
151 check the contents of that buffer against the display. If they
152 differ, update the display. */
153 allocated_win_width = win->width + 1;
154 printed_line = (char *)xmalloc (allocated_win_width);
155
156 if (!win->node || !win->line_starts)
8
Assuming field 'node' is non-null
9
Assuming field 'line_starts' is non-null
10
Taking false branch
157 goto done_with_node_display;
158
159 nodetext = win->line_starts[win->pagetop];
160 last_node_char = win->node->contents + win->node->nodelen;
161
162 for (; nodetext < last_node_char; nodetext++)
11
Loop condition is true. Entering loop body
163 {
164 char *rep = NULL((void *)0), *rep_carried_over, rep_temp[2];
165 int replen;
166
167 if (isprint (*nodetext))
12
Taking true branch
168 {
169 rep_temp[0] = *nodetext;
170 replen = 1;
171 rep_temp[1] = '\0';
172 rep = rep_temp;
173 }
174 else
175 {
176 if (*nodetext == '\r' || *nodetext == '\n')
177 {
178 replen = win->width - pl_index + pl_ignore;
179 }
180 else if (*nodetext == '\0'
181 && (nodetext + 2) < last_node_char
182 && *(nodetext + 1) == '\b'
183 && *(nodetext + 2) == '[')
184 {
185 /* Found new style tag/cookie \0\b[
186 Read until the closing tag \0\b] */
187 int element_len = 0;
188 char *element;
189
190 /* Skip the escapes. */
191 nodetext += 3;
192
193 while (!(*nodetext == '\0'
194 && *(nodetext + 1) == '\b'
195 && *(nodetext + 2) == ']'))
196 {
197 nodetext++;
198 element_len++;
199 }
200
201 element = (char *) malloc (element_len + 1);
202 strncpy (element, nodetext - element_len, element_len);
203
204 /* Skip the escapes. */
205 nodetext += 2;
206 pl_ignore += element_len + 5;
207 /* Append string terminator. */
208 element[element_len] = '\0';
209
210 handle_tag (element);
211
212 /* Over and out */
213 free (element);
214
215 continue;
216 }
217 else
218 {
219 rep = printed_representation (*nodetext, pl_index);
220 replen = strlen (rep);
221 }
222 }
223
224 /* Support ANSI escape sequences under -R. */
225 if (raw_escapes_p
13
Assuming 'raw_escapes_p' is 0
226 && *nodetext == '\033'
227 && nodetext[1] == '['
228 && isdigit (nodetext[2]))
229 {
230 if (nodetext[3] == 'm')
231 pl_ignore += 4;
232 else if (isdigit (nodetext[3]) && nodetext[4] == 'm')
233 pl_ignore += 5;
234 }
235 while (pl_index + 2 >= allocated_win_width - 1)
14
Assuming the condition is true
15
Loop condition is true. Entering loop body
16
Assuming the condition is false
17
Loop condition is false. Execution continues on line 243
236 {
237 allocated_win_width *= 2;
238 printed_line = (char *)xrealloc (printed_line, allocated_win_width);
239 }
240
241 /* If this character can be printed without passing the width of
242 the line, then stuff it into the line. */
243 if (replen + pl_index < win->width + pl_ignore)
18
Assuming the condition is false
19
Taking false branch
244 {
245 /* Optimize if possible. */
246 if (replen == 1)
247 {
248 printed_line[pl_index++] = *rep;
249 }
250 else
251 {
252 for (i = 0; i < replen; i++)
253 printed_line[pl_index++] = rep[i];
254 }
255 }
256 else
257 {
258 DISPLAY_LINE *entry;
259
260 /* If this character cannot be printed in this line, we have
261 found the end of this line as it would appear on the screen.
262 Carefully print the end of the line, and then compare. */
263 if (*nodetext == '\n' || *nodetext == '\r' || *nodetext == '\t')
20
Taking false branch
264 {
265 printed_line[pl_index] = '\0';
266 rep_carried_over = (char *)NULL((void *)0);
267 }
268 else
269 {
270 /* The printed representation of this character extends into
271 the next line. Remember the offset of the last character
272 printed out of REP so that we can carry the character over
273 to the next line. */
274 for (i = 0; pl_index < (win->width + pl_ignore - 1);)
21
Assuming the condition is true
22
Loop condition is true. Entering loop body
23
Loop condition is true. Entering loop body
24
Loop condition is true. Entering loop body
275 printed_line[pl_index++] = rep[i++];
25
Assigned value is garbage or undefined
276
277 rep_carried_over = rep + i;
278
279 /* If printing the last character in this window couldn't
280 possibly cause the screen to scroll, place a backslash
281 in the rightmost column. */
282 if (1 + line_index + win->first_row < the_screen->height)
283 {
284 if (win->flags & W_NoWrap0x10)
285 printed_line[pl_index++] = '$';
286 else
287 printed_line[pl_index++] = '\\';
288 }
289 printed_line[pl_index] = '\0';
290 }
291
292 /* We have the exact line as it should appear on the screen.
293 Check to see if this line matches the one already appearing
294 on the screen. */
295 entry = display[line_index + win->first_row];
296
297 /* If the screen line is inversed, then we have to clear
298 the line from the screen first. Why, I don't know.
299 (But don't do this if we have no visible entries, as can
300 happen if the window is shrunk very small.) */
301 if ((entry && entry->inverse)
302 /* Need to erase the line if it has escape sequences. */
303 || (raw_escapes_p && strchr (entry->text, '\033') != 0))
304 {
305 terminal_goto_xy (0, line_index + win->first_row);
306 terminal_clear_to_eol ();
307 entry->inverse = 0;
308 entry->text[0] = '\0';
309 entry->textlen = 0;
310 }
311
312 /* Find the offset where these lines differ. */
313 for (i = 0; i < pl_index; i++)
314 if (printed_line[i] != entry->text[i])
315 break;
316
317 /* If the lines are not the same length, or if they differed
318 at all, we must do some redrawing. */
319 if ((i != pl_index) || (pl_index != entry->textlen))
320 {
321 /* Move to the proper point on the terminal. */
322 terminal_goto_xy (i, line_index + win->first_row);
323
324 /* If there is any text to print, print it. */
325 if (i != pl_index)
326 terminal_put_text (printed_line + i);
327
328 /* If the printed text didn't extend all the way to the edge
329 of the window, and text was appearing between here and the
330 edge of the window, clear from here to the end of the line. */
331 if ((pl_index < win->width + pl_ignore
332 && pl_index < entry->textlen)
333 || (entry->inverse))
334 terminal_clear_to_eol ();
335
336 fflush (stdout(&__sF[1]));
337
338 /* Update the display text buffer. */
339 if (strlen (printed_line) > (unsigned int) screenwidth)
340 /* printed_line[] can include more than screenwidth
341 characters if we are under -R and there are escape
342 sequences in it. However, entry->text was
343 allocated (in display_initialize_display) for
344 screenwidth characters only. */
345 entry->text = xrealloc (entry->text, strlen (printed_line)+1);
346 strcpy (entry->text + i, printed_line + i);
347 entry->textlen = pl_index;
348
349 /* Lines showing node text are not in inverse. Only modelines
350 have that distinction. */
351 entry->inverse = 0;
352 }
353
354 /* We have done at least one line. Increment our screen line
355 index, and check against the bottom of the window. */
356 if (++line_index == win->height)
357 break;
358
359 /* A line has been displayed, and the screen reflects that state.
360 If there is typeahead pending, then let that typeahead be read
361 now, instead of continuing with the display. */
362 if (info_any_buffered_input_p ())
363 {
364 free (printed_line);
365 display_was_interrupted_p = 1;
366 return;
367 }
368
369 /* Reset PL_INDEX to the start of the line. */
370 pl_index = 0;
371 pl_ignore = 0; /* this is computed per line */
372
373 /* If there are characters from REP left to print, stuff them
374 into the buffer now. */
375 if (rep_carried_over)
376 for (; rep[pl_index]; pl_index++)
377 printed_line[pl_index] = rep[pl_index];
378
379 /* If this window has chosen not to wrap lines, skip to the end
380 of the physical line in the buffer, and start a new line here. */
381 if (pl_index && (win->flags & W_NoWrap0x10))
382 {
383 char *begin;
384
385 pl_index = 0;
386 printed_line[0] = '\0';
387
388 begin = nodetext;
389
390 while ((nodetext < last_node_char) && (*nodetext != '\n'))
391 nodetext++;
392 }
393 }
394 }
395
396 done_with_node_display:
397 /* We have reached the end of the node or the end of the window. If it
398 is the end of the node, then clear the lines of the window from here
399 to the end of the window. */
400 for (; line_index < win->height; line_index++)
401 {
402 DISPLAY_LINE *entry = display[line_index + win->first_row];
403
404 /* If this line has text on it then make it go away. */
405 if (entry && entry->textlen)
406 {
407 entry->textlen = 0;
408 entry->text[0] = '\0';
409
410 terminal_goto_xy (0, line_index + win->first_row);
411 terminal_clear_to_eol ();
412 }
413 }
414
415 /* Finally, if this window has a modeline it might need to be redisplayed.
416 Check the window's modeline against the one in the display, and update
417 if necessary. */
418 if ((win->flags & W_InhibitMode0x08) == 0)
419 {
420 window_make_modeline (win);
421 line_index = win->first_row + win->height;
422
423 /* This display line must both be in inverse, and have the same
424 contents. */
425 if ((!display[line_index]->inverse) ||
426 (strcmp (display[line_index]->text, win->modeline) != 0))
427 {
428 terminal_goto_xy (0, line_index);
429 terminal_begin_inverse ();
430 terminal_put_text (win->modeline);
431 terminal_end_inverse ();
432 strcpy (display[line_index]->text, win->modeline);
433 display[line_index]->inverse = 1;
434 display[line_index]->textlen = strlen (win->modeline);
435 fflush (stdout(&__sF[1]));
436 }
437 }
438
439 /* Okay, this window doesn't need updating anymore. */
440 win->flags &= ~W_UpdateWindow0x01;
441 free (printed_line);
442 fflush (stdout(&__sF[1]));
443}
444
445/* Scroll the region of the_display starting at START, ending at END, and
446 moving the lines AMOUNT lines. If AMOUNT is less than zero, the lines
447 are moved up in the screen, otherwise down. Actually, it is possible
448 for no scrolling to take place in the case that the terminal doesn't
449 support it. This doesn't matter to us. */
450void
451display_scroll_display (int start, int end, int amount)
452{
453 register int i, last;
454 DISPLAY_LINE *temp;
455
456 /* If this terminal cannot do scrolling, give up now. */
457 if (!terminal_can_scroll)
458 return;
459
460 /* If there isn't anything displayed on the screen because it is too
461 small, quit now. */
462 if (!the_display[0])
463 return;
464
465 /* If there is typeahead pending, then don't actually do any scrolling. */
466 if (info_any_buffered_input_p ())
467 return;
468
469 /* Do it on the screen. */
470 terminal_scroll_terminal (start, end, amount);
471
472 /* Now do it in the display buffer so our contents match the screen. */
473 if (amount > 0)
474 {
475 last = end + amount;
476
477 /* Shift the lines to scroll right into place. */
478 for (i = 0; i < (end - start); i++)
479 {
480 temp = the_display[last - i];
481 the_display[last - i] = the_display[end - i];
482 the_display[end - i] = temp;
483 }
484
485 /* The lines have been shifted down in the buffer. Clear all of the
486 lines that were vacated. */
487 for (i = start; i != (start + amount); i++)
488 {
489 the_display[i]->text[0] = '\0';
490 the_display[i]->textlen = 0;
491 the_display[i]->inverse = 0;
492 }
493 }
494
495 if (amount < 0)
496 {
497 last = start + amount;
498 for (i = 0; i < (end - start); i++)
499 {
500 temp = the_display[last + i];
501 the_display[last + i] = the_display[start + i];
502 the_display[start + i] = temp;
503 }
504
505 /* The lines have been shifted up in the buffer. Clear all of the
506 lines that are left over. */
507 for (i = end + amount; i != end; i++)
508 {
509 the_display[i]->text[0] = '\0';
510 the_display[i]->textlen = 0;
511 the_display[i]->inverse = 0;
512 }
513 }
514}
515
516/* Try to scroll lines in WINDOW. OLD_PAGETOP is the pagetop of WINDOW before
517 having had its line starts recalculated. OLD_STARTS is the list of line
518 starts that used to appear in this window. OLD_COUNT is the number of lines
519 that appear in the OLD_STARTS array. */
520void
521display_scroll_line_starts (WINDOW *window, int old_pagetop,
522 char **old_starts, int old_count)
523{
524 register int i, old, new; /* Indices into the line starts arrays. */
525 int last_new, last_old; /* Index of the last visible line. */
526 int old_first, new_first; /* Index of the first changed line. */
527 int unchanged_at_top = 0;
528 int already_scrolled = 0;
529
530 /* Locate the first line which was displayed on the old window. */
531 old_first = old_pagetop;
532 new_first = window->pagetop;
533
534 /* Find the last line currently visible in this window. */
535 last_new = window->pagetop + (window->height - 1);
536 if (last_new > window->line_count)
537 last_new = window->line_count - 1;
538
539 /* Find the last line which used to be currently visible in this window. */
540 last_old = old_pagetop + (window->height - 1);
541 if (last_old > old_count)
542 last_old = old_count - 1;
543
544 for (old = old_first, new = new_first;
545 old < last_old && new < last_new;
546 old++, new++)
547 if (old_starts[old] != window->line_starts[new])
548 break;
549 else
550 unchanged_at_top++;
551
552 /* Loop through the old lines looking for a match in the new lines. */
553 for (old = old_first + unchanged_at_top; old < last_old; old++)
554 {
555 for (new = new_first; new < last_new; new++)
556 if (old_starts[old] == window->line_starts[new])
557 {
558 /* Find the extent of the matching lines. */
559 for (i = 0; (old + i) < last_old; i++)
560 if (old_starts[old + i] != window->line_starts[new + i])
561 break;
562
563 /* Scroll these lines if there are enough of them. */
564 {
565 int start, end, amount;
566
567 start = (window->first_row
568 + ((old + already_scrolled) - old_pagetop));
569 amount = new - (old + already_scrolled);
570 end = window->first_row + window->height;
571
572 /* If we are shifting the block of lines down, then the last
573 AMOUNT lines will become invisible. Thus, don't bother
574 scrolling them. */
575 if (amount > 0)
576 end -= amount;
577
578 if ((end - start) > 0)
579 {
580 display_scroll_display (start, end, amount);
581
582 /* Some lines have been scrolled. Simulate the scrolling
583 by offsetting the value of the old index. */
584 old += i;
585 already_scrolled += amount;
586 }
587 }
588 }
589 }
590}
591
592/* Move the screen cursor to directly over the current character in WINDOW. */
593void
594display_cursor_at_point (WINDOW *window)
595{
596 int vpos, hpos;
597
598 vpos = window_line_of_point (window) - window->pagetop + window->first_row;
599 hpos = window_get_cursor_column (window);
600 terminal_goto_xy (hpos, vpos);
601 fflush (stdout(&__sF[1]));
602}
603
604/* **************************************************************** */
605/* */
606/* Functions Static to this File */
607/* */
608/* **************************************************************** */
609
610/* Make a DISPLAY_LINE ** with width and height. */
611static DISPLAY_LINE **
612make_display (int width, int height)
613{
614 register int i;
615 DISPLAY_LINE **display;
616
617 display = (DISPLAY_LINE **)xmalloc ((1 + height) * sizeof (DISPLAY_LINE *));
618
619 for (i = 0; i < height; i++)
620 {
621 display[i] = (DISPLAY_LINE *)xmalloc (sizeof (DISPLAY_LINE));
622 display[i]->text = (char *)xmalloc (1 + width);
623 display[i]->textlen = 0;
624 display[i]->inverse = 0;
625 }
626 display[i] = (DISPLAY_LINE *)NULL((void *)0);
627 return (display);
628}
629
630/* Free the storage allocated to DISPLAY. */
631static void
632free_display (DISPLAY_LINE **display)
633{
634 register int i;
635 register DISPLAY_LINE *display_line;
636
637 if (!display)
638 return;
639
640 for (i = 0; (display_line = display[i]); i++)
641 {
642 free (display_line->text);
643 free (display_line);
644 }
645 free (display);
646}