OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [utils.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.