GDB copyright headers update after running GDB's copyright.py script.
[external/binutils.git] / gdb / c-lang.c
1 /* C language support routines for GDB, the GNU debugger.
2
3    Copyright (C) 1992-2016 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 ((const char *) 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 }