contrib/gdb-7/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       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   int width = TYPE_LENGTH (type);
 206   struct obstack wchar_buf, output;
 207   struct cleanup *cleanup;
 208   struct wchar_iterator *iter;
 209   int finished = 0;
 210   int need_escape = 0;
 211
 212   str_type = (classify_type (type, get_type_arch (type), &type_encoding)
 213               & ~C_CHAR);
 214   switch (str_type)
 215     {
 216     case C_STRING:
 217       break;
 218     case C_WIDE_STRING:
 219       fputs_filtered ("L", stream);
 220       break;
 221     case C_STRING_16:
 222       fputs_filtered ("u", stream);
 223       break;
 224     case C_STRING_32:
 225       fputs_filtered ("U", stream);
 226       break;
 227     }
 228
 229   encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
 230
 231   generic_printstr (stream, type, string, length, encoding, force_ellipses,
 232                     '"', 1, options);
 233 }
 234
 235 /* Obtain a C string from the inferior storing it in a newly allocated
 236    buffer in BUFFER, which should be freed by the caller.  If the in-
 237    and out-parameter *LENGTH is specified at -1, the string is read
 238    until a null character of the appropriate width is found, otherwise
 239    the string is read to the length of characters specified.  The size
 240    of a character is determined by the length of the target type of
 241    the pointer or array.  If VALUE is an array with a known length,
 242    the function will not read past the end of the array.  On
 243    completion, *LENGTH will be set to the size of the string read in
 244    characters.  (If a length of -1 is specified, the length returned
 245    will not include the null character).  CHARSET is always set to the
 246    target charset.  */
 247
 248 void
 249 c_get_string (struct value *value, gdb_byte **buffer,
 250               int *length, struct type **char_type,
 251               const char **charset)
 252 {
 253   int err, width;
 254   unsigned int fetchlimit;
 255   struct type *type = check_typedef (value_type (value));
 256   struct type *element_type = TYPE_TARGET_TYPE (type);
 257   int req_length = *length;
 258   enum bfd_endian byte_order
 259     = gdbarch_byte_order (get_type_arch (type));
 260   enum c_string_type kind;
 261
 262   if (element_type == NULL)
 263     goto error;
 264
 265   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 266     {
 267       /* If we know the size of the array, we can use it as a limit on
 268          the number of characters to be fetched.  */
 269       if (TYPE_NFIELDS (type) == 1
 270           && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
 271         {
 272           LONGEST low_bound, high_bound;
 273
 274           get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
 275                                &low_bound, &high_bound);
 276           fetchlimit = high_bound - low_bound + 1;
 277         }
 278       else
 279         fetchlimit = UINT_MAX;
 280     }
 281   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
 282     fetchlimit = UINT_MAX;
 283   else
 284     /* We work only with arrays and pointers.  */
 285     goto error;
 286
 287   if (! c_textual_element_type (element_type, 0))
 288     goto error;
 289   kind = classify_type (element_type,
 290                         get_type_arch (element_type),
 291                         charset);
 292   width = TYPE_LENGTH (element_type);
 293
 294   /* If the string lives in GDB's memory instead of the inferior's,
 295      then we just need to copy it to BUFFER.  Also, since such strings
 296      are arrays with known size, FETCHLIMIT will hold the size of the
 297      array.  */
 298   if ((VALUE_LVAL (value) == not_lval
 299        || VALUE_LVAL (value) == lval_internalvar)
 300       && fetchlimit != UINT_MAX)
 301     {
 302       int i;
 303       const gdb_byte *contents = value_contents (value);
 304
 305       /* If a length is specified, use that.  */
 306       if (*length >= 0)
 307         i  = *length;
 308       else
 309         /* Otherwise, look for a null character.  */
 310         for (i = 0; i < fetchlimit; i++)
 311           if (extract_unsigned_integer (contents + i * width,
 312                                         width, byte_order) == 0)
 313             break;
 314
 315       /* I is now either a user-defined length, the number of non-null
 316          characters, or FETCHLIMIT.  */
 317       *length = i * width;
 318       *buffer = xmalloc (*length);
 319       memcpy (*buffer, contents, *length);
 320       err = 0;
 321     }
 322   else
 323     {
 324       CORE_ADDR addr = value_as_address (value);
 325
 326       err = read_string (addr, *length, width, fetchlimit,
 327                          byte_order, buffer, length);
 328       if (err)
 329         {
 330           xfree (*buffer);
 331           if (err == EIO)
 332             throw_error (MEMORY_ERROR, "Address %s out of bounds",
 333                          paddress (get_type_arch (type), addr));
 334           else
 335             error (_("Error reading string from inferior: %s"),
 336                    safe_strerror (err));
 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                                    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, 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_NEG, PREC_PREFIX, 0},
 752   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 753   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 754   {"*", UNOP_IND, PREC_PREFIX, 0},
 755   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 756   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 757   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 758   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 759   {NULL, 0, 0, 0}
 760 };
 761 \f
 762 enum c_primitive_types {
 763   c_primitive_type_int,
 764   c_primitive_type_long,
 765   c_primitive_type_short,
 766   c_primitive_type_char,
 767   c_primitive_type_float,
 768   c_primitive_type_double,
 769   c_primitive_type_void,
 770   c_primitive_type_long_long,
 771   c_primitive_type_signed_char,
 772   c_primitive_type_unsigned_char,
 773   c_primitive_type_unsigned_short,
 774   c_primitive_type_unsigned_int,
 775   c_primitive_type_unsigned_long,
 776   c_primitive_type_unsigned_long_long,
 777   c_primitive_type_long_double,
 778   c_primitive_type_complex,
 779   c_primitive_type_double_complex,
 780   c_primitive_type_decfloat,
 781   c_primitive_type_decdouble,
 782   c_primitive_type_declong,
 783   nr_c_primitive_types
 784 };
 785
 786 void
 787 c_language_arch_info (struct gdbarch *gdbarch,
 788                       struct language_arch_info *lai)
 789 {
 790   const struct builtin_type *builtin = builtin_type (gdbarch);
 791
 792   lai->string_char_type = builtin->builtin_char;
 793   lai->primitive_type_vector
 794     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 795                               struct type *);
 796   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 797   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 798   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 799   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 800   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 801   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 802   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 803   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 804   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 805   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 806   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 807   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 808   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 809   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 810   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 811   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 812   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 813   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 814   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 815   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 816
 817   lai->bool_type_default = builtin->builtin_int;
 818 }
 819
 820 const struct exp_descriptor exp_descriptor_c =
 821 {
 822   print_subexp_standard,
 823   operator_length_standard,
 824   operator_check_standard,
 825   op_name_standard,
 826   dump_subexp_body_standard,
 827   evaluate_subexp_c
 828 };
 829
 830 const struct language_defn c_language_defn =
 831 {
 832   "c",                          /* Language name */
 833   language_c,
 834   range_check_off,
 835   type_check_off,
 836   case_sensitive_on,
 837   array_row_major,
 838   macro_expansion_c,
 839   &exp_descriptor_c,
 840   c_parse,
 841   c_error,
 842   null_post_parser,
 843   c_printchar,                  /* Print a character constant */
 844   c_printstr,                   /* Function to print string constant */
 845   c_emit_char,                  /* Print a single char */
 846   c_print_type,                 /* Print a type using appropriate syntax */
 847   c_print_typedef,              /* Print a typedef using appropriate syntax */
 848   c_val_print,                  /* Print a value using appropriate syntax */
 849   c_value_print,                /* Print a top-level value */
 850   NULL,                         /* Language specific skip_trampoline */
 851   NULL,                         /* name_of_this */
 852   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 853   basic_lookup_transparent_type,/* lookup_transparent_type */
 854   NULL,                         /* Language specific symbol demangler */
 855   NULL,                         /* Language specific
 856                                    class_name_from_physname */
 857   c_op_print_tab,               /* expression operators for printing */
 858   1,                            /* c-style arrays */
 859   0,                            /* String lower bound */
 860   default_word_break_characters,
 861   default_make_symbol_completion_list,
 862   c_language_arch_info,
 863   default_print_array_index,
 864   default_pass_by_reference,
 865   c_get_string,
 866   strcmp_iw_ordered,
 867   iterate_over_symbols,
 868   LANG_MAGIC
 869 };
 870
 871 enum cplus_primitive_types {
 872   cplus_primitive_type_int,
 873   cplus_primitive_type_long,
 874   cplus_primitive_type_short,
 875   cplus_primitive_type_char,
 876   cplus_primitive_type_float,
 877   cplus_primitive_type_double,
 878   cplus_primitive_type_void,
 879   cplus_primitive_type_long_long,
 880   cplus_primitive_type_signed_char,
 881   cplus_primitive_type_unsigned_char,
 882   cplus_primitive_type_unsigned_short,
 883   cplus_primitive_type_unsigned_int,
 884   cplus_primitive_type_unsigned_long,
 885   cplus_primitive_type_unsigned_long_long,
 886   cplus_primitive_type_long_double,
 887   cplus_primitive_type_complex,
 888   cplus_primitive_type_double_complex,
 889   cplus_primitive_type_bool,
 890   cplus_primitive_type_decfloat,
 891   cplus_primitive_type_decdouble,
 892   cplus_primitive_type_declong,
 893   nr_cplus_primitive_types
 894 };
 895
 896 static void
 897 cplus_language_arch_info (struct gdbarch *gdbarch,
 898                           struct language_arch_info *lai)
 899 {
 900   const struct builtin_type *builtin = builtin_type (gdbarch);
 901
 902   lai->string_char_type = builtin->builtin_char;
 903   lai->primitive_type_vector
 904     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 905                               struct type *);
 906   lai->primitive_type_vector [cplus_primitive_type_int]
 907     = builtin->builtin_int;
 908   lai->primitive_type_vector [cplus_primitive_type_long]
 909     = builtin->builtin_long;
 910   lai->primitive_type_vector [cplus_primitive_type_short]
 911     = builtin->builtin_short;
 912   lai->primitive_type_vector [cplus_primitive_type_char]
 913     = builtin->builtin_char;
 914   lai->primitive_type_vector [cplus_primitive_type_float]
 915     = builtin->builtin_float;
 916   lai->primitive_type_vector [cplus_primitive_type_double]
 917     = builtin->builtin_double;
 918   lai->primitive_type_vector [cplus_primitive_type_void]
 919     = builtin->builtin_void;
 920   lai->primitive_type_vector [cplus_primitive_type_long_long]
 921     = builtin->builtin_long_long;
 922   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 923     = builtin->builtin_signed_char;
 924   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 925     = builtin->builtin_unsigned_char;
 926   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 927     = builtin->builtin_unsigned_short;
 928   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 929     = builtin->builtin_unsigned_int;
 930   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 931     = builtin->builtin_unsigned_long;
 932   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 933     = builtin->builtin_unsigned_long_long;
 934   lai->primitive_type_vector [cplus_primitive_type_long_double]
 935     = builtin->builtin_long_double;
 936   lai->primitive_type_vector [cplus_primitive_type_complex]
 937     = builtin->builtin_complex;
 938   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 939     = builtin->builtin_double_complex;
 940   lai->primitive_type_vector [cplus_primitive_type_bool]
 941     = builtin->builtin_bool;
 942   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 943     = builtin->builtin_decfloat;
 944   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 945     = builtin->builtin_decdouble;
 946   lai->primitive_type_vector [cplus_primitive_type_declong]
 947     = builtin->builtin_declong;
 948
 949   lai->bool_type_symbol = "bool";
 950   lai->bool_type_default = builtin->builtin_bool;
 951 }
 952
 953 const struct language_defn cplus_language_defn =
 954 {
 955   "c++",                        /* Language name */
 956   language_cplus,
 957   range_check_off,
 958   type_check_off,
 959   case_sensitive_on,
 960   array_row_major,
 961   macro_expansion_c,
 962   &exp_descriptor_c,
 963   c_parse,
 964   c_error,
 965   null_post_parser,
 966   c_printchar,                  /* Print a character constant */
 967   c_printstr,                   /* Function to print string constant */
 968   c_emit_char,                  /* Print a single char */
 969   c_print_type,                 /* Print a type using appropriate syntax */
 970   c_print_typedef,              /* Print a typedef using appropriate syntax */
 971   c_val_print,                  /* Print a value using appropriate syntax */
 972   c_value_print,                /* Print a top-level value */
 973   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 974   "this",                       /* name_of_this */
 975   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 976   cp_lookup_transparent_type,   /* lookup_transparent_type */
 977   cplus_demangle,               /* Language specific symbol demangler */
 978   cp_class_name_from_physname,  /* Language specific
 979                                    class_name_from_physname */
 980   c_op_print_tab,               /* expression operators for printing */
 981   1,                            /* c-style arrays */
 982   0,                            /* String lower bound */
 983   default_word_break_characters,
 984   default_make_symbol_completion_list,
 985   cplus_language_arch_info,
 986   default_print_array_index,
 987   cp_pass_by_reference,
 988   c_get_string,
 989   strcmp_iw_ordered,
 990   iterate_over_symbols,
 991   LANG_MAGIC
 992 };
 993
 994 const struct language_defn asm_language_defn =
 995 {
 996   "asm",                        /* Language name */
 997   language_asm,
 998   range_check_off,
 999   type_check_off,
1000   case_sensitive_on,
1001   array_row_major,
1002   macro_expansion_c,
1003   &exp_descriptor_c,
1004   c_parse,
1005   c_error,
1006   null_post_parser,
1007   c_printchar,                  /* Print a character constant */
1008   c_printstr,                   /* Function to print string constant */
1009   c_emit_char,                  /* Print a single char */
1010   c_print_type,                 /* Print a type using appropriate syntax */
1011   c_print_typedef,              /* Print a typedef using appropriate syntax */
1012   c_val_print,                  /* Print a value using appropriate syntax */
1013   c_value_print,                /* Print a top-level value */
1014   NULL,                         /* Language specific skip_trampoline */
1015   NULL,                         /* name_of_this */
1016   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1017   basic_lookup_transparent_type,/* lookup_transparent_type */
1018   NULL,                         /* Language specific symbol demangler */
1019   NULL,                         /* Language specific
1020                                    class_name_from_physname */
1021   c_op_print_tab,               /* expression operators for printing */
1022   1,                            /* c-style arrays */
1023   0,                            /* String lower bound */
1024   default_word_break_characters,
1025   default_make_symbol_completion_list,
1026   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1027   default_print_array_index,
1028   default_pass_by_reference,
1029   c_get_string,
1030   strcmp_iw_ordered,
1031   iterate_over_symbols,
1032   LANG_MAGIC
1033 };
1034
1035 /* The following language_defn does not represent a real language.
1036    It just provides a minimal support a-la-C that should allow users
1037    to do some simple operations when debugging applications that use
1038    a language currently not supported by GDB.  */
1039
1040 const struct language_defn minimal_language_defn =
1041 {
1042   "minimal",                    /* Language name */
1043   language_minimal,
1044   range_check_off,
1045   type_check_off,
1046   case_sensitive_on,
1047   array_row_major,
1048   macro_expansion_c,
1049   &exp_descriptor_c,
1050   c_parse,
1051   c_error,
1052   null_post_parser,
1053   c_printchar,                  /* Print a character constant */
1054   c_printstr,                   /* Function to print string constant */
1055   c_emit_char,                  /* Print a single char */
1056   c_print_type,                 /* Print a type using appropriate syntax */
1057   c_print_typedef,              /* Print a typedef using appropriate syntax */
1058   c_val_print,                  /* Print a value using appropriate syntax */
1059   c_value_print,                /* Print a top-level value */
1060   NULL,                         /* Language specific skip_trampoline */
1061   NULL,                         /* name_of_this */
1062   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1063   basic_lookup_transparent_type,/* lookup_transparent_type */
1064   NULL,                         /* Language specific symbol demangler */
1065   NULL,                         /* Language specific
1066                                    class_name_from_physname */
1067   c_op_print_tab,               /* expression operators for printing */
1068   1,                            /* c-style arrays */
1069   0,                            /* String lower bound */
1070   default_word_break_characters,
1071   default_make_symbol_completion_list,
1072   c_language_arch_info,
1073   default_print_array_index,
1074   default_pass_by_reference,
1075   c_get_string,
1076   strcmp_iw_ordered,
1077   iterate_over_symbols,
1078   LANG_MAGIC
1079 };
1080
1081 void
1082 _initialize_c_language (void)
1083 {
1084   add_language (&c_language_defn);
1085   add_language (&cplus_language_defn);
1086   add_language (&asm_language_defn);
1087   add_language (&minimal_language_defn);
1088 }