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