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

Subversion Repositories openrisc_me

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

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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