gdb/utils.c

   1 /* General utility routines for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB 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 1, or (at your option)
   9 any later version.
  10
  11 GDB 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 GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/param.h>
  23 #include <pwd.h>
  24 #include "defs.h"
  25 #include "param.h"
  26 #include "signals.h"
  27 #include "gdbcmd.h"
  28 #include "terminal.h"
  29 #include <varargs.h>
  30 #include <ctype.h>
  31 #include <string.h>
  32 #include "bfd.h"
  33 #include "target.h"
  34
  35 extern volatile void return_to_top_level ();
  36 extern volatile void exit ();
  37 extern char *gdb_readline ();
  38 extern char *getenv();
  39 extern char *malloc();
  40 extern char *realloc();
  41
  42 /* If this definition isn't overridden by the header files, assume
  43    that isatty and fileno exist on this system.  */
  44 #ifndef ISATTY
  45 #define ISATTY(FP)      (isatty (fileno (FP)))
  46 #endif
  47
  48 #ifdef MISSING_VPRINTF
  49 #ifdef __GNU_LIBRARY
  50 #undef MISSING_VPRINTF
  51 #else  /* !__GNU_LIBRARY */
  52
  53 #ifndef vfprintf
  54 #define vfprintf(file, format, ap) _doprnt (format, ap, file)
  55 #endif /* vfprintf */
  56
  57 #ifndef vprintf
  58 /* Can't #define it since printcmd.c needs it */
  59 void
  60 vprintf (format, ap)
  61      char *format; void *ap;
  62 {
  63   vfprintf (stdout, format, ap);
  64 }
  65 #endif /* vprintf */
  66
  67 #endif /* GNU_LIBRARY */
  68 #endif /* MISSING_VPRINTF */
  69
  70 void error ();
  71 void fatal ();
  72
  73 /* Chain of cleanup actions established with make_cleanup,
  74    to be executed if an error happens.  */
  75
  76 static struct cleanup *cleanup_chain;
  77
  78 /* Nonzero means a quit has been requested.  */
  79
  80 int quit_flag;
  81
  82 /* Nonzero means quit immediately if Control-C is typed now,
  83    rather than waiting until QUIT is executed.  */
  84
  85 int immediate_quit;
  86
  87 /* Nonzero means that encoded C++ names should be printed out in their
  88    C++ form rather than raw.  */
  89
  90 int demangle = 1;
  91
  92 /* Nonzero means that encoded C++ names should be printed out in their
  93    C++ form even in assembler language displays.  If this is set, but
  94    DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls.  */
  95
  96 int asm_demangle = 0;
  97
  98 /* Nonzero means that strings with character values >0x7F should be printed
  99    as octal escapes.  Zero means just print the value (e.g. it's an
 100    international character, and the terminal or window can cope.)  */
 101
 102 int sevenbit_strings = 0;
 103 \f
 104 /* Add a new cleanup to the cleanup_chain,
 105    and return the previous chain pointer
 106    to be passed later to do_cleanups or discard_cleanups.
 107    Args are FUNCTION to clean up with, and ARG to pass to it.  */
 108
 109 struct cleanup *
 110 make_cleanup (function, arg)
 111      void (*function) ();
 112      int arg;
 113 {
 114   register struct cleanup *new
 115     = (struct cleanup *) xmalloc (sizeof (struct cleanup));
 116   register struct cleanup *old_chain = cleanup_chain;
 117
 118   new->next = cleanup_chain;
 119   new->function = function;
 120   new->arg = arg;
 121   cleanup_chain = new;
 122
 123   return old_chain;
 124 }
 125
 126 /* Discard cleanups and do the actions they describe
 127    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
 128
 129 void
 130 do_cleanups (old_chain)
 131      register struct cleanup *old_chain;
 132 {
 133   register struct cleanup *ptr;
 134   while ((ptr = cleanup_chain) != old_chain)
 135     {
 136       (*ptr->function) (ptr->arg);
 137       cleanup_chain = ptr->next;
 138       free (ptr);
 139     }
 140 }
 141
 142 /* Discard cleanups, not doing the actions they describe,
 143    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
 144
 145 void
 146 discard_cleanups (old_chain)
 147      register struct cleanup *old_chain;
 148 {
 149   register struct cleanup *ptr;
 150   while ((ptr = cleanup_chain) != old_chain)
 151     {
 152       cleanup_chain = ptr->next;
 153       free (ptr);
 154     }
 155 }
 156
 157 /* Set the cleanup_chain to 0, and return the old cleanup chain.  */
 158 struct cleanup *
 159 save_cleanups ()
 160 {
 161   struct cleanup *old_chain = cleanup_chain;
 162
 163   cleanup_chain = 0;
 164   return old_chain;
 165 }
 166
 167 /* Restore the cleanup chain from a previously saved chain.  */
 168 void
 169 restore_cleanups (chain)
 170      struct cleanup *chain;
 171 {
 172   cleanup_chain = chain;
 173 }
 174
 175 /* This function is useful for cleanups.
 176    Do
 177
 178      foo = xmalloc (...);
 179      old_chain = make_cleanup (free_current_contents, &foo);
 180
 181    to arrange to free the object thus allocated.  */
 182
 183 void
 184 free_current_contents (location)
 185      char **location;
 186 {
 187   free (*location);
 188 }
 189 \f
 190 /* Print an error message and return to command level.
 191    The first argument STRING is the error message, used as a fprintf string,
 192    and the remaining args are passed as arguments to it.  */
 193
 194 /* VARARGS */
 195 void
 196 error (va_alist)
 197      va_dcl
 198 {
 199   va_list args;
 200   char *string;
 201
 202   va_start (args);
 203   target_terminal_ours ();
 204   fflush (stdout);
 205   string = va_arg (args, char *);
 206   vfprintf (stderr, string, args);
 207   fprintf (stderr, "\n");
 208   va_end (args);
 209   return_to_top_level ();
 210 }
 211
 212 /* Print an error message and exit reporting failure.
 213    This is for a error that we cannot continue from.
 214    The arguments are printed a la printf.  */
 215
 216 /* VARARGS */
 217 void
 218 fatal (va_alist)
 219      va_dcl
 220 {
 221   va_list args;
 222   char *string;
 223
 224   va_start (args);
 225   string = va_arg (args, char *);
 226   fprintf (stderr, "gdb: ");
 227   vfprintf (stderr, string, args);
 228   fprintf (stderr, "\n");
 229   va_end (args);
 230   exit (1);
 231 }
 232
 233 /* Print an error message and exit, dumping core.
 234    The arguments are printed a la printf ().  */
 235 /* VARARGS */
 236 void
 237 fatal_dump_core (va_alist)
 238      va_dcl
 239 {
 240   va_list args;
 241   char *string;
 242
 243   va_start (args);
 244   string = va_arg (args, char *);
 245   /* "internal error" is always correct, since GDB should never dump
 246      core, no matter what the input.  */
 247   fprintf (stderr, "gdb internal error: ");
 248   vfprintf (stderr, string, args);
 249   fprintf (stderr, "\n");
 250   va_end (args);
 251
 252   signal (SIGQUIT, SIG_DFL);
 253   kill (getpid (), SIGQUIT);
 254   /* We should never get here, but just in case...  */
 255   exit (1);
 256 }
 257 \f
 258 /* Memory management stuff (malloc friends).  */
 259
 260 #if defined (NO_MALLOC_CHECK)
 261 void
 262 init_malloc ()
 263 {}
 264 #else /* Have mcheck().  */
 265 static void
 266 malloc_botch ()
 267 {
 268   fatal_dump_core ("Memory corruption");
 269 }
 270
 271 void
 272 init_malloc ()
 273 {
 274   mcheck (malloc_botch);
 275   mtrace ();
 276 }
 277 #endif /* Have mcheck().  */
 278
 279 /* Like malloc but get error if no storage available.  */
 280
 281 #ifdef __STDC__
 282 void *
 283 #else
 284 char *
 285 #endif
 286 xmalloc (size)
 287      long size;
 288 {
 289   register char *val;
 290
 291   /* At least one place (dbxread.c:condense_misc_bunches where misc_count == 0)
 292      GDB wants to allocate zero bytes.  */
 293   if (size == 0)
 294     return NULL;
 295
 296   val = (char *) malloc (size);
 297   if (!val)
 298     fatal ("virtual memory exhausted.", 0);
 299   return val;
 300 }
 301
 302 /* Like realloc but get error if no storage available.  */
 303
 304 #ifdef __STDC__
 305 void *
 306 #else
 307 char *
 308 #endif
 309 xrealloc (ptr, size)
 310      char *ptr;
 311      long size;
 312 {
 313   register char *val = (char *) realloc (ptr, size);
 314   if (!val)
 315     fatal ("virtual memory exhausted.", 0);
 316   return val;
 317 }
 318
 319 /* Print the system error message for errno, and also mention STRING
 320    as the file name for which the error was encountered.
 321    Then return to command level.  */
 322
 323 void
 324 perror_with_name (string)
 325      char *string;
 326 {
 327   extern int sys_nerr;
 328   extern char *sys_errlist[];
 329   char *err;
 330   char *combined;
 331
 332   if (errno < sys_nerr)
 333     err = sys_errlist[errno];
 334   else
 335     err = "unknown error";
 336
 337   combined = (char *) alloca (strlen (err) + strlen (string) + 3);
 338   strcpy (combined, string);
 339   strcat (combined, ": ");
 340   strcat (combined, err);
 341
 342   /* I understand setting these is a matter of taste.  Still, some people
 343      may clear errno but not know about bfd_error.  Doing this here is not
 344      unreasonable. */
 345   bfd_error = no_error;
 346   errno = 0;
 347
 348   error ("%s.", combined);
 349 }
 350
 351 /* Print the system error message for ERRCODE, and also mention STRING
 352    as the file name for which the error was encountered.  */
 353
 354 void
 355 print_sys_errmsg (string, errcode)
 356      char *string;
 357      int errcode;
 358 {
 359   extern int sys_nerr;
 360   extern char *sys_errlist[];
 361   char *err;
 362   char *combined;
 363
 364   if (errcode < sys_nerr)
 365     err = sys_errlist[errcode];
 366   else
 367     err = "unknown error";
 368
 369   combined = (char *) alloca (strlen (err) + strlen (string) + 3);
 370   strcpy (combined, string);
 371   strcat (combined, ": ");
 372   strcat (combined, err);
 373
 374   printf ("%s.\n", combined);
 375 }
 376
 377 /* Control C eventually causes this to be called, at a convenient time.  */
 378
 379 void
 380 quit ()
 381 {
 382   target_terminal_ours ();
 383 #ifdef HAVE_TERMIO
 384   ioctl (fileno (stdout), TCFLSH, 1);
 385 #else /* not HAVE_TERMIO */
 386   ioctl (fileno (stdout), TIOCFLUSH, 0);
 387 #endif /* not HAVE_TERMIO */
 388 #ifdef TIOCGPGRP
 389   error ("Quit");
 390 #else
 391   error ("Quit (expect signal %d when inferior is resumed)", SIGINT);
 392 #endif /* TIOCGPGRP */
 393 }
 394
 395 /* Control C comes here */
 396
 397 void
 398 request_quit ()
 399 {
 400   quit_flag = 1;
 401
 402 #ifdef USG
 403   /* Restore the signal handler.  */
 404   signal (SIGINT, request_quit);
 405 #endif
 406
 407   if (immediate_quit)
 408     quit ();
 409 }
 410 \f
 411 /* My replacement for the read system call.
 412    Used like `read' but keeps going if `read' returns too soon.  */
 413
 414 int
 415 myread (desc, addr, len)
 416      int desc;
 417      char *addr;
 418      int len;
 419 {
 420   register int val;
 421   int orglen = len;
 422
 423   while (len > 0)
 424     {
 425       val = read (desc, addr, len);
 426       if (val < 0)
 427         return val;
 428       if (val == 0)
 429         return orglen - len;
 430       len -= val;
 431       addr += val;
 432     }
 433   return orglen;
 434 }
 435 \f
 436 /* Make a copy of the string at PTR with SIZE characters
 437    (and add a null character at the end in the copy).
 438    Uses malloc to get the space.  Returns the address of the copy.  */
 439
 440 char *
 441 savestring (ptr, size)
 442      char *ptr;
 443      int size;
 444 {
 445   register char *p = (char *) xmalloc (size + 1);
 446   bcopy (ptr, p, size);
 447   p[size] = 0;
 448   return p;
 449 }
 450
 451 char *
 452 strsave (ptr)
 453      char *ptr;
 454 {
 455   return savestring (ptr, strlen (ptr));
 456 }
 457
 458 char *
 459 concat (s1, s2, s3)
 460      char *s1, *s2, *s3;
 461 {
 462   register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
 463   register char *val = (char *) xmalloc (len);
 464   strcpy (val, s1);
 465   strcat (val, s2);
 466   strcat (val, s3);
 467   return val;
 468 }
 469
 470 void
 471 print_spaces (n, file)
 472      register int n;
 473      register FILE *file;
 474 {
 475   while (n-- > 0)
 476     fputc (' ', file);
 477 }
 478
 479 /* Ask user a y-or-n question and return 1 iff answer is yes.
 480    Takes three args which are given to printf to print the question.
 481    The first, a control string, should end in "? ".
 482    It should not say how to answer, because we do that.  */
 483
 484 /* VARARGS */
 485 int
 486 query (va_alist)
 487      va_dcl
 488 {
 489   va_list args;
 490   char *ctlstr;
 491   register int answer;
 492   register int ans2;
 493
 494   /* Automatically answer "yes" if input is not from a terminal.  */
 495   if (!input_from_terminal_p ())
 496     return 1;
 497
 498   while (1)
 499     {
 500       va_start (args);
 501       ctlstr = va_arg (args, char *);
 502       vfprintf (stdout, ctlstr, args);
 503       va_end (args);
 504       printf ("(y or n) ");
 505       fflush (stdout);
 506       answer = fgetc (stdin);
 507       clearerr (stdin);         /* in case of C-d */
 508       if (answer == EOF)        /* C-d */
 509         return 1;
 510       if (answer != '\n')       /* Eat rest of input line, to EOF or newline */
 511         do
 512           {
 513             ans2 = fgetc (stdin);
 514             clearerr (stdin);
 515           }
 516         while (ans2 != EOF && ans2 != '\n');
 517       if (answer >= 'a')
 518         answer -= 040;
 519       if (answer == 'Y')
 520         return 1;
 521       if (answer == 'N')
 522         return 0;
 523       printf ("Please answer y or n.\n");
 524     }
 525 }
 526 \f
 527 /* Parse a C escape sequence.  STRING_PTR points to a variable
 528    containing a pointer to the string to parse.  That pointer
 529    should point to the character after the \.  That pointer
 530    is updated past the characters we use.  The value of the
 531    escape sequence is returned.
 532
 533    A negative value means the sequence \ newline was seen,
 534    which is supposed to be equivalent to nothing at all.
 535
 536    If \ is followed by a null character, we return a negative
 537    value and leave the string pointer pointing at the null character.
 538
 539    If \ is followed by 000, we return 0 and leave the string pointer
 540    after the zeros.  A value of 0 does not mean end of string.  */
 541
 542 int
 543 parse_escape (string_ptr)
 544      char **string_ptr;
 545 {
 546   register int c = *(*string_ptr)++;
 547   switch (c)
 548     {
 549     case 'a':
 550       return '\a';
 551     case 'b':
 552       return '\b';
 553     case 'e':
 554       return 033;
 555     case 'f':
 556       return '\f';
 557     case 'n':
 558       return '\n';
 559     case 'r':
 560       return '\r';
 561     case 't':
 562       return '\t';
 563     case 'v':
 564       return '\v';
 565     case '\n':
 566       return -2;
 567     case 0:
 568       (*string_ptr)--;
 569       return 0;
 570     case '^':
 571       c = *(*string_ptr)++;
 572       if (c == '\\')
 573         c = parse_escape (string_ptr);
 574       if (c == '?')
 575         return 0177;
 576       return (c & 0200) | (c & 037);
 577
 578     case '0':
 579     case '1':
 580     case '2':
 581     case '3':
 582     case '4':
 583     case '5':
 584     case '6':
 585     case '7':
 586       {
 587         register int i = c - '0';
 588         register int count = 0;
 589         while (++count < 3)
 590           {
 591             if ((c = *(*string_ptr)++) >= '0' && c <= '7')
 592               {
 593                 i *= 8;
 594                 i += c - '0';
 595               }
 596             else
 597               {
 598                 (*string_ptr)--;
 599                 break;
 600               }
 601           }
 602         return i;
 603       }
 604     default:
 605       return c;
 606     }
 607 }
 608 \f
 609 /* Print the character CH on STREAM as part of the contents
 610    of a literal string whose delimiter is QUOTER.  */
 611
 612 void
 613 printchar (ch, stream, quoter)
 614      unsigned char ch;
 615      FILE *stream;
 616      int quoter;
 617 {
 618   register int c = ch;
 619
 620   if (c < 040 || (sevenbit_strings && c >= 0177))
 621     switch (c)
 622       {
 623       case '\n':
 624         fputs_filtered ("\\n", stream);
 625         break;
 626       case '\b':
 627         fputs_filtered ("\\b", stream);
 628         break;
 629       case '\t':
 630         fputs_filtered ("\\t", stream);
 631         break;
 632       case '\f':
 633         fputs_filtered ("\\f", stream);
 634         break;
 635       case '\r':
 636         fputs_filtered ("\\r", stream);
 637         break;
 638       case '\033':
 639         fputs_filtered ("\\e", stream);
 640         break;
 641       case '\007':
 642         fputs_filtered ("\\a", stream);
 643         break;
 644       default:
 645         fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
 646         break;
 647       }
 648   else
 649     {
 650       if (c == '\\' || c == quoter)
 651         fputs_filtered ("\\", stream);
 652       fprintf_filtered (stream, "%c", c);
 653     }
 654 }
 655 \f
 656 /* Number of lines per page or UINT_MAX if paging is disabled.  */
 657 static unsigned int lines_per_page;
 658 /* Number of chars per line or UNIT_MAX is line folding is disabled.  */
 659 static unsigned int chars_per_line;
 660 /* Current count of lines printed on this page, chars on this line.  */
 661 static unsigned int lines_printed, chars_printed;
 662
 663 /* Buffer and start column of buffered text, for doing smarter word-
 664    wrapping.  When someone calls wrap_here(), we start buffering output
 665    that comes through fputs_filtered().  If we see a newline, we just
 666    spit it out and forget about the wrap_here().  If we see another
 667    wrap_here(), we spit it out and remember the newer one.  If we see
 668    the end of the line, we spit out a newline, the indent, and then
 669    the buffered output.
 670
 671    wrap_column is the column number on the screen where wrap_buffer begins.
 672      When wrap_column is zero, wrapping is not in effect.
 673    wrap_buffer is malloc'd with chars_per_line+2 bytes.
 674      When wrap_buffer[0] is null, the buffer is empty.
 675    wrap_pointer points into it at the next character to fill.
 676    wrap_indent is the string that should be used as indentation if the
 677      wrap occurs.  */
 678
 679 static char *wrap_buffer, *wrap_pointer, *wrap_indent;
 680 static int wrap_column;
 681
 682 /* Get the number of lines to print with commands like "list".
 683    This is based on guessing how many long (i.e. more than chars_per_line
 684    characters) lines there will be.  To be completely correct, "list"
 685    and friends should be rewritten to count characters and see where
 686    things are wrapping, but that would be a fair amount of work.  */
 687 int
 688 lines_to_list ()
 689 {
 690   /* RMS didn't like the following algorithm.  Let's set it back to
 691      10 and see if anyone else complains.  */
 692   /* return lines_per_page == UINT_MAX ? 10 : lines_per_page / 2; */
 693   return 10;
 694 }
 695
 696 static void
 697 set_width_command (args, from_tty, c)
 698      char *args;
 699      int from_tty;
 700      struct cmd_list_element *c;
 701 {
 702   if (!wrap_buffer)
 703     {
 704       wrap_buffer = (char *) xmalloc (chars_per_line + 2);
 705       wrap_buffer[0] = '\0';
 706     }
 707   else
 708     wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
 709   wrap_pointer = wrap_buffer;   /* Start it at the beginning */
 710 }
 711
 712 static void
 713 prompt_for_continue ()
 714 {
 715   immediate_quit++;
 716   gdb_readline ("---Type <return> to continue---", 0);
 717   chars_printed = lines_printed = 0;
 718   immediate_quit--;
 719 }
 720
 721 /* Reinitialize filter; ie. tell it to reset to original values.  */
 722
 723 void
 724 reinitialize_more_filter ()
 725 {
 726   lines_printed = 0;
 727   chars_printed = 0;
 728 }
 729
 730 /* Indicate that if the next sequence of characters overflows the line,
 731    a newline should be inserted here rather than when it hits the end.
 732    If INDENT is nonzero, it is a string to be printed to indent the
 733    wrapped part on the next line.  INDENT must remain accessible until
 734    the next call to wrap_here() or until a newline is printed through
 735    fputs_filtered().
 736
 737    If the line is already overfull, we immediately print a newline and
 738    the indentation, and disable further wrapping.
 739
 740    INDENT should not contain tabs, as that
 741    will mess up the char count on the next line.  FIXME.  */
 742
 743 void
 744 wrap_here(indent)
 745   char *indent;
 746 {
 747   if (wrap_buffer[0])
 748     {
 749       *wrap_pointer = '\0';
 750       fputs (wrap_buffer, stdout);
 751     }
 752   wrap_pointer = wrap_buffer;
 753   wrap_buffer[0] = '\0';
 754   if (chars_printed >= chars_per_line)
 755     {
 756       puts_filtered ("\n");
 757       puts_filtered (indent);
 758       wrap_column = 0;
 759     }
 760   else
 761     {
 762       wrap_column = chars_printed;
 763       wrap_indent = indent;
 764     }
 765 }
 766
 767 /* Like fputs but pause after every screenful, and can wrap at points
 768    other than the final character of a line.
 769    Unlike fputs, fputs_filtered does not return a value.
 770    It is OK for LINEBUFFER to be NULL, in which case just don't print
 771    anything.
 772
 773    Note that a longjmp to top level may occur in this routine
 774    (since prompt_for_continue may do so) so this routine should not be
 775    called when cleanups are not in place.  */
 776
 777 void
 778 fputs_filtered (linebuffer, stream)
 779      char *linebuffer;
 780      FILE *stream;
 781 {
 782   char *lineptr;
 783
 784   if (linebuffer == 0)
 785     return;
 786
 787   /* Don't do any filtering if it is disabled.  */
 788   if (stream != stdout
 789    || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
 790     {
 791       fputs (linebuffer, stream);
 792       return;
 793     }
 794
 795   /* Go through and output each character.  Show line extension
 796      when this is necessary; prompt user for new page when this is
 797      necessary.  */
 798
 799   lineptr = linebuffer;
 800   while (*lineptr)
 801     {
 802       /* Possible new page.  */
 803       if (lines_printed >= lines_per_page - 1)
 804         prompt_for_continue ();
 805
 806       while (*lineptr && *lineptr != '\n')
 807         {
 808           /* Print a single line.  */
 809           if (*lineptr == '\t')
 810             {
 811               if (wrap_column)
 812                 *wrap_pointer++ = '\t';
 813               else
 814                 putc ('\t', stream);
 815               /* Shifting right by 3 produces the number of tab stops
 816                  we have already passed, and then adding one and
 817                  shifting left 3 advances to the next tab stop.  */
 818               chars_printed = ((chars_printed >> 3) + 1) << 3;
 819               lineptr++;
 820             }
 821           else
 822             {
 823               if (wrap_column)
 824                 *wrap_pointer++ = *lineptr;
 825               else
 826                 putc (*lineptr, stream);
 827               chars_printed++;
 828               lineptr++;
 829             }
 830
 831           if (chars_printed >= chars_per_line)
 832             {
 833               unsigned int save_chars = chars_printed;
 834
 835               chars_printed = 0;
 836               lines_printed++;
 837               /* If we aren't actually wrapping, don't output newline --
 838                  if chars_per_line is right, we probably just overflowed
 839                  anyway; if it's wrong, let us keep going.  */
 840               if (wrap_column)
 841                 putc ('\n', stream);
 842
 843               /* Possible new page.  */
 844               if (lines_printed >= lines_per_page - 1)
 845                 prompt_for_continue ();
 846
 847               /* Now output indentation and wrapped string */
 848               if (wrap_column)
 849                 {
 850                   if (wrap_indent)
 851                     fputs (wrap_indent, stream);
 852                   *wrap_pointer = '\0';         /* Null-terminate saved stuff */
 853                   fputs (wrap_buffer, stream);  /* and eject it */
 854                   /* FIXME, this strlen is what prevents wrap_indent from
 855                      containing tabs.  However, if we recurse to print it
 856                      and count its chars, we risk trouble if wrap_indent is
 857                      longer than (the user settable) chars_per_line.
 858                      Note also that this can set chars_printed > chars_per_line
 859                      if we are printing a long string.  */
 860                   chars_printed = strlen (wrap_indent)
 861                                 + (save_chars - wrap_column);
 862                   wrap_pointer = wrap_buffer;   /* Reset buffer */
 863                   wrap_buffer[0] = '\0';
 864                   wrap_column = 0;              /* And disable fancy wrap */
 865                 }
 866             }
 867         }
 868
 869       if (*lineptr == '\n')
 870         {
 871           chars_printed = 0;
 872           wrap_here ("");       /* Spit out chars, cancel further wraps */
 873           lines_printed++;
 874           putc ('\n', stream);
 875           lineptr++;
 876         }
 877     }
 878 }
 879
 880
 881 /* fputs_demangled is a variant of fputs_filtered that
 882    demangles g++ names.*/
 883
 884 void
 885 fputs_demangled (linebuffer, stream, arg_mode)
 886      char *linebuffer;
 887      FILE *stream;
 888      int arg_mode;
 889 {
 890 #ifdef __STDC__
 891   extern char *cplus_demangle (const char *, int);
 892 #else
 893   extern char *cplus_demangle ();
 894 #endif
 895 #define SYMBOL_MAX 1024
 896
 897 #define SYMBOL_CHAR(c) (isascii(c) \
 898   && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
 899
 900   char buf[SYMBOL_MAX+1];
 901 # define SLOP 5         /* How much room to leave in buf */
 902   char *p;
 903
 904   if (linebuffer == NULL)
 905     return;
 906
 907   /* If user wants to see raw output, no problem.  */
 908   if (!demangle) {
 909     fputs_filtered (linebuffer, stream);
 910   }
 911
 912   p = linebuffer;
 913
 914   while ( *p != (char) 0 ) {
 915     int i = 0;
 916
 917     /* collect non-interesting characters into buf */
 918     while ( *p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-SLOP ) {
 919       buf[i++] = *p;
 920       p++;
 921     }
 922     if (i > 0) {
 923       /* output the non-interesting characters without demangling */
 924       buf[i] = (char) 0;
 925       fputs_filtered(buf, stream);
 926       i = 0;  /* reset buf */
 927     }
 928
 929     /* and now the interesting characters */
 930     while (i < SYMBOL_MAX
 931      && *p != (char) 0
 932      && SYMBOL_CHAR(*p)
 933      && i < (int)sizeof(buf) - SLOP) {
 934       buf[i++] = *p;
 935       p++;
 936     }
 937     buf[i] = (char) 0;
 938     if (i > 0) {
 939       char * result;
 940
 941       if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) {
 942         fputs_filtered(result, stream);
 943         free(result);
 944       }
 945       else {
 946         fputs_filtered(buf, stream);
 947       }
 948     }
 949   }
 950 }
 951
 952 /* Print a variable number of ARGS using format FORMAT.  If this
 953    information is going to put the amount written (since the last call
 954    to INITIALIZE_MORE_FILTER or the last page break) over the page size,
 955    print out a pause message and do a gdb_readline to get the users
 956    permision to continue.
 957
 958    Unlike fprintf, this function does not return a value.
 959
 960    We implement three variants, vfprintf (takes a vararg list and stream),
 961    fprintf (takes a stream to write on), and printf (the usual).
 962
 963    Note that this routine has a restriction that the length of the
 964    final output line must be less than 255 characters *or* it must be
 965    less than twice the size of the format string.  This is a very
 966    arbitrary restriction, but it is an internal restriction, so I'll
 967    put it in.  This means that the %s format specifier is almost
 968    useless; unless the caller can GUARANTEE that the string is short
 969    enough, fputs_filtered should be used instead.
 970
 971    Note also that a longjmp to top level may occur in this routine
 972    (since prompt_for_continue may do so) so this routine should not be
 973    called when cleanups are not in place.  */
 974
 975 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
 976 /* VARARGS */
 977 void
 978 vfprintf_filtered (stream, format, args)
 979      va_list args;
 980 #else
 981 void fprintf_filtered (stream, format, arg1, arg2, arg3, arg4, arg5, arg6)
 982 #endif
 983      FILE *stream;
 984      char *format;
 985 {
 986   static char *linebuffer = (char *) 0;
 987   static int line_size;
 988   int format_length;
 989
 990   format_length = strlen (format);
 991
 992   /* Allocated linebuffer for the first time.  */
 993   if (!linebuffer)
 994     {
 995       linebuffer = (char *) xmalloc (255);
 996       line_size = 255;
 997     }
 998
 999   /* Reallocate buffer to a larger size if this is necessary.  */
1000   if (format_length * 2 > line_size)
1001     {
1002       line_size = format_length * 2;
1003
1004       /* You don't have to copy.  */
1005       free (linebuffer);
1006       linebuffer = (char *) xmalloc (line_size);
1007     }
1008
1009
1010   /* This won't blow up if the restrictions described above are
1011      followed.   */
1012 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1013   (void) vsprintf (linebuffer, format, args);
1014 #else
1015   (void) sprintf (linebuffer, format, arg1, arg2, arg3, arg4, arg5, arg6);
1016 #endif
1017
1018   fputs_filtered (linebuffer, stream);
1019 }
1020
1021 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1022 /* VARARGS */
1023 void
1024 fprintf_filtered (va_alist)
1025      va_dcl
1026 {
1027   va_list args;
1028   FILE *stream;
1029   char *format;
1030
1031   va_start (args);
1032   stream = va_arg (args, FILE *);
1033   format = va_arg (args, char *);
1034
1035   /* This won't blow up if the restrictions described above are
1036      followed.   */
1037   (void) vfprintf_filtered (stream, format, args);
1038   va_end (args);
1039 }
1040
1041 /* VARARGS */
1042 void
1043 printf_filtered (va_alist)
1044      va_dcl
1045 {
1046   va_list args;
1047   char *format;
1048
1049   va_start (args);
1050   format = va_arg (args, char *);
1051
1052   (void) vfprintf_filtered (stdout, format, args);
1053   va_end (args);
1054 }
1055 #else
1056 void
1057 printf_filtered (format, arg1, arg2, arg3, arg4, arg5, arg6)
1058      char *format;
1059      int arg1, arg2, arg3, arg4, arg5, arg6;
1060 {
1061   fprintf_filtered (stdout, format, arg1, arg2, arg3, arg4, arg5, arg6);
1062 }
1063 #endif
1064
1065 /* Easy */
1066
1067 void
1068 puts_filtered (string)
1069      char *string;
1070 {
1071   fputs_filtered (string, stdout);
1072 }
1073
1074 /* Return a pointer to N spaces and a null.  The pointer is good
1075    until the next call to here.  */
1076 char *
1077 n_spaces (n)
1078      int n;
1079 {
1080   register char *t;
1081   static char *spaces;
1082   static int max_spaces;
1083
1084   if (n > max_spaces)
1085     {
1086       if (spaces)
1087         free (spaces);
1088       spaces = malloc (n+1);
1089       for (t = spaces+n; t != spaces;)
1090         *--t = ' ';
1091       spaces[n] = '\0';
1092       max_spaces = n;
1093     }
1094
1095   return spaces + max_spaces - n;
1096 }
1097
1098 /* Print N spaces.  */
1099 void
1100 print_spaces_filtered (n, stream)
1101      int n;
1102      FILE *stream;
1103 {
1104   fputs_filtered (n_spaces (n), stream);
1105 }
1106 \f
1107 /* C++ demangler stuff.  */
1108 char *cplus_demangle ();
1109
1110 /* Print NAME on STREAM, demangling if necessary.  */
1111 void
1112 fprint_symbol (stream, name)
1113      FILE *stream;
1114      char *name;
1115 {
1116   char *demangled;
1117   if ((!demangle) || NULL == (demangled = cplus_demangle (name, 1)))
1118     fputs_filtered (name, stream);
1119   else
1120     {
1121       fputs_filtered (demangled, stream);
1122       free (demangled);
1123     }
1124 }
1125 \f
1126 #if !defined (USG_UTILS)
1127 #define USG_UTILS defined (USG)
1128 #endif
1129
1130 #if USG_UTILS
1131 bcopy (from, to, count)
1132 char *from, *to;
1133 {
1134         memcpy (to, from, count);
1135 }
1136
1137 bcmp (from, to, count)
1138 {
1139         return (memcmp (to, from, count));
1140 }
1141
1142 bzero (to, count)
1143 char *to;
1144 {
1145         while (count--)
1146                 *to++ = 0;
1147 }
1148
1149 getwd (buf)
1150 char *buf;
1151 {
1152   getcwd (buf, MAXPATHLEN);
1153 }
1154
1155 char *
1156 index (s, c)
1157      char *s;
1158 {
1159   char *strchr ();
1160   return strchr (s, c);
1161 }
1162
1163 char *
1164 rindex (s, c)
1165      char *s;
1166 {
1167   char *strrchr ();
1168   return strrchr (s, c);
1169 }
1170 #endif /* USG_UTILS.  */
1171
1172 #if !defined (QUEUE_MISSING)
1173 #define QUEUE_MISSING defined (USG)
1174 #endif
1175
1176 #if QUEUE_MISSING
1177 /* Queue routines */
1178
1179 struct queue {
1180         struct queue *forw;
1181         struct queue *back;
1182 };
1183
1184 insque (item, after)
1185 struct queue *item;
1186 struct queue *after;
1187 {
1188         item->forw = after->forw;
1189         after->forw->back = item;
1190
1191         item->back = after;
1192         after->forw = item;
1193 }
1194
1195 remque (item)
1196 struct queue *item;
1197 {
1198         item->forw->back = item->back;
1199         item->back->forw = item->forw;
1200 }
1201 #endif /* QUEUE_MISSING */
1202 \f
1203 /* Simple implementation of strstr, since some implementations lack it. */
1204 char *
1205 strstr (in, find)
1206      const char *in, *find;
1207 {
1208   register char *p = in - 1;
1209
1210   while (0 != (p = strchr (p+1, *find))) {
1211     if (strcmp (p, find))
1212       return p;
1213   }
1214   return 0;
1215 }
1216 \f
1217 void
1218 _initialize_utils ()
1219 {
1220   struct cmd_list_element *c;
1221
1222   c = add_set_cmd ("width", class_support, var_uinteger,
1223                   (char *)&chars_per_line,
1224                   "Set number of characters gdb thinks are in a line.",
1225                   &setlist);
1226   add_show_from_set (c, &showlist);
1227   c->function = set_width_command;
1228
1229   add_show_from_set
1230     (add_set_cmd ("height", class_support,
1231                   var_uinteger, (char *)&lines_per_page,
1232                   "Set number of lines gdb thinks are in a page.", &setlist),
1233      &showlist);
1234
1235   /* These defaults will be used if we are unable to get the correct
1236      values from termcap.  */
1237   lines_per_page = 24;
1238   chars_per_line = 80;
1239   /* Initialize the screen height and width from termcap.  */
1240   {
1241     char *termtype = getenv ("TERM");
1242
1243     /* Positive means success, nonpositive means failure.  */
1244     int status;
1245
1246     /* 2048 is large enough for all known terminals, according to the
1247        GNU termcap manual.  */
1248     char term_buffer[2048];
1249
1250     if (termtype)
1251       {
1252         status = tgetent (term_buffer, termtype);
1253         if (status > 0)
1254           {
1255             int val;
1256
1257             val = tgetnum ("li");
1258             if (val >= 0)
1259               lines_per_page = val;
1260             else
1261               /* The number of lines per page is not mentioned
1262                  in the terminal description.  This probably means
1263                  that paging is not useful (e.g. emacs shell window),
1264                  so disable paging.  */
1265               lines_per_page = UINT_MAX;
1266
1267             val = tgetnum ("co");
1268             if (val >= 0)
1269               chars_per_line = val;
1270           }
1271       }
1272   }
1273
1274   set_width_command ((char *)NULL, 0, c);
1275
1276   add_show_from_set
1277     (add_set_cmd ("demangle", class_support, var_boolean,
1278                   (char *)&demangle,
1279                 "Set demangling of encoded C++ names when displaying symbols.",
1280                   &setprintlist),
1281      &showprintlist);
1282
1283   add_show_from_set
1284     (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
1285                   (char *)&sevenbit_strings,
1286    "Set printing of 8-bit characters in strings as \\nnn.",
1287                   &setprintlist),
1288      &showprintlist);
1289
1290   add_show_from_set
1291     (add_set_cmd ("asm-demangle", class_support, var_boolean,
1292                   (char *)&asm_demangle,
1293         "Set demangling of C++ names in disassembly listings.",
1294                   &setprintlist),
1295      &showprintlist);
1296 }