gdb/printcmd.c

   1 /* Print values for GNU debugger GDB.
   2    Copyright (C) 1986-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 <string.h>
  22 #include "defs.h"
  23 #include "param.h"
  24 #include "frame.h"
  25 #include "symtab.h"
  26 #include "value.h"
  27 #include "expression.h"
  28 #include "gdbcore.h"
  29 #include "gdbcmd.h"
  30 #include "target.h"
  31
  32 extern int asm_demangle;        /* Whether to demangle syms in asm printouts */
  33
  34 extern struct block *get_current_block ();
  35
  36 static void print_frame_nameless_args ();
  37
  38 struct format_data
  39 {
  40   int count;
  41   char format;
  42   char size;
  43 };
  44
  45 /* Last specified output format.  */
  46
  47 static char last_format = 'x';
  48
  49 /* Last specified examination size.  'b', 'h', 'w' or `q'.  */
  50
  51 static char last_size = 'w';
  52
  53 /* Default address to examine next.  */
  54
  55 static CORE_ADDR next_address;
  56
  57 /* Last address examined.  */
  58
  59 static CORE_ADDR last_examine_address;
  60
  61 /* Contents of last address examined.
  62    This is not valid past the end of the `x' command!  */
  63
  64 static value last_examine_value;
  65
  66 /* Number of auto-display expression currently being displayed.
  67    So that we can deleted it if we get an error or a signal within it.
  68    -1 when not doing one.  */
  69
  70 int current_display_number;
  71
  72 /* Flag to low-level print routines that this value is being printed
  73    in an epoch window.  We'd like to pass this as a parameter, but
  74    every routine would need to take it.  Perhaps we can encapsulate
  75    this in the I/O stream once we have GNU stdio. */
  76
  77 int inspect_it = 0;
  78
  79 static void do_one_display ();
  80
  81 void do_displays ();
  82 void print_scalar_formatted ();
  83
  84 \f
  85 /* Decode a format specification.  *STRING_PTR should point to it.
  86    OFORMAT and OSIZE are used as defaults for the format and size
  87    if none are given in the format specification.
  88    If OSIZE is zero, then the size field of the returned value
  89    should be set only if a size is explicitly specified by the
  90    user.
  91    The structure returned describes all the data
  92    found in the specification.  In addition, *STRING_PTR is advanced
  93    past the specification and past all whitespace following it.  */
  94
  95 struct format_data
  96 decode_format (string_ptr, oformat, osize)
  97      char **string_ptr;
  98      char oformat;
  99      char osize;
 100 {
 101   struct format_data val;
 102   register char *p = *string_ptr;
 103
 104   val.format = '?';
 105   val.size = '?';
 106   val.count = 1;
 107
 108   if (*p >= '0' && *p <= '9')
 109     val.count = atoi (p);
 110   while (*p >= '0' && *p <= '9') p++;
 111
 112   /* Now process size or format letters that follow.  */
 113
 114   while (1)
 115     {
 116       if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
 117         val.size = *p++;
 118 #ifdef LONG_LONG
 119       else if (*p == 'l')
 120         {
 121           val.size = 'g';
 122           p++;
 123         }
 124 #endif
 125       else if (*p >= 'a' && *p <= 'z')
 126         val.format = *p++;
 127       else
 128         break;
 129     }
 130
 131 #ifndef LONG_LONG
 132   /* Make sure 'g' size is not used on integer types.
 133      Well, actually, we can handle hex.  */
 134   if (val.size == 'g' && val.format != 'f' && val.format != 'x')
 135     val.size = 'w';
 136 #endif
 137
 138   while (*p == ' ' || *p == '\t') p++;
 139   *string_ptr = p;
 140
 141   /* Set defaults for format and size if not specified.  */
 142   if (val.format == '?')
 143     {
 144       if (val.size == '?')
 145         {
 146           /* Neither has been specified.  */
 147           val.format = oformat;
 148           val.size = osize;
 149         }
 150       else
 151         /* If a size is specified, any format makes a reasonable
 152            default except 'i'.  */
 153         val.format = oformat == 'i' ? 'x' : oformat;
 154     }
 155   else if (val.size == '?')
 156     switch (val.format)
 157       {
 158       case 'a':
 159       case 's':
 160         /* Addresses must be words.  */
 161         val.size = osize ? 'w' : osize;
 162         break;
 163       case 'f':
 164         /* Floating point has to be word or giantword.  */
 165         if (osize == 'w' || osize == 'g')
 166           val.size = osize;
 167         else
 168           /* Default it to giantword if the last used size is not
 169              appropriate.  */
 170           val.size = osize ? 'g' : osize;
 171         break;
 172       case 'c':
 173         /* Characters default to one byte.  */
 174         val.size = osize ? 'b' : osize;
 175         break;
 176       default:
 177         /* The default is the size most recently specified.  */
 178         val.size = osize;
 179       }
 180
 181   return val;
 182 }
 183 \f
 184 /* Print value VAL on stdout according to FORMAT, a letter or 0.
 185    Do not end with a newline.
 186    0 means print VAL according to its own type.
 187    SIZE is the letter for the size of datum being printed.
 188    This is used to pad hex numbers so they line up.  */
 189
 190 static void
 191 print_formatted (val, format, size)
 192      register value val;
 193      register char format;
 194      char size;
 195 {
 196   int len = TYPE_LENGTH (VALUE_TYPE (val));
 197
 198   if (VALUE_LVAL (val) == lval_memory)
 199     next_address = VALUE_ADDRESS (val) + len;
 200
 201   switch (format)
 202     {
 203     case 's':
 204       next_address = VALUE_ADDRESS (val)
 205         + value_print (value_addr (val), stdout, format, Val_pretty_default);
 206       break;
 207
 208     case 'i':
 209       next_address = VALUE_ADDRESS (val)
 210         + print_insn (VALUE_ADDRESS (val), stdout);
 211       break;
 212
 213     default:
 214       if (format == 0
 215           || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_ARRAY
 216           || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRUCT
 217           || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION
 218           || VALUE_REPEATED (val))
 219         value_print (val, stdout, format, Val_pretty_default);
 220       else
 221         print_scalar_formatted (VALUE_CONTENTS (val), VALUE_TYPE (val),
 222                                 format, size, stdout);
 223     }
 224 }
 225
 226 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
 227    according to letters FORMAT and SIZE on STREAM.
 228    FORMAT may not be zero.  Formats s and i are not supported at this level.
 229
 230    This is how the elements of an array or structure are printed
 231    with a format.  */
 232
 233 void
 234 print_scalar_formatted (valaddr, type, format, size, stream)
 235      char *valaddr;
 236      struct type *type;
 237      char format;
 238      int size;
 239      FILE *stream;
 240 {
 241   LONGEST val_long;
 242   int len = TYPE_LENGTH (type);
 243
 244   if (size == 'g' && sizeof (LONGEST) < 8
 245       && format == 'x')
 246     {
 247       /* ok, we're going to have to get fancy here.  Assumption: a
 248          long is four bytes.  FIXME.  */
 249       unsigned long v1, v2, tmp;
 250
 251       v1 = unpack_long (builtin_type_long, valaddr);
 252       v2 = unpack_long (builtin_type_long, valaddr + 4);
 253
 254 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
 255       /* Swap the two for printing */
 256       tmp = v1;
 257       v1 = v2;
 258       v2 = tmp;
 259 #endif
 260
 261       switch (format)
 262         {
 263         case 'x':
 264           fprintf_filtered (stream, "0x%08x%08x", v1, v2);
 265           break;
 266         default:
 267           error ("Output size \"g\" unimplemented for format \"%c\".",
 268                  format);
 269         }
 270       return;
 271     }
 272
 273   val_long = unpack_long (type, valaddr);
 274
 275   /* If value is unsigned, truncate it in case negative.  */
 276   if (format != 'd')
 277     {
 278       if (len == sizeof (char))
 279         val_long &= (1 << 8 * sizeof(char)) - 1;
 280       else if (len == sizeof (short))
 281         val_long &= (1 << 8 * sizeof(short)) - 1;
 282       else if (len == sizeof (long))
 283         val_long &= (unsigned long) - 1;
 284     }
 285
 286   switch (format)
 287     {
 288     case 'x':
 289       if (!size)
 290         {
 291           /* no size specified, like in print.  Print varying # of digits. */
 292 #if defined (LONG_LONG)
 293           fprintf_filtered (stream, "0x%llx", val_long);
 294 #else /* not LONG_LONG.  */
 295           fprintf_filtered (stream, "0x%lx", val_long);
 296 #endif /* not LONG_LONG.  */
 297         }
 298       else
 299 #if defined (LONG_LONG)
 300       switch (size)
 301         {
 302         case 'b':
 303           fprintf_filtered (stream, "0x%02llx", val_long);
 304           break;
 305         case 'h':
 306           fprintf_filtered (stream, "0x%04llx", val_long);
 307           break;
 308         case 'w':
 309           fprintf_filtered (stream, "0x%08llx", val_long);
 310           break;
 311         case 'g':
 312           fprintf_filtered (stream, "0x%016llx", val_long);
 313           break;
 314         default:
 315           error ("Undefined output size \"%c\".", size);
 316         }
 317 #else /* not LONG_LONG.  */
 318       switch (size)
 319         {
 320         case 'b':
 321           fprintf_filtered (stream, "0x%02x", val_long);
 322           break;
 323         case 'h':
 324           fprintf_filtered (stream, "0x%04x", val_long);
 325           break;
 326         case 'w':
 327           fprintf_filtered (stream, "0x%08x", val_long);
 328           break;
 329         case 'g':
 330           fprintf_filtered (stream, "0x%016x", val_long);
 331           break;
 332         default:
 333           error ("Undefined output size \"%c\".", size);
 334         }
 335 #endif /* not LONG_LONG */
 336       break;
 337
 338     case 'd':
 339 #ifdef LONG_LONG
 340       fprintf_filtered (stream, "%lld", val_long);
 341 #else
 342       fprintf_filtered (stream, "%d", val_long);
 343 #endif
 344       break;
 345
 346     case 'u':
 347 #ifdef LONG_LONG
 348       fprintf_filtered (stream, "%llu", val_long);
 349 #else
 350       fprintf_filtered (stream, "%u", val_long);
 351 #endif
 352       break;
 353
 354     case 'o':
 355       if (val_long)
 356 #ifdef LONG_LONG
 357         fprintf_filtered (stream, "0%llo", val_long);
 358 #else
 359         fprintf_filtered (stream, "0%o", val_long);
 360 #endif
 361       else
 362         fprintf_filtered (stream, "0");
 363       break;
 364
 365     case 'a':
 366       print_address (unpack_pointer (type, valaddr), stream);
 367       break;
 368
 369     case 'c':
 370       value_print (value_from_long (builtin_type_char, val_long), stream, 0,
 371                    Val_pretty_default);
 372       break;
 373
 374     case 'f':
 375       if (len == sizeof (float))
 376         type = builtin_type_float;
 377       else if (len == sizeof (double))
 378         type = builtin_type_double;
 379       print_floating (valaddr, type, stream);
 380       break;
 381
 382     case 0:
 383       abort ();
 384
 385     case 't':
 386       /* Binary; 't' stands for "two".  */
 387       {
 388         char bits[8*(sizeof val_long) + 1];
 389         char *cp = bits;
 390         int width;
 391
 392         if (!size)
 393           width = 8*(sizeof val_long);
 394         else
 395           switch (size)
 396             {
 397             case 'b':
 398               width = 8;
 399               break;
 400             case 'h':
 401               width = 16;
 402               break;
 403             case 'w':
 404               width = 32;
 405               break;
 406             case 'g':
 407               width = 64;
 408               break;
 409             default:
 410               error ("Undefined output size \"%c\".", size);
 411             }
 412
 413         bits[width] = '\0';
 414         while (width-- > 0)
 415           {
 416             bits[width] = (val_long & 1) ? '1' : '0';
 417             val_long >>= 1;
 418           }
 419         if (!size)
 420           {
 421             while (*cp && *cp == '0')
 422               cp++;
 423             if (*cp == '\0')
 424               cp--;
 425           }
 426         fprintf_filtered (stream, cp);
 427       }
 428       break;
 429
 430     default:
 431       error ("Undefined output format \"%c\".", format);
 432     }
 433 }
 434
 435 /* Specify default address for `x' command.
 436    `info lines' uses this.  */
 437
 438 void
 439 set_next_address (addr)
 440      CORE_ADDR addr;
 441 {
 442   next_address = addr;
 443
 444   /* Make address available to the user as $_.  */
 445   set_internalvar (lookup_internalvar ("_"),
 446                    value_from_long (builtin_type_int, (LONGEST) addr));
 447 }
 448
 449 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM.
 450    DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
 451    or to interpret it as a possible C++ name and convert it back to source
 452    form. */
 453
 454 void
 455 print_address_symbolic (addr, stream, do_demangle)
 456      CORE_ADDR addr;
 457      FILE *stream;
 458      int do_demangle;
 459 {
 460   int name_location;
 461   register int i = find_pc_misc_function (addr);
 462
 463   /* If nothing comes out, don't print anything symbolic.  */
 464
 465   if (i < 0)
 466     return;
 467
 468   fputs_filtered (" <", stream);
 469   if (do_demangle)
 470     fputs_demangled (misc_function_vector[i].name, stream, 1);
 471   else
 472     fputs_filtered (misc_function_vector[i].name, stream);
 473   name_location = misc_function_vector[i].address;
 474   if (addr - name_location)
 475     fprintf_filtered (stream, "+%d>", addr - name_location);
 476   else
 477     fputs_filtered (">", stream);
 478 }
 479
 480 /* Print address ADDR symbolically on STREAM.
 481    First print it as a number.  Then perhaps print
 482    <SYMBOL + OFFSET> after the number.  */
 483
 484 void
 485 print_address (addr, stream)
 486      CORE_ADDR addr;
 487      FILE *stream;
 488 {
 489   fprintf_filtered (stream, "0x%x", addr);
 490   print_address_symbolic (addr, stream, asm_demangle);
 491 }
 492
 493 /* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE
 494    controls whether to print the symbolic name "raw" or demangled.  */
 495
 496 void
 497 print_address_demangle (addr, stream, do_demangle)
 498      CORE_ADDR addr;
 499      FILE *stream;
 500      int do_demangle;
 501 {
 502   fprintf_filtered (stream, "0x%x", addr);
 503   print_address_symbolic (addr, stream, do_demangle);
 504 }
 505
 506 \f
 507
 508 /* Examine data at address ADDR in format FMT.
 509    Fetch it from memory and print on stdout.  */
 510
 511 static void
 512 do_examine (fmt, addr)
 513      struct format_data fmt;
 514      CORE_ADDR addr;
 515 {
 516   register char format = 0;
 517   register char size;
 518   register int count = 1;
 519   struct type *val_type;
 520   register int i;
 521   register int maxelts;
 522
 523   format = fmt.format;
 524   size = fmt.size;
 525   count = fmt.count;
 526   next_address = addr;
 527
 528   /* String or instruction format implies fetch single bytes
 529      regardless of the specified size.  */
 530   if (format == 's' || format == 'i')
 531     size = 'b';
 532
 533   if (size == 'b')
 534     val_type = builtin_type_char;
 535   else if (size == 'h')
 536     val_type = builtin_type_short;
 537   else if (size == 'w')
 538     val_type = builtin_type_long;
 539   else if (size == 'g')
 540 #ifndef LONG_LONG
 541     val_type = builtin_type_double;
 542 #else
 543     val_type = builtin_type_long_long;
 544 #endif
 545
 546   maxelts = 8;
 547   if (size == 'w')
 548     maxelts = 4;
 549   if (size == 'g')
 550     maxelts = 2;
 551   if (format == 's' || format == 'i')
 552     maxelts = 1;
 553
 554   /* Print as many objects as specified in COUNT, at most maxelts per line,
 555      with the address of the next one at the start of each line.  */
 556
 557   while (count > 0)
 558     {
 559       print_address (next_address, stdout);
 560       printf_filtered (":");
 561       for (i = maxelts;
 562            i > 0 && count > 0;
 563            i--, count--)
 564         {
 565           printf_filtered ("\t");
 566           /* Note that print_formatted sets next_address for the next
 567              object.  */
 568           last_examine_address = next_address;
 569           last_examine_value = value_at (val_type, next_address);
 570           print_formatted (last_examine_value, format, size);
 571         }
 572       printf_filtered ("\n");
 573       fflush (stdout);
 574     }
 575 }
 576 \f
 577 static void
 578 validate_format (fmt, cmdname)
 579      struct format_data fmt;
 580      char *cmdname;
 581 {
 582   if (fmt.size != 0)
 583     error ("Size letters are meaningless in \"%s\" command.", cmdname);
 584   if (fmt.count != 1)
 585     error ("Item count other than 1 is meaningless in \"%s\" command.",
 586            cmdname);
 587   if (fmt.format == 'i' || fmt.format == 's')
 588     error ("Format letter \"%c\" is meaningless in \"%s\" command.",
 589            fmt.format, cmdname);
 590 }
 591
 592 static void
 593 print_command_1 (exp, inspect, voidprint)
 594      char *exp;
 595      int inspect;
 596      int voidprint;
 597 {
 598   struct expression *expr;
 599   register struct cleanup *old_chain = 0;
 600   register char format = 0;
 601   register value val;
 602   struct format_data fmt;
 603   int cleanup = 0;
 604
 605   /* Pass inspect flag to the rest of the print routines in a global (sigh). */
 606   inspect_it = inspect;
 607
 608   if (exp && *exp == '/')
 609     {
 610       exp++;
 611       fmt = decode_format (&exp, last_format, 0);
 612       validate_format (fmt, "print");
 613       last_format = format = fmt.format;
 614     }
 615   else
 616     {
 617       fmt.count = 1;
 618       fmt.format = 0;
 619       fmt.size = 0;
 620     }
 621
 622   if (exp && *exp)
 623     {
 624       extern int objectprint;
 625       struct type *type;
 626       expr = parse_c_expression (exp);
 627       old_chain = make_cleanup (free_current_contents, &expr);
 628       cleanup = 1;
 629       val = evaluate_expression (expr);
 630
 631       /* C++: figure out what type we actually want to print it as.  */
 632       type = VALUE_TYPE (val);
 633
 634       if (objectprint
 635           && (TYPE_CODE (type) == TYPE_CODE_PTR
 636               || TYPE_CODE (type) == TYPE_CODE_REF)
 637           && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)
 638         {
 639           value v;
 640
 641           v = value_from_vtable_info (val, TYPE_TARGET_TYPE (type));
 642           if (v != 0)
 643             {
 644               val = v;
 645               type = VALUE_TYPE (val);
 646             }
 647         }
 648     }
 649   else
 650     val = access_value_history (0);
 651
 652   if (voidprint || (val && VALUE_TYPE (val) &&
 653                     TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
 654     {
 655       int histindex = record_latest_value (val);
 656
 657       if (inspect)
 658         printf ("\031(gdb-makebuffer \"%s\"  %d '(\"", exp, histindex);
 659       else
 660         if (histindex >= 0) printf_filtered ("$%d = ", histindex);
 661
 662       print_formatted (val, format, fmt.size);
 663       printf_filtered ("\n");
 664       if (inspect)
 665         printf("\") )\030");
 666     }
 667
 668   if (cleanup)
 669     do_cleanups (old_chain);
 670   inspect_it = 0;       /* Reset print routines to normal */
 671 }
 672
 673 /* ARGSUSED */
 674 static void
 675 print_command (exp, from_tty)
 676      char *exp;
 677      int from_tty;
 678 {
 679   print_command_1 (exp, 0, 1);
 680 }
 681
 682 /* Same as print, except in epoch, it gets its own window */
 683 /* ARGSUSED */
 684 static void
 685 inspect_command (exp, from_tty)
 686      char *exp;
 687      int from_tty;
 688 {
 689   extern int epoch_interface;
 690
 691   print_command_1 (exp, epoch_interface, 1);
 692 }
 693
 694 /* Same as print, except it doesn't print void results. */
 695 /* ARGSUSED */
 696 static void
 697 call_command (exp, from_tty)
 698      char *exp;
 699      int from_tty;
 700 {
 701   print_command_1 (exp, 0, 0);
 702 }
 703
 704 /* ARGSUSED */
 705 static void
 706 output_command (exp, from_tty)
 707      char *exp;
 708      int from_tty;
 709 {
 710   struct expression *expr;
 711   register struct cleanup *old_chain;
 712   register char format = 0;
 713   register value val;
 714   struct format_data fmt;
 715
 716   if (exp && *exp == '/')
 717     {
 718       exp++;
 719       fmt = decode_format (&exp, 0, 0);
 720       validate_format (fmt, "print");
 721       format = fmt.format;
 722     }
 723
 724   expr = parse_c_expression (exp);
 725   old_chain = make_cleanup (free_current_contents, &expr);
 726
 727   val = evaluate_expression (expr);
 728
 729   print_formatted (val, format, fmt.size);
 730
 731   do_cleanups (old_chain);
 732 }
 733
 734 /* ARGSUSED */
 735 static void
 736 set_command (exp, from_tty)
 737      char *exp;
 738      int from_tty;
 739 {
 740   struct expression *expr = parse_c_expression (exp);
 741   register struct cleanup *old_chain
 742     = make_cleanup (free_current_contents, &expr);
 743   evaluate_expression (expr);
 744   do_cleanups (old_chain);
 745 }
 746
 747 /* ARGSUSED */
 748 static void
 749 address_info (exp, from_tty)
 750      char *exp;
 751      int from_tty;
 752 {
 753   register struct symbol *sym;
 754   register long val;
 755   int is_a_field_of_this;       /* C++: lookup_symbol sets this to nonzero
 756                                    if exp is a field of `this'. */
 757
 758   if (exp == 0)
 759     error ("Argument required.");
 760
 761   sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE,
 762                        &is_a_field_of_this, (struct symtab **)NULL);
 763   if (sym == 0)
 764     {
 765       register int i;
 766
 767       if (is_a_field_of_this)
 768         {
 769           printf ("Symbol \"%s\" is a field of the local class variable `this'\n", exp);
 770           return;
 771         }
 772
 773       for (i = 0; i < misc_function_count; i++)
 774         if (!strcmp (misc_function_vector[i].name, exp))
 775           break;
 776
 777       if (i < misc_function_count)
 778         printf ("Symbol \"%s\" is at 0x%x in a file compiled without -g.\n",
 779                 exp, misc_function_vector[i].address);
 780       else
 781         error ("No symbol \"%s\" in current context.", exp);
 782       return;
 783     }
 784
 785   printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym));
 786   val = SYMBOL_VALUE (sym);
 787
 788   switch (SYMBOL_CLASS (sym))
 789     {
 790     case LOC_CONST:
 791     case LOC_CONST_BYTES:
 792       printf ("constant");
 793       break;
 794
 795     case LOC_LABEL:
 796       printf ("a label at address 0x%x", SYMBOL_VALUE_ADDRESS (sym));
 797       break;
 798
 799     case LOC_REGISTER:
 800       printf ("a variable in register %s", reg_names[val]);
 801       break;
 802
 803     case LOC_STATIC:
 804       printf ("static at address 0x%x", SYMBOL_VALUE_ADDRESS (sym));
 805       break;
 806
 807     case LOC_REGPARM:
 808       printf ("an argument in register %s", reg_names[val]);
 809       break;
 810
 811     case LOC_ARG:
 812       printf ("an argument at offset %ld", val);
 813       break;
 814
 815     case LOC_LOCAL_ARG:
 816       printf ("an argument at frame offset %ld", val);
 817       break;
 818
 819     case LOC_LOCAL:
 820       printf ("a local variable at frame offset %ld", val);
 821       break;
 822
 823     case LOC_REF_ARG:
 824       printf ("a reference argument at offset %ld", val);
 825       break;
 826
 827     case LOC_TYPEDEF:
 828       printf ("a typedef");
 829       break;
 830
 831     case LOC_BLOCK:
 832       printf ("a function at address 0x%x",
 833               BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
 834       break;
 835
 836     case LOC_EXTERNAL:
 837       printf ("an external symbol at address 0x%x",
 838               SYMBOL_VALUE_ADDRESS (sym));
 839       break;
 840
 841     default:
 842       printf ("of unknown (botched) type");
 843       break;
 844     }
 845   printf (".\n");
 846 }
 847 \f
 848 static void
 849 x_command (exp, from_tty)
 850      char *exp;
 851      int from_tty;
 852 {
 853   struct expression *expr;
 854   struct format_data fmt;
 855   struct cleanup *old_chain;
 856   struct value *val;
 857
 858   fmt.format = last_format;
 859   fmt.size = last_size;
 860   fmt.count = 1;
 861
 862   if (exp && *exp == '/')
 863     {
 864       exp++;
 865       fmt = decode_format (&exp, last_format, last_size);
 866       last_size = fmt.size;
 867       last_format = fmt.format;
 868     }
 869
 870   /* If we have an expression, evaluate it and use it as the address.  */
 871
 872   if (exp != 0 && *exp != 0)
 873     {
 874       expr = parse_c_expression (exp);
 875       /* Cause expression not to be there any more
 876          if this command is repeated with Newline.
 877          But don't clobber a user-defined command's definition.  */
 878       if (from_tty)
 879         *exp = 0;
 880       old_chain = make_cleanup (free_current_contents, &expr);
 881       val = evaluate_expression (expr);
 882       if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
 883         val = value_ind (val);
 884       /* In rvalue contexts, such as this, functions are coerced into
 885          pointers to functions.  This makes "x/i main" work.  */
 886       if (/* last_format == 'i'
 887           && */ TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
 888           && VALUE_LVAL (val) == lval_memory)
 889         next_address = VALUE_ADDRESS (val);
 890       else
 891         next_address = value_as_pointer (val);
 892       do_cleanups (old_chain);
 893     }
 894
 895   do_examine (fmt, next_address);
 896
 897   /* Set a couple of internal variables if appropriate. */
 898   if (last_examine_value)
 899     {
 900       /* Make last address examined available to the user as $_.  */
 901       set_internalvar (lookup_internalvar ("_"),
 902                        value_from_long (builtin_type_int,
 903                                         (LONGEST) last_examine_address));
 904
 905       /* Make contents of last address examined available to the user as $__.*/
 906       set_internalvar (lookup_internalvar ("__"), last_examine_value);
 907     }
 908 }
 909 \f
 910 /* Commands for printing types of things.  */
 911
 912 /* Print type of EXP, or last thing in value history if EXP == NULL.
 913    show is passed to type_print.  */
 914 static void
 915 whatis_exp (exp, show)
 916      char *exp;
 917      int show;
 918 {
 919   struct expression *expr;
 920   register value val;
 921   register struct cleanup *old_chain;
 922
 923   if (exp)
 924     {
 925       expr = parse_c_expression (exp);
 926       old_chain = make_cleanup (free_current_contents, &expr);
 927       val = evaluate_type (expr);
 928     }
 929   else
 930     val = access_value_history (0);
 931
 932   printf_filtered ("type = ");
 933   type_print (VALUE_TYPE (val), "", stdout, show);
 934   printf_filtered ("\n");
 935
 936   if (exp)
 937     do_cleanups (old_chain);
 938 }
 939
 940 /* ARGSUSED */
 941 static void
 942 whatis_command (exp, from_tty)
 943      char *exp;
 944      int from_tty;
 945 {
 946   /* Most of the time users do not want to see all the fields
 947      in a structure.  If they do they can use the "ptype" command.
 948      Hence the "-1" below.  */
 949   whatis_exp (exp, -1);
 950 }
 951
 952 /* TYPENAME is either the name of a type, or an expression.  */
 953 /* ARGSUSED */
 954 static void
 955 ptype_command (typename, from_tty)
 956      char *typename;
 957      int from_tty;
 958 {
 959   register char *p = typename;
 960   register int len;
 961   register struct block *b
 962     = target_has_stack ? get_current_block () : 0;
 963   register struct type *type;
 964
 965   if (typename == 0)
 966     {
 967       whatis_exp (typename, 1);
 968       return;
 969     }
 970
 971   while (*p && *p != ' ' && *p != '\t') p++;
 972   len = p - typename;
 973   while (*p == ' ' || *p == '\t') p++;
 974
 975   if (len == 6 && !strncmp (typename, "struct", 6))
 976     type = lookup_struct (p, b);
 977   else if (len == 5 && !strncmp (typename, "union", 5))
 978     type = lookup_union (p, b);
 979   else if (len == 4 && !strncmp (typename, "enum", 4))
 980     type = lookup_enum (p, b);
 981   else
 982     {
 983       type = lookup_typename (typename, b, 1);
 984       if (type == 0)
 985         {
 986           register struct symbol *sym
 987             = lookup_symbol (typename, b, STRUCT_NAMESPACE, 0,
 988                              (struct symtab **)NULL);
 989           if (sym == 0)
 990             {
 991               /* It's not the name of a type, either VAR_NAMESPACE
 992                  or STRUCT_NAMESPACE, so it must be an expression.  */
 993               whatis_exp (typename, 1);
 994               return;
 995             }
 996           printf_filtered ("No type named %s, ", typename);
 997           wrap_here ("");
 998           printf_filtered ("but there is ");
 999           switch (TYPE_CODE (SYMBOL_TYPE (sym)))
1000             {
1001             case TYPE_CODE_STRUCT:
1002               printf_filtered ("a struct");
1003               break;
1004
1005             case TYPE_CODE_UNION:
1006               printf_filtered ("a union");
1007               break;
1008
1009             case TYPE_CODE_ENUM:
1010               printf_filtered ("an enum");
1011               break;
1012
1013             default:
1014               printf_filtered ("(Internal error in gdb)");
1015               break;
1016             }
1017           printf_filtered (" %s.  ", typename);
1018           wrap_here ("");
1019           printf_filtered ("(Type \"help ptype\".)\n");
1020           type = SYMBOL_TYPE (sym);
1021         }
1022     }
1023
1024   type_print (type, "", stdout, 1);
1025   printf_filtered ("\n");
1026 }
1027 \f
1028 #if 0
1029 /* This is not necessary.  Instead, decode_line_1 takes any variable,
1030    so "info line foo" is a close equivalent to "whereis foo".  */
1031 static void
1032 whereis_command (var, from_tty)
1033      char *var;
1034      int from_tty;
1035 {
1036   struct symtab *s;
1037   struct symbol *sym;
1038
1039   if (var == NULL)
1040     error_no_arg ("Variable name.");
1041
1042   sym = lookup_symbol (var, get_selected_block (), VAR_NAMESPACE,
1043                        NULL, &s);
1044
1045   if (sym != NULL && s != NULL)
1046     printf_filtered ("Symbol \"%s\" is at line %d of file %s\n",
1047                      var, sym->line, s->filename);
1048   else
1049     {
1050       if (lookup_misc_func (var) >= 0)
1051         printf_filtered ("Symbol \"%s\" is in a file compiled without -g.",
1052                          var);
1053       else
1054         error ("No symbol \"%s\" in current context.", var);
1055     }
1056 }
1057 #endif /* 0 */
1058 \f
1059 enum display_status {disabled, enabled};
1060
1061 struct display
1062 {
1063   /* Chain link to next auto-display item.  */
1064   struct display *next;
1065   /* Expression to be evaluated and displayed.  */
1066   struct expression *exp;
1067   /* Item number of this auto-display item.  */
1068   int number;
1069   /* Display format specified.  */
1070   struct format_data format;
1071   /* Innermost block required by this expression when evaluated */
1072   struct block *block;
1073   /* Status of this display (enabled or disabled) */
1074   enum display_status status;
1075 };
1076
1077 /* Chain of expressions whose values should be displayed
1078    automatically each time the program stops.  */
1079
1080 static struct display *display_chain;
1081
1082 static int display_number;
1083
1084 /* Add an expression to the auto-display chain.
1085    Specify the expression.  */
1086
1087 static void
1088 display_command (exp, from_tty)
1089      char *exp;
1090      int from_tty;
1091 {
1092   struct format_data fmt;
1093   register struct expression *expr;
1094   register struct display *new;
1095
1096   if (exp == 0)
1097     {
1098       do_displays ();
1099       return;
1100     }
1101
1102   if (*exp == '/')
1103     {
1104       exp++;
1105       fmt = decode_format (&exp, 0, 0);
1106       if (fmt.size && fmt.format == 0)
1107         fmt.format = 'x';
1108       if (fmt.format == 'i' || fmt.format == 's')
1109         fmt.size = 'b';
1110     }
1111   else
1112     {
1113       fmt.format = 0;
1114       fmt.size = 0;
1115       fmt.count = 0;
1116     }
1117
1118   innermost_block = 0;
1119   expr = parse_c_expression (exp);
1120
1121   new = (struct display *) xmalloc (sizeof (struct display));
1122
1123   new->exp = expr;
1124   new->block = innermost_block;
1125   new->next = display_chain;
1126   new->number = ++display_number;
1127   new->format = fmt;
1128   new->status = enabled;
1129   display_chain = new;
1130
1131   if (from_tty && target_has_execution)
1132     do_one_display (new);
1133
1134   dont_repeat ();
1135 }
1136
1137 static void
1138 free_display (d)
1139      struct display *d;
1140 {
1141   free (d->exp);
1142   free (d);
1143 }
1144
1145 /* Clear out the display_chain.
1146    Done when new symtabs are loaded, since this invalidates
1147    the types stored in many expressions.  */
1148
1149 void
1150 clear_displays ()
1151 {
1152   register struct display *d;
1153
1154   while (d = display_chain)
1155     {
1156       free (d->exp);
1157       display_chain = d->next;
1158       free (d);
1159     }
1160 }
1161
1162 /* Delete the auto-display number NUM.  */
1163
1164 void
1165 delete_display (num)
1166      int num;
1167 {
1168   register struct display *d1, *d;
1169
1170   if (!display_chain)
1171     error ("No display number %d.", num);
1172
1173   if (display_chain->number == num)
1174     {
1175       d1 = display_chain;
1176       display_chain = d1->next;
1177       free_display (d1);
1178     }
1179   else
1180     for (d = display_chain; ; d = d->next)
1181       {
1182         if (d->next == 0)
1183           error ("No display number %d.", num);
1184         if (d->next->number == num)
1185           {
1186             d1 = d->next;
1187             d->next = d1->next;
1188             free_display (d1);
1189             break;
1190           }
1191       }
1192 }
1193
1194 /* Delete some values from the auto-display chain.
1195    Specify the element numbers.  */
1196
1197 static void
1198 undisplay_command (args)
1199      char *args;
1200 {
1201   register char *p = args;
1202   register char *p1;
1203   register int num;
1204
1205   if (args == 0)
1206     {
1207       if (query ("Delete all auto-display expressions? "))
1208         clear_displays ();
1209       dont_repeat ();
1210       return;
1211     }
1212
1213   while (*p)
1214     {
1215       p1 = p;
1216       while (*p1 >= '0' && *p1 <= '9') p1++;
1217       if (*p1 && *p1 != ' ' && *p1 != '\t')
1218         error ("Arguments must be display numbers.");
1219
1220       num = atoi (p);
1221
1222       delete_display (num);
1223
1224       p = p1;
1225       while (*p == ' ' || *p == '\t') p++;
1226     }
1227   dont_repeat ();
1228 }
1229
1230 /* Display a single auto-display.
1231    Do nothing if the display cannot be printed in the current context,
1232    or if the display is disabled. */
1233
1234 static void
1235 do_one_display (d)
1236      struct display *d;
1237 {
1238   int within_current_scope;
1239
1240   if (d->status == disabled)
1241     return;
1242
1243   if (d->block)
1244     within_current_scope = contained_in (get_selected_block (), d->block);
1245   else
1246     within_current_scope = 1;
1247   if (!within_current_scope)
1248     return;
1249
1250   current_display_number = d->number;
1251
1252   printf_filtered ("%d: ", d->number);
1253   if (d->format.size)
1254     {
1255       CORE_ADDR addr;
1256
1257       printf_filtered ("x/");
1258       if (d->format.count != 1)
1259         printf_filtered ("%d", d->format.count);
1260       printf_filtered ("%c", d->format.format);
1261       if (d->format.format != 'i' && d->format.format != 's')
1262         printf_filtered ("%c", d->format.size);
1263       printf_filtered (" ");
1264       print_expression (d->exp, stdout);
1265       if (d->format.count != 1)
1266         printf_filtered ("\n");
1267       else
1268         printf_filtered ("  ");
1269
1270       addr = value_as_pointer (evaluate_expression (d->exp));
1271       if (d->format.format == 'i')
1272         addr = ADDR_BITS_REMOVE (addr);
1273
1274       do_examine (d->format, addr);
1275     }
1276   else
1277     {
1278       if (d->format.format)
1279         printf_filtered ("/%c ", d->format.format);
1280       print_expression (d->exp, stdout);
1281       printf_filtered (" = ");
1282       print_formatted (evaluate_expression (d->exp),
1283                        d->format.format, d->format.size);
1284       printf_filtered ("\n");
1285     }
1286
1287   fflush (stdout);
1288   current_display_number = -1;
1289 }
1290
1291 /* Display all of the values on the auto-display chain which can be
1292    evaluated in the current scope.  */
1293
1294 void
1295 do_displays ()
1296 {
1297   register struct display *d;
1298
1299   for (d = display_chain; d; d = d->next)
1300     do_one_display (d);
1301 }
1302
1303 /* Delete the auto-display which we were in the process of displaying.
1304    This is done when there is an error or a signal.  */
1305
1306 void
1307 disable_display (num)
1308      int num;
1309 {
1310   register struct display *d;
1311
1312   for (d = display_chain; d; d = d->next)
1313     if (d->number == num)
1314       {
1315         d->status = disabled;
1316         return;
1317       }
1318   printf ("No display number %d.\n", num);
1319 }
1320
1321 void
1322 disable_current_display ()
1323 {
1324   if (current_display_number >= 0)
1325     {
1326       disable_display (current_display_number);
1327       fprintf (stderr, "Disabling display %d to avoid infinite recursion.\n",
1328                current_display_number);
1329     }
1330   current_display_number = -1;
1331 }
1332
1333 static void
1334 display_info ()
1335 {
1336   register struct display *d;
1337
1338   if (!display_chain)
1339     printf ("There are no auto-display expressions now.\n");
1340   else
1341       printf_filtered ("Auto-display expressions now in effect:\n\
1342 Num Enb Expression\n");
1343
1344   for (d = display_chain; d; d = d->next)
1345     {
1346       printf_filtered ("%d:   %c  ", d->number, "ny"[(int)d->status]);
1347       if (d->format.size)
1348         printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1349                 d->format.format);
1350       else if (d->format.format)
1351         printf_filtered ("/%c ", d->format.format);
1352       print_expression (d->exp, stdout);
1353       if (d->block && !contained_in (get_selected_block (), d->block))
1354         printf_filtered (" (cannot be evaluated in the current context)");
1355       printf_filtered ("\n");
1356       fflush (stdout);
1357     }
1358 }
1359
1360 void
1361 enable_display (args)
1362      char *args;
1363 {
1364   register char *p = args;
1365   register char *p1;
1366   register int num;
1367   register struct display *d;
1368
1369   if (p == 0)
1370     {
1371       for (d = display_chain; d; d = d->next)
1372         d->status = enabled;
1373     }
1374   else
1375     while (*p)
1376       {
1377         p1 = p;
1378         while (*p1 >= '0' && *p1 <= '9')
1379           p1++;
1380         if (*p1 && *p1 != ' ' && *p1 != '\t')
1381           error ("Arguments must be display numbers.");
1382
1383         num = atoi (p);
1384
1385         for (d = display_chain; d; d = d->next)
1386           if (d->number == num)
1387             {
1388               d->status = enabled;
1389               goto win;
1390             }
1391         printf ("No display number %d.\n", num);
1392       win:
1393         p = p1;
1394         while (*p == ' ' || *p == '\t')
1395           p++;
1396       }
1397 }
1398
1399 /* ARGSUSED */
1400 void
1401 disable_display_command (args, from_tty)
1402      char *args;
1403      int from_tty;
1404 {
1405   register char *p = args;
1406   register char *p1;
1407   register struct display *d;
1408
1409   if (p == 0)
1410     {
1411       for (d = display_chain; d; d = d->next)
1412         d->status = disabled;
1413     }
1414   else
1415     while (*p)
1416       {
1417         p1 = p;
1418         while (*p1 >= '0' && *p1 <= '9')
1419           p1++;
1420         if (*p1 && *p1 != ' ' && *p1 != '\t')
1421           error ("Arguments must be display numbers.");
1422
1423         disable_display (atoi (p));
1424
1425         p = p1;
1426         while (*p == ' ' || *p == '\t')
1427           p++;
1428       }
1429 }
1430
1431 \f
1432 /* Print the value in stack frame FRAME of a variable
1433    specified by a struct symbol.  */
1434
1435 void
1436 print_variable_value (var, frame, stream)
1437      struct symbol *var;
1438      FRAME frame;
1439      FILE *stream;
1440 {
1441   value val = read_var_value (var, frame);
1442   value_print (val, stream, 0, Val_pretty_default);
1443 }
1444
1445 /* Print the arguments of a stack frame, given the function FUNC
1446    running in that frame (as a symbol), the info on the frame,
1447    and the number of args according to the stack frame (or -1 if unknown).  */
1448
1449 /* References here and elsewhere to "number of args according to the
1450    stack frame" appear in all cases to refer to "number of ints of args
1451    according to the stack frame".  At least for VAX, i386, isi.  */
1452
1453 void
1454 print_frame_args (func, fi, num, stream)
1455      struct symbol *func;
1456      struct frame_info *fi;
1457      int num;
1458      FILE *stream;
1459 {
1460   struct block *b;
1461   int nsyms = 0;
1462   int first = 1;
1463   register int i;
1464   register struct symbol *sym;
1465   register value val;
1466   /* Offset of next stack argument beyond the one we have seen that is
1467      at the highest offset.
1468      -1 if we haven't come to a stack argument yet.  */
1469   long highest_offset = -1;
1470   int arg_size;
1471   /* Number of ints of arguments that we have printed so far.  */
1472   int args_printed = 0;
1473
1474   if (func)
1475     {
1476       b = SYMBOL_BLOCK_VALUE (func);
1477       nsyms = BLOCK_NSYMS (b);
1478     }
1479
1480   for (i = 0; i < nsyms; i++)
1481     {
1482       QUIT;
1483       sym = BLOCK_SYM (b, i);
1484
1485       if (SYMBOL_CLASS (sym) != LOC_REGPARM
1486           && SYMBOL_CLASS (sym) != LOC_ARG
1487           && SYMBOL_CLASS (sym) != LOC_LOCAL_ARG
1488           && SYMBOL_CLASS (sym) != LOC_REF_ARG)
1489         continue;
1490
1491       /* We have to re-look-up the symbol because arguments often have
1492          two entries (one a parameter, one a register or local), and the one
1493          we want is the non-parm, which lookup_symbol will find for
1494          us.  After this, sym could be any SYMBOL_CLASS...  */
1495       sym = lookup_symbol (SYMBOL_NAME (sym),
1496                     b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
1497
1498       switch (SYMBOL_CLASS (sym)) {
1499
1500       /* Keep track of the highest stack argument offset seen */
1501       case LOC_ARG:
1502       case LOC_REF_ARG:
1503         {
1504           long current_offset = SYMBOL_VALUE (sym);
1505
1506           arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
1507
1508           /* Compute address of next argument by adding the size of
1509              this argument and rounding to an int boundary.  */
1510           current_offset
1511             = ((current_offset + arg_size + sizeof (int) - 1)
1512                & ~(sizeof (int) - 1));
1513
1514           /* If this is the highest offset seen yet, set highest_offset.  */
1515           if (highest_offset == -1
1516               || (current_offset > highest_offset))
1517             highest_offset = current_offset;
1518
1519           /* Add the number of ints we're about to print to args_printed.  */
1520           args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
1521         }
1522
1523       /* Other types of symbols don't need to be kept track of.  */
1524       default:
1525         break;
1526       }
1527
1528       /* Print the current arg.  */
1529       if (! first)
1530         fprintf_filtered (stream, ", ");
1531       wrap_here ("    ");
1532       fprint_symbol (stream, SYMBOL_NAME (sym));
1533       fputs_filtered ("=", stream);
1534
1535       /* Avoid value_print because it will deref ref parameters.  We just
1536          want to print their addresses.  Print ??? for args whose address
1537          we do not know.  We pass 2 as "recurse" to val_print because our
1538          standard indentation here is 4 spaces, and val_print indents
1539          2 for each recurse.  */
1540       val = read_var_value (sym, FRAME_INFO_ID (fi));
1541       if (val)
1542         val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
1543                    stream, 0, 0, 2, Val_no_prettyprint);
1544       else
1545         fputs_filtered ("???", stream);
1546       first = 0;
1547     }
1548
1549   /* Don't print nameless args in situations where we don't know
1550      enough about the stack to find them.  */
1551   if (num != -1)
1552     {
1553       long start;
1554       CORE_ADDR addr;
1555
1556       if (highest_offset == -1)
1557         start = FRAME_ARGS_SKIP;
1558       else
1559         start = highest_offset;
1560
1561       addr = FRAME_ARGS_ADDRESS (fi);
1562       if (addr)
1563         print_frame_nameless_args (addr, start, num - args_printed,
1564                                    first, stream);
1565     }
1566 }
1567
1568 /* Print nameless args on STREAM.
1569    ARGSADDR is the address of the arglist, START is the offset
1570    of the first nameless arg, and NUM is the number of nameless args to
1571    print.  FIRST is nonzero if this is the first argument (not just
1572    the first nameless arg).  */
1573 static void
1574 print_frame_nameless_args (argsaddr, start, num, first, stream)
1575      CORE_ADDR argsaddr;
1576      long start;
1577      int num;
1578      int first;
1579      FILE *stream;
1580 {
1581   int i;
1582   for (i = 0; i < num; i++)
1583     {
1584       QUIT;
1585       if (!first)
1586         fprintf_filtered (stream, ", ");
1587 #ifndef PRINT_TYPELESS_INTEGER
1588       fprintf_filtered (stream, "%d",
1589                read_memory_integer (argsaddr + start, sizeof (int)));
1590 #else
1591       PRINT_TYPELESS_INTEGER (stream, builtin_type_int,
1592                               (LONGEST)
1593                               read_memory_integer (argsaddr + start,
1594                                                    sizeof (int)));
1595 #endif
1596       first = 0;
1597       start += sizeof (int);
1598     }
1599 }
1600 \f
1601 /* ARGSUSED */
1602 static void
1603 printf_command (arg, from_tty)
1604      char *arg;
1605      int from_tty;
1606 {
1607   register char *f;
1608   register char *s = arg;
1609   char *string;
1610   value *val_args;
1611   int nargs = 0;
1612   int allocated_args = 20;
1613   char *arg_bytes;
1614
1615   val_args = (value *) xmalloc (allocated_args * sizeof (value));
1616
1617   if (s == 0)
1618     error_no_arg ("format-control string and values to print");
1619
1620   /* Skip white space before format string */
1621   while (*s == ' ' || *s == '\t') s++;
1622
1623   /* A format string should follow, enveloped in double quotes */
1624   if (*s++ != '"')
1625     error ("Bad format string, missing '\"'.");
1626
1627   /* Parse the format-control string and copy it into the string STRING,
1628      processing some kinds of escape sequence.  */
1629
1630   f = string = (char *) alloca (strlen (s) + 1);
1631   while (*s != '"')
1632     {
1633       int c = *s++;
1634       switch (c)
1635         {
1636         case '\0':
1637           error ("Bad format string, non-terminated '\"'.");
1638           /* doesn't return */
1639
1640         case '\\':
1641           switch (c = *s++)
1642             {
1643             case '\\':
1644               *f++ = '\\';
1645               break;
1646             case 'n':
1647               *f++ = '\n';
1648               break;
1649             case 't':
1650               *f++ = '\t';
1651               break;
1652             case 'r':
1653               *f++ = '\r';
1654               break;
1655             case '"':
1656               *f++ = '"';
1657               break;
1658             default:
1659               /* ??? TODO: handle other escape sequences */
1660               error ("Unrecognized \\ escape character in format string.");
1661             }
1662           break;
1663
1664         default:
1665           *f++ = c;
1666         }
1667     }
1668
1669   /* Skip over " and following space and comma.  */
1670   s++;
1671   *f++ = '\0';
1672   while (*s == ' ' || *s == '\t') s++;
1673
1674   if (*s != ',' && *s != 0)
1675     error ("Invalid argument syntax");
1676
1677   if (*s == ',') s++;
1678   while (*s == ' ' || *s == '\t') s++;
1679
1680   {
1681     /* Now scan the string for %-specs and see what kinds of args they want.
1682        argclass[I] classifies the %-specs so we can give vprintf something
1683        of the right size.  */
1684
1685     enum argclass {int_arg, string_arg, double_arg, long_long_arg};
1686     enum argclass *argclass;
1687     int nargs_wanted;
1688     int argindex;
1689     int lcount;
1690     int i;
1691
1692     argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
1693     nargs_wanted = 0;
1694     f = string;
1695     while (*f)
1696       if (*f++ == '%')
1697         {
1698           lcount = 0;
1699           while (strchr ("0123456789.hlL-+ #", *f))
1700             {
1701               if (*f == 'l' || *f == 'L')
1702                 lcount++;
1703               f++;
1704             }
1705           if (*f == 's')
1706             argclass[nargs_wanted++] = string_arg;
1707           else if (*f == 'e' || *f == 'f' || *f == 'g')
1708             argclass[nargs_wanted++] = double_arg;
1709           else if (lcount > 1)
1710             argclass[nargs_wanted++] = long_long_arg;
1711           else if (*f != '%')
1712             argclass[nargs_wanted++] = int_arg;
1713           f++;
1714         }
1715
1716     /* Now, parse all arguments and evaluate them.
1717        Store the VALUEs in VAL_ARGS.  */
1718
1719     while (*s != '\0')
1720       {
1721         char *s1;
1722         if (nargs == allocated_args)
1723           val_args = (value *) xrealloc (val_args,
1724                                          (allocated_args *= 2)
1725                                          * sizeof (value));
1726         s1 = s;
1727         val_args[nargs] = parse_to_comma_and_eval (&s1);
1728
1729         /* If format string wants a float, unchecked-convert the value to
1730            floating point of the same size */
1731
1732         if (argclass[nargs] == double_arg)
1733           {
1734             if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (float))
1735               VALUE_TYPE (val_args[nargs]) = builtin_type_float;
1736             if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (double))
1737               VALUE_TYPE (val_args[nargs]) = builtin_type_double;
1738           }
1739         nargs++;
1740         s = s1;
1741         if (*s == ',')
1742           s++;
1743       }
1744
1745     if (nargs != nargs_wanted)
1746       error ("Wrong number of arguments for specified format-string");
1747
1748     /* Now lay out an argument-list containing the arguments
1749        as doubles, integers and C pointers.  */
1750
1751     arg_bytes = (char *) alloca (sizeof (double) * nargs);
1752     argindex = 0;
1753     for (i = 0; i < nargs; i++)
1754       {
1755         if (argclass[i] == string_arg)
1756           {
1757             char *str;
1758             CORE_ADDR tem;
1759             int j;
1760             tem = value_as_pointer (val_args[i]);
1761
1762             /* This is a %s argument.  Find the length of the string.  */
1763             for (j = 0; ; j++)
1764               {
1765                 char c;
1766                 QUIT;
1767                 read_memory (tem + j, &c, 1);
1768                 if (c == 0)
1769                   break;
1770               }
1771
1772             /* Copy the string contents into a string inside GDB.  */
1773             str = (char *) alloca (j + 1);
1774             read_memory (tem, str, j);
1775             str[j] = 0;
1776
1777             /* Pass address of internal copy as the arg to vprintf.  */
1778             *((int *) &arg_bytes[argindex]) = (int) str;
1779             argindex += sizeof (int);
1780           }
1781         else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT)
1782           {
1783             *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]);
1784             argindex += sizeof (double);
1785           }
1786         else
1787 #ifdef LONG_LONG
1788           if (argclass[i] == long_long_arg)
1789             {
1790               *(long long *) &arg_bytes[argindex] = value_as_long (val_args[i]);
1791               argindex += sizeof (long long);
1792             }
1793           else
1794 #endif
1795             {
1796               *((long *) &arg_bytes[argindex]) = value_as_long (val_args[i]);
1797               argindex += sizeof (long);
1798             }
1799       }
1800   }
1801
1802   /* There is not a standard way to make a va_list, so we need
1803      to do various things for different systems.  */
1804 #if defined (__INT_VARARGS_H)
1805   {
1806     va_list list;
1807
1808     list.__va_arg = 0;
1809     list.__va_stk = (int *) arg_bytes;
1810     list.__va_reg = (int *) arg_bytes;
1811     vprintf (string, list);
1812   }
1813 #else /* No __INT_VARARGS_H.  */
1814   vprintf (string, arg_bytes);
1815 #endif /* No __INT_VARARGS_H.  */
1816 }
1817 \f
1818 /* Helper function for asdump_command.  Finds the bounds of a function
1819    for a specified section of text.  PC is an address within the
1820    function which you want bounds for; *LOW and *HIGH are set to the
1821    beginning (inclusive) and end (exclusive) of the function.  This
1822    function returns 1 on success and 0 on failure.  */
1823
1824 static int
1825 containing_function_bounds (pc, low, high)
1826      CORE_ADDR pc, *low, *high;
1827 {
1828   int scan;
1829
1830   if (!find_pc_partial_function (pc, 0, low))
1831     return 0;
1832
1833   scan = *low;
1834   do {
1835     scan++;
1836     if (!find_pc_partial_function (scan, 0, high))
1837       return 0;
1838   } while (*low == *high);
1839
1840   return 1;
1841 }
1842
1843 /* Dump a specified section of assembly code.  With no command line
1844    arguments, this command will dump the assembly code for the
1845    function surrounding the pc value in the selected frame.  With one
1846    argument, it will dump the assembly code surrounding that pc value.
1847    Two arguments are interpeted as bounds within which to dump
1848    assembly.  */
1849
1850 /* ARGSUSED */
1851 static void
1852 disassemble_command (arg, from_tty)
1853      char *arg;
1854      int from_tty;
1855 {
1856   CORE_ADDR low, high;
1857   CORE_ADDR pc;
1858   char *space_index;
1859
1860   if (!arg)
1861     {
1862       if (!selected_frame)
1863         error ("No frame selected.\n");
1864
1865       pc = get_frame_pc (selected_frame);
1866       if (!containing_function_bounds (pc, &low, &high))
1867         error ("No function contains pc specified by selected frame.\n");
1868     }
1869   else if (!(space_index = (char *) strchr (arg, ' ')))
1870     {
1871       /* One argument.  */
1872       pc = parse_and_eval_address (arg);
1873       if (!containing_function_bounds (pc, &low, &high))
1874         error ("No function contains specified pc.\n");
1875     }
1876   else
1877     {
1878       /* Two arguments.  */
1879       *space_index = '\0';
1880       low = parse_and_eval_address (arg);
1881       high = parse_and_eval_address (space_index + 1);
1882     }
1883
1884   printf_filtered ("Dump of assembler code ");
1885   if (!space_index)
1886     {
1887       char *name;
1888       find_pc_partial_function (pc, &name, 0);
1889       printf_filtered ("for function %s:\n", name);
1890     }
1891   else
1892     printf_filtered ("from 0x%x to 0x%x:\n", low, high);
1893
1894   /* Dump the specified range.  */
1895   for (pc = low; pc < high; )
1896     {
1897       QUIT;
1898       print_address (pc, stdout);
1899       printf_filtered (":\t");
1900       pc += print_insn (pc, stdout);
1901       printf_filtered ("\n");
1902     }
1903   printf_filtered ("End of assembler dump.\n");
1904   fflush (stdout);
1905 }
1906
1907 \f
1908 void
1909 _initialize_printcmd ()
1910 {
1911   current_display_number = -1;
1912
1913   add_info ("address", address_info,
1914            "Describe where variable VAR is stored.");
1915
1916   add_com ("x", class_vars, x_command,
1917            "Examine memory: x/FMT ADDRESS.\n\
1918 ADDRESS is an expression for the memory address to examine.\n\
1919 FMT is a repeat count followed by a format letter and a size letter.\n\
1920 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
1921  f(float), a(address), i(instruction), c(char) and s(string).\n\
1922 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
1923   g is meaningful only with f, for type double.\n\
1924 The specified number of objects of the specified size are printed\n\
1925 according to the format.\n\n\
1926 Defaults for format and size letters are those previously used.\n\
1927 Default count is 1.  Default address is following last thing printed\n\
1928 with this command or \"print\".");
1929
1930   add_com ("disassemble", class_vars, disassemble_command,
1931            "Disassemble a specified section of memory.\n\
1932 Default is the function surrounding the pc of the selected frame.\n\
1933 With a single argument, the function surrounding that address is dumped.\n\
1934 Two arguments are taken as a range of memory to dump.");
1935
1936   add_com ("ptype", class_vars, ptype_command,
1937            "Print definition of type TYPE.\n\
1938 Argument may be a type name defined by typedef, or \"struct STRUCTNAME\"\n\
1939 or \"union UNIONNAME\" or \"enum ENUMNAME\".\n\
1940 The selected stack frame's lexical context is used to look up the name.");
1941
1942   add_com ("whatis", class_vars, whatis_command,
1943            "Print data type of expression EXP.");
1944
1945 #if 0
1946   add_com ("whereis", class_vars, whereis_command,
1947            "Print line number and file of definition of variable.");
1948 #endif
1949
1950   add_info ("display", display_info,
1951             "Expressions to display when program stops, with code numbers.");
1952
1953   add_cmd ("undisplay", class_vars, undisplay_command,
1954            "Cancel some expressions to be displayed when program stops.\n\
1955 Arguments are the code numbers of the expressions to stop displaying.\n\
1956 No argument means cancel all automatic-display expressions.\n\
1957 \"delete display\" has the same effect as this command.\n\
1958 Do \"info display\" to see current list of code numbers.",
1959                   &cmdlist);
1960
1961   add_com ("display", class_vars, display_command,
1962            "Print value of expression EXP each time the program stops.\n\
1963 /FMT may be used before EXP as in the \"print\" command.\n\
1964 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
1965 as in the \"x\" command, and then EXP is used to get the address to examine\n\
1966 and examining is done as in the \"x\" command.\n\n\
1967 With no argument, display all currently requested auto-display expressions.\n\
1968 Use \"undisplay\" to cancel display requests previously made.");
1969
1970   add_cmd ("display", class_vars, enable_display,
1971            "Enable some expressions to be displayed when program stops.\n\
1972 Arguments are the code numbers of the expressions to resume displaying.\n\
1973 No argument means enable all automatic-display expressions.\n\
1974 Do \"info display\" to see current list of code numbers.", &enablelist);
1975
1976   add_cmd ("display", class_vars, disable_display_command,
1977            "Disable some expressions to be displayed when program stops.\n\
1978 Arguments are the code numbers of the expressions to stop displaying.\n\
1979 No argument means disable all automatic-display expressions.\n\
1980 Do \"info display\" to see current list of code numbers.", &disablelist);
1981
1982   add_cmd ("display", class_vars, undisplay_command,
1983            "Cancel some expressions to be displayed when program stops.\n\
1984 Arguments are the code numbers of the expressions to stop displaying.\n\
1985 No argument means cancel all automatic-display expressions.\n\
1986 Do \"info display\" to see current list of code numbers.", &deletelist);
1987
1988   add_com ("printf", class_vars, printf_command,
1989         "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
1990 This is useful for formatted output in user-defined commands.");
1991   add_com ("output", class_vars, output_command,
1992            "Like \"print\" but don't put in value history and don't print newline.\n\
1993 This is useful in user-defined commands.");
1994
1995   add_prefix_cmd ("set", class_vars, set_command,
1996 "Perform an assignment VAR = EXP.\n\
1997 You must type the \"=\".  VAR may be a debugger \"convenience\" variable\n\
1998 (names starting with $), a register (a few standard names starting with $),\n\
1999 or an actual variable in the program being debugged.  EXP is any expression.\n\
2000 Use \"set variable\" for variables with names identical to set subcommands.\n\
2001 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2002 You can see these environment settings with the \"show\" command.",
2003                   &setlist, "set ", 1, &cmdlist);
2004
2005   /* "call" is the same as "set", but handy for dbx users to call fns. */
2006   add_com ("call", class_vars, call_command,
2007            "Call a function in the inferior process.\n\
2008 The argument is the function name and arguments, in standard C notation.\n\
2009 The result is printed and saved in the value history, if it is not void.");
2010
2011   add_cmd ("variable", class_vars, set_command,
2012            "Perform an assignment VAR = EXP.\n\
2013 You must type the \"=\".  VAR may be a debugger \"convenience\" variable\n\
2014 (names starting with $), a register (a few standard names starting with $),\n\
2015 or an actual variable in the program being debugged.  EXP is any expression.\n\
2016 This may usually be abbreviated to simply \"set\".",
2017            &setlist);
2018
2019   add_com ("print", class_vars, print_command,
2020            concat ("Print value of expression EXP.\n\
2021 Variables accessible are those of the lexical environment of the selected\n\
2022 stack frame, plus all those whose scope is global or an entire file.\n\
2023 \n\
2024 $NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
2025 $$NUM refers to NUM'th value back from the last one.\n\
2026 Names starting with $ refer to registers (with the values they would have\n\
2027 if the program were to return to the stack frame now selected, restoring\n\
2028 all registers saved by frames farther in) or else to debugger\n\
2029 \"convenience\" variables (any such name not a known register).\n\
2030 Use assignment expressions to give values to convenience variables.\n",
2031                    "\n\
2032 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2033 @ is a binary operator for treating consecutive data objects\n\
2034 anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
2035 element is FOO, whose second element is stored in the space following\n\
2036 where FOO is stored, etc.  FOO must be an expression whose value\n\
2037 resides in memory.\n",
2038                    "\n\
2039 EXP may be preceded with /FMT, where FMT is a format letter\n\
2040 but no count or size letter (see \"x\" command)."));
2041   add_com_alias ("p", "print", class_vars, 1);
2042
2043   add_com ("inspect", class_vars, inspect_command,
2044 "Same as \"print\" command, except that if you are running in the epoch\n\
2045 environment, the value is printed in its own window.");
2046 }