gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "parser-defs.h"
  25 #include "language.h"
  26 #include "varobj.h"
  27 #include "c-lang.h"
  28 #include "valprint.h"
  29 #include "macroscope.h"
  30 #include "charset.h"
  31 #include "demangle.h"
  32 #include "cp-abi.h"
  33 #include "cp-support.h"
  34 #include "gdb_obstack.h"
  35 #include <ctype.h>
  36 #include "gdbcore.h"
  37
  38 extern void _initialize_c_language (void);
  39
  40 /* Given a C string type, STR_TYPE, return the corresponding target
  41    character set name.  */
  42
  43 static const char *
  44 charset_for_string_type (c_string_type str_type, struct gdbarch *gdbarch)
  45 {
  46   switch (str_type & ~C_CHAR)
  47     {
  48     case C_STRING:
  49       return target_charset (gdbarch);
  50     case C_WIDE_STRING:
  51       return target_wide_charset (gdbarch);
  52     case C_STRING_16:
  53       /* FIXME: UTF-16 is not always correct.  */
  54       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  55         return "UTF-16BE";
  56       else
  57         return "UTF-16LE";
  58     case C_STRING_32:
  59       /* FIXME: UTF-32 is not always correct.  */
  60       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
  61         return "UTF-32BE";
  62       else
  63         return "UTF-32LE";
  64     }
  65   internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
  66 }
  67
  68 /* Classify ELTTYPE according to what kind of character it is.  Return
  69    the enum constant representing the character type.  Also set
  70    *ENCODING to the name of the character set to use when converting
  71    characters of this type in target BYTE_ORDER to the host character
  72    set.  */
  73
  74 static c_string_type
  75 classify_type (struct type *elttype, struct gdbarch *gdbarch,
  76                const char **encoding)
  77 {
  78   c_string_type result;
  79
  80   /* We loop because ELTTYPE may be a typedef, and we want to
  81      successively peel each typedef until we reach a type we
  82      understand.  We don't use CHECK_TYPEDEF because that will strip
  83      all typedefs at once -- but in C, wchar_t is itself a typedef, so
  84      that would do the wrong thing.  */
  85   while (elttype)
  86     {
  87       const char *name = TYPE_NAME (elttype);
  88
  89       if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
  90         {
  91           result = C_CHAR;
  92           goto done;
  93         }
  94
  95       if (!strcmp (name, "wchar_t"))
  96         {
  97           result = C_WIDE_CHAR;
  98           goto done;
  99         }
 100
 101       if (!strcmp (name, "char16_t"))
 102         {
 103           result = C_CHAR_16;
 104           goto done;
 105         }
 106
 107       if (!strcmp (name, "char32_t"))
 108         {
 109           result = C_CHAR_32;
 110           goto done;
 111         }
 112
 113       if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
 114         break;
 115
 116       /* Call for side effects.  */
 117       check_typedef (elttype);
 118
 119       if (TYPE_TARGET_TYPE (elttype))
 120         elttype = TYPE_TARGET_TYPE (elttype);
 121       else
 122         {
 123           /* Perhaps check_typedef did not update the target type.  In
 124              this case, force the lookup again and hope it works out.
 125              It never will for C, but it might for C++.  */
 126           elttype = check_typedef (elttype);
 127         }
 128     }
 129
 130   /* Punt.  */
 131   result = C_CHAR;
 132
 133  done:
 134   if (encoding)
 135     *encoding = charset_for_string_type (result, gdbarch);
 136
 137   return result;
 138 }
 139
 140 /* Print the character C on STREAM as part of the contents of a
 141    literal string whose delimiter is QUOTER.  Note that that format
 142    for printing characters and strings is language specific.  */
 143
 144 void
 145 c_emit_char (int c, struct type *type,
 146              struct ui_file *stream, int quoter)
 147 {
 148   const char *encoding;
 149
 150   classify_type (type, get_type_arch (type), &encoding);
 151   generic_emit_char (c, type, stream, quoter, encoding);
 152 }
 153
 154 void
 155 c_printchar (int c, struct type *type, struct ui_file *stream)
 156 {
 157   c_string_type str_type;
 158
 159   str_type = classify_type (type, get_type_arch (type), NULL);
 160   switch (str_type)
 161     {
 162     case C_CHAR:
 163       break;
 164     case C_WIDE_CHAR:
 165       fputc_filtered ('L', stream);
 166       break;
 167     case C_CHAR_16:
 168       fputc_filtered ('u', stream);
 169       break;
 170     case C_CHAR_32:
 171       fputc_filtered ('U', stream);
 172       break;
 173     }
 174
 175   fputc_filtered ('\'', stream);
 176   LA_EMIT_CHAR (c, type, stream, '\'');
 177   fputc_filtered ('\'', stream);
 178 }
 179
 180 /* Print the character string STRING, printing at most LENGTH
 181    characters.  LENGTH is -1 if the string is nul terminated.  Each
 182    character is WIDTH bytes long.  Printing stops early if the number
 183    hits print_max; repeat counts are printed as appropriate.  Print
 184    ellipses at the end if we had to stop before printing LENGTH
 185    characters, or if FORCE_ELLIPSES.  */
 186
 187 void
 188 c_printstr (struct ui_file *stream, struct type *type,
 189             const gdb_byte *string, unsigned int length,
 190             const char *user_encoding, int force_ellipses,
 191             const struct value_print_options *options)
 192 {
 193   c_string_type str_type;
 194   const char *type_encoding;
 195   const char *encoding;
 196
 197   str_type = (classify_type (type, get_type_arch (type), &type_encoding)
 198               & ~C_CHAR);
 199   switch (str_type)
 200     {
 201     case C_STRING:
 202       break;
 203     case C_WIDE_STRING:
 204       fputs_filtered ("L", stream);
 205       break;
 206     case C_STRING_16:
 207       fputs_filtered ("u", stream);
 208       break;
 209     case C_STRING_32:
 210       fputs_filtered ("U", stream);
 211       break;
 212     }
 213
 214   encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
 215
 216   generic_printstr (stream, type, string, length, encoding, force_ellipses,
 217                     '"', 1, options);
 218 }
 219
 220 /* Obtain a C string from the inferior storing it in a newly allocated
 221    buffer in BUFFER, which should be freed by the caller.  If the in-
 222    and out-parameter *LENGTH is specified at -1, the string is read
 223    until a null character of the appropriate width is found, otherwise
 224    the string is read to the length of characters specified.  The size
 225    of a character is determined by the length of the target type of
 226    the pointer or array.
 227
 228    If VALUE is an array with a known length, and *LENGTH is -1,
 229    the function will not read past the end of the array.  However, any
 230    declared size of the array is ignored if *LENGTH > 0.
 231
 232    On completion, *LENGTH will be set to the size of the string read in
 233    characters.  (If a length of -1 is specified, the length returned
 234    will not include the null character).  CHARSET is always set to the
 235    target charset.  */
 236
 237 void
 238 c_get_string (struct value *value, gdb_byte **buffer,
 239               int *length, struct type **char_type,
 240               const char **charset)
 241 {
 242   int err, width;
 243   unsigned int fetchlimit;
 244   struct type *type = check_typedef (value_type (value));
 245   struct type *element_type = TYPE_TARGET_TYPE (type);
 246   int req_length = *length;
 247   enum bfd_endian byte_order
 248     = gdbarch_byte_order (get_type_arch (type));
 249
 250   if (element_type == NULL)
 251     goto error;
 252
 253   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 254     {
 255       /* If we know the size of the array, we can use it as a limit on
 256          the number of characters to be fetched.  */
 257       if (TYPE_NFIELDS (type) == 1
 258           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 259         {
 260           LONGEST low_bound, high_bound;
 261
 262           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 263                                &low_bound, &high_bound);
 264           fetchlimit = high_bound - low_bound + 1;
 265         }
 266       else
 267         fetchlimit = UINT_MAX;
 268     }
 269   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 270     fetchlimit = UINT_MAX;
 271   else
 272     /* We work only with arrays and pointers.  */
 273     goto error;
 274
 275   if (! c_textual_element_type (element_type, 0))
 276     goto error;
 277   classify_type (element_type, get_type_arch (element_type), charset);
 278   width = TYPE_LENGTH (element_type);
 279
 280   /* If the string lives in GDB's memory instead of the inferior's,
 281      then we just need to copy it to BUFFER.  Also, since such strings
 282      are arrays with known size, FETCHLIMIT will hold the size of the
 283      array.  */
 284   if ((VALUE_LVAL (value) == not_lval
 285        || VALUE_LVAL (value) == lval_internalvar)
 286       && fetchlimit != UINT_MAX)
 287     {
 288       int i;
 289       const gdb_byte *contents = value_contents (value);
 290
 291       /* If a length is specified, use that.  */
 292       if (*length >= 0)
 293         i  = *length;
 294       else
 295         /* Otherwise, look for a null character.  */
 296         for (i = 0; i < fetchlimit; i++)
 297           if (extract_unsigned_integer (contents + i * width,
 298                                         width, byte_order) == 0)
 299             break;
 300
 301       /* I is now either a user-defined length, the number of non-null
 302          characters, or FETCHLIMIT.  */
 303       *length = i * width;
 304       *buffer = (gdb_byte *) xmalloc (*length);
 305       memcpy (*buffer, contents, *length);
 306       err = 0;
 307     }
 308   else
 309     {
 310       CORE_ADDR addr = value_as_address (value);
 311
 312       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
 313          if length > 0.  The old "broken" behaviour is the behaviour we want:
 314          The caller may want to fetch 100 bytes from a variable length array
 315          implemented using the common idiom of having an array of length 1 at
 316          the end of a struct.  In this case we want to ignore the declared
 317          size of the array.  However, it's counterintuitive to implement that
 318          behaviour in read_string: what does fetchlimit otherwise mean if
 319          length > 0.  Therefore we implement the behaviour we want here:
 320          If *length > 0, don't specify a fetchlimit.  This preserves the
 321          previous behaviour.  We could move this check above where we know
 322          whether the array is declared with a fixed size, but we only want
 323          to apply this behaviour when calling read_string.  PR 16286.  */
 324       if (*length > 0)
 325         fetchlimit = UINT_MAX;
 326
 327       err = read_string (addr, *length, width, fetchlimit,
 328                          byte_order, buffer, length);
 329       if (err != 0)
 330         {
 331           xfree (*buffer);
 332           memory_error (TARGET_XFER_E_IO, addr);
 333         }
 334     }
 335
 336   /* If the LENGTH is specified at -1, we want to return the string
 337      length up to the terminating null character.  If an actual length
 338      was specified, we want to return the length of exactly what was
 339      read.  */
 340   if (req_length == -1)
 341     /* If the last character is null, subtract it from LENGTH.  */
 342     if (*length > 0
 343         && extract_unsigned_integer (*buffer + *length - width,
 344                                      width, byte_order) == 0)
 345       *length -= width;
 346
 347   /* The read_string function will return the number of bytes read.
 348      If length returned from read_string was > 0, return the number of
 349      characters read by dividing the number of bytes by width.  */
 350   if (*length != 0)
 351      *length = *length / width;
 352
 353   *char_type = element_type;
 354
 355   return;
 356
 357  error:
 358   {
 359     std::string type_str = type_to_string (type);
 360     if (!type_str.empty ())
 361       {
 362         error (_("Trying to read string with inappropriate type `%s'."),
 363                type_str.c_str ());
 364       }
 365     else
 366       error (_("Trying to read string with inappropriate type."));
 367   }
 368 }
 369
 370 \f
 371 /* Evaluating C and C++ expressions.  */
 372
 373 /* Convert a UCN.  The digits of the UCN start at P and extend no
 374    farther than LIMIT.  DEST_CHARSET is the name of the character set
 375    into which the UCN should be converted.  The results are written to
 376    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 377    Returns a pointer to just after the final digit of the UCN.  */
 378
 379 static char *
 380 convert_ucn (char *p, char *limit, const char *dest_charset,
 381              struct obstack *output, int length)
 382 {
 383   unsigned long result = 0;
 384   gdb_byte data[4];
 385   int i;
 386
 387   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 388     result = (result << 4) + host_hex_value (*p);
 389
 390   for (i = 3; i >= 0; --i)
 391     {
 392       data[i] = result & 0xff;
 393       result >>= 8;
 394     }
 395
 396   convert_between_encodings ("UTF-32BE", dest_charset, data,
 397                              4, 4, output, translit_none);
 398
 399   return p;
 400 }
 401
 402 /* Emit a character, VALUE, which was specified numerically, to
 403    OUTPUT.  TYPE is the target character type.  */
 404
 405 static void
 406 emit_numeric_character (struct type *type, unsigned long value,
 407                         struct obstack *output)
 408 {
 409   gdb_byte *buffer;
 410
 411   buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
 412   pack_long (buffer, type, value);
 413   obstack_grow (output, buffer, TYPE_LENGTH (type));
 414 }
 415
 416 /* Convert an octal escape sequence.  TYPE is the target character
 417    type.  The digits of the escape sequence begin at P and extend no
 418    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 419    pointer to just after the final digit of the escape sequence.  */
 420
 421 static char *
 422 convert_octal (struct type *type, char *p,
 423                char *limit, struct obstack *output)
 424 {
 425   int i;
 426   unsigned long value = 0;
 427
 428   for (i = 0;
 429        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 430        ++i)
 431     {
 432       value = 8 * value + host_hex_value (*p);
 433       ++p;
 434     }
 435
 436   emit_numeric_character (type, value, output);
 437
 438   return p;
 439 }
 440
 441 /* Convert a hex escape sequence.  TYPE is the target character type.
 442    The digits of the escape sequence begin at P and extend no farther
 443    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 444    just after the final digit of the escape sequence.  */
 445
 446 static char *
 447 convert_hex (struct type *type, char *p,
 448              char *limit, struct obstack *output)
 449 {
 450   unsigned long value = 0;
 451
 452   while (p < limit && isxdigit (*p))
 453     {
 454       value = 16 * value + host_hex_value (*p);
 455       ++p;
 456     }
 457
 458   emit_numeric_character (type, value, output);
 459
 460   return p;
 461 }
 462
 463 #define ADVANCE                                 \
 464   do {                                          \
 465     ++p;                                        \
 466     if (p == limit)                             \
 467       error (_("Malformed escape sequence"));   \
 468   } while (0)
 469
 470 /* Convert an escape sequence to a target format.  TYPE is the target
 471    character type to use, and DEST_CHARSET is the name of the target
 472    character set.  The backslash of the escape sequence is at *P, and
 473    the escape sequence will not extend past LIMIT.  The results are
 474    written to OUTPUT.  Returns a pointer to just past the final
 475    character of the escape sequence.  */
 476
 477 static char *
 478 convert_escape (struct type *type, const char *dest_charset,
 479                 char *p, char *limit, struct obstack *output)
 480 {
 481   /* Skip the backslash.  */
 482   ADVANCE;
 483
 484   switch (*p)
 485     {
 486     case '\\':
 487       obstack_1grow (output, '\\');
 488       ++p;
 489       break;
 490
 491     case 'x':
 492       ADVANCE;
 493       if (!isxdigit (*p))
 494         error (_("\\x used with no following hex digits."));
 495       p = convert_hex (type, p, limit, output);
 496       break;
 497
 498     case '0':
 499     case '1':
 500     case '2':
 501     case '3':
 502     case '4':
 503     case '5':
 504     case '6':
 505     case '7':
 506       p = convert_octal (type, p, limit, output);
 507       break;
 508
 509     case 'u':
 510     case 'U':
 511       {
 512         int length = *p == 'u' ? 4 : 8;
 513
 514         ADVANCE;
 515         if (!isxdigit (*p))
 516           error (_("\\u used with no following hex digits"));
 517         p = convert_ucn (p, limit, dest_charset, output, length);
 518       }
 519     }
 520
 521   return p;
 522 }
 523
 524 /* Given a single string from a (C-specific) OP_STRING list, convert
 525    it to a target string, handling escape sequences specially.  The
 526    output is written to OUTPUT.  DATA is the input string, which has
 527    length LEN.  DEST_CHARSET is the name of the target character set,
 528    and TYPE is the type of target character to use.  */
 529
 530 static void
 531 parse_one_string (struct obstack *output, char *data, int len,
 532                   const char *dest_charset, struct type *type)
 533 {
 534   char *limit;
 535
 536   limit = data + len;
 537
 538   while (data < limit)
 539     {
 540       char *p = data;
 541
 542       /* Look for next escape, or the end of the input.  */
 543       while (p < limit && *p != '\\')
 544         ++p;
 545       /* If we saw a run of characters, convert them all.  */
 546       if (p > data)
 547         convert_between_encodings (host_charset (), dest_charset,
 548                                    (gdb_byte *) data, p - data, 1,
 549                                    output, translit_none);
 550       /* If we saw an escape, convert it.  */
 551       if (p < limit)
 552         p = convert_escape (type, dest_charset, p, limit, output);
 553       data = p;
 554     }
 555 }
 556
 557 /* Expression evaluator for the C language family.  Most operations
 558    are delegated to evaluate_subexp_standard; see that function for a
 559    description of the arguments.  */
 560
 561 struct value *
 562 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 563                    int *pos, enum noside noside)
 564 {
 565   enum exp_opcode op = exp->elts[*pos].opcode;
 566
 567   switch (op)
 568     {
 569     case OP_STRING:
 570       {
 571         int oplen, limit;
 572         struct type *type;
 573         struct obstack output;
 574         struct cleanup *cleanup;
 575         struct value *result;
 576         c_string_type dest_type;
 577         const char *dest_charset;
 578         int satisfy_expected = 0;
 579
 580         obstack_init (&output);
 581         cleanup = make_cleanup_obstack_free (&output);
 582
 583         ++*pos;
 584         oplen = longest_to_int (exp->elts[*pos].longconst);
 585
 586         ++*pos;
 587         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 588         dest_type = ((enum c_string_type_values)
 589                      longest_to_int (exp->elts[*pos].longconst));
 590         switch (dest_type & ~C_CHAR)
 591           {
 592           case C_STRING:
 593             type = language_string_char_type (exp->language_defn,
 594                                               exp->gdbarch);
 595             break;
 596           case C_WIDE_STRING:
 597             type = lookup_typename (exp->language_defn, exp->gdbarch,
 598                                     "wchar_t", NULL, 0);
 599             break;
 600           case C_STRING_16:
 601             type = lookup_typename (exp->language_defn, exp->gdbarch,
 602                                     "char16_t", NULL, 0);
 603             break;
 604           case C_STRING_32:
 605             type = lookup_typename (exp->language_defn, exp->gdbarch,
 606                                     "char32_t", NULL, 0);
 607             break;
 608           default:
 609             internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
 610           }
 611
 612         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 613         check_typedef (type);
 614
 615         /* If the caller expects an array of some integral type,
 616            satisfy them.  If something odder is expected, rely on the
 617            caller to cast.  */
 618         if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 619           {
 620             struct type *element_type
 621               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 622
 623             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 624                 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
 625               {
 626                 type = element_type;
 627                 satisfy_expected = 1;
 628               }
 629           }
 630
 631         dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
 632
 633         ++*pos;
 634         while (*pos < limit)
 635           {
 636             int len;
 637
 638             len = longest_to_int (exp->elts[*pos].longconst);
 639
 640             ++*pos;
 641             if (noside != EVAL_SKIP)
 642               parse_one_string (&output, &exp->elts[*pos].string, len,
 643                                 dest_charset, type);
 644             *pos += BYTES_TO_EXP_ELEM (len);
 645           }
 646
 647         /* Skip the trailing length and opcode.  */
 648         *pos += 2;
 649
 650         if (noside == EVAL_SKIP)
 651           {
 652             /* Return a dummy value of the appropriate type.  */
 653             if (expect_type != NULL)
 654               result = allocate_value (expect_type);
 655             else if ((dest_type & C_CHAR) != 0)
 656               result = allocate_value (type);
 657             else
 658               result = value_cstring ("", 0, type);
 659             do_cleanups (cleanup);
 660             return result;
 661           }
 662
 663         if ((dest_type & C_CHAR) != 0)
 664           {
 665             LONGEST value;
 666
 667             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 668               error (_("Could not convert character "
 669                        "constant to target character set"));
 670             value = unpack_long (type, (gdb_byte *) obstack_base (&output));
 671             result = value_from_longest (type, value);
 672           }
 673         else
 674           {
 675             int i;
 676
 677             /* Write the terminating character.  */
 678             for (i = 0; i < TYPE_LENGTH (type); ++i)
 679               obstack_1grow (&output, 0);
 680
 681             if (satisfy_expected)
 682               {
 683                 LONGEST low_bound, high_bound;
 684                 int element_size = TYPE_LENGTH (type);
 685
 686                 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
 687                                          &low_bound, &high_bound) < 0)
 688                   {
 689                     low_bound = 0;
 690                     high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
 691                   }
 692                 if (obstack_object_size (&output) / element_size
 693                     > (high_bound - low_bound + 1))
 694                   error (_("Too many array elements"));
 695
 696                 result = allocate_value (expect_type);
 697                 memcpy (value_contents_raw (result), obstack_base (&output),
 698                         obstack_object_size (&output));
 699               }
 700             else
 701               result = value_cstring ((const char *) obstack_base (&output),
 702                                       obstack_object_size (&output),
 703                                       type);
 704           }
 705         do_cleanups (cleanup);
 706         return result;
 707       }
 708       break;
 709
 710     default:
 711       break;
 712     }
 713   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 714 }
 715
 716
 717 \f
 718 /* Table mapping opcodes into strings for printing operators
 719    and precedences of the operators.  */
 720
 721 const struct op_print c_op_print_tab[] =
 722 {
 723   {",", BINOP_COMMA, PREC_COMMA, 0},
 724   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 725   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 726   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 727   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 728   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 729   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 730   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 731   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 732   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 733   {">=", BINOP_GEQ, PREC_ORDER, 0},
 734   {">", BINOP_GTR, PREC_ORDER, 0},
 735   {"<", BINOP_LESS, PREC_ORDER, 0},
 736   {">>", BINOP_RSH, PREC_SHIFT, 0},
 737   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 738   {"+", BINOP_ADD, PREC_ADD, 0},
 739   {"-", BINOP_SUB, PREC_ADD, 0},
 740   {"*", BINOP_MUL, PREC_MUL, 0},
 741   {"/", BINOP_DIV, PREC_MUL, 0},
 742   {"%", BINOP_REM, PREC_MUL, 0},
 743   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 744   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 745   {"-", UNOP_NEG, PREC_PREFIX, 0},
 746   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 747   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 748   {"*", UNOP_IND, PREC_PREFIX, 0},
 749   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 750   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 751   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 752   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 753   {NULL, OP_NULL, PREC_PREFIX, 0}
 754 };
 755 \f
 756 enum c_primitive_types {
 757   c_primitive_type_int,
 758   c_primitive_type_long,
 759   c_primitive_type_short,
 760   c_primitive_type_char,
 761   c_primitive_type_float,
 762   c_primitive_type_double,
 763   c_primitive_type_void,
 764   c_primitive_type_long_long,
 765   c_primitive_type_signed_char,
 766   c_primitive_type_unsigned_char,
 767   c_primitive_type_unsigned_short,
 768   c_primitive_type_unsigned_int,
 769   c_primitive_type_unsigned_long,
 770   c_primitive_type_unsigned_long_long,
 771   c_primitive_type_long_double,
 772   c_primitive_type_complex,
 773   c_primitive_type_double_complex,
 774   c_primitive_type_decfloat,
 775   c_primitive_type_decdouble,
 776   c_primitive_type_declong,
 777   nr_c_primitive_types
 778 };
 779
 780 void
 781 c_language_arch_info (struct gdbarch *gdbarch,
 782                       struct language_arch_info *lai)
 783 {
 784   const struct builtin_type *builtin = builtin_type (gdbarch);
 785
 786   lai->string_char_type = builtin->builtin_char;
 787   lai->primitive_type_vector
 788     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 789                               struct type *);
 790   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 791   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 792   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 793   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 794   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 795   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 796   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 797   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 798   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 799   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 800   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 801   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 802   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 803   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 804   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 805   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 806   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 807   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 808   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 809   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 810
 811   lai->bool_type_default = builtin->builtin_int;
 812 }
 813
 814 const struct exp_descriptor exp_descriptor_c =
 815 {
 816   print_subexp_standard,
 817   operator_length_standard,
 818   operator_check_standard,
 819   op_name_standard,
 820   dump_subexp_body_standard,
 821   evaluate_subexp_c
 822 };
 823
 824 static const char *c_extensions[] =
 825 {
 826   ".c", NULL
 827 };
 828
 829 const struct language_defn c_language_defn =
 830 {
 831   "c",                          /* Language name */
 832   "C",
 833   language_c,
 834   range_check_off,
 835   case_sensitive_on,
 836   array_row_major,
 837   macro_expansion_c,
 838   c_extensions,
 839   &exp_descriptor_c,
 840   c_parse,
 841   c_yyerror,
 842   null_post_parser,
 843   c_printchar,                  /* Print a character constant */
 844   c_printstr,                   /* Function to print string constant */
 845   c_emit_char,                  /* Print a single char */
 846   c_print_type,                 /* Print a type using appropriate syntax */
 847   c_print_typedef,              /* Print a typedef using appropriate syntax */
 848   c_val_print,                  /* Print a value using appropriate syntax */
 849   c_value_print,                /* Print a top-level value */
 850   default_read_var_value,       /* la_read_var_value */
 851   NULL,                         /* Language specific skip_trampoline */
 852   NULL,                         /* name_of_this */
 853   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 854   basic_lookup_transparent_type,/* lookup_transparent_type */
 855   NULL,                         /* Language specific symbol demangler */
 856   NULL,
 857   NULL,                         /* Language specific
 858                                    class_name_from_physname */
 859   c_op_print_tab,               /* expression operators for printing */
 860   1,                            /* c-style arrays */
 861   0,                            /* String lower bound */
 862   default_word_break_characters,
 863   default_make_symbol_completion_list,
 864   c_language_arch_info,
 865   default_print_array_index,
 866   default_pass_by_reference,
 867   c_get_string,
 868   NULL,                         /* la_get_symbol_name_cmp */
 869   iterate_over_symbols,
 870   &c_varobj_ops,
 871   c_get_compile_context,
 872   c_compute_program,
 873   LANG_MAGIC
 874 };
 875
 876 enum cplus_primitive_types {
 877   cplus_primitive_type_int,
 878   cplus_primitive_type_long,
 879   cplus_primitive_type_short,
 880   cplus_primitive_type_char,
 881   cplus_primitive_type_float,
 882   cplus_primitive_type_double,
 883   cplus_primitive_type_void,
 884   cplus_primitive_type_long_long,
 885   cplus_primitive_type_signed_char,
 886   cplus_primitive_type_unsigned_char,
 887   cplus_primitive_type_unsigned_short,
 888   cplus_primitive_type_unsigned_int,
 889   cplus_primitive_type_unsigned_long,
 890   cplus_primitive_type_unsigned_long_long,
 891   cplus_primitive_type_long_double,
 892   cplus_primitive_type_complex,
 893   cplus_primitive_type_double_complex,
 894   cplus_primitive_type_bool,
 895   cplus_primitive_type_decfloat,
 896   cplus_primitive_type_decdouble,
 897   cplus_primitive_type_declong,
 898   nr_cplus_primitive_types
 899 };
 900
 901 static void
 902 cplus_language_arch_info (struct gdbarch *gdbarch,
 903                           struct language_arch_info *lai)
 904 {
 905   const struct builtin_type *builtin = builtin_type (gdbarch);
 906
 907   lai->string_char_type = builtin->builtin_char;
 908   lai->primitive_type_vector
 909     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 910                               struct type *);
 911   lai->primitive_type_vector [cplus_primitive_type_int]
 912     = builtin->builtin_int;
 913   lai->primitive_type_vector [cplus_primitive_type_long]
 914     = builtin->builtin_long;
 915   lai->primitive_type_vector [cplus_primitive_type_short]
 916     = builtin->builtin_short;
 917   lai->primitive_type_vector [cplus_primitive_type_char]
 918     = builtin->builtin_char;
 919   lai->primitive_type_vector [cplus_primitive_type_float]
 920     = builtin->builtin_float;
 921   lai->primitive_type_vector [cplus_primitive_type_double]
 922     = builtin->builtin_double;
 923   lai->primitive_type_vector [cplus_primitive_type_void]
 924     = builtin->builtin_void;
 925   lai->primitive_type_vector [cplus_primitive_type_long_long]
 926     = builtin->builtin_long_long;
 927   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 928     = builtin->builtin_signed_char;
 929   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 930     = builtin->builtin_unsigned_char;
 931   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 932     = builtin->builtin_unsigned_short;
 933   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 934     = builtin->builtin_unsigned_int;
 935   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 936     = builtin->builtin_unsigned_long;
 937   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 938     = builtin->builtin_unsigned_long_long;
 939   lai->primitive_type_vector [cplus_primitive_type_long_double]
 940     = builtin->builtin_long_double;
 941   lai->primitive_type_vector [cplus_primitive_type_complex]
 942     = builtin->builtin_complex;
 943   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 944     = builtin->builtin_double_complex;
 945   lai->primitive_type_vector [cplus_primitive_type_bool]
 946     = builtin->builtin_bool;
 947   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 948     = builtin->builtin_decfloat;
 949   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 950     = builtin->builtin_decdouble;
 951   lai->primitive_type_vector [cplus_primitive_type_declong]
 952     = builtin->builtin_declong;
 953
 954   lai->bool_type_symbol = "bool";
 955   lai->bool_type_default = builtin->builtin_bool;
 956 }
 957
 958 static const char *cplus_extensions[] =
 959 {
 960   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
 961 };
 962
 963 const struct language_defn cplus_language_defn =
 964 {
 965   "c++",                        /* Language name */
 966   "C++",
 967   language_cplus,
 968   range_check_off,
 969   case_sensitive_on,
 970   array_row_major,
 971   macro_expansion_c,
 972   cplus_extensions,
 973   &exp_descriptor_c,
 974   c_parse,
 975   c_yyerror,
 976   null_post_parser,
 977   c_printchar,                  /* Print a character constant */
 978   c_printstr,                   /* Function to print string constant */
 979   c_emit_char,                  /* Print a single char */
 980   c_print_type,                 /* Print a type using appropriate syntax */
 981   c_print_typedef,              /* Print a typedef using appropriate syntax */
 982   c_val_print,                  /* Print a value using appropriate syntax */
 983   c_value_print,                /* Print a top-level value */
 984   default_read_var_value,       /* la_read_var_value */
 985   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 986   "this",                       /* name_of_this */
 987   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 988   cp_lookup_transparent_type,   /* lookup_transparent_type */
 989   gdb_demangle,                 /* Language specific symbol demangler */
 990   gdb_sniff_from_mangled_name,
 991   cp_class_name_from_physname,  /* Language specific
 992                                    class_name_from_physname */
 993   c_op_print_tab,               /* expression operators for printing */
 994   1,                            /* c-style arrays */
 995   0,                            /* String lower bound */
 996   default_word_break_characters,
 997   default_make_symbol_completion_list,
 998   cplus_language_arch_info,
 999   default_print_array_index,
1000   cp_pass_by_reference,
1001   c_get_string,
1002   NULL,                         /* la_get_symbol_name_cmp */
1003   iterate_over_symbols,
1004   &cplus_varobj_ops,
1005   NULL,
1006   NULL,
1007   LANG_MAGIC
1008 };
1009
1010 static const char *asm_extensions[] =
1011 {
1012   ".s", ".sx", ".S", NULL
1013 };
1014
1015 const struct language_defn asm_language_defn =
1016 {
1017   "asm",                        /* Language name */
1018   "assembly",
1019   language_asm,
1020   range_check_off,
1021   case_sensitive_on,
1022   array_row_major,
1023   macro_expansion_c,
1024   asm_extensions,
1025   &exp_descriptor_c,
1026   c_parse,
1027   c_yyerror,
1028   null_post_parser,
1029   c_printchar,                  /* Print a character constant */
1030   c_printstr,                   /* Function to print string constant */
1031   c_emit_char,                  /* Print a single char */
1032   c_print_type,                 /* Print a type using appropriate syntax */
1033   c_print_typedef,              /* Print a typedef using appropriate syntax */
1034   c_val_print,                  /* Print a value using appropriate syntax */
1035   c_value_print,                /* Print a top-level value */
1036   default_read_var_value,       /* la_read_var_value */
1037   NULL,                         /* Language specific skip_trampoline */
1038   NULL,                         /* name_of_this */
1039   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1040   basic_lookup_transparent_type,/* lookup_transparent_type */
1041   NULL,                         /* Language specific symbol demangler */
1042   NULL,
1043   NULL,                         /* Language specific
1044                                    class_name_from_physname */
1045   c_op_print_tab,               /* expression operators for printing */
1046   1,                            /* c-style arrays */
1047   0,                            /* String lower bound */
1048   default_word_break_characters,
1049   default_make_symbol_completion_list,
1050   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1051   default_print_array_index,
1052   default_pass_by_reference,
1053   c_get_string,
1054   NULL,                         /* la_get_symbol_name_cmp */
1055   iterate_over_symbols,
1056   &default_varobj_ops,
1057   NULL,
1058   NULL,
1059   LANG_MAGIC
1060 };
1061
1062 /* The following language_defn does not represent a real language.
1063    It just provides a minimal support a-la-C that should allow users
1064    to do some simple operations when debugging applications that use
1065    a language currently not supported by GDB.  */
1066
1067 const struct language_defn minimal_language_defn =
1068 {
1069   "minimal",                    /* Language name */
1070   "Minimal",
1071   language_minimal,
1072   range_check_off,
1073   case_sensitive_on,
1074   array_row_major,
1075   macro_expansion_c,
1076   NULL,
1077   &exp_descriptor_c,
1078   c_parse,
1079   c_yyerror,
1080   null_post_parser,
1081   c_printchar,                  /* Print a character constant */
1082   c_printstr,                   /* Function to print string constant */
1083   c_emit_char,                  /* Print a single char */
1084   c_print_type,                 /* Print a type using appropriate syntax */
1085   c_print_typedef,              /* Print a typedef using appropriate syntax */
1086   c_val_print,                  /* Print a value using appropriate syntax */
1087   c_value_print,                /* Print a top-level value */
1088   default_read_var_value,       /* la_read_var_value */
1089   NULL,                         /* Language specific skip_trampoline */
1090   NULL,                         /* name_of_this */
1091   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1092   basic_lookup_transparent_type,/* lookup_transparent_type */
1093   NULL,                         /* Language specific symbol demangler */
1094   NULL,
1095   NULL,                         /* Language specific
1096                                    class_name_from_physname */
1097   c_op_print_tab,               /* expression operators for printing */
1098   1,                            /* c-style arrays */
1099   0,                            /* String lower bound */
1100   default_word_break_characters,
1101   default_make_symbol_completion_list,
1102   c_language_arch_info,
1103   default_print_array_index,
1104   default_pass_by_reference,
1105   c_get_string,
1106   NULL,                         /* la_get_symbol_name_cmp */
1107   iterate_over_symbols,
1108   &default_varobj_ops,
1109   NULL,
1110   NULL,
1111   LANG_MAGIC
1112 };
1113
1114 void
1115 _initialize_c_language (void)
1116 {
1117   add_language (&c_language_defn);
1118   add_language (&cplus_language_defn);
1119   add_language (&asm_language_defn);
1120   add_language (&minimal_language_defn);
1121 }