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