xref: /freebsd/contrib/byacc/test/grammar.y (revision 3f0164abf32b9b761e0a2cb4bdca3a8b84f156d4) 
1 /* $Id: grammar.y,v 1.5 2012/01/15 20:00:59 tom Exp $
2  *
3  * yacc grammar for C function prototype generator
4  * This was derived from the grammar in Appendix A of
5  * "The C Programming Language" by Kernighan and Ritchie.
6  */
7 %expect 1
8 %{
9 #ifdef YYBISON
10 #include <stdlib.h>
11 #define YYSTYPE_IS_DECLARED
12 #define yyerror yaccError
13 #endif
14 
15 #if defined(YYBISON) || !defined(YYBYACC)
16 static void yyerror(const char *s);
17 #endif
18 %}
19 
20 %token <text> '(' '*' '&'
21 	/* identifiers that are not reserved words */
22 	T_IDENTIFIER T_TYPEDEF_NAME T_DEFINE_NAME
23 
24 	/* storage class */
25 	T_AUTO T_EXTERN T_REGISTER T_STATIC T_TYPEDEF
26 	/* This keyword included for compatibility with C++. */
27 	T_INLINE
28 	/* This keyword included for compatibility with GCC */
29 	T_EXTENSION
30 
31 	/* type specifiers */
32 	T_CHAR T_DOUBLE T_FLOAT T_INT T_VOID
33 	T_LONG T_SHORT T_SIGNED T_UNSIGNED
34 	T_ENUM T_STRUCT T_UNION
35 	/* C9X new types */
36 	T_Bool T_Complex T_Imaginary
37 
38 	/* type qualifiers */
39 	T_TYPE_QUALIFIER
40 
41 	/* paired square brackets and everything between them: [ ... ] */
42 	T_BRACKETS
43 
44 %token
45 	/* left brace */
46 	T_LBRACE
47 	/* all input to the matching right brace */
48 	T_MATCHRBRACE
49 
50 	/* three periods */
51 	T_ELLIPSIS
52 
53 	/* constant expression or paired braces following an equal sign */
54 	T_INITIALIZER
55 
56 	/* string literal */
57 	T_STRING_LITERAL
58 
59 	/* asm */
60 	T_ASM
61 	/* ( "string literal" ) following asm keyword */
62 	T_ASMARG
63 
64 	/* va_dcl from <varargs.h> */
65 	T_VA_DCL
66 
67 %type <decl_spec> decl_specifiers decl_specifier
68 %type <decl_spec> storage_class type_specifier type_qualifier
69 %type <decl_spec> struct_or_union_specifier enum_specifier
70 %type <decl_list> init_declarator_list
71 %type <declarator> init_declarator declarator direct_declarator
72 %type <declarator> abs_declarator direct_abs_declarator
73 %type <param_list> parameter_type_list parameter_list
74 %type <parameter> parameter_declaration
75 %type <param_list> opt_identifier_list identifier_list
76 %type <text> struct_or_union pointer opt_type_qualifiers type_qualifier_list
77 	any_id identifier_or_ref
78 %type <text> enumeration
79 
80 %{
81 #include <stdio.h>
82 #include <ctype.h>
83 #include <string.h>
84 
85 #define OPT_LINTLIBRARY 1
86 
87 #ifndef TRUE
88 #define	TRUE	(1)
89 #endif
90 
91 #ifndef FALSE
92 #define	FALSE	(0)
93 #endif
94 
95 /* #include "cproto.h" */
96 #define MAX_TEXT_SIZE 1024
97 
98 /* Prototype styles */
99 #if OPT_LINTLIBRARY
100 #define PROTO_ANSI_LLIB		-2	/* form ANSI lint-library source */
101 #define PROTO_LINTLIBRARY	-1	/* form lint-library source */
102 #endif
103 #define PROTO_NONE		0	/* do not output any prototypes */
104 #define PROTO_TRADITIONAL	1	/* comment out parameters */
105 #define PROTO_ABSTRACT		2	/* comment out parameter names */
106 #define PROTO_ANSI		3	/* ANSI C prototype */
107 
108 typedef int PrototypeStyle;
109 
110 typedef char boolean;
111 
112 extern boolean types_out;
113 extern PrototypeStyle proto_style;
114 
115 #define ansiLintLibrary() (proto_style == PROTO_ANSI_LLIB)
116 #define knrLintLibrary()  (proto_style == PROTO_LINTLIBRARY)
117 #define lintLibrary()     (knrLintLibrary() || ansiLintLibrary())
118 
119 #if OPT_LINTLIBRARY
120 #define FUNC_UNKNOWN		-1	/* unspecified */
121 #else
122 #define FUNC_UNKNOWN		0	/* unspecified (same as FUNC_NONE) */
123 #endif
124 #define FUNC_NONE		0	/* not a function definition */
125 #define FUNC_TRADITIONAL	1	/* traditional style */
126 #define FUNC_ANSI		2	/* ANSI style */
127 #define FUNC_BOTH		3	/* both styles */
128 
129 typedef int FuncDefStyle;
130 
131 /* Source file text */
132 typedef struct text {
133     char text[MAX_TEXT_SIZE];	/* source text */
134     long begin; 		/* offset in temporary file */
135 } Text;
136 
137 /* Declaration specifier flags */
138 #define DS_NONE 	0	/* default */
139 #define DS_EXTERN	1	/* contains "extern" specifier */
140 #define DS_STATIC	2	/* contains "static" specifier */
141 #define DS_CHAR 	4	/* contains "char" type specifier */
142 #define DS_SHORT	8	/* contains "short" type specifier */
143 #define DS_FLOAT	16	/* contains "float" type specifier */
144 #define DS_INLINE	32	/* contains "inline" specifier */
145 #define DS_JUNK 	64	/* we're not interested in this declaration */
146 
147 /* This structure stores information about a declaration specifier. */
148 typedef struct decl_spec {
149     unsigned short flags;	/* flags defined above */
150     char *text; 		/* source text */
151     long begin; 		/* offset in temporary file */
152 } DeclSpec;
153 
154 /* This is a list of function parameters. */
155 typedef struct _ParameterList {
156     struct parameter *first;	/* pointer to first parameter in list */
157     struct parameter *last;	/* pointer to last parameter in list */
158     long begin_comment; 	/* begin offset of comment */
159     long end_comment;		/* end offset of comment */
160     char *comment;		/* comment at start of parameter list */
161 } ParameterList;
162 
163 /* This structure stores information about a declarator. */
164 typedef struct _Declarator {
165     char *name; 			/* name of variable or function */
166     char *text; 			/* source text */
167     long begin; 			/* offset in temporary file */
168     long begin_comment; 		/* begin offset of comment */
169     long end_comment;			/* end offset of comment */
170     FuncDefStyle func_def;		/* style of function definition */
171     ParameterList params;		/* function parameters */
172     boolean pointer;			/* TRUE if it declares a pointer */
173     struct _Declarator *head;		/* head function declarator */
174     struct _Declarator *func_stack;	/* stack of function declarators */
175     struct _Declarator *next;		/* next declarator in list */
176 } Declarator;
177 
178 /* This structure stores information about a function parameter. */
179 typedef struct parameter {
180     struct parameter *next;	/* next parameter in list */
181     DeclSpec decl_spec;
182     Declarator *declarator;
183     char *comment;		/* comment following the parameter */
184 } Parameter;
185 
186 /* This is a list of declarators. */
187 typedef struct declarator_list {
188     Declarator *first;		/* pointer to first declarator in list */
189     Declarator *last;		/* pointer to last declarator in list */
190 } DeclaratorList;
191 
192 /* #include "symbol.h" */
193 typedef struct symbol {
194     struct symbol *next;	/* next symbol in list */
195     char *name; 		/* name of symbol */
196     char *value;		/* value of symbol (for defines) */
197     short flags;		/* symbol attributes */
198 } Symbol;
199 
200 /* parser stack entry type */
201 typedef union {
202     Text text;
203     DeclSpec decl_spec;
204     Parameter *parameter;
205     ParameterList param_list;
206     Declarator *declarator;
207     DeclaratorList decl_list;
208 } YYSTYPE;
209 
210 /* The hash table length should be a prime number. */
211 #define SYM_MAX_HASH 251
212 
213 typedef struct symbol_table {
214     Symbol *bucket[SYM_MAX_HASH];	/* hash buckets */
215 } SymbolTable;
216 
217 extern SymbolTable *new_symbol_table	/* Create symbol table */
218 	(void);
219 extern void free_symbol_table		/* Destroy symbol table */
220 	(SymbolTable *s);
221 extern Symbol *find_symbol		/* Lookup symbol name */
222 	(SymbolTable *s, const char *n);
223 extern Symbol *new_symbol		/* Define new symbol */
224 	(SymbolTable *s, const char *n, const char *v, int f);
225 
226 /* #include "semantic.h" */
227 extern void new_decl_spec (DeclSpec *, const char *, long, int);
228 extern void free_decl_spec (DeclSpec *);
229 extern void join_decl_specs (DeclSpec *, DeclSpec *, DeclSpec *);
230 extern void check_untagged (DeclSpec *);
231 extern Declarator *new_declarator (const char *, const char *, long);
232 extern void free_declarator (Declarator *);
233 extern void new_decl_list (DeclaratorList *, Declarator *);
234 extern void free_decl_list (DeclaratorList *);
235 extern void add_decl_list (DeclaratorList *, DeclaratorList *, Declarator *);
236 extern Parameter *new_parameter (DeclSpec *, Declarator *);
237 extern void free_parameter (Parameter *);
238 extern void new_param_list (ParameterList *, Parameter *);
239 extern void free_param_list (ParameterList *);
240 extern void add_param_list (ParameterList *, ParameterList *, Parameter *);
241 extern void new_ident_list (ParameterList *);
242 extern void add_ident_list (ParameterList *, ParameterList *, const char *);
243 extern void set_param_types (ParameterList *, DeclSpec *, DeclaratorList *);
244 extern void gen_declarations (DeclSpec *, DeclaratorList *);
245 extern void gen_prototype (DeclSpec *, Declarator *);
246 extern void gen_func_declarator (Declarator *);
247 extern void gen_func_definition (DeclSpec *, Declarator *);
248 
249 extern void init_parser     (void);
250 extern void process_file    (FILE *infile, char *name);
251 extern char *cur_text       (void);
252 extern char *cur_file_name  (void);
253 extern char *implied_typedef (void);
254 extern void include_file    (char *name, int convert);
255 extern char *supply_parm    (int count);
256 extern char *xstrdup        (const char *);
257 extern int already_declared (char *name);
258 extern int is_actual_func   (Declarator *d);
259 extern int lint_ellipsis    (Parameter *p);
260 extern int want_typedef     (void);
261 extern void begin_tracking  (void);
262 extern void begin_typedef   (void);
263 extern void copy_typedef    (char *s);
264 extern void ellipsis_varargs (Declarator *d);
265 extern void end_typedef     (void);
266 extern void flush_varargs   (void);
267 extern void fmt_library     (int code);
268 extern void imply_typedef   (const char *s);
269 extern void indent          (FILE *outf);
270 extern void put_blankline   (FILE *outf);
271 extern void put_body        (FILE *outf, DeclSpec *decl_spec, Declarator *declarator);
272 extern void put_char        (FILE *outf, int c);
273 extern void put_error       (void);
274 extern void put_newline     (FILE *outf);
275 extern void put_padded      (FILE *outf, const char *s);
276 extern void put_string      (FILE *outf, const char *s);
277 extern void track_in        (void);
278 
279 extern boolean file_comments;
280 extern FuncDefStyle func_style;
281 extern char base_file[];
282 
283 extern	int	yylex (void);
284 
285 /* declaration specifier attributes for the typedef statement currently being
286  * scanned
287  */
288 static int cur_decl_spec_flags;
289 
290 /* pointer to parameter list for the current function definition */
291 static ParameterList *func_params;
292 
293 /* A parser semantic action sets this pointer to the current declarator in
294  * a function parameter declaration in order to catch any comments following
295  * the parameter declaration on the same line.  If the lexer scans a comment
296  * and <cur_declarator> is not NULL, then the comment is attached to the
297  * declarator.  To ignore subsequent comments, the lexer sets this to NULL
298  * after scanning a comment or end of line.
299  */
300 static Declarator *cur_declarator;
301 
302 /* temporary string buffer */
303 static char buf[MAX_TEXT_SIZE];
304 
305 /* table of typedef names */
306 static SymbolTable *typedef_names;
307 
308 /* table of define names */
309 static SymbolTable *define_names;
310 
311 /* table of type qualifiers */
312 static SymbolTable *type_qualifiers;
313 
314 /* information about the current input file */
315 typedef struct {
316     char *base_name;		/* base input file name */
317     char *file_name;		/* current file name */
318     FILE *file; 		/* input file */
319     unsigned line_num;		/* current line number in input file */
320     FILE *tmp_file;		/* temporary file */
321     long begin_comment; 	/* tmp file offset after last written ) or ; */
322     long end_comment;		/* tmp file offset after last comment */
323     boolean convert;		/* if TRUE, convert function definitions */
324     boolean changed;		/* TRUE if conversion done in this file */
325 } IncludeStack;
326 
327 static IncludeStack *cur_file;	/* current input file */
328 
329 /* #include "yyerror.c" */
330 
331 static int haveAnsiParam (void);
332 
333 
334 /* Flags to enable us to find if a procedure returns a value.
335  */
336 static int return_val;	/* nonzero on BRACES iff return-expression found */
337 
338 static const char *
339 dft_decl_spec (void)
340 {
341     return (lintLibrary() && !return_val) ? "void" : "int";
342 }
343 
344 static int
345 haveAnsiParam (void)
346 {
347     Parameter *p;
348     if (func_params != 0) {
349 	for (p = func_params->first; p != 0; p = p->next) {
350 	    if (p->declarator->func_def == FUNC_ANSI) {
351 		return TRUE;
352 	    }
353 	}
354     }
355     return FALSE;
356 }
357 %}
358 %%
359 
360 program
361 	: /* empty */
362 	| translation_unit
363 	;
364 
365 translation_unit
366 	: external_declaration
367 	| translation_unit external_declaration
368 	;
369 
370 external_declaration
371 	: declaration
372 	| function_definition
373 	| ';'
374 	| linkage_specification
375 	| T_ASM T_ASMARG ';'
376 	| error T_MATCHRBRACE
377 	{
378 	    yyerrok;
379 	}
380 	| error ';'
381 	{
382 	    yyerrok;
383 	}
384 	;
385 
386 braces
387 	: T_LBRACE T_MATCHRBRACE
388 	;
389 
390 linkage_specification
391 	: T_EXTERN T_STRING_LITERAL braces
392 	{
393 	    /* Provide an empty action here so bison will not complain about
394 	     * incompatible types in the default action it normally would
395 	     * have generated.
396 	     */
397 	}
398 	| T_EXTERN T_STRING_LITERAL declaration
399 	{
400 	    /* empty */
401 	}
402 	;
403 
404 declaration
405 	: decl_specifiers ';'
406 	{
407 #if OPT_LINTLIBRARY
408 	    if (types_out && want_typedef()) {
409 		gen_declarations(&$1, (DeclaratorList *)0);
410 		flush_varargs();
411 	    }
412 #endif
413 	    free_decl_spec(&$1);
414 	    end_typedef();
415 	}
416 	| decl_specifiers init_declarator_list ';'
417 	{
418 	    if (func_params != NULL) {
419 		set_param_types(func_params, &$1, &$2);
420 	    } else {
421 		gen_declarations(&$1, &$2);
422 #if OPT_LINTLIBRARY
423 		flush_varargs();
424 #endif
425 		free_decl_list(&$2);
426 	    }
427 	    free_decl_spec(&$1);
428 	    end_typedef();
429 	}
430 	| any_typedef decl_specifiers
431 	{
432 	    cur_decl_spec_flags = $2.flags;
433 	    free_decl_spec(&$2);
434 	}
435 	  opt_declarator_list ';'
436 	{
437 	    end_typedef();
438 	}
439 	;
440 
441 any_typedef
442 	: T_EXTENSION T_TYPEDEF
443 	{
444 	    begin_typedef();
445 	}
446 	| T_TYPEDEF
447 	{
448 	    begin_typedef();
449 	}
450 	;
451 
452 opt_declarator_list
453 	: /* empty */
454 	| declarator_list
455 	;
456 
457 declarator_list
458 	: declarator
459 	{
460 	    int flags = cur_decl_spec_flags;
461 
462 	    /* If the typedef is a pointer type, then reset the short type
463 	     * flags so it does not get promoted.
464 	     */
465 	    if (strcmp($1->text, $1->name) != 0)
466 		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
467 	    new_symbol(typedef_names, $1->name, NULL, flags);
468 	    free_declarator($1);
469 	}
470 	| declarator_list ',' declarator
471 	{
472 	    int flags = cur_decl_spec_flags;
473 
474 	    if (strcmp($3->text, $3->name) != 0)
475 		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
476 	    new_symbol(typedef_names, $3->name, NULL, flags);
477 	    free_declarator($3);
478 	}
479 	;
480 
481 function_definition
482 	: decl_specifiers declarator
483 	{
484 	    check_untagged(&$1);
485 	    if ($2->func_def == FUNC_NONE) {
486 		yyerror("syntax error");
487 		YYERROR;
488 	    }
489 	    func_params = &($2->head->params);
490 	    func_params->begin_comment = cur_file->begin_comment;
491 	    func_params->end_comment = cur_file->end_comment;
492 	}
493 	  opt_declaration_list T_LBRACE
494 	{
495 	    /* If we're converting to K&R and we've got a nominally K&R
496 	     * function which has a parameter which is ANSI (i.e., a prototyped
497 	     * function pointer), then we must override the deciphered value of
498 	     * 'func_def' so that the parameter will be converted.
499 	     */
500 	    if (func_style == FUNC_TRADITIONAL
501 	     && haveAnsiParam()
502 	     && $2->head->func_def == func_style) {
503 		$2->head->func_def = FUNC_BOTH;
504 	    }
505 
506 	    func_params = NULL;
507 
508 	    if (cur_file->convert)
509 		gen_func_definition(&$1, $2);
510 	    gen_prototype(&$1, $2);
511 #if OPT_LINTLIBRARY
512 	    flush_varargs();
513 #endif
514 	    free_decl_spec(&$1);
515 	    free_declarator($2);
516 	}
517 	  T_MATCHRBRACE
518 	| declarator
519 	{
520 	    if ($1->func_def == FUNC_NONE) {
521 		yyerror("syntax error");
522 		YYERROR;
523 	    }
524 	    func_params = &($1->head->params);
525 	    func_params->begin_comment = cur_file->begin_comment;
526 	    func_params->end_comment = cur_file->end_comment;
527 	}
528 	  opt_declaration_list T_LBRACE T_MATCHRBRACE
529 	{
530 	    DeclSpec decl_spec;
531 
532 	    func_params = NULL;
533 
534 	    new_decl_spec(&decl_spec, dft_decl_spec(), $1->begin, DS_NONE);
535 	    if (cur_file->convert)
536 		gen_func_definition(&decl_spec, $1);
537 	    gen_prototype(&decl_spec, $1);
538 #if OPT_LINTLIBRARY
539 	    flush_varargs();
540 #endif
541 	    free_decl_spec(&decl_spec);
542 	    free_declarator($1);
543 	}
544 	;
545 
546 opt_declaration_list
547 	: /* empty */
548 	| T_VA_DCL
549 	| declaration_list
550 	;
551 
552 declaration_list
553 	: declaration
554 	| declaration_list declaration
555 	;
556 
557 decl_specifiers
558 	: decl_specifier
559 	| decl_specifiers decl_specifier
560 	{
561 	    join_decl_specs(&$$, &$1, &$2);
562 	    free($1.text);
563 	    free($2.text);
564 	}
565 	;
566 
567 decl_specifier
568 	: storage_class
569 	| type_specifier
570 	| type_qualifier
571 	;
572 
573 storage_class
574 	: T_AUTO
575 	{
576 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
577 	}
578 	| T_EXTERN
579 	{
580 	    new_decl_spec(&$$, $1.text, $1.begin, DS_EXTERN);
581 	}
582 	| T_REGISTER
583 	{
584 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
585 	}
586 	| T_STATIC
587 	{
588 	    new_decl_spec(&$$, $1.text, $1.begin, DS_STATIC);
589 	}
590 	| T_INLINE
591 	{
592 	    new_decl_spec(&$$, $1.text, $1.begin, DS_INLINE);
593 	}
594 	| T_EXTENSION
595 	{
596 	    new_decl_spec(&$$, $1.text, $1.begin, DS_JUNK);
597 	}
598 	;
599 
600 type_specifier
601 	: T_CHAR
602 	{
603 	    new_decl_spec(&$$, $1.text, $1.begin, DS_CHAR);
604 	}
605 	| T_DOUBLE
606 	{
607 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
608 	}
609 	| T_FLOAT
610 	{
611 	    new_decl_spec(&$$, $1.text, $1.begin, DS_FLOAT);
612 	}
613 	| T_INT
614 	{
615 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
616 	}
617 	| T_LONG
618 	{
619 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
620 	}
621 	| T_SHORT
622 	{
623 	    new_decl_spec(&$$, $1.text, $1.begin, DS_SHORT);
624 	}
625 	| T_SIGNED
626 	{
627 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
628 	}
629 	| T_UNSIGNED
630 	{
631 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
632 	}
633 	| T_VOID
634 	{
635 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
636 	}
637 	| T_Bool
638 	{
639 	    new_decl_spec(&$$, $1.text, $1.begin, DS_CHAR);
640 	}
641 	| T_Complex
642 	{
643 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
644 	}
645 	| T_Imaginary
646 	{
647 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
648 	}
649 	| T_TYPEDEF_NAME
650 	{
651 	    Symbol *s;
652 	    s = find_symbol(typedef_names, $1.text);
653 	    if (s != NULL)
654 		new_decl_spec(&$$, $1.text, $1.begin, s->flags);
655 	}
656 	| struct_or_union_specifier
657 	| enum_specifier
658 	;
659 
660 type_qualifier
661 	: T_TYPE_QUALIFIER
662 	{
663 	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
664 	}
665 	| T_DEFINE_NAME
666 	{
667 	    /* This rule allows the <pointer> nonterminal to scan #define
668 	     * names as if they were type modifiers.
669 	     */
670 	    Symbol *s;
671 	    s = find_symbol(define_names, $1.text);
672 	    if (s != NULL)
673 		new_decl_spec(&$$, $1.text, $1.begin, s->flags);
674 	}
675 	;
676 
677 struct_or_union_specifier
678 	: struct_or_union any_id braces
679 	{
680 	    char *s;
681 	    if ((s = implied_typedef()) == 0)
682 	        (void)sprintf(s = buf, "%s %s", $1.text, $2.text);
683 	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
684 	}
685 	| struct_or_union braces
686 	{
687 	    char *s;
688 	    if ((s = implied_typedef()) == 0)
689 		(void)sprintf(s = buf, "%s {}", $1.text);
690 	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
691 	}
692 	| struct_or_union any_id
693 	{
694 	    (void)sprintf(buf, "%s %s", $1.text, $2.text);
695 	    new_decl_spec(&$$, buf, $1.begin, DS_NONE);
696 	}
697 	;
698 
699 struct_or_union
700 	: T_STRUCT
701 	{
702 	    imply_typedef($$.text);
703 	}
704 	| T_UNION
705 	{
706 	    imply_typedef($$.text);
707 	}
708 	;
709 
710 init_declarator_list
711 	: init_declarator
712 	{
713 	    new_decl_list(&$$, $1);
714 	}
715 	| init_declarator_list ',' init_declarator
716 	{
717 	    add_decl_list(&$$, &$1, $3);
718 	}
719 	;
720 
721 init_declarator
722 	: declarator
723 	{
724 	    if ($1->func_def != FUNC_NONE && func_params == NULL &&
725 		func_style == FUNC_TRADITIONAL && cur_file->convert) {
726 		gen_func_declarator($1);
727 		fputs(cur_text(), cur_file->tmp_file);
728 	    }
729 	    cur_declarator = $$;
730 	}
731 	| declarator '='
732 	{
733 	    if ($1->func_def != FUNC_NONE && func_params == NULL &&
734 		func_style == FUNC_TRADITIONAL && cur_file->convert) {
735 		gen_func_declarator($1);
736 		fputs(" =", cur_file->tmp_file);
737 	    }
738 	}
739 	  T_INITIALIZER
740 	;
741 
742 enum_specifier
743 	: enumeration any_id braces
744 	{
745 	    char *s;
746 	    if ((s = implied_typedef()) == 0)
747 		(void)sprintf(s = buf, "enum %s", $2.text);
748 	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
749 	}
750 	| enumeration braces
751 	{
752 	    char *s;
753 	    if ((s = implied_typedef()) == 0)
754 		(void)sprintf(s = buf, "%s {}", $1.text);
755 	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
756 	}
757 	| enumeration any_id
758 	{
759 	    (void)sprintf(buf, "enum %s", $2.text);
760 	    new_decl_spec(&$$, buf, $1.begin, DS_NONE);
761 	}
762 	;
763 
764 enumeration
765 	: T_ENUM
766 	{
767 	    imply_typedef("enum");
768 	    $$ = $1;
769 	}
770 	;
771 
772 any_id
773 	: T_IDENTIFIER
774 	| T_TYPEDEF_NAME
775 	;
776 
777 declarator
778 	: pointer direct_declarator
779 	{
780 	    $$ = $2;
781 	    (void)sprintf(buf, "%s%s", $1.text, $$->text);
782 	    free($$->text);
783 	    $$->text = xstrdup(buf);
784 	    $$->begin = $1.begin;
785 	    $$->pointer = TRUE;
786 	}
787 	| direct_declarator
788 	;
789 
790 direct_declarator
791 	: identifier_or_ref
792 	{
793 	    $$ = new_declarator($1.text, $1.text, $1.begin);
794 	}
795 	| '(' declarator ')'
796 	{
797 	    $$ = $2;
798 	    (void)sprintf(buf, "(%s)", $$->text);
799 	    free($$->text);
800 	    $$->text = xstrdup(buf);
801 	    $$->begin = $1.begin;
802 	}
803 	| direct_declarator T_BRACKETS
804 	{
805 	    $$ = $1;
806 	    (void)sprintf(buf, "%s%s", $$->text, $2.text);
807 	    free($$->text);
808 	    $$->text = xstrdup(buf);
809 	}
810 	| direct_declarator '(' parameter_type_list ')'
811 	{
812 	    $$ = new_declarator("%s()", $1->name, $1->begin);
813 	    $$->params = $3;
814 	    $$->func_stack = $1;
815 	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
816 	    $$->func_def = FUNC_ANSI;
817 	}
818 	| direct_declarator '(' opt_identifier_list ')'
819 	{
820 	    $$ = new_declarator("%s()", $1->name, $1->begin);
821 	    $$->params = $3;
822 	    $$->func_stack = $1;
823 	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
824 	    $$->func_def = FUNC_TRADITIONAL;
825 	}
826 	;
827 
828 pointer
829 	: '*' opt_type_qualifiers
830 	{
831 	    (void)sprintf($$.text, "*%s", $2.text);
832 	    $$.begin = $1.begin;
833 	}
834 	| '*' opt_type_qualifiers pointer
835 	{
836 	    (void)sprintf($$.text, "*%s%s", $2.text, $3.text);
837 	    $$.begin = $1.begin;
838 	}
839 	;
840 
841 opt_type_qualifiers
842 	: /* empty */
843 	{
844 	    strcpy($$.text, "");
845 	    $$.begin = 0L;
846 	}
847 	| type_qualifier_list
848 	;
849 
850 type_qualifier_list
851 	: type_qualifier
852 	{
853 	    (void)sprintf($$.text, "%s ", $1.text);
854 	    $$.begin = $1.begin;
855 	    free($1.text);
856 	}
857 	| type_qualifier_list type_qualifier
858 	{
859 	    (void)sprintf($$.text, "%s%s ", $1.text, $2.text);
860 	    $$.begin = $1.begin;
861 	    free($2.text);
862 	}
863 	;
864 
865 parameter_type_list
866 	: parameter_list
867 	| parameter_list ',' T_ELLIPSIS
868 	{
869 	    add_ident_list(&$$, &$1, "...");
870 	}
871 	;
872 
873 parameter_list
874 	: parameter_declaration
875 	{
876 	    new_param_list(&$$, $1);
877 	}
878 	| parameter_list ',' parameter_declaration
879 	{
880 	    add_param_list(&$$, &$1, $3);
881 	}
882 	;
883 
884 parameter_declaration
885 	: decl_specifiers declarator
886 	{
887 	    check_untagged(&$1);
888 	    $$ = new_parameter(&$1, $2);
889 	}
890 	| decl_specifiers abs_declarator
891 	{
892 	    check_untagged(&$1);
893 	    $$ = new_parameter(&$1, $2);
894 	}
895 	| decl_specifiers
896 	{
897 	    check_untagged(&$1);
898 	    $$ = new_parameter(&$1, (Declarator *)0);
899 	}
900 	;
901 
902 opt_identifier_list
903 	: /* empty */
904 	{
905 	    new_ident_list(&$$);
906 	}
907 	| identifier_list
908 	;
909 
910 identifier_list
911 	: any_id
912 	{
913 	    new_ident_list(&$$);
914 	    add_ident_list(&$$, &$$, $1.text);
915 	}
916 	| identifier_list ',' any_id
917 	{
918 	    add_ident_list(&$$, &$1, $3.text);
919 	}
920 	;
921 
922 identifier_or_ref
923 	: any_id
924 	{
925 	    $$ = $1;
926 	}
927 	| '&' any_id
928 	{
929 #if OPT_LINTLIBRARY
930 	    if (lintLibrary()) { /* Lint doesn't grok C++ ref variables */
931 		$$ = $2;
932 	    } else
933 #endif
934 		(void)sprintf($$.text, "&%s", $2.text);
935 	    $$.begin = $1.begin;
936 	}
937 	;
938 
939 abs_declarator
940 	: pointer
941 	{
942 	    $$ = new_declarator($1.text, "", $1.begin);
943 	}
944 	| pointer direct_abs_declarator
945 	{
946 	    $$ = $2;
947 	    (void)sprintf(buf, "%s%s", $1.text, $$->text);
948 	    free($$->text);
949 	    $$->text = xstrdup(buf);
950 	    $$->begin = $1.begin;
951 	}
952 	| direct_abs_declarator
953 	;
954 
955 direct_abs_declarator
956 	: '(' abs_declarator ')'
957 	{
958 	    $$ = $2;
959 	    (void)sprintf(buf, "(%s)", $$->text);
960 	    free($$->text);
961 	    $$->text = xstrdup(buf);
962 	    $$->begin = $1.begin;
963 	}
964 	| direct_abs_declarator T_BRACKETS
965 	{
966 	    $$ = $1;
967 	    (void)sprintf(buf, "%s%s", $$->text, $2.text);
968 	    free($$->text);
969 	    $$->text = xstrdup(buf);
970 	}
971 	| T_BRACKETS
972 	{
973 	    $$ = new_declarator($1.text, "", $1.begin);
974 	}
975 	| direct_abs_declarator '(' parameter_type_list ')'
976 	{
977 	    $$ = new_declarator("%s()", "", $1->begin);
978 	    $$->params = $3;
979 	    $$->func_stack = $1;
980 	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
981 	    $$->func_def = FUNC_ANSI;
982 	}
983 	| direct_abs_declarator '(' ')'
984 	{
985 	    $$ = new_declarator("%s()", "", $1->begin);
986 	    $$->func_stack = $1;
987 	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
988 	    $$->func_def = FUNC_ANSI;
989 	}
990 	| '(' parameter_type_list ')'
991 	{
992 	    Declarator *d;
993 
994 	    d = new_declarator("", "", $1.begin);
995 	    $$ = new_declarator("%s()", "", $1.begin);
996 	    $$->params = $2;
997 	    $$->func_stack = d;
998 	    $$->head = $$;
999 	    $$->func_def = FUNC_ANSI;
1000 	}
1001 	| '(' ')'
1002 	{
1003 	    Declarator *d;
1004 
1005 	    d = new_declarator("", "", $1.begin);
1006 	    $$ = new_declarator("%s()", "", $1.begin);
1007 	    $$->func_stack = d;
1008 	    $$->head = $$;
1009 	    $$->func_def = FUNC_ANSI;
1010 	}
1011 	;
1012 
1013 %%
1014 
1015 /* lex.yy.c */
1016 #define BEGIN yy_start = 1 + 2 *
1017 
1018 #define CPP1 1
1019 #define INIT1 2
1020 #define INIT2 3
1021 #define CURLY 4
1022 #define LEXYACC 5
1023 #define ASM 6
1024 #define CPP_INLINE 7
1025 
1026 extern char *yytext;
1027 extern FILE *yyin, *yyout;
1028 
1029 static int curly;			/* number of curly brace nesting levels */
1030 static int ly_count;			/* number of occurances of %% */
1031 static int inc_depth;			/* include nesting level */
1032 static SymbolTable *included_files;	/* files already included */
1033 static int yy_start = 0;		/* start state number */
1034 
1035 #define grammar_error(s) yaccError(s)
1036 
1037 static void
1038 yaccError (const char *msg)
1039 {
1040     func_params = NULL;
1041     put_error();		/* tell what line we're on, and what file */
1042     fprintf(stderr, "%s at token '%s'\n", msg, yytext);
1043 }
1044 
1045 /* Initialize the table of type qualifier keywords recognized by the lexical
1046  * analyzer.
1047  */
1048 void
1049 init_parser (void)
1050 {
1051     static const char *keywords[] = {
1052 	"const",
1053 	"restrict",
1054 	"volatile",
1055 	"interrupt",
1056 #ifdef vms
1057 	"noshare",
1058 	"readonly",
1059 #endif
1060 #if defined(MSDOS) || defined(OS2)
1061 	"__cdecl",
1062 	"__export",
1063 	"__far",
1064 	"__fastcall",
1065 	"__fortran",
1066 	"__huge",
1067 	"__inline",
1068 	"__interrupt",
1069 	"__loadds",
1070 	"__near",
1071 	"__pascal",
1072 	"__saveregs",
1073 	"__segment",
1074 	"__stdcall",
1075 	"__syscall",
1076 	"_cdecl",
1077 	"_cs",
1078 	"_ds",
1079 	"_es",
1080 	"_export",
1081 	"_far",
1082 	"_fastcall",
1083 	"_fortran",
1084 	"_huge",
1085 	"_interrupt",
1086 	"_loadds",
1087 	"_near",
1088 	"_pascal",
1089 	"_saveregs",
1090 	"_seg",
1091 	"_segment",
1092 	"_ss",
1093 	"cdecl",
1094 	"far",
1095 	"huge",
1096 	"near",
1097 	"pascal",
1098 #ifdef OS2
1099 	"__far16",
1100 #endif
1101 #endif
1102 #ifdef __GNUC__
1103 	/* gcc aliases */
1104 	"__builtin_va_arg",
1105 	"__builtin_va_list",
1106 	"__const",
1107 	"__const__",
1108 	"__inline",
1109 	"__inline__",
1110 	"__restrict",
1111 	"__restrict__",
1112 	"__volatile",
1113 	"__volatile__",
1114 #endif
1115     };
1116     unsigned i;
1117 
1118     /* Initialize type qualifier table. */
1119     type_qualifiers = new_symbol_table();
1120     for (i = 0; i < sizeof(keywords)/sizeof(keywords[0]); ++i) {
1121 	new_symbol(type_qualifiers, keywords[i], NULL, DS_NONE);
1122     }
1123 }
1124 
1125 /* Process the C source file.  Write function prototypes to the standard
1126  * output.  Convert function definitions and write the converted source
1127  * code to a temporary file.
1128  */
1129 void
1130 process_file (FILE *infile, char *name)
1131 {
1132     char *s;
1133 
1134     if (strlen(name) > 2) {
1135 	s = name + strlen(name) - 2;
1136 	if (*s == '.') {
1137 	    ++s;
1138 	    if (*s == 'l' || *s == 'y')
1139 		BEGIN LEXYACC;
1140 #if defined(MSDOS) || defined(OS2)
1141 	    if (*s == 'L' || *s == 'Y')
1142 		BEGIN LEXYACC;
1143 #endif
1144 	}
1145     }
1146 
1147     included_files = new_symbol_table();
1148     typedef_names = new_symbol_table();
1149     define_names = new_symbol_table();
1150     inc_depth = -1;
1151     curly = 0;
1152     ly_count = 0;
1153     func_params = NULL;
1154     yyin = infile;
1155     include_file(strcpy(base_file, name), func_style != FUNC_NONE);
1156     if (file_comments) {
1157 #if OPT_LINTLIBRARY
1158     	if (lintLibrary()) {
1159 	    put_blankline(stdout);
1160 	    begin_tracking();
1161 	}
1162 #endif
1163 	put_string(stdout, "/* ");
1164 	put_string(stdout, cur_file_name());
1165 	put_string(stdout, " */\n");
1166     }
1167     yyparse();
1168     free_symbol_table(define_names);
1169     free_symbol_table(typedef_names);
1170     free_symbol_table(included_files);
1171 }
1172 
1173 #ifdef NO_LEAKS
1174 void
1175 free_parser(void)
1176 {
1177     free_symbol_table (type_qualifiers);
1178 #ifdef FLEX_SCANNER
1179     if (yy_current_buffer != 0)
1180 	yy_delete_buffer(yy_current_buffer);
1181 #endif
1182 }
1183 #endif
1184