![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-parse.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-parse.y CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* YACC parser for C syntax.
2: Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* To whomever it may concern: I have heard that such a thing was once
22: written by AT&T, but I have never seen it. */
23:
24: %expect 8
25:
26: /* These are the 8 conflicts you should get in parse.output;
27: the state numbers may vary if minor changes in the grammar are made.
28:
29: State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.)
30: State 92 contains 1 shift/reduce conflict. (Two ways to recover from error.)
31: State 99 contains 1 shift/reduce conflict. (Two ways to recover from error.)
32: State 103 contains 1 shift/reduce conflict. (Two ways to recover from error.)
33: State 119 contains 1 shift/reduce conflict. (See comment at component_decl.)
34: State 183 contains 1 shift/reduce conflict. (Two ways to recover from error.)
35: State 193 contains 1 shift/reduce conflict. (Two ways to recover from error.)
36: State 199 contains 1 shift/reduce conflict. (Two ways to recover from error.)
37: */
38:
39: %{
40: #include <stdio.h>
41: #include <errno.h>
42: #include <setjmp.h>
43:
44: #include "config.h"
45: #include "tree.h"
46: #include "input.h"
47: #include "c-lex.h"
48: #include "c-tree.h"
49: #include "flags.h"
50:
51: #ifdef MULTIBYTE_CHARS
52: #include <stdlib.h>
53: #include <locale.h>
54: #endif
55:
56: #ifndef errno
57: extern int errno;
58: #endif
59:
60: void yyerror ();
61:
62: /* Like YYERROR but do call yyerror. */
63: #define YYERROR1 { yyerror ("syntax error"); YYERROR; }
64:
65: /* Cause the `yydebug' variable to be defined. */
66: #define YYDEBUG 1
67: %}
68:
69: %start program
70:
71: %union {long itype; tree ttype; enum tree_code code;
72: char *filename; int lineno; }
73:
74: /* All identifiers that are not reserved words
75: and are not declared typedefs in the current block */
76: %token IDENTIFIER
77:
78: /* All identifiers that are declared typedefs in the current block.
79: In some contexts, they are treated just like IDENTIFIER,
80: but they can also serve as typespecs in declarations. */
81: %token TYPENAME
82:
83: /* Reserved words that specify storage class.
84: yylval contains an IDENTIFIER_NODE which indicates which one. */
85: %token SCSPEC
86:
87: /* Reserved words that specify type.
88: yylval contains an IDENTIFIER_NODE which indicates which one. */
89: %token TYPESPEC
90:
91: /* Reserved words that qualify type: "const" or "volatile".
92: yylval contains an IDENTIFIER_NODE which indicates which one. */
93: %token TYPE_QUAL
94:
95: /* Character or numeric constants.
96: yylval is the node for the constant. */
97: %token CONSTANT
98:
99: /* String constants in raw form.
100: yylval is a STRING_CST node. */
101: %token STRING
102:
103: /* "...", used for functions with variable arglists. */
104: %token ELLIPSIS
105:
106: /* the reserved words */
107: %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
108: %token BREAK CONTINUE RETURN GOTO ASM TYPEOF ALIGNOF ALIGN
109: %token ATTRIBUTE EXTENSION LABEL
110:
111: /* Add precedence rules to solve dangling else s/r conflict */
112: %nonassoc IF
113: %nonassoc ELSE
114:
115: /* Define the operator tokens and their precedences.
116: The value is an integer because, if used, it is the tree code
117: to use in the expression made from the operator. */
118:
119: %right <code> ASSIGN '='
120: %right <code> '?' ':'
121: %left <code> OROR
122: %left <code> ANDAND
123: %left <code> '|'
124: %left <code> '^'
125: %left <code> '&'
126: %left <code> EQCOMPARE
127: %left <code> ARITHCOMPARE
128: %left <code> LSHIFT RSHIFT
129: %left <code> '+' '-'
130: %left <code> '*' '/' '%'
131: %right <code> UNARY PLUSPLUS MINUSMINUS
132: %left HYPERUNARY
133: %left <code> POINTSAT '.' '(' '['
134:
135: /* The Objective-C keywords, here so our token codes match obj's. */
136: %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE
137: %token CLASSNAME PUBLIC
138:
139:
140: %type <code> unop
141:
142: %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
143: %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING
144: %type <ttype> typed_declspecs reserved_declspecs
145: %type <ttype> typed_typespecs reserved_typespecquals
146: %type <ttype> declmods typespec typespecqual_reserved
147: %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
148: %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
149: %type <ttype> init initlist maybeasm
150: %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers
151: %type <ttype> maybe_attribute attribute_list attrib
152:
153: %type <ttype> compstmt
154:
155: %type <ttype> declarator
156: %type <ttype> notype_declarator after_type_declarator
157: %type <ttype> parm_declarator
158:
159: %type <ttype> structsp component_decl_list component_decl_list2
160: %type <ttype> component_decl components component_declarator
161: %type <ttype> enumlist enumerator
162: %type <ttype> typename absdcl absdcl1 type_quals
163: %type <ttype> xexpr parms parm identifiers
164:
165: %type <ttype> parmlist parmlist_1 parmlist_2
166: %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
167: %type <ttype> identifiers_or_typenames
168:
169: %type <itype> setspecs
170:
171: %type <filename> save_filename
172: %type <lineno> save_lineno
173:
174: %{
175: /* Number of statements (loosely speaking) seen so far. */
176: static int stmt_count;
177:
178: /* Input file and line number of the end of the body of last simple_if;
179: used by the stmt-rule immediately after simple_if returns. */
180: static char *if_stmt_file;
181: static int if_stmt_line;
182:
183: /* List of types and structure classes of the current declaration. */
184: static tree current_declspecs;
185:
186: /* Stack of saved values of current_declspecs. */
187: static tree declspec_stack;
188:
189: /* 1 if we explained undeclared var errors. */
190: static int undeclared_variable_notice;
191:
192: /* Tell yyparse how to print a token's value, if yydebug is set. */
193:
194: #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
195: extern void yyprint ();
196: %}
197:
198: %%
199: program: /* empty */
200: { if (pedantic)
201: pedwarn ("ANSI C forbids an empty source file"); }
202: | extdefs
203: ;
204:
205: /* the reason for the strange actions in this rule
206: is so that notype_initdecls when reached via datadef
207: can find a valid list of type and sc specs in $0. */
208:
209: extdefs:
210: {$<ttype>$ = NULL_TREE; } extdef
211: | extdefs {$<ttype>$ = NULL_TREE; } extdef
212: ;
213:
214: extdef:
215: fndef
216: | datadef
217: | ASM '(' expr ')' ';'
218: { STRIP_NOPS ($3);
219: if ((TREE_CODE ($3) == ADDR_EXPR
220: && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST)
221: || TREE_CODE ($3) == STRING_CST)
222: assemble_asm ($3);
223: else
224: error ("argument of `asm' is not a constant string"); }
225: ;
226:
227: datadef:
228: setspecs notype_initdecls ';'
229: { if (pedantic)
230: error ("ANSI C forbids data definition with no type or storage class");
231: else if (!flag_traditional)
232: warning ("data definition has no type or storage class"); }
233: | declmods setspecs notype_initdecls ';'
234: {}
235: | typed_declspecs setspecs initdecls ';'
236: {}
237: | declmods ';'
238: { error ("empty declaration"); }
239: | typed_declspecs ';'
240: { shadow_tag ($1); }
241: | error ';'
242: | error '}'
243: | ';'
244: { if (pedantic)
245: pedwarn ("ANSI C does not allow extra `;' outside of a function"); }
246: ;
247:
248: fndef:
249: typed_declspecs setspecs declarator
250: { if (! start_function ($1, $3, 0))
251: YYERROR1;
252: reinit_parse_for_function (); }
253: xdecls
254: { store_parm_decls (); }
255: compstmt_or_error
256: { finish_function (0); }
257: | typed_declspecs setspecs declarator error
258: { }
259: | declmods setspecs notype_declarator
260: { if (! start_function ($1, $3, 0))
261: YYERROR1;
262: reinit_parse_for_function (); }
263: xdecls
264: { store_parm_decls (); }
265: compstmt_or_error
266: { finish_function (0); }
267: | declmods setspecs notype_declarator error
268: { }
269: | setspecs notype_declarator
270: { if (! start_function (0, $2, 0))
271: YYERROR1;
272: reinit_parse_for_function (); }
273: xdecls
274: { store_parm_decls (); }
275: compstmt_or_error
276: { finish_function (0); }
277: | setspecs notype_declarator error
278: { }
279: ;
280:
281: identifier:
282: IDENTIFIER
283: | TYPENAME
284: ;
285:
286: unop: '&'
287: { $$ = ADDR_EXPR; }
288: | '-'
289: { $$ = NEGATE_EXPR; }
290: | '+'
291: { $$ = CONVERT_EXPR; }
292: | PLUSPLUS
293: { $$ = PREINCREMENT_EXPR; }
294: | MINUSMINUS
295: { $$ = PREDECREMENT_EXPR; }
296: | '~'
297: { $$ = BIT_NOT_EXPR; }
298: | '!'
299: { $$ = TRUTH_NOT_EXPR; }
300: ;
301:
302: expr: nonnull_exprlist
303: { $$ = build_compound_expr ($1); }
304: ;
305:
306: exprlist:
307: /* empty */
308: { $$ = NULL_TREE; }
309: | nonnull_exprlist
310: ;
311:
312: nonnull_exprlist:
313: expr_no_commas
314: { $$ = build_tree_list (NULL_TREE, $1); }
315: | nonnull_exprlist ',' expr_no_commas
316: { chainon ($1, build_tree_list (NULL_TREE, $3)); }
317: ;
318:
319: unary_expr:
320: primary
321: | '*' cast_expr %prec UNARY
322: { $$ = build_indirect_ref ($2, "unary *"); }
323: /* __extension__ turns off -pedantic for following primary. */
324: | EXTENSION
325: { $<itype>1 = pedantic;
326: pedantic = 0; }
327: cast_expr %prec UNARY
328: { $$ = $3;
329: pedantic = $<itype>1; }
330: | unop cast_expr %prec UNARY
331: { $$ = build_unary_op ($1, $2, 0); }
332: /* Refer to the address of a label as a pointer. */
333: | ANDAND identifier
334: { tree label = lookup_label ($2);
335: TREE_USED (label) = 1;
336: $$ = build1 (ADDR_EXPR, ptr_type_node, label);
337: TREE_CONSTANT ($$) = 1; }
338: /* This seems to be impossible on some machines, so let's turn it off.
339: | '&' ELLIPSIS
340: { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl));
341: $$ = error_mark_node;
342: if (TREE_VALUE (tree_last (types)) == void_type_node)
343: error ("`&...' used in function with fixed number of arguments");
344: else
345: {
346: if (pedantic)
347: pedwarn ("ANSI C forbids `&...'");
348: $$ = tree_last (DECL_ARGUMENTS (current_function_decl));
349: $$ = build_unary_op (ADDR_EXPR, $$, 0);
350: } }
351: */
352: | SIZEOF unary_expr %prec UNARY
353: { if (TREE_CODE ($2) == COMPONENT_REF
354: && DECL_BIT_FIELD (TREE_OPERAND ($2, 1)))
355: error ("`sizeof' applied to a bit-field");
356: $$ = c_sizeof (TREE_TYPE ($2)); }
357: | SIZEOF '(' typename ')' %prec HYPERUNARY
358: { $$ = c_sizeof (groktypename ($3)); }
359: | ALIGNOF unary_expr %prec UNARY
360: { $$ = c_alignof_expr ($2); }
361: | ALIGNOF '(' typename ')' %prec HYPERUNARY
362: { $$ = c_alignof (groktypename ($3)); }
363: ;
364:
365: cast_expr:
366: unary_expr
367: | '(' typename ')' cast_expr %prec UNARY
368: { tree type = groktypename ($2);
369: $$ = build_c_cast (type, $4); }
370: | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY
371: { tree type = groktypename ($2);
372: char *name;
373: if (pedantic)
374: pedwarn ("ANSI C forbids constructor expressions");
375: if (TYPE_NAME (type) != 0)
376: {
377: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
378: name = IDENTIFIER_POINTER (TYPE_NAME (type));
379: else
380: name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
381: }
382: else
383: name = "";
384: $$ = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5)),
385: 0, 0, 0, name);
386: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
387: {
388: int failure = complete_array_type (type, $$, 1);
389: if (failure)
390: abort ();
391: }
392: }
393: ;
394:
395: expr_no_commas:
396: cast_expr
397: | expr_no_commas '+' expr_no_commas
398: { $$ = parser_build_binary_op ($2, $1, $3); }
399: | expr_no_commas '-' expr_no_commas
400: { $$ = parser_build_binary_op ($2, $1, $3); }
401: | expr_no_commas '*' expr_no_commas
402: { $$ = parser_build_binary_op ($2, $1, $3); }
403: | expr_no_commas '/' expr_no_commas
404: { $$ = parser_build_binary_op ($2, $1, $3); }
405: | expr_no_commas '%' expr_no_commas
406: { $$ = parser_build_binary_op ($2, $1, $3); }
407: | expr_no_commas LSHIFT expr_no_commas
408: { $$ = parser_build_binary_op ($2, $1, $3); }
409: | expr_no_commas RSHIFT expr_no_commas
410: { $$ = parser_build_binary_op ($2, $1, $3); }
411: | expr_no_commas ARITHCOMPARE expr_no_commas
412: { $$ = parser_build_binary_op ($2, $1, $3); }
413: | expr_no_commas EQCOMPARE expr_no_commas
414: { $$ = parser_build_binary_op ($2, $1, $3); }
415: | expr_no_commas '&' expr_no_commas
416: { $$ = parser_build_binary_op ($2, $1, $3); }
417: | expr_no_commas '|' expr_no_commas
418: { $$ = parser_build_binary_op ($2, $1, $3); }
419: | expr_no_commas '^' expr_no_commas
420: { $$ = parser_build_binary_op ($2, $1, $3); }
421: | expr_no_commas ANDAND expr_no_commas
422: { $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); }
423: | expr_no_commas OROR expr_no_commas
424: { $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $3); }
425: | expr_no_commas '?' xexpr ':' expr_no_commas
426: { $$ = build_conditional_expr ($1, $3, $5); }
427: | expr_no_commas '=' expr_no_commas
428: { $$ = build_modify_expr ($1, NOP_EXPR, $3); }
429: | expr_no_commas ASSIGN expr_no_commas
430: { $$ = build_modify_expr ($1, $2, $3); }
431: ;
432:
433: primary:
434: IDENTIFIER
435: {
436: tree context;
437:
438: $$ = lastiddecl;
439: if (!$$ || $$ == error_mark_node)
440: {
441: if (yychar == YYEMPTY)
442: yychar = YYLEX;
443: if (yychar == '(')
444: {
445: $$ = implicitly_declare ($1);
446: assemble_external ($$);
447: TREE_USED ($$) = 1;
448: }
449: else if (current_function_decl == 0)
450: {
451: error ("`%s' undeclared, outside of functions",
452: IDENTIFIER_POINTER ($1));
453: $$ = error_mark_node;
454: }
455: else
456: {
457: if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node
458: || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl)
459: {
460: error ("`%s' undeclared (first use this function)",
461: IDENTIFIER_POINTER ($1));
462:
463: if (! undeclared_variable_notice)
464: {
465: error ("(Each undeclared identifier is reported only once");
466: error ("for each function it appears in.)");
467: undeclared_variable_notice = 1;
468: }
469: }
470: $$ = error_mark_node;
471: /* Prevent repeated error messages. */
472: IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node;
473: IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl;
474: }
475: }
476: else if (TREE_TYPE ($$) == error_mark_node)
477: $$ = error_mark_node;
478: else if (! TREE_USED ($$))
479: {
480: if (TREE_EXTERNAL ($$))
481: assemble_external ($$);
482: TREE_USED ($$) = 1;
483: }
484: if (TREE_CODE ($$) == CONST_DECL)
485: $$ = DECL_INITIAL ($$);
486: }
487: | CONSTANT
488: | string
489: { $$ = combine_strings ($1); }
490: | '(' expr ')'
491: { char class = TREE_CODE_CLASS (TREE_CODE ($2));
492: if (class == 'e' || class == '1'
493: || class == '2' || class == '<')
494: C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK);
495: $$ = $2; }
496: | '(' error ')'
497: { $$ = error_mark_node; }
498: | '('
499: { if (current_function_decl == 0)
500: {
501: error ("braced-group within expression allowed only inside a function");
502: YYERROR;
503: }
504: /* We must force a BLOCK for this level
505: so that, if it is not expanded later,
506: there is a way to turn off the entire subtree of blocks
507: that are contained in it. */
508: keep_next_level ();
509: push_label_level ();
510: $<ttype>$ = expand_start_stmt_expr (); }
511: compstmt ')'
512: { tree rtl_exp;
513: if (pedantic)
514: pedwarn ("ANSI C forbids braced-groups within expressions");
515: pop_label_level ();
516: rtl_exp = expand_end_stmt_expr ($<ttype>2);
517: /* The statements have side effects, so the group does. */
518: TREE_SIDE_EFFECTS (rtl_exp) = 1;
519:
520: /* Make a BIND_EXPR for the BLOCK already made. */
521: $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp),
522: NULL_TREE, rtl_exp, $3);
523: }
524: | primary '(' exprlist ')' %prec '.'
525: { $$ = build_function_call ($1, $3); }
526: | primary '[' expr ']' %prec '.'
527: { $$ = build_array_ref ($1, $3); }
528: | primary '.' identifier
529: { $$ = build_component_ref ($1, $3); }
530: | primary POINTSAT identifier
531: { $$ = build_component_ref (build_indirect_ref ($1, "->"), $3); }
532: | primary PLUSPLUS
533: { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
534: | primary MINUSMINUS
535: { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
536: ;
537:
538: /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
539: string:
540: STRING
541: | string STRING
542: { $$ = chainon ($1, $2); }
543: ;
544:
545: xdecls:
546: /* empty */
547: | datadecls
548: | datadecls ELLIPSIS
549: /* ... is used here to indicate a varargs function. */
550: { c_mark_varargs ();
551: if (pedantic)
552: pedwarn ("ANSI C does not permit use of `varargs.h'"); }
553: ;
554:
555: /* The following are analogous to lineno_decl, decls and decl
556: except that they do not allow nested functions.
557: They are used for old-style parm decls. */
558: lineno_datadecl:
559: save_filename save_lineno datadecl
560: { }
561: ;
562:
563: datadecls:
564: lineno_datadecl
565: | errstmt
566: | datadecls lineno_datadecl
567: | lineno_datadecl errstmt
568: ;
569:
570: datadecl:
571: typed_declspecs setspecs initdecls ';'
572: { current_declspecs = TREE_VALUE (declspec_stack);
573: declspec_stack = TREE_CHAIN (declspec_stack);
574: resume_momentary ($2); }
575: | declmods setspecs notype_initdecls ';'
576: { current_declspecs = TREE_VALUE (declspec_stack);
577: declspec_stack = TREE_CHAIN (declspec_stack);
578: resume_momentary ($2); }
579: | typed_declspecs ';'
580: { shadow_tag ($1); }
581: | declmods ';'
582: { pedwarn ("empty declaration"); }
583: ;
584:
585: /* This combination which saves a lineno before a decl
586: is the normal thing to use, rather than decl itself.
587: This is to avoid shift/reduce conflicts in contexts
588: where statement labels are allowed. */
589: lineno_decl:
590: save_filename save_lineno decl
591: { }
592: ;
593:
594: decls:
595: lineno_decl
596: | errstmt
597: | decls lineno_decl
598: | lineno_decl errstmt
599: ;
600:
601: /* records the type and storage class specs to use for processing
602: the declarators that follow.
603: Maintains a stack of outer-level values of current_declspecs,
604: for the sake of parm declarations nested in function declarators. */
605: setspecs: /* empty */
606: { $$ = suspend_momentary ();
607: pending_xref_error ();
608: declspec_stack = tree_cons (0, current_declspecs,
609: declspec_stack);
610: current_declspecs = $<ttype>0; }
611: ;
612:
613: decl:
614: typed_declspecs setspecs initdecls ';'
615: { current_declspecs = TREE_VALUE (declspec_stack);
616: declspec_stack = TREE_CHAIN (declspec_stack);
617: resume_momentary ($2); }
618: | declmods setspecs notype_initdecls ';'
619: { current_declspecs = TREE_VALUE (declspec_stack);
620: declspec_stack = TREE_CHAIN (declspec_stack);
621: resume_momentary ($2); }
622: | typed_declspecs setspecs nested_function
623: { current_declspecs = TREE_VALUE (declspec_stack);
624: declspec_stack = TREE_CHAIN (declspec_stack);
625: resume_momentary ($2); }
626: | declmods setspecs notype_nested_function
627: { current_declspecs = TREE_VALUE (declspec_stack);
628: declspec_stack = TREE_CHAIN (declspec_stack);
629: resume_momentary ($2); }
630: | typed_declspecs ';'
631: { shadow_tag ($1); }
632: | declmods ';'
633: { pedwarn ("empty declaration"); }
634: ;
635:
636: /* Declspecs which contain at least one type specifier or typedef name.
637: (Just `const' or `volatile' is not enough.)
638: A typedef'd name following these is taken as a name to be declared. */
639:
640: typed_declspecs:
641: typespec reserved_declspecs
642: { $$ = tree_cons (NULL_TREE, $1, $2); }
643: | declmods typespec reserved_declspecs
644: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
645: ;
646:
647: reserved_declspecs: /* empty */
648: { $$ = NULL_TREE; }
649: | reserved_declspecs typespecqual_reserved
650: { $$ = tree_cons (NULL_TREE, $2, $1); }
651: | reserved_declspecs SCSPEC
652: { $$ = tree_cons (NULL_TREE, $2, $1); }
653: ;
654:
655: /* List of just storage classes and type modifiers.
656: A declaration can start with just this, but then it cannot be used
657: to redeclare a typedef-name. */
658:
659: declmods:
660: TYPE_QUAL
661: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
662: | SCSPEC
663: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
664: | declmods TYPE_QUAL
665: { $$ = tree_cons (NULL_TREE, $2, $1); }
666: | declmods SCSPEC
667: { $$ = tree_cons (NULL_TREE, $2, $1); }
668: ;
669:
670:
671: /* Used instead of declspecs where storage classes are not allowed
672: (that is, for typenames and structure components).
673: Don't accept a typedef-name if anything but a modifier precedes it. */
674:
675: typed_typespecs:
676: typespec reserved_typespecquals
677: { $$ = tree_cons (NULL_TREE, $1, $2); }
678: | nonempty_type_quals typespec reserved_typespecquals
679: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
680: ;
681:
682: reserved_typespecquals: /* empty */
683: { $$ = NULL_TREE; }
684: | reserved_typespecquals typespecqual_reserved
685: { $$ = tree_cons (NULL_TREE, $2, $1); }
686: ;
687:
688: /* A typespec (but not a type qualifier).
689: Once we have seen one of these in a declaration,
690: if a typedef name appears then it is being redeclared. */
691:
692: typespec: TYPESPEC
693: | structsp
694: | TYPENAME
695: { /* For a typedef name, record the meaning, not the name.
696: In case of `foo foo, bar;'. */
697: $$ = lookup_name ($1); }
698: | TYPEOF '(' expr ')'
699: { $$ = TREE_TYPE ($3);
700: if (pedantic)
701: pedwarn ("ANSI C forbids `typeof'"); }
702: | TYPEOF '(' typename ')'
703: { $$ = groktypename ($3);
704: if (pedantic)
705: pedwarn ("ANSI C forbids `typeof'"); }
706: ;
707:
708: /* A typespec that is a reserved word, or a type qualifier. */
709:
710: typespecqual_reserved: TYPESPEC
711: | TYPE_QUAL
712: | structsp
713: ;
714:
715: initdecls:
716: initdcl
717: | initdecls ',' initdcl
718: ;
719:
720: notype_initdecls:
721: notype_initdcl
722: | notype_initdecls ',' initdcl
723: ;
724:
725: maybeasm:
726: /* empty */
727: { $$ = NULL_TREE; }
728: | ASM '(' string ')'
729: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
730: $$ = $3;
731: }
732: ;
733:
734: initdcl:
735: declarator maybeasm maybe_attribute '='
736: { $<ttype>$ = start_decl ($1, current_declspecs, 1); }
737: init
738: /* Note how the declaration of the variable is in effect while its init is parsed! */
739: { decl_attributes ($<ttype>5, $3);
740: finish_decl ($<ttype>5, $6, $2); }
741: | declarator maybeasm maybe_attribute
742: { tree d = start_decl ($1, current_declspecs, 0);
743: decl_attributes (d, $3);
744: finish_decl (d, NULL_TREE, $2); }
745: ;
746:
747: notype_initdcl:
748: notype_declarator maybeasm maybe_attribute '='
749: { $<ttype>$ = start_decl ($1, current_declspecs, 1); }
750: init
751: /* Note how the declaration of the variable is in effect while its init is parsed! */
752: { decl_attributes ($<ttype>5, $3);
753: finish_decl ($<ttype>5, $6, $2); }
754: | notype_declarator maybeasm maybe_attribute
755: { tree d = start_decl ($1, current_declspecs, 0);
756: decl_attributes (d, $3);
757: finish_decl (d, NULL_TREE, $2); }
758: ;
759: /* the * rules are dummies to accept the Apollo extended syntax
760: so that the header files compile. */
761: maybe_attribute:
762: /* empty */
763: { $$ = NULL_TREE; }
764: | ATTRIBUTE '(' '(' attribute_list ')' ')'
765: { $$ = $4; }
766: ;
767:
768: attribute_list
769: : attrib
770: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
771: | attribute_list ',' attrib
772: { $$ = tree_cons (NULL_TREE, $3, $1); }
773: ;
774:
775: attrib
776: : IDENTIFIER
777: { if (strcmp (IDENTIFIER_POINTER ($1), "packed"))
778: warning ("`%s' attribute directive ignored",
779: IDENTIFIER_POINTER ($1));
780: $$ = $1; }
781: | IDENTIFIER '(' CONSTANT ')'
782: { /* if not "aligned(n)", then issue warning */
783: if (strcmp (IDENTIFIER_POINTER ($1), "aligned") != 0
784: || TREE_CODE ($3) != INTEGER_CST)
785: {
786: warning ("`%s' attribute directive ignored",
787: IDENTIFIER_POINTER ($1));
788: $$ = $1;
789: }
790: else
791: $$ = tree_cons ($1, $3); }
792: | IDENTIFIER '(' IDENTIFIER ',' CONSTANT ',' CONSTANT ')'
793: { /* if not "format(...)", then issue warning */
794: if (strcmp (IDENTIFIER_POINTER ($1), "format") != 0
795: || TREE_CODE ($5) != INTEGER_CST
796: || TREE_CODE ($7) != INTEGER_CST)
797: {
798: warning ("`%s' attribute directive ignored",
799: IDENTIFIER_POINTER ($1));
800: $$ = $1;
801: }
802: else
803: $$ = tree_cons ($1, tree_cons ($3, tree_cons ($5, $7))); }
804: ;
805:
806: init:
807: expr_no_commas
808: | '{' '}'
809: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
810: if (pedantic)
811: pedwarn ("ANSI C forbids empty initializer braces"); }
812: | '{' initlist '}'
813: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
814: | '{' initlist ',' '}'
815: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
816: | error
817: { $$ = NULL_TREE; }
818: ;
819:
820: /* This chain is built in reverse order,
821: and put in forward order where initlist is used. */
822: initlist:
823: init
824: { $$ = build_tree_list (NULL_TREE, $1); }
825: | initlist ',' init
826: { $$ = tree_cons (NULL_TREE, $3, $1); }
827: /* These are for labeled elements. */
828: | '[' expr_no_commas ']' init
829: { $$ = build_tree_list ($2, $4); }
830: | initlist ',' '[' expr_no_commas ']' init
831: { $$ = tree_cons ($4, $6, $1); }
832: | identifier ':' init
833: { $$ = build_tree_list ($1, $3); }
834: | initlist ',' identifier ':' init
835: { $$ = tree_cons ($3, $5, $1); }
836: ;
837:
838: nested_function:
839: declarator
840: { push_c_function_context ();
841: if (! start_function (current_declspecs, $1, 1))
842: {
843: pop_c_function_context ();
844: YYERROR1;
845: }
846: reinit_parse_for_function ();
847: store_parm_decls (); }
848: /* This used to use compstmt_or_error.
849: That caused a bug with input `f(g) int g {}',
850: where the use of YYERROR1 above caused an error
851: which then was handled by compstmt_or_error.
852: There followed a repeated execution of that same rule,
853: which called YYERROR1 again, and so on. */
854: compstmt
855: { finish_function (1);
856: pop_c_function_context (); }
857: ;
858:
859: notype_nested_function:
860: notype_declarator
861: { push_c_function_context ();
862: if (! start_function (current_declspecs, $1, 1))
863: {
864: pop_c_function_context ();
865: YYERROR1;
866: }
867: reinit_parse_for_function ();
868: store_parm_decls (); }
869: /* This used to use compstmt_or_error.
870: That caused a bug with input `f(g) int g {}',
871: where the use of YYERROR1 above caused an error
872: which then was handled by compstmt_or_error.
873: There followed a repeated execution of that same rule,
874: which called YYERROR1 again, and so on. */
875: compstmt
876: { finish_function (1);
877: pop_c_function_context (); }
878: ;
879:
880: /* Any kind of declarator (thus, all declarators allowed
881: after an explicit typespec). */
882:
883: declarator:
884: after_type_declarator
885: | notype_declarator
886: ;
887:
888: /* A declarator that is allowed only after an explicit typespec. */
889:
890: after_type_declarator:
891: '(' after_type_declarator ')'
892: { $$ = $2; }
893: | after_type_declarator '(' parmlist_or_identifiers %prec '.'
894: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
895: /* | after_type_declarator '(' error ')' %prec '.'
896: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
897: poplevel (0, 0, 0); } */
898: | after_type_declarator '[' expr ']' %prec '.'
899: { $$ = build_nt (ARRAY_REF, $1, $3); }
900: | after_type_declarator '[' ']' %prec '.'
901: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
902: | '*' type_quals after_type_declarator %prec UNARY
903: { $$ = make_pointer_declarator ($2, $3); }
904: | TYPENAME
905: ;
906:
907: /* Kinds of declarator that can appear in a parameter list
908: in addition to notype_declarator. This is like after_type_declarator
909: but does not allow a typedef name in parentheses as an identifier
910: (because it would conflict with a function with that typedef as arg). */
911:
912: parm_declarator:
913: parm_declarator '(' parmlist_or_identifiers %prec '.'
914: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
915: /* | parm_declarator '(' error ')' %prec '.'
916: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
917: poplevel (0, 0, 0); } */
918: | parm_declarator '[' expr ']' %prec '.'
919: { $$ = build_nt (ARRAY_REF, $1, $3); }
920: | parm_declarator '[' ']' %prec '.'
921: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
922: | '*' type_quals parm_declarator %prec UNARY
923: { $$ = make_pointer_declarator ($2, $3); }
924: | TYPENAME
925: ;
926:
927: /* A declarator allowed whether or not there has been
928: an explicit typespec. These cannot redeclare a typedef-name. */
929:
930: notype_declarator:
931: notype_declarator '(' parmlist_or_identifiers %prec '.'
932: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
933: /* | notype_declarator '(' error ')' %prec '.'
934: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
935: poplevel (0, 0, 0); } */
936: | '(' notype_declarator ')'
937: { $$ = $2; }
938: | '*' type_quals notype_declarator %prec UNARY
939: { $$ = make_pointer_declarator ($2, $3); }
940: | notype_declarator '[' expr ']' %prec '.'
941: { $$ = build_nt (ARRAY_REF, $1, $3); }
942: | notype_declarator '[' ']' %prec '.'
943: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
944: | IDENTIFIER
945: ;
946:
947: structsp:
948: STRUCT identifier '{'
949: { $$ = start_struct (RECORD_TYPE, $2);
950: /* Start scope of tag before parsing components. */
951: }
952: component_decl_list '}'
953: { $$ = finish_struct ($<ttype>4, $5);
954: /* Really define the structure. */
955: }
956: | STRUCT '{' component_decl_list '}'
957: { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
958: $3); }
959: | STRUCT identifier
960: { $$ = xref_tag (RECORD_TYPE, $2); }
961: | UNION identifier '{'
962: { $$ = start_struct (UNION_TYPE, $2); }
963: component_decl_list '}'
964: { $$ = finish_struct ($<ttype>4, $5); }
965: | UNION '{' component_decl_list '}'
966: { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
967: $3); }
968: | UNION identifier
969: { $$ = xref_tag (UNION_TYPE, $2); }
970: | ENUM identifier '{'
971: { $<itype>3 = suspend_momentary ();
972: $$ = start_enum ($2); }
973: enumlist maybecomma_warn '}'
974: { $$ = finish_enum ($<ttype>4, nreverse ($5));
975: resume_momentary ($<itype>3); }
976: | ENUM '{'
977: { $<itype>2 = suspend_momentary ();
978: $$ = start_enum (NULL_TREE); }
979: enumlist maybecomma_warn '}'
980: { $$ = finish_enum ($<ttype>3, nreverse ($4));
981: resume_momentary ($<itype>2); }
982: | ENUM identifier
983: { $$ = xref_tag (ENUMERAL_TYPE, $2); }
984: ;
985:
986: maybecomma:
987: /* empty */
988: | ','
989: ;
990:
991: maybecomma_warn:
992: /* empty */
993: | ','
994: { if (pedantic) pedwarn ("comma at end of enumerator list"); }
995: ;
996:
997: component_decl_list:
998: component_decl_list2
999: { $$ = $1; }
1000: | component_decl_list2 component_decl
1001: { $$ = chainon ($1, $2);
1002: warning ("no semicolon at end of struct or union"); }
1003: ;
1004:
1005: component_decl_list2: /* empty */
1006: { $$ = NULL_TREE; }
1007: | component_decl_list2 component_decl ';'
1008: { $$ = chainon ($1, $2); }
1009: | component_decl_list2 ';'
1010: { if (pedantic)
1011: pedwarn ("extra semicolon in struct or union specified"); }
1012: ;
1013:
1014: /* There is a shift-reduce conflict here, because `components' may
1015: start with a `typename'. It happens that shifting (the default resolution)
1016: does the right thing, because it treats the `typename' as part of
1017: a `typed_typespecs'.
1018:
1019: It is possible that this same technique would allow the distinction
1020: between `notype_initdecls' and `initdecls' to be eliminated.
1021: But I am being cautious and not trying it. */
1022:
1023: component_decl:
1024: typed_typespecs setspecs components
1025: { $$ = $3;
1026: current_declspecs = TREE_VALUE (declspec_stack);
1027: declspec_stack = TREE_CHAIN (declspec_stack);
1028: resume_momentary ($2); }
1029: | typed_typespecs
1030: { if (pedantic)
1031: pedwarn ("ANSI C forbids member declarations with no members");
1032: shadow_tag($1);
1033: $$ = NULL_TREE; }
1034: | nonempty_type_quals setspecs components
1035: { $$ = $3;
1036: current_declspecs = TREE_VALUE (declspec_stack);
1037: declspec_stack = TREE_CHAIN (declspec_stack);
1038: resume_momentary ($2); }
1039: | nonempty_type_quals
1040: { if (pedantic)
1041: pedwarn ("ANSI C forbids member declarations with no members");
1042: shadow_tag($1);
1043: $$ = NULL_TREE; }
1044: | error
1045: { $$ = NULL_TREE; }
1046: ;
1047:
1048: components:
1049: component_declarator
1050: | components ',' component_declarator
1051: { $$ = chainon ($1, $3); }
1052: ;
1053:
1054: component_declarator:
1055: save_filename save_lineno declarator maybe_attribute
1056: { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE);
1057: decl_attributes ($$, $4); }
1058: | save_filename save_lineno
1059: declarator ':' expr_no_commas maybe_attribute
1060: { $$ = grokfield ($1, $2, $3, current_declspecs, $5);
1061: decl_attributes ($$, $6); }
1062: | save_filename save_lineno ':' expr_no_commas
1063: { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4); }
1064: ;
1065:
1066: /* We chain the enumerators in reverse order.
1067: They are put in forward order where enumlist is used.
1068: (The order used to be significant, but no longer is so.
1069: However, we still maintain the order, just to be clean.) */
1070:
1071: enumlist:
1072: enumerator
1073: | enumlist ',' enumerator
1074: { $$ = chainon ($3, $1); }
1075: ;
1076:
1077:
1078: enumerator:
1079: identifier
1080: { $$ = build_enumerator ($1, NULL_TREE); }
1081: | identifier '=' expr_no_commas
1082: { $$ = build_enumerator ($1, $3); }
1083: ;
1084:
1085: typename:
1086: typed_typespecs absdcl
1087: { $$ = build_tree_list ($1, $2); }
1088: | nonempty_type_quals absdcl
1089: { $$ = build_tree_list ($1, $2); }
1090: ;
1091:
1092: absdcl: /* an absolute declarator */
1093: /* empty */
1094: { $$ = NULL_TREE; }
1095: | absdcl1
1096: ;
1097:
1098: nonempty_type_quals:
1099: TYPE_QUAL
1100: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
1101: | nonempty_type_quals TYPE_QUAL
1102: { $$ = tree_cons (NULL_TREE, $2, $1); }
1103: ;
1104:
1105: type_quals:
1106: /* empty */
1107: { $$ = NULL_TREE; }
1108: | type_quals TYPE_QUAL
1109: { $$ = tree_cons (NULL_TREE, $2, $1); }
1110: ;
1111:
1112: absdcl1: /* a nonempty absolute declarator */
1113: '(' absdcl1 ')'
1114: { $$ = $2; }
1115: /* `(typedef)1' is `int'. */
1116: | '*' type_quals absdcl1 %prec UNARY
1117: { $$ = make_pointer_declarator ($2, $3); }
1118: | '*' type_quals %prec UNARY
1119: { $$ = make_pointer_declarator ($2, NULL_TREE); }
1120: | absdcl1 '(' parmlist %prec '.'
1121: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
1122: | absdcl1 '[' expr ']' %prec '.'
1123: { $$ = build_nt (ARRAY_REF, $1, $3); }
1124: | absdcl1 '[' ']' %prec '.'
1125: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
1126: | '(' parmlist %prec '.'
1127: { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
1128: | '[' expr ']' %prec '.'
1129: { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
1130: | '[' ']' %prec '.'
1131: { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
1132: ;
1133:
1134: /* at least one statement, the first of which parses without error. */
1135: /* stmts is used only after decls, so an invalid first statement
1136: is actually regarded as an invalid decl and part of the decls. */
1137:
1138: stmts:
1139: lineno_stmt_or_label
1140: | stmts lineno_stmt_or_label
1141: | stmts errstmt
1142: ;
1143:
1144: xstmts:
1145: /* empty */
1146: | stmts
1147: ;
1148:
1149: errstmt: error ';'
1150: ;
1151:
1152: pushlevel: /* empty */
1153: { emit_line_note (input_filename, lineno);
1154: pushlevel (0);
1155: clear_last_expr ();
1156: push_momentary ();
1157: expand_start_bindings (0); }
1158: ;
1159:
1160: /* Read zero or more forward-declarations for labels
1161: that nested functions can jump to. */
1162: maybe_label_decls:
1163: /* empty */
1164: | label_decls
1165: { if (pedantic)
1166: pedwarn ("ANSI C forbids label declarations"); }
1167: ;
1168:
1169: label_decls:
1170: label_decl
1171: | label_decls label_decl
1172: ;
1173:
1174: label_decl:
1175: LABEL identifiers_or_typenames ';'
1176: { tree link;
1177: for (link = $2; link; link = TREE_CHAIN (link))
1178: {
1179: tree label = shadow_label (TREE_VALUE (link));
1180: C_DECLARED_LABEL_FLAG (label) = 1;
1181: declare_nonlocal_label (label);
1182: }
1183: }
1184: ;
1185:
1186: /* This is the body of a function definition.
1187: It causes syntax errors to ignore to the next openbrace. */
1188: compstmt_or_error:
1189: compstmt
1190: {}
1191: | error compstmt
1192: ;
1193:
1194: compstmt: '{' '}'
1195: { $$ = convert (void_type_node, integer_zero_node); }
1196: | '{' pushlevel maybe_label_decls decls xstmts '}'
1197: { emit_line_note (input_filename, lineno);
1198: expand_end_bindings (getdecls (), 1, 0);
1199: $$ = poplevel (1, 1, 0);
1200: pop_momentary (); }
1201: | '{' pushlevel maybe_label_decls error '}'
1202: { emit_line_note (input_filename, lineno);
1203: expand_end_bindings (getdecls (), kept_level_p (), 0);
1204: $$ = poplevel (kept_level_p (), 0, 0);
1205: pop_momentary (); }
1206: | '{' pushlevel maybe_label_decls stmts '}'
1207: { emit_line_note (input_filename, lineno);
1208: expand_end_bindings (getdecls (), kept_level_p (), 0);
1209: $$ = poplevel (kept_level_p (), 0, 0);
1210: pop_momentary (); }
1211: ;
1212:
1213: /* Value is number of statements counted as of the closeparen. */
1214: simple_if:
1215: if_prefix lineno_labeled_stmt
1216: /* Make sure expand_end_cond is run once
1217: for each call to expand_start_cond.
1218: Otherwise a crash is likely. */
1219: | if_prefix error
1220: ;
1221:
1222: if_prefix:
1223: IF '(' expr ')'
1224: { emit_line_note ($<filename>-1, $<lineno>0);
1225: expand_start_cond (truthvalue_conversion ($3), 0);
1226: $<itype>1 = stmt_count;
1227: if_stmt_file = $<filename>-1;
1228: if_stmt_line = $<lineno>0;
1229: position_after_white_space (); }
1230: ;
1231:
1232: save_filename:
1233: { $$ = input_filename; }
1234: ;
1235:
1236: save_lineno:
1237: { $$ = lineno; }
1238: ;
1239:
1240: lineno_labeled_stmt:
1241: save_filename save_lineno stmt
1242: { }
1243: /* | save_filename save_lineno error
1244: { }
1245: */
1246: | save_filename save_lineno label lineno_labeled_stmt
1247: { }
1248: ;
1249:
1250: lineno_stmt_or_label:
1251: save_filename save_lineno stmt_or_label
1252: { }
1253: ;
1254:
1255: stmt_or_label:
1256: stmt
1257: | label
1258: { int next;
1259: position_after_white_space ();
1260: next = getc (finput);
1261: ungetc (next, finput);
1262: if (pedantic && next == '}')
1263: pedwarn ("ANSI C forbids label at end of compound statement");
1264: }
1265: ;
1266:
1267: /* Parse a single real statement, not including any labels. */
1268: stmt:
1269: compstmt
1270: { stmt_count++; }
1271: | expr ';'
1272: { stmt_count++;
1273: emit_line_note ($<filename>-1, $<lineno>0);
1274: c_expand_expr_stmt ($1);
1275: clear_momentary (); }
1276: | simple_if ELSE
1277: { expand_start_else ();
1278: $<itype>1 = stmt_count;
1279: position_after_white_space (); }
1280: lineno_labeled_stmt
1281: { expand_end_cond ();
1282: if (extra_warnings && stmt_count == $<itype>1)
1283: warning ("empty body in an else-statement"); }
1284: | simple_if %prec IF
1285: { expand_end_cond ();
1286: if (extra_warnings && stmt_count == $<itype>1)
1287: warning_with_file_and_line (if_stmt_file, if_stmt_line,
1288: "empty body in an if-statement"); }
1289: /* Make sure expand_end_cond is run once
1290: for each call to expand_start_cond.
1291: Otherwise a crash is likely. */
1292: | simple_if ELSE error
1293: { expand_end_cond (); }
1294: | WHILE
1295: { stmt_count++;
1296: emit_line_note ($<filename>-1, $<lineno>0);
1297: /* The emit_nop used to come before emit_line_note,
1298: but that made the nop seem like part of the preceding line.
1299: And that was confusing when the preceding line was
1300: inside of an if statement and was not really executed.
1301: I think it ought to work to put the nop after the line number.
1302: We will see. --rms, July 15, 1991. */
1303: emit_nop ();
1304: expand_start_loop (1); }
1305: '(' expr ')'
1306: { emit_line_note (input_filename, lineno);
1307: expand_exit_loop_if_false (0, truthvalue_conversion ($4));
1308: position_after_white_space (); }
1309: lineno_labeled_stmt
1310: { expand_end_loop (); }
1311: | DO
1312: { stmt_count++;
1313: emit_line_note ($<filename>-1, $<lineno>0);
1314: /* See comment in `while' alternative, above. */
1315: emit_nop ();
1316: expand_start_loop_continue_elsewhere (1);
1317: position_after_white_space (); }
1318: lineno_labeled_stmt WHILE
1319: { expand_loop_continue_here (); }
1320: '(' expr ')' ';'
1321: { emit_line_note (input_filename, lineno);
1322: expand_exit_loop_if_false (0, truthvalue_conversion ($7));
1323: expand_end_loop ();
1324: clear_momentary (); }
1325: | FOR
1326: '(' xexpr ';'
1327: { stmt_count++;
1328: emit_line_note ($<filename>-1, $<lineno>0);
1329: /* See comment in `while' alternative, above. */
1330: emit_nop ();
1331: if ($3) c_expand_expr_stmt ($3);
1332: expand_start_loop_continue_elsewhere (1); }
1333: xexpr ';'
1334: { emit_line_note (input_filename, lineno);
1335: if ($6)
1336: expand_exit_loop_if_false (0, truthvalue_conversion ($6)); }
1337: xexpr ')'
1338: /* Don't let the tree nodes for $9 be discarded
1339: by clear_momentary during the parsing of the next stmt. */
1340: { push_momentary ();
1341: position_after_white_space (); }
1342: lineno_labeled_stmt
1343: { emit_line_note ($<filename>-1, $<lineno>0);
1344: expand_loop_continue_here ();
1345: if ($9)
1346: c_expand_expr_stmt ($9);
1347: pop_momentary ();
1348: expand_end_loop (); }
1349: | SWITCH '(' expr ')'
1350: { stmt_count++;
1351: emit_line_note ($<filename>-1, $<lineno>0);
1352: c_expand_start_case ($3);
1353: /* Don't let the tree nodes for $3 be discarded by
1354: clear_momentary during the parsing of the next stmt. */
1355: push_momentary ();
1356: position_after_white_space (); }
1357: lineno_labeled_stmt
1358: { expand_end_case ($3);
1359: pop_momentary (); }
1360: | BREAK ';'
1361: { stmt_count++;
1362: emit_line_note ($<filename>-1, $<lineno>0);
1363: if ( ! expand_exit_something ())
1364: error ("break statement not within loop or switch"); }
1365: | CONTINUE ';'
1366: { stmt_count++;
1367: emit_line_note ($<filename>-1, $<lineno>0);
1368: if (! expand_continue_loop (0))
1369: error ("continue statement not within a loop"); }
1370: | RETURN ';'
1371: { stmt_count++;
1372: emit_line_note ($<filename>-1, $<lineno>0);
1373: c_expand_return (NULL_TREE); }
1374: | RETURN expr ';'
1375: { stmt_count++;
1376: emit_line_note ($<filename>-1, $<lineno>0);
1377: c_expand_return ($2); }
1378: | ASM maybe_type_qual '(' expr ')' ';'
1379: { stmt_count++;
1380: emit_line_note ($<filename>-1, $<lineno>0);
1381: STRIP_NOPS ($4);
1382: if ((TREE_CODE ($4) == ADDR_EXPR
1383: && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST)
1384: || TREE_CODE ($4) == STRING_CST)
1385: expand_asm ($4);
1386: else
1387: error ("argument of `asm' is not a constant string"); }
1388: /* This is the case with just output operands. */
1389: | ASM maybe_type_qual '(' expr ':' asm_operands ')' ';'
1390: { stmt_count++;
1391: emit_line_note ($<filename>-1, $<lineno>0);
1392: c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE,
1393: $2 == ridpointers[(int)RID_VOLATILE],
1394: input_filename, lineno); }
1395: /* This is the case with input operands as well. */
1396: | ASM maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';'
1397: { stmt_count++;
1398: emit_line_note ($<filename>-1, $<lineno>0);
1399: c_expand_asm_operands ($4, $6, $8, NULL_TREE,
1400: $2 == ridpointers[(int)RID_VOLATILE],
1401: input_filename, lineno); }
1402: /* This is the case with clobbered registers as well. */
1403: | ASM maybe_type_qual '(' expr ':' asm_operands ':'
1404: asm_operands ':' asm_clobbers ')' ';'
1405: { stmt_count++;
1406: emit_line_note ($<filename>-1, $<lineno>0);
1407: c_expand_asm_operands ($4, $6, $8, $10,
1408: $2 == ridpointers[(int)RID_VOLATILE],
1409: input_filename, lineno); }
1410: | GOTO identifier ';'
1411: { tree decl;
1412: stmt_count++;
1413: emit_line_note ($<filename>-1, $<lineno>0);
1414: decl = lookup_label ($2);
1415: if (decl != 0)
1416: {
1417: TREE_USED (decl) = 1;
1418: expand_goto (decl);
1419: }
1420: }
1421: | GOTO '*' expr ';'
1422: { stmt_count++;
1423: emit_line_note ($<filename>-1, $<lineno>0);
1424: expand_computed_goto ($3); }
1425: | ';'
1426: ;
1427:
1428: /* Any kind of label, including jump labels and case labels.
1429: ANSI C accepts labels only before statements, but we allow them
1430: also at the end of a compound statement. */
1431:
1432: label: CASE expr ':'
1433: { register tree value = check_case_value ($2);
1434: register tree label
1435: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1436:
1437: stmt_count++;
1438:
1439: if (value != error_mark_node)
1440: {
1441: tree duplicate;
1442: int success = pushcase (value, label, &duplicate);
1443: if (success == 1)
1444: error ("case label not within a switch statement");
1445: else if (success == 2)
1446: {
1447: error ("duplicate case value");
1448: error_with_decl (duplicate, "this is the first entry for that value");
1449: }
1450: else if (success == 3)
1451: warning ("case value out of range");
1452: else if (success == 5)
1453: error ("case label within scope of cleanup or variable array");
1454: }
1455: position_after_white_space (); }
1456: | CASE expr ELLIPSIS expr ':'
1457: { register tree value1 = check_case_value ($2);
1458: register tree value2 = check_case_value ($4);
1459: register tree label
1460: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1461:
1462: stmt_count++;
1463:
1464: if (value1 != error_mark_node && value2 != error_mark_node)
1465: {
1466: tree duplicate;
1467: int success = pushcase_range (value1, value2, label,
1468: &duplicate);
1469: if (success == 1)
1470: error ("case label not within a switch statement");
1471: else if (success == 2)
1472: {
1473: error ("duplicate case value");
1474: error_with_decl (duplicate, "this is the first entry for that value");
1475: }
1476: else if (success == 3)
1477: warning ("case value out of range");
1478: else if (success == 4)
1479: warning ("empty case range");
1480: else if (success == 5)
1481: error ("case label within scope of cleanup or variable array");
1482: }
1483: position_after_white_space (); }
1484: | DEFAULT ':'
1485: {
1486: tree duplicate;
1487: register tree label
1488: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1489: int success = pushcase (NULL_TREE, label, &duplicate);
1490: stmt_count++;
1491: if (success == 1)
1492: error ("default label not within a switch statement");
1493: else if (success == 2)
1494: {
1495: error ("multiple default labels in one switch");
1496: error_with_decl (duplicate, "this is the first default label");
1497: }
1498: position_after_white_space (); }
1499: | identifier ':'
1500: { tree label = define_label (input_filename, lineno, $1);
1501: stmt_count++;
1502: emit_nop ();
1503: if (label)
1504: expand_label (label);
1505: position_after_white_space (); }
1506: ;
1507:
1508: /* Either a type-qualifier or nothing. First thing in an `asm' statement. */
1509:
1510: maybe_type_qual:
1511: /* empty */
1512: { emit_line_note (input_filename, lineno); }
1513: | TYPE_QUAL
1514: { emit_line_note (input_filename, lineno); }
1515: ;
1516:
1517: xexpr:
1518: /* empty */
1519: { $$ = NULL_TREE; }
1520: | expr
1521: ;
1522:
1523: /* These are the operands other than the first string and colon
1524: in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */
1525: asm_operands: /* empty */
1526: { $$ = NULL_TREE; }
1527: | nonnull_asm_operands
1528: ;
1529:
1530: nonnull_asm_operands:
1531: asm_operand
1532: | nonnull_asm_operands ',' asm_operand
1533: { $$ = chainon ($1, $3); }
1534: ;
1535:
1536: asm_operand:
1537: STRING '(' expr ')'
1538: { $$ = build_tree_list ($1, $3); }
1539: ;
1540:
1541: asm_clobbers:
1542: string
1543: { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); }
1544: | asm_clobbers ',' string
1545: { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); }
1546: ;
1547:
1548: /* This is what appears inside the parens in a function declarator.
1549: Its value is a list of ..._TYPE nodes. */
1550: parmlist:
1551: { pushlevel (0);
1552: clear_parm_order ();
1553: declare_parm_level (0); }
1554: parmlist_1
1555: { $$ = $2;
1556: parmlist_tags_warning ();
1557: poplevel (0, 0, 0); }
1558: ;
1559:
1560: parmlist_1:
1561: parmlist_2 ')'
1562: | parms ';'
1563: { tree parm;
1564: /* Mark the forward decls as such. */
1565: for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
1566: TREE_ASM_WRITTEN (parm) = 1;
1567: clear_parm_order (); }
1568: parmlist_1
1569: { $$ = $4; }
1570: | error ')'
1571: { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
1572: ;
1573:
1574: /* This is what appears inside the parens in a function declarator.
1575: Is value is represented in the format that grokdeclarator expects. */
1576: parmlist_2: /* empty */
1577: { $$ = get_parm_info (0); }
1578: | ELLIPSIS
1579: { $$ = get_parm_info (0);
1580: if (pedantic)
1581: pedwarn ("ANSI C requires a named argument before `...'");
1582: }
1583: | parms
1584: { $$ = get_parm_info (1); }
1585: | parms ',' ELLIPSIS
1586: { $$ = get_parm_info (0); }
1587: ;
1588:
1589: parms:
1590: parm
1591: { push_parm_decl ($1); }
1592: | parms ',' parm
1593: { push_parm_decl ($3); }
1594: ;
1595:
1596: /* A single parameter declaration or parameter type name,
1597: as found in a parmlist. */
1598: parm:
1599: typed_declspecs parm_declarator
1600: { $$ = build_tree_list ($1, $2) ; }
1601: | typed_declspecs notype_declarator
1602: { $$ = build_tree_list ($1, $2) ; }
1603: | typed_declspecs absdcl
1604: { $$ = build_tree_list ($1, $2); }
1605: | declmods notype_declarator
1606: { $$ = build_tree_list ($1, $2) ; }
1607: | declmods absdcl
1608: { $$ = build_tree_list ($1, $2); }
1609: ;
1610:
1611: /* This is used in a function definition
1612: where either a parmlist or an identifier list is ok.
1613: Its value is a list of ..._TYPE nodes or a list of identifiers. */
1614: parmlist_or_identifiers:
1615: { pushlevel (0);
1616: clear_parm_order ();
1617: declare_parm_level (1); }
1618: parmlist_or_identifiers_1
1619: { $$ = $2;
1620: parmlist_tags_warning ();
1621: poplevel (0, 0, 0); }
1622: ;
1623:
1624: parmlist_or_identifiers_1:
1625: parmlist_2 ')'
1626: | parms ';'
1627: { tree parm;
1628: /* Mark the forward decls as such. */
1629: for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
1630: TREE_ASM_WRITTEN (parm) = 1;
1631: clear_parm_order (); }
1632: parmlist_or_identifiers_1
1633: { $$ = $4; }
1634: | identifiers ')'
1635: { tree t;
1636: for (t = $1; t; t = TREE_CHAIN (t))
1637: if (TREE_VALUE (t) == NULL_TREE)
1638: error ("`...' in old-style identifier list");
1639: $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
1640: | error ')'
1641: { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
1642: ;
1643:
1644: /* A nonempty list of identifiers. */
1645: identifiers:
1646: IDENTIFIER
1647: { $$ = build_tree_list (NULL_TREE, $1); }
1648: | identifiers ',' IDENTIFIER
1649: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
1650: ;
1651:
1652: /* A nonempty list of identifiers, including typenames. */
1653: identifiers_or_typenames:
1654: identifier
1655: { $$ = build_tree_list (NULL_TREE, $1); }
1656: | identifiers_or_typenames ',' identifier
1657: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
1658: ;
1659: %%
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.