1/* C global declaration parser for genksyms.
2   Copyright 1996, 1997 Linux International.
3
4   New implementation contributed by Richard Henderson <rth@tamu.edu>
5   Based on original work by Bjorn Ekwall <bj0rn@blox.se>
6
7   This file is part of the Linux modutils.
8
9   This program is free software; you can redistribute it and/or modify it
10   under the terms of the GNU General Public License as published by the
11   Free Software Foundation; either version 2 of the License, or (at your
12   option) any later version.
13
14   This program is distributed in the hope that it will be useful, but
15   WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17   General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software Foundation,
21   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22
23
24%{
25
26#include <assert.h>
27#include <stdlib.h>
28#include <string.h>
29#include "genksyms.h"
30
31static int is_typedef;
32static int is_extern;
33static char *current_name;
34static struct string_list *decl_spec;
35
36static void yyerror(const char *);
37
38static inline void
39remove_node(struct string_list **p)
40{
41  struct string_list *node = *p;
42  *p = node->next;
43  free_node(node);
44}
45
46static inline void
47remove_list(struct string_list **pb, struct string_list **pe)
48{
49  struct string_list *b = *pb, *e = *pe;
50  *pb = e;
51  free_list(b, e);
52}
53
54%}
55
56%token ASM_KEYW
57%token ATTRIBUTE_KEYW
58%token AUTO_KEYW
59%token BOOL_KEYW
60%token CHAR_KEYW
61%token CONST_KEYW
62%token DOUBLE_KEYW
63%token ENUM_KEYW
64%token EXTERN_KEYW
65%token EXTENSION_KEYW
66%token FLOAT_KEYW
67%token INLINE_KEYW
68%token INT_KEYW
69%token LONG_KEYW
70%token REGISTER_KEYW
71%token RESTRICT_KEYW
72%token SHORT_KEYW
73%token SIGNED_KEYW
74%token STATIC_KEYW
75%token STRUCT_KEYW
76%token TYPEDEF_KEYW
77%token UNION_KEYW
78%token UNSIGNED_KEYW
79%token VOID_KEYW
80%token VOLATILE_KEYW
81%token TYPEOF_KEYW
82
83%token EXPORT_SYMBOL_KEYW
84
85%token ASM_PHRASE
86%token ATTRIBUTE_PHRASE
87%token BRACE_PHRASE
88%token BRACKET_PHRASE
89%token EXPRESSION_PHRASE
90
91%token CHAR
92%token DOTS
93%token IDENT
94%token INT
95%token REAL
96%token STRING
97%token TYPE
98%token OTHER
99%token FILENAME
100
101%%
102
103declaration_seq:
104	declaration
105	| declaration_seq declaration
106	;
107
108declaration:
109	{ is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; }
110	declaration1
111	{ free_list(*$2, NULL); *$2 = NULL; }
112	;
113
114declaration1:
115	EXTENSION_KEYW TYPEDEF_KEYW { is_typedef = 1; } simple_declaration
116		{ $$ = $4; }
117	| TYPEDEF_KEYW { is_typedef = 1; } simple_declaration
118		{ $$ = $3; }
119	| simple_declaration
120	| function_definition
121	| asm_definition
122	| export_definition
123	| error ';'				{ $$ = $2; }
124	| error '}'				{ $$ = $2; }
125	;
126
127simple_declaration:
128	decl_specifier_seq_opt init_declarator_list_opt ';'
129		{ if (current_name) {
130		    struct string_list *decl = (*$3)->next;
131		    (*$3)->next = NULL;
132		    add_symbol(current_name,
133			       is_typedef ? SYM_TYPEDEF : SYM_NORMAL,
134			       decl, is_extern);
135		    current_name = NULL;
136		  }
137		  $$ = $3;
138		}
139	;
140
141init_declarator_list_opt:
142	/* empty */				{ $$ = NULL; }
143	| init_declarator_list
144	;
145
146init_declarator_list:
147	init_declarator
148		{ struct string_list *decl = *$1;
149		  *$1 = NULL;
150		  add_symbol(current_name,
151			     is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
152		  current_name = NULL;
153		  $$ = $1;
154		}
155	| init_declarator_list ',' init_declarator
156		{ struct string_list *decl = *$3;
157		  *$3 = NULL;
158		  free_list(*$2, NULL);
159		  *$2 = decl_spec;
160		  add_symbol(current_name,
161			     is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern);
162		  current_name = NULL;
163		  $$ = $3;
164		}
165	;
166
167init_declarator:
168	declarator asm_phrase_opt attribute_opt initializer_opt
169		{ $$ = $4 ? $4 : $3 ? $3 : $2 ? $2 : $1; }
170	;
171
172/* Hang on to the specifiers so that we can reuse them.  */
173decl_specifier_seq_opt:
174	/* empty */				{ decl_spec = NULL; }
175	| decl_specifier_seq
176	;
177
178decl_specifier_seq:
179	decl_specifier				{ decl_spec = *$1; }
180	| decl_specifier_seq decl_specifier	{ decl_spec = *$2; }
181	;
182
183decl_specifier:
184	storage_class_specifier
185		{ /* Version 2 checksumming ignores storage class, as that
186		     is really irrelevant to the linkage.  */
187		  remove_node($1);
188		  $$ = $1;
189		}
190	| type_specifier
191	;
192
193storage_class_specifier:
194	AUTO_KEYW
195	| REGISTER_KEYW
196	| STATIC_KEYW
197	| EXTERN_KEYW	{ is_extern = 1; $$ = $1; }
198	| INLINE_KEYW	{ is_extern = 0; $$ = $1; }
199	;
200
201type_specifier:
202	simple_type_specifier
203	| cvar_qualifier
204	| TYPEOF_KEYW '(' decl_specifier_seq '*' ')'
205	| TYPEOF_KEYW '(' decl_specifier_seq ')'
206
207	/* References to s/u/e's defined elsewhere.  Rearrange things
208	   so that it is easier to expand the definition fully later.  */
209	| STRUCT_KEYW IDENT
210		{ remove_node($1); (*$2)->tag = SYM_STRUCT; $$ = $2; }
211	| UNION_KEYW IDENT
212		{ remove_node($1); (*$2)->tag = SYM_UNION; $$ = $2; }
213	| ENUM_KEYW IDENT
214		{ remove_node($1); (*$2)->tag = SYM_ENUM; $$ = $2; }
215
216	/* Full definitions of an s/u/e.  Record it.  */
217	| STRUCT_KEYW IDENT class_body
218		{ struct string_list *s = *$3, *i = *$2, *r;
219		  r = copy_node(i); r->tag = SYM_STRUCT;
220		  r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL;
221		  add_symbol(i->string, SYM_STRUCT, s, is_extern);
222		  $$ = $3;
223		}
224	| UNION_KEYW IDENT class_body
225		{ struct string_list *s = *$3, *i = *$2, *r;
226		  r = copy_node(i); r->tag = SYM_UNION;
227		  r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL;
228		  add_symbol(i->string, SYM_UNION, s, is_extern);
229		  $$ = $3;
230		}
231	| ENUM_KEYW IDENT enum_body
232		{ struct string_list *s = *$3, *i = *$2, *r;
233		  r = copy_node(i); r->tag = SYM_ENUM;
234		  r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL;
235		  add_symbol(i->string, SYM_ENUM, s, is_extern);
236		  $$ = $3;
237		}
238	/*
239	 * Anonymous enum definition. Tell add_symbol() to restart its counter.
240	 */
241	| ENUM_KEYW enum_body
242		{ add_symbol(NULL, SYM_ENUM, NULL, 0); $$ = $2; }
243	/* Anonymous s/u definitions.  Nothing needs doing.  */
244	| STRUCT_KEYW class_body			{ $$ = $2; }
245	| UNION_KEYW class_body				{ $$ = $2; }
246	;
247
248simple_type_specifier:
249	CHAR_KEYW
250	| SHORT_KEYW
251	| INT_KEYW
252	| LONG_KEYW
253	| SIGNED_KEYW
254	| UNSIGNED_KEYW
255	| FLOAT_KEYW
256	| DOUBLE_KEYW
257	| VOID_KEYW
258	| BOOL_KEYW
259	| TYPE			{ (*$1)->tag = SYM_TYPEDEF; $$ = $1; }
260	;
261
262ptr_operator:
263	'*' cvar_qualifier_seq_opt
264		{ $$ = $2 ? $2 : $1; }
265	;
266
267cvar_qualifier_seq_opt:
268	/* empty */					{ $$ = NULL; }
269	| cvar_qualifier_seq
270	;
271
272cvar_qualifier_seq:
273	cvar_qualifier
274	| cvar_qualifier_seq cvar_qualifier		{ $$ = $2; }
275	;
276
277cvar_qualifier:
278	CONST_KEYW | VOLATILE_KEYW | ATTRIBUTE_PHRASE
279	| RESTRICT_KEYW
280		{ /* restrict has no effect in prototypes so ignore it */
281		  remove_node($1);
282		  $$ = $1;
283		}
284	;
285
286declarator:
287	ptr_operator declarator			{ $$ = $2; }
288	| direct_declarator
289	;
290
291direct_declarator:
292	IDENT
293		{ if (current_name != NULL) {
294		    error_with_pos("unexpected second declaration name");
295		    YYERROR;
296		  } else {
297		    current_name = (*$1)->string;
298		    $$ = $1;
299		  }
300		}
301	| direct_declarator '(' parameter_declaration_clause ')'
302		{ $$ = $4; }
303	| direct_declarator '(' error ')'
304		{ $$ = $4; }
305	| direct_declarator BRACKET_PHRASE
306		{ $$ = $2; }
307	| '(' declarator ')'
308		{ $$ = $3; }
309	| '(' error ')'
310		{ $$ = $3; }
311	;
312
313/* Nested declarators differ from regular declarators in that they do
314   not record the symbols they find in the global symbol table.  */
315nested_declarator:
316	ptr_operator nested_declarator		{ $$ = $2; }
317	| direct_nested_declarator
318	;
319
320direct_nested_declarator:
321	IDENT
322	| TYPE
323	| direct_nested_declarator '(' parameter_declaration_clause ')'
324		{ $$ = $4; }
325	| direct_nested_declarator '(' error ')'
326		{ $$ = $4; }
327	| direct_nested_declarator BRACKET_PHRASE
328		{ $$ = $2; }
329	| '(' nested_declarator ')'
330		{ $$ = $3; }
331	| '(' error ')'
332		{ $$ = $3; }
333	;
334
335parameter_declaration_clause:
336	parameter_declaration_list_opt DOTS		{ $$ = $2; }
337	| parameter_declaration_list_opt
338	| parameter_declaration_list ',' DOTS		{ $$ = $3; }
339	;
340
341parameter_declaration_list_opt:
342	/* empty */					{ $$ = NULL; }
343	| parameter_declaration_list
344	;
345
346parameter_declaration_list:
347	parameter_declaration
348	| parameter_declaration_list ',' parameter_declaration
349		{ $$ = $3; }
350	;
351
352parameter_declaration:
353	decl_specifier_seq m_abstract_declarator
354		{ $$ = $2 ? $2 : $1; }
355	;
356
357m_abstract_declarator:
358	ptr_operator m_abstract_declarator
359		{ $$ = $2 ? $2 : $1; }
360	| direct_m_abstract_declarator
361	;
362
363direct_m_abstract_declarator:
364	/* empty */					{ $$ = NULL; }
365	| IDENT
366		{ /* For version 2 checksums, we don't want to remember
367		     private parameter names.  */
368		  remove_node($1);
369		  $$ = $1;
370		}
371	/* This wasn't really a typedef name but an identifier that
372	   shadows one.  */
373	| TYPE
374		{ remove_node($1);
375		  $$ = $1;
376		}
377	| direct_m_abstract_declarator '(' parameter_declaration_clause ')'
378		{ $$ = $4; }
379	| direct_m_abstract_declarator '(' error ')'
380		{ $$ = $4; }
381	| direct_m_abstract_declarator BRACKET_PHRASE
382		{ $$ = $2; }
383	| '(' m_abstract_declarator ')'
384		{ $$ = $3; }
385	| '(' error ')'
386		{ $$ = $3; }
387	;
388
389function_definition:
390	decl_specifier_seq_opt declarator BRACE_PHRASE
391		{ struct string_list *decl = *$2;
392		  *$2 = NULL;
393		  add_symbol(current_name, SYM_NORMAL, decl, is_extern);
394		  $$ = $3;
395		}
396	;
397
398initializer_opt:
399	/* empty */					{ $$ = NULL; }
400	| initializer
401	;
402
403/* We never care about the contents of an initializer.  */
404initializer:
405	'=' EXPRESSION_PHRASE
406		{ remove_list($2, &(*$1)->next); $$ = $2; }
407	;
408
409class_body:
410	'{' member_specification_opt '}'		{ $$ = $3; }
411	| '{' error '}'					{ $$ = $3; }
412	;
413
414member_specification_opt:
415	/* empty */					{ $$ = NULL; }
416	| member_specification
417	;
418
419member_specification:
420	member_declaration
421	| member_specification member_declaration	{ $$ = $2; }
422	;
423
424member_declaration:
425	decl_specifier_seq_opt member_declarator_list_opt ';'
426		{ $$ = $3; }
427	| error ';'
428		{ $$ = $2; }
429	;
430
431member_declarator_list_opt:
432	/* empty */					{ $$ = NULL; }
433	| member_declarator_list
434	;
435
436member_declarator_list:
437	member_declarator
438	| member_declarator_list ',' member_declarator	{ $$ = $3; }
439	;
440
441member_declarator:
442	nested_declarator attribute_opt			{ $$ = $2 ? $2 : $1; }
443	| IDENT member_bitfield_declarator		{ $$ = $2; }
444	| member_bitfield_declarator
445	;
446
447member_bitfield_declarator:
448	':' EXPRESSION_PHRASE				{ $$ = $2; }
449	;
450
451attribute_opt:
452	/* empty */					{ $$ = NULL; }
453	| attribute_opt ATTRIBUTE_PHRASE
454	;
455
456enum_body:
457	'{' enumerator_list '}'				{ $$ = $3; }
458	| '{' enumerator_list ',' '}'			{ $$ = $4; }
459	 ;
460
461enumerator_list:
462	enumerator
463	| enumerator_list ',' enumerator
464
465enumerator:
466	IDENT
467		{
468			const char *name = strdup((*$1)->string);
469			add_symbol(name, SYM_ENUM_CONST, NULL, 0);
470		}
471	| IDENT '=' EXPRESSION_PHRASE
472		{
473			const char *name = strdup((*$1)->string);
474			struct string_list *expr = copy_list_range(*$3, *$2);
475			add_symbol(name, SYM_ENUM_CONST, expr, 0);
476		}
477
478asm_definition:
479	ASM_PHRASE ';'					{ $$ = $2; }
480	;
481
482asm_phrase_opt:
483	/* empty */					{ $$ = NULL; }
484	| ASM_PHRASE
485	;
486
487export_definition:
488	EXPORT_SYMBOL_KEYW '(' IDENT ')' ';'
489		{ export_symbol((*$3)->string); $$ = $5; }
490	;
491
492
493%%
494
495static void
496yyerror(const char *e)
497{
498  error_with_pos("%s", e);
499}
500