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