gdb/c-lang.c

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