1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "dyn-string.h"
22 #include "gdb_assert.h"
24 #include "gdb_string.h"
26 #include "event-top.h"
27 #include "exceptions.h"
28 #include "gdbthread.h"
31 #ifdef HAVE_SYS_RESOURCE_H
32 #include <sys/resource.h>
33 #endif /* HAVE_SYS_RESOURCE_H */
36 #include "tui/tui.h" /* For tui_get_command_dimension. */
43 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
49 #include "timeval-utils.h"
54 #include "gdb-demangle.h"
55 #include "expression.h"
59 #include "filenames.h"
61 #include "gdb_obstack.h"
67 #include "inferior.h" /* for signed_pointer_to_address */
69 #include <sys/param.h> /* For MAXPATHLEN */
71 #include "gdb_curses.h"
73 #include "readline/readline.h"
78 #include "gdb_usleep.h"
80 #include "gdb_regex.h"
83 extern PTR
malloc (); /* ARI: PTR */
85 #if !HAVE_DECL_REALLOC
86 extern PTR
realloc (); /* ARI: PTR */
92 /* readline defines this. */
95 void (*deprecated_error_begin_hook
) (void);
97 /* Prototypes for local functions */
99 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
100 va_list, int) ATTRIBUTE_PRINTF (2, 0);
102 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
104 static void prompt_for_continue (void);
106 static void set_screen_size (void);
107 static void set_width (void);
109 /* A flag indicating whether to timestamp debugging messages. */
111 static int debug_timestamp
= 0;
113 /* Nonzero if we have job control. */
117 /* Nonzero means a quit has been requested. */
121 /* Nonzero means quit immediately if Control-C is typed now, rather
122 than waiting until QUIT is executed. Be careful in setting this;
123 code which executes with immediate_quit set has to be very careful
124 about being able to deal with being interrupted at any time. It is
125 almost always better to use QUIT; the only exception I can think of
126 is being able to quit out of a system call (using EINTR loses if
127 the SIGINT happens between the previous QUIT and the system call).
128 To immediately quit in the case in which a SIGINT happens between
129 the previous QUIT and setting immediate_quit (desirable anytime we
130 expect to block), call QUIT after setting immediate_quit. */
134 /* Nonzero means that strings with character values >0x7F should be printed
135 as octal escapes. Zero means just print the value (e.g. it's an
136 international character, and the terminal or window can cope.) */
138 int sevenbit_strings
= 0;
140 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
141 struct cmd_list_element
*c
, const char *value
)
143 fprintf_filtered (file
, _("Printing of 8-bit characters "
144 "in strings as \\nnn is %s.\n"),
148 /* String to be printed before error messages, if any. */
150 char *error_pre_print
;
152 /* String to be printed before quit messages, if any. */
154 char *quit_pre_print
;
156 /* String to be printed before warning messages, if any. */
158 char *warning_pre_print
= "\nwarning: ";
160 int pagination_enabled
= 1;
162 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
163 struct cmd_list_element
*c
, const char *value
)
165 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
169 /* Cleanup utilities.
171 These are not defined in cleanups.c (nor declared in cleanups.h)
172 because while they use the "cleanup API" they are not part of the
176 do_freeargv (void *arg
)
178 freeargv ((char **) arg
);
182 make_cleanup_freeargv (char **arg
)
184 return make_cleanup (do_freeargv
, arg
);
188 do_dyn_string_delete (void *arg
)
190 dyn_string_delete ((dyn_string_t
) arg
);
194 make_cleanup_dyn_string_delete (dyn_string_t arg
)
196 return make_cleanup (do_dyn_string_delete
, arg
);
200 do_bfd_close_cleanup (void *arg
)
206 make_cleanup_bfd_unref (bfd
*abfd
)
208 return make_cleanup (do_bfd_close_cleanup
, abfd
);
212 do_close_cleanup (void *arg
)
220 make_cleanup_close (int fd
)
222 int *saved_fd
= xmalloc (sizeof (fd
));
225 return make_cleanup_dtor (do_close_cleanup
, saved_fd
, xfree
);
228 /* Helper function which does the work for make_cleanup_fclose. */
231 do_fclose_cleanup (void *arg
)
238 /* Return a new cleanup that closes FILE. */
241 make_cleanup_fclose (FILE *file
)
243 return make_cleanup (do_fclose_cleanup
, file
);
246 /* Helper function which does the work for make_cleanup_obstack_free. */
249 do_obstack_free (void *arg
)
251 struct obstack
*ob
= arg
;
253 obstack_free (ob
, NULL
);
256 /* Return a new cleanup that frees OBSTACK. */
259 make_cleanup_obstack_free (struct obstack
*obstack
)
261 return make_cleanup (do_obstack_free
, obstack
);
265 do_ui_file_delete (void *arg
)
267 ui_file_delete (arg
);
271 make_cleanup_ui_file_delete (struct ui_file
*arg
)
273 return make_cleanup (do_ui_file_delete
, arg
);
276 /* Helper function for make_cleanup_ui_out_redirect_pop. */
279 do_ui_out_redirect_pop (void *arg
)
281 struct ui_out
*uiout
= arg
;
283 if (ui_out_redirect (uiout
, NULL
) < 0)
284 warning (_("Cannot restore redirection of the current output protocol"));
287 /* Return a new cleanup that pops the last redirection by ui_out_redirect
288 with NULL parameter. */
291 make_cleanup_ui_out_redirect_pop (struct ui_out
*uiout
)
293 return make_cleanup (do_ui_out_redirect_pop
, uiout
);
297 do_free_section_addr_info (void *arg
)
299 free_section_addr_info (arg
);
303 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
305 return make_cleanup (do_free_section_addr_info
, addrs
);
308 struct restore_integer_closure
315 restore_integer (void *p
)
317 struct restore_integer_closure
*closure
= p
;
319 *(closure
->variable
) = closure
->value
;
322 /* Remember the current value of *VARIABLE and make it restored when
323 the cleanup is run. */
326 make_cleanup_restore_integer (int *variable
)
328 struct restore_integer_closure
*c
=
329 xmalloc (sizeof (struct restore_integer_closure
));
331 c
->variable
= variable
;
332 c
->value
= *variable
;
334 return make_cleanup_dtor (restore_integer
, (void *) c
, xfree
);
337 /* Remember the current value of *VARIABLE and make it restored when
338 the cleanup is run. */
341 make_cleanup_restore_uinteger (unsigned int *variable
)
343 return make_cleanup_restore_integer ((int *) variable
);
346 /* Helper for make_cleanup_unpush_target. */
349 do_unpush_target (void *arg
)
351 struct target_ops
*ops
= arg
;
356 /* Return a new cleanup that unpushes OPS. */
359 make_cleanup_unpush_target (struct target_ops
*ops
)
361 return make_cleanup (do_unpush_target
, ops
);
364 /* Helper for make_cleanup_htab_delete compile time checking the types. */
367 do_htab_delete_cleanup (void *htab_voidp
)
369 htab_t htab
= htab_voidp
;
374 /* Return a new cleanup that deletes HTAB. */
377 make_cleanup_htab_delete (htab_t htab
)
379 return make_cleanup (do_htab_delete_cleanup
, htab
);
382 struct restore_ui_file_closure
384 struct ui_file
**variable
;
385 struct ui_file
*value
;
389 do_restore_ui_file (void *p
)
391 struct restore_ui_file_closure
*closure
= p
;
393 *(closure
->variable
) = closure
->value
;
396 /* Remember the current value of *VARIABLE and make it restored when
397 the cleanup is run. */
400 make_cleanup_restore_ui_file (struct ui_file
**variable
)
402 struct restore_ui_file_closure
*c
= XNEW (struct restore_ui_file_closure
);
404 c
->variable
= variable
;
405 c
->value
= *variable
;
407 return make_cleanup_dtor (do_restore_ui_file
, (void *) c
, xfree
);
410 /* Helper for make_cleanup_value_free_to_mark. */
413 do_value_free_to_mark (void *value
)
415 value_free_to_mark ((struct value
*) value
);
418 /* Free all values allocated since MARK was obtained by value_mark
419 (except for those released) when the cleanup is run. */
422 make_cleanup_value_free_to_mark (struct value
*mark
)
424 return make_cleanup (do_value_free_to_mark
, mark
);
427 /* Helper for make_cleanup_value_free. */
430 do_value_free (void *value
)
438 make_cleanup_value_free (struct value
*value
)
440 return make_cleanup (do_value_free
, value
);
443 /* Helper for make_cleanup_free_so. */
446 do_free_so (void *arg
)
448 struct so_list
*so
= arg
;
453 /* Make cleanup handler calling free_so for SO. */
456 make_cleanup_free_so (struct so_list
*so
)
458 return make_cleanup (do_free_so
, so
);
461 /* This function is useful for cleanups.
465 old_chain = make_cleanup (free_current_contents, &foo);
467 to arrange to free the object thus allocated. */
470 free_current_contents (void *ptr
)
472 void **location
= ptr
;
474 if (location
== NULL
)
475 internal_error (__FILE__
, __LINE__
,
476 _("free_current_contents: NULL pointer"));
477 if (*location
!= NULL
)
484 /* If nonzero, display time usage both at startup and for each command. */
486 static int display_time
;
488 /* If nonzero, display space usage both at startup and for each command. */
490 static int display_space
;
492 /* Records a run time and space usage to be used as a base for
493 reporting elapsed time or change in space. In addition,
494 the msg_type field indicates whether the saved time is from the
495 beginning of GDB execution (0) or the beginning of an individual
496 command execution (1). */
501 struct timeval start_wall_time
;
505 /* Set whether to display time statistics to NEW_VALUE (non-zero
508 set_display_time (int new_value
)
510 display_time
= new_value
;
513 /* Set whether to display space statistics to NEW_VALUE (non-zero
516 set_display_space (int new_value
)
518 display_space
= new_value
;
521 /* As indicated by display_time and display_space, report GDB's elapsed time
522 and space usage from the base time and space provided in ARG, which
523 must be a pointer to a struct cmd_stat. This function is intended
524 to be called as a cleanup. */
526 report_command_stats (void *arg
)
528 struct cmd_stats
*start_stats
= (struct cmd_stats
*) arg
;
529 int msg_type
= start_stats
->msg_type
;
533 long cmd_time
= get_run_time () - start_stats
->start_cpu_time
;
534 struct timeval now_wall_time
, delta_wall_time
;
536 gettimeofday (&now_wall_time
, NULL
);
537 timeval_sub (&delta_wall_time
,
538 &now_wall_time
, &start_stats
->start_wall_time
);
540 printf_unfiltered (msg_type
== 0
541 ? _("Startup time: %ld.%06ld (cpu), %ld.%06ld (wall)\n")
542 : _("Command execution time: %ld.%06ld (cpu), %ld.%06ld (wall)\n"),
543 cmd_time
/ 1000000, cmd_time
% 1000000,
544 (long) delta_wall_time
.tv_sec
,
545 (long) delta_wall_time
.tv_usec
);
551 char *lim
= (char *) sbrk (0);
553 long space_now
= lim
- lim_at_start
;
554 long space_diff
= space_now
- start_stats
->start_space
;
556 printf_unfiltered (msg_type
== 0
557 ? _("Space used: %ld (%s%ld during startup)\n")
558 : _("Space used: %ld (%s%ld for this command)\n"),
560 (space_diff
>= 0 ? "+" : ""),
566 /* Create a cleanup that reports time and space used since its
567 creation. Precise messages depend on MSG_TYPE:
568 0: Initial time/space
569 1: Individual command time/space. */
571 make_command_stats_cleanup (int msg_type
)
573 struct cmd_stats
*new_stat
= XMALLOC (struct cmd_stats
);
576 char *lim
= (char *) sbrk (0);
577 new_stat
->start_space
= lim
- lim_at_start
;
580 new_stat
->msg_type
= msg_type
;
581 new_stat
->start_cpu_time
= get_run_time ();
582 gettimeofday (&new_stat
->start_wall_time
, NULL
);
584 return make_cleanup_dtor (report_command_stats
, new_stat
, xfree
);
589 /* Print a warning message. The first argument STRING is the warning
590 message, used as an fprintf format string, the second is the
591 va_list of arguments for that string. A warning is unfiltered (not
592 paginated) so that the user does not need to page through each
593 screen full of warnings when there are lots of them. */
596 vwarning (const char *string
, va_list args
)
598 if (deprecated_warning_hook
)
599 (*deprecated_warning_hook
) (string
, args
);
602 target_terminal_ours ();
603 wrap_here (""); /* Force out any buffered output. */
604 gdb_flush (gdb_stdout
);
605 if (warning_pre_print
)
606 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
607 vfprintf_unfiltered (gdb_stderr
, string
, args
);
608 fprintf_unfiltered (gdb_stderr
, "\n");
613 /* Print a warning message.
614 The first argument STRING is the warning message, used as a fprintf string,
615 and the remaining args are passed as arguments to it.
616 The primary difference between warnings and errors is that a warning
617 does not force the return to command level. */
620 warning (const char *string
, ...)
624 va_start (args
, string
);
625 vwarning (string
, args
);
629 /* Print an error message and return to command level.
630 The first argument STRING is the error message, used as a fprintf string,
631 and the remaining args are passed as arguments to it. */
634 verror (const char *string
, va_list args
)
636 throw_verror (GENERIC_ERROR
, string
, args
);
640 error (const char *string
, ...)
644 va_start (args
, string
);
645 throw_verror (GENERIC_ERROR
, string
, args
);
649 /* Print an error message and quit.
650 The first argument STRING is the error message, used as a fprintf string,
651 and the remaining args are passed as arguments to it. */
654 vfatal (const char *string
, va_list args
)
656 throw_vfatal (string
, args
);
660 fatal (const char *string
, ...)
664 va_start (args
, string
);
665 throw_vfatal (string
, args
);
670 error_stream (struct ui_file
*stream
)
672 char *message
= ui_file_xstrdup (stream
, NULL
);
674 make_cleanup (xfree
, message
);
675 error (("%s"), message
);
678 /* Dump core trying to increase the core soft limit to hard limit first. */
683 #ifdef HAVE_SETRLIMIT
684 struct rlimit rlim
= { RLIM_INFINITY
, RLIM_INFINITY
};
686 setrlimit (RLIMIT_CORE
, &rlim
);
687 #endif /* HAVE_SETRLIMIT */
689 abort (); /* NOTE: GDB has only three calls to abort(). */
692 /* Check whether GDB will be able to dump core using the dump_core
696 can_dump_core (const char *reason
)
698 #ifdef HAVE_GETRLIMIT
701 /* Be quiet and assume we can dump if an error is returned. */
702 if (getrlimit (RLIMIT_CORE
, &rlim
) != 0)
705 if (rlim
.rlim_max
== 0)
707 fprintf_unfiltered (gdb_stderr
,
708 _("%s\nUnable to dump core, use `ulimit -c"
709 " unlimited' before executing GDB next time.\n"),
713 #endif /* HAVE_GETRLIMIT */
718 /* Allow the user to configure the debugger behavior with respect to
719 what to do when an internal problem is detected. */
721 const char internal_problem_ask
[] = "ask";
722 const char internal_problem_yes
[] = "yes";
723 const char internal_problem_no
[] = "no";
724 static const char *const internal_problem_modes
[] =
726 internal_problem_ask
,
727 internal_problem_yes
,
732 /* Print a message reporting an internal error/warning. Ask the user
733 if they want to continue, dump core, or just exit. Return
734 something to indicate a quit. */
736 struct internal_problem
739 const char *should_quit
;
740 const char *should_dump_core
;
743 /* Report a problem, internal to GDB, to the user. Once the problem
744 has been reported, and assuming GDB didn't quit, the caller can
745 either allow execution to resume or throw an error. */
747 static void ATTRIBUTE_PRINTF (4, 0)
748 internal_vproblem (struct internal_problem
*problem
,
749 const char *file
, int line
, const char *fmt
, va_list ap
)
756 /* Don't allow infinite error/warning recursion. */
758 static char msg
[] = "Recursive internal problem.\n";
767 fputs_unfiltered (msg
, gdb_stderr
);
768 abort (); /* NOTE: GDB has only three calls to abort(). */
771 /* Newer GLIBC versions put the warn_unused_result attribute
772 on write, but this is one of those rare cases where
773 ignoring the return value is correct. Casting to (void)
774 does not fix this problem. This is the solution suggested
775 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
776 if (write (STDERR_FILENO
, msg
, sizeof (msg
)) != sizeof (msg
))
777 abort (); /* NOTE: GDB has only three calls to abort(). */
782 /* Try to get the message out and at the start of a new line. */
783 target_terminal_ours ();
786 /* Create a string containing the full error/warning message. Need
787 to call query with this full string, as otherwize the reason
788 (error/warning) and question become separated. Format using a
789 style similar to a compiler error message. Include extra detail
790 so that the user knows that they are living on the edge. */
794 msg
= xstrvprintf (fmt
, ap
);
795 reason
= xstrprintf ("%s:%d: %s: %s\n"
796 "A problem internal to GDB has been detected,\n"
797 "further debugging may prove unreliable.",
798 file
, line
, problem
->name
, msg
);
800 make_cleanup (xfree
, reason
);
803 if (problem
->should_quit
== internal_problem_ask
)
805 /* Default (yes/batch case) is to quit GDB. When in batch mode
806 this lessens the likelihood of GDB going into an infinite
810 /* Emit the message and quit. */
811 fputs_unfiltered (reason
, gdb_stderr
);
812 fputs_unfiltered ("\n", gdb_stderr
);
816 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
818 else if (problem
->should_quit
== internal_problem_yes
)
820 else if (problem
->should_quit
== internal_problem_no
)
823 internal_error (__FILE__
, __LINE__
, _("bad switch"));
825 if (problem
->should_dump_core
== internal_problem_ask
)
827 if (!can_dump_core (reason
))
831 /* Default (yes/batch case) is to dump core. This leaves a GDB
832 `dropping' so that it is easier to see that something went
834 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
837 else if (problem
->should_dump_core
== internal_problem_yes
)
838 dump_core_p
= can_dump_core (reason
);
839 else if (problem
->should_dump_core
== internal_problem_no
)
842 internal_error (__FILE__
, __LINE__
, _("bad switch"));
855 #ifdef HAVE_WORKING_FORK
865 static struct internal_problem internal_error_problem
= {
866 "internal-error", internal_problem_ask
, internal_problem_ask
870 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
872 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
873 deprecated_throw_reason (RETURN_ERROR
);
877 internal_error (const char *file
, int line
, const char *string
, ...)
881 va_start (ap
, string
);
882 internal_verror (file
, line
, string
, ap
);
886 static struct internal_problem internal_warning_problem
= {
887 "internal-warning", internal_problem_ask
, internal_problem_ask
891 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
893 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
897 internal_warning (const char *file
, int line
, const char *string
, ...)
901 va_start (ap
, string
);
902 internal_vwarning (file
, line
, string
, ap
);
906 /* Dummy functions to keep add_prefix_cmd happy. */
909 set_internal_problem_cmd (char *args
, int from_tty
)
914 show_internal_problem_cmd (char *args
, int from_tty
)
918 /* When GDB reports an internal problem (error or warning) it gives
919 the user the opportunity to quit GDB and/or create a core file of
920 the current debug session. This function registers a few commands
921 that make it possible to specify that GDB should always or never
922 quit or create a core file, without asking. The commands look
925 maint set PROBLEM-NAME quit ask|yes|no
926 maint show PROBLEM-NAME quit
927 maint set PROBLEM-NAME corefile ask|yes|no
928 maint show PROBLEM-NAME corefile
930 Where PROBLEM-NAME is currently "internal-error" or
931 "internal-warning". */
934 add_internal_problem_command (struct internal_problem
*problem
)
936 struct cmd_list_element
**set_cmd_list
;
937 struct cmd_list_element
**show_cmd_list
;
941 set_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
942 show_cmd_list
= xmalloc (sizeof (*set_cmd_list
));
943 *set_cmd_list
= NULL
;
944 *show_cmd_list
= NULL
;
946 set_doc
= xstrprintf (_("Configure what GDB does when %s is detected."),
949 show_doc
= xstrprintf (_("Show what GDB does when %s is detected."),
952 add_prefix_cmd ((char*) problem
->name
,
953 class_maintenance
, set_internal_problem_cmd
, set_doc
,
955 concat ("maintenance set ", problem
->name
, " ",
957 0/*allow-unknown*/, &maintenance_set_cmdlist
);
959 add_prefix_cmd ((char*) problem
->name
,
960 class_maintenance
, show_internal_problem_cmd
, show_doc
,
962 concat ("maintenance show ", problem
->name
, " ",
964 0/*allow-unknown*/, &maintenance_show_cmdlist
);
966 set_doc
= xstrprintf (_("Set whether GDB should quit "
967 "when an %s is detected"),
969 show_doc
= xstrprintf (_("Show whether GDB will quit "
970 "when an %s is detected"),
972 add_setshow_enum_cmd ("quit", class_maintenance
,
973 internal_problem_modes
,
974 &problem
->should_quit
,
986 set_doc
= xstrprintf (_("Set whether GDB should create a core "
987 "file of GDB when %s is detected"),
989 show_doc
= xstrprintf (_("Show whether GDB will create a core "
990 "file of GDB when %s is detected"),
992 add_setshow_enum_cmd ("corefile", class_maintenance
,
993 internal_problem_modes
,
994 &problem
->should_dump_core
,
1007 /* Print the system error message for errno, and also mention STRING
1008 as the file name for which the error was encountered.
1009 Then return to command level. */
1012 perror_with_name (const char *string
)
1017 err
= safe_strerror (errno
);
1018 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1019 strcpy (combined
, string
);
1020 strcat (combined
, ": ");
1021 strcat (combined
, err
);
1023 /* I understand setting these is a matter of taste. Still, some people
1024 may clear errno but not know about bfd_error. Doing this here is not
1026 bfd_set_error (bfd_error_no_error
);
1029 error (_("%s."), combined
);
1032 /* Print the system error message for ERRCODE, and also mention STRING
1033 as the file name for which the error was encountered. */
1036 print_sys_errmsg (const char *string
, int errcode
)
1041 err
= safe_strerror (errcode
);
1042 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
1043 strcpy (combined
, string
);
1044 strcat (combined
, ": ");
1045 strcat (combined
, err
);
1047 /* We want anything which was printed on stdout to come out first, before
1049 gdb_flush (gdb_stdout
);
1050 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
1053 /* Control C eventually causes this to be called, at a convenient time. */
1059 /* No steenking SIGINT will ever be coming our way when the
1060 program is resumed. Don't lie. */
1064 /* If there is no terminal switching for this target, then we can't
1065 possibly get screwed by the lack of job control. */
1066 || current_target
.to_terminal_ours
== NULL
)
1069 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1074 /* Called when a memory allocation fails, with the number of bytes of
1075 memory requested in SIZE. */
1078 malloc_failure (long size
)
1082 internal_error (__FILE__
, __LINE__
,
1083 _("virtual memory exhausted: can't allocate %ld bytes."),
1088 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
1092 /* My replacement for the read system call.
1093 Used like `read' but keeps going if `read' returns too soon. */
1096 myread (int desc
, char *addr
, int len
)
1103 val
= read (desc
, addr
, len
);
1107 return orglen
- len
;
1114 /* Make a copy of the string at PTR with SIZE characters
1115 (and add a null character at the end in the copy).
1116 Uses malloc to get the space. Returns the address of the copy. */
1119 savestring (const char *ptr
, size_t size
)
1121 char *p
= (char *) xmalloc (size
+ 1);
1123 memcpy (p
, ptr
, size
);
1129 print_spaces (int n
, struct ui_file
*file
)
1131 fputs_unfiltered (n_spaces (n
), file
);
1134 /* Print a host address. */
1137 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1139 fprintf_filtered (stream
, "%s", host_address_to_string (addr
));
1143 /* A cleanup function that calls regfree. */
1146 do_regfree_cleanup (void *r
)
1151 /* Create a new cleanup that frees the compiled regular expression R. */
1154 make_regfree_cleanup (regex_t
*r
)
1156 return make_cleanup (do_regfree_cleanup
, r
);
1159 /* Return an xmalloc'd error message resulting from a regular
1160 expression compilation failure. */
1163 get_regcomp_error (int code
, regex_t
*rx
)
1165 size_t length
= regerror (code
, rx
, NULL
, 0);
1166 char *result
= xmalloc (length
);
1168 regerror (code
, rx
, result
, length
);
1174 /* This function supports the query, nquery, and yquery functions.
1175 Ask user a y-or-n question and return 0 if answer is no, 1 if
1176 answer is yes, or default the answer to the specified default
1177 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1178 default answer, or '\0' for no default.
1179 CTLSTR is the control string and should end in "? ". It should
1180 not say how to answer, because we do that.
1181 ARGS are the arguments passed along with the CTLSTR argument to
1184 static int ATTRIBUTE_PRINTF (1, 0)
1185 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1191 char def_answer
, not_def_answer
;
1192 char *y_string
, *n_string
, *question
;
1194 /* Set up according to which answer is the default. */
1195 if (defchar
== '\0')
1199 not_def_answer
= 'N';
1203 else if (defchar
== 'y')
1207 not_def_answer
= 'N';
1215 not_def_answer
= 'Y';
1220 /* Automatically answer the default value if the user did not want
1221 prompts or the command was issued with the server prefix. */
1222 if (!confirm
|| server_command
)
1225 /* If input isn't coming from the user directly, just say what
1226 question we're asking, and then answer the default automatically. This
1227 way, important error messages don't get lost when talking to GDB
1229 if (! input_from_terminal_p ())
1232 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1234 printf_filtered (_("(%s or %s) [answered %c; "
1235 "input not from terminal]\n"),
1236 y_string
, n_string
, def_answer
);
1237 gdb_flush (gdb_stdout
);
1242 if (deprecated_query_hook
)
1244 return deprecated_query_hook (ctlstr
, args
);
1247 /* Format the question outside of the loop, to avoid reusing args. */
1248 question
= xstrvprintf (ctlstr
, args
);
1252 wrap_here (""); /* Flush any buffered output. */
1253 gdb_flush (gdb_stdout
);
1255 if (annotation_level
> 1)
1256 printf_filtered (("\n\032\032pre-query\n"));
1258 fputs_filtered (question
, gdb_stdout
);
1259 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1261 if (annotation_level
> 1)
1262 printf_filtered (("\n\032\032query\n"));
1265 gdb_flush (gdb_stdout
);
1267 answer
= fgetc (stdin
);
1269 /* We expect fgetc to block until a character is read. But
1270 this may not be the case if the terminal was opened with
1271 the NONBLOCK flag. In that case, if there is nothing to
1272 read on stdin, fgetc returns EOF, but also sets the error
1273 condition flag on stdin and errno to EAGAIN. With a true
1274 EOF, stdin's error condition flag is not set.
1276 A situation where this behavior was observed is a pseudo
1278 while (answer
== EOF
&& ferror (stdin
) && errno
== EAGAIN
)
1280 /* Not a real EOF. Wait a little while and try again until
1281 we read something. */
1284 answer
= fgetc (stdin
);
1287 clearerr (stdin
); /* in case of C-d */
1288 if (answer
== EOF
) /* C-d */
1290 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1294 /* Eat rest of input line, to EOF or newline. */
1298 ans2
= fgetc (stdin
);
1301 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1305 /* Check answer. For the non-default, the user must specify
1306 the non-default explicitly. */
1307 if (answer
== not_def_answer
)
1309 retval
= !def_value
;
1312 /* Otherwise, if a default was specified, the user may either
1313 specify the required input or have it default by entering
1315 if (answer
== def_answer
1316 || (defchar
!= '\0' &&
1317 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1322 /* Invalid entries are not defaulted and require another selection. */
1323 printf_filtered (_("Please answer %s or %s.\n"),
1324 y_string
, n_string
);
1328 if (annotation_level
> 1)
1329 printf_filtered (("\n\032\032post-query\n"));
1334 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1335 answer is yes, or 0 if answer is defaulted.
1336 Takes three args which are given to printf to print the question.
1337 The first, a control string, should end in "? ".
1338 It should not say how to answer, because we do that. */
1341 nquery (const char *ctlstr
, ...)
1346 va_start (args
, ctlstr
);
1347 ret
= defaulted_query (ctlstr
, 'n', args
);
1352 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1353 answer is yes, or 1 if answer is defaulted.
1354 Takes three args which are given to printf to print the question.
1355 The first, a control string, should end in "? ".
1356 It should not say how to answer, because we do that. */
1359 yquery (const char *ctlstr
, ...)
1364 va_start (args
, ctlstr
);
1365 ret
= defaulted_query (ctlstr
, 'y', args
);
1370 /* Ask user a y-or-n question and return 1 iff answer is yes.
1371 Takes three args which are given to printf to print the question.
1372 The first, a control string, should end in "? ".
1373 It should not say how to answer, because we do that. */
1376 query (const char *ctlstr
, ...)
1381 va_start (args
, ctlstr
);
1382 ret
= defaulted_query (ctlstr
, '\0', args
);
1387 /* A helper for parse_escape that converts a host character to a
1388 target character. C is the host character. If conversion is
1389 possible, then the target character is stored in *TARGET_C and the
1390 function returns 1. Otherwise, the function returns 0. */
1393 host_char_to_target (struct gdbarch
*gdbarch
, int c
, int *target_c
)
1395 struct obstack host_data
;
1397 struct cleanup
*cleanups
;
1400 obstack_init (&host_data
);
1401 cleanups
= make_cleanup_obstack_free (&host_data
);
1403 convert_between_encodings (target_charset (gdbarch
), host_charset (),
1404 &the_char
, 1, 1, &host_data
, translit_none
);
1406 if (obstack_object_size (&host_data
) == 1)
1409 *target_c
= *(char *) obstack_base (&host_data
);
1412 do_cleanups (cleanups
);
1416 /* Parse a C escape sequence. STRING_PTR points to a variable
1417 containing a pointer to the string to parse. That pointer
1418 should point to the character after the \. That pointer
1419 is updated past the characters we use. The value of the
1420 escape sequence is returned.
1422 A negative value means the sequence \ newline was seen,
1423 which is supposed to be equivalent to nothing at all.
1425 If \ is followed by a null character, we return a negative
1426 value and leave the string pointer pointing at the null character.
1428 If \ is followed by 000, we return 0 and leave the string pointer
1429 after the zeros. A value of 0 does not mean end of string. */
1432 parse_escape (struct gdbarch
*gdbarch
, char **string_ptr
)
1434 int target_char
= -2; /* Initialize to avoid GCC warnings. */
1435 int c
= *(*string_ptr
)++;
1454 int i
= host_hex_value (c
);
1459 if (isdigit (c
) && c
!= '8' && c
!= '9')
1463 i
+= host_hex_value (c
);
1499 if (!host_char_to_target (gdbarch
, c
, &target_char
))
1500 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1501 " which has no equivalent\nin the `%s' character set."),
1502 c
, c
, target_charset (gdbarch
));
1506 /* Print the character C on STREAM as part of the contents of a literal
1507 string whose delimiter is QUOTER. Note that this routine should only
1508 be call for printing things which are independent of the language
1509 of the program being debugged. */
1512 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1513 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1514 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1516 c
&= 0xFF; /* Avoid sign bit follies */
1518 if (c
< 0x20 || /* Low control chars */
1519 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1520 (sevenbit_strings
&& c
>= 0x80))
1521 { /* high order bit set */
1525 do_fputs ("\\n", stream
);
1528 do_fputs ("\\b", stream
);
1531 do_fputs ("\\t", stream
);
1534 do_fputs ("\\f", stream
);
1537 do_fputs ("\\r", stream
);
1540 do_fputs ("\\e", stream
);
1543 do_fputs ("\\a", stream
);
1546 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1552 if (c
== '\\' || c
== quoter
)
1553 do_fputs ("\\", stream
);
1554 do_fprintf (stream
, "%c", c
);
1558 /* Print the character C on STREAM as part of the contents of a
1559 literal string whose delimiter is QUOTER. Note that these routines
1560 should only be call for printing things which are independent of
1561 the language of the program being debugged. */
1564 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1567 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1571 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1574 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1578 fputstrn_filtered (const char *str
, int n
, int quoter
,
1579 struct ui_file
*stream
)
1583 for (i
= 0; i
< n
; i
++)
1584 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1588 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1589 struct ui_file
*stream
)
1593 for (i
= 0; i
< n
; i
++)
1594 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1598 /* Number of lines per page or UINT_MAX if paging is disabled. */
1599 static unsigned int lines_per_page
;
1601 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1602 struct cmd_list_element
*c
, const char *value
)
1604 fprintf_filtered (file
,
1605 _("Number of lines gdb thinks are in a page is %s.\n"),
1609 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1610 static unsigned int chars_per_line
;
1612 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1613 struct cmd_list_element
*c
, const char *value
)
1615 fprintf_filtered (file
,
1616 _("Number of characters gdb thinks "
1617 "are in a line is %s.\n"),
1621 /* Current count of lines printed on this page, chars on this line. */
1622 static unsigned int lines_printed
, chars_printed
;
1624 /* Buffer and start column of buffered text, for doing smarter word-
1625 wrapping. When someone calls wrap_here(), we start buffering output
1626 that comes through fputs_filtered(). If we see a newline, we just
1627 spit it out and forget about the wrap_here(). If we see another
1628 wrap_here(), we spit it out and remember the newer one. If we see
1629 the end of the line, we spit out a newline, the indent, and then
1630 the buffered output. */
1632 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1633 are waiting to be output (they have already been counted in chars_printed).
1634 When wrap_buffer[0] is null, the buffer is empty. */
1635 static char *wrap_buffer
;
1637 /* Pointer in wrap_buffer to the next character to fill. */
1638 static char *wrap_pointer
;
1640 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1642 static char *wrap_indent
;
1644 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1645 is not in effect. */
1646 static int wrap_column
;
1649 /* Inialize the number of lines per page and chars per line. */
1652 init_page_info (void)
1656 lines_per_page
= UINT_MAX
;
1657 chars_per_line
= UINT_MAX
;
1661 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1666 #if defined(__GO32__)
1667 rows
= ScreenRows ();
1668 cols
= ScreenCols ();
1669 lines_per_page
= rows
;
1670 chars_per_line
= cols
;
1672 /* Make sure Readline has initialized its terminal settings. */
1673 rl_reset_terminal (NULL
);
1675 /* Get the screen size from Readline. */
1676 rl_get_screen_size (&rows
, &cols
);
1677 lines_per_page
= rows
;
1678 chars_per_line
= cols
;
1680 /* Readline should have fetched the termcap entry for us. */
1681 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1683 /* The number of lines per page is not mentioned in the
1684 terminal description. This probably means that paging is
1685 not useful (e.g. emacs shell window), so disable paging. */
1686 lines_per_page
= UINT_MAX
;
1689 /* FIXME: Get rid of this junk. */
1690 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1691 SIGWINCH_HANDLER (SIGWINCH
);
1694 /* If the output is not a terminal, don't paginate it. */
1695 if (!ui_file_isatty (gdb_stdout
))
1696 lines_per_page
= UINT_MAX
;
1704 /* Helper for make_cleanup_restore_page_info. */
1707 do_restore_page_info_cleanup (void *arg
)
1713 /* Provide cleanup for restoring the terminal size. */
1716 make_cleanup_restore_page_info (void)
1718 struct cleanup
*back_to
;
1720 back_to
= make_cleanup (do_restore_page_info_cleanup
, NULL
);
1721 make_cleanup_restore_uinteger (&lines_per_page
);
1722 make_cleanup_restore_uinteger (&chars_per_line
);
1727 /* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1728 Provide cleanup for restoring the original state. */
1731 set_batch_flag_and_make_cleanup_restore_page_info (void)
1733 struct cleanup
*back_to
= make_cleanup_restore_page_info ();
1735 make_cleanup_restore_integer (&batch_flag
);
1742 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1745 set_screen_size (void)
1747 int rows
= lines_per_page
;
1748 int cols
= chars_per_line
;
1756 /* Update Readline's idea of the terminal size. */
1757 rl_set_screen_size (rows
, cols
);
1760 /* Reinitialize WRAP_BUFFER according to the current value of
1766 if (chars_per_line
== 0)
1771 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1772 wrap_buffer
[0] = '\0';
1775 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1776 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1780 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1787 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1792 /* Wait, so the user can read what's on the screen. Prompt the user
1793 to continue by pressing RETURN. */
1796 prompt_for_continue (void)
1799 char cont_prompt
[120];
1801 if (annotation_level
> 1)
1802 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1804 strcpy (cont_prompt
,
1805 "---Type <return> to continue, or q <return> to quit---");
1806 if (annotation_level
> 1)
1807 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1809 /* We must do this *before* we call gdb_readline, else it will eventually
1810 call us -- thinking that we're trying to print beyond the end of the
1812 reinitialize_more_filter ();
1815 /* On a real operating system, the user can quit with SIGINT.
1818 'q' is provided on all systems so users don't have to change habits
1819 from system to system, and because telling them what to do in
1820 the prompt is more user-friendly than expecting them to think of
1822 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1823 whereas control-C to gdb_readline will cause the user to get dumped
1825 ignore
= gdb_readline_wrapper (cont_prompt
);
1827 if (annotation_level
> 1)
1828 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1834 while (*p
== ' ' || *p
== '\t')
1837 async_request_quit (0);
1842 /* Now we have to do this again, so that GDB will know that it doesn't
1843 need to save the ---Type <return>--- line at the top of the screen. */
1844 reinitialize_more_filter ();
1846 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1849 /* Reinitialize filter; ie. tell it to reset to original values. */
1852 reinitialize_more_filter (void)
1858 /* Indicate that if the next sequence of characters overflows the line,
1859 a newline should be inserted here rather than when it hits the end.
1860 If INDENT is non-null, it is a string to be printed to indent the
1861 wrapped part on the next line. INDENT must remain accessible until
1862 the next call to wrap_here() or until a newline is printed through
1865 If the line is already overfull, we immediately print a newline and
1866 the indentation, and disable further wrapping.
1868 If we don't know the width of lines, but we know the page height,
1869 we must not wrap words, but should still keep track of newlines
1870 that were explicitly printed.
1872 INDENT should not contain tabs, as that will mess up the char count
1873 on the next line. FIXME.
1875 This routine is guaranteed to force out any output which has been
1876 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1877 used to force out output from the wrap_buffer. */
1880 wrap_here (char *indent
)
1882 /* This should have been allocated, but be paranoid anyway. */
1884 internal_error (__FILE__
, __LINE__
,
1885 _("failed internal consistency check"));
1889 *wrap_pointer
= '\0';
1890 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1892 wrap_pointer
= wrap_buffer
;
1893 wrap_buffer
[0] = '\0';
1894 if (chars_per_line
== UINT_MAX
) /* No line overflow checking. */
1898 else if (chars_printed
>= chars_per_line
)
1900 puts_filtered ("\n");
1902 puts_filtered (indent
);
1907 wrap_column
= chars_printed
;
1911 wrap_indent
= indent
;
1915 /* Print input string to gdb_stdout, filtered, with wrap,
1916 arranging strings in columns of n chars. String can be
1917 right or left justified in the column. Never prints
1918 trailing spaces. String should never be longer than
1919 width. FIXME: this could be useful for the EXAMINE
1920 command, which currently doesn't tabulate very well. */
1923 puts_filtered_tabular (char *string
, int width
, int right
)
1929 gdb_assert (chars_per_line
> 0);
1930 if (chars_per_line
== UINT_MAX
)
1932 fputs_filtered (string
, gdb_stdout
);
1933 fputs_filtered ("\n", gdb_stdout
);
1937 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1938 fputs_filtered ("\n", gdb_stdout
);
1940 if (width
>= chars_per_line
)
1941 width
= chars_per_line
- 1;
1943 stringlen
= strlen (string
);
1945 if (chars_printed
> 0)
1946 spaces
= width
- (chars_printed
- 1) % width
- 1;
1948 spaces
+= width
- stringlen
;
1950 spacebuf
= alloca (spaces
+ 1);
1951 spacebuf
[spaces
] = '\0';
1953 spacebuf
[spaces
] = ' ';
1955 fputs_filtered (spacebuf
, gdb_stdout
);
1956 fputs_filtered (string
, gdb_stdout
);
1960 /* Ensure that whatever gets printed next, using the filtered output
1961 commands, starts at the beginning of the line. I.e. if there is
1962 any pending output for the current line, flush it and start a new
1963 line. Otherwise do nothing. */
1968 if (chars_printed
> 0)
1970 puts_filtered ("\n");
1975 /* Like fputs but if FILTER is true, pause after every screenful.
1977 Regardless of FILTER can wrap at points other than the final
1978 character of a line.
1980 Unlike fputs, fputs_maybe_filtered does not return a value.
1981 It is OK for LINEBUFFER to be NULL, in which case just don't print
1984 Note that a longjmp to top level may occur in this routine (only if
1985 FILTER is true) (since prompt_for_continue may do so) so this
1986 routine should not be called when cleanups are not in place. */
1989 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1992 const char *lineptr
;
1994 if (linebuffer
== 0)
1997 /* Don't do any filtering if it is disabled. */
1998 if (stream
!= gdb_stdout
1999 || !pagination_enabled
2001 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
)
2002 || top_level_interpreter () == NULL
2003 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2005 fputs_unfiltered (linebuffer
, stream
);
2009 /* Go through and output each character. Show line extension
2010 when this is necessary; prompt user for new page when this is
2013 lineptr
= linebuffer
;
2016 /* Possible new page. */
2017 if (filter
&& (lines_printed
>= lines_per_page
- 1))
2018 prompt_for_continue ();
2020 while (*lineptr
&& *lineptr
!= '\n')
2022 /* Print a single line. */
2023 if (*lineptr
== '\t')
2026 *wrap_pointer
++ = '\t';
2028 fputc_unfiltered ('\t', stream
);
2029 /* Shifting right by 3 produces the number of tab stops
2030 we have already passed, and then adding one and
2031 shifting left 3 advances to the next tab stop. */
2032 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2038 *wrap_pointer
++ = *lineptr
;
2040 fputc_unfiltered (*lineptr
, stream
);
2045 if (chars_printed
>= chars_per_line
)
2047 unsigned int save_chars
= chars_printed
;
2051 /* If we aren't actually wrapping, don't output newline --
2052 if chars_per_line is right, we probably just overflowed
2053 anyway; if it's wrong, let us keep going. */
2055 fputc_unfiltered ('\n', stream
);
2057 /* Possible new page. */
2058 if (lines_printed
>= lines_per_page
- 1)
2059 prompt_for_continue ();
2061 /* Now output indentation and wrapped string. */
2064 fputs_unfiltered (wrap_indent
, stream
);
2065 *wrap_pointer
= '\0'; /* Null-terminate saved stuff, */
2066 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it. */
2067 /* FIXME, this strlen is what prevents wrap_indent from
2068 containing tabs. However, if we recurse to print it
2069 and count its chars, we risk trouble if wrap_indent is
2070 longer than (the user settable) chars_per_line.
2071 Note also that this can set chars_printed > chars_per_line
2072 if we are printing a long string. */
2073 chars_printed
= strlen (wrap_indent
)
2074 + (save_chars
- wrap_column
);
2075 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2076 wrap_buffer
[0] = '\0';
2077 wrap_column
= 0; /* And disable fancy wrap */
2082 if (*lineptr
== '\n')
2085 wrap_here ((char *) 0); /* Spit out chars, cancel
2088 fputc_unfiltered ('\n', stream
);
2095 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2097 fputs_maybe_filtered (linebuffer
, stream
, 1);
2101 putchar_unfiltered (int c
)
2105 ui_file_write (gdb_stdout
, &buf
, 1);
2109 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2110 May return nonlocally. */
2113 putchar_filtered (int c
)
2115 return fputc_filtered (c
, gdb_stdout
);
2119 fputc_unfiltered (int c
, struct ui_file
*stream
)
2123 ui_file_write (stream
, &buf
, 1);
2128 fputc_filtered (int c
, struct ui_file
*stream
)
2134 fputs_filtered (buf
, stream
);
2138 /* puts_debug is like fputs_unfiltered, except it prints special
2139 characters in printable fashion. */
2142 puts_debug (char *prefix
, char *string
, char *suffix
)
2146 /* Print prefix and suffix after each line. */
2147 static int new_line
= 1;
2148 static int return_p
= 0;
2149 static char *prev_prefix
= "";
2150 static char *prev_suffix
= "";
2152 if (*string
== '\n')
2155 /* If the prefix is changing, print the previous suffix, a new line,
2156 and the new prefix. */
2157 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2159 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2160 fputs_unfiltered ("\n", gdb_stdlog
);
2161 fputs_unfiltered (prefix
, gdb_stdlog
);
2164 /* Print prefix if we printed a newline during the previous call. */
2168 fputs_unfiltered (prefix
, gdb_stdlog
);
2171 prev_prefix
= prefix
;
2172 prev_suffix
= suffix
;
2174 /* Output characters in a printable format. */
2175 while ((ch
= *string
++) != '\0')
2181 fputc_unfiltered (ch
, gdb_stdlog
);
2184 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2188 fputs_unfiltered ("\\\\", gdb_stdlog
);
2191 fputs_unfiltered ("\\b", gdb_stdlog
);
2194 fputs_unfiltered ("\\f", gdb_stdlog
);
2198 fputs_unfiltered ("\\n", gdb_stdlog
);
2201 fputs_unfiltered ("\\r", gdb_stdlog
);
2204 fputs_unfiltered ("\\t", gdb_stdlog
);
2207 fputs_unfiltered ("\\v", gdb_stdlog
);
2211 return_p
= ch
== '\r';
2214 /* Print suffix if we printed a newline. */
2217 fputs_unfiltered (suffix
, gdb_stdlog
);
2218 fputs_unfiltered ("\n", gdb_stdlog
);
2223 /* Print a variable number of ARGS using format FORMAT. If this
2224 information is going to put the amount written (since the last call
2225 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2226 call prompt_for_continue to get the users permision to continue.
2228 Unlike fprintf, this function does not return a value.
2230 We implement three variants, vfprintf (takes a vararg list and stream),
2231 fprintf (takes a stream to write on), and printf (the usual).
2233 Note also that a longjmp to top level may occur in this routine
2234 (since prompt_for_continue may do so) so this routine should not be
2235 called when cleanups are not in place. */
2238 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2239 va_list args
, int filter
)
2242 struct cleanup
*old_cleanups
;
2244 linebuffer
= xstrvprintf (format
, args
);
2245 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2246 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2247 do_cleanups (old_cleanups
);
2252 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2254 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2258 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2261 struct cleanup
*old_cleanups
;
2263 linebuffer
= xstrvprintf (format
, args
);
2264 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2265 if (debug_timestamp
&& stream
== gdb_stdlog
)
2271 gettimeofday (&tm
, NULL
);
2273 len
= strlen (linebuffer
);
2274 need_nl
= (len
> 0 && linebuffer
[len
- 1] != '\n');
2276 timestamp
= xstrprintf ("%ld:%ld %s%s",
2277 (long) tm
.tv_sec
, (long) tm
.tv_usec
,
2279 need_nl
? "\n": "");
2280 make_cleanup (xfree
, timestamp
);
2281 fputs_unfiltered (timestamp
, stream
);
2284 fputs_unfiltered (linebuffer
, stream
);
2285 do_cleanups (old_cleanups
);
2289 vprintf_filtered (const char *format
, va_list args
)
2291 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2295 vprintf_unfiltered (const char *format
, va_list args
)
2297 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2301 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2305 va_start (args
, format
);
2306 vfprintf_filtered (stream
, format
, args
);
2311 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2315 va_start (args
, format
);
2316 vfprintf_unfiltered (stream
, format
, args
);
2320 /* Like fprintf_filtered, but prints its result indented.
2321 Called as fprintfi_filtered (spaces, stream, format, ...); */
2324 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2329 va_start (args
, format
);
2330 print_spaces_filtered (spaces
, stream
);
2332 vfprintf_filtered (stream
, format
, args
);
2338 printf_filtered (const char *format
, ...)
2342 va_start (args
, format
);
2343 vfprintf_filtered (gdb_stdout
, format
, args
);
2349 printf_unfiltered (const char *format
, ...)
2353 va_start (args
, format
);
2354 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2358 /* Like printf_filtered, but prints it's result indented.
2359 Called as printfi_filtered (spaces, format, ...); */
2362 printfi_filtered (int spaces
, const char *format
, ...)
2366 va_start (args
, format
);
2367 print_spaces_filtered (spaces
, gdb_stdout
);
2368 vfprintf_filtered (gdb_stdout
, format
, args
);
2372 /* Easy -- but watch out!
2374 This routine is *not* a replacement for puts()! puts() appends a newline.
2375 This one doesn't, and had better not! */
2378 puts_filtered (const char *string
)
2380 fputs_filtered (string
, gdb_stdout
);
2384 puts_unfiltered (const char *string
)
2386 fputs_unfiltered (string
, gdb_stdout
);
2389 /* Return a pointer to N spaces and a null. The pointer is good
2390 until the next call to here. */
2395 static char *spaces
= 0;
2396 static int max_spaces
= -1;
2402 spaces
= (char *) xmalloc (n
+ 1);
2403 for (t
= spaces
+ n
; t
!= spaces
;)
2409 return spaces
+ max_spaces
- n
;
2412 /* Print N spaces. */
2414 print_spaces_filtered (int n
, struct ui_file
*stream
)
2416 fputs_filtered (n_spaces (n
), stream
);
2419 /* C++/ObjC demangler stuff. */
2421 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2422 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2423 If the name is not mangled, or the language for the name is unknown, or
2424 demangling is off, the name is printed in its "raw" form. */
2427 fprintf_symbol_filtered (struct ui_file
*stream
, const char *name
,
2428 enum language lang
, int arg_mode
)
2434 /* If user wants to see raw output, no problem. */
2437 fputs_filtered (name
, stream
);
2441 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2442 fputs_filtered (demangled
? demangled
: name
, stream
);
2443 if (demangled
!= NULL
)
2451 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2452 differences in whitespace. Returns 0 if they match, non-zero if they
2453 don't (slightly different than strcmp()'s range of return values).
2455 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2456 This "feature" is useful when searching for matching C++ function names
2457 (such as if the user types 'break FOO', where FOO is a mangled C++
2461 strcmp_iw (const char *string1
, const char *string2
)
2463 while ((*string1
!= '\0') && (*string2
!= '\0'))
2465 while (isspace (*string1
))
2469 while (isspace (*string2
))
2473 if (case_sensitivity
== case_sensitive_on
&& *string1
!= *string2
)
2475 if (case_sensitivity
== case_sensitive_off
2476 && (tolower ((unsigned char) *string1
)
2477 != tolower ((unsigned char) *string2
)))
2479 if (*string1
!= '\0')
2485 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2488 /* This is like strcmp except that it ignores whitespace and treats
2489 '(' as the first non-NULL character in terms of ordering. Like
2490 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2491 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2492 according to that ordering.
2494 If a list is sorted according to this function and if you want to
2495 find names in the list that match some fixed NAME according to
2496 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2497 where this function would put NAME.
2499 This function must be neutral to the CASE_SENSITIVITY setting as the user
2500 may choose it during later lookup. Therefore this function always sorts
2501 primarily case-insensitively and secondarily case-sensitively.
2503 Here are some examples of why using strcmp to sort is a bad idea:
2507 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2508 we try to do a search for "foo<char*>", strcmp will locate this
2509 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2510 will start looking at strings beginning with "goo", and will never
2511 see the correct match of "foo<char *>".
2513 Parenthesis example:
2515 In practice, this is less like to be an issue, but I'll give it a
2516 shot. Let's assume that '$' is a legitimate character to occur in
2517 symbols. (Which may well even be the case on some systems.) Then
2518 say that the partial symbol table contains "foo$" and "foo(int)".
2519 strcmp will put them in this order, since '$' < '('. Now, if the
2520 user searches for "foo", then strcmp will sort "foo" before "foo$".
2521 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2522 "foo") is false, so it won't proceed to the actual match of
2523 "foo(int)" with "foo". */
2526 strcmp_iw_ordered (const char *string1
, const char *string2
)
2528 const char *saved_string1
= string1
, *saved_string2
= string2
;
2529 enum case_sensitivity case_pass
= case_sensitive_off
;
2533 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2534 Provide stub characters if we are already at the end of one of the
2536 char c1
= 'X', c2
= 'X';
2538 while (*string1
!= '\0' && *string2
!= '\0')
2540 while (isspace (*string1
))
2542 while (isspace (*string2
))
2547 case case_sensitive_off
:
2548 c1
= tolower ((unsigned char) *string1
);
2549 c2
= tolower ((unsigned char) *string2
);
2551 case case_sensitive_on
:
2559 if (*string1
!= '\0')
2568 /* Characters are non-equal unless they're both '\0'; we want to
2569 make sure we get the comparison right according to our
2570 comparison in the cases where one of them is '\0' or '('. */
2572 if (*string2
== '\0')
2577 if (*string2
== '\0')
2582 if (*string2
== '\0' || *string2
== '(')
2591 if (case_pass
== case_sensitive_on
)
2594 /* Otherwise the strings were equal in case insensitive way, make
2595 a more fine grained comparison in a case sensitive way. */
2597 case_pass
= case_sensitive_on
;
2598 string1
= saved_string1
;
2599 string2
= saved_string2
;
2603 /* A simple comparison function with opposite semantics to strcmp. */
2606 streq (const char *lhs
, const char *rhs
)
2608 return !strcmp (lhs
, rhs
);
2614 ** Answer whether string_to_compare is a full or partial match to
2615 ** template_string. The partial match must be in sequence starting
2619 subset_compare (char *string_to_compare
, char *template_string
)
2623 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2624 && strlen (string_to_compare
) <= strlen (template_string
))
2627 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2634 pagination_on_command (char *arg
, int from_tty
)
2636 pagination_enabled
= 1;
2640 pagination_off_command (char *arg
, int from_tty
)
2642 pagination_enabled
= 0;
2646 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2647 struct cmd_list_element
*c
, const char *value
)
2649 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"),
2655 initialize_utils (void)
2657 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2658 Set number of characters gdb thinks are in a line."), _("\
2659 Show number of characters gdb thinks are in a line."), NULL
,
2661 show_chars_per_line
,
2662 &setlist
, &showlist
);
2664 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2665 Set number of lines gdb thinks are in a page."), _("\
2666 Show number of lines gdb thinks are in a page."), NULL
,
2668 show_lines_per_page
,
2669 &setlist
, &showlist
);
2673 add_setshow_boolean_cmd ("pagination", class_support
,
2674 &pagination_enabled
, _("\
2675 Set state of pagination."), _("\
2676 Show state of pagination."), NULL
,
2678 show_pagination_enabled
,
2679 &setlist
, &showlist
);
2683 add_com ("am", class_support
, pagination_on_command
,
2684 _("Enable pagination"));
2685 add_com ("sm", class_support
, pagination_off_command
,
2686 _("Disable pagination"));
2689 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2690 &sevenbit_strings
, _("\
2691 Set printing of 8-bit characters in strings as \\nnn."), _("\
2692 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2694 show_sevenbit_strings
,
2695 &setprintlist
, &showprintlist
);
2697 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2698 &debug_timestamp
, _("\
2699 Set timestamping of debugging messages."), _("\
2700 Show timestamping of debugging messages."), _("\
2701 When set, debugging messages will be marked with seconds and microseconds."),
2703 show_debug_timestamp
,
2704 &setdebuglist
, &showdebuglist
);
2707 /* Machine specific function to handle SIGWINCH signal. */
2709 #ifdef SIGWINCH_HANDLER_BODY
2710 SIGWINCH_HANDLER_BODY
2712 /* Print routines to handle variable size regs, etc. */
2713 /* Temporary storage using circular buffer. */
2719 static char buf
[NUMCELLS
][CELLSIZE
];
2720 static int cell
= 0;
2722 if (++cell
>= NUMCELLS
)
2728 paddress (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2730 /* Truncate address to the size of a target address, avoiding shifts
2731 larger or equal than the width of a CORE_ADDR. The local
2732 variable ADDR_BIT stops the compiler reporting a shift overflow
2733 when it won't occur. */
2734 /* NOTE: This assumes that the significant address information is
2735 kept in the least significant bits of ADDR - the upper bits were
2736 either zero or sign extended. Should gdbarch_address_to_pointer or
2737 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2739 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2741 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2742 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2743 return hex_string (addr
);
2746 /* This function is described in "defs.h". */
2749 print_core_address (struct gdbarch
*gdbarch
, CORE_ADDR address
)
2751 int addr_bit
= gdbarch_addr_bit (gdbarch
);
2753 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2754 address
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2756 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2757 that returns the language localized string formatted to a width
2758 based on gdbarch_addr_bit. */
2760 return hex_string_custom (address
, 8);
2762 return hex_string_custom (address
, 16);
2765 /* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2768 core_addr_hash (const void *ap
)
2770 const CORE_ADDR
*addrp
= ap
;
2775 /* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2778 core_addr_eq (const void *ap
, const void *bp
)
2780 const CORE_ADDR
*addr_ap
= ap
;
2781 const CORE_ADDR
*addr_bp
= bp
;
2783 return *addr_ap
== *addr_bp
;
2787 decimal2str (char *sign
, ULONGEST addr
, int width
)
2789 /* Steal code from valprint.c:print_decimal(). Should this worry
2790 about the real size of addr as the above does? */
2791 unsigned long temp
[3];
2792 char *str
= get_cell ();
2797 temp
[i
] = addr
% (1000 * 1000 * 1000);
2798 addr
/= (1000 * 1000 * 1000);
2802 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2811 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2814 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2818 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2819 temp
[2], temp
[1], temp
[0]);
2822 internal_error (__FILE__
, __LINE__
,
2823 _("failed internal consistency check"));
2830 octal2str (ULONGEST addr
, int width
)
2832 unsigned long temp
[3];
2833 char *str
= get_cell ();
2838 temp
[i
] = addr
% (0100000 * 0100000);
2839 addr
/= (0100000 * 0100000);
2843 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2853 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
2855 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
2858 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2861 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
2862 temp
[2], temp
[1], temp
[0]);
2865 internal_error (__FILE__
, __LINE__
,
2866 _("failed internal consistency check"));
2873 pulongest (ULONGEST u
)
2875 return decimal2str ("", u
, 0);
2879 plongest (LONGEST l
)
2882 return decimal2str ("-", -l
, 0);
2884 return decimal2str ("", l
, 0);
2887 /* Eliminate warning from compiler on 32-bit systems. */
2888 static int thirty_two
= 32;
2891 phex (ULONGEST l
, int sizeof_l
)
2899 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
2900 (unsigned long) (l
>> thirty_two
),
2901 (unsigned long) (l
& 0xffffffff));
2905 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
2909 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
2912 str
= phex (l
, sizeof (l
));
2920 phex_nz (ULONGEST l
, int sizeof_l
)
2928 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2932 xsnprintf (str
, CELLSIZE
, "%lx",
2933 (unsigned long) (l
& 0xffffffff));
2935 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
2936 (unsigned long) (l
& 0xffffffff));
2941 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
2945 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
2948 str
= phex_nz (l
, sizeof (l
));
2955 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2956 in a static string. Returns a pointer to this string. */
2958 hex_string (LONGEST num
)
2960 char *result
= get_cell ();
2962 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2966 /* Converts a LONGEST number to a C-format hexadecimal literal and
2967 stores it in a static string. Returns a pointer to this string
2968 that is valid until the next call. The number is padded on the
2969 left with 0s to at least WIDTH characters. */
2971 hex_string_custom (LONGEST num
, int width
)
2973 char *result
= get_cell ();
2974 char *result_end
= result
+ CELLSIZE
- 1;
2975 const char *hex
= phex_nz (num
, sizeof (num
));
2976 int hex_len
= strlen (hex
);
2978 if (hex_len
> width
)
2980 if (width
+ 2 >= CELLSIZE
)
2981 internal_error (__FILE__
, __LINE__
, _("\
2982 hex_string_custom: insufficient space to store result"));
2984 strcpy (result_end
- width
- 2, "0x");
2985 memset (result_end
- width
, '0', width
);
2986 strcpy (result_end
- hex_len
, hex
);
2987 return result_end
- width
- 2;
2990 /* Convert VAL to a numeral in the given radix. For
2991 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2992 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2993 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2994 * to use C format in all cases. If it is false, then 'x'
2995 * and 'o' formats do not include a prefix (0x or leading 0). */
2998 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
3008 result
= hex_string (val
);
3010 result
= hex_string_custom (val
, width
);
3017 if (is_signed
&& val
< 0)
3018 return decimal2str ("-", -val
, width
);
3020 return decimal2str ("", val
, width
);
3024 char *result
= octal2str (val
, width
);
3026 if (use_c_format
|| val
== 0)
3032 internal_error (__FILE__
, __LINE__
,
3033 _("failed internal consistency check"));
3037 /* Convert a CORE_ADDR into a string. */
3039 core_addr_to_string (const CORE_ADDR addr
)
3041 char *str
= get_cell ();
3044 strcat (str
, phex (addr
, sizeof (addr
)));
3049 core_addr_to_string_nz (const CORE_ADDR addr
)
3051 char *str
= get_cell ();
3054 strcat (str
, phex_nz (addr
, sizeof (addr
)));
3058 /* Convert a string back into a CORE_ADDR. */
3060 string_to_core_addr (const char *my_string
)
3064 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
3066 /* Assume that it is in hex. */
3069 for (i
= 2; my_string
[i
] != '\0'; i
++)
3071 if (isdigit (my_string
[i
]))
3072 addr
= (my_string
[i
] - '0') + (addr
* 16);
3073 else if (isxdigit (my_string
[i
]))
3074 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
3076 error (_("invalid hex \"%s\""), my_string
);
3081 /* Assume that it is in decimal. */
3084 for (i
= 0; my_string
[i
] != '\0'; i
++)
3086 if (isdigit (my_string
[i
]))
3087 addr
= (my_string
[i
] - '0') + (addr
* 10);
3089 error (_("invalid decimal \"%s\""), my_string
);
3097 host_address_to_string (const void *addr
)
3099 char *str
= get_cell ();
3101 xsnprintf (str
, CELLSIZE
, "0x%s", phex_nz ((uintptr_t) addr
, sizeof (addr
)));
3106 gdb_realpath (const char *filename
)
3108 /* Method 1: The system has a compile time upper bound on a filename
3109 path. Use that and realpath() to canonicalize the name. This is
3110 the most common case. Note that, if there isn't a compile time
3111 upper bound, you want to avoid realpath() at all costs. */
3112 #if defined(HAVE_REALPATH)
3114 # if defined (PATH_MAX)
3116 # define USE_REALPATH
3117 # elif defined (MAXPATHLEN)
3118 char buf
[MAXPATHLEN
];
3119 # define USE_REALPATH
3121 # if defined (USE_REALPATH)
3122 const char *rp
= realpath (filename
, buf
);
3126 return xstrdup (rp
);
3129 #endif /* HAVE_REALPATH */
3131 /* Method 2: The host system (i.e., GNU) has the function
3132 canonicalize_file_name() which malloc's a chunk of memory and
3133 returns that, use that. */
3134 #if defined(HAVE_CANONICALIZE_FILE_NAME)
3136 char *rp
= canonicalize_file_name (filename
);
3139 return xstrdup (filename
);
3145 /* FIXME: cagney/2002-11-13:
3147 Method 2a: Use realpath() with a NULL buffer. Some systems, due
3148 to the problems described in method 3, have modified their
3149 realpath() implementation so that it will allocate a buffer when
3150 NULL is passed in. Before this can be used, though, some sort of
3151 configure time test would need to be added. Otherwize the code
3152 will likely core dump. */
3154 /* Method 3: Now we're getting desperate! The system doesn't have a
3155 compile time buffer size and no alternative function. Query the
3156 OS, using pathconf(), for the buffer limit. Care is needed
3157 though, some systems do not limit PATH_MAX (return -1 for
3158 pathconf()) making it impossible to pass a correctly sized buffer
3159 to realpath() (it could always overflow). On those systems, we
3161 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3163 /* Find out the max path size. */
3164 long path_max
= pathconf ("/", _PC_PATH_MAX
);
3168 /* PATH_MAX is bounded. */
3169 char *buf
= alloca (path_max
);
3170 char *rp
= realpath (filename
, buf
);
3172 return xstrdup (rp
? rp
: filename
);
3177 /* The MS Windows method. If we don't have realpath, we assume we
3178 don't have symlinks and just canonicalize to a Windows absolute
3179 path. GetFullPath converts ../ and ./ in relative paths to
3180 absolute paths, filling in current drive if one is not given
3181 or using the current directory of a specified drive (eg, "E:foo").
3182 It also converts all forward slashes to back slashes. */
3183 /* The file system is case-insensitive but case-preserving.
3184 So we do not lowercase the path. Otherwise, we might not
3185 be able to display the original casing in a given path. */
3186 #if defined (_WIN32)
3189 DWORD len
= GetFullPathName (filename
, MAX_PATH
, buf
, NULL
);
3191 if (len
> 0 && len
< MAX_PATH
)
3192 return xstrdup (buf
);
3196 /* This system is a lost cause, just dup the buffer. */
3197 return xstrdup (filename
);
3200 /* Return a copy of FILENAME, with its directory prefix canonicalized
3204 xfullpath (const char *filename
)
3206 const char *base_name
= lbasename (filename
);
3211 /* Extract the basename of filename, and return immediately
3212 a copy of filename if it does not contain any directory prefix. */
3213 if (base_name
== filename
)
3214 return xstrdup (filename
);
3216 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3217 /* Allocate enough space to store the dir_name + plus one extra
3218 character sometimes needed under Windows (see below), and
3219 then the closing \000 character. */
3220 strncpy (dir_name
, filename
, base_name
- filename
);
3221 dir_name
[base_name
- filename
] = '\000';
3223 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3224 /* We need to be careful when filename is of the form 'd:foo', which
3225 is equivalent of d:./foo, which is totally different from d:/foo. */
3226 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3229 dir_name
[3] = '\000';
3233 /* Canonicalize the directory prefix, and build the resulting
3234 filename. If the dirname realpath already contains an ending
3235 directory separator, avoid doubling it. */
3236 real_path
= gdb_realpath (dir_name
);
3237 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3238 result
= concat (real_path
, base_name
, (char *) NULL
);
3240 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *) NULL
);
3247 /* This is the 32-bit CRC function used by the GNU separate debug
3248 facility. An executable may contain a section named
3249 .gnu_debuglink, which holds the name of a separate executable file
3250 containing its debug info, and a checksum of that file's contents,
3251 computed using this function. */
3253 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3255 static const unsigned int crc32_table
[256] = {
3256 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3257 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3258 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3259 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3260 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3261 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3262 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3263 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3264 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3265 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3266 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3267 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3268 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3269 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3270 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3271 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3272 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3273 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3274 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3275 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3276 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3277 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3278 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3279 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3280 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3281 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3282 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3283 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3284 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3285 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3286 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3287 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3288 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3289 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3290 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3291 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3292 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3293 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3294 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3295 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3296 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3297 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3298 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3299 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3300 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3301 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3302 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3303 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3304 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3305 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3306 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3311 crc
= ~crc
& 0xffffffff;
3312 for (end
= buf
+ len
; buf
< end
; ++buf
)
3313 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3314 return ~crc
& 0xffffffff;
3318 align_up (ULONGEST v
, int n
)
3320 /* Check that N is really a power of two. */
3321 gdb_assert (n
&& (n
& (n
-1)) == 0);
3322 return (v
+ n
- 1) & -n
;
3326 align_down (ULONGEST v
, int n
)
3328 /* Check that N is really a power of two. */
3329 gdb_assert (n
&& (n
& (n
-1)) == 0);
3333 /* Allocation function for the libiberty hash table which uses an
3334 obstack. The obstack is passed as DATA. */
3337 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3339 unsigned int total
= size
* count
;
3340 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3342 memset (ptr
, 0, total
);
3346 /* Trivial deallocation function for the libiberty splay tree and hash
3347 table - don't deallocate anything. Rely on later deletion of the
3348 obstack. DATA will be the obstack, although it is not needed
3352 dummy_obstack_deallocate (void *object
, void *data
)
3357 /* The bit offset of the highest byte in a ULONGEST, for overflow
3360 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3362 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3363 where 2 <= BASE <= 36. */
3366 is_digit_in_base (unsigned char digit
, int base
)
3368 if (!isalnum (digit
))
3371 return (isdigit (digit
) && digit
< base
+ '0');
3373 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3377 digit_to_int (unsigned char c
)
3382 return tolower (c
) - 'a' + 10;
3385 /* As for strtoul, but for ULONGEST results. */
3388 strtoulst (const char *num
, const char **trailer
, int base
)
3390 unsigned int high_part
;
3395 /* Skip leading whitespace. */
3396 while (isspace (num
[i
]))
3399 /* Handle prefixes. */
3402 else if (num
[i
] == '-')
3408 if (base
== 0 || base
== 16)
3410 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3418 if (base
== 0 && num
[i
] == '0')
3424 if (base
< 2 || base
> 36)
3430 result
= high_part
= 0;
3431 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3433 result
= result
* base
+ digit_to_int (num
[i
]);
3434 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3435 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3436 if (high_part
> 0xff)
3439 result
= ~ (ULONGEST
) 0;
3446 if (trailer
!= NULL
)
3449 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3456 /* Simple, portable version of dirname that does not modify its
3460 ldirname (const char *filename
)
3462 const char *base
= lbasename (filename
);
3465 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3468 if (base
== filename
)
3471 dirname
= xmalloc (base
- filename
+ 2);
3472 memcpy (dirname
, filename
, base
- filename
);
3474 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3475 create "d:./bar" later instead of the (different) "d:/bar". */
3476 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3477 && !IS_DIR_SEPARATOR (filename
[0]))
3478 dirname
[base
++ - filename
] = '.';
3480 dirname
[base
- filename
] = '\0';
3484 /* Call libiberty's buildargv, and return the result.
3485 If buildargv fails due to out-of-memory, call nomem.
3486 Therefore, the returned value is guaranteed to be non-NULL,
3487 unless the parameter itself is NULL. */
3490 gdb_buildargv (const char *s
)
3492 char **argv
= buildargv (s
);
3494 if (s
!= NULL
&& argv
== NULL
)
3500 compare_positive_ints (const void *ap
, const void *bp
)
3502 /* Because we know we're comparing two ints which are positive,
3503 there's no danger of overflow here. */
3504 return * (int *) ap
- * (int *) bp
;
3507 /* String compare function for qsort. */
3510 compare_strings (const void *arg1
, const void *arg2
)
3512 const char **s1
= (const char **) arg1
;
3513 const char **s2
= (const char **) arg2
;
3515 return strcmp (*s1
, *s2
);
3518 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
3519 #define AMBIGUOUS_MESS2 \
3520 ".\nUse \"set gnutarget format-name\" to specify the format."
3523 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
3529 /* Check if errmsg just need simple return. */
3530 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
3531 return bfd_errmsg (error_tag
);
3533 ret_len
= strlen (bfd_errmsg (error_tag
)) + strlen (AMBIGUOUS_MESS1
)
3534 + strlen (AMBIGUOUS_MESS2
);
3535 for (p
= matching
; *p
; p
++)
3536 ret_len
+= strlen (*p
) + 1;
3537 ret
= xmalloc (ret_len
+ 1);
3539 make_cleanup (xfree
, ret
);
3541 strcpy (retp
, bfd_errmsg (error_tag
));
3542 retp
+= strlen (retp
);
3544 strcpy (retp
, AMBIGUOUS_MESS1
);
3545 retp
+= strlen (retp
);
3547 for (p
= matching
; *p
; p
++)
3549 sprintf (retp
, " %s", *p
);
3550 retp
+= strlen (retp
);
3554 strcpy (retp
, AMBIGUOUS_MESS2
);
3559 /* Return ARGS parsed as a valid pid, or throw an error. */
3562 parse_pid_to_attach (char *args
)
3568 error_no_arg (_("process-id to attach"));
3571 pid
= strtoul (args
, &dummy
, 0);
3572 /* Some targets don't set errno on errors, grrr! */
3573 if ((pid
== 0 && dummy
== args
) || dummy
!= &args
[strlen (args
)])
3574 error (_("Illegal process-id: %s."), args
);
3579 /* Helper for make_bpstat_clear_actions_cleanup. */
3582 do_bpstat_clear_actions_cleanup (void *unused
)
3584 bpstat_clear_actions ();
3587 /* Call bpstat_clear_actions for the case an exception is throw. You should
3588 discard_cleanups if no exception is caught. */
3591 make_bpstat_clear_actions_cleanup (void)
3593 return make_cleanup (do_bpstat_clear_actions_cleanup
, NULL
);
3596 /* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3597 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3598 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3601 producer_is_gcc_ge_4 (const char *producer
)
3606 if (producer
== NULL
)
3608 /* For unknown compilers expect their behavior is not compliant. For GCC
3609 this case can also happen for -gdwarf-4 type units supported since
3615 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
3617 if (strncmp (producer
, "GNU ", strlen ("GNU ")) != 0)
3619 /* For non-GCC compilers expect their behavior is not compliant. */
3623 cs
= &producer
[strlen ("GNU ")];
3624 while (*cs
&& !isdigit (*cs
))
3626 if (sscanf (cs
, "%d.%d", &major
, &minor
) != 2)
3628 /* Not recognized as GCC. */
3640 /* Helper for make_cleanup_free_char_ptr_vec. */
3643 do_free_char_ptr_vec (void *arg
)
3645 VEC (char_ptr
) *char_ptr_vec
= arg
;
3647 free_char_ptr_vec (char_ptr_vec
);
3650 /* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
3651 final VEC_free for CHAR_PTR_VEC itself.
3653 You must not modify CHAR_PTR_VEC after this cleanup registration as the
3654 CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
3655 this function does not (cannot) clear the pointer. */
3658 make_cleanup_free_char_ptr_vec (VEC (char_ptr
) *char_ptr_vec
)
3660 return make_cleanup (do_free_char_ptr_vec
, char_ptr_vec
);
3663 /* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
3664 must come from xrealloc-compatible allocator and it may be updated. FROM
3665 needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
3666 located at the start or end of *STRINGP. */
3669 substitute_path_component (char **stringp
, const char *from
, const char *to
)
3671 char *string
= *stringp
, *s
;
3672 const size_t from_len
= strlen (from
);
3673 const size_t to_len
= strlen (to
);
3677 s
= strstr (s
, from
);
3681 if ((s
== string
|| IS_DIR_SEPARATOR (s
[-1])
3682 || s
[-1] == DIRNAME_SEPARATOR
)
3683 && (s
[from_len
] == '\0' || IS_DIR_SEPARATOR (s
[from_len
])
3684 || s
[from_len
] == DIRNAME_SEPARATOR
))
3688 string_new
= xrealloc (string
, (strlen (string
) + to_len
+ 1));
3690 /* Relocate the current S pointer. */
3691 s
= s
- string
+ string_new
;
3692 string
= string_new
;
3694 /* Replace from by to. */
3695 memmove (&s
[to_len
], &s
[from_len
], strlen (&s
[from_len
]) + 1);
3696 memcpy (s
, to
, to_len
);
3711 /* SIGALRM handler for waitpid_with_timeout. */
3714 sigalrm_handler (int signo
)
3716 /* Nothing to do. */
3721 /* Wrapper to wait for child PID to die with TIMEOUT.
3722 TIMEOUT is the time to stop waiting in seconds.
3723 If TIMEOUT is zero, pass WNOHANG to waitpid.
3724 Returns PID if it was successfully waited for, otherwise -1.
3726 Timeouts are currently implemented with alarm and SIGALRM.
3727 If the host does not support them, this waits "forever".
3728 It would be odd though for a host to have waitpid and not SIGALRM. */
3731 wait_to_die_with_timeout (pid_t pid
, int *status
, int timeout
)
3733 pid_t waitpid_result
;
3735 gdb_assert (pid
> 0);
3736 gdb_assert (timeout
>= 0);
3741 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3742 struct sigaction sa
, old_sa
;
3744 sa
.sa_handler
= sigalrm_handler
;
3745 sigemptyset (&sa
.sa_mask
);
3747 sigaction (SIGALRM
, &sa
, &old_sa
);
3751 ofunc
= (void (*)()) signal (SIGALRM
, sigalrm_handler
);
3757 waitpid_result
= waitpid (pid
, status
, 0);
3761 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
3762 sigaction (SIGALRM
, &old_sa
, NULL
);
3764 signal (SIGALRM
, ofunc
);
3769 waitpid_result
= waitpid (pid
, status
, WNOHANG
);
3771 if (waitpid_result
== pid
)
3777 #endif /* HAVE_WAITPID */
3779 /* Provide fnmatch compatible function for FNM_FILE_NAME matching of host files.
3780 Both FNM_FILE_NAME and FNM_NOESCAPE must be set in FLAGS.
3782 It handles correctly HAVE_DOS_BASED_FILE_SYSTEM and
3783 HAVE_CASE_INSENSITIVE_FILE_SYSTEM. */
3786 gdb_filename_fnmatch (const char *pattern
, const char *string
, int flags
)
3788 gdb_assert ((flags
& FNM_FILE_NAME
) != 0);
3790 /* It is unclear how '\' escaping vs. directory separator should coexist. */
3791 gdb_assert ((flags
& FNM_NOESCAPE
) != 0);
3793 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3795 char *pattern_slash
, *string_slash
;
3797 /* Replace '\' by '/' in both strings. */
3799 pattern_slash
= alloca (strlen (pattern
) + 1);
3800 strcpy (pattern_slash
, pattern
);
3801 pattern
= pattern_slash
;
3802 for (; *pattern_slash
!= 0; pattern_slash
++)
3803 if (IS_DIR_SEPARATOR (*pattern_slash
))
3804 *pattern_slash
= '/';
3806 string_slash
= alloca (strlen (string
) + 1);
3807 strcpy (string_slash
, string
);
3808 string
= string_slash
;
3809 for (; *string_slash
!= 0; string_slash
++)
3810 if (IS_DIR_SEPARATOR (*string_slash
))
3811 *string_slash
= '/';
3813 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
3815 #ifdef HAVE_CASE_INSENSITIVE_FILE_SYSTEM
3816 flags
|= FNM_CASEFOLD
;
3817 #endif /* HAVE_CASE_INSENSITIVE_FILE_SYSTEM */
3819 return fnmatch (pattern
, string
, flags
);
3822 /* Provide a prototype to silence -Wmissing-prototypes. */
3823 extern initialize_file_ftype _initialize_utils
;
3826 _initialize_utils (void)
3828 add_internal_problem_command (&internal_error_problem
);
3829 add_internal_problem_command (&internal_warning_problem
);