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