gdb/expread.tab.c

   1
   2 /*  A Bison parser, made from ./expread.y  */
   3
   4 #define INT     258
   5 #define CHAR    259
   6 #define UINT    260
   7 #define FLOAT   261
   8 #define STRING  262
   9 #define NAME    263
  10 #define BLOCKNAME       264
  11 #define TYPENAME        265
  12 #define NAME_OR_INT     266
  13 #define NAME_OR_UINT    267
  14 #define STRUCT  268
  15 #define UNION   269
  16 #define ENUM    270
  17 #define SIZEOF  271
  18 #define UNSIGNED        272
  19 #define COLONCOLON      273
  20 #define ERROR   274
  21 #define SIGNED  275
  22 #define LONG    276
  23 #define SHORT   277
  24 #define INT_KEYWORD     278
  25 #define LAST    279
  26 #define REGNAME 280
  27 #define VARIABLE        281
  28 #define ASSIGN_MODIFY   282
  29 #define THIS    283
  30 #define ABOVE_COMMA     284
  31 #define OR      285
  32 #define AND     286
  33 #define EQUAL   287
  34 #define NOTEQUAL        288
  35 #define LEQ     289
  36 #define GEQ     290
  37 #define LSH     291
  38 #define RSH     292
  39 #define UNARY   293
  40 #define INCREMENT       294
  41 #define DECREMENT       295
  42 #define ARROW   296
  43
  44 #line 29 "./expread.y"
  45
  46 #include <stdio.h>
  47 #include "defs.h"
  48 #include "param.h"
  49 #include "symtab.h"
  50 #include "frame.h"
  51 #include "expression.h"
  52 #include "value.h"
  53 #include "command.h"
  54
  55 static struct expression *expout;
  56 static int expout_size;
  57 static int expout_ptr;
  58
  59 static int yylex ();
  60 static void yyerror ();
  61 static void write_exp_elt ();
  62 static void write_exp_elt_opcode ();
  63 static void write_exp_elt_sym ();
  64 static void write_exp_elt_longcst ();
  65 static void write_exp_elt_dblcst ();
  66 static void write_exp_elt_type ();
  67 static void write_exp_elt_intern ();
  68 static void write_exp_string ();
  69 static void start_arglist ();
  70 static int end_arglist ();
  71 static void free_funcalls ();
  72 static char *copy_name ();
  73 static int parse_number ();
  74
  75 /* If this is nonzero, this block is used as the lexical context
  76    for symbol names.  */
  77
  78 static struct block *expression_context_block;
  79
  80 /* The innermost context required by the stack and register variables
  81    we've encountered so far. */
  82 struct block *innermost_block;
  83
  84 /* The block in which the most recently discovered symbol was found. */
  85 struct block *block_found;
  86
  87 /* Number of arguments seen so far in innermost function call.  */
  88 static int arglist_len;
  89
  90 /* Data structure for saving values of arglist_len
  91    for function calls whose arguments contain other function calls.  */
  92
  93 struct funcall
  94   {
  95     struct funcall *next;
  96     int arglist_len;
  97   };
  98
  99 struct funcall *funcall_chain;
 100
 101 /* This kind of datum is used to represent the name
 102    of a symbol token.  */
 103
 104 struct stoken
 105   {
 106     char *ptr;
 107     int length;
 108   };
 109
 110 struct ttype
 111   {
 112     struct stoken stoken;
 113     struct type *type;
 114   };
 115
 116 struct symtoken
 117   {
 118     struct stoken stoken;
 119     struct symbol *sym;
 120     int is_a_field_of_this;
 121   };
 122
 123 /* For parsing of complicated types.
 124    An array should be preceded in the list by the size of the array.  */
 125 enum type_pieces
 126   {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
 127 /* The stack can contain either an enum type_pieces or an int.  */
 128 union type_stack_elt {
 129   enum type_pieces piece;
 130   int int_val;
 131 };
 132 static union type_stack_elt *type_stack;
 133 static int type_stack_depth, type_stack_size;
 134
 135 static void push_type ();
 136 static void push_type_int ();
 137 static enum type_pieces pop_type ();
 138 static int pop_type_int ();
 139
 140 /* Allow debugging of parsing.  */
 141 #define YYDEBUG 1
 142
 143 #line 132 "./expread.y"
 144 typedef union
 145   {
 146     LONGEST lval;
 147     unsigned LONGEST ulval;
 148     double dval;
 149     struct symbol *sym;
 150     struct type *tval;
 151     struct stoken sval;
 152     struct ttype tsym;
 153     struct symtoken ssym;
 154     int voidval;
 155     struct block *bval;
 156     enum exp_opcode opcode;
 157     struct internalvar *ivar;
 158
 159     struct type **tvec;
 160     int *ivec;
 161   } YYSTYPE;
 162
 163 #ifndef YYLTYPE
 164 typedef
 165   struct yyltype
 166     {
 167       int timestamp;
 168       int first_line;
 169       int first_column;
 170       int last_line;
 171       int last_column;
 172       char *text;
 173    }
 174   yyltype;
 175
 176 #define YYLTYPE yyltype
 177 #endif
 178
 179 #include <stdio.h>
 180
 181 #ifndef __STDC__
 182 #define const
 183 #endif
 184
 185
 186
 187 #define YYFINAL         197
 188 #define YYFLAG          -32768
 189 #define YYNTBASE        66
 190
 191 #define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 84)
 192
 193 static const char yytranslate[] = {     0,
 194      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 195      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 196      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 197      2,     2,    59,     2,     2,     2,    51,    37,     2,    58,
 198     62,    49,    47,    29,    48,    56,    50,     2,     2,     2,
 199      2,     2,     2,     2,     2,     2,     2,    65,     2,    40,
 200     31,    41,    32,    46,     2,     2,     2,     2,     2,     2,
 201      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 202      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 203     57,     2,    61,    36,     2,     2,     2,     2,     2,     2,
 204      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 205      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 206      2,     2,    63,    35,    64,    60,     2,     2,     2,     2,
 207      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 208      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 209      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 210      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 211      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 212      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 213      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 214      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 215      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 216      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 217      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 218      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 219      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
 220      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
 221     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
 222     26,    27,    28,    30,    33,    34,    38,    39,    42,    43,
 223     44,    45,    52,    53,    54,    55
 224 };
 225
 226 static const short yyprhs[] = {     0,
 227      0,     2,     4,     8,    11,    14,    17,    20,    23,    26,
 228     29,    32,    35,    38,    42,    47,    51,    56,    61,    62,
 229     68,    69,    71,    75,    80,    85,    89,    93,    97,   101,
 230    105,   109,   113,   117,   121,   125,   129,   133,   137,   141,
 231    145,   149,   153,   157,   161,   165,   171,   175,   179,   181,
 232    183,   185,   187,   189,   191,   193,   195,   197,   199,   204,
 233    206,   208,   210,   214,   218,   222,   227,   230,   232,   234,
 234    237,   239,   242,   244,   247,   249,   253,   256,   258,   261,
 235    263,   266,   270,   273,   275,   279,   286,   295,   305,   307,
 236    309,   311,   313,   316,   320,   323,   327,   331,   336,   339,
 237    343,   346,   349,   352,   355,   357,   360,   362,   364,   366,
 238    368,   370,   372,   376,   378,   380,   382,   384,   386,   388
 239 };
 240
 241 static const short yyrhs[] = {    67,
 242      0,    68,     0,    67,    29,    68,     0,    49,    68,     0,
 243     37,    68,     0,    48,    68,     0,    59,    68,     0,    60,
 244     68,     0,    53,    68,     0,    54,    68,     0,    68,    53,
 245      0,    68,    54,     0,    16,    68,     0,    68,    55,    82,
 246      0,    68,    55,    49,    68,     0,    68,    56,    82,     0,
 247     68,    56,    49,    68,     0,    68,    57,    67,    61,     0,
 248      0,    68,    58,    69,    70,    62,     0,     0,    68,     0,
 249     70,    29,    68,     0,    63,    78,    64,    68,     0,    58,
 250     78,    62,    68,     0,    58,    67,    62,     0,    68,    46,
 251     68,     0,    68,    49,    68,     0,    68,    50,    68,     0,
 252     68,    51,    68,     0,    68,    47,    68,     0,    68,    48,
 253     68,     0,    68,    44,    68,     0,    68,    45,    68,     0,
 254     68,    38,    68,     0,    68,    39,    68,     0,    68,    42,
 255     68,     0,    68,    43,    68,     0,    68,    40,    68,     0,
 256     68,    41,    68,     0,    68,    37,    68,     0,    68,    36,
 257     68,     0,    68,    35,    68,     0,    68,    34,    68,     0,
 258     68,    33,    68,     0,    68,    32,    68,    65,    68,     0,
 259     68,    31,    68,     0,    68,    27,    68,     0,     3,     0,
 260     11,     0,     5,     0,    12,     0,     4,     0,     6,     0,
 261     72,     0,    24,     0,    25,     0,    26,     0,    16,    58,
 262     78,    62,     0,     7,     0,    28,     0,     9,     0,    71,
 263     18,    82,     0,    71,    18,    82,     0,    79,    18,    82,
 264      0,    79,    18,    60,    82,     0,    18,    82,     0,    83,
 265      0,    79,     0,    79,    74,     0,    49,     0,    49,    74,
 266      0,    37,     0,    37,    74,     0,    75,     0,    58,    74,
 267     62,     0,    75,    76,     0,    76,     0,    75,    77,     0,
 268     77,     0,    57,    61,     0,    57,     3,    61,     0,    58,
 269     62,     0,    73,     0,    79,    18,    49,     0,    78,    58,
 270     79,    18,    49,    62,     0,    78,    58,    79,    18,    49,
 271     62,    58,    62,     0,    78,    58,    79,    18,    49,    62,
 272     58,    81,    62,     0,    10,     0,    23,     0,    21,     0,
 273     22,     0,    21,    23,     0,    17,    21,    23,     0,    21,
 274     21,     0,    21,    21,    23,     0,    17,    21,    21,     0,
 275     17,    21,    21,    23,     0,    22,    23,     0,    17,    22,
 276     23,     0,    13,    82,     0,    14,    82,     0,    15,    82,
 277      0,    17,    80,     0,    17,     0,    20,    80,     0,    20,
 278      0,    10,     0,    23,     0,    21,     0,    22,     0,    78,
 279      0,    81,    29,    78,     0,     8,     0,     9,     0,    10,
 280      0,    11,     0,    12,     0,     8,     0,     9,     0
 281 };
 282
 283 #if YYDEBUG != 0
 284 static const short yyrline[] = { 0,
 285    225,   229,   230,   235,   238,   241,   245,   249,   253,   257,
 286    261,   265,   269,   273,   279,   283,   289,   293,   297,   301,
 287    307,   310,   314,   318,   324,   330,   336,   340,   344,   348,
 288    352,   356,   360,   364,   368,   372,   376,   380,   384,   388,
 289    392,   396,   400,   404,   408,   412,   416,   420,   426,   436,
 290    449,   461,   474,   481,   488,   491,   497,   503,   509,   516,
 291    523,   530,   548,   558,   570,   583,   601,   647,   742,   743,
 292    778,   780,   782,   784,   786,   789,   791,   796,   802,   804,
 293    808,   810,   814,   818,   819,   821,   823,   826,   833,   835,
 294    837,   839,   841,   843,   845,   847,   849,   851,   853,   855,
 295    857,   860,   863,   866,   868,   870,   872,   876,   877,   883,
 296    889,   898,   903,   910,   911,   912,   913,   914,   917,   918
 297 };
 298
 299 static const char * const yytname[] = {   "$",
 300 "error","$illegal.","INT","CHAR","UINT","FLOAT","STRING","NAME","BLOCKNAME","TYPENAME",
 301 "NAME_OR_INT","NAME_OR_UINT","STRUCT","UNION","ENUM","SIZEOF","UNSIGNED","COLONCOLON","ERROR","SIGNED",
 302 "LONG","SHORT","INT_KEYWORD","LAST","REGNAME","VARIABLE","ASSIGN_MODIFY","THIS","','","ABOVE_COMMA",
 303 "'='","'?'","OR","AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'",
 304 "'>'","LEQ","GEQ","LSH","RSH","'@'","'+'","'-'","'*'","'/'",
 305 "'%'","UNARY","INCREMENT","DECREMENT","ARROW","'.'","'['","'('","'!'","'~'",
 306 "']'","')'","'{'","'}'","':'","start","exp1","exp","@1","arglist",
 307 "block","variable","ptype","abs_decl","direct_abs_decl","array_mod","func_mod","type","typebase","typename",
 308 "nonempty_typelist","name","name_not_typename",""
 309 };
 310 #endif
 311
 312 static const short yyr1[] = {     0,
 313     66,    67,    67,    68,    68,    68,    68,    68,    68,    68,
 314     68,    68,    68,    68,    68,    68,    68,    68,    69,    68,
 315     70,    70,    70,    68,    68,    68,    68,    68,    68,    68,
 316     68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
 317     68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
 318     68,    68,    68,    68,    68,    68,    68,    68,    68,    68,
 319     68,    71,    71,    72,    72,    72,    72,    72,    73,    73,
 320     74,    74,    74,    74,    74,    75,    75,    75,    75,    75,
 321     76,    76,    77,    78,    78,    78,    78,    78,    79,    79,
 322     79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
 323     79,    79,    79,    79,    79,    79,    79,    80,    80,    80,
 324     80,    81,    81,    82,    82,    82,    82,    82,    83,    83
 325 };
 326
 327 static const short yyr2[] = {     0,
 328      1,     1,     3,     2,     2,     2,     2,     2,     2,     2,
 329      2,     2,     2,     3,     4,     3,     4,     4,     0,     5,
 330      0,     1,     3,     4,     4,     3,     3,     3,     3,     3,
 331      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
 332      3,     3,     3,     3,     3,     5,     3,     3,     1,     1,
 333      1,     1,     1,     1,     1,     1,     1,     1,     4,     1,
 334      1,     1,     3,     3,     3,     4,     2,     1,     1,     2,
 335      1,     2,     1,     2,     1,     3,     2,     1,     2,     1,
 336      2,     3,     2,     1,     3,     6,     8,     9,     1,     1,
 337      1,     1,     2,     3,     2,     3,     3,     4,     2,     3,
 338      2,     2,     2,     2,     1,     2,     1,     1,     1,     1,
 339      1,     1,     3,     1,     1,     1,     1,     1,     1,     1
 340 };
 341
 342 static const short yydefact[] = {     0,
 343     49,    53,    51,    54,    60,   119,   120,    89,    50,    52,
 344      0,     0,     0,     0,   105,     0,   107,    91,    92,    90,
 345     56,    57,    58,    61,     0,     0,     0,     0,     0,     0,
 346      0,     0,     0,     1,     2,     0,    55,     0,    68,   114,
 347    115,   116,   117,   118,   101,   102,   103,     0,    13,   108,
 348    110,   111,   109,   104,    67,   110,   111,   106,    95,    93,
 349     99,     5,     6,     4,     9,    10,     0,    84,     0,    69,
 350      7,     8,     0,    69,     0,     0,     0,     0,     0,     0,
 351      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 352      0,     0,     0,     0,     0,     0,     0,    11,    12,     0,
 353      0,     0,    19,     0,     0,     0,    97,    94,   100,    96,
 354     26,     0,     0,     0,    73,    71,     0,     0,    70,    75,
 355     78,    80,     0,     0,     3,    48,    47,     0,    45,    44,
 356     43,    42,    41,    35,    36,    39,    40,    37,    38,    33,
 357     34,    27,    31,    32,    28,    29,    30,     0,    14,     0,
 358     16,     0,    21,    64,     0,    65,    59,    98,     0,    25,
 359     85,    74,    72,     0,    81,    83,     0,     0,    77,    79,
 360     24,     0,    15,    17,    18,    22,     0,    66,     0,    82,
 361     76,    46,     0,    20,     0,    23,    86,     0,    87,   112,
 362      0,     0,    88,   113,     0,     0,     0
 363 };
 364
 365 static const short yydefgoto[] = {   195,
 366     67,    35,   153,   177,    36,    37,    68,   119,   120,   121,
 367    122,    69,    38,    54,   191,   156,    39
 368 };
 369
 370 static const short yypact[] = {   167,
 371 -32768,-32768,-32768,-32768,-32768,-32768,     7,-32768,-32768,-32768,
 372     22,    22,    22,   228,   190,    22,   245,   119,    -7,-32768,
 373 -32768,-32768,-32768,-32768,   167,   167,   167,   167,   167,   167,
 374    167,   167,   528,    60,   303,    33,-32768,    76,-32768,-32768,
 375 -32768,-32768,-32768,-32768,-32768,-32768,-32768,   167,   216,-32768,
 376    134,    77,-32768,-32768,-32768,-32768,-32768,-32768,    78,-32768,
 377 -32768,   216,   216,   216,   216,   216,    59,-32768,   -52,    75,
 378    216,   216,   -55,    80,   167,   167,   167,   167,   167,   167,
 379    167,   167,   167,   167,   167,   167,   167,   167,   167,   167,
 380    167,   167,   167,   167,   167,   167,   167,-32768,-32768,   198,
 381    249,   167,-32768,    22,   138,   -34,    90,-32768,-32768,-32768,
 382 -32768,   528,   167,    96,   165,   165,    26,   104,-32768,   -50,
 383 -32768,-32768,   167,    47,   303,   303,   303,   268,   355,   379,
 384    402,   424,   445,   464,   464,   479,   479,   479,   479,   506,
 385    506,   518,   529,   529,   216,   216,   216,   167,-32768,   167,
 386 -32768,    -2,   167,    98,    22,-32768,    32,-32768,   113,   216,
 387 -32768,-32768,-32768,    62,-32768,-32768,    82,   106,-32768,-32768,
 388    216,   167,   216,   216,-32768,   303,    68,-32768,   137,-32768,
 389 -32768,   330,   167,-32768,   132,   303,   139,   105,-32768,   141,
 390     73,   528,-32768,   141,   196,   201,-32768
 391 };
 392
 393 static const short yypgoto[] = {-32768,
 394      1,   -14,-32768,-32768,-32768,-32768,-32768,    36,-32768,    83,
 395     85,   -29,   -28,   200,-32768,    10,-32768
 396 };
 397
 398
 399 #define YYLAST          587
 400
 401
 402 static const short yytable[] = {    49,
 403     34,    70,   112,    73,    74,   112,   117,   168,   123,   113,
 404     62,    63,    64,    65,    66,    61,    71,    72,   106,    70,
 405     45,    46,    47,   112,   -62,    55,    75,   157,   164,    40,
 406     41,    42,    43,    44,     1,     2,     3,     4,     5,     6,
 407      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 408    104,    17,    18,    19,    20,    21,    22,    23,   175,    24,
 409    125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
 410    135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
 411    145,   146,   147,   159,    28,    29,   165,    75,    75,    30,
 412     31,    32,   114,   105,    33,   161,   183,   124,   160,   109,
 413    110,   192,   152,    40,    41,    42,    43,    44,   171,   149,
 414    151,   115,   158,   154,     8,   -63,   115,    11,    12,    13,
 415    111,    15,   180,   116,    17,    18,    19,    20,   116,   184,
 416    179,   117,   118,   173,   193,   174,   117,   118,   176,    59,
 417    115,    60,   160,   181,   161,    40,    41,    42,    43,    44,
 418    162,   163,   116,   167,   107,   155,   108,   182,   190,    74,
 419    117,   118,   194,    74,   178,   166,   189,   166,   186,     1,
 420      2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
 421     12,    13,    14,    15,    16,   185,    17,    18,    19,    20,
 422     21,    22,    23,   187,    24,   196,   188,   155,   112,    50,
 423    197,   115,   169,    25,   170,    40,    41,    42,    43,    44,
 424     51,    52,    53,   116,    26,    27,    58,     0,     0,    28,
 425     29,   117,   118,     0,    30,    31,    32,     0,     0,    33,
 426      1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
 427     11,    12,    13,    14,    15,    16,   148,    17,    18,    19,
 428     20,    21,    22,    23,    50,    24,    40,    41,    42,    43,
 429     44,     0,     0,     0,    25,    56,    57,    53,    98,    99,
 430    100,   101,   102,   103,     0,    26,    27,     0,     0,     0,
 431     28,    29,     0,     0,     0,    48,    31,    32,     0,     0,
 432     33,     0,     0,     0,    76,     0,     0,   150,    77,    78,
 433     79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
 434     89,    90,    91,    92,    93,    94,    95,    96,    97,     0,
 435     98,    99,   100,   101,   102,   103,     0,     0,     0,    76,
 436      0,     0,   172,    77,    78,    79,    80,    81,    82,    83,
 437     84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
 438     94,    95,    96,    97,     0,    98,    99,   100,   101,   102,
 439    103,    78,    79,    80,    81,    82,    83,    84,    85,    86,
 440     87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
 441     97,     0,    98,    99,   100,   101,   102,   103,    80,    81,
 442     82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
 443     92,    93,    94,    95,    96,    97,     0,    98,    99,   100,
 444    101,   102,   103,    81,    82,    83,    84,    85,    86,    87,
 445     88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
 446      0,    98,    99,   100,   101,   102,   103,    82,    83,    84,
 447     85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
 448     95,    96,    97,     0,    98,    99,   100,   101,   102,   103,
 449     83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
 450     93,    94,    95,    96,    97,     0,    98,    99,   100,   101,
 451    102,   103,    84,    85,    86,    87,    88,    89,    90,    91,
 452     92,    93,    94,    95,    96,    97,     0,    98,    99,   100,
 453    101,   102,   103,    86,    87,    88,    89,    90,    91,    92,
 454     93,    94,    95,    96,    97,     0,    98,    99,   100,   101,
 455    102,   103,    90,    91,    92,    93,    94,    95,    96,    97,
 456      0,    98,    99,   100,   101,   102,   103,     8,     0,     0,
 457     11,    12,    13,     0,    15,     0,     0,    17,    18,    19,
 458     20,    92,    93,    94,    95,    96,    97,     0,    98,    99,
 459    100,   101,   102,   103,    93,    94,    95,    96,    97,     0,
 460     98,    99,   100,   101,   102,   103,     0,    95,    96,    97,
 461      0,    98,    99,   100,   101,   102,   103
 462 };
 463
 464 static const short yycheck[] = {    14,
 465      0,    30,    58,    33,    33,    58,    57,    58,    64,    62,
 466     25,    26,    27,    28,    29,    23,    31,    32,    48,    48,
 467     11,    12,    13,    58,    18,    16,    29,    62,     3,     8,
 468      9,    10,    11,    12,     3,     4,     5,     6,     7,     8,
 469      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
 470     18,    20,    21,    22,    23,    24,    25,    26,    61,    28,
 471     75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
 472     85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
 473     95,    96,    97,   112,    53,    54,    61,    29,    29,    58,
 474     59,    60,    18,    18,    63,    49,    29,    18,   113,    23,
 475     23,    29,   102,     8,     9,    10,    11,    12,   123,   100,
 476    101,    37,    23,   104,    10,    18,    37,    13,    14,    15,
 477     62,    17,    61,    49,    20,    21,    22,    23,    49,    62,
 478     18,    57,    58,   148,    62,   150,    57,    58,   153,    21,
 479     37,    23,   157,    62,    49,     8,     9,    10,    11,    12,
 480    115,   116,    49,   118,    21,    60,    23,   172,   188,   188,
 481     57,    58,   192,   192,   155,    62,    62,    62,   183,     3,
 482      4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
 483     14,    15,    16,    17,    18,    49,    20,    21,    22,    23,
 484     24,    25,    26,    62,    28,     0,    58,    60,    58,    10,
 485      0,    37,   120,    37,   120,     8,     9,    10,    11,    12,
 486     21,    22,    23,    49,    48,    49,    17,    -1,    -1,    53,
 487     54,    57,    58,    -1,    58,    59,    60,    -1,    -1,    63,
 488      3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
 489     13,    14,    15,    16,    17,    18,    49,    20,    21,    22,
 490     23,    24,    25,    26,    10,    28,     8,     9,    10,    11,
 491     12,    -1,    -1,    -1,    37,    21,    22,    23,    53,    54,
 492     55,    56,    57,    58,    -1,    48,    49,    -1,    -1,    -1,
 493     53,    54,    -1,    -1,    -1,    58,    59,    60,    -1,    -1,
 494     63,    -1,    -1,    -1,    27,    -1,    -1,    49,    31,    32,
 495     33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
 496     43,    44,    45,    46,    47,    48,    49,    50,    51,    -1,
 497     53,    54,    55,    56,    57,    58,    -1,    -1,    -1,    27,
 498     -1,    -1,    65,    31,    32,    33,    34,    35,    36,    37,
 499     38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
 500     48,    49,    50,    51,    -1,    53,    54,    55,    56,    57,
 501     58,    32,    33,    34,    35,    36,    37,    38,    39,    40,
 502     41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
 503     51,    -1,    53,    54,    55,    56,    57,    58,    34,    35,
 504     36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
 505     46,    47,    48,    49,    50,    51,    -1,    53,    54,    55,
 506     56,    57,    58,    35,    36,    37,    38,    39,    40,    41,
 507     42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
 508     -1,    53,    54,    55,    56,    57,    58,    36,    37,    38,
 509     39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
 510     49,    50,    51,    -1,    53,    54,    55,    56,    57,    58,
 511     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
 512     47,    48,    49,    50,    51,    -1,    53,    54,    55,    56,
 513     57,    58,    38,    39,    40,    41,    42,    43,    44,    45,
 514     46,    47,    48,    49,    50,    51,    -1,    53,    54,    55,
 515     56,    57,    58,    40,    41,    42,    43,    44,    45,    46,
 516     47,    48,    49,    50,    51,    -1,    53,    54,    55,    56,
 517     57,    58,    44,    45,    46,    47,    48,    49,    50,    51,
 518     -1,    53,    54,    55,    56,    57,    58,    10,    -1,    -1,
 519     13,    14,    15,    -1,    17,    -1,    -1,    20,    21,    22,
 520     23,    46,    47,    48,    49,    50,    51,    -1,    53,    54,
 521     55,    56,    57,    58,    47,    48,    49,    50,    51,    -1,
 522     53,    54,    55,    56,    57,    58,    -1,    49,    50,    51,
 523     -1,    53,    54,    55,    56,    57,    58
 524 };
 525 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 526 #line 3 "/usr/unsupported/lib/bison.simple"
 527
 528 /* Skeleton output parser for bison,
 529    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
 530
 531 This program is free software; you can redistribute it and/or modify
 532 it under the terms of the GNU General Public License as published by
 533 the Free Software Foundation; either version 2 of the License, or
 534 (at your option) any later version.
 535
 536 This program is distributed in the hope that it will be useful,
 537 but WITHOUT ANY WARRANTY; without even the implied warranty of
 538 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 539 GNU General Public License for more details.
 540
 541 You should have received a copy of the GNU General Public License
 542 along with this program; if not, write to the Free Software
 543 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 544
 545
 546 #ifndef alloca
 547 #ifdef __GNUC__
 548 #define alloca __builtin_alloca
 549 #else /* Not GNU C.  */
 550 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
 551 #include <alloca.h>
 552 #else /* Not sparc */
 553 #ifdef MSDOS
 554 #include <malloc.h>
 555 #endif /* MSDOS */
 556 #endif /* Not sparc.  */
 557 #endif /* Not GNU C.  */
 558 #endif /* alloca not defined.  */
 559
 560 /* This is the parser code that is written into each bison parser
 561   when the %semantic_parser declaration is not specified in the grammar.
 562   It was written by Richard Stallman by simplifying the hairy parser
 563   used when %semantic_parser is specified.  */
 564
 565 /* Note: there must be only one dollar sign in this file.
 566    It is replaced by the list of actions, each action
 567    as one case of the switch.  */
 568
 569 #define yyerrok         (yyerrstatus = 0)
 570 #define yyclearin       (yychar = YYEMPTY)
 571 #define YYEMPTY         -2
 572 #define YYEOF           0
 573 #define YYACCEPT        return(0)
 574 #define YYABORT         return(1)
 575 #define YYERROR         goto yyerrlab1
 576 /* Like YYERROR except do call yyerror.
 577    This remains here temporarily to ease the
 578    transition to the new meaning of YYERROR, for GCC.
 579    Once GCC version 2 has supplanted version 1, this can go.  */
 580 #define YYFAIL          goto yyerrlab
 581 #define YYRECOVERING()  (!!yyerrstatus)
 582 #define YYBACKUP(token, value) \
 583 do                                                              \
 584   if (yychar == YYEMPTY && yylen == 1)                          \
 585     { yychar = (token), yylval = (value);                       \
 586       yychar1 = YYTRANSLATE (yychar);                           \
 587       YYPOPSTACK;                                               \
 588       goto yybackup;                                            \
 589     }                                                           \
 590   else                                                          \
 591     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 592 while (0)
 593
 594 #define YYTERROR        1
 595 #define YYERRCODE       256
 596
 597 #ifndef YYPURE
 598 #define YYLEX           yylex()
 599 #endif
 600
 601 #ifdef YYPURE
 602 #ifdef YYLSP_NEEDED
 603 #define YYLEX           yylex(&yylval, &yylloc)
 604 #else
 605 #define YYLEX           yylex(&yylval)
 606 #endif
 607 #endif
 608
 609 /* If nonreentrant, generate the variables here */
 610
 611 #ifndef YYPURE
 612
 613 int     yychar;                 /*  the lookahead symbol                */
 614 YYSTYPE yylval;                 /*  the semantic value of the           */
 615                                 /*  lookahead symbol                    */
 616
 617 #ifdef YYLSP_NEEDED
 618 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 619                                 /*  symbol                              */
 620 #endif
 621
 622 int yynerrs;                    /*  number of parse errors so far       */
 623 #endif  /* not YYPURE */
 624
 625 #if YYDEBUG != 0
 626 int yydebug;                    /*  nonzero means print parse trace     */
 627 /* Since this is uninitialized, it does not stop multiple parsers
 628    from coexisting.  */
 629 #endif
 630
 631 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 632
 633 #ifndef YYINITDEPTH
 634 #define YYINITDEPTH 200
 635 #endif
 636
 637 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 638     (effective only if the built-in stack extension method is used).  */
 639
 640 #if YYMAXDEPTH == 0
 641 #undef YYMAXDEPTH
 642 #endif
 643
 644 #ifndef YYMAXDEPTH
 645 #define YYMAXDEPTH 10000
 646 #endif
 647 \f
 648 #ifndef __cplusplus
 649
 650 /* This is the most reliable way to avoid incompatibilities
 651    in available built-in functions on various systems.  */
 652 static void
 653 __yy_bcopy (from, to, count)
 654      char *from;
 655      char *to;
 656      int count;
 657 {
 658   register char *f = from;
 659   register char *t = to;
 660   register int i = count;
 661
 662   while (i-- > 0)
 663     *t++ = *f++;
 664 }
 665
 666 #else /* __cplusplus */
 667
 668 /* This is the most reliable way to avoid incompatibilities
 669    in available built-in functions on various systems.  */
 670 static void
 671 __yy_bcopy (char *from, char *to, int count)
 672 {
 673   register char *f = from;
 674   register char *t = to;
 675   register int i = count;
 676
 677   while (i-- > 0)
 678     *t++ = *f++;
 679 }
 680
 681 #endif
 682 \f
 683 #line 160 "/usr/unsupported/lib/bison.simple"
 684 int
 685 yyparse()
 686 {
 687   register int yystate;
 688   register int yyn;
 689   register short *yyssp;
 690   register YYSTYPE *yyvsp;
 691   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 692   int yychar1;          /*  lookahead token as an internal (translated) token number */
 693
 694   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 695   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 696
 697   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 698   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 699
 700 #ifdef YYLSP_NEEDED
 701   YYLTYPE *yyls = yylsa;
 702   YYLTYPE *yylsp;
 703   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 704
 705 #define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
 706 #else
 707 #define YYPOPSTACK   (yyvsp--, yysp--)
 708 #endif
 709
 710   int yystacksize = YYINITDEPTH;
 711
 712 #ifdef YYPURE
 713   int yychar;
 714   YYSTYPE yylval;
 715   int yynerrs;
 716 #ifdef YYLSP_NEEDED
 717   YYLTYPE yylloc;
 718 #endif
 719 #endif
 720
 721   YYSTYPE yyval;                /*  the variable used to return         */
 722                                 /*  semantic values from the action     */
 723                                 /*  routines                            */
 724
 725   int yylen;
 726
 727 #if YYDEBUG != 0
 728   if (yydebug)
 729     fprintf(stderr, "Starting parse\n");
 730 #endif
 731
 732   yystate = 0;
 733   yyerrstatus = 0;
 734   yynerrs = 0;
 735   yychar = YYEMPTY;             /* Cause a token to be read.  */
 736
 737   /* Initialize stack pointers.
 738      Waste one element of value and location stack
 739      so that they stay on the same level as the state stack.  */
 740
 741   yyssp = yyss - 1;
 742   yyvsp = yyvs;
 743 #ifdef YYLSP_NEEDED
 744   yylsp = yyls;
 745 #endif
 746
 747 /* Push a new state, which is found in  yystate  .  */
 748 /* In all cases, when you get here, the value and location stacks
 749    have just been pushed. so pushing a state here evens the stacks.  */
 750 yynewstate:
 751
 752   *++yyssp = yystate;
 753
 754   if (yyssp >= yyss + yystacksize - 1)
 755     {
 756       /* Give user a chance to reallocate the stack */
 757       /* Use copies of these so that the &'s don't force the real ones into memory. */
 758       YYSTYPE *yyvs1 = yyvs;
 759       short *yyss1 = yyss;
 760 #ifdef YYLSP_NEEDED
 761       YYLTYPE *yyls1 = yyls;
 762 #endif
 763
 764       /* Get the current used size of the three stacks, in elements.  */
 765       int size = yyssp - yyss + 1;
 766
 767 #ifdef yyoverflow
 768       /* Each stack pointer address is followed by the size of
 769          the data in use in that stack, in bytes.  */
 770       yyoverflow("parser stack overflow",
 771                  &yyss1, size * sizeof (*yyssp),
 772                  &yyvs1, size * sizeof (*yyvsp),
 773 #ifdef YYLSP_NEEDED
 774                  &yyls1, size * sizeof (*yylsp),
 775 #endif
 776                  &yystacksize);
 777
 778       yyss = yyss1; yyvs = yyvs1;
 779 #ifdef YYLSP_NEEDED
 780       yyls = yyls1;
 781 #endif
 782 #else /* no yyoverflow */
 783       /* Extend the stack our own way.  */
 784       if (yystacksize >= YYMAXDEPTH)
 785         {
 786           yyerror("parser stack overflow");
 787           return 2;
 788         }
 789       yystacksize *= 2;
 790       if (yystacksize > YYMAXDEPTH)
 791         yystacksize = YYMAXDEPTH;
 792       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
 793       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
 794       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
 795       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
 796 #ifdef YYLSP_NEEDED
 797       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
 798       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
 799 #endif
 800 #endif /* no yyoverflow */
 801
 802       yyssp = yyss + size - 1;
 803       yyvsp = yyvs + size - 1;
 804 #ifdef YYLSP_NEEDED
 805       yylsp = yyls + size - 1;
 806 #endif
 807
 808 #if YYDEBUG != 0
 809       if (yydebug)
 810         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 811 #endif
 812
 813       if (yyssp >= yyss + yystacksize - 1)
 814         YYABORT;
 815     }
 816
 817 #if YYDEBUG != 0
 818   if (yydebug)
 819     fprintf(stderr, "Entering state %d\n", yystate);
 820 #endif
 821
 822  yybackup:
 823
 824 /* Do appropriate processing given the current state.  */
 825 /* Read a lookahead token if we need one and don't already have one.  */
 826 /* yyresume: */
 827
 828   /* First try to decide what to do without reference to lookahead token.  */
 829
 830   yyn = yypact[yystate];
 831   if (yyn == YYFLAG)
 832     goto yydefault;
 833
 834   /* Not known => get a lookahead token if don't already have one.  */
 835
 836   /* yychar is either YYEMPTY or YYEOF
 837      or a valid token in external form.  */
 838
 839   if (yychar == YYEMPTY)
 840     {
 841 #if YYDEBUG != 0
 842       if (yydebug)
 843         fprintf(stderr, "Reading a token: ");
 844 #endif
 845       yychar = YYLEX;
 846     }
 847
 848   /* Convert token to internal form (in yychar1) for indexing tables with */
 849
 850   if (yychar <= 0)              /* This means end of input. */
 851     {
 852       yychar1 = 0;
 853       yychar = YYEOF;           /* Don't call YYLEX any more */
 854
 855 #if YYDEBUG != 0
 856       if (yydebug)
 857         fprintf(stderr, "Now at end of input.\n");
 858 #endif
 859     }
 860   else
 861     {
 862       yychar1 = YYTRANSLATE(yychar);
 863
 864 #if YYDEBUG != 0
 865       if (yydebug)
 866         fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
 867 #endif
 868     }
 869
 870   yyn += yychar1;
 871   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 872     goto yydefault;
 873
 874   yyn = yytable[yyn];
 875
 876   /* yyn is what to do for this token type in this state.
 877      Negative => reduce, -yyn is rule number.
 878      Positive => shift, yyn is new state.
 879        New state is final state => don't bother to shift,
 880        just return success.
 881      0, or most negative number => error.  */
 882
 883   if (yyn < 0)
 884     {
 885       if (yyn == YYFLAG)
 886         goto yyerrlab;
 887       yyn = -yyn;
 888       goto yyreduce;
 889     }
 890   else if (yyn == 0)
 891     goto yyerrlab;
 892
 893   if (yyn == YYFINAL)
 894     YYACCEPT;
 895
 896   /* Shift the lookahead token.  */
 897
 898 #if YYDEBUG != 0
 899   if (yydebug)
 900     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 901 #endif
 902
 903   /* Discard the token being shifted unless it is eof.  */
 904   if (yychar != YYEOF)
 905     yychar = YYEMPTY;
 906
 907   *++yyvsp = yylval;
 908 #ifdef YYLSP_NEEDED
 909   *++yylsp = yylloc;
 910 #endif
 911
 912   /* count tokens shifted since error; after three, turn off error status.  */
 913   if (yyerrstatus) yyerrstatus--;
 914
 915   yystate = yyn;
 916   goto yynewstate;
 917
 918 /* Do the default action for the current state.  */
 919 yydefault:
 920
 921   yyn = yydefact[yystate];
 922   if (yyn == 0)
 923     goto yyerrlab;
 924
 925 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 926 yyreduce:
 927   yylen = yyr2[yyn];
 928   yyval = yyvsp[1-yylen]; /* implement default value of the action */
 929
 930 #if YYDEBUG != 0
 931   if (yydebug)
 932     {
 933       int i;
 934
 935       fprintf (stderr, "Reducing via rule %d (line %d), ",
 936                yyn, yyrline[yyn]);
 937
 938       /* Print the symboles being reduced, and their result.  */
 939       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 940         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 941       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 942     }
 943 #endif
 944
 945
 946   switch (yyn) {
 947
 948 case 3:
 949 #line 231 "./expread.y"
 950 { write_exp_elt_opcode (BINOP_COMMA); ;
 951     break;}
 952 case 4:
 953 #line 236 "./expread.y"
 954 { write_exp_elt_opcode (UNOP_IND); ;
 955     break;}
 956 case 5:
 957 #line 239 "./expread.y"
 958 { write_exp_elt_opcode (UNOP_ADDR); ;
 959     break;}
 960 case 6:
 961 #line 242 "./expread.y"
 962 { write_exp_elt_opcode (UNOP_NEG); ;
 963     break;}
 964 case 7:
 965 #line 246 "./expread.y"
 966 { write_exp_elt_opcode (UNOP_ZEROP); ;
 967     break;}
 968 case 8:
 969 #line 250 "./expread.y"
 970 { write_exp_elt_opcode (UNOP_LOGNOT); ;
 971     break;}
 972 case 9:
 973 #line 254 "./expread.y"
 974 { write_exp_elt_opcode (UNOP_PREINCREMENT); ;
 975     break;}
 976 case 10:
 977 #line 258 "./expread.y"
 978 { write_exp_elt_opcode (UNOP_PREDECREMENT); ;
 979     break;}
 980 case 11:
 981 #line 262 "./expread.y"
 982 { write_exp_elt_opcode (UNOP_POSTINCREMENT); ;
 983     break;}
 984 case 12:
 985 #line 266 "./expread.y"
 986 { write_exp_elt_opcode (UNOP_POSTDECREMENT); ;
 987     break;}
 988 case 13:
 989 #line 270 "./expread.y"
 990 { write_exp_elt_opcode (UNOP_SIZEOF); ;
 991     break;}
 992 case 14:
 993 #line 274 "./expread.y"
 994 { write_exp_elt_opcode (STRUCTOP_PTR);
 995                           write_exp_string (yyvsp[0].sval);
 996                           write_exp_elt_opcode (STRUCTOP_PTR); ;
 997     break;}
 998 case 15:
 999 #line 280 "./expread.y"
1000 { write_exp_elt_opcode (STRUCTOP_MPTR); ;
1001     break;}
1002 case 16:
1003 #line 284 "./expread.y"
1004 { write_exp_elt_opcode (STRUCTOP_STRUCT);
1005                           write_exp_string (yyvsp[0].sval);
1006                           write_exp_elt_opcode (STRUCTOP_STRUCT); ;
1007     break;}
1008 case 17:
1009 #line 290 "./expread.y"
1010 { write_exp_elt_opcode (STRUCTOP_MEMBER); ;
1011     break;}
1012 case 18:
1013 #line 294 "./expread.y"
1014 { write_exp_elt_opcode (BINOP_SUBSCRIPT); ;
1015     break;}
1016 case 19:
1017 #line 300 "./expread.y"
1018 { start_arglist (); ;
1019     break;}
1020 case 20:
1021 #line 302 "./expread.y"
1022 { write_exp_elt_opcode (OP_FUNCALL);
1023                           write_exp_elt_longcst ((LONGEST) end_arglist ());
1024                           write_exp_elt_opcode (OP_FUNCALL); ;
1025     break;}
1026 case 22:
1027 #line 311 "./expread.y"
1028 { arglist_len = 1; ;
1029     break;}
1030 case 23:
1031 #line 315 "./expread.y"
1032 { arglist_len++; ;
1033     break;}
1034 case 24:
1035 #line 319 "./expread.y"
1036 { write_exp_elt_opcode (UNOP_MEMVAL);
1037                           write_exp_elt_type (yyvsp[-2].tval);
1038                           write_exp_elt_opcode (UNOP_MEMVAL); ;
1039     break;}
1040 case 25:
1041 #line 325 "./expread.y"
1042 { write_exp_elt_opcode (UNOP_CAST);
1043                           write_exp_elt_type (yyvsp[-2].tval);
1044                           write_exp_elt_opcode (UNOP_CAST); ;
1045     break;}
1046 case 26:
1047 #line 331 "./expread.y"
1048 { ;
1049     break;}
1050 case 27:
1051 #line 337 "./expread.y"
1052 { write_exp_elt_opcode (BINOP_REPEAT); ;
1053     break;}
1054 case 28:
1055 #line 341 "./expread.y"
1056 { write_exp_elt_opcode (BINOP_MUL); ;
1057     break;}
1058 case 29:
1059 #line 345 "./expread.y"
1060 { write_exp_elt_opcode (BINOP_DIV); ;
1061     break;}
1062 case 30:
1063 #line 349 "./expread.y"
1064 { write_exp_elt_opcode (BINOP_REM); ;
1065     break;}
1066 case 31:
1067 #line 353 "./expread.y"
1068 { write_exp_elt_opcode (BINOP_ADD); ;
1069     break;}
1070 case 32:
1071 #line 357 "./expread.y"
1072 { write_exp_elt_opcode (BINOP_SUB); ;
1073     break;}
1074 case 33:
1075 #line 361 "./expread.y"
1076 { write_exp_elt_opcode (BINOP_LSH); ;
1077     break;}
1078 case 34:
1079 #line 365 "./expread.y"
1080 { write_exp_elt_opcode (BINOP_RSH); ;
1081     break;}
1082 case 35:
1083 #line 369 "./expread.y"
1084 { write_exp_elt_opcode (BINOP_EQUAL); ;
1085     break;}
1086 case 36:
1087 #line 373 "./expread.y"
1088 { write_exp_elt_opcode (BINOP_NOTEQUAL); ;
1089     break;}
1090 case 37:
1091 #line 377 "./expread.y"
1092 { write_exp_elt_opcode (BINOP_LEQ); ;
1093     break;}
1094 case 38:
1095 #line 381 "./expread.y"
1096 { write_exp_elt_opcode (BINOP_GEQ); ;
1097     break;}
1098 case 39:
1099 #line 385 "./expread.y"
1100 { write_exp_elt_opcode (BINOP_LESS); ;
1101     break;}
1102 case 40:
1103 #line 389 "./expread.y"
1104 { write_exp_elt_opcode (BINOP_GTR); ;
1105     break;}
1106 case 41:
1107 #line 393 "./expread.y"
1108 { write_exp_elt_opcode (BINOP_LOGAND); ;
1109     break;}
1110 case 42:
1111 #line 397 "./expread.y"
1112 { write_exp_elt_opcode (BINOP_LOGXOR); ;
1113     break;}
1114 case 43:
1115 #line 401 "./expread.y"
1116 { write_exp_elt_opcode (BINOP_LOGIOR); ;
1117     break;}
1118 case 44:
1119 #line 405 "./expread.y"
1120 { write_exp_elt_opcode (BINOP_AND); ;
1121     break;}
1122 case 45:
1123 #line 409 "./expread.y"
1124 { write_exp_elt_opcode (BINOP_OR); ;
1125     break;}
1126 case 46:
1127 #line 413 "./expread.y"
1128 { write_exp_elt_opcode (TERNOP_COND); ;
1129     break;}
1130 case 47:
1131 #line 417 "./expread.y"
1132 { write_exp_elt_opcode (BINOP_ASSIGN); ;
1133     break;}
1134 case 48:
1135 #line 421 "./expread.y"
1136 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
1137                           write_exp_elt_opcode (yyvsp[-1].opcode);
1138                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); ;
1139     break;}
1140 case 49:
1141 #line 427 "./expread.y"
1142 { write_exp_elt_opcode (OP_LONG);
1143                           if (yyvsp[0].lval == (int) yyvsp[0].lval || yyvsp[0].lval == (unsigned int) yyvsp[0].lval)
1144                             write_exp_elt_type (builtin_type_int);
1145                           else
1146                             write_exp_elt_type (BUILTIN_TYPE_LONGEST);
1147                           write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1148                           write_exp_elt_opcode (OP_LONG); ;
1149     break;}
1150 case 50:
1151 #line 437 "./expread.y"
1152 { YYSTYPE val;
1153                           parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
1154                           write_exp_elt_opcode (OP_LONG);
1155                           if (val.lval == (int) val.lval ||
1156                               val.lval == (unsigned int) val.lval)
1157                             write_exp_elt_type (builtin_type_int);
1158                           else
1159                             write_exp_elt_type (BUILTIN_TYPE_LONGEST);
1160                           write_exp_elt_longcst (val.lval);
1161                           write_exp_elt_opcode (OP_LONG); ;
1162     break;}
1163 case 51:
1164 #line 450 "./expread.y"
1165 {
1166                           write_exp_elt_opcode (OP_LONG);
1167                           if (yyvsp[0].ulval == (unsigned int) yyvsp[0].ulval)
1168                             write_exp_elt_type (builtin_type_unsigned_int);
1169                           else
1170                             write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
1171                           write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval);
1172                           write_exp_elt_opcode (OP_LONG);
1173                         ;
1174     break;}
1175 case 52:
1176 #line 462 "./expread.y"
1177 { YYSTYPE val;
1178                           parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
1179                           write_exp_elt_opcode (OP_LONG);
1180                           if (val.ulval == (unsigned int) val.ulval)
1181                             write_exp_elt_type (builtin_type_unsigned_int);
1182                           else
1183                             write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
1184                           write_exp_elt_longcst ((LONGEST)val.ulval);
1185                           write_exp_elt_opcode (OP_LONG);
1186                         ;
1187     break;}
1188 case 53:
1189 #line 475 "./expread.y"
1190 { write_exp_elt_opcode (OP_LONG);
1191                           write_exp_elt_type (builtin_type_char);
1192                           write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1193                           write_exp_elt_opcode (OP_LONG); ;
1194     break;}
1195 case 54:
1196 #line 482 "./expread.y"
1197 { write_exp_elt_opcode (OP_DOUBLE);
1198                           write_exp_elt_type (builtin_type_double);
1199                           write_exp_elt_dblcst (yyvsp[0].dval);
1200                           write_exp_elt_opcode (OP_DOUBLE); ;
1201     break;}
1202 case 56:
1203 #line 492 "./expread.y"
1204 { write_exp_elt_opcode (OP_LAST);
1205                           write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1206                           write_exp_elt_opcode (OP_LAST); ;
1207     break;}
1208 case 57:
1209 #line 498 "./expread.y"
1210 { write_exp_elt_opcode (OP_REGISTER);
1211                           write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
1212                           write_exp_elt_opcode (OP_REGISTER); ;
1213     break;}
1214 case 58:
1215 #line 504 "./expread.y"
1216 { write_exp_elt_opcode (OP_INTERNALVAR);
1217                           write_exp_elt_intern (yyvsp[0].ivar);
1218                           write_exp_elt_opcode (OP_INTERNALVAR); ;
1219     break;}
1220 case 59:
1221 #line 510 "./expread.y"
1222 { write_exp_elt_opcode (OP_LONG);
1223                           write_exp_elt_type (builtin_type_int);
1224                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
1225                           write_exp_elt_opcode (OP_LONG); ;
1226     break;}
1227 case 60:
1228 #line 517 "./expread.y"
1229 { write_exp_elt_opcode (OP_STRING);
1230                           write_exp_string (yyvsp[0].sval);
1231                           write_exp_elt_opcode (OP_STRING); ;
1232     break;}
1233 case 61:
1234 #line 524 "./expread.y"
1235 { write_exp_elt_opcode (OP_THIS);
1236                           write_exp_elt_opcode (OP_THIS); ;
1237     break;}
1238 case 62:
1239 #line 531 "./expread.y"
1240 {
1241                           if (yyvsp[0].ssym.sym != 0)
1242                               yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);
1243                           else
1244                             {
1245                               struct symtab *tem =
1246                                   lookup_symtab (copy_name (yyvsp[0].ssym.stoken));
1247                               if (tem)
1248                                 yyval.bval = BLOCKVECTOR_BLOCK
1249                                          (BLOCKVECTOR (tem), STATIC_BLOCK);
1250                               else
1251                                 error ("No file or function \"%s\".",
1252                                        copy_name (yyvsp[0].ssym.stoken));
1253                             }
1254                         ;
1255     break;}
1256 case 63:
1257 #line 549 "./expread.y"
1258 { struct symbol *tem
1259                             = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1260                                              VAR_NAMESPACE, 0, NULL);
1261                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
1262                             error ("No function \"%s\" in specified context.",
1263                                    copy_name (yyvsp[0].sval));
1264                           yyval.bval = SYMBOL_BLOCK_VALUE (tem); ;
1265     break;}
1266 case 64:
1267 #line 559 "./expread.y"
1268 { struct symbol *sym;
1269                           sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
1270                                                VAR_NAMESPACE, 0, NULL);
1271                           if (sym == 0)
1272                             error ("No symbol \"%s\" in specified context.",
1273                                    copy_name (yyvsp[0].sval));
1274                           write_exp_elt_opcode (OP_VAR_VALUE);
1275                           write_exp_elt_sym (sym);
1276                           write_exp_elt_opcode (OP_VAR_VALUE); ;
1277     break;}
1278 case 65:
1279 #line 571 "./expread.y"
1280 {
1281                           struct type *type = yyvsp[-2].tval;
1282                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1283                               && TYPE_CODE (type) != TYPE_CODE_UNION)
1284                             error ("`%s' is not defined as an aggregate type.",
1285                                    TYPE_NAME (type));
1286
1287                           write_exp_elt_opcode (OP_SCOPE);
1288                           write_exp_elt_type (type);
1289                           write_exp_string (yyvsp[0].sval);
1290                           write_exp_elt_opcode (OP_SCOPE);
1291                         ;
1292     break;}
1293 case 66:
1294 #line 584 "./expread.y"
1295 {
1296                           struct type *type = yyvsp[-3].tval;
1297                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1298                               && TYPE_CODE (type) != TYPE_CODE_UNION)
1299                             error ("`%s' is not defined as an aggregate type.",
1300                                    TYPE_NAME (type));
1301
1302                           if (strcmp (type_name_no_tag (type), yyvsp[0].sval.ptr))
1303                             error ("invalid destructor `%s::~%s'",
1304                                    type_name_no_tag (type), yyvsp[0].sval.ptr);
1305
1306                           write_exp_elt_opcode (OP_SCOPE);
1307                           write_exp_elt_type (type);
1308                           write_exp_string (yyvsp[0].sval);
1309                           write_exp_elt_opcode (OP_SCOPE);
1310                           write_exp_elt_opcode (UNOP_LOGNOT);
1311                         ;
1312     break;}
1313 case 67:
1314 #line 602 "./expread.y"
1315 {
1316                           char *name = copy_name (yyvsp[0].sval);
1317                           struct symbol *sym;
1318                           int i;
1319
1320                           sym =
1321                             lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
1322                           if (sym)
1323                             {
1324                               write_exp_elt_opcode (OP_VAR_VALUE);
1325                               write_exp_elt_sym (sym);
1326                               write_exp_elt_opcode (OP_VAR_VALUE);
1327                               break;
1328                             }
1329                           for (i = 0; i < misc_function_count; i++)
1330                             if (!strcmp (misc_function_vector[i].name, name))
1331                               break;
1332
1333                           if (i < misc_function_count)
1334                             {
1335                               enum misc_function_type mft =
1336                                   misc_function_vector[i].type;
1337
1338                               write_exp_elt_opcode (OP_LONG);
1339                               write_exp_elt_type (builtin_type_int);
1340                               write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
1341                               write_exp_elt_opcode (OP_LONG);
1342                               write_exp_elt_opcode (UNOP_MEMVAL);
1343                               if (mft == mf_data || mft == mf_bss)
1344                                 write_exp_elt_type (builtin_type_int);
1345                               else if (mft == mf_text)
1346                                 write_exp_elt_type (lookup_function_type (builtin_type_int));
1347                               else
1348                                 write_exp_elt_type (builtin_type_char);
1349                               write_exp_elt_opcode (UNOP_MEMVAL);
1350                             }
1351                           else
1352                             if (symtab_list == 0
1353                                 && partial_symtab_list == 0)
1354                               error ("No symbol table is loaded.  Use the \"file\" command.");
1355                             else
1356                               error ("No symbol \"%s\" in current context.", name);
1357                         ;
1358     break;}
1359 case 68:
1360 #line 648 "./expread.y"
1361 { struct symbol *sym = yyvsp[0].ssym.sym;
1362
1363                           if (sym)
1364                             {
1365                               switch (sym->class)
1366                                 {
1367                                 case LOC_REGISTER:
1368                                 case LOC_ARG:
1369                                 case LOC_REF_ARG:
1370                                 case LOC_REGPARM:
1371                                 case LOC_LOCAL:
1372                                 case LOC_LOCAL_ARG:
1373                                   if (innermost_block == 0 ||
1374                                       contained_in (block_found,
1375                                                     innermost_block))
1376                                     innermost_block = block_found;
1377                                 case LOC_UNDEF:
1378                                 case LOC_CONST:
1379                                 case LOC_STATIC:
1380                                 case LOC_TYPEDEF:
1381                                 case LOC_LABEL:
1382                                 case LOC_BLOCK:
1383                                 case LOC_EXTERNAL:
1384                                 case LOC_CONST_BYTES:
1385
1386                                   /* In this case the expression can
1387                                      be evaluated regardless of what
1388                                      frame we are in, so there is no
1389                                      need to check for the
1390                                      innermost_block.  These cases are
1391                                      listed so that gcc -Wall will
1392                                      report types that may not have
1393                                      been considered.  */
1394
1395                                   break;
1396                                 }
1397                               write_exp_elt_opcode (OP_VAR_VALUE);
1398                               write_exp_elt_sym (sym);
1399                               write_exp_elt_opcode (OP_VAR_VALUE);
1400                             }
1401                           else if (yyvsp[0].ssym.is_a_field_of_this)
1402                             {
1403                               /* C++: it hangs off of `this'.  Must
1404                                  not inadvertently convert from a method call
1405                                  to data ref.  */
1406                               if (innermost_block == 0 ||
1407                                   contained_in (block_found, innermost_block))
1408                                 innermost_block = block_found;
1409                               write_exp_elt_opcode (OP_THIS);
1410                               write_exp_elt_opcode (OP_THIS);
1411                               write_exp_elt_opcode (STRUCTOP_PTR);
1412                               write_exp_string (yyvsp[0].ssym.stoken);
1413                               write_exp_elt_opcode (STRUCTOP_PTR);
1414                             }
1415                           else
1416                             {
1417                               register int i;
1418                               register char *arg = copy_name (yyvsp[0].ssym.stoken);
1419
1420                                 /* FIXME, this search is linear!  At least
1421                                    optimize the strcmp with a 1-char cmp... */
1422                               for (i = 0; i < misc_function_count; i++)
1423                                 if (!strcmp (misc_function_vector[i].name, arg))
1424                                   break;
1425
1426                               if (i < misc_function_count)
1427                                 {
1428                                   enum misc_function_type mft =
1429                                       misc_function_vector[i].type;
1430
1431                                   write_exp_elt_opcode (OP_LONG);
1432                                   write_exp_elt_type (builtin_type_int);
1433                                   write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
1434                                   write_exp_elt_opcode (OP_LONG);
1435                                   write_exp_elt_opcode (UNOP_MEMVAL);
1436                                   if (mft == mf_data || mft == mf_bss)
1437                                     write_exp_elt_type (builtin_type_int);
1438                                   else if (mft == mf_text)
1439                                     write_exp_elt_type (lookup_function_type (builtin_type_int));
1440                                   else
1441                                     write_exp_elt_type (builtin_type_char);
1442                                   write_exp_elt_opcode (UNOP_MEMVAL);
1443                                 }
1444                               else if (symtab_list == 0
1445                                        && partial_symtab_list == 0)
1446                                 error ("No symbol table is loaded.  Use the \"file\" command.");
1447                               else
1448                                 error ("No symbol \"%s\" in current context.",
1449                                        copy_name (yyvsp[0].ssym.stoken));
1450                             }
1451                         ;
1452     break;}
1453 case 70:
1454 #line 744 "./expread.y"
1455 {
1456                   /* This is where the interesting stuff happens.  */
1457                   int done = 0;
1458                   int array_size;
1459                   struct type *follow_type = yyvsp[-1].tval;
1460
1461                   while (!done)
1462                     switch (pop_type ())
1463                       {
1464                       case tp_end:
1465                         done = 1;
1466                         break;
1467                       case tp_pointer:
1468                         follow_type = lookup_pointer_type (follow_type);
1469                         break;
1470                       case tp_reference:
1471                         follow_type = lookup_reference_type (follow_type);
1472                         break;
1473                       case tp_array:
1474                         array_size = pop_type_int ();
1475                         if (array_size != -1)
1476                           follow_type = create_array_type (follow_type,
1477                                                            array_size);
1478                         else
1479                           follow_type = lookup_pointer_type (follow_type);
1480                         break;
1481                       case tp_function:
1482                         follow_type = lookup_function_type (follow_type);
1483                         break;
1484                       }
1485                   yyval.tval = follow_type;
1486                 ;
1487     break;}
1488 case 71:
1489 #line 779 "./expread.y"
1490 { push_type (tp_pointer); yyval.voidval = 0; ;
1491     break;}
1492 case 72:
1493 #line 781 "./expread.y"
1494 { push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; ;
1495     break;}
1496 case 73:
1497 #line 783 "./expread.y"
1498 { push_type (tp_reference); yyval.voidval = 0; ;
1499     break;}
1500 case 74:
1501 #line 785 "./expread.y"
1502 { push_type (tp_reference); yyval.voidval = yyvsp[0].voidval; ;
1503     break;}
1504 case 76:
1505 #line 790 "./expread.y"
1506 { yyval.voidval = yyvsp[-1].voidval; ;
1507     break;}
1508 case 77:
1509 #line 792 "./expread.y"
1510 {
1511                           push_type_int (yyvsp[0].lval);
1512                           push_type (tp_array);
1513                         ;
1514     break;}
1515 case 78:
1516 #line 797 "./expread.y"
1517 {
1518                           push_type_int (yyvsp[0].lval);
1519                           push_type (tp_array);
1520                           yyval.voidval = 0;
1521                         ;
1522     break;}
1523 case 79:
1524 #line 803 "./expread.y"
1525 { push_type (tp_function); ;
1526     break;}
1527 case 80:
1528 #line 805 "./expread.y"
1529 { push_type (tp_function); ;
1530     break;}
1531 case 81:
1532 #line 809 "./expread.y"
1533 { yyval.lval = -1; ;
1534     break;}
1535 case 82:
1536 #line 811 "./expread.y"
1537 { yyval.lval = yyvsp[-1].lval; ;
1538     break;}
1539 case 83:
1540 #line 815 "./expread.y"
1541 { yyval.voidval = 0; ;
1542     break;}
1543 case 85:
1544 #line 820 "./expread.y"
1545 { yyval.tval = lookup_member_type (builtin_type_int, yyvsp[-2].tval); ;
1546     break;}
1547 case 86:
1548 #line 822 "./expread.y"
1549 { yyval.tval = lookup_member_type (yyvsp[-5].tval, yyvsp[-3].tval); ;
1550     break;}
1551 case 87:
1552 #line 824 "./expread.y"
1553 { yyval.tval = lookup_member_type
1554                             (lookup_function_type (yyvsp[-7].tval), yyvsp[-5].tval); ;
1555     break;}
1556 case 88:
1557 #line 827 "./expread.y"
1558 { yyval.tval = lookup_member_type
1559                             (lookup_function_type (yyvsp[-8].tval), yyvsp[-6].tval);
1560                           free (yyvsp[-1].tvec); ;
1561     break;}
1562 case 89:
1563 #line 834 "./expread.y"
1564 { yyval.tval = yyvsp[0].tsym.type; ;
1565     break;}
1566 case 90:
1567 #line 836 "./expread.y"
1568 { yyval.tval = builtin_type_int; ;
1569     break;}
1570 case 91:
1571 #line 838 "./expread.y"
1572 { yyval.tval = builtin_type_long; ;
1573     break;}
1574 case 92:
1575 #line 840 "./expread.y"
1576 { yyval.tval = builtin_type_short; ;
1577     break;}
1578 case 93:
1579 #line 842 "./expread.y"
1580 { yyval.tval = builtin_type_long; ;
1581     break;}
1582 case 94:
1583 #line 844 "./expread.y"
1584 { yyval.tval = builtin_type_unsigned_long; ;
1585     break;}
1586 case 95:
1587 #line 846 "./expread.y"
1588 { yyval.tval = builtin_type_long_long; ;
1589     break;}
1590 case 96:
1591 #line 848 "./expread.y"
1592 { yyval.tval = builtin_type_long_long; ;
1593     break;}
1594 case 97:
1595 #line 850 "./expread.y"
1596 { yyval.tval = builtin_type_unsigned_long_long; ;
1597     break;}
1598 case 98:
1599 #line 852 "./expread.y"
1600 { yyval.tval = builtin_type_unsigned_long_long; ;
1601     break;}
1602 case 99:
1603 #line 854 "./expread.y"
1604 { yyval.tval = builtin_type_short; ;
1605     break;}
1606 case 100:
1607 #line 856 "./expread.y"
1608 { yyval.tval = builtin_type_unsigned_short; ;
1609     break;}
1610 case 101:
1611 #line 858 "./expread.y"
1612 { yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
1613                                               expression_context_block); ;
1614     break;}
1615 case 102:
1616 #line 861 "./expread.y"
1617 { yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
1618                                              expression_context_block); ;
1619     break;}
1620 case 103:
1621 #line 864 "./expread.y"
1622 { yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
1623                                             expression_context_block); ;
1624     break;}
1625 case 104:
1626 #line 867 "./expread.y"
1627 { yyval.tval = lookup_unsigned_typename (TYPE_NAME(yyvsp[0].tsym.type)); ;
1628     break;}
1629 case 105:
1630 #line 869 "./expread.y"
1631 { yyval.tval = builtin_type_unsigned_int; ;
1632     break;}
1633 case 106:
1634 #line 871 "./expread.y"
1635 { yyval.tval = yyvsp[0].tsym.type; ;
1636     break;}
1637 case 107:
1638 #line 873 "./expread.y"
1639 { yyval.tval = builtin_type_int; ;
1640     break;}
1641 case 109:
1642 #line 878 "./expread.y"
1643 {
1644                   yyval.tsym.stoken.ptr = "int";
1645                   yyval.tsym.stoken.length = 3;
1646                   yyval.tsym.type = builtin_type_int;
1647                 ;
1648     break;}
1649 case 110:
1650 #line 884 "./expread.y"
1651 {
1652                   yyval.tsym.stoken.ptr = "long";
1653                   yyval.tsym.stoken.length = 4;
1654                   yyval.tsym.type = builtin_type_long;
1655                 ;
1656     break;}
1657 case 111:
1658 #line 890 "./expread.y"
1659 {
1660                   yyval.tsym.stoken.ptr = "short";
1661                   yyval.tsym.stoken.length = 5;
1662                   yyval.tsym.type = builtin_type_short;
1663                 ;
1664     break;}
1665 case 112:
1666 #line 899 "./expread.y"
1667 { yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2);
1668                   yyval.tvec[0] = (struct type *)0;
1669                   yyval.tvec[1] = yyvsp[0].tval;
1670                 ;
1671     break;}
1672 case 113:
1673 #line 904 "./expread.y"
1674 { int len = sizeof (struct type *) * ++(yyvsp[-2].ivec[0]);
1675                   yyval.tvec = (struct type **)xrealloc (yyvsp[-2].tvec, len);
1676                   yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
1677                 ;
1678     break;}
1679 case 114:
1680 #line 910 "./expread.y"
1681 { yyval.sval = yyvsp[0].ssym.stoken; ;
1682     break;}
1683 case 115:
1684 #line 911 "./expread.y"
1685 { yyval.sval = yyvsp[0].ssym.stoken; ;
1686     break;}
1687 case 116:
1688 #line 912 "./expread.y"
1689 { yyval.sval = yyvsp[0].tsym.stoken; ;
1690     break;}
1691 case 117:
1692 #line 913 "./expread.y"
1693 { yyval.sval = yyvsp[0].ssym.stoken; ;
1694     break;}
1695 case 118:
1696 #line 914 "./expread.y"
1697 { yyval.sval = yyvsp[0].ssym.stoken; ;
1698     break;}
1699 }
1700    /* the action file gets copied in in place of this dollarsign */
1701 #line 423 "/usr/unsupported/lib/bison.simple"
1702 \f
1703   yyvsp -= yylen;
1704   yyssp -= yylen;
1705 #ifdef YYLSP_NEEDED
1706   yylsp -= yylen;
1707 #endif
1708
1709 #if YYDEBUG != 0
1710   if (yydebug)
1711     {
1712       short *ssp1 = yyss - 1;
1713       fprintf (stderr, "state stack now");
1714       while (ssp1 != yyssp)
1715         fprintf (stderr, " %d", *++ssp1);
1716       fprintf (stderr, "\n");
1717     }
1718 #endif
1719
1720   *++yyvsp = yyval;
1721
1722 #ifdef YYLSP_NEEDED
1723   yylsp++;
1724   if (yylen == 0)
1725     {
1726       yylsp->first_line = yylloc.first_line;
1727       yylsp->first_column = yylloc.first_column;
1728       yylsp->last_line = (yylsp-1)->last_line;
1729       yylsp->last_column = (yylsp-1)->last_column;
1730       yylsp->text = 0;
1731     }
1732   else
1733     {
1734       yylsp->last_line = (yylsp+yylen-1)->last_line;
1735       yylsp->last_column = (yylsp+yylen-1)->last_column;
1736     }
1737 #endif
1738
1739   /* Now "shift" the result of the reduction.
1740      Determine what state that goes to,
1741      based on the state we popped back to
1742      and the rule number reduced by.  */
1743
1744   yyn = yyr1[yyn];
1745
1746   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1747   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1748     yystate = yytable[yystate];
1749   else
1750     yystate = yydefgoto[yyn - YYNTBASE];
1751
1752   goto yynewstate;
1753
1754 yyerrlab:   /* here on detecting error */
1755
1756   if (! yyerrstatus)
1757     /* If not already recovering from an error, report this error.  */
1758     {
1759       ++yynerrs;
1760
1761 #ifdef YYERROR_VERBOSE
1762       yyn = yypact[yystate];
1763
1764       if (yyn > YYFLAG && yyn < YYLAST)
1765         {
1766           int size = 0;
1767           char *msg;
1768           int x, count;
1769
1770           count = 0;
1771           for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
1772             if (yycheck[x + yyn] == x)
1773               size += strlen(yytname[x]) + 15, count++;
1774           msg = (char *) xmalloc(size + 15);
1775           strcpy(msg, "parse error");
1776
1777           if (count < 5)
1778             {
1779               count = 0;
1780               for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
1781                 if (yycheck[x + yyn] == x)
1782                   {
1783                     strcat(msg, count == 0 ? ", expecting `" : " or `");
1784                     strcat(msg, yytname[x]);
1785                     strcat(msg, "'");
1786                     count++;
1787                   }
1788             }
1789           yyerror(msg);
1790           free(msg);
1791         }
1792       else
1793 #endif /* YYERROR_VERBOSE */
1794         yyerror("parse error");
1795     }
1796
1797 yyerrlab1:   /* here on error raised explicitly by an action */
1798
1799   if (yyerrstatus == 3)
1800     {
1801       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1802
1803       /* return failure if at end of input */
1804       if (yychar == YYEOF)
1805         YYABORT;
1806
1807 #if YYDEBUG != 0
1808       if (yydebug)
1809         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1810 #endif
1811
1812       yychar = YYEMPTY;
1813     }
1814
1815   /* Else will try to reuse lookahead token
1816      after shifting the error token.  */
1817
1818   yyerrstatus = 3;              /* Each real token shifted decrements this */
1819
1820   goto yyerrhandle;
1821
1822 yyerrdefault:  /* current state does not do anything special for the error token. */
1823
1824 #if 0
1825   /* This is wrong; only states that explicitly want error tokens
1826      should shift them.  */
1827   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1828   if (yyn) goto yydefault;
1829 #endif
1830
1831 yyerrpop:   /* pop the current state because it cannot handle the error token */
1832
1833   if (yyssp == yyss) YYABORT;
1834   yyvsp--;
1835   yystate = *--yyssp;
1836 #ifdef YYLSP_NEEDED
1837   yylsp--;
1838 #endif
1839
1840 #if YYDEBUG != 0
1841   if (yydebug)
1842     {
1843       short *ssp1 = yyss - 1;
1844       fprintf (stderr, "Error: state stack now");
1845       while (ssp1 != yyssp)
1846         fprintf (stderr, " %d", *++ssp1);
1847       fprintf (stderr, "\n");
1848     }
1849 #endif
1850
1851 yyerrhandle:
1852
1853   yyn = yypact[yystate];
1854   if (yyn == YYFLAG)
1855     goto yyerrdefault;
1856
1857   yyn += YYTERROR;
1858   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1859     goto yyerrdefault;
1860
1861   yyn = yytable[yyn];
1862   if (yyn < 0)
1863     {
1864       if (yyn == YYFLAG)
1865         goto yyerrpop;
1866       yyn = -yyn;
1867       goto yyreduce;
1868     }
1869   else if (yyn == 0)
1870     goto yyerrpop;
1871
1872   if (yyn == YYFINAL)
1873     YYACCEPT;
1874
1875 #if YYDEBUG != 0
1876   if (yydebug)
1877     fprintf(stderr, "Shifting error token, ");
1878 #endif
1879
1880   *++yyvsp = yylval;
1881 #ifdef YYLSP_NEEDED
1882   *++yylsp = yylloc;
1883 #endif
1884
1885   yystate = yyn;
1886   goto yynewstate;
1887 }
1888 #line 929 "./expread.y"
1889
1890 \f
1891 /* Begin counting arguments for a function call,
1892    saving the data about any containing call.  */
1893
1894 static void
1895 start_arglist ()
1896 {
1897   register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
1898
1899   new->next = funcall_chain;
1900   new->arglist_len = arglist_len;
1901   arglist_len = 0;
1902   funcall_chain = new;
1903 }
1904
1905 /* Return the number of arguments in a function call just terminated,
1906    and restore the data for the containing function call.  */
1907
1908 static int
1909 end_arglist ()
1910 {
1911   register int val = arglist_len;
1912   register struct funcall *call = funcall_chain;
1913   funcall_chain = call->next;
1914   arglist_len = call->arglist_len;
1915   free (call);
1916   return val;
1917 }
1918
1919 /* Free everything in the funcall chain.
1920    Used when there is an error inside parsing.  */
1921
1922 static void
1923 free_funcalls ()
1924 {
1925   register struct funcall *call, *next;
1926
1927   for (call = funcall_chain; call; call = next)
1928     {
1929       next = call->next;
1930       free (call);
1931     }
1932 }
1933 \f
1934 /* This page contains the functions for adding data to the  struct expression
1935    being constructed.  */
1936
1937 /* Add one element to the end of the expression.  */
1938
1939 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
1940    a register through here */
1941
1942 static void
1943 write_exp_elt (expelt)
1944      union exp_element expelt;
1945 {
1946   if (expout_ptr >= expout_size)
1947     {
1948       expout_size *= 2;
1949       expout = (struct expression *) xrealloc (expout,
1950                                                sizeof (struct expression)
1951                                                + expout_size * sizeof (union exp_element));
1952     }
1953   expout->elts[expout_ptr++] = expelt;
1954 }
1955
1956 static void
1957 write_exp_elt_opcode (expelt)
1958      enum exp_opcode expelt;
1959 {
1960   union exp_element tmp;
1961
1962   tmp.opcode = expelt;
1963
1964   write_exp_elt (tmp);
1965 }
1966
1967 static void
1968 write_exp_elt_sym (expelt)
1969      struct symbol *expelt;
1970 {
1971   union exp_element tmp;
1972
1973   tmp.symbol = expelt;
1974
1975   write_exp_elt (tmp);
1976 }
1977
1978 static void
1979 write_exp_elt_longcst (expelt)
1980      LONGEST expelt;
1981 {
1982   union exp_element tmp;
1983
1984   tmp.longconst = expelt;
1985
1986   write_exp_elt (tmp);
1987 }
1988
1989 static void
1990 write_exp_elt_dblcst (expelt)
1991      double expelt;
1992 {
1993   union exp_element tmp;
1994
1995   tmp.doubleconst = expelt;
1996
1997   write_exp_elt (tmp);
1998 }
1999
2000 static void
2001 write_exp_elt_type (expelt)
2002      struct type *expelt;
2003 {
2004   union exp_element tmp;
2005
2006   tmp.type = expelt;
2007
2008   write_exp_elt (tmp);
2009 }
2010
2011 static void
2012 write_exp_elt_intern (expelt)
2013      struct internalvar *expelt;
2014 {
2015   union exp_element tmp;
2016
2017   tmp.internalvar = expelt;
2018
2019   write_exp_elt (tmp);
2020 }
2021
2022 /* Add a string constant to the end of the expression.
2023    Follow it by its length in bytes, as a separate exp_element.  */
2024
2025 static void
2026 write_exp_string (str)
2027      struct stoken str;
2028 {
2029   register int len = str.length;
2030   register int lenelt
2031     = (len + sizeof (union exp_element)) / sizeof (union exp_element);
2032
2033   expout_ptr += lenelt;
2034
2035   if (expout_ptr >= expout_size)
2036     {
2037       expout_size = max (expout_size * 2, expout_ptr + 10);
2038       expout = (struct expression *)
2039         xrealloc (expout, (sizeof (struct expression)
2040                            + (expout_size * sizeof (union exp_element))));
2041     }
2042   bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
2043   ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
2044   write_exp_elt_longcst ((LONGEST) len);
2045 }
2046 \f
2047 /* During parsing of a C expression, the pointer to the next character
2048    is in this variable.  */
2049
2050 static char *lexptr;
2051
2052 /* Tokens that refer to names do so with explicit pointer and length,
2053    so they can share the storage that lexptr is parsing.
2054
2055    When it is necessary to pass a name to a function that expects
2056    a null-terminated string, the substring is copied out
2057    into a block of storage that namecopy points to.
2058
2059    namecopy is allocated once, guaranteed big enough, for each parsing.  */
2060
2061 static char *namecopy;
2062
2063 /* Current depth in parentheses within the expression.  */
2064
2065 static int paren_depth;
2066
2067 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
2068
2069 static int comma_terminates;
2070
2071 /* Take care of parsing a number (anything that starts with a digit).
2072    Set yylval and return the token type; update lexptr.
2073    LEN is the number of characters in it.  */
2074
2075 /*** Needs some error checking for the float case ***/
2076
2077 static int
2078 parse_number (p, len, parsed_float, putithere)
2079      register char *p;
2080      register int len;
2081      int parsed_float;
2082      YYSTYPE *putithere;
2083 {
2084   register LONGEST n = 0;
2085   register int i;
2086   register int c;
2087   register int base = input_radix;
2088   int unsigned_p = 0;
2089
2090   extern double atof ();
2091
2092   if (parsed_float)
2093     {
2094       /* It's a float since it contains a point or an exponent.  */
2095       putithere->dval = atof (p);
2096       return FLOAT;
2097     }
2098
2099   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
2100   if (p[0] == '0')
2101     switch (p[1])
2102       {
2103       case 'x':
2104       case 'X':
2105         if (len >= 3)
2106           {
2107             p += 2;
2108             base = 16;
2109             len -= 2;
2110           }
2111         break;
2112
2113       case 't':
2114       case 'T':
2115       case 'd':
2116       case 'D':
2117         if (len >= 3)
2118           {
2119             p += 2;
2120             base = 10;
2121             len -= 2;
2122           }
2123         break;
2124
2125       default:
2126         base = 8;
2127         break;
2128       }
2129
2130   while (len-- > 0)
2131     {
2132       c = *p++;
2133       if (c >= 'A' && c <= 'Z')
2134         c += 'a' - 'A';
2135       if (c != 'l' && c != 'u')
2136         n *= base;
2137       if (c >= '0' && c <= '9')
2138         n += i = c - '0';
2139       else
2140         {
2141           if (base > 10 && c >= 'a' && c <= 'f')
2142             n += i = c - 'a' + 10;
2143           else if (len == 0 && c == 'l')
2144             ;
2145           else if (len == 0 && c == 'u')
2146             unsigned_p = 1;
2147           else
2148             return ERROR;       /* Char not a digit */
2149         }
2150       if (i >= base)
2151         return ERROR;           /* Invalid digit in this base */
2152     }
2153
2154   if (unsigned_p)
2155     {
2156       putithere->ulval = n;
2157       return UINT;
2158     }
2159   else
2160     {
2161       putithere->lval = n;
2162       return INT;
2163     }
2164 }
2165
2166 struct token
2167 {
2168   char *operator;
2169   int token;
2170   enum exp_opcode opcode;
2171 };
2172
2173 const static struct token tokentab3[] =
2174   {
2175     {">>=", ASSIGN_MODIFY, BINOP_RSH},
2176     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
2177   };
2178
2179 const static struct token tokentab2[] =
2180   {
2181     {"+=", ASSIGN_MODIFY, BINOP_ADD},
2182     {"-=", ASSIGN_MODIFY, BINOP_SUB},
2183     {"*=", ASSIGN_MODIFY, BINOP_MUL},
2184     {"/=", ASSIGN_MODIFY, BINOP_DIV},
2185     {"%=", ASSIGN_MODIFY, BINOP_REM},
2186     {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
2187     {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
2188     {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
2189     {"++", INCREMENT, BINOP_END},
2190     {"--", DECREMENT, BINOP_END},
2191     {"->", ARROW, BINOP_END},
2192     {"&&", AND, BINOP_END},
2193     {"||", OR, BINOP_END},
2194     {"::", COLONCOLON, BINOP_END},
2195     {"<<", LSH, BINOP_END},
2196     {">>", RSH, BINOP_END},
2197     {"==", EQUAL, BINOP_END},
2198     {"!=", NOTEQUAL, BINOP_END},
2199     {"<=", LEQ, BINOP_END},
2200     {">=", GEQ, BINOP_END}
2201   };
2202
2203 /* assign machine-independent names to certain registers
2204  * (unless overridden by the REGISTER_NAMES table)
2205  */
2206 struct std_regs {
2207         char *name;
2208         int regnum;
2209 } std_regs[] = {
2210 #ifdef PC_REGNUM
2211         { "pc", PC_REGNUM },
2212 #endif
2213 #ifdef FP_REGNUM
2214         { "fp", FP_REGNUM },
2215 #endif
2216 #ifdef SP_REGNUM
2217         { "sp", SP_REGNUM },
2218 #endif
2219 #ifdef PS_REGNUM
2220         { "ps", PS_REGNUM },
2221 #endif
2222 };
2223
2224 #define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
2225
2226 /* Read one token, getting characters through lexptr.  */
2227
2228 static int
2229 yylex ()
2230 {
2231   register int c;
2232   register int namelen;
2233   register unsigned i;
2234   register char *tokstart;
2235
2236  retry:
2237
2238   tokstart = lexptr;
2239   /* See if it is a special token of length 3.  */
2240   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2241     if (!strncmp (tokstart, tokentab3[i].operator, 3))
2242       {
2243         lexptr += 3;
2244         yylval.opcode = tokentab3[i].opcode;
2245         return tokentab3[i].token;
2246       }
2247
2248   /* See if it is a special token of length 2.  */
2249   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2250     if (!strncmp (tokstart, tokentab2[i].operator, 2))
2251       {
2252         lexptr += 2;
2253         yylval.opcode = tokentab2[i].opcode;
2254         return tokentab2[i].token;
2255       }
2256
2257   switch (c = *tokstart)
2258     {
2259     case 0:
2260       return 0;
2261
2262     case ' ':
2263     case '\t':
2264     case '\n':
2265       lexptr++;
2266       goto retry;
2267
2268     case '\'':
2269       lexptr++;
2270       c = *lexptr++;
2271       if (c == '\\')
2272         c = parse_escape (&lexptr);
2273       yylval.lval = c;
2274       c = *lexptr++;
2275       if (c != '\'')
2276         error ("Invalid character constant.");
2277       return CHAR;
2278
2279     case '(':
2280       paren_depth++;
2281       lexptr++;
2282       return c;
2283
2284     case ')':
2285       if (paren_depth == 0)
2286         return 0;
2287       paren_depth--;
2288       lexptr++;
2289       return c;
2290
2291     case ',':
2292       if (comma_terminates && paren_depth == 0)
2293         return 0;
2294       lexptr++;
2295       return c;
2296
2297     case '.':
2298       /* Might be a floating point number.  */
2299       if (lexptr[1] < '0' || lexptr[1] > '9')
2300         goto symbol;            /* Nope, must be a symbol. */
2301       /* FALL THRU into number case.  */
2302
2303     case '0':
2304     case '1':
2305     case '2':
2306     case '3':
2307     case '4':
2308     case '5':
2309     case '6':
2310     case '7':
2311     case '8':
2312     case '9':
2313       {
2314         /* It's a number.  */
2315         int got_dot = 0, got_e = 0, toktype;
2316         register char *p = tokstart;
2317         int hex = input_radix > 10;
2318
2319         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2320           {
2321             p += 2;
2322             hex = 1;
2323           }
2324         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2325           {
2326             p += 2;
2327             hex = 0;
2328           }
2329
2330         for (;; ++p)
2331           {
2332             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2333               got_dot = got_e = 1;
2334             else if (!hex && !got_dot && *p == '.')
2335               got_dot = 1;
2336             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2337                      && (*p == '-' || *p == '+'))
2338               /* This is the sign of the exponent, not the end of the
2339                  number.  */
2340               continue;
2341             /* We will take any letters or digits.  parse_number will
2342                complain if past the radix, or if L or U are not final.  */
2343             else if ((*p < '0' || *p > '9')
2344                      && ((*p < 'a' || *p > 'z')
2345                                   && (*p < 'A' || *p > 'Z')))
2346               break;
2347           }
2348         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2349         if (toktype == ERROR)
2350           {
2351             char *err_copy = (char *) alloca (p - tokstart + 1);
2352
2353             bcopy (tokstart, err_copy, p - tokstart);
2354             err_copy[p - tokstart] = 0;
2355             error ("Invalid number \"%s\".", err_copy);
2356           }
2357         lexptr = p;
2358         return toktype;
2359       }
2360
2361     case '+':
2362     case '-':
2363     case '*':
2364     case '/':
2365     case '%':
2366     case '|':
2367     case '&':
2368     case '^':
2369     case '~':
2370     case '!':
2371     case '@':
2372     case '<':
2373     case '>':
2374     case '[':
2375     case ']':
2376     case '?':
2377     case ':':
2378     case '=':
2379     case '{':
2380     case '}':
2381     symbol:
2382       lexptr++;
2383       return c;
2384
2385     case '"':
2386       for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
2387         if (c == '\\')
2388           {
2389             c = tokstart[++namelen];
2390             if (c >= '0' && c <= '9')
2391               {
2392                 c = tokstart[++namelen];
2393                 if (c >= '0' && c <= '9')
2394                   c = tokstart[++namelen];
2395               }
2396           }
2397       yylval.sval.ptr = tokstart + 1;
2398       yylval.sval.length = namelen - 1;
2399       lexptr += namelen + 1;
2400       return STRING;
2401     }
2402
2403   if (!(c == '_' || c == '$'
2404         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2405     /* We must have come across a bad character (e.g. ';').  */
2406     error ("Invalid character '%c' in expression.", c);
2407
2408   /* It's a name.  See how long it is.  */
2409   namelen = 0;
2410   for (c = tokstart[namelen];
2411        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2412         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
2413        c = tokstart[++namelen])
2414     ;
2415
2416   /* The token "if" terminates the expression and is NOT
2417      removed from the input stream.  */
2418   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
2419     {
2420       return 0;
2421     }
2422
2423   lexptr += namelen;
2424
2425   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
2426      and $$digits (equivalent to $<-digits> if you could type that).
2427      Make token type LAST, and put the number (the digits) in yylval.  */
2428
2429   if (*tokstart == '$')
2430     {
2431       register int negate = 0;
2432       c = 1;
2433       /* Double dollar means negate the number and add -1 as well.
2434          Thus $$ alone means -1.  */
2435       if (namelen >= 2 && tokstart[1] == '$')
2436         {
2437           negate = 1;
2438           c = 2;
2439         }
2440       if (c == namelen)
2441         {
2442           /* Just dollars (one or two) */
2443           yylval.lval = - negate;
2444           return LAST;
2445         }
2446       /* Is the rest of the token digits?  */
2447       for (; c < namelen; c++)
2448         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
2449           break;
2450       if (c == namelen)
2451         {
2452           yylval.lval = atoi (tokstart + 1 + negate);
2453           if (negate)
2454             yylval.lval = - yylval.lval;
2455           return LAST;
2456         }
2457     }
2458
2459   /* Handle tokens that refer to machine registers:
2460      $ followed by a register name.  */
2461
2462   if (*tokstart == '$') {
2463     for (c = 0; c < NUM_REGS; c++)
2464       if (namelen - 1 == strlen (reg_names[c])
2465           && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
2466         {
2467           yylval.lval = c;
2468           return REGNAME;
2469         }
2470     for (c = 0; c < NUM_STD_REGS; c++)
2471      if (namelen - 1 == strlen (std_regs[c].name)
2472          && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
2473        {
2474          yylval.lval = std_regs[c].regnum;
2475          return REGNAME;
2476        }
2477   }
2478   /* Catch specific keywords.  Should be done with a data structure.  */
2479   switch (namelen)
2480     {
2481     case 8:
2482       if (!strncmp (tokstart, "unsigned", 8))
2483         return UNSIGNED;
2484       break;
2485     case 6:
2486       if (!strncmp (tokstart, "struct", 6))
2487         return STRUCT;
2488       if (!strncmp (tokstart, "signed", 6))
2489         return SIGNED;
2490       if (!strncmp (tokstart, "sizeof", 6))
2491         return SIZEOF;
2492       break;
2493     case 5:
2494       if (!strncmp (tokstart, "union", 5))
2495         return UNION;
2496       if (!strncmp (tokstart, "short", 5))
2497         return SHORT;
2498       break;
2499     case 4:
2500       if (!strncmp (tokstart, "enum", 4))
2501         return ENUM;
2502       if (!strncmp (tokstart, "long", 4))
2503         return LONG;
2504       if (!strncmp (tokstart, "this", 4))
2505         {
2506           static const char this_name[] =
2507                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
2508
2509           if (lookup_symbol (this_name, expression_context_block,
2510                              VAR_NAMESPACE, 0, NULL))
2511             return THIS;
2512         }
2513       break;
2514     case 3:
2515       if (!strncmp (tokstart, "int", 3))
2516         return INT_KEYWORD;
2517       break;
2518     default:
2519       break;
2520     }
2521
2522   yylval.sval.ptr = tokstart;
2523   yylval.sval.length = namelen;
2524
2525   /* Any other names starting in $ are debugger internal variables.  */
2526
2527   if (*tokstart == '$')
2528     {
2529       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
2530       return VARIABLE;
2531     }
2532
2533   /* Use token-type BLOCKNAME for symbols that happen to be defined as
2534      functions or symtabs.  If this is not so, then ...
2535      Use token-type TYPENAME for symbols that happen to be defined
2536      currently as names of types; NAME for other symbols.
2537      The caller is not constrained to care about the distinction.  */
2538   {
2539     char *tmp = copy_name (yylval.sval);
2540     struct symbol *sym;
2541     int is_a_field_of_this = 0;
2542     int hextype;
2543
2544     sym = lookup_symbol (tmp, expression_context_block,
2545                          VAR_NAMESPACE, &is_a_field_of_this, NULL);
2546     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
2547         lookup_partial_symtab (tmp))
2548       {
2549         yylval.ssym.sym = sym;
2550         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2551         return BLOCKNAME;
2552       }
2553     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2554         {
2555           yylval.tsym.type = SYMBOL_TYPE (sym);
2556           return TYPENAME;
2557         }
2558     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
2559         return TYPENAME;
2560
2561     /* Input names that aren't symbols but ARE valid hex numbers,
2562        when the input radix permits them, can be names or numbers
2563        depending on the parse.  Note we support radixes > 16 here.  */
2564     if (!sym &&
2565         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
2566          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2567       {
2568         YYSTYPE newlval;        /* Its value is ignored.  */
2569         hextype = parse_number (tokstart, namelen, 0, &newlval);
2570         if (hextype == INT)
2571           {
2572             yylval.ssym.sym = sym;
2573             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2574             return NAME_OR_INT;
2575           }
2576         if (hextype == UINT)
2577           {
2578             yylval.ssym.sym = sym;
2579             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2580             return NAME_OR_UINT;
2581           }
2582       }
2583
2584     /* Any other kind of symbol */
2585     yylval.ssym.sym = sym;
2586     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2587     return NAME;
2588   }
2589 }
2590
2591 static void
2592 yyerror (msg)
2593      char *msg;
2594 {
2595   error ("Invalid syntax in expression.");
2596 }
2597
2598 /* Return a null-terminated temporary copy of the name
2599    of a string token.  */
2600
2601 static char *
2602 copy_name (token)
2603      struct stoken token;
2604 {
2605   bcopy (token.ptr, namecopy, token.length);
2606   namecopy[token.length] = 0;
2607   return namecopy;
2608 }
2609 \f
2610 /* Reverse an expression from suffix form (in which it is constructed)
2611    to prefix form (in which we can conveniently print or execute it).  */
2612
2613 static void prefixify_subexp ();
2614
2615 static void
2616 prefixify_expression (expr)
2617      register struct expression *expr;
2618 {
2619   register int len = sizeof (struct expression) +
2620                                     expr->nelts * sizeof (union exp_element);
2621   register struct expression *temp;
2622   register int inpos = expr->nelts, outpos = 0;
2623
2624   temp = (struct expression *) alloca (len);
2625
2626   /* Copy the original expression into temp.  */
2627   bcopy (expr, temp, len);
2628
2629   prefixify_subexp (temp, expr, inpos, outpos);
2630 }
2631
2632 /* Return the number of exp_elements in the subexpression of EXPR
2633    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
2634
2635 static int
2636 length_of_subexp (expr, endpos)
2637      register struct expression *expr;
2638      register int endpos;
2639 {
2640   register int oplen = 1;
2641   register int args = 0;
2642   register int i;
2643
2644   if (endpos < 0)
2645     error ("?error in length_of_subexp");
2646
2647   i = (int) expr->elts[endpos - 1].opcode;
2648
2649   switch (i)
2650     {
2651       /* C++  */
2652     case OP_SCOPE:
2653       oplen = 4 + ((expr->elts[endpos - 2].longconst
2654                     + sizeof (union exp_element))
2655                    / sizeof (union exp_element));
2656       break;
2657
2658     case OP_LONG:
2659     case OP_DOUBLE:
2660       oplen = 4;
2661       break;
2662
2663     case OP_VAR_VALUE:
2664     case OP_LAST:
2665     case OP_REGISTER:
2666     case OP_INTERNALVAR:
2667       oplen = 3;
2668       break;
2669
2670     case OP_FUNCALL:
2671       oplen = 3;
2672       args = 1 + expr->elts[endpos - 2].longconst;
2673       break;
2674
2675     case UNOP_CAST:
2676     case UNOP_MEMVAL:
2677       oplen = 3;
2678       args = 1;
2679       break;
2680
2681     case STRUCTOP_STRUCT:
2682     case STRUCTOP_PTR:
2683       args = 1;
2684     case OP_STRING:
2685       oplen = 3 + ((expr->elts[endpos - 2].longconst
2686                     + sizeof (union exp_element))
2687                    / sizeof (union exp_element));
2688       break;
2689
2690     case TERNOP_COND:
2691       args = 3;
2692       break;
2693
2694     case BINOP_ASSIGN_MODIFY:
2695       oplen = 3;
2696       args = 2;
2697       break;
2698
2699       /* C++ */
2700     case OP_THIS:
2701       oplen = 2;
2702       break;
2703
2704     default:
2705       args = 1 + (i < (int) BINOP_END);
2706     }
2707
2708   while (args > 0)
2709     {
2710       oplen += length_of_subexp (expr, endpos - oplen);
2711       args--;
2712     }
2713
2714   return oplen;
2715 }
2716
2717 /* Copy the subexpression ending just before index INEND in INEXPR
2718    into OUTEXPR, starting at index OUTBEG.
2719    In the process, convert it from suffix to prefix form.  */
2720
2721 static void
2722 prefixify_subexp (inexpr, outexpr, inend, outbeg)
2723      register struct expression *inexpr;
2724      struct expression *outexpr;
2725      register int inend;
2726      int outbeg;
2727 {
2728   register int oplen = 1;
2729   register int args = 0;
2730   register int i;
2731   int *arglens;
2732   enum exp_opcode opcode;
2733
2734   /* Compute how long the last operation is (in OPLEN),
2735      and also how many preceding subexpressions serve as
2736      arguments for it (in ARGS).  */
2737
2738   opcode = inexpr->elts[inend - 1].opcode;
2739   switch (opcode)
2740     {
2741       /* C++  */
2742     case OP_SCOPE:
2743       oplen = 4 + ((inexpr->elts[inend - 2].longconst
2744                     + sizeof (union exp_element))
2745                    / sizeof (union exp_element));
2746       break;
2747
2748     case OP_LONG:
2749     case OP_DOUBLE:
2750       oplen = 4;
2751       break;
2752
2753     case OP_VAR_VALUE:
2754     case OP_LAST:
2755     case OP_REGISTER:
2756     case OP_INTERNALVAR:
2757       oplen = 3;
2758       break;
2759
2760     case OP_FUNCALL:
2761       oplen = 3;
2762       args = 1 + inexpr->elts[inend - 2].longconst;
2763       break;
2764
2765     case UNOP_CAST:
2766     case UNOP_MEMVAL:
2767       oplen = 3;
2768       args = 1;
2769       break;
2770
2771     case STRUCTOP_STRUCT:
2772     case STRUCTOP_PTR:
2773       args = 1;
2774     case OP_STRING:
2775       oplen = 3 + ((inexpr->elts[inend - 2].longconst
2776                     + sizeof (union exp_element))
2777                    / sizeof (union exp_element));
2778
2779       break;
2780
2781     case TERNOP_COND:
2782       args = 3;
2783       break;
2784
2785     case BINOP_ASSIGN_MODIFY:
2786       oplen = 3;
2787       args = 2;
2788       break;
2789
2790       /* C++ */
2791     case OP_THIS:
2792       oplen = 2;
2793       break;
2794
2795     default:
2796       args = 1 + ((int) opcode < (int) BINOP_END);
2797     }
2798
2799   /* Copy the final operator itself, from the end of the input
2800      to the beginning of the output.  */
2801   inend -= oplen;
2802   bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
2803          oplen * sizeof (union exp_element));
2804   outbeg += oplen;
2805
2806   /* Find the lengths of the arg subexpressions.  */
2807   arglens = (int *) alloca (args * sizeof (int));
2808   for (i = args - 1; i >= 0; i--)
2809     {
2810       oplen = length_of_subexp (inexpr, inend);
2811       arglens[i] = oplen;
2812       inend -= oplen;
2813     }
2814
2815   /* Now copy each subexpression, preserving the order of
2816      the subexpressions, but prefixifying each one.
2817      In this loop, inend starts at the beginning of
2818      the expression this level is working on
2819      and marches forward over the arguments.
2820      outbeg does similarly in the output.  */
2821   for (i = 0; i < args; i++)
2822     {
2823       oplen = arglens[i];
2824       inend += oplen;
2825       prefixify_subexp (inexpr, outexpr, inend, outbeg);
2826       outbeg += oplen;
2827     }
2828 }
2829 \f
2830 /* This page contains the two entry points to this file.  */
2831
2832 /* Read a C expression from the string *STRINGPTR points to,
2833    parse it, and return a pointer to a  struct expression  that we malloc.
2834    Use block BLOCK as the lexical context for variable names;
2835    if BLOCK is zero, use the block of the selected stack frame.
2836    Meanwhile, advance *STRINGPTR to point after the expression,
2837    at the first nonwhite character that is not part of the expression
2838    (possibly a null character).
2839
2840    If COMMA is nonzero, stop if a comma is reached.  */
2841
2842 struct expression *
2843 parse_c_1 (stringptr, block, comma)
2844      char **stringptr;
2845      struct block *block;
2846      int comma;
2847 {
2848   struct cleanup *old_chain;
2849
2850   lexptr = *stringptr;
2851
2852   paren_depth = 0;
2853   type_stack_depth = 0;
2854
2855   comma_terminates = comma;
2856
2857   if (lexptr == 0 || *lexptr == 0)
2858     error_no_arg ("expression to compute");
2859
2860   old_chain = make_cleanup (free_funcalls, 0);
2861   funcall_chain = 0;
2862
2863   expression_context_block = block ? block : get_selected_block ();
2864
2865   namecopy = (char *) alloca (strlen (lexptr) + 1);
2866   expout_size = 10;
2867   expout_ptr = 0;
2868   expout = (struct expression *)
2869     xmalloc (sizeof (struct expression)
2870              + expout_size * sizeof (union exp_element));
2871   make_cleanup (free_current_contents, &expout);
2872   if (yyparse ())
2873     yyerror (NULL);
2874   discard_cleanups (old_chain);
2875   expout->nelts = expout_ptr;
2876   expout = (struct expression *)
2877     xrealloc (expout,
2878               sizeof (struct expression)
2879               + expout_ptr * sizeof (union exp_element));
2880   prefixify_expression (expout);
2881   *stringptr = lexptr;
2882   return expout;
2883 }
2884
2885 /* Parse STRING as an expression, and complain if this fails
2886    to use up all of the contents of STRING.  */
2887
2888 struct expression *
2889 parse_c_expression (string)
2890      char *string;
2891 {
2892   register struct expression *exp;
2893   exp = parse_c_1 (&string, 0, 0);
2894   if (*string)
2895     error ("Junk after end of expression.");
2896   return exp;
2897 }
2898
2899 static void
2900 push_type (tp)
2901      enum type_pieces tp;
2902 {
2903   if (type_stack_depth == type_stack_size)
2904     {
2905       type_stack_size *= 2;
2906       type_stack = (union type_stack_elt *)
2907         xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
2908     }
2909   type_stack[type_stack_depth++].piece = tp;
2910 }
2911
2912 static void
2913 push_type_int (n)
2914      int n;
2915 {
2916   if (type_stack_depth == type_stack_size)
2917     {
2918       type_stack_size *= 2;
2919       type_stack = (union type_stack_elt *)
2920         xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
2921     }
2922   type_stack[type_stack_depth++].int_val = n;
2923 }
2924
2925 static enum type_pieces
2926 pop_type ()
2927 {
2928   if (type_stack_depth)
2929     return type_stack[--type_stack_depth].piece;
2930   return tp_end;
2931 }
2932
2933 static int
2934 pop_type_int ()
2935 {
2936   if (type_stack_depth)
2937     return type_stack[--type_stack_depth].int_val;
2938   /* "Can't happen".  */
2939   return 0;
2940 }
2941
2942 void
2943 _initialize_expread ()
2944 {
2945   type_stack_size = 80;
2946   type_stack_depth = 0;
2947   type_stack = (union type_stack_elt *)
2948     xmalloc (type_stack_size * sizeof (*type_stack));
2949 }