gdb-3.3

1 files changed, 1619 insertions, 801 deletions

diff --git a/gdb/expread.tab.c b/gdb/expread.tab.c
index 99a855e..87de8f6 100644
--- a/gdb/expread.tab.c
+++ b/gdb/expread.tab.c
@@ -1,5 +1,45 @@
 
-# line 31 "expread.y"
+/*  A Bison parser, made from expread.y  */
+
+#define	INT	258
+#define	CHAR	259
+#define	UINT	260
+#define	FLOAT	261
+#define	NAME	262
+#define	TYPENAME	263
+#define	BLOCKNAME	264
+#define	STRING	265
+#define	STRUCT	266
+#define	UNION	267
+#define	ENUM	268
+#define	SIZEOF	269
+#define	UNSIGNED	270
+#define	COLONCOLON	271
+#define	SIGNED	272
+#define	LONG	273
+#define	SHORT	274
+#define	INT_KEYWORD	275
+#define	LAST	276
+#define	REGNAME	277
+#define	VARIABLE	278
+#define	ASSIGN_MODIFY	279
+#define	THIS	280
+#define	ABOVE_COMMA	281
+#define	OR	282
+#define	AND	283
+#define	EQUAL	284
+#define	NOTEQUAL	285
+#define	LEQ	286
+#define	GEQ	287
+#define	LSH	288
+#define	RSH	289
+#define	UNARY	290
+#define	INCREMENT	291
+#define	DECREMENT	292
+#define	ARROW	293
+
+#line 29 "expread.y"
+
 #include "defs.h"
 #include "param.h"
 #include "symtab.h"
@@ -7,6 +47,7 @@
 #include "expression.h"
 
 #include <stdio.h>
+#include <a.out.h>
 
 static struct expression *expout;
 static int expout_size;
@@ -15,6 +56,12 @@ static int expout_ptr;
 static int yylex ();
 static void yyerror ();
 static void write_exp_elt ();
+static void write_exp_elt_opcode ();
+static void write_exp_elt_sym ();
+static void write_exp_elt_longcst ();
+static void write_exp_elt_dblcst ();
+static void write_exp_elt_type ();
+static void write_exp_elt_intern ();
 static void write_exp_string ();
 static void start_arglist ();
 static int end_arglist ();
@@ -56,10 +103,24 @@ struct stoken
     int length;
   };
 
-# line 92 "expread.y"
-typedef union 
+/* For parsing of complicated types.
+   An array should be preceded in the list by the size of the array.  */
+enum type_pieces
+  {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
+static enum type_pieces *type_stack;
+static int type_stack_depth, type_stack_size;
+
+static void push_type ();
+static enum type_pieces pop_type ();
+
+/* Allow debugging of parsing.  */
+#define YYDEBUG 1
+
+#line 111 "expread.y"
+typedef union
   {
-    long lval;
+    LONGEST lval;
+    unsigned LONGEST ulval;
     double dval;
     struct symbol *sym;
     struct type *tval;
@@ -72,47 +133,1427 @@ typedef union
     struct type **tvec;
     int *ivec;
   } YYSTYPE;
-# define INT 257
-# define CHAR 258
-# define FLOAT 259
-# define NAME 260
-# define TYPENAME 261
-# define STRING 262
-# define STRUCT 263
-# define UNION 264
-# define ENUM 265
-# define SIZEOF 266
-# define UNSIGNED 267
-# define COLONCOLON 268
-# define LAST 269
-# define REGNAME 270
-# define VARIABLE 271
-# define ASSIGN_MODIFY 272
-# define THIS 273
-# define ABOVE_COMMA 274
-# define OR 275
-# define AND 276
-# define EQUAL 277
-# define NOTEQUAL 278
-# define LEQ 279
-# define GEQ 280
-# define LSH 281
-# define RSH 282
-# define UNARY 283
-# define INCREMENT 284
-# define DECREMENT 285
-# define ARROW 286
-#define yyclearin yychar = -1
-#define yyerrok yyerrflag = 0
-extern int yychar;
-extern short yyerrflag;
-#ifndef YYMAXDEPTH
-#define YYMAXDEPTH 150
+
+#ifndef YYLTYPE
+typedef
+  struct yyltype
+    {
+      int timestamp;
+      int first_line;
+      int first_column;
+      int last_line;
+      int last_column;
+      char *text;
+   }
+  yyltype;
+
+#define YYLTYPE yyltype
+#endif
+
+#include <stdio.h>
+
+#ifndef __STDC__
+#define const
+#endif
+
+
+
+#define	YYFINAL		185
+#define	YYFLAG		-32768
+#define	YYNTBASE	63
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 293 ? yytranslate[x] : 81)
+
+static const char yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    56,     2,     2,     2,    48,    34,     2,    55,
+    59,    46,    44,    26,    45,    53,    47,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,    62,     2,    37,
+    28,    38,    29,    43,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+    54,     2,    58,    33,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    60,    32,    61,    57,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
+     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    27,    30,    31,    35,    36,    39,    40,    41,    42,    49,
+    50,    51,    52
+};
+
+static const short yyrline[] = {     0,
+   190,   194,   195,   200,   203,   206,   210,   214,   218,   222,
+   226,   230,   234,   238,   244,   248,   254,   258,   262,   266,
+   272,   275,   279,   283,   289,   295,   301,   305,   309,   313,
+   317,   321,   325,   329,   333,   337,   341,   345,   349,   353,
+   357,   361,   365,   369,   373,   377,   381,   385,   391,   401,
+   413,   420,   427,   430,   436,   442,   448,   455,   462,   469,
+   490,   499,   510,   523,   569,   646,   647,   682,   684,   686,
+   689,   691,   696,   702,   704,   708,   710,   714,   718,   719,
+   721,   723,   726,   733,   736,   738,   740,   742,   744,   746,
+   748,   750,   753,   756,   759,   761,   763,   766,   770,   771,
+   776,   781,   789,   794,   801,   802,   803,   806,   807
+};
+
+static const char * const yytname[] = {     0,
+"error","$illegal.","INT","CHAR","UINT","FLOAT","NAME","TYPENAME","BLOCKNAME","STRING",
+"STRUCT","UNION","ENUM","SIZEOF","UNSIGNED","COLONCOLON","SIGNED","LONG","SHORT","INT_KEYWORD",
+"LAST","REGNAME","VARIABLE","ASSIGN_MODIFY","THIS","','","ABOVE_COMMA","'='","'?'","OR",
+"AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'","'>'","LEQ","GEQ",
+"LSH","RSH","'@'","'+'","'-'","'*'","'/'","'%'","UNARY","INCREMENT",
+"DECREMENT","ARROW","'.'","'['","'('","'!'","'~'","']'","')'","'{'",
+"'}'","':'","start"
+};
+
+static const short yyr1[] = {     0,
+    63,    64,    64,    65,    65,    65,    65,    65,    65,    65,
+    65,    65,    65,    65,    65,    65,    65,    65,    66,    65,
+    67,    67,    67,    65,    65,    65,    65,    65,    65,    65,
+    65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
+    65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
+    65,    65,    65,    65,    65,    65,    65,    65,    65,    68,
+    68,    69,    69,    69,    69,    70,    70,    71,    71,    71,
+    72,    72,    72,    72,    72,    73,    73,    74,    75,    75,
+    75,    75,    75,    76,    76,    76,    76,    76,    76,    76,
+    76,    76,    76,    76,    76,    76,    76,    76,    77,    77,
+    77,    77,    78,    78,    79,    79,    79,    80,    80
+};
+
+static const short yyr2[] = {     0,
+     1,     1,     3,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     3,     4,     3,     4,     4,     0,     5,
+     0,     1,     3,     4,     4,     3,     3,     3,     3,     3,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+     3,     3,     3,     3,     3,     5,     3,     3,     1,     1,
+     1,     1,     1,     1,     1,     1,     4,     1,     1,     1,
+     3,     3,     3,     2,     1,     1,     2,     1,     2,     1,
+     3,     2,     1,     2,     1,     2,     3,     2,     1,     3,
+     6,     8,     9,     1,     1,     1,     1,     2,     3,     2,
+     3,     2,     2,     2,     2,     1,     2,     1,     1,     1,
+     1,     1,     1,     3,     1,     1,     1,     1,     1
+};
+
+static const short yydefact[] = {     0,
+    49,    51,    50,    52,   108,    84,   109,    58,     0,     0,
+     0,     0,    96,     0,    98,    86,    87,    85,    54,    55,
+    56,    59,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     1,     2,     0,    53,     0,    65,   105,   107,   106,
+    92,    93,    94,     0,    13,    99,   101,   102,   100,    95,
+    64,   101,   102,    97,    88,    90,     5,     6,     4,     9,
+    10,     0,    79,     0,    66,     7,     8,     0,    66,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,    11,    12,     0,     0,     0,    19,     0,     0,
+     0,    89,    91,    26,     0,     0,     0,    68,     0,     0,
+    67,    70,    73,    75,     0,     0,     3,    48,    47,     0,
+    45,    44,    43,    42,    41,    35,    36,    39,    40,    37,
+    38,    33,    34,    27,    31,    32,    28,    29,    30,     0,
+    14,     0,    16,     0,    21,    62,    63,    57,     0,    25,
+    80,    69,     0,    76,    78,     0,     0,    72,    74,    24,
+     0,    15,    17,    18,    22,     0,     0,    77,    71,    46,
+     0,    20,     0,    23,    81,     0,    82,   103,     0,     0,
+    83,   104,     0,     0,     0
+};
+
+static const short yydefgoto[] = {   183,
+    62,    33,   145,   166,    34,    35,    63,   111,   112,   113,
+   114,    64,    36,    50,   179,   147,    37
+};
+
+static const short yypact[] = {   157,
+-32768,-32768,-32768,-32768,-32768,-32768,   -13,-32768,   105,   105,
+   105,   215,    82,   105,   178,   -10,    -4,-32768,-32768,-32768,
+-32768,-32768,   157,   157,   157,   157,   157,   157,   157,   157,
+   239,     6,   284,    75,-32768,    79,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,   157,   501,-32768,    66,    84,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,   501,   501,   501,   501,
+   501,    67,-32768,   -50,    69,   501,   501,   -53,   138,   157,
+   157,   157,   157,   157,   157,   157,   157,   157,   157,   157,
+   157,   157,   157,   157,   157,   157,   157,   157,   157,   157,
+   157,   157,-32768,-32768,   111,   197,   157,-32768,   105,   105,
+   -28,-32768,-32768,-32768,   239,   157,   202,   -21,    26,    51,
+-32768,    62,-32768,-32768,   157,    63,   284,   284,   284,   249,
+   336,   360,   383,   405,   426,   445,   445,   460,   460,   460,
+   460,   473,   473,   485,   495,   495,   501,   501,   501,   157,
+-32768,   157,-32768,    -2,   157,   106,-32768,    32,   109,   501,
+-32768,-32768,    77,-32768,-32768,    68,    72,-32768,-32768,   501,
+   157,   501,   501,-32768,   284,    70,    94,-32768,-32768,   311,
+   157,-32768,    83,   284,    92,   126,-32768,    93,    73,   239,
+-32768,    93,   121,   150,-32768
+};
+
+static const short yypgoto[] = {-32768,
+     1,   -12,-32768,-32768,-32768,-32768,-32768,   -80,-32768,    41,
+    46,   -25,   -24,   166,-32768,    12,-32768
+};
+
+
+#define	YYLAST		556
+
+
+static const short yytable[] = {    45,
+    32,   105,   -60,    65,   105,    68,    69,   115,   106,    55,
+    57,    58,    59,    60,    61,    56,    66,    67,   101,    65,
+    41,    42,    43,    70,   108,    51,   105,   152,   153,   156,
+   148,    70,   109,   110,     1,     2,     3,     4,     5,     6,
+     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+    17,    18,    19,    20,    21,   164,    22,   117,   118,   119,
+   120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
+   130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+   149,    26,    27,   154,   107,   102,    28,    29,    30,    46,
+    99,    31,    70,   150,   100,   171,   108,   144,   180,    47,
+    48,    49,   160,   103,   109,   110,   141,   143,   151,   155,
+   146,    38,    39,    40,   108,   109,   157,    38,    39,    40,
+   184,   -61,   109,   110,   167,   104,   169,   162,   172,   163,
+   155,   181,   165,     6,   168,   150,     9,    10,    11,   173,
+    13,   175,    15,    16,    17,    18,   176,   105,   170,   185,
+   178,    69,   158,   116,   182,    69,   140,   159,   174,     1,
+     2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+    12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+    54,    22,     0,   108,   177,    46,     0,     0,     0,     0,
+    23,   109,   110,     0,     0,    52,    53,    49,     0,     0,
+     0,    24,    25,    38,    39,    40,    26,    27,    38,    39,
+    40,    28,    29,    30,     0,     0,    31,     1,     2,     3,
+     4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+    14,    15,    16,    17,    18,    19,    20,    21,     0,    22,
+     0,     0,   142,     0,     0,     0,     6,   151,    23,     9,
+    10,    11,     0,    13,     0,    15,    16,    17,    18,    24,
+    25,     0,     0,     0,    26,    27,     0,     0,     0,    44,
+    29,    30,    71,     0,    31,     0,    72,    73,    74,    75,
+    76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+    86,    87,    88,    89,    90,    91,    92,     0,    93,    94,
+    95,    96,    97,    98,     0,     0,     0,    71,     0,     0,
+   161,    72,    73,    74,    75,    76,    77,    78,    79,    80,
+    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
+    91,    92,     0,    93,    94,    95,    96,    97,    98,    73,
+    74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+    84,    85,    86,    87,    88,    89,    90,    91,    92,     0,
+    93,    94,    95,    96,    97,    98,    75,    76,    77,    78,
+    79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+    89,    90,    91,    92,     0,    93,    94,    95,    96,    97,
+    98,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+    85,    86,    87,    88,    89,    90,    91,    92,     0,    93,
+    94,    95,    96,    97,    98,    77,    78,    79,    80,    81,
+    82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+    92,     0,    93,    94,    95,    96,    97,    98,    78,    79,
+    80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+    90,    91,    92,     0,    93,    94,    95,    96,    97,    98,
+    79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+    89,    90,    91,    92,     0,    93,    94,    95,    96,    97,
+    98,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+    90,    91,    92,     0,    93,    94,    95,    96,    97,    98,
+    85,    86,    87,    88,    89,    90,    91,    92,     0,    93,
+    94,    95,    96,    97,    98,    87,    88,    89,    90,    91,
+    92,     0,    93,    94,    95,    96,    97,    98,    88,    89,
+    90,    91,    92,     0,    93,    94,    95,    96,    97,    98,
+    90,    91,    92,     0,    93,    94,    95,    96,    97,    98,
+    93,    94,    95,    96,    97,    98
+};
+
+static const short yycheck[] = {    12,
+     0,    55,    16,    28,    55,    31,    31,    61,    59,    20,
+    23,    24,    25,    26,    27,    20,    29,    30,    44,    44,
+     9,    10,    11,    26,    46,    14,    55,   108,     3,   110,
+    59,    26,    54,    55,     3,     4,     5,     6,     7,     8,
+     9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+    19,    20,    21,    22,    23,    58,    25,    70,    71,    72,
+    73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+    83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+   105,    50,    51,    58,    16,    20,    55,    56,    57,     8,
+    16,    60,    26,   106,    16,    26,    46,    97,    26,    18,
+    19,    20,   115,    20,    54,    55,    95,    96,    46,    59,
+    99,     7,     8,     9,    46,    54,    55,     7,     8,     9,
+     0,    16,    54,    55,    16,    59,    59,   140,    59,   142,
+    59,    59,   145,     8,    58,   148,    11,    12,    13,    46,
+    15,    59,    17,    18,    19,    20,    55,    55,   161,     0,
+   176,   176,   112,    16,   180,   180,    46,   112,   171,     3,
+     4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+    14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+    15,    25,    -1,    46,    59,     8,    -1,    -1,    -1,    -1,
+    34,    54,    55,    -1,    -1,    18,    19,    20,    -1,    -1,
+    -1,    45,    46,     7,     8,     9,    50,    51,     7,     8,
+     9,    55,    56,    57,    -1,    -1,    60,     3,     4,     5,
+     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+    16,    17,    18,    19,    20,    21,    22,    23,    -1,    25,
+    -1,    -1,    46,    -1,    -1,    -1,     8,    46,    34,    11,
+    12,    13,    -1,    15,    -1,    17,    18,    19,    20,    45,
+    46,    -1,    -1,    -1,    50,    51,    -1,    -1,    -1,    55,
+    56,    57,    24,    -1,    60,    -1,    28,    29,    30,    31,
+    32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+    42,    43,    44,    45,    46,    47,    48,    -1,    50,    51,
+    52,    53,    54,    55,    -1,    -1,    -1,    24,    -1,    -1,
+    62,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+    47,    48,    -1,    50,    51,    52,    53,    54,    55,    29,
+    30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+    40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
+    50,    51,    52,    53,    54,    55,    31,    32,    33,    34,
+    35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+    45,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
+    55,    32,    33,    34,    35,    36,    37,    38,    39,    40,
+    41,    42,    43,    44,    45,    46,    47,    48,    -1,    50,
+    51,    52,    53,    54,    55,    33,    34,    35,    36,    37,
+    38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
+    48,    -1,    50,    51,    52,    53,    54,    55,    34,    35,
+    36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+    46,    47,    48,    -1,    50,    51,    52,    53,    54,    55,
+    35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+    45,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
+    55,    37,    38,    39,    40,    41,    42,    43,    44,    45,
+    46,    47,    48,    -1,    50,    51,    52,    53,    54,    55,
+    41,    42,    43,    44,    45,    46,    47,    48,    -1,    50,
+    51,    52,    53,    54,    55,    43,    44,    45,    46,    47,
+    48,    -1,    50,    51,    52,    53,    54,    55,    44,    45,
+    46,    47,    48,    -1,    50,    51,    52,    53,    54,    55,
+    46,    47,    48,    -1,    50,    51,    52,    53,    54,    55,
+    50,    51,    52,    53,    54,    55
+};
+#define YYPURE 1
+
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "bison.simple"
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984 Bob Corbett and Richard Stallman
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 1, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
+#include <alloca.h>
+#endif
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYFAIL		goto yyerrlab;
+#define YYACCEPT	return(0)
+#define YYABORT 	return(1)
+#define YYERROR		goto yyerrlab
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#ifndef YYIMPURE
+#define YYLEX		yylex()
+#endif
+
+#ifndef YYPURE
+#define YYLEX		yylex(&yylval, &yylloc)
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYIMPURE
+
+int	yychar;			/*  the lookahead symbol		*/
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+YYLTYPE yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
+
+int yynerrs;			/*  number of parse errors so far       */
+#endif  /* YYIMPURE */
+
+#if YYDEBUG != 0
+int yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+/*  YYMAXDEPTH indicates the initial size of the parser's stacks	*/
+
+#ifndef	YYMAXDEPTH
+#define YYMAXDEPTH 200
+#endif
+
+/*  YYMAXLIMIT is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#ifndef YYMAXLIMIT
+#define YYMAXLIMIT 10000
+#endif
+
+
+#line 90 "bison.simple"
+int
+yyparse()
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  YYLTYPE *yylsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYMAXDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYMAXDEPTH];	/*  the semantic value stack		*/
+  YYLTYPE yylsa[YYMAXDEPTH];	/*  the location stack			*/
+
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+  YYLTYPE *yyls = yylsa;
+
+  int yymaxdepth = YYMAXDEPTH;
+
+#ifndef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  YYLTYPE yylloc;
+  int yynerrs;
+#endif
+
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int yylen;
+  void yyerror();
+  void bcopy();
+  int yylex();
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+  yylsp = yyls;
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yymaxdepth - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+#if defined(yyoverflow) || defined(YYLSP_NEEDED)
+      YYLTYPE *yyls1 = yyls;
+#endif
+      short *yyss1 = yyss;
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+		 &yyls1, size * sizeof (*yylsp),
+		 &yymaxdepth);
+
+      yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
+#else /* no yyoverflow */
+      /* Extend the stack our own way.  */
+      if (yymaxdepth >= YYMAXLIMIT)
+	yyerror("parser stack overflow");
+      yymaxdepth *= 2;
+      if (yymaxdepth > YYMAXLIMIT)
+	yymaxdepth = YYMAXLIMIT;
+      yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
+      bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+      yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
+      bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
+      bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
+#endif
+
+      if (yyssp >= yyss + yymaxdepth - 1)
+	YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      if (yylen == 1)
+	fprintf (stderr, "Reducing 1 value via line %d, ",
+		 yyrline[yyn]);
+      else
+	fprintf (stderr, "Reducing %d values via line %d, ",
+		 yylen, yyrline[yyn]);
+    }
+#endif
+
+
+  switch (yyn) {
+
+case 3:
+#line 196 "expread.y"
+{ write_exp_elt_opcode (BINOP_COMMA); ;
+    break;}
+case 4:
+#line 201 "expread.y"
+{ write_exp_elt_opcode (UNOP_IND); ;
+    break;}
+case 5:
+#line 204 "expread.y"
+{ write_exp_elt_opcode (UNOP_ADDR); ;
+    break;}
+case 6:
+#line 207 "expread.y"
+{ write_exp_elt_opcode (UNOP_NEG); ;
+    break;}
+case 7:
+#line 211 "expread.y"
+{ write_exp_elt_opcode (UNOP_ZEROP); ;
+    break;}
+case 8:
+#line 215 "expread.y"
+{ write_exp_elt_opcode (UNOP_LOGNOT); ;
+    break;}
+case 9:
+#line 219 "expread.y"
+{ write_exp_elt_opcode (UNOP_PREINCREMENT); ;
+    break;}
+case 10:
+#line 223 "expread.y"
+{ write_exp_elt_opcode (UNOP_PREDECREMENT); ;
+    break;}
+case 11:
+#line 227 "expread.y"
+{ write_exp_elt_opcode (UNOP_POSTINCREMENT); ;
+    break;}
+case 12:
+#line 231 "expread.y"
+{ write_exp_elt_opcode (UNOP_POSTDECREMENT); ;
+    break;}
+case 13:
+#line 235 "expread.y"
+{ write_exp_elt_opcode (UNOP_SIZEOF); ;
+    break;}
+case 14:
+#line 239 "expread.y"
+{ write_exp_elt_opcode (STRUCTOP_PTR);
+			  write_exp_string (yyvsp[0].sval);
+			  write_exp_elt_opcode (STRUCTOP_PTR); ;
+    break;}
+case 15:
+#line 245 "expread.y"
+{ write_exp_elt_opcode (STRUCTOP_MPTR); ;
+    break;}
+case 16:
+#line 249 "expread.y"
+{ write_exp_elt_opcode (STRUCTOP_STRUCT);
+			  write_exp_string (yyvsp[0].sval);
+			  write_exp_elt_opcode (STRUCTOP_STRUCT); ;
+    break;}
+case 17:
+#line 255 "expread.y"
+{ write_exp_elt_opcode (STRUCTOP_MEMBER); ;
+    break;}
+case 18:
+#line 259 "expread.y"
+{ write_exp_elt_opcode (BINOP_SUBSCRIPT); ;
+    break;}
+case 19:
+#line 265 "expread.y"
+{ start_arglist (); ;
+    break;}
+case 20:
+#line 267 "expread.y"
+{ write_exp_elt_opcode (OP_FUNCALL);
+			  write_exp_elt_longcst ((LONGEST) end_arglist ());
+			  write_exp_elt_opcode (OP_FUNCALL); ;
+    break;}
+case 22:
+#line 276 "expread.y"
+{ arglist_len = 1; ;
+    break;}
+case 23:
+#line 280 "expread.y"
+{ arglist_len++; ;
+    break;}
+case 24:
+#line 284 "expread.y"
+{ write_exp_elt_opcode (UNOP_MEMVAL);
+			  write_exp_elt_type (yyvsp[-2].tval);
+			  write_exp_elt_opcode (UNOP_MEMVAL); ;
+    break;}
+case 25:
+#line 290 "expread.y"
+{ write_exp_elt_opcode (UNOP_CAST);
+			  write_exp_elt_type (yyvsp[-2].tval);
+			  write_exp_elt_opcode (UNOP_CAST); ;
+    break;}
+case 26:
+#line 296 "expread.y"
+{ ;
+    break;}
+case 27:
+#line 302 "expread.y"
+{ write_exp_elt_opcode (BINOP_REPEAT); ;
+    break;}
+case 28:
+#line 306 "expread.y"
+{ write_exp_elt_opcode (BINOP_MUL); ;
+    break;}
+case 29:
+#line 310 "expread.y"
+{ write_exp_elt_opcode (BINOP_DIV); ;
+    break;}
+case 30:
+#line 314 "expread.y"
+{ write_exp_elt_opcode (BINOP_REM); ;
+    break;}
+case 31:
+#line 318 "expread.y"
+{ write_exp_elt_opcode (BINOP_ADD); ;
+    break;}
+case 32:
+#line 322 "expread.y"
+{ write_exp_elt_opcode (BINOP_SUB); ;
+    break;}
+case 33:
+#line 326 "expread.y"
+{ write_exp_elt_opcode (BINOP_LSH); ;
+    break;}
+case 34:
+#line 330 "expread.y"
+{ write_exp_elt_opcode (BINOP_RSH); ;
+    break;}
+case 35:
+#line 334 "expread.y"
+{ write_exp_elt_opcode (BINOP_EQUAL); ;
+    break;}
+case 36:
+#line 338 "expread.y"
+{ write_exp_elt_opcode (BINOP_NOTEQUAL); ;
+    break;}
+case 37:
+#line 342 "expread.y"
+{ write_exp_elt_opcode (BINOP_LEQ); ;
+    break;}
+case 38:
+#line 346 "expread.y"
+{ write_exp_elt_opcode (BINOP_GEQ); ;
+    break;}
+case 39:
+#line 350 "expread.y"
+{ write_exp_elt_opcode (BINOP_LESS); ;
+    break;}
+case 40:
+#line 354 "expread.y"
+{ write_exp_elt_opcode (BINOP_GTR); ;
+    break;}
+case 41:
+#line 358 "expread.y"
+{ write_exp_elt_opcode (BINOP_LOGAND); ;
+    break;}
+case 42:
+#line 362 "expread.y"
+{ write_exp_elt_opcode (BINOP_LOGXOR); ;
+    break;}
+case 43:
+#line 366 "expread.y"
+{ write_exp_elt_opcode (BINOP_LOGIOR); ;
+    break;}
+case 44:
+#line 370 "expread.y"
+{ write_exp_elt_opcode (BINOP_AND); ;
+    break;}
+case 45:
+#line 374 "expread.y"
+{ write_exp_elt_opcode (BINOP_OR); ;
+    break;}
+case 46:
+#line 378 "expread.y"
+{ write_exp_elt_opcode (TERNOP_COND); ;
+    break;}
+case 47:
+#line 382 "expread.y"
+{ write_exp_elt_opcode (BINOP_ASSIGN); ;
+    break;}
+case 48:
+#line 386 "expread.y"
+{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
+			  write_exp_elt_opcode (yyvsp[-1].opcode);
+			  write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); ;
+    break;}
+case 49:
+#line 392 "expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+			  if (yyvsp[0].lval == (int) yyvsp[0].lval || yyvsp[0].lval == (unsigned int) yyvsp[0].lval)
+			    write_exp_elt_type (builtin_type_int);
+			  else
+			    write_exp_elt_type (BUILTIN_TYPE_LONGEST);
+			  write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+			  write_exp_elt_opcode (OP_LONG); ;
+    break;}
+case 50:
+#line 402 "expread.y"
+{
+			  write_exp_elt_opcode (OP_LONG);
+			  if (yyvsp[0].ulval == (unsigned int) yyvsp[0].ulval)
+			    write_exp_elt_type (builtin_type_unsigned_int);
+			  else
+			    write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
+			  write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
+			  write_exp_elt_opcode (OP_LONG);
+			;
+    break;}
+case 51:
+#line 414 "expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+			  write_exp_elt_type (builtin_type_char);
+			  write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+			  write_exp_elt_opcode (OP_LONG); ;
+    break;}
+case 52:
+#line 421 "expread.y"
+{ write_exp_elt_opcode (OP_DOUBLE);
+			  write_exp_elt_type (builtin_type_double);
+			  write_exp_elt_dblcst (yyvsp[0].dval);
+			  write_exp_elt_opcode (OP_DOUBLE); ;
+    break;}
+case 54:
+#line 431 "expread.y"
+{ write_exp_elt_opcode (OP_LAST);
+			  write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+			  write_exp_elt_opcode (OP_LAST); ;
+    break;}
+case 55:
+#line 437 "expread.y"
+{ write_exp_elt_opcode (OP_REGISTER);
+			  write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
+			  write_exp_elt_opcode (OP_REGISTER); ;
+    break;}
+case 56:
+#line 443 "expread.y"
+{ write_exp_elt_opcode (OP_INTERNALVAR);
+			  write_exp_elt_intern (yyvsp[0].ivar);
+			  write_exp_elt_opcode (OP_INTERNALVAR); ;
+    break;}
+case 57:
+#line 449 "expread.y"
+{ write_exp_elt_opcode (OP_LONG);
+			  write_exp_elt_type (builtin_type_int);
+			  write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
+			  write_exp_elt_opcode (OP_LONG); ;
+    break;}
+case 58:
+#line 456 "expread.y"
+{ write_exp_elt_opcode (OP_STRING);
+			  write_exp_string (yyvsp[0].sval);
+			  write_exp_elt_opcode (OP_STRING); ;
+    break;}
+case 59:
+#line 463 "expread.y"
+{ write_exp_elt_opcode (OP_THIS);
+			  write_exp_elt_opcode (OP_THIS); ;
+    break;}
+case 60:
+#line 470 "expread.y"
+{
+			  struct symtab *tem = lookup_symtab (copy_name (yyvsp[0].sval));
+			  struct symbol *sym;
+			  
+			  if (tem)
+			    yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
+			  else
+			    {
+			      sym = lookup_symbol (copy_name (yyvsp[0].sval),
+						   expression_context_block,
+						   VAR_NAMESPACE, 0);
+			      if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+				yyval.bval = SYMBOL_BLOCK_VALUE (sym);
+			      else
+				error ("No file or function \"%s\".",
+				       copy_name (yyvsp[0].sval));
+			    }
+			;
+    break;}
+case 61:
+#line 491 "expread.y"
+{ struct symbol *tem
+			    = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, VAR_NAMESPACE, 0);
+			  if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
+			    error ("No function \"%s\" in specified context.",
+				   copy_name (yyvsp[0].sval));
+			  yyval.bval = SYMBOL_BLOCK_VALUE (tem); ;
+    break;}
+case 62:
+#line 500 "expread.y"
+{ struct symbol *sym;
+			  sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, VAR_NAMESPACE, 0);
+			  if (sym == 0)
+			    error ("No symbol \"%s\" in specified context.",
+				   copy_name (yyvsp[0].sval));
+			  write_exp_elt_opcode (OP_VAR_VALUE);
+			  write_exp_elt_sym (sym);
+			  write_exp_elt_opcode (OP_VAR_VALUE); ;
+    break;}
+case 63:
+#line 511 "expread.y"
+{
+			  struct type *type = yyvsp[-2].tval;
+			  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+			      && TYPE_CODE (type) != TYPE_CODE_UNION)
+			    error ("`%s' is not defined as an aggregate type.",
+				   TYPE_NAME (type));
+
+			  write_exp_elt_opcode (OP_SCOPE);
+			  write_exp_elt_type (type);
+			  write_exp_string (yyvsp[0].sval);
+			  write_exp_elt_opcode (OP_SCOPE);
+			;
+    break;}
+case 64:
+#line 524 "expread.y"
+{
+			  char *name = copy_name (yyvsp[0].sval);
+			  struct symbol *sym;
+			  int i;
+
+			  sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0);
+			  if (sym)
+			    {
+			      write_exp_elt_opcode (OP_VAR_VALUE);
+			      write_exp_elt_sym (sym);
+			      write_exp_elt_opcode (OP_VAR_VALUE);
+			      break;
+			    }
+			  for (i = 0; i < misc_function_count; i++)
+			    if (!strcmp (misc_function_vector[i].name, name))
+			      break;
+
+			  if (i < misc_function_count)
+			    {
+			      enum misc_function_type mft =
+				(enum misc_function_type)
+				  misc_function_vector[i].type;
+			      
+			      write_exp_elt_opcode (OP_LONG);
+			      write_exp_elt_type (builtin_type_int);
+			      write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+			      write_exp_elt_opcode (OP_LONG);
+			      write_exp_elt_opcode (UNOP_MEMVAL);
+			      if (mft == mf_data || mft == mf_bss)
+				write_exp_elt_type (builtin_type_int);
+			      else if (mft == mf_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);
+			    }
+			  else
+			    if (symtab_list == 0
+				&& partial_symtab_list == 0)
+			      error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+			    else
+			      error ("No symbol \"%s\" in current context.", name);
+			;
+    break;}
+case 65:
+#line 570 "expread.y"
+{ struct symbol *sym;
+			  int is_a_field_of_this;
+
+			  sym = lookup_symbol (copy_name (yyvsp[0].sval),
+					       expression_context_block,
+					       VAR_NAMESPACE,
+					       &is_a_field_of_this);
+			  if (sym)
+			    {
+			      switch (sym->class)
+				{
+				case LOC_REGISTER:
+				case LOC_ARG:
+				case LOC_LOCAL:
+				  if (innermost_block == 0 ||
+				      contained_in (block_found, 
+						    innermost_block))
+				    innermost_block = block_found;
+				}
+			      write_exp_elt_opcode (OP_VAR_VALUE);
+			      write_exp_elt_sym (sym);
+			      write_exp_elt_opcode (OP_VAR_VALUE);
+			    }
+			  else if (is_a_field_of_this)
+			    {
+			      /* C++: it hangs off of `this'.  Must
+			         not inadvertently convert from a method call
+				 to data ref.  */
+			      if (innermost_block == 0 || 
+				  contained_in (block_found, innermost_block))
+				innermost_block = block_found;
+			      write_exp_elt_opcode (OP_THIS);
+			      write_exp_elt_opcode (OP_THIS);
+			      write_exp_elt_opcode (STRUCTOP_PTR);
+			      write_exp_string (yyvsp[0].sval);
+			      write_exp_elt_opcode (STRUCTOP_PTR);
+			    }
+			  else
+			    {
+			      register int i;
+			      register char *arg = copy_name (yyvsp[0].sval);
+
+			      for (i = 0; i < misc_function_count; i++)
+				if (!strcmp (misc_function_vector[i].name, arg))
+				  break;
+
+			      if (i < misc_function_count)
+				{
+				  enum misc_function_type mft =
+				    (enum misc_function_type)
+				      misc_function_vector[i].type;
+				  
+				  write_exp_elt_opcode (OP_LONG);
+				  write_exp_elt_type (builtin_type_int);
+				  write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+				  write_exp_elt_opcode (OP_LONG);
+				  write_exp_elt_opcode (UNOP_MEMVAL);
+				  if (mft == mf_data || mft == mf_bss)
+				    write_exp_elt_type (builtin_type_int);
+				  else if (mft == mf_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);
+				}
+			      else if (symtab_list == 0
+				       && partial_symtab_list == 0)
+				error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+			      else
+				error ("No symbol \"%s\" in current context.",
+				       copy_name (yyvsp[0].sval));
+			    }
+			;
+    break;}
+case 67:
+#line 648 "expread.y"
+{
+		  /* This is where the interesting stuff happens.  */
+		  int done = 0;
+		  int array_size;
+		  struct type *follow_type = yyvsp[-1].tval;
+		  
+		  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 = (int) pop_type ();
+			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;
+		      }
+		  yyval.tval = follow_type;
+		;
+    break;}
+case 68:
+#line 683 "expread.y"
+{ push_type (tp_pointer); yyval.voidval = 0; ;
+    break;}
+case 69:
+#line 685 "expread.y"
+{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; ;
+    break;}
+case 71:
+#line 690 "expread.y"
+{ yyval.voidval = yyvsp[-1].voidval; ;
+    break;}
+case 72:
+#line 692 "expread.y"
+{
+			  push_type ((enum type_pieces) yyvsp[0].lval);
+			  push_type (tp_array);
+			;
+    break;}
+case 73:
+#line 697 "expread.y"
+{
+			  push_type ((enum type_pieces) yyvsp[0].lval);
+			  push_type (tp_array);
+			  yyval.voidval = 0;
+			;
+    break;}
+case 74:
+#line 703 "expread.y"
+{ push_type (tp_function); ;
+    break;}
+case 75:
+#line 705 "expread.y"
+{ push_type (tp_function); ;
+    break;}
+case 76:
+#line 709 "expread.y"
+{ yyval.lval = -1; ;
+    break;}
+case 77:
+#line 711 "expread.y"
+{ yyval.lval = yyvsp[-1].lval; ;
+    break;}
+case 78:
+#line 715 "expread.y"
+{ yyval.voidval = 0; ;
+    break;}
+case 80:
+#line 720 "expread.y"
+{ yyval.tval = lookup_member_type (builtin_type_int, yyvsp[-2].tval); ;
+    break;}
+case 81:
+#line 722 "expread.y"
+{ yyval.tval = lookup_member_type (yyvsp[-5].tval, yyvsp[-3].tval); ;
+    break;}
+case 82:
+#line 724 "expread.y"
+{ yyval.tval = lookup_member_type
+			    (lookup_function_type (yyvsp[-7].tval), yyvsp[-5].tval); ;
+    break;}
+case 83:
+#line 727 "expread.y"
+{ yyval.tval = lookup_member_type
+			    (lookup_function_type (yyvsp[-8].tval), yyvsp[-6].tval);
+			  free (yyvsp[-1].tvec); ;
+    break;}
+case 84:
+#line 734 "expread.y"
+{ yyval.tval = lookup_typename (copy_name (yyvsp[0].sval),
+						expression_context_block, 0); ;
+    break;}
+case 85:
+#line 737 "expread.y"
+{ yyval.tval = builtin_type_int; ;
+    break;}
+case 86:
+#line 739 "expread.y"
+{ yyval.tval = builtin_type_long; ;
+    break;}
+case 87:
+#line 741 "expread.y"
+{ yyval.tval = builtin_type_short; ;
+    break;}
+case 88:
+#line 743 "expread.y"
+{ yyval.tval = builtin_type_long; ;
+    break;}
+case 89:
+#line 745 "expread.y"
+{ yyval.tval = builtin_type_unsigned_long; ;
+    break;}
+case 90:
+#line 747 "expread.y"
+{ yyval.tval = builtin_type_short; ;
+    break;}
+case 91:
+#line 749 "expread.y"
+{ yyval.tval = builtin_type_unsigned_short; ;
+    break;}
+case 92:
+#line 751 "expread.y"
+{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
+					      expression_context_block); ;
+    break;}
+case 93:
+#line 754 "expread.y"
+{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
+					     expression_context_block); ;
+    break;}
+case 94:
+#line 757 "expread.y"
+{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
+					    expression_context_block); ;
+    break;}
+case 95:
+#line 760 "expread.y"
+{ yyval.tval = lookup_unsigned_typename (copy_name (yyvsp[0].sval)); ;
+    break;}
+case 96:
+#line 762 "expread.y"
+{ yyval.tval = builtin_type_unsigned_int; ;
+    break;}
+case 97:
+#line 764 "expread.y"
+{ yyval.tval = lookup_typename (copy_name (yyvsp[0].sval),
+						expression_context_block, 0); ;
+    break;}
+case 98:
+#line 767 "expread.y"
+{ yyval.tval = builtin_type_int; ;
+    break;}
+case 100:
+#line 772 "expread.y"
+{
+		  yyval.sval.ptr = "int";
+		  yyval.sval.length = 3;
+		;
+    break;}
+case 101:
+#line 777 "expread.y"
+{
+		  yyval.sval.ptr = "long";
+		  yyval.sval.length = 4;
+		;
+    break;}
+case 102:
+#line 782 "expread.y"
+{
+		  yyval.sval.ptr = "short";
+		  yyval.sval.length = 5;
+		;
+    break;}
+case 103:
+#line 790 "expread.y"
+{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
+		  yyval.tvec[0] = (struct type *)0;
+		  yyval.tvec[1] = yyvsp[0].tval;
+		;
+    break;}
+case 104:
+#line 795 "expread.y"
+{ int len = sizeof (struct type *) * ++(yyvsp[-2].ivec[0]);
+		  yyval.tvec = (struct type **)xrealloc (yyvsp[-2].tvec, len);
+		  yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
+		;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+#line 331 "bison.simple"
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++yynerrs;
+      yyerror("parse error");
+    }
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
 #endif
-YYSTYPE yylval, yyval;
-# define YYERRCODE 256
 
-# line 630 "expread.y"
+  yystate = yyn;
+  goto yynewstate;
+}
+#line 810 "expread.y"
 
 
 /* Begin counting arguments for a function call,
@@ -268,7 +1709,7 @@ write_exp_string (str)
     }
   bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
   ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
-  write_exp_elt_longcst (len);
+  write_exp_elt_longcst ((LONGEST) len);
 }
 
 /* During parsing of a C expression, the pointer to the next character
@@ -306,11 +1747,12 @@ parse_number (olen)
      int olen;
 {
   register char *p = lexptr;
-  register long n = 0;
+  register LONGEST n = 0;
   register int c;
   register int base = 10;
   register int len = olen;
   char *err_copy;
+  int unsigned_p = 0;
 
   extern double atof ();
 
@@ -336,7 +1778,7 @@ parse_number (olen)
     {
       c = *p++;
       if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
-      if (c != 'l')
+      if (c != 'l' && c != 'u')
 	n *= base;
       if (c >= '0' && c <= '9')
 	n += c - '0';
@@ -346,6 +1788,16 @@ parse_number (olen)
 	    n += c - 'a' + 10;
 	  else if (len == 0 && c == 'l')
 	    ;
+	  else if (len == 0 && c == 'u')
+	    unsigned_p = 1;
+	  else if (base == 10 && len != 0 && (c == 'e' || c == 'E'))
+	    {
+	      /* Scientific notation, where we are unlucky enough not
+		 to have a '.' in the string.  */
+	      yylval.dval = atof (lexptr);
+	      lexptr += olen;
+	      return FLOAT;
+	    }
 	  else
 	    {
 	      err_copy = (char *) alloca (olen + 1);
@@ -357,8 +1809,16 @@ parse_number (olen)
     }
 
   lexptr = p;
-  yylval.lval = n;
-  return INT;
+  if (unsigned_p)
+    {
+      yylval.ulval = n;
+      return UINT;
+    }
+  else
+    {
+      yylval.lval = n;
+      return INT;
+    }
 }
 
 struct token
@@ -492,6 +1952,11 @@ yylex ()
       lexptr++;
       return c;
 
+    case '.':
+      /* Might be a floating point number.  */
+      if (lexptr[1] >= '0' && lexptr[1] <= '9')
+	break;			/* Falls into number code.  */
+
     case '+':
     case '-':
     case '*':
@@ -507,7 +1972,6 @@ yylex ()
     case '>':
     case '[':
     case ']':
-    case '.':
     case '?':
     case ':':
     case '=':
@@ -533,29 +1997,47 @@ yylex ()
       lexptr += namelen + 1;
       return STRING;
     }
-  if (c >= '0' && c <= '9')
+
+  /* Is it a number?  */
+  /* Note:  We have already dealt with the case of the token '.'.
+     See case '.' above.  */
+  if ((c >= '0' && c <= '9') || c == '.')
     {
-      /* It's a number */
-      for (namelen = 0;
-	   c = tokstart[namelen],
-	   (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
-	    || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
-	   namelen++)
-	;
-      return parse_number (namelen);
+      /* It's a number.  */
+      int got_dot = 0, got_e = 0;
+      register char *p = tokstart;
+      int hex = c == '0' && (p[1] == 'x' || p[1] == 'X');
+      if (hex)
+	p += 2;
+      for (;; ++p)
+	{
+	  if (!hex && !got_e && (*p == 'e' || *p == 'E'))
+	    got_dot = got_e = 1;
+	  else if (!hex && !got_dot && *p == '.')
+	    got_dot = 1;
+	  else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
+		   && (*p == '-' || *p == '+'))
+	    /* This is the sign of the exponent, not the end of the
+	       number.  */
+	    continue;
+	  else if (*p < '0' || *p > '9'
+		   && (!hex || ((*p < 'a' || *p > 'f')
+				&& (*p < 'A' || *p > 'F'))))
+	    break;
+	}
+      return parse_number (p - tokstart);
     }
 
   if (!(c == '_' || c == '$'
 	|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
     error ("Invalid token in expression.");
 
-  /* It is a name.  See how long it is.  */
-
-  for (namelen = 0;
-       c = tokstart[namelen],
+  /* It's a name.  See how long it is.  */
+  namelen = 0;
+  for (c = tokstart[namelen];
        (c == '_' || c == '$' || (c >= '0' && c <= '9')
 	|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
-       namelen++)
+       c = tokstart[++namelen])
     ;
 
   /* The token "if" terminates the expression and is NOT 
@@ -620,36 +2102,45 @@ yylex ()
 	 return REGNAME;
        }
   }
-  if (namelen == 6 && !strncmp (tokstart, "struct", 6))
-    {
-      return STRUCT;
-    }
-  if (namelen == 5)
+  /* Catch specific keywords.  Should be done with a data structure.  */
+  switch (namelen)
     {
+    case 8:
+      if (!strncmp (tokstart, "unsigned", 8))
+	return UNSIGNED;
+      break;
+    case 6:
+      if (!strncmp (tokstart, "struct", 6))
+	return STRUCT;
+      if (!strncmp (tokstart, "signed", 6))
+	return SIGNED;
+      if (!strncmp (tokstart, "sizeof", 6))      
+	return SIZEOF;
+      break;
+    case 5:
       if (!strncmp (tokstart, "union", 5))
-	{
-	  return UNION;
-	}
-    }
-  if (namelen == 4)
-    {
+	return UNION;
+      if (!strncmp (tokstart, "short", 5))
+	return SHORT;
+      break;
+    case 4:
       if (!strncmp (tokstart, "enum", 4))
-	{
-	  return ENUM;
-	}
+	return ENUM;
+      if (!strncmp (tokstart, "long", 4))
+	return LONG;
       if (!strncmp (tokstart, "this", 4)
 	  && lookup_symbol ("$this", expression_context_block,
 			    VAR_NAMESPACE, 0))
 	return THIS;
+      break;
+    case 3:
+      if (!strncmp (tokstart, "int", 3))
+	return INT_KEYWORD;
+      break;
+    default:
+      break;
     }
-  if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
-    {
-      return SIZEOF;
-    }
-  if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
-    {
-      return UNSIGNED;
-    }
+
   yylval.sval.ptr = tokstart;
   yylval.sval.length = namelen;
 
@@ -661,12 +2152,25 @@ yylex ()
       return VARIABLE;
     }
 
-  /* Use token-type TYPENAME for symbols that happen to be defined
+  /* Use token-type BLOCKNAME for symbols that happen to be defined as
+     functions or symtabs.  If this is not so, then ...
+     Use token-type TYPENAME for symbols that happen to be defined
      currently as names of types; NAME for other symbols.
      The caller is not constrained to care about the distinction.  */
-  if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
-    return TYPENAME;
-  return NAME;
+  {
+    char *tmp = copy_name (yylval.sval);
+    struct symbol *sym;
+
+    if (lookup_partial_symtab (tmp))
+      return BLOCKNAME;
+    sym = lookup_symbol (tmp, expression_context_block,
+			 VAR_NAMESPACE, 0);
+    if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+      return BLOCKNAME;
+    if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
+      return TYPENAME;
+    return NAME;
+  }
 }
 
 static void
@@ -929,6 +2433,7 @@ parse_c_1 (stringptr, block, comma)
   lexptr = *stringptr;
 
   paren_depth = 0;
+  type_stack_depth = 0;
 
   comma_terminates = comma;
 
@@ -973,720 +2478,33 @@ parse_c_expression (string)
     error ("Junk after end of expression.");
   return exp;
 }
-short yyexca[] ={
--1, 1,
-	0, -1,
-	-2, 0,
--1, 26,
-	268, 79,
-	-2, 64,
--1, 124,
-	268, 60,
-	-2, 61,
-	};
-# define YYNPROD 81
-# define YYLAST 696
-short yyact[]={
-
-  43,  54, 140,  39, 123,  41,  44, 120,  45,  37,
-  42,  78,  77,  73,  39,  29,  30,  31, 142,  32,
-  37, 131,  33,  52,  60,  53,  59,  40,  80,  81,
- 143, 148,  33, 135, 149,  43,  54,  59,  39, 135,
-  41,  44,  71,  45,  37,  42, 137, 129, 122, 138,
-  90,  33, 144,  92,  38,  23,  74,  55,  52,  60,
-  53,  59,  40, 146, 118,  38, 119,  88, 117,  17,
-  43,  54,   1,  39,   0,  41,  44,   0,  45,  37,
-  42, 128, 118,   0, 119,   0, 117,  56,   0,  38,
-   0,   0,  55,  52,   0,  53,  59,  40,   7,   0,
-   0,  75,   2,   5,   0,  13,   0,   4,   0,   0,
-   6,  43,  54, 115,  39,   0,  41,  44,   0,  45,
-  37,  42,  56,   0,  38,   0, 118,  55, 119, 132,
- 117,   0,   0,   0,  52,   0,  53,  59,  40,   7,
-  91,   0,   0,   0,   5,   0,  70,   0,   4,   0,
-   0,   6,   0,  43,  54,   0,  39,  56,  41,  44,
-   0,  45,  37,  42,   0,  38,   0,   0,  55, 116,
- 118,   0, 119, 121, 117,   0,  52,   0,  53,  59,
-  40,   0,   0,   0,   0,   0,   0, 147,  12,   0,
-   0,   8, 150,   0, 145,   0,  43,  54,  56,  39,
-   0,  41,  44,   0,  45,  37,  42,  38,   0,   0,
-  55,   0,   0,   0,   0,   0,   0,   0,   0,  52,
-   0,  53,  59,  40,   0,   0,   0,   0,   0,  12,
-  39,   0,   8,   0,   0,  61,  37,   0,  58,  57,
-  48,  49,  50,  51,  46,  47,   0,  34,  35,  36,
-  38,  80,  81,  59,  40,   0,   0,   0,  34,  35,
-  36,   0,  43,   0,   0,  39,   0,  41,  80,  81,
-  61,  37,  42,  58,  57,  48,  49,  50,  51,  46,
-  47,  38,  34,  35,  36,  80,  81,   0,  59,  40,
-   0,   0,   0,   0,  43,   0,   0,  39,   0,  41,
-  44,   0,  45,  37,  42,   0,   0,   0,   0,  57,
-  48,  49,  50,  51,  46,  47,  38,  34,  35,  36,
-  59,  40,  14,  15,  16,  26,  28,  21,  29,  30,
-  31,  11,  32,  25,  18,  19,  20,   0,  22,   0,
-   0,   0,   0,   0,   0,   0,   0,   0,  38,   9,
-  10,  48,  49,  50,  51,  46,  47,   0,  34,  35,
-  36,   0,   0,  14,  15,  16,  26,  28,  21,  29,
-  30,  31,  11,  32,  25,  18,  19,  20,  43,  22,
-   0,  39,   0,  41,  44,   0,  45,  37,  42,   0,
-   9,  10,   0,  48,  49,  50,  51,  46,  47,   0,
-  34,  35,  36,  43,  59,  40,  39,   0,  41,  44,
-  24,  45,  37,  42,  73,   0,  29,  30,  31,   0,
-  32,   0,   0,  72,  76,   0,  52,   0,  53,  59,
-  40,   0,  38,   0,   0,   0,  48,  49,  50,  51,
-  46,  47,   0,  34,  35,  36,  43,   0,   0,  39,
-   0,  41,  44,  27,  45,  37,  42,  38,   0,   0,
-   0,   0,   0,   0,   0,   0,   0,   0,   0,  52,
-   0,  53,  59,  40,  34,  35,  36,   0,   0,  79,
-   0,  76,   0,  82,  83,  84,  85,   0,   0,   0,
-  87,  89,   0,   0,   0,   0,   0,   0,   0,   0,
-  38,   0,   0,   0,   0,   0,   0,   0,   0,  34,
-  35,  36,   0,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
- 134, 124, 125,   0,   0,   0,   0,   0,  46,  47,
-   3,  34,  35,  36,   0,  62,  63,  64,  65,  66,
-  67,  68,  69,   0,   0,  72,   0,   0,   0,   0,
-  72,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,  86,   0,   0, 125,   0,   0,
-   0,  93,  94,  95,  96,  97,  98,  99, 100, 101,
- 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
- 112, 113, 114,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,   0,  34,  35,  36,   0, 126,
-   0, 127,   0, 130,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,  48,  49,  50,  51,  46,  47,   0,
-  34,  35,  36,   0,   0,   0,   0, 133,   0,   0,
-   0,   0, 136,   0,   0,   0,   0,   0,   0,   0,
-   0,   0, 139, 136,   0,   0,   0,   0,   0, 141,
-   0,   0,   0,   0,   0,   0,   0,   0,  50,  51,
-  46,  47,   0,  34,  35,  36 };
-short yypact[]={
-
-  65,-1000, -22,  -2,  65,  65,  65,  65,  65,  65,
-  65, 106,-248,  65,-1000,-1000,-1000,-1000,-1000,-1000,
--1000,-1000,-1000,-256,-257,-232,-1000,-1000,-1000,-232,
--232,-232,-232,  65,-1000,-1000,  25,   8,  65,-1000,
-  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,
-  65,  65,  65,  65,  65,  65,  65,  65,  65,  65,
-  65,  65, -26, -26, -26, -26, -26, -26, -26, -26,
-  65,  44,-261,-1000, 132,   7,-264,-232,-232,-1000,
--1000,-1000,-1000,-1000,-1000,-1000,  -2,-1000,  65,-1000,
-  65, -12,  65, -26, 190, 190, 190, 225, 225, 341,
- 341, 409, 409, 257, 257, 257, 257, 366, 159, 116,
-  74,  33, -37,  -2,  -2,  88,  65,-1000,-1000,-248,
-  -3,  65,-1000,  -9,-1000,-1000, 190, 190,-1000,   5,
-  -2,  65,  65, -26,-266,-1000, -26,-1000,  65,  -2,
- -24,  -2, -11,  12, 153,-1000, -10,  26,-1000,-248,
-  26 };
-short yypgo[]={
-
-   0, 540, 101,  72,  69,  42, 410,  63,  55, 453,
-  53,  47 };
-short yyr1[]={
-
-   0,   3,   2,   2,   1,   1,   1,   1,   1,   1,
-   1,   1,   1,   1,   1,   1,   1,   1,   1,  10,
-   1,  11,  11,  11,   1,   1,   1,   1,   1,   1,
-   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-   1,   1,   1,   1,   1,   1,   1,   1,   1,   8,
-   8,   4,   4,   4,   4,   5,   5,   5,   5,   5,
-   5,   5,   6,   6,   6,   6,   6,   7,   7,   9,
-   9 };
-short yyr2[]={
-
-   0,   1,   1,   3,   2,   2,   2,   2,   2,   2,
-   2,   2,   2,   2,   3,   4,   3,   4,   4,   0,
-   5,   0,   1,   3,   4,   4,   3,   3,   3,   3,
-   3,   3,   3,   3,   3,   3,   3,   3,   3,   3,
-   3,   3,   3,   3,   3,   3,   5,   3,   3,   1,
-   1,   1,   1,   1,   1,   1,   4,   1,   1,   1,
-   3,   3,   3,   2,   1,   1,   2,   2,   3,   6,
-   8,   9,   1,   2,   2,   2,   2,   1,   3,   1,
-   1 };
-short yychk[]={
-
--1000,  -3,  -2,  -1,  42,  38,  45,  33, 126, 284,
- 285, 266, 123,  40, 257, 258, 259,  -4, 269, 270,
- 271, 262, 273,  -8,  -6, 268, 260,  -9, 261, 263,
- 264, 265, 267,  44, 284, 285, 286,  46,  91,  40,
-  64,  42,  47,  37,  43,  45, 281, 282, 277, 278,
- 279, 280,  60,  62,  38,  94, 124, 276, 275,  63,
-  61, 272,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-  40,  -5,  -6, 261,  -5,  -2,  -6, 268, 268,  -9,
- 260, 261,  -9,  -9,  -9,  -9,  -1,  -9,  42,  -9,
-  42,  -2, -10,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
-  -1,  -1,  -1,  -1,  -1,  -5, 125,  42,  38,  40,
- 268,  41,  41, 268,  -9,  -9,  -1,  -1,  93, -11,
-  -1,  58,  41,  -1,  -6,  42,  -1,  41,  44,  -1,
- 268,  -1,  42,  41,  40,  41,  -7,  -5,  41,  44,
-  -5 };
-short yydef[]={
-
-   0,  -2,   1,   2,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,  49,  50,  51,  52,  53,  54,
-  55,  57,  58,   0,   0,   0,  -2,  59,  72,   0,
-   0,   0,   0,   0,  11,  12,   0,   0,   0,  19,
-   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-   0,   0,   4,   5,   6,   7,   8,   9,  10,  13,
-   0,   0,  65,  72,   0,   0,  65,   0,   0,  63,
-  79,  80,  73,  74,  75,  76,   3,  14,   0,  16,
-   0,   0,  21,  27,  28,  29,  30,  31,  32,  33,
-  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-  44,  45,   0,  47,  48,   0,   0,  66,  67,   0,
-   0,   0,  26,   0,  -2,  62,  15,  17,  18,   0,
-  22,   0,  56,  24,   0,  68,  25,  20,   0,  46,
-   0,  23,   0,  69,   0,  70,   0,  77,  71,   0,
-  78 };
-#ifndef lint
-static	char yaccpar_sccsid[] = "@(#)yaccpar 1.5 86/08/27 SMI"; /* from UCB 4.1 83/02/11 */
-#endif
-
-#
-# define YYFLAG -1000
-# define YYERROR goto yyerrlab
-# define YYACCEPT return(0)
-# define YYABORT return(1)
-
-/*	parser for yacc output	*/
-
-#ifdef YYDEBUG
-int yydebug = 0; /* 1 for debugging */
-#endif
-YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
-int yychar = -1; /* current input token number */
-int yynerrs = 0;  /* number of errors */
-short yyerrflag = 0;  /* error recovery flag */
-
-yyparse() {
-
-	short yys[YYMAXDEPTH];
-	short yyj, yym;
-	register YYSTYPE *yypvt;
-	register short yystate, *yyps, yyn;
-	register YYSTYPE *yypv;
-	register short *yyxi;
-
-	yystate = 0;
-	yychar = -1;
-	yynerrs = 0;
-	yyerrflag = 0;
-	yyps= &yys[-1];
-	yypv= &yyv[-1];
-
- yystack:    /* put a state and value onto the stack */
-
-#ifdef YYDEBUG
-	if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
-#endif
-		if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
-		*yyps = yystate;
-		++yypv;
-		*yypv = yyval;
-
- yynewstate:
-
-	yyn = yypact[yystate];
-
-	if( yyn<= YYFLAG ) goto yydefault; /* simple state */
-
-	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
-	if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
-
-	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
-		yychar = -1;
-		yyval = yylval;
-		yystate = yyn;
-		if( yyerrflag > 0 ) --yyerrflag;
-		goto yystack;
-		}
-
- yydefault:
-	/* default state action */
-
-	if( (yyn=yydef[yystate]) == -2 ) {
-		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
-		/* look through exception table */
-
-		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
-
-		while( *(yyxi+=2) >= 0 ){
-			if( *yyxi == yychar ) break;
-			}
-		if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
-		}
-
-	if( yyn == 0 ){ /* error */
-		/* error ... attempt to resume parsing */
-
-		switch( yyerrflag ){
-
-		case 0:   /* brand new error */
-
-			yyerror( "syntax error" );
-		yyerrlab:
-			++yynerrs;
-
-		case 1:
-		case 2: /* incompletely recovered error ... try again */
-
-			yyerrflag = 3;
-
-			/* find a state where "error" is a legal shift action */
-
-			while ( yyps >= yys ) {
-			   yyn = yypact[*yyps] + YYERRCODE;
-			   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
-			      yystate = yyact[yyn];  /* simulate a shift of "error" */
-			      goto yystack;
-			      }
-			   yyn = yypact[*yyps];
-
-			   /* the current yyps has no shift onn "error", pop stack */
-
-#ifdef YYDEBUG
-			   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
-#endif
-			   --yyps;
-			   --yypv;
-			   }
-
-			/* there is no state on the stack with an error shift ... abort */
-
-	yyabort:
-			return(1);
-
-
-		case 3:  /* no shift yet; clobber input char */
-
-#ifdef YYDEBUG
-			if( yydebug ) printf( "error recovery discards char %d\n", yychar );
-#endif
-
-			if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
-			yychar = -1;
-			goto yynewstate;   /* try again in the same state */
-
-			}
 
-		}
-
-	/* reduction by production yyn */
-
-#ifdef YYDEBUG
-		if( yydebug ) printf("reduce %d\n",yyn);
-#endif
-		yyps -= yyr2[yyn];
-		yypvt = yypv;
-		yypv -= yyr2[yyn];
-		yyval = yypv[1];
-		yym=yyn;
-			/* consult goto table to find next state */
-		yyn = yyr1[yyn];
-		yyj = yypgo[yyn] + *yyps + 1;
-		if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
-		switch(yym){
-			
-case 3:
-# line 165 "expread.y"
-{ write_exp_elt_opcode (BINOP_COMMA); } break;
-case 4:
-# line 170 "expread.y"
-{ write_exp_elt_opcode (UNOP_IND); } break;
-case 5:
-# line 173 "expread.y"
-{ write_exp_elt_opcode (UNOP_ADDR); } break;
-case 6:
-# line 176 "expread.y"
-{ write_exp_elt_opcode (UNOP_NEG); } break;
-case 7:
-# line 180 "expread.y"
-{ write_exp_elt_opcode (UNOP_ZEROP); } break;
-case 8:
-# line 184 "expread.y"
-{ write_exp_elt_opcode (UNOP_LOGNOT); } break;
-case 9:
-# line 188 "expread.y"
-{ write_exp_elt_opcode (UNOP_PREINCREMENT); } break;
-case 10:
-# line 192 "expread.y"
-{ write_exp_elt_opcode (UNOP_PREDECREMENT); } break;
-case 11:
-# line 196 "expread.y"
-{ write_exp_elt_opcode (UNOP_POSTINCREMENT); } break;
-case 12:
-# line 200 "expread.y"
-{ write_exp_elt_opcode (UNOP_POSTDECREMENT); } break;
-case 13:
-# line 204 "expread.y"
-{ write_exp_elt_opcode (UNOP_SIZEOF); } break;
-case 14:
-# line 208 "expread.y"
-{ write_exp_elt_opcode (STRUCTOP_PTR);
-			  write_exp_string (yypvt[-0].sval);
-			  write_exp_elt_opcode (STRUCTOP_PTR); } break;
-case 15:
-# line 214 "expread.y"
-{ write_exp_elt_opcode (STRUCTOP_MPTR); } break;
-case 16:
-# line 218 "expread.y"
-{ write_exp_elt_opcode (STRUCTOP_STRUCT);
-			  write_exp_string (yypvt[-0].sval);
-			  write_exp_elt_opcode (STRUCTOP_STRUCT); } break;
-case 17:
-# line 224 "expread.y"
-{ write_exp_elt_opcode (STRUCTOP_MEMBER); } break;
-case 18:
-# line 228 "expread.y"
-{ write_exp_elt_opcode (BINOP_SUBSCRIPT); } break;
-case 19:
-# line 234 "expread.y"
-{ start_arglist (); } break;
-case 20:
-# line 236 "expread.y"
-{ write_exp_elt_opcode (OP_FUNCALL);
-			  write_exp_elt_longcst (end_arglist ());
-			  write_exp_elt_opcode (OP_FUNCALL); } break;
-case 22:
-# line 245 "expread.y"
-{ arglist_len = 1; } break;
-case 23:
-# line 249 "expread.y"
-{ arglist_len++; } break;
-case 24:
-# line 253 "expread.y"
-{ write_exp_elt_opcode (UNOP_MEMVAL);
-			  write_exp_elt_type (yypvt[-2].tval);
-			  write_exp_elt_opcode (UNOP_MEMVAL); } break;
-case 25:
-# line 259 "expread.y"
-{ write_exp_elt_opcode (UNOP_CAST);
-			  write_exp_elt_type (yypvt[-2].tval);
-			  write_exp_elt_opcode (UNOP_CAST); } break;
-case 26:
-# line 265 "expread.y"
-{ } break;
-case 27:
-# line 271 "expread.y"
-{ write_exp_elt_opcode (BINOP_REPEAT); } break;
-case 28:
-# line 275 "expread.y"
-{ write_exp_elt_opcode (BINOP_MUL); } break;
-case 29:
-# line 279 "expread.y"
-{ write_exp_elt_opcode (BINOP_DIV); } break;
-case 30:
-# line 283 "expread.y"
-{ write_exp_elt_opcode (BINOP_REM); } break;
-case 31:
-# line 287 "expread.y"
-{ write_exp_elt_opcode (BINOP_ADD); } break;
-case 32:
-# line 291 "expread.y"
-{ write_exp_elt_opcode (BINOP_SUB); } break;
-case 33:
-# line 295 "expread.y"
-{ write_exp_elt_opcode (BINOP_LSH); } break;
-case 34:
-# line 299 "expread.y"
-{ write_exp_elt_opcode (BINOP_RSH); } break;
-case 35:
-# line 303 "expread.y"
-{ write_exp_elt_opcode (BINOP_EQUAL); } break;
-case 36:
-# line 307 "expread.y"
-{ write_exp_elt_opcode (BINOP_NOTEQUAL); } break;
-case 37:
-# line 311 "expread.y"
-{ write_exp_elt_opcode (BINOP_LEQ); } break;
-case 38:
-# line 315 "expread.y"
-{ write_exp_elt_opcode (BINOP_GEQ); } break;
-case 39:
-# line 319 "expread.y"
-{ write_exp_elt_opcode (BINOP_LESS); } break;
-case 40:
-# line 323 "expread.y"
-{ write_exp_elt_opcode (BINOP_GTR); } break;
-case 41:
-# line 327 "expread.y"
-{ write_exp_elt_opcode (BINOP_LOGAND); } break;
-case 42:
-# line 331 "expread.y"
-{ write_exp_elt_opcode (BINOP_LOGXOR); } break;
-case 43:
-# line 335 "expread.y"
-{ write_exp_elt_opcode (BINOP_LOGIOR); } break;
-case 44:
-# line 339 "expread.y"
-{ write_exp_elt_opcode (BINOP_AND); } break;
-case 45:
-# line 343 "expread.y"
-{ write_exp_elt_opcode (BINOP_OR); } break;
-case 46:
-# line 347 "expread.y"
-{ write_exp_elt_opcode (TERNOP_COND); } break;
-case 47:
-# line 351 "expread.y"
-{ write_exp_elt_opcode (BINOP_ASSIGN); } break;
-case 48:
-# line 355 "expread.y"
-{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
-			  write_exp_elt_opcode (yypvt[-1].opcode);
-			  write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } break;
-case 49:
-# line 361 "expread.y"
-{ write_exp_elt_opcode (OP_LONG);
-			  write_exp_elt_type (builtin_type_long);
-			  write_exp_elt_longcst (yypvt[-0].lval);
-			  write_exp_elt_opcode (OP_LONG); } break;
-case 50:
-# line 368 "expread.y"
-{ write_exp_elt_opcode (OP_LONG);
-			  write_exp_elt_type (builtin_type_char);
-			  write_exp_elt_longcst (yypvt[-0].lval);
-			  write_exp_elt_opcode (OP_LONG); } break;
-case 51:
-# line 375 "expread.y"
-{ write_exp_elt_opcode (OP_DOUBLE);
-			  write_exp_elt_type (builtin_type_double);
-			  write_exp_elt_dblcst (yypvt[-0].dval);
-			  write_exp_elt_opcode (OP_DOUBLE); } break;
-case 53:
-# line 385 "expread.y"
-{ write_exp_elt_opcode (OP_LAST);
-			  write_exp_elt_longcst (yypvt[-0].lval);
-			  write_exp_elt_opcode (OP_LAST); } break;
-case 54:
-# line 391 "expread.y"
-{ write_exp_elt_opcode (OP_REGISTER);
-			  write_exp_elt_longcst (yypvt[-0].lval);
-			  write_exp_elt_opcode (OP_REGISTER); } break;
-case 55:
-# line 397 "expread.y"
-{ write_exp_elt_opcode (OP_INTERNALVAR);
-			  write_exp_elt_intern (yypvt[-0].ivar);
-			  write_exp_elt_opcode (OP_INTERNALVAR); } break;
-case 56:
-# line 403 "expread.y"
-{ write_exp_elt_opcode (OP_LONG);
-			  write_exp_elt_type (builtin_type_int);
-			  write_exp_elt_longcst ((long) TYPE_LENGTH (yypvt[-1].tval));
-			  write_exp_elt_opcode (OP_LONG); } break;
-case 57:
-# line 410 "expread.y"
-{ write_exp_elt_opcode (OP_STRING);
-			  write_exp_string (yypvt[-0].sval);
-			  write_exp_elt_opcode (OP_STRING); } break;
-case 58:
-# line 417 "expread.y"
-{ write_exp_elt_opcode (OP_THIS);
-			  write_exp_elt_opcode (OP_THIS); } break;
-case 59:
-# line 424 "expread.y"
-{
-			  struct symtab *tem = lookup_symtab (copy_name (yypvt[-0].sval));
-			  struct symbol *sym;
-			  
-			  if (tem)
-			    yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
-			  else
-			    {
-			      sym = lookup_symbol (copy_name (yypvt[-0].sval),
-						   expression_context_block,
-						   VAR_NAMESPACE, 0);
-			      if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
-				yyval.bval = SYMBOL_BLOCK_VALUE (sym);
-			      else
-				error ("No file or function \"%s\".",
-				       copy_name (yypvt[-0].sval));
-			    }
-			} break;
-case 60:
-# line 445 "expread.y"
-{ struct symbol *tem
-			    = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE, 0);
-			  if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
-			    error ("No function \"%s\" in specified context.",
-				   copy_name (yypvt[-0].sval));
-			  yyval.bval = SYMBOL_BLOCK_VALUE (tem); } break;
-case 61:
-# line 454 "expread.y"
-{ struct symbol *sym;
-			  sym = lookup_symbol (copy_name (yypvt[-0].sval), yypvt[-2].bval, VAR_NAMESPACE, 0);
-			  if (sym == 0)
-			    error ("No symbol \"%s\" in specified context.",
-				   copy_name (yypvt[-0].sval));
-			  write_exp_elt_opcode (OP_VAR_VALUE);
-			  write_exp_elt_sym (sym);
-			  write_exp_elt_opcode (OP_VAR_VALUE); } break;
-case 62:
-# line 465 "expread.y"
+static void 
+push_type (tp)
+     enum type_pieces tp;
 {
-			  struct type *type = yypvt[-2].tval;
-			  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
-			      && TYPE_CODE (type) != TYPE_CODE_UNION)
-			    error ("`%s' is not defined as an aggregate type.",
-				   TYPE_NAME (type));
+  if (type_stack_depth == type_stack_size)
+    {
+      type_stack_size *= 2;
+      type_stack = (enum type_pieces *)
+	xrealloc (type_stack, type_stack_size * sizeof (enum type_pieces));
+    }
+  type_stack[type_stack_depth++] = tp;
+}
 
-			  write_exp_elt_opcode (OP_SCOPE);
-			  write_exp_elt_type (type);
-			  write_exp_string (yypvt[-0].sval);
-			  write_exp_elt_opcode (OP_SCOPE);
-			} break;
-case 63:
-# line 478 "expread.y"
+static enum type_pieces 
+pop_type ()
 {
-			  char *name = copy_name (yypvt[-0].sval);
-			  struct symbol *sym;
-			  int i;
-
-			  sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0);
-			  if (sym)
-			    {
-			      write_exp_elt_opcode (OP_VAR_VALUE);
-			      write_exp_elt_sym (sym);
-			      write_exp_elt_opcode (OP_VAR_VALUE);
-			      break;
-			    }
-			  for (i = 0; i < misc_function_count; i++)
-			    if (!strcmp (misc_function_vector[i].name, name))
-			      break;
-
-			  if (i < misc_function_count)
-			    {
-			      write_exp_elt_opcode (OP_LONG);
-			      write_exp_elt_type (builtin_type_int);
-			      write_exp_elt_longcst (misc_function_vector[i].address);
-			      write_exp_elt_opcode (OP_LONG);
-			      write_exp_elt_opcode (UNOP_MEMVAL);
-			      write_exp_elt_type (builtin_type_char);
-			      write_exp_elt_opcode (UNOP_MEMVAL);
-			    }
-			  else
-			    if (symtab_list == 0
-				&& partial_symtab_list == 0)
-			      error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
-			    else
-			      error ("No symbol \"%s\" in current context.", name);
-			} break;
-case 64:
-# line 515 "expread.y"
-{ struct symbol *sym;
-			  int is_a_field_of_this;
-
-			  sym = lookup_symbol (copy_name (yypvt[-0].sval),
-					       expression_context_block,
-					       VAR_NAMESPACE,
-					       &is_a_field_of_this);
-			  if (sym)
-			    {
-			      switch (sym->class)
-				{
-				case LOC_REGISTER:
-				case LOC_ARG:
-				case LOC_LOCAL:
-				  if (innermost_block == 0 ||
-				      contained_in (block_found, 
-						    innermost_block))
-				    innermost_block = block_found;
-				}
-			      write_exp_elt_opcode (OP_VAR_VALUE);
-			      write_exp_elt_sym (sym);
-			      write_exp_elt_opcode (OP_VAR_VALUE);
-			    }
-			  else if (is_a_field_of_this)
-			    {
-			      /* C++: it hangs off of `this'.  Must
-			         not inadvertently convert from a method call
-				 to data ref.  */
-			      if (innermost_block == 0 || 
-				  contained_in (block_found, innermost_block))
-				innermost_block = block_found;
-			      write_exp_elt_opcode (OP_THIS);
-			      write_exp_elt_opcode (OP_THIS);
-			      write_exp_elt_opcode (STRUCTOP_PTR);
-			      write_exp_string (yypvt[-0].sval);
-			      write_exp_elt_opcode (STRUCTOP_PTR);
-			    }
-			  else
-			    {
-			      register int i;
-			      register char *arg = copy_name (yypvt[-0].sval);
-
-			      for (i = 0; i < misc_function_count; i++)
-				if (!strcmp (misc_function_vector[i].name, arg))
-				  break;
-
-			      if (i < misc_function_count)
-				{
-				  write_exp_elt_opcode (OP_LONG);
-				  write_exp_elt_type (builtin_type_int);
-				  write_exp_elt_longcst (misc_function_vector[i].address);
-				  write_exp_elt_opcode (OP_LONG);
-				  write_exp_elt_opcode (UNOP_MEMVAL);
-				  write_exp_elt_type (builtin_type_char);
-				  write_exp_elt_opcode (UNOP_MEMVAL);
-				}
-			      else if (symtab_list == 0
-				       && partial_symtab_list == 0)
-				error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
-			      else
-				error ("No symbol \"%s\" in current context.",
-				       copy_name (yypvt[-0].sval));
-			    }
-			} break;
-case 66:
-# line 583 "expread.y"
-{ yyval.tval = lookup_pointer_type (yypvt[-1].tval); } break;
-case 67:
-# line 585 "expread.y"
-{ yyval.tval = lookup_reference_type (yypvt[-1].tval); } break;
-case 68:
-# line 587 "expread.y"
-{ yyval.tval = lookup_member_type (builtin_type_int, yypvt[-2].tval); } break;
-case 69:
-# line 589 "expread.y"
-{ yyval.tval = lookup_member_type (yypvt[-5].tval, yypvt[-3].tval); } break;
-case 70:
-# line 591 "expread.y"
-{ yyval.tval = lookup_member_type (lookup_function_type (yypvt[-7].tval)); } break;
-case 71:
-# line 593 "expread.y"
-{ yyval.tval = lookup_member_type (lookup_function_type (yypvt[-8].tval));
-			  free (yypvt[-1].tvec); } break;
-case 72:
-# line 599 "expread.y"
-{ yyval.tval = lookup_typename (copy_name (yypvt[-0].sval),
-						expression_context_block, 0); } break;
-case 73:
-# line 602 "expread.y"
-{ yyval.tval = lookup_struct (copy_name (yypvt[-0].sval),
-					      expression_context_block); } break;
-case 74:
-# line 605 "expread.y"
-{ yyval.tval = lookup_union (copy_name (yypvt[-0].sval),
-					     expression_context_block); } break;
-case 75:
-# line 608 "expread.y"
-{ yyval.tval = lookup_enum (copy_name (yypvt[-0].sval),
-					    expression_context_block); } break;
-case 76:
-# line 611 "expread.y"
-{ yyval.tval = lookup_unsigned_typename (copy_name (yypvt[-0].sval)); } break;
-case 77:
-# line 616 "expread.y"
-{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
-		  yyval.tvec[0] = (struct type *)0;
-		  yyval.tvec[1] = yypvt[-0].tval;
-		} break;
-case 78:
-# line 621 "expread.y"
-{ int len = sizeof (struct type *) * ++(yypvt[-2].ivec[0]);
-		  yyval.tvec = (struct type **)xrealloc (yypvt[-2].tvec, len);
-		  yyval.tvec[yyval.ivec[0]] = yypvt[-0].tval;
-		} break;
-		}
-		goto yystack;  /* stack new state and value */
+  if (type_stack_depth)
+    return type_stack[--type_stack_depth];
+  return tp_end;
+}
 
-	}
+void
+_initialize_expread ()
+{
+  type_stack_size = 80;
+  type_stack_depth = 0;
+  type_stack = (enum type_pieces *)
+    xmalloc (type_stack_size * sizeof (enum type_pieces));
+}