*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / c-exp.y
index f0c743fca21b6e992c1e53595dbdf85f99345df1..1955fc0adec1637483a4905928f052dfb30a90a4 100644 (file)
@@ -1,6 +1,6 @@
 /* YACC parser for C expressions, for GDB.
-   Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-   1998, 1999, 2000, 2003, 2004
+   Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+   1998, 1999, 2000, 2003, 2004, 2006
    Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -17,7 +17,8 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 /* Parse a C expression from text in a string,
    and return the result as a  struct expression  pointer.
@@ -256,6 +257,10 @@ exp        :       '-' exp    %prec UNARY
                        { write_exp_elt_opcode (UNOP_NEG); }
        ;
 
+exp    :       '+' exp    %prec UNARY
+                       { write_exp_elt_opcode (UNOP_PLUS); }
+       ;
+
 exp    :       '!' exp    %prec UNARY
                        { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
        ;
@@ -501,7 +506,7 @@ exp :       VARIABLE
 
 exp    :       SIZEOF '(' type ')'     %prec UNARY
                        { write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (builtin_type_int);
+                         write_exp_elt_type (builtin_type (current_gdbarch)->builtin_int);
                          CHECK_TYPEDEF ($3);
                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
                          write_exp_elt_opcode (OP_LONG); }
@@ -517,12 +522,12 @@ exp       :       STRING
                          while (count-- > 0)
                            {
                              write_exp_elt_opcode (OP_LONG);
-                             write_exp_elt_type (builtin_type_char);
+                             write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
                              write_exp_elt_longcst ((LONGEST)(*sp++));
                              write_exp_elt_opcode (OP_LONG);
                            }
                          write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (builtin_type_char);
+                         write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
                          write_exp_elt_longcst ((LONGEST)'\0');
                          write_exp_elt_opcode (OP_LONG);
                          write_exp_elt_opcode (OP_ARRAY);
@@ -534,14 +539,14 @@ exp       :       STRING
 /* C++.  */
 exp     :       TRUEKEYWORD    
                         { write_exp_elt_opcode (OP_LONG);
-                          write_exp_elt_type (builtin_type_bool);
+                          write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
                           write_exp_elt_longcst ((LONGEST) 1);
                           write_exp_elt_opcode (OP_LONG); }
        ;
 
 exp     :       FALSEKEYWORD   
                         { write_exp_elt_opcode (OP_LONG);
-                          write_exp_elt_type (builtin_type_bool);
+                          write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
                           write_exp_elt_longcst ((LONGEST) 0);
                           write_exp_elt_opcode (OP_LONG); }
        ;
@@ -652,8 +657,8 @@ variable:   qualified_name
                          if (msymbol != NULL)
                            {
                              write_exp_msymbol (msymbol,
-                                                lookup_function_type (builtin_type_int),
-                                                builtin_type_int);
+                                                lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
+                                                builtin_type (current_gdbarch)->builtin_int);
                            }
                          else
                            if (!have_full_symbols () && !have_partial_symbols ())
@@ -708,8 +713,8 @@ variable:   name_not_typename
                              if (msymbol != NULL)
                                {
                                  write_exp_msymbol (msymbol,
-                                                    lookup_function_type (builtin_type_int),
-                                                    builtin_type_int);
+                                                    lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
+                                                    builtin_type (current_gdbarch)->builtin_int);
                                }
                              else if (!have_full_symbols () && !have_partial_symbols ())
                                error ("No symbol table is loaded.  Use the \"file\" command.");
@@ -795,68 +800,68 @@ func_mod: '(' ')'
 
 type   :       ptype
        |       typebase COLONCOLON '*'
-                       { $$ = lookup_member_type (builtin_type_int, $1); }
+                       { $$ = lookup_member_type (builtin_type (current_gdbarch)->builtin_int, $1); }
        ;
 
 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
        :       TYPENAME
                        { $$ = $1.type; }
        |       INT_KEYWORD
-                       { $$ = builtin_type_int; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_int; }
        |       LONG
-                       { $$ = builtin_type_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long; }
        |       SHORT
-                       { $$ = builtin_type_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_short; }
        |       LONG INT_KEYWORD
-                       { $$ = builtin_type_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long; }
        |       LONG SIGNED_KEYWORD INT_KEYWORD
-                       { $$ = builtin_type_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long; }
        |       LONG SIGNED_KEYWORD
-                       { $$ = builtin_type_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long; }
        |       SIGNED_KEYWORD LONG INT_KEYWORD
-                       { $$ = builtin_type_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long; }
        |       UNSIGNED LONG INT_KEYWORD
-                       { $$ = builtin_type_unsigned_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
        |       LONG UNSIGNED INT_KEYWORD
-                       { $$ = builtin_type_unsigned_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
        |       LONG UNSIGNED
-                       { $$ = builtin_type_unsigned_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
        |       LONG LONG
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       LONG LONG INT_KEYWORD
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       LONG LONG SIGNED_KEYWORD
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       SIGNED_KEYWORD LONG LONG
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
-                       { $$ = builtin_type_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
        |       UNSIGNED LONG LONG
-                       { $$ = builtin_type_unsigned_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
        |       UNSIGNED LONG LONG INT_KEYWORD
-                       { $$ = builtin_type_unsigned_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
        |       LONG LONG UNSIGNED
-                       { $$ = builtin_type_unsigned_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
        |       LONG LONG UNSIGNED INT_KEYWORD
-                       { $$ = builtin_type_unsigned_long_long; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
        |       SHORT INT_KEYWORD
-                       { $$ = builtin_type_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_short; }
        |       SHORT SIGNED_KEYWORD INT_KEYWORD
-                       { $$ = builtin_type_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_short; }
        |       SHORT SIGNED_KEYWORD
-                       { $$ = builtin_type_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_short; }
        |       UNSIGNED SHORT INT_KEYWORD
-                       { $$ = builtin_type_unsigned_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
        |       SHORT UNSIGNED 
-                       { $$ = builtin_type_unsigned_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
        |       SHORT UNSIGNED INT_KEYWORD
-                       { $$ = builtin_type_unsigned_short; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
        |       DOUBLE_KEYWORD
-                       { $$ = builtin_type_double; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_double; }
        |       LONG DOUBLE_KEYWORD
-                       { $$ = builtin_type_long_double; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_long_double; }
        |       STRUCT name
                        { $$ = lookup_struct (copy_name ($2),
                                              expression_context_block); }
@@ -872,11 +877,11 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
        |       UNSIGNED typename
                        { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
        |       UNSIGNED
-                       { $$ = builtin_type_unsigned_int; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_unsigned_int; }
        |       SIGNED_KEYWORD typename
                        { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
        |       SIGNED_KEYWORD
-                       { $$ = builtin_type_int; }
+                       { $$ = builtin_type (current_gdbarch)->builtin_int; }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead
                    in the token processing code in yylex. */         
@@ -966,19 +971,19 @@ typename: TYPENAME
                {
                  $$.stoken.ptr = "int";
                  $$.stoken.length = 3;
-                 $$.type = builtin_type_int;
+                 $$.type = builtin_type (current_gdbarch)->builtin_int;
                }
        |       LONG
                {
                  $$.stoken.ptr = "long";
                  $$.stoken.length = 4;
-                 $$.type = builtin_type_long;
+                 $$.type = builtin_type (current_gdbarch)->builtin_long;
                }
        |       SHORT
                {
                  $$.stoken.ptr = "short";
                  $$.stoken.length = 5;
-                 $$.type = builtin_type_short;
+                 $$.type = builtin_type (current_gdbarch)->builtin_short;
                }
        ;
 
@@ -1070,43 +1075,32 @@ parse_number (p, len, parsed_float, putithere)
   if (parsed_float)
     {
       /* It's a float since it contains a point or an exponent.  */
-      char c;
+      char *s = malloc (len);
       int num = 0;     /* number of tokens scanned by scanf */
       char saved_char = p[len];
 
       p[len] = 0;      /* null-terminate the token */
-      if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
-       num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
-      else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
-       num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
-      else
+      num = sscanf (p, DOUBLEST_SCAN_FORMAT "%s",
+                   &putithere->typed_val_float.dval, s);
+      p[len] = saved_char;     /* restore the input stream */
+
+      if (num == 1)
+       putithere->typed_val_float.type = 
+         builtin_type (current_gdbarch)->builtin_double;
+
+      if (num == 2 )
        {
-#ifdef SCANF_HAS_LONG_DOUBLE
-         num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
-#else
-         /* Scan it into a double, then assign it to the long double.
-            This at least wins with values representable in the range
-            of doubles. */
-         double temp;
-         num = sscanf (p, "%lg%c", &temp,&c);
-         putithere->typed_val_float.dval = temp;
-#endif
+         /* See if it has any float suffix: 'f' for float, 'l' for long 
+            double.  */
+         if (!strcasecmp (s, "f"))
+           putithere->typed_val_float.type = 
+             builtin_type (current_gdbarch)->builtin_float;
+         else if (!strcasecmp (s, "l"))
+           putithere->typed_val_float.type = 
+             builtin_type (current_gdbarch)->builtin_long_double;
+         else
+           return ERROR;
        }
-      p[len] = saved_char;     /* restore the input stream */
-      if (num != 1)            /* check scanf found ONLY a float ... */
-       return ERROR;
-      /* See if it has `f' or `l' suffix (float or long double).  */
-
-      c = tolower (p[len - 1]);
-
-      if (c == 'f')
-       putithere->typed_val_float.type = builtin_type_float;
-      else if (c == 'l')
-       putithere->typed_val_float.type = builtin_type_long_double;
-      else if (isdigit (c) || c == '.')
-       putithere->typed_val_float.type = builtin_type_double;
-      else
-       return ERROR;
 
       return FLOAT;
     }
@@ -1220,15 +1214,15 @@ parse_number (p, len, parsed_float, putithere)
         int.  This probably should be fixed.  GCC gives a warning on
         such constants.  */
 
-      unsigned_type = builtin_type_unsigned_int;
-      signed_type = builtin_type_int;
+      unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_int;
+      signed_type = builtin_type (current_gdbarch)->builtin_int;
     }
   else if (long_p <= 1
           && (un >> (TARGET_LONG_BIT - 2)) == 0)
     {
       high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
-      unsigned_type = builtin_type_unsigned_long;
-      signed_type = builtin_type_long;
+      unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long;
+      signed_type = builtin_type (current_gdbarch)->builtin_long;
     }
   else
     {
@@ -1239,8 +1233,8 @@ parse_number (p, len, parsed_float, putithere)
       else
        shift = (TARGET_LONG_LONG_BIT - 1);
       high_bit = (ULONGEST) 1 << shift;
-      unsigned_type = builtin_type_unsigned_long_long;
-      signed_type = builtin_type_long_long;
+      unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long_long;
+      signed_type = builtin_type (current_gdbarch)->builtin_long_long;
     }
 
    putithere->typed_val_int.val = n;
@@ -1392,7 +1386,7 @@ yylex ()
         }
 
       yylval.typed_val_int.val = c;
-      yylval.typed_val_int.type = builtin_type_char;
+      yylval.typed_val_int.type = builtin_type (current_gdbarch)->builtin_char;
 
       c = *lexptr++;
       if (c != '\'')
This page took 0.030527 seconds and 4 git commands to generate.