Beginnings of template debugging tests.

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

diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 73e08553066bfeb306077c3bf7456e4ae05545b9..bbbdda48f7786253fd05ea7a0dd129cc4daaab9e 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
+   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.
 


@@ -26,26 +27,36 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
    See expression.h for the details of the format.
    What is important here is that it can be built up sequentially
    during the process of parsing; the lower levels of the tree always
    See expression.h for the details of the format.
    What is important here is that it can be built up sequentially
    during the process of parsing; the lower levels of the tree always

-   come first in the result.  */
+   come first in the result.
+
+   Note that malloc's and realloc's in this file are transformed to
+   xmalloc and xrealloc respectively by the same sed command in the
+   makefile that remaps any other malloc/realloc inserted by the parser
+   generator.  Doing this with #defines and trying to control the interaction
+   with include files (<malloc.h> and <stdlib.h> for example) just became
+   too messy, particularly when such includes can be inserted at random
+   times by the parser generator. */

    
 %{
    
 %{

-#include <stdio.h>
-#include <string.h>
+

 #include "defs.h"
 #include "defs.h"

-#include "symtab.h"
-#include "gdbtypes.h"
-#include "frame.h"
+#include <string.h>

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

-#include "bfd.h"
-#include "symfile.h"
-#include "objfiles.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
+   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. */

 
 

-/* 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. */

 #define        yymaxdepth m2_maxdepth
 #define        yyparse m2_parse
 #define        yylex   m2_lex
 #define        yymaxdepth m2_maxdepth
 #define        yyparse m2_parse
 #define        yylex   m2_lex


@@ -61,8 +72,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        yypgo   m2_pgo
 #define        yyact   m2_act
 #define        yyexca  m2_exca
 #define        yypgo   m2_pgo
 #define        yyact   m2_act
 #define        yyexca  m2_exca

-#define yyerrflag m2_errflag
-#define yynerrs        m2_nerrs
+#define        yyerrflag m2_errflag
+#define        yynerrs m2_nerrs

 #define        yyps    m2_ps
 #define        yypv    m2_pv
 #define        yys     m2_s
 #define        yyps    m2_ps
 #define        yypv    m2_pv
 #define        yys     m2_s


@@ -73,36 +84,39 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        yy_yyv  m2_yyv
 #define        yyval   m2_val
 #define        yylloc  m2_lloc
 #define        yy_yyv  m2_yyv
 #define        yyval   m2_val
 #define        yylloc  m2_lloc

-#define yyss   m2_yyss         /* byacc */
-#define        yyssp   m2_yysp         /* byacc */
-#define        yyvs    m2_yyvs         /* byacc */
-#define        yyvsp   m2_yyvsp        /* byacc */
+#define        yyreds  m2_reds         /* With YYDEBUG defined */
+#define        yytoks  m2_toks         /* With YYDEBUG defined */

 
 

-#if 0
-static char *
-make_qualname PARAMS ((char *, char *));
+#ifndef YYDEBUG
+#define        YYDEBUG 0               /* Default to no yydebug support */

 #endif
 
 #endif
 

-static int
-parse_number PARAMS ((int));
+int
+yyparse PARAMS ((void));

 
 static int
 yylex PARAMS ((void));
 
 
 static int
 yylex PARAMS ((void));
 

-static void
+void

 yyerror PARAMS ((char *));
 
 yyerror PARAMS ((char *));
 

-int
-yyparse PARAMS ((void));
+#if 0
+static char *
+make_qualname PARAMS ((char *, char *));
+#endif
+
+static int
+parse_number PARAMS ((int));

 
 /* The sign of the number being parsed. */
 
 /* The sign of the number being parsed. */

-int number_sign = 1;
+static int number_sign = 1;

 
 /* The block that the module specified by the qualifer on an identifer is
    contained in, */
 
 /* The block that the module specified by the qualifer on an identifer is
    contained in, */

-struct block *modblock=0;
+#if 0
+static struct block *modblock=0;
+#endif

 
 

-/* #define     YYDEBUG 1 */

 %}
 
 /* Although the yacc "value" of an expression is not used,
 %}
 
 /* Although the yacc "value" of an expression is not used,


@@ -165,7 +179,7 @@ struct block *modblock=0;
 %nonassoc ASSIGN
 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
 %left OROR
 %nonassoc ASSIGN
 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
 %left OROR

-%left ANDAND '&'
+%left LOGICAL_AND '&'

 %left '@'
 %left '+' '-'
 %left '*' '/' DIV MOD
 %left '@'
 %left '+' '-'
 %left '*' '/' DIV MOD


@@ -177,18 +191,7 @@ struct block *modblock=0;
 %right QID
 */
 
 %right QID
 */
 

-%{
-/* Ensure that if the generated parser contains any calls to malloc/realloc,
-   that they get mapped to xmalloc/xrealloc.  We have to do this here
-   rather than earlier in the file because this is the first point after
-   the place where the SVR4 yacc includes <malloc.h>, and if we do it
-   before that, then the remapped declarations in <malloc.h> will collide
-   with the ones in "defs.h". */
-
-#define malloc xmalloc
-#define realloc        xrealloc
-%}
-
+\f

 %%
 
 start   :      exp
 %%
 
 start   :      exp


@@ -219,7 +222,7 @@ exp :       '+' exp    %prec UNARY
        ;
 
 exp    :       not_exp exp %prec UNARY
        ;
 
 exp    :       not_exp exp %prec UNARY

-                       { write_exp_elt_opcode (UNOP_ZEROP); }
+                       { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }

        ;
 
 not_exp        :       NOT
        ;
 
 not_exp        :       NOT


@@ -335,9 +338,9 @@ exp     :       exp '['
                           function types */
                         { start_arglist(); }
                 non_empty_arglist ']'  %prec DOT
                           function types */
                         { start_arglist(); }
                 non_empty_arglist ']'  %prec DOT

-                        { write_exp_elt_opcode (BINOP_MULTI_SUBSCRIPT);
+                        { write_exp_elt_opcode (MULTI_SUBSCRIPT);

                          write_exp_elt_longcst ((LONGEST) end_arglist());
                          write_exp_elt_longcst ((LONGEST) end_arglist());

-                         write_exp_elt_opcode (BINOP_MULTI_SUBSCRIPT); }
+                         write_exp_elt_opcode (MULTI_SUBSCRIPT); }

         ;
 
 exp    :       exp '('
         ;
 
 exp    :       exp '('


@@ -446,16 +449,12 @@ exp       :       exp '>' exp
                        { write_exp_elt_opcode (BINOP_GTR); }
        ;
 
                        { write_exp_elt_opcode (BINOP_GTR); }
        ;
 

-exp    :       exp ANDAND exp
-                       { write_exp_elt_opcode (BINOP_AND); }
-       ;
-
-exp    :       exp '&' exp
-                       { write_exp_elt_opcode (BINOP_AND); }
+exp    :       exp LOGICAL_AND exp
+                       { write_exp_elt_opcode (BINOP_LOGICAL_AND); }

        ;
 
 exp    :       exp OROR exp
        ;
 
 exp    :       exp OROR exp

-                       { write_exp_elt_opcode (BINOP_OR); }
+                       { write_exp_elt_opcode (BINOP_LOGICAL_OR); }

        ;
 
 exp    :       exp ASSIGN exp
        ;
 
 exp    :       exp ASSIGN exp


@@ -565,6 +564,7 @@ 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); }
        ;
                          write_exp_elt_sym ($1);
                          write_exp_elt_opcode (OP_VAR_VALUE); }
        ;


@@ -586,6 +586,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); }
        ;


@@ -602,32 +604,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:
-                                 /* 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);
                            }


@@ -636,23 +625,13 @@ 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);

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

-                                 write_exp_elt_opcode (OP_LONG);
-                                 write_exp_elt_type (builtin_type_int);
-                                 write_exp_elt_longcst ((LONGEST) msymbol -> address);
-                                 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.");


@@ -815,7 +794,7 @@ static struct keyword keytab[] =
 {
     {"OR" ,   OROR      },
     {"IN",    IN         },/* Note space after IN */
 {
     {"OR" ,   OROR      },
     {"IN",    IN         },/* Note space after IN */

-    {"AND",   ANDAND     },
+    {"AND",   LOGICAL_AND},

     {"ABS",   ABS       },
     {"CHR",   CHR       },
     {"DEC",   DEC       },
     {"ABS",   ABS       },
     {"CHR",   CHR       },
     {"DEC",   DEC       },


@@ -859,7 +838,7 @@ yylex ()
 
   /* See if it is a special token of length 2 */
   for( i = 0 ; i < sizeof tokentab2 / sizeof tokentab2[0] ; i++)
 
   /* See if it is a special token of length 2 */
   for( i = 0 ; i < sizeof tokentab2 / sizeof tokentab2[0] ; i++)

-     if(!strncmp(tokentab2[i].name, tokstart, 2))
+     if(STREQN(tokentab2[i].name, tokstart, 2))

      {
        lexptr += 2;
        return tokentab2[i].token;
      {
        lexptr += 2;
        return tokentab2[i].token;


@@ -1054,14 +1033,14 @@ yylex ()
   if (*tokstart == '$') {
     for (c = 0; c < NUM_REGS; c++)
       if (namelen - 1 == strlen (reg_names[c])
   if (*tokstart == '$') {
     for (c = 0; c < NUM_REGS; c++)
       if (namelen - 1 == strlen (reg_names[c])

-         && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
+         && 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)
        {
          yylval.lval = c;
          return REGNAME;
        }
     for (c = 0; c < num_std_regs; c++)
      if (namelen - 1 == strlen (std_regs[c].name)

-        && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
+        && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))

        {
         yylval.lval = std_regs[c].regnum;
         return REGNAME;
        {
         yylval.lval = std_regs[c].regnum;
         return REGNAME;


@@ -1071,7 +1050,7 @@ yylex ()
 
   /*  Lookup special keywords */
   for(i = 0 ; i < sizeof(keytab) / sizeof(keytab[0]) ; i++)
 
   /*  Lookup special keywords */
   for(i = 0 ; i < sizeof(keytab) / sizeof(keytab[0]) ; i++)

-     if(namelen == strlen(keytab[i].keyw) && !strncmp(tokstart,keytab[i].keyw,namelen))
+     if(namelen == strlen(keytab[i].keyw) && STREQN(tokstart,keytab[i].keyw,namelen))

           return keytab[i].token;
 
   yylval.sval.ptr = tokstart;
           return keytab[i].token;
 
   yylval.sval.ptr = tokstart;


@@ -1115,10 +1094,14 @@ yylex ()
        case LOC_ARG:
        case LOC_REF_ARG:
        case LOC_REGPARM:
        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:


@@ -1137,12 +1120,12 @@ yylex ()
     else
     {
        /* Built-in BOOLEAN type.  This is sort of a hack. */
     else
     {
        /* Built-in BOOLEAN type.  This is sort of a hack. */

-       if(!strncmp(tokstart,"TRUE",4))
+       if(STREQN(tokstart,"TRUE",4))

        {
          yylval.ulval = 1;
          return M2_TRUE;
        }
        {
          yylval.ulval = 1;
          return M2_TRUE;
        }

-       else if(!strncmp(tokstart,"FALSE",5))
+       else if(STREQN(tokstart,"FALSE",5))

        {
          yylval.ulval = 0;
          return M2_FALSE;
        {
          yylval.ulval = 0;
          return M2_FALSE;


@@ -1159,7 +1142,7 @@ static char *
 make_qualname(mod,ident)
    char *mod, *ident;
 {
 make_qualname(mod,ident)
    char *mod, *ident;
 {

-   char *new = xmalloc(strlen(mod)+strlen(ident)+2);
+   char *new = malloc(strlen(mod)+strlen(ident)+2);

 
    strcpy(new,mod);
    strcat(new,".");
 
    strcpy(new,mod);
    strcat(new,".");


@@ -1168,113 +1151,9 @@ make_qualname(mod,ident)
 }
 #endif  /* 0 */
 
 }
 #endif  /* 0 */
 

-static void
-yyerror(msg)
-     char *msg;        /* unused */
-{
-   printf("Parsing:  %s\n",lexptr);
-   if (yychar < 256)
-     error("Invalid syntax in expression near character '%c'.",yychar);
-   else
-     error("Invalid syntax in expression");
-}
-\f
-/* Table of operators and their precedences for printing expressions.  */
-
-const static struct op_print m2_op_print_tab[] = {
-    {"+",   BINOP_ADD, PREC_ADD, 0},
-    {"+",   UNOP_PLUS, PREC_PREFIX, 0},
-    {"-",   BINOP_SUB, PREC_ADD, 0},
-    {"-",   UNOP_NEG, PREC_PREFIX, 0},
-    {"*",   BINOP_MUL, PREC_MUL, 0},
-    {"/",   BINOP_DIV, PREC_MUL, 0},
-    {"DIV", BINOP_INTDIV, PREC_MUL, 0},
-    {"MOD", BINOP_REM, PREC_MUL, 0},
-    {":=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
-    {"OR",  BINOP_OR, PREC_OR, 0},
-    {"AND", BINOP_AND, PREC_AND, 0},
-    {"NOT", UNOP_ZEROP, PREC_PREFIX, 0},
-    {"=",   BINOP_EQUAL, PREC_EQUAL, 0},
-    {"<>",  BINOP_NOTEQUAL, PREC_EQUAL, 0},
-    {"<=",  BINOP_LEQ, PREC_ORDER, 0},
-    {">=",  BINOP_GEQ, PREC_ORDER, 0},
-    {">",   BINOP_GTR, PREC_ORDER, 0},
-    {"<",   BINOP_LESS, PREC_ORDER, 0},
-    {"^",   UNOP_IND, PREC_PREFIX, 0},
-    {"@",   BINOP_REPEAT, PREC_REPEAT, 0},
-};
-\f
-/* The built-in types of Modula-2.  */
-
-struct type *builtin_type_m2_char;
-struct type *builtin_type_m2_int;
-struct type *builtin_type_m2_card;
-struct type *builtin_type_m2_real;
-struct type *builtin_type_m2_bool;
-
-struct type ** const (m2_builtin_types[]) = 
-{
-  &builtin_type_m2_char,
-  &builtin_type_m2_int,
-  &builtin_type_m2_card,
-  &builtin_type_m2_real,
-  &builtin_type_m2_bool,
-  0
-};
-
-const struct language_defn m2_language_defn = {
-  "modula-2",
-  language_m2,
-  m2_builtin_types,
-  range_check_on,
-  type_check_on,
-  m2_parse,                    /* parser */
-  m2_error,                    /* parser error function */
-  &builtin_type_m2_int,                /* longest signed   integral type */
-  &builtin_type_m2_card,               /* longest unsigned integral type */
-  &builtin_type_m2_real,               /* longest floating point type */
-  "0%XH", "0%", "XH",          /* Hex   format string, prefix, suffix */
-  "%oB",  "%",  "oB",          /* Octal format string, prefix, suffix */
-  m2_op_print_tab,             /* expression operators for printing */
-  LANG_MAGIC
-};
-
-/* Initialization for Modula-2 */
-

 void
 void

-_initialize_m2_exp ()
+yyerror (msg)
+     char *msg;

 {
 {

-  /* Modula-2 "pervasive" types.  NOTE:  these can be redefined!!! */
-  builtin_type_m2_int =
-    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-              0,
-              "INTEGER", (struct objfile *) NULL);
-  builtin_type_m2_card =
-    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "CARDINAL", (struct objfile *) NULL);
-  builtin_type_m2_real =
-    init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-              0,
-              "REAL", (struct objfile *) NULL);
-  builtin_type_m2_char =
-    init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "CHAR", (struct objfile *) NULL);
-  builtin_type_m2_bool =
-    init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "BOOLEAN", (struct objfile *) NULL);
-
-  TYPE_NFIELDS(builtin_type_m2_bool) = 2;
-  TYPE_FIELDS(builtin_type_m2_bool) = 
-     (struct field *) malloc (sizeof (struct field) * 2);
-  TYPE_FIELD_BITPOS(builtin_type_m2_bool,0) = 0;
-  TYPE_FIELD_NAME(builtin_type_m2_bool,0) = (char *)malloc(6);
-  strcpy(TYPE_FIELD_NAME(builtin_type_m2_bool,0),"FALSE");
-  TYPE_FIELD_BITPOS(builtin_type_m2_bool,1) = 1;
-  TYPE_FIELD_NAME(builtin_type_m2_bool,1) = (char *)malloc(5);
-  strcpy(TYPE_FIELD_NAME(builtin_type_m2_bool,1),"TRUE");
-
-  add_language (&m2_language_defn);
+  error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);

 }
 }