gdb/c-lang.c

   1 /* C language support routines for GDB, the GNU debugger.
   2    Copyright 1992, 1993, 1994, 2000 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "parser-defs.h"
  26 #include "language.h"
  27 #include "c-lang.h"
  28 #include "valprint.h"
  29
  30 extern void _initialize_c_language (void);
  31 static void c_emit_char (int c, struct ui_file * stream, int quoter);
  32
  33 /* Print the character C on STREAM as part of the contents of a literal
  34    string whose delimiter is QUOTER.  Note that that format for printing
  35    characters and strings is language specific. */
  36
  37 static void
  38 c_emit_char (register int c, struct ui_file *stream, int quoter)
  39 {
  40   c &= 0xFF;                    /* Avoid sign bit follies */
  41
  42   if (PRINT_LITERAL_FORM (c))
  43     {
  44       if (c == '\\' || c == quoter)
  45         {
  46           fputs_filtered ("\\", stream);
  47         }
  48       fprintf_filtered (stream, "%c", c);
  49     }
  50   else
  51     {
  52       switch (c)
  53         {
  54         case '\n':
  55           fputs_filtered ("\\n", stream);
  56           break;
  57         case '\b':
  58           fputs_filtered ("\\b", stream);
  59           break;
  60         case '\t':
  61           fputs_filtered ("\\t", stream);
  62           break;
  63         case '\f':
  64           fputs_filtered ("\\f", stream);
  65           break;
  66         case '\r':
  67           fputs_filtered ("\\r", stream);
  68           break;
  69         case '\033':
  70           fputs_filtered ("\\e", stream);
  71           break;
  72         case '\007':
  73           fputs_filtered ("\\a", stream);
  74           break;
  75         default:
  76           fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
  77           break;
  78         }
  79     }
  80 }
  81
  82 void
  83 c_printchar (int c, struct ui_file *stream)
  84 {
  85   fputc_filtered ('\'', stream);
  86   LA_EMIT_CHAR (c, stream, '\'');
  87   fputc_filtered ('\'', stream);
  88 }
  89
  90 /* Print the character string STRING, printing at most LENGTH characters.
  91    LENGTH is -1 if the string is nul terminated.  Each character is WIDTH bytes
  92    long.  Printing stops early if the number hits print_max; repeat counts are
  93    printed as appropriate.  Print ellipses at the end if we had to stop before
  94    printing LENGTH characters, or if FORCE_ELLIPSES.  */
  95
  96 void
  97 c_printstr (struct ui_file *stream, char *string, unsigned int length,
  98             int width, int force_ellipses)
  99 {
 100   register unsigned int i;
 101   unsigned int things_printed = 0;
 102   int in_quotes = 0;
 103   int need_comma = 0;
 104   extern int inspect_it;
 105
 106   /* If the string was not truncated due to `set print elements', and
 107      the last byte of it is a null, we don't print that, in traditional C
 108      style.  */
 109   if (!force_ellipses
 110       && length > 0
 111   && extract_unsigned_integer (string + (length - 1) * width, width) == '\0')
 112     length--;
 113
 114   if (length == 0)
 115     {
 116       fputs_filtered ("\"\"", stream);
 117       return;
 118     }
 119
 120   for (i = 0; i < length && things_printed < print_max; ++i)
 121     {
 122       /* Position of the character we are examining
 123          to see whether it is repeated.  */
 124       unsigned int rep1;
 125       /* Number of repetitions we have detected so far.  */
 126       unsigned int reps;
 127       unsigned long current_char;
 128
 129       QUIT;
 130
 131       if (need_comma)
 132         {
 133           fputs_filtered (", ", stream);
 134           need_comma = 0;
 135         }
 136
 137       current_char = extract_unsigned_integer (string + i * width, width);
 138
 139       rep1 = i + 1;
 140       reps = 1;
 141       while (rep1 < length
 142              && extract_unsigned_integer (string + rep1 * width, width)
 143              == current_char)
 144         {
 145           ++rep1;
 146           ++reps;
 147         }
 148
 149       if (reps > repeat_count_threshold)
 150         {
 151           if (in_quotes)
 152             {
 153               if (inspect_it)
 154                 fputs_filtered ("\\\", ", stream);
 155               else
 156                 fputs_filtered ("\", ", stream);
 157               in_quotes = 0;
 158             }
 159           LA_PRINT_CHAR (current_char, stream);
 160           fprintf_filtered (stream, " <repeats %u times>", reps);
 161           i = rep1 - 1;
 162           things_printed += repeat_count_threshold;
 163           need_comma = 1;
 164         }
 165       else
 166         {
 167           if (!in_quotes)
 168             {
 169               if (inspect_it)
 170                 fputs_filtered ("\\\"", stream);
 171               else
 172                 fputs_filtered ("\"", stream);
 173               in_quotes = 1;
 174             }
 175           LA_EMIT_CHAR (current_char, stream, '"');
 176           ++things_printed;
 177         }
 178     }
 179
 180   /* Terminate the quotes if necessary.  */
 181   if (in_quotes)
 182     {
 183       if (inspect_it)
 184         fputs_filtered ("\\\"", stream);
 185       else
 186         fputs_filtered ("\"", stream);
 187     }
 188
 189   if (force_ellipses || i < length)
 190     fputs_filtered ("...", stream);
 191 }
 192
 193 /* Create a fundamental C type using default reasonable for the current
 194    target machine.
 195
 196    Some object/debugging file formats (DWARF version 1, COFF, etc) do not
 197    define fundamental types such as "int" or "double".  Others (stabs or
 198    DWARF version 2, etc) do define fundamental types.  For the formats which
 199    don't provide fundamental types, gdb can create such types using this
 200    function.
 201
 202    FIXME:  Some compilers distinguish explicitly signed integral types
 203    (signed short, signed int, signed long) from "regular" integral types
 204    (short, int, long) in the debugging information.  There is some dis-
 205    agreement as to how useful this feature is.  In particular, gcc does
 206    not support this.  Also, only some debugging formats allow the
 207    distinction to be passed on to a debugger.  For now, we always just
 208    use "short", "int", or "long" as the type name, for both the implicit
 209    and explicitly signed types.  This also makes life easier for the
 210    gdb test suite since we don't have to account for the differences
 211    in output depending upon what the compiler and debugging format
 212    support.  We will probably have to re-examine the issue when gdb
 213    starts taking it's fundamental type information directly from the
 214    debugging information supplied by the compiler.  fnf@cygnus.com */
 215
 216 struct type *
 217 c_create_fundamental_type (struct objfile *objfile, int typeid)
 218 {
 219   register struct type *type = NULL;
 220
 221   switch (typeid)
 222     {
 223     default:
 224       /* FIXME:  For now, if we are asked to produce a type not in this
 225          language, create the equivalent of a C integer type with the
 226          name "<?type?>".  When all the dust settles from the type
 227          reconstruction work, this should probably become an error. */
 228       type = init_type (TYPE_CODE_INT,
 229                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 230                         0, "<?type?>", objfile);
 231       warning ("internal error: no C/C++ fundamental type %d", typeid);
 232       break;
 233     case FT_VOID:
 234       type = init_type (TYPE_CODE_VOID,
 235                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 236                         0, "void", objfile);
 237       break;
 238     case FT_BOOLEAN:
 239       type = init_type (TYPE_CODE_BOOL,
 240                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 241                         0, "bool", objfile);
 242
 243       break;
 244     case FT_CHAR:
 245       type = init_type (TYPE_CODE_INT,
 246                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 247                         0, "char", objfile);
 248       TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN;
 249       break;
 250     case FT_SIGNED_CHAR:
 251       type = init_type (TYPE_CODE_INT,
 252                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 253                         0, "signed char", objfile);
 254       break;
 255     case FT_UNSIGNED_CHAR:
 256       type = init_type (TYPE_CODE_INT,
 257                         TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 258                         TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
 259       break;
 260     case FT_SHORT:
 261       type = init_type (TYPE_CODE_INT,
 262                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 263                         0, "short", objfile);
 264       break;
 265     case FT_SIGNED_SHORT:
 266       type = init_type (TYPE_CODE_INT,
 267                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 268                         0, "short", objfile);   /* FIXME-fnf */
 269       break;
 270     case FT_UNSIGNED_SHORT:
 271       type = init_type (TYPE_CODE_INT,
 272                         TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 273                         TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
 274       break;
 275     case FT_INTEGER:
 276       type = init_type (TYPE_CODE_INT,
 277                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 278                         0, "int", objfile);
 279       break;
 280     case FT_SIGNED_INTEGER:
 281       type = init_type (TYPE_CODE_INT,
 282                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 283                         0, "int", objfile);     /* FIXME -fnf */
 284       break;
 285     case FT_UNSIGNED_INTEGER:
 286       type = init_type (TYPE_CODE_INT,
 287                         TARGET_INT_BIT / TARGET_CHAR_BIT,
 288                         TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
 289       break;
 290     case FT_LONG:
 291       type = init_type (TYPE_CODE_INT,
 292                         TARGET_LONG_BIT / TARGET_CHAR_BIT,
 293                         0, "long", objfile);
 294       break;
 295     case FT_SIGNED_LONG:
 296       type = init_type (TYPE_CODE_INT,
 297                         TARGET_LONG_BIT / TARGET_CHAR_BIT,
 298                         0, "long", objfile);    /* FIXME -fnf */
 299       break;
 300     case FT_UNSIGNED_LONG:
 301       type = init_type (TYPE_CODE_INT,
 302                         TARGET_LONG_BIT / TARGET_CHAR_BIT,
 303                         TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
 304       break;
 305     case FT_LONG_LONG:
 306       type = init_type (TYPE_CODE_INT,
 307                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 308                         0, "long long", objfile);
 309       break;
 310     case FT_SIGNED_LONG_LONG:
 311       type = init_type (TYPE_CODE_INT,
 312                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 313                         0, "signed long long", objfile);
 314       break;
 315     case FT_UNSIGNED_LONG_LONG:
 316       type = init_type (TYPE_CODE_INT,
 317                         TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
 318                         TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
 319       break;
 320     case FT_FLOAT:
 321       type = init_type (TYPE_CODE_FLT,
 322                         TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 323                         0, "float", objfile);
 324       break;
 325     case FT_DBL_PREC_FLOAT:
 326       type = init_type (TYPE_CODE_FLT,
 327                         TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 328                         0, "double", objfile);
 329       break;
 330     case FT_EXT_PREC_FLOAT:
 331       type = init_type (TYPE_CODE_FLT,
 332                         TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 333                         0, "long double", objfile);
 334       break;
 335     case FT_TEMPLATE_ARG:
 336       type = init_type (TYPE_CODE_TEMPLATE_ARG,
 337                         0,
 338                         0, "<template arg>", objfile);
 339
 340       break;
 341     }
 342   return (type);
 343 }
 344 \f
 345
 346 /* Table mapping opcodes into strings for printing operators
 347    and precedences of the operators.  */
 348
 349 const struct op_print c_op_print_tab[] =
 350 {
 351   {",", BINOP_COMMA, PREC_COMMA, 0},
 352   {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
 353   {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
 354   {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
 355   {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
 356   {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
 357   {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
 358   {"==", BINOP_EQUAL, PREC_EQUAL, 0},
 359   {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
 360   {"<=", BINOP_LEQ, PREC_ORDER, 0},
 361   {">=", BINOP_GEQ, PREC_ORDER, 0},
 362   {">", BINOP_GTR, PREC_ORDER, 0},
 363   {"<", BINOP_LESS, PREC_ORDER, 0},
 364   {">>", BINOP_RSH, PREC_SHIFT, 0},
 365   {"<<", BINOP_LSH, PREC_SHIFT, 0},
 366   {"+", BINOP_ADD, PREC_ADD, 0},
 367   {"-", BINOP_SUB, PREC_ADD, 0},
 368   {"*", BINOP_MUL, PREC_MUL, 0},
 369   {"/", BINOP_DIV, PREC_MUL, 0},
 370   {"%", BINOP_REM, PREC_MUL, 0},
 371   {"@", BINOP_REPEAT, PREC_REPEAT, 0},
 372   {"-", UNOP_NEG, PREC_PREFIX, 0},
 373   {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
 374   {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
 375   {"*", UNOP_IND, PREC_PREFIX, 0},
 376   {"&", UNOP_ADDR, PREC_PREFIX, 0},
 377   {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
 378   {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
 379   {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
 380   {NULL, 0, 0, 0}
 381 };
 382 \f
 383 struct type **CONST_PTR (c_builtin_types[]) =
 384 {
 385   &builtin_type_int,
 386     &builtin_type_long,
 387     &builtin_type_short,
 388     &builtin_type_char,
 389     &builtin_type_float,
 390     &builtin_type_double,
 391     &builtin_type_void,
 392     &builtin_type_long_long,
 393     &builtin_type_signed_char,
 394     &builtin_type_unsigned_char,
 395     &builtin_type_unsigned_short,
 396     &builtin_type_unsigned_int,
 397     &builtin_type_unsigned_long,
 398     &builtin_type_unsigned_long_long,
 399     &builtin_type_long_double,
 400     &builtin_type_complex,
 401     &builtin_type_double_complex,
 402     0
 403 };
 404
 405 const struct language_defn c_language_defn =
 406 {
 407   "c",                          /* Language name */
 408   language_c,
 409   c_builtin_types,
 410   range_check_off,
 411   type_check_off,
 412   case_sensitive_on,
 413   c_parse,
 414   c_error,
 415   evaluate_subexp_standard,
 416   c_printchar,                  /* Print a character constant */
 417   c_printstr,                   /* Function to print string constant */
 418   c_emit_char,                  /* Print a single char */
 419   c_create_fundamental_type,    /* Create fundamental type in this language */
 420   c_print_type,                 /* Print a type using appropriate syntax */
 421   c_val_print,                  /* Print a value using appropriate syntax */
 422   c_value_print,                /* Print a top-level value */
 423   {"", "", "", ""},             /* Binary format info */
 424   {"0%lo", "0", "o", ""},       /* Octal format info */
 425   {"%ld", "", "d", ""},         /* Decimal format info */
 426   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 427   c_op_print_tab,               /* expression operators for printing */
 428   1,                            /* c-style arrays */
 429   0,                            /* String lower bound */
 430   &builtin_type_char,           /* Type of string elements */
 431   LANG_MAGIC
 432 };
 433
 434 struct type **const (cplus_builtin_types[]) =
 435 {
 436   &builtin_type_int,
 437     &builtin_type_long,
 438     &builtin_type_short,
 439     &builtin_type_char,
 440     &builtin_type_float,
 441     &builtin_type_double,
 442     &builtin_type_void,
 443     &builtin_type_long_long,
 444     &builtin_type_signed_char,
 445     &builtin_type_unsigned_char,
 446     &builtin_type_unsigned_short,
 447     &builtin_type_unsigned_int,
 448     &builtin_type_unsigned_long,
 449     &builtin_type_unsigned_long_long,
 450     &builtin_type_long_double,
 451     &builtin_type_complex,
 452     &builtin_type_double_complex,
 453     &builtin_type_bool,
 454     0
 455 };
 456
 457 const struct language_defn cplus_language_defn =
 458 {
 459   "c++",                        /* Language name */
 460   language_cplus,
 461   cplus_builtin_types,
 462   range_check_off,
 463   type_check_off,
 464   case_sensitive_on,
 465   c_parse,
 466   c_error,
 467   evaluate_subexp_standard,
 468   c_printchar,                  /* Print a character constant */
 469   c_printstr,                   /* Function to print string constant */
 470   c_emit_char,                  /* Print a single char */
 471   c_create_fundamental_type,    /* Create fundamental type in this language */
 472   c_print_type,                 /* Print a type using appropriate syntax */
 473   c_val_print,                  /* Print a value using appropriate syntax */
 474   c_value_print,                /* Print a top-level value */
 475   {"", "", "", ""},             /* Binary format info */
 476   {"0%lo", "0", "o", ""},       /* Octal format info */
 477   {"%ld", "", "d", ""},         /* Decimal format info */
 478   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 479   c_op_print_tab,               /* expression operators for printing */
 480   1,                            /* c-style arrays */
 481   0,                            /* String lower bound */
 482   &builtin_type_char,           /* Type of string elements */
 483   LANG_MAGIC
 484 };
 485
 486 const struct language_defn asm_language_defn =
 487 {
 488   "asm",                        /* Language name */
 489   language_asm,
 490   c_builtin_types,
 491   range_check_off,
 492   type_check_off,
 493   case_sensitive_on,
 494   c_parse,
 495   c_error,
 496   evaluate_subexp_standard,
 497   c_printchar,                  /* Print a character constant */
 498   c_printstr,                   /* Function to print string constant */
 499   c_emit_char,                  /* Print a single char */
 500   c_create_fundamental_type,    /* Create fundamental type in this language */
 501   c_print_type,                 /* Print a type using appropriate syntax */
 502   c_val_print,                  /* Print a value using appropriate syntax */
 503   c_value_print,                /* Print a top-level value */
 504   {"", "", "", ""},             /* Binary format info */
 505   {"0%lo", "0", "o", ""},       /* Octal format info */
 506   {"%ld", "", "d", ""},         /* Decimal format info */
 507   {"0x%lx", "0x", "x", ""},     /* Hex format info */
 508   c_op_print_tab,               /* expression operators for printing */
 509   1,                            /* c-style arrays */
 510   0,                            /* String lower bound */
 511   &builtin_type_char,           /* Type of string elements */
 512   LANG_MAGIC
 513 };
 514
 515 void
 516 _initialize_c_language (void)
 517 {
 518   add_language (&c_language_defn);
 519   add_language (&cplus_language_defn);
 520   add_language (&asm_language_defn);
 521 }