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   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   default_read_var_value,       /* la_read_var_value */
 851   NULL,                         /* Language specific skip_trampoline */
 852   NULL,                         /* name_of_this */
 853   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 854   basic_lookup_transparent_type,/* lookup_transparent_type */
 855   NULL,                         /* Language specific symbol demangler */
 856   NULL,                         /* Language specific
 857                                    class_name_from_physname */
 858   c_op_print_tab,               /* expression operators for printing */
 859   1,                            /* c-style arrays */
 860   0,                            /* String lower bound */
 861   default_word_break_characters,
 862   default_make_symbol_completion_list,
 863   c_language_arch_info,
 864   default_print_array_index,
 865   default_pass_by_reference,
 866   c_get_string,
 867   NULL,                         /* la_get_symbol_name_cmp */
 868   iterate_over_symbols,
 869   LANG_MAGIC
 870 };
 871
 872 enum cplus_primitive_types {
 873   cplus_primitive_type_int,
 874   cplus_primitive_type_long,
 875   cplus_primitive_type_short,
 876   cplus_primitive_type_char,
 877   cplus_primitive_type_float,
 878   cplus_primitive_type_double,
 879   cplus_primitive_type_void,
 880   cplus_primitive_type_long_long,
 881   cplus_primitive_type_signed_char,
 882   cplus_primitive_type_unsigned_char,
 883   cplus_primitive_type_unsigned_short,
 884   cplus_primitive_type_unsigned_int,
 885   cplus_primitive_type_unsigned_long,
 886   cplus_primitive_type_unsigned_long_long,
 887   cplus_primitive_type_long_double,
 888   cplus_primitive_type_complex,
 889   cplus_primitive_type_double_complex,
 890   cplus_primitive_type_bool,
 891   cplus_primitive_type_decfloat,
 892   cplus_primitive_type_decdouble,
 893   cplus_primitive_type_declong,
 894   nr_cplus_primitive_types
 895 };
 896
 897 static void
 898 cplus_language_arch_info (struct gdbarch *gdbarch,
 899                           struct language_arch_info *lai)
 900 {
 901   const struct builtin_type *builtin = builtin_type (gdbarch);
 902
 903   lai->string_char_type = builtin->builtin_char;
 904   lai->primitive_type_vector
 905     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 906                               struct type *);
 907   lai->primitive_type_vector [cplus_primitive_type_int]
 908     = builtin->builtin_int;
 909   lai->primitive_type_vector [cplus_primitive_type_long]
 910     = builtin->builtin_long;
 911   lai->primitive_type_vector [cplus_primitive_type_short]
 912     = builtin->builtin_short;
 913   lai->primitive_type_vector [cplus_primitive_type_char]
 914     = builtin->builtin_char;
 915   lai->primitive_type_vector [cplus_primitive_type_float]
 916     = builtin->builtin_float;
 917   lai->primitive_type_vector [cplus_primitive_type_double]
 918     = builtin->builtin_double;
 919   lai->primitive_type_vector [cplus_primitive_type_void]
 920     = builtin->builtin_void;
 921   lai->primitive_type_vector [cplus_primitive_type_long_long]
 922     = builtin->builtin_long_long;
 923   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 924     = builtin->builtin_signed_char;
 925   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 926     = builtin->builtin_unsigned_char;
 927   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 928     = builtin->builtin_unsigned_short;
 929   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 930     = builtin->builtin_unsigned_int;
 931   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 932     = builtin->builtin_unsigned_long;
 933   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 934     = builtin->builtin_unsigned_long_long;
 935   lai->primitive_type_vector [cplus_primitive_type_long_double]
 936     = builtin->builtin_long_double;
 937   lai->primitive_type_vector [cplus_primitive_type_complex]
 938     = builtin->builtin_complex;
 939   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 940     = builtin->builtin_double_complex;
 941   lai->primitive_type_vector [cplus_primitive_type_bool]
 942     = builtin->builtin_bool;
 943   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 944     = builtin->builtin_decfloat;
 945   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 946     = builtin->builtin_decdouble;
 947   lai->primitive_type_vector [cplus_primitive_type_declong]
 948     = builtin->builtin_declong;
 949
 950   lai->bool_type_symbol = "bool";
 951   lai->bool_type_default = builtin->builtin_bool;
 952 }
 953
 954 const struct language_defn cplus_language_defn =
 955 {
 956   "c++",                        /* Language name */
 957   language_cplus,
 958   range_check_off,
 959   type_check_off,
 960   case_sensitive_on,
 961   array_row_major,
 962   macro_expansion_c,
 963   &exp_descriptor_c,
 964   c_parse,
 965   c_error,
 966   null_post_parser,
 967   c_printchar,                  /* Print a character constant */
 968   c_printstr,                   /* Function to print string constant */
 969   c_emit_char,                  /* Print a single char */
 970   c_print_type,                 /* Print a type using appropriate syntax */
 971   c_print_typedef,              /* Print a typedef using appropriate syntax */
 972   c_val_print,                  /* Print a value using appropriate syntax */
 973   c_value_print,                /* Print a top-level value */
 974   default_read_var_value,       /* la_read_var_value */
 975   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 976   "this",                       /* name_of_this */
 977   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 978   cp_lookup_transparent_type,   /* lookup_transparent_type */
 979   cplus_demangle,               /* Language specific symbol demangler */
 980   cp_class_name_from_physname,  /* Language specific
 981                                    class_name_from_physname */
 982   c_op_print_tab,               /* expression operators for printing */
 983   1,                            /* c-style arrays */
 984   0,                            /* String lower bound */
 985   default_word_break_characters,
 986   default_make_symbol_completion_list,
 987   cplus_language_arch_info,
 988   default_print_array_index,
 989   cp_pass_by_reference,
 990   c_get_string,
 991   NULL,                         /* la_get_symbol_name_cmp */
 992   iterate_over_symbols,
 993   LANG_MAGIC
 994 };
 995
 996 const struct language_defn asm_language_defn =
 997 {
 998   "asm",                        /* Language name */
 999   language_asm,
1000   range_check_off,
1001   type_check_off,
1002   case_sensitive_on,
1003   array_row_major,
1004   macro_expansion_c,
1005   &exp_descriptor_c,
1006   c_parse,
1007   c_error,
1008   null_post_parser,
1009   c_printchar,                  /* Print a character constant */
1010   c_printstr,                   /* Function to print string constant */
1011   c_emit_char,                  /* Print a single char */
1012   c_print_type,                 /* Print a type using appropriate syntax */
1013   c_print_typedef,              /* Print a typedef using appropriate syntax */
1014   c_val_print,                  /* Print a value using appropriate syntax */
1015   c_value_print,                /* Print a top-level value */
1016   default_read_var_value,       /* la_read_var_value */
1017   NULL,                         /* Language specific skip_trampoline */
1018   NULL,                         /* name_of_this */
1019   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1020   basic_lookup_transparent_type,/* lookup_transparent_type */
1021   NULL,                         /* Language specific symbol demangler */
1022   NULL,                         /* Language specific
1023                                    class_name_from_physname */
1024   c_op_print_tab,               /* expression operators for printing */
1025   1,                            /* c-style arrays */
1026   0,                            /* String lower bound */
1027   default_word_break_characters,
1028   default_make_symbol_completion_list,
1029   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1030   default_print_array_index,
1031   default_pass_by_reference,
1032   c_get_string,
1033   NULL,                         /* la_get_symbol_name_cmp */
1034   iterate_over_symbols,
1035   LANG_MAGIC
1036 };
1037
1038 /* The following language_defn does not represent a real language.
1039    It just provides a minimal support a-la-C that should allow users
1040    to do some simple operations when debugging applications that use
1041    a language currently not supported by GDB.  */
1042
1043 const struct language_defn minimal_language_defn =
1044 {
1045   "minimal",                    /* Language name */
1046   language_minimal,
1047   range_check_off,
1048   type_check_off,
1049   case_sensitive_on,
1050   array_row_major,
1051   macro_expansion_c,
1052   &exp_descriptor_c,
1053   c_parse,
1054   c_error,
1055   null_post_parser,
1056   c_printchar,                  /* Print a character constant */
1057   c_printstr,                   /* Function to print string constant */
1058   c_emit_char,                  /* Print a single char */
1059   c_print_type,                 /* Print a type using appropriate syntax */
1060   c_print_typedef,              /* Print a typedef using appropriate syntax */
1061   c_val_print,                  /* Print a value using appropriate syntax */
1062   c_value_print,                /* Print a top-level value */
1063   default_read_var_value,       /* la_read_var_value */
1064   NULL,                         /* Language specific skip_trampoline */
1065   NULL,                         /* name_of_this */
1066   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1067   basic_lookup_transparent_type,/* lookup_transparent_type */
1068   NULL,                         /* Language specific symbol demangler */
1069   NULL,                         /* Language specific
1070                                    class_name_from_physname */
1071   c_op_print_tab,               /* expression operators for printing */
1072   1,                            /* c-style arrays */
1073   0,                            /* String lower bound */
1074   default_word_break_characters,
1075   default_make_symbol_completion_list,
1076   c_language_arch_info,
1077   default_print_array_index,
1078   default_pass_by_reference,
1079   c_get_string,
1080   NULL,                         /* la_get_symbol_name_cmp */
1081   iterate_over_symbols,
1082   LANG_MAGIC
1083 };
1084
1085 void
1086 _initialize_c_language (void)
1087 {
1088   add_language (&c_language_defn);
1089   add_language (&cplus_language_defn);
1090   add_language (&asm_language_defn);
1091   add_language (&minimal_language_defn);
1092 }