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_NEG, PREC_PREFIX, 0},
 736   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 737   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 738   {"*", UNOP_IND, PREC_PREFIX, 0},
 739   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 740   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 741   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 742   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 743   {NULL, 0, 0, 0}
 744 };
 745 \f
 746 enum c_primitive_types {
 747   c_primitive_type_int,
 748   c_primitive_type_long,
 749   c_primitive_type_short,
 750   c_primitive_type_char,
 751   c_primitive_type_float,
 752   c_primitive_type_double,
 753   c_primitive_type_void,
 754   c_primitive_type_long_long,
 755   c_primitive_type_signed_char,
 756   c_primitive_type_unsigned_char,
 757   c_primitive_type_unsigned_short,
 758   c_primitive_type_unsigned_int,
 759   c_primitive_type_unsigned_long,
 760   c_primitive_type_unsigned_long_long,
 761   c_primitive_type_long_double,
 762   c_primitive_type_complex,
 763   c_primitive_type_double_complex,
 764   c_primitive_type_decfloat,
 765   c_primitive_type_decdouble,
 766   c_primitive_type_declong,
 767   nr_c_primitive_types
 768 };
 769
 770 void
 771 c_language_arch_info (struct gdbarch *gdbarch,
 772                       struct language_arch_info *lai)
 773 {
 774   const struct builtin_type *builtin = builtin_type (gdbarch);
 775
 776   lai->string_char_type = builtin->builtin_char;
 777   lai->primitive_type_vector
 778     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_c_primitive_types + 1,
 779                               struct type *);
 780   lai->primitive_type_vector [c_primitive_type_int] = builtin->builtin_int;
 781   lai->primitive_type_vector [c_primitive_type_long] = builtin->builtin_long;
 782   lai->primitive_type_vector [c_primitive_type_short] = builtin->builtin_short;
 783   lai->primitive_type_vector [c_primitive_type_char] = builtin->builtin_char;
 784   lai->primitive_type_vector [c_primitive_type_float] = builtin->builtin_float;
 785   lai->primitive_type_vector [c_primitive_type_double] = builtin->builtin_double;
 786   lai->primitive_type_vector [c_primitive_type_void] = builtin->builtin_void;
 787   lai->primitive_type_vector [c_primitive_type_long_long] = builtin->builtin_long_long;
 788   lai->primitive_type_vector [c_primitive_type_signed_char] = builtin->builtin_signed_char;
 789   lai->primitive_type_vector [c_primitive_type_unsigned_char] = builtin->builtin_unsigned_char;
 790   lai->primitive_type_vector [c_primitive_type_unsigned_short] = builtin->builtin_unsigned_short;
 791   lai->primitive_type_vector [c_primitive_type_unsigned_int] = builtin->builtin_unsigned_int;
 792   lai->primitive_type_vector [c_primitive_type_unsigned_long] = builtin->builtin_unsigned_long;
 793   lai->primitive_type_vector [c_primitive_type_unsigned_long_long] = builtin->builtin_unsigned_long_long;
 794   lai->primitive_type_vector [c_primitive_type_long_double] = builtin->builtin_long_double;
 795   lai->primitive_type_vector [c_primitive_type_complex] = builtin->builtin_complex;
 796   lai->primitive_type_vector [c_primitive_type_double_complex] = builtin->builtin_double_complex;
 797   lai->primitive_type_vector [c_primitive_type_decfloat] = builtin->builtin_decfloat;
 798   lai->primitive_type_vector [c_primitive_type_decdouble] = builtin->builtin_decdouble;
 799   lai->primitive_type_vector [c_primitive_type_declong] = builtin->builtin_declong;
 800
 801   lai->bool_type_default = builtin->builtin_int;
 802 }
 803
 804 const struct exp_descriptor exp_descriptor_c =
 805 {
 806   print_subexp_standard,
 807   operator_length_standard,
 808   operator_check_standard,
 809   op_name_standard,
 810   dump_subexp_body_standard,
 811   evaluate_subexp_c
 812 };
 813
 814 const struct language_defn c_language_defn =
 815 {
 816   "c",                          /* Language name */
 817   language_c,
 818   range_check_off,
 819   case_sensitive_on,
 820   array_row_major,
 821   macro_expansion_c,
 822   &exp_descriptor_c,
 823   c_parse,
 824   c_error,
 825   null_post_parser,
 826   c_printchar,                  /* Print a character constant */
 827   c_printstr,                   /* Function to print string constant */
 828   c_emit_char,                  /* Print a single char */
 829   c_print_type,                 /* Print a type using appropriate syntax */
 830   c_print_typedef,              /* Print a typedef using appropriate syntax */
 831   c_val_print,                  /* Print a value using appropriate syntax */
 832   c_value_print,                /* Print a top-level value */
 833   default_read_var_value,       /* la_read_var_value */
 834   NULL,                         /* Language specific skip_trampoline */
 835   NULL,                         /* name_of_this */
 836   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 837   basic_lookup_transparent_type,/* lookup_transparent_type */
 838   NULL,                         /* Language specific symbol demangler */
 839   NULL,                         /* Language specific
 840                                    class_name_from_physname */
 841   c_op_print_tab,               /* expression operators for printing */
 842   1,                            /* c-style arrays */
 843   0,                            /* String lower bound */
 844   default_word_break_characters,
 845   default_make_symbol_completion_list,
 846   c_language_arch_info,
 847   default_print_array_index,
 848   default_pass_by_reference,
 849   c_get_string,
 850   NULL,                         /* la_get_symbol_name_cmp */
 851   iterate_over_symbols,
 852   LANG_MAGIC
 853 };
 854
 855 enum cplus_primitive_types {
 856   cplus_primitive_type_int,
 857   cplus_primitive_type_long,
 858   cplus_primitive_type_short,
 859   cplus_primitive_type_char,
 860   cplus_primitive_type_float,
 861   cplus_primitive_type_double,
 862   cplus_primitive_type_void,
 863   cplus_primitive_type_long_long,
 864   cplus_primitive_type_signed_char,
 865   cplus_primitive_type_unsigned_char,
 866   cplus_primitive_type_unsigned_short,
 867   cplus_primitive_type_unsigned_int,
 868   cplus_primitive_type_unsigned_long,
 869   cplus_primitive_type_unsigned_long_long,
 870   cplus_primitive_type_long_double,
 871   cplus_primitive_type_complex,
 872   cplus_primitive_type_double_complex,
 873   cplus_primitive_type_bool,
 874   cplus_primitive_type_decfloat,
 875   cplus_primitive_type_decdouble,
 876   cplus_primitive_type_declong,
 877   nr_cplus_primitive_types
 878 };
 879
 880 static void
 881 cplus_language_arch_info (struct gdbarch *gdbarch,
 882                           struct language_arch_info *lai)
 883 {
 884   const struct builtin_type *builtin = builtin_type (gdbarch);
 885
 886   lai->string_char_type = builtin->builtin_char;
 887   lai->primitive_type_vector
 888     = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_cplus_primitive_types + 1,
 889                               struct type *);
 890   lai->primitive_type_vector [cplus_primitive_type_int]
 891     = builtin->builtin_int;
 892   lai->primitive_type_vector [cplus_primitive_type_long]
 893     = builtin->builtin_long;
 894   lai->primitive_type_vector [cplus_primitive_type_short]
 895     = builtin->builtin_short;
 896   lai->primitive_type_vector [cplus_primitive_type_char]
 897     = builtin->builtin_char;
 898   lai->primitive_type_vector [cplus_primitive_type_float]
 899     = builtin->builtin_float;
 900   lai->primitive_type_vector [cplus_primitive_type_double]
 901     = builtin->builtin_double;
 902   lai->primitive_type_vector [cplus_primitive_type_void]
 903     = builtin->builtin_void;
 904   lai->primitive_type_vector [cplus_primitive_type_long_long]
 905     = builtin->builtin_long_long;
 906   lai->primitive_type_vector [cplus_primitive_type_signed_char]
 907     = builtin->builtin_signed_char;
 908   lai->primitive_type_vector [cplus_primitive_type_unsigned_char]
 909     = builtin->builtin_unsigned_char;
 910   lai->primitive_type_vector [cplus_primitive_type_unsigned_short]
 911     = builtin->builtin_unsigned_short;
 912   lai->primitive_type_vector [cplus_primitive_type_unsigned_int]
 913     = builtin->builtin_unsigned_int;
 914   lai->primitive_type_vector [cplus_primitive_type_unsigned_long]
 915     = builtin->builtin_unsigned_long;
 916   lai->primitive_type_vector [cplus_primitive_type_unsigned_long_long]
 917     = builtin->builtin_unsigned_long_long;
 918   lai->primitive_type_vector [cplus_primitive_type_long_double]
 919     = builtin->builtin_long_double;
 920   lai->primitive_type_vector [cplus_primitive_type_complex]
 921     = builtin->builtin_complex;
 922   lai->primitive_type_vector [cplus_primitive_type_double_complex]
 923     = builtin->builtin_double_complex;
 924   lai->primitive_type_vector [cplus_primitive_type_bool]
 925     = builtin->builtin_bool;
 926   lai->primitive_type_vector [cplus_primitive_type_decfloat]
 927     = builtin->builtin_decfloat;
 928   lai->primitive_type_vector [cplus_primitive_type_decdouble]
 929     = builtin->builtin_decdouble;
 930   lai->primitive_type_vector [cplus_primitive_type_declong]
 931     = builtin->builtin_declong;
 932
 933   lai->bool_type_symbol = "bool";
 934   lai->bool_type_default = builtin->builtin_bool;
 935 }
 936
 937 const struct language_defn cplus_language_defn =
 938 {
 939   "c++",                        /* Language name */
 940   language_cplus,
 941   range_check_off,
 942   case_sensitive_on,
 943   array_row_major,
 944   macro_expansion_c,
 945   &exp_descriptor_c,
 946   c_parse,
 947   c_error,
 948   null_post_parser,
 949   c_printchar,                  /* Print a character constant */
 950   c_printstr,                   /* Function to print string constant */
 951   c_emit_char,                  /* Print a single char */
 952   c_print_type,                 /* Print a type using appropriate syntax */
 953   c_print_typedef,              /* Print a typedef using appropriate syntax */
 954   c_val_print,                  /* Print a value using appropriate syntax */
 955   c_value_print,                /* Print a top-level value */
 956   default_read_var_value,       /* la_read_var_value */
 957   cplus_skip_trampoline,        /* Language specific skip_trampoline */
 958   "this",                       /* name_of_this */
 959   cp_lookup_symbol_nonlocal,    /* lookup_symbol_nonlocal */
 960   cp_lookup_transparent_type,   /* lookup_transparent_type */
 961   cplus_demangle,               /* Language specific symbol demangler */
 962   cp_class_name_from_physname,  /* Language specific
 963                                    class_name_from_physname */
 964   c_op_print_tab,               /* expression operators for printing */
 965   1,                            /* c-style arrays */
 966   0,                            /* String lower bound */
 967   default_word_break_characters,
 968   default_make_symbol_completion_list,
 969   cplus_language_arch_info,
 970   default_print_array_index,
 971   cp_pass_by_reference,
 972   c_get_string,
 973   NULL,                         /* la_get_symbol_name_cmp */
 974   iterate_over_symbols,
 975   LANG_MAGIC
 976 };
 977
 978 const struct language_defn asm_language_defn =
 979 {
 980   "asm",                        /* Language name */
 981   language_asm,
 982   range_check_off,
 983   case_sensitive_on,
 984   array_row_major,
 985   macro_expansion_c,
 986   &exp_descriptor_c,
 987   c_parse,
 988   c_error,
 989   null_post_parser,
 990   c_printchar,                  /* Print a character constant */
 991   c_printstr,                   /* Function to print string constant */
 992   c_emit_char,                  /* Print a single char */
 993   c_print_type,                 /* Print a type using appropriate syntax */
 994   c_print_typedef,              /* Print a typedef using appropriate syntax */
 995   c_val_print,                  /* Print a value using appropriate syntax */
 996   c_value_print,                /* Print a top-level value */
 997   default_read_var_value,       /* la_read_var_value */
 998   NULL,                         /* Language specific skip_trampoline */
 999   NULL,                         /* name_of_this */
1000   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1001   basic_lookup_transparent_type,/* lookup_transparent_type */
1002   NULL,                         /* Language specific symbol demangler */
1003   NULL,                         /* Language specific
1004                                    class_name_from_physname */
1005   c_op_print_tab,               /* expression operators for printing */
1006   1,                            /* c-style arrays */
1007   0,                            /* String lower bound */
1008   default_word_break_characters,
1009   default_make_symbol_completion_list,
1010   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1011   default_print_array_index,
1012   default_pass_by_reference,
1013   c_get_string,
1014   NULL,                         /* la_get_symbol_name_cmp */
1015   iterate_over_symbols,
1016   LANG_MAGIC
1017 };
1018
1019 /* The following language_defn does not represent a real language.
1020    It just provides a minimal support a-la-C that should allow users
1021    to do some simple operations when debugging applications that use
1022    a language currently not supported by GDB.  */
1023
1024 const struct language_defn minimal_language_defn =
1025 {
1026   "minimal",                    /* Language name */
1027   language_minimal,
1028   range_check_off,
1029   case_sensitive_on,
1030   array_row_major,
1031   macro_expansion_c,
1032   &exp_descriptor_c,
1033   c_parse,
1034   c_error,
1035   null_post_parser,
1036   c_printchar,                  /* Print a character constant */
1037   c_printstr,                   /* Function to print string constant */
1038   c_emit_char,                  /* Print a single char */
1039   c_print_type,                 /* Print a type using appropriate syntax */
1040   c_print_typedef,              /* Print a typedef using appropriate syntax */
1041   c_val_print,                  /* Print a value using appropriate syntax */
1042   c_value_print,                /* Print a top-level value */
1043   default_read_var_value,       /* la_read_var_value */
1044   NULL,                         /* Language specific skip_trampoline */
1045   NULL,                         /* name_of_this */
1046   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1047   basic_lookup_transparent_type,/* lookup_transparent_type */
1048   NULL,                         /* Language specific symbol demangler */
1049   NULL,                         /* Language specific
1050                                    class_name_from_physname */
1051   c_op_print_tab,               /* expression operators for printing */
1052   1,                            /* c-style arrays */
1053   0,                            /* String lower bound */
1054   default_word_break_characters,
1055   default_make_symbol_completion_list,
1056   c_language_arch_info,
1057   default_print_array_index,
1058   default_pass_by_reference,
1059   c_get_string,
1060   NULL,                         /* la_get_symbol_name_cmp */
1061   iterate_over_symbols,
1062   LANG_MAGIC
1063 };
1064
1065 void
1066 _initialize_c_language (void)
1067 {
1068   add_language (&c_language_defn);
1069   add_language (&cplus_language_defn);
1070   add_language (&asm_language_defn);
1071   add_language (&minimal_language_defn);
1072 }