Fix gdb build with --enable-build-with-cxx --disable-nls

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

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 56400cee93fde31e3641c18bc58340e8d4c2e214..9f2a229fafcb379ec42bbbdfc2d00188fd69dd56 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -1,5 +1,5 @@
 /* YACC parser for C expressions, for GDB.
 /* YACC parser for C expressions, for GDB.

-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2016 Free Software Foundation, Inc.

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


@@ -32,7 +32,7 @@
    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.  */
    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 "defs.h"
 %{
 
 #include "defs.h"


@@ -164,7 +164,7 @@ static int type_aggregate_p (struct type *);
 
     struct type_stack *type_stack;
 
 
     struct type_stack *type_stack;
 

-    struct objc_class_str class;
+    struct objc_class_str theclass;

   }
 
 %{
   }
 
 %{


@@ -215,11 +215,11 @@ static void c_print_token (FILE *file, int type, YYSTYPE value);
 %token <ssym> UNKNOWN_CPP_NAME
 %token <voidval> COMPLETE
 %token <tsym> TYPENAME
 %token <ssym> UNKNOWN_CPP_NAME
 %token <voidval> COMPLETE
 %token <tsym> TYPENAME

-%token <class> CLASSNAME       /* ObjC Class name */
+%token <theclass> CLASSNAME    /* ObjC Class name */

 %type <sval> name
 %type <svec> string_exp
 %type <ssym> name_not_typename
 %type <sval> name
 %type <svec> string_exp
 %type <ssym> name_not_typename

-%type <tsym> typename
+%type <tsym> type_name

 
  /* This is like a '[' token, but is only generated when parsing
     Objective C.  This lets us reuse the same parser without
 
  /* This is like a '[' token, but is only generated when parsing
     Objective C.  This lets us reuse the same parser without


@@ -231,14 +231,14 @@ static void c_print_token (FILE *file, int type, YYSTYPE value);
    E.g. "c" when input_radix==16.  Depending on the parse, it will be
    turned into a name or into a number.  */
 
    E.g. "c" when input_radix==16.  Depending on the parse, it will be
    turned into a name or into a number.  */
 

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

 
 %token OPERATOR
 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 %token TEMPLATE
 %token ERROR
 %token NEW DELETE
 
 %token OPERATOR
 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 %token TEMPLATE
 %token ERROR
 %token NEW DELETE

-%type <sval> operator
+%type <sval> oper

 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 %token ENTRY
 %token TYPEOF
 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 %token ENTRY
 %token TYPEOF


@@ -275,7 +275,7 @@ static void c_print_token (FILE *file, int type, YYSTYPE value);
 %left '*' '/' '%'
 %right UNARY INCREMENT DECREMENT
 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
 %left '*' '/' '%'
 %right UNARY INCREMENT DECREMENT
 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('

-%token <ssym> BLOCKNAME 
+%token <ssym> BLOCKNAME

 %token <bval> FILENAME
 %type <bval> block
 %left COLONCOLON
 %token <bval> FILENAME
 %type <bval> block
 %left COLONCOLON


@@ -479,17 +479,17 @@ exp       :       exp OBJC_LBRAC exp1 ']'
 
 exp    :       OBJC_LBRAC TYPENAME
                        {
 
 exp    :       OBJC_LBRAC TYPENAME
                        {

-                         CORE_ADDR class;
+                         CORE_ADDR theclass;

 
 

-                         class = lookup_objc_class (parse_gdbarch (pstate),
+                         theclass = lookup_objc_class (parse_gdbarch (pstate),

                                                     copy_name ($2.stoken));
                                                     copy_name ($2.stoken));

-                         if (class == 0)
+                         if (theclass == 0)

                            error (_("%s is not an ObjC Class"),
                                   copy_name ($2.stoken));
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate,
                                            parse_type (pstate)->builtin_int);
                            error (_("%s is not an ObjC Class"),
                                   copy_name ($2.stoken));
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate,
                                            parse_type (pstate)->builtin_int);

-                         write_exp_elt_longcst (pstate, (LONGEST) class);
+                         write_exp_elt_longcst (pstate, (LONGEST) theclass);

                          write_exp_elt_opcode (pstate, OP_LONG);
                          start_msglist();
                        }
                          write_exp_elt_opcode (pstate, OP_LONG);
                          start_msglist();
                        }


@@ -505,7 +505,7 @@ exp :       OBJC_LBRAC CLASSNAME
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate,
                                            parse_type (pstate)->builtin_int);
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate,
                                            parse_type (pstate)->builtin_int);

-                         write_exp_elt_longcst (pstate, (LONGEST) $2.class);
+                         write_exp_elt_longcst (pstate, (LONGEST) $2.theclass);

                          write_exp_elt_opcode (pstate, OP_LONG);
                          start_msglist();
                        }
                          write_exp_elt_opcode (pstate, OP_LONG);
                          start_msglist();
                        }


@@ -542,7 +542,7 @@ msgarg      :       name ':' exp
                        { add_msglist(0, 0);   }
        ;
 
                        { add_msglist(0, 0);   }
        ;
 

-exp    :       exp '(' 
+exp    :       exp '('

                        /* This is to save the value of arglist_len
                           being accumulated by an outer function call.  */
                        { start_arglist (); }
                        /* This is to save the value of arglist_len
                           being accumulated by an outer function call.  */
                        { start_arglist (); }


@@ -715,7 +715,7 @@ exp :       exp OROR exp
 exp    :       exp '?' exp ':' exp     %prec '?'
                        { write_exp_elt_opcode (pstate, TERNOP_COND); }
        ;
 exp    :       exp '?' exp ':' exp     %prec '?'
                        { write_exp_elt_opcode (pstate, TERNOP_COND); }
        ;

-                         
+

 exp    :       exp '=' exp
                        { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
        ;
 exp    :       exp '=' exp
                        { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
        ;


@@ -793,7 +793,7 @@ exp :       SIZEOF '(' type ')'     %prec UNARY
                                              (parse_language (pstate),
                                               parse_gdbarch (pstate),
                                               "int"));
                                              (parse_language (pstate),
                                               parse_gdbarch (pstate),
                                               "int"));

-                         CHECK_TYPEDEF (type);
+                         type = check_typedef (type);

 
                            /* $5.3.3/2 of the C++ Standard (n3290 draft)
                               says of sizeof:  "When applied to a reference
 
                            /* $5.3.3/2 of the C++ Standard (n3290 draft)
                               says of sizeof:  "When applied to a reference


@@ -839,7 +839,7 @@ string_exp:
 
                          vec->type = $1.type;
                          vec->length = $1.length;
 
                          vec->type = $1.type;
                          vec->length = $1.length;

-                         vec->ptr = malloc ($1.length + 1);
+                         vec->ptr = (char *) malloc ($1.length + 1);

                          memcpy (vec->ptr, $1.ptr, $1.length + 1);
                        }
 
                          memcpy (vec->ptr, $1.ptr, $1.length + 1);
                        }
 


@@ -849,10 +849,10 @@ string_exp:
                             for convenience.  */
                          char *p;
                          ++$$.len;
                             for convenience.  */
                          char *p;
                          ++$$.len;

-                         $$.tokens = realloc ($$.tokens,
-                                              $$.len * sizeof (struct typed_stoken));
+                         $$.tokens = XRESIZEVEC (struct typed_stoken,
+                                                 $$.tokens, $$.len);

 
 

-                         p = malloc ($2.length + 1);
+                         p = (char *) malloc ($2.length + 1);

                          memcpy (p, $2.ptr, $2.length + 1);
 
                          $$.tokens[$$.len - 1].type = $2.type;
                          memcpy (p, $2.ptr, $2.length + 1);
 
                          $$.tokens[$$.len - 1].type = $2.type;


@@ -864,7 +864,7 @@ string_exp:
 exp    :       string_exp
                        {
                          int i;
 exp    :       string_exp
                        {
                          int i;

-                         enum c_string_type type = C_STRING;
+                         c_string_type type = C_STRING;

 
                          for (i = 0; i < $1.len; ++i)
                            {
 
                          for (i = 0; i < $1.len; ++i)
                            {


@@ -878,7 +878,7 @@ exp :       string_exp
                                  if (type != C_STRING
                                      && type != $1.tokens[i].type)
                                    error (_("Undefined string concatenation."));
                                  if (type != C_STRING
                                      && type != $1.tokens[i].type)
                                    error (_("Undefined string concatenation."));

-                                 type = $1.tokens[i].type;
+                                 type = (enum c_string_type_values) $1.tokens[i].type;

                                  break;
                                default:
                                  /* internal error */
                                  break;
                                default:
                                  /* internal error */


@@ -903,7 +903,7 @@ exp     :   NSSTRING        /* ObjC NextStep NSString constant
        ;
 
 /* C++.  */
        ;
 
 /* C++.  */

-exp     :       TRUEKEYWORD    
+exp     :       TRUEKEYWORD

                         { write_exp_elt_opcode (pstate, OP_LONG);
                           write_exp_elt_type (pstate,
                                          parse_type (pstate)->builtin_bool);
                         { write_exp_elt_opcode (pstate, OP_LONG);
                           write_exp_elt_type (pstate,
                                          parse_type (pstate)->builtin_bool);


@@ -911,7 +911,7 @@ exp     :       TRUEKEYWORD
                           write_exp_elt_opcode (pstate, OP_LONG); }
        ;
 
                           write_exp_elt_opcode (pstate, OP_LONG); }
        ;
 

-exp     :       FALSEKEYWORD   
+exp     :       FALSEKEYWORD

                         { write_exp_elt_opcode (pstate, OP_LONG);
                           write_exp_elt_type (pstate,
                                          parse_type (pstate)->builtin_bool);
                         { write_exp_elt_opcode (pstate, OP_LONG);
                           write_exp_elt_type (pstate,
                                          parse_type (pstate)->builtin_bool);


@@ -923,8 +923,8 @@ exp     :       FALSEKEYWORD
 
 block  :       BLOCKNAME
                        {
 
 block  :       BLOCKNAME
                        {

-                         if ($1.sym)
-                           $$ = SYMBOL_BLOCK_VALUE ($1.sym);
+                         if ($1.sym.symbol)
+                           $$ = SYMBOL_BLOCK_VALUE ($1.sym.symbol);

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


@@ -938,7 +938,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_DOMAIN, NULL);
+                                            VAR_DOMAIN, NULL).symbol;
+

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


@@ -946,7 +947,7 @@ block       :       block COLONCOLON name
        ;
 
 variable:      name_not_typename ENTRY
        ;
 
 variable:      name_not_typename ENTRY

-                       { struct symbol *sym = $1.sym;
+                       { struct symbol *sym = $1.sym.symbol;

 
                          if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
                              || !symbol_read_needs_frame (sym))
 
                          if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
                              || !symbol_read_needs_frame (sym))


@@ -961,31 +962,31 @@ variable: name_not_typename ENTRY
        ;
 
 variable:      block COLONCOLON name
        ;
 
 variable:      block COLONCOLON name

-                       { struct symbol *sym;
-                         sym = lookup_symbol (copy_name ($3), $1,
-                                              VAR_DOMAIN, NULL);
-                         if (sym == 0)
+                       { struct block_symbol sym
+                           = lookup_symbol (copy_name ($3), $1,
+                                            VAR_DOMAIN, NULL);
+
+                         if (sym.symbol == 0)

                            error (_("No symbol \"%s\" in specified context."),
                                   copy_name ($3));
                            error (_("No symbol \"%s\" in specified context."),
                                   copy_name ($3));

-                         if (symbol_read_needs_frame (sym))
+                         if (symbol_read_needs_frame (sym.symbol))

                            {
                              if (innermost_block == 0
                            {
                              if (innermost_block == 0

-                                 || contained_in (block_found,
+                                 || contained_in (sym.block,

                                                   innermost_block))
                                                   innermost_block))

-                               innermost_block = block_found;
+                               innermost_block = sym.block;

                            }
 
                          write_exp_elt_opcode (pstate, OP_VAR_VALUE);
                            }
 
                          write_exp_elt_opcode (pstate, OP_VAR_VALUE);

-                         /* block_found is set by lookup_symbol.  */
-                         write_exp_elt_block (pstate, block_found);
-                         write_exp_elt_sym (pstate, sym);
+                         write_exp_elt_block (pstate, sym.block);
+                         write_exp_elt_sym (pstate, sym.symbol);

                          write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
        ;
 
 qualified_name:        TYPENAME COLONCOLON name
                        {
                          struct type *type = $1.type;
                          write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
        ;
 
 qualified_name:        TYPENAME COLONCOLON name
                        {
                          struct type *type = $1.type;

-                         CHECK_TYPEDEF (type);
+                         type = check_typedef (type);

                          if (!type_aggregate_p (type))
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));
                          if (!type_aggregate_p (type))
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));


@@ -1001,11 +1002,11 @@ qualified_name: TYPENAME COLONCOLON name
                          struct stoken tmp_token;
                          char *buf;
 
                          struct stoken tmp_token;
                          char *buf;
 

-                         CHECK_TYPEDEF (type);
+                         type = check_typedef (type);

                          if (!type_aggregate_p (type))
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));
                          if (!type_aggregate_p (type))
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));

-                         buf = alloca ($4.length + 2);
+                         buf = (char *) alloca ($4.length + 2);

                          tmp_token.ptr = buf;
                          tmp_token.length = $4.length + 1;
                          buf[0] = '~';
                          tmp_token.ptr = buf;
                          tmp_token.length = $4.length + 1;
                          buf[0] = '~';


@@ -1035,9 +1036,9 @@ variable: qualified_name
                          struct symbol *sym;
                          struct bound_minimal_symbol msymbol;
 
                          struct symbol *sym;
                          struct bound_minimal_symbol msymbol;
 

-                         sym =
-                           lookup_symbol (name, (const struct block *) NULL,
-                                          VAR_DOMAIN, NULL);
+                         sym
+                           = lookup_symbol (name, (const struct block *) NULL,
+                                            VAR_DOMAIN, NULL).symbol;

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


@@ -1058,24 +1059,21 @@ variable:       qualified_name
        ;
 
 variable:      name_not_typename
        ;
 
 variable:      name_not_typename

-                       { struct symbol *sym = $1.sym;
+                       { struct block_symbol sym = $1.sym;

 
 

-                         if (sym)
+                         if (sym.symbol)

                            {
                            {

-                             if (symbol_read_needs_frame (sym))
+                             if (symbol_read_needs_frame (sym.symbol))

                                {
                                  if (innermost_block == 0
                                {
                                  if (innermost_block == 0

-                                     || contained_in (block_found, 
+                                     || contained_in (sym.block,

                                                       innermost_block))
                                                       innermost_block))

-                                   innermost_block = block_found;
+                                   innermost_block = sym.block;

                                }
 
                              write_exp_elt_opcode (pstate, OP_VAR_VALUE);
                                }
 
                              write_exp_elt_opcode (pstate, 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 (pstate, NULL);
-                             write_exp_elt_sym (pstate, sym);
+                             write_exp_elt_block (pstate, sym.block);
+                             write_exp_elt_sym (pstate, sym.symbol);

                              write_exp_elt_opcode (pstate, OP_VAR_VALUE);
                            }
                          else if ($1.is_a_field_of_this)
                              write_exp_elt_opcode (pstate, OP_VAR_VALUE);
                            }
                          else if ($1.is_a_field_of_this)


@@ -1084,9 +1082,9 @@ variable: name_not_typename
                                 not inadvertently convert from a method call
                                 to data ref.  */
                              if (innermost_block == 0
                                 not inadvertently convert from a method call
                                 to data ref.  */
                              if (innermost_block == 0

-                                 || contained_in (block_found,
+                                 || contained_in (sym.block,

                                                   innermost_block))
                                                   innermost_block))

-                               innermost_block = block_found;
+                               innermost_block = sym.block;

                              write_exp_elt_opcode (pstate, OP_THIS);
                              write_exp_elt_opcode (pstate, OP_THIS);
                              write_exp_elt_opcode (pstate, STRUCTOP_PTR);
                              write_exp_elt_opcode (pstate, OP_THIS);
                              write_exp_elt_opcode (pstate, OP_THIS);
                              write_exp_elt_opcode (pstate, STRUCTOP_PTR);


@@ -1123,10 +1121,10 @@ cv_with_space_id : const_or_volatile space_identifier const_or_volatile
        ;
 
 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
        ;
 
 const_or_volatile_or_space_identifier_noopt: cv_with_space_id

-       | const_or_volatile_noopt 
+       | const_or_volatile_noopt

        ;
 
        ;
 

-const_or_volatile_or_space_identifier: 
+const_or_volatile_or_space_identifier:

                const_or_volatile_or_space_identifier_noopt
        |
        ;
                const_or_volatile_or_space_identifier_noopt
        |
        ;


@@ -1135,7 +1133,7 @@ ptr_operator:
                ptr_operator '*'
                        { insert_type (tp_pointer); }
                const_or_volatile_or_space_identifier
                ptr_operator '*'
                        { insert_type (tp_pointer); }
                const_or_volatile_or_space_identifier

-       |       '*' 
+       |       '*'

                        { insert_type (tp_pointer); }
                const_or_volatile_or_space_identifier
        |       '&'
                        { insert_type (tp_pointer); }
                const_or_volatile_or_space_identifier
        |       '&'


@@ -1155,7 +1153,7 @@ ptr_operator_ts: ptr_operator
 
 abs_decl:      ptr_operator_ts direct_abs_decl
                        { $$ = append_type_stack ($2, $1); }
 
 abs_decl:      ptr_operator_ts direct_abs_decl
                        { $$ = append_type_stack ($2, $1); }

-       |       ptr_operator_ts 
+       |       ptr_operator_ts

        |       direct_abs_decl
        ;
 
        |       direct_abs_decl
        ;
 


@@ -1314,7 +1312,7 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "short"); }
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "short"); }

-       |       SHORT UNSIGNED 
+       |       SHORT UNSIGNED

                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "short"); }
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "short"); }


@@ -1353,12 +1351,12 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
                                              expression_context_block); }
        |       CLASS COMPLETE
                        {
                                              expression_context_block); }
        |       CLASS COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_CLASS, "", 0);
+                         mark_completion_tag (TYPE_CODE_STRUCT, "", 0);

                          $$ = NULL;
                        }
        |       CLASS name COMPLETE
                        {
                          $$ = NULL;
                        }
        |       CLASS name COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_CLASS, $2.ptr,
+                         mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,

                                               $2.length);
                          $$ = NULL;
                        }
                                               $2.length);
                          $$ = NULL;
                        }


@@ -1390,7 +1388,7 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
                                               $2.length);
                          $$ = NULL;
                        }
                                               $2.length);
                          $$ = NULL;
                        }

-       |       UNSIGNED typename
+       |       UNSIGNED type_name

                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         TYPE_NAME($2.type)); }
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         TYPE_NAME($2.type)); }


@@ -1398,7 +1396,7 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "int"); }
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
                                                         parse_gdbarch (pstate),
                                                         "int"); }

-       |       SIGNED_KEYWORD typename
+       |       SIGNED_KEYWORD type_name

                        { $$ = lookup_signed_typename (parse_language (pstate),
                                                       parse_gdbarch (pstate),
                                                       TYPE_NAME($2.type)); }
                        { $$ = lookup_signed_typename (parse_language (pstate),
                                                       parse_gdbarch (pstate),
                                                       TYPE_NAME($2.type)); }


@@ -1408,18 +1406,18 @@ typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
                                                       "int"); }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead
                                                       "int"); }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead

-                   in the token processing code in yylex. */         
+                   in the token processing code in yylex. */

        |       TEMPLATE name '<' type '>'
                        { $$ = lookup_template_type(copy_name($2), $4,
                                                    expression_context_block);
                        }
        |       TEMPLATE name '<' type '>'
                        { $$ = lookup_template_type(copy_name($2), $4,
                                                    expression_context_block);
                        }

-       | const_or_volatile_or_space_identifier_noopt typebase 
+       | const_or_volatile_or_space_identifier_noopt typebase

                        { $$ = follow_types ($2); }
                        { $$ = follow_types ($2); }

-       | typebase const_or_volatile_or_space_identifier_noopt 
+       | typebase const_or_volatile_or_space_identifier_noopt

                        { $$ = follow_types ($1); }
        ;
 
                        { $$ = follow_types ($1); }
        ;
 

-typename:      TYPENAME
+type_name:     TYPENAME

        |       INT_KEYWORD
                {
                  $$.stoken.ptr = "int";
        |       INT_KEYWORD
                {
                  $$.stoken.ptr = "int";


@@ -1491,9 +1489,9 @@ const_and_volatile:       CONST_KEYWORD VOLATILE_KEYWORD
        |               VOLATILE_KEYWORD CONST_KEYWORD
        ;
 
        |               VOLATILE_KEYWORD CONST_KEYWORD
        ;
 

-const_or_volatile_noopt:       const_and_volatile 
+const_or_volatile_noopt:       const_and_volatile

                        { insert_type (tp_const);
                        { insert_type (tp_const);

-                         insert_type (tp_volatile); 
+                         insert_type (tp_volatile);

                        }
        |               CONST_KEYWORD
                        { insert_type (tp_const); }
                        }
        |               CONST_KEYWORD
                        { insert_type (tp_const); }


@@ -1501,7 +1499,7 @@ const_or_volatile_noopt:          const_and_volatile
                        { insert_type (tp_volatile); }
        ;
 
                        { insert_type (tp_volatile); }
        ;
 

-operator:      OPERATOR NEW
+oper:  OPERATOR NEW

                        { $$ = operator_stoken (" new"); }
        |       OPERATOR DELETE
                        { $$ = operator_stoken (" delete"); }
                        { $$ = operator_stoken (" new"); }
        |       OPERATOR DELETE
                        { $$ = operator_stoken (" delete"); }


@@ -1632,7 +1630,7 @@ name      :       NAME { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }
        |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }
        |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }

-       |       operator { $$ = $1; }
+       |       oper { $$ = $1; }

        ;
 
 name_not_typename :    NAME
        ;
 
 name_not_typename :    NAME


@@ -1644,7 +1642,7 @@ name_not_typename :       NAME
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT
  */
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT
  */

-       |       operator
+       |       oper

                        {
                          struct field_of_this_result is_a_field_of_this;
 
                        {
                          struct field_of_this_result is_a_field_of_this;
 


@@ -1666,7 +1664,7 @@ name_not_typename :       NAME
 static void
 write_destructor_name (struct parser_state *par_state, struct stoken token)
 {
 static void
 write_destructor_name (struct parser_state *par_state, struct stoken token)
 {

-  char *copy = alloca (token.length + 1);
+  char *copy = (char *) alloca (token.length + 1);

 
   copy[0] = '~';
   memcpy (&copy[1], token.ptr, token.length);
 
   copy[0] = '~';
   memcpy (&copy[1], token.ptr, token.length);


@@ -1678,7 +1676,8 @@ write_destructor_name (struct parser_state *par_state, struct stoken token)
 }
 
 /* Returns a stoken of the operator name given by OP (which does not
 }
 
 /* Returns a stoken of the operator name given by OP (which does not

-   include the string "operator").  */ 
+   include the string "operator").  */
+

 static struct stoken
 operator_stoken (const char *op)
 {
 static struct stoken
 operator_stoken (const char *op)
 {


@@ -1687,7 +1686,7 @@ operator_stoken (const char *op)
   char *buf;
 
   st.length = strlen (operator_string) + strlen (op);
   char *buf;
 
   st.length = strlen (operator_string) + strlen (op);

-  buf = malloc (st.length + 1);
+  buf = (char *) malloc (st.length + 1);

   strcpy (buf, operator_string);
   strcat (buf, op);
   st.ptr = buf;
   strcpy (buf, operator_string);
   strcat (buf, op);
   st.ptr = buf;


@@ -1772,7 +1771,7 @@ parse_number (struct parser_state *par_state,
   struct type *unsigned_type;
   char *p;
 
   struct type *unsigned_type;
   char *p;
 

-  p = alloca (len);
+  p = (char *) alloca (len);

   memcpy (p, buf, len);
 
   if (parsed_float)
   memcpy (p, buf, len);
 
   if (parsed_float)


@@ -1824,7 +1823,7 @@ parse_number (struct parser_state *par_state,
     }
 
   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
     }
 
   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */

-  if (p[0] == '0')
+  if (p[0] == '0' && len > 1)

     switch (p[1])
       {
       case 'x':
     switch (p[1])
       {
       case 'x':


@@ -1957,7 +1956,7 @@ parse_number (struct parser_state *par_state,
   else
     {
       int shift;
   else
     {
       int shift;

-      if (sizeof (ULONGEST) * HOST_CHAR_BIT 
+      if (sizeof (ULONGEST) * HOST_CHAR_BIT

          < gdbarch_long_long_bit (parse_gdbarch (par_state)))
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
          < gdbarch_long_long_bit (parse_gdbarch (par_state)))
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);


@@ -1973,11 +1972,11 @@ parse_number (struct parser_state *par_state,
    /* If the high bit of the worked out type is set then this number
       has to be unsigned. */
 
    /* If the high bit of the worked out type is set then this number
       has to be unsigned. */
 

-   if (unsigned_p || (n & high_bit)) 
+   if (unsigned_p || (n & high_bit))

      {
        putithere->typed_val_int.type = unsigned_type;
      }
      {
        putithere->typed_val_int.type = unsigned_type;
      }

-   else 
+   else

      {
        putithere->typed_val_int.type = signed_type;
      }
      {
        putithere->typed_val_int.type = signed_type;
      }


@@ -2159,12 +2158,13 @@ c_parse_escape (const char **ptr, struct obstack *output)
    stored in VALUE.  This returns a token value, either STRING or
    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
    number of host characters in the literal.  */
    stored in VALUE.  This returns a token value, either STRING or
    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
    number of host characters in the literal.  */

+

 static int
 parse_string_or_char (const char *tokptr, const char **outptr,
                      struct typed_stoken *value, int *host_chars)
 {
   int quote;
 static int
 parse_string_or_char (const char *tokptr, const char **outptr,
                      struct typed_stoken *value, int *host_chars)
 {
   int quote;

-  enum c_string_type type;
+  c_string_type type;

   int is_objc = 0;
 
   /* Build the gdb internal form of the input string in tempbuf.  Note
   int is_objc = 0;
 
   /* Build the gdb internal form of the input string in tempbuf.  Note


@@ -2247,7 +2247,7 @@ parse_string_or_char (const char *tokptr, const char **outptr,
   ++tokptr;
 
   value->type = type;
   ++tokptr;
 
   value->type = type;

-  value->ptr = obstack_base (&tempbuf);
+  value->ptr = (char *) obstack_base (&tempbuf);

   value->length = obstack_object_size (&tempbuf);
 
   *outptr = tokptr;
   value->length = obstack_object_size (&tempbuf);
 
   *outptr = tokptr;


@@ -2257,7 +2257,7 @@ parse_string_or_char (const char *tokptr, const char **outptr,
 
 /* This is used to associate some attributes with a token.  */
 
 
 /* This is used to associate some attributes with a token.  */
 

-enum token_flags
+enum token_flag

 {
   /* If this bit is set, the token is C++-only.  */
 
 {
   /* If this bit is set, the token is C++-only.  */
 


@@ -2269,13 +2269,14 @@ enum token_flags
 
   FLAG_SHADOW = 2
 };
 
   FLAG_SHADOW = 2
 };

+DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);

 
 struct token
 {
 
 struct token
 {

-  char *operator;
+  char *oper;

   int token;
   enum exp_opcode opcode;
   int token;
   enum exp_opcode opcode;

-  enum token_flags flags;
+  token_flags flags;

 };
 
 static const struct token tokentab3[] =
 };
 
 static const struct token tokentab3[] =


@@ -2399,7 +2400,8 @@ scan_macro_expansion (char *expansion)
 
   /* Copy to the obstack, and then free the intermediate
      expansion.  */
 
   /* Copy to the obstack, and then free the intermediate
      expansion.  */

-  copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
+  copy = (char *) obstack_copy0 (&expansion_obstack, expansion,
+                                strlen (expansion));

   xfree (expansion);
 
   /* Save the old lexptr value, so we can return to it when we're done
   xfree (expansion);
 
   /* Save the old lexptr value, so we can return to it when we're done


@@ -2408,15 +2410,13 @@ scan_macro_expansion (char *expansion)
   lexptr = copy;
 }
 
   lexptr = copy;
 }
 

-

 static int
 scanning_macro_expansion (void)
 {
   return macro_original_text != 0;
 }
 
 static int
 scanning_macro_expansion (void)
 {
   return macro_original_text != 0;
 }
 

-
-static void 
+static void

 finished_macro_expansion (void)
 {
   /* There'd better be something to pop back to.  */
 finished_macro_expansion (void)
 {
   /* There'd better be something to pop back to.  */


@@ -2427,7 +2427,6 @@ finished_macro_expansion (void)
   macro_original_text = 0;
 }
 
   macro_original_text = 0;
 }
 

-

 static void
 scan_macro_cleanup (void *dummy)
 {
 static void
 scan_macro_cleanup (void *dummy)
 {


@@ -2494,7 +2493,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
   tokstart = lexptr;
   /* See if it is a special token of length 3.  */
   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
   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) == 0)
+    if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)

       {
        if ((tokentab3[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)
       {
        if ((tokentab3[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)


@@ -2507,7 +2506,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
 
   /* 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) == 0)
+    if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)

       {
        if ((tokentab2[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)
       {
        if ((tokentab2[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)


@@ -2754,7 +2753,6 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
                 that we look ahead only when the '<' adjoins non-whitespace
                 characters; for comparison expressions, e.g. "a < b > c",
                 there must be spaces before the '<', etc. */
                 that we look ahead only when the '<' adjoins non-whitespace
                 characters; for comparison expressions, e.g. "a < b > c",
                 there must be spaces before the '<', etc. */

-               

              const char *p = find_template_name_end (tokstart + namelen);
 
              if (p)
              const char *p = find_template_name_end (tokstart + namelen);
 
              if (p)


@@ -2805,7 +2803,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
   /* Catch specific keywords.  */
   copy = copy_name (yylval.sval);
   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
   /* Catch specific keywords.  */
   copy = copy_name (yylval.sval);
   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)

-    if (strcmp (copy, ident_tokens[i].operator) == 0)
+    if (strcmp (copy, ident_tokens[i].oper) == 0)

       {
        if ((ident_tokens[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)
       {
        if ((ident_tokens[i].flags & FLAG_CXX) != 0
            && parse_language (par_state)->la_language != language_cplus)


@@ -2819,7 +2817,7 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
                               VAR_DOMAIN,
                               (parse_language (par_state)->la_language
                                == language_cplus ? &is_a_field_of_this
                               VAR_DOMAIN,
                               (parse_language (par_state)->la_language
                                == language_cplus ? &is_a_field_of_this

-                               : NULL))
+                               : NULL)).symbol

                != NULL)
              {
                /* The keyword is shadowed.  */
                != NULL)
              {
                /* The keyword is shadowed.  */


@@ -2840,7 +2838,8 @@ lex_one_token (struct parser_state *par_state, int *is_quoted_name)
     saw_name_at_eof = 1;
 
   yylval.ssym.stoken = yylval.sval;
     saw_name_at_eof = 1;
 
   yylval.ssym.stoken = yylval.sval;

-  yylval.ssym.sym = NULL;
+  yylval.ssym.sym.symbol = NULL;
+  yylval.ssym.sym.block = NULL;

   yylval.ssym.is_a_field_of_this = 0;
   return NAME;
 }
   yylval.ssym.is_a_field_of_this = 0;
   return NAME;
 }


@@ -2870,11 +2869,12 @@ static struct obstack name_obstack;
    in which lookups start; this can be NULL to mean the global scope.
    IS_QUOTED_NAME is non-zero if the name token was originally quoted
    in single quotes.  */
    in which lookups start; this can be NULL to mean the global scope.
    IS_QUOTED_NAME is non-zero if the name token was originally quoted
    in single quotes.  */

+

 static int
 classify_name (struct parser_state *par_state, const struct block *block,
               int is_quoted_name)
 {
 static int
 classify_name (struct parser_state *par_state, const struct block *block,
               int is_quoted_name)
 {

-  struct symbol *sym;
+  struct block_symbol bsym;

   char *copy;
   struct field_of_this_result is_a_field_of_this;
 
   char *copy;
   struct field_of_this_result is_a_field_of_this;
 


@@ -2884,17 +2884,17 @@ classify_name (struct parser_state *par_state, const struct block *block,
      we can refer to it unconditionally below.  */
   memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
 
      we can refer to it unconditionally below.  */
   memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
 

-  sym = lookup_symbol (copy, block, VAR_DOMAIN, 
-                      parse_language (par_state)->la_name_of_this
-                      ? &is_a_field_of_this : NULL);
+  bsym = lookup_symbol (copy, block, VAR_DOMAIN,
+                       parse_language (par_state)->la_name_of_this
+                       ? &is_a_field_of_this : NULL);

 
 

-  if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+  if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)

     {
     {

-      yylval.ssym.sym = sym;
+      yylval.ssym.sym = bsym;

       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
       return BLOCKNAME;
     }
       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
       return BLOCKNAME;
     }

-  else if (!sym)
+  else if (!bsym.symbol)

     {
       /* If we found a field of 'this', we might have erroneously
         found a constructor where we wanted a type name.  Handle this
     {
       /* If we found a field of 'this', we might have erroneously
         found a constructor where we wanted a type name.  Handle this


@@ -2907,11 +2907,11 @@ classify_name (struct parser_state *par_state, const struct block *block,
        {
          struct field_of_this_result inner_is_a_field_of_this;
 
        {
          struct field_of_this_result inner_is_a_field_of_this;
 

-         sym = lookup_symbol (copy, block, STRUCT_DOMAIN,
-                              &inner_is_a_field_of_this);
-         if (sym != NULL)
+         bsym = lookup_symbol (copy, block, STRUCT_DOMAIN,
+                               &inner_is_a_field_of_this);
+         if (bsym.symbol != NULL)

            {
            {

-             yylval.tsym.type = SYMBOL_TYPE (sym);
+             yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);

              return TYPENAME;
            }
        }
              return TYPENAME;
            }
        }


@@ -2928,36 +2928,31 @@ classify_name (struct parser_state *par_state, const struct block *block,
          symtab = lookup_symtab (copy);
          if (symtab)
            {
          symtab = lookup_symtab (copy);
          if (symtab)
            {

-             yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
+             yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),

                                               STATIC_BLOCK);
              return FILENAME;
            }
        }
     }
 
                                               STATIC_BLOCK);
              return FILENAME;
            }
        }
     }
 

-  if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+  if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_TYPEDEF)

     {
     {

-      yylval.tsym.type = SYMBOL_TYPE (sym);
+      yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);

       return TYPENAME;
     }
 
       return TYPENAME;
     }
 

-  yylval.tsym.type
-    = language_lookup_primitive_type_by_name (parse_language (par_state),
-                                             parse_gdbarch (par_state),
-                                             copy);
-  if (yylval.tsym.type != NULL)
-    return TYPENAME;
-

   /* See if it's an ObjC classname.  */
   /* See if it's an ObjC classname.  */

-  if (parse_language (par_state)->la_language == language_objc && !sym)
+  if (parse_language (par_state)->la_language == language_objc && !bsym.symbol)

     {
       CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
       if (Class)
        {
     {
       CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
       if (Class)
        {

-         yylval.class.class = Class;
+         struct symbol *sym;
+
+         yylval.theclass.theclass = Class;

          sym = lookup_struct_typedef (copy, expression_context_block, 1);
          if (sym)
          sym = lookup_struct_typedef (copy, expression_context_block, 1);
          if (sym)

-           yylval.class.type = SYMBOL_TYPE (sym);
+           yylval.theclass.type = SYMBOL_TYPE (sym);

          return CLASSNAME;
        }
     }
          return CLASSNAME;
        }
     }


@@ -2965,26 +2960,27 @@ classify_name (struct parser_state *par_state, const struct block *block,
   /* Input names that aren't symbols but ARE valid hex numbers, when
      the input radix permits them, can be names or numbers depending
      on the parse.  Note we support radixes > 16 here.  */
   /* Input names that aren't symbols but ARE valid hex numbers, when
      the input radix permits them, can be names or numbers depending
      on the parse.  Note we support radixes > 16 here.  */

-  if (!sym
+  if (!bsym.symbol

       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
          || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
     {
       YYSTYPE newlval; /* Its value is ignored.  */
       int hextype = parse_number (par_state, copy, yylval.sval.length,
                                  0, &newlval);
       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
          || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
     {
       YYSTYPE newlval; /* Its value is ignored.  */
       int hextype = parse_number (par_state, copy, yylval.sval.length,
                                  0, &newlval);

+

       if (hextype == INT)
        {
       if (hextype == INT)
        {

-         yylval.ssym.sym = sym;
+         yylval.ssym.sym = bsym;

          yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
          return NAME_OR_INT;
        }
     }
 
   /* Any other kind of symbol */
          yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
          return NAME_OR_INT;
        }
     }
 
   /* Any other kind of symbol */

-  yylval.ssym.sym = sym;
+  yylval.ssym.sym = bsym;

   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
 
   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
 

-  if (sym == NULL
+  if (bsym.symbol == NULL

       && parse_language (par_state)->la_language == language_cplus
       && is_a_field_of_this.type == NULL
       && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
       && parse_language (par_state)->la_language == language_cplus
       && is_a_field_of_this.type == NULL
       && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)


@@ -3012,14 +3008,15 @@ classify_inner_name (struct parser_state *par_state,
     return ERROR;
 
   copy = copy_name (yylval.ssym.stoken);
     return ERROR;
 
   copy = copy_name (yylval.ssym.stoken);

-  yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block);
+  /* N.B. We assume the symbol can only be in VAR_DOMAIN.  */
+  yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block, VAR_DOMAIN);

 
   /* If no symbol was found, search for a matching base class named
      COPY.  This will allow users to enter qualified names of class members
      relative to the `this' pointer.  */
 
   /* If no symbol was found, search for a matching base class named
      COPY.  This will allow users to enter qualified names of class members
      relative to the `this' pointer.  */

-  if (yylval.ssym.sym == NULL)
+  if (yylval.ssym.sym.symbol == NULL)

     {
     {

-      struct type *base_type = find_type_baseclass_by_name (type, copy);
+      struct type *base_type = cp_find_type_baseclass_by_name (type, copy);

 
       if (base_type != NULL)
        {
 
       if (base_type != NULL)
        {


@@ -3030,7 +3027,7 @@ classify_inner_name (struct parser_state *par_state,
       return ERROR;
     }
 
       return ERROR;
     }
 

-  switch (SYMBOL_CLASS (yylval.ssym.sym))
+  switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))

     {
     case LOC_BLOCK:
     case LOC_LABEL:
     {
     case LOC_BLOCK:
     case LOC_LABEL:


@@ -3038,7 +3035,7 @@ classify_inner_name (struct parser_state *par_state,
         named COPY when we really wanted a base class of the same name.
         Double-check this case by looking for a base class.  */
       {
         named COPY when we really wanted a base class of the same name.
         Double-check this case by looking for a base class.  */
       {

-       struct type *base_type = find_type_baseclass_by_name (type, copy);
+       struct type *base_type = cp_find_type_baseclass_by_name (type, copy);

 
        if (base_type != NULL)
          {
 
        if (base_type != NULL)
          {


@@ -3049,7 +3046,7 @@ classify_inner_name (struct parser_state *par_state,
       return ERROR;
 
     case LOC_TYPEDEF:
       return ERROR;
 
     case LOC_TYPEDEF:

-      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
+      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);

       return TYPENAME;
 
     default:
       return TYPENAME;
 
     default:


@@ -3064,11 +3061,12 @@ classify_inner_name (struct parser_state *par_state,
    problem in our parsing approach, where the parser could not
    distinguish between qualified names and qualified types at the
    right point.
    problem in our parsing approach, where the parser could not
    distinguish between qualified names and qualified types at the
    right point.

-   
+

    This approach is still not ideal, because it mishandles template
    types.  See the comment in lex_one_token for an example.  However,
    this is still an improvement over the earlier approach, and will
    suffice until we move to better parsing technology.  */
    This approach is still not ideal, because it mishandles template
    types.  See the comment in lex_one_token for an example.  However,
    this is still an improvement over the earlier approach, and will
    suffice until we move to better parsing technology.  */

+

 static int
 yylex (void)
 {
 static int
 yylex (void)
 {


@@ -3175,13 +3173,13 @@ yylex (void)
          obstack_grow (&name_obstack, next->value.sval.ptr,
                        next->value.sval.length);
 
          obstack_grow (&name_obstack, next->value.sval.ptr,
                        next->value.sval.length);
 

-         yylval.sval.ptr = obstack_base (&name_obstack);
+         yylval.sval.ptr = (const char *) obstack_base (&name_obstack);

          yylval.sval.length = obstack_object_size (&name_obstack);
          current.value = yylval;
          current.token = classification;
 
          last_was_coloncolon = 0;
          yylval.sval.length = obstack_object_size (&name_obstack);
          current.value = yylval;
          current.token = classification;
 
          last_was_coloncolon = 0;

-         
+

          if (classification == NAME)
            break;
 
          if (classification == NAME)
            break;
 


@@ -3200,9 +3198,10 @@ yylex (void)
      the FIFO, and delete the other constituent tokens.  */
   if (checkpoint > 0)
     {
      the FIFO, and delete the other constituent tokens.  */
   if (checkpoint > 0)
     {

-      current.value.sval.ptr = obstack_copy0 (&expansion_obstack,
-                                             current.value.sval.ptr,
-                                             current.value.sval.length);
+      current.value.sval.ptr
+       = (const char *) obstack_copy0 (&expansion_obstack,
+                                       current.value.sval.ptr,
+                                       current.value.sval.length);

 
       VEC_replace (token_and_value, token_fifo, 0, &current);
       if (checkpoint > 1)
 
       VEC_replace (token_and_value, token_fifo, 0, &current);
       if (checkpoint > 1)


@@ -3282,7 +3281,7 @@ c_print_token (FILE *file, int type, YYSTYPE value)
     case CHAR:
     case STRING:
       {
     case CHAR:
     case STRING:
       {

-       char *copy = alloca (value.tsval.length + 1);
+       char *copy = (char *) alloca (value.tsval.length + 1);

 
        memcpy (copy, value.tsval.ptr, value.tsval.length);
        copy[value.tsval.length] = '\0';
 
        memcpy (copy, value.tsval.ptr, value.tsval.length);
        copy[value.tsval.length] = '\0';


@@ -3308,8 +3307,8 @@ c_print_token (FILE *file, int type, YYSTYPE value)
     case BLOCKNAME:
       fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
               copy_name (value.ssym.stoken),
     case BLOCKNAME:
       fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
               copy_name (value.ssym.stoken),

-              (value.ssym.sym == NULL
-               ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym)),
+              (value.ssym.sym.symbol == NULL
+               ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym.symbol)),

               value.ssym.is_a_field_of_this);
       break;
 
               value.ssym.is_a_field_of_this);
       break;