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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [utils.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* General utility routines for GDB, the GNU debugger.
2
   Copyright 1986, 1989, 1990-1992, 1995, 1996, 1998, 2000
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include "defs.h"
23
#include <ctype.h>
24
#include "gdb_string.h"
25
#include "event-top.h"
26
 
27
#ifdef HAVE_CURSES_H
28
#include <curses.h>
29
#endif
30
#ifdef HAVE_TERM_H
31
#include <term.h>
32
#endif
33
 
34
#ifdef __GO32__
35
#include <pc.h>
36
#endif
37
 
38
/* SunOS's curses.h has a '#define reg register' in it.  Thank you Sun. */
39
#ifdef reg
40
#undef reg
41
#endif
42
 
43
#include "signals.h"
44
#include "gdbcmd.h"
45
#include "serial.h"
46
#include "bfd.h"
47
#include "target.h"
48
#include "demangle.h"
49
#include "expression.h"
50
#include "language.h"
51
#include "annotate.h"
52
 
53
#include <readline/readline.h>
54
 
55
#undef XMALLOC
56
#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
57
 
58
/* readline defines this.  */
59
#undef savestring
60
 
61
void (*error_begin_hook) PARAMS ((void));
62
 
63
/* Holds the last error message issued by gdb */
64
 
65
static struct ui_file *gdb_lasterr;
66
 
67
/* Prototypes for local functions */
68
 
69
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
70
                                     va_list, int);
71
 
72
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
73
 
74
#if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
75
static void malloc_botch PARAMS ((void));
76
#endif
77
 
78
static void
79
prompt_for_continue PARAMS ((void));
80
 
81
static void
82
set_width_command PARAMS ((char *, int, struct cmd_list_element *));
83
 
84
static void
85
set_width PARAMS ((void));
86
 
87
/* Chain of cleanup actions established with make_cleanup,
88
   to be executed if an error happens.  */
89
 
90
static struct cleanup *cleanup_chain;   /* cleaned up after a failed command */
91
static struct cleanup *final_cleanup_chain;     /* cleaned up when gdb exits */
92
static struct cleanup *run_cleanup_chain;       /* cleaned up on each 'run' */
93
static struct cleanup *exec_cleanup_chain;      /* cleaned up on each execution command */
94
/* cleaned up on each error from within an execution command */
95
static struct cleanup *exec_error_cleanup_chain;
96
 
97
/* Pointer to what is left to do for an execution command after the
98
   target stops. Used only in asynchronous mode, by targets that
99
   support async execution.  The finish and until commands use it. So
100
   does the target extended-remote command. */
101
struct continuation *cmd_continuation;
102
struct continuation *intermediate_continuation;
103
 
104
/* Nonzero if we have job control. */
105
 
106
int job_control;
107
 
108
/* Nonzero means a quit has been requested.  */
109
 
110
int quit_flag;
111
 
112
/* Nonzero means quit immediately if Control-C is typed now, rather
113
   than waiting until QUIT is executed.  Be careful in setting this;
114
   code which executes with immediate_quit set has to be very careful
115
   about being able to deal with being interrupted at any time.  It is
116
   almost always better to use QUIT; the only exception I can think of
117
   is being able to quit out of a system call (using EINTR loses if
118
   the SIGINT happens between the previous QUIT and the system call).
119
   To immediately quit in the case in which a SIGINT happens between
120
   the previous QUIT and setting immediate_quit (desirable anytime we
121
   expect to block), call QUIT after setting immediate_quit.  */
122
 
123
int immediate_quit;
124
 
125
/* Nonzero means that encoded C++ names should be printed out in their
126
   C++ form rather than raw.  */
127
 
128
int demangle = 1;
129
 
130
/* Nonzero means that encoded C++ names should be printed out in their
131
   C++ form even in assembler language displays.  If this is set, but
132
   DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls.  */
133
 
134
int asm_demangle = 0;
135
 
136
/* Nonzero means that strings with character values >0x7F should be printed
137
   as octal escapes.  Zero means just print the value (e.g. it's an
138
   international character, and the terminal or window can cope.)  */
139
 
140
int sevenbit_strings = 0;
141
 
142
/* String to be printed before error messages, if any.  */
143
 
144
char *error_pre_print;
145
 
146
/* String to be printed before quit messages, if any.  */
147
 
148
char *quit_pre_print;
149
 
150
/* String to be printed before warning messages, if any.  */
151
 
152
char *warning_pre_print = "\nwarning: ";
153
 
154
int pagination_enabled = 1;
155
 
156
 
157
/* Add a new cleanup to the cleanup_chain,
158
   and return the previous chain pointer
159
   to be passed later to do_cleanups or discard_cleanups.
160
   Args are FUNCTION to clean up with, and ARG to pass to it.  */
161
 
162
struct cleanup *
163
make_cleanup (make_cleanup_ftype *function, void *arg)
164
{
165
  return make_my_cleanup (&cleanup_chain, function, arg);
166
}
167
 
168
struct cleanup *
169
make_final_cleanup (make_cleanup_ftype *function, void *arg)
170
{
171
  return make_my_cleanup (&final_cleanup_chain, function, arg);
172
}
173
 
174
struct cleanup *
175
make_run_cleanup (make_cleanup_ftype *function, void *arg)
176
{
177
  return make_my_cleanup (&run_cleanup_chain, function, arg);
178
}
179
 
180
struct cleanup *
181
make_exec_cleanup (make_cleanup_ftype *function, void *arg)
182
{
183
  return make_my_cleanup (&exec_cleanup_chain, function, arg);
184
}
185
 
186
struct cleanup *
187
make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
188
{
189
  return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
190
}
191
 
192
static void
193
do_freeargv (arg)
194
     void *arg;
195
{
196
  freeargv ((char **) arg);
197
}
198
 
199
struct cleanup *
200
make_cleanup_freeargv (arg)
201
     char **arg;
202
{
203
  return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
204
}
205
 
206
static void
207
do_ui_file_delete (void *arg)
208
{
209
  ui_file_delete (arg);
210
}
211
 
212
struct cleanup *
213
make_cleanup_ui_file_delete (struct ui_file *arg)
214
{
215
  return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
216
}
217
 
218
struct cleanup *
219
make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
220
                 void *arg)
221
{
222
  register struct cleanup *new
223
  = (struct cleanup *) xmalloc (sizeof (struct cleanup));
224
  register struct cleanup *old_chain = *pmy_chain;
225
 
226
  new->next = *pmy_chain;
227
  new->function = function;
228
  new->arg = arg;
229
  *pmy_chain = new;
230
 
231
  return old_chain;
232
}
233
 
234
/* Discard cleanups and do the actions they describe
235
   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
236
 
237
void
238
do_cleanups (old_chain)
239
     register struct cleanup *old_chain;
240
{
241
  do_my_cleanups (&cleanup_chain, old_chain);
242
}
243
 
244
void
245
do_final_cleanups (old_chain)
246
     register struct cleanup *old_chain;
247
{
248
  do_my_cleanups (&final_cleanup_chain, old_chain);
249
}
250
 
251
void
252
do_run_cleanups (old_chain)
253
     register struct cleanup *old_chain;
254
{
255
  do_my_cleanups (&run_cleanup_chain, old_chain);
256
}
257
 
258
void
259
do_exec_cleanups (old_chain)
260
     register struct cleanup *old_chain;
261
{
262
  do_my_cleanups (&exec_cleanup_chain, old_chain);
263
}
264
 
265
void
266
do_exec_error_cleanups (old_chain)
267
     register struct cleanup *old_chain;
268
{
269
  do_my_cleanups (&exec_error_cleanup_chain, old_chain);
270
}
271
 
272
void
273
do_my_cleanups (pmy_chain, old_chain)
274
     register struct cleanup **pmy_chain;
275
     register struct cleanup *old_chain;
276
{
277
  register struct cleanup *ptr;
278
  while ((ptr = *pmy_chain) != old_chain)
279
    {
280
      *pmy_chain = ptr->next;   /* Do this first incase recursion */
281
      (*ptr->function) (ptr->arg);
282
      free (ptr);
283
    }
284
}
285
 
286
/* Discard cleanups, not doing the actions they describe,
287
   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
288
 
289
void
290
discard_cleanups (old_chain)
291
     register struct cleanup *old_chain;
292
{
293
  discard_my_cleanups (&cleanup_chain, old_chain);
294
}
295
 
296
void
297
discard_final_cleanups (old_chain)
298
     register struct cleanup *old_chain;
299
{
300
  discard_my_cleanups (&final_cleanup_chain, old_chain);
301
}
302
 
303
void
304
discard_exec_error_cleanups (old_chain)
305
     register struct cleanup *old_chain;
306
{
307
  discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
308
}
309
 
310
void
311
discard_my_cleanups (pmy_chain, old_chain)
312
     register struct cleanup **pmy_chain;
313
     register struct cleanup *old_chain;
314
{
315
  register struct cleanup *ptr;
316
  while ((ptr = *pmy_chain) != old_chain)
317
    {
318
      *pmy_chain = ptr->next;
319
      free (ptr);
320
    }
321
}
322
 
323
/* Set the cleanup_chain to 0, and return the old cleanup chain.  */
324
struct cleanup *
325
save_cleanups ()
326
{
327
  return save_my_cleanups (&cleanup_chain);
328
}
329
 
330
struct cleanup *
331
save_final_cleanups ()
332
{
333
  return save_my_cleanups (&final_cleanup_chain);
334
}
335
 
336
struct cleanup *
337
save_my_cleanups (pmy_chain)
338
     struct cleanup **pmy_chain;
339
{
340
  struct cleanup *old_chain = *pmy_chain;
341
 
342
  *pmy_chain = 0;
343
  return old_chain;
344
}
345
 
346
/* Restore the cleanup chain from a previously saved chain.  */
347
void
348
restore_cleanups (chain)
349
     struct cleanup *chain;
350
{
351
  restore_my_cleanups (&cleanup_chain, chain);
352
}
353
 
354
void
355
restore_final_cleanups (chain)
356
     struct cleanup *chain;
357
{
358
  restore_my_cleanups (&final_cleanup_chain, chain);
359
}
360
 
361
void
362
restore_my_cleanups (pmy_chain, chain)
363
     struct cleanup **pmy_chain;
364
     struct cleanup *chain;
365
{
366
  *pmy_chain = chain;
367
}
368
 
369
/* This function is useful for cleanups.
370
   Do
371
 
372
   foo = xmalloc (...);
373
   old_chain = make_cleanup (free_current_contents, &foo);
374
 
375
   to arrange to free the object thus allocated.  */
376
 
377
void
378
free_current_contents (void *ptr)
379
{
380
  void **location = ptr;
381
  if (*location != NULL)
382
    free (*location);
383
}
384
 
385
/* Provide a known function that does nothing, to use as a base for
386
   for a possibly long chain of cleanups.  This is useful where we
387
   use the cleanup chain for handling normal cleanups as well as dealing
388
   with cleanups that need to be done as a result of a call to error().
389
   In such cases, we may not be certain where the first cleanup is, unless
390
   we have a do-nothing one to always use as the base. */
391
 
392
/* ARGSUSED */
393
void
394
null_cleanup (void *arg)
395
{
396
}
397
 
398
/* Add a continuation to the continuation list, the gloabl list
399
   cmd_continuation. The new continuation will be added at the front.*/
400
void
401
add_continuation (continuation_hook, arg_list)
402
     void (*continuation_hook) PARAMS ((struct continuation_arg *));
403
     struct continuation_arg *arg_list;
404
{
405
  struct continuation *continuation_ptr;
406
 
407
  continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
408
  continuation_ptr->continuation_hook = continuation_hook;
409
  continuation_ptr->arg_list = arg_list;
410
  continuation_ptr->next = cmd_continuation;
411
  cmd_continuation = continuation_ptr;
412
}
413
 
414
/* Walk down the cmd_continuation list, and execute all the
415
   continuations. There is a problem though. In some cases new
416
   continuations may be added while we are in the middle of this
417
   loop. If this happens they will be added in the front, and done
418
   before we have a chance of exhausting those that were already
419
   there. We need to then save the beginning of the list in a pointer
420
   and do the continuations from there on, instead of using the
421
   global beginning of list as our iteration pointer.*/
422
void
423
do_all_continuations ()
424
{
425
  struct continuation *continuation_ptr;
426
  struct continuation *saved_continuation;
427
 
428
  /* Copy the list header into another pointer, and set the global
429
     list header to null, so that the global list can change as a side
430
     effect of invoking the continuations and the processing of
431
     the preexisting continuations will not be affected. */
432
  continuation_ptr = cmd_continuation;
433
  cmd_continuation = NULL;
434
 
435
  /* Work now on the list we have set aside. */
436
  while (continuation_ptr)
437
     {
438
       (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
439
       saved_continuation = continuation_ptr;
440
       continuation_ptr = continuation_ptr->next;
441
       free (saved_continuation);
442
     }
443
}
444
 
445
/* Walk down the cmd_continuation list, and get rid of all the
446
   continuations. */
447
void
448
discard_all_continuations ()
449
{
450
  struct continuation *continuation_ptr;
451
 
452
  while (cmd_continuation)
453
    {
454
      continuation_ptr = cmd_continuation;
455
      cmd_continuation = continuation_ptr->next;
456
      free (continuation_ptr);
457
    }
458
}
459
 
460
/* Add a continuation to the continuation list, the global list
461
   intermediate_continuation. The new continuation will be added at the front.*/
462
void
463
add_intermediate_continuation (continuation_hook, arg_list)
464
     void (*continuation_hook) PARAMS ((struct continuation_arg *));
465
     struct continuation_arg *arg_list;
466
{
467
  struct continuation *continuation_ptr;
468
 
469
  continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
470
  continuation_ptr->continuation_hook = continuation_hook;
471
  continuation_ptr->arg_list = arg_list;
472
  continuation_ptr->next = intermediate_continuation;
473
  intermediate_continuation = continuation_ptr;
474
}
475
 
476
/* Walk down the cmd_continuation list, and execute all the
477
   continuations. There is a problem though. In some cases new
478
   continuations may be added while we are in the middle of this
479
   loop. If this happens they will be added in the front, and done
480
   before we have a chance of exhausting those that were already
481
   there. We need to then save the beginning of the list in a pointer
482
   and do the continuations from there on, instead of using the
483
   global beginning of list as our iteration pointer.*/
484
void
485
do_all_intermediate_continuations ()
486
{
487
  struct continuation *continuation_ptr;
488
  struct continuation *saved_continuation;
489
 
490
  /* Copy the list header into another pointer, and set the global
491
     list header to null, so that the global list can change as a side
492
     effect of invoking the continuations and the processing of
493
     the preexisting continuations will not be affected. */
494
  continuation_ptr = intermediate_continuation;
495
  intermediate_continuation = NULL;
496
 
497
  /* Work now on the list we have set aside. */
498
  while (continuation_ptr)
499
     {
500
       (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
501
       saved_continuation = continuation_ptr;
502
       continuation_ptr = continuation_ptr->next;
503
       free (saved_continuation);
504
     }
505
}
506
 
507
/* Walk down the cmd_continuation list, and get rid of all the
508
   continuations. */
509
void
510
discard_all_intermediate_continuations ()
511
{
512
  struct continuation *continuation_ptr;
513
 
514
  while (intermediate_continuation)
515
    {
516
      continuation_ptr = intermediate_continuation;
517
      intermediate_continuation = continuation_ptr->next;
518
      free (continuation_ptr);
519
    }
520
}
521
 
522
 
523
 
524
/* Print a warning message.  Way to use this is to call warning_begin,
525
   output the warning message (use unfiltered output to gdb_stderr),
526
   ending in a newline.  There is not currently a warning_end that you
527
   call afterwards, but such a thing might be added if it is useful
528
   for a GUI to separate warning messages from other output.
529
 
530
   FIXME: Why do warnings use unfiltered output and errors filtered?
531
   Is this anything other than a historical accident?  */
532
 
533
void
534
warning_begin ()
535
{
536
  target_terminal_ours ();
537
  wrap_here ("");               /* Force out any buffered output */
538
  gdb_flush (gdb_stdout);
539
  if (warning_pre_print)
540
    fprintf_unfiltered (gdb_stderr, warning_pre_print);
541
}
542
 
543
/* Print a warning message.
544
   The first argument STRING is the warning message, used as a fprintf string,
545
   and the remaining args are passed as arguments to it.
546
   The primary difference between warnings and errors is that a warning
547
   does not force the return to command level.  */
548
 
549
void
550
warning (const char *string,...)
551
{
552
  va_list args;
553
  va_start (args, string);
554
  if (warning_hook)
555
    (*warning_hook) (string, args);
556
  else
557
    {
558
      warning_begin ();
559
      vfprintf_unfiltered (gdb_stderr, string, args);
560
      fprintf_unfiltered (gdb_stderr, "\n");
561
      va_end (args);
562
    }
563
}
564
 
565
/* Start the printing of an error message.  Way to use this is to call
566
   this, output the error message (use filtered output to gdb_stderr
567
   (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
568
   in a newline, and then call return_to_top_level (RETURN_ERROR).
569
   error() provides a convenient way to do this for the special case
570
   that the error message can be formatted with a single printf call,
571
   but this is more general.  */
572
void
573
error_begin ()
574
{
575
  if (error_begin_hook)
576
    error_begin_hook ();
577
 
578
  target_terminal_ours ();
579
  wrap_here ("");               /* Force out any buffered output */
580
  gdb_flush (gdb_stdout);
581
 
582
  annotate_error_begin ();
583
 
584
  if (error_pre_print)
585
    fprintf_filtered (gdb_stderr, error_pre_print);
586
}
587
 
588
/* Print an error message and return to command level.
589
   The first argument STRING is the error message, used as a fprintf string,
590
   and the remaining args are passed as arguments to it.  */
591
 
592
NORETURN void
593
verror (const char *string, va_list args)
594
{
595
  char *err_string;
596
  struct cleanup *err_string_cleanup;
597
  /* FIXME: cagney/1999-11-10: All error calls should come here.
598
     Unfortunatly some code uses the sequence: error_begin(); print
599
     error message; return_to_top_level.  That code should be
600
     flushed. */
601
  error_begin ();
602
  /* NOTE: It's tempting to just do the following...
603
        vfprintf_filtered (gdb_stderr, string, args);
604
     and then follow with a similar looking statement to cause the message
605
     to also go to gdb_lasterr.  But if we do this, we'll be traversing the
606
     va_list twice which works on some platforms and fails miserably on
607
     others. */
608
  /* Save it as the last error */
609
  ui_file_rewind (gdb_lasterr);
610
  vfprintf_filtered (gdb_lasterr, string, args);
611
  /* Retrieve the last error and print it to gdb_stderr */
612
  err_string = error_last_message ();
613
  err_string_cleanup = make_cleanup (free, err_string);
614
  fputs_filtered (err_string, gdb_stderr);
615
  fprintf_filtered (gdb_stderr, "\n");
616
  do_cleanups (err_string_cleanup);
617
  return_to_top_level (RETURN_ERROR);
618
}
619
 
620
NORETURN void
621
error (const char *string,...)
622
{
623
  va_list args;
624
  va_start (args, string);
625
  verror (string, args);
626
  va_end (args);
627
}
628
 
629
NORETURN void
630
error_stream (struct ui_file *stream)
631
{
632
  long size;
633
  char *msg = ui_file_xstrdup (stream, &size);
634
  make_cleanup (free, msg);
635
  error ("%s", msg);
636
}
637
 
638
/* Get the last error message issued by gdb */
639
 
640
char *
641
error_last_message (void)
642
{
643
  long len;
644
  return ui_file_xstrdup (gdb_lasterr, &len);
645
}
646
 
647
/* This is to be called by main() at the very beginning */
648
 
649
void
650
error_init (void)
651
{
652
  gdb_lasterr = mem_fileopen ();
653
}
654
 
655
/* Print a message reporting an internal error. Ask the user if they
656
   want to continue, dump core, or just exit. */
657
 
658
NORETURN void
659
internal_verror (const char *fmt, va_list ap)
660
{
661
  static char msg[] = "Internal GDB error: recursive internal error.\n";
662
  static int dejavu = 0;
663
  int continue_p;
664
  int dump_core_p;
665
 
666
  /* don't allow infinite error recursion. */
667
  switch (dejavu)
668
    {
669
    case 0:
670
      dejavu = 1;
671
      break;
672
    case 1:
673
      dejavu = 2;
674
      fputs_unfiltered (msg, gdb_stderr);
675
      abort ();
676
    default:
677
      dejavu = 3;
678
      write (STDERR_FILENO, msg, sizeof (msg));
679
      exit (1);
680
    }
681
 
682
  /* Try to get the message out */
683
  fputs_unfiltered ("gdb-internal-error: ", gdb_stderr);
684
  vfprintf_unfiltered (gdb_stderr, fmt, ap);
685
  fputs_unfiltered ("\n", gdb_stderr);
686
 
687
  /* Default (no case) is to quit GDB.  When in batch mode this
688
     lessens the likelhood of GDB going into an infinate loop. */
689
  continue_p = query ("\
690
An internal GDB error was detected.  This may make make further\n\
691
debugging unreliable.  Continue this debugging session? ");
692
 
693
  /* Default (no case) is to not dump core.  Lessen the chance of GDB
694
     leaving random core files around. */
695
  dump_core_p = query ("\
696
Create a core file containing the current state of GDB? ");
697
 
698
  if (continue_p)
699
    {
700
      if (dump_core_p)
701
        {
702
          if (fork () == 0)
703
            abort ();
704
        }
705
    }
706
  else
707
    {
708
      if (dump_core_p)
709
        abort ();
710
      else
711
        exit (1);
712
    }
713
 
714
  dejavu = 0;
715
  return_to_top_level (RETURN_ERROR);
716
}
717
 
718
NORETURN void
719
internal_error (char *string, ...)
720
{
721
  va_list ap;
722
  va_start (ap, string);
723
  internal_verror (string, ap);
724
  va_end (ap);
725
}
726
 
727
/* The strerror() function can return NULL for errno values that are
728
   out of range.  Provide a "safe" version that always returns a
729
   printable string. */
730
 
731
char *
732
safe_strerror (errnum)
733
     int errnum;
734
{
735
  char *msg;
736
  static char buf[32];
737
 
738
  if ((msg = strerror (errnum)) == NULL)
739
    {
740
      sprintf (buf, "(undocumented errno %d)", errnum);
741
      msg = buf;
742
    }
743
  return (msg);
744
}
745
 
746
/* The strsignal() function can return NULL for signal values that are
747
   out of range.  Provide a "safe" version that always returns a
748
   printable string. */
749
 
750
char *
751
safe_strsignal (signo)
752
     int signo;
753
{
754
  char *msg;
755
  static char buf[32];
756
 
757
  if ((msg = strsignal (signo)) == NULL)
758
    {
759
      sprintf (buf, "(undocumented signal %d)", signo);
760
      msg = buf;
761
    }
762
  return (msg);
763
}
764
 
765
 
766
/* Print the system error message for errno, and also mention STRING
767
   as the file name for which the error was encountered.
768
   Then return to command level.  */
769
 
770
NORETURN void
771
perror_with_name (string)
772
     char *string;
773
{
774
  char *err;
775
  char *combined;
776
 
777
  err = safe_strerror (errno);
778
  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
779
  strcpy (combined, string);
780
  strcat (combined, ": ");
781
  strcat (combined, err);
782
 
783
  /* I understand setting these is a matter of taste.  Still, some people
784
     may clear errno but not know about bfd_error.  Doing this here is not
785
     unreasonable. */
786
  bfd_set_error (bfd_error_no_error);
787
  errno = 0;
788
 
789
  error ("%s.", combined);
790
}
791
 
792
/* Print the system error message for ERRCODE, and also mention STRING
793
   as the file name for which the error was encountered.  */
794
 
795
void
796
print_sys_errmsg (string, errcode)
797
     char *string;
798
     int errcode;
799
{
800
  char *err;
801
  char *combined;
802
 
803
  err = safe_strerror (errcode);
804
  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
805
  strcpy (combined, string);
806
  strcat (combined, ": ");
807
  strcat (combined, err);
808
 
809
  /* We want anything which was printed on stdout to come out first, before
810
     this message.  */
811
  gdb_flush (gdb_stdout);
812
  fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
813
}
814
 
815
/* Control C eventually causes this to be called, at a convenient time.  */
816
 
817
void
818
quit ()
819
{
820
  serial_t gdb_stdout_serial = serial_fdopen (1);
821
 
822
  target_terminal_ours ();
823
 
824
  /* We want all output to appear now, before we print "Quit".  We
825
     have 3 levels of buffering we have to flush (it's possible that
826
     some of these should be changed to flush the lower-level ones
827
     too):  */
828
 
829
  /* 1.  The _filtered buffer.  */
830
  wrap_here ((char *) 0);
831
 
832
  /* 2.  The stdio buffer.  */
833
  gdb_flush (gdb_stdout);
834
  gdb_flush (gdb_stderr);
835
 
836
  /* 3.  The system-level buffer.  */
837
  SERIAL_DRAIN_OUTPUT (gdb_stdout_serial);
838
  SERIAL_UN_FDOPEN (gdb_stdout_serial);
839
 
840
  annotate_error_begin ();
841
 
842
  /* Don't use *_filtered; we don't want to prompt the user to continue.  */
843
  if (quit_pre_print)
844
    fprintf_unfiltered (gdb_stderr, quit_pre_print);
845
 
846
#ifdef __MSDOS__
847
  /* No steenking SIGINT will ever be coming our way when the
848
     program is resumed.  Don't lie.  */
849
  fprintf_unfiltered (gdb_stderr, "Quit\n");
850
#else
851
  if (job_control
852
  /* If there is no terminal switching for this target, then we can't
853
     possibly get screwed by the lack of job control.  */
854
      || current_target.to_terminal_ours == NULL)
855
    fprintf_unfiltered (gdb_stderr, "Quit\n");
856
  else
857
    fprintf_unfiltered (gdb_stderr,
858
               "Quit (expect signal SIGINT when the program is resumed)\n");
859
#endif
860
  return_to_top_level (RETURN_QUIT);
861
}
862
 
863
 
864
#if defined(_MSC_VER)           /* should test for wingdb instead? */
865
 
866
/*
867
 * Windows translates all keyboard and mouse events
868
 * into a message which is appended to the message
869
 * queue for the process.
870
 */
871
 
872
void
873
notice_quit ()
874
{
875
  int k = win32pollquit ();
876
  if (k == 1)
877
    quit_flag = 1;
878
  else if (k == 2)
879
    immediate_quit = 1;
880
}
881
 
882
#else /* !defined(_MSC_VER) */
883
 
884
void
885
notice_quit ()
886
{
887
  /* Done by signals */
888
}
889
 
890
#endif /* !defined(_MSC_VER) */
891
 
892
/* Control C comes here */
893
void
894
request_quit (signo)
895
     int signo;
896
{
897
  quit_flag = 1;
898
  /* Restore the signal handler.  Harmless with BSD-style signals, needed
899
     for System V-style signals.  So just always do it, rather than worrying
900
     about USG defines and stuff like that.  */
901
  signal (signo, request_quit);
902
 
903
#ifdef REQUEST_QUIT
904
  REQUEST_QUIT;
905
#else
906
  if (immediate_quit)
907
    quit ();
908
#endif
909
}
910
 
911
/* Memory management stuff (malloc friends).  */
912
 
913
/* Make a substitute size_t for non-ANSI compilers. */
914
 
915
#ifndef HAVE_STDDEF_H
916
#ifndef size_t
917
#define size_t unsigned int
918
#endif
919
#endif
920
 
921
#if !defined (USE_MMALLOC)
922
 
923
PTR
924
mcalloc (PTR md, size_t number, size_t size)
925
{
926
  return calloc (number, size);
927
}
928
 
929
PTR
930
mmalloc (md, size)
931
     PTR md;
932
     size_t size;
933
{
934
  return malloc (size);
935
}
936
 
937
PTR
938
mrealloc (md, ptr, size)
939
     PTR md;
940
     PTR ptr;
941
     size_t size;
942
{
943
  if (ptr == 0)                  /* Guard against old realloc's */
944
    return malloc (size);
945
  else
946
    return realloc (ptr, size);
947
}
948
 
949
void
950
mfree (md, ptr)
951
     PTR md;
952
     PTR ptr;
953
{
954
  free (ptr);
955
}
956
 
957
#endif /* USE_MMALLOC */
958
 
959
#if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
960
 
961
void
962
init_malloc (void *md)
963
{
964
}
965
 
966
#else /* Have mmalloc and want corruption checking */
967
 
968
static void
969
malloc_botch ()
970
{
971
  fprintf_unfiltered (gdb_stderr, "Memory corruption\n");
972
  abort ();
973
}
974
 
975
/* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
976
   by MD, to detect memory corruption.  Note that MD may be NULL to specify
977
   the default heap that grows via sbrk.
978
 
979
   Note that for freshly created regions, we must call mmcheckf prior to any
980
   mallocs in the region.  Otherwise, any region which was allocated prior to
981
   installing the checking hooks, which is later reallocated or freed, will
982
   fail the checks!  The mmcheck function only allows initial hooks to be
983
   installed before the first mmalloc.  However, anytime after we have called
984
   mmcheck the first time to install the checking hooks, we can call it again
985
   to update the function pointer to the memory corruption handler.
986
 
987
   Returns zero on failure, non-zero on success. */
988
 
989
#ifndef MMCHECK_FORCE
990
#define MMCHECK_FORCE 0
991
#endif
992
 
993
void
994
init_malloc (void *md)
995
{
996
  if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE))
997
    {
998
      /* Don't use warning(), which relies on current_target being set
999
         to something other than dummy_target, until after
1000
         initialize_all_files(). */
1001
 
1002
      fprintf_unfiltered
1003
        (gdb_stderr, "warning: failed to install memory consistency checks; ");
1004
      fprintf_unfiltered
1005
        (gdb_stderr, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1006
    }
1007
 
1008
  mmtrace ();
1009
}
1010
 
1011
#endif /* Have mmalloc and want corruption checking  */
1012
 
1013
/* Called when a memory allocation fails, with the number of bytes of
1014
   memory requested in SIZE. */
1015
 
1016
NORETURN void
1017
nomem (size)
1018
     long size;
1019
{
1020
  if (size > 0)
1021
    {
1022
      internal_error ("virtual memory exhausted: can't allocate %ld bytes.", size);
1023
    }
1024
  else
1025
    {
1026
      internal_error ("virtual memory exhausted.");
1027
    }
1028
}
1029
 
1030
/* Like mmalloc but get error if no storage available, and protect against
1031
   the caller wanting to allocate zero bytes.  Whether to return NULL for
1032
   a zero byte request, or translate the request into a request for one
1033
   byte of zero'd storage, is a religious issue. */
1034
 
1035
PTR
1036
xmmalloc (md, size)
1037
     PTR md;
1038
     long size;
1039
{
1040
  register PTR val;
1041
 
1042
  if (size == 0)
1043
    {
1044
      val = NULL;
1045
    }
1046
  else if ((val = mmalloc (md, size)) == NULL)
1047
    {
1048
      nomem (size);
1049
    }
1050
  return (val);
1051
}
1052
 
1053
/* Like mrealloc but get error if no storage available.  */
1054
 
1055
PTR
1056
xmrealloc (md, ptr, size)
1057
     PTR md;
1058
     PTR ptr;
1059
     long size;
1060
{
1061
  register PTR val;
1062
 
1063
  if (ptr != NULL)
1064
    {
1065
      val = mrealloc (md, ptr, size);
1066
    }
1067
  else
1068
    {
1069
      val = mmalloc (md, size);
1070
    }
1071
  if (val == NULL)
1072
    {
1073
      nomem (size);
1074
    }
1075
  return (val);
1076
}
1077
 
1078
/* Like malloc but get error if no storage available, and protect against
1079
   the caller wanting to allocate zero bytes.  */
1080
 
1081
PTR
1082
xmalloc (size)
1083
     size_t size;
1084
{
1085
  return (xmmalloc ((PTR) NULL, size));
1086
}
1087
 
1088
/* Like calloc but get error if no storage available */
1089
 
1090
PTR
1091
xcalloc (size_t number, size_t size)
1092
{
1093
  void *mem = mcalloc (NULL, number, size);
1094
  if (mem == NULL)
1095
    nomem (number * size);
1096
  return mem;
1097
}
1098
 
1099
/* Like mrealloc but get error if no storage available.  */
1100
 
1101
PTR
1102
xrealloc (ptr, size)
1103
     PTR ptr;
1104
     size_t size;
1105
{
1106
  return (xmrealloc ((PTR) NULL, ptr, size));
1107
}
1108
 
1109
 
1110
/* My replacement for the read system call.
1111
   Used like `read' but keeps going if `read' returns too soon.  */
1112
 
1113
int
1114
myread (desc, addr, len)
1115
     int desc;
1116
     char *addr;
1117
     int len;
1118
{
1119
  register int val;
1120
  int orglen = len;
1121
 
1122
  while (len > 0)
1123
    {
1124
      val = read (desc, addr, len);
1125
      if (val < 0)
1126
        return val;
1127
      if (val == 0)
1128
        return orglen - len;
1129
      len -= val;
1130
      addr += val;
1131
    }
1132
  return orglen;
1133
}
1134
 
1135
/* Make a copy of the string at PTR with SIZE characters
1136
   (and add a null character at the end in the copy).
1137
   Uses malloc to get the space.  Returns the address of the copy.  */
1138
 
1139
char *
1140
savestring (ptr, size)
1141
     const char *ptr;
1142
     int size;
1143
{
1144
  register char *p = (char *) xmalloc (size + 1);
1145
  memcpy (p, ptr, size);
1146
  p[size] = 0;
1147
  return p;
1148
}
1149
 
1150
char *
1151
msavestring (void *md, const char *ptr, int size)
1152
{
1153
  register char *p = (char *) xmmalloc (md, size + 1);
1154
  memcpy (p, ptr, size);
1155
  p[size] = 0;
1156
  return p;
1157
}
1158
 
1159
/* The "const" is so it compiles under DGUX (which prototypes strsave
1160
   in <string.h>.  FIXME: This should be named "xstrsave", shouldn't it?
1161
   Doesn't real strsave return NULL if out of memory?  */
1162
char *
1163
strsave (ptr)
1164
     const char *ptr;
1165
{
1166
  return savestring (ptr, strlen (ptr));
1167
}
1168
 
1169
char *
1170
mstrsave (void *md, const char *ptr)
1171
{
1172
  return (msavestring (md, ptr, strlen (ptr)));
1173
}
1174
 
1175
void
1176
print_spaces (n, file)
1177
     register int n;
1178
     register struct ui_file *file;
1179
{
1180
  fputs_unfiltered (n_spaces (n), file);
1181
}
1182
 
1183
/* Print a host address.  */
1184
 
1185
void
1186
gdb_print_host_address (void *addr, struct ui_file *stream)
1187
{
1188
 
1189
  /* We could use the %p conversion specifier to fprintf if we had any
1190
     way of knowing whether this host supports it.  But the following
1191
     should work on the Alpha and on 32 bit machines.  */
1192
 
1193
  fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
1194
}
1195
 
1196
/* Ask user a y-or-n question and return 1 iff answer is yes.
1197
   Takes three args which are given to printf to print the question.
1198
   The first, a control string, should end in "? ".
1199
   It should not say how to answer, because we do that.  */
1200
 
1201
/* VARARGS */
1202
int
1203
query (char *ctlstr,...)
1204
{
1205
  va_list args;
1206
  register int answer;
1207
  register int ans2;
1208
  int retval;
1209
 
1210
  va_start (args, ctlstr);
1211
 
1212
  if (query_hook)
1213
    {
1214
      return query_hook (ctlstr, args);
1215
    }
1216
 
1217
  /* Automatically answer "yes" if input is not from a terminal.  */
1218
  if (!input_from_terminal_p ())
1219
    return 1;
1220
#ifdef MPW
1221
  /* FIXME Automatically answer "yes" if called from MacGDB.  */
1222
  if (mac_app)
1223
    return 1;
1224
#endif /* MPW */
1225
 
1226
  while (1)
1227
    {
1228
      wrap_here ("");           /* Flush any buffered output */
1229
      gdb_flush (gdb_stdout);
1230
 
1231
      if (annotation_level > 1)
1232
        printf_filtered ("\n\032\032pre-query\n");
1233
 
1234
      vfprintf_filtered (gdb_stdout, ctlstr, args);
1235
      printf_filtered ("(y or n) ");
1236
 
1237
      if (annotation_level > 1)
1238
        printf_filtered ("\n\032\032query\n");
1239
 
1240
#ifdef MPW
1241
      /* If not in MacGDB, move to a new line so the entered line doesn't
1242
         have a prompt on the front of it. */
1243
      if (!mac_app)
1244
        fputs_unfiltered ("\n", gdb_stdout);
1245
#endif /* MPW */
1246
 
1247
      wrap_here ("");
1248
      gdb_flush (gdb_stdout);
1249
 
1250
#if defined(TUI)
1251
      if (!tui_version || cmdWin == tuiWinWithFocus ())
1252
#endif
1253
        answer = fgetc (stdin);
1254
#if defined(TUI)
1255
      else
1256
        answer = (unsigned char) tuiBufferGetc ();
1257
 
1258
#endif
1259
      clearerr (stdin);         /* in case of C-d */
1260
      if (answer == EOF)        /* C-d */
1261
        {
1262
          retval = 1;
1263
          break;
1264
        }
1265
      /* Eat rest of input line, to EOF or newline */
1266
      if ((answer != '\n') || (tui_version && answer != '\r'))
1267
        do
1268
          {
1269
#if defined(TUI)
1270
            if (!tui_version || cmdWin == tuiWinWithFocus ())
1271
#endif
1272
              ans2 = fgetc (stdin);
1273
#if defined(TUI)
1274
            else
1275
              ans2 = (unsigned char) tuiBufferGetc ();
1276
#endif
1277
            clearerr (stdin);
1278
          }
1279
        while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1280
      TUIDO (((TuiOpaqueFuncPtr) tui_vStartNewLines, 1));
1281
 
1282
      if (answer >= 'a')
1283
        answer -= 040;
1284
      if (answer == 'Y')
1285
        {
1286
          retval = 1;
1287
          break;
1288
        }
1289
      if (answer == 'N')
1290
        {
1291
          retval = 0;
1292
          break;
1293
        }
1294
      printf_filtered ("Please answer y or n.\n");
1295
    }
1296
 
1297
  if (annotation_level > 1)
1298
    printf_filtered ("\n\032\032post-query\n");
1299
  return retval;
1300
}
1301
 
1302
 
1303
/* Parse a C escape sequence.  STRING_PTR points to a variable
1304
   containing a pointer to the string to parse.  That pointer
1305
   should point to the character after the \.  That pointer
1306
   is updated past the characters we use.  The value of the
1307
   escape sequence is returned.
1308
 
1309
   A negative value means the sequence \ newline was seen,
1310
   which is supposed to be equivalent to nothing at all.
1311
 
1312
   If \ is followed by a null character, we return a negative
1313
   value and leave the string pointer pointing at the null character.
1314
 
1315
   If \ is followed by 000, we return 0 and leave the string pointer
1316
   after the zeros.  A value of 0 does not mean end of string.  */
1317
 
1318
int
1319
parse_escape (string_ptr)
1320
     char **string_ptr;
1321
{
1322
  register int c = *(*string_ptr)++;
1323
  switch (c)
1324
    {
1325
    case 'a':
1326
      return 007;               /* Bell (alert) char */
1327
    case 'b':
1328
      return '\b';
1329
    case 'e':                   /* Escape character */
1330
      return 033;
1331
    case 'f':
1332
      return '\f';
1333
    case 'n':
1334
      return '\n';
1335
    case 'r':
1336
      return '\r';
1337
    case 't':
1338
      return '\t';
1339
    case 'v':
1340
      return '\v';
1341
    case '\n':
1342
      return -2;
1343
    case 0:
1344
      (*string_ptr)--;
1345
      return 0;
1346
    case '^':
1347
      c = *(*string_ptr)++;
1348
      if (c == '\\')
1349
        c = parse_escape (string_ptr);
1350
      if (c == '?')
1351
        return 0177;
1352
      return (c & 0200) | (c & 037);
1353
 
1354
    case '0':
1355
    case '1':
1356
    case '2':
1357
    case '3':
1358
    case '4':
1359
    case '5':
1360
    case '6':
1361
    case '7':
1362
      {
1363
        register int i = c - '0';
1364
        register int count = 0;
1365
        while (++count < 3)
1366
          {
1367
            if ((c = *(*string_ptr)++) >= '0' && c <= '7')
1368
              {
1369
                i *= 8;
1370
                i += c - '0';
1371
              }
1372
            else
1373
              {
1374
                (*string_ptr)--;
1375
                break;
1376
              }
1377
          }
1378
        return i;
1379
      }
1380
    default:
1381
      return c;
1382
    }
1383
}
1384
 
1385
/* Print the character C on STREAM as part of the contents of a literal
1386
   string whose delimiter is QUOTER.  Note that this routine should only
1387
   be call for printing things which are independent of the language
1388
   of the program being debugged. */
1389
 
1390
static void printchar (int c, void (*do_fputs) (const char *, struct ui_file*), void (*do_fprintf) (struct ui_file*, const char *, ...), struct ui_file *stream, int quoter);
1391
 
1392
static void
1393
printchar (c, do_fputs, do_fprintf, stream, quoter)
1394
     int c;
1395
     void (*do_fputs) PARAMS ((const char *, struct ui_file*));
1396
     void (*do_fprintf) PARAMS ((struct ui_file*, const char *, ...));
1397
     struct ui_file *stream;
1398
     int quoter;
1399
{
1400
 
1401
  c &= 0xFF;                    /* Avoid sign bit follies */
1402
 
1403
  if (c < 0x20 ||               /* Low control chars */
1404
      (c >= 0x7F && c < 0xA0) ||        /* DEL, High controls */
1405
      (sevenbit_strings && c >= 0x80))
1406
    {                           /* high order bit set */
1407
      switch (c)
1408
        {
1409
        case '\n':
1410
          do_fputs ("\\n", stream);
1411
          break;
1412
        case '\b':
1413
          do_fputs ("\\b", stream);
1414
          break;
1415
        case '\t':
1416
          do_fputs ("\\t", stream);
1417
          break;
1418
        case '\f':
1419
          do_fputs ("\\f", stream);
1420
          break;
1421
        case '\r':
1422
          do_fputs ("\\r", stream);
1423
          break;
1424
        case '\033':
1425
          do_fputs ("\\e", stream);
1426
          break;
1427
        case '\007':
1428
          do_fputs ("\\a", stream);
1429
          break;
1430
        default:
1431
          do_fprintf (stream, "\\%.3o", (unsigned int) c);
1432
          break;
1433
        }
1434
    }
1435
  else
1436
    {
1437
      if (c == '\\' || c == quoter)
1438
        do_fputs ("\\", stream);
1439
      do_fprintf (stream, "%c", c);
1440
    }
1441
}
1442
 
1443
/* Print the character C on STREAM as part of the contents of a
1444
   literal string whose delimiter is QUOTER.  Note that these routines
1445
   should only be call for printing things which are independent of
1446
   the language of the program being debugged. */
1447
 
1448
void
1449
fputstr_filtered (str, quoter, stream)
1450
     const char *str;
1451
     int quoter;
1452
     struct ui_file *stream;
1453
{
1454
  while (*str)
1455
    printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1456
}
1457
 
1458
void
1459
fputstr_unfiltered (str, quoter, stream)
1460
     const char *str;
1461
     int quoter;
1462
     struct ui_file *stream;
1463
{
1464
  while (*str)
1465
    printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1466
}
1467
 
1468
void
1469
fputstrn_unfiltered (str, n, quoter, stream)
1470
     const char *str;
1471
     int n;
1472
     int quoter;
1473
     struct ui_file *stream;
1474
{
1475
  int i;
1476
  for (i = 0; i < n; i++)
1477
    printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1478
}
1479
 
1480
 
1481
 
1482
/* Number of lines per page or UINT_MAX if paging is disabled.  */
1483
static unsigned int lines_per_page;
1484
/* Number of chars per line or UNIT_MAX if line folding is disabled.  */
1485
static unsigned int chars_per_line;
1486
/* Current count of lines printed on this page, chars on this line.  */
1487
static unsigned int lines_printed, chars_printed;
1488
 
1489
/* Buffer and start column of buffered text, for doing smarter word-
1490
   wrapping.  When someone calls wrap_here(), we start buffering output
1491
   that comes through fputs_filtered().  If we see a newline, we just
1492
   spit it out and forget about the wrap_here().  If we see another
1493
   wrap_here(), we spit it out and remember the newer one.  If we see
1494
   the end of the line, we spit out a newline, the indent, and then
1495
   the buffered output.  */
1496
 
1497
/* Malloc'd buffer with chars_per_line+2 bytes.  Contains characters which
1498
   are waiting to be output (they have already been counted in chars_printed).
1499
   When wrap_buffer[0] is null, the buffer is empty.  */
1500
static char *wrap_buffer;
1501
 
1502
/* Pointer in wrap_buffer to the next character to fill.  */
1503
static char *wrap_pointer;
1504
 
1505
/* String to indent by if the wrap occurs.  Must not be NULL if wrap_column
1506
   is non-zero.  */
1507
static char *wrap_indent;
1508
 
1509
/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1510
   is not in effect.  */
1511
static int wrap_column;
1512
 
1513
 
1514
/* Inialize the lines and chars per page */
1515
void
1516
init_page_info ()
1517
{
1518
#if defined(TUI)
1519
  if (tui_version && m_winPtrNotNull (cmdWin))
1520
    {
1521
      lines_per_page = cmdWin->generic.height;
1522
      chars_per_line = cmdWin->generic.width;
1523
    }
1524
  else
1525
#endif
1526
    {
1527
      /* These defaults will be used if we are unable to get the correct
1528
         values from termcap.  */
1529
#if defined(__GO32__)
1530
      lines_per_page = ScreenRows ();
1531
      chars_per_line = ScreenCols ();
1532
#else
1533
      lines_per_page = 24;
1534
      chars_per_line = 80;
1535
 
1536
#if !defined (MPW) && !defined (_WIN32)
1537
      /* No termcap under MPW, although might be cool to do something
1538
         by looking at worksheet or console window sizes. */
1539
      /* Initialize the screen height and width from termcap.  */
1540
      {
1541
        char *termtype = getenv ("TERM");
1542
 
1543
        /* Positive means success, nonpositive means failure.  */
1544
        int status;
1545
 
1546
        /* 2048 is large enough for all known terminals, according to the
1547
           GNU termcap manual.  */
1548
        char term_buffer[2048];
1549
 
1550
        if (termtype)
1551
          {
1552
            status = tgetent (term_buffer, termtype);
1553
            if (status > 0)
1554
              {
1555
                int val;
1556
                int running_in_emacs = getenv ("EMACS") != NULL;
1557
 
1558
                val = tgetnum ("li");
1559
                if (val >= 0 && !running_in_emacs)
1560
                  lines_per_page = val;
1561
                else
1562
                  /* The number of lines per page is not mentioned
1563
                     in the terminal description.  This probably means
1564
                     that paging is not useful (e.g. emacs shell window),
1565
                     so disable paging.  */
1566
                  lines_per_page = UINT_MAX;
1567
 
1568
                val = tgetnum ("co");
1569
                if (val >= 0)
1570
                  chars_per_line = val;
1571
              }
1572
          }
1573
      }
1574
#endif /* MPW */
1575
 
1576
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1577
 
1578
      /* If there is a better way to determine the window size, use it. */
1579
      SIGWINCH_HANDLER (SIGWINCH);
1580
#endif
1581
#endif
1582
      /* If the output is not a terminal, don't paginate it.  */
1583
      if (!ui_file_isatty (gdb_stdout))
1584
        lines_per_page = UINT_MAX;
1585
    }                           /* the command_line_version */
1586
  set_width ();
1587
}
1588
 
1589
static void
1590
set_width ()
1591
{
1592
  if (chars_per_line == 0)
1593
    init_page_info ();
1594
 
1595
  if (!wrap_buffer)
1596
    {
1597
      wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1598
      wrap_buffer[0] = '\0';
1599
    }
1600
  else
1601
    wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1602
  wrap_pointer = wrap_buffer;   /* Start it at the beginning */
1603
}
1604
 
1605
/* ARGSUSED */
1606
static void
1607
set_width_command (args, from_tty, c)
1608
     char *args;
1609
     int from_tty;
1610
     struct cmd_list_element *c;
1611
{
1612
  set_width ();
1613
}
1614
 
1615
/* Wait, so the user can read what's on the screen.  Prompt the user
1616
   to continue by pressing RETURN.  */
1617
 
1618
static void
1619
prompt_for_continue ()
1620
{
1621
  char *ignore;
1622
  char cont_prompt[120];
1623
 
1624
  if (annotation_level > 1)
1625
    printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1626
 
1627
  strcpy (cont_prompt,
1628
          "---Type <return> to continue, or q <return> to quit---");
1629
  if (annotation_level > 1)
1630
    strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1631
 
1632
  /* We must do this *before* we call gdb_readline, else it will eventually
1633
     call us -- thinking that we're trying to print beyond the end of the
1634
     screen.  */
1635
  reinitialize_more_filter ();
1636
 
1637
  immediate_quit++;
1638
  /* On a real operating system, the user can quit with SIGINT.
1639
     But not on GO32.
1640
 
1641
     'q' is provided on all systems so users don't have to change habits
1642
     from system to system, and because telling them what to do in
1643
     the prompt is more user-friendly than expecting them to think of
1644
     SIGINT.  */
1645
  /* Call readline, not gdb_readline, because GO32 readline handles control-C
1646
     whereas control-C to gdb_readline will cause the user to get dumped
1647
     out to DOS.  */
1648
  ignore = readline (cont_prompt);
1649
 
1650
  if (annotation_level > 1)
1651
    printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1652
 
1653
  if (ignore)
1654
    {
1655
      char *p = ignore;
1656
      while (*p == ' ' || *p == '\t')
1657
        ++p;
1658
      if (p[0] == 'q')
1659
        {
1660
          if (!event_loop_p)
1661
            request_quit (SIGINT);
1662
          else
1663
            async_request_quit (0);
1664
        }
1665
      free (ignore);
1666
    }
1667
  immediate_quit--;
1668
 
1669
  /* Now we have to do this again, so that GDB will know that it doesn't
1670
     need to save the ---Type <return>--- line at the top of the screen.  */
1671
  reinitialize_more_filter ();
1672
 
1673
  dont_repeat ();               /* Forget prev cmd -- CR won't repeat it. */
1674
}
1675
 
1676
/* Reinitialize filter; ie. tell it to reset to original values.  */
1677
 
1678
void
1679
reinitialize_more_filter ()
1680
{
1681
  lines_printed = 0;
1682
  chars_printed = 0;
1683
}
1684
 
1685
/* Indicate that if the next sequence of characters overflows the line,
1686
   a newline should be inserted here rather than when it hits the end.
1687
   If INDENT is non-null, it is a string to be printed to indent the
1688
   wrapped part on the next line.  INDENT must remain accessible until
1689
   the next call to wrap_here() or until a newline is printed through
1690
   fputs_filtered().
1691
 
1692
   If the line is already overfull, we immediately print a newline and
1693
   the indentation, and disable further wrapping.
1694
 
1695
   If we don't know the width of lines, but we know the page height,
1696
   we must not wrap words, but should still keep track of newlines
1697
   that were explicitly printed.
1698
 
1699
   INDENT should not contain tabs, as that will mess up the char count
1700
   on the next line.  FIXME.
1701
 
1702
   This routine is guaranteed to force out any output which has been
1703
   squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1704
   used to force out output from the wrap_buffer.  */
1705
 
1706
void
1707
wrap_here (indent)
1708
     char *indent;
1709
{
1710
  /* This should have been allocated, but be paranoid anyway. */
1711
  if (!wrap_buffer)
1712
    abort ();
1713
 
1714
  if (wrap_buffer[0])
1715
    {
1716
      *wrap_pointer = '\0';
1717
      fputs_unfiltered (wrap_buffer, gdb_stdout);
1718
    }
1719
  wrap_pointer = wrap_buffer;
1720
  wrap_buffer[0] = '\0';
1721
  if (chars_per_line == UINT_MAX)       /* No line overflow checking */
1722
    {
1723
      wrap_column = 0;
1724
    }
1725
  else if (chars_printed >= chars_per_line)
1726
    {
1727
      puts_filtered ("\n");
1728
      if (indent != NULL)
1729
        puts_filtered (indent);
1730
      wrap_column = 0;
1731
    }
1732
  else
1733
    {
1734
      wrap_column = chars_printed;
1735
      if (indent == NULL)
1736
        wrap_indent = "";
1737
      else
1738
        wrap_indent = indent;
1739
    }
1740
}
1741
 
1742
/* Ensure that whatever gets printed next, using the filtered output
1743
   commands, starts at the beginning of the line.  I.E. if there is
1744
   any pending output for the current line, flush it and start a new
1745
   line.  Otherwise do nothing. */
1746
 
1747
void
1748
begin_line ()
1749
{
1750
  if (chars_printed > 0)
1751
    {
1752
      puts_filtered ("\n");
1753
    }
1754
}
1755
 
1756
 
1757
/* Like fputs but if FILTER is true, pause after every screenful.
1758
 
1759
   Regardless of FILTER can wrap at points other than the final
1760
   character of a line.
1761
 
1762
   Unlike fputs, fputs_maybe_filtered does not return a value.
1763
   It is OK for LINEBUFFER to be NULL, in which case just don't print
1764
   anything.
1765
 
1766
   Note that a longjmp to top level may occur in this routine (only if
1767
   FILTER is true) (since prompt_for_continue may do so) so this
1768
   routine should not be called when cleanups are not in place.  */
1769
 
1770
static void
1771
fputs_maybe_filtered (linebuffer, stream, filter)
1772
     const char *linebuffer;
1773
     struct ui_file *stream;
1774
     int filter;
1775
{
1776
  const char *lineptr;
1777
 
1778
  if (linebuffer == 0)
1779
    return;
1780
 
1781
  /* Don't do any filtering if it is disabled.  */
1782
  if ((stream != gdb_stdout) || !pagination_enabled
1783
      || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
1784
    {
1785
      fputs_unfiltered (linebuffer, stream);
1786
      return;
1787
    }
1788
 
1789
  /* Go through and output each character.  Show line extension
1790
     when this is necessary; prompt user for new page when this is
1791
     necessary.  */
1792
 
1793
  lineptr = linebuffer;
1794
  while (*lineptr)
1795
    {
1796
      /* Possible new page.  */
1797
      if (filter &&
1798
          (lines_printed >= lines_per_page - 1))
1799
        prompt_for_continue ();
1800
 
1801
      while (*lineptr && *lineptr != '\n')
1802
        {
1803
          /* Print a single line.  */
1804
          if (*lineptr == '\t')
1805
            {
1806
              if (wrap_column)
1807
                *wrap_pointer++ = '\t';
1808
              else
1809
                fputc_unfiltered ('\t', stream);
1810
              /* Shifting right by 3 produces the number of tab stops
1811
                 we have already passed, and then adding one and
1812
                 shifting left 3 advances to the next tab stop.  */
1813
              chars_printed = ((chars_printed >> 3) + 1) << 3;
1814
              lineptr++;
1815
            }
1816
          else
1817
            {
1818
              if (wrap_column)
1819
                *wrap_pointer++ = *lineptr;
1820
              else
1821
                fputc_unfiltered (*lineptr, stream);
1822
              chars_printed++;
1823
              lineptr++;
1824
            }
1825
 
1826
          if (chars_printed >= chars_per_line)
1827
            {
1828
              unsigned int save_chars = chars_printed;
1829
 
1830
              chars_printed = 0;
1831
              lines_printed++;
1832
              /* If we aren't actually wrapping, don't output newline --
1833
                 if chars_per_line is right, we probably just overflowed
1834
                 anyway; if it's wrong, let us keep going.  */
1835
              if (wrap_column)
1836
                fputc_unfiltered ('\n', stream);
1837
 
1838
              /* Possible new page.  */
1839
              if (lines_printed >= lines_per_page - 1)
1840
                prompt_for_continue ();
1841
 
1842
              /* Now output indentation and wrapped string */
1843
              if (wrap_column)
1844
                {
1845
                  fputs_unfiltered (wrap_indent, stream);
1846
                  *wrap_pointer = '\0';         /* Null-terminate saved stuff */
1847
                  fputs_unfiltered (wrap_buffer, stream);       /* and eject it */
1848
                  /* FIXME, this strlen is what prevents wrap_indent from
1849
                     containing tabs.  However, if we recurse to print it
1850
                     and count its chars, we risk trouble if wrap_indent is
1851
                     longer than (the user settable) chars_per_line.
1852
                     Note also that this can set chars_printed > chars_per_line
1853
                     if we are printing a long string.  */
1854
                  chars_printed = strlen (wrap_indent)
1855
                    + (save_chars - wrap_column);
1856
                  wrap_pointer = wrap_buffer;   /* Reset buffer */
1857
                  wrap_buffer[0] = '\0';
1858
                  wrap_column = 0;       /* And disable fancy wrap */
1859
                }
1860
            }
1861
        }
1862
 
1863
      if (*lineptr == '\n')
1864
        {
1865
          chars_printed = 0;
1866
          wrap_here ((char *) 0);        /* Spit out chars, cancel further wraps */
1867
          lines_printed++;
1868
          fputc_unfiltered ('\n', stream);
1869
          lineptr++;
1870
        }
1871
    }
1872
}
1873
 
1874
void
1875
fputs_filtered (linebuffer, stream)
1876
     const char *linebuffer;
1877
     struct ui_file *stream;
1878
{
1879
  fputs_maybe_filtered (linebuffer, stream, 1);
1880
}
1881
 
1882
int
1883
putchar_unfiltered (c)
1884
     int c;
1885
{
1886
  char buf = c;
1887
  ui_file_write (gdb_stdout, &buf, 1);
1888
  return c;
1889
}
1890
 
1891
int
1892
fputc_unfiltered (c, stream)
1893
     int c;
1894
     struct ui_file *stream;
1895
{
1896
  char buf = c;
1897
  ui_file_write (stream, &buf, 1);
1898
  return c;
1899
}
1900
 
1901
int
1902
fputc_filtered (c, stream)
1903
     int c;
1904
     struct ui_file *stream;
1905
{
1906
  char buf[2];
1907
 
1908
  buf[0] = c;
1909
  buf[1] = 0;
1910
  fputs_filtered (buf, stream);
1911
  return c;
1912
}
1913
 
1914
/* puts_debug is like fputs_unfiltered, except it prints special
1915
   characters in printable fashion.  */
1916
 
1917
void
1918
puts_debug (prefix, string, suffix)
1919
     char *prefix;
1920
     char *string;
1921
     char *suffix;
1922
{
1923
  int ch;
1924
 
1925
  /* Print prefix and suffix after each line.  */
1926
  static int new_line = 1;
1927
  static int return_p = 0;
1928
  static char *prev_prefix = "";
1929
  static char *prev_suffix = "";
1930
 
1931
  if (*string == '\n')
1932
    return_p = 0;
1933
 
1934
  /* If the prefix is changing, print the previous suffix, a new line,
1935
     and the new prefix.  */
1936
  if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
1937
    {
1938
      fputs_unfiltered (prev_suffix, gdb_stdlog);
1939
      fputs_unfiltered ("\n", gdb_stdlog);
1940
      fputs_unfiltered (prefix, gdb_stdlog);
1941
    }
1942
 
1943
  /* Print prefix if we printed a newline during the previous call.  */
1944
  if (new_line)
1945
    {
1946
      new_line = 0;
1947
      fputs_unfiltered (prefix, gdb_stdlog);
1948
    }
1949
 
1950
  prev_prefix = prefix;
1951
  prev_suffix = suffix;
1952
 
1953
  /* Output characters in a printable format.  */
1954
  while ((ch = *string++) != '\0')
1955
    {
1956
      switch (ch)
1957
        {
1958
        default:
1959
          if (isprint (ch))
1960
            fputc_unfiltered (ch, gdb_stdlog);
1961
 
1962
          else
1963
            fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
1964
          break;
1965
 
1966
        case '\\':
1967
          fputs_unfiltered ("\\\\", gdb_stdlog);
1968
          break;
1969
        case '\b':
1970
          fputs_unfiltered ("\\b", gdb_stdlog);
1971
          break;
1972
        case '\f':
1973
          fputs_unfiltered ("\\f", gdb_stdlog);
1974
          break;
1975
        case '\n':
1976
          new_line = 1;
1977
          fputs_unfiltered ("\\n", gdb_stdlog);
1978
          break;
1979
        case '\r':
1980
          fputs_unfiltered ("\\r", gdb_stdlog);
1981
          break;
1982
        case '\t':
1983
          fputs_unfiltered ("\\t", gdb_stdlog);
1984
          break;
1985
        case '\v':
1986
          fputs_unfiltered ("\\v", gdb_stdlog);
1987
          break;
1988
        }
1989
 
1990
      return_p = ch == '\r';
1991
    }
1992
 
1993
  /* Print suffix if we printed a newline.  */
1994
  if (new_line)
1995
    {
1996
      fputs_unfiltered (suffix, gdb_stdlog);
1997
      fputs_unfiltered ("\n", gdb_stdlog);
1998
    }
1999
}
2000
 
2001
 
2002
/* Print a variable number of ARGS using format FORMAT.  If this
2003
   information is going to put the amount written (since the last call
2004
   to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2005
   call prompt_for_continue to get the users permision to continue.
2006
 
2007
   Unlike fprintf, this function does not return a value.
2008
 
2009
   We implement three variants, vfprintf (takes a vararg list and stream),
2010
   fprintf (takes a stream to write on), and printf (the usual).
2011
 
2012
   Note also that a longjmp to top level may occur in this routine
2013
   (since prompt_for_continue may do so) so this routine should not be
2014
   called when cleanups are not in place.  */
2015
 
2016
static void
2017
vfprintf_maybe_filtered (stream, format, args, filter)
2018
     struct ui_file *stream;
2019
     const char *format;
2020
     va_list args;
2021
     int filter;
2022
{
2023
  char *linebuffer;
2024
  struct cleanup *old_cleanups;
2025
 
2026
  vasprintf (&linebuffer, format, args);
2027
  if (linebuffer == NULL)
2028
    {
2029
      fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
2030
      exit (1);
2031
    }
2032
  old_cleanups = make_cleanup (free, linebuffer);
2033
  fputs_maybe_filtered (linebuffer, stream, filter);
2034
  do_cleanups (old_cleanups);
2035
}
2036
 
2037
 
2038
void
2039
vfprintf_filtered (stream, format, args)
2040
     struct ui_file *stream;
2041
     const char *format;
2042
     va_list args;
2043
{
2044
  vfprintf_maybe_filtered (stream, format, args, 1);
2045
}
2046
 
2047
void
2048
vfprintf_unfiltered (stream, format, args)
2049
     struct ui_file *stream;
2050
     const char *format;
2051
     va_list args;
2052
{
2053
  char *linebuffer;
2054
  struct cleanup *old_cleanups;
2055
 
2056
  vasprintf (&linebuffer, format, args);
2057
  if (linebuffer == NULL)
2058
    {
2059
      fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
2060
      exit (1);
2061
    }
2062
  old_cleanups = make_cleanup (free, linebuffer);
2063
  fputs_unfiltered (linebuffer, stream);
2064
  do_cleanups (old_cleanups);
2065
}
2066
 
2067
void
2068
vprintf_filtered (format, args)
2069
     const char *format;
2070
     va_list args;
2071
{
2072
  vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2073
}
2074
 
2075
void
2076
vprintf_unfiltered (format, args)
2077
     const char *format;
2078
     va_list args;
2079
{
2080
  vfprintf_unfiltered (gdb_stdout, format, args);
2081
}
2082
 
2083
void
2084
fprintf_filtered (struct ui_file * stream, const char *format,...)
2085
{
2086
  va_list args;
2087
  va_start (args, format);
2088
  vfprintf_filtered (stream, format, args);
2089
  va_end (args);
2090
}
2091
 
2092
void
2093
fprintf_unfiltered (struct ui_file * stream, const char *format,...)
2094
{
2095
  va_list args;
2096
  va_start (args, format);
2097
  vfprintf_unfiltered (stream, format, args);
2098
  va_end (args);
2099
}
2100
 
2101
/* Like fprintf_filtered, but prints its result indented.
2102
   Called as fprintfi_filtered (spaces, stream, format, ...);  */
2103
 
2104
void
2105
fprintfi_filtered (int spaces, struct ui_file * stream, const char *format,...)
2106
{
2107
  va_list args;
2108
  va_start (args, format);
2109
  print_spaces_filtered (spaces, stream);
2110
 
2111
  vfprintf_filtered (stream, format, args);
2112
  va_end (args);
2113
}
2114
 
2115
 
2116
void
2117
printf_filtered (const char *format,...)
2118
{
2119
  va_list args;
2120
  va_start (args, format);
2121
  vfprintf_filtered (gdb_stdout, format, args);
2122
  va_end (args);
2123
}
2124
 
2125
 
2126
void
2127
printf_unfiltered (const char *format,...)
2128
{
2129
  va_list args;
2130
  va_start (args, format);
2131
  vfprintf_unfiltered (gdb_stdout, format, args);
2132
  va_end (args);
2133
}
2134
 
2135
/* Like printf_filtered, but prints it's result indented.
2136
   Called as printfi_filtered (spaces, format, ...);  */
2137
 
2138
void
2139
printfi_filtered (int spaces, const char *format,...)
2140
{
2141
  va_list args;
2142
  va_start (args, format);
2143
  print_spaces_filtered (spaces, gdb_stdout);
2144
  vfprintf_filtered (gdb_stdout, format, args);
2145
  va_end (args);
2146
}
2147
 
2148
/* Easy -- but watch out!
2149
 
2150
   This routine is *not* a replacement for puts()!  puts() appends a newline.
2151
   This one doesn't, and had better not!  */
2152
 
2153
void
2154
puts_filtered (string)
2155
     const char *string;
2156
{
2157
  fputs_filtered (string, gdb_stdout);
2158
}
2159
 
2160
void
2161
puts_unfiltered (string)
2162
     const char *string;
2163
{
2164
  fputs_unfiltered (string, gdb_stdout);
2165
}
2166
 
2167
/* Return a pointer to N spaces and a null.  The pointer is good
2168
   until the next call to here.  */
2169
char *
2170
n_spaces (n)
2171
     int n;
2172
{
2173
  char *t;
2174
  static char *spaces = 0;
2175
  static int max_spaces = -1;
2176
 
2177
  if (n > max_spaces)
2178
    {
2179
      if (spaces)
2180
        free (spaces);
2181
      spaces = (char *) xmalloc (n + 1);
2182
      for (t = spaces + n; t != spaces;)
2183
        *--t = ' ';
2184
      spaces[n] = '\0';
2185
      max_spaces = n;
2186
    }
2187
 
2188
  return spaces + max_spaces - n;
2189
}
2190
 
2191
/* Print N spaces.  */
2192
void
2193
print_spaces_filtered (n, stream)
2194
     int n;
2195
     struct ui_file *stream;
2196
{
2197
  fputs_filtered (n_spaces (n), stream);
2198
}
2199
 
2200
/* C++ demangler stuff.  */
2201
 
2202
/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2203
   LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2204
   If the name is not mangled, or the language for the name is unknown, or
2205
   demangling is off, the name is printed in its "raw" form. */
2206
 
2207
void
2208
fprintf_symbol_filtered (stream, name, lang, arg_mode)
2209
     struct ui_file *stream;
2210
     char *name;
2211
     enum language lang;
2212
     int arg_mode;
2213
{
2214
  char *demangled;
2215
 
2216
  if (name != NULL)
2217
    {
2218
      /* If user wants to see raw output, no problem.  */
2219
      if (!demangle)
2220
        {
2221
          fputs_filtered (name, stream);
2222
        }
2223
      else
2224
        {
2225
          switch (lang)
2226
            {
2227
            case language_cplus:
2228
              demangled = cplus_demangle (name, arg_mode);
2229
              break;
2230
            case language_java:
2231
              demangled = cplus_demangle (name, arg_mode | DMGL_JAVA);
2232
              break;
2233
            case language_chill:
2234
              demangled = chill_demangle (name);
2235
              break;
2236
            default:
2237
              demangled = NULL;
2238
              break;
2239
            }
2240
          fputs_filtered (demangled ? demangled : name, stream);
2241
          if (demangled != NULL)
2242
            {
2243
              free (demangled);
2244
            }
2245
        }
2246
    }
2247
}
2248
 
2249
/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2250
   differences in whitespace.  Returns 0 if they match, non-zero if they
2251
   don't (slightly different than strcmp()'s range of return values).
2252
 
2253
   As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2254
   This "feature" is useful when searching for matching C++ function names
2255
   (such as if the user types 'break FOO', where FOO is a mangled C++
2256
   function). */
2257
 
2258
int
2259
strcmp_iw (string1, string2)
2260
     const char *string1;
2261
     const char *string2;
2262
{
2263
  while ((*string1 != '\0') && (*string2 != '\0'))
2264
    {
2265
      while (isspace (*string1))
2266
        {
2267
          string1++;
2268
        }
2269
      while (isspace (*string2))
2270
        {
2271
          string2++;
2272
        }
2273
      if (*string1 != *string2)
2274
        {
2275
          break;
2276
        }
2277
      if (*string1 != '\0')
2278
        {
2279
          string1++;
2280
          string2++;
2281
        }
2282
    }
2283
  return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2284
}
2285
 
2286
 
2287
/*
2288
   ** subset_compare()
2289
   **    Answer whether string_to_compare is a full or partial match to
2290
   **    template_string.  The partial match must be in sequence starting
2291
   **    at index 0.
2292
 */
2293
int
2294
subset_compare (string_to_compare, template_string)
2295
     char *string_to_compare;
2296
     char *template_string;
2297
{
2298
  int match;
2299
  if (template_string != (char *) NULL && string_to_compare != (char *) NULL &&
2300
      strlen (string_to_compare) <= strlen (template_string))
2301
    match = (strncmp (template_string,
2302
                      string_to_compare,
2303
                      strlen (string_to_compare)) == 0);
2304
  else
2305
    match = 0;
2306
  return match;
2307
}
2308
 
2309
 
2310
static void pagination_on_command PARAMS ((char *arg, int from_tty));
2311
static void
2312
pagination_on_command (arg, from_tty)
2313
     char *arg;
2314
     int from_tty;
2315
{
2316
  pagination_enabled = 1;
2317
}
2318
 
2319
static void pagination_on_command PARAMS ((char *arg, int from_tty));
2320
static void
2321
pagination_off_command (arg, from_tty)
2322
     char *arg;
2323
     int from_tty;
2324
{
2325
  pagination_enabled = 0;
2326
}
2327
 
2328
 
2329
void
2330
initialize_utils ()
2331
{
2332
  struct cmd_list_element *c;
2333
 
2334
  c = add_set_cmd ("width", class_support, var_uinteger,
2335
                   (char *) &chars_per_line,
2336
                   "Set number of characters gdb thinks are in a line.",
2337
                   &setlist);
2338
  add_show_from_set (c, &showlist);
2339
  c->function.sfunc = set_width_command;
2340
 
2341
  add_show_from_set
2342
    (add_set_cmd ("height", class_support,
2343
                  var_uinteger, (char *) &lines_per_page,
2344
                  "Set number of lines gdb thinks are in a page.", &setlist),
2345
     &showlist);
2346
 
2347
  init_page_info ();
2348
 
2349
  /* If the output is not a terminal, don't paginate it.  */
2350
  if (!ui_file_isatty (gdb_stdout))
2351
    lines_per_page = UINT_MAX;
2352
 
2353
  set_width_command ((char *) NULL, 0, c);
2354
 
2355
  add_show_from_set
2356
    (add_set_cmd ("demangle", class_support, var_boolean,
2357
                  (char *) &demangle,
2358
             "Set demangling of encoded C++ names when displaying symbols.",
2359
                  &setprintlist),
2360
     &showprintlist);
2361
 
2362
  add_show_from_set
2363
    (add_set_cmd ("pagination", class_support,
2364
                  var_boolean, (char *) &pagination_enabled,
2365
                  "Set state of pagination.", &setlist),
2366
     &showlist);
2367
  if (xdb_commands)
2368
    {
2369
      add_com ("am", class_support, pagination_on_command,
2370
               "Enable pagination");
2371
      add_com ("sm", class_support, pagination_off_command,
2372
               "Disable pagination");
2373
    }
2374
 
2375
  add_show_from_set
2376
    (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
2377
                  (char *) &sevenbit_strings,
2378
                  "Set printing of 8-bit characters in strings as \\nnn.",
2379
                  &setprintlist),
2380
     &showprintlist);
2381
 
2382
  add_show_from_set
2383
    (add_set_cmd ("asm-demangle", class_support, var_boolean,
2384
                  (char *) &asm_demangle,
2385
                  "Set demangling of C++ names in disassembly listings.",
2386
                  &setprintlist),
2387
     &showprintlist);
2388
}
2389
 
2390
/* Machine specific function to handle SIGWINCH signal. */
2391
 
2392
#ifdef  SIGWINCH_HANDLER_BODY
2393
SIGWINCH_HANDLER_BODY
2394
#endif
2395
 
2396
/* Support for converting target fp numbers into host DOUBLEST format.  */
2397
 
2398
/* XXX - This code should really be in libiberty/floatformat.c, however
2399
   configuration issues with libiberty made this very difficult to do in the
2400
   available time.  */
2401
 
2402
#include "floatformat.h"
2403
#include <math.h>               /* ldexp */
2404
 
2405
/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
2406
   going to bother with trying to muck around with whether it is defined in
2407
   a system header, what we do if not, etc.  */
2408
#define FLOATFORMAT_CHAR_BIT 8
2409
 
2410
static unsigned long get_field PARAMS ((unsigned char *,
2411
                                        enum floatformat_byteorders,
2412
                                        unsigned int,
2413
                                        unsigned int,
2414
                                        unsigned int));
2415
 
2416
/* Extract a field which starts at START and is LEN bytes long.  DATA and
2417
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
2418
static unsigned long
2419
get_field (data, order, total_len, start, len)
2420
     unsigned char *data;
2421
     enum floatformat_byteorders order;
2422
     unsigned int total_len;
2423
     unsigned int start;
2424
     unsigned int len;
2425
{
2426
  unsigned long result;
2427
  unsigned int cur_byte;
2428
  int cur_bitshift;
2429
 
2430
  /* Start at the least significant part of the field.  */
2431
  if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2432
    {
2433
      /* We start counting from the other end (i.e, from the high bytes
2434
         rather than the low bytes).  As such, we need to be concerned
2435
         with what happens if bit 0 doesn't start on a byte boundary.
2436
         I.e, we need to properly handle the case where total_len is
2437
         not evenly divisible by 8.  So we compute ``excess'' which
2438
         represents the number of bits from the end of our starting
2439
         byte needed to get to bit 0. */
2440
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
2441
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
2442
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
2443
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
2444
                     - FLOATFORMAT_CHAR_BIT;
2445
    }
2446
  else
2447
    {
2448
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
2449
      cur_bitshift =
2450
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
2451
    }
2452
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
2453
    result = *(data + cur_byte) >> (-cur_bitshift);
2454
  else
2455
    result = 0;
2456
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
2457
  if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2458
    ++cur_byte;
2459
  else
2460
    --cur_byte;
2461
 
2462
  /* Move towards the most significant part of the field.  */
2463
  while (cur_bitshift < len)
2464
    {
2465
      result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
2466
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
2467
      if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2468
        ++cur_byte;
2469
      else
2470
        --cur_byte;
2471
    }
2472
  if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
2473
    /* Mask out bits which are not part of the field */
2474
    result &= ((1UL << len) - 1);
2475
  return result;
2476
}
2477
 
2478
/* Convert from FMT to a DOUBLEST.
2479
   FROM is the address of the extended float.
2480
   Store the DOUBLEST in *TO.  */
2481
 
2482
void
2483
floatformat_to_doublest (fmt, from, to)
2484
     const struct floatformat *fmt;
2485
     char *from;
2486
     DOUBLEST *to;
2487
{
2488
  unsigned char *ufrom = (unsigned char *) from;
2489
  DOUBLEST dto;
2490
  long exponent;
2491
  unsigned long mant;
2492
  unsigned int mant_bits, mant_off;
2493
  int mant_bits_left;
2494
  int special_exponent;         /* It's a NaN, denorm or zero */
2495
 
2496
  /* If the mantissa bits are not contiguous from one end of the
2497
     mantissa to the other, we need to make a private copy of the
2498
     source bytes that is in the right order since the unpacking
2499
     algorithm assumes that the bits are contiguous.
2500
 
2501
     Swap the bytes individually rather than accessing them through
2502
     "long *" since we have no guarantee that they start on a long
2503
     alignment, and also sizeof(long) for the host could be different
2504
     than sizeof(long) for the target.  FIXME: Assumes sizeof(long)
2505
     for the target is 4. */
2506
 
2507
  if (fmt->byteorder == floatformat_littlebyte_bigword)
2508
    {
2509
      static unsigned char *newfrom;
2510
      unsigned char *swapin, *swapout;
2511
      int longswaps;
2512
 
2513
      longswaps = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
2514
      longswaps >>= 3;
2515
 
2516
      if (newfrom == NULL)
2517
        {
2518
          newfrom = (unsigned char *) xmalloc (fmt->totalsize);
2519
        }
2520
      swapout = newfrom;
2521
      swapin = ufrom;
2522
      ufrom = newfrom;
2523
      while (longswaps-- > 0)
2524
        {
2525
          /* This is ugly, but efficient */
2526
          *swapout++ = swapin[4];
2527
          *swapout++ = swapin[5];
2528
          *swapout++ = swapin[6];
2529
          *swapout++ = swapin[7];
2530
          *swapout++ = swapin[0];
2531
          *swapout++ = swapin[1];
2532
          *swapout++ = swapin[2];
2533
          *swapout++ = swapin[3];
2534
          swapin += 8;
2535
        }
2536
    }
2537
 
2538
  exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
2539
                        fmt->exp_start, fmt->exp_len);
2540
  /* Note that if exponent indicates a NaN, we can't really do anything useful
2541
     (not knowing if the host has NaN's, or how to build one).  So it will
2542
     end up as an infinity or something close; that is OK.  */
2543
 
2544
  mant_bits_left = fmt->man_len;
2545
  mant_off = fmt->man_start;
2546
  dto = 0.0;
2547
 
2548
  special_exponent = exponent == 0 || exponent == fmt->exp_nan;
2549
 
2550
/* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
2551
   we don't check for zero as the exponent doesn't matter. */
2552
  if (!special_exponent)
2553
    exponent -= fmt->exp_bias;
2554
  else if (exponent == 0)
2555
    exponent = 1 - fmt->exp_bias;
2556
 
2557
  /* Build the result algebraically.  Might go infinite, underflow, etc;
2558
     who cares. */
2559
 
2560
/* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
2561
   increment the exponent by one to account for the integer bit.  */
2562
 
2563
  if (!special_exponent)
2564
    {
2565
      if (fmt->intbit == floatformat_intbit_no)
2566
        dto = ldexp (1.0, exponent);
2567
      else
2568
        exponent++;
2569
    }
2570
 
2571
  while (mant_bits_left > 0)
2572
    {
2573
      mant_bits = min (mant_bits_left, 32);
2574
 
2575
      mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
2576
                        mant_off, mant_bits);
2577
 
2578
      dto += ldexp ((double) mant, exponent - mant_bits);
2579
      exponent -= mant_bits;
2580
      mant_off += mant_bits;
2581
      mant_bits_left -= mant_bits;
2582
    }
2583
 
2584
  /* Negate it if negative.  */
2585
  if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
2586
    dto = -dto;
2587
  *to = dto;
2588
}
2589
 
2590
static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
2591
                               unsigned int,
2592
                               unsigned int,
2593
                               unsigned int,
2594
                               unsigned long));
2595
 
2596
/* Set a field which starts at START and is LEN bytes long.  DATA and
2597
   TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
2598
static void
2599
put_field (data, order, total_len, start, len, stuff_to_put)
2600
     unsigned char *data;
2601
     enum floatformat_byteorders order;
2602
     unsigned int total_len;
2603
     unsigned int start;
2604
     unsigned int len;
2605
     unsigned long stuff_to_put;
2606
{
2607
  unsigned int cur_byte;
2608
  int cur_bitshift;
2609
 
2610
  /* Start at the least significant part of the field.  */
2611
  if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2612
    {
2613
      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
2614
      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
2615
                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
2616
      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
2617
                     - FLOATFORMAT_CHAR_BIT;
2618
    }
2619
  else
2620
    {
2621
      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
2622
      cur_bitshift =
2623
        ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
2624
    }
2625
  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
2626
    {
2627
      *(data + cur_byte) &=
2628
        ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
2629
          << (-cur_bitshift));
2630
      *(data + cur_byte) |=
2631
        (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
2632
    }
2633
  cur_bitshift += FLOATFORMAT_CHAR_BIT;
2634
  if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2635
    ++cur_byte;
2636
  else
2637
    --cur_byte;
2638
 
2639
  /* Move towards the most significant part of the field.  */
2640
  while (cur_bitshift < len)
2641
    {
2642
      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
2643
        {
2644
          /* This is the last byte.  */
2645
          *(data + cur_byte) &=
2646
            ~((1 << (len - cur_bitshift)) - 1);
2647
          *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
2648
        }
2649
      else
2650
        *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
2651
                              & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
2652
      cur_bitshift += FLOATFORMAT_CHAR_BIT;
2653
      if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2654
        ++cur_byte;
2655
      else
2656
        --cur_byte;
2657
    }
2658
}
2659
 
2660
#ifdef HAVE_LONG_DOUBLE
2661
/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
2662
   The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
2663
   frexp, but operates on the long double data type.  */
2664
 
2665
static long double ldfrexp PARAMS ((long double value, int *eptr));
2666
 
2667
static long double
2668
ldfrexp (value, eptr)
2669
     long double value;
2670
     int *eptr;
2671
{
2672
  long double tmp;
2673
  int exp;
2674
 
2675
  /* Unfortunately, there are no portable functions for extracting the exponent
2676
     of a long double, so we have to do it iteratively by multiplying or dividing
2677
     by two until the fraction is between 0.5 and 1.0.  */
2678
 
2679
  if (value < 0.0l)
2680
    value = -value;
2681
 
2682
  tmp = 1.0l;
2683
  exp = 0;
2684
 
2685
  if (value >= tmp)             /* Value >= 1.0 */
2686
    while (value >= tmp)
2687
      {
2688
        tmp *= 2.0l;
2689
        exp++;
2690
      }
2691
  else if (value != 0.0l)       /* Value < 1.0  and > 0.0 */
2692
    {
2693
      while (value < tmp)
2694
        {
2695
          tmp /= 2.0l;
2696
          exp--;
2697
        }
2698
      tmp *= 2.0l;
2699
      exp++;
2700
    }
2701
 
2702
  *eptr = exp;
2703
  return value / tmp;
2704
}
2705
#endif /* HAVE_LONG_DOUBLE */
2706
 
2707
 
2708
/* The converse: convert the DOUBLEST *FROM to an extended float
2709
   and store where TO points.  Neither FROM nor TO have any alignment
2710
   restrictions.  */
2711
 
2712
void
2713
floatformat_from_doublest (fmt, from, to)
2714
     CONST struct floatformat *fmt;
2715
     DOUBLEST *from;
2716
     char *to;
2717
{
2718
  DOUBLEST dfrom;
2719
  int exponent;
2720
  DOUBLEST mant;
2721
  unsigned int mant_bits, mant_off;
2722
  int mant_bits_left;
2723
  unsigned char *uto = (unsigned char *) to;
2724
 
2725
  memcpy (&dfrom, from, sizeof (dfrom));
2726
  memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
2727
                    / FLOATFORMAT_CHAR_BIT);
2728
  if (dfrom == 0)
2729
    return;                     /* Result is zero */
2730
  if (dfrom != dfrom)           /* Result is NaN */
2731
    {
2732
      /* From is NaN */
2733
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
2734
                 fmt->exp_len, fmt->exp_nan);
2735
      /* Be sure it's not infinity, but NaN value is irrel */
2736
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
2737
                 32, 1);
2738
      return;
2739
    }
2740
 
2741
  /* If negative, set the sign bit.  */
2742
  if (dfrom < 0)
2743
    {
2744
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
2745
      dfrom = -dfrom;
2746
    }
2747
 
2748
  if (dfrom + dfrom == dfrom && dfrom != 0.0)   /* Result is Infinity */
2749
    {
2750
      /* Infinity exponent is same as NaN's.  */
2751
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
2752
                 fmt->exp_len, fmt->exp_nan);
2753
      /* Infinity mantissa is all zeroes.  */
2754
      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
2755
                 fmt->man_len, 0);
2756
      return;
2757
    }
2758
 
2759
#ifdef HAVE_LONG_DOUBLE
2760
  mant = ldfrexp (dfrom, &exponent);
2761
#else
2762
  mant = frexp (dfrom, &exponent);
2763
#endif
2764
 
2765
  put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
2766
             exponent + fmt->exp_bias - 1);
2767
 
2768
  mant_bits_left = fmt->man_len;
2769
  mant_off = fmt->man_start;
2770
  while (mant_bits_left > 0)
2771
    {
2772
      unsigned long mant_long;
2773
      mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
2774
 
2775
      mant *= 4294967296.0;
2776
      mant_long = ((unsigned long) mant) & 0xffffffffL;
2777
      mant -= mant_long;
2778
 
2779
      /* If the integer bit is implicit, then we need to discard it.
2780
         If we are discarding a zero, we should be (but are not) creating
2781
         a denormalized number which means adjusting the exponent
2782
         (I think).  */
2783
      if (mant_bits_left == fmt->man_len
2784
          && fmt->intbit == floatformat_intbit_no)
2785
        {
2786
          mant_long <<= 1;
2787
          mant_long &= 0xffffffffL;
2788
          mant_bits -= 1;
2789
        }
2790
 
2791
      if (mant_bits < 32)
2792
        {
2793
          /* The bits we want are in the most significant MANT_BITS bits of
2794
             mant_long.  Move them to the least significant.  */
2795
          mant_long >>= 32 - mant_bits;
2796
        }
2797
 
2798
      put_field (uto, fmt->byteorder, fmt->totalsize,
2799
                 mant_off, mant_bits, mant_long);
2800
      mant_off += mant_bits;
2801
      mant_bits_left -= mant_bits;
2802
    }
2803
  if (fmt->byteorder == floatformat_littlebyte_bigword)
2804
    {
2805
      int count;
2806
      unsigned char *swaplow = uto;
2807
      unsigned char *swaphigh = uto + 4;
2808
      unsigned char tmp;
2809
 
2810
      for (count = 0; count < 4; count++)
2811
        {
2812
          tmp = *swaplow;
2813
          *swaplow++ = *swaphigh;
2814
          *swaphigh++ = tmp;
2815
        }
2816
    }
2817
}
2818
 
2819
/* temporary storage using circular buffer */
2820
#define NUMCELLS 16
2821
#define CELLSIZE 32
2822
static char *
2823
get_cell ()
2824
{
2825
  static char buf[NUMCELLS][CELLSIZE];
2826
  static int cell = 0;
2827
  if (++cell >= NUMCELLS)
2828
    cell = 0;
2829
  return buf[cell];
2830
}
2831
 
2832
/* print routines to handle variable size regs, etc.
2833
 
2834
   FIXME: Note that t_addr is a bfd_vma, which is currently either an
2835
   unsigned long or unsigned long long, determined at configure time.
2836
   If t_addr is an unsigned long long and sizeof (unsigned long long)
2837
   is greater than sizeof (unsigned long), then I believe this code will
2838
   probably lose, at least for little endian machines.  I believe that
2839
   it would also be better to eliminate the switch on the absolute size
2840
   of t_addr and replace it with a sequence of if statements that compare
2841
   sizeof t_addr with sizeof the various types and do the right thing,
2842
   which includes knowing whether or not the host supports long long.
2843
   -fnf
2844
 
2845
 */
2846
 
2847
int
2848
strlen_paddr (void)
2849
{
2850
  return (TARGET_PTR_BIT / 8 * 2);
2851
}
2852
 
2853
 
2854
/* eliminate warning from compiler on 32-bit systems */
2855
static int thirty_two = 32;
2856
 
2857
char *
2858
paddr (CORE_ADDR addr)
2859
{
2860
  char *paddr_str = get_cell ();
2861
  switch (TARGET_PTR_BIT / 8)
2862
    {
2863
    case 8:
2864
      sprintf (paddr_str, "%08lx%08lx",
2865
               (unsigned long) (addr >> thirty_two), (unsigned long) (addr & 0xffffffff));
2866
      break;
2867
    case 4:
2868
      sprintf (paddr_str, "%08lx", (unsigned long) addr);
2869
      break;
2870
    case 2:
2871
      sprintf (paddr_str, "%04x", (unsigned short) (addr & 0xffff));
2872
      break;
2873
    default:
2874
      sprintf (paddr_str, "%lx", (unsigned long) addr);
2875
    }
2876
  return paddr_str;
2877
}
2878
 
2879
char *
2880
paddr_nz (CORE_ADDR addr)
2881
{
2882
  char *paddr_str = get_cell ();
2883
  switch (TARGET_PTR_BIT / 8)
2884
    {
2885
    case 8:
2886
      {
2887
        unsigned long high = (unsigned long) (addr >> thirty_two);
2888
        if (high == 0)
2889
          sprintf (paddr_str, "%lx", (unsigned long) (addr & 0xffffffff));
2890
        else
2891
          sprintf (paddr_str, "%lx%08lx",
2892
                   high, (unsigned long) (addr & 0xffffffff));
2893
        break;
2894
      }
2895
    case 4:
2896
      sprintf (paddr_str, "%lx", (unsigned long) addr);
2897
      break;
2898
    case 2:
2899
      sprintf (paddr_str, "%x", (unsigned short) (addr & 0xffff));
2900
      break;
2901
    default:
2902
      sprintf (paddr_str, "%lx", (unsigned long) addr);
2903
    }
2904
  return paddr_str;
2905
}
2906
 
2907
static void
2908
decimal2str (char *paddr_str, char *sign, ULONGEST addr)
2909
{
2910
  /* steal code from valprint.c:print_decimal().  Should this worry
2911
     about the real size of addr as the above does? */
2912
  unsigned long temp[3];
2913
  int i = 0;
2914
  do
2915
    {
2916
      temp[i] = addr % (1000 * 1000 * 1000);
2917
      addr /= (1000 * 1000 * 1000);
2918
      i++;
2919
    }
2920
  while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
2921
  switch (i)
2922
    {
2923
    case 1:
2924
      sprintf (paddr_str, "%s%lu",
2925
               sign, temp[0]);
2926
      break;
2927
    case 2:
2928
      sprintf (paddr_str, "%s%lu%09lu",
2929
               sign, temp[1], temp[0]);
2930
      break;
2931
    case 3:
2932
      sprintf (paddr_str, "%s%lu%09lu%09lu",
2933
               sign, temp[2], temp[1], temp[0]);
2934
      break;
2935
    default:
2936
      abort ();
2937
    }
2938
}
2939
 
2940
char *
2941
paddr_u (CORE_ADDR addr)
2942
{
2943
  char *paddr_str = get_cell ();
2944
  decimal2str (paddr_str, "", addr);
2945
  return paddr_str;
2946
}
2947
 
2948
char *
2949
paddr_d (LONGEST addr)
2950
{
2951
  char *paddr_str = get_cell ();
2952
  if (addr < 0)
2953
    decimal2str (paddr_str, "-", -addr);
2954
  else
2955
    decimal2str (paddr_str, "", addr);
2956
  return paddr_str;
2957
}
2958
 
2959
char *
2960
preg (reg)
2961
     t_reg reg;
2962
{
2963
  char *preg_str = get_cell ();
2964
  switch (sizeof (t_reg))
2965
    {
2966
    case 8:
2967
      sprintf (preg_str, "%08lx%08lx",
2968
               (unsigned long) (reg >> thirty_two), (unsigned long) (reg & 0xffffffff));
2969
      break;
2970
    case 4:
2971
      sprintf (preg_str, "%08lx", (unsigned long) reg);
2972
      break;
2973
    case 2:
2974
      sprintf (preg_str, "%04x", (unsigned short) (reg & 0xffff));
2975
      break;
2976
    default:
2977
      sprintf (preg_str, "%lx", (unsigned long) reg);
2978
    }
2979
  return preg_str;
2980
}
2981
 
2982
char *
2983
preg_nz (reg)
2984
     t_reg reg;
2985
{
2986
  char *preg_str = get_cell ();
2987
  switch (sizeof (t_reg))
2988
    {
2989
    case 8:
2990
      {
2991
        unsigned long high = (unsigned long) (reg >> thirty_two);
2992
        if (high == 0)
2993
          sprintf (preg_str, "%lx", (unsigned long) (reg & 0xffffffff));
2994
        else
2995
          sprintf (preg_str, "%lx%08lx",
2996
                   high, (unsigned long) (reg & 0xffffffff));
2997
        break;
2998
      }
2999
    case 4:
3000
      sprintf (preg_str, "%lx", (unsigned long) reg);
3001
      break;
3002
    case 2:
3003
      sprintf (preg_str, "%x", (unsigned short) (reg & 0xffff));
3004
      break;
3005
    default:
3006
      sprintf (preg_str, "%lx", (unsigned long) reg);
3007
    }
3008
  return preg_str;
3009
}
3010
 
3011
/* Helper functions for INNER_THAN */
3012
int
3013
core_addr_lessthan (lhs, rhs)
3014
     CORE_ADDR lhs;
3015
     CORE_ADDR rhs;
3016
{
3017
  return (lhs < rhs);
3018
}
3019
 
3020
int
3021
core_addr_greaterthan (lhs, rhs)
3022
     CORE_ADDR lhs;
3023
     CORE_ADDR rhs;
3024
{
3025
  return (lhs > rhs);
3026
}

powered by: WebSVN 2.1.0

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