gdb/c-lang.c

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