gdb vendor branch: Bring in additional source files
[dragonfly.git] / contrib / gdb-7 / gdb / utils.c
CommitLineData
5796c8dc
SS
1/* General utility routines for GDB, the GNU debugger.
2
a45ae5f8 3 Copyright (C) 1986, 1988-2012 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
a45ae5f8 21#include "dyn-string.h"
5796c8dc
SS
22#include "gdb_assert.h"
23#include <ctype.h>
24#include "gdb_string.h"
25#include "event-top.h"
26#include "exceptions.h"
27#include "gdbthread.h"
cf7f2e2d
JM
28#ifdef HAVE_SYS_RESOURCE_H
29#include <sys/resource.h>
30#endif /* HAVE_SYS_RESOURCE_H */
5796c8dc
SS
31
32#ifdef TUI
33#include "tui/tui.h" /* For tui_get_command_dimension. */
34#endif
35
36#ifdef __GO32__
37#include <pc.h>
38#endif
39
c50c785c 40/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
5796c8dc
SS
41#ifdef reg
42#undef reg
43#endif
44
45#include <signal.h>
a45ae5f8 46#include "timeval-utils.h"
5796c8dc
SS
47#include "gdbcmd.h"
48#include "serial.h"
49#include "bfd.h"
50#include "target.h"
a45ae5f8 51#include "gdb-demangle.h"
5796c8dc
SS
52#include "expression.h"
53#include "language.h"
54#include "charset.h"
55#include "annotate.h"
56#include "filenames.h"
57#include "symfile.h"
58#include "gdb_obstack.h"
59#include "gdbcore.h"
60#include "top.h"
cf7f2e2d 61#include "main.h"
a45ae5f8 62#include "solist.h"
5796c8dc
SS
63
64#include "inferior.h" /* for signed_pointer_to_address */
65
66#include <sys/param.h> /* For MAXPATHLEN */
67
68#include "gdb_curses.h"
69
70#include "readline/readline.h"
71
72#include <sys/time.h>
73#include <time.h>
74
75#include "gdb_usleep.h"
cf7f2e2d 76#include "interps.h"
c50c785c 77#include "gdb_regex.h"
5796c8dc
SS
78
79#if !HAVE_DECL_MALLOC
80extern PTR malloc (); /* ARI: PTR */
81#endif
82#if !HAVE_DECL_REALLOC
83extern PTR realloc (); /* ARI: PTR */
84#endif
85#if !HAVE_DECL_FREE
86extern void free ();
87#endif
88
89/* readline defines this. */
90#undef savestring
91
92void (*deprecated_error_begin_hook) (void);
93
94/* Prototypes for local functions */
95
96static void vfprintf_maybe_filtered (struct ui_file *, const char *,
cf7f2e2d 97 va_list, int) ATTRIBUTE_PRINTF (2, 0);
5796c8dc
SS
98
99static void fputs_maybe_filtered (const char *, struct ui_file *, int);
100
101static void do_my_cleanups (struct cleanup **, struct cleanup *);
102
103static void prompt_for_continue (void);
104
105static void set_screen_size (void);
106static void set_width (void);
107
108/* A flag indicating whether to timestamp debugging messages. */
109
110static int debug_timestamp = 0;
111
112/* Chain of cleanup actions established with make_cleanup,
113 to be executed if an error happens. */
114
115static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
116static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
117
c50c785c 118/* Nonzero if we have job control. */
5796c8dc
SS
119
120int job_control;
121
122/* Nonzero means a quit has been requested. */
123
124int quit_flag;
125
126/* Nonzero means quit immediately if Control-C is typed now, rather
127 than waiting until QUIT is executed. Be careful in setting this;
128 code which executes with immediate_quit set has to be very careful
129 about being able to deal with being interrupted at any time. It is
130 almost always better to use QUIT; the only exception I can think of
131 is being able to quit out of a system call (using EINTR loses if
132 the SIGINT happens between the previous QUIT and the system call).
133 To immediately quit in the case in which a SIGINT happens between
134 the previous QUIT and setting immediate_quit (desirable anytime we
135 expect to block), call QUIT after setting immediate_quit. */
136
137int immediate_quit;
138
5796c8dc
SS
139/* Nonzero means that strings with character values >0x7F should be printed
140 as octal escapes. Zero means just print the value (e.g. it's an
141 international character, and the terminal or window can cope.) */
142
143int sevenbit_strings = 0;
144static void
145show_sevenbit_strings (struct ui_file *file, int from_tty,
146 struct cmd_list_element *c, const char *value)
147{
c50c785c
JM
148 fprintf_filtered (file, _("Printing of 8-bit characters "
149 "in strings as \\nnn is %s.\n"),
5796c8dc
SS
150 value);
151}
152
153/* String to be printed before error messages, if any. */
154
155char *error_pre_print;
156
157/* String to be printed before quit messages, if any. */
158
159char *quit_pre_print;
160
161/* String to be printed before warning messages, if any. */
162
163char *warning_pre_print = "\nwarning: ";
164
165int pagination_enabled = 1;
166static void
167show_pagination_enabled (struct ui_file *file, int from_tty,
168 struct cmd_list_element *c, const char *value)
169{
170 fprintf_filtered (file, _("State of pagination is %s.\n"), value);
171}
172
173\f
174
175/* Add a new cleanup to the cleanup_chain,
176 and return the previous chain pointer
177 to be passed later to do_cleanups or discard_cleanups.
178 Args are FUNCTION to clean up with, and ARG to pass to it. */
179
180struct cleanup *
181make_cleanup (make_cleanup_ftype *function, void *arg)
182{
183 return make_my_cleanup (&cleanup_chain, function, arg);
184}
185
186struct cleanup *
187make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
188 void (*dtor) (void *))
189{
190 return make_my_cleanup2 (&cleanup_chain,
191 function, arg, dtor);
192}
193
194struct cleanup *
195make_final_cleanup (make_cleanup_ftype *function, void *arg)
196{
197 return make_my_cleanup (&final_cleanup_chain, function, arg);
198}
199
200static void
201do_freeargv (void *arg)
202{
203 freeargv ((char **) arg);
204}
205
206struct cleanup *
207make_cleanup_freeargv (char **arg)
208{
209 return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
210}
211
a45ae5f8
JM
212static void
213do_dyn_string_delete (void *arg)
214{
215 dyn_string_delete ((dyn_string_t) arg);
216}
217
218struct cleanup *
219make_cleanup_dyn_string_delete (dyn_string_t arg)
220{
221 return make_my_cleanup (&cleanup_chain, do_dyn_string_delete, arg);
222}
223
5796c8dc
SS
224static void
225do_bfd_close_cleanup (void *arg)
226{
227 bfd_close (arg);
228}
229
230struct cleanup *
231make_cleanup_bfd_close (bfd *abfd)
232{
233 return make_cleanup (do_bfd_close_cleanup, abfd);
234}
235
236static void
237do_close_cleanup (void *arg)
238{
239 int *fd = arg;
cf7f2e2d 240
5796c8dc
SS
241 close (*fd);
242}
243
244struct cleanup *
245make_cleanup_close (int fd)
246{
247 int *saved_fd = xmalloc (sizeof (fd));
cf7f2e2d 248
5796c8dc
SS
249 *saved_fd = fd;
250 return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
251}
252
253/* Helper function which does the work for make_cleanup_fclose. */
254
255static void
256do_fclose_cleanup (void *arg)
257{
258 FILE *file = arg;
cf7f2e2d
JM
259
260 fclose (file);
5796c8dc
SS
261}
262
263/* Return a new cleanup that closes FILE. */
264
265struct cleanup *
266make_cleanup_fclose (FILE *file)
267{
268 return make_cleanup (do_fclose_cleanup, file);
269}
270
271/* Helper function which does the work for make_cleanup_obstack_free. */
272
273static void
274do_obstack_free (void *arg)
275{
276 struct obstack *ob = arg;
cf7f2e2d 277
5796c8dc
SS
278 obstack_free (ob, NULL);
279}
280
281/* Return a new cleanup that frees OBSTACK. */
282
283struct cleanup *
284make_cleanup_obstack_free (struct obstack *obstack)
285{
286 return make_cleanup (do_obstack_free, obstack);
287}
288
289static void
290do_ui_file_delete (void *arg)
291{
292 ui_file_delete (arg);
293}
294
295struct cleanup *
296make_cleanup_ui_file_delete (struct ui_file *arg)
297{
298 return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
299}
300
c50c785c
JM
301/* Helper function for make_cleanup_ui_out_redirect_pop. */
302
303static void
304do_ui_out_redirect_pop (void *arg)
305{
306 struct ui_out *uiout = arg;
307
308 if (ui_out_redirect (uiout, NULL) < 0)
309 warning (_("Cannot restore redirection of the current output protocol"));
310}
311
312/* Return a new cleanup that pops the last redirection by ui_out_redirect
313 with NULL parameter. */
314
315struct cleanup *
316make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
317{
318 return make_my_cleanup (&cleanup_chain, do_ui_out_redirect_pop, uiout);
319}
320
5796c8dc
SS
321static void
322do_free_section_addr_info (void *arg)
323{
324 free_section_addr_info (arg);
325}
326
327struct cleanup *
328make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
329{
330 return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs);
331}
332
333struct restore_integer_closure
334{
335 int *variable;
336 int value;
337};
338
339static void
340restore_integer (void *p)
341{
342 struct restore_integer_closure *closure = p;
cf7f2e2d 343
5796c8dc
SS
344 *(closure->variable) = closure->value;
345}
346
c50c785c
JM
347/* Remember the current value of *VARIABLE and make it restored when
348 the cleanup is run. */
cf7f2e2d 349
5796c8dc
SS
350struct cleanup *
351make_cleanup_restore_integer (int *variable)
352{
353 struct restore_integer_closure *c =
354 xmalloc (sizeof (struct restore_integer_closure));
cf7f2e2d 355
5796c8dc
SS
356 c->variable = variable;
357 c->value = *variable;
358
359 return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c,
360 xfree);
361}
362
c50c785c
JM
363/* Remember the current value of *VARIABLE and make it restored when
364 the cleanup is run. */
cf7f2e2d
JM
365
366struct cleanup *
367make_cleanup_restore_uinteger (unsigned int *variable)
368{
369 return make_cleanup_restore_integer ((int *) variable);
370}
371
c50c785c
JM
372/* Helper for make_cleanup_unpush_target. */
373
374static void
375do_unpush_target (void *arg)
376{
377 struct target_ops *ops = arg;
378
379 unpush_target (ops);
380}
381
382/* Return a new cleanup that unpushes OPS. */
383
384struct cleanup *
385make_cleanup_unpush_target (struct target_ops *ops)
386{
387 return make_my_cleanup (&cleanup_chain, do_unpush_target, ops);
388}
389
a45ae5f8
JM
390/* Helper for make_cleanup_htab_delete compile time checking the types. */
391
392static void
393do_htab_delete_cleanup (void *htab_voidp)
394{
395 htab_t htab = htab_voidp;
396
397 htab_delete (htab);
398}
399
400/* Return a new cleanup that deletes HTAB. */
401
402struct cleanup *
403make_cleanup_htab_delete (htab_t htab)
404{
405 return make_cleanup (do_htab_delete_cleanup, htab);
406}
407
cf7f2e2d
JM
408struct restore_ui_file_closure
409{
410 struct ui_file **variable;
411 struct ui_file *value;
412};
413
414static void
415do_restore_ui_file (void *p)
416{
417 struct restore_ui_file_closure *closure = p;
418
419 *(closure->variable) = closure->value;
420}
421
422/* Remember the current value of *VARIABLE and make it restored when
423 the cleanup is run. */
424
425struct cleanup *
426make_cleanup_restore_ui_file (struct ui_file **variable)
427{
428 struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
429
430 c->variable = variable;
431 c->value = *variable;
432
433 return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
434}
435
a45ae5f8
JM
436/* Helper for make_cleanup_value_free_to_mark. */
437
438static void
439do_value_free_to_mark (void *value)
440{
441 value_free_to_mark ((struct value *) value);
442}
443
444/* Free all values allocated since MARK was obtained by value_mark
445 (except for those released) when the cleanup is run. */
446
447struct cleanup *
448make_cleanup_value_free_to_mark (struct value *mark)
449{
450 return make_my_cleanup (&cleanup_chain, do_value_free_to_mark, mark);
451}
452
453/* Helper for make_cleanup_value_free. */
454
455static void
456do_value_free (void *value)
457{
458 value_free (value);
459}
460
461/* Free VALUE. */
462
463struct cleanup *
464make_cleanup_value_free (struct value *value)
465{
466 return make_my_cleanup (&cleanup_chain, do_value_free, value);
467}
468
469/* Helper for make_cleanup_free_so. */
470
471static void
472do_free_so (void *arg)
473{
474 struct so_list *so = arg;
475
476 free_so (so);
477}
478
479/* Make cleanup handler calling free_so for SO. */
480
481struct cleanup *
482make_cleanup_free_so (struct so_list *so)
483{
484 return make_my_cleanup (&cleanup_chain, do_free_so, so);
485}
486
5796c8dc
SS
487struct cleanup *
488make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
489 void *arg, void (*free_arg) (void *))
490{
491 struct cleanup *new
492 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
493 struct cleanup *old_chain = *pmy_chain;
494
495 new->next = *pmy_chain;
496 new->function = function;
497 new->free_arg = free_arg;
498 new->arg = arg;
499 *pmy_chain = new;
500
501 return old_chain;
502}
503
504struct cleanup *
505make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
506 void *arg)
507{
508 return make_my_cleanup2 (pmy_chain, function, arg, NULL);
509}
510
511/* Discard cleanups and do the actions they describe
512 until we get back to the point OLD_CHAIN in the cleanup_chain. */
513
514void
515do_cleanups (struct cleanup *old_chain)
516{
517 do_my_cleanups (&cleanup_chain, old_chain);
518}
519
520void
521do_final_cleanups (struct cleanup *old_chain)
522{
523 do_my_cleanups (&final_cleanup_chain, old_chain);
524}
525
526static void
527do_my_cleanups (struct cleanup **pmy_chain,
528 struct cleanup *old_chain)
529{
530 struct cleanup *ptr;
cf7f2e2d 531
5796c8dc
SS
532 while ((ptr = *pmy_chain) != old_chain)
533 {
c50c785c 534 *pmy_chain = ptr->next; /* Do this first in case of recursion. */
5796c8dc
SS
535 (*ptr->function) (ptr->arg);
536 if (ptr->free_arg)
537 (*ptr->free_arg) (ptr->arg);
538 xfree (ptr);
539 }
540}
541
542/* Discard cleanups, not doing the actions they describe,
543 until we get back to the point OLD_CHAIN in the cleanup_chain. */
544
545void
546discard_cleanups (struct cleanup *old_chain)
547{
548 discard_my_cleanups (&cleanup_chain, old_chain);
549}
550
551void
552discard_final_cleanups (struct cleanup *old_chain)
553{
554 discard_my_cleanups (&final_cleanup_chain, old_chain);
555}
556
557void
558discard_my_cleanups (struct cleanup **pmy_chain,
559 struct cleanup *old_chain)
560{
561 struct cleanup *ptr;
cf7f2e2d 562
5796c8dc
SS
563 while ((ptr = *pmy_chain) != old_chain)
564 {
565 *pmy_chain = ptr->next;
566 if (ptr->free_arg)
567 (*ptr->free_arg) (ptr->arg);
568 xfree (ptr);
569 }
570}
571
572/* Set the cleanup_chain to 0, and return the old cleanup chain. */
573struct cleanup *
574save_cleanups (void)
575{
576 return save_my_cleanups (&cleanup_chain);
577}
578
579struct cleanup *
580save_final_cleanups (void)
581{
582 return save_my_cleanups (&final_cleanup_chain);
583}
584
585struct cleanup *
586save_my_cleanups (struct cleanup **pmy_chain)
587{
588 struct cleanup *old_chain = *pmy_chain;
589
590 *pmy_chain = 0;
591 return old_chain;
592}
593
594/* Restore the cleanup chain from a previously saved chain. */
595void
596restore_cleanups (struct cleanup *chain)
597{
598 restore_my_cleanups (&cleanup_chain, chain);
599}
600
601void
602restore_final_cleanups (struct cleanup *chain)
603{
604 restore_my_cleanups (&final_cleanup_chain, chain);
605}
606
607void
608restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
609{
610 *pmy_chain = chain;
611}
612
613/* This function is useful for cleanups.
614 Do
615
616 foo = xmalloc (...);
617 old_chain = make_cleanup (free_current_contents, &foo);
618
619 to arrange to free the object thus allocated. */
620
621void
622free_current_contents (void *ptr)
623{
624 void **location = ptr;
cf7f2e2d 625
5796c8dc
SS
626 if (location == NULL)
627 internal_error (__FILE__, __LINE__,
628 _("free_current_contents: NULL pointer"));
629 if (*location != NULL)
630 {
631 xfree (*location);
632 *location = NULL;
633 }
634}
635
636/* Provide a known function that does nothing, to use as a base for
a45ae5f8 637 a possibly long chain of cleanups. This is useful where we
5796c8dc
SS
638 use the cleanup chain for handling normal cleanups as well as dealing
639 with cleanups that need to be done as a result of a call to error().
640 In such cases, we may not be certain where the first cleanup is, unless
c50c785c 641 we have a do-nothing one to always use as the base. */
5796c8dc
SS
642
643void
644null_cleanup (void *arg)
645{
646}
647
cf7f2e2d
JM
648/* If nonzero, display time usage both at startup and for each command. */
649
650static int display_time;
651
652/* If nonzero, display space usage both at startup and for each command. */
653
654static int display_space;
655
656/* Records a run time and space usage to be used as a base for
657 reporting elapsed time or change in space. In addition,
658 the msg_type field indicates whether the saved time is from the
659 beginning of GDB execution (0) or the beginning of an individual
660 command execution (1). */
661struct cmd_stats
662{
663 int msg_type;
a45ae5f8
JM
664 long start_cpu_time;
665 struct timeval start_wall_time;
cf7f2e2d
JM
666 long start_space;
667};
668
669/* Set whether to display time statistics to NEW_VALUE (non-zero
670 means true). */
671void
672set_display_time (int new_value)
673{
674 display_time = new_value;
675}
676
677/* Set whether to display space statistics to NEW_VALUE (non-zero
678 means true). */
679void
680set_display_space (int new_value)
681{
682 display_space = new_value;
683}
684
685/* As indicated by display_time and display_space, report GDB's elapsed time
686 and space usage from the base time and space provided in ARG, which
c50c785c
JM
687 must be a pointer to a struct cmd_stat. This function is intended
688 to be called as a cleanup. */
cf7f2e2d
JM
689static void
690report_command_stats (void *arg)
691{
692 struct cmd_stats *start_stats = (struct cmd_stats *) arg;
693 int msg_type = start_stats->msg_type;
694
695 if (display_time)
696 {
a45ae5f8
JM
697 long cmd_time = get_run_time () - start_stats->start_cpu_time;
698 struct timeval now_wall_time, delta_wall_time;
699
700 gettimeofday (&now_wall_time, NULL);
701 timeval_sub (&delta_wall_time,
702 &now_wall_time, &start_stats->start_wall_time);
cf7f2e2d
JM
703
704 printf_unfiltered (msg_type == 0
a45ae5f8
JM
705 ? _("Startup time: %ld.%06ld (cpu), %ld.%06ld (wall)\n")
706 : _("Command execution time: %ld.%06ld (cpu), %ld.%06ld (wall)\n"),
707 cmd_time / 1000000, cmd_time % 1000000,
708 (long) delta_wall_time.tv_sec,
709 (long) delta_wall_time.tv_usec);
cf7f2e2d
JM
710 }
711
712 if (display_space)
713 {
714#ifdef HAVE_SBRK
715 char *lim = (char *) sbrk (0);
716
717 long space_now = lim - lim_at_start;
718 long space_diff = space_now - start_stats->start_space;
719
720 printf_unfiltered (msg_type == 0
c50c785c
JM
721 ? _("Space used: %ld (%s%ld during startup)\n")
722 : _("Space used: %ld (%s%ld for this command)\n"),
cf7f2e2d 723 space_now,
c50c785c 724 (space_diff >= 0 ? "+" : ""),
cf7f2e2d
JM
725 space_diff);
726#endif
727 }
728}
729
730/* Create a cleanup that reports time and space used since its
731 creation. Precise messages depend on MSG_TYPE:
732 0: Initial time/space
733 1: Individual command time/space. */
734struct cleanup *
735make_command_stats_cleanup (int msg_type)
736{
737 struct cmd_stats *new_stat = XMALLOC (struct cmd_stats);
738
739#ifdef HAVE_SBRK
740 char *lim = (char *) sbrk (0);
741 new_stat->start_space = lim - lim_at_start;
742#endif
743
744 new_stat->msg_type = msg_type;
a45ae5f8
JM
745 new_stat->start_cpu_time = get_run_time ();
746 gettimeofday (&new_stat->start_wall_time, NULL);
cf7f2e2d
JM
747
748 return make_cleanup_dtor (report_command_stats, new_stat, xfree);
749}
5796c8dc
SS
750\f
751
752
753/* Print a warning message. The first argument STRING is the warning
754 message, used as an fprintf format string, the second is the
755 va_list of arguments for that string. A warning is unfiltered (not
756 paginated) so that the user does not need to page through each
757 screen full of warnings when there are lots of them. */
758
759void
760vwarning (const char *string, va_list args)
761{
762 if (deprecated_warning_hook)
763 (*deprecated_warning_hook) (string, args);
764 else
765 {
766 target_terminal_ours ();
c50c785c 767 wrap_here (""); /* Force out any buffered output. */
5796c8dc
SS
768 gdb_flush (gdb_stdout);
769 if (warning_pre_print)
770 fputs_unfiltered (warning_pre_print, gdb_stderr);
771 vfprintf_unfiltered (gdb_stderr, string, args);
772 fprintf_unfiltered (gdb_stderr, "\n");
773 va_end (args);
774 }
775}
776
777/* Print a warning message.
778 The first argument STRING is the warning message, used as a fprintf string,
779 and the remaining args are passed as arguments to it.
780 The primary difference between warnings and errors is that a warning
781 does not force the return to command level. */
782
783void
784warning (const char *string, ...)
785{
786 va_list args;
cf7f2e2d 787
5796c8dc
SS
788 va_start (args, string);
789 vwarning (string, args);
790 va_end (args);
791}
792
793/* Print an error message and return to command level.
794 The first argument STRING is the error message, used as a fprintf string,
795 and the remaining args are passed as arguments to it. */
796
cf7f2e2d 797void
5796c8dc
SS
798verror (const char *string, va_list args)
799{
800 throw_verror (GENERIC_ERROR, string, args);
801}
802
cf7f2e2d 803void
5796c8dc
SS
804error (const char *string, ...)
805{
806 va_list args;
cf7f2e2d 807
5796c8dc
SS
808 va_start (args, string);
809 throw_verror (GENERIC_ERROR, string, args);
810 va_end (args);
811}
812
813/* Print an error message and quit.
814 The first argument STRING is the error message, used as a fprintf string,
815 and the remaining args are passed as arguments to it. */
816
cf7f2e2d 817void
5796c8dc
SS
818vfatal (const char *string, va_list args)
819{
820 throw_vfatal (string, args);
821}
822
cf7f2e2d 823void
5796c8dc
SS
824fatal (const char *string, ...)
825{
826 va_list args;
cf7f2e2d 827
5796c8dc
SS
828 va_start (args, string);
829 throw_vfatal (string, args);
830 va_end (args);
831}
832
cf7f2e2d 833void
5796c8dc
SS
834error_stream (struct ui_file *stream)
835{
836 char *message = ui_file_xstrdup (stream, NULL);
cf7f2e2d 837
5796c8dc
SS
838 make_cleanup (xfree, message);
839 error (("%s"), message);
840}
841
cf7f2e2d
JM
842/* Dump core trying to increase the core soft limit to hard limit first. */
843
844static void
845dump_core (void)
846{
847#ifdef HAVE_SETRLIMIT
848 struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
849
850 setrlimit (RLIMIT_CORE, &rlim);
851#endif /* HAVE_SETRLIMIT */
852
853 abort (); /* NOTE: GDB has only three calls to abort(). */
854}
855
c50c785c
JM
856/* Check whether GDB will be able to dump core using the dump_core
857 function. */
cf7f2e2d
JM
858
859static int
860can_dump_core (const char *reason)
861{
862#ifdef HAVE_GETRLIMIT
863 struct rlimit rlim;
864
865 /* Be quiet and assume we can dump if an error is returned. */
866 if (getrlimit (RLIMIT_CORE, &rlim) != 0)
867 return 1;
868
869 if (rlim.rlim_max == 0)
870 {
871 fprintf_unfiltered (gdb_stderr,
c50c785c
JM
872 _("%s\nUnable to dump core, use `ulimit -c"
873 " unlimited' before executing GDB next time.\n"),
874 reason);
cf7f2e2d
JM
875 return 0;
876 }
877#endif /* HAVE_GETRLIMIT */
878
879 return 1;
880}
881
5796c8dc
SS
882/* Allow the user to configure the debugger behavior with respect to
883 what to do when an internal problem is detected. */
884
885const char internal_problem_ask[] = "ask";
886const char internal_problem_yes[] = "yes";
887const char internal_problem_no[] = "no";
888static const char *internal_problem_modes[] =
889{
890 internal_problem_ask,
891 internal_problem_yes,
892 internal_problem_no,
893 NULL
894};
5796c8dc 895
c50c785c 896/* Print a message reporting an internal error/warning. Ask the user
5796c8dc
SS
897 if they want to continue, dump core, or just exit. Return
898 something to indicate a quit. */
899
900struct internal_problem
901{
902 const char *name;
903 const char *should_quit;
904 const char *should_dump_core;
905};
906
907/* Report a problem, internal to GDB, to the user. Once the problem
908 has been reported, and assuming GDB didn't quit, the caller can
909 either allow execution to resume or throw an error. */
910
cf7f2e2d 911static void ATTRIBUTE_PRINTF (4, 0)
5796c8dc
SS
912internal_vproblem (struct internal_problem *problem,
913 const char *file, int line, const char *fmt, va_list ap)
914{
915 static int dejavu;
916 int quit_p;
917 int dump_core_p;
918 char *reason;
919
920 /* Don't allow infinite error/warning recursion. */
921 {
922 static char msg[] = "Recursive internal problem.\n";
cf7f2e2d 923
5796c8dc
SS
924 switch (dejavu)
925 {
926 case 0:
927 dejavu = 1;
928 break;
929 case 1:
930 dejavu = 2;
931 fputs_unfiltered (msg, gdb_stderr);
cf7f2e2d 932 abort (); /* NOTE: GDB has only three calls to abort(). */
5796c8dc
SS
933 default:
934 dejavu = 3;
935 /* Newer GLIBC versions put the warn_unused_result attribute
936 on write, but this is one of those rare cases where
937 ignoring the return value is correct. Casting to (void)
938 does not fix this problem. This is the solution suggested
939 at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
940 if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
cf7f2e2d 941 abort (); /* NOTE: GDB has only three calls to abort(). */
5796c8dc
SS
942 exit (1);
943 }
944 }
945
946 /* Try to get the message out and at the start of a new line. */
947 target_terminal_ours ();
948 begin_line ();
949
950 /* Create a string containing the full error/warning message. Need
951 to call query with this full string, as otherwize the reason
952 (error/warning) and question become separated. Format using a
953 style similar to a compiler error message. Include extra detail
954 so that the user knows that they are living on the edge. */
955 {
956 char *msg;
cf7f2e2d 957
5796c8dc 958 msg = xstrvprintf (fmt, ap);
c50c785c
JM
959 reason = xstrprintf ("%s:%d: %s: %s\n"
960 "A problem internal to GDB has been detected,\n"
961 "further debugging may prove unreliable.",
962 file, line, problem->name, msg);
5796c8dc
SS
963 xfree (msg);
964 make_cleanup (xfree, reason);
965 }
966
967 if (problem->should_quit == internal_problem_ask)
968 {
969 /* Default (yes/batch case) is to quit GDB. When in batch mode
970 this lessens the likelihood of GDB going into an infinite
971 loop. */
972 if (caution == 0)
973 {
974 /* Emit the message and quit. */
975 fputs_unfiltered (reason, gdb_stderr);
976 fputs_unfiltered ("\n", gdb_stderr);
977 quit_p = 1;
978 }
979 else
980 quit_p = query (_("%s\nQuit this debugging session? "), reason);
981 }
982 else if (problem->should_quit == internal_problem_yes)
983 quit_p = 1;
984 else if (problem->should_quit == internal_problem_no)
985 quit_p = 0;
986 else
987 internal_error (__FILE__, __LINE__, _("bad switch"));
988
989 if (problem->should_dump_core == internal_problem_ask)
990 {
cf7f2e2d
JM
991 if (!can_dump_core (reason))
992 dump_core_p = 0;
993 else
994 {
995 /* Default (yes/batch case) is to dump core. This leaves a GDB
996 `dropping' so that it is easier to see that something went
997 wrong in GDB. */
998 dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
999 }
5796c8dc
SS
1000 }
1001 else if (problem->should_dump_core == internal_problem_yes)
cf7f2e2d 1002 dump_core_p = can_dump_core (reason);
5796c8dc
SS
1003 else if (problem->should_dump_core == internal_problem_no)
1004 dump_core_p = 0;
1005 else
1006 internal_error (__FILE__, __LINE__, _("bad switch"));
1007
1008 if (quit_p)
1009 {
1010 if (dump_core_p)
cf7f2e2d 1011 dump_core ();
5796c8dc
SS
1012 else
1013 exit (1);
1014 }
1015 else
1016 {
1017 if (dump_core_p)
1018 {
1019#ifdef HAVE_WORKING_FORK
1020 if (fork () == 0)
cf7f2e2d 1021 dump_core ();
5796c8dc
SS
1022#endif
1023 }
1024 }
1025
1026 dejavu = 0;
1027}
1028
1029static struct internal_problem internal_error_problem = {
1030 "internal-error", internal_problem_ask, internal_problem_ask
1031};
1032
cf7f2e2d 1033void
5796c8dc
SS
1034internal_verror (const char *file, int line, const char *fmt, va_list ap)
1035{
1036 internal_vproblem (&internal_error_problem, file, line, fmt, ap);
1037 deprecated_throw_reason (RETURN_ERROR);
1038}
1039
cf7f2e2d 1040void
5796c8dc
SS
1041internal_error (const char *file, int line, const char *string, ...)
1042{
1043 va_list ap;
cf7f2e2d 1044
5796c8dc
SS
1045 va_start (ap, string);
1046 internal_verror (file, line, string, ap);
1047 va_end (ap);
1048}
1049
1050static struct internal_problem internal_warning_problem = {
1051 "internal-warning", internal_problem_ask, internal_problem_ask
1052};
1053
1054void
1055internal_vwarning (const char *file, int line, const char *fmt, va_list ap)
1056{
1057 internal_vproblem (&internal_warning_problem, file, line, fmt, ap);
1058}
1059
1060void
1061internal_warning (const char *file, int line, const char *string, ...)
1062{
1063 va_list ap;
cf7f2e2d 1064
5796c8dc
SS
1065 va_start (ap, string);
1066 internal_vwarning (file, line, string, ap);
1067 va_end (ap);
1068}
1069
1070/* Dummy functions to keep add_prefix_cmd happy. */
1071
1072static void
1073set_internal_problem_cmd (char *args, int from_tty)
1074{
1075}
1076
1077static void
1078show_internal_problem_cmd (char *args, int from_tty)
1079{
1080}
1081
1082/* When GDB reports an internal problem (error or warning) it gives
1083 the user the opportunity to quit GDB and/or create a core file of
1084 the current debug session. This function registers a few commands
1085 that make it possible to specify that GDB should always or never
1086 quit or create a core file, without asking. The commands look
1087 like:
1088
1089 maint set PROBLEM-NAME quit ask|yes|no
1090 maint show PROBLEM-NAME quit
1091 maint set PROBLEM-NAME corefile ask|yes|no
1092 maint show PROBLEM-NAME corefile
1093
1094 Where PROBLEM-NAME is currently "internal-error" or
1095 "internal-warning". */
1096
1097static void
1098add_internal_problem_command (struct internal_problem *problem)
1099{
1100 struct cmd_list_element **set_cmd_list;
1101 struct cmd_list_element **show_cmd_list;
1102 char *set_doc;
1103 char *show_doc;
1104
1105 set_cmd_list = xmalloc (sizeof (*set_cmd_list));
1106 show_cmd_list = xmalloc (sizeof (*set_cmd_list));
1107 *set_cmd_list = NULL;
1108 *show_cmd_list = NULL;
1109
1110 set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
1111 problem->name);
1112
1113 show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
1114 problem->name);
1115
1116 add_prefix_cmd ((char*) problem->name,
1117 class_maintenance, set_internal_problem_cmd, set_doc,
1118 set_cmd_list,
cf7f2e2d
JM
1119 concat ("maintenance set ", problem->name, " ",
1120 (char *) NULL),
5796c8dc
SS
1121 0/*allow-unknown*/, &maintenance_set_cmdlist);
1122
1123 add_prefix_cmd ((char*) problem->name,
1124 class_maintenance, show_internal_problem_cmd, show_doc,
1125 show_cmd_list,
cf7f2e2d
JM
1126 concat ("maintenance show ", problem->name, " ",
1127 (char *) NULL),
5796c8dc
SS
1128 0/*allow-unknown*/, &maintenance_show_cmdlist);
1129
c50c785c
JM
1130 set_doc = xstrprintf (_("Set whether GDB should quit "
1131 "when an %s is detected"),
5796c8dc 1132 problem->name);
c50c785c
JM
1133 show_doc = xstrprintf (_("Show whether GDB will quit "
1134 "when an %s is detected"),
5796c8dc
SS
1135 problem->name);
1136 add_setshow_enum_cmd ("quit", class_maintenance,
1137 internal_problem_modes,
1138 &problem->should_quit,
1139 set_doc,
1140 show_doc,
1141 NULL, /* help_doc */
1142 NULL, /* setfunc */
1143 NULL, /* showfunc */
1144 set_cmd_list,
1145 show_cmd_list);
1146
1147 xfree (set_doc);
1148 xfree (show_doc);
1149
c50c785c
JM
1150 set_doc = xstrprintf (_("Set whether GDB should create a core "
1151 "file of GDB when %s is detected"),
5796c8dc 1152 problem->name);
c50c785c
JM
1153 show_doc = xstrprintf (_("Show whether GDB will create a core "
1154 "file of GDB when %s is detected"),
5796c8dc
SS
1155 problem->name);
1156 add_setshow_enum_cmd ("corefile", class_maintenance,
1157 internal_problem_modes,
1158 &problem->should_dump_core,
1159 set_doc,
1160 show_doc,
1161 NULL, /* help_doc */
1162 NULL, /* setfunc */
1163 NULL, /* showfunc */
1164 set_cmd_list,
1165 show_cmd_list);
1166
1167 xfree (set_doc);
1168 xfree (show_doc);
1169}
1170
1171/* Print the system error message for errno, and also mention STRING
1172 as the file name for which the error was encountered.
1173 Then return to command level. */
1174
cf7f2e2d 1175void
5796c8dc
SS
1176perror_with_name (const char *string)
1177{
1178 char *err;
1179 char *combined;
1180
1181 err = safe_strerror (errno);
1182 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1183 strcpy (combined, string);
1184 strcat (combined, ": ");
1185 strcat (combined, err);
1186
1187 /* I understand setting these is a matter of taste. Still, some people
1188 may clear errno but not know about bfd_error. Doing this here is not
c50c785c 1189 unreasonable. */
5796c8dc
SS
1190 bfd_set_error (bfd_error_no_error);
1191 errno = 0;
1192
1193 error (_("%s."), combined);
1194}
1195
1196/* Print the system error message for ERRCODE, and also mention STRING
1197 as the file name for which the error was encountered. */
1198
1199void
1200print_sys_errmsg (const char *string, int errcode)
1201{
1202 char *err;
1203 char *combined;
1204
1205 err = safe_strerror (errcode);
1206 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
1207 strcpy (combined, string);
1208 strcat (combined, ": ");
1209 strcat (combined, err);
1210
1211 /* We want anything which was printed on stdout to come out first, before
1212 this message. */
1213 gdb_flush (gdb_stdout);
1214 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
1215}
1216
1217/* Control C eventually causes this to be called, at a convenient time. */
1218
1219void
1220quit (void)
1221{
1222#ifdef __MSDOS__
1223 /* No steenking SIGINT will ever be coming our way when the
1224 program is resumed. Don't lie. */
1225 fatal ("Quit");
1226#else
1227 if (job_control
1228 /* If there is no terminal switching for this target, then we can't
1229 possibly get screwed by the lack of job control. */
1230 || current_target.to_terminal_ours == NULL)
1231 fatal ("Quit");
1232 else
1233 fatal ("Quit (expect signal SIGINT when the program is resumed)");
1234#endif
1235}
1236
1237\f
1238/* Called when a memory allocation fails, with the number of bytes of
c50c785c 1239 memory requested in SIZE. */
5796c8dc 1240
cf7f2e2d 1241void
a45ae5f8 1242malloc_failure (long size)
5796c8dc
SS
1243{
1244 if (size > 0)
1245 {
1246 internal_error (__FILE__, __LINE__,
1247 _("virtual memory exhausted: can't allocate %ld bytes."),
1248 size);
1249 }
1250 else
1251 {
1252 internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
1253 }
1254}
1255
5796c8dc
SS
1256/* My replacement for the read system call.
1257 Used like `read' but keeps going if `read' returns too soon. */
1258
1259int
1260myread (int desc, char *addr, int len)
1261{
1262 int val;
1263 int orglen = len;
1264
1265 while (len > 0)
1266 {
1267 val = read (desc, addr, len);
1268 if (val < 0)
1269 return val;
1270 if (val == 0)
1271 return orglen - len;
1272 len -= val;
1273 addr += val;
1274 }
1275 return orglen;
1276}
a45ae5f8 1277
5796c8dc
SS
1278/* Make a copy of the string at PTR with SIZE characters
1279 (and add a null character at the end in the copy).
1280 Uses malloc to get the space. Returns the address of the copy. */
1281
1282char *
1283savestring (const char *ptr, size_t size)
1284{
1285 char *p = (char *) xmalloc (size + 1);
cf7f2e2d 1286
5796c8dc
SS
1287 memcpy (p, ptr, size);
1288 p[size] = 0;
1289 return p;
1290}
1291
1292void
1293print_spaces (int n, struct ui_file *file)
1294{
1295 fputs_unfiltered (n_spaces (n), file);
1296}
1297
1298/* Print a host address. */
1299
1300void
1301gdb_print_host_address (const void *addr, struct ui_file *stream)
1302{
1303 fprintf_filtered (stream, "%s", host_address_to_string (addr));
1304}
1305\f
1306
c50c785c
JM
1307/* A cleanup function that calls regfree. */
1308
1309static void
1310do_regfree_cleanup (void *r)
1311{
1312 regfree (r);
1313}
1314
1315/* Create a new cleanup that frees the compiled regular expression R. */
1316
1317struct cleanup *
1318make_regfree_cleanup (regex_t *r)
1319{
1320 return make_cleanup (do_regfree_cleanup, r);
1321}
1322
1323/* Return an xmalloc'd error message resulting from a regular
1324 expression compilation failure. */
1325
1326char *
1327get_regcomp_error (int code, regex_t *rx)
1328{
1329 size_t length = regerror (code, rx, NULL, 0);
1330 char *result = xmalloc (length);
1331
1332 regerror (code, rx, result, length);
1333 return result;
1334}
1335
1336\f
1337
5796c8dc
SS
1338/* This function supports the query, nquery, and yquery functions.
1339 Ask user a y-or-n question and return 0 if answer is no, 1 if
1340 answer is yes, or default the answer to the specified default
1341 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1342 default answer, or '\0' for no default.
1343 CTLSTR is the control string and should end in "? ". It should
1344 not say how to answer, because we do that.
1345 ARGS are the arguments passed along with the CTLSTR argument to
1346 printf. */
1347
cf7f2e2d 1348static int ATTRIBUTE_PRINTF (1, 0)
5796c8dc
SS
1349defaulted_query (const char *ctlstr, const char defchar, va_list args)
1350{
1351 int answer;
1352 int ans2;
1353 int retval;
1354 int def_value;
1355 char def_answer, not_def_answer;
1356 char *y_string, *n_string, *question;
1357
1358 /* Set up according to which answer is the default. */
1359 if (defchar == '\0')
1360 {
1361 def_value = 1;
1362 def_answer = 'Y';
1363 not_def_answer = 'N';
1364 y_string = "y";
1365 n_string = "n";
1366 }
1367 else if (defchar == 'y')
1368 {
1369 def_value = 1;
1370 def_answer = 'Y';
1371 not_def_answer = 'N';
1372 y_string = "[y]";
1373 n_string = "n";
1374 }
1375 else
1376 {
1377 def_value = 0;
1378 def_answer = 'N';
1379 not_def_answer = 'Y';
1380 y_string = "y";
1381 n_string = "[n]";
1382 }
1383
1384 /* Automatically answer the default value if the user did not want
1385 prompts or the command was issued with the server prefix. */
1386 if (! caution || server_command)
1387 return def_value;
1388
1389 /* If input isn't coming from the user directly, just say what
1390 question we're asking, and then answer the default automatically. This
1391 way, important error messages don't get lost when talking to GDB
1392 over a pipe. */
1393 if (! input_from_terminal_p ())
1394 {
1395 wrap_here ("");
1396 vfprintf_filtered (gdb_stdout, ctlstr, args);
1397
c50c785c
JM
1398 printf_filtered (_("(%s or %s) [answered %c; "
1399 "input not from terminal]\n"),
5796c8dc
SS
1400 y_string, n_string, def_answer);
1401 gdb_flush (gdb_stdout);
1402
1403 return def_value;
1404 }
1405
1406 if (deprecated_query_hook)
1407 {
1408 return deprecated_query_hook (ctlstr, args);
1409 }
1410
1411 /* Format the question outside of the loop, to avoid reusing args. */
1412 question = xstrvprintf (ctlstr, args);
1413
1414 while (1)
1415 {
c50c785c 1416 wrap_here (""); /* Flush any buffered output. */
5796c8dc
SS
1417 gdb_flush (gdb_stdout);
1418
1419 if (annotation_level > 1)
1420 printf_filtered (("\n\032\032pre-query\n"));
1421
1422 fputs_filtered (question, gdb_stdout);
1423 printf_filtered (_("(%s or %s) "), y_string, n_string);
1424
1425 if (annotation_level > 1)
1426 printf_filtered (("\n\032\032query\n"));
1427
1428 wrap_here ("");
1429 gdb_flush (gdb_stdout);
1430
1431 answer = fgetc (stdin);
1432
1433 /* We expect fgetc to block until a character is read. But
1434 this may not be the case if the terminal was opened with
1435 the NONBLOCK flag. In that case, if there is nothing to
1436 read on stdin, fgetc returns EOF, but also sets the error
1437 condition flag on stdin and errno to EAGAIN. With a true
1438 EOF, stdin's error condition flag is not set.
1439
1440 A situation where this behavior was observed is a pseudo
1441 terminal on AIX. */
1442 while (answer == EOF && ferror (stdin) && errno == EAGAIN)
1443 {
1444 /* Not a real EOF. Wait a little while and try again until
1445 we read something. */
1446 clearerr (stdin);
1447 gdb_usleep (10000);
1448 answer = fgetc (stdin);
1449 }
1450
1451 clearerr (stdin); /* in case of C-d */
1452 if (answer == EOF) /* C-d */
1453 {
1454 printf_filtered ("EOF [assumed %c]\n", def_answer);
1455 retval = def_value;
1456 break;
1457 }
c50c785c 1458 /* Eat rest of input line, to EOF or newline. */
5796c8dc
SS
1459 if (answer != '\n')
1460 do
1461 {
1462 ans2 = fgetc (stdin);
1463 clearerr (stdin);
1464 }
1465 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1466
1467 if (answer >= 'a')
1468 answer -= 040;
1469 /* Check answer. For the non-default, the user must specify
1470 the non-default explicitly. */
1471 if (answer == not_def_answer)
1472 {
1473 retval = !def_value;
1474 break;
1475 }
1476 /* Otherwise, if a default was specified, the user may either
1477 specify the required input or have it default by entering
1478 nothing. */
1479 if (answer == def_answer
1480 || (defchar != '\0' &&
1481 (answer == '\n' || answer == '\r' || answer == EOF)))
1482 {
1483 retval = def_value;
1484 break;
1485 }
1486 /* Invalid entries are not defaulted and require another selection. */
1487 printf_filtered (_("Please answer %s or %s.\n"),
1488 y_string, n_string);
1489 }
1490
1491 xfree (question);
1492 if (annotation_level > 1)
1493 printf_filtered (("\n\032\032post-query\n"));
1494 return retval;
1495}
1496\f
1497
1498/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1499 answer is yes, or 0 if answer is defaulted.
1500 Takes three args which are given to printf to print the question.
1501 The first, a control string, should end in "? ".
1502 It should not say how to answer, because we do that. */
1503
1504int
1505nquery (const char *ctlstr, ...)
1506{
1507 va_list args;
c50c785c 1508 int ret;
5796c8dc
SS
1509
1510 va_start (args, ctlstr);
c50c785c 1511 ret = defaulted_query (ctlstr, 'n', args);
5796c8dc 1512 va_end (args);
c50c785c 1513 return ret;
5796c8dc
SS
1514}
1515
1516/* Ask user a y-or-n question and return 0 if answer is no, 1 if
1517 answer is yes, or 1 if answer is defaulted.
1518 Takes three args which are given to printf to print the question.
1519 The first, a control string, should end in "? ".
1520 It should not say how to answer, because we do that. */
1521
1522int
1523yquery (const char *ctlstr, ...)
1524{
1525 va_list args;
c50c785c 1526 int ret;
5796c8dc
SS
1527
1528 va_start (args, ctlstr);
c50c785c 1529 ret = defaulted_query (ctlstr, 'y', args);
5796c8dc 1530 va_end (args);
c50c785c 1531 return ret;
5796c8dc
SS
1532}
1533
1534/* Ask user a y-or-n question and return 1 iff answer is yes.
1535 Takes three args which are given to printf to print the question.
1536 The first, a control string, should end in "? ".
1537 It should not say how to answer, because we do that. */
1538
1539int
1540query (const char *ctlstr, ...)
1541{
1542 va_list args;
c50c785c 1543 int ret;
5796c8dc
SS
1544
1545 va_start (args, ctlstr);
c50c785c 1546 ret = defaulted_query (ctlstr, '\0', args);
5796c8dc 1547 va_end (args);
c50c785c 1548 return ret;
5796c8dc
SS
1549}
1550
1551/* A helper for parse_escape that converts a host character to a
1552 target character. C is the host character. If conversion is
1553 possible, then the target character is stored in *TARGET_C and the
1554 function returns 1. Otherwise, the function returns 0. */
1555
1556static int
cf7f2e2d 1557host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
5796c8dc
SS
1558{
1559 struct obstack host_data;
1560 char the_char = c;
1561 struct cleanup *cleanups;
1562 int result = 0;
1563
1564 obstack_init (&host_data);
1565 cleanups = make_cleanup_obstack_free (&host_data);
1566
cf7f2e2d 1567 convert_between_encodings (target_charset (gdbarch), host_charset (),
5796c8dc
SS
1568 &the_char, 1, 1, &host_data, translit_none);
1569
1570 if (obstack_object_size (&host_data) == 1)
1571 {
1572 result = 1;
1573 *target_c = *(char *) obstack_base (&host_data);
1574 }
1575
1576 do_cleanups (cleanups);
1577 return result;
1578}
1579
1580/* Parse a C escape sequence. STRING_PTR points to a variable
1581 containing a pointer to the string to parse. That pointer
1582 should point to the character after the \. That pointer
1583 is updated past the characters we use. The value of the
1584 escape sequence is returned.
1585
1586 A negative value means the sequence \ newline was seen,
1587 which is supposed to be equivalent to nothing at all.
1588
1589 If \ is followed by a null character, we return a negative
1590 value and leave the string pointer pointing at the null character.
1591
1592 If \ is followed by 000, we return 0 and leave the string pointer
1593 after the zeros. A value of 0 does not mean end of string. */
1594
1595int
cf7f2e2d 1596parse_escape (struct gdbarch *gdbarch, char **string_ptr)
5796c8dc 1597{
c50c785c 1598 int target_char = -2; /* Initialize to avoid GCC warnings. */
5796c8dc 1599 int c = *(*string_ptr)++;
cf7f2e2d 1600
5796c8dc
SS
1601 switch (c)
1602 {
1603 case '\n':
1604 return -2;
1605 case 0:
1606 (*string_ptr)--;
1607 return 0;
1608
1609 case '0':
1610 case '1':
1611 case '2':
1612 case '3':
1613 case '4':
1614 case '5':
1615 case '6':
1616 case '7':
1617 {
1618 int i = host_hex_value (c);
1619 int count = 0;
1620 while (++count < 3)
1621 {
1622 c = (**string_ptr);
1623 if (isdigit (c) && c != '8' && c != '9')
1624 {
1625 (*string_ptr)++;
1626 i *= 8;
1627 i += host_hex_value (c);
1628 }
1629 else
1630 {
1631 break;
1632 }
1633 }
1634 return i;
1635 }
1636
1637 case 'a':
1638 c = '\a';
1639 break;
1640 case 'b':
1641 c = '\b';
1642 break;
1643 case 'f':
1644 c = '\f';
1645 break;
1646 case 'n':
1647 c = '\n';
1648 break;
1649 case 'r':
1650 c = '\r';
1651 break;
1652 case 't':
1653 c = '\t';
1654 break;
1655 case 'v':
1656 c = '\v';
1657 break;
1658
1659 default:
1660 break;
1661 }
1662
cf7f2e2d 1663 if (!host_char_to_target (gdbarch, c, &target_char))
c50c785c
JM
1664 error (_("The escape sequence `\\%c' is equivalent to plain `%c',"
1665 " which has no equivalent\nin the `%s' character set."),
1666 c, c, target_charset (gdbarch));
5796c8dc
SS
1667 return target_char;
1668}
1669\f
1670/* Print the character C on STREAM as part of the contents of a literal
1671 string whose delimiter is QUOTER. Note that this routine should only
1672 be call for printing things which are independent of the language
c50c785c 1673 of the program being debugged. */
5796c8dc
SS
1674
1675static void
1676printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
1677 void (*do_fprintf) (struct ui_file *, const char *, ...)
1678 ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
1679{
5796c8dc
SS
1680 c &= 0xFF; /* Avoid sign bit follies */
1681
1682 if (c < 0x20 || /* Low control chars */
1683 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1684 (sevenbit_strings && c >= 0x80))
1685 { /* high order bit set */
1686 switch (c)
1687 {
1688 case '\n':
1689 do_fputs ("\\n", stream);
1690 break;
1691 case '\b':
1692 do_fputs ("\\b", stream);
1693 break;
1694 case '\t':
1695 do_fputs ("\\t", stream);
1696 break;
1697 case '\f':
1698 do_fputs ("\\f", stream);
1699 break;
1700 case '\r':
1701 do_fputs ("\\r", stream);
1702 break;
1703 case '\033':
1704 do_fputs ("\\e", stream);
1705 break;
1706 case '\007':
1707 do_fputs ("\\a", stream);
1708 break;
1709 default:
1710 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1711 break;
1712 }
1713 }
1714 else
1715 {
1716 if (c == '\\' || c == quoter)
1717 do_fputs ("\\", stream);
1718 do_fprintf (stream, "%c", c);
1719 }
1720}
1721
1722/* Print the character C on STREAM as part of the contents of a
1723 literal string whose delimiter is QUOTER. Note that these routines
1724 should only be call for printing things which are independent of
c50c785c 1725 the language of the program being debugged. */
5796c8dc
SS
1726
1727void
1728fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
1729{
1730 while (*str)
1731 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1732}
1733
1734void
1735fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
1736{
1737 while (*str)
1738 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1739}
1740
1741void
1742fputstrn_filtered (const char *str, int n, int quoter,
1743 struct ui_file *stream)
1744{
1745 int i;
cf7f2e2d 1746
5796c8dc
SS
1747 for (i = 0; i < n; i++)
1748 printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
1749}
1750
1751void
1752fputstrn_unfiltered (const char *str, int n, int quoter,
1753 struct ui_file *stream)
1754{
1755 int i;
cf7f2e2d 1756
5796c8dc
SS
1757 for (i = 0; i < n; i++)
1758 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1759}
1760\f
1761
1762/* Number of lines per page or UINT_MAX if paging is disabled. */
1763static unsigned int lines_per_page;
1764static void
1765show_lines_per_page (struct ui_file *file, int from_tty,
1766 struct cmd_list_element *c, const char *value)
1767{
c50c785c
JM
1768 fprintf_filtered (file,
1769 _("Number of lines gdb thinks are in a page is %s.\n"),
5796c8dc
SS
1770 value);
1771}
1772
1773/* Number of chars per line or UINT_MAX if line folding is disabled. */
1774static unsigned int chars_per_line;
1775static void
1776show_chars_per_line (struct ui_file *file, int from_tty,
1777 struct cmd_list_element *c, const char *value)
1778{
c50c785c
JM
1779 fprintf_filtered (file,
1780 _("Number of characters gdb thinks "
1781 "are in a line is %s.\n"),
5796c8dc
SS
1782 value);
1783}
1784
1785/* Current count of lines printed on this page, chars on this line. */
1786static unsigned int lines_printed, chars_printed;
1787
1788/* Buffer and start column of buffered text, for doing smarter word-
1789 wrapping. When someone calls wrap_here(), we start buffering output
1790 that comes through fputs_filtered(). If we see a newline, we just
1791 spit it out and forget about the wrap_here(). If we see another
1792 wrap_here(), we spit it out and remember the newer one. If we see
1793 the end of the line, we spit out a newline, the indent, and then
1794 the buffered output. */
1795
1796/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1797 are waiting to be output (they have already been counted in chars_printed).
1798 When wrap_buffer[0] is null, the buffer is empty. */
1799static char *wrap_buffer;
1800
1801/* Pointer in wrap_buffer to the next character to fill. */
1802static char *wrap_pointer;
1803
1804/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1805 is non-zero. */
1806static char *wrap_indent;
1807
1808/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1809 is not in effect. */
1810static int wrap_column;
1811\f
1812
1813/* Inialize the number of lines per page and chars per line. */
1814
1815void
1816init_page_info (void)
1817{
cf7f2e2d
JM
1818 if (batch_flag)
1819 {
1820 lines_per_page = UINT_MAX;
1821 chars_per_line = UINT_MAX;
1822 }
1823 else
5796c8dc
SS
1824#if defined(TUI)
1825 if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
1826#endif
1827 {
1828 int rows, cols;
1829
1830#if defined(__GO32__)
1831 rows = ScreenRows ();
1832 cols = ScreenCols ();
1833 lines_per_page = rows;
1834 chars_per_line = cols;
1835#else
1836 /* Make sure Readline has initialized its terminal settings. */
1837 rl_reset_terminal (NULL);
1838
1839 /* Get the screen size from Readline. */
1840 rl_get_screen_size (&rows, &cols);
1841 lines_per_page = rows;
1842 chars_per_line = cols;
1843
1844 /* Readline should have fetched the termcap entry for us. */
1845 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1846 {
1847 /* The number of lines per page is not mentioned in the
1848 terminal description. This probably means that paging is
1849 not useful (e.g. emacs shell window), so disable paging. */
1850 lines_per_page = UINT_MAX;
1851 }
1852
1853 /* FIXME: Get rid of this junk. */
1854#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1855 SIGWINCH_HANDLER (SIGWINCH);
1856#endif
1857
1858 /* If the output is not a terminal, don't paginate it. */
1859 if (!ui_file_isatty (gdb_stdout))
1860 lines_per_page = UINT_MAX;
1861#endif
1862 }
1863
1864 set_screen_size ();
1865 set_width ();
1866}
1867
cf7f2e2d
JM
1868/* Helper for make_cleanup_restore_page_info. */
1869
1870static void
1871do_restore_page_info_cleanup (void *arg)
1872{
1873 set_screen_size ();
1874 set_width ();
1875}
1876
1877/* Provide cleanup for restoring the terminal size. */
1878
1879struct cleanup *
1880make_cleanup_restore_page_info (void)
1881{
1882 struct cleanup *back_to;
1883
1884 back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
1885 make_cleanup_restore_uinteger (&lines_per_page);
1886 make_cleanup_restore_uinteger (&chars_per_line);
1887
1888 return back_to;
1889}
1890
1891/* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
1892 Provide cleanup for restoring the original state. */
1893
1894struct cleanup *
1895set_batch_flag_and_make_cleanup_restore_page_info (void)
1896{
1897 struct cleanup *back_to = make_cleanup_restore_page_info ();
1898
1899 make_cleanup_restore_integer (&batch_flag);
1900 batch_flag = 1;
1901 init_page_info ();
1902
1903 return back_to;
1904}
1905
5796c8dc
SS
1906/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1907
1908static void
1909set_screen_size (void)
1910{
1911 int rows = lines_per_page;
1912 int cols = chars_per_line;
1913
1914 if (rows <= 0)
1915 rows = INT_MAX;
1916
1917 if (cols <= 0)
1918 cols = INT_MAX;
1919
1920 /* Update Readline's idea of the terminal size. */
1921 rl_set_screen_size (rows, cols);
1922}
1923
1924/* Reinitialize WRAP_BUFFER according to the current value of
1925 CHARS_PER_LINE. */
1926
1927static void
1928set_width (void)
1929{
1930 if (chars_per_line == 0)
1931 init_page_info ();
1932
1933 if (!wrap_buffer)
1934 {
1935 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1936 wrap_buffer[0] = '\0';
1937 }
1938 else
1939 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1940 wrap_pointer = wrap_buffer; /* Start it at the beginning. */
1941}
1942
1943static void
1944set_width_command (char *args, int from_tty, struct cmd_list_element *c)
1945{
1946 set_screen_size ();
1947 set_width ();
1948}
1949
1950static void
1951set_height_command (char *args, int from_tty, struct cmd_list_element *c)
1952{
1953 set_screen_size ();
1954}
1955
1956/* Wait, so the user can read what's on the screen. Prompt the user
1957 to continue by pressing RETURN. */
1958
1959static void
1960prompt_for_continue (void)
1961{
1962 char *ignore;
1963 char cont_prompt[120];
1964
1965 if (annotation_level > 1)
1966 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1967
1968 strcpy (cont_prompt,
1969 "---Type <return> to continue, or q <return> to quit---");
1970 if (annotation_level > 1)
1971 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1972
1973 /* We must do this *before* we call gdb_readline, else it will eventually
1974 call us -- thinking that we're trying to print beyond the end of the
1975 screen. */
1976 reinitialize_more_filter ();
1977
1978 immediate_quit++;
1979 /* On a real operating system, the user can quit with SIGINT.
1980 But not on GO32.
1981
1982 'q' is provided on all systems so users don't have to change habits
1983 from system to system, and because telling them what to do in
1984 the prompt is more user-friendly than expecting them to think of
1985 SIGINT. */
1986 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1987 whereas control-C to gdb_readline will cause the user to get dumped
1988 out to DOS. */
1989 ignore = gdb_readline_wrapper (cont_prompt);
1990
1991 if (annotation_level > 1)
1992 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1993
1994 if (ignore)
1995 {
1996 char *p = ignore;
cf7f2e2d 1997
5796c8dc
SS
1998 while (*p == ' ' || *p == '\t')
1999 ++p;
2000 if (p[0] == 'q')
2001 async_request_quit (0);
2002 xfree (ignore);
2003 }
2004 immediate_quit--;
2005
2006 /* Now we have to do this again, so that GDB will know that it doesn't
2007 need to save the ---Type <return>--- line at the top of the screen. */
2008 reinitialize_more_filter ();
2009
c50c785c 2010 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
5796c8dc
SS
2011}
2012
2013/* Reinitialize filter; ie. tell it to reset to original values. */
2014
2015void
2016reinitialize_more_filter (void)
2017{
2018 lines_printed = 0;
2019 chars_printed = 0;
2020}
2021
2022/* Indicate that if the next sequence of characters overflows the line,
c50c785c 2023 a newline should be inserted here rather than when it hits the end.
5796c8dc
SS
2024 If INDENT is non-null, it is a string to be printed to indent the
2025 wrapped part on the next line. INDENT must remain accessible until
2026 the next call to wrap_here() or until a newline is printed through
2027 fputs_filtered().
2028
2029 If the line is already overfull, we immediately print a newline and
2030 the indentation, and disable further wrapping.
2031
2032 If we don't know the width of lines, but we know the page height,
2033 we must not wrap words, but should still keep track of newlines
2034 that were explicitly printed.
2035
2036 INDENT should not contain tabs, as that will mess up the char count
2037 on the next line. FIXME.
2038
2039 This routine is guaranteed to force out any output which has been
2040 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
2041 used to force out output from the wrap_buffer. */
2042
2043void
2044wrap_here (char *indent)
2045{
c50c785c 2046 /* This should have been allocated, but be paranoid anyway. */
5796c8dc 2047 if (!wrap_buffer)
c50c785c
JM
2048 internal_error (__FILE__, __LINE__,
2049 _("failed internal consistency check"));
5796c8dc
SS
2050
2051 if (wrap_buffer[0])
2052 {
2053 *wrap_pointer = '\0';
2054 fputs_unfiltered (wrap_buffer, gdb_stdout);
2055 }
2056 wrap_pointer = wrap_buffer;
2057 wrap_buffer[0] = '\0';
c50c785c 2058 if (chars_per_line == UINT_MAX) /* No line overflow checking. */
5796c8dc
SS
2059 {
2060 wrap_column = 0;
2061 }
2062 else if (chars_printed >= chars_per_line)
2063 {
2064 puts_filtered ("\n");
2065 if (indent != NULL)
2066 puts_filtered (indent);
2067 wrap_column = 0;
2068 }
2069 else
2070 {
2071 wrap_column = chars_printed;
2072 if (indent == NULL)
2073 wrap_indent = "";
2074 else
2075 wrap_indent = indent;
2076 }
2077}
2078
2079/* Print input string to gdb_stdout, filtered, with wrap,
c50c785c 2080 arranging strings in columns of n chars. String can be
5796c8dc
SS
2081 right or left justified in the column. Never prints
2082 trailing spaces. String should never be longer than
2083 width. FIXME: this could be useful for the EXAMINE
c50c785c 2084 command, which currently doesn't tabulate very well. */
5796c8dc
SS
2085
2086void
2087puts_filtered_tabular (char *string, int width, int right)
2088{
2089 int spaces = 0;
2090 int stringlen;
2091 char *spacebuf;
2092
2093 gdb_assert (chars_per_line > 0);
2094 if (chars_per_line == UINT_MAX)
2095 {
2096 fputs_filtered (string, gdb_stdout);
2097 fputs_filtered ("\n", gdb_stdout);
2098 return;
2099 }
2100
2101 if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
2102 fputs_filtered ("\n", gdb_stdout);
2103
2104 if (width >= chars_per_line)
2105 width = chars_per_line - 1;
2106
2107 stringlen = strlen (string);
2108
2109 if (chars_printed > 0)
2110 spaces = width - (chars_printed - 1) % width - 1;
2111 if (right)
2112 spaces += width - stringlen;
2113
2114 spacebuf = alloca (spaces + 1);
2115 spacebuf[spaces] = '\0';
2116 while (spaces--)
2117 spacebuf[spaces] = ' ';
2118
2119 fputs_filtered (spacebuf, gdb_stdout);
2120 fputs_filtered (string, gdb_stdout);
2121}
2122
2123
2124/* Ensure that whatever gets printed next, using the filtered output
c50c785c 2125 commands, starts at the beginning of the line. I.e. if there is
5796c8dc 2126 any pending output for the current line, flush it and start a new
c50c785c 2127 line. Otherwise do nothing. */
5796c8dc
SS
2128
2129void
2130begin_line (void)
2131{
2132 if (chars_printed > 0)
2133 {
2134 puts_filtered ("\n");
2135 }
2136}
2137
2138
2139/* Like fputs but if FILTER is true, pause after every screenful.
2140
2141 Regardless of FILTER can wrap at points other than the final
2142 character of a line.
2143
2144 Unlike fputs, fputs_maybe_filtered does not return a value.
2145 It is OK for LINEBUFFER to be NULL, in which case just don't print
2146 anything.
2147
2148 Note that a longjmp to top level may occur in this routine (only if
2149 FILTER is true) (since prompt_for_continue may do so) so this
2150 routine should not be called when cleanups are not in place. */
2151
2152static void
2153fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
2154 int filter)
2155{
2156 const char *lineptr;
2157
2158 if (linebuffer == 0)
2159 return;
2160
2161 /* Don't do any filtering if it is disabled. */
cf7f2e2d 2162 if (stream != gdb_stdout
a45ae5f8
JM
2163 || !pagination_enabled
2164 || batch_flag
cf7f2e2d
JM
2165 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
2166 || top_level_interpreter () == NULL
2167 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
5796c8dc
SS
2168 {
2169 fputs_unfiltered (linebuffer, stream);
2170 return;
2171 }
2172
2173 /* Go through and output each character. Show line extension
2174 when this is necessary; prompt user for new page when this is
2175 necessary. */
2176
2177 lineptr = linebuffer;
2178 while (*lineptr)
2179 {
2180 /* Possible new page. */
2181 if (filter && (lines_printed >= lines_per_page - 1))
2182 prompt_for_continue ();
2183
2184 while (*lineptr && *lineptr != '\n')
2185 {
2186 /* Print a single line. */
2187 if (*lineptr == '\t')
2188 {
2189 if (wrap_column)
2190 *wrap_pointer++ = '\t';
2191 else
2192 fputc_unfiltered ('\t', stream);
2193 /* Shifting right by 3 produces the number of tab stops
2194 we have already passed, and then adding one and
2195 shifting left 3 advances to the next tab stop. */
2196 chars_printed = ((chars_printed >> 3) + 1) << 3;
2197 lineptr++;
2198 }
2199 else
2200 {
2201 if (wrap_column)
2202 *wrap_pointer++ = *lineptr;
2203 else
2204 fputc_unfiltered (*lineptr, stream);
2205 chars_printed++;
2206 lineptr++;
2207 }
2208
2209 if (chars_printed >= chars_per_line)
2210 {
2211 unsigned int save_chars = chars_printed;
2212
2213 chars_printed = 0;
2214 lines_printed++;
2215 /* If we aren't actually wrapping, don't output newline --
2216 if chars_per_line is right, we probably just overflowed
2217 anyway; if it's wrong, let us keep going. */
2218 if (wrap_column)
2219 fputc_unfiltered ('\n', stream);
2220
2221 /* Possible new page. */
2222 if (lines_printed >= lines_per_page - 1)
2223 prompt_for_continue ();
2224
c50c785c 2225 /* Now output indentation and wrapped string. */
5796c8dc
SS
2226 if (wrap_column)
2227 {
2228 fputs_unfiltered (wrap_indent, stream);
c50c785c
JM
2229 *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
2230 fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
5796c8dc
SS
2231 /* FIXME, this strlen is what prevents wrap_indent from
2232 containing tabs. However, if we recurse to print it
2233 and count its chars, we risk trouble if wrap_indent is
c50c785c 2234 longer than (the user settable) chars_per_line.
5796c8dc
SS
2235 Note also that this can set chars_printed > chars_per_line
2236 if we are printing a long string. */
2237 chars_printed = strlen (wrap_indent)
2238 + (save_chars - wrap_column);
2239 wrap_pointer = wrap_buffer; /* Reset buffer */
2240 wrap_buffer[0] = '\0';
2241 wrap_column = 0; /* And disable fancy wrap */
2242 }
2243 }
2244 }
2245
2246 if (*lineptr == '\n')
2247 {
2248 chars_printed = 0;
c50c785c
JM
2249 wrap_here ((char *) 0); /* Spit out chars, cancel
2250 further wraps. */
5796c8dc
SS
2251 lines_printed++;
2252 fputc_unfiltered ('\n', stream);
2253 lineptr++;
2254 }
2255 }
2256}
2257
2258void
2259fputs_filtered (const char *linebuffer, struct ui_file *stream)
2260{
2261 fputs_maybe_filtered (linebuffer, stream, 1);
2262}
2263
2264int
2265putchar_unfiltered (int c)
2266{
2267 char buf = c;
cf7f2e2d 2268
5796c8dc
SS
2269 ui_file_write (gdb_stdout, &buf, 1);
2270 return c;
2271}
2272
2273/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2274 May return nonlocally. */
2275
2276int
2277putchar_filtered (int c)
2278{
2279 return fputc_filtered (c, gdb_stdout);
2280}
2281
2282int
2283fputc_unfiltered (int c, struct ui_file *stream)
2284{
2285 char buf = c;
cf7f2e2d 2286
5796c8dc
SS
2287 ui_file_write (stream, &buf, 1);
2288 return c;
2289}
2290
2291int
2292fputc_filtered (int c, struct ui_file *stream)
2293{
2294 char buf[2];
2295
2296 buf[0] = c;
2297 buf[1] = 0;
2298 fputs_filtered (buf, stream);
2299 return c;
2300}
2301
2302/* puts_debug is like fputs_unfiltered, except it prints special
2303 characters in printable fashion. */
2304
2305void
2306puts_debug (char *prefix, char *string, char *suffix)
2307{
2308 int ch;
2309
2310 /* Print prefix and suffix after each line. */
2311 static int new_line = 1;
2312 static int return_p = 0;
2313 static char *prev_prefix = "";
2314 static char *prev_suffix = "";
2315
2316 if (*string == '\n')
2317 return_p = 0;
2318
2319 /* If the prefix is changing, print the previous suffix, a new line,
2320 and the new prefix. */
2321 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2322 {
2323 fputs_unfiltered (prev_suffix, gdb_stdlog);
2324 fputs_unfiltered ("\n", gdb_stdlog);
2325 fputs_unfiltered (prefix, gdb_stdlog);
2326 }
2327
2328 /* Print prefix if we printed a newline during the previous call. */
2329 if (new_line)
2330 {
2331 new_line = 0;
2332 fputs_unfiltered (prefix, gdb_stdlog);
2333 }
2334
2335 prev_prefix = prefix;
2336 prev_suffix = suffix;
2337
2338 /* Output characters in a printable format. */
2339 while ((ch = *string++) != '\0')
2340 {
2341 switch (ch)
2342 {
2343 default:
2344 if (isprint (ch))
2345 fputc_unfiltered (ch, gdb_stdlog);
2346
2347 else
2348 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2349 break;
2350
2351 case '\\':
2352 fputs_unfiltered ("\\\\", gdb_stdlog);
2353 break;
2354 case '\b':
2355 fputs_unfiltered ("\\b", gdb_stdlog);
2356 break;
2357 case '\f':
2358 fputs_unfiltered ("\\f", gdb_stdlog);
2359 break;
2360 case '\n':
2361 new_line = 1;
2362 fputs_unfiltered ("\\n", gdb_stdlog);
2363 break;
2364 case '\r':
2365 fputs_unfiltered ("\\r", gdb_stdlog);
2366 break;
2367 case '\t':
2368 fputs_unfiltered ("\\t", gdb_stdlog);
2369 break;
2370 case '\v':
2371 fputs_unfiltered ("\\v", gdb_stdlog);
2372 break;
2373 }
2374
2375 return_p = ch == '\r';
2376 }
2377
2378 /* Print suffix if we printed a newline. */
2379 if (new_line)
2380 {
2381 fputs_unfiltered (suffix, gdb_stdlog);
2382 fputs_unfiltered ("\n", gdb_stdlog);
2383 }
2384}
2385
2386
2387/* Print a variable number of ARGS using format FORMAT. If this
2388 information is going to put the amount written (since the last call
2389 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2390 call prompt_for_continue to get the users permision to continue.
2391
2392 Unlike fprintf, this function does not return a value.
2393
2394 We implement three variants, vfprintf (takes a vararg list and stream),
2395 fprintf (takes a stream to write on), and printf (the usual).
2396
2397 Note also that a longjmp to top level may occur in this routine
2398 (since prompt_for_continue may do so) so this routine should not be
2399 called when cleanups are not in place. */
2400
2401static void
2402vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
2403 va_list args, int filter)
2404{
2405 char *linebuffer;
2406 struct cleanup *old_cleanups;
2407
2408 linebuffer = xstrvprintf (format, args);
2409 old_cleanups = make_cleanup (xfree, linebuffer);
2410 fputs_maybe_filtered (linebuffer, stream, filter);
2411 do_cleanups (old_cleanups);
2412}
2413
2414
2415void
2416vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
2417{
2418 vfprintf_maybe_filtered (stream, format, args, 1);
2419}
2420
2421void
2422vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
2423{
2424 char *linebuffer;
2425 struct cleanup *old_cleanups;
2426
2427 linebuffer = xstrvprintf (format, args);
2428 old_cleanups = make_cleanup (xfree, linebuffer);
2429 if (debug_timestamp && stream == gdb_stdlog)
2430 {
2431 struct timeval tm;
2432 char *timestamp;
2433 int len, need_nl;
2434
2435 gettimeofday (&tm, NULL);
2436
2437 len = strlen (linebuffer);
2438 need_nl = (len > 0 && linebuffer[len - 1] != '\n');
2439
2440 timestamp = xstrprintf ("%ld:%ld %s%s",
2441 (long) tm.tv_sec, (long) tm.tv_usec,
2442 linebuffer,
2443 need_nl ? "\n": "");
2444 make_cleanup (xfree, timestamp);
2445 fputs_unfiltered (timestamp, stream);
2446 }
2447 else
2448 fputs_unfiltered (linebuffer, stream);
2449 do_cleanups (old_cleanups);
2450}
2451
2452void
2453vprintf_filtered (const char *format, va_list args)
2454{
2455 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2456}
2457
2458void
2459vprintf_unfiltered (const char *format, va_list args)
2460{
2461 vfprintf_unfiltered (gdb_stdout, format, args);
2462}
2463
2464void
2465fprintf_filtered (struct ui_file *stream, const char *format, ...)
2466{
2467 va_list args;
cf7f2e2d 2468
5796c8dc
SS
2469 va_start (args, format);
2470 vfprintf_filtered (stream, format, args);
2471 va_end (args);
2472}
2473
2474void
2475fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
2476{
2477 va_list args;
cf7f2e2d 2478
5796c8dc
SS
2479 va_start (args, format);
2480 vfprintf_unfiltered (stream, format, args);
2481 va_end (args);
2482}
2483
2484/* Like fprintf_filtered, but prints its result indented.
2485 Called as fprintfi_filtered (spaces, stream, format, ...); */
2486
2487void
2488fprintfi_filtered (int spaces, struct ui_file *stream, const char *format,
2489 ...)
2490{
2491 va_list args;
cf7f2e2d 2492
5796c8dc
SS
2493 va_start (args, format);
2494 print_spaces_filtered (spaces, stream);
2495
2496 vfprintf_filtered (stream, format, args);
2497 va_end (args);
2498}
2499
2500
2501void
2502printf_filtered (const char *format, ...)
2503{
2504 va_list args;
cf7f2e2d 2505
5796c8dc
SS
2506 va_start (args, format);
2507 vfprintf_filtered (gdb_stdout, format, args);
2508 va_end (args);
2509}
2510
2511
2512void
2513printf_unfiltered (const char *format, ...)
2514{
2515 va_list args;
cf7f2e2d 2516
5796c8dc
SS
2517 va_start (args, format);
2518 vfprintf_unfiltered (gdb_stdout, format, args);
2519 va_end (args);
2520}
2521
2522/* Like printf_filtered, but prints it's result indented.
2523 Called as printfi_filtered (spaces, format, ...); */
2524
2525void
2526printfi_filtered (int spaces, const char *format, ...)
2527{
2528 va_list args;
cf7f2e2d 2529
5796c8dc
SS
2530 va_start (args, format);
2531 print_spaces_filtered (spaces, gdb_stdout);
2532 vfprintf_filtered (gdb_stdout, format, args);
2533 va_end (args);
2534}
2535
2536/* Easy -- but watch out!
2537
2538 This routine is *not* a replacement for puts()! puts() appends a newline.
2539 This one doesn't, and had better not! */
2540
2541void
2542puts_filtered (const char *string)
2543{
2544 fputs_filtered (string, gdb_stdout);
2545}
2546
2547void
2548puts_unfiltered (const char *string)
2549{
2550 fputs_unfiltered (string, gdb_stdout);
2551}
2552
2553/* Return a pointer to N spaces and a null. The pointer is good
2554 until the next call to here. */
2555char *
2556n_spaces (int n)
2557{
2558 char *t;
2559 static char *spaces = 0;
2560 static int max_spaces = -1;
2561
2562 if (n > max_spaces)
2563 {
2564 if (spaces)
2565 xfree (spaces);
2566 spaces = (char *) xmalloc (n + 1);
2567 for (t = spaces + n; t != spaces;)
2568 *--t = ' ';
2569 spaces[n] = '\0';
2570 max_spaces = n;
2571 }
2572
2573 return spaces + max_spaces - n;
2574}
2575
2576/* Print N spaces. */
2577void
2578print_spaces_filtered (int n, struct ui_file *stream)
2579{
2580 fputs_filtered (n_spaces (n), stream);
2581}
2582\f
2583/* C++/ObjC demangler stuff. */
2584
2585/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2586 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2587 If the name is not mangled, or the language for the name is unknown, or
c50c785c 2588 demangling is off, the name is printed in its "raw" form. */
5796c8dc
SS
2589
2590void
2591fprintf_symbol_filtered (struct ui_file *stream, char *name,
2592 enum language lang, int arg_mode)
2593{
2594 char *demangled;
2595
2596 if (name != NULL)
2597 {
2598 /* If user wants to see raw output, no problem. */
2599 if (!demangle)
2600 {
2601 fputs_filtered (name, stream);
2602 }
2603 else
2604 {
2605 demangled = language_demangle (language_def (lang), name, arg_mode);
2606 fputs_filtered (demangled ? demangled : name, stream);
2607 if (demangled != NULL)
2608 {
2609 xfree (demangled);
2610 }
2611 }
2612 }
2613}
2614
2615/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2616 differences in whitespace. Returns 0 if they match, non-zero if they
2617 don't (slightly different than strcmp()'s range of return values).
2618
2619 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2620 This "feature" is useful when searching for matching C++ function names
2621 (such as if the user types 'break FOO', where FOO is a mangled C++
c50c785c 2622 function). */
5796c8dc
SS
2623
2624int
2625strcmp_iw (const char *string1, const char *string2)
2626{
2627 while ((*string1 != '\0') && (*string2 != '\0'))
2628 {
2629 while (isspace (*string1))
2630 {
2631 string1++;
2632 }
2633 while (isspace (*string2))
2634 {
2635 string2++;
2636 }
a45ae5f8
JM
2637 if (case_sensitivity == case_sensitive_on && *string1 != *string2)
2638 break;
2639 if (case_sensitivity == case_sensitive_off
2640 && (tolower ((unsigned char) *string1)
2641 != tolower ((unsigned char) *string2)))
2642 break;
5796c8dc
SS
2643 if (*string1 != '\0')
2644 {
2645 string1++;
2646 string2++;
2647 }
2648 }
2649 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2650}
2651
2652/* This is like strcmp except that it ignores whitespace and treats
2653 '(' as the first non-NULL character in terms of ordering. Like
2654 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2655 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2656 according to that ordering.
2657
2658 If a list is sorted according to this function and if you want to
2659 find names in the list that match some fixed NAME according to
2660 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2661 where this function would put NAME.
2662
a45ae5f8
JM
2663 This function must be neutral to the CASE_SENSITIVITY setting as the user
2664 may choose it during later lookup. Therefore this function always sorts
2665 primarily case-insensitively and secondarily case-sensitively.
2666
5796c8dc
SS
2667 Here are some examples of why using strcmp to sort is a bad idea:
2668
2669 Whitespace example:
2670
2671 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2672 we try to do a search for "foo<char*>", strcmp will locate this
2673 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2674 will start looking at strings beginning with "goo", and will never
2675 see the correct match of "foo<char *>".
2676
2677 Parenthesis example:
2678
2679 In practice, this is less like to be an issue, but I'll give it a
2680 shot. Let's assume that '$' is a legitimate character to occur in
2681 symbols. (Which may well even be the case on some systems.) Then
2682 say that the partial symbol table contains "foo$" and "foo(int)".
2683 strcmp will put them in this order, since '$' < '('. Now, if the
2684 user searches for "foo", then strcmp will sort "foo" before "foo$".
2685 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2686 "foo") is false, so it won't proceed to the actual match of
2687 "foo(int)" with "foo". */
2688
2689int
2690strcmp_iw_ordered (const char *string1, const char *string2)
2691{
a45ae5f8
JM
2692 const char *saved_string1 = string1, *saved_string2 = string2;
2693 enum case_sensitivity case_pass = case_sensitive_off;
2694
2695 for (;;)
5796c8dc 2696 {
a45ae5f8
JM
2697 /* C1 and C2 are valid only if *string1 != '\0' && *string2 != '\0'.
2698 Provide stub characters if we are already at the end of one of the
2699 strings. */
2700 char c1 = 'X', c2 = 'X';
2701
2702 while (*string1 != '\0' && *string2 != '\0')
5796c8dc 2703 {
a45ae5f8
JM
2704 while (isspace (*string1))
2705 string1++;
2706 while (isspace (*string2))
2707 string2++;
2708
2709 switch (case_pass)
2710 {
2711 case case_sensitive_off:
2712 c1 = tolower ((unsigned char) *string1);
2713 c2 = tolower ((unsigned char) *string2);
2714 break;
2715 case case_sensitive_on:
2716 c1 = *string1;
2717 c2 = *string2;
2718 break;
2719 }
2720 if (c1 != c2)
2721 break;
2722
2723 if (*string1 != '\0')
2724 {
2725 string1++;
2726 string2++;
2727 }
5796c8dc 2728 }
a45ae5f8
JM
2729
2730 switch (*string1)
5796c8dc 2731 {
a45ae5f8
JM
2732 /* Characters are non-equal unless they're both '\0'; we want to
2733 make sure we get the comparison right according to our
2734 comparison in the cases where one of them is '\0' or '('. */
2735 case '\0':
2736 if (*string2 == '\0')
2737 break;
2738 else
2739 return -1;
2740 case '(':
2741 if (*string2 == '\0')
2742 return 1;
2743 else
2744 return -1;
2745 default:
2746 if (*string2 == '\0' || *string2 == '(')
2747 return 1;
2748 else if (c1 > c2)
2749 return 1;
2750 else if (c1 < c2)
2751 return -1;
2752 /* PASSTHRU */
5796c8dc 2753 }
5796c8dc 2754
a45ae5f8 2755 if (case_pass == case_sensitive_on)
5796c8dc 2756 return 0;
a45ae5f8
JM
2757
2758 /* Otherwise the strings were equal in case insensitive way, make
2759 a more fine grained comparison in a case sensitive way. */
2760
2761 case_pass = case_sensitive_on;
2762 string1 = saved_string1;
2763 string2 = saved_string2;
5796c8dc
SS
2764 }
2765}
2766
2767/* A simple comparison function with opposite semantics to strcmp. */
2768
2769int
2770streq (const char *lhs, const char *rhs)
2771{
2772 return !strcmp (lhs, rhs);
2773}
2774\f
2775
2776/*
2777 ** subset_compare()
2778 ** Answer whether string_to_compare is a full or partial match to
2779 ** template_string. The partial match must be in sequence starting
2780 ** at index 0.
2781 */
2782int
2783subset_compare (char *string_to_compare, char *template_string)
2784{
2785 int match;
cf7f2e2d 2786
5796c8dc
SS
2787 if (template_string != (char *) NULL && string_to_compare != (char *) NULL
2788 && strlen (string_to_compare) <= strlen (template_string))
2789 match =
2790 (strncmp
2791 (template_string, string_to_compare, strlen (string_to_compare)) == 0);
2792 else
2793 match = 0;
2794 return match;
2795}
2796
2797static void
2798pagination_on_command (char *arg, int from_tty)
2799{
2800 pagination_enabled = 1;
2801}
2802
2803static void
2804pagination_off_command (char *arg, int from_tty)
2805{
2806 pagination_enabled = 0;
2807}
2808
2809static void
2810show_debug_timestamp (struct ui_file *file, int from_tty,
2811 struct cmd_list_element *c, const char *value)
2812{
c50c785c
JM
2813 fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
2814 value);
5796c8dc
SS
2815}
2816\f
2817
2818void
2819initialize_utils (void)
2820{
5796c8dc
SS
2821 add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
2822Set number of characters gdb thinks are in a line."), _("\
2823Show number of characters gdb thinks are in a line."), NULL,
2824 set_width_command,
2825 show_chars_per_line,
2826 &setlist, &showlist);
2827
2828 add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
2829Set number of lines gdb thinks are in a page."), _("\
2830Show number of lines gdb thinks are in a page."), NULL,
2831 set_height_command,
2832 show_lines_per_page,
2833 &setlist, &showlist);
2834
2835 init_page_info ();
2836
5796c8dc
SS
2837 add_setshow_boolean_cmd ("pagination", class_support,
2838 &pagination_enabled, _("\
2839Set state of pagination."), _("\
2840Show state of pagination."), NULL,
2841 NULL,
2842 show_pagination_enabled,
2843 &setlist, &showlist);
2844
2845 if (xdb_commands)
2846 {
2847 add_com ("am", class_support, pagination_on_command,
2848 _("Enable pagination"));
2849 add_com ("sm", class_support, pagination_off_command,
2850 _("Disable pagination"));
2851 }
2852
2853 add_setshow_boolean_cmd ("sevenbit-strings", class_support,
2854 &sevenbit_strings, _("\
2855Set printing of 8-bit characters in strings as \\nnn."), _("\
2856Show printing of 8-bit characters in strings as \\nnn."), NULL,
2857 NULL,
2858 show_sevenbit_strings,
2859 &setprintlist, &showprintlist);
2860
5796c8dc
SS
2861 add_setshow_boolean_cmd ("timestamp", class_maintenance,
2862 &debug_timestamp, _("\
2863Set timestamping of debugging messages."), _("\
2864Show timestamping of debugging messages."), _("\
2865When set, debugging messages will be marked with seconds and microseconds."),
2866 NULL,
2867 show_debug_timestamp,
2868 &setdebuglist, &showdebuglist);
2869}
2870
c50c785c 2871/* Machine specific function to handle SIGWINCH signal. */
5796c8dc
SS
2872
2873#ifdef SIGWINCH_HANDLER_BODY
2874SIGWINCH_HANDLER_BODY
2875#endif
c50c785c
JM
2876/* Print routines to handle variable size regs, etc. */
2877/* Temporary storage using circular buffer. */
5796c8dc
SS
2878#define NUMCELLS 16
2879#define CELLSIZE 50
2880static char *
2881get_cell (void)
2882{
2883 static char buf[NUMCELLS][CELLSIZE];
2884 static int cell = 0;
cf7f2e2d 2885
5796c8dc
SS
2886 if (++cell >= NUMCELLS)
2887 cell = 0;
2888 return buf[cell];
2889}
2890
2891const char *
2892paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
2893{
2894 /* Truncate address to the size of a target address, avoiding shifts
2895 larger or equal than the width of a CORE_ADDR. The local
2896 variable ADDR_BIT stops the compiler reporting a shift overflow
c50c785c 2897 when it won't occur. */
5796c8dc
SS
2898 /* NOTE: This assumes that the significant address information is
2899 kept in the least significant bits of ADDR - the upper bits were
2900 either zero or sign extended. Should gdbarch_address_to_pointer or
2901 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2902
2903 int addr_bit = gdbarch_addr_bit (gdbarch);
2904
2905 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2906 addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
2907 return hex_string (addr);
2908}
2909
c50c785c
JM
2910/* This function is described in "defs.h". */
2911
2912const char *
2913print_core_address (struct gdbarch *gdbarch, CORE_ADDR address)
2914{
2915 int addr_bit = gdbarch_addr_bit (gdbarch);
2916
2917 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2918 address &= ((CORE_ADDR) 1 << addr_bit) - 1;
2919
2920 /* FIXME: cagney/2002-05-03: Need local_address_string() function
2921 that returns the language localized string formatted to a width
2922 based on gdbarch_addr_bit. */
2923 if (addr_bit <= 32)
2924 return hex_string_custom (address, 8);
2925 else
2926 return hex_string_custom (address, 16);
2927}
2928
a45ae5f8
JM
2929/* Callback hash_f for htab_create_alloc or htab_create_alloc_ex. */
2930
2931hashval_t
2932core_addr_hash (const void *ap)
2933{
2934 const CORE_ADDR *addrp = ap;
2935
2936 return *addrp;
2937}
2938
2939/* Callback eq_f for htab_create_alloc or htab_create_alloc_ex. */
2940
2941int
2942core_addr_eq (const void *ap, const void *bp)
2943{
2944 const CORE_ADDR *addr_ap = ap;
2945 const CORE_ADDR *addr_bp = bp;
2946
2947 return *addr_ap == *addr_bp;
2948}
2949
5796c8dc
SS
2950static char *
2951decimal2str (char *sign, ULONGEST addr, int width)
2952{
2953 /* Steal code from valprint.c:print_decimal(). Should this worry
c50c785c 2954 about the real size of addr as the above does? */
5796c8dc
SS
2955 unsigned long temp[3];
2956 char *str = get_cell ();
5796c8dc 2957 int i = 0;
cf7f2e2d 2958
5796c8dc
SS
2959 do
2960 {
2961 temp[i] = addr % (1000 * 1000 * 1000);
2962 addr /= (1000 * 1000 * 1000);
2963 i++;
2964 width -= 9;
2965 }
2966 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
2967
2968 width += 9;
2969 if (width < 0)
2970 width = 0;
2971
2972 switch (i)
2973 {
2974 case 1:
2975 xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
2976 break;
2977 case 2:
2978 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
2979 temp[1], temp[0]);
2980 break;
2981 case 3:
2982 xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
2983 temp[2], temp[1], temp[0]);
2984 break;
2985 default:
2986 internal_error (__FILE__, __LINE__,
2987 _("failed internal consistency check"));
2988 }
2989
2990 return str;
2991}
2992
2993static char *
2994octal2str (ULONGEST addr, int width)
2995{
2996 unsigned long temp[3];
2997 char *str = get_cell ();
5796c8dc 2998 int i = 0;
cf7f2e2d 2999
5796c8dc
SS
3000 do
3001 {
3002 temp[i] = addr % (0100000 * 0100000);
3003 addr /= (0100000 * 0100000);
3004 i++;
3005 width -= 10;
3006 }
3007 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3008
3009 width += 10;
3010 if (width < 0)
3011 width = 0;
3012
3013 switch (i)
3014 {
3015 case 1:
3016 if (temp[0] == 0)
3017 xsnprintf (str, CELLSIZE, "%*o", width, 0);
3018 else
3019 xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
3020 break;
3021 case 2:
3022 xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
3023 break;
3024 case 3:
3025 xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
3026 temp[2], temp[1], temp[0]);
3027 break;
3028 default:
3029 internal_error (__FILE__, __LINE__,
3030 _("failed internal consistency check"));
3031 }
3032
3033 return str;
3034}
3035
3036char *
3037pulongest (ULONGEST u)
3038{
3039 return decimal2str ("", u, 0);
3040}
3041
3042char *
3043plongest (LONGEST l)
3044{
3045 if (l < 0)
3046 return decimal2str ("-", -l, 0);
3047 else
3048 return decimal2str ("", l, 0);
3049}
3050
3051/* Eliminate warning from compiler on 32-bit systems. */
3052static int thirty_two = 32;
3053
3054char *
3055phex (ULONGEST l, int sizeof_l)
3056{
3057 char *str;
3058
3059 switch (sizeof_l)
3060 {
3061 case 8:
3062 str = get_cell ();
3063 xsnprintf (str, CELLSIZE, "%08lx%08lx",
3064 (unsigned long) (l >> thirty_two),
3065 (unsigned long) (l & 0xffffffff));
3066 break;
3067 case 4:
3068 str = get_cell ();
3069 xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
3070 break;
3071 case 2:
3072 str = get_cell ();
3073 xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
3074 break;
3075 default:
3076 str = phex (l, sizeof (l));
3077 break;
3078 }
3079
3080 return str;
3081}
3082
3083char *
3084phex_nz (ULONGEST l, int sizeof_l)
3085{
3086 char *str;
3087
3088 switch (sizeof_l)
3089 {
3090 case 8:
3091 {
3092 unsigned long high = (unsigned long) (l >> thirty_two);
cf7f2e2d 3093
5796c8dc
SS
3094 str = get_cell ();
3095 if (high == 0)
3096 xsnprintf (str, CELLSIZE, "%lx",
3097 (unsigned long) (l & 0xffffffff));
3098 else
3099 xsnprintf (str, CELLSIZE, "%lx%08lx", high,
3100 (unsigned long) (l & 0xffffffff));
3101 break;
3102 }
3103 case 4:
3104 str = get_cell ();
3105 xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
3106 break;
3107 case 2:
3108 str = get_cell ();
3109 xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
3110 break;
3111 default:
3112 str = phex_nz (l, sizeof (l));
3113 break;
3114 }
3115
3116 return str;
3117}
3118
3119/* Converts a LONGEST to a C-format hexadecimal literal and stores it
3120 in a static string. Returns a pointer to this string. */
3121char *
3122hex_string (LONGEST num)
3123{
3124 char *result = get_cell ();
cf7f2e2d 3125
5796c8dc
SS
3126 xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
3127 return result;
3128}
3129
3130/* Converts a LONGEST number to a C-format hexadecimal literal and
3131 stores it in a static string. Returns a pointer to this string
3132 that is valid until the next call. The number is padded on the
3133 left with 0s to at least WIDTH characters. */
3134char *
3135hex_string_custom (LONGEST num, int width)
3136{
3137 char *result = get_cell ();
3138 char *result_end = result + CELLSIZE - 1;
3139 const char *hex = phex_nz (num, sizeof (num));
3140 int hex_len = strlen (hex);
3141
3142 if (hex_len > width)
3143 width = hex_len;
3144 if (width + 2 >= CELLSIZE)
c50c785c
JM
3145 internal_error (__FILE__, __LINE__, _("\
3146hex_string_custom: insufficient space to store result"));
5796c8dc
SS
3147
3148 strcpy (result_end - width - 2, "0x");
3149 memset (result_end - width, '0', width);
3150 strcpy (result_end - hex_len, hex);
3151 return result_end - width - 2;
3152}
3153
3154/* Convert VAL to a numeral in the given radix. For
3155 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
3156 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
3157 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
3158 * to use C format in all cases. If it is false, then 'x'
c50c785c 3159 * and 'o' formats do not include a prefix (0x or leading 0). */
5796c8dc
SS
3160
3161char *
3162int_string (LONGEST val, int radix, int is_signed, int width,
3163 int use_c_format)
3164{
3165 switch (radix)
3166 {
3167 case 16:
3168 {
3169 char *result;
cf7f2e2d 3170
5796c8dc
SS
3171 if (width == 0)
3172 result = hex_string (val);
3173 else
3174 result = hex_string_custom (val, width);
3175 if (! use_c_format)
3176 result += 2;
3177 return result;
3178 }
3179 case 10:
3180 {
3181 if (is_signed && val < 0)
3182 return decimal2str ("-", -val, width);
3183 else
3184 return decimal2str ("", val, width);
3185 }
3186 case 8:
3187 {
3188 char *result = octal2str (val, width);
cf7f2e2d 3189
5796c8dc
SS
3190 if (use_c_format || val == 0)
3191 return result;
3192 else
3193 return result + 1;
3194 }
3195 default:
3196 internal_error (__FILE__, __LINE__,
3197 _("failed internal consistency check"));
3198 }
3199}
3200
3201/* Convert a CORE_ADDR into a string. */
3202const char *
3203core_addr_to_string (const CORE_ADDR addr)
3204{
3205 char *str = get_cell ();
cf7f2e2d 3206
5796c8dc
SS
3207 strcpy (str, "0x");
3208 strcat (str, phex (addr, sizeof (addr)));
3209 return str;
3210}
3211
3212const char *
3213core_addr_to_string_nz (const CORE_ADDR addr)
3214{
3215 char *str = get_cell ();
cf7f2e2d 3216
5796c8dc
SS
3217 strcpy (str, "0x");
3218 strcat (str, phex_nz (addr, sizeof (addr)));
3219 return str;
3220}
3221
3222/* Convert a string back into a CORE_ADDR. */
3223CORE_ADDR
3224string_to_core_addr (const char *my_string)
3225{
3226 CORE_ADDR addr = 0;
3227
3228 if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
3229 {
3230 /* Assume that it is in hex. */
3231 int i;
cf7f2e2d 3232
5796c8dc
SS
3233 for (i = 2; my_string[i] != '\0'; i++)
3234 {
3235 if (isdigit (my_string[i]))
3236 addr = (my_string[i] - '0') + (addr * 16);
3237 else if (isxdigit (my_string[i]))
3238 addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
3239 else
3240 error (_("invalid hex \"%s\""), my_string);
3241 }
3242 }
3243 else
3244 {
3245 /* Assume that it is in decimal. */
3246 int i;
cf7f2e2d 3247
5796c8dc
SS
3248 for (i = 0; my_string[i] != '\0'; i++)
3249 {
3250 if (isdigit (my_string[i]))
3251 addr = (my_string[i] - '0') + (addr * 10);
3252 else
3253 error (_("invalid decimal \"%s\""), my_string);
3254 }
3255 }
3256
3257 return addr;
3258}
3259
3260const char *
3261host_address_to_string (const void *addr)
3262{
3263 char *str = get_cell ();
3264
3265 xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
3266 return str;
3267}
3268
3269char *
3270gdb_realpath (const char *filename)
3271{
3272 /* Method 1: The system has a compile time upper bound on a filename
3273 path. Use that and realpath() to canonicalize the name. This is
3274 the most common case. Note that, if there isn't a compile time
3275 upper bound, you want to avoid realpath() at all costs. */
3276#if defined(HAVE_REALPATH)
3277 {
3278# if defined (PATH_MAX)
3279 char buf[PATH_MAX];
3280# define USE_REALPATH
3281# elif defined (MAXPATHLEN)
3282 char buf[MAXPATHLEN];
3283# define USE_REALPATH
3284# endif
3285# if defined (USE_REALPATH)
3286 const char *rp = realpath (filename, buf);
cf7f2e2d 3287
5796c8dc
SS
3288 if (rp == NULL)
3289 rp = filename;
3290 return xstrdup (rp);
3291# endif
3292 }
3293#endif /* HAVE_REALPATH */
3294
3295 /* Method 2: The host system (i.e., GNU) has the function
3296 canonicalize_file_name() which malloc's a chunk of memory and
3297 returns that, use that. */
3298#if defined(HAVE_CANONICALIZE_FILE_NAME)
3299 {
3300 char *rp = canonicalize_file_name (filename);
cf7f2e2d 3301
5796c8dc
SS
3302 if (rp == NULL)
3303 return xstrdup (filename);
3304 else
3305 return rp;
3306 }
3307#endif
3308
3309 /* FIXME: cagney/2002-11-13:
3310
3311 Method 2a: Use realpath() with a NULL buffer. Some systems, due
a45ae5f8 3312 to the problems described in method 3, have modified their
5796c8dc
SS
3313 realpath() implementation so that it will allocate a buffer when
3314 NULL is passed in. Before this can be used, though, some sort of
3315 configure time test would need to be added. Otherwize the code
3316 will likely core dump. */
3317
3318 /* Method 3: Now we're getting desperate! The system doesn't have a
3319 compile time buffer size and no alternative function. Query the
3320 OS, using pathconf(), for the buffer limit. Care is needed
3321 though, some systems do not limit PATH_MAX (return -1 for
3322 pathconf()) making it impossible to pass a correctly sized buffer
3323 to realpath() (it could always overflow). On those systems, we
3324 skip this. */
3325#if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
3326 {
3327 /* Find out the max path size. */
3328 long path_max = pathconf ("/", _PC_PATH_MAX);
cf7f2e2d 3329
5796c8dc
SS
3330 if (path_max > 0)
3331 {
3332 /* PATH_MAX is bounded. */
3333 char *buf = alloca (path_max);
3334 char *rp = realpath (filename, buf);
cf7f2e2d 3335
5796c8dc
SS
3336 return xstrdup (rp ? rp : filename);
3337 }
3338 }
3339#endif
3340
3341 /* This system is a lost cause, just dup the buffer. */
3342 return xstrdup (filename);
3343}
3344
3345/* Return a copy of FILENAME, with its directory prefix canonicalized
3346 by gdb_realpath. */
3347
3348char *
3349xfullpath (const char *filename)
3350{
3351 const char *base_name = lbasename (filename);
3352 char *dir_name;
3353 char *real_path;
3354 char *result;
3355
3356 /* Extract the basename of filename, and return immediately
c50c785c 3357 a copy of filename if it does not contain any directory prefix. */
5796c8dc
SS
3358 if (base_name == filename)
3359 return xstrdup (filename);
3360
3361 dir_name = alloca ((size_t) (base_name - filename + 2));
3362 /* Allocate enough space to store the dir_name + plus one extra
3363 character sometimes needed under Windows (see below), and
c50c785c 3364 then the closing \000 character. */
5796c8dc
SS
3365 strncpy (dir_name, filename, base_name - filename);
3366 dir_name[base_name - filename] = '\000';
3367
3368#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3369 /* We need to be careful when filename is of the form 'd:foo', which
3370 is equivalent of d:./foo, which is totally different from d:/foo. */
3371 if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
3372 {
3373 dir_name[2] = '.';
3374 dir_name[3] = '\000';
3375 }
3376#endif
3377
3378 /* Canonicalize the directory prefix, and build the resulting
c50c785c 3379 filename. If the dirname realpath already contains an ending
5796c8dc
SS
3380 directory separator, avoid doubling it. */
3381 real_path = gdb_realpath (dir_name);
3382 if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
cf7f2e2d 3383 result = concat (real_path, base_name, (char *) NULL);
5796c8dc 3384 else
cf7f2e2d 3385 result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
5796c8dc
SS
3386
3387 xfree (real_path);
3388 return result;
3389}
3390
3391
3392/* This is the 32-bit CRC function used by the GNU separate debug
3393 facility. An executable may contain a section named
3394 .gnu_debuglink, which holds the name of a separate executable file
3395 containing its debug info, and a checksum of that file's contents,
3396 computed using this function. */
3397unsigned long
3398gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
3399{
3400 static const unsigned int crc32_table[256] = {
3401 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3402 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3403 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3404 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3405 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3406 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3407 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3408 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3409 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3410 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3411 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3412 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3413 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3414 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3415 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3416 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3417 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3418 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3419 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3420 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3421 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3422 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3423 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3424 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3425 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3426 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3427 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3428 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3429 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3430 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3431 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3432 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3433 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3434 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3435 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3436 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3437 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3438 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3439 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3440 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3441 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3442 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3443 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3444 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3445 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3446 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3447 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3448 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3449 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3450 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3451 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3452 0x2d02ef8d
3453 };
3454 unsigned char *end;
3455
3456 crc = ~crc & 0xffffffff;
3457 for (end = buf + len; buf < end; ++buf)
3458 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
c50c785c 3459 return ~crc & 0xffffffff;
5796c8dc
SS
3460}
3461
3462ULONGEST
3463align_up (ULONGEST v, int n)
3464{
3465 /* Check that N is really a power of two. */
3466 gdb_assert (n && (n & (n-1)) == 0);
3467 return (v + n - 1) & -n;
3468}
3469
3470ULONGEST
3471align_down (ULONGEST v, int n)
3472{
3473 /* Check that N is really a power of two. */
3474 gdb_assert (n && (n & (n-1)) == 0);
3475 return (v & -n);
3476}
3477
3478/* Allocation function for the libiberty hash table which uses an
3479 obstack. The obstack is passed as DATA. */
3480
3481void *
3482hashtab_obstack_allocate (void *data, size_t size, size_t count)
3483{
3484 unsigned int total = size * count;
3485 void *ptr = obstack_alloc ((struct obstack *) data, total);
cf7f2e2d 3486
5796c8dc
SS
3487 memset (ptr, 0, total);
3488 return ptr;
3489}
3490
3491/* Trivial deallocation function for the libiberty splay tree and hash
3492 table - don't deallocate anything. Rely on later deletion of the
3493 obstack. DATA will be the obstack, although it is not needed
3494 here. */
3495
3496void
3497dummy_obstack_deallocate (void *object, void *data)
3498{
3499 return;
3500}
3501
3502/* The bit offset of the highest byte in a ULONGEST, for overflow
3503 checking. */
3504
3505#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3506
3507/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3508 where 2 <= BASE <= 36. */
3509
3510static int
3511is_digit_in_base (unsigned char digit, int base)
3512{
3513 if (!isalnum (digit))
3514 return 0;
3515 if (base <= 10)
3516 return (isdigit (digit) && digit < base + '0');
3517 else
3518 return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
3519}
3520
3521static int
3522digit_to_int (unsigned char c)
3523{
3524 if (isdigit (c))
3525 return c - '0';
3526 else
3527 return tolower (c) - 'a' + 10;
3528}
3529
3530/* As for strtoul, but for ULONGEST results. */
3531
3532ULONGEST
3533strtoulst (const char *num, const char **trailer, int base)
3534{
3535 unsigned int high_part;
3536 ULONGEST result;
3537 int minus = 0;
3538 int i = 0;
3539
3540 /* Skip leading whitespace. */
3541 while (isspace (num[i]))
3542 i++;
3543
3544 /* Handle prefixes. */
3545 if (num[i] == '+')
3546 i++;
3547 else if (num[i] == '-')
3548 {
3549 minus = 1;
3550 i++;
3551 }
3552
3553 if (base == 0 || base == 16)
3554 {
3555 if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
3556 {
3557 i += 2;
3558 if (base == 0)
3559 base = 16;
3560 }
3561 }
3562
3563 if (base == 0 && num[i] == '0')
3564 base = 8;
3565
3566 if (base == 0)
3567 base = 10;
3568
3569 if (base < 2 || base > 36)
3570 {
3571 errno = EINVAL;
3572 return 0;
3573 }
3574
3575 result = high_part = 0;
3576 for (; is_digit_in_base (num[i], base); i += 1)
3577 {
3578 result = result * base + digit_to_int (num[i]);
3579 high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
3580 result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
3581 if (high_part > 0xff)
3582 {
3583 errno = ERANGE;
3584 result = ~ (ULONGEST) 0;
3585 high_part = 0;
3586 minus = 0;
3587 break;
3588 }
3589 }
3590
3591 if (trailer != NULL)
3592 *trailer = &num[i];
3593
3594 result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
3595 if (minus)
3596 return -result;
3597 else
3598 return result;
3599}
3600
3601/* Simple, portable version of dirname that does not modify its
3602 argument. */
3603
3604char *
3605ldirname (const char *filename)
3606{
3607 const char *base = lbasename (filename);
3608 char *dirname;
3609
3610 while (base > filename && IS_DIR_SEPARATOR (base[-1]))
3611 --base;
3612
3613 if (base == filename)
3614 return NULL;
3615
3616 dirname = xmalloc (base - filename + 2);
3617 memcpy (dirname, filename, base - filename);
3618
3619 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3620 create "d:./bar" later instead of the (different) "d:/bar". */
3621 if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
3622 && !IS_DIR_SEPARATOR (filename[0]))
3623 dirname[base++ - filename] = '.';
3624
3625 dirname[base - filename] = '\0';
3626 return dirname;
3627}
3628
3629/* Call libiberty's buildargv, and return the result.
3630 If buildargv fails due to out-of-memory, call nomem.
3631 Therefore, the returned value is guaranteed to be non-NULL,
3632 unless the parameter itself is NULL. */
3633
3634char **
3635gdb_buildargv (const char *s)
3636{
3637 char **argv = buildargv (s);
cf7f2e2d 3638
5796c8dc 3639 if (s != NULL && argv == NULL)
a45ae5f8 3640 malloc_failure (0);
5796c8dc
SS
3641 return argv;
3642}
3643
cf7f2e2d
JM
3644int
3645compare_positive_ints (const void *ap, const void *bp)
3646{
3647 /* Because we know we're comparing two ints which are positive,
3648 there's no danger of overflow here. */
3649 return * (int *) ap - * (int *) bp;
3650}
3651
a45ae5f8
JM
3652/* String compare function for qsort. */
3653
3654int
3655compare_strings (const void *arg1, const void *arg2)
3656{
3657 const char **s1 = (const char **) arg1;
3658 const char **s2 = (const char **) arg2;
3659
3660 return strcmp (*s1, *s2);
3661}
3662
cf7f2e2d 3663#define AMBIGUOUS_MESS1 ".\nMatching formats:"
c50c785c
JM
3664#define AMBIGUOUS_MESS2 \
3665 ".\nUse \"set gnutarget format-name\" to specify the format."
cf7f2e2d
JM
3666
3667const char *
3668gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
3669{
3670 char *ret, *retp;
3671 int ret_len;
3672 char **p;
3673
3674 /* Check if errmsg just need simple return. */
3675 if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
3676 return bfd_errmsg (error_tag);
3677
3678 ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
3679 + strlen (AMBIGUOUS_MESS2);
3680 for (p = matching; *p; p++)
3681 ret_len += strlen (*p) + 1;
3682 ret = xmalloc (ret_len + 1);
3683 retp = ret;
3684 make_cleanup (xfree, ret);
3685
3686 strcpy (retp, bfd_errmsg (error_tag));
3687 retp += strlen (retp);
3688
3689 strcpy (retp, AMBIGUOUS_MESS1);
3690 retp += strlen (retp);
3691
3692 for (p = matching; *p; p++)
3693 {
3694 sprintf (retp, " %s", *p);
3695 retp += strlen (retp);
3696 }
3697 xfree (matching);
3698
3699 strcpy (retp, AMBIGUOUS_MESS2);
3700
3701 return ret;
3702}
3703
3704/* Return ARGS parsed as a valid pid, or throw an error. */
3705
3706int
3707parse_pid_to_attach (char *args)
3708{
3709 unsigned long pid;
3710 char *dummy;
3711
3712 if (!args)
3713 error_no_arg (_("process-id to attach"));
3714
3715 dummy = args;
3716 pid = strtoul (args, &dummy, 0);
3717 /* Some targets don't set errno on errors, grrr! */
3718 if ((pid == 0 && dummy == args) || dummy != &args[strlen (args)])
3719 error (_("Illegal process-id: %s."), args);
3720
3721 return pid;
3722}
3723
a45ae5f8
JM
3724/* Helper for make_bpstat_clear_actions_cleanup. */
3725
3726static void
3727do_bpstat_clear_actions_cleanup (void *unused)
3728{
3729 bpstat_clear_actions ();
3730}
3731
3732/* Call bpstat_clear_actions for the case an exception is throw. You should
3733 discard_cleanups if no exception is caught. */
3734
3735struct cleanup *
3736make_bpstat_clear_actions_cleanup (void)
3737{
3738 return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
3739}
3740
3741/* Check for GCC >= 4.x according to the symtab->producer string. Return minor
3742 version (x) of 4.x in such case. If it is not GCC or it is GCC older than
3743 4.x return -1. If it is GCC 5.x or higher return INT_MAX. */
3744
3745int
3746producer_is_gcc_ge_4 (const char *producer)
3747{
3748 const char *cs;
3749 int major, minor;
3750
3751 if (producer == NULL)
3752 {
3753 /* For unknown compilers expect their behavior is not compliant. For GCC
3754 this case can also happen for -gdwarf-4 type units supported since
3755 gcc-4.5. */
3756
3757 return -1;
3758 }
3759
3760 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
3761
3762 if (strncmp (producer, "GNU ", strlen ("GNU ")) != 0)
3763 {
3764 /* For non-GCC compilers expect their behavior is not compliant. */
3765
3766 return -1;
3767 }
3768 cs = &producer[strlen ("GNU ")];
3769 while (*cs && !isdigit (*cs))
3770 cs++;
3771 if (sscanf (cs, "%d.%d", &major, &minor) != 2)
3772 {
3773 /* Not recognized as GCC. */
3774
3775 return -1;
3776 }
3777
3778 if (major < 4)
3779 return -1;
3780 if (major > 4)
3781 return INT_MAX;
3782 return minor;
3783}
3784
5796c8dc
SS
3785/* Provide a prototype to silence -Wmissing-prototypes. */
3786extern initialize_file_ftype _initialize_utils;
3787
3788void
3789_initialize_utils (void)
3790{
3791 add_internal_problem_command (&internal_error_problem);
3792 add_internal_problem_command (&internal_warning_problem);
3793}