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: UTF-16 is not always correct.  */
  56       if (byte_order == BFD_ENDIAN_BIG)
  57         return "UTF-16BE";
  58       else
  59         return "UTF-16LE";
  60     case C_STRING_32:
  61       /* FIXME: UTF-32 is not always correct.  */
  62       if (byte_order == BFD_ENDIAN_BIG)
  63         return "UTF-32BE";
  64       else
  65         return "UTF-32LE";
  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 && things_printed < options->print_max)
 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               struct type **char_type, 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   enum c_string_type kind;
 630
 631   if (element_type == NULL)
 632     goto error;
 633
 634   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 635     {
 636       /* If we know the size of the array, we can use it as a limit on the
 637          number of characters to be fetched.  */
 638       if (TYPE_NFIELDS (type) == 1
 639           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 640         {
 641           LONGEST low_bound, high_bound;
 642
 643           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 644                                &low_bound, &high_bound);
 645           fetchlimit = high_bound - low_bound + 1;
 646         }
 647       else
 648         fetchlimit = UINT_MAX;
 649     }
 650   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 651     fetchlimit = UINT_MAX;
 652   else
 653     /* We work only with arrays and pointers.  */
 654     goto error;
 655
 656   if (! c_textual_element_type (element_type, 0))
 657     goto error;
 658   kind = classify_type (element_type,
 659                         gdbarch_byte_order (get_type_arch (element_type)),
 660                         charset);
 661   width = TYPE_LENGTH (element_type);
 662
 663   /* If the string lives in GDB's memory instead of the inferior's, then we
 664      just need to copy it to BUFFER.  Also, since such strings are arrays
 665      with known size, FETCHLIMIT will hold the size of the array.  */
 666   if ((VALUE_LVAL (value) == not_lval
 667        || VALUE_LVAL (value) == lval_internalvar)
 668       && fetchlimit != UINT_MAX)
 669     {
 670       int i;
 671       const gdb_byte *contents = value_contents (value);
 672
 673       /* If a length is specified, use that.  */
 674       if (*length >= 0)
 675         i  = *length;
 676       else
 677         /* Otherwise, look for a null character.  */
 678         for (i = 0; i < fetchlimit; i++)
 679           if (extract_unsigned_integer (contents + i * width, width,
 680                                         byte_order) == 0)
 681             break;
 682
 683       /* I is now either a user-defined length, the number of non-null
 684          characters, or FETCHLIMIT.  */
 685       *length = i * width;
 686       *buffer = xmalloc (*length);
 687       memcpy (*buffer, contents, *length);
 688       err = 0;
 689     }
 690   else
 691     {
 692       err = read_string (value_as_address (value), *length, width, fetchlimit,
 693                          byte_order, buffer, length);
 694       if (err)
 695         {
 696           xfree (*buffer);
 697           error (_("Error reading string from inferior: %s"),
 698                  safe_strerror (err));
 699         }
 700     }
 701
 702   /* If the LENGTH is specified at -1, we want to return the string
 703      length up to the terminating null character.  If an actual length
 704      was specified, we want to return the length of exactly what was
 705      read.  */
 706   if (req_length == -1)
 707     /* If the last character is null, subtract it from LENGTH.  */
 708     if (*length > 0
 709         && extract_unsigned_integer (*buffer + *length - width, width,
 710                                      byte_order) == 0)
 711       *length -= width;
 712
 713   /* The read_string function will return the number of bytes read.
 714      If length returned from read_string was > 0, return the number of
 715      characters read by dividing the number of bytes by width.  */
 716   if (*length != 0)
 717      *length = *length / width;
 718
 719   *char_type = element_type;
 720
 721   return;
 722
 723  error:
 724   {
 725     char *type_str;
 726
 727     type_str = type_to_string (type);
 728     if (type_str)
 729       {
 730         make_cleanup (xfree, type_str);
 731         error (_("Trying to read string with inappropriate type `%s'."),
 732                type_str);
 733       }
 734     else
 735       error (_("Trying to read string with inappropriate type."));
 736   }
 737 }
 738
 739 \f
 740 /* Evaluating C and C++ expressions.  */
 741
 742 /* Convert a UCN.  The digits of the UCN start at P and extend no
 743    farther than LIMIT.  DEST_CHARSET is the name of the character set
 744    into which the UCN should be converted.  The results are written to
 745    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 746    Returns a pointer to just after the final digit of the UCN.  */
 747
 748 static char *
 749 convert_ucn (char *p, char *limit, const char *dest_charset,
 750              struct obstack *output, int length)
 751 {
 752   unsigned long result = 0;
 753   gdb_byte data[4];
 754   int i;
 755
 756   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 757     result = (result << 4) + host_hex_value (*p);
 758
 759   for (i = 3; i >= 0; --i)
 760     {
 761       data[i] = result & 0xff;
 762       result >>= 8;
 763     }
 764
 765   convert_between_encodings ("UTF-32BE", dest_charset, data, 4, 4, output,
 766                              translit_none);
 767
 768   return p;
 769 }
 770
 771 /* Emit a character, VALUE, which was specified numerically, to
 772    OUTPUT.  TYPE is the target character type.  */
 773
 774 static void
 775 emit_numeric_character (struct type *type, unsigned long value,
 776                         struct obstack *output)
 777 {
 778   gdb_byte *buffer;
 779
 780   buffer = alloca (TYPE_LENGTH (type));
 781   pack_long (buffer, type, value);
 782   obstack_grow (output, buffer, TYPE_LENGTH (type));
 783 }
 784
 785 /* Convert an octal escape sequence.  TYPE is the target character
 786    type.  The digits of the escape sequence begin at P and extend no
 787    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 788    pointer to just after the final digit of the escape sequence.  */
 789
 790 static char *
 791 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
 792 {
 793   int i;
 794   unsigned long value = 0;
 795
 796   for (i = 0;
 797        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 798        ++i)
 799     {
 800       value = 8 * value + host_hex_value (*p);
 801       ++p;
 802     }
 803
 804   emit_numeric_character (type, value, output);
 805
 806   return p;
 807 }
 808
 809 /* Convert a hex escape sequence.  TYPE is the target character type.
 810    The digits of the escape sequence begin at P and extend no farther
 811    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 812    just after the final digit of the escape sequence.  */
 813
 814 static char *
 815 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
 816 {
 817   unsigned long value = 0;
 818
 819   while (p < limit && isxdigit (*p))
 820     {
 821       value = 16 * value + host_hex_value (*p);
 822       ++p;
 823     }
 824
 825   emit_numeric_character (type, value, output);
 826
 827   return p;
 828 }
 829
 830 #define ADVANCE                                 \
 831   do {                                          \
 832     ++p;                                        \
 833     if (p == limit)                             \
 834       error (_("Malformed escape sequence"));   \
 835   } while (0)
 836
 837 /* Convert an escape sequence to a target format.  TYPE is the target
 838    character type to use, and DEST_CHARSET is the name of the target
 839    character set.  The backslash of the escape sequence is at *P, and
 840    the escape sequence will not extend past LIMIT.  The results are
 841    written to OUTPUT.  Returns a pointer to just past the final
 842    character of the escape sequence.  */
 843
 844 static char *
 845 convert_escape (struct type *type, const char *dest_charset,
 846                 char *p, char *limit, struct obstack *output)
 847 {
 848   /* Skip the backslash.  */
 849   ADVANCE;
 850
 851   switch (*p)
 852     {
 853     case '\\':
 854       obstack_1grow (output, '\\');
 855       ++p;
 856       break;
 857
 858     case 'x':
 859       ADVANCE;
 860       if (!isxdigit (*p))
 861         error (_("\\x used with no following hex digits."));
 862       p = convert_hex (type, p, limit, output);
 863       break;
 864
 865     case '0':
 866     case '1':
 867     case '2':
 868     case '3':
 869     case '4':
 870     case '5':
 871     case '6':
 872     case '7':
 873       p = convert_octal (type, p, limit, output);
 874       break;
 875
 876     case 'u':
 877     case 'U':
 878       {
 879         int length = *p == 'u' ? 4 : 8;
 880         ADVANCE;
 881         if (!isxdigit (*p))
 882           error (_("\\u used with no following hex digits"));
 883         p = convert_ucn (p, limit, dest_charset, output, length);
 884       }
 885     }
 886
 887   return p;
 888 }
 889
 890 /* Given a single string from a (C-specific) OP_STRING list, convert
 891    it to a target string, handling escape sequences specially.  The
 892    output is written to OUTPUT.  DATA is the input string, which has
 893    length LEN.  DEST_CHARSET is the name of the target character set,
 894    and TYPE is the type of target character to use.  */
 895
 896 static void
 897 parse_one_string (struct obstack *output, char *data, int len,
 898                   const char *dest_charset, struct type *type)
 899 {
 900   char *limit;
 901
 902   limit = data + len;
 903
 904   while (data < limit)
 905     {
 906       char *p = data;
 907       /* Look for next escape, or the end of the input.  */
 908       while (p < limit && *p != '\\')
 909         ++p;
 910       /* If we saw a run of characters, convert them all.  */
 911       if (p > data)
 912         convert_between_encodings (host_charset (), dest_charset,
 913                                    data, p - data, 1, output, translit_none);
 914       /* If we saw an escape, convert it.  */
 915       if (p < limit)
 916         p = convert_escape (type, dest_charset, p, limit, output);
 917       data = p;
 918     }
 919 }
 920
 921 /* Expression evaluator for the C language family.  Most operations
 922    are delegated to evaluate_subexp_standard; see that function for a
 923    description of the arguments.  */
 924
 925 static struct value *
 926 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 927                    int *pos, enum noside noside)
 928 {
 929   enum exp_opcode op = exp->elts[*pos].opcode;
 930
 931   switch (op)
 932     {
 933     case OP_STRING:
 934       {
 935         int oplen, limit;
 936         struct type *type;
 937         struct obstack output;
 938         struct cleanup *cleanup;
 939         struct value *result;
 940         enum c_string_type dest_type;
 941         const char *dest_charset;
 942         enum bfd_endian byte_order;
 943
 944         obstack_init (&output);
 945         cleanup = make_cleanup_obstack_free (&output);
 946
 947         ++*pos;
 948         oplen = longest_to_int (exp->elts[*pos].longconst);
 949
 950         ++*pos;
 951         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 952         dest_type
 953           = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
 954         switch (dest_type & ~C_CHAR)
 955           {
 956           case C_STRING:
 957             type = language_string_char_type (exp->language_defn,
 958                                               exp->gdbarch);
 959             break;
 960           case C_WIDE_STRING:
 961             type = lookup_typename (exp->language_defn, exp->gdbarch,
 962                                     "wchar_t", NULL, 0);
 963             break;
 964           case C_STRING_16:
 965             type = lookup_typename (exp->language_defn, exp->gdbarch,
 966                                     "char16_t", NULL, 0);
 967             break;
 968           case C_STRING_32:
 969             type = lookup_typename (exp->language_defn, exp->gdbarch,
 970                                     "char32_t", NULL, 0);
 971             break;
 972           default:
 973             internal_error (__FILE__, __LINE__, "unhandled c_string_type");
 974           }
 975
 976         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 977         check_typedef (type);
 978
 979         byte_order = gdbarch_byte_order (exp->gdbarch);
 980         dest_charset = charset_for_string_type (dest_type, byte_order);
 981
 982         ++*pos;
 983         while (*pos < limit)
 984           {
 985             int len;
 986
 987             len = longest_to_int (exp->elts[*pos].longconst);
 988
 989             ++*pos;
 990             if (noside != EVAL_SKIP)
 991               parse_one_string (&output, &exp->elts[*pos].string, len,
 992                                 dest_charset, type);
 993             *pos += BYTES_TO_EXP_ELEM (len);
 994           }
 995
 996         /* Skip the trailing length and opcode.  */
 997         *pos += 2;
 998
 999         if (noside == EVAL_SKIP)
1000           {
1001             /* Return a dummy value of the appropriate type.  */
1002             if ((dest_type & C_CHAR) != 0)
1003               result = allocate_value (type);
1004             else
1005               result = value_cstring ("", 0, type);
1006             do_cleanups (cleanup);
1007             return result;
1008           }
1009
1010         if ((dest_type & C_CHAR) != 0)
1011           {
1012             LONGEST value;
1013
1014             if (obstack_object_size (&output) != TYPE_LENGTH (type))
1015               error (_("Could not convert character constant to target character set"));
1016             value = unpack_long (type, obstack_base (&output));
1017             result = value_from_longest (type, value);
1018           }
1019         else
1020           {
1021             int i;
1022             /* Write the terminating character.  */
1023             for (i = 0; i < TYPE_LENGTH (type); ++i)
1024               obstack_1grow (&output, 0);
1025             result = value_cstring (obstack_base (&output),
1026                                     obstack_object_size (&output),
1027                                     type);
1028           }
1029         do_cleanups (cleanup);
1030         return result;
1031       }
1032       break;
1033
1034     default:
1035       break;
1036     }
1037   return evaluate_subexp_standard (expect_type, exp, pos, noside);
1038 }
1039
1040
1041 \f
1042 /* Table mapping opcodes into strings for printing operators
1043    and precedences of the operators.  */
1044
1045 const struct op_print c_op_print_tab[] =
1046 {
1047   {",", BINOP_COMMA, PREC_COMMA, 0},
1048   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
1049   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
1050   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
1051   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
1052   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
1053   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1054   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1055   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1056   {"<=", BINOP_LEQ, PREC_ORDER, 0},
1057   {">=", BINOP_GEQ, PREC_ORDER, 0},
1058   {">", BINOP_GTR, PREC_ORDER, 0},
1059   {"<", BINOP_LESS, PREC_ORDER, 0},
1060   {">>", BINOP_RSH, PREC_SHIFT, 0},
1061   {"<<", BINOP_LSH, PREC_SHIFT, 0},
1062   {"+", BINOP_ADD, PREC_ADD, 0},
1063   {"-", BINOP_SUB, PREC_ADD, 0},
1064   {"*", BINOP_MUL, PREC_MUL, 0},
1065   {"/", BINOP_DIV, PREC_MUL, 0},
1066   {"%", BINOP_REM, PREC_MUL, 0},
1067   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1068   {"-", UNOP_NEG, PREC_PREFIX, 0},
1069   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1070   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1071   {"*", UNOP_IND, PREC_PREFIX, 0},
1072   {"&", UNOP_ADDR, PREC_PREFIX, 0},
1073   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1074   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1075   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1076   {NULL, 0, 0, 0}
1077 };
1078 \f
1079 enum c_primitive_types {
1080   c_primitive_type_int,
1081   c_primitive_type_long,
1082   c_primitive_type_short,
1083   c_primitive_type_char,
1084   c_primitive_type_float,
1085   c_primitive_type_double,
1086   c_primitive_type_void,
1087   c_primitive_type_long_long,
1088   c_primitive_type_signed_char,
1089   c_primitive_type_unsigned_char,
1090   c_primitive_type_unsigned_short,
1091   c_primitive_type_unsigned_int,
1092   c_primitive_type_unsigned_long,
1093   c_primitive_type_unsigned_long_long,
1094   c_primitive_type_long_double,
1095   c_primitive_type_complex,
1096   c_primitive_type_double_complex,
1097   c_primitive_type_decfloat,
1098   c_primitive_type_decdouble,
1099   c_primitive_type_declong,
1100   nr_c_primitive_types
1101 };
1102
1103 void
1104 c_language_arch_info (struct gdbarch *gdbarch,
1105                       struct language_arch_info *lai)
1106 {
1107   const struct builtin_type *builtin = builtin_type (gdbarch);
1108   lai->string_char_type = builtin->builtin_char;
1109   lai->primitive_type_vector
1110     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1111                               struct type *);
1112   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1113   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1114   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1115   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1116   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1117   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1118   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1119   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1120   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1121   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1122   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1123   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1124   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1125   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1126   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1127   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1128   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1129   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1130   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1131   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1132
1133   lai->bool_type_default = builtin->builtin_int;
1134 }
1135
1136 static const struct exp_descriptor exp_descriptor_c =
1137 {
1138   print_subexp_standard,
1139   operator_length_standard,
1140   op_name_standard,
1141   dump_subexp_body_standard,
1142   evaluate_subexp_c
1143 };
1144
1145 const struct language_defn c_language_defn =
1146 {
1147   "c",                          /* Language name */
1148   language_c,
1149   range_check_off,
1150   type_check_off,
1151   case_sensitive_on,
1152   array_row_major,
1153   macro_expansion_c,
1154   &exp_descriptor_c,
1155   c_parse,
1156   c_error,
1157   null_post_parser,
1158   c_printchar,                  /* Print a character constant */
1159   c_printstr,                   /* Function to print string constant */
1160   c_emit_char,                  /* Print a single char */
1161   c_print_type,                 /* Print a type using appropriate syntax */
1162   c_print_typedef,              /* Print a typedef using appropriate syntax */
1163   c_val_print,                  /* Print a value using appropriate syntax */
1164   c_value_print,                /* Print a top-level value */
1165   NULL,                         /* Language specific skip_trampoline */
1166   NULL,                         /* name_of_this */
1167   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1168   basic_lookup_transparent_type,/* lookup_transparent_type */
1169   NULL,                         /* Language specific symbol demangler */
1170   NULL,                         /* Language specific class_name_from_physname */
1171   c_op_print_tab,               /* expression operators for printing */
1172   1,                            /* c-style arrays */
1173   0,                            /* String lower bound */
1174   default_word_break_characters,
1175   default_make_symbol_completion_list,
1176   c_language_arch_info,
1177   default_print_array_index,
1178   default_pass_by_reference,
1179   c_get_string,
1180   LANG_MAGIC
1181 };
1182
1183 enum cplus_primitive_types {
1184   cplus_primitive_type_int,
1185   cplus_primitive_type_long,
1186   cplus_primitive_type_short,
1187   cplus_primitive_type_char,
1188   cplus_primitive_type_float,
1189   cplus_primitive_type_double,
1190   cplus_primitive_type_void,
1191   cplus_primitive_type_long_long,
1192   cplus_primitive_type_signed_char,
1193   cplus_primitive_type_unsigned_char,
1194   cplus_primitive_type_unsigned_short,
1195   cplus_primitive_type_unsigned_int,
1196   cplus_primitive_type_unsigned_long,
1197   cplus_primitive_type_unsigned_long_long,
1198   cplus_primitive_type_long_double,
1199   cplus_primitive_type_complex,
1200   cplus_primitive_type_double_complex,
1201   cplus_primitive_type_bool,
1202   cplus_primitive_type_decfloat,
1203   cplus_primitive_type_decdouble,
1204   cplus_primitive_type_declong,
1205   nr_cplus_primitive_types
1206 };
1207
1208 static void
1209 cplus_language_arch_info (struct gdbarch *gdbarch,
1210                           struct language_arch_info *lai)
1211 {
1212   const struct builtin_type *builtin = builtin_type (gdbarch);
1213   lai->string_char_type = builtin->builtin_char;
1214   lai->primitive_type_vector
1215     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1216                               struct type *);
1217   lai->primitive_type_vector [cplus_primitive_type_int]
1218     = builtin->builtin_int;
1219   lai->primitive_type_vector [cplus_primitive_type_long]
1220     = builtin->builtin_long;
1221   lai->primitive_type_vector [cplus_primitive_type_short]
1222     = builtin->builtin_short;
1223   lai->primitive_type_vector [cplus_primitive_type_char]
1224     = builtin->builtin_char;
1225   lai->primitive_type_vector [cplus_primitive_type_float]
1226     = builtin->builtin_float;
1227   lai->primitive_type_vector [cplus_primitive_type_double]
1228     = builtin->builtin_double;
1229   lai->primitive_type_vector [cplus_primitive_type_void]
1230     = builtin->builtin_void;
1231   lai->primitive_type_vector [cplus_primitive_type_long_long]
1232     = builtin->builtin_long_long;
1233   lai->primitive_type_vector [cplus_primitive_type_signed_char]
1234     = builtin->builtin_signed_char;
1235   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1236     = builtin->builtin_unsigned_char;
1237   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1238     = builtin->builtin_unsigned_short;
1239   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1240     = builtin->builtin_unsigned_int;
1241   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1242     = builtin->builtin_unsigned_long;
1243   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1244     = builtin->builtin_unsigned_long_long;
1245   lai->primitive_type_vector [cplus_primitive_type_long_double]
1246     = builtin->builtin_long_double;
1247   lai->primitive_type_vector [cplus_primitive_type_complex]
1248     = builtin->builtin_complex;
1249   lai->primitive_type_vector [cplus_primitive_type_double_complex]
1250     = builtin->builtin_double_complex;
1251   lai->primitive_type_vector [cplus_primitive_type_bool]
1252     = builtin->builtin_bool;
1253   lai->primitive_type_vector [cplus_primitive_type_decfloat]
1254     = builtin->builtin_decfloat;
1255   lai->primitive_type_vector [cplus_primitive_type_decdouble]
1256     = builtin->builtin_decdouble;
1257   lai->primitive_type_vector [cplus_primitive_type_declong]
1258     = builtin->builtin_declong;
1259
1260   lai->bool_type_symbol = "bool";
1261   lai->bool_type_default = builtin->builtin_bool;
1262 }
1263
1264 const struct language_defn cplus_language_defn =
1265 {
1266   "c++",                        /* Language name */
1267   language_cplus,
1268   range_check_off,
1269   type_check_off,
1270   case_sensitive_on,
1271   array_row_major,
1272   macro_expansion_c,
1273   &exp_descriptor_c,
1274   c_parse,
1275   c_error,
1276   null_post_parser,
1277   c_printchar,                  /* Print a character constant */
1278   c_printstr,                   /* Function to print string constant */
1279   c_emit_char,                  /* Print a single char */
1280   c_print_type,                 /* Print a type using appropriate syntax */
1281   c_print_typedef,              /* Print a typedef using appropriate syntax */
1282   c_val_print,                  /* Print a value using appropriate syntax */
1283   c_value_print,                /* Print a top-level value */
1284   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1285   "this",                       /* name_of_this */
1286   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1287   cp_lookup_transparent_type,   /* lookup_transparent_type */
1288   cplus_demangle,               /* Language specific symbol demangler */
1289   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
1290   c_op_print_tab,               /* expression operators for printing */
1291   1,                            /* c-style arrays */
1292   0,                            /* String lower bound */
1293   default_word_break_characters,
1294   default_make_symbol_completion_list,
1295   cplus_language_arch_info,
1296   default_print_array_index,
1297   cp_pass_by_reference,
1298   c_get_string,
1299   LANG_MAGIC
1300 };
1301
1302 const struct language_defn asm_language_defn =
1303 {
1304   "asm",                        /* Language name */
1305   language_asm,
1306   range_check_off,
1307   type_check_off,
1308   case_sensitive_on,
1309   array_row_major,
1310   macro_expansion_c,
1311   &exp_descriptor_c,
1312   c_parse,
1313   c_error,
1314   null_post_parser,
1315   c_printchar,                  /* Print a character constant */
1316   c_printstr,                   /* Function to print string constant */
1317   c_emit_char,                  /* Print a single char */
1318   c_print_type,                 /* Print a type using appropriate syntax */
1319   c_print_typedef,              /* Print a typedef using appropriate syntax */
1320   c_val_print,                  /* Print a value using appropriate syntax */
1321   c_value_print,                /* Print a top-level value */
1322   NULL,                         /* Language specific skip_trampoline */
1323   NULL,                         /* name_of_this */
1324   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1325   basic_lookup_transparent_type,/* lookup_transparent_type */
1326   NULL,                         /* Language specific symbol demangler */
1327   NULL,                         /* Language specific class_name_from_physname */
1328   c_op_print_tab,               /* expression operators for printing */
1329   1,                            /* c-style arrays */
1330   0,                            /* String lower bound */
1331   default_word_break_characters,
1332   default_make_symbol_completion_list,
1333   c_language_arch_info, /* FIXME: la_language_arch_info.  */
1334   default_print_array_index,
1335   default_pass_by_reference,
1336   c_get_string,
1337   LANG_MAGIC
1338 };
1339
1340 /* The following language_defn does not represent a real language.
1341    It just provides a minimal support a-la-C that should allow users
1342    to do some simple operations when debugging applications that use
1343    a language currently not supported by GDB.  */
1344
1345 const struct language_defn minimal_language_defn =
1346 {
1347   "minimal",                    /* Language name */
1348   language_minimal,
1349   range_check_off,
1350   type_check_off,
1351   case_sensitive_on,
1352   array_row_major,
1353   macro_expansion_c,
1354   &exp_descriptor_c,
1355   c_parse,
1356   c_error,
1357   null_post_parser,
1358   c_printchar,                  /* Print a character constant */
1359   c_printstr,                   /* Function to print string constant */
1360   c_emit_char,                  /* Print a single char */
1361   c_print_type,                 /* Print a type using appropriate syntax */
1362   c_print_typedef,              /* Print a typedef using appropriate syntax */
1363   c_val_print,                  /* Print a value using appropriate syntax */
1364   c_value_print,                /* Print a top-level value */
1365   NULL,                         /* Language specific skip_trampoline */
1366   NULL,                         /* name_of_this */
1367   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1368   basic_lookup_transparent_type,/* lookup_transparent_type */
1369   NULL,                         /* Language specific symbol demangler */
1370   NULL,                         /* Language specific class_name_from_physname */
1371   c_op_print_tab,               /* expression operators for printing */
1372   1,                            /* c-style arrays */
1373   0,                            /* String lower bound */
1374   default_word_break_characters,
1375   default_make_symbol_completion_list,
1376   c_language_arch_info,
1377   default_print_array_index,
1378   default_pass_by_reference,
1379   c_get_string,
1380   LANG_MAGIC
1381 };
1382
1383 void
1384 _initialize_c_language (void)
1385 {
1386   add_language (&c_language_defn);
1387   add_language (&cplus_language_defn);
1388   add_language (&asm_language_defn);
1389   add_language (&minimal_language_defn);
1390 }