* main.c (main): Make sure command loop is used with cygwin32.

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

diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 56ed6e675e296682aef92e255e1413c1f1595058..08a11ce2c3c81eead4336b72c09948fa72b19c5e 100644 (file)
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -1,5 +1,6 @@
 /* YACC grammar for Modula-2 expressions, for GDB.
 /* YACC grammar for Modula-2 expressions, for GDB.

-   Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 1995
+   Free Software Foundation, Inc.

    Generated from expread.y (now c-exp.y) and contributed by the Department
    of Computer Science at the State University of New York at Buffalo, 1991.
 
    Generated from expread.y (now c-exp.y) and contributed by the Department
    of Computer Science at the State University of New York at Buffalo, 1991.
 


@@ -17,7 +18,7 @@ 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
 
 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 /* Parse a Modula-2 expression from text in a string,
    and return the result as a  struct expression  pointer.
 
 /* Parse a Modula-2 expression from text in a string,
    and return the result as a  struct expression  pointer.


@@ -39,11 +40,15 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 %{
 
 #include "defs.h"
 %{
 
 #include "defs.h"

+#include "gdb_string.h"

 #include "expression.h"
 #include "language.h"
 #include "value.h"
 #include "parser-defs.h"
 #include "m2-lang.h"
 #include "expression.h"
 #include "language.h"
 #include "value.h"
 #include "parser-defs.h"
 #include "m2-lang.h"

+#include "bfd.h" /* Required by objfiles.h.  */
+#include "symfile.h" /* Required by objfiles.h.  */
+#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */

 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
    as well as gratuitiously global symbol names, so we can have multiple
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
    as well as gratuitiously global symbol names, so we can have multiple


@@ -81,6 +86,15 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        yylloc  m2_lloc
 #define        yyreds  m2_reds         /* With YYDEBUG defined */
 #define        yytoks  m2_toks         /* With YYDEBUG defined */
 #define        yylloc  m2_lloc
 #define        yyreds  m2_reds         /* With YYDEBUG defined */
 #define        yytoks  m2_toks         /* With YYDEBUG defined */

+#define yylhs  m2_yylhs
+#define yylen  m2_yylen
+#define yydefred m2_yydefred
+#define yydgoto        m2_yydgoto
+#define yysindex m2_yysindex
+#define yyrindex m2_yyrindex
+#define yygindex m2_yygindex
+#define yytable         m2_yytable
+#define yycheck         m2_yycheck

 
 #ifndef YYDEBUG
 #define        YYDEBUG 0               /* Default to no yydebug support */
 
 #ifndef YYDEBUG
 #define        YYDEBUG 0               /* Default to no yydebug support */


@@ -122,7 +136,7 @@ static struct block *modblock=0;
   {
     LONGEST lval;
     unsigned LONGEST ulval;
   {
     LONGEST lval;
     unsigned LONGEST ulval;

-    double dval;
+    DOUBLEST dval;

     struct symbol *sym;
     struct type *tval;
     struct stoken sval;
     struct symbol *sym;
     struct type *tval;
     struct stoken sval;


@@ -164,9 +178,7 @@ static struct block *modblock=0;
 /* The GDB scope operator */
 %token COLONCOLON
 
 /* The GDB scope operator */
 %token COLONCOLON
 

-%token <lval> LAST REGNAME
-
-%token <ivar> INTERNAL_VAR
+%token <voidval> INTERNAL_VAR

 
 /* M2 tokens */
 %left ','
 
 /* M2 tokens */
 %left ','


@@ -505,19 +517,6 @@ exp        :       FLOAT
 exp    :       variable
        ;
 
 exp    :       variable
        ;
 

-/* The GDB internal variable $$, et al. */
-exp    :       LAST
-                       { write_exp_elt_opcode (OP_LAST);
-                         write_exp_elt_longcst ((LONGEST) $1);
-                         write_exp_elt_opcode (OP_LAST); }
-       ;
-
-exp    :       REGNAME
-                       { write_exp_elt_opcode (OP_REGISTER);
-                         write_exp_elt_longcst ((LONGEST) $1);
-                         write_exp_elt_opcode (OP_REGISTER); }
-       ;
-

 exp    :       SIZE '(' type ')'       %prec UNARY
                        { write_exp_elt_opcode (OP_LONG);
                          write_exp_elt_type (builtin_type_int);
 exp    :       SIZE '(' type ')'       %prec UNARY
                        { write_exp_elt_opcode (OP_LONG);
                          write_exp_elt_type (builtin_type_int);


@@ -559,15 +558,13 @@ fblock    :       block COLONCOLON BLOCKNAME
 /* Useful for assigning to PROCEDURE variables */
 variable:      fblock
                        { write_exp_elt_opcode(OP_VAR_VALUE);
 /* Useful for assigning to PROCEDURE variables */
 variable:      fblock
                        { write_exp_elt_opcode(OP_VAR_VALUE);

+                         write_exp_elt_block (NULL);

                          write_exp_elt_sym ($1);
                          write_exp_elt_opcode (OP_VAR_VALUE); }
        ;
 
 /* GDB internal ($foo) variable */
 variable:      INTERNAL_VAR
                          write_exp_elt_sym ($1);
                          write_exp_elt_opcode (OP_VAR_VALUE); }
        ;
 
 /* GDB internal ($foo) variable */
 variable:      INTERNAL_VAR

-                       { write_exp_elt_opcode (OP_INTERNALVAR);
-                         write_exp_elt_intern ($1);
-                         write_exp_elt_opcode (OP_INTERNALVAR); }

        ;
 
 /* GDB scope operator */
        ;
 
 /* GDB scope operator */


@@ -580,6 +577,8 @@ variable:   block COLONCOLON NAME
                                   copy_name ($3));
 
                          write_exp_elt_opcode (OP_VAR_VALUE);
                                   copy_name ($3));
 
                          write_exp_elt_opcode (OP_VAR_VALUE);

+                         /* block_found is set by lookup_symbol.  */
+                         write_exp_elt_block (block_found);

                          write_exp_elt_sym (sym);
                          write_exp_elt_opcode (OP_VAR_VALUE); }
        ;
                          write_exp_elt_sym (sym);
                          write_exp_elt_opcode (OP_VAR_VALUE); }
        ;


@@ -596,33 +595,19 @@ variable: NAME
                                               NULL);
                          if (sym)
                            {
                                               NULL);
                          if (sym)
                            {

-                             switch (sym->class)
+                             if (symbol_read_needs_frame (sym))

                                {
                                {

-                               case LOC_REGISTER:
-                               case LOC_ARG:
-                               case LOC_LOCAL:
-                               case LOC_REF_ARG:
-                               case LOC_REGPARM:
-                               case LOC_LOCAL_ARG:

                                  if (innermost_block == 0 ||
                                  if (innermost_block == 0 ||

-                                     contained_in (block_found,
+                                     contained_in (block_found, 

                                                    innermost_block))
                                    innermost_block = block_found;
                                                    innermost_block))
                                    innermost_block = block_found;

-                                 break;
-
-                               case LOC_UNDEF:
-                               case LOC_CONST:
-                               case LOC_STATIC:
-                               case LOC_TYPEDEF:
-                               case LOC_LABEL: /* maybe should go above? */
-                               case LOC_BLOCK:
-                               case LOC_CONST_BYTES:
-                               case LOC_OPTIMIZED_OUT:
-                                 /* These are listed so gcc -Wall will reveal
-                                    un-handled cases.  */
-                                 break;

                                }
                                }

+

                              write_exp_elt_opcode (OP_VAR_VALUE);
                              write_exp_elt_opcode (OP_VAR_VALUE);

+                             /* We want to use the selected frame, not
+                                another more inner frame which happens to
+                                be in the same block.  */
+                             write_exp_elt_block (NULL);

                              write_exp_elt_sym (sym);
                              write_exp_elt_opcode (OP_VAR_VALUE);
                            }
                              write_exp_elt_sym (sym);
                              write_exp_elt_opcode (OP_VAR_VALUE);
                            }


@@ -631,23 +616,14 @@ variable: NAME
                              struct minimal_symbol *msymbol;
                              register char *arg = copy_name ($1);
 
                              struct minimal_symbol *msymbol;
                              register char *arg = copy_name ($1);
 

-                             msymbol = lookup_minimal_symbol (arg,
-                                         (struct objfile *) NULL);
+                             msymbol =
+                               lookup_minimal_symbol (arg, NULL, NULL);

                              if (msymbol != NULL)
                                {
                              if (msymbol != NULL)
                                {

-                                 write_exp_elt_opcode (OP_LONG);
-                                 write_exp_elt_type (builtin_type_int);
-                                 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
-                                 write_exp_elt_opcode (OP_LONG);
-                                 write_exp_elt_opcode (UNOP_MEMVAL);
-                                 if (msymbol -> type == mst_data ||
-                                     msymbol -> type == mst_bss)
-                                   write_exp_elt_type (builtin_type_int);
-                                 else if (msymbol -> type == mst_text)
-                                   write_exp_elt_type (lookup_function_type (builtin_type_int));
-                                 else
-                                   write_exp_elt_type (builtin_type_char);
-                                 write_exp_elt_opcode (UNOP_MEMVAL);
+                                 write_exp_msymbol
+                                   (msymbol,
+                                    lookup_function_type (builtin_type_int),
+                                    builtin_type_int);

                                }
                              else if (!have_full_symbols () && !have_partial_symbols ())
                                error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
                                }
                              else if (!have_full_symbols () && !have_partial_symbols ())
                                error ("No symbol table is loaded.  Use the \"symbol-file\" command.");


@@ -853,7 +829,7 @@ yylex ()
 
 
   /* See if it is a special token of length 2 */
 
 
   /* See if it is a special token of length 2 */

-  for( i = 0 ; i < sizeof tokentab2 / sizeof tokentab2[0] ; i++)
+  for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)

      if(STREQN(tokentab2[i].name, tokstart, 2))
      {
        lexptr += 2;
      if(STREQN(tokentab2[i].name, tokstart, 2))
      {
        lexptr += 2;


@@ -1009,78 +985,20 @@ yylex ()
 
   lexptr += namelen;
 
 
   lexptr += namelen;
 

-  /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
-     and $$digits (equivalent to $<-digits> if you could type that).
-     Make token type LAST, and put the number (the digits) in yylval.  */
-
-  if (*tokstart == '$')
-    {
-      register int negate = 0;
-      c = 1;
-      /* Double dollar means negate the number and add -1 as well.
-        Thus $$ alone means -1.  */
-      if (namelen >= 2 && tokstart[1] == '$')
-       {
-         negate = 1;
-         c = 2;
-       }
-      if (c == namelen)
-       {
-         /* Just dollars (one or two) */
-         yylval.lval = - negate;
-         return LAST;
-       }
-      /* Is the rest of the token digits?  */
-      for (; c < namelen; c++)
-       if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
-         break;
-      if (c == namelen)
-       {
-         yylval.lval = atoi (tokstart + 1 + negate);
-         if (negate)
-           yylval.lval = - yylval.lval;
-         return LAST;
-       }
-    }
-
-  /* Handle tokens that refer to machine registers:
-     $ followed by a register name.  */
-
-  if (*tokstart == '$') {
-    for (c = 0; c < NUM_REGS; c++)
-      if (namelen - 1 == strlen (reg_names[c])
-         && STREQN (tokstart + 1, reg_names[c], namelen - 1))
-       {
-         yylval.lval = c;
-         return REGNAME;
-       }
-    for (c = 0; c < num_std_regs; c++)
-     if (namelen - 1 == strlen (std_regs[c].name)
-        && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
-       {
-        yylval.lval = std_regs[c].regnum;
-        return REGNAME;
-       }
-  }
-
-

   /*  Lookup special keywords */
   /*  Lookup special keywords */

-  for(i = 0 ; i < sizeof(keytab) / sizeof(keytab[0]) ; i++)
+  for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)

      if(namelen == strlen(keytab[i].keyw) && STREQN(tokstart,keytab[i].keyw,namelen))
           return keytab[i].token;
 
   yylval.sval.ptr = tokstart;
   yylval.sval.length = namelen;
 
      if(namelen == strlen(keytab[i].keyw) && STREQN(tokstart,keytab[i].keyw,namelen))
           return keytab[i].token;
 
   yylval.sval.ptr = tokstart;
   yylval.sval.length = namelen;
 

-  /* Any other names starting in $ are debugger internal variables.  */
-

   if (*tokstart == '$')
     {
   if (*tokstart == '$')
     {

-      yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
+      write_dollar_variable (yylval.sval);

       return INTERNAL_VAR;
     }
 
       return INTERNAL_VAR;
     }
 

-

   /* Use token-type BLOCKNAME for symbols that happen to be defined as
      functions.  If this is not so, then ...
      Use token-type TYPENAME for symbols that happen to be defined
   /* Use token-type BLOCKNAME for symbols that happen to be defined as
      functions.  If this is not so, then ...
      Use token-type TYPENAME for symbols that happen to be defined


@@ -1103,17 +1021,21 @@ yylex ()
 
     if(sym)
     {
 
     if(sym)
     {

-       switch(sym->class)
+       switch(sym->aclass)

        {
        case LOC_STATIC:
        case LOC_REGISTER:
        case LOC_ARG:
        case LOC_REF_ARG:
        case LOC_REGPARM:
        {
        case LOC_STATIC:
        case LOC_REGISTER:
        case LOC_ARG:
        case LOC_REF_ARG:
        case LOC_REGPARM:

+       case LOC_REGPARM_ADDR:

        case LOC_LOCAL:
        case LOC_LOCAL_ARG:
        case LOC_LOCAL:
        case LOC_LOCAL_ARG:

+       case LOC_BASEREG:
+       case LOC_BASEREG_ARG:

        case LOC_CONST:
        case LOC_CONST_BYTES:
        case LOC_CONST:
        case LOC_CONST_BYTES:

+       case LOC_OPTIMIZED_OUT:

          return NAME;
 
        case LOC_TYPEDEF:
          return NAME;
 
        case LOC_TYPEDEF:


@@ -1126,6 +1048,7 @@ yylex ()
          error("internal:  Undefined class in m2lex()");
 
        case LOC_LABEL:
          error("internal:  Undefined class in m2lex()");
 
        case LOC_LABEL:

+       case LOC_UNRESOLVED:

          error("internal:  Unforseen case in m2lex()");
        }
     }
          error("internal:  Unforseen case in m2lex()");
        }
     }


@@ -1164,13 +1087,8 @@ make_qualname(mod,ident)
 #endif  /* 0 */
 
 void
 #endif  /* 0 */
 
 void

-yyerror(msg)
-     char *msg;        /* unused */
+yyerror (msg)
+     char *msg;

 {
 {

-   printf("Parsing:  %s\n",lexptr);
-   if (yychar < 256)
-     error("Invalid syntax in expression near character '%c'.",yychar);
-   else
-     error("Invalid syntax in expression");
+  error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);

 }
 }

-