gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2016 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     char *type_str;
 360
 361     type_str = type_to_string (type);
 362     if (type_str)
 363       {
 364         make_cleanup (xfree, type_str);
 365         error (_("Trying to read string with inappropriate type `%s'."),
 366                type_str);
 367       }
 368     else
 369       error (_("Trying to read string with inappropriate type."));
 370   }
 371 }
 372
 373 \f
 374 /* Evaluating C and C++ expressions.  */
 375
 376 /* Convert a UCN.  The digits of the UCN start at P and extend no
 377    farther than LIMIT.  DEST_CHARSET is the name of the character set
 378    into which the UCN should be converted.  The results are written to
 379    OUTPUT.  LENGTH is the maximum length of the UCN, either 4 or 8.
 380    Returns a pointer to just after the final digit of the UCN.  */
 381
 382 static char *
 383 convert_ucn (char *p, char *limit, const char *dest_charset,
 384              struct obstack *output, int length)
 385 {
 386   unsigned long result = 0;
 387   gdb_byte data[4];
 388   int i;
 389
 390   for (i = 0; i < length && p < limit && isxdigit (*p); ++i, ++p)
 391     result = (result << 4) + host_hex_value (*p);
 392
 393   for (i = 3; i >= 0; --i)
 394     {
 395       data[i] = result & 0xff;
 396       result >>= 8;
 397     }
 398
 399   convert_between_encodings ("UTF-32BE", dest_charset, data,
 400                              4, 4, output, translit_none);
 401
 402   return p;
 403 }
 404
 405 /* Emit a character, VALUE, which was specified numerically, to
 406    OUTPUT.  TYPE is the target character type.  */
 407
 408 static void
 409 emit_numeric_character (struct type *type, unsigned long value,
 410                         struct obstack *output)
 411 {
 412   gdb_byte *buffer;
 413
 414   buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
 415   pack_long (buffer, type, value);
 416   obstack_grow (output, buffer, TYPE_LENGTH (type));
 417 }
 418
 419 /* Convert an octal escape sequence.  TYPE is the target character
 420    type.  The digits of the escape sequence begin at P and extend no
 421    farther than LIMIT.  The result is written to OUTPUT.  Returns a
 422    pointer to just after the final digit of the escape sequence.  */
 423
 424 static char *
 425 convert_octal (struct type *type, char *p,
 426                char *limit, struct obstack *output)
 427 {
 428   int i;
 429   unsigned long value = 0;
 430
 431   for (i = 0;
 432        i < 3 && p < limit && isdigit (*p) && *p != '8' && *p != '9';
 433        ++i)
 434     {
 435       value = 8 * value + host_hex_value (*p);
 436       ++p;
 437     }
 438
 439   emit_numeric_character (type, value, output);
 440
 441   return p;
 442 }
 443
 444 /* Convert a hex escape sequence.  TYPE is the target character type.
 445    The digits of the escape sequence begin at P and extend no farther
 446    than LIMIT.  The result is written to OUTPUT.  Returns a pointer to
 447    just after the final digit of the escape sequence.  */
 448
 449 static char *
 450 convert_hex (struct type *type, char *p,
 451              char *limit, struct obstack *output)
 452 {
 453   unsigned long value = 0;
 454
 455   while (p < limit && isxdigit (*p))
 456     {
 457       value = 16 * value + host_hex_value (*p);
 458       ++p;
 459     }
 460
 461   emit_numeric_character (type, value, output);
 462
 463   return p;
 464 }
 465
 466 #define ADVANCE                                 \
 467   do {                                          \
 468     ++p;                                        \
 469     if (p == limit)                             \
 470       error (_("Malformed escape sequence"));   \
 471   } while (0)
 472
 473 /* Convert an escape sequence to a target format.  TYPE is the target
 474    character type to use, and DEST_CHARSET is the name of the target
 475    character set.  The backslash of the escape sequence is at *P, and
 476    the escape sequence will not extend past LIMIT.  The results are
 477    written to OUTPUT.  Returns a pointer to just past the final
 478    character of the escape sequence.  */
 479
 480 static char *
 481 convert_escape (struct type *type, const char *dest_charset,
 482                 char *p, char *limit, struct obstack *output)
 483 {
 484   /* Skip the backslash.  */
 485   ADVANCE;
 486
 487   switch (*p)
 488     {
 489     case '\\':
 490       obstack_1grow (output, '\\');
 491       ++p;
 492       break;
 493
 494     case 'x':
 495       ADVANCE;
 496       if (!isxdigit (*p))
 497         error (_("\\x used with no following hex digits."));
 498       p = convert_hex (type, p, limit, output);
 499       break;
 500
 501     case '0':
 502     case '1':
 503     case '2':
 504     case '3':
 505     case '4':
 506     case '5':
 507     case '6':
 508     case '7':
 509       p = convert_octal (type, p, limit, output);
 510       break;
 511
 512     case 'u':
 513     case 'U':
 514       {
 515         int length = *p == 'u' ? 4 : 8;
 516
 517         ADVANCE;
 518         if (!isxdigit (*p))
 519           error (_("\\u used with no following hex digits"));
 520         p = convert_ucn (p, limit, dest_charset, output, length);
 521       }
 522     }
 523
 524   return p;
 525 }
 526
 527 /* Given a single string from a (C-specific) OP_STRING list, convert
 528    it to a target string, handling escape sequences specially.  The
 529    output is written to OUTPUT.  DATA is the input string, which has
 530    length LEN.  DEST_CHARSET is the name of the target character set,
 531    and TYPE is the type of target character to use.  */
 532
 533 static void
 534 parse_one_string (struct obstack *output, char *data, int len,
 535                   const char *dest_charset, struct type *type)
 536 {
 537   char *limit;
 538
 539   limit = data + len;
 540
 541   while (data < limit)
 542     {
 543       char *p = data;
 544
 545       /* Look for next escape, or the end of the input.  */
 546       while (p < limit && *p != '\\')
 547         ++p;
 548       /* If we saw a run of characters, convert them all.  */
 549       if (p > data)
 550         convert_between_encodings (host_charset (), dest_charset,
 551                                    (gdb_byte *) data, p - data, 1,
 552                                    output, translit_none);
 553       /* If we saw an escape, convert it.  */
 554       if (p < limit)
 555         p = convert_escape (type, dest_charset, p, limit, output);
 556       data = p;
 557     }
 558 }
 559
 560 /* Expression evaluator for the C language family.  Most operations
 561    are delegated to evaluate_subexp_standard; see that function for a
 562    description of the arguments.  */
 563
 564 struct value *
 565 evaluate_subexp_c (struct type *expect_type, struct expression *exp,
 566                    int *pos, enum noside noside)
 567 {
 568   enum exp_opcode op = exp->elts[*pos].opcode;
 569
 570   switch (op)
 571     {
 572     case OP_STRING:
 573       {
 574         int oplen, limit;
 575         struct type *type;
 576         struct obstack output;
 577         struct cleanup *cleanup;
 578         struct value *result;
 579         c_string_type dest_type;
 580         const char *dest_charset;
 581         int satisfy_expected = 0;
 582
 583         obstack_init (&output);
 584         cleanup = make_cleanup_obstack_free (&output);
 585
 586         ++*pos;
 587         oplen = longest_to_int (exp->elts[*pos].longconst);
 588
 589         ++*pos;
 590         limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
 591         dest_type = ((enum c_string_type_values)
 592                      longest_to_int (exp->elts[*pos].longconst));
 593         switch (dest_type & ~C_CHAR)
 594           {
 595           case C_STRING:
 596             type = language_string_char_type (exp->language_defn,
 597                                               exp->gdbarch);
 598             break;
 599           case C_WIDE_STRING:
 600             type = lookup_typename (exp->language_defn, exp->gdbarch,
 601                                     "wchar_t", NULL, 0);
 602             break;
 603           case C_STRING_16:
 604             type = lookup_typename (exp->language_defn, exp->gdbarch,
 605                                     "char16_t", NULL, 0);
 606             break;
 607           case C_STRING_32:
 608             type = lookup_typename (exp->language_defn, exp->gdbarch,
 609                                     "char32_t", NULL, 0);
 610             break;
 611           default:
 612             internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
 613           }
 614
 615         /* Ensure TYPE_LENGTH is valid for TYPE.  */
 616         check_typedef (type);
 617
 618         /* If the caller expects an array of some integral type,
 619            satisfy them.  If something odder is expected, rely on the
 620            caller to cast.  */
 621         if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
 622           {
 623             struct type *element_type
 624               = check_typedef (TYPE_TARGET_TYPE (expect_type));
 625
 626             if (TYPE_CODE (element_type) == TYPE_CODE_INT
 627                 || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
 628               {
 629                 type = element_type;
 630                 satisfy_expected = 1;
 631               }
 632           }
 633
 634         dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
 635
 636         ++*pos;
 637         while (*pos < limit)
 638           {
 639             int len;
 640
 641             len = longest_to_int (exp->elts[*pos].longconst);
 642
 643             ++*pos;
 644             if (noside != EVAL_SKIP)
 645               parse_one_string (&output, &exp->elts[*pos].string, len,
 646                                 dest_charset, type);
 647             *pos += BYTES_TO_EXP_ELEM (len);
 648           }
 649
 650         /* Skip the trailing length and opcode.  */
 651         *pos += 2;
 652
 653         if (noside == EVAL_SKIP)
 654           {
 655             /* Return a dummy value of the appropriate type.  */
 656             if (expect_type != NULL)
 657               result = allocate_value (expect_type);
 658             else if ((dest_type & C_CHAR) != 0)
 659               result = allocate_value (type);
 660             else
 661               result = value_cstring ("", 0, type);
 662             do_cleanups (cleanup);
 663             return result;
 664           }
 665
 666         if ((dest_type & C_CHAR) != 0)
 667           {
 668             LONGEST value;
 669
 670             if (obstack_object_size (&output) != TYPE_LENGTH (type))
 671               error (_("Could not convert character "
 672                        "constant to target character set"));
 673             value = unpack_long (type, (gdb_byte *) obstack_base (&output));
 674             result = value_from_longest (type, value);
 675           }
 676         else
 677           {
 678             int i;
 679
 680             /* Write the terminating character.  */
 681             for (i = 0; i < TYPE_LENGTH (type); ++i)
 682               obstack_1grow (&output, 0);
 683
 684             if (satisfy_expected)
 685               {
 686                 LONGEST low_bound, high_bound;
 687                 int element_size = TYPE_LENGTH (type);
 688
 689                 if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
 690                                          &low_bound, &high_bound) < 0)
 691                   {
 692                     low_bound = 0;
 693                     high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
 694                   }
 695                 if (obstack_object_size (&output) / element_size
 696                     > (high_bound - low_bound + 1))
 697                   error (_("Too many array elements"));
 698
 699                 result = allocate_value (expect_type);
 700                 memcpy (value_contents_raw (result), obstack_base (&output),
 701                         obstack_object_size (&output));
 702               }
 703             else
 704               result = value_cstring ((const char *) obstack_base (&output),
 705                                       obstack_object_size (&output),
 706                                       type);
 707           }
 708         do_cleanups (cleanup);
 709         return result;
 710       }
 711       break;
 712
 713     default:
 714       break;
 715     }
 716   return evaluate_subexp_standard (expect_type, exp, pos, noside);
 717 }
 718
 719
 720 \f
 721 /* Table mapping opcodes into strings for printing operators
 722    and precedences of the operators.  */
 723
 724 const struct op_print c_op_print_tab[] =
 725 {
 726   {",", BINOP_COMMA, PREC_COMMA, 0},
 727   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 728   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 729   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 730   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 731   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 732   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 733   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 734   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 735   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 736   {">=", BINOP_GEQ, PREC_ORDER, 0},
 737   {">", BINOP_GTR, PREC_ORDER, 0},
 738   {"<", BINOP_LESS, PREC_ORDER, 0},
 739   {">>", BINOP_RSH, PREC_SHIFT, 0},
 740   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 741   {"+", BINOP_ADD, PREC_ADD, 0},
 742   {"-", BINOP_SUB, PREC_ADD, 0},
 743   {"*", BINOP_MUL, PREC_MUL, 0},
 744   {"/", BINOP_DIV, PREC_MUL, 0},
 745   {"%", BINOP_REM, PREC_MUL, 0},
 746   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 747   {"+", UNOP_PLUS, PREC_PREFIX, 0},
 748   {"-", UNOP_NEG, PREC_PREFIX, 0},
 749   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 750   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 751   {"*", UNOP_IND, PREC_PREFIX, 0},
 752   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 753   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 754   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 755   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 756   {NULL, OP_NULL, PREC_PREFIX, 0}
 757 };
 758 \f
 759 enum c_primitive_types {
 760   c_primitive_type_int,
 761   c_primitive_type_long,
 762   c_primitive_type_short,
 763   c_primitive_type_char,
 764   c_primitive_type_float,
 765   c_primitive_type_double,
 766   c_primitive_type_void,
 767   c_primitive_type_long_long,
 768   c_primitive_type_signed_char,
 769   c_primitive_type_unsigned_char,
 770   c_primitive_type_unsigned_short,
 771   c_primitive_type_unsigned_int,
 772   c_primitive_type_unsigned_long,
 773   c_primitive_type_unsigned_long_long,
 774   c_primitive_type_long_double,
 775   c_primitive_type_complex,
 776   c_primitive_type_double_complex,
 777   c_primitive_type_decfloat,
 778   c_primitive_type_decdouble,
 779   c_primitive_type_declong,
 780   nr_c_primitive_types
 781 };
 782
 783 void
 784 c_language_arch_info (struct gdbarch *gdbarch,
 785                       struct language_arch_info *lai)
 786 {
 787   const struct builtin_type *builtin = builtin_type (gdbarch);
 788
 789   lai->string_char_type = builtin->builtin_char;
 790   lai->primitive_type_vector
 791     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 792                               struct type *);
 793   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 794   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 795   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 796   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 797   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 798   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 799   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 800   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 801   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 802   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 803   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 804   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 805   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 806   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 807   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 808   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 809   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 810   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 811   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 812   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 813
 814   lai->bool_type_default = builtin->builtin_int;
 815 }
 816
 817 const struct exp_descriptor exp_descriptor_c =
 818 {
 819   print_subexp_standard,
 820   operator_length_standard,
 821   operator_check_standard,
 822   op_name_standard,
 823   dump_subexp_body_standard,
 824   evaluate_subexp_c
 825 };
 826
 827 static const char *c_extensions[] =
 828 {
 829   ".c", NULL
 830 };
 831
 832 const struct language_defn c_language_defn =
 833 {
 834   "c",                          /* Language name */
 835   "C",
 836   language_c,
 837   range_check_off,
 838   case_sensitive_on,
 839   array_row_major,
 840   macro_expansion_c,
 841   c_extensions,
 842   &exp_descriptor_c,
 843   c_parse,
 844   c_yyerror,
 845   null_post_parser,
 846   c_printchar,                  /* Print a character constant */
 847   c_printstr,                   /* Function to print string constant */
 848   c_emit_char,                  /* Print a single char */
 849   c_print_type,                 /* Print a type using appropriate syntax */
 850   c_print_typedef,              /* Print a typedef using appropriate syntax */
 851   c_val_print,                  /* Print a value using appropriate syntax */
 852   c_value_print,                /* Print a top-level value */
 853   default_read_var_value,       /* la_read_var_value */
 854   NULL,                         /* Language specific skip_trampoline */
 855   NULL,                         /* name_of_this */
 856   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 857   basic_lookup_transparent_type,/* lookup_transparent_type */
 858   NULL,                         /* Language specific symbol demangler */
 859   NULL,
 860   NULL,                         /* Language specific
 861                                    class_name_from_physname */
 862   c_op_print_tab,               /* expression operators for printing */
 863   1,                            /* c-style arrays */
 864   0,                            /* String lower bound */
 865   default_word_break_characters,
 866   default_make_symbol_completion_list,
 867   c_language_arch_info,
 868   default_print_array_index,
 869   default_pass_by_reference,
 870   c_get_string,
 871   NULL,                         /* la_get_symbol_name_cmp */
 872   iterate_over_symbols,
 873   &c_varobj_ops,
 874   c_get_compile_context,
 875   c_compute_program,
 876   LANG_MAGIC
 877 };
 878
 879 enum cplus_primitive_types {
 880   cplus_primitive_type_int,
 881   cplus_primitive_type_long,
 882   cplus_primitive_type_short,
 883   cplus_primitive_type_char,
 884   cplus_primitive_type_float,
 885   cplus_primitive_type_double,
 886   cplus_primitive_type_void,
 887   cplus_primitive_type_long_long,
 888   cplus_primitive_type_signed_char,
 889   cplus_primitive_type_unsigned_char,
 890   cplus_primitive_type_unsigned_short,
 891   cplus_primitive_type_unsigned_int,
 892   cplus_primitive_type_unsigned_long,
 893   cplus_primitive_type_unsigned_long_long,
 894   cplus_primitive_type_long_double,
 895   cplus_primitive_type_complex,
 896   cplus_primitive_type_double_complex,
 897   cplus_primitive_type_bool,
 898   cplus_primitive_type_decfloat,
 899   cplus_primitive_type_decdouble,
 900   cplus_primitive_type_declong,
 901   nr_cplus_primitive_types
 902 };
 903
 904 static void
 905 cplus_language_arch_info (struct gdbarch *gdbarch,
 906                           struct language_arch_info *lai)
 907 {
 908   const struct builtin_type *builtin = builtin_type (gdbarch);
 909
 910   lai->string_char_type = builtin->builtin_char;
 911   lai->primitive_type_vector
 912     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 913                               struct type *);
 914   lai->primitive_type_vector [cplus_primitive_type_int]
 915     = builtin->builtin_int;
 916   lai->primitive_type_vector [cplus_primitive_type_long]
 917     = builtin->builtin_long;
 918   lai->primitive_type_vector [cplus_primitive_type_short]
 919     = builtin->builtin_short;
 920   lai->primitive_type_vector [cplus_primitive_type_char]
 921     = builtin->builtin_char;
 922   lai->primitive_type_vector [cplus_primitive_type_float]
 923     = builtin->builtin_float;
 924   lai->primitive_type_vector [cplus_primitive_type_double]
 925     = builtin->builtin_double;
 926   lai->primitive_type_vector [cplus_primitive_type_void]
 927     = builtin->builtin_void;
 928   lai->primitive_type_vector [cplus_primitive_type_long_long]
 929     = builtin->builtin_long_long;
 930   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 931     = builtin->builtin_signed_char;
 932   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 933     = builtin->builtin_unsigned_char;
 934   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 935     = builtin->builtin_unsigned_short;
 936   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 937     = builtin->builtin_unsigned_int;
 938   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 939     = builtin->builtin_unsigned_long;
 940   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 941     = builtin->builtin_unsigned_long_long;
 942   lai->primitive_type_vector [cplus_primitive_type_long_double]
 943     = builtin->builtin_long_double;
 944   lai->primitive_type_vector [cplus_primitive_type_complex]
 945     = builtin->builtin_complex;
 946   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 947     = builtin->builtin_double_complex;
 948   lai->primitive_type_vector [cplus_primitive_type_bool]
 949     = builtin->builtin_bool;
 950   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 951     = builtin->builtin_decfloat;
 952   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 953     = builtin->builtin_decdouble;
 954   lai->primitive_type_vector [cplus_primitive_type_declong]
 955     = builtin->builtin_declong;
 956
 957   lai->bool_type_symbol = "bool";
 958   lai->bool_type_default = builtin->builtin_bool;
 959 }
 960
 961 static const char *cplus_extensions[] =
 962 {
 963   ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
 964 };
 965
 966 const struct language_defn cplus_language_defn =
 967 {
 968   "c++",                        /* Language name */
 969   "C++",
 970   language_cplus,
 971   range_check_off,
 972   case_sensitive_on,
 973   array_row_major,
 974   macro_expansion_c,
 975   cplus_extensions,
 976   &exp_descriptor_c,
 977   c_parse,
 978   c_yyerror,
 979   null_post_parser,
 980   c_printchar,                  /* Print a character constant */
 981   c_printstr,                   /* Function to print string constant */
 982   c_emit_char,                  /* Print a single char */
 983   c_print_type,                 /* Print a type using appropriate syntax */
 984   c_print_typedef,              /* Print a typedef using appropriate syntax */
 985   c_val_print,                  /* Print a value using appropriate syntax */
 986   c_value_print,                /* Print a top-level value */
 987   default_read_var_value,       /* la_read_var_value */
 988   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 989   "this",                       /* name_of_this */
 990   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 991   cp_lookup_transparent_type,   /* lookup_transparent_type */
 992   gdb_demangle,                 /* Language specific symbol demangler */
 993   gdb_sniff_from_mangled_name,
 994   cp_class_name_from_physname,  /* Language specific
 995                                    class_name_from_physname */
 996   c_op_print_tab,               /* expression operators for printing */
 997   1,                            /* c-style arrays */
 998   0,                            /* String lower bound */
 999   default_word_break_characters,
1000   default_make_symbol_completion_list,
1001   cplus_language_arch_info,
1002   default_print_array_index,
1003   cp_pass_by_reference,
1004   c_get_string,
1005   NULL,                         /* la_get_symbol_name_cmp */
1006   iterate_over_symbols,
1007   &cplus_varobj_ops,
1008   NULL,
1009   NULL,
1010   LANG_MAGIC
1011 };
1012
1013 static const char *asm_extensions[] =
1014 {
1015   ".s", ".sx", ".S", NULL
1016 };
1017
1018 const struct language_defn asm_language_defn =
1019 {
1020   "asm",                        /* Language name */
1021   "assembly",
1022   language_asm,
1023   range_check_off,
1024   case_sensitive_on,
1025   array_row_major,
1026   macro_expansion_c,
1027   asm_extensions,
1028   &exp_descriptor_c,
1029   c_parse,
1030   c_yyerror,
1031   null_post_parser,
1032   c_printchar,                  /* Print a character constant */
1033   c_printstr,                   /* Function to print string constant */
1034   c_emit_char,                  /* Print a single char */
1035   c_print_type,                 /* Print a type using appropriate syntax */
1036   c_print_typedef,              /* Print a typedef using appropriate syntax */
1037   c_val_print,                  /* Print a value using appropriate syntax */
1038   c_value_print,                /* Print a top-level value */
1039   default_read_var_value,       /* la_read_var_value */
1040   NULL,                         /* Language specific skip_trampoline */
1041   NULL,                         /* name_of_this */
1042   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1043   basic_lookup_transparent_type,/* lookup_transparent_type */
1044   NULL,                         /* Language specific symbol demangler */
1045   NULL,
1046   NULL,                         /* Language specific
1047                                    class_name_from_physname */
1048   c_op_print_tab,               /* expression operators for printing */
1049   1,                            /* c-style arrays */
1050   0,                            /* String lower bound */
1051   default_word_break_characters,
1052   default_make_symbol_completion_list,
1053   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1054   default_print_array_index,
1055   default_pass_by_reference,
1056   c_get_string,
1057   NULL,                         /* la_get_symbol_name_cmp */
1058   iterate_over_symbols,
1059   &default_varobj_ops,
1060   NULL,
1061   NULL,
1062   LANG_MAGIC
1063 };
1064
1065 /* The following language_defn does not represent a real language.
1066    It just provides a minimal support a-la-C that should allow users
1067    to do some simple operations when debugging applications that use
1068    a language currently not supported by GDB.  */
1069
1070 const struct language_defn minimal_language_defn =
1071 {
1072   "minimal",                    /* Language name */
1073   "Minimal",
1074   language_minimal,
1075   range_check_off,
1076   case_sensitive_on,
1077   array_row_major,
1078   macro_expansion_c,
1079   NULL,
1080   &exp_descriptor_c,
1081   c_parse,
1082   c_yyerror,
1083   null_post_parser,
1084   c_printchar,                  /* Print a character constant */
1085   c_printstr,                   /* Function to print string constant */
1086   c_emit_char,                  /* Print a single char */
1087   c_print_type,                 /* Print a type using appropriate syntax */
1088   c_print_typedef,              /* Print a typedef using appropriate syntax */
1089   c_val_print,                  /* Print a value using appropriate syntax */
1090   c_value_print,                /* Print a top-level value */
1091   default_read_var_value,       /* la_read_var_value */
1092   NULL,                         /* Language specific skip_trampoline */
1093   NULL,                         /* name_of_this */
1094   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1095   basic_lookup_transparent_type,/* lookup_transparent_type */
1096   NULL,                         /* Language specific symbol demangler */
1097   NULL,
1098   NULL,                         /* Language specific
1099                                    class_name_from_physname */
1100   c_op_print_tab,               /* expression operators for printing */
1101   1,                            /* c-style arrays */
1102   0,                            /* String lower bound */
1103   default_word_break_characters,
1104   default_make_symbol_completion_list,
1105   c_language_arch_info,
1106   default_print_array_index,
1107   default_pass_by_reference,
1108   c_get_string,
1109   NULL,                         /* la_get_symbol_name_cmp */
1110   iterate_over_symbols,
1111   &default_varobj_ops,
1112   NULL,
1113   NULL,
1114   LANG_MAGIC
1115 };
1116
1117 void
1118 _initialize_c_language (void)
1119 {
1120   add_language (&c_language_defn);
1121   add_language (&cplus_language_defn);
1122   add_language (&asm_language_defn);
1123   add_language (&minimal_language_defn);
1124 }