1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3
4 This file is part of GDB.
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 of the License, or
9 (at your option) 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 #include "defs.h"
21 #if !defined(__GO32__)
22 #include <sys/ioctl.h>
23 #include <sys/param.h>
24 #include <pwd.h>
25 #endif
26 #include <varargs.h>
27 #include <ctype.h>
28 #include <string.h>
29
30 #include "signals.h"
31 #include "gdbcmd.h"
32 #include "terminal.h"
33 #include "bfd.h"
34 #include "target.h"
35 #include "demangle.h"
36
37 /* Prototypes for local functions */
38
39 #if !defined (NO_MALLOC_CHECK)
40
41 static void
42 malloc_botch PARAMS ((void));
43
44 #endif /* NO_MALLOC_CHECK */
45
46 static void
47 fatal_dump_core (); /* Can't prototype with <varargs.h> usage... */
48
49 static void
50 prompt_for_continue PARAMS ((void));
51
52 static void
53 set_width_command PARAMS ((char *, int, struct cmd_list_element *));
54
55 /* If this definition isn't overridden by the header files, assume
56 that isatty and fileno exist on this system. */
57 #ifndef ISATTY
58 #define ISATTY(FP) (isatty (fileno (FP)))
59 #endif
60
61 /* Chain of cleanup actions established with make_cleanup,
62 to be executed if an error happens. */
63
64 static struct cleanup *cleanup_chain;
65
66 /* Nonzero means a quit has been requested. */
67
68 int quit_flag;
69
70 /* Nonzero means quit immediately if Control-C is typed now,
71 rather than waiting until QUIT is executed. */
72
73 int immediate_quit;
74
75 /* Nonzero means that encoded C++ names should be printed out in their
76 C++ form rather than raw. */
77
78 int demangle = 1;
79
80 /* Nonzero means that encoded C++ names should be printed out in their
81 C++ form even in assembler language displays. If this is set, but
82 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
83
84 int asm_demangle = 0;
85
86 /* Nonzero means that strings with character values >0x7F should be printed
87 as octal escapes. Zero means just print the value (e.g. it's an
88 international character, and the terminal or window can cope.) */
89
90 int sevenbit_strings = 0;
91
92 /* String to be printed before error messages, if any. */
93
94 char *error_pre_print;
95 char *warning_pre_print = "\nwarning: ";
96
97 /* Add a new cleanup to the cleanup_chain,
98 and return the previous chain pointer
99 to be passed later to do_cleanups or discard_cleanups.
100 Args are FUNCTION to clean up with, and ARG to pass to it. */
101
102 struct cleanup *
103 make_cleanup (function, arg)
104 void (*function) PARAMS ((PTR));
105 PTR arg;
106 {
107 register struct cleanup *new
108 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
109 register struct cleanup *old_chain = cleanup_chain;
110
111 new->next = cleanup_chain;
112 new->function = function;
113 new->arg = arg;
114 cleanup_chain = new;
115
116 return old_chain;
117 }
118
119 /* Discard cleanups and do the actions they describe
120 until we get back to the point OLD_CHAIN in the cleanup_chain. */
121
122 void
do_cleanups(old_chain)123 do_cleanups (old_chain)
124 register struct cleanup *old_chain;
125 {
126 register struct cleanup *ptr;
127 while ((ptr = cleanup_chain) != old_chain)
128 {
129 cleanup_chain = ptr->next; /* Do this first incase recursion */
130 (*ptr->function) (ptr->arg);
131 free (ptr);
132 }
133 }
134
135 /* Discard cleanups, not doing the actions they describe,
136 until we get back to the point OLD_CHAIN in the cleanup_chain. */
137
138 void
discard_cleanups(old_chain)139 discard_cleanups (old_chain)
140 register struct cleanup *old_chain;
141 {
142 register struct cleanup *ptr;
143 while ((ptr = cleanup_chain) != old_chain)
144 {
145 cleanup_chain = ptr->next;
146 free ((PTR)ptr);
147 }
148 }
149
150 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
151 struct cleanup *
save_cleanups()152 save_cleanups ()
153 {
154 struct cleanup *old_chain = cleanup_chain;
155
156 cleanup_chain = 0;
157 return old_chain;
158 }
159
160 /* Restore the cleanup chain from a previously saved chain. */
161 void
restore_cleanups(chain)162 restore_cleanups (chain)
163 struct cleanup *chain;
164 {
165 cleanup_chain = chain;
166 }
167
168 /* This function is useful for cleanups.
169 Do
170
171 foo = xmalloc (...);
172 old_chain = make_cleanup (free_current_contents, &foo);
173
174 to arrange to free the object thus allocated. */
175
176 void
free_current_contents(location)177 free_current_contents (location)
178 char **location;
179 {
180 free (*location);
181 }
182
183 /* Provide a known function that does nothing, to use as a base for
184 for a possibly long chain of cleanups. This is useful where we
185 use the cleanup chain for handling normal cleanups as well as dealing
186 with cleanups that need to be done as a result of a call to error().
187 In such cases, we may not be certain where the first cleanup is, unless
188 we have a do-nothing one to always use as the base. */
189
190 /* ARGSUSED */
191 void
null_cleanup(arg)192 null_cleanup (arg)
193 char **arg;
194 {
195 }
196
197
198 /* Provide a hook for modules wishing to print their own warning messages
199 to set up the terminal state in a compatible way, without them having
200 to import all the target_<...> macros. */
201
202 void
warning_setup()203 warning_setup ()
204 {
205 target_terminal_ours ();
206 wrap_here(""); /* Force out any buffered output */
207 fflush (stdout);
208 }
209
210 /* Print a warning message.
211 The first argument STRING is the warning message, used as a fprintf string,
212 and the remaining args are passed as arguments to it.
213 The primary difference between warnings and errors is that a warning
214 does not force the return to command level. */
215
216 /* VARARGS */
217 void
warning(va_alist)218 warning (va_alist)
219 va_dcl
220 {
221 va_list args;
222 char *string;
223
224 va_start (args);
225 target_terminal_ours ();
226 wrap_here(""); /* Force out any buffered output */
227 fflush (stdout);
228 if (warning_pre_print)
229 fprintf (stderr, warning_pre_print);
230 string = va_arg (args, char *);
231 vfprintf (stderr, string, args);
232 fprintf (stderr, "\n");
233 va_end (args);
234 }
235
236 /* Print an error message and return to command level.
237 The first argument STRING is the error message, used as a fprintf string,
238 and the remaining args are passed as arguments to it. */
239
240 /* VARARGS */
241 NORETURN void
error(va_alist)242 error (va_alist)
243 va_dcl
244 {
245 va_list args;
246 char *string;
247
248 va_start (args);
249 target_terminal_ours ();
250 wrap_here(""); /* Force out any buffered output */
251 fflush (stdout);
252 if (error_pre_print)
253 fprintf_filtered (stderr, error_pre_print);
254 string = va_arg (args, char *);
255 vfprintf_filtered (stderr, string, args);
256 fprintf_filtered (stderr, "\n");
257 va_end (args);
258 return_to_top_level ();
259 }
260
261 /* Print an error message and exit reporting failure.
262 This is for a error that we cannot continue from.
263 The arguments are printed a la printf.
264
265 This function cannot be declared volatile (NORETURN) in an
266 ANSI environment because exit() is not declared volatile. */
267
268 /* VARARGS */
269 NORETURN void
fatal(va_alist)270 fatal (va_alist)
271 va_dcl
272 {
273 va_list args;
274 char *string;
275
276 va_start (args);
277 string = va_arg (args, char *);
278 fprintf (stderr, "\ngdb: ");
279 vfprintf (stderr, string, args);
280 fprintf (stderr, "\n");
281 va_end (args);
282 exit (1);
283 }
284
285 /* Print an error message and exit, dumping core.
286 The arguments are printed a la printf (). */
287
288 /* VARARGS */
289 static void
fatal_dump_core(va_alist)290 fatal_dump_core (va_alist)
291 va_dcl
292 {
293 va_list args;
294 char *string;
295
296 va_start (args);
297 string = va_arg (args, char *);
298 /* "internal error" is always correct, since GDB should never dump
299 core, no matter what the input. */
300 fprintf (stderr, "\ngdb internal error: ");
301 vfprintf (stderr, string, args);
302 fprintf (stderr, "\n");
303 va_end (args);
304
305 signal (SIGQUIT, SIG_DFL);
306 kill (getpid (), SIGQUIT);
307 /* We should never get here, but just in case... */
308 exit (1);
309 }
310
311 /* The strerror() function can return NULL for errno values that are
312 out of range. Provide a "safe" version that always returns a
313 printable string. */
314
315 char *
safe_strerror(errnum)316 safe_strerror (errnum)
317 int errnum;
318 {
319 char *msg;
320 static char buf[32];
321
322 if ((msg = strerror (errnum)) == NULL)
323 {
324 sprintf (buf, "(undocumented errno %d)", errnum);
325 msg = buf;
326 }
327 return (msg);
328 }
329
330 /* The strsignal() function can return NULL for signal values that are
331 out of range. Provide a "safe" version that always returns a
332 printable string. */
333
334 char *
safe_strsignal(signo)335 safe_strsignal (signo)
336 int signo;
337 {
338 char *msg;
339 static char buf[32];
340
341 if ((msg = strsignal (signo)) == NULL)
342 {
343 sprintf (buf, "(undocumented signal %d)", signo);
344 msg = buf;
345 }
346 return (msg);
347 }
348
349
350 /* Print the system error message for errno, and also mention STRING
351 as the file name for which the error was encountered.
352 Then return to command level. */
353
354 void
perror_with_name(string)355 perror_with_name (string)
356 char *string;
357 {
358 char *err;
359 char *combined;
360
361 err = safe_strerror (errno);
362 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
363 strcpy (combined, string);
364 strcat (combined, ": ");
365 strcat (combined, err);
366
367 /* I understand setting these is a matter of taste. Still, some people
368 may clear errno but not know about bfd_error. Doing this here is not
369 unreasonable. */
370 bfd_error = no_error;
371 errno = 0;
372
373 error ("%s.", combined);
374 }
375
376 /* Print the system error message for ERRCODE, and also mention STRING
377 as the file name for which the error was encountered. */
378
379 void
print_sys_errmsg(string,errcode)380 print_sys_errmsg (string, errcode)
381 char *string;
382 int errcode;
383 {
384 char *err;
385 char *combined;
386
387 err = safe_strerror (errcode);
388 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
389 strcpy (combined, string);
390 strcat (combined, ": ");
391 strcat (combined, err);
392
393 fprintf (stderr, "%s.\n", combined);
394 }
395
396 /* Control C eventually causes this to be called, at a convenient time. */
397
398 void
quit()399 quit ()
400 {
401 target_terminal_ours ();
402 wrap_here ((char *)0); /* Force out any pending output */
403 #if !defined(__GO32__)
404 #ifdef HAVE_TERMIO
405 ioctl (fileno (stdout), TCFLSH, 1);
406 #else /* not HAVE_TERMIO */
407 ioctl (fileno (stdout), TIOCFLUSH, 0);
408 #endif /* not HAVE_TERMIO */
409 #ifdef TIOCGPGRP
410 error ("Quit");
411 #else
412 error ("Quit (expect signal %d when inferior is resumed)", SIGINT);
413 #endif /* TIOCGPGRP */
414 #endif
415 }
416
417 /* Control C comes here */
418
419 void
request_quit(signo)420 request_quit (signo)
421 int signo;
422 {
423 quit_flag = 1;
424
425 #ifdef USG
426 /* Restore the signal handler. */
427 signal (signo, request_quit);
428 #endif
429
430 if (immediate_quit)
431 quit ();
432 }
433
434
435 /* Memory management stuff (malloc friends). */
436
437 #if defined (NO_MMALLOC)
438
439 PTR
mmalloc(md,size)440 mmalloc (md, size)
441 PTR md;
442 long size;
443 {
444 return (malloc (size));
445 }
446
447 PTR
mrealloc(md,ptr,size)448 mrealloc (md, ptr, size)
449 PTR md;
450 PTR ptr;
451 long size;
452 {
453 if (ptr == 0) /* Guard against old realloc's */
454 return malloc (size);
455 else
456 return realloc (ptr, size);
457 }
458
459 void
mfree(md,ptr)460 mfree (md, ptr)
461 PTR md;
462 PTR ptr;
463 {
464 free (ptr);
465 }
466
467 #endif /* NO_MMALLOC */
468
469 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
470
471 void
init_malloc(md)472 init_malloc (md)
473 PTR md;
474 {
475 }
476
477 #else /* have mmalloc and want corruption checking */
478
479 static void
malloc_botch()480 malloc_botch ()
481 {
482 fatal_dump_core ("Memory corruption");
483 }
484
485 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
486 by MD, to detect memory corruption. Note that MD may be NULL to specify
487 the default heap that grows via sbrk.
488
489 Note that for freshly created regions, we must call mmcheck prior to any
490 mallocs in the region. Otherwise, any region which was allocated prior to
491 installing the checking hooks, which is later reallocated or freed, will
492 fail the checks! The mmcheck function only allows initial hooks to be
493 installed before the first mmalloc. However, anytime after we have called
494 mmcheck the first time to install the checking hooks, we can call it again
495 to update the function pointer to the memory corruption handler.
496
497 Returns zero on failure, non-zero on success. */
498
499 void
init_malloc(md)500 init_malloc (md)
501 PTR md;
502 {
503 if (!mmcheck (md, malloc_botch))
504 {
505 warning ("internal error: failed to install memory consistency checks");
506 }
507
508 mmtrace ();
509 }
510
511 #endif /* Have mmalloc and want corruption checking */
512
513 /* Called when a memory allocation fails, with the number of bytes of
514 memory requested in SIZE. */
515
516 NORETURN void
nomem(size)517 nomem (size)
518 long size;
519 {
520 if (size > 0)
521 {
522 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size);
523 }
524 else
525 {
526 fatal ("virtual memory exhausted.");
527 }
528 }
529
530 /* Like mmalloc but get error if no storage available, and protect against
531 the caller wanting to allocate zero bytes. Whether to return NULL for
532 a zero byte request, or translate the request into a request for one
533 byte of zero'd storage, is a religious issue. */
534
535 PTR
xmmalloc(md,size)536 xmmalloc (md, size)
537 PTR md;
538 long size;
539 {
540 register PTR val;
541
542 if (size == 0)
543 {
544 val = NULL;
545 }
546 else if ((val = mmalloc (md, size)) == NULL)
547 {
548 nomem (size);
549 }
550 return (val);
551 }
552
553 /* Like mrealloc but get error if no storage available. */
554
555 PTR
xmrealloc(md,ptr,size)556 xmrealloc (md, ptr, size)
557 PTR md;
558 PTR ptr;
559 long size;
560 {
561 register PTR val;
562
563 if (ptr != NULL)
564 {
565 val = mrealloc (md, ptr, size);
566 }
567 else
568 {
569 val = mmalloc (md, size);
570 }
571 if (val == NULL)
572 {
573 nomem (size);
574 }
575 return (val);
576 }
577
578 /* Like malloc but get error if no storage available, and protect against
579 the caller wanting to allocate zero bytes. */
580
581 PTR
xmalloc(size)582 xmalloc (size)
583 long size;
584 {
585 return (xmmalloc ((void *) NULL, size));
586 }
587
588 /* Like mrealloc but get error if no storage available. */
589
590 PTR
xrealloc(ptr,size)591 xrealloc (ptr, size)
592 PTR ptr;
593 long size;
594 {
595 return (xmrealloc ((void *) NULL, ptr, size));
596 }
597
598
599 /* My replacement for the read system call.
600 Used like `read' but keeps going if `read' returns too soon. */
601
602 int
myread(desc,addr,len)603 myread (desc, addr, len)
604 int desc;
605 char *addr;
606 int len;
607 {
608 register int val;
609 int orglen = len;
610
611 while (len > 0)
612 {
613 val = read (desc, addr, len);
614 if (val < 0)
615 return val;
616 if (val == 0)
617 return orglen - len;
618 len -= val;
619 addr += val;
620 }
621 return orglen;
622 }
623
624 /* Make a copy of the string at PTR with SIZE characters
625 (and add a null character at the end in the copy).
626 Uses malloc to get the space. Returns the address of the copy. */
627
628 char *
savestring(ptr,size)629 savestring (ptr, size)
630 const char *ptr;
631 int size;
632 {
633 register char *p = (char *) xmalloc (size + 1);
634 memcpy (p, ptr, size);
635 p[size] = 0;
636 return p;
637 }
638
639 char *
msavestring(md,ptr,size)640 msavestring (md, ptr, size)
641 void *md;
642 const char *ptr;
643 int size;
644 {
645 register char *p = (char *) xmmalloc (md, size + 1);
646 memcpy (p, ptr, size);
647 p[size] = 0;
648 return p;
649 }
650
651 /* The "const" is so it compiles under DGUX (which prototypes strsave
652 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
653 Doesn't real strsave return NULL if out of memory? */
654 char *
strsave(ptr)655 strsave (ptr)
656 const char *ptr;
657 {
658 return savestring (ptr, strlen (ptr));
659 }
660
661 char *
mstrsave(md,ptr)662 mstrsave (md, ptr)
663 void *md;
664 const char *ptr;
665 {
666 return (msavestring (md, ptr, strlen (ptr)));
667 }
668
669 void
print_spaces(n,file)670 print_spaces (n, file)
671 register int n;
672 register FILE *file;
673 {
674 while (n-- > 0)
675 fputc (' ', file);
676 }
677
678 /* Ask user a y-or-n question and return 1 iff answer is yes.
679 Takes three args which are given to printf to print the question.
680 The first, a control string, should end in "? ".
681 It should not say how to answer, because we do that. */
682
683 /* VARARGS */
684 int
query(va_alist)685 query (va_alist)
686 va_dcl
687 {
688 va_list args;
689 char *ctlstr;
690 register int answer;
691 register int ans2;
692
693 /* Automatically answer "yes" if input is not from a terminal. */
694 if (!input_from_terminal_p ())
695 return 1;
696
697 while (1)
698 {
699 wrap_here (""); /* Flush any buffered output */
700 fflush (stdout);
701 va_start (args);
702 ctlstr = va_arg (args, char *);
703 vfprintf_filtered (stdout, ctlstr, args);
704 va_end (args);
705 printf_filtered ("(y or n) ");
706 fflush (stdout);
707 answer = fgetc (stdin);
708 clearerr (stdin); /* in case of C-d */
709 if (answer == EOF) /* C-d */
710 return 1;
711 if (answer != '\n') /* Eat rest of input line, to EOF or newline */
712 do
713 {
714 ans2 = fgetc (stdin);
715 clearerr (stdin);
716 }
717 while (ans2 != EOF && ans2 != '\n');
718 if (answer >= 'a')
719 answer -= 040;
720 if (answer == 'Y')
721 return 1;
722 if (answer == 'N')
723 return 0;
724 printf_filtered ("Please answer y or n.\n");
725 }
726 }
727
728
729 /* Parse a C escape sequence. STRING_PTR points to a variable
730 containing a pointer to the string to parse. That pointer
731 should point to the character after the \. That pointer
732 is updated past the characters we use. The value of the
733 escape sequence is returned.
734
735 A negative value means the sequence \ newline was seen,
736 which is supposed to be equivalent to nothing at all.
737
738 If \ is followed by a null character, we return a negative
739 value and leave the string pointer pointing at the null character.
740
741 If \ is followed by 000, we return 0 and leave the string pointer
742 after the zeros. A value of 0 does not mean end of string. */
743
744 int
parse_escape(string_ptr)745 parse_escape (string_ptr)
746 char **string_ptr;
747 {
748 register int c = *(*string_ptr)++;
749 switch (c)
750 {
751 case 'a':
752 return 007; /* Bell (alert) char */
753 case 'b':
754 return '\b';
755 case 'e': /* Escape character */
756 return 033;
757 case 'f':
758 return '\f';
759 case 'n':
760 return '\n';
761 case 'r':
762 return '\r';
763 case 't':
764 return '\t';
765 case 'v':
766 return '\v';
767 case '\n':
768 return -2;
769 case 0:
770 (*string_ptr)--;
771 return 0;
772 case '^':
773 c = *(*string_ptr)++;
774 if (c == '\\')
775 c = parse_escape (string_ptr);
776 if (c == '?')
777 return 0177;
778 return (c & 0200) | (c & 037);
779
780 case '0':
781 case '1':
782 case '2':
783 case '3':
784 case '4':
785 case '5':
786 case '6':
787 case '7':
788 {
789 register int i = c - '0';
790 register int count = 0;
791 while (++count < 3)
792 {
793 if ((c = *(*string_ptr)++) >= '0' && c <= '7')
794 {
795 i *= 8;
796 i += c - '0';
797 }
798 else
799 {
800 (*string_ptr)--;
801 break;
802 }
803 }
804 return i;
805 }
806 default:
807 return c;
808 }
809 }
810
811 /* Print the character C on STREAM as part of the contents
812 of a literal string whose delimiter is QUOTER. */
813
814 void
printchar(c,stream,quoter)815 printchar (c, stream, quoter)
816 register int c;
817 FILE *stream;
818 int quoter;
819 {
820
821 c &= 0xFF; /* Avoid sign bit follies */
822
823 if ( c < 0x20 || /* Low control chars */
824 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
825 (sevenbit_strings && c >= 0x80)) { /* high order bit set */
826 switch (c)
827 {
828 case '\n':
829 fputs_filtered ("\\n", stream);
830 break;
831 case '\b':
832 fputs_filtered ("\\b", stream);
833 break;
834 case '\t':
835 fputs_filtered ("\\t", stream);
836 break;
837 case '\f':
838 fputs_filtered ("\\f", stream);
839 break;
840 case '\r':
841 fputs_filtered ("\\r", stream);
842 break;
843 case '\033':
844 fputs_filtered ("\\e", stream);
845 break;
846 case '\007':
847 fputs_filtered ("\\a", stream);
848 break;
849 default:
850 fprintf_filtered (stream, "\\%X", (unsigned int) c);
851 break;
852 }
853 } else {
854 if (c == '\\' || c == quoter)
855 fputs_filtered ("\\", stream);
856 fprintf_filtered (stream, "%c", c);
857 }
858 }
859
860 /* Number of lines per page or UINT_MAX if paging is disabled. */
861 static unsigned int lines_per_page;
862 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
863 static unsigned int chars_per_line;
864 /* Current count of lines printed on this page, chars on this line. */
865 static unsigned int lines_printed, chars_printed;
866
867 /* Buffer and start column of buffered text, for doing smarter word-
868 wrapping. When someone calls wrap_here(), we start buffering output
869 that comes through fputs_filtered(). If we see a newline, we just
870 spit it out and forget about the wrap_here(). If we see another
871 wrap_here(), we spit it out and remember the newer one. If we see
872 the end of the line, we spit out a newline, the indent, and then
873 the buffered output.
874
875 wrap_column is the column number on the screen where wrap_buffer begins.
876 When wrap_column is zero, wrapping is not in effect.
877 wrap_buffer is malloc'd with chars_per_line+2 bytes.
878 When wrap_buffer[0] is null, the buffer is empty.
879 wrap_pointer points into it at the next character to fill.
880 wrap_indent is the string that should be used as indentation if the
881 wrap occurs. */
882
883 static char *wrap_buffer, *wrap_pointer, *wrap_indent;
884 static int wrap_column;
885
886 /* ARGSUSED */
887 static void
set_width_command(args,from_tty,c)888 set_width_command (args, from_tty, c)
889 char *args;
890 int from_tty;
891 struct cmd_list_element *c;
892 {
893 if (!wrap_buffer)
894 {
895 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
896 wrap_buffer[0] = '\0';
897 }
898 else
899 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
900 wrap_pointer = wrap_buffer; /* Start it at the beginning */
901 }
902
903 extern FILE *instream;
904
905 static void
instream_cleanup(stream)906 instream_cleanup(stream)
907 FILE *stream;
908 {
909 instream = stream;
910 }
911
912 static void
prompt_for_continue()913 prompt_for_continue ()
914 {
915 if (ISATTY(stdin) && ISATTY(stdout))
916 {
917 struct cleanup *old_chain = make_cleanup(instream_cleanup, instream);
918 char *cp;
919
920 instream = stdin;
921 immediate_quit++;
922 cp = gdb_readline ("---Type <return> to continue---");
923 if (cp)
924 free (cp);
925 chars_printed = lines_printed = 0;
926 immediate_quit--;
927 do_cleanups(old_chain);
928 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
929 }
930 }
931
932 /* Reinitialize filter; ie. tell it to reset to original values. */
933
934 void
reinitialize_more_filter()935 reinitialize_more_filter ()
936 {
937 lines_printed = 0;
938 chars_printed = 0;
939 }
940
941 /* Indicate that if the next sequence of characters overflows the line,
942 a newline should be inserted here rather than when it hits the end.
943 If INDENT is nonzero, it is a string to be printed to indent the
944 wrapped part on the next line. INDENT must remain accessible until
945 the next call to wrap_here() or until a newline is printed through
946 fputs_filtered().
947
948 If the line is already overfull, we immediately print a newline and
949 the indentation, and disable further wrapping.
950
951 If we don't know the width of lines, but we know the page height,
952 we must not wrap words, but should still keep track of newlines
953 that were explicitly printed.
954
955 INDENT should not contain tabs, as that
956 will mess up the char count on the next line. FIXME. */
957
958 void
wrap_here(indent)959 wrap_here(indent)
960 char *indent;
961 {
962 if (wrap_buffer[0])
963 {
964 *wrap_pointer = '\0';
965 fputs (wrap_buffer, stdout);
966 }
967 wrap_pointer = wrap_buffer;
968 wrap_buffer[0] = '\0';
969 if (chars_per_line == UINT_MAX) /* No line overflow checking */
970 {
971 wrap_column = 0;
972 }
973 else if (chars_printed >= chars_per_line)
974 {
975 puts_filtered ("\n");
976 puts_filtered (indent);
977 wrap_column = 0;
978 }
979 else
980 {
981 wrap_column = chars_printed;
982 wrap_indent = indent;
983 }
984 }
985
986 /* Like fputs but pause after every screenful, and can wrap at points
987 other than the final character of a line.
988 Unlike fputs, fputs_filtered does not return a value.
989 It is OK for LINEBUFFER to be NULL, in which case just don't print
990 anything.
991
992 Note that a longjmp to top level may occur in this routine
993 (since prompt_for_continue may do so) so this routine should not be
994 called when cleanups are not in place. */
995
996 void
fputs_filtered(linebuffer,stream)997 fputs_filtered (linebuffer, stream)
998 const char *linebuffer;
999 FILE *stream;
1000 {
1001 const char *lineptr;
1002
1003 if (linebuffer == 0)
1004 return;
1005
1006 /* Don't do any filtering if it is disabled. */
1007 if (stream != stdout
1008 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
1009 {
1010 fputs (linebuffer, stream);
1011 return;
1012 }
1013
1014 /* Go through and output each character. Show line extension
1015 when this is necessary; prompt user for new page when this is
1016 necessary. */
1017
1018 lineptr = linebuffer;
1019 while (*lineptr)
1020 {
1021 /* Possible new page. */
1022 if (lines_printed >= lines_per_page - 1)
1023 prompt_for_continue ();
1024
1025 while (*lineptr && *lineptr != '\n')
1026 {
1027 /* Print a single line. */
1028 if (*lineptr == '\t')
1029 {
1030 if (wrap_column)
1031 *wrap_pointer++ = '\t';
1032 else
1033 putc ('\t', stream);
1034 /* Shifting right by 3 produces the number of tab stops
1035 we have already passed, and then adding one and
1036 shifting left 3 advances to the next tab stop. */
1037 chars_printed = ((chars_printed >> 3) + 1) << 3;
1038 lineptr++;
1039 }
1040 else
1041 {
1042 if (wrap_column)
1043 *wrap_pointer++ = *lineptr;
1044 else
1045 putc (*lineptr, stream);
1046 chars_printed++;
1047 lineptr++;
1048 }
1049
1050 if (chars_printed >= chars_per_line)
1051 {
1052 unsigned int save_chars = chars_printed;
1053
1054 chars_printed = 0;
1055 lines_printed++;
1056 /* If we aren't actually wrapping, don't output newline --
1057 if chars_per_line is right, we probably just overflowed
1058 anyway; if it's wrong, let us keep going. */
1059 if (wrap_column)
1060 putc ('\n', stream);
1061
1062 /* Possible new page. */
1063 if (lines_printed >= lines_per_page - 1)
1064 prompt_for_continue ();
1065
1066 /* Now output indentation and wrapped string */
1067 if (wrap_column)
1068 {
1069 if (wrap_indent)
1070 fputs (wrap_indent, stream);
1071 *wrap_pointer = '\0'; /* Null-terminate saved stuff */
1072 fputs (wrap_buffer, stream); /* and eject it */
1073 /* FIXME, this strlen is what prevents wrap_indent from
1074 containing tabs. However, if we recurse to print it
1075 and count its chars, we risk trouble if wrap_indent is
1076 longer than (the user settable) chars_per_line.
1077 Note also that this can set chars_printed > chars_per_line
1078 if we are printing a long string. */
1079 chars_printed = strlen (wrap_indent)
1080 + (save_chars - wrap_column);
1081 wrap_pointer = wrap_buffer; /* Reset buffer */
1082 wrap_buffer[0] = '\0';
1083 wrap_column = 0; /* And disable fancy wrap */
1084 }
1085 }
1086 }
1087
1088 if (*lineptr == '\n')
1089 {
1090 chars_printed = 0;
1091 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
1092 lines_printed++;
1093 putc ('\n', stream);
1094 lineptr++;
1095 }
1096 }
1097 }
1098
1099
1100 /* fputs_demangled is a variant of fputs_filtered that
1101 demangles g++ names.*/
1102
1103 void
fputs_demangled(linebuffer,stream,arg_mode)1104 fputs_demangled (linebuffer, stream, arg_mode)
1105 char *linebuffer;
1106 FILE *stream;
1107 int arg_mode;
1108 {
1109 #define SYMBOL_MAX 1024
1110
1111 #define SYMBOL_CHAR(c) (isascii(c) \
1112 && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
1113
1114 char buf[SYMBOL_MAX+1];
1115 # define DMSLOP 5 /* How much room to leave in buf */
1116 char *p;
1117
1118 if (linebuffer == NULL)
1119 return;
1120
1121 /* If user wants to see raw output, no problem. */
1122 if (!demangle) {
1123 fputs_filtered (linebuffer, stream);
1124 return;
1125 }
1126
1127 p = linebuffer;
1128
1129 while ( *p != (char) 0 ) {
1130 int i = 0;
1131
1132 /* collect non-interesting characters into buf */
1133 while (*p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-DMSLOP ) {
1134 buf[i++] = *p;
1135 p++;
1136 }
1137 if (i > 0) {
1138 /* output the non-interesting characters without demangling */
1139 buf[i] = (char) 0;
1140 fputs_filtered(buf, stream);
1141 i = 0; /* reset buf */
1142 }
1143
1144 /* and now the interesting characters */
1145 while (i < SYMBOL_MAX
1146 && *p != (char) 0
1147 && SYMBOL_CHAR(*p)
1148 && i < (int)sizeof(buf) - DMSLOP) {
1149 buf[i++] = *p;
1150 p++;
1151 }
1152 buf[i] = (char) 0;
1153 if (i > 0) {
1154 char * result;
1155
1156 if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) {
1157 fputs_filtered(result, stream);
1158 free(result);
1159 }
1160 else {
1161 fputs_filtered(buf, stream);
1162 }
1163 }
1164 }
1165 }
1166
1167 /* Print a variable number of ARGS using format FORMAT. If this
1168 information is going to put the amount written (since the last call
1169 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1170 print out a pause message and do a gdb_readline to get the users
1171 permision to continue.
1172
1173 Unlike fprintf, this function does not return a value.
1174
1175 We implement three variants, vfprintf (takes a vararg list and stream),
1176 fprintf (takes a stream to write on), and printf (the usual).
1177
1178 Note that this routine has a restriction that the length of the
1179 final output line must be less than 255 characters *or* it must be
1180 less than twice the size of the format string. This is a very
1181 arbitrary restriction, but it is an internal restriction, so I'll
1182 put it in. This means that the %s format specifier is almost
1183 useless; unless the caller can GUARANTEE that the string is short
1184 enough, fputs_filtered should be used instead.
1185
1186 Note also that a longjmp to top level may occur in this routine
1187 (since prompt_for_continue may do so) so this routine should not be
1188 called when cleanups are not in place. */
1189
1190 #define MIN_LINEBUF 255
1191
1192 void
vfprintf_filtered(stream,format,args)1193 vfprintf_filtered (stream, format, args)
1194 FILE *stream;
1195 char *format;
1196 va_list args;
1197 {
1198 char line_buf[MIN_LINEBUF+10];
1199 char *linebuffer = line_buf;
1200 int format_length;
1201
1202 format_length = strlen (format);
1203
1204 /* Reallocate buffer to a larger size if this is necessary. */
1205 if (format_length * 2 > MIN_LINEBUF)
1206 {
1207 linebuffer = alloca (10 + format_length * 2);
1208 }
1209
1210 /* This won't blow up if the restrictions described above are
1211 followed. */
1212 vsprintf (linebuffer, format, args);
1213
1214 fputs_filtered (linebuffer, stream);
1215 }
1216
1217 /* VARARGS */
1218 void
fprintf_filtered(va_alist)1219 fprintf_filtered (va_alist)
1220 va_dcl
1221 {
1222 va_list args;
1223 FILE *stream;
1224 char *format;
1225
1226 va_start (args);
1227 stream = va_arg (args, FILE *);
1228 format = va_arg (args, char *);
1229
1230 /* This won't blow up if the restrictions described above are
1231 followed. */
1232 vfprintf_filtered (stream, format, args);
1233 va_end (args);
1234 }
1235
1236 /* Like fprintf_filtered, but prints it's result indent.
1237 Called as fprintfi_filtered (spaces, format, arg1, arg2, ...); */
1238
1239 /* VARARGS */
1240 void
fprintfi_filtered(va_alist)1241 fprintfi_filtered (va_alist)
1242 va_dcl
1243 {
1244 va_list args;
1245 int spaces;
1246 FILE *stream;
1247 char *format;
1248
1249 va_start (args);
1250 spaces = va_arg (args, int);
1251 stream = va_arg (args, FILE *);
1252 format = va_arg (args, char *);
1253 print_spaces_filtered (spaces, stream);
1254
1255 /* This won't blow up if the restrictions described above are
1256 followed. */
1257 vfprintf_filtered (stream, format, args);
1258 va_end (args);
1259 }
1260
1261 /* VARARGS */
1262 void
printf_filtered(va_alist)1263 printf_filtered (va_alist)
1264 va_dcl
1265 {
1266 va_list args;
1267 char *format;
1268
1269 va_start (args);
1270 format = va_arg (args, char *);
1271
1272 vfprintf_filtered (stdout, format, args);
1273 va_end (args);
1274 }
1275
1276 /* Like printf_filtered, but prints it's result indented.
1277 Called as printfi_filtered (spaces, format, arg1, arg2, ...); */
1278
1279 /* VARARGS */
1280 void
printfi_filtered(va_alist)1281 printfi_filtered (va_alist)
1282 va_dcl
1283 {
1284 va_list args;
1285 int spaces;
1286 char *format;
1287
1288 va_start (args);
1289 spaces = va_arg (args, int);
1290 format = va_arg (args, char *);
1291 print_spaces_filtered (spaces, stdout);
1292 vfprintf_filtered (stdout, format, args);
1293 va_end (args);
1294 }
1295
1296 /* Easy -- but watch out!
1297
1298 This routine is *not* a replacement for puts()! puts() appends a newline.
1299 This one doesn't, and had better not! */
1300
1301 void
puts_filtered(string)1302 puts_filtered (string)
1303 char *string;
1304 {
1305 fputs_filtered (string, stdout);
1306 }
1307
1308 /* Return a pointer to N spaces and a null. The pointer is good
1309 until the next call to here. */
1310 char *
n_spaces(n)1311 n_spaces (n)
1312 int n;
1313 {
1314 register char *t;
1315 static char *spaces;
1316 static int max_spaces;
1317
1318 if (n > max_spaces)
1319 {
1320 if (spaces)
1321 free (spaces);
1322 spaces = (char *) xmalloc (n+1);
1323 for (t = spaces+n; t != spaces;)
1324 *--t = ' ';
1325 spaces[n] = '\0';
1326 max_spaces = n;
1327 }
1328
1329 return spaces + max_spaces - n;
1330 }
1331
1332 /* Print N spaces. */
1333 void
print_spaces_filtered(n,stream)1334 print_spaces_filtered (n, stream)
1335 int n;
1336 FILE *stream;
1337 {
1338 fputs_filtered (n_spaces (n), stream);
1339 }
1340
1341 /* C++ demangler stuff. */
1342
1343 /* Make a copy of a symbol, applying C++ demangling if demangling is enabled
1344 and a demangled version exists. Note that the value returned from
1345 cplus_demangle is already allocated in malloc'd memory. */
1346
1347 char *
strdup_demangled(name)1348 strdup_demangled (name)
1349 const char *name;
1350 {
1351 char *demangled = NULL;
1352
1353 if (demangle)
1354 {
1355 demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI);
1356 }
1357 return ((demangled != NULL) ? demangled : strdup (name));
1358 }
1359
1360
1361 /* Print NAME on STREAM, demangling if necessary. */
1362 void
fprint_symbol(stream,name)1363 fprint_symbol (stream, name)
1364 FILE *stream;
1365 char *name;
1366 {
1367 char *demangled;
1368 if ((!demangle)
1369 || NULL == (demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI)))
1370 fputs_filtered (name, stream);
1371 else
1372 {
1373 fputs_filtered (demangled, stream);
1374 free (demangled);
1375 }
1376 }
1377
1378 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
1379 differences in whitespace. Returns 0 if they match, non-zero if they
1380 don't (slightly different than strcmp()'s range of return values).
1381
1382 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
1383 This "feature" is useful for demangle_and_match(), which is used
1384 when searching for matching C++ function names (such as if the
1385 user types 'break FOO', where FOO is a mangled C++ function). */
1386
1387 int
strcmp_iw(string1,string2)1388 strcmp_iw (string1, string2)
1389 const char *string1;
1390 const char *string2;
1391 {
1392 while ((*string1 != '\0') && (*string2 != '\0'))
1393 {
1394 while (isspace (*string1))
1395 {
1396 string1++;
1397 }
1398 while (isspace (*string2))
1399 {
1400 string2++;
1401 }
1402 if (*string1 != *string2)
1403 {
1404 break;
1405 }
1406 if (*string1 != '\0')
1407 {
1408 string1++;
1409 string2++;
1410 }
1411 }
1412 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
1413 }
1414
1415 /* Demangle NAME and compare the result with LOOKFOR, ignoring any differences
1416 in whitespace.
1417
1418 If a match is found, returns a pointer to the demangled version of NAME
1419 in malloc'd memory, which needs to be freed by the caller after use.
1420 If a match is not found, returns NULL.
1421
1422 OPTIONS is a flags word that controls the demangling process and is just
1423 passed on to the demangler.
1424
1425 When the caller sees a non-NULL result, it knows that NAME is the mangled
1426 equivalent of LOOKFOR, and it can use either NAME, the "official demangled"
1427 version of NAME (the return value) or the "unofficial demangled" version
1428 of NAME (LOOKFOR, which it already knows). */
1429
1430 char *
demangle_and_match(name,lookfor,options)1431 demangle_and_match (name, lookfor, options)
1432 const char *name;
1433 const char *lookfor;
1434 int options;
1435 {
1436 char *demangled;
1437
1438 if ((demangled = cplus_demangle (name, options)) != NULL)
1439 {
1440 if (strcmp_iw (demangled, lookfor) != 0)
1441 {
1442 free (demangled);
1443 demangled = NULL;
1444 }
1445 }
1446 return (demangled);
1447 }
1448
1449 #ifdef TIOCGWINSZ
1450 #ifdef SIGWINCH
1451 static void
sigwinch()1452 sigwinch()
1453 {
1454 struct winsize win;
1455
1456 if (ioctl(0, TIOCGWINSZ, (char *)&win) < 0) {
1457 perror("TIOCGWINSZ");
1458 return;
1459 }
1460 lines_per_page = win.ws_row;
1461 chars_per_line = win.ws_col;
1462 }
1463
1464 #ifndef SIGWINCH_HANDLER
1465 #define SIGWINCH_HANDLER sigwinch
1466 #endif
1467
1468 #endif
1469
termdim()1470 termdim()
1471 {
1472 SIGWINCH_HANDLER();
1473 #ifdef SIGWINCH
1474 signal(SIGWINCH, SIGWINCH_HANDLER);
1475 #endif
1476 }
1477
1478 #else
1479 /* Initialize the screen height and width from termcap. */
termdim()1480 termdim()
1481 {
1482 register int v;
1483 register char *cp;
1484 /* 2048 is large enough for all known terminals, according to the
1485 GNU termcap manual. */
1486 char term_buffer[2048];
1487
1488 if ((termtype = getenv ("TERM")) == 0 || tgetent(term_buffer, cp) <= 0)
1489 return;
1490
1491 v = tgetnum("li");
1492 if (v >= 0)
1493 lines_per_page = v;
1494 else
1495 /* The number of lines per page is not mentioned
1496 in the terminal description. This probably means
1497 that paging is not useful (e.g. emacs shell window),
1498 so disable paging. */
1499 lines_per_page = UINT_MAX;
1500
1501 v = tgetnum("co");
1502 if (v >= 0)
1503 chars_per_line = v;
1504 }
1505 #endif
1506
1507 void
_initialize_utils()1508 _initialize_utils ()
1509 {
1510 struct cmd_list_element *c;
1511
1512 c = add_set_cmd ("width", class_support, var_uinteger,
1513 (char *)&chars_per_line,
1514 "Set number of characters gdb thinks are in a line.",
1515 &setlist);
1516 add_show_from_set (c, &showlist);
1517 c->function.sfunc = set_width_command;
1518
1519 add_show_from_set
1520 (add_set_cmd ("height", class_support,
1521 var_uinteger, (char *)&lines_per_page,
1522 "Set number of lines gdb thinks are in a page.", &setlist),
1523 &showlist);
1524
1525 /* These defaults will be used if we are unable to get the correct
1526 values from termcap. */
1527 #if defined(__GO32__)
1528 lines_per_page = ScreenRows();
1529 chars_per_line = ScreenCols();
1530 #else
1531 lines_per_page = 24;
1532 chars_per_line = 80;
1533 termdim();
1534 #endif
1535 /* If the output is not a terminal, don't paginate it. */
1536 if (!ISATTY (stdout))
1537 lines_per_page = UINT_MAX;
1538
1539 set_width_command ((char *)NULL, 0, c);
1540
1541 add_show_from_set
1542 (add_set_cmd ("demangle", class_support, var_boolean,
1543 (char *)&demangle,
1544 "Set demangling of encoded C++ names when displaying symbols.",
1545 &setprintlist),
1546 &showprintlist);
1547
1548 add_show_from_set
1549 (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
1550 (char *)&sevenbit_strings,
1551 "Set printing of 8-bit characters in strings as \\nnn.",
1552 &setprintlist),
1553 &showprintlist);
1554
1555 add_show_from_set
1556 (add_set_cmd ("asm-demangle", class_support, var_boolean,
1557 (char *)&asm_demangle,
1558 "Set demangling of C++ names in disassembly listings.",
1559 &setprintlist),
1560 &showprintlist);
1561 }
1562
1563 /* Machine specific function to handle SIGWINCH signal. */
1564
1565 #ifdef SIGWINCH_HANDLER_BODY
1566 SIGWINCH_HANDLER_BODY
1567 #endif
1568