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, 2010 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, const char *user_encoding, 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 *type_encoding;
 385   const char *encoding;
 386   struct wchar_iterator *iter;
 387   int finished = 0;
 388   int need_escape = 0;
 389
 390   /* If the string was not truncated due to `set print elements', and
 391      the last byte of it is a null, we don't print that, in traditional C
 392      style.  */
 393   if (!force_ellipses
 394       && length > 0
 395       && (extract_unsigned_integer (string + (length - 1) * width,
 396                                     width, byte_order) == 0))
 397     length--;
 398
 399   str_type = classify_type (type, byte_order, &type_encoding) & ~C_CHAR;
 400   switch (str_type)
 401     {
 402     case C_STRING:
 403       break;
 404     case C_WIDE_STRING:
 405       fputs_filtered ("L", stream);
 406       break;
 407     case C_STRING_16:
 408       fputs_filtered ("u", stream);
 409       break;
 410     case C_STRING_32:
 411       fputs_filtered ("U", stream);
 412       break;
 413     }
 414
 415   encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
 416
 417   if (length == 0)
 418     {
 419       fputs_filtered ("\"\"", stream);
 420       return;
 421     }
 422
 423   if (length == -1)
 424     {
 425       unsigned long current_char = 1;
 426       for (i = 0; current_char; ++i)
 427         {
 428           QUIT;
 429           current_char = extract_unsigned_integer (string + i * width,
 430                                                    width, byte_order);
 431         }
 432       length = i;
 433     }
 434
 435   /* Arrange to iterate over the characters, in wchar_t form.  */
 436   iter = make_wchar_iterator (string, length * width, encoding, width);
 437   cleanup = make_cleanup_wchar_iterator (iter);
 438
 439   /* WCHAR_BUF is the obstack we use to represent the string in
 440      wchar_t form.  */
 441   obstack_init (&wchar_buf);
 442   make_cleanup_obstack_free (&wchar_buf);
 443
 444   while (!finished && things_printed < options->print_max)
 445     {
 446       int num_chars;
 447       enum wchar_iterate_result result;
 448       gdb_wchar_t *chars;
 449       const gdb_byte *buf;
 450       size_t buflen;
 451
 452       QUIT;
 453
 454       if (need_comma)
 455         {
 456           obstack_grow_wstr (&wchar_buf, LCST (", "));
 457           need_comma = 0;
 458         }
 459
 460       num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 461       /* We only look at repetitions when we were able to convert a
 462          single character in isolation.  This makes the code simpler
 463          and probably does the sensible thing in the majority of
 464          cases.  */
 465       while (num_chars == 1 && things_printed < options->print_max)
 466         {
 467           /* Count the number of repetitions.  */
 468           unsigned int reps = 0;
 469           gdb_wchar_t current_char = chars[0];
 470           const gdb_byte *orig_buf = buf;
 471           int orig_len = buflen;
 472
 473           if (need_comma)
 474             {
 475               obstack_grow_wstr (&wchar_buf, LCST (", "));
 476               need_comma = 0;
 477             }
 478
 479           while (num_chars == 1 && current_char == chars[0])
 480             {
 481               num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
 482               ++reps;
 483             }
 484
 485           /* Emit CURRENT_CHAR according to the repetition count and
 486              options.  */
 487           if (reps > options->repeat_count_threshold)
 488             {
 489               if (in_quotes)
 490                 {
 491                   if (options->inspect_it)
 492                     obstack_grow_wstr (&wchar_buf, LCST ("\\\", "));
 493                   else
 494                     obstack_grow_wstr (&wchar_buf, LCST ("\", "));
 495                   in_quotes = 0;
 496                 }
 497               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 498               need_escape = 0;
 499               print_wchar (current_char, orig_buf, orig_len, width,
 500                            byte_order, &wchar_buf, '\'', &need_escape);
 501               obstack_grow_wstr (&wchar_buf, LCST ("'"));
 502               {
 503                 /* Painful gyrations.  */
 504                 int j;
 505                 char *s = xstrprintf (_(" <repeats %u times>"), reps);
 506                 for (j = 0; s[j]; ++j)
 507                   {
 508                     gdb_wchar_t w = gdb_btowc (s[j]);
 509                     obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
 510                   }
 511                 xfree (s);
 512               }
 513               things_printed += options->repeat_count_threshold;
 514               need_comma = 1;
 515             }
 516           else
 517             {
 518               /* Saw the character one or more times, but fewer than
 519                  the repetition threshold.  */
 520               if (!in_quotes)
 521                 {
 522                   if (options->inspect_it)
 523                     obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 524                   else
 525                     obstack_grow_wstr (&wchar_buf, LCST ("\""));
 526                   in_quotes = 1;
 527                   need_escape = 0;
 528                 }
 529
 530               while (reps-- > 0)
 531                 {
 532                   print_wchar (current_char, orig_buf, orig_len, width,
 533                                byte_order, &wchar_buf, '"', &need_escape);
 534                   ++things_printed;
 535                 }
 536             }
 537         }
 538
 539       /* NUM_CHARS and the other outputs from wchar_iterate are valid
 540          here regardless of which branch was taken above.  */
 541       if (num_chars < 0)
 542         {
 543           /* Hit EOF.  */
 544           finished = 1;
 545           break;
 546         }
 547
 548       switch (result)
 549         {
 550         case wchar_iterate_invalid:
 551           if (!in_quotes)
 552             {
 553               if (options->inspect_it)
 554                 obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 555               else
 556                 obstack_grow_wstr (&wchar_buf, LCST ("\""));
 557               in_quotes = 1;
 558             }
 559           need_escape = 0;
 560           print_wchar (gdb_WEOF, buf, buflen, width, byte_order, &wchar_buf,
 561                        '"', &need_escape);
 562           break;
 563
 564         case wchar_iterate_incomplete:
 565           if (in_quotes)
 566             {
 567               if (options->inspect_it)
 568                 obstack_grow_wstr (&wchar_buf, LCST ("\\\","));
 569               else
 570                 obstack_grow_wstr (&wchar_buf, LCST ("\","));
 571               in_quotes = 0;
 572             }
 573           obstack_grow_wstr (&wchar_buf, LCST (" <incomplete sequence "));
 574           print_wchar (gdb_WEOF, buf, buflen, width, byte_order, &wchar_buf,
 575                        0, &need_escape);
 576           obstack_grow_wstr (&wchar_buf, LCST (">"));
 577           finished = 1;
 578           break;
 579         }
 580     }
 581
 582   /* Terminate the quotes if necessary.  */
 583   if (in_quotes)
 584     {
 585       if (options->inspect_it)
 586         obstack_grow_wstr (&wchar_buf, LCST ("\\\""));
 587       else
 588         obstack_grow_wstr (&wchar_buf, LCST ("\""));
 589     }
 590
 591   if (force_ellipses || !finished)
 592     obstack_grow_wstr (&wchar_buf, LCST ("..."));
 593
 594   /* OUTPUT is where we collect `char's for printing.  */
 595   obstack_init (&output);
 596   make_cleanup_obstack_free (&output);
 597
 598   convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
 599                              obstack_base (&wchar_buf),
 600                              obstack_object_size (&wchar_buf),
 601                              1, &output, translit_char);
 602   obstack_1grow (&output, '\0');
 603
 604   fputs_filtered (obstack_base (&output), stream);
 605
 606   do_cleanups (cleanup);
 607 }
 608
 609 /* Obtain a C string from the inferior storing it in a newly allocated
 610    buffer in BUFFER, which should be freed by the caller.   If the
 611    in- and out-parameter *LENGTH is specified at -1, the string is read
 612    until a null character of the appropriate width is found, otherwise
 613    the string is read to the length of characters specified.
 614    The size of a character is determined by the length of the target
 615    type of the pointer or  array.  If VALUE is an array with a known
 616    length, the function will  not read past the end of the array.
 617    On completion, *LENGTH will be set to the size of the string read in
 618    characters.  (If a length of -1 is specified, the length returned
 619    will not include the null character).  CHARSET is always set to the
 620    target charset.  */
 621
 622 void
 623 c_get_string (struct value *value, gdb_byte **buffer, int *length,
 624               struct type **char_type, const char **charset)
 625 {
 626   int err, width;
 627   unsigned int fetchlimit;
 628   struct type *type = check_typedef (value_type (value));
 629   struct type *element_type = TYPE_TARGET_TYPE (type);
 630   int req_length = *length;
 631   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 632   enum c_string_type kind;
 633
 634   if (element_type == NULL)
 635     goto error;
 636
 637   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 638     {
 639       /* If we know the size of the array, we can use it as a limit on the
 640          number of characters to be fetched.  */
 641       if (TYPE_NFIELDS (type) == 1
 642           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 643         {
 644           LONGEST low_bound, high_bound;
 645
 646           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 647                                &low_bound, &high_bound);
 648           fetchlimit = high_bound - low_bound + 1;
 649         }
 650       else
 651         fetchlimit = UINT_MAX;
 652     }
 653   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 654     fetchlimit = UINT_MAX;
 655   else
 656     /* We work only with arrays and pointers.  */
 657     goto error;
 658
 659   if (! c_textual_element_type (element_type, 0))
 660     goto error;
 661   kind = classify_type (element_type,
 662                         gdbarch_byte_order (get_type_arch (element_type)),
 663                         charset);
 664   width = TYPE_LENGTH (element_type);
 665
 666   /* If the string lives in GDB's memory instead of the inferior's, then we
 667      just need to copy it to BUFFER.  Also, since such strings are arrays
 668      with known size, FETCHLIMIT will hold the size of the array.  */
 669   if ((VALUE_LVAL (value) == not_lval
 670        || VALUE_LVAL (value) == lval_internalvar)
 671       && fetchlimit != UINT_MAX)
 672     {
 673       int i;
 674       const gdb_byte *contents = value_contents (value);
 675
 676       /* If a length is specified, use that.  */
 677       if (*length >= 0)
 678         i  = *length;
 679       else
 680         /* Otherwise, look for a null character.  */
 681         for (i = 0; i < fetchlimit; i++)
 682           if (extract_unsigned_integer (contents + i * width, width,
 683                                         byte_order) == 0)
 684             break;
 685
 686       /* I is now either a user-defined length, the number of non-null
 687          characters, or FETCHLIMIT.  */
 688       *length = i * width;
 689       *buffer = xmalloc (*length);
 690       memcpy (*buffer, contents, *length);
 691       err = 0;
 692     }
 693   else
 694     {
 695       err = read_string (value_as_address (value), *length, width, fetchlimit,
 696                          byte_order, buffer, length);
 697       if (err)
 698         {
 699           xfree (*buffer);
 700           error (_("Error reading string from inferior: %s"),
 701                  safe_strerror (err));
 702         }
 703     }
 704
 705   /* If the LENGTH is specified at -1, we want to return the string
 706      length up to the terminating null character.  If an actual length
 707      was specified, we want to return the length of exactly what was
 708      read.  */
 709   if (req_length == -1)
 710     /* If the last character is null, subtract it from LENGTH.  */
 711     if (*length > 0
 712         && extract_unsigned_integer (*buffer + *length - width, width,
 713                                      byte_order) == 0)
 714       *length -= width;
 715
 716   /* The read_string function will return the number of bytes read.
 717      If length returned from read_string was > 0, return the number of
 718      characters read by dividing the number of bytes by width.  */
 719   if (*length != 0)
 720      *length = *length / width;
 721
 722   *char_type = element_type;
 723
 724   return;
 725
 726  error:
 727   {
 728     char *type_str;
 729
 730     type_str = type_to_string (type);
 731     if (type_str)
 732       {
 733         make_cleanup (xfree, type_str);
 734         error (_("Trying to read string with inappropriate type `%s'."),
 735                type_str);
 736       }
 737     else
 738       error (_("Trying to read string with inappropriate type."));
 739   }
 740 }
 741
 742 \f
 743 /* Evaluating C and C++ expressions.  */
 744
 745 /* Convert a UCN.  The digits of the UCN start at P and extend no
 746    farther than LIMIT.  DEST_CHARSET is the name of the character set
 747    into which the UCN should be converted.  The results are written to
 748    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 749    Returns a pointer to just after the final digit of the UCN.  */
 750
 751 static char *
 752 convert_ucn (char *p, char *limit, const char *dest_charset,
 753              struct obstack *output, int length)
 754 {
 755   unsigned long result = 0;
 756   gdb_byte data[4];
 757   int i;
 758
 759   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 760     result = (result << 4) + host_hex_value (*p);
 761
 762   for (i = 3; i >= 0; --i)
 763     {
 764       data[i] = result & 0xff;
 765       result >>= 8;
 766     }
 767
 768   convert_between_encodings ("UTF-32BE", dest_charset, data, 4, 4, output,
 769                              translit_none);
 770
 771   return p;
 772 }
 773
 774 /* Emit a character, VALUE, which was specified numerically, to
 775    OUTPUT.  TYPE is the target character type.  */
 776
 777 static void
 778 emit_numeric_character (struct type *type, unsigned long value,
 779                         struct obstack *output)
 780 {
 781   gdb_byte *buffer;
 782
 783   buffer = alloca (TYPE_LENGTH (type));
 784   pack_long (buffer, type, value);
 785   obstack_grow (output, buffer, TYPE_LENGTH (type));
 786 }
 787
 788 /* Convert an octal escape sequence.  TYPE is the target character
 789    type.  The digits of the escape sequence begin at P and extend no
 790    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 791    pointer to just after the final digit of the escape sequence.  */
 792
 793 static char *
 794 convert_octal (struct type *type, char *p, char *limit, struct obstack *output)
 795 {
 796   int i;
 797   unsigned long value = 0;
 798
 799   for (i = 0;
 800        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 801        ++i)
 802     {
 803       value = 8 * value + host_hex_value (*p);
 804       ++p;
 805     }
 806
 807   emit_numeric_character (type, value, output);
 808
 809   return p;
 810 }
 811
 812 /* Convert a hex escape sequence.  TYPE is the target character type.
 813    The digits of the escape sequence begin at P and extend no farther
 814    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 815    just after the final digit of the escape sequence.  */
 816
 817 static char *
 818 convert_hex (struct type *type, char *p, char *limit, struct obstack *output)
 819 {
 820   unsigned long value = 0;
 821
 822   while (p < limit && isxdigit (*p))
 823     {
 824       value = 16 * value + host_hex_value (*p);
 825       ++p;
 826     }
 827
 828   emit_numeric_character (type, value, output);
 829
 830   return p;
 831 }
 832
 833 #define ADVANCE                                 \
 834   do {                                          \
 835     ++p;                                        \
 836     if (p == limit)                             \
 837       error (_("Malformed escape sequence"));   \
 838   } while (0)
 839
 840 /* Convert an escape sequence to a target format.  TYPE is the target
 841    character type to use, and DEST_CHARSET is the name of the target
 842    character set.  The backslash of the escape sequence is at *P, and
 843    the escape sequence will not extend past LIMIT.  The results are
 844    written to OUTPUT.  Returns a pointer to just past the final
 845    character of the escape sequence.  */
 846
 847 static char *
 848 convert_escape (struct type *type, const char *dest_charset,
 849                 char *p, char *limit, struct obstack *output)
 850 {
 851   /* Skip the backslash.  */
 852   ADVANCE;
 853
 854   switch (*p)
 855     {
 856     case '\\':
 857       obstack_1grow (output, '\\');
 858       ++p;
 859       break;
 860
 861     case 'x':
 862       ADVANCE;
 863       if (!isxdigit (*p))
 864         error (_("\\x used with no following hex digits."));
 865       p = convert_hex (type, p, limit, output);
 866       break;
 867
 868     case '0':
 869     case '1':
 870     case '2':
 871     case '3':
 872     case '4':
 873     case '5':
 874     case '6':
 875     case '7':
 876       p = convert_octal (type, p, limit, output);
 877       break;
 878
 879     case 'u':
 880     case 'U':
 881       {
 882         int length = *p == 'u' ? 4 : 8;
 883         ADVANCE;
 884         if (!isxdigit (*p))
 885           error (_("\\u used with no following hex digits"));
 886         p = convert_ucn (p, limit, dest_charset, output, length);
 887       }
 888     }
 889
 890   return p;
 891 }
 892
 893 /* Given a single string from a (C-specific) OP_STRING list, convert
 894    it to a target string, handling escape sequences specially.  The
 895    output is written to OUTPUT.  DATA is the input string, which has
 896    length LEN.  DEST_CHARSET is the name of the target character set,
 897    and TYPE is the type of target character to use.  */
 898
 899 static void
 900 parse_one_string (struct obstack *output, char *data, int len,
 901                   const char *dest_charset, struct type *type)
 902 {
 903   char *limit;
 904
 905   limit = data + len;
 906
 907   while (data < limit)
 908     {
 909       char *p = data;
 910       /* Look for next escape, or the end of the input.  */
 911       while (p < limit && *p != '\\')
 912         ++p;
 913       /* If we saw a run of characters, convert them all.  */
 914       if (p > data)
 915         convert_between_encodings (host_charset (), dest_charset,
 916                                    data, p - data, 1, output, translit_none);
 917       /* If we saw an escape, convert it.  */
 918       if (p < limit)
 919         p = convert_escape (type, dest_charset, p, limit, output);
 920       data = p;
 921     }
 922 }
 923
 924 /* Expression evaluator for the C language family.  Most operations
 925    are delegated to evaluate_subexp_standard; see that function for a
 926    description of the arguments.  */
 927
 928 static struct value *
 929 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 930                    int *pos, enum noside noside)
 931 {
 932   enum exp_opcode op = exp->elts[*pos].opcode;
 933
 934   switch (op)
 935     {
 936     case OP_STRING:
 937       {
 938         int oplen, limit;
 939         struct type *type;
 940         struct obstack output;
 941         struct cleanup *cleanup;
 942         struct value *result;
 943         enum c_string_type dest_type;
 944         const char *dest_charset;
 945         enum bfd_endian byte_order;
 946
 947         obstack_init (&output);
 948         cleanup = make_cleanup_obstack_free (&output);
 949
 950         ++*pos;
 951         oplen = longest_to_int (exp->elts[*pos].longconst);
 952
 953         ++*pos;
 954         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 955         dest_type
 956           = (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
 957         switch (dest_type & ~C_CHAR)
 958           {
 959           case C_STRING:
 960             type = language_string_char_type (exp->language_defn,
 961                                               exp->gdbarch);
 962             break;
 963           case C_WIDE_STRING:
 964             type = lookup_typename (exp->language_defn, exp->gdbarch,
 965                                     "wchar_t", NULL, 0);
 966             break;
 967           case C_STRING_16:
 968             type = lookup_typename (exp->language_defn, exp->gdbarch,
 969                                     "char16_t", NULL, 0);
 970             break;
 971           case C_STRING_32:
 972             type = lookup_typename (exp->language_defn, exp->gdbarch,
 973                                     "char32_t", NULL, 0);
 974             break;
 975           default:
 976             internal_error (__FILE__, __LINE__, "unhandled c_string_type");
 977           }
 978
 979         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 980         check_typedef (type);
 981
 982         byte_order = gdbarch_byte_order (exp->gdbarch);
 983         dest_charset = charset_for_string_type (dest_type, byte_order);
 984
 985         ++*pos;
 986         while (*pos < limit)
 987           {
 988             int len;
 989
 990             len = longest_to_int (exp->elts[*pos].longconst);
 991
 992             ++*pos;
 993             if (noside != EVAL_SKIP)
 994               parse_one_string (&output, &exp->elts[*pos].string, len,
 995                                 dest_charset, type);
 996             *pos += BYTES_TO_EXP_ELEM (len);
 997           }
 998
 999         /* Skip the trailing length and opcode.  */
1000         *pos += 2;
1001
1002         if (noside == EVAL_SKIP)
1003           {
1004             /* Return a dummy value of the appropriate type.  */
1005             if ((dest_type & C_CHAR) != 0)
1006               result = allocate_value (type);
1007             else
1008               result = value_cstring ("", 0, type);
1009             do_cleanups (cleanup);
1010             return result;
1011           }
1012
1013         if ((dest_type & C_CHAR) != 0)
1014           {
1015             LONGEST value;
1016
1017             if (obstack_object_size (&output) != TYPE_LENGTH (type))
1018               error (_("Could not convert character constant to target character set"));
1019             value = unpack_long (type, obstack_base (&output));
1020             result = value_from_longest (type, value);
1021           }
1022         else
1023           {
1024             int i;
1025             /* Write the terminating character.  */
1026             for (i = 0; i < TYPE_LENGTH (type); ++i)
1027               obstack_1grow (&output, 0);
1028             result = value_cstring (obstack_base (&output),
1029                                     obstack_object_size (&output),
1030                                     type);
1031           }
1032         do_cleanups (cleanup);
1033         return result;
1034       }
1035       break;
1036
1037     default:
1038       break;
1039     }
1040   return evaluate_subexp_standard (expect_type, exp, pos, noside);
1041 }
1042
1043
1044 \f
1045 /* Table mapping opcodes into strings for printing operators
1046    and precedences of the operators.  */
1047
1048 const struct op_print c_op_print_tab[] =
1049 {
1050   {",", BINOP_COMMA, PREC_COMMA, 0},
1051   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
1052   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
1053   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
1054   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
1055   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
1056   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1057   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1058   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1059   {"<=", BINOP_LEQ, PREC_ORDER, 0},
1060   {">=", BINOP_GEQ, PREC_ORDER, 0},
1061   {">", BINOP_GTR, PREC_ORDER, 0},
1062   {"<", BINOP_LESS, PREC_ORDER, 0},
1063   {">>", BINOP_RSH, PREC_SHIFT, 0},
1064   {"<<", BINOP_LSH, PREC_SHIFT, 0},
1065   {"+", BINOP_ADD, PREC_ADD, 0},
1066   {"-", BINOP_SUB, PREC_ADD, 0},
1067   {"*", BINOP_MUL, PREC_MUL, 0},
1068   {"/", BINOP_DIV, PREC_MUL, 0},
1069   {"%", BINOP_REM, PREC_MUL, 0},
1070   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1071   {"-", UNOP_NEG, PREC_PREFIX, 0},
1072   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1073   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1074   {"*", UNOP_IND, PREC_PREFIX, 0},
1075   {"&", UNOP_ADDR, PREC_PREFIX, 0},
1076   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1077   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1078   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1079   {NULL, 0, 0, 0}
1080 };
1081 \f
1082 enum c_primitive_types {
1083   c_primitive_type_int,
1084   c_primitive_type_long,
1085   c_primitive_type_short,
1086   c_primitive_type_char,
1087   c_primitive_type_float,
1088   c_primitive_type_double,
1089   c_primitive_type_void,
1090   c_primitive_type_long_long,
1091   c_primitive_type_signed_char,
1092   c_primitive_type_unsigned_char,
1093   c_primitive_type_unsigned_short,
1094   c_primitive_type_unsigned_int,
1095   c_primitive_type_unsigned_long,
1096   c_primitive_type_unsigned_long_long,
1097   c_primitive_type_long_double,
1098   c_primitive_type_complex,
1099   c_primitive_type_double_complex,
1100   c_primitive_type_decfloat,
1101   c_primitive_type_decdouble,
1102   c_primitive_type_declong,
1103   nr_c_primitive_types
1104 };
1105
1106 void
1107 c_language_arch_info (struct gdbarch *gdbarch,
1108                       struct language_arch_info *lai)
1109 {
1110   const struct builtin_type *builtin = builtin_type (gdbarch);
1111   lai->string_char_type = builtin->builtin_char;
1112   lai->primitive_type_vector
1113     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
1114                               struct type *);
1115   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
1116   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
1117   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
1118   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
1119   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
1120   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
1121   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
1122   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
1123   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
1124   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
1125   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
1126   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
1127   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
1128   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
1129   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
1130   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
1131   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
1132   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
1133   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
1134   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
1135
1136   lai->bool_type_default = builtin->builtin_int;
1137 }
1138
1139 static const struct exp_descriptor exp_descriptor_c =
1140 {
1141   print_subexp_standard,
1142   operator_length_standard,
1143   op_name_standard,
1144   dump_subexp_body_standard,
1145   evaluate_subexp_c
1146 };
1147
1148 const struct language_defn c_language_defn =
1149 {
1150   "c",                          /* Language name */
1151   language_c,
1152   range_check_off,
1153   type_check_off,
1154   case_sensitive_on,
1155   array_row_major,
1156   macro_expansion_c,
1157   &exp_descriptor_c,
1158   c_parse,
1159   c_error,
1160   null_post_parser,
1161   c_printchar,                  /* Print a character constant */
1162   c_printstr,                   /* Function to print string constant */
1163   c_emit_char,                  /* Print a single char */
1164   c_print_type,                 /* Print a type using appropriate syntax */
1165   c_print_typedef,              /* Print a typedef using appropriate syntax */
1166   c_val_print,                  /* Print a value using appropriate syntax */
1167   c_value_print,                /* Print a top-level value */
1168   NULL,                         /* Language specific skip_trampoline */
1169   NULL,                         /* name_of_this */
1170   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1171   basic_lookup_transparent_type,/* lookup_transparent_type */
1172   NULL,                         /* Language specific symbol demangler */
1173   NULL,                         /* Language specific class_name_from_physname */
1174   c_op_print_tab,               /* expression operators for printing */
1175   1,                            /* c-style arrays */
1176   0,                            /* String lower bound */
1177   default_word_break_characters,
1178   default_make_symbol_completion_list,
1179   c_language_arch_info,
1180   default_print_array_index,
1181   default_pass_by_reference,
1182   c_get_string,
1183   LANG_MAGIC
1184 };
1185
1186 enum cplus_primitive_types {
1187   cplus_primitive_type_int,
1188   cplus_primitive_type_long,
1189   cplus_primitive_type_short,
1190   cplus_primitive_type_char,
1191   cplus_primitive_type_float,
1192   cplus_primitive_type_double,
1193   cplus_primitive_type_void,
1194   cplus_primitive_type_long_long,
1195   cplus_primitive_type_signed_char,
1196   cplus_primitive_type_unsigned_char,
1197   cplus_primitive_type_unsigned_short,
1198   cplus_primitive_type_unsigned_int,
1199   cplus_primitive_type_unsigned_long,
1200   cplus_primitive_type_unsigned_long_long,
1201   cplus_primitive_type_long_double,
1202   cplus_primitive_type_complex,
1203   cplus_primitive_type_double_complex,
1204   cplus_primitive_type_bool,
1205   cplus_primitive_type_decfloat,
1206   cplus_primitive_type_decdouble,
1207   cplus_primitive_type_declong,
1208   nr_cplus_primitive_types
1209 };
1210
1211 static void
1212 cplus_language_arch_info (struct gdbarch *gdbarch,
1213                           struct language_arch_info *lai)
1214 {
1215   const struct builtin_type *builtin = builtin_type (gdbarch);
1216   lai->string_char_type = builtin->builtin_char;
1217   lai->primitive_type_vector
1218     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
1219                               struct type *);
1220   lai->primitive_type_vector [cplus_primitive_type_int]
1221     = builtin->builtin_int;
1222   lai->primitive_type_vector [cplus_primitive_type_long]
1223     = builtin->builtin_long;
1224   lai->primitive_type_vector [cplus_primitive_type_short]
1225     = builtin->builtin_short;
1226   lai->primitive_type_vector [cplus_primitive_type_char]
1227     = builtin->builtin_char;
1228   lai->primitive_type_vector [cplus_primitive_type_float]
1229     = builtin->builtin_float;
1230   lai->primitive_type_vector [cplus_primitive_type_double]
1231     = builtin->builtin_double;
1232   lai->primitive_type_vector [cplus_primitive_type_void]
1233     = builtin->builtin_void;
1234   lai->primitive_type_vector [cplus_primitive_type_long_long]
1235     = builtin->builtin_long_long;
1236   lai->primitive_type_vector [cplus_primitive_type_signed_char]
1237     = builtin->builtin_signed_char;
1238   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
1239     = builtin->builtin_unsigned_char;
1240   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
1241     = builtin->builtin_unsigned_short;
1242   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
1243     = builtin->builtin_unsigned_int;
1244   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
1245     = builtin->builtin_unsigned_long;
1246   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
1247     = builtin->builtin_unsigned_long_long;
1248   lai->primitive_type_vector [cplus_primitive_type_long_double]
1249     = builtin->builtin_long_double;
1250   lai->primitive_type_vector [cplus_primitive_type_complex]
1251     = builtin->builtin_complex;
1252   lai->primitive_type_vector [cplus_primitive_type_double_complex]
1253     = builtin->builtin_double_complex;
1254   lai->primitive_type_vector [cplus_primitive_type_bool]
1255     = builtin->builtin_bool;
1256   lai->primitive_type_vector [cplus_primitive_type_decfloat]
1257     = builtin->builtin_decfloat;
1258   lai->primitive_type_vector [cplus_primitive_type_decdouble]
1259     = builtin->builtin_decdouble;
1260   lai->primitive_type_vector [cplus_primitive_type_declong]
1261     = builtin->builtin_declong;
1262
1263   lai->bool_type_symbol = "bool";
1264   lai->bool_type_default = builtin->builtin_bool;
1265 }
1266
1267 const struct language_defn cplus_language_defn =
1268 {
1269   "c++",                        /* Language name */
1270   language_cplus,
1271   range_check_off,
1272   type_check_off,
1273   case_sensitive_on,
1274   array_row_major,
1275   macro_expansion_c,
1276   &exp_descriptor_c,
1277   c_parse,
1278   c_error,
1279   null_post_parser,
1280   c_printchar,                  /* Print a character constant */
1281   c_printstr,                   /* Function to print string constant */
1282   c_emit_char,                  /* Print a single char */
1283   c_print_type,                 /* Print a type using appropriate syntax */
1284   c_print_typedef,              /* Print a typedef using appropriate syntax */
1285   c_val_print,                  /* Print a value using appropriate syntax */
1286   c_value_print,                /* Print a top-level value */
1287   cplus_skip_trampoline,        /* Language specific skip_trampoline */
1288   "this",                       /* name_of_this */
1289   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
1290   cp_lookup_transparent_type,   /* lookup_transparent_type */
1291   cplus_demangle,               /* Language specific symbol demangler */
1292   cp_class_name_from_physname,  /* Language specific class_name_from_physname */
1293   c_op_print_tab,               /* expression operators for printing */
1294   1,                            /* c-style arrays */
1295   0,                            /* String lower bound */
1296   default_word_break_characters,
1297   default_make_symbol_completion_list,
1298   cplus_language_arch_info,
1299   default_print_array_index,
1300   cp_pass_by_reference,
1301   c_get_string,
1302   LANG_MAGIC
1303 };
1304
1305 const struct language_defn asm_language_defn =
1306 {
1307   "asm",                        /* Language name */
1308   language_asm,
1309   range_check_off,
1310   type_check_off,
1311   case_sensitive_on,
1312   array_row_major,
1313   macro_expansion_c,
1314   &exp_descriptor_c,
1315   c_parse,
1316   c_error,
1317   null_post_parser,
1318   c_printchar,                  /* Print a character constant */
1319   c_printstr,                   /* Function to print string constant */
1320   c_emit_char,                  /* Print a single char */
1321   c_print_type,                 /* Print a type using appropriate syntax */
1322   c_print_typedef,              /* Print a typedef using appropriate syntax */
1323   c_val_print,                  /* Print a value using appropriate syntax */
1324   c_value_print,                /* Print a top-level value */
1325   NULL,                         /* Language specific skip_trampoline */
1326   NULL,                         /* name_of_this */
1327   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1328   basic_lookup_transparent_type,/* lookup_transparent_type */
1329   NULL,                         /* Language specific symbol demangler */
1330   NULL,                         /* Language specific class_name_from_physname */
1331   c_op_print_tab,               /* expression operators for printing */
1332   1,                            /* c-style arrays */
1333   0,                            /* String lower bound */
1334   default_word_break_characters,
1335   default_make_symbol_completion_list,
1336   c_language_arch_info, /* FIXME: la_language_arch_info.  */
1337   default_print_array_index,
1338   default_pass_by_reference,
1339   c_get_string,
1340   LANG_MAGIC
1341 };
1342
1343 /* The following language_defn does not represent a real language.
1344    It just provides a minimal support a-la-C that should allow users
1345    to do some simple operations when debugging applications that use
1346    a language currently not supported by GDB.  */
1347
1348 const struct language_defn minimal_language_defn =
1349 {
1350   "minimal",                    /* Language name */
1351   language_minimal,
1352   range_check_off,
1353   type_check_off,
1354   case_sensitive_on,
1355   array_row_major,
1356   macro_expansion_c,
1357   &exp_descriptor_c,
1358   c_parse,
1359   c_error,
1360   null_post_parser,
1361   c_printchar,                  /* Print a character constant */
1362   c_printstr,                   /* Function to print string constant */
1363   c_emit_char,                  /* Print a single char */
1364   c_print_type,                 /* Print a type using appropriate syntax */
1365   c_print_typedef,              /* Print a typedef using appropriate syntax */
1366   c_val_print,                  /* Print a value using appropriate syntax */
1367   c_value_print,                /* Print a top-level value */
1368   NULL,                         /* Language specific skip_trampoline */
1369   NULL,                         /* name_of_this */
1370   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1371   basic_lookup_transparent_type,/* lookup_transparent_type */
1372   NULL,                         /* Language specific symbol demangler */
1373   NULL,                         /* Language specific class_name_from_physname */
1374   c_op_print_tab,               /* expression operators for printing */
1375   1,                            /* c-style arrays */
1376   0,                            /* String lower bound */
1377   default_word_break_characters,
1378   default_make_symbol_completion_list,
1379   c_language_arch_info,
1380   default_print_array_index,
1381   default_pass_by_reference,
1382   c_get_string,
1383   LANG_MAGIC
1384 };
1385
1386 void
1387 _initialize_c_language (void)
1388 {
1389   add_language (&c_language_defn);
1390   add_language (&cplus_language_defn);
1391   add_language (&asm_language_defn);
1392   add_language (&minimal_language_defn);
1393 }