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