gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002, 2003,
   4    2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "parser-defs.h"
  26 #include "language.h"
  27 #include "c-lang.h"
  28 #include "valprint.h"
  29 #include "macroscope.h"
  30 #include "gdb_assert.h"
  31 #include "charset.h"
  32 #include "gdb_string.h"
  33 #include "demangle.h"
  34 #include "cp-abi.h"
  35 #include "cp-support.h"
  36 #include "gdb_obstack.h"
  37 #include <ctype.h>
  38
  39 extern void _initialize_c_language (void);
  40
  41 /* Given a C string type, STR_TYPE, return the corresponding target
  42    character set name.  */
  43
  44 static const char *
  45 charset_for_string_type (enum c_string_type str_type,
  46                          enum bfd_endian byte_order)
  47 {
  48   switch (str_type & ~C_CHAR)
  49     {
  50     case C_STRING:
  51       return target_charset ();
  52     case C_WIDE_STRING:
  53       return target_wide_charset (byte_order);
  54     case C_STRING_16:
  55       /* FIXME: UCS-2 is not always correct.  */
  56       if (byte_order == BFD_ENDIAN_BIG)
  57         return "UCS-2BE";
  58       else
  59         return "UCS-2LE";
  60     case C_STRING_32:
  61       /* FIXME: UCS-4 is not always correct.  */
  62       if (byte_order == BFD_ENDIAN_BIG)
  63         return "UCS-4BE";
  64       else
  65         return "UCS-4LE";
  66     }
  67   internal_error (__FILE__, __LINE__, "unhandled c_string_type");
  68 }
  69
  70 /* Classify ELTTYPE according to what kind of character it is.  Return
  71    the enum constant representing the character type.  Also set
  72    *ENCODING to the name of the character set to use when converting
  73    characters of this type in target BYTE_ORDER to the host character set.  */
  74
  75 static enum c_string_type
  76 classify_type (struct type *elttype, enum bfd_endian byte_order,
  77                const char **encoding)
  78 {
  79   struct type *saved_type;
  80   enum c_string_type result;
  81
  82   /* We loop because ELTTYPE may be a typedef, and we want to
  83      successively peel each typedef until we reach a type we
  84      understand.  We don't use CHECK_TYPEDEF because that will strip
  85      all typedefs at once -- but in C, wchar_t is itself a typedef, so
  86      that would do the wrong thing.  */
  87   while (elttype)
  88     {
  89       char *name = TYPE_NAME (elttype);
  90
  91       if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
  92         {
  93           result = C_CHAR;
  94           goto done;
  95         }
  96
  97       if (!strcmp (name, "wchar_t"))
  98         {
  99           result = C_WIDE_CHAR;
 100           goto done;
 101         }
 102
 103       if (!strcmp (name, "char16_t"))
 104         {
 105           result = C_CHAR_16;
 106           goto done;
 107         }
 108
 109       if (!strcmp (name, "char32_t"))
 110         {
 111           result = C_CHAR_32;
 112           goto done;
 113         }
 114
 115       if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
 116         break;
 117
 118       /* Call for side effects.  */
 119       check_typedef (elttype);
 120
 121       if (TYPE_TARGET_TYPE (elttype))
 122         elttype = TYPE_TARGET_TYPE (elttype);
 123       else
 124         {
 125           /* Perhaps check_typedef did not update the target type.  In
 126              this case, force the lookup again and hope it works out.
 127              It never will for C, but it might for C++.  */
 128           CHECK_TYPEDEF (elttype);
 129         }
 130     }
 131
 132   /* Punt.  */
 133   result = C_CHAR;
 134
 135  done:
 136   if (encoding)
 137     *encoding = charset_for_string_type (result, byte_order);
 138
 139   return result;
 140 }
 141
 142 /* Return true if print_wchar can display W without resorting to a
 143    numeric escape, false otherwise.  */
 144
 145 static int
 146 wchar_printable (gdb_wchar_t w)
 147 {
 148   return (gdb_iswprint (w)
 149           || w == LCST ('\a') || w == LCST ('\b')
 150           || w == LCST ('\f') || w == LCST ('\n')
 151           || w == LCST ('\r') || w == LCST ('\t')
 152           || w == LCST ('\v'));
 153 }
 154
 155 /* A helper function that converts the contents of STRING to wide
 156    characters and then appends them to OUTPUT.  */
 157
 158 static void
 159 append_string_as_wide (const char *string, struct obstack *output)
 160 {
 161   for (; *string; ++string)
 162     {
 163       gdb_wchar_t w = gdb_btowc (*string);
 164       obstack_grow (output, &w, sizeof (gdb_wchar_t));
 165     }
 166 }
 167
 168 /* Print a wide character W to OUTPUT.  ORIG is a pointer to the
 169    original (target) bytes representing the character, ORIG_LEN is the
 170    number of valid bytes.  WIDTH is the number of bytes in a base
 171    characters of the type.  OUTPUT is an obstack to which wide
 172    characters are emitted.  QUOTER is a (narrow) character indicating
 173    the style of quotes surrounding the character to be printed.
 174    NEED_ESCAPE is an in/out flag which is used to track numeric
 175    escapes across calls.  */
 176
 177 static void
 178 print_wchar (gdb_wint_t w, const gdb_byte *orig, int orig_len,
 179              int width, enum bfd_endian byte_order, struct obstack *output,
 180              int quoter, int *need_escapep)
 181 {
 182   int need_escape = *need_escapep;
 183   *need_escapep = 0;
 184   if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
 185                                             && w != LCST ('8')
 186                                             && w != LCST ('9'))))
 187     {
 188       gdb_wchar_t wchar = w;
 189
 190       if (w == gdb_btowc (quoter) || w == LCST ('\\'))
 191         obstack_grow_wstr (output, LCST ("\\"));
 192       obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
 193     }
 194   else
 195     {
 196       switch (w)
 197         {
 198         case LCST ('\a'):
 199           obstack_grow_wstr (output, LCST ("\\a"));
 200           break;
 201         case LCST ('\b'):
 202           obstack_grow_wstr (output, LCST ("\\b"));
 203           break;
 204         case LCST ('\f'):
 205           obstack_grow_wstr (output, LCST ("\\f"));
 206           break;
 207         case LCST ('\n'):
 208           obstack_grow_wstr (output, LCST ("\\n"));
 209           break;
 210         case LCST ('\r'):
 211           obstack_grow_wstr (output, LCST ("\\r"));
 212           break;
 213         case LCST ('\t'):
 214           obstack_grow_wstr (output, LCST ("\\t"));
 215           break;
 216         case LCST ('\v'):
 217           obstack_grow_wstr (output, LCST ("\\v"));
 218           break;
 219         default:
 220           {
 221             int i;
 222
 223             for (i = 0; i + width <= orig_len; i += width)
 224               {
 225                 char octal[30];
 226                 ULONGEST value;
 227                 value = extract_unsigned_integer (&orig[i], width, byte_order);
 228                 /* If the value fits in 3 octal digits, print it that
 229                    way.  Otherwise, print it as a hex escape.  */
 230                 if (value <= 0777)
 231                   sprintf (octal, "\\%.3o", (int) (value & 0777));
 232                 else
 233                   sprintf (octal, "\\x%lx", (long) value);
 234                 append_string_as_wide (octal, output);
 235               }
 236             /* If we somehow have extra bytes, print them now.  */
 237             while (i < orig_len)
 238               {
 239                 char octal[5];
 240                 sprintf (octal, "\\%.3o", orig[i] & 0xff);
 241                 append_string_as_wide (octal, output);
 242                 ++i;
 243               }
 244
 245             *need_escapep = 1;
 246           }
 247           break;
 248         }
 249     }
 250 }
 251
 252 /* Print the character C on STREAM as part of the contents of a literal
 253    string whose delimiter is QUOTER.  Note that that format for printing
 254    characters and strings is language specific. */
 255
 256 static void
 257 c_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
 258 {
 259   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 260   struct obstack wchar_buf, output;
 261   struct cleanup *cleanups;
 262   const char *encoding;
 263   gdb_byte *buf;
 264   struct wchar_iterator *iter;
 265   int need_escape = 0;
 266
 267   classify_type (type, byte_order, &encoding);
 268
 269   buf = alloca (TYPE_LENGTH (type));
 270   pack_long (buf, type, c);
 271
 272   iter = make_wchar_iterator (buf, TYPE_LENGTH (type), encoding,
 273                               TYPE_LENGTH (type));
 274   cleanups = make_cleanup_wchar_iterator (iter);
 275
 276   /* This holds the printable form of the wchar_t data.  */
 277   obstack_init (&wchar_buf);
 278   make_cleanup_obstack_free (&wchar_buf);
 279
 280   while (1)
 281     {
 282       int num_chars;
 283       gdb_wchar_t *chars;
 284       const gdb_byte *buf;
 285       size_t buflen;
 286       int print_escape = 1;
 287       enum wchar_iterate_result result;
 288
 289       num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 290       if (num_chars < 0)
 291         break;
 292       if (num_chars > 0)
 293         {
 294           /* If all characters are printable, print them.  Otherwise,
 295              we're going to have to print an escape sequence.  We
 296              check all characters because we want to print the target
 297              bytes in the escape sequence, and we don't know character
 298              boundaries there.  */
 299           int i;
 300
 301           print_escape = 0;
 302           for (i = 0; i < num_chars; ++i)
 303             if (!wchar_printable (chars[i]))
 304               {
 305                 print_escape = 1;
 306                 break;
 307               }
 308
 309           if (!print_escape)
 310             {
 311               for (i = 0; i < num_chars; ++i)
 312                 print_wchar (chars[i], buf, buflen, TYPE_LENGTH (type),
 313                              byte_order, &wchar_buf, quoter, &need_escape);
 314             }
 315         }
 316
 317       /* This handles the NUM_CHARS == 0 case as well.  */
 318       if (print_escape)
 319         print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), byte_order,
 320                      &wchar_buf, quoter, &need_escape);
 321     }
 322
 323   /* The output in the host encoding.  */
 324   obstack_init (&output);
 325   make_cleanup_obstack_free (&output);
 326
 327   convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
 328                              obstack_base (&wchar_buf),
 329                              obstack_object_size (&wchar_buf),
 330                              1, &output, translit_char);
 331   obstack_1grow (&output, '\0');
 332
 333   fputs_filtered (obstack_base (&output), stream);
 334
 335   do_cleanups (cleanups);
 336 }
 337
 338 void
 339 c_printchar (int c, struct type *type, struct ui_file *stream)
 340 {
 341   enum c_string_type str_type;
 342
 343   str_type = classify_type (type, BFD_ENDIAN_UNKNOWN, NULL);
 344   switch (str_type)
 345     {
 346     case C_CHAR:
 347       break;
 348     case C_WIDE_CHAR:
 349       fputc_filtered ('L', stream);
 350       break;
 351     case C_CHAR_16:
 352       fputc_filtered ('u', stream);
 353       break;
 354     case C_CHAR_32:
 355       fputc_filtered ('U', stream);
 356       break;
 357     }
 358
 359   fputc_filtered ('\'', stream);
 360   LA_EMIT_CHAR (c, type, stream, '\'');
 361   fputc_filtered ('\'', stream);
 362 }
 363
 364 /* Print the character string STRING, printing at most LENGTH characters.
 365    LENGTH is -1 if the string is nul terminated.  Each character is WIDTH bytes
 366    long.  Printing stops early if the number hits print_max; repeat counts are
 367    printed as appropriate.  Print ellipses at the end if we had to stop before
 368    printing LENGTH characters, or if FORCE_ELLIPSES.  */
 369
 370 void
 371 c_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
 372             unsigned int length, int force_ellipses,
 373             const struct value_print_options *options)
 374 {
 375   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 376   unsigned int i;
 377   unsigned int things_printed = 0;
 378   int in_quotes = 0;
 379   int need_comma = 0;
 380   int width = TYPE_LENGTH (type);
 381   struct obstack wchar_buf, output;
 382   struct cleanup *cleanup;
 383   enum c_string_type str_type;
 384   const char *encoding;
 385   struct wchar_iterator *iter;
 386   int finished = 0;
 387   int need_escape = 0;
 388
 389   /* If the string was not truncated due to `set print elements', and
 390      the last byte of it is a null, we don't print that, in traditional C
 391      style.  */
 392   if (!force_ellipses
 393       && length > 0
 394       && (extract_unsigned_integer (string + (length - 1) * width,
 395                                     width, byte_order) == 0))
 396     length--;
 397
 398   str_type = classify_type (type, byte_order, &encoding) & ~C_CHAR;
 399   switch (str_type)
 400     {
 401     case C_STRING:
 402       break;
 403     case C_WIDE_STRING:
 404       fputs_filtered ("L", stream);
 405       break;
 406     case C_STRING_16:
 407       fputs_filtered ("u", stream);
 408       break;
 409     case C_STRING_32:
 410       fputs_filtered ("U", stream);
 411       break;
 412     }
 413
 414   if (length == 0)
 415     {
 416       fputs_filtered ("\"\"", stream);
 417       return;
 418     }
 419
 420   if (length == -1)
 421     {
 422       unsigned long current_char = 1;
 423       for (i = 0; current_char; ++i)
 424         {
 425           QUIT;
 426           current_char = extract_unsigned_integer (string + i * width,
 427                                                    width, byte_order);
 428         }
 429       length = i;
 430     }
 431
 432   /* Arrange to iterate over the characters, in wchar_t form.  */
 433   iter = make_wchar_iterator (string, length * width, encoding, width);
 434   cleanup = make_cleanup_wchar_iterator (iter);
 435
 436   /* WCHAR_BUF is the obstack we use to represent the string in
 437      wchar_t form.  */
 438   obstack_init (&wchar_buf);
 439   make_cleanup_obstack_free (&wchar_buf);
 440
 441   while (!finished && things_printed < options->print_max)
 442     {
 443       int num_chars;
 444       enum wchar_iterate_result result;
 445       gdb_wchar_t *chars;
 446       const gdb_byte *buf;
 447       size_t buflen;
 448
 449       QUIT;
 450
 451       if (need_comma)
 452         {
 453           obstack_grow_wstr (&wchar_buf, LCST (", "));
 454           need_comma = 0;
 455         }
 456
 457       num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 458       /* We only look at repetitions when we were able to convert a
 459          single character in isolation.  This makes the code simpler
 460          and probably does the sensible thing in the majority of
 461          cases.  */
 462       while (num_chars == 1)
 463         {
 464           /* Count the number of repetitions.  */
 465           unsigned int reps = 0;
 466           gdb_wchar_t current_char = chars[0];
 467           const gdb_byte *orig_buf = buf;
 468           int orig_len = buflen;
 469
 470           if (need_comma)
 471             {
 472               obstack_grow_wstr (&wchar_buf, LCST (", "));
 473               need_comma = 0;
 474             }
 475
 476           while (num_chars == 1 && current_char == chars[0])
 477             {
 478               num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 479               ++reps;
 480             }
 481
 482           /* Emit CURRENT_CHAR according to the repetition count and
 483              options.  */
 484           if (reps > options->repeat_count_threshold)
 485             {
 486               if (in_quotes)
 487                 {
 488                   if (options->inspect_it)
 489                     obstack_grow_wstr (&wchar_buf, LCST ("\\\", "));
 490                   else
 491                     obstack_grow_wstr (&wchar_buf, LCST ("\", "));
 492                   in_quotes = 0;
 493                 }
 494               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 495               need_escape = 0;
 496               print_wchar (current_char, orig_buf, orig_len, width,
 497                            byte_order, &wchar_buf, '\'', &need_escape);
 498               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 499               {
 500                 /* Painful gyrations.  */
 501                 int j;
 502                 char *s = xstrprintf (_(" <repeats %u times>"), reps);
 503                 for (j = 0; s[j]; ++j)
 504                   {
 505                     gdb_wchar_t w = gdb_btowc (s[j]);
 506                     obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
 507                   }
 508                 xfree (s);
 509               }
 510               things_printed += options->repeat_count_threshold;
 511               need_comma = 1;
 512             }
 513           else
 514             {
 515               /* Saw the character one or more times, but fewer than
 516                  the repetition threshold.  */
 517               if (!in_quotes)
 518                 {
 519                   if (options->inspect_it)
 520                     obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 521                   else
 522                     obstack_grow_wstr (&wchar_buf, LCST ("\""));
 523                   in_quotes = 1;
 524                   need_escape = 0;
 525                 }
 526
 527               while (reps-- > 0)
 528                 {
 529                   print_wchar (current_char, orig_buf, orig_len, width,
 530                                byte_order, &wchar_buf, '"', &need_escape);
 531                   ++things_printed;
 532                 }
 533             }
 534         }
 535
 536       /* NUM_CHARS and the other outputs from wchar_iterate are valid
 537          here regardless of which branch was taken above.  */
 538       if (num_chars < 0)
 539         {
 540           /* Hit EOF.  */
 541           finished = 1;
 542           break;
 543         }
 544
 545       switch (result)
 546         {
 547         case wchar_iterate_invalid:
 548           if (!in_quotes)
 549             {
 550               if (options->inspect_it)
 551                 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 552               else
 553                 obstack_grow_wstr (&wchar_buf, LCST ("\""));
 554               in_quotes = 1;
 555             }
 556           need_escape = 0;
 557           print_wchar (gdb_WEOF, buf, buflen, width, byte_order, &wchar_buf,
 558                        '"', &need_escape);
 559           break;
 560
 561         case wchar_iterate_incomplete:
 562           if (in_quotes)
 563             {
 564               if (options->inspect_it)
 565                 obstack_grow_wstr (&wchar_buf, LCST ("\\\","));
 566               else
 567                 obstack_grow_wstr (&wchar_buf, LCST ("\","));
 568               in_quotes = 0;
 569             }
 570           obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
 571           print_wchar (gdb_WEOF, buf, buflen, width, byte_order, &wchar_buf,
 572                        0, &need_escape);
 573           obstack_grow_wstr (&wchar_buf, LCST (">"));
 574           finished = 1;
 575           break;
 576         }
 577     }
 578
 579   /* Terminate the quotes if necessary.  */
 580   if (in_quotes)
 581     {
 582       if (options->inspect_it)
 583         obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 584       else
 585         obstack_grow_wstr (&wchar_buf, LCST ("\""));
 586     }
 587
 588   if (force_ellipses || !finished)
 589     obstack_grow_wstr (&wchar_buf, LCST ("..."));
 590
 591   /* OUTPUT is where we collect `char's for printing.  */
 592   obstack_init (&output);
 593   make_cleanup_obstack_free (&output);
 594
 595   convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
 596                              obstack_base (&wchar_buf),
 597                              obstack_object_size (&wchar_buf),
 598                              1, &output, translit_char);
 599   obstack_1grow (&output, '\0');
 600
 601   fputs_filtered (obstack_base (&output), stream);
 602
 603   do_cleanups (cleanup);
 604 }
 605
 606 /* Obtain a C string from the inferior storing it in a newly allocated
 607    buffer in BUFFER, which should be freed by the caller.   If the
 608    in- and out-parameter *LENGTH is specified at -1, the string is read
 609    until a null character of the appropriate width is found, otherwise
 610    the string is read to the length of characters specified.
 611    The size of a character is determined by the length of the target
 612    type of the pointer or  array.  If VALUE is an array with a known
 613    length, the function will  not read past the end of the array.
 614    On completion, *LENGTH will be set to the size of the string read in
 615    characters.  (If a length of -1 is specified, the length returned
 616    will not include the null character).  CHARSET is always set to the
 617    target charset.  */
 618
 619 void
 620 c_get_string (struct value *value, gdb_byte **buffer, int *length,
 621               const char **charset)
 622 {
 623   int err, width;
 624   unsigned int fetchlimit;
 625   struct type *type = check_typedef (value_type (value));
 626   struct type *element_type = TYPE_TARGET_TYPE (type);
 627   int req_length = *length;
 628   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 629
 630   if (element_type == NULL)
 631     goto error;
 632
 633   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 634     {
 635       /* If we know the size of the array, we can use it as a limit on the
 636          number of characters to be fetched.  */
 637       if (TYPE_NFIELDS (type) == 1
 638           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 639         {
 640           LONGEST low_bound, high_bound;
 641
 642           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 643                                &low_bound, &high_bound);
 644           fetchlimit = high_bound - low_bound + 1;
 645         }
 646       else
 647         fetchlimit = UINT_MAX;
 648     }
 649   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 650     fetchlimit = UINT_MAX;
 651   else
 652     /* We work only with arrays and pointers.  */
 653     goto error;
 654
 655   element_type = check_typedef (element_type);
 656   if (TYPE_CODE (element_type) != TYPE_CODE_INT
 657       && TYPE_CODE (element_type) != TYPE_CODE_CHAR)
 658     /* If the elements are not integers or characters, we don't consider it
 659        a string.  */
 660     goto error;
 661
 662   width = TYPE_LENGTH (element_type);
 663
 664   /* If the string lives in GDB's memory instead of the inferior's, then we
 665      just need to copy it to BUFFER.  Also, since such strings are arrays
 666      with known size, FETCHLIMIT will hold the size of the array.  */
 667   if ((VALUE_LVAL (value) == not_lval
 668        || VALUE_LVAL (value) == lval_internalvar)
 669       && fetchlimit != UINT_MAX)
 670     {
 671       int i;
 672       const gdb_byte *contents = value_contents (value);
 673
 674       /* If a length is specified, use that.  */
 675       if (*length >= 0)
 676         i  = *length;
 677       else
 678         /* Otherwise, look for a null character.  */
 679         for (i = 0; i < fetchlimit; i++)
 680           if (extract_unsigned_integer (contents + i * width, width,
 681                                         byte_order) == 0)
 682             break;
 683
 684       /* I is now either a user-defined length, the number of non-null
 685          characters, or FETCHLIMIT.  */
 686       *length = i * width;
 687       *buffer = xmalloc (*length);
 688       memcpy (*buffer, contents, *length);
 689       err = 0;
 690     }
 691   else
 692     {
 693       err = read_string (value_as_address (value), *length, width, fetchlimit,
 694                          byte_order, buffer, length);
 695       if (err)
 696         {
 697           xfree (*buffer);
 698           error (_("Error reading string from inferior: %s"),
 699                  safe_strerror (err));
 700         }
 701     }
 702
 703   /* If the LENGTH is specified at -1, we want to return the string
 704      length up to the terminating null character.  If an actual length
 705      was specified, we want to return the length of exactly what was
 706      read.  */
 707   if (req_length == -1)
 708     /* If the last character is null, subtract it from LENGTH.  */
 709     if (*length > 0
 710         && extract_unsigned_integer (*buffer + *length - width, width,
 711                                      byte_order) == 0)
 712       *length -= width;
 713
 714   /* The read_string function will return the number of bytes read.
 715      If length returned from read_string was > 0, return the number of
 716      characters read by dividing the number of bytes by width.  */
 717   if (*length != 0)
 718      *length = *length / width;
 719
 720   *charset = target_charset ();
 721
 722   return;
 723
 724  error:
 725   {
 726     char *type_str;
 727
 728     type_str = type_to_string (type);
 729     if (type_str)
 730       {
 731         make_cleanup (xfree, type_str);
 732         error (_("Trying to read string with inappropriate type `%s'."),
 733                type_str);
 734       }
 735     else
 736       error (_("Trying to read string with inappropriate type."));
 737   }
 738 }
 739
 740 \f
 741 /* Evaluating C and C++ expressions.  */
 742
 743 /* Convert a UCN.  The digits of the UCN start at P and extend no
 744    farther than LIMIT.  DEST_CHARSET is the name of the character set
 745    into which the UCN should be converted.  The results are written to
 746    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 747    Returns a pointer to just after the final digit of the UCN.  */
 748
 749 static char *
 750 convert_ucn (char *p, char *limit, const char *dest_charset,
 751              struct obstack *output, int length)
 752 {
 753   unsigned long result = 0;
 754   gdb_byte data[4];
 755   int i;
 756
 757   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 758     result = (result << 4) + host_hex_value (*p);
 759
 760   for (i = 3; i >= 0; --i)
 761     {
 762       data[i] = result & 0xff;
 763       result >>= 8;
 764     }
 765
 766   convert_between_encodings ("UCS-4BE", dest_charset, data, 4, 4, output,
 767                              translit_none);
 768
 769   return p;
 770 }
 771
 772 /* Emit a character, VALUE, which was specified numerically, to
 773    OUTPUT.  TYPE is the target character type.  */
 774
 775 static void
 776 emit_numeric_character (struct type *type, unsigned long value,
 777                         struct obstack *output)
 778 {
 779   gdb_byte *buffer;
 780
 781   buffer = alloca (TYPE_LENGTH (type));
 782   pack_long (buffer, type, value);
 783   obstack_grow (output, buffer, TYPE_LENGTH (type));
 784 }
 785
 786 /* Convert an octal escape sequence.  TYPE is the target character
 787    type.  The digits of the escape sequence begin at P and extend no
 788    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 789    pointer to just after the final digit of the escape sequence.  */
 790
 791 static char *
 792 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
 793 {
 794   int i;
 795   unsigned long value = 0;
 796
 797   for (i = 0;
 798        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 799        ++i)
 800     {
 801       value = 8 * value + host_hex_value (*p);
 802       ++p;
 803     }
 804
 805   emit_numeric_character (type, value, output);
 806
 807   return p;
 808 }
 809
 810 /* Convert a hex escape sequence.  TYPE is the target character type.
 811    The digits of the escape sequence begin at P and extend no farther
 812    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 813    just after the final digit of the escape sequence.  */
 814
 815 static char *
 816 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
 817 {
 818   unsigned long value = 0;
 819
 820   while (p < limit && isxdigit (*p))
 821     {
 822       value = 16 * value + host_hex_value (*p);
 823       ++p;
 824     }
 825
 826   emit_numeric_character (type, value, output);
 827
 828   return p;
 829 }
 830
 831 #define ADVANCE                                 \
 832   do {                                          \
 833     ++p;                                        \
 834     if (p == limit)                             \
 835       error (_("Malformed escape sequence"));   \
 836   } while (0)
 837
 838 /* Convert an escape sequence to a target format.  TYPE is the target
 839    character type to use, and DEST_CHARSET is the name of the target
 840    character set.  The backslash of the escape sequence is at *P, and
 841    the escape sequence will not extend past LIMIT.  The results are
 842    written to OUTPUT.  Returns a pointer to just past the final
 843    character of the escape sequence.  */
 844
 845 static char *
 846 convert_escape (struct type *type, const char *dest_charset,
 847                 char *p, char *limit, struct obstack *output)
 848 {
 849   /* Skip the backslash.  */
 850   ADVANCE;
 851
 852   switch (*p)
 853     {
 854     case '\\':
 855       obstack_1grow (output, '\\');
 856       ++p;
 857       break;
 858
 859     case 'x':
 860       ADVANCE;
 861       if (!isxdigit (*p))
 862         error (_("\\x used with no following hex digits."));
 863       p = convert_hex (type, p, limit, output);
 864       break;
 865
 866     case '0':
 867     case '1':
 868     case '2':
 869     case '3':
 870     case '4':
 871     case '5':
 872     case '6':
 873     case '7':
 874       p = convert_octal (type, p, limit, output);
 875       break;
 876
 877     case 'u':
 878     case 'U':
 879       {
 880         int length = *p == 'u' ? 4 : 8;
 881         ADVANCE;
 882         if (!isxdigit (*p))
 883           error (_("\\u used with no following hex digits"));
 884         p = convert_ucn (p, limit, dest_charset, output, length);
 885       }
 886     }
 887
 888   return p;
 889 }
 890
 891 /* Given a single string from a (C-specific) OP_STRING list, convert
 892    it to a target string, handling escape sequences specially.  The
 893    output is written to OUTPUT.  DATA is the input string, which has
 894    length LEN.  DEST_CHARSET is the name of the target character set,
 895    and TYPE is the type of target character to use.  */
 896
 897 static void
 898 parse_one_string (struct obstack *output, char *data, int len,
 899                   const char *dest_charset, struct type *type)
 900 {
 901   char *limit;
 902
 903   limit = data + len;
 904
 905   while (data < limit)
 906     {
 907       char *p = data;
 908       /* Look for next escape, or the end of the input.  */
 909       while (p < limit && *p != '\\')
 910         ++p;
 911       /* If we saw a run of characters, convert them all.  */
 912       if (p > data)
 913         convert_between_encodings (host_charset (), dest_charset,
 914                                    data, p - data, 1, output, translit_none);
 915       /* If we saw an escape, convert it.  */
 916       if (p < limit)
 917         p = convert_escape (type, dest_charset, p, limit, output);
 918       data = p;
 919     }
 920 }
 921
 922 /* Expression evaluator for the C language family.  Most operations
 923    are delegated to evaluate_subexp_standard; see that function for a
 924    description of the arguments.  */
 925
 926 static struct value *
 927 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 928                    int *pos, enum noside noside)
 929 {
 930   enum exp_opcode op = exp->elts[*pos].opcode;
 931
 932   switch (op)
 933     {
 934     case OP_STRING:
 935       {
 936         int oplen, limit;
 937         struct type *type;
 938         struct obstack output;
 939         struct cleanup *cleanup;
 940         struct value *result;
 941         enum c_string_type dest_type;
 942         const char *dest_charset;
 943         enum bfd_endian byte_order;
 944
 945         obstack_init (&output);
 946         cleanup = make_cleanup_obstack_free (&output);
 947
 948         ++*pos;
 949         oplen = longest_to_int (exp->elts[*pos].longconst);
 950
 951         ++*pos;
 952         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 953         dest_type
 954           = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
 955         switch (dest_type & ~C_CHAR)
 956           {
 957           case C_STRING:
 958             type = language_string_char_type (exp->language_defn,
 959                                               exp->gdbarch);
 960             break;
 961           case C_WIDE_STRING:
 962             type = lookup_typename (exp->language_defn, exp->gdbarch,
 963                                     "wchar_t", NULL, 0);
 964             break;
 965           case C_STRING_16:
 966             type = lookup_typename (exp->language_defn, exp->gdbarch,
 967                                     "char16_t", NULL, 0);
 968             break;
 969           case C_STRING_32:
 970             type = lookup_typename (exp->language_defn, exp->gdbarch,
 971                                     "char32_t", NULL, 0);
 972             break;
 973           default:
 974             internal_error (__FILE__, __LINE__, "unhandled c_string_type");
 975           }
 976
 977         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 978         check_typedef (type);
 979
 980         byte_order = gdbarch_byte_order (exp->gdbarch);
 981         dest_charset = charset_for_string_type (dest_type, byte_order);
 982
 983         ++*pos;
 984         while (*pos < limit)
 985           {
 986             int len;
 987
 988             len = longest_to_int (exp->elts[*pos].longconst);
 989
 990             ++*pos;
 991             if (noside != EVAL_SKIP)
 992               parse_one_string (&output, &exp->elts[*pos].string, len,
 993                                 dest_charset, type);
 994             *pos += BYTES_TO_EXP_ELEM (len);
 995           }
 996
 997         /* Skip the trailing length and opcode.  */
 998         *pos += 2;
 999
1000         if (noside == EVAL_SKIP)
1001           {
1002             /* Return a dummy value of the appropriate type.  */
1003             if ((dest_type & C_CHAR) != 0)
1004               result = allocate_value (type);
1005             else
1006               result = value_cstring ("", 0, type);
1007             do_cleanups (cleanup);
1008             return result;
1009           }
1010
1011         if ((dest_type & C_CHAR) != 0)
1012           {
1013             LONGEST value;
1014
1015             if (obstack_object_size (&output) != TYPE_LENGTH (type))
1016               error (_("Could not convert character constant to target character set"));
1017             value = unpack_long (type, obstack_base (&output));
1018             result = value_from_longest (type, value);
1019           }
1020         else
1021           {
1022             int i;
1023             /* Write the terminating character.  */
1024             for (i = 0; i < TYPE_LENGTH (type); ++i)
1025               obstack_1grow (&output, 0);
1026             result = value_cstring (obstack_base (&output),
1027                                     obstack_object_size (&output),
1028                                     type);
1029           }
1030         do_cleanups (cleanup);
1031         return result;
1032       }
1033       break;
1034
1035     default:
1036       break;
1037     }
1038   return evaluate_subexp_standard (expect_type, exp, pos, noside);
1039 }
1040
1041
1042 \f
1043 /* Table mapping opcodes into strings for printing operators
1044    and precedences of the operators.  */
1045
1046 const struct op_print c_op_print_tab[] =
1047 {
1048   {",", BINOP_COMMA, PREC_COMMA, 0},
1049   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
1050   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
1051   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
1052   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
1053   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
1054   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1055   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1056   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1057   {"<=", BINOP_LEQ, PREC_ORDER, 0},
1058   {">=", BINOP_GEQ, PREC_ORDER, 0},
1059   {">", BINOP_GTR, PREC_ORDER, 0},
1060   {"<", BINOP_LESS, PREC_ORDER, 0},
1061   {">>", BINOP_RSH, PREC_SHIFT, 0},
1062   {"<<", BINOP_LSH, PREC_SHIFT, 0},
1063   {"+", BINOP_ADD, PREC_ADD, 0},
1064   {"-", BINOP_SUB, PREC_ADD, 0},
1065   {"*", BINOP_MUL, PREC_MUL, 0},
1066   {"/", BINOP_DIV, PREC_MUL, 0},
1067   {"%", BINOP_REM, PREC_MUL, 0},
1068   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1069   {"-", UNOP_NEG, PREC_PREFIX, 0},
1070   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1071   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1072   {"*", UNOP_IND, PREC_PREFIX, 0},
1073   {"&", UNOP_ADDR, PREC_PREFIX, 0},
1074   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1075   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1076   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1077   {NULL, 0, 0, 0}
1078 };
1079 \f
1080 enum c_primitive_types {
1081   c_primitive_type_int,
1082   c_primitive_type_long,
1083   c_primitive_type_short,
1084   c_primitive_type_char,
1085   c_primitive_type_float,
1086   c_primitive_type_double,
1087   c_primitive_type_void,
1088   c_primitive_type_long_long,
1089   c_primitive_type_signed_char,
1090   c_primitive_type_unsigned_char,
1091   c_primitive_type_unsigned_short,
1092   c_primitive_type_unsigned_int,
1093   c_primitive_type_unsigned_long,
1094   c_primitive_type_unsigned_long_long,
1095   c_primitive_type_long_double,
1096   c_primitive_type_complex,
1097   c_primitive_type_double_complex,
1098   c_primitive_type_decfloat,
1099   c_primitive_type_decdouble,
1100   c_primitive_type_declong,
1101   nr_c_primitive_types
1102 };
1103
1104 void
1105 c_language_arch_info (struct gdbarch *gdbarch,
1106                       struct language_arch_info *lai)
1107 {
1108   const struct builtin_type *builtin = builtin_type (gdbarch);
1109   lai->string_char_type = builtin->builtin_char;
1110   lai->primitive_type_vector
1111     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1112                               struct type *);
1113   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1114   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1115   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1116   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1117   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1118   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1119   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1120   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1121   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1122   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1123   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1124   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1125   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1126   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1127   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1128   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1129   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1130   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1131   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1132   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1133
1134   lai->bool_type_default = builtin->builtin_int;
1135 }
1136
1137 static const struct exp_descriptor exp_descriptor_c =
1138 {
1139   print_subexp_standard,
1140   operator_length_standard,
1141   op_name_standard,
1142   dump_subexp_body_standard,
1143   evaluate_subexp_c
1144 };
1145
1146 const struct language_defn c_language_defn =
1147 {
1148   "c",                          /* Language name */
1149   language_c,
1150   range_check_off,
1151   type_check_off,
1152   case_sensitive_on,
1153   array_row_major,
1154   macro_expansion_c,
1155   &exp_descriptor_c,
1156   c_parse,
1157   c_error,
1158   null_post_parser,
1159   c_printchar,                  /* Print a character constant */
1160   c_printstr,                   /* Function to print string constant */
1161   c_emit_char,                  /* Print a single char */
1162   c_print_type,                 /* Print a type using appropriate syntax */
1163   c_print_typedef,              /* Print a typedef using appropriate syntax */
1164   c_val_print,                  /* Print a value using appropriate syntax */
1165   c_value_print,                /* Print a top-level value */
1166   NULL,                         /* Language specific skip_trampoline */
1167   NULL,                         /* name_of_this */
1168   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1169   basic_lookup_transparent_type,/* lookup_transparent_type */
1170   NULL,                         /* Language specific symbol demangler */
1171   NULL,                         /* Language specific class_name_from_physname */
1172   c_op_print_tab,               /* expression operators for printing */
1173   1,                            /* c-style arrays */
1174   0,                            /* String lower bound */
1175   default_word_break_characters,
1176   default_make_symbol_completion_list,
1177   c_language_arch_info,
1178   default_print_array_index,
1179   default_pass_by_reference,
1180   c_get_string,
1181   LANG_MAGIC
1182 };
1183
1184 enum cplus_primitive_types {
1185   cplus_primitive_type_int,
1186   cplus_primitive_type_long,
1187   cplus_primitive_type_short,
1188   cplus_primitive_type_char,
1189   cplus_primitive_type_float,
1190   cplus_primitive_type_double,
1191   cplus_primitive_type_void,
1192   cplus_primitive_type_long_long,
1193   cplus_primitive_type_signed_char,
1194   cplus_primitive_type_unsigned_char,
1195   cplus_primitive_type_unsigned_short,
1196   cplus_primitive_type_unsigned_int,
1197   cplus_primitive_type_unsigned_long,
1198   cplus_primitive_type_unsigned_long_long,
1199   cplus_primitive_type_long_double,
1200   cplus_primitive_type_complex,
1201   cplus_primitive_type_double_complex,
1202   cplus_primitive_type_bool,
1203   cplus_primitive_type_decfloat,
1204   cplus_primitive_type_decdouble,
1205   cplus_primitive_type_declong,
1206   nr_cplus_primitive_types
1207 };
1208
1209 static void
1210 cplus_language_arch_info (struct gdbarch *gdbarch,
1211                           struct language_arch_info *lai)
1212 {
1213   const struct builtin_type *builtin = builtin_type (gdbarch);
1214   lai->string_char_type = builtin->builtin_char;
1215   lai->primitive_type_vector
1216     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1217                               struct type *);
1218   lai->primitive_type_vector [cplus_primitive_type_int]
1219     = builtin->builtin_int;
1220   lai->primitive_type_vector [cplus_primitive_type_long]
1221     = builtin->builtin_long;
1222   lai->primitive_type_vector [cplus_primitive_type_short]
1223     = builtin->builtin_short;
1224   lai->primitive_type_vector [cplus_primitive_type_char]
1225     = builtin->builtin_char;
1226   lai->primitive_type_vector [cplus_primitive_type_float]
1227     = builtin->builtin_float;
1228   lai->primitive_type_vector [cplus_primitive_type_double]
1229     = builtin->builtin_double;
1230   lai->primitive_type_vector [cplus_primitive_type_void]
1231     = builtin->builtin_void;
1232   lai->primitive_type_vector [cplus_primitive_type_long_long]
1233     = builtin->builtin_long_long;
1234   lai->primitive_type_vector [cplus_primitive_type_signed_char]
1235     = builtin->builtin_signed_char;
1236   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1237     = builtin->builtin_unsigned_char;
1238   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1239     = builtin->builtin_unsigned_short;
1240   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1241     = builtin->builtin_unsigned_int;
1242   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1243     = builtin->builtin_unsigned_long;
1244   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1245     = builtin->builtin_unsigned_long_long;
1246   lai->primitive_type_vector [cplus_primitive_type_long_double]
1247     = builtin->builtin_long_double;
1248   lai->primitive_type_vector [cplus_primitive_type_complex]
1249     = builtin->builtin_complex;
1250   lai->primitive_type_vector [cplus_primitive_type_double_complex]
1251     = builtin->builtin_double_complex;
1252   lai->primitive_type_vector [cplus_primitive_type_bool]
1253     = builtin->builtin_bool;
1254   lai->primitive_type_vector [cplus_primitive_type_decfloat]
1255     = builtin->builtin_decfloat;
1256   lai->primitive_type_vector [cplus_primitive_type_decdouble]
1257     = builtin->builtin_decdouble;
1258   lai->primitive_type_vector [cplus_primitive_type_declong]
1259     = builtin->builtin_declong;
1260
1261   lai->bool_type_symbol = "bool";
1262   lai->bool_type_default = builtin->builtin_bool;
1263 }
1264
1265 const struct language_defn cplus_language_defn =
1266 {
1267   "c++",                        /* Language name */
1268   language_cplus,
1269   range_check_off,
1270   type_check_off,
1271   case_sensitive_on,
1272   array_row_major,
1273   macro_expansion_c,
1274   &exp_descriptor_c,
1275   c_parse,
1276   c_error,
1277   null_post_parser,
1278   c_printchar,                  /* Print a character constant */
1279   c_printstr,                   /* Function to print string constant */
1280   c_emit_char,                  /* Print a single char */
1281   c_print_type,                 /* Print a type using appropriate syntax */
1282   c_print_typedef,              /* Print a typedef using appropriate syntax */
1283   c_val_print,                  /* Print a value using appropriate syntax */
1284   c_value_print,                /* Print a top-level value */
1285   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1286   "this",                       /* name_of_this */
1287   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1288   cp_lookup_transparent_type,   /* lookup_transparent_type */
1289   cplus_demangle,               /* Language specific symbol demangler */
1290   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
1291   c_op_print_tab,               /* expression operators for printing */
1292   1,                            /* c-style arrays */
1293   0,                            /* String lower bound */
1294   default_word_break_characters,
1295   default_make_symbol_completion_list,
1296   cplus_language_arch_info,
1297   default_print_array_index,
1298   cp_pass_by_reference,
1299   c_get_string,
1300   LANG_MAGIC
1301 };
1302
1303 const struct language_defn asm_language_defn =
1304 {
1305   "asm",                        /* Language name */
1306   language_asm,
1307   range_check_off,
1308   type_check_off,
1309   case_sensitive_on,
1310   array_row_major,
1311   macro_expansion_c,
1312   &exp_descriptor_c,
1313   c_parse,
1314   c_error,
1315   null_post_parser,
1316   c_printchar,                  /* Print a character constant */
1317   c_printstr,                   /* Function to print string constant */
1318   c_emit_char,                  /* Print a single char */
1319   c_print_type,                 /* Print a type using appropriate syntax */
1320   c_print_typedef,              /* Print a typedef using appropriate syntax */
1321   c_val_print,                  /* Print a value using appropriate syntax */
1322   c_value_print,                /* Print a top-level value */
1323   NULL,                         /* Language specific skip_trampoline */
1324   NULL,                         /* name_of_this */
1325   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1326   basic_lookup_transparent_type,/* lookup_transparent_type */
1327   NULL,                         /* Language specific symbol demangler */
1328   NULL,                         /* Language specific class_name_from_physname */
1329   c_op_print_tab,               /* expression operators for printing */
1330   1,                            /* c-style arrays */
1331   0,                            /* String lower bound */
1332   default_word_break_characters,
1333   default_make_symbol_completion_list,
1334   c_language_arch_info, /* FIXME: la_language_arch_info.  */
1335   default_print_array_index,
1336   default_pass_by_reference,
1337   c_get_string,
1338   LANG_MAGIC
1339 };
1340
1341 /* The following language_defn does not represent a real language.
1342    It just provides a minimal support a-la-C that should allow users
1343    to do some simple operations when debugging applications that use
1344    a language currently not supported by GDB.  */
1345
1346 const struct language_defn minimal_language_defn =
1347 {
1348   "minimal",                    /* Language name */
1349   language_minimal,
1350   range_check_off,
1351   type_check_off,
1352   case_sensitive_on,
1353   array_row_major,
1354   macro_expansion_c,
1355   &exp_descriptor_c,
1356   c_parse,
1357   c_error,
1358   null_post_parser,
1359   c_printchar,                  /* Print a character constant */
1360   c_printstr,                   /* Function to print string constant */
1361   c_emit_char,                  /* Print a single char */
1362   c_print_type,                 /* Print a type using appropriate syntax */
1363   c_print_typedef,              /* Print a typedef using appropriate syntax */
1364   c_val_print,                  /* Print a value using appropriate syntax */
1365   c_value_print,                /* Print a top-level value */
1366   NULL,                         /* Language specific skip_trampoline */
1367   NULL,                         /* name_of_this */
1368   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1369   basic_lookup_transparent_type,/* lookup_transparent_type */
1370   NULL,                         /* Language specific symbol demangler */
1371   NULL,                         /* Language specific class_name_from_physname */
1372   c_op_print_tab,               /* expression operators for printing */
1373   1,                            /* c-style arrays */
1374   0,                            /* String lower bound */
1375   default_word_break_characters,
1376   default_make_symbol_completion_list,
1377   c_language_arch_info,
1378   default_print_array_index,
1379   default_pass_by_reference,
1380   c_get_string,
1381   LANG_MAGIC
1382 };
1383
1384 void
1385 _initialize_c_language (void)
1386 {
1387   add_language (&c_language_defn);
1388   add_language (&cplus_language_defn);
1389   add_language (&asm_language_defn);
1390   add_language (&minimal_language_defn);
1391 }