gdb/c-lang.c

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