scripts/genksyms/parse.c_shipped

   1
   2 /*  A Bison parser, made from scripts/genksyms/parse.y
   3     by GNU Bison version 1.28  */
   4
   5 #define YYBISON 1  /* Identify Bison output.  */
   6
   7 #define ASM_KEYW        257
   8 #define ATTRIBUTE_KEYW  258
   9 #define AUTO_KEYW       259
  10 #define BOOL_KEYW       260
  11 #define CHAR_KEYW       261
  12 #define CONST_KEYW      262
  13 #define DOUBLE_KEYW     263
  14 #define ENUM_KEYW       264
  15 #define EXTERN_KEYW     265
  16 #define FLOAT_KEYW      266
  17 #define INLINE_KEYW     267
  18 #define INT_KEYW        268
  19 #define LONG_KEYW       269
  20 #define REGISTER_KEYW   270
  21 #define RESTRICT_KEYW   271
  22 #define SHORT_KEYW      272
  23 #define SIGNED_KEYW     273
  24 #define STATIC_KEYW     274
  25 #define STRUCT_KEYW     275
  26 #define TYPEDEF_KEYW    276
  27 #define UNION_KEYW      277
  28 #define UNSIGNED_KEYW   278
  29 #define VOID_KEYW       279
  30 #define VOLATILE_KEYW   280
  31 #define TYPEOF_KEYW     281
  32 #define EXPORT_SYMBOL_KEYW      282
  33 #define ASM_PHRASE      283
  34 #define ATTRIBUTE_PHRASE        284
  35 #define BRACE_PHRASE    285
  36 #define BRACKET_PHRASE  286
  37 #define EXPRESSION_PHRASE       287
  38 #define CHAR    288
  39 #define DOTS    289
  40 #define IDENT   290
  41 #define INT     291
  42 #define REAL    292
  43 #define STRING  293
  44 #define TYPE    294
  45 #define OTHER   295
  46 #define FILENAME        296
  47
  48 #line 24 "scripts/genksyms/parse.y"
  49
  50
  51 #include <assert.h>
  52 #include <malloc.h>
  53 #include "genksyms.h"
  54
  55 static int is_typedef;
  56 static int is_extern;
  57 static char *current_name;
  58 static struct string_list *decl_spec;
  59
  60 static void yyerror(const char *);
  61
  62 static inline void
  63 remove_node(struct string_list **p)
  64 {
  65   struct string_list *node = *p;
  66   *p = node->next;
  67   free_node(node);
  68 }
  69
  70 static inline void
  71 remove_list(struct string_list **pb, struct string_list **pe)
  72 {
  73   struct string_list *b = *pb, *e = *pe;
  74   *pb = e;
  75   free_list(b, e);
  76 }
  77
  78 #ifndef YYSTYPE
  79 #define YYSTYPE int
  80 #endif
  81 #ifndef YYDEBUG
  82 #define YYDEBUG 1
  83 #endif
  84
  85 #include <stdio.h>
  86
  87 #ifndef __cplusplus
  88 #ifndef __STDC__
  89 #define const
  90 #endif
  91 #endif
  92
  93
  94
  95 #define YYFINAL         172
  96 #define YYFLAG          -32768
  97 #define YYNTBASE        52
  98
  99 #define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 96)
 100
 101 static const char yytranslate[] = {     0,
 102      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 103      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 104      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 105      2,     2,     2,     2,     2,     2,     2,     2,     2,    46,
 106     47,    48,     2,    45,     2,     2,     2,     2,     2,     2,
 107      2,     2,     2,     2,     2,     2,     2,    51,    43,     2,
 108     49,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 109      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 110      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 112      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 114      2,     2,    50,     2,    44,     2,     2,     2,     2,     2,
 115      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 116      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 120      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 121      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 122      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 123      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 124      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 125      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 126      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 127      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 128      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 129     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 130     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 131     37,    38,    39,    40,    41,    42
 132 };
 133
 134 #if YYDEBUG != 0
 135 static const short yyprhs[] = {     0,
 136      0,     2,     5,     6,     9,    10,    14,    16,    18,    20,
 137     22,    25,    28,    32,    33,    35,    37,    41,    46,    47,
 138     49,    51,    54,    56,    58,    60,    62,    64,    66,    68,
 139     70,    72,    77,    80,    83,    86,    90,    94,    98,   101,
 140    104,   107,   109,   111,   113,   115,   117,   119,   121,   123,
 141    125,   127,   129,   132,   133,   135,   137,   140,   142,   144,
 142    146,   148,   151,   153,   155,   160,   165,   168,   172,   176,
 143    179,   181,   183,   185,   190,   195,   198,   202,   206,   209,
 144    211,   215,   216,   218,   220,   224,   227,   230,   232,   233,
 145    235,   237,   242,   247,   250,   254,   258,   262,   263,   265,
 146    268,   272,   276,   277,   279,   281,   284,   288,   291,   292,
 147    294,   296,   300,   303,   306,   308,   311,   312,   314,   317,
 148    318,   320
 149 };
 150
 151 static const short yyrhs[] = {    53,
 152      0,    52,    53,     0,     0,    54,    55,     0,     0,    22,
 153     56,    57,     0,    57,     0,    81,     0,    93,     0,    95,
 154      0,     1,    43,     0,     1,    44,     0,    61,    58,    43,
 155      0,     0,    59,     0,    60,     0,    59,    45,    60,     0,
 156     71,    94,    92,    82,     0,     0,    62,     0,    63,     0,
 157     62,    63,     0,    64,     0,    65,     0,     5,     0,    16,
 158      0,    20,     0,    11,     0,    13,     0,    66,     0,    70,
 159      0,    27,    46,    62,    47,     0,    21,    36,     0,    23,
 160     36,     0,    10,    36,     0,    21,    36,    84,     0,    23,
 161     36,    84,     0,    10,    36,    31,     0,    10,    31,     0,
 162     21,    84,     0,    23,    84,     0,     7,     0,    18,     0,
 163     14,     0,    15,     0,    19,     0,    24,     0,    12,     0,
 164      9,     0,    25,     0,     6,     0,    40,     0,    48,    68,
 165      0,     0,    69,     0,    70,     0,    69,    70,     0,     8,
 166      0,    26,     0,    30,     0,    17,     0,    67,    71,     0,
 167     72,     0,    36,     0,    72,    46,    75,    47,     0,    72,
 168     46,     1,    47,     0,    72,    32,     0,    46,    71,    47,
 169      0,    46,     1,    47,     0,    67,    73,     0,    74,     0,
 170     36,     0,    40,     0,    74,    46,    75,    47,     0,    74,
 171     46,     1,    47,     0,    74,    32,     0,    46,    73,    47,
 172      0,    46,     1,    47,     0,    76,    35,     0,    76,     0,
 173     77,    45,    35,     0,     0,    77,     0,    78,     0,    77,
 174     45,    78,     0,    62,    79,     0,    67,    79,     0,    80,
 175      0,     0,    36,     0,    40,     0,    80,    46,    75,    47,
 176      0,    80,    46,     1,    47,     0,    80,    32,     0,    46,
 177     79,    47,     0,    46,     1,    47,     0,    61,    71,    31,
 178      0,     0,    83,     0,    49,    33,     0,    50,    85,    44,
 179      0,    50,     1,    44,     0,     0,    86,     0,    87,     0,
 180     86,    87,     0,    61,    88,    43,     0,     1,    43,     0,
 181      0,    89,     0,    90,     0,    89,    45,    90,     0,    73,
 182     92,     0,    36,    91,     0,    91,     0,    51,    33,     0,
 183      0,    30,     0,    29,    43,     0,     0,    29,     0,    28,
 184     46,    36,    47,    43,     0
 185 };
 186
 187 #endif
 188
 189 #if YYDEBUG != 0
 190 static const short yyrline[] = { 0,
 191    101,   103,   106,   109,   112,   114,   115,   116,   117,   118,
 192    119,   120,   123,   137,   139,   142,   151,   163,   169,   171,
 193    174,   176,   179,   186,   189,   191,   192,   193,   194,   197,
 194    199,   200,   204,   206,   208,   212,   219,   226,   235,   236,
 195    237,   240,   242,   243,   244,   245,   246,   247,   248,   249,
 196    250,   251,   254,   259,   261,   264,   266,   269,   270,   270,
 197    271,   278,   280,   283,   293,   295,   297,   299,   301,   307,
 198    309,   312,   314,   315,   317,   319,   321,   323,   327,   329,
 199    330,   333,   335,   338,   340,   344,   349,   352,   355,   357,
 200    365,   369,   371,   373,   375,   377,   381,   390,   392,   396,
 201    401,   403,   406,   408,   411,   413,   416,   419,   423,   425,
 202    428,   430,   433,   435,   436,   439,   443,   445,   448,   452,
 203    454,   457
 204 };
 205 #endif
 206
 207
 208 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 209
 210 static const char * const yytname[] = {   "$","error","$undefined.","ASM_KEYW",
 211 "ATTRIBUTE_KEYW","AUTO_KEYW","BOOL_KEYW","CHAR_KEYW","CONST_KEYW","DOUBLE_KEYW",
 212 "ENUM_KEYW","EXTERN_KEYW","FLOAT_KEYW","INLINE_KEYW","INT_KEYW","LONG_KEYW",
 213 "REGISTER_KEYW","RESTRICT_KEYW","SHORT_KEYW","SIGNED_KEYW","STATIC_KEYW","STRUCT_KEYW",
 214 "TYPEDEF_KEYW","UNION_KEYW","UNSIGNED_KEYW","VOID_KEYW","VOLATILE_KEYW","TYPEOF_KEYW",
 215 "EXPORT_SYMBOL_KEYW","ASM_PHRASE","ATTRIBUTE_PHRASE","BRACE_PHRASE","BRACKET_PHRASE",
 216 "EXPRESSION_PHRASE","CHAR","DOTS","IDENT","INT","REAL","STRING","TYPE","OTHER",
 217 "FILENAME","';'","'}'","','","'('","')'","'*'","'='","'{'","':'","declaration_seq",
 218 "declaration","@1","declaration1","@2","simple_declaration","init_declarator_list_opt",
 219 "init_declarator_list","init_declarator","decl_specifier_seq_opt","decl_specifier_seq",
 220 "decl_specifier","storage_class_specifier","type_specifier","simple_type_specifier",
 221 "ptr_operator","cvar_qualifier_seq_opt","cvar_qualifier_seq","cvar_qualifier",
 222 "declarator","direct_declarator","nested_declarator","direct_nested_declarator",
 223 "parameter_declaration_clause","parameter_declaration_list_opt","parameter_declaration_list",
 224 "parameter_declaration","m_abstract_declarator","direct_m_abstract_declarator",
 225 "function_definition","initializer_opt","initializer","class_body","member_specification_opt",
 226 "member_specification","member_declaration","member_declarator_list_opt","member_declarator_list",
 227 "member_declarator","member_bitfield_declarator","attribute_opt","asm_definition",
 228 "asm_phrase_opt","export_definition", NULL
 229 };
 230 #endif
 231
 232 static const short yyr1[] = {     0,
 233     52,    52,    54,    53,    56,    55,    55,    55,    55,    55,
 234     55,    55,    57,    58,    58,    59,    59,    60,    61,    61,
 235     62,    62,    63,    63,    64,    64,    64,    64,    64,    65,
 236     65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
 237     65,    66,    66,    66,    66,    66,    66,    66,    66,    66,
 238     66,    66,    67,    68,    68,    69,    69,    70,    70,    70,
 239     70,    71,    71,    72,    72,    72,    72,    72,    72,    73,
 240     73,    74,    74,    74,    74,    74,    74,    74,    75,    75,
 241     75,    76,    76,    77,    77,    78,    79,    79,    80,    80,
 242     80,    80,    80,    80,    80,    80,    81,    82,    82,    83,
 243     84,    84,    85,    85,    86,    86,    87,    87,    88,    88,
 244     89,    89,    90,    90,    90,    91,    92,    92,    93,    94,
 245     94,    95
 246 };
 247
 248 static const short yyr2[] = {     0,
 249      1,     2,     0,     2,     0,     3,     1,     1,     1,     1,
 250      2,     2,     3,     0,     1,     1,     3,     4,     0,     1,
 251      1,     2,     1,     1,     1,     1,     1,     1,     1,     1,
 252      1,     4,     2,     2,     2,     3,     3,     3,     2,     2,
 253      2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 254      1,     1,     2,     0,     1,     1,     2,     1,     1,     1,
 255      1,     2,     1,     1,     4,     4,     2,     3,     3,     2,
 256      1,     1,     1,     4,     4,     2,     3,     3,     2,     1,
 257      3,     0,     1,     1,     3,     2,     2,     1,     0,     1,
 258      1,     4,     4,     2,     3,     3,     3,     0,     1,     2,
 259      3,     3,     0,     1,     1,     2,     3,     2,     0,     1,
 260      1,     3,     2,     2,     1,     2,     0,     1,     2,     0,
 261      1,     5
 262 };
 263
 264 static const short yydefact[] = {     3,
 265      3,     1,     0,     2,     0,    25,    51,    42,    58,    49,
 266      0,    28,    48,    29,    44,    45,    26,    61,    43,    46,
 267     27,     0,     5,     0,    47,    50,    59,     0,     0,     0,
 268     60,    52,     4,     7,    14,    20,    21,    23,    24,    30,
 269     31,     8,     9,    10,    11,    12,    39,    35,    33,     0,
 270     40,    19,    34,    41,     0,     0,   119,    64,     0,    54,
 271      0,    15,    16,     0,   120,    63,    22,    38,    36,     0,
 272    109,     0,     0,   105,     6,    14,    37,     0,     0,     0,
 273      0,    53,    55,    56,    13,     0,    62,   121,    97,   117,
 274     67,     0,   108,   102,    72,    73,     0,     0,     0,   117,
 275     71,     0,   110,   111,   115,   101,     0,   106,   120,    32,
 276      0,    69,    68,    57,    17,   118,    98,     0,    89,     0,
 277     80,    83,    84,   114,     0,    72,     0,   116,    70,   113,
 278     76,     0,   107,     0,   122,     0,    18,    99,    66,    90,
 279     52,     0,    89,    86,    88,    65,    79,     0,    78,    77,
 280      0,     0,   112,   100,     0,    91,     0,    87,    94,     0,
 281     81,    85,    75,    74,    96,    95,     0,     0,    93,    92,
 282      0,     0
 283 };
 284
 285 static const short yydefgoto[] = {     1,
 286      2,     3,    33,    52,    34,    61,    62,    63,    71,    36,
 287     37,    38,    39,    40,    64,    82,    83,    41,   109,    66,
 288    100,   101,   120,   121,   122,   123,   144,   145,    42,   137,
 289    138,    51,    72,    73,    74,   102,   103,   104,   105,   117,
 290     43,    90,    44
 291 };
 292
 293 static const short yypact[] = {-32768,
 294     15,-32768,   197,-32768,    23,-32768,-32768,-32768,-32768,-32768,
 295    -18,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 296 -32768,   -28,-32768,   -25,-32768,-32768,-32768,   -26,   -22,   -12,
 297 -32768,-32768,-32768,-32768,    49,   493,-32768,-32768,-32768,-32768,
 298 -32768,-32768,-32768,-32768,-32768,-32768,-32768,    27,    -8,   101,
 299 -32768,   493,    -8,-32768,   493,    10,-32768,-32768,    11,     9,
 300     18,    26,-32768,    49,   -15,   -13,-32768,-32768,-32768,    25,
 301     24,    48,   149,-32768,-32768,    49,-32768,   414,    39,    40,
 302     47,-32768,     9,-32768,-32768,    49,-32768,-32768,-32768,    66,
 303 -32768,   241,-32768,-32768,    50,-32768,     5,    65,    42,    66,
 304     17,    56,    55,-32768,-32768,-32768,    60,-32768,    75,-32768,
 305     80,-32768,-32768,-32768,-32768,-32768,    81,    82,   370,    85,
 306     98,    89,-32768,-32768,    88,-32768,    91,-32768,-32768,-32768,
 307 -32768,   284,-32768,    24,-32768,   103,-32768,-32768,-32768,-32768,
 308 -32768,     8,    43,-32768,    30,-32768,-32768,   457,-32768,-32768,
 309     92,    93,-32768,-32768,    95,-32768,    96,-32768,-32768,   327,
 310 -32768,-32768,-32768,-32768,-32768,-32768,    99,   104,-32768,-32768,
 311    148,-32768
 312 };
 313
 314 static const short yypgoto[] = {-32768,
 315    152,-32768,-32768,-32768,   119,-32768,-32768,    94,     0,   -55,
 316    -35,-32768,-32768,-32768,   -69,-32768,-32768,   -56,   -30,-32768,
 317    -76,-32768,  -122,-32768,-32768,    29,   -62,-32768,-32768,-32768,
 318 -32768,   -17,-32768,-32768,   105,-32768,-32768,    52,    86,    83,
 319 -32768,-32768,-32768
 320 };
 321
 322
 323 #define YYLAST          533
 324
 325
 326 static const short yytable[] = {    78,
 327     67,    99,    35,    84,    65,   125,    54,    49,   155,   152,
 328     53,    80,    47,    88,   171,    89,     9,    48,    91,    55,
 329    127,    50,   129,    56,    50,    18,   114,    99,    81,    99,
 330     57,    69,    92,    87,    27,    77,   119,   168,    31,   -89,
 331    126,    50,    67,   140,    96,    79,    58,   156,   131,   143,
 332     97,    76,    60,   142,   -89,    60,    59,    68,    60,    95,
 333     85,   159,   132,    96,    99,    45,    46,    93,    94,    97,
 334     86,    60,   143,   143,    98,   160,   119,   126,   140,   157,
 335    158,    96,   156,    67,    58,   111,   112,    97,   142,    60,
 336     60,   106,   119,   113,    59,   116,    60,   128,   133,   134,
 337     98,    70,    93,    88,   119,     6,     7,     8,     9,    10,
 338     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 339     21,    22,   135,    24,    25,    26,    27,    28,   139,   136,
 340     31,   146,   147,   148,   149,   154,   -19,   150,   163,   164,
 341     32,   165,   166,   -19,  -103,   169,   -19,   172,   -19,   107,
 342    170,   -19,     4,     6,     7,     8,     9,    10,    11,    12,
 343     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
 344     75,    24,    25,    26,    27,    28,   162,   108,    31,   115,
 345    124,     0,   130,     0,   -19,   153,     0,     0,    32,     0,
 346      0,   -19,  -104,     0,   -19,     0,   -19,     5,     0,   -19,
 347      0,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 348     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 349     25,    26,    27,    28,    29,    30,    31,     0,     0,     0,
 350      0,     0,   -19,     0,     0,     0,    32,     0,     0,   -19,
 351      0,   118,   -19,     0,   -19,     6,     7,     8,     9,    10,
 352     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 353     21,    22,     0,    24,    25,    26,    27,    28,     0,     0,
 354     31,     0,     0,     0,     0,   -82,     0,     0,     0,     0,
 355     32,     0,     0,     0,   151,     0,     0,   -82,     6,     7,
 356      8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 357     18,    19,    20,    21,    22,     0,    24,    25,    26,    27,
 358     28,     0,     0,    31,     0,     0,     0,     0,   -82,     0,
 359      0,     0,     0,    32,     0,     0,     0,   167,     0,     0,
 360    -82,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 361     15,    16,    17,    18,    19,    20,    21,    22,     0,    24,
 362     25,    26,    27,    28,     0,     0,    31,     0,     0,     0,
 363      0,   -82,     0,     0,     0,     0,    32,     0,     0,     0,
 364      0,     0,     0,   -82,     6,     7,     8,     9,    10,    11,
 365     12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
 366     22,     0,    24,    25,    26,    27,    28,     0,     0,    31,
 367      0,     0,     0,     0,     0,   140,     0,     0,     0,   141,
 368      0,     0,     0,     0,     0,   142,     0,    60,     6,     7,
 369      8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 370     18,    19,    20,    21,    22,     0,    24,    25,    26,    27,
 371     28,     0,     0,    31,     0,     0,     0,     0,     0,     0,
 372      0,     0,     0,    32,     0,     0,     0,     0,     0,     0,
 373    110,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 374     15,    16,    17,    18,    19,    20,    21,    22,     0,    24,
 375     25,    26,    27,    28,     0,     0,    31,     0,     0,     0,
 376      0,   161,     0,     0,     0,     0,    32,     6,     7,     8,
 377      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
 378     19,    20,    21,    22,     0,    24,    25,    26,    27,    28,
 379      0,     0,    31,     0,     0,     0,     0,     0,     0,     0,
 380      0,     0,    32
 381 };
 382
 383 static const short yycheck[] = {    55,
 384     36,    71,     3,    60,    35,     1,    24,    36,     1,   132,
 385     36,     1,    31,    29,     0,    31,     8,    36,    32,    46,
 386     97,    50,    99,    46,    50,    17,    83,    97,    59,    99,
 387     43,    49,    46,    64,    26,    53,    92,   160,    30,    32,
 388     36,    50,    78,    36,    40,    36,    36,    40,    32,   119,
 389     46,    52,    48,    46,    47,    48,    46,    31,    48,    36,
 390     43,    32,    46,    40,   134,    43,    44,    43,    44,    46,
 391     45,    48,   142,   143,    51,    46,   132,    36,    36,   142,
 392    143,    40,    40,   119,    36,    47,    47,    46,    46,    48,
 393     48,    44,   148,    47,    46,    30,    48,    33,    43,    45,
 394     51,     1,    43,    29,   160,     5,     6,     7,     8,     9,
 395     10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 396     20,    21,    43,    23,    24,    25,    26,    27,    47,    49,
 397     30,    47,    35,    45,    47,    33,    36,    47,    47,    47,
 398     40,    47,    47,    43,    44,    47,    46,     0,    48,     1,
 399     47,    51,     1,     5,     6,     7,     8,     9,    10,    11,
 400     12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
 401     52,    23,    24,    25,    26,    27,   148,    73,    30,    86,
 402     95,    -1,   100,    -1,    36,   134,    -1,    -1,    40,    -1,
 403     -1,    43,    44,    -1,    46,    -1,    48,     1,    -1,    51,
 404     -1,     5,     6,     7,     8,     9,    10,    11,    12,    13,
 405     14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
 406     24,    25,    26,    27,    28,    29,    30,    -1,    -1,    -1,
 407     -1,    -1,    36,    -1,    -1,    -1,    40,    -1,    -1,    43,
 408     -1,     1,    46,    -1,    48,     5,     6,     7,     8,     9,
 409     10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 410     20,    21,    -1,    23,    24,    25,    26,    27,    -1,    -1,
 411     30,    -1,    -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,
 412     40,    -1,    -1,    -1,     1,    -1,    -1,    47,     5,     6,
 413      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 414     17,    18,    19,    20,    21,    -1,    23,    24,    25,    26,
 415     27,    -1,    -1,    30,    -1,    -1,    -1,    -1,    35,    -1,
 416     -1,    -1,    -1,    40,    -1,    -1,    -1,     1,    -1,    -1,
 417     47,     5,     6,     7,     8,     9,    10,    11,    12,    13,
 418     14,    15,    16,    17,    18,    19,    20,    21,    -1,    23,
 419     24,    25,    26,    27,    -1,    -1,    30,    -1,    -1,    -1,
 420     -1,    35,    -1,    -1,    -1,    -1,    40,    -1,    -1,    -1,
 421     -1,    -1,    -1,    47,     5,     6,     7,     8,     9,    10,
 422     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 423     21,    -1,    23,    24,    25,    26,    27,    -1,    -1,    30,
 424     -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,    40,
 425     -1,    -1,    -1,    -1,    -1,    46,    -1,    48,     5,     6,
 426      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 427     17,    18,    19,    20,    21,    -1,    23,    24,    25,    26,
 428     27,    -1,    -1,    30,    -1,    -1,    -1,    -1,    -1,    -1,
 429     -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,
 430     47,     5,     6,     7,     8,     9,    10,    11,    12,    13,
 431     14,    15,    16,    17,    18,    19,    20,    21,    -1,    23,
 432     24,    25,    26,    27,    -1,    -1,    30,    -1,    -1,    -1,
 433     -1,    35,    -1,    -1,    -1,    -1,    40,     5,     6,     7,
 434      8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 435     18,    19,    20,    21,    -1,    23,    24,    25,    26,    27,
 436     -1,    -1,    30,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 437     -1,    -1,    40
 438 };
 439 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 440 #line 3 "/usr/lib/bison.simple"
 441 /* This file comes from bison-1.28.  */
 442
 443 /* Skeleton output parser for bison,
 444    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 445
 446    This program is free software; you can redistribute it and/or modify
 447    it under the terms of the GNU General Public License as published by
 448    the Free Software Foundation; either version 2, or (at your option)
 449    any later version.
 450
 451    This program is distributed in the hope that it will be useful,
 452    but WITHOUT ANY WARRANTY; without even the implied warranty of
 453    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 454    GNU General Public License for more details.
 455
 456    You should have received a copy of the GNU General Public License
 457    along with this program; if not, write to the Free Software
 458    Foundation, Inc., 59 Temple Place - Suite 330,
 459    Boston, MA 02111-1307, USA.  */
 460
 461 /* As a special exception, when this file is copied by Bison into a
 462    Bison output file, you may use that output file without restriction.
 463    This special exception was added by the Free Software Foundation
 464    in version 1.24 of Bison.  */
 465
 466 /* This is the parser code that is written into each bison parser
 467   when the %semantic_parser declaration is not specified in the grammar.
 468   It was written by Richard Stallman by simplifying the hairy parser
 469   used when %semantic_parser is specified.  */
 470
 471 #ifndef YYSTACK_USE_ALLOCA
 472 #ifdef alloca
 473 #define YYSTACK_USE_ALLOCA
 474 #else /* alloca not defined */
 475 #ifdef __GNUC__
 476 #define YYSTACK_USE_ALLOCA
 477 #define alloca __builtin_alloca
 478 #else /* not GNU C.  */
 479 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 480 #define YYSTACK_USE_ALLOCA
 481 #include <alloca.h>
 482 #else /* not sparc */
 483 /* We think this test detects Watcom and Microsoft C.  */
 484 /* This used to test MSDOS, but that is a bad idea
 485    since that symbol is in the user namespace.  */
 486 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 487 #if 0 /* No need for malloc.h, which pollutes the namespace;
 488          instead, just don't use alloca.  */
 489 #include <malloc.h>
 490 #endif
 491 #else /* not MSDOS, or __TURBOC__ */
 492 #if defined(_AIX)
 493 /* I don't know what this was needed for, but it pollutes the namespace.
 494    So I turned it off.   rms, 2 May 1997.  */
 495 /* #include <malloc.h>  */
 496  #pragma alloca
 497 #define YYSTACK_USE_ALLOCA
 498 #else /* not MSDOS, or __TURBOC__, or _AIX */
 499 #if 0
 500 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 501                  and on HPUX 10.  Eventually we can turn this on.  */
 502 #define YYSTACK_USE_ALLOCA
 503 #define alloca __builtin_alloca
 504 #endif /* __hpux */
 505 #endif
 506 #endif /* not _AIX */
 507 #endif /* not MSDOS, or __TURBOC__ */
 508 #endif /* not sparc */
 509 #endif /* not GNU C */
 510 #endif /* alloca not defined */
 511 #endif /* YYSTACK_USE_ALLOCA not defined */
 512
 513 #ifdef YYSTACK_USE_ALLOCA
 514 #define YYSTACK_ALLOC alloca
 515 #else
 516 #define YYSTACK_ALLOC malloc
 517 #endif
 518
 519 /* Note: there must be only one dollar sign in this file.
 520    It is replaced by the list of actions, each action
 521    as one case of the switch.  */
 522
 523 #define yyerrok         (yyerrstatus = 0)
 524 #define yyclearin       (yychar = YYEMPTY)
 525 #define YYEMPTY         -2
 526 #define YYEOF           0
 527 #define YYACCEPT        goto yyacceptlab
 528 #define YYABORT         goto yyabortlab
 529 #define YYERROR         goto yyerrlab1
 530 /* Like YYERROR except do call yyerror.
 531    This remains here temporarily to ease the
 532    transition to the new meaning of YYERROR, for GCC.
 533    Once GCC version 2 has supplanted version 1, this can go.  */
 534 #define YYFAIL          goto yyerrlab
 535 #define YYRECOVERING()  (!!yyerrstatus)
 536 #define YYBACKUP(token, value) \
 537 do                                                              \
 538   if (yychar == YYEMPTY && yylen == 1)                          \
 539     { yychar = (token), yylval = (value);                       \
 540       yychar1 = YYTRANSLATE (yychar);                           \
 541       YYPOPSTACK;                                               \
 542       goto yybackup;                                            \
 543     }                                                           \
 544   else                                                          \
 545     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 546 while (0)
 547
 548 #define YYTERROR        1
 549 #define YYERRCODE       256
 550
 551 #ifndef YYPURE
 552 #define YYLEX           yylex()
 553 #endif
 554
 555 #ifdef YYPURE
 556 #ifdef YYLSP_NEEDED
 557 #ifdef YYLEX_PARAM
 558 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 559 #else
 560 #define YYLEX           yylex(&yylval, &yylloc)
 561 #endif
 562 #else /* not YYLSP_NEEDED */
 563 #ifdef YYLEX_PARAM
 564 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 565 #else
 566 #define YYLEX           yylex(&yylval)
 567 #endif
 568 #endif /* not YYLSP_NEEDED */
 569 #endif
 570
 571 /* If nonreentrant, generate the variables here */
 572
 573 #ifndef YYPURE
 574
 575 int     yychar;                 /*  the lookahead symbol                */
 576 YYSTYPE yylval;                 /*  the semantic value of the           */
 577                                 /*  lookahead symbol                    */
 578
 579 #ifdef YYLSP_NEEDED
 580 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 581                                 /*  symbol                              */
 582 #endif
 583
 584 int yynerrs;                    /*  number of parse errors so far       */
 585 #endif  /* not YYPURE */
 586
 587 #if YYDEBUG != 0
 588 int yydebug;                    /*  nonzero means print parse trace     */
 589 /* Since this is uninitialized, it does not stop multiple parsers
 590    from coexisting.  */
 591 #endif
 592
 593 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 594
 595 #ifndef YYINITDEPTH
 596 #define YYINITDEPTH 200
 597 #endif
 598
 599 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 600     (effective only if the built-in stack extension method is used).  */
 601
 602 #if YYMAXDEPTH == 0
 603 #undef YYMAXDEPTH
 604 #endif
 605
 606 #ifndef YYMAXDEPTH
 607 #define YYMAXDEPTH 10000
 608 #endif
 609 \f
 610 /* Define __yy_memcpy.  Note that the size argument
 611    should be passed with type unsigned int, because that is what the non-GCC
 612    definitions require.  With GCC, __builtin_memcpy takes an arg
 613    of type size_t, but it can handle unsigned int.  */
 614
 615 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 616 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 617 #else                           /* not GNU C or C++ */
 618 #ifndef __cplusplus
 619
 620 /* This is the most reliable way to avoid incompatibilities
 621    in available built-in functions on various systems.  */
 622 static void
 623 __yy_memcpy (to, from, count)
 624      char *to;
 625      char *from;
 626      unsigned int count;
 627 {
 628   register char *f = from;
 629   register char *t = to;
 630   register int i = count;
 631
 632   while (i-- > 0)
 633     *t++ = *f++;
 634 }
 635
 636 #else /* __cplusplus */
 637
 638 /* This is the most reliable way to avoid incompatibilities
 639    in available built-in functions on various systems.  */
 640 static void
 641 __yy_memcpy (char *to, char *from, unsigned int count)
 642 {
 643   register char *t = to;
 644   register char *f = from;
 645   register int i = count;
 646
 647   while (i-- > 0)
 648     *t++ = *f++;
 649 }
 650
 651 #endif
 652 #endif
 653 \f
 654 #line 217 "/usr/lib/bison.simple"
 655
 656 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 657    into yyparse.  The argument should have type void *.
 658    It should actually point to an object.
 659    Grammar actions can access the variable by casting it
 660    to the proper pointer type.  */
 661
 662 #ifdef YYPARSE_PARAM
 663 #ifdef __cplusplus
 664 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 665 #define YYPARSE_PARAM_DECL
 666 #else /* not __cplusplus */
 667 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 668 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 669 #endif /* not __cplusplus */
 670 #else /* not YYPARSE_PARAM */
 671 #define YYPARSE_PARAM_ARG
 672 #define YYPARSE_PARAM_DECL
 673 #endif /* not YYPARSE_PARAM */
 674
 675 /* Prevent warning if -Wstrict-prototypes.  */
 676 #ifdef __GNUC__
 677 #ifdef YYPARSE_PARAM
 678 int yyparse (void *);
 679 #else
 680 int yyparse (void);
 681 #endif
 682 #endif
 683
 684 int
 685 yyparse(YYPARSE_PARAM_ARG)
 686      YYPARSE_PARAM_DECL
 687 {
 688   register int yystate;
 689   register int yyn;
 690   register short *yyssp;
 691   register YYSTYPE *yyvsp;
 692   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 693   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 694
 695   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 696   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 697
 698   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 699   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 700
 701 #ifdef YYLSP_NEEDED
 702   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 703   YYLTYPE *yyls = yylsa;
 704   YYLTYPE *yylsp;
 705
 706 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 707 #else
 708 #define YYPOPSTACK   (yyvsp--, yyssp--)
 709 #endif
 710
 711   int yystacksize = YYINITDEPTH;
 712   int yyfree_stacks = 0;
 713
 714 #ifdef YYPURE
 715   int yychar;
 716   YYSTYPE yylval;
 717   int yynerrs;
 718 #ifdef YYLSP_NEEDED
 719   YYLTYPE yylloc;
 720 #endif
 721 #endif
 722
 723   YYSTYPE yyval;                /*  the variable used to return         */
 724                                 /*  semantic values from the action     */
 725                                 /*  routines                            */
 726
 727   int yylen;
 728
 729 #if YYDEBUG != 0
 730   if (yydebug)
 731     fprintf(stderr, "Starting parse\n");
 732 #endif
 733
 734   yystate = 0;
 735   yyerrstatus = 0;
 736   yynerrs = 0;
 737   yychar = YYEMPTY;             /* Cause a token to be read.  */
 738
 739   /* Initialize stack pointers.
 740      Waste one element of value and location stack
 741      so that they stay on the same level as the state stack.
 742      The wasted elements are never initialized.  */
 743
 744   yyssp = yyss - 1;
 745   yyvsp = yyvs;
 746 #ifdef YYLSP_NEEDED
 747   yylsp = yyls;
 748 #endif
 749
 750 /* Push a new state, which is found in  yystate  .  */
 751 /* In all cases, when you get here, the value and location stacks
 752    have just been pushed. so pushing a state here evens the stacks.  */
 753 yynewstate:
 754
 755   *++yyssp = yystate;
 756
 757   if (yyssp >= yyss + yystacksize - 1)
 758     {
 759       /* Give user a chance to reallocate the stack */
 760       /* Use copies of these so that the &'s don't force the real ones into memory. */
 761       YYSTYPE *yyvs1 = yyvs;
 762       short *yyss1 = yyss;
 763 #ifdef YYLSP_NEEDED
 764       YYLTYPE *yyls1 = yyls;
 765 #endif
 766
 767       /* Get the current used size of the three stacks, in elements.  */
 768       int size = yyssp - yyss + 1;
 769
 770 #ifdef yyoverflow
 771       /* Each stack pointer address is followed by the size of
 772          the data in use in that stack, in bytes.  */
 773 #ifdef YYLSP_NEEDED
 774       /* This used to be a conditional around just the two extra args,
 775          but that might be undefined if yyoverflow is a macro.  */
 776       yyoverflow("parser stack overflow",
 777                  &yyss1, size * sizeof (*yyssp),
 778                  &yyvs1, size * sizeof (*yyvsp),
 779                  &yyls1, size * sizeof (*yylsp),
 780                  &yystacksize);
 781 #else
 782       yyoverflow("parser stack overflow",
 783                  &yyss1, size * sizeof (*yyssp),
 784                  &yyvs1, size * sizeof (*yyvsp),
 785                  &yystacksize);
 786 #endif
 787
 788       yyss = yyss1; yyvs = yyvs1;
 789 #ifdef YYLSP_NEEDED
 790       yyls = yyls1;
 791 #endif
 792 #else /* no yyoverflow */
 793       /* Extend the stack our own way.  */
 794       if (yystacksize >= YYMAXDEPTH)
 795         {
 796           yyerror("parser stack overflow");
 797           if (yyfree_stacks)
 798             {
 799               free (yyss);
 800               free (yyvs);
 801 #ifdef YYLSP_NEEDED
 802               free (yyls);
 803 #endif
 804             }
 805           return 2;
 806         }
 807       yystacksize *= 2;
 808       if (yystacksize > YYMAXDEPTH)
 809         yystacksize = YYMAXDEPTH;
 810 #ifndef YYSTACK_USE_ALLOCA
 811       yyfree_stacks = 1;
 812 #endif
 813       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 814       __yy_memcpy ((char *)yyss, (char *)yyss1,
 815                    size * (unsigned int) sizeof (*yyssp));
 816       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 817       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 818                    size * (unsigned int) sizeof (*yyvsp));
 819 #ifdef YYLSP_NEEDED
 820       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 821       __yy_memcpy ((char *)yyls, (char *)yyls1,
 822                    size * (unsigned int) sizeof (*yylsp));
 823 #endif
 824 #endif /* no yyoverflow */
 825
 826       yyssp = yyss + size - 1;
 827       yyvsp = yyvs + size - 1;
 828 #ifdef YYLSP_NEEDED
 829       yylsp = yyls + size - 1;
 830 #endif
 831
 832 #if YYDEBUG != 0
 833       if (yydebug)
 834         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 835 #endif
 836
 837       if (yyssp >= yyss + yystacksize - 1)
 838         YYABORT;
 839     }
 840
 841 #if YYDEBUG != 0
 842   if (yydebug)
 843     fprintf(stderr, "Entering state %d\n", yystate);
 844 #endif
 845
 846   goto yybackup;
 847  yybackup:
 848
 849 /* Do appropriate processing given the current state.  */
 850 /* Read a lookahead token if we need one and don't already have one.  */
 851 /* yyresume: */
 852
 853   /* First try to decide what to do without reference to lookahead token.  */
 854
 855   yyn = yypact[yystate];
 856   if (yyn == YYFLAG)
 857     goto yydefault;
 858
 859   /* Not known => get a lookahead token if don't already have one.  */
 860
 861   /* yychar is either YYEMPTY or YYEOF
 862      or a valid token in external form.  */
 863
 864   if (yychar == YYEMPTY)
 865     {
 866 #if YYDEBUG != 0
 867       if (yydebug)
 868         fprintf(stderr, "Reading a token: ");
 869 #endif
 870       yychar = YYLEX;
 871     }
 872
 873   /* Convert token to internal form (in yychar1) for indexing tables with */
 874
 875   if (yychar <= 0)              /* This means end of input. */
 876     {
 877       yychar1 = 0;
 878       yychar = YYEOF;           /* Don't call YYLEX any more */
 879
 880 #if YYDEBUG != 0
 881       if (yydebug)
 882         fprintf(stderr, "Now at end of input.\n");
 883 #endif
 884     }
 885   else
 886     {
 887       yychar1 = YYTRANSLATE(yychar);
 888
 889 #if YYDEBUG != 0
 890       if (yydebug)
 891         {
 892           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 893           /* Give the individual parser a way to print the precise meaning
 894              of a token, for further debugging info.  */
 895 #ifdef YYPRINT
 896           YYPRINT (stderr, yychar, yylval);
 897 #endif
 898           fprintf (stderr, ")\n");
 899         }
 900 #endif
 901     }
 902
 903   yyn += yychar1;
 904   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 905     goto yydefault;
 906
 907   yyn = yytable[yyn];
 908
 909   /* yyn is what to do for this token type in this state.
 910      Negative => reduce, -yyn is rule number.
 911      Positive => shift, yyn is new state.
 912        New state is final state => don't bother to shift,
 913        just return success.
 914      0, or most negative number => error.  */
 915
 916   if (yyn < 0)
 917     {
 918       if (yyn == YYFLAG)
 919         goto yyerrlab;
 920       yyn = -yyn;
 921       goto yyreduce;
 922     }
 923   else if (yyn == 0)
 924     goto yyerrlab;
 925
 926   if (yyn == YYFINAL)
 927     YYACCEPT;
 928
 929   /* Shift the lookahead token.  */
 930
 931 #if YYDEBUG != 0
 932   if (yydebug)
 933     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 934 #endif
 935
 936   /* Discard the token being shifted unless it is eof.  */
 937   if (yychar != YYEOF)
 938     yychar = YYEMPTY;
 939
 940   *++yyvsp = yylval;
 941 #ifdef YYLSP_NEEDED
 942   *++yylsp = yylloc;
 943 #endif
 944
 945   /* count tokens shifted since error; after three, turn off error status.  */
 946   if (yyerrstatus) yyerrstatus--;
 947
 948   yystate = yyn;
 949   goto yynewstate;
 950
 951 /* Do the default action for the current state.  */
 952 yydefault:
 953
 954   yyn = yydefact[yystate];
 955   if (yyn == 0)
 956     goto yyerrlab;
 957
 958 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 959 yyreduce:
 960   yylen = yyr2[yyn];
 961   if (yylen > 0)
 962     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 963
 964 #if YYDEBUG != 0
 965   if (yydebug)
 966     {
 967       int i;
 968
 969       fprintf (stderr, "Reducing via rule %d (line %d), ",
 970                yyn, yyrline[yyn]);
 971
 972       /* Print the symbols being reduced, and their result.  */
 973       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 974         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 975       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 976     }
 977 #endif
 978
 979
 980   switch (yyn) {
 981
 982 case 3:
 983 #line 107 "scripts/genksyms/parse.y"
 984 { is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; ;
 985     break;}
 986 case 4:
 987 #line 109 "scripts/genksyms/parse.y"
 988 { free_list(*yyvsp[0], NULL); *yyvsp[0] = NULL; ;
 989     break;}
 990 case 5:
 991 #line 113 "scripts/genksyms/parse.y"
 992 { is_typedef = 1; ;
 993     break;}
 994 case 6:
 995 #line 114 "scripts/genksyms/parse.y"
 996 { yyval = yyvsp[0]; ;
 997     break;}
 998 case 11:
 999 #line 119 "scripts/genksyms/parse.y"
1000 { yyval = yyvsp[0]; ;
1001     break;}
1002 case 12:
1003 #line 120 "scripts/genksyms/parse.y"
1004 { yyval = yyvsp[0]; ;
1005     break;}
1006 case 13:
1007 #line 125 "scripts/genksyms/parse.y"
1008 { if (current_name) {
1009                     struct string_list *decl = (*yyvsp[0])->next;
1010                     (*yyvsp[0])->next = NULL;
1011                     add_symbol(current_name,
1012                                is_typedef ? SYM_TYPEDEF : SYM_NORMAL,
1013                                decl, is_extern);
1014                     current_name = NULL;
1015                   }
1016                   yyval = yyvsp[0];
1017                 ;
1018     break;}
1019 case 14:
1020 #line 138 "scripts/genksyms/parse.y"
1021 { yyval = NULL; ;
1022     break;}
1023 case 16:
1024 #line 144 "scripts/genksyms/parse.y"
1025 { struct string_list *decl = *yyvsp[0];
1026                   *yyvsp[0] = NULL;
1027                   add_symbol(current_name,
1028                              is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
1029                   current_name = NULL;
1030                   yyval = yyvsp[0];
1031                 ;
1032     break;}
1033 case 17:
1034 #line 152 "scripts/genksyms/parse.y"
1035 { struct string_list *decl = *yyvsp[0];
1036                   *yyvsp[0] = NULL;
1037                   free_list(*yyvsp[-1], NULL);
1038                   *yyvsp[-1] = decl_spec;
1039                   add_symbol(current_name,
1040                              is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
1041                   current_name = NULL;
1042                   yyval = yyvsp[0];
1043                 ;
1044     break;}
1045 case 18:
1046 #line 165 "scripts/genksyms/parse.y"
1047 { yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1] ? yyvsp[-1] : yyvsp[-2] ? yyvsp[-2] : yyvsp[-3]; ;
1048     break;}
1049 case 19:
1050 #line 170 "scripts/genksyms/parse.y"
1051 { decl_spec = NULL; ;
1052     break;}
1053 case 21:
1054 #line 175 "scripts/genksyms/parse.y"
1055 { decl_spec = *yyvsp[0]; ;
1056     break;}
1057 case 22:
1058 #line 176 "scripts/genksyms/parse.y"
1059 { decl_spec = *yyvsp[0]; ;
1060     break;}
1061 case 23:
1062 #line 181 "scripts/genksyms/parse.y"
1063 { /* Version 2 checksumming ignores storage class, as that
1064                      is really irrelevant to the linkage.  */
1065                   remove_node(yyvsp[0]);
1066                   yyval = yyvsp[0];
1067                 ;
1068     break;}
1069 case 28:
1070 #line 193 "scripts/genksyms/parse.y"
1071 { is_extern = 1; yyval = yyvsp[0]; ;
1072     break;}
1073 case 29:
1074 #line 194 "scripts/genksyms/parse.y"
1075 { is_extern = 0; yyval = yyvsp[0]; ;
1076     break;}
1077 case 33:
1078 #line 205 "scripts/genksyms/parse.y"
1079 { remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_STRUCT; yyval = yyvsp[0]; ;
1080     break;}
1081 case 34:
1082 #line 207 "scripts/genksyms/parse.y"
1083 { remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_UNION; yyval = yyvsp[0]; ;
1084     break;}
1085 case 35:
1086 #line 209 "scripts/genksyms/parse.y"
1087 { remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_ENUM; yyval = yyvsp[0]; ;
1088     break;}
1089 case 36:
1090 #line 213 "scripts/genksyms/parse.y"
1091 { struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r;
1092                   r = copy_node(i); r->tag = SYM_STRUCT;
1093                   r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL;
1094                   add_symbol(i->string, SYM_STRUCT, s, is_extern);
1095                   yyval = yyvsp[0];
1096                 ;
1097     break;}
1098 case 37:
1099 #line 220 "scripts/genksyms/parse.y"
1100 { struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r;
1101                   r = copy_node(i); r->tag = SYM_UNION;
1102                   r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL;
1103                   add_symbol(i->string, SYM_UNION, s, is_extern);
1104                   yyval = yyvsp[0];
1105                 ;
1106     break;}
1107 case 38:
1108 #line 227 "scripts/genksyms/parse.y"
1109 { struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r;
1110                   r = copy_node(i); r->tag = SYM_ENUM;
1111                   r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL;
1112                   add_symbol(i->string, SYM_ENUM, s, is_extern);
1113                   yyval = yyvsp[0];
1114                 ;
1115     break;}
1116 case 39:
1117 #line 235 "scripts/genksyms/parse.y"
1118 { yyval = yyvsp[0]; ;
1119     break;}
1120 case 40:
1121 #line 236 "scripts/genksyms/parse.y"
1122 { yyval = yyvsp[0]; ;
1123     break;}
1124 case 41:
1125 #line 237 "scripts/genksyms/parse.y"
1126 { yyval = yyvsp[0]; ;
1127     break;}
1128 case 52:
1129 #line 251 "scripts/genksyms/parse.y"
1130 { (*yyvsp[0])->tag = SYM_TYPEDEF; yyval = yyvsp[0]; ;
1131     break;}
1132 case 53:
1133 #line 256 "scripts/genksyms/parse.y"
1134 { yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ;
1135     break;}
1136 case 54:
1137 #line 260 "scripts/genksyms/parse.y"
1138 { yyval = NULL; ;
1139     break;}
1140 case 57:
1141 #line 266 "scripts/genksyms/parse.y"
1142 { yyval = yyvsp[0]; ;
1143     break;}
1144 case 61:
1145 #line 272 "scripts/genksyms/parse.y"
1146 { /* restrict has no effect in prototypes so ignore it */
1147                   remove_node(yyvsp[0]);
1148                   yyval = yyvsp[0];
1149                 ;
1150     break;}
1151 case 62:
1152 #line 279 "scripts/genksyms/parse.y"
1153 { yyval = yyvsp[0]; ;
1154     break;}
1155 case 64:
1156 #line 285 "scripts/genksyms/parse.y"
1157 { if (current_name != NULL) {
1158                     error_with_pos("unexpected second declaration name");
1159                     YYERROR;
1160                   } else {
1161                     current_name = (*yyvsp[0])->string;
1162                     yyval = yyvsp[0];
1163                   }
1164                 ;
1165     break;}
1166 case 65:
1167 #line 294 "scripts/genksyms/parse.y"
1168 { yyval = yyvsp[0]; ;
1169     break;}
1170 case 66:
1171 #line 296 "scripts/genksyms/parse.y"
1172 { yyval = yyvsp[0]; ;
1173     break;}
1174 case 67:
1175 #line 298 "scripts/genksyms/parse.y"
1176 { yyval = yyvsp[0]; ;
1177     break;}
1178 case 68:
1179 #line 300 "scripts/genksyms/parse.y"
1180 { yyval = yyvsp[0]; ;
1181     break;}
1182 case 69:
1183 #line 302 "scripts/genksyms/parse.y"
1184 { yyval = yyvsp[0]; ;
1185     break;}
1186 case 70:
1187 #line 308 "scripts/genksyms/parse.y"
1188 { yyval = yyvsp[0]; ;
1189     break;}
1190 case 74:
1191 #line 316 "scripts/genksyms/parse.y"
1192 { yyval = yyvsp[0]; ;
1193     break;}
1194 case 75:
1195 #line 318 "scripts/genksyms/parse.y"
1196 { yyval = yyvsp[0]; ;
1197     break;}
1198 case 76:
1199 #line 320 "scripts/genksyms/parse.y"
1200 { yyval = yyvsp[0]; ;
1201     break;}
1202 case 77:
1203 #line 322 "scripts/genksyms/parse.y"
1204 { yyval = yyvsp[0]; ;
1205     break;}
1206 case 78:
1207 #line 324 "scripts/genksyms/parse.y"
1208 { yyval = yyvsp[0]; ;
1209     break;}
1210 case 79:
1211 #line 328 "scripts/genksyms/parse.y"
1212 { yyval = yyvsp[0]; ;
1213     break;}
1214 case 81:
1215 #line 330 "scripts/genksyms/parse.y"
1216 { yyval = yyvsp[0]; ;
1217     break;}
1218 case 82:
1219 #line 334 "scripts/genksyms/parse.y"
1220 { yyval = NULL; ;
1221     break;}
1222 case 85:
1223 #line 341 "scripts/genksyms/parse.y"
1224 { yyval = yyvsp[0]; ;
1225     break;}
1226 case 86:
1227 #line 346 "scripts/genksyms/parse.y"
1228 { yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ;
1229     break;}
1230 case 87:
1231 #line 351 "scripts/genksyms/parse.y"
1232 { yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ;
1233     break;}
1234 case 89:
1235 #line 356 "scripts/genksyms/parse.y"
1236 { yyval = NULL; ;
1237     break;}
1238 case 90:
1239 #line 358 "scripts/genksyms/parse.y"
1240 { /* For version 2 checksums, we don't want to remember
1241                      private parameter names.  */
1242                   remove_node(yyvsp[0]);
1243                   yyval = yyvsp[0];
1244                 ;
1245     break;}
1246 case 91:
1247 #line 366 "scripts/genksyms/parse.y"
1248 { remove_node(yyvsp[0]);
1249                   yyval = yyvsp[0];
1250                 ;
1251     break;}
1252 case 92:
1253 #line 370 "scripts/genksyms/parse.y"
1254 { yyval = yyvsp[0]; ;
1255     break;}
1256 case 93:
1257 #line 372 "scripts/genksyms/parse.y"
1258 { yyval = yyvsp[0]; ;
1259     break;}
1260 case 94:
1261 #line 374 "scripts/genksyms/parse.y"
1262 { yyval = yyvsp[0]; ;
1263     break;}
1264 case 95:
1265 #line 376 "scripts/genksyms/parse.y"
1266 { yyval = yyvsp[0]; ;
1267     break;}
1268 case 96:
1269 #line 378 "scripts/genksyms/parse.y"
1270 { yyval = yyvsp[0]; ;
1271     break;}
1272 case 97:
1273 #line 383 "scripts/genksyms/parse.y"
1274 { struct string_list *decl = *yyvsp[-1];
1275                   *yyvsp[-1] = NULL;
1276                   add_symbol(current_name, SYM_NORMAL, decl, is_extern);
1277                   yyval = yyvsp[0];
1278                 ;
1279     break;}
1280 case 98:
1281 #line 391 "scripts/genksyms/parse.y"
1282 { yyval = NULL; ;
1283     break;}
1284 case 100:
1285 #line 398 "scripts/genksyms/parse.y"
1286 { remove_list(yyvsp[0], &(*yyvsp[-1])->next); yyval = yyvsp[0]; ;
1287     break;}
1288 case 101:
1289 #line 402 "scripts/genksyms/parse.y"
1290 { yyval = yyvsp[0]; ;
1291     break;}
1292 case 102:
1293 #line 403 "scripts/genksyms/parse.y"
1294 { yyval = yyvsp[0]; ;
1295     break;}
1296 case 103:
1297 #line 407 "scripts/genksyms/parse.y"
1298 { yyval = NULL; ;
1299     break;}
1300 case 106:
1301 #line 413 "scripts/genksyms/parse.y"
1302 { yyval = yyvsp[0]; ;
1303     break;}
1304 case 107:
1305 #line 418 "scripts/genksyms/parse.y"
1306 { yyval = yyvsp[0]; ;
1307     break;}
1308 case 108:
1309 #line 420 "scripts/genksyms/parse.y"
1310 { yyval = yyvsp[0]; ;
1311     break;}
1312 case 109:
1313 #line 424 "scripts/genksyms/parse.y"
1314 { yyval = NULL; ;
1315     break;}
1316 case 112:
1317 #line 430 "scripts/genksyms/parse.y"
1318 { yyval = yyvsp[0]; ;
1319     break;}
1320 case 113:
1321 #line 434 "scripts/genksyms/parse.y"
1322 { yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ;
1323     break;}
1324 case 114:
1325 #line 435 "scripts/genksyms/parse.y"
1326 { yyval = yyvsp[0]; ;
1327     break;}
1328 case 116:
1329 #line 440 "scripts/genksyms/parse.y"
1330 { yyval = yyvsp[0]; ;
1331     break;}
1332 case 117:
1333 #line 444 "scripts/genksyms/parse.y"
1334 { yyval = NULL; ;
1335     break;}
1336 case 119:
1337 #line 449 "scripts/genksyms/parse.y"
1338 { yyval = yyvsp[0]; ;
1339     break;}
1340 case 120:
1341 #line 453 "scripts/genksyms/parse.y"
1342 { yyval = NULL; ;
1343     break;}
1344 case 122:
1345 #line 459 "scripts/genksyms/parse.y"
1346 { export_symbol((*yyvsp[-2])->string); yyval = yyvsp[0]; ;
1347     break;}
1348 }
1349    /* the action file gets copied in in place of this dollarsign */
1350 #line 543 "/usr/lib/bison.simple"
1351 \f
1352   yyvsp -= yylen;
1353   yyssp -= yylen;
1354 #ifdef YYLSP_NEEDED
1355   yylsp -= yylen;
1356 #endif
1357
1358 #if YYDEBUG != 0
1359   if (yydebug)
1360     {
1361       short *ssp1 = yyss - 1;
1362       fprintf (stderr, "state stack now");
1363       while (ssp1 != yyssp)
1364         fprintf (stderr, " %d", *++ssp1);
1365       fprintf (stderr, "\n");
1366     }
1367 #endif
1368
1369   *++yyvsp = yyval;
1370
1371 #ifdef YYLSP_NEEDED
1372   yylsp++;
1373   if (yylen == 0)
1374     {
1375       yylsp->first_line = yylloc.first_line;
1376       yylsp->first_column = yylloc.first_column;
1377       yylsp->last_line = (yylsp-1)->last_line;
1378       yylsp->last_column = (yylsp-1)->last_column;
1379       yylsp->text = 0;
1380     }
1381   else
1382     {
1383       yylsp->last_line = (yylsp+yylen-1)->last_line;
1384       yylsp->last_column = (yylsp+yylen-1)->last_column;
1385     }
1386 #endif
1387
1388   /* Now "shift" the result of the reduction.
1389      Determine what state that goes to,
1390      based on the state we popped back to
1391      and the rule number reduced by.  */
1392
1393   yyn = yyr1[yyn];
1394
1395   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1396   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1397     yystate = yytable[yystate];
1398   else
1399     yystate = yydefgoto[yyn - YYNTBASE];
1400
1401   goto yynewstate;
1402
1403 yyerrlab:   /* here on detecting error */
1404
1405   if (! yyerrstatus)
1406     /* If not already recovering from an error, report this error.  */
1407     {
1408       ++yynerrs;
1409
1410 #ifdef YYERROR_VERBOSE
1411       yyn = yypact[yystate];
1412
1413       if (yyn > YYFLAG && yyn < YYLAST)
1414         {
1415           int size = 0;
1416           char *msg;
1417           int x, count;
1418
1419           count = 0;
1420           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1421           for (x = (yyn < 0 ? -yyn : 0);
1422                x < (sizeof(yytname) / sizeof(char *)); x++)
1423             if (yycheck[x + yyn] == x)
1424               size += strlen(yytname[x]) + 15, count++;
1425           msg = (char *) malloc(size + 15);
1426           if (msg != 0)
1427             {
1428               strcpy(msg, "parse error");
1429
1430               if (count < 5)
1431                 {
1432                   count = 0;
1433                   for (x = (yyn < 0 ? -yyn : 0);
1434                        x < (sizeof(yytname) / sizeof(char *)); x++)
1435                     if (yycheck[x + yyn] == x)
1436                       {
1437                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1438                         strcat(msg, yytname[x]);
1439                         strcat(msg, "'");
1440                         count++;
1441                       }
1442                 }
1443               yyerror(msg);
1444               free(msg);
1445             }
1446           else
1447             yyerror ("parse error; also virtual memory exceeded");
1448         }
1449       else
1450 #endif /* YYERROR_VERBOSE */
1451         yyerror("parse error");
1452     }
1453
1454   goto yyerrlab1;
1455 yyerrlab1:   /* here on error raised explicitly by an action */
1456
1457   if (yyerrstatus == 3)
1458     {
1459       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1460
1461       /* return failure if at end of input */
1462       if (yychar == YYEOF)
1463         YYABORT;
1464
1465 #if YYDEBUG != 0
1466       if (yydebug)
1467         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1468 #endif
1469
1470       yychar = YYEMPTY;
1471     }
1472
1473   /* Else will try to reuse lookahead token
1474      after shifting the error token.  */
1475
1476   yyerrstatus = 3;              /* Each real token shifted decrements this */
1477
1478   goto yyerrhandle;
1479
1480 yyerrdefault:  /* current state does not do anything special for the error token. */
1481
1482 #if 0
1483   /* This is wrong; only states that explicitly want error tokens
1484      should shift them.  */
1485   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1486   if (yyn) goto yydefault;
1487 #endif
1488
1489 yyerrpop:   /* pop the current state because it cannot handle the error token */
1490
1491   if (yyssp == yyss) YYABORT;
1492   yyvsp--;
1493   yystate = *--yyssp;
1494 #ifdef YYLSP_NEEDED
1495   yylsp--;
1496 #endif
1497
1498 #if YYDEBUG != 0
1499   if (yydebug)
1500     {
1501       short *ssp1 = yyss - 1;
1502       fprintf (stderr, "Error: state stack now");
1503       while (ssp1 != yyssp)
1504         fprintf (stderr, " %d", *++ssp1);
1505       fprintf (stderr, "\n");
1506     }
1507 #endif
1508
1509 yyerrhandle:
1510
1511   yyn = yypact[yystate];
1512   if (yyn == YYFLAG)
1513     goto yyerrdefault;
1514
1515   yyn += YYTERROR;
1516   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1517     goto yyerrdefault;
1518
1519   yyn = yytable[yyn];
1520   if (yyn < 0)
1521     {
1522       if (yyn == YYFLAG)
1523         goto yyerrpop;
1524       yyn = -yyn;
1525       goto yyreduce;
1526     }
1527   else if (yyn == 0)
1528     goto yyerrpop;
1529
1530   if (yyn == YYFINAL)
1531     YYACCEPT;
1532
1533 #if YYDEBUG != 0
1534   if (yydebug)
1535     fprintf(stderr, "Shifting error token, ");
1536 #endif
1537
1538   *++yyvsp = yylval;
1539 #ifdef YYLSP_NEEDED
1540   *++yylsp = yylloc;
1541 #endif
1542
1543   yystate = yyn;
1544   goto yynewstate;
1545
1546  yyacceptlab:
1547   /* YYACCEPT comes here.  */
1548   if (yyfree_stacks)
1549     {
1550       free (yyss);
1551       free (yyvs);
1552 #ifdef YYLSP_NEEDED
1553       free (yyls);
1554 #endif
1555     }
1556   return 0;
1557
1558  yyabortlab:
1559   /* YYABORT comes here.  */
1560   if (yyfree_stacks)
1561     {
1562       free (yyss);
1563       free (yyvs);
1564 #ifdef YYLSP_NEEDED
1565       free (yyls);
1566 #endif
1567     }
1568   return 1;
1569 }
1570 #line 463 "scripts/genksyms/parse.y"
1571
1572
1573 static void
1574 yyerror(const char *e)
1575 {
1576   error_with_pos("%s", e);
1577 }