gdb/c-lang.c

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