* rs6000-tdep.c (push_arguments): Remove unused variable "pc".

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

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index fa8ebb90b99fd64ad0bf9ef5c414a0795e32160c..03691ef709459ef692843bc67b4bfdca17fccb64 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -1,5 +1,6 @@
 /* YACC parser for C expressions, for GDB.
 /* YACC parser for C 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.

 
 This file is part of GDB.
 
 
 This file is part of GDB.
 


@@ -15,7 +16,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 C expression from text in a string,
    and return the result as a  struct expression  pointer.
 
 /* Parse a C expression from text in a string,
    and return the result as a  struct expression  pointer.


@@ -24,27 +25,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 <ctype.h>

 #include "expression.h"
 #include "expression.h"

-#include "parser-defs.h"

 #include "value.h"
 #include "value.h"

+#include "parser-defs.h"

 #include "language.h"
 #include "language.h"

-#include "bfd.h"
-#include "symfile.h"
-#include "objfiles.h"
+#include "c-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 c_maxdepth
 #define        yyparse c_parse
 #define        yylex   c_lex
 #define        yymaxdepth c_maxdepth
 #define        yyparse c_parse
 #define        yylex   c_lex


@@ -72,22 +83,31 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        yy_yyv  c_yyv
 #define        yyval   c_val
 #define        yylloc  c_lloc
 #define        yy_yyv  c_yyv
 #define        yyval   c_val
 #define        yylloc  c_lloc

-#define yyss   c_yyss          /* byacc */
-#define        yyssp   c_yysp          /* byacc */
-#define        yyvs    c_yyvs          /* byacc */
-#define        yyvsp   c_yyvsp         /* byacc */
+#define yyreds c_reds          /* With YYDEBUG defined */
+#define yytoks c_toks          /* With YYDEBUG defined */
+#define yylhs  c_yylhs
+#define yylen  c_yylen
+#define yydefred c_yydefred
+#define yydgoto        c_yydgoto
+#define yysindex c_yysindex
+#define yyrindex c_yyrindex
+#define yygindex c_yygindex
+#define yytable         c_yytable
+#define yycheck         c_yycheck
+
+#ifndef YYDEBUG
+#define        YYDEBUG 0               /* Default to no yydebug support */
+#endif

 
 int
 yyparse PARAMS ((void));
 
 
 int
 yyparse PARAMS ((void));
 

-int
+static int

 yylex PARAMS ((void));
 
 void
 yyerror PARAMS ((char *));
 
 yylex PARAMS ((void));
 
 void
 yyerror PARAMS ((char *));
 

-/* #define     YYDEBUG 1 */
-

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


@@ -97,8 +117,14 @@ yyerror PARAMS ((char *));
 %union
   {
     LONGEST lval;
 %union
   {
     LONGEST lval;

-    unsigned LONGEST ulval;
-    double dval;
+    struct {
+      LONGEST val;
+      struct type *type;
+    } typed_val_int;
+    struct {
+      DOUBLEST dval;
+      struct type *type;
+    } typed_val_float;

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


@@ -119,7 +145,8 @@ static int
 parse_number PARAMS ((char *, int, int, YYSTYPE *));
 %}
 
 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 */
 %type <tval> type typebase
 %type <tvec> nonempty_typelist
 /* %type <bval> block */


@@ -129,9 +156,8 @@ parse_number PARAMS ((char *, int, int, YYSTYPE *));
 %type <tval> ptype
 %type <lval> array_mod
 
 %type <tval> ptype
 %type <lval> array_mod
 

-%token <lval> INT CHAR
-%token <ulval> UINT
-%token <dval> FLOAT
+%token <typed_val_int> INT
+%token <typed_val_float> FLOAT

 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.


@@ -151,9 +177,9 @@ parse_number PARAMS ((char *, int, int, YYSTYPE *));
 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
    but which would parse as a valid number in the current input radix.
    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
    but which would parse as a valid number in the current input radix.
    E.g. "c" when input_radix==16.  Depending on the parse, it will be

-   turned into a name or into a number.  NAME_OR_UINT ditto.  */
+   turned into a name or into a number.  */

 
 

-%token <ssym> NAME_OR_INT NAME_OR_UINT
+%token <ssym> NAME_OR_INT 

 
 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 %token TEMPLATE
 
 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 %token TEMPLATE


@@ -161,11 +187,9 @@ parse_number PARAMS ((char *, int, int, YYSTYPE *));
 
 /* Special type cases, put in to allow the parser to distinguish different
    legal basetypes.  */
 
 /* Special type cases, put in to allow the parser to distinguish different
    legal basetypes.  */

-%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
+%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD

 
 

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

 
 %token <opcode> ASSIGN_MODIFY
 
 
 %token <opcode> ASSIGN_MODIFY
 


@@ -193,18 +217,6 @@ parse_number PARAMS ((char *, int, int, YYSTYPE *));
 %type <bval> block
 %left COLONCOLON
 
 %type <bval> block
 %left COLONCOLON
 

-%{
-/* 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
 %%
 
 \f
 %%
 


@@ -236,11 +248,11 @@ exp       :       '-' exp    %prec UNARY
        ;
 
 exp    :       '!' exp    %prec UNARY
        ;
 
 exp    :       '!' exp    %prec UNARY

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

        ;
 
 exp    :       '~' exp    %prec UNARY
        ;
 
 exp    :       '~' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_LOGNOT); }
+                       { write_exp_elt_opcode (UNOP_COMPLEMENT); }

        ;
 
 exp    :       INCREMENT exp    %prec UNARY
        ;
 
 exp    :       INCREMENT exp    %prec UNARY


@@ -286,6 +298,15 @@ exp        :       exp '.' name
                          write_exp_elt_opcode (STRUCTOP_STRUCT); }
        ;
 
                          write_exp_elt_opcode (STRUCTOP_STRUCT); }
        ;
 

+/* start-sanitize-gm
+Need to find a better way to do this...
+exp    :       exp '@' name
+                       { write_exp_elt_opcode (STRUCTOP_FIELD);
+                         write_exp_string ($3);
+                         write_exp_elt_opcode (STRUCTOP_FIELD);
+                       }
+ end-sanitize-gm */
+

 exp    :       exp '.' qualified_name
                        { /* exp.type::name becomes exp.*(&type::name) */
                          /* Note: this doesn't work if name is a
 exp    :       exp '.' qualified_name
                        { /* exp.type::name becomes exp.*(&type::name) */
                          /* Note: this doesn't work if name is a


@@ -312,6 +333,10 @@ exp        :       exp '('
                          write_exp_elt_opcode (OP_FUNCALL); }
        ;
 
                          write_exp_elt_opcode (OP_FUNCALL); }
        ;
 

+lcurly :       '{'
+                       { start_arglist (); }
+       ;
+

 arglist        :
        ;
 
 arglist        :
        ;
 


@@ -323,7 +348,17 @@ arglist    :       arglist ',' exp   %prec ABOVE_COMMA
                        { arglist_len++; }
        ;
 
                        { 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); }
                        { write_exp_elt_opcode (UNOP_MEMVAL);
                          write_exp_elt_type ($2);
                          write_exp_elt_opcode (UNOP_MEMVAL); }


@@ -398,23 +433,23 @@ exp       :       exp '>' exp
        ;
 
 exp    :       exp '&' exp
        ;
 
 exp    :       exp '&' exp

-                       { write_exp_elt_opcode (BINOP_LOGAND); }
+                       { write_exp_elt_opcode (BINOP_BITWISE_AND); }

        ;
 
 exp    :       exp '^' exp
        ;
 
 exp    :       exp '^' exp

-                       { write_exp_elt_opcode (BINOP_LOGXOR); }
+                       { write_exp_elt_opcode (BINOP_BITWISE_XOR); }

        ;
 
 exp    :       exp '|' exp
        ;
 
 exp    :       exp '|' exp

-                       { write_exp_elt_opcode (BINOP_LOGIOR); }
+                       { write_exp_elt_opcode (BINOP_BITWISE_IOR); }

        ;
 
 exp    :       exp ANDAND exp
        ;
 
 exp    :       exp ANDAND exp

-                       { write_exp_elt_opcode (BINOP_AND); }
+                       { 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 '?' exp ':' exp     %prec '?'
        ;
 
 exp    :       exp '?' exp ':' exp     %prec '?'


@@ -433,11 +468,8 @@ exp        :       exp ASSIGN_MODIFY exp
 
 exp    :       INT
                        { write_exp_elt_opcode (OP_LONG);
 
 exp    :       INT
                        { write_exp_elt_opcode (OP_LONG);

-                         if ($1 == (int) $1 || $1 == (unsigned int) $1)
-                           write_exp_elt_type (builtin_type_int);
-                         else
-                           write_exp_elt_type (BUILTIN_TYPE_LONGEST);
-                         write_exp_elt_longcst ((LONGEST) $1);
+                         write_exp_elt_type ($1.type);
+                         write_exp_elt_longcst ((LONGEST)($1.val));

                          write_exp_elt_opcode (OP_LONG); }
        ;
 
                          write_exp_elt_opcode (OP_LONG); }
        ;
 


@@ -445,86 +477,57 @@ exp       :       NAME_OR_INT
                        { YYSTYPE val;
                          parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
                          write_exp_elt_opcode (OP_LONG);
                        { YYSTYPE val;
                          parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
                          write_exp_elt_opcode (OP_LONG);

-                         if (val.lval == (int) val.lval ||
-                             val.lval == (unsigned int) val.lval)
-                           write_exp_elt_type (builtin_type_int);
-                         else
-                           write_exp_elt_type (BUILTIN_TYPE_LONGEST);
-                         write_exp_elt_longcst (val.lval);
-                         write_exp_elt_opcode (OP_LONG); }
-       ;
-
-exp    :       UINT
-                       {
-                         write_exp_elt_opcode (OP_LONG);
-                         if ($1 == (unsigned int) $1)
-                           write_exp_elt_type (builtin_type_unsigned_int);
-                         else
-                           write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
-                         write_exp_elt_longcst ((LONGEST) $1);
-                         write_exp_elt_opcode (OP_LONG);
-                       }
-       ;
-
-exp    :       NAME_OR_UINT
-                       { YYSTYPE val;
-                         parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
-                         write_exp_elt_opcode (OP_LONG);
-                         if (val.ulval == (unsigned int) val.ulval)
-                           write_exp_elt_type (builtin_type_unsigned_int);
-                         else
-                           write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
-                         write_exp_elt_longcst ((LONGEST)val.ulval);
+                         write_exp_elt_type (val.typed_val_int.type);
+                         write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);

                          write_exp_elt_opcode (OP_LONG);
                        }
        ;
 
                          write_exp_elt_opcode (OP_LONG);
                        }
        ;
 

-exp    :       CHAR
-                       { write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (builtin_type_char);
-                         write_exp_elt_longcst ((LONGEST) $1);
-                         write_exp_elt_opcode (OP_LONG); }
-       ;

 
 exp    :       FLOAT
                        { write_exp_elt_opcode (OP_DOUBLE);
 
 exp    :       FLOAT
                        { write_exp_elt_opcode (OP_DOUBLE);

-                         write_exp_elt_type (builtin_type_double);
-                         write_exp_elt_dblcst ($1);
+                         write_exp_elt_type ($1.type);
+                         write_exp_elt_dblcst ($1.dval);

                          write_exp_elt_opcode (OP_DOUBLE); }
        ;
 
 exp    :       variable
        ;
 
                          write_exp_elt_opcode (OP_DOUBLE); }
        ;
 
 exp    :       variable
        ;
 

-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    :       VARIABLE
 exp    :       VARIABLE

-                       { write_exp_elt_opcode (OP_INTERNALVAR);
-                         write_exp_elt_intern ($1);
-                         write_exp_elt_opcode (OP_INTERNALVAR); }
+                       /* Already written by write_dollar_variable. */

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

+                         CHECK_TYPEDEF ($3);

                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
                          write_exp_elt_opcode (OP_LONG); }
        ;
 
 exp    :       STRING
                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
                          write_exp_elt_opcode (OP_LONG); }
        ;
 
 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++.  */
        ;
 
 /* C++.  */


@@ -544,8 +547,7 @@ block       :       BLOCKNAME
                              struct symtab *tem =
                                  lookup_symtab (copy_name ($1.stoken));
                              if (tem)
                              struct symtab *tem =
                                  lookup_symtab (copy_name ($1.stoken));
                              if (tem)

-                               $$ = BLOCKVECTOR_BLOCK
-                                        (BLOCKVECTOR (tem), STATIC_BLOCK);
+                               $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);

                              else
                                error ("No file or function \"%s\".",
                                       copy_name ($1.stoken));
                              else
                                error ("No file or function \"%s\".",
                                       copy_name ($1.stoken));


@@ -556,7 +558,8 @@ block       :       BLOCKNAME
 block  :       block COLONCOLON name
                        { struct symbol *tem
                            = lookup_symbol (copy_name ($3), $1,
 block  :       block COLONCOLON name
                        { struct symbol *tem
                            = lookup_symbol (copy_name ($3), $1,

-                                            VAR_NAMESPACE, 0, NULL);
+                                            VAR_NAMESPACE, (int *) NULL,
+                                            (struct symtab **) 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));


@@ -566,12 +569,15 @@ block     :       block COLONCOLON name
 variable:      block COLONCOLON name
                        { struct symbol *sym;
                          sym = lookup_symbol (copy_name ($3), $1,
 variable:      block COLONCOLON name
                        { struct symbol *sym;
                          sym = lookup_symbol (copy_name ($3), $1,

-                                              VAR_NAMESPACE, 0, NULL);
+                                              VAR_NAMESPACE, (int *) NULL,
+                                              (struct symtab **) 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); }
        ;


@@ -598,7 +604,7 @@ qualified_name:     typebase COLONCOLON name
                            error ("`%s' is not defined as an aggregate type.",
                                   TYPE_NAME (type));
 
                            error ("`%s' is not defined as an aggregate type.",
                                   TYPE_NAME (type));
 

-                         if (strcmp (type_name_no_tag (type), $4.ptr))
+                         if (!STREQ (type_name_no_tag (type), $4.ptr))

                            error ("invalid destructor `%s::~%s'",
                                   type_name_no_tag (type), $4.ptr);
 
                            error ("invalid destructor `%s::~%s'",
                                   type_name_no_tag (type), $4.ptr);
 


@@ -622,32 +628,24 @@ variable: qualified_name
                          struct minimal_symbol *msymbol;
 
                          sym =
                          struct minimal_symbol *msymbol;
 
                          sym =

-                           lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
+                           lookup_symbol (name, (const struct block *) NULL,
+                                          VAR_NAMESPACE, (int *) NULL,
+                                          (struct symtab **) NULL);

                          if (sym)
                            {
                              write_exp_elt_opcode (OP_VAR_VALUE);
                          if (sym)
                            {
                              write_exp_elt_opcode (OP_VAR_VALUE);

+                             write_exp_elt_block (NULL);

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

-                         msymbol = lookup_minimal_symbol (name,
-                                     (struct objfile *) NULL);
+                         msymbol = lookup_minimal_symbol (name, 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 ())
                            }
                          else
                            if (!have_full_symbols () && !have_partial_symbols ())


@@ -662,38 +660,19 @@ variable: name_not_typename
 
                          if (sym)
                            {
 
                          if (sym)
                            {

-                             switch (SYMBOL_CLASS (sym))
+                             if (symbol_read_needs_frame (sym))

                                {
                                {

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

                                  if (innermost_block == 0 ||
                                      contained_in (block_found, 
                                                    innermost_block))
                                    innermost_block = block_found;
                                  if (innermost_block == 0 ||
                                      contained_in (block_found, 
                                                    innermost_block))
                                    innermost_block = block_found;

-                               case LOC_UNDEF:
-                               case LOC_CONST:
-                               case LOC_STATIC:
-                               case LOC_TYPEDEF:
-                               case LOC_LABEL:
-                               case LOC_BLOCK:
-                               case LOC_CONST_BYTES:
-
-                                 /* In this case the expression can
-                                    be evaluated regardless of what
-                                    frame we are in, so there is no
-                                    need to check for the
-                                    innermost_block.  These cases are
-                                    listed so that gcc -Wall will
-                                    report types that may not have
-                                    been considered.  */
-
-                                 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);
                            }


@@ -716,23 +695,13 @@ variable: name_not_typename
                              struct minimal_symbol *msymbol;
                              register char *arg = copy_name ($1.stoken);
 
                              struct minimal_symbol *msymbol;
                              register char *arg = copy_name ($1.stoken);
 

-                             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 \"file\" command.");
                                }
                              else if (!have_full_symbols () && !have_partial_symbols ())
                                error ("No symbol table is loaded.  Use the \"file\" command.");


@@ -745,39 +714,19 @@ variable: name_not_typename
 
 
 ptype  :       typebase
 
 
 ptype  :       typebase

+       /* "const" and "volatile" are curently ignored.  A type qualifier
+          before the type is currently handled in the typebase rule.
+          The reason for recognizing these here (shift/reduce conflicts)
+          might be obsolete now that some pointer to member rules have
+          been deleted.  */
+       |       typebase CONST_KEYWORD
+       |       typebase VOLATILE_KEYWORD

        |       typebase abs_decl
        |       typebase abs_decl

-               {
-                 /* This is where the interesting stuff happens.  */
-                 int done = 0;
-                 int array_size;
-                 struct type *follow_type = $1;
-                 
-                 while (!done)
-                   switch (pop_type ())
-                     {
-                     case tp_end:
-                       done = 1;
-                       break;
-                     case tp_pointer:
-                       follow_type = lookup_pointer_type (follow_type);
-                       break;
-                     case tp_reference:
-                       follow_type = lookup_reference_type (follow_type);
-                       break;
-                     case tp_array:
-                       array_size = pop_type_int ();
-                       if (array_size != -1)
-                         follow_type = create_array_type (follow_type,
-                                                          array_size);
-                       else
-                         follow_type = lookup_pointer_type (follow_type);
-                       break;
-                     case tp_function:
-                       follow_type = lookup_function_type (follow_type);
-                       break;
-                     }
-                 $$ = follow_type;
-               }
+               { $$ = follow_types ($1); }
+       |       typebase CONST_KEYWORD abs_decl
+               { $$ = follow_types ($1); }
+       |       typebase VOLATILE_KEYWORD abs_decl
+               { $$ = follow_types ($1); }

        ;
 
 abs_decl:      '*'
        ;
 
 abs_decl:      '*'


@@ -804,6 +753,7 @@ direct_abs_decl: '(' abs_decl ')'
                          push_type (tp_array);
                          $$ = 0;
                        }
                          push_type (tp_array);
                          $$ = 0;
                        }

+

        |       direct_abs_decl func_mod
                        { push_type (tp_function); }
        |       func_mod
        |       direct_abs_decl func_mod
                        { push_type (tp_function); }
        |       func_mod


@@ -813,7 +763,7 @@ direct_abs_decl: '(' abs_decl ')'
 array_mod:     '[' ']'
                        { $$ = -1; }
        |       '[' INT ']'
 array_mod:     '[' ']'
                        { $$ = -1; }
        |       '[' INT ']'

-                       { $$ = $2; }
+                       { $$ = $2.val; }

        ;
 
 func_mod:      '(' ')'
        ;
 
 func_mod:      '(' ')'


@@ -822,24 +772,20 @@ func_mod: '(' ')'
                        { free ((PTR)$2); $$ = 0; }
        ;
 
                        { free ((PTR)$2); $$ = 0; }
        ;
 

+/* We used to try to recognize more pointer to member types here, but
+   that didn't work (shift/reduce conflicts meant that these rules never
+   got executed).  The problem is that
+     int (foo::bar::baz::bizzle)
+   is a function type but
+     int (foo::bar::baz::bizzle::*)
+   is a pointer to member type.  Stroustrup loses again!  */
+

 type   :       ptype
        |       typebase COLONCOLON '*'
                        { $$ = lookup_member_type (builtin_type_int, $1); }
 type   :       ptype
        |       typebase COLONCOLON '*'
                        { $$ = lookup_member_type (builtin_type_int, $1); }

-       |       type '(' typebase COLONCOLON '*' ')'
-                       { $$ = lookup_member_type ($1, $3); }
-       |       type '(' typebase COLONCOLON '*' ')' '(' ')'
-                       { $$ = lookup_member_type
-                           (lookup_function_type ($1), $3); }
-       |       type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
-                       { $$ = lookup_member_type
-                           (lookup_function_type ($1), $3);
-                         free ((PTR)$8); }
-       /* "const" and "volatile" are curently ignored. */
-       |       CONST_KEYWORD type { $$ = $2; }
-       |       VOLATILE_KEYWORD type { $$ = $2; }
-       ;
-
-typebase
+       ;
+
+typebase  /* Implements (approximately): (type-qualifier)* type-specifier */

        :       TYPENAME
                        { $$ = $1.type; }
        |       INT_KEYWORD
        :       TYPENAME
                        { $$ = $1.type; }
        |       INT_KEYWORD


@@ -864,6 +810,10 @@ typebase
                        { $$ = builtin_type_short; }
        |       UNSIGNED SHORT INT_KEYWORD
                        { $$ = builtin_type_unsigned_short; }
                        { $$ = builtin_type_short; }
        |       UNSIGNED SHORT INT_KEYWORD
                        { $$ = builtin_type_unsigned_short; }

+       |       DOUBLE_KEYWORD
+                       { $$ = builtin_type_double; }
+       |       LONG DOUBLE_KEYWORD
+                       { $$ = builtin_type_long_double; }

        |       STRUCT name
                        { $$ = lookup_struct (copy_name ($2),
                                              expression_context_block); }
        |       STRUCT name
                        { $$ = lookup_struct (copy_name ($2),
                                              expression_context_block); }


@@ -888,6 +838,11 @@ typebase
                        { $$ = lookup_template_type(copy_name($2), $4,
                                                    expression_context_block);
                        }
                        { $$ = lookup_template_type(copy_name($2), $4,
                                                    expression_context_block);
                        }

+       /* "const" and "volatile" are curently ignored.  A type qualifier
+          after the type is handled in the ptype rule.  I think these could
+          be too.  */
+       |       CONST_KEYWORD typebase { $$ = $2; }
+       |       VOLATILE_KEYWORD typebase { $$ = $2; }

        ;
 
 typename:      TYPENAME
        ;
 
 typename:      TYPENAME


@@ -913,13 +868,13 @@ typename: TYPENAME
 
 nonempty_typelist
        :       type
 
 nonempty_typelist
        :       type

-               { $$ = (struct type **) xmalloc (sizeof (struct type *) * 2);
+               { $$ = (struct type **) malloc (sizeof (struct type *) * 2);

                  $<ivec>$[0] = 1;      /* Number of types in vector */
                  $$[1] = $1;
                }
        |       nonempty_typelist ',' type
                { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
                  $<ivec>$[0] = 1;      /* Number of types in vector */
                  $$[1] = $1;
                }
        |       nonempty_typelist ',' type
                { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);

-                 $$ = (struct type **) xrealloc ((char *) $1, len);
+                 $$ = (struct type **) realloc ((char *) $1, len);

                  $$[$<ivec>$[0]] = $3;
                }
        ;
                  $$[$<ivec>$[0]] = $3;
                }
        ;


@@ -928,7 +883,6 @@ name        :       NAME { $$ = $1.stoken; }
        |       BLOCKNAME { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }
        |       BLOCKNAME { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }

-       |       NAME_OR_UINT  { $$ = $1.stoken; }

        ;
 
 name_not_typename :    NAME
        ;
 
 name_not_typename :    NAME


@@ -939,7 +893,6 @@ name_not_typename : NAME
    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT
    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT

-       |       NAME_OR_UINT

  */
        ;
 
  */
        ;
 


@@ -958,17 +911,64 @@ parse_number (p, len, parsed_float, putithere)
      int parsed_float;
      YYSTYPE *putithere;
 {
      int parsed_float;
      YYSTYPE *putithere;
 {

+  /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
+     here, and we do kind of silly things like cast to unsigned.  */

   register LONGEST n = 0;
   register LONGEST prevn = 0;
   register LONGEST n = 0;
   register LONGEST prevn = 0;

-  register int i;
+  unsigned LONGEST un;
+
+  register int i = 0;

   register int c;
   register int base = input_radix;
   int unsigned_p = 0;
 
   register int c;
   register int base = input_radix;
   int unsigned_p = 0;
 

+  /* Number of "L" suffixes encountered.  */
+  int long_p = 0;
+
+  /* We have found a "L" or "U" suffix.  */
+  int found_suffix = 0;
+
+  unsigned LONGEST high_bit;
+  struct type *signed_type;
+  struct type *unsigned_type;
+

   if (parsed_float)
     {
   if (parsed_float)
     {

+      char c;
+

       /* It's a float since it contains a point or an exponent.  */
       /* It's a float since it contains a point or an exponent.  */

-      putithere->dval = atof (p);
+
+      if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
+       sscanf (p, "%g", &putithere->typed_val_float.dval);
+      else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
+       sscanf (p, "%lg", &putithere->typed_val_float.dval);
+      else
+       {
+#ifdef PRINTF_HAS_LONG_DOUBLE
+         sscanf (p, "%Lg", &putithere->typed_val_float.dval);
+#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;
+         sscanf (p, "%lg", &temp);
+         putithere->typed_val_float.dval = temp;
+#endif
+       }
+
+      /* 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;
     }
 
       return FLOAT;
     }
 


@@ -1011,43 +1011,115 @@ parse_number (p, len, parsed_float, putithere)
       if (c != 'l' && c != 'u')
        n *= base;
       if (c >= '0' && c <= '9')
       if (c != 'l' && c != 'u')
        n *= base;
       if (c >= '0' && c <= '9')

-       n += i = c - '0';
+       {
+         if (found_suffix)
+           return ERROR;
+         n += i = c - '0';
+       }

       else
        {
          if (base > 10 && c >= 'a' && c <= 'f')
       else
        {
          if (base > 10 && c >= 'a' && c <= 'f')

-           n += i = c - 'a' + 10;
-         else if (len == 0 && c == 'l')
-           ;
-         else if (len == 0 && c == 'u')
-           unsigned_p = 1;
+           {
+             if (found_suffix)
+               return ERROR;
+             n += i = c - 'a' + 10;
+           }
+         else if (c == 'l')
+           {
+             ++long_p;
+             found_suffix = 1;
+           }
+         else if (c == 'u')
+           {
+             unsigned_p = 1;
+             found_suffix = 1;
+           }

          else
            return ERROR;       /* Char not a digit */
        }
       if (i >= base)
        return ERROR;           /* Invalid digit in this base */
          else
            return ERROR;       /* Char not a digit */
        }
       if (i >= base)
        return ERROR;           /* Invalid digit in this base */

+

       /* Portably test for overflow (only works for nonzero values, so make
       /* Portably test for overflow (only works for nonzero values, so make

-        a second check for zero).  */
-      if((prevn >= n) && n != 0)
-        unsigned_p=1;          /* Try something unsigned */
-      /* If range checking enabled, portably test for unsigned overflow.  */
-      if(RANGE_CHECK && n!=0)
-      {        
-        if((unsigned_p && (unsigned)prevn >= (unsigned)n))
-           range_error("Overflow on numeric constant.");        
-      }
-      prevn=n;
+        a second check for zero).  FIXME: Can't we just make n and prevn
+        unsigned and avoid this?  */
+      if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
+       unsigned_p = 1;         /* Try something unsigned */
+
+      /* Portably test for unsigned overflow.
+        FIXME: This check is wrong; for example it doesn't find overflow
+        on 0x123456789 when LONGEST is 32 bits.  */
+      if (c != 'l' && c != 'u' && n != 0)
+       {       
+         if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
+           error ("Numeric constant too large.");
+       }
+      prevn = n;

     }
 
     }
 

-  if (unsigned_p)
+  /* An integer constant is an int, a long, or a long long.  An L
+     suffix forces it to be long; an LL suffix forces it to be long
+     long.  If not forced to a larger size, it gets the first type of
+     the above that it fits in.  To figure out whether it fits, we
+     shift it right and see whether anything remains.  Note that we
+     can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
+     operation, because many compilers will warn about such a shift
+     (which always produces a zero result).  Sometimes TARGET_INT_BIT
+     or TARGET_LONG_BIT will be that big, sometimes not.  To deal with
+     the case where it is we just always shift the value more than
+     once, with fewer bits each time.  */
+
+  un = (unsigned LONGEST)n >> 2;
+  if (long_p == 0
+      && (un >> (TARGET_INT_BIT - 2)) == 0)
+    {
+      high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
+
+      /* A large decimal (not hex or octal) constant (between INT_MAX
+        and UINT_MAX) is a long or unsigned long, according to ANSI,
+        never an unsigned int, but this code treats it as unsigned
+        int.  This probably should be fixed.  GCC gives a warning on
+        such constants.  */
+
+      unsigned_type = builtin_type_unsigned_int;
+      signed_type = builtin_type_int;
+    }
+  else if (long_p <= 1
+          && (un >> (TARGET_LONG_BIT - 2)) == 0)

     {
     {

-      putithere->ulval = n;
-      return UINT;
+      high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
+      unsigned_type = builtin_type_unsigned_long;
+      signed_type = builtin_type_long;

     }
   else
     {
     }
   else
     {

-      putithere->lval = n;
-      return INT;
+      high_bit = (((unsigned LONGEST)1)
+                 << (TARGET_LONG_LONG_BIT - 32 - 1)
+                 << 16
+                 << 16);
+      if (high_bit == 0)
+       /* A long long does not fit in a LONGEST.  */
+       high_bit =
+         (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
+      unsigned_type = builtin_type_unsigned_long_long;
+      signed_type = builtin_type_long_long;

     }
     }

+
+   putithere->typed_val_int.val = n;
+
+   /* If the high bit of the worked out type is set then this number
+      has to be unsigned. */
+
+   if (unsigned_p || (n & high_bit)) 
+     {
+       putithere->typed_val_int.type = unsigned_type;
+     }
+   else 
+     {
+       putithere->typed_val_int.type = signed_type;
+     }
+
+   return INT;

 }
 
 struct token
 }
 
 struct token


@@ -1057,22 +1129,22 @@ struct token
   enum exp_opcode opcode;
 };
 
   enum exp_opcode opcode;
 };
 

-const static struct token tokentab3[] =
+static const struct token tokentab3[] =

   {
     {">>=", ASSIGN_MODIFY, BINOP_RSH},
     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
   };
 
   {
     {">>=", ASSIGN_MODIFY, BINOP_RSH},
     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
   };
 

-const static struct token tokentab2[] =
+static const struct token tokentab2[] =

   {
     {"+=", ASSIGN_MODIFY, BINOP_ADD},
     {"-=", ASSIGN_MODIFY, BINOP_SUB},
     {"*=", ASSIGN_MODIFY, BINOP_MUL},
     {"/=", ASSIGN_MODIFY, BINOP_DIV},
     {"%=", ASSIGN_MODIFY, BINOP_REM},
   {
     {"+=", ASSIGN_MODIFY, BINOP_ADD},
     {"-=", ASSIGN_MODIFY, BINOP_SUB},
     {"*=", ASSIGN_MODIFY, BINOP_MUL},
     {"/=", ASSIGN_MODIFY, BINOP_DIV},
     {"%=", ASSIGN_MODIFY, BINOP_REM},

-    {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
-    {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
-    {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
+    {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
+    {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
+    {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},

     {"++", INCREMENT, BINOP_END},
     {"--", DECREMENT, BINOP_END},
     {"->", ARROW, BINOP_END},
     {"++", INCREMENT, BINOP_END},
     {"--", DECREMENT, BINOP_END},
     {"->", ARROW, BINOP_END},


@@ -1089,20 +1161,24 @@ const static struct token tokentab2[] =
 
 /* Read one token, getting characters through lexptr.  */
 
 
 /* Read one token, getting characters through lexptr.  */
 

-int
+static int

 yylex ()
 {
 yylex ()
 {

-  register int c;
-  register int namelen;
-  register unsigned i;
-  register char *tokstart;
-
+  int c;
+  int namelen;
+  unsigned int i;
+  char *tokstart;
+  char *tokptr;
+  int tempbufindex;
+  static char *tempbuf;
+  static int tempbufsize;
+  

  retry:
 
   tokstart = lexptr;
   /* See if it is a special token of length 3.  */
   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
  retry:
 
   tokstart = lexptr;
   /* See if it is a special token of length 3.  */
   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)

-    if (!strncmp (tokstart, tokentab3[i].operator, 3))
+    if (STREQN (tokstart, tokentab3[i].operator, 3))

       {
        lexptr += 3;
        yylval.opcode = tokentab3[i].opcode;
       {
        lexptr += 3;
        yylval.opcode = tokentab3[i].opcode;


@@ -1111,7 +1187,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 (tokstart, tokentab2[i].operator, 2))
+    if (STREQN (tokstart, tokentab2[i].operator, 2))

       {
        lexptr += 2;
        yylval.opcode = tokentab2[i].opcode;
       {
        lexptr += 2;
        yylval.opcode = tokentab2[i].opcode;


@@ -1137,7 +1213,12 @@ yylex ()
       c = *lexptr++;
       if (c == '\\')
        c = parse_escape (&lexptr);
       c = *lexptr++;
       if (c == '\\')
        c = parse_escape (&lexptr);

-      yylval.lval = c;
+      else if (c == '\'')
+       error ("Empty character constant.");
+
+      yylval.typed_val_int.val = c;
+      yylval.typed_val_int.type = builtin_type_char;
+

       c = *lexptr++;
       if (c != '\'')
        {
       c = *lexptr++;
       if (c != '\'')
        {


@@ -1145,13 +1226,15 @@ yylex ()
          if (namelen > 2)
            {
              lexptr = tokstart + namelen;
          if (namelen > 2)
            {
              lexptr = tokstart + namelen;

+             if (lexptr[-1] != '\'')
+               error ("Unmatched single quote.");

              namelen -= 2;
              tokstart++;
              goto tryname;
            }
          error ("Invalid character constant.");
        }
              namelen -= 2;
              tokstart++;
              goto tryname;
            }
          error ("Invalid character constant.");
        }

-      return CHAR;
+      return INT;

 
     case '(':
       paren_depth++;
 
     case '(':
       paren_depth++;


@@ -1206,9 +1289,14 @@ yylex ()
 
        for (;; ++p)
          {
 
        for (;; ++p)
          {

+           /* This test includes !hex because 'e' is a valid hex digit
+              and thus does not indicate a floating point number when
+              the radix is hex.  */

            if (!hex && !got_e && (*p == 'e' || *p == 'E'))
              got_dot = got_e = 1;
            if (!hex && !got_e && (*p == 'e' || *p == 'E'))
              got_dot = got_e = 1;

-           else if (!hex && !got_dot && *p == '.')
+           /* This test does not include !hex, because a '.' always indicates
+              a decimal floating point number regardless of the radix.  */
+           else if (!got_dot && *p == '.')

              got_dot = 1;
            else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
                     && (*p == '-' || *p == '+'))
              got_dot = 1;
            else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
                     && (*p == '-' || *p == '+'))


@@ -1260,21 +1348,55 @@ yylex ()
       return c;
 
     case '"':
       return c;
 
     case '"':

-      for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
-       if (c == '\\')
+
+      /* Build the gdb internal form of the input string in tempbuf,
+        translating any standard C escape forms seen.  Note that the
+        buffer is null byte terminated *only* for the convenience of
+        debugging gdb itself and printing the buffer contents when
+        the buffer contains no embedded nulls.  Gdb does not depend
+        upon the buffer being null byte terminated, it uses the length
+        string instead.  This allows gdb to handle C strings (as well
+        as strings in other languages) with embedded null bytes */
+
+      tokptr = ++tokstart;
+      tempbufindex = 0;
+
+      do {
+       /* Grow the static temp buffer if necessary, including allocating
+          the first one on demand. */
+       if (tempbufindex + 1 >= tempbufsize)
+         {
+           tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
+         }
+       switch (*tokptr)

          {
          {

-           c = tokstart[++namelen];
-           if (c >= '0' && c <= '9')
+         case '\0':
+         case '"':
+           /* Do nothing, loop will terminate. */
+           break;
+         case '\\':
+           tokptr++;
+           c = parse_escape (&tokptr);
+           if (c == -1)

              {
              {

-               c = tokstart[++namelen];
-               if (c >= '0' && c <= '9')
-                 c = tokstart[++namelen];
+               continue;

              }
              }

+           tempbuf[tempbufindex++] = c;
+           break;
+         default:
+           tempbuf[tempbufindex++] = *tokptr++;
+           break;

          }
          }

-      yylval.sval.ptr = tokstart + 1;
-      yylval.sval.length = namelen - 1;
-      lexptr += namelen + 1;
-      return STRING;
+      } while ((*tokptr != '"') && (*tokptr != '\0'));
+      if (*tokptr++ != '"')
+       {
+         error ("Unterminated string in expression.");
+       }
+      tempbuf[tempbufindex] = '\0';    /* See note above */
+      yylval.sval.ptr = tempbuf;
+      yylval.sval.length = tempbufindex;
+      lexptr = tokptr;
+      return (STRING);

     }
 
   if (!(c == '_' || c == '$'
     }
 
   if (!(c == '_' || c == '$'


@@ -1286,9 +1408,17 @@ yylex ()
   namelen = 0;
   for (c = tokstart[namelen];
        (c == '_' || c == '$' || (c >= '0' && c <= '9')
   namelen = 0;
   for (c = tokstart[namelen];
        (c == '_' || c == '$' || (c >= '0' && c <= '9')

-       || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
-       c = tokstart[++namelen])
-    ;
+       || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
+    {
+       if (c == '<')
+        {
+          int i = namelen;
+          while (tokstart[++i] && tokstart[i] != '>');
+          if (tokstart[i] == '>')
+            namelen = i;
+         }
+       c = tokstart[++namelen];
+     }

 
   /* The token "if" terminates the expression and is NOT 
      removed from the input stream.  */
 
   /* The token "if" terminates the expression and is NOT 
      removed from the input stream.  */


@@ -1299,109 +1429,60 @@ 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.  */
-

   tryname:
   tryname:

-  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;
-       }
-  }

   /* Catch specific keywords.  Should be done with a data structure.  */
   switch (namelen)
     {
     case 8:
   /* Catch specific keywords.  Should be done with a data structure.  */
   switch (namelen)
     {
     case 8:

-      if (!strncmp (tokstart, "unsigned", 8))
+      if (STREQN (tokstart, "unsigned", 8))

        return UNSIGNED;
       if (current_language->la_language == language_cplus
        return UNSIGNED;
       if (current_language->la_language == language_cplus

-         && !strncmp (tokstart, "template", 8))
+         && STREQN (tokstart, "template", 8))

        return TEMPLATE;
        return TEMPLATE;

-      if (!strncmp (tokstart, "volatile", 8))
+      if (STREQN (tokstart, "volatile", 8))

        return VOLATILE_KEYWORD;
       break;
     case 6:
        return VOLATILE_KEYWORD;
       break;
     case 6:

-      if (!strncmp (tokstart, "struct", 6))
+      if (STREQN (tokstart, "struct", 6))

        return STRUCT;
        return STRUCT;

-      if (!strncmp (tokstart, "signed", 6))
+      if (STREQN (tokstart, "signed", 6))

        return SIGNED_KEYWORD;
        return SIGNED_KEYWORD;

-      if (!strncmp (tokstart, "sizeof", 6))      
+      if (STREQN (tokstart, "sizeof", 6))      

        return SIZEOF;
        return SIZEOF;

+      if (STREQN (tokstart, "double", 6))      
+       return DOUBLE_KEYWORD;

       break;
     case 5:
       if (current_language->la_language == language_cplus
       break;
     case 5:
       if (current_language->la_language == language_cplus

-         && !strncmp (tokstart, "class", 5))
+         && STREQN (tokstart, "class", 5))

        return CLASS;
        return CLASS;

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

        return UNION;
        return UNION;

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

        return SHORT;
        return SHORT;

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

        return CONST_KEYWORD;
       break;
     case 4:
        return CONST_KEYWORD;
       break;
     case 4:

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

        return ENUM;
        return ENUM;

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

        return LONG;
       if (current_language->la_language == language_cplus
        return LONG;
       if (current_language->la_language == language_cplus

-         && !strncmp (tokstart, "this", 4))
+         && STREQN (tokstart, "this", 4))

        {
          static const char this_name[] =
                                 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
 
          if (lookup_symbol (this_name, expression_context_block,
        {
          static const char this_name[] =
                                 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
 
          if (lookup_symbol (this_name, expression_context_block,

-                            VAR_NAMESPACE, 0, NULL))
+                            VAR_NAMESPACE, (int *) NULL,
+                            (struct symtab **) NULL))

            return THIS;
        }
       break;
     case 3:
            return THIS;
        }
       break;
     case 3:

-      if (!strncmp (tokstart, "int", 3))
+      if (STREQN (tokstart, "int", 3))

        return INT_KEYWORD;
       break;
     default:
        return INT_KEYWORD;
       break;
     default:


@@ -1411,11 +1492,9 @@ yylex ()
   yylval.sval.ptr = tokstart;
   yylval.sval.length = namelen;
 
   yylval.sval.ptr = tokstart;
   yylval.sval.length = namelen;
 

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

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

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

       return VARIABLE;
     }
 
       return VARIABLE;
     }
 


@@ -1433,10 +1512,13 @@ yylex ()
     sym = lookup_symbol (tmp, expression_context_block,
                         VAR_NAMESPACE,
                         current_language->la_language == language_cplus
     sym = lookup_symbol (tmp, expression_context_block,
                         VAR_NAMESPACE,
                         current_language->la_language == language_cplus

-                        ? &is_a_field_of_this : NULL,
-                        NULL);
+                        ? &is_a_field_of_this : (int *) NULL,
+                        (struct symtab **) NULL);
+    /* Call lookup_symtab, not lookup_partial_symtab, in case there are
+       no psymtabs (coff, xcoff, or some future change to blow away the
+       psymtabs once once symbols are read).  */

     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||

-        lookup_partial_symtab (tmp))
+        lookup_symtab (tmp))

       {
        yylval.ssym.sym = sym;
        yylval.ssym.is_a_field_of_this = is_a_field_of_this;
       {
        yylval.ssym.sym = sym;
        yylval.ssym.is_a_field_of_this = is_a_field_of_this;


@@ -1444,7 +1526,92 @@ yylex ()
       }
     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
         {
       }
     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
         {

+#if 1
+         /* Despite the following flaw, we need to keep this code enabled.
+            Because we can get called from check_stub_method, if we don't
+            handle nested types then it screws many operations in any
+            program which uses nested types.  */
+         /* In "A::x", if x is a member function of A and there happens
+            to be a type (nested or not, since the stabs don't make that
+            distinction) named x, then this code incorrectly thinks we
+            are dealing with nested types rather than a member function.  */
+
+         char *p;
+         char *namestart;
+         struct symbol *best_sym;
+
+         /* Look ahead to detect nested types.  This probably should be
+            done in the grammar, but trying seemed to introduce a lot
+            of shift/reduce and reduce/reduce conflicts.  It's possible
+            that it could be done, though.  Or perhaps a non-grammar, but
+            less ad hoc, approach would work well.  */
+
+         /* Since we do not currently have any way of distinguishing
+            a nested type from a non-nested one (the stabs don't tell
+            us whether a type is nested), we just ignore the
+            containing type.  */
+
+         p = lexptr;
+         best_sym = sym;
+         while (1)
+           {
+             /* Skip whitespace.  */
+             while (*p == ' ' || *p == '\t' || *p == '\n')
+               ++p;
+             if (*p == ':' && p[1] == ':')
+               {
+                 /* Skip the `::'.  */
+                 p += 2;
+                 /* Skip whitespace.  */
+                 while (*p == ' ' || *p == '\t' || *p == '\n')
+                   ++p;
+                 namestart = p;
+                 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
+                        || (*p >= 'a' && *p <= 'z')
+                        || (*p >= 'A' && *p <= 'Z'))
+                   ++p;
+                 if (p != namestart)
+                   {
+                     struct symbol *cur_sym;
+                     /* As big as the whole rest of the expression, which is
+                        at least big enough.  */
+                     char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
+                     char *tmp1;
+
+                     tmp1 = ncopy;
+                     memcpy (tmp1, tmp, strlen (tmp));
+                     tmp1 += strlen (tmp);
+                     memcpy (tmp1, "::", 2);
+                     tmp1 += 2;
+                     memcpy (tmp1, namestart, p - namestart);
+                     tmp1[p - namestart] = '\0';
+                     cur_sym = lookup_symbol (ncopy, expression_context_block,
+                                              VAR_NAMESPACE, (int *) NULL,
+                                              (struct symtab **) NULL);
+                     if (cur_sym)
+                       {
+                         if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
+                           {
+                             best_sym = cur_sym;
+                             lexptr = p;
+                           }
+                         else
+                           break;
+                       }
+                     else
+                       break;
+                   }
+                 else
+                   break;
+               }
+             else
+               break;
+           }
+
+         yylval.tsym.type = SYMBOL_TYPE (best_sym);
+#else /* not 0 */

          yylval.tsym.type = SYMBOL_TYPE (sym);
          yylval.tsym.type = SYMBOL_TYPE (sym);

+#endif /* not 0 */

          return TYPENAME;
         }
     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
          return TYPENAME;
         }
     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)


@@ -1465,12 +1632,6 @@ yylex ()
            yylval.ssym.is_a_field_of_this = is_a_field_of_this;
            return NAME_OR_INT;
          }
            yylval.ssym.is_a_field_of_this = is_a_field_of_this;
            return NAME_OR_INT;
          }

-       if (hextype == UINT)
-         {
-           yylval.ssym.sym = sym;
-           yylval.ssym.is_a_field_of_this = is_a_field_of_this;
-           return NAME_OR_UINT;
-         }

       }
 
     /* Any other kind of symbol */
       }
 
     /* Any other kind of symbol */


@@ -1484,196 +1645,5 @@ void
 yyerror (msg)
      char *msg;
 {
 yyerror (msg)
      char *msg;
 {

-  error (msg ? msg : "Invalid syntax in expression.");
-}
-\f
-/* Table mapping opcodes into strings for printing operators
-   and precedences of the operators.  */
-
-const static struct op_print c_op_print_tab[] =
-  {
-    {",",  BINOP_COMMA, PREC_COMMA, 0},
-    {"=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
-    {"||", BINOP_OR, PREC_OR, 0},
-    {"&&", BINOP_AND, PREC_AND, 0},
-    {"|",  BINOP_LOGIOR, PREC_LOGIOR, 0},
-    {"&",  BINOP_LOGAND, PREC_LOGAND, 0},
-    {"^",  BINOP_LOGXOR, PREC_LOGXOR, 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},
-    {">>", BINOP_RSH, PREC_SHIFT, 0},
-    {"<<", BINOP_LSH, PREC_SHIFT, 0},
-    {"+",  BINOP_ADD, PREC_ADD, 0},
-    {"-",  BINOP_SUB, PREC_ADD, 0},
-    {"*",  BINOP_MUL, PREC_MUL, 0},
-    {"/",  BINOP_DIV, PREC_MUL, 0},
-    {"%",  BINOP_REM, PREC_MUL, 0},
-    {"@",  BINOP_REPEAT, PREC_REPEAT, 0},
-    {"-",  UNOP_NEG, PREC_PREFIX, 0},
-    {"!",  UNOP_ZEROP, PREC_PREFIX, 0},
-    {"~",  UNOP_LOGNOT, PREC_PREFIX, 0},
-    {"*",  UNOP_IND, PREC_PREFIX, 0},
-    {"&",  UNOP_ADDR, PREC_PREFIX, 0},
-    {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
-    {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
-    {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
-    /* C++  */
-    {"::", BINOP_SCOPE, PREC_PREFIX, 0},
-};
-\f
-/* These variables point to the objects
-   representing the predefined C data types.  */
-
-struct type *builtin_type_void;
-struct type *builtin_type_char;
-struct type *builtin_type_short;
-struct type *builtin_type_int;
-struct type *builtin_type_long;
-struct type *builtin_type_long_long;
-struct type *builtin_type_signed_char;
-struct type *builtin_type_unsigned_char;
-struct type *builtin_type_unsigned_short;
-struct type *builtin_type_unsigned_int;
-struct type *builtin_type_unsigned_long;
-struct type *builtin_type_unsigned_long_long;
-struct type *builtin_type_float;
-struct type *builtin_type_double;
-struct type *builtin_type_long_double;
-struct type *builtin_type_complex;
-struct type *builtin_type_double_complex;
-
-struct type ** const (c_builtin_types[]) = 
-{
-  &builtin_type_int,
-  &builtin_type_long,
-  &builtin_type_short,
-  &builtin_type_char,
-  &builtin_type_float,
-  &builtin_type_double,
-  &builtin_type_void,
-  &builtin_type_long_long,
-  &builtin_type_signed_char,
-  &builtin_type_unsigned_char,
-  &builtin_type_unsigned_short,
-  &builtin_type_unsigned_int,
-  &builtin_type_unsigned_long,
-  &builtin_type_unsigned_long_long,
-  &builtin_type_long_double,
-  &builtin_type_complex,
-  &builtin_type_double_complex,
-  0
-};
-
-const struct language_defn c_language_defn = {
-  "c",                         /* Language name */
-  language_c,
-  c_builtin_types,
-  range_check_off,
-  type_check_off,
-  c_parse,
-  c_error,
-  &BUILTIN_TYPE_LONGEST,        /* longest signed   integral type */
-  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
-  &builtin_type_double,                /* longest floating point type */ /*FIXME*/
-  "0x%x", "0x%", "x",          /* Hex   format, prefix, suffix */
-  "0%o",  "0%",  "o",          /* Octal format, prefix, suffix */
-  c_op_print_tab,              /* expression operators for printing */
-  LANG_MAGIC
-};
-
-const struct language_defn cplus_language_defn = {
-  "c++",                               /* Language name */
-  language_cplus,
-  c_builtin_types,
-  range_check_off,
-  type_check_off,
-  c_parse,
-  c_error,
-  &BUILTIN_TYPE_LONGEST,        /* longest signed   integral type */
-  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
-  &builtin_type_double,                /* longest floating point type */ /*FIXME*/
-  "0x%x", "0x%", "x",          /* Hex   format, prefix, suffix */
-  "0%o",  "0%",  "o",          /* Octal format, prefix, suffix */
-  c_op_print_tab,              /* expression operators for printing */
-  LANG_MAGIC
-};
-
-void
-_initialize_c_exp ()
-{
-  builtin_type_void =
-    init_type (TYPE_CODE_VOID, 1,
-              0,
-              "void", (struct objfile *) NULL);
-  builtin_type_char =
-    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-              0,
-              "char", (struct objfile *) NULL);
-  builtin_type_signed_char =
-    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_SIGNED,
-              "signed char", (struct objfile *) NULL);
-  builtin_type_unsigned_char =
-    init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "unsigned char", (struct objfile *) NULL);
-  builtin_type_short =
-    init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
-              0,
-              "short", (struct objfile *) NULL);
-  builtin_type_unsigned_short =
-    init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "unsigned short", (struct objfile *) NULL);
-  builtin_type_int =
-    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-              0,
-              "int", (struct objfile *) NULL);
-  builtin_type_unsigned_int =
-    init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "unsigned int", (struct objfile *) NULL);
-  builtin_type_long =
-    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
-              0,
-              "long", (struct objfile *) NULL);
-  builtin_type_unsigned_long =
-    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "unsigned long", (struct objfile *) NULL);
-  builtin_type_long_long =
-    init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
-              0,
-              "long long", (struct objfile *) NULL);
-  builtin_type_unsigned_long_long = 
-    init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
-              TYPE_FLAG_UNSIGNED,
-              "unsigned long long", (struct objfile *) NULL);
-  builtin_type_float =
-    init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-              0,
-              "float", (struct objfile *) NULL);
-  builtin_type_double =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-              0,
-              "double", (struct objfile *) NULL);
-  builtin_type_long_double =
-    init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
-              0,
-              "long double", (struct objfile *) NULL);
-  builtin_type_complex =
-    init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
-              0,
-              "complex", (struct objfile *) NULL);
-  builtin_type_double_complex =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
-              0,
-              "double complex", (struct objfile *) NULL);
-
-  add_language (&c_language_defn);
-  add_language (&cplus_language_defn);
+  error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);

 }
 }