* c-exp.y (type): Remove incorrect pointer to member case.

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

diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index a6f96a3407838d2ad5929e814893d99af9db1600..10dd92a215b7da08c55576eb9c4ccb5184b1fd77 100644 (file)
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -1,5 +1,7 @@
 /* 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, 1992, 1993, 1994, 1995, 1996, 1999,
+   2000
+   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 +19,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
 
 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., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, 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.


@@ -26,26 +29,37 @@ 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 "gdb_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 */
+#include "block.h"
+
+/* 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 +75,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,40 +87,47 @@ 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 */
-
-#if 0
-static char *
-make_qualname PARAMS ((char *, char *));
+#define        yyreds  m2_reds         /* With YYDEBUG defined */
+#define        yytoks  m2_toks         /* With YYDEBUG defined */
+#define yyname m2_name         /* With YYDEBUG defined */
+#define yyrule m2_rule         /* 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 1               /* Default to yydebug support */

 #endif
 
 #endif
 

-static int
-parse_number PARAMS ((int));
+#define YYFPRINTF parser_fprintf

 
 

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

 
 

-static void
-yyerror PARAMS ((char *));
+static int yylex (void);

 
 

-int
-yyparse PARAMS ((void));
+void yyerror (char *);
+
+#if 0
+static char *make_qualname (char *, char *);
+#endif
+
+static int parse_number (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;
-
-/* #define     YYDEBUG 1 */
+#if 0
+static struct block *modblock=0;
+#endif

 
 

-/* !@&%ing AIX defines these!  Prevent cpp complaints by undeffing them */
-#undef TRUE
-#undef FALSE

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


@@ -116,8 +137,8 @@ struct block *modblock=0;
 %union
   {
     LONGEST lval;
 %union
   {
     LONGEST lval;

-    unsigned LONGEST ulval;
-    double dval;
+    ULONGEST ulval;
+    DOUBLEST dval;

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


@@ -137,7 +158,7 @@ struct block *modblock=0;
 %type <sym> fblock 
 
 %token <lval> INT HEX ERROR
 %type <sym> fblock 
 
 %token <lval> INT HEX ERROR

-%token <ulval> UINT TRUE FALSE CHAR
+%token <ulval> UINT M2_TRUE M2_FALSE CHAR

 %token <dval> FLOAT
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
 %token <dval> FLOAT
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,


@@ -159,9 +180,7 @@ 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 ','


@@ -169,7 +188,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


@@ -180,19 +199,9 @@ struct block *modblock=0;
 /* This is not an actual token ; it is used for precedence. 
 %right QID
 */
 /* This is not an actual token ; it is used for precedence. 
 %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
        |       type_exp
 
 start   :      exp
        |       type_exp


@@ -209,6 +218,7 @@ type_exp:   type
 
 exp     :       exp '^'   %prec UNARY
                         { write_exp_elt_opcode (UNOP_IND); }
 
 exp     :       exp '^'   %prec UNARY
                         { write_exp_elt_opcode (UNOP_IND); }

+       ;

 
 exp    :       '-'
                        { number_sign = -1; }
 
 exp    :       '-'
                        { number_sign = -1; }


@@ -222,7 +232,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


@@ -323,6 +333,7 @@ exp :       INCL '(' exp ',' exp ')'
 
 exp    :       EXCL '(' exp ',' exp ')'
                        { error("Sets are not implemented.");}
 
 exp    :       EXCL '(' exp ',' exp ')'
                        { error("Sets are not implemented.");}

+       ;

 
 set    :       '{' arglist '}'
                        { error("Sets are not implemented.");}
 
 set    :       '{' arglist '}'
                        { error("Sets are not implemented.");}


@@ -338,9 +349,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 '('


@@ -449,16 +460,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


@@ -468,13 +475,13 @@ exp       :       exp ASSIGN exp
 
 /* Constants */
 
 
 /* Constants */
 

-exp    :       TRUE
+exp    :       M2_TRUE

                        { write_exp_elt_opcode (OP_BOOL);
                          write_exp_elt_longcst ((LONGEST) $1);
                          write_exp_elt_opcode (OP_BOOL); }
        ;
 
                        { write_exp_elt_opcode (OP_BOOL);
                          write_exp_elt_longcst ((LONGEST) $1);
                          write_exp_elt_opcode (OP_BOOL); }
        ;
 

-exp    :       FALSE
+exp    :       M2_FALSE

                        { write_exp_elt_opcode (OP_BOOL);
                          write_exp_elt_longcst ((LONGEST) $1);
                          write_exp_elt_opcode (OP_BOOL); }
                        { write_exp_elt_opcode (OP_BOOL);
                          write_exp_elt_longcst ((LONGEST) $1);
                          write_exp_elt_opcode (OP_BOOL); }


@@ -514,19 +521,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);


@@ -548,7 +542,7 @@ block       :       fblock
 fblock :       BLOCKNAME
                        { struct symbol *sym
                            = lookup_symbol (copy_name ($1), expression_context_block,
 fblock :       BLOCKNAME
                        { struct symbol *sym
                            = lookup_symbol (copy_name ($1), expression_context_block,

-                                            VAR_NAMESPACE, 0, NULL);
+                                            VAR_DOMAIN, 0, NULL);

                          $$ = sym;}
        ;
                             
                          $$ = sym;}
        ;
                             


@@ -557,7 +551,7 @@ fblock      :       BLOCKNAME
 fblock :       block COLONCOLON BLOCKNAME
                        { struct symbol *tem
                            = lookup_symbol (copy_name ($3), $1,
 fblock :       block COLONCOLON BLOCKNAME
                        { struct symbol *tem
                            = lookup_symbol (copy_name ($3), $1,

-                                            VAR_NAMESPACE, 0, NULL);
+                                            VAR_DOMAIN, 0, NULL);

                          if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
                            error ("No function \"%s\" in specified context.",
                                   copy_name ($3));
                          if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
                            error ("No function \"%s\" in specified context.",
                                   copy_name ($3));


@@ -568,27 +562,27 @@ 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 */
 variable:      block COLONCOLON NAME
                        { struct symbol *sym;
                          sym = lookup_symbol (copy_name ($3), $1,
        ;
 
 /* GDB scope operator */
 variable:      block COLONCOLON NAME
                        { struct symbol *sym;
                          sym = lookup_symbol (copy_name ($3), $1,

-                                              VAR_NAMESPACE, 0, NULL);
+                                              VAR_DOMAIN, 0, NULL);

                          if (sym == 0)
                            error ("No symbol \"%s\" in specified context.",
                                   copy_name ($3));
 
                          write_exp_elt_opcode (OP_VAR_VALUE);
                          if (sym == 0)
                            error ("No symbol \"%s\" in specified context.",
                                   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); }
        ;


@@ -600,62 +594,40 @@ variable: NAME
 
                          sym = lookup_symbol (copy_name ($1),
                                               expression_context_block,
 
                          sym = lookup_symbol (copy_name ($1),
                                               expression_context_block,

-                                              VAR_NAMESPACE,
+                                              VAR_DOMAIN,

                                               &is_a_field_of_this,
                                               NULL);
                          if (sym)
                            {
                                               &is_a_field_of_this,
                                               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);
                            }
                          else
                            {
                              struct minimal_symbol *msymbol;
                              write_exp_elt_sym (sym);
                              write_exp_elt_opcode (OP_VAR_VALUE);
                            }
                          else
                            {
                              struct minimal_symbol *msymbol;

-                             register char *arg = copy_name ($1);
+                             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) 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.");


@@ -701,12 +673,12 @@ static int
 parse_number (olen)
      int olen;
 {
 parse_number (olen)
      int olen;
 {

-  register char *p = lexptr;
-  register LONGEST n = 0;
-  register LONGEST prevn = 0;
-  register int c,i,ischar=0;
-  register int base = input_radix;
-  register int len = olen;
+  char *p = lexptr;
+  LONGEST n = 0;
+  LONGEST prevn = 0;
+  int c,i,ischar=0;
+  int base = input_radix;
+  int len = olen;

   int unsigned_p = number_sign == 1 ? 1 : 0;
 
   if(p[len-1] == 'H')
   int unsigned_p = number_sign == 1 ? 1 : 0;
 
   if(p[len-1] == 'H')


@@ -818,7 +790,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       },


@@ -849,20 +821,22 @@ static struct keyword keytab[] =
 static int
 yylex ()
 {
 static int
 yylex ()
 {

-  register int c;
-  register int namelen;
-  register int i;
-  register char *tokstart;
-  register char quote;
+  int c;
+  int namelen;
+  int i;
+  char *tokstart;
+  char quote;

 
  retry:
 
 
  retry:
 

+  prev_lexptr = lexptr;
+

   tokstart = lexptr;
 
 
   /* See if it is a special token of length 2 */
   tokstart = lexptr;
 
 
   /* 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))
+  for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
+     if(DEPRECATED_STREQN(tokentab2[i].name, tokstart, 2))

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


@@ -963,7 +937,7 @@ yylex ()
     {
       /* It's a number.  */
       int got_dot = 0, got_e = 0;
     {
       /* It's a number.  */
       int got_dot = 0, got_e = 0;

-      register char *p = tokstart;
+      char *p = tokstart;

       int toktype;
 
       for (++p ;; ++p)
       int toktype;
 
       for (++p ;; ++p)


@@ -987,7 +961,7 @@ yylex ()
          {
            char *err_copy = (char *) alloca (p - tokstart + 1);
 
          {
            char *err_copy = (char *) alloca (p - tokstart + 1);
 

-           (void) memcpy (err_copy, tokstart, p - tokstart);
+           memcpy (err_copy, tokstart, p - tokstart);

            err_copy[p - tokstart] = 0;
            error ("Invalid number \"%s\".", err_copy);
          }
            err_copy[p - tokstart] = 0;
            error ("Invalid number \"%s\".", err_copy);
          }


@@ -1017,78 +991,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])
-         && !strncmp (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)
-        && !strncmp (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++)
-     if(namelen == strlen(keytab[i].keyw) && !strncmp(tokstart,keytab[i].keyw,namelen))
+  for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
+     if(namelen == strlen(keytab[i].keyw) && DEPRECATED_STREQN(tokstart,keytab[i].keyw,namelen))

           return keytab[i].token;
 
   yylval.sval.ptr = tokstart;
   yylval.sval.length = 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,7 +1019,7 @@ yylex ()
     if (lookup_partial_symtab (tmp))
       return BLOCKNAME;
     sym = lookup_symbol (tmp, expression_context_block,
     if (lookup_partial_symtab (tmp))
       return BLOCKNAME;
     sym = lookup_symbol (tmp, expression_context_block,

-                        VAR_NAMESPACE, 0, NULL);
+                        VAR_DOMAIN, 0, NULL);

     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
       return BLOCKNAME;
     if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
       return BLOCKNAME;
     if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))


@@ -1111,17 +1027,23 @@ 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:
+       case LOC_COMPUTED:
+       case LOC_COMPUTED_ARG:

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


@@ -1134,21 +1056,26 @@ 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()");

+
+       default:
+         error ("unhandled token in m2lex()");
+         break;

        }
     }
     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(DEPRECATED_STREQN(tokstart,"TRUE",4))

        {
          yylval.ulval = 1;
        {
          yylval.ulval = 1;

-         return TRUE;
+         return M2_TRUE;

        }
        }

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

        {
          yylval.ulval = 0;
        {
          yylval.ulval = 0;

-         return FALSE;
+         return M2_FALSE;

        }
     }
 
        }
     }
 


@@ -1162,7 +1089,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,".");


@@ -1171,113 +1098,12 @@ 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);
+  if (prev_lexptr)
+    lexptr = prev_lexptr;
+
+  error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);

 }
 }