* snapshots.readme: Add notes for UNIX make and GNU make.

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

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index b77200ea0c079bd281ec90676fd6989feb6c4c45..654bf75c356453652d3804f0bd14f9abb1b70118 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -43,9 +43,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "language.h"
 #include "c-lang.h"
 
-/* These MUST be included in any grammar file!!!! Please choose unique names!
-   Note that this are a combined list of variables that can be produced
-   by any one of bison, byacc, or yacc. */
+/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
+   as well as gratuitiously global symbol names, so we can have multiple
+   yacc generated parsers in gdb.  Note that these are only the variables
+   produced by yacc.  If other parser generators (bison, byacc, etc) produce
+   additional global names that conflict at link time, then those parser
+   generators need to be fixed instead of adding those names to this list. */
+
 #define        yymaxdepth c_maxdepth
 #define        yyparse c_parse
 #define        yylex   c_lex
@@ -75,24 +79,20 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        yylloc  c_lloc
 #define yyreds c_reds          /* With YYDEBUG defined */
 #define yytoks c_toks          /* With YYDEBUG defined */
-#define yyss   c_yyss          /* byacc */
-#define        yyssp   c_yysp          /* byacc */
-#define        yyvs    c_yyvs          /* byacc */
-#define        yyvsp   c_yyvsp         /* byacc */
+
+#ifndef YYDEBUG
+#define        YYDEBUG 0               /* Default to no yydebug support */
+#endif
 
 int
 yyparse PARAMS ((void));
 
-int
+static int
 yylex PARAMS ((void));
 
 void
 yyerror PARAMS ((char *));
 
-#if MAINTENANCE_CMDS
-#define        YYDEBUG 1
-#endif
-
 %}
 
 /* Although the yacc "value" of an expression is not used,
@@ -102,7 +102,6 @@ yyerror PARAMS ((char *));
 %union
   {
     LONGEST lval;
-    unsigned LONGEST ulval;
     struct {
       LONGEST val;
       struct type *type;
@@ -128,7 +127,8 @@ static int
 parse_number PARAMS ((char *, int, int, YYSTYPE *));
 %}
 
-%type <voidval> exp exp1 type_exp start variable qualified_name
+%type <voidval> exp exp1 type_exp start variable qualified_name lcurly
+%type <lval> rcurly
 %type <tval> type typebase
 %type <tvec> nonempty_typelist
 /* %type <bval> block */
@@ -307,6 +307,10 @@ exp        :       exp '('
                          write_exp_elt_opcode (OP_FUNCALL); }
        ;
 
+lcurly :       '{'
+                       { start_arglist (); }
+       ;
+
 arglist        :
        ;
 
@@ -318,7 +322,17 @@ arglist    :       arglist ',' exp   %prec ABOVE_COMMA
                        { arglist_len++; }
        ;
 
-exp    :       '{' type '}' exp  %prec UNARY
+rcurly :       '}'
+                       { $$ = end_arglist () - 1; }
+       ;
+exp    :       lcurly arglist rcurly   %prec ARROW
+                       { write_exp_elt_opcode (OP_ARRAY);
+                         write_exp_elt_longcst ((LONGEST) 0);
+                         write_exp_elt_longcst ((LONGEST) $3);
+                         write_exp_elt_opcode (OP_ARRAY); }
+       ;
+
+exp    :       lcurly type rcurly exp  %prec UNARY
                        { write_exp_elt_opcode (UNOP_MEMVAL);
                          write_exp_elt_type ($2);
                          write_exp_elt_opcode (UNOP_MEMVAL); }
@@ -480,9 +494,27 @@ exp        :       SIZEOF '(' type ')'     %prec UNARY
        ;
 
 exp    :       STRING
-                       { write_exp_elt_opcode (OP_STRING);
-                         write_exp_string ($1);
-                         write_exp_elt_opcode (OP_STRING); }
+                       { /* C strings are converted into array constants with
+                            an explicit null byte added at the end.  Thus
+                            the array upper bound is the string length.
+                            There is no such thing in C as a completely empty
+                            string. */
+                         char *sp = $1.ptr; int count = $1.length;
+                         while (count-- > 0)
+                           {
+                             write_exp_elt_opcode (OP_LONG);
+                             write_exp_elt_type (builtin_type_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_longcst ((LONGEST)'\0');
+                         write_exp_elt_opcode (OP_LONG);
+                         write_exp_elt_opcode (OP_ARRAY);
+                         write_exp_elt_longcst ((LONGEST) 0);
+                         write_exp_elt_longcst ((LONGEST) ($1.length));
+                         write_exp_elt_opcode (OP_ARRAY); }
        ;
 
 /* C++.  */
@@ -639,6 +671,7 @@ variable:   name_not_typename
                                case LOC_LABEL:
                                case LOC_BLOCK:
                                case LOC_CONST_BYTES:
+                               case LOC_OPTIMIZED_OUT:
 
                                  /* In this case the expression can
                                     be evaluated regardless of what
@@ -929,7 +962,7 @@ parse_number (p, len, parsed_float, putithere)
   register int base = input_radix;
   int unsigned_p = 0;
   int long_p = 0;
-  LONGEST high_bit;
+  unsigned LONGEST high_bit;
   struct type *signed_type;
   struct type *unsigned_type;
 
@@ -1010,17 +1043,26 @@ parse_number (p, len, parsed_float, putithere)
      /* If the number is too big to be an int, or it's got an l suffix
        then it's a long.  Work out if this has to be a long by
        shifting right and and seeing if anything remains, and the
-       target int size is different to the target long size. */
-
-    if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
+       target int size is different to the target long size.
+
+       In the expression below, we could have tested
+               (n >> TARGET_INT_BIT)
+       to see if it was zero,
+       but too many compilers warn about that, when ints and longs
+       are the same size.  So we shift it twice, with fewer bits
+       each time, for the same result.  */
+
+    if (   (TARGET_INT_BIT != TARGET_LONG_BIT 
+            && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */
+        || long_p)
       {
-         high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
+         high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
         unsigned_type = builtin_type_unsigned_long;
         signed_type = builtin_type_long;
       }
     else 
       {
-        high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
+        high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
         unsigned_type = builtin_type_unsigned_int;
         signed_type = builtin_type_int;
       }    
@@ -1081,7 +1123,7 @@ static const struct token tokentab2[] =
 
 /* Read one token, getting characters through lexptr.  */
 
-int
+static int
 yylex ()
 {
   int c;