Remove cleanups from link_callbacks_einfo

[deliverable/binutils-gdb.git] / gdb / c-exp.y

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index f7f098ba525aea86947db5a7254709a951ac4038..8eaf7c0df89ab0967248e7d51f8c5766e5bae890 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -48,7 +48,6 @@
 #include "charset.h"
 #include "block.h"
 #include "cp-support.h"
-#include "dfp.h"
 #include "macroscope.h"
 #include "objc-lang.h"
 #include "typeprint.h"
@@ -87,14 +86,10 @@ static int type_aggregate_p (struct type *);
       LONGEST val;
       struct type *type;
     } typed_val_int;
-    struct {
-      DOUBLEST dval;
-      struct type *type;
-    } typed_val_float;
     struct {
       gdb_byte val[16];
       struct type *type;
-    } typed_val_decfloat;
+    } typed_val_float;
     struct type *tval;
     struct stoken sval;
     struct typed_stoken tsval;
@@ -142,7 +137,6 @@ static void c_print_token (FILE *file, int type, YYSTYPE value);
 
 %token <typed_val_int> INT
 %token <typed_val_float> FLOAT
-%token <typed_val_decfloat> DECFLOAT
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.
@@ -558,6 +552,11 @@ function_method:       exp '(' parameter_typelist ')' const_or_volatile
                          LONGEST len = VEC_length (type_ptr, type_list);
 
                          write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                         /* Save the const/volatile qualifiers as
+                            recorded by the const_or_volatile
+                            production's actions.  */
+                         write_exp_elt_longcst (pstate,
+                                                follow_type_instance_flags ());
                          write_exp_elt_longcst (pstate, len);
                          for (i = 0;
                               VEC_iterate (type_ptr, type_list, i, type_elt);
@@ -571,6 +570,9 @@ function_method:       exp '(' parameter_typelist ')' const_or_volatile
 
 function_method_void:      exp '(' ')' const_or_volatile
                       { write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                        /* See above.  */
+                        write_exp_elt_longcst (pstate,
+                                               follow_type_instance_flags ());
                         write_exp_elt_longcst (pstate, 0);
                         write_exp_elt_longcst (pstate, 0);
                         write_exp_elt_opcode (pstate, TYPE_INSTANCE);
@@ -741,17 +743,10 @@ exp       :       NAME_OR_INT
 
 
 exp    :       FLOAT
-                       { write_exp_elt_opcode (pstate, OP_DOUBLE);
+                       { write_exp_elt_opcode (pstate, OP_FLOAT);
                          write_exp_elt_type (pstate, $1.type);
-                         write_exp_elt_dblcst (pstate, $1.dval);
-                         write_exp_elt_opcode (pstate, OP_DOUBLE); }
-       ;
-
-exp    :       DECFLOAT
-                       { write_exp_elt_opcode (pstate, OP_DECFLOAT);
-                         write_exp_elt_type (pstate, $1.type);
-                         write_exp_elt_decfloatcst (pstate, $1.val);
-                         write_exp_elt_opcode (pstate, OP_DECFLOAT); }
+                         write_exp_elt_floatcst (pstate, $1.val);
+                         write_exp_elt_opcode (pstate, OP_FLOAT); }
        ;
 
 exp    :       variable
@@ -1546,7 +1541,7 @@ oper:     OPERATOR NEW
        |       OPERATOR '>'
                        { $$ = operator_stoken (">"); }
        |       OPERATOR ASSIGN_MODIFY
-                       { const char *op = "unknown";
+                       { const char *op = " unknown";
                          switch ($2)
                            {
                            case BINOP_RSH:
@@ -1622,7 +1617,13 @@ oper:    OPERATOR NEW
 
                          c_print_type ($2, NULL, &buf, -1, 0,
                                        &type_print_raw_options);
-                         $$ = operator_stoken (buf.c_str ());
+
+                         /* This also needs canonicalization.  */
+                         std::string canon
+                           = cp_canonicalize_string (buf.c_str ());
+                         if (canon.empty ())
+                           canon = std::move (buf.string ());
+                         $$ = operator_stoken ((" " + canon).c_str ());
                        }
        ;
 
@@ -1778,49 +1779,49 @@ parse_number (struct parser_state *par_state,
 
   if (parsed_float)
     {
-      /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
-         point.  Return DECFLOAT.  */
-
+      /* Handle suffixes for decimal floating-point: "df", "dd" or "dl".  */
       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
        {
-         p[len - 2] = '\0';
-         putithere->typed_val_decfloat.type
+         putithere->typed_val_float.type
            = parse_type (par_state)->builtin_decfloat;
-         decimal_from_string (putithere->typed_val_decfloat.val, 4,
-                              gdbarch_byte_order (parse_gdbarch (par_state)),
-                              p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         len -= 2;
        }
-
-      if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
+      else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
        {
-         p[len - 2] = '\0';
-         putithere->typed_val_decfloat.type
+         putithere->typed_val_float.type
            = parse_type (par_state)->builtin_decdouble;
-         decimal_from_string (putithere->typed_val_decfloat.val, 8,
-                              gdbarch_byte_order (parse_gdbarch (par_state)),
-                              p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         len -= 2;
        }
-
-      if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
+      else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
        {
-         p[len - 2] = '\0';
-         putithere->typed_val_decfloat.type
+         putithere->typed_val_float.type
            = parse_type (par_state)->builtin_declong;
-         decimal_from_string (putithere->typed_val_decfloat.val, 16,
-                              gdbarch_byte_order (parse_gdbarch (par_state)),
-                              p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         len -= 2;
+       }
+      /* Handle suffixes: 'f' for float, 'l' for long double.  */
+      else if (len >= 1 && tolower (p[len - 1]) == 'f')
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_float;
+         len -= 1;
+       }
+      else if (len >= 1 && tolower (p[len - 1]) == 'l')
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_long_double;
+         len -= 1;
+       }
+      /* Default type for floating-point literals is double.  */
+      else
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_double;
        }
 
-      if (! parse_c_float (parse_gdbarch (par_state), p, len,
-                          &putithere->typed_val_float.dval,
-                          &putithere->typed_val_float.type))
-       return ERROR;
+      if (!parse_float (p, len,
+                       putithere->typed_val_float.type,
+                       putithere->typed_val_float.val))
+        return ERROR;
       return FLOAT;
     }
 
@@ -3224,6 +3225,7 @@ c_parse (struct parser_state *par_state)
   struct cleanup *back_to;
 
   /* Setting up the parser state.  */
+  scoped_restore pstate_restore = make_scoped_restore (&pstate);
   gdb_assert (par_state != NULL);
   pstate = par_state;
 
@@ -3231,7 +3233,6 @@ c_parse (struct parser_state *par_state)
      assuming they'll be run here (below).  */
 
   back_to = make_cleanup (free_current_contents, &expression_macro_scope);
-  make_cleanup_clear_parser_state (&pstate);
 
   /* Set up the scope for macro expansion.  */
   expression_macro_scope = NULL;