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   "C",
 816   language_c,
 817   range_check_off,
 818   case_sensitive_on,
 819   array_row_major,
 820   macro_expansion_c,
 821   &exp_descriptor_c,
 822   c_parse,
 823   c_error,
 824   null_post_parser,
 825   c_printchar,                  /* Print a character constant */
 826   c_printstr,                   /* Function to print string constant */
 827   c_emit_char,                  /* Print a single char */
 828   c_print_type,                 /* Print a type using appropriate syntax */
 829   c_print_typedef,              /* Print a typedef using appropriate syntax */
 830   c_val_print,                  /* Print a value using appropriate syntax */
 831   c_value_print,                /* Print a top-level value */
 832   default_read_var_value,       /* la_read_var_value */
 833   NULL,                         /* Language specific skip_trampoline */
 834   NULL,                         /* name_of_this */
 835   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
 836   basic_lookup_transparent_type,/* lookup_transparent_type */
 837   NULL,                         /* Language specific symbol demangler */
 838   NULL,                         /* Language specific
 839                                    class_name_from_physname */
 840   c_op_print_tab,               /* expression operators for printing */
 841   1,                            /* c-style arrays */
 842   0,                            /* String lower bound */
 843   default_word_break_characters,
 844   default_make_symbol_completion_list,
 845   c_language_arch_info,
 846   default_print_array_index,
 847   default_pass_by_reference,
 848   c_get_string,
 849   NULL,                         /* la_get_symbol_name_cmp */
 850   iterate_over_symbols,
 851   &c_varobj_ops,
 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   "C++",
 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   gdb_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   &cplus_varobj_ops,
 977   LANG_MAGIC
 978 };
 979
 980 const struct language_defn asm_language_defn =
 981 {
 982   "asm",                        /* Language name */
 983   "assembly",
 984   language_asm,
 985   range_check_off,
 986   case_sensitive_on,
 987   array_row_major,
 988   macro_expansion_c,
 989   &exp_descriptor_c,
 990   c_parse,
 991   c_error,
 992   null_post_parser,
 993   c_printchar,                  /* Print a character constant */
 994   c_printstr,                   /* Function to print string constant */
 995   c_emit_char,                  /* Print a single char */
 996   c_print_type,                 /* Print a type using appropriate syntax */
 997   c_print_typedef,              /* Print a typedef using appropriate syntax */
 998   c_val_print,                  /* Print a value using appropriate syntax */
 999   c_value_print,                /* Print a top-level value */
1000   default_read_var_value,       /* la_read_var_value */
1001   NULL,                         /* Language specific skip_trampoline */
1002   NULL,                         /* name_of_this */
1003   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1004   basic_lookup_transparent_type,/* lookup_transparent_type */
1005   NULL,                         /* Language specific symbol demangler */
1006   NULL,                         /* Language specific
1007                                    class_name_from_physname */
1008   c_op_print_tab,               /* expression operators for printing */
1009   1,                            /* c-style arrays */
1010   0,                            /* String lower bound */
1011   default_word_break_characters,
1012   default_make_symbol_completion_list,
1013   c_language_arch_info,         /* FIXME: la_language_arch_info.  */
1014   default_print_array_index,
1015   default_pass_by_reference,
1016   c_get_string,
1017   NULL,                         /* la_get_symbol_name_cmp */
1018   iterate_over_symbols,
1019   &default_varobj_ops,
1020   LANG_MAGIC
1021 };
1022
1023 /* The following language_defn does not represent a real language.
1024    It just provides a minimal support a-la-C that should allow users
1025    to do some simple operations when debugging applications that use
1026    a language currently not supported by GDB.  */
1027
1028 const struct language_defn minimal_language_defn =
1029 {
1030   "minimal",                    /* Language name */
1031   "Minimal",
1032   language_minimal,
1033   range_check_off,
1034   case_sensitive_on,
1035   array_row_major,
1036   macro_expansion_c,
1037   &exp_descriptor_c,
1038   c_parse,
1039   c_error,
1040   null_post_parser,
1041   c_printchar,                  /* Print a character constant */
1042   c_printstr,                   /* Function to print string constant */
1043   c_emit_char,                  /* Print a single char */
1044   c_print_type,                 /* Print a type using appropriate syntax */
1045   c_print_typedef,              /* Print a typedef using appropriate syntax */
1046   c_val_print,                  /* Print a value using appropriate syntax */
1047   c_value_print,                /* Print a top-level value */
1048   default_read_var_value,       /* la_read_var_value */
1049   NULL,                         /* Language specific skip_trampoline */
1050   NULL,                         /* name_of_this */
1051   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1052   basic_lookup_transparent_type,/* lookup_transparent_type */
1053   NULL,                         /* Language specific symbol demangler */
1054   NULL,                         /* Language specific
1055                                    class_name_from_physname */
1056   c_op_print_tab,               /* expression operators for printing */
1057   1,                            /* c-style arrays */
1058   0,                            /* String lower bound */
1059   default_word_break_characters,
1060   default_make_symbol_completion_list,
1061   c_language_arch_info,
1062   default_print_array_index,
1063   default_pass_by_reference,
1064   c_get_string,
1065   NULL,                         /* la_get_symbol_name_cmp */
1066   iterate_over_symbols,
1067   &default_varobj_ops,
1068   LANG_MAGIC
1069 };
1070
1071 void
1072 _initialize_c_language (void)
1073 {
1074   add_language (&c_language_defn);
1075   add_language (&cplus_language_defn);
1076   add_language (&asm_language_defn);
1077   add_language (&minimal_language_defn);
1078 }