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