Linux-2.6.12-rc2
[linux-3.10.git] / 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 }