1 /* General utility routines for GDB, the GNU debugger.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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. */
21 #include <sys/ioctl.h>
22 #include <sys/param.h>
35 extern volatile void return_to_top_level ();
36 extern volatile void exit ();
37 extern char *gdb_readline ();
38 extern char *getenv();
39 extern char *malloc();
40 extern char *realloc();
42 /* If this definition isn't overridden by the header files, assume
43 that isatty and fileno exist on this system. */
45 #define ISATTY(FP) (isatty (fileno (FP)))
48 #ifdef MISSING_VPRINTF
50 #undef MISSING_VPRINTF
51 #else /* !__GNU_LIBRARY */
54 #define vfprintf(file, format, ap) _doprnt (format, ap, file)
58 /* Can't #define it since printcmd.c needs it */
64 vfprintf (stdout
, format
, ap
);
68 #endif /* GNU_LIBRARY */
69 #endif /* MISSING_VPRINTF */
74 /* Chain of cleanup actions established with make_cleanup,
75 to be executed if an error happens. */
77 static struct cleanup
*cleanup_chain
;
79 /* Nonzero means a quit has been requested. */
83 /* Nonzero means quit immediately if Control-C is typed now,
84 rather than waiting until QUIT is executed. */
88 /* Nonzero means that encoded C++ names should be printed out in their
89 C++ form rather than raw. */
93 /* Nonzero means that encoded C++ names should be printed out in their
94 C++ form even in assembler language displays. If this is set, but
95 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
99 /* Nonzero means that strings with character values >0x7F should be printed
100 as octal escapes. Zero means just print the value (e.g. it's an
101 international character, and the terminal or window can cope.) */
103 int sevenbit_strings
= 0;
105 /* String to be printed before error messages, if any. */
107 char *error_pre_print
;
109 /* Add a new cleanup to the cleanup_chain,
110 and return the previous chain pointer
111 to be passed later to do_cleanups or discard_cleanups.
112 Args are FUNCTION to clean up with, and ARG to pass to it. */
115 make_cleanup (function
, arg
)
119 register struct cleanup
*new
120 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
121 register struct cleanup
*old_chain
= cleanup_chain
;
123 new->next
= cleanup_chain
;
124 new->function
= function
;
131 /* Discard cleanups and do the actions they describe
132 until we get back to the point OLD_CHAIN in the cleanup_chain. */
135 do_cleanups (old_chain
)
136 register struct cleanup
*old_chain
;
138 register struct cleanup
*ptr
;
139 while ((ptr
= cleanup_chain
) != old_chain
)
141 cleanup_chain
= ptr
->next
; /* Do this first incase recursion */
142 (*ptr
->function
) (ptr
->arg
);
147 /* Discard cleanups, not doing the actions they describe,
148 until we get back to the point OLD_CHAIN in the cleanup_chain. */
151 discard_cleanups (old_chain
)
152 register struct cleanup
*old_chain
;
154 register struct cleanup
*ptr
;
155 while ((ptr
= cleanup_chain
) != old_chain
)
157 cleanup_chain
= ptr
->next
;
162 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
166 struct cleanup
*old_chain
= cleanup_chain
;
172 /* Restore the cleanup chain from a previously saved chain. */
174 restore_cleanups (chain
)
175 struct cleanup
*chain
;
177 cleanup_chain
= chain
;
180 /* This function is useful for cleanups.
184 old_chain = make_cleanup (free_current_contents, &foo);
186 to arrange to free the object thus allocated. */
189 free_current_contents (location
)
195 /* Print an error message and return to command level.
196 The first argument STRING is the error message, used as a fprintf string,
197 and the remaining args are passed as arguments to it. */
208 target_terminal_ours ();
211 fprintf (stderr
, error_pre_print
);
212 string
= va_arg (args
, char *);
213 vfprintf (stderr
, string
, args
);
214 fprintf (stderr
, "\n");
216 return_to_top_level ();
219 /* Print an error message and exit reporting failure.
220 This is for a error that we cannot continue from.
221 The arguments are printed a la printf. */
232 string
= va_arg (args
, char *);
233 fprintf (stderr
, "gdb: ");
234 vfprintf (stderr
, string
, args
);
235 fprintf (stderr
, "\n");
240 /* Print an error message and exit, dumping core.
241 The arguments are printed a la printf (). */
244 fatal_dump_core (va_alist
)
251 string
= va_arg (args
, char *);
252 /* "internal error" is always correct, since GDB should never dump
253 core, no matter what the input. */
254 fprintf (stderr
, "gdb internal error: ");
255 vfprintf (stderr
, string
, args
);
256 fprintf (stderr
, "\n");
259 signal (SIGQUIT
, SIG_DFL
);
260 kill (getpid (), SIGQUIT
);
261 /* We should never get here, but just in case... */
265 /* Memory management stuff (malloc friends). */
267 #if defined (NO_MALLOC_CHECK)
271 #else /* Have mcheck(). */
275 fatal_dump_core ("Memory corruption");
281 mcheck (malloc_botch
);
284 #endif /* Have mcheck(). */
286 /* Like malloc but get error if no storage available. */
298 /* At least one place (dbxread.c:condense_misc_bunches where misc_count == 0)
299 GDB wants to allocate zero bytes. */
303 val
= (char *) malloc (size
);
305 fatal ("virtual memory exhausted.", 0);
309 /* Like realloc but get error if no storage available. */
320 register char *val
= (char *) realloc (ptr
, size
);
322 fatal ("virtual memory exhausted.", 0);
326 /* Print the system error message for errno, and also mention STRING
327 as the file name for which the error was encountered.
328 Then return to command level. */
331 perror_with_name (string
)
335 extern char *sys_errlist
[];
339 if (errno
< sys_nerr
)
340 err
= sys_errlist
[errno
];
342 err
= "unknown error";
344 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
345 strcpy (combined
, string
);
346 strcat (combined
, ": ");
347 strcat (combined
, err
);
349 /* I understand setting these is a matter of taste. Still, some people
350 may clear errno but not know about bfd_error. Doing this here is not
352 bfd_error
= no_error
;
355 error ("%s.", combined
);
358 /* Print the system error message for ERRCODE, and also mention STRING
359 as the file name for which the error was encountered. */
362 print_sys_errmsg (string
, errcode
)
367 extern char *sys_errlist
[];
371 if (errcode
< sys_nerr
)
372 err
= sys_errlist
[errcode
];
374 err
= "unknown error";
376 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
377 strcpy (combined
, string
);
378 strcat (combined
, ": ");
379 strcat (combined
, err
);
381 printf ("%s.\n", combined
);
384 /* Control C eventually causes this to be called, at a convenient time. */
389 target_terminal_ours ();
390 wrap_here ((char *)0); /* Force out any pending output */
392 ioctl (fileno (stdout
), TCFLSH
, 1);
393 #else /* not HAVE_TERMIO */
394 ioctl (fileno (stdout
), TIOCFLUSH
, 0);
395 #endif /* not HAVE_TERMIO */
399 error ("Quit (expect signal %d when inferior is resumed)", SIGINT
);
400 #endif /* TIOCGPGRP */
403 /* Control C comes here */
411 /* Restore the signal handler. */
412 signal (SIGINT
, request_quit
);
419 /* My replacement for the read system call.
420 Used like `read' but keeps going if `read' returns too soon. */
423 myread (desc
, addr
, len
)
433 val
= read (desc
, addr
, len
);
444 /* Make a copy of the string at PTR with SIZE characters
445 (and add a null character at the end in the copy).
446 Uses malloc to get the space. Returns the address of the copy. */
449 savestring (ptr
, size
)
453 register char *p
= (char *) xmalloc (size
+ 1);
454 bcopy (ptr
, p
, size
);
459 /* The "const" is so it compiles under DGUX (which prototypes strsave
460 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
461 Doesn't real strsave return NULL if out of memory? */
466 return savestring (ptr
, strlen (ptr
));
473 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
474 register char *val
= (char *) xmalloc (len
);
482 print_spaces (n
, file
)
490 /* Ask user a y-or-n question and return 1 iff answer is yes.
491 Takes three args which are given to printf to print the question.
492 The first, a control string, should end in "? ".
493 It should not say how to answer, because we do that. */
505 /* Automatically answer "yes" if input is not from a terminal. */
506 if (!input_from_terminal_p ())
512 ctlstr
= va_arg (args
, char *);
513 vfprintf (stdout
, ctlstr
, args
);
515 printf ("(y or n) ");
517 answer
= fgetc (stdin
);
518 clearerr (stdin
); /* in case of C-d */
519 if (answer
== EOF
) /* C-d */
521 if (answer
!= '\n') /* Eat rest of input line, to EOF or newline */
524 ans2
= fgetc (stdin
);
527 while (ans2
!= EOF
&& ans2
!= '\n');
534 printf ("Please answer y or n.\n");
538 /* Parse a C escape sequence. STRING_PTR points to a variable
539 containing a pointer to the string to parse. That pointer
540 should point to the character after the \. That pointer
541 is updated past the characters we use. The value of the
542 escape sequence is returned.
544 A negative value means the sequence \ newline was seen,
545 which is supposed to be equivalent to nothing at all.
547 If \ is followed by a null character, we return a negative
548 value and leave the string pointer pointing at the null character.
550 If \ is followed by 000, we return 0 and leave the string pointer
551 after the zeros. A value of 0 does not mean end of string. */
554 parse_escape (string_ptr
)
557 register int c
= *(*string_ptr
)++;
582 c
= *(*string_ptr
)++;
584 c
= parse_escape (string_ptr
);
587 return (c
& 0200) | (c
& 037);
598 register int i
= c
- '0';
599 register int count
= 0;
602 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
620 /* Print the character CH on STREAM as part of the contents
621 of a literal string whose delimiter is QUOTER. */
624 printchar (ch
, stream
, quoter
)
631 if (c
< 040 || (sevenbit_strings
&& c
>= 0177))
635 fputs_filtered ("\\n", stream
);
638 fputs_filtered ("\\b", stream
);
641 fputs_filtered ("\\t", stream
);
644 fputs_filtered ("\\f", stream
);
647 fputs_filtered ("\\r", stream
);
650 fputs_filtered ("\\e", stream
);
653 fputs_filtered ("\\a", stream
);
656 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
661 if (c
== '\\' || c
== quoter
)
662 fputs_filtered ("\\", stream
);
663 fprintf_filtered (stream
, "%c", c
);
667 /* Number of lines per page or UINT_MAX if paging is disabled. */
668 static unsigned int lines_per_page
;
669 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
670 static unsigned int chars_per_line
;
671 /* Current count of lines printed on this page, chars on this line. */
672 static unsigned int lines_printed
, chars_printed
;
674 /* Buffer and start column of buffered text, for doing smarter word-
675 wrapping. When someone calls wrap_here(), we start buffering output
676 that comes through fputs_filtered(). If we see a newline, we just
677 spit it out and forget about the wrap_here(). If we see another
678 wrap_here(), we spit it out and remember the newer one. If we see
679 the end of the line, we spit out a newline, the indent, and then
682 wrap_column is the column number on the screen where wrap_buffer begins.
683 When wrap_column is zero, wrapping is not in effect.
684 wrap_buffer is malloc'd with chars_per_line+2 bytes.
685 When wrap_buffer[0] is null, the buffer is empty.
686 wrap_pointer points into it at the next character to fill.
687 wrap_indent is the string that should be used as indentation if the
690 static char *wrap_buffer
, *wrap_pointer
, *wrap_indent
;
691 static int wrap_column
;
693 /* Get the number of lines to print with commands like "list".
694 This is based on guessing how many long (i.e. more than chars_per_line
695 characters) lines there will be. To be completely correct, "list"
696 and friends should be rewritten to count characters and see where
697 things are wrapping, but that would be a fair amount of work. */
701 /* RMS didn't like the following algorithm. Let's set it back to
702 10 and see if anyone else complains. */
703 /* return lines_per_page == UINT_MAX ? 10 : lines_per_page / 2; */
709 set_width_command (args
, from_tty
, c
)
712 struct cmd_list_element
*c
;
716 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
717 wrap_buffer
[0] = '\0';
720 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
721 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
725 prompt_for_continue ()
730 ignore
= gdb_readline ("---Type <return> to continue---");
733 chars_printed
= lines_printed
= 0;
735 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
738 /* Reinitialize filter; ie. tell it to reset to original values. */
741 reinitialize_more_filter ()
747 /* Indicate that if the next sequence of characters overflows the line,
748 a newline should be inserted here rather than when it hits the end.
749 If INDENT is nonzero, it is a string to be printed to indent the
750 wrapped part on the next line. INDENT must remain accessible until
751 the next call to wrap_here() or until a newline is printed through
754 If the line is already overfull, we immediately print a newline and
755 the indentation, and disable further wrapping.
757 INDENT should not contain tabs, as that
758 will mess up the char count on the next line. FIXME. */
766 *wrap_pointer
= '\0';
767 fputs (wrap_buffer
, stdout
);
769 wrap_pointer
= wrap_buffer
;
770 wrap_buffer
[0] = '\0';
771 if (chars_printed
>= chars_per_line
)
773 puts_filtered ("\n");
774 puts_filtered (indent
);
779 wrap_column
= chars_printed
;
780 wrap_indent
= indent
;
784 /* Like fputs but pause after every screenful, and can wrap at points
785 other than the final character of a line.
786 Unlike fputs, fputs_filtered does not return a value.
787 It is OK for LINEBUFFER to be NULL, in which case just don't print
790 Note that a longjmp to top level may occur in this routine
791 (since prompt_for_continue may do so) so this routine should not be
792 called when cleanups are not in place. */
795 fputs_filtered (linebuffer
, stream
)
804 /* Don't do any filtering if it is disabled. */
806 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
808 fputs (linebuffer
, stream
);
812 /* Go through and output each character. Show line extension
813 when this is necessary; prompt user for new page when this is
816 lineptr
= linebuffer
;
819 /* Possible new page. */
820 if (lines_printed
>= lines_per_page
- 1)
821 prompt_for_continue ();
823 while (*lineptr
&& *lineptr
!= '\n')
825 /* Print a single line. */
826 if (*lineptr
== '\t')
829 *wrap_pointer
++ = '\t';
832 /* Shifting right by 3 produces the number of tab stops
833 we have already passed, and then adding one and
834 shifting left 3 advances to the next tab stop. */
835 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
841 *wrap_pointer
++ = *lineptr
;
843 putc (*lineptr
, stream
);
848 if (chars_printed
>= chars_per_line
)
850 unsigned int save_chars
= chars_printed
;
854 /* If we aren't actually wrapping, don't output newline --
855 if chars_per_line is right, we probably just overflowed
856 anyway; if it's wrong, let us keep going. */
860 /* Possible new page. */
861 if (lines_printed
>= lines_per_page
- 1)
862 prompt_for_continue ();
864 /* Now output indentation and wrapped string */
868 fputs (wrap_indent
, stream
);
869 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
870 fputs (wrap_buffer
, stream
); /* and eject it */
871 /* FIXME, this strlen is what prevents wrap_indent from
872 containing tabs. However, if we recurse to print it
873 and count its chars, we risk trouble if wrap_indent is
874 longer than (the user settable) chars_per_line.
875 Note also that this can set chars_printed > chars_per_line
876 if we are printing a long string. */
877 chars_printed
= strlen (wrap_indent
)
878 + (save_chars
- wrap_column
);
879 wrap_pointer
= wrap_buffer
; /* Reset buffer */
880 wrap_buffer
[0] = '\0';
881 wrap_column
= 0; /* And disable fancy wrap */
886 if (*lineptr
== '\n')
889 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
898 /* fputs_demangled is a variant of fputs_filtered that
899 demangles g++ names.*/
902 fputs_demangled (linebuffer
, stream
, arg_mode
)
908 extern char *cplus_demangle (const char *, int);
910 extern char *cplus_demangle ();
912 #define SYMBOL_MAX 1024
914 #define SYMBOL_CHAR(c) (isascii(c) \
915 && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
917 char buf
[SYMBOL_MAX
+1];
918 # define SLOP 5 /* How much room to leave in buf */
921 if (linebuffer
== NULL
)
924 /* If user wants to see raw output, no problem. */
926 fputs_filtered (linebuffer
, stream
);
932 while ( *p
!= (char) 0 ) {
935 /* collect non-interesting characters into buf */
936 while ( *p
!= (char) 0 && !SYMBOL_CHAR(*p
) && i
< (int)sizeof(buf
)-SLOP
) {
941 /* output the non-interesting characters without demangling */
943 fputs_filtered(buf
, stream
);
944 i
= 0; /* reset buf */
947 /* and now the interesting characters */
948 while (i
< SYMBOL_MAX
951 && i
< (int)sizeof(buf
) - SLOP
) {
959 if ( (result
= cplus_demangle(buf
, arg_mode
)) != NULL
) {
960 fputs_filtered(result
, stream
);
964 fputs_filtered(buf
, stream
);
970 /* Print a variable number of ARGS using format FORMAT. If this
971 information is going to put the amount written (since the last call
972 to INITIALIZE_MORE_FILTER or the last page break) over the page size,
973 print out a pause message and do a gdb_readline to get the users
974 permision to continue.
976 Unlike fprintf, this function does not return a value.
978 We implement three variants, vfprintf (takes a vararg list and stream),
979 fprintf (takes a stream to write on), and printf (the usual).
981 Note that this routine has a restriction that the length of the
982 final output line must be less than 255 characters *or* it must be
983 less than twice the size of the format string. This is a very
984 arbitrary restriction, but it is an internal restriction, so I'll
985 put it in. This means that the %s format specifier is almost
986 useless; unless the caller can GUARANTEE that the string is short
987 enough, fputs_filtered should be used instead.
989 Note also that a longjmp to top level may occur in this routine
990 (since prompt_for_continue may do so) so this routine should not be
991 called when cleanups are not in place. */
993 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
996 vfprintf_filtered (stream
, format
, args
)
999 void fprintf_filtered (stream
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
)
1004 static char *linebuffer
= (char *) 0;
1005 static int line_size
;
1008 format_length
= strlen (format
);
1010 /* Allocated linebuffer for the first time. */
1013 linebuffer
= (char *) xmalloc (255);
1017 /* Reallocate buffer to a larger size if this is necessary. */
1018 if (format_length
* 2 > line_size
)
1020 line_size
= format_length
* 2;
1022 /* You don't have to copy. */
1024 linebuffer
= (char *) xmalloc (line_size
);
1028 /* This won't blow up if the restrictions described above are
1030 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1031 (void) vsprintf (linebuffer
, format
, args
);
1033 (void) sprintf (linebuffer
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
1036 fputs_filtered (linebuffer
, stream
);
1039 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1042 fprintf_filtered (va_alist
)
1050 stream
= va_arg (args
, FILE *);
1051 format
= va_arg (args
, char *);
1053 /* This won't blow up if the restrictions described above are
1055 (void) vfprintf_filtered (stream
, format
, args
);
1061 printf_filtered (va_alist
)
1068 format
= va_arg (args
, char *);
1070 (void) vfprintf_filtered (stdout
, format
, args
);
1075 printf_filtered (format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
)
1077 int arg1
, arg2
, arg3
, arg4
, arg5
, arg6
;
1079 fprintf_filtered (stdout
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
1086 puts_filtered (string
)
1089 fputs_filtered (string
, stdout
);
1092 /* Return a pointer to N spaces and a null. The pointer is good
1093 until the next call to here. */
1099 static char *spaces
;
1100 static int max_spaces
;
1106 spaces
= malloc (n
+1);
1107 for (t
= spaces
+n
; t
!= spaces
;)
1113 return spaces
+ max_spaces
- n
;
1116 /* Print N spaces. */
1118 print_spaces_filtered (n
, stream
)
1122 fputs_filtered (n_spaces (n
), stream
);
1125 /* C++ demangler stuff. */
1126 char *cplus_demangle ();
1128 /* Print NAME on STREAM, demangling if necessary. */
1130 fprint_symbol (stream
, name
)
1135 if ((!demangle
) || NULL
== (demangled
= cplus_demangle (name
, 1)))
1136 fputs_filtered (name
, stream
);
1139 fputs_filtered (demangled
, stream
);
1144 #if !defined (USG_UTILS)
1145 #define USG_UTILS defined (USG)
1149 bcopy (from
, to
, count
)
1152 memcpy (to
, from
, count
);
1155 bcmp (from
, to
, count
)
1157 return (memcmp (to
, from
, count
));
1170 getcwd (buf
, MAXPATHLEN
);
1178 return strchr (s
, c
);
1186 return strrchr (s
, c
);
1188 #endif /* USG_UTILS. */
1190 #if !defined (QUEUE_MISSING)
1191 #define QUEUE_MISSING defined (USG)
1195 /* Queue routines */
1202 insque (item
, after
)
1204 struct queue
*after
;
1206 item
->forw
= after
->forw
;
1207 after
->forw
->back
= item
;
1216 item
->forw
->back
= item
->back
;
1217 item
->back
->forw
= item
->forw
;
1219 #endif /* QUEUE_MISSING */
1222 /* Simple implementation of strstr, since some implementations lack it. */
1225 const char *in
, *find
;
1227 register const char *p
= in
- 1;
1229 while (0 != (p
= strchr (p
+1, *find
))) {
1230 if (strcmp (p
, find
))
1235 #endif /* do not HAVE_STRSTR */
1238 _initialize_utils ()
1240 struct cmd_list_element
*c
;
1242 c
= add_set_cmd ("width", class_support
, var_uinteger
,
1243 (char *)&chars_per_line
,
1244 "Set number of characters gdb thinks are in a line.",
1246 add_show_from_set (c
, &showlist
);
1247 c
->function
= set_width_command
;
1250 (add_set_cmd ("height", class_support
,
1251 var_uinteger
, (char *)&lines_per_page
,
1252 "Set number of lines gdb thinks are in a page.", &setlist
),
1255 /* These defaults will be used if we are unable to get the correct
1256 values from termcap. */
1257 lines_per_page
= 24;
1258 chars_per_line
= 80;
1259 /* Initialize the screen height and width from termcap. */
1261 char *termtype
= getenv ("TERM");
1263 /* Positive means success, nonpositive means failure. */
1266 /* 2048 is large enough for all known terminals, according to the
1267 GNU termcap manual. */
1268 char term_buffer
[2048];
1272 status
= tgetent (term_buffer
, termtype
);
1277 val
= tgetnum ("li");
1279 lines_per_page
= val
;
1281 /* The number of lines per page is not mentioned
1282 in the terminal description. This probably means
1283 that paging is not useful (e.g. emacs shell window),
1284 so disable paging. */
1285 lines_per_page
= UINT_MAX
;
1287 val
= tgetnum ("co");
1289 chars_per_line
= val
;
1294 set_width_command ((char *)NULL
, 0, c
);
1297 (add_set_cmd ("demangle", class_support
, var_boolean
,
1299 "Set demangling of encoded C++ names when displaying symbols.",
1304 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
1305 (char *)&sevenbit_strings
,
1306 "Set printing of 8-bit characters in strings as \\nnn.",
1311 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
1312 (char *)&asm_demangle
,
1313 "Set demangling of C++ names in disassembly listings.",
This page took 0.057011 seconds and 4 git commands to generate.