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