gdb/utils.c

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