![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parse.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to parse.y CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* YACC parser for C syntax.
2: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* To whomever it may concern: I have heard that such a thing was once
23: written by AT&T, but I have never seen it. */
24:
25: %expect 19
26:
27: /* These are the 19 conflicts you should get in parse.output;
28: the state numbers may vary if minor changes in the grammar are made.
29:
30: State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.)
31: State 96 contains 1 shift/reduce conflict. (Two ways to recover from error.)
32: State 100 contains 1 shift/reduce conflict. (Two ways to recover from error.)
33: State 116 contains 1 shift/reduce conflict. (See comment at component_decl.)
34: State 166 contains 2 shift/reduce conflicts. (make notype_declarator longer.)
35: State 241 contains 2 shift/reduce conflicts. (make absdcl1 longer if poss.)
36: State 275 contains 2 shift/reduce conflicts. (same for after_type_declarator).
37: State 306 contains 2 shift/reduce conflicts. (similar for absdcl1 again.)
38: State 314 contains 2 shift/reduce conflicts. (like 241, other context.)
39: State 318 contains 2 shift/reduce conflicts. (like 241, other context.)
40: State 362 contains 1 shift/reduce conflict. (dangling else.)
41: State 369 contains 2 shift/reduce conflicts. (like 166 for parm_declarator).
42: */
43:
44: %{
45: #include "config.h"
46: #include "tree.h"
47: #include "parse.h"
48: #include "c-tree.h"
49: #include "flags.h"
50:
51: #include <stdio.h>
52:
53: /* Cause the `yydebug' variable to be defined. */
54: #define YYDEBUG
55: %}
56:
57: %start program
58:
59: %union {long itype; tree ttype; enum tree_code code; char *cptr; }
60:
61: /* All identifiers that are not reserved words
62: and are not declared typedefs in the current block */
63: %token IDENTIFIER
64:
65: /* All identifiers that are declared typedefs in the current block.
66: In some contexts, they are treated just like IDENTIFIER,
67: but they can also serve as typespecs in declarations. */
68: %token TYPENAME
69:
70: /* Reserved words that specify storage class.
71: yylval contains an IDENTIFIER_NODE which indicates which one. */
72: %token SCSPEC
73:
74: /* Reserved words that specify type.
75: yylval contains an IDENTIFIER_NODE which indicates which one. */
76: %token TYPESPEC
77:
78: /* Reserved words that qualify type: "const" or "volatile".
79: yylval contains an IDENTIFIER_NODE which indicates which one. */
80: %token TYPE_QUAL
81:
82: /* Character or numeric constants.
83: yylval is the node for the constant. */
84: %token CONSTANT
85:
86: /* String constants in raw form.
87: yylval is a STRING_CST node. */
88: %token STRING
89:
90: /* "...", used for functions with variable arglists. */
91: %token ELLIPSIS
92:
93: /* the reserved words */
94: %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
95: %token BREAK CONTINUE RETURN GOTO ASM TYPEOF ALIGNOF
96:
97: /* Define the operator tokens and their precedences.
98: The value is an integer because, if used, it is the tree code
99: to use in the expression made from the operator. */
100:
101: %right <code> ASSIGN '='
102: %right <code> '?' ':'
103: %left <code> OROR
104: %left <code> ANDAND
105: %left <code> '|'
106: %left <code> '^'
107: %left <code> '&'
108: %left <code> EQCOMPARE
109: %left <code> ARITHCOMPARE
110: %left <code> LSHIFT RSHIFT
111: %left <code> '+' '-'
112: %left <code> '*' '/' '%'
113: %right <code> UNARY PLUSPLUS MINUSMINUS
114: %left HYPERUNARY
115: %left <code> POINTSAT '.'
116:
117: %type <code> unop
118:
119: %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist
120: %type <ttype> expr_no_commas primary string STRING
121: %type <ttype> typed_declspecs reserved_declspecs
122: %type <ttype> typed_typespecs reserved_typespecquals
123: %type <ttype> declmods typespec typespecqual_reserved
124: %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual
125: %type <ttype> initdecls notype_initdecls initdcl notype_initdcl
126: %type <ttype> init initlist maybeasm
127: %type <ttype> asm_operands asm_operand
128:
129: %type <ttype> declarator
130: %type <ttype> notype_declarator after_type_declarator
131: %type <ttype> parm_declarator
132:
133: %type <ttype> structsp component_decl_list component_decl components component_declarator
134: %type <ttype> enumlist enumerator
135: %type <ttype> typename absdcl absdcl1 type_quals
136: %type <ttype> xexpr parms parm identifiers
137:
138: %type <ttype> parmlist parmlist_1 parmlist_2
139: %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1
140:
141: %type <itype> setspecs
142:
143: %{
144: /* the declaration found for the last IDENTIFIER token read in.
145: yylex must look this up to detect typedefs, which get token type TYPENAME,
146: so it is left around in case the identifier is not a typedef but is
147: used in a context which makes it a reference to a variable. */
148: static tree lastiddecl;
149:
150: static tree make_pointer_declarator ();
151: static tree combine_strings ();
152: static void reinit_parse_for_function ();
153:
154: extern double atof ();
155:
156: /* List of types and structure classes of the current declaration */
157: tree current_declspecs;
158:
159: char *input_filename; /* source file current line is coming from */
160: char *main_input_filename; /* top-level source file */
161: %}
162:
163: %%
164: program: /* empty */
165: | extdefs
166: ;
167:
168: /* the reason for the strange actions in this rule
169: is so that notype_initdecls when reached via datadef
170: can find a valid list of type and sc specs in $0. */
171:
172: extdefs:
173: {$<ttype>$ = NULL_TREE; } extdef
174: | extdefs {$<ttype>$ = NULL_TREE; } extdef
175: ;
176:
177: extdef:
178: fndef
179: | datadef
180: | ASM '(' string ')' ';'
181: { if (pedantic)
182: warning ("ANSI C forbids use of `asm' keyword");
183: if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
184: assemble_asm ($3); }
185: ;
186:
187: datadef:
188: setspecs notype_initdecls ';'
189: { if (pedantic)
190: error ("ANSI C forbids data definition lacking type or storage class");
191: else
192: warning ("data definition lacks type or storage class"); }
193: | declmods setspecs notype_initdecls ';'
194: {}
195: | typed_declspecs setspecs initdecls ';'
196: {}
197: | declmods ';'
198: { error ("empty declaration"); }
199: | typed_declspecs ';'
200: { shadow_tag ($1); }
201: | error ';'
202: | error '}'
203: | ';'
204: ;
205:
206: fndef:
207: typed_declspecs setspecs declarator
208: { if (! start_function ($1, $3))
209: YYFAIL;
210: reinit_parse_for_function (); }
211: xdecls
212: { store_parm_decls (); }
213: compstmt
214: { finish_function (); }
215: | typed_declspecs setspecs declarator error
216: { }
217: | declmods setspecs notype_declarator
218: { if (! start_function ($1, $3))
219: YYFAIL;
220: reinit_parse_for_function (); }
221: xdecls
222: { store_parm_decls (); }
223: compstmt
224: { finish_function (); }
225: | declmods setspecs notype_declarator error
226: { }
227: | setspecs notype_declarator
228: { if (! start_function (0, $2))
229: YYFAIL;
230: reinit_parse_for_function (); }
231: xdecls
232: { store_parm_decls (); }
233: compstmt
234: { finish_function (); }
235: | setspecs notype_declarator error
236: { }
237: ;
238:
239: identifier:
240: IDENTIFIER
241: | TYPENAME
242: ;
243:
244: unop: '&'
245: { $$ = ADDR_EXPR; }
246: | '-'
247: { $$ = NEGATE_EXPR; }
248: | '+'
249: { $$ = CONVERT_EXPR; }
250: | PLUSPLUS
251: { $$ = PREINCREMENT_EXPR; }
252: | MINUSMINUS
253: { $$ = PREDECREMENT_EXPR; }
254: | '~'
255: { $$ = BIT_NOT_EXPR; }
256: | '!'
257: { $$ = TRUTH_NOT_EXPR; }
258: ;
259:
260: expr: nonnull_exprlist
261: { $$ = build_compound_expr ($1); }
262: ;
263:
264: exprlist:
265: /* empty */
266: { $$ = NULL_TREE; }
267: | nonnull_exprlist
268: ;
269:
270: nonnull_exprlist:
271: expr_no_commas
272: { $$ = build_tree_list (NULL_TREE, $1); }
273: | nonnull_exprlist ',' expr_no_commas
274: { chainon ($1, build_tree_list (NULL_TREE, $3)); }
275: ;
276:
277: expr_no_commas:
278: primary
279: | '*' expr_no_commas %prec UNARY
280: { $$ = build_indirect_ref ($2, "unary *"); }
281: | unop expr_no_commas %prec UNARY
282: { $$ = build_unary_op ($1, $2, 0); }
283: | '(' typename ')' expr_no_commas %prec UNARY
284: { tree type = groktypename ($2);
285: $$ = build_c_cast (type, $4); }
286: | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY
287: { tree type = groktypename ($2);
288: if (pedantic)
289: warning ("ANSI C forbids constructor-expressions");
290: $$ = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5)), 0);
291: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
292: {
293: int failure = complete_array_type (type, $$, 1);
294: if (failure)
295: abort ();
296: }
297: }
298: | SIZEOF expr_no_commas %prec UNARY
299: { if (TREE_CODE ($2) == COMPONENT_REF
300: && TREE_PACKED (TREE_OPERAND ($2, 1)))
301: error ("sizeof applied to a bit-field");
302: $$ = c_sizeof (TREE_TYPE ($2)); }
303: | SIZEOF '(' typename ')' %prec HYPERUNARY
304: { $$ = c_sizeof (groktypename ($3)); }
305: | ALIGNOF expr_no_commas %prec UNARY
306: { if (TREE_CODE ($2) == COMPONENT_REF
307: && TREE_PACKED (TREE_OPERAND ($2, 1)))
308: error ("__alignof applied to a bit-field");
309: $$ = c_alignof (TREE_TYPE ($2)); }
310: | ALIGNOF '(' typename ')' %prec HYPERUNARY
311: { $$ = c_alignof (groktypename ($3)); }
312: | expr_no_commas '+' expr_no_commas
313: { $$ = build_binary_op ($2, $1, $3); }
314: | expr_no_commas '-' expr_no_commas
315: { $$ = build_binary_op ($2, $1, $3); }
316: | expr_no_commas '*' expr_no_commas
317: { $$ = build_binary_op ($2, $1, $3); }
318: | expr_no_commas '/' expr_no_commas
319: { $$ = build_binary_op ($2, $1, $3); }
320: | expr_no_commas '%' expr_no_commas
321: { $$ = build_binary_op ($2, $1, $3); }
322: | expr_no_commas LSHIFT expr_no_commas
323: { $$ = build_binary_op ($2, $1, $3); }
324: | expr_no_commas RSHIFT expr_no_commas
325: { $$ = build_binary_op ($2, $1, $3); }
326: | expr_no_commas ARITHCOMPARE expr_no_commas
327: { $$ = build_binary_op ($2, $1, $3); }
328: | expr_no_commas EQCOMPARE expr_no_commas
329: { $$ = build_binary_op ($2, $1, $3); }
330: | expr_no_commas '&' expr_no_commas
331: { $$ = build_binary_op ($2, $1, $3); }
332: | expr_no_commas '|' expr_no_commas
333: { $$ = build_binary_op ($2, $1, $3); }
334: | expr_no_commas '^' expr_no_commas
335: { $$ = build_binary_op ($2, $1, $3); }
336: | expr_no_commas ANDAND expr_no_commas
337: { $$ = build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); }
338: | expr_no_commas OROR expr_no_commas
339: { $$ = build_binary_op (TRUTH_ORIF_EXPR, $1, $3); }
340: | expr_no_commas '?' xexpr ':' expr_no_commas
341: { $$ = build_conditional_expr ($1, $3, $5); }
342: | expr_no_commas '=' expr_no_commas
343: { $$ = build_modify_expr ($1, NOP_EXPR, $3); }
344: | expr_no_commas ASSIGN expr_no_commas
345: { $$ = build_modify_expr ($1, $2, $3); }
346: ;
347:
348: primary:
349: IDENTIFIER
350: { $$ = lastiddecl;
351: if (!$$)
352: {
353: if (yychar == YYEMPTY)
354: yychar = YYLEX;
355: if (yychar == '(')
356: $$ = implicitly_declare ($1);
357: else
358: {
359: if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node)
360: error ("undeclared variable `%s' (first use here)",
361: IDENTIFIER_POINTER ($1));
362: $$ = error_mark_node;
363: /* Prevent repeated error messages. */
364: IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node;
365: }
366: }
367: if (TREE_CODE ($$) == CONST_DECL)
368: $$ = DECL_INITIAL ($$);
369: }
370: | CONSTANT
371: | string
372: { $$ = combine_strings ($1); }
373: | '(' expr ')'
374: { $$ = $2; }
375: | '(' error ')'
376: { $$ = error_mark_node; }
377: | '('
378: { if (current_function_decl == 0)
379: {
380: error ("braced-group within expression allowed only inside a function");
381: YYFAIL;
382: }
383: expand_start_stmt_expr (); }
384: compstmt ')'
385: { if (pedantic)
386: warning ("ANSI C forbids braced-groups within expressions");
387: $$ = get_last_expr ();
388: expand_end_stmt_expr (); }
389: | primary '(' exprlist ')' %prec '.'
390: { $$ = build_function_call ($1, $3); }
391: | primary '[' expr ']' %prec '.'
392: { $$ = build_array_ref ($1, $3); }
393: | primary '.' identifier
394: { $$ = build_component_ref ($1, $3); }
395: | primary POINTSAT identifier
396: { $$ = build_component_ref (build_indirect_ref ($1, "->"), $3); }
397: | primary PLUSPLUS
398: { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); }
399: | primary MINUSMINUS
400: { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); }
401: ;
402:
403: /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */
404: string:
405: STRING
406: | string STRING
407: { $$ = chainon ($1, $2); }
408: ;
409:
410: xdecls:
411: /* empty */
412: | decls
413: ;
414:
415: decls:
416: decl
417: | errstmt
418: | decls decl
419: | decl errstmt
420: ;
421:
422: /* records the type and storage class specs to use for processing
423: the declarators that follow */
424: setspecs: /* empty */
425: { current_declspecs = $<ttype>0;
426: $$ = suspend_momentary (); }
427: ;
428:
429: decl:
430: typed_declspecs setspecs initdecls ';'
431: { resume_momentary ($2); }
432: | declmods setspecs notype_initdecls ';'
433: { resume_momentary ($2); }
434: | typed_declspecs ';'
435: { shadow_tag ($1); }
436: | declmods ';'
437: { warning ("empty declaration"); }
438: ;
439:
440: /* Declspecs which contain at least one type specifier or typedef name.
441: (Just `const' or `volatile' is not enough.)
442: A typedef'd name following these is taken as a name to be declared. */
443:
444: typed_declspecs:
445: typespec reserved_declspecs
446: { $$ = tree_cons (NULL_TREE, $1, $2); }
447: | declmods typespec reserved_declspecs
448: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
449: ;
450:
451: reserved_declspecs: /* empty */
452: { $$ = NULL_TREE; }
453: | reserved_declspecs typespecqual_reserved
454: { $$ = tree_cons (NULL_TREE, $2, $1); }
455: | reserved_declspecs SCSPEC
456: { $$ = tree_cons (NULL_TREE, $2, $1); }
457: ;
458:
459: /* List of just storage classes and type modifiers.
460: A declaration can start with just this, but then it cannot be used
461: to redeclare a typedef-name. */
462:
463: declmods:
464: TYPE_QUAL
465: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
466: | SCSPEC
467: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
468: | declmods TYPE_QUAL
469: { $$ = tree_cons (NULL_TREE, $2, $1); }
470: | declmods SCSPEC
471: { $$ = tree_cons (NULL_TREE, $2, $1); }
472: ;
473:
474:
475: /* Used instead of declspecs where storage classes are not allowed
476: (that is, for typenames and structure components).
477: Don't accept a typedef-name if anything but a modifier precedes it. */
478:
479: typed_typespecs:
480: typespec reserved_typespecquals
481: { $$ = tree_cons (NULL_TREE, $1, $2); }
482: | nonempty_type_quals typespec reserved_typespecquals
483: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); }
484: ;
485:
486: reserved_typespecquals: /* empty */
487: { $$ = NULL_TREE; }
488: | reserved_typespecquals typespecqual_reserved
489: { $$ = tree_cons (NULL_TREE, $2, $1); }
490: ;
491:
492: /* A typespec (but not a type qualifier).
493: Once we have seen one of these in a declaration,
494: if a typedef name appears then it is being redeclared. */
495:
496: typespec: TYPESPEC
497: | structsp
498: | TYPENAME
499: | TYPEOF '(' expr ')'
500: { $$ = TREE_TYPE ($3);
501: if (pedantic)
502: warning ("ANSI C forbids `typeof'") }
503: | TYPEOF '(' typename ')'
504: { $$ = groktypename ($3);
505: if (pedantic)
506: warning ("ANSI C forbids `typeof'") }
507: ;
508:
509: /* A typespec that is a reserved word, or a type qualifier. */
510:
511: typespecqual_reserved: TYPESPEC
512: | TYPE_QUAL
513: | structsp
514: ;
515:
516: initdecls:
517: initdcl
518: | initdecls ',' initdcl
519: ;
520:
521: notype_initdecls:
522: notype_initdcl
523: | notype_initdecls ',' initdcl
524: ;
525:
526: maybeasm:
527: /* empty */
528: { $$ = NULL_TREE; }
529: | ASM '(' string ')'
530: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
531: $$ = $3;
532: if (pedantic)
533: warning ("ANSI C forbids use of `asm' keyword");
534: }
535: ;
536:
537: initdcl:
538: declarator maybeasm '='
539: { $<ttype>$ = start_decl ($1, current_declspecs, 1); }
540: init
541: /* Note how the declaration of the variable is in effect while its init is parsed! */
542: { finish_decl ($<ttype>4, $5, $2); }
543: | declarator maybeasm
544: { tree d = start_decl ($1, current_declspecs, 0);
545: finish_decl (d, NULL_TREE, $2); }
546: ;
547:
548: notype_initdcl:
549: notype_declarator maybeasm '='
550: { $<ttype>$ = start_decl ($1, current_declspecs, 1); }
551: init
552: /* Note how the declaration of the variable is in effect while its init is parsed! */
553: { finish_decl ($<ttype>4, $5, $2); }
554: | notype_declarator maybeasm
555: { tree d = start_decl ($1, current_declspecs, 0);
556: finish_decl (d, NULL_TREE, $2); }
557: ;
558:
559: init:
560: expr_no_commas
561: | '{' initlist '}'
562: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
563: | '{' initlist ',' '}'
564: { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); }
565: | error
566: { $$ = NULL_TREE; }
567: ;
568:
569: /* This chain is built in reverse order,
570: and put in forward order where initlist is used. */
571: initlist:
572: init
573: { $$ = build_tree_list (NULL_TREE, $1); }
574: | initlist ',' init
575: { $$ = tree_cons (NULL_TREE, $3, $1); }
576: ;
577:
578: /* Any kind of declarator (thus, all declarators allowed
579: after an explicit typespec). */
580:
581: declarator:
582: after_type_declarator
583: | notype_declarator
584: ;
585:
586: /* A declarator that is allowed only after an explicit typespec. */
587:
588: after_type_declarator:
589: '(' after_type_declarator ')'
590: { $$ = $2; }
591: | after_type_declarator '(' parmlist_or_identifiers %prec '.'
592: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
593: /* | after_type_declarator '(' error ')' %prec '.'
594: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
595: poplevel (0, 0, 0); } */
596: | after_type_declarator '[' expr ']' %prec '.'
597: { $$ = build_nt (ARRAY_REF, $1, $3); }
598: | after_type_declarator '[' ']' %prec '.'
599: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
600: | '*' type_quals after_type_declarator %prec UNARY
601: { $$ = make_pointer_declarator ($2, $3); }
602: | TYPENAME
603: ;
604:
605: /* Kinds of declarator that can appear in a parameter list
606: in addition to notype_declarator. This is like after_type_declarator
607: but does not allow a typedef name in parentheses as an identifier
608: (because it would conflict with a function with that typedef as arg). */
609:
610: parm_declarator:
611: parm_declarator '(' parmlist_or_identifiers %prec '.'
612: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
613: /* | parm_declarator '(' error ')' %prec '.'
614: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
615: poplevel (0, 0, 0); } */
616: | parm_declarator '[' expr ']' %prec '.'
617: { $$ = build_nt (ARRAY_REF, $1, $3); }
618: | parm_declarator '[' ']' %prec '.'
619: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
620: | '*' type_quals parm_declarator %prec UNARY
621: { $$ = make_pointer_declarator ($2, $3); }
622: | TYPENAME
623: ;
624:
625: /* A declarator allowed whether or not there has been
626: an explicit typespec. These cannot redeclare a typedef-name. */
627:
628: notype_declarator:
629: notype_declarator '(' parmlist_or_identifiers %prec '.'
630: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
631: /* | notype_declarator '(' error ')' %prec '.'
632: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE);
633: poplevel (0, 0, 0); } */
634: | '(' notype_declarator ')'
635: { $$ = $2; }
636: | '*' type_quals notype_declarator %prec UNARY
637: { $$ = make_pointer_declarator ($2, $3); }
638: | notype_declarator '[' expr ']' %prec '.'
639: { $$ = build_nt (ARRAY_REF, $1, $3); }
640: | notype_declarator '[' ']' %prec '.'
641: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
642: | IDENTIFIER
643: ;
644:
645: structsp:
646: STRUCT identifier '{'
647: { $$ = start_struct (RECORD_TYPE, $2);
648: /* Start scope of tag before parsing components. */
649: }
650: component_decl_list '}'
651: { $$ = finish_struct ($<ttype>4, $5);
652: /* Really define the structure. */
653: }
654: | STRUCT '{' component_decl_list '}'
655: { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
656: $3); }
657: | STRUCT identifier
658: { $$ = xref_tag (RECORD_TYPE, $2); }
659: | UNION identifier '{'
660: { $$ = start_struct (UNION_TYPE, $2); }
661: component_decl_list '}'
662: { $$ = finish_struct ($<ttype>4, $5); }
663: | UNION '{' component_decl_list '}'
664: { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
665: $3); }
666: | UNION identifier
667: { $$ = xref_tag (UNION_TYPE, $2); }
668: | ENUM identifier '{'
669: { $<itype>3 = suspend_momentary ();
670: $$ = start_enum ($2); }
671: enumlist maybecomma '}'
672: { $$ = finish_enum ($<ttype>4, nreverse ($5));
673: resume_momentary ($<itype>3); }
674: | ENUM '{'
675: { $<itype>2 = suspend_momentary ();
676: $$ = start_enum (NULL_TREE); }
677: enumlist maybecomma '}'
678: { $$ = finish_enum ($<ttype>3, nreverse ($4));
679: resume_momentary ($<itype>2); }
680: | ENUM identifier
681: { $$ = xref_tag (ENUMERAL_TYPE, $2); }
682: ;
683:
684: maybecomma:
685: /* empty */
686: | ','
687: ;
688:
689: component_decl_list: /* empty */
690: { $$ = NULL_TREE; }
691: | component_decl_list component_decl ';'
692: { $$ = chainon ($1, $2); }
693: | component_decl_list ';'
694: { if (pedantic)
695: warning ("extra semicolon in struct or union specified"); }
696: ;
697:
698: /* There is a shift-reduce conflict here, because `components' may
699: start with a `typename'. It happens that shifting (the default resolution)
700: does the right thing, because it treats the `typename' as part of
701: a `typed_typespecs'.
702:
703: It is possible that this same technique would allow the distinction
704: between `notype_initdecls' and `initdecls' to be eliminated.
705: But I am being cautious and not trying it. */
706:
707: component_decl:
708: typed_typespecs setspecs components
709: { $$ = $3;
710: resume_momentary ($2); }
711: | nonempty_type_quals setspecs components
712: { $$ = $3;
713: resume_momentary ($2); }
714: | error
715: { $$ = NULL_TREE; }
716: ;
717:
718: components:
719: /* empty */
720: { $$ = NULL_TREE; }
721: | component_declarator
722: | components ',' component_declarator
723: { $$ = chainon ($1, $3); }
724: ;
725:
726: component_declarator:
727: declarator
728: { $$ = grokfield (input_filename, lineno, $1, current_declspecs, NULL_TREE); }
729: | declarator ':' expr_no_commas
730: { $$ = grokfield (input_filename, lineno, $1, current_declspecs, $3); }
731: | ':' expr_no_commas
732: { $$ = grokfield (input_filename, lineno, NULL_TREE, current_declspecs, $2); }
733: ;
734:
735: /* We chain the enumerators in reverse order.
736: They are put in forward order where enumlist is used.
737: (The order used to be significant, but no longer is so.
738: However, we still maintain the order, just to be clean.) */
739:
740: enumlist:
741: enumerator
742: | enumlist ',' enumerator
743: { $$ = chainon ($3, $1); }
744: ;
745:
746:
747: enumerator:
748: identifier
749: { $$ = build_enumerator ($1, NULL_TREE); }
750: | identifier '=' expr_no_commas
751: { $$ = build_enumerator ($1, $3); }
752: ;
753:
754: typename:
755: typed_typespecs absdcl
756: { $$ = build_tree_list ($1, $2); }
757: | nonempty_type_quals absdcl
758: { $$ = build_tree_list ($1, $2); }
759: ;
760:
761: absdcl: /* an absolute declarator */
762: /* empty */
763: { $$ = NULL_TREE; }
764: | absdcl1
765: ;
766:
767: nonempty_type_quals:
768: TYPE_QUAL
769: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); }
770: | nonempty_type_quals TYPE_QUAL
771: { $$ = tree_cons (NULL_TREE, $2, $1); }
772: ;
773:
774: type_quals:
775: /* empty */
776: { $$ = NULL_TREE; }
777: | type_quals TYPE_QUAL
778: { $$ = tree_cons (NULL_TREE, $2, $1); }
779: ;
780:
781: absdcl1: /* a nonempty absolute declarator */
782: '(' absdcl1 ')'
783: { $$ = $2; }
784: /* `(typedef)1' is `int'. */
785: | '*' type_quals absdcl1 %prec UNARY
786: { $$ = make_pointer_declarator ($2, $3); }
787: | '*' type_quals %prec UNARY
788: { $$ = make_pointer_declarator ($2, NULL_TREE); }
789: | absdcl1 '(' parmlist %prec '.'
790: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); }
791: | absdcl1 '[' expr ']' %prec '.'
792: { $$ = build_nt (ARRAY_REF, $1, $3); }
793: | absdcl1 '[' ']' %prec '.'
794: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); }
795: | '(' parmlist %prec '.'
796: { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); }
797: | '[' expr ']' %prec '.'
798: { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); }
799: | '[' ']' %prec '.'
800: { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); }
801: ;
802:
803: /* at least one statement, the first of which parses without error. */
804: /* stmts is used only after decls, so an invalid first statement
805: is actually regarded as an invalid decl and part of the decls. */
806:
807: stmts:
808: stmt
809: | stmts stmt
810: | stmts errstmt
811: ;
812:
813: xstmts:
814: /* empty */
815: | stmts
816: ;
817:
818: errstmt: error ';'
819: ;
820:
821: pushlevel: /* empty */
822: { pushlevel (0);
823: clear_last_expr ();
824: push_momentary ();
825: expand_start_bindings (0); }
826: ;
827:
828: compstmt: '{' '}'
829: | '{' pushlevel decls xstmts '}'
830: { expand_end_bindings (getdecls (), 1);
831: poplevel (1, 1, 0);
832: pop_momentary (); }
833: | '{' pushlevel error '}'
834: { expand_end_bindings (getdecls (), 0);
835: poplevel (0, 0, 0);
836: pop_momentary (); }
837: | '{' pushlevel stmts '}'
838: { expand_end_bindings (getdecls (), 0);
839: poplevel (0, 0, 0);
840: pop_momentary (); }
841: ;
842:
843: simple_if:
844: IF '(' expr ')'
845: { emit_note (input_filename, lineno);
846: expand_start_cond (truthvalue_conversion ($3), 0); }
847: stmt
848: ;
849:
850: stmt:
851: compstmt
852: | expr ';'
853: { emit_note (input_filename, lineno);
854: expand_expr_stmt ($1);
855: clear_momentary (); }
856: | simple_if ELSE
857: { expand_start_else (); }
858: stmt
859: { expand_end_else (); }
860: | simple_if
861: { expand_end_cond (); }
862: | WHILE
863: { emit_note (input_filename, lineno);
864: expand_start_loop (1); }
865: '(' expr ')'
866: { emit_note (input_filename, lineno);
867: expand_exit_loop_if_false (truthvalue_conversion ($4)); }
868: stmt
869: { expand_end_loop (); }
870: | DO
871: { emit_note (input_filename, lineno);
872: expand_start_loop_continue_elsewhere (1); }
873: stmt WHILE
874: { expand_loop_continue_here (); }
875: '(' expr ')' ';'
876: { emit_note (input_filename, lineno);
877: expand_exit_loop_if_false (truthvalue_conversion ($7));
878: expand_end_loop ();
879: clear_momentary (); }
880: | FOR
881: '(' xexpr ';'
882: { emit_note (input_filename, lineno);
883: if ($3) expand_expr_stmt ($3);
884: expand_start_loop_continue_elsewhere (1); }
885: xexpr ';'
886: { emit_note (input_filename, lineno);
887: if ($6)
888: expand_exit_loop_if_false (truthvalue_conversion ($6)); }
889: xexpr ')'
890: /* Don't let the tree nodes for $9 be discarded
891: by clear_momentary during the parsing of the next stmt. */
892: { push_momentary ();
893: $<itype>10 = lineno; }
894: stmt
895: { emit_note (input_filename, $<itype>10);
896: expand_loop_continue_here ();
897: if ($9)
898: expand_expr_stmt ($9);
899: pop_momentary ();
900: expand_end_loop (); }
901: | SWITCH '(' expr ')'
902: { emit_note (input_filename, lineno);
903: c_expand_start_case ($3);
904: /* Don't let the tree nodes for $3 be discarded by
905: clear_momentary during the parsing of the next stmt. */
906: push_momentary (); }
907: stmt
908: { expand_end_case ();
909: pop_momentary (); }
910: | CASE expr ':'
911: { register tree value = fold ($2);
912: register tree label
913: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
914:
915: if (TREE_CODE (value) != INTEGER_CST
916: && value != error_mark_node)
917: {
918: error ("case label does not reduce to an integer constant");
919: value = error_mark_node;
920: }
921: else
922: /* Promote char or short to int. */
923: value = default_conversion (value);
924: if (value != error_mark_node)
925: {
926: int success = pushcase (value, label);
927: if (success == 1)
928: error ("case label not within a switch statement");
929: else if (success == 2)
930: error ("duplicate case value");
931: else if (success == 3)
932: warning ("case value out of range");
933: }
934: }
935: stmt
936: | DEFAULT ':'
937: {
938: register tree label
939: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
940: int success = pushcase (NULL_TREE, label);
941: if (success == 1)
942: error ("default label not within a switch statement");
943: else if (success == 2)
944: error ("multiple default labels in one switch");
945: }
946: stmt
947: | BREAK ';'
948: { emit_note (input_filename, lineno);
949: if ( ! expand_exit_something ())
950: error ("break statement not within loop or switch"); }
951: | CONTINUE ';'
952: { emit_note (input_filename, lineno);
953: if (! expand_continue_loop ())
954: error ("continue statement not within a loop"); }
955: | RETURN ';'
956: { emit_note (input_filename, lineno);
957: c_expand_return (NULL_TREE); }
958: | RETURN expr ';'
959: { emit_note (input_filename, lineno);
960: c_expand_return ($2); }
961: | ASM maybe_type_qual '(' string ')' ';'
962: { if (pedantic)
963: warning ("ANSI C forbids use of `asm' keyword");
964: if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
965: expand_asm ($4); }
966: /* This is the case with just output operands. */
967: | ASM maybe_type_qual '(' string ':' asm_operands ')' ';'
968: { if (pedantic)
969: warning ("ANSI C forbids use of `asm' keyword");
970: if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
971: c_expand_asm_operands ($4, $6, NULL_TREE,
972: $2 == ridpointers[(int)RID_VOLATILE]); }
973: /* This is the case with input operands as well. */
974: | ASM maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';'
975: { if (pedantic)
976: warning ("ANSI C forbids use of `asm' keyword");
977: if (TREE_CHAIN ($4)) $4 = combine_strings ($4);
978: c_expand_asm_operands ($4, $6, $8,
979: $2 == ridpointers[(int)RID_VOLATILE]); }
980: | GOTO identifier ';'
981: { tree decl;
982: emit_note (input_filename, lineno);
983: decl = lookup_label ($2);
984: expand_goto (decl); }
985: | identifier ':'
986: { tree label = define_label (input_filename, lineno, $1);
987: if (label)
988: expand_label (label); }
989: stmt
990: | ';'
991: ;
992:
993: maybe_type_qual:
994: /* empty */
995: { emit_note (input_filename, lineno); }
996: | TYPE_QUAL
997: { emit_note (input_filename, lineno); }
998: ;
999:
1000: xexpr:
1001: /* empty */
1002: { $$ = NULL_TREE; }
1003: | expr
1004: ;
1005:
1006: /* These are the operands other than the first string and comma
1007: in asm ("addextend %2,%1", "=dm" (x), "0" (y), "g" (*x)) */
1008: asm_operands: asm_operand
1009: | asm_operands ',' asm_operand
1010: { $$ = chainon ($1, $3); }
1011: ;
1012:
1013: asm_operand:
1014: | STRING '(' expr ')'
1015: { $$ = build_tree_list ($1, $3); }
1016: ;
1017:
1018: /* This is what appears inside the parens in a function declarator.
1019: Its value is a list of ..._TYPE nodes. */
1020: parmlist:
1021: { pushlevel (0); }
1022: parmlist_1
1023: { $$ = $2; poplevel (0, 0, 0); }
1024: ;
1025:
1026: /* This is referred to where either a parmlist or an identifier list is ok.
1027: Its value is a list of ..._TYPE nodes or a list of identifiers. */
1028: parmlist_or_identifiers:
1029: { pushlevel (0); }
1030: parmlist_or_identifiers_1
1031: { $$ = $2; poplevel (0, 0, 0); }
1032: ;
1033:
1034: parmlist_or_identifiers_1:
1035: parmlist_2 ')'
1036: | identifiers ')'
1037: { $$ = tree_cons (NULL_TREE, NULL_TREE, $1); }
1038: | error ')'
1039: { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
1040: ;
1041:
1042: parmlist_1:
1043: parmlist_2 ')'
1044: | error ')'
1045: { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); }
1046: ;
1047:
1048: /* This is what appears inside the parens in a function declarator.
1049: Is value is represented in the format that grokdeclarator expects. */
1050: parmlist_2: /* empty */
1051: { $$ = get_parm_info (0); }
1052: | parms
1053: { $$ = get_parm_info (1); }
1054: | parms ',' ELLIPSIS
1055: { $$ = get_parm_info (0); }
1056: ;
1057:
1058: parms:
1059: parm
1060: { push_parm_decl ($1); }
1061: | parms ',' parm
1062: { push_parm_decl ($3); }
1063: ;
1064:
1065: /* A single parameter declaration or parameter type name,
1066: as found in a parmlist. */
1067: parm:
1068: typed_declspecs parm_declarator
1069: { $$ = build_tree_list ($1, $2) ; }
1070: | typed_declspecs notype_declarator
1071: { $$ = build_tree_list ($1, $2) ; }
1072: | typed_declspecs absdcl
1073: { $$ = build_tree_list ($1, $2); }
1074: | declmods notype_declarator
1075: { $$ = build_tree_list ($1, $2) ; }
1076: | declmods absdcl
1077: { $$ = build_tree_list ($1, $2); }
1078: ;
1079:
1080: /* A nonempty list of identifiers. */
1081: identifiers:
1082: IDENTIFIER
1083: { $$ = build_tree_list (NULL_TREE, $1); }
1084: | identifiers ',' IDENTIFIER
1085: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); }
1086: ;
1087: %%
1088:
1089: /* Return something to represent absolute declarators containing a *.
1090: TARGET is the absolute declarator that the * contains.
1091: TYPE_QUALS is a list of modifiers such as const or volatile
1092: to apply to the pointer type, represented as identifiers.
1093:
1094: We return an INDIRECT_REF whose "contents" are TARGET
1095: and whose type is the modifier list. */
1096:
1097: static tree
1098: make_pointer_declarator (type_quals, target)
1099: tree type_quals, target;
1100: {
1101: return build (INDIRECT_REF, type_quals, target);
1102: }
1103:
1104: /* Given a chain of STRING_CST nodes,
1105: concatenate them into one STRING_CST
1106: and give it a suitable array-of-chars data type. */
1107:
1108: static tree
1109: combine_strings (strings)
1110: tree strings;
1111: {
1112: register tree value, t;
1113: register int length = 1;
1114: int wide_length = 0;
1115: int wide_flag = 0;
1116:
1117: if (TREE_CHAIN (strings))
1118: {
1119: /* More than one in the chain, so concatenate. */
1120: register char *p, *q;
1121:
1122: /* Don't include the \0 at the end of each substring,
1123: except for the last one.
1124: Count wide strings and ordinary strings separately. */
1125: for (t = strings; t; t = TREE_CHAIN (t))
1126: {
1127: if (TREE_TYPE (t) == int_array_type_node)
1128: {
1129: wide_length += (TREE_STRING_LENGTH (t) - 1);
1130: wide_flag = 1;
1131: }
1132: else
1133: length += (TREE_STRING_LENGTH (t) - 1);
1134: }
1135:
1136: /* If anything is wide, the non-wides will be converted,
1137: which makes them take more space. */
1138: if (wide_flag)
1139: length = length * UNITS_PER_WORD + wide_length;
1140:
1141: p = (char *) oballoc (length);
1142:
1143: /* Copy the individual strings into the new combined string.
1144: If the combined string is wide, convert the chars to ints
1145: for any individual strings that are not wide. */
1146:
1147: q = p;
1148: for (t = strings; t; t = TREE_CHAIN (t))
1149: {
1150: int len = TREE_STRING_LENGTH (t) - 1;
1151: if ((TREE_TYPE (t) == int_array_type_node) == wide_flag)
1152: {
1153: bcopy (TREE_STRING_POINTER (t), q, len);
1154: q += len;
1155: }
1156: else
1157: {
1158: int i;
1159: for (i = 0; i < len; i++)
1160: ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
1161: q += len * UNITS_PER_WORD;
1162: }
1163: }
1164: *q = 0;
1165:
1166: value = make_node (STRING_CST);
1167: TREE_STRING_POINTER (value) = p;
1168: TREE_STRING_LENGTH (value) = length;
1169: TREE_LITERAL (value) = 1;
1170: }
1171: else
1172: {
1173: value = strings;
1174: length = TREE_STRING_LENGTH (value);
1175: if (TREE_TYPE (value) == int_array_type_node)
1176: wide_flag = 1;
1177: }
1178:
1179: TREE_TYPE (value)
1180: = build_array_type (wide_flag ? integer_type_node : char_type_node,
1181: make_index_type (build_int_2 (length - 1, 0)));
1182: TREE_LITERAL (value) = 1;
1183: TREE_STATIC (value) = 1;
1184: return value;
1185: }
1186:
1187: int lineno; /* current line number in file being read */
1188:
1189: FILE *finput; /* input file.
1190: Normally a pipe from the preprocessor. */
1191:
1192: /* lexical analyzer */
1193:
1194: static int maxtoken; /* Current nominal length of token buffer */
1195: static char *token_buffer; /* Pointer to token buffer.
1196: Actual allocated length is maxtoken + 2. */
1197: static dollar_seen = 0; /* Nonzero if have warned about `$'. */
1198:
1199: #define MAXRESERVED 9
1200:
1201: /* frw[I] is index in `reswords' of the first word whose length is I;
1202: frw[I+1] is one plus the index of the last word whose length is I.
1203: The length of frw must be MAXRESERVED + 2 so there is an element
1204: at MAXRESERVED+1 for the case I == MAXRESERVED. */
1205:
1206: static char frw[MAXRESERVED+2] =
1207: { 0, 0, 0, 2, 5, 13, 19, 29, 32, 36, 37 };
1208:
1209: /* Table of reserved words. */
1210:
1211: struct resword { char *name; short token; enum rid rid;};
1212:
1213: #define NORID RID_UNUSED
1214:
1215: static struct resword reswords[]
1216: = {{"if", IF, NORID},
1217: {"do", DO, NORID},
1218: {"int", TYPESPEC, RID_INT},
1219: {"for", FOR, NORID},
1220: {"asm", ASM, NORID},
1221: {"case", CASE, NORID},
1222: {"char", TYPESPEC, RID_CHAR},
1223: {"auto", SCSPEC, RID_AUTO},
1224: {"goto", GOTO, NORID},
1225: {"else", ELSE, NORID},
1226: {"long", TYPESPEC, RID_LONG},
1227: {"void", TYPESPEC, RID_VOID},
1228: {"enum", ENUM, NORID},
1229: {"float", TYPESPEC, RID_FLOAT},
1230: {"short", TYPESPEC, RID_SHORT},
1231: {"union", UNION, NORID},
1232: {"break", BREAK, NORID},
1233: {"while", WHILE, NORID},
1234: {"const", TYPE_QUAL, RID_CONST},
1235: {"double", TYPESPEC, RID_DOUBLE},
1236: {"static", SCSPEC, RID_STATIC},
1237: {"extern", SCSPEC, RID_EXTERN},
1238: {"struct", STRUCT, NORID},
1239: {"return", RETURN, NORID},
1240: {"sizeof", SIZEOF, NORID},
1241: {"typeof", TYPEOF, NORID},
1242: {"switch", SWITCH, NORID},
1243: {"signed", TYPESPEC, RID_SIGNED},
1244: {"inline", SCSPEC, RID_INLINE},
1245: {"typedef", SCSPEC, RID_TYPEDEF},
1246: {"default", DEFAULT, NORID},
1247: {"noalias", TYPE_QUAL, RID_NOALIAS},
1248: {"unsigned", TYPESPEC, RID_UNSIGNED},
1249: {"continue", CONTINUE, NORID},
1250: {"register", SCSPEC, RID_REGISTER},
1251: {"volatile", TYPE_QUAL, RID_VOLATILE},
1252: {"__alignof", ALIGNOF, NORID}};
1253:
1254: /* The elements of `ridpointers' are identifier nodes
1255: for the reserved type names and storage classes.
1256: It is indexed by a RID_... value. */
1257:
1258: tree ridpointers[(int) RID_MAX];
1259:
1260: static tree line_identifier; /* The identifier node named "line" */
1261:
1262: void check_newline ();
1263:
1264: void
1265: init_lex ()
1266: {
1267: extern char *malloc ();
1268:
1269: /* Start it at 0, because check_newline is called at the very beginning
1270: and will increment it to 1. */
1271: lineno = 0;
1272: line_identifier = get_identifier ("line");
1273:
1274: maxtoken = 40;
1275: token_buffer = malloc (maxtoken + 2);
1276: ridpointers[(int) RID_INT] = get_identifier ("int");
1277: ridpointers[(int) RID_CHAR] = get_identifier ("char");
1278: ridpointers[(int) RID_VOID] = get_identifier ("void");
1279: ridpointers[(int) RID_FLOAT] = get_identifier ("float");
1280: ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
1281: ridpointers[(int) RID_SHORT] = get_identifier ("short");
1282: ridpointers[(int) RID_LONG] = get_identifier ("long");
1283: ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
1284: ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
1285: ridpointers[(int) RID_INLINE] = get_identifier ("inline");
1286: ridpointers[(int) RID_CONST] = get_identifier ("const");
1287: ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
1288: ridpointers[(int) RID_AUTO] = get_identifier ("auto");
1289: ridpointers[(int) RID_STATIC] = get_identifier ("static");
1290: ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
1291: ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
1292: ridpointers[(int) RID_REGISTER] = get_identifier ("register");
1293: }
1294:
1295: static void
1296: reinit_parse_for_function ()
1297: {
1298: }
1299:
1300: static int
1301: skip_white_space ()
1302: {
1303: register int c;
1304: register int inside;
1305:
1306: c = getc (finput);
1307:
1308: for (;;)
1309: {
1310: switch (c)
1311: {
1312: case '/':
1313: c = getc (finput);
1314: if (c != '*')
1315: {
1316: ungetc (c, finput);
1317: return '/';
1318: }
1319:
1320: c = getc (finput);
1321:
1322: inside = 1;
1323: while (inside)
1324: {
1325: if (c == '*')
1326: {
1327: while (c == '*')
1328: c = getc (finput);
1329:
1330: if (c == '/')
1331: {
1332: inside = 0;
1333: c = getc (finput);
1334: }
1335: }
1336: else if (c == '\n')
1337: {
1338: lineno++;
1339: c = getc (finput);
1340: }
1341: else if (c == EOF)
1342: {
1343: error ("unterminated comment");
1344: break;
1345: }
1346: else
1347: c = getc (finput);
1348: }
1349:
1350: break;
1351:
1352: case '\n':
1353: check_newline ();
1354:
1355: case ' ':
1356: case '\t':
1357: case '\f':
1358: case '\r':
1359: case '\b':
1360: c = getc (finput);
1361: break;
1362:
1363: case '\\':
1364: c = getc (finput);
1365: if (c == '\n')
1366: lineno++;
1367: else
1368: error ("stray '\\' in program");
1369: c = getc (finput);
1370: break;
1371:
1372: default:
1373: return (c);
1374: }
1375: }
1376: }
1377:
1378:
1379:
1380: /* Make the token buffer longer, preserving the data in it.
1381: P should point to just beyond the last valid character in the old buffer.
1382: The value we return is a pointer to the new buffer
1383: at a place corresponding to P. */
1384:
1385: static char *
1386: extend_token_buffer (p)
1387: char *p;
1388: {
1389: int offset = p - token_buffer;
1390:
1391: maxtoken = maxtoken * 2 + 10;
1392: token_buffer = (char *) realloc (token_buffer, maxtoken + 2);
1393: if (token_buffer == 0)
1394: fatal ("virtual memory exceeded");
1395:
1396: return token_buffer + offset;
1397: }
1398:
1399: /* At the beginning of a line, increment the line number
1400: and handle a #line directive immediately following */
1401:
1402: void
1403: check_newline ()
1404: {
1405: register int c;
1406: register int token;
1407:
1408: while (1)
1409: {
1410: lineno++;
1411:
1412: /* Read first nonwhite char on the line. */
1413:
1414: c = getc (finput);
1415: while (c == ' ' || c == '\t')
1416: c = getc (finput);
1417:
1418: if (c != '#')
1419: {
1420: /* If not #, unread it. */
1421: ungetc (c, finput);
1422: return;
1423: }
1424:
1425: /* Read first nonwhite char after the `#'. */
1426:
1427: c = getc (finput);
1428: while (c == ' ' || c == '\t')
1429: c = getc (finput);
1430:
1431: /* If a letter follows, then if the word here is `line', skip
1432: it and ignore it; otherwise, ignore the line, with an error
1433: if the word isn't `pragma'. */
1434:
1435: if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
1436: {
1437: if (c == 'p')
1438: {
1439: if (getc (finput) == 'r'
1440: && getc (finput) == 'a'
1441: && getc (finput) == 'g'
1442: && getc (finput) == 'm'
1443: && getc (finput) == 'a'
1444: && ((c = getc (finput)) == ' ' || c == '\t'))
1445: goto noerror;
1446: }
1447:
1448: else if (c == 'l')
1449: {
1450: if (getc (finput) == 'i'
1451: && getc (finput) == 'n'
1452: && getc (finput) == 'e'
1453: && ((c = getc (finput)) == ' ' || c == '\t'))
1454: goto linenum;
1455: }
1456:
1457: error ("undefined or invalid # directive");
1458: noerror:
1459:
1460: while ((c = getc (finput)) && c != '\n');
1461:
1462: continue;
1463: }
1464:
1465: linenum:
1466: /* Here we have either `#line' or `# <nonletter>'.
1467: In either case, it should be a line number; a digit should follow.
1468:
1469: while (c == ' ' || c == '\t')
1470: c = getc (finput);
1471:
1472: /* If the # is the only nonwhite char on the line,
1473: just ignore it. Check the new newline. */
1474: if (c == '\n')
1475: continue;
1476:
1477: /* Something follows the #; read a token. */
1478:
1479: ungetc (c, finput);
1480: token = yylex ();
1481:
1482: if (token == CONSTANT
1483: && TREE_CODE (yylval.ttype) == INTEGER_CST)
1484: {
1485: /* subtract one, because it is the following line that
1486: gets the specified number */
1487:
1488: int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
1489:
1490: /* Is this the last nonwhite stuff on the line? */
1491: c = getc (finput);
1492: while (c == ' ' || c == '\t')
1493: c = getc (finput);
1494: if (c == '\n')
1495: {
1496: /* No more: store the line number and check following line. */
1497: lineno = l;
1498: continue;
1499: }
1500: ungetc (c, finput);
1501:
1502: /* More follows: it must be a string constant (filename). */
1503:
1504: token = yylex ();
1505: if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
1506: {
1507: error ("invalid #line");
1508: return;
1509: }
1510:
1511: input_filename
1512: = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
1513: strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
1514: lineno = l;
1515:
1516: if (main_input_filename == 0)
1517: main_input_filename = input_filename;
1518: }
1519: else
1520: error ("invalid #line");
1521:
1522: /* skip the rest of this line. */
1523: while ((c = getc (finput)) != '\n');
1524: }
1525: }
1526:
1527:
1528:
1529: #define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
1530: #define isdigit(char) (char >= '0' && char <= '9')
1531: #define ENDFILE -1 /* token that represents end-of-file */
1532:
1533:
1534: static int
1535: readescape ()
1536: {
1537: register int c = getc (finput);
1538: register int count, code;
1539:
1540: switch (c)
1541: {
1542: case 'x':
1543: code = 0;
1544: count = 0;
1545: while (1)
1546: {
1547: c = getc (finput);
1548: if (!(c >= 'a' && c <= 'f')
1549: && !(c >= 'A' && c <= 'F')
1550: && !(c >= '0' && c <= '9'))
1551: {
1552: ungetc (c, finput);
1553: break;
1554: }
1555: code *= 16;
1556: if (c >= 'a' && c <= 'f')
1557: code += c - 'a' + 10;
1558: if (c >= 'A' && c <= 'F')
1559: code += c - 'A' + 10;
1560: if (c >= '0' && c <= '9')
1561: code += c - '0';
1562: count++;
1563: }
1564: if (count == 0)
1565: error ("\\x used with no following hex digits");
1566: return code;
1567:
1568: case '0': case '1': case '2': case '3': case '4':
1569: case '5': case '6': case '7':
1570: code = 0;
1571: count = 0;
1572: while ((c <= '7') && (c >= '0') && (count++ < 3))
1573: {
1574: code = (code * 8) + (c - '0');
1575: c = getc (finput);
1576: }
1577: ungetc (c, finput);
1578: return code;
1579:
1580: case '\\': case '\'': case '"':
1581: return c;
1582:
1583: case '\n':
1584: lineno++;
1585: return -1;
1586:
1587: case 'n':
1588: return TARGET_NEWLINE;
1589:
1590: case 't':
1591: return TARGET_TAB;
1592:
1593: case 'r':
1594: return TARGET_CR;
1595:
1596: case 'f':
1597: return TARGET_FF;
1598:
1599: case 'b':
1600: return TARGET_BS;
1601:
1602: case 'a':
1603: return TARGET_BELL;
1604:
1605: case 'v':
1606: return TARGET_VT;
1607:
1608: case 'E':
1609: return 033;
1610:
1611: case '?':
1612: return c;
1613: }
1614: if (c >= 040 && c <= 0177)
1615: warning ("unknown escape sequence `\\%c'", c);
1616: else
1617: warning ("unknown escape sequence: `\\' followed by char code 0x%x", c);
1618: return c;
1619: }
1620:
1621: void
1622: yyerror (string)
1623: char *string;
1624: {
1625: char buf[200];
1626:
1627: strcpy (buf, string);
1628:
1629: /* We can't print string and character constants well
1630: because the token_buffer contains the result of processing escapes. */
1631: if (token_buffer[0] == 0)
1632: strcat (buf, " at end of input");
1633: else if (token_buffer[0] == '"')
1634: strcat (buf, " before string constant");
1635: else if (token_buffer[0] == '\'')
1636: strcat (buf, " before character constant");
1637: else
1638: strcat (buf, " before `%s'");
1639:
1640: error (buf, token_buffer);
1641: }
1642:
1643: static int
1644: yylex ()
1645: {
1646: register int c;
1647: register char *p;
1648: register int value;
1649: int wide_flag = 0;
1650:
1651: /* Effectively do c = skip_white_space ()
1652: but do it faster in the usual cases. */
1653: c = getc (finput);
1654: while (1)
1655: switch (c)
1656: {
1657: case ' ':
1658: case '\t':
1659: case '\f':
1660: case '\r':
1661: case '\b':
1662: c = getc (finput);
1663: break;
1664:
1665: case '\n':
1666: case '/':
1667: case '\\':
1668: ungetc (c, finput);
1669: c = skip_white_space ();
1670: default:
1671: goto found_nonwhite;
1672: }
1673: found_nonwhite:
1674:
1675: token_buffer[0] = c;
1676: token_buffer[1] = 0;
1677:
1678: yylloc.first_line = lineno;
1679:
1680: switch (c)
1681: {
1682: case EOF:
1683: token_buffer[0] = 0;
1684: value = ENDFILE;
1685: break;
1686:
1687: case 'L':
1688: /* Capital L may start a wide-string or wide-character constant. */
1689: {
1690: register int c = getc (finput);
1691: if (c == '\'')
1692: {
1693: wide_flag = 1;
1694: goto char_constant;
1695: }
1696: if (c == '"')
1697: {
1698: wide_flag = 1;
1699: goto string_constant;
1700: }
1701: ungetc (c, finput);
1702: }
1703:
1704: case 'A': case 'B': case 'C': case 'D': case 'E':
1705: case 'F': case 'G': case 'H': case 'I': case 'J':
1706: case 'K': case 'M': case 'N': case 'O':
1707: case 'P': case 'Q': case 'R': case 'S': case 'T':
1708: case 'U': case 'V': case 'W': case 'X': case 'Y':
1709: case 'Z':
1710: case 'a': case 'b': case 'c': case 'd': case 'e':
1711: case 'f': case 'g': case 'h': case 'i': case 'j':
1712: case 'k': case 'l': case 'm': case 'n': case 'o':
1713: case 'p': case 'q': case 'r': case 's': case 't':
1714: case 'u': case 'v': case 'w': case 'x': case 'y':
1715: case 'z':
1716: case '_':
1717: case '$':
1718: p = token_buffer;
1719: while (isalnum (c) || c == '_' || c == '$')
1720: {
1721: if (p >= token_buffer + maxtoken)
1722: p = extend_token_buffer (p);
1723: if (c == '$')
1724: {
1725: if (pedantic)
1726: {
1727: if (! dollar_seen)
1728: warning ("ANSI C forbids `$' (first use here)");
1729: dollar_seen = 1;
1730: }
1731: }
1732:
1733: *p++ = c;
1734: c = getc (finput);
1735: }
1736:
1737: *p = 0;
1738: ungetc (c, finput);
1739:
1740: value = IDENTIFIER;
1741: yylval.itype = 0;
1742:
1743: /* Try to recognize a keyword. */
1744:
1745: if (p - token_buffer <= MAXRESERVED)
1746: {
1747: register int lim = frw [p - token_buffer + 1];
1748: register int i = frw[p - token_buffer];
1749: register struct resword *p = &reswords[i];
1750:
1751: for (; i < lim; i++, p++)
1752: if (p->name[0] == token_buffer[0]
1753: && !strcmp (p->name, token_buffer))
1754: {
1755: if (p->rid)
1756: yylval.ttype = ridpointers[(int) p->rid];
1757: if ((! flag_no_asm
1758: || ((int) p->token != ASM
1759: && (int) p->token != TYPEOF
1760: && strcmp (p->name, "inline")))
1761: /* -ftraditional means don't recognize
1762: typeof, const, volatile, noalias, signed or inline. */
1763: && (! flag_traditional
1764: || ((int) p->token != TYPE_QUAL
1765: && (int) p->token != TYPEOF
1766: && strcmp (p->name, "signed")
1767: && strcmp (p->name, "inline"))))
1768: value = (int) p->token;
1769: break;
1770: }
1771: }
1772:
1773: /* If we did not find a keyword, look for an identifier
1774: (or a typename). */
1775:
1776: if (value == IDENTIFIER)
1777: {
1778: yylval.ttype = get_identifier (token_buffer);
1779: lastiddecl = lookup_name (yylval.ttype);
1780:
1781: if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1782: value = TYPENAME;
1783: }
1784:
1785: break;
1786:
1787: case '0': case '1': case '2': case '3': case '4':
1788: case '5': case '6': case '7': case '8': case '9':
1789: case '.':
1790: {
1791: int base = 10;
1792: int count = 0;
1793: int largest_digit = 0;
1794: int numdigits = 0;
1795: /* for multi-precision arithmetic,
1796: we store only 8 live bits in each short,
1797: giving us 64 bits of reliable precision */
1798: short shorts[8];
1799: int floatflag = 0; /* Set 1 if we learn this is a floating constant */
1800:
1801: for (count = 0; count < 8; count++)
1802: shorts[count] = 0;
1803:
1804: p = token_buffer;
1805: *p++ = c;
1806:
1807: if (c == '0')
1808: {
1809: *p++ = (c = getc (finput));
1810: if ((c == 'x') || (c == 'X'))
1811: {
1812: base = 16;
1813: *p++ = (c = getc (finput));
1814: }
1815: else
1816: {
1817: base = 8;
1818: numdigits++;
1819: }
1820: }
1821:
1822: /* Read all the digits-and-decimal-points. */
1823:
1824: while (c == '.'
1825: || (isalnum (c) && (c != 'l') && (c != 'L')
1826: && (c != 'u') && (c != 'U')
1827: && (!floatflag || ((c != 'f') && (c != 'F')))))
1828: {
1829: if (c == '.')
1830: {
1831: if (base == 16)
1832: error ("floating constant may not be in radix 16");
1833: floatflag = 1;
1834: base = 10;
1835: *p++ = c = getc (finput);
1836: /* Accept '.' as the start of a floating-point number
1837: only when it is followed by a digit.
1838: Otherwise, unread the following non-digit
1839: and use the '.' as a structural token. */
1840: if (p == token_buffer + 2 && !isdigit (c))
1841: {
1842: if (c == '.')
1843: {
1844: c = getc (finput);
1845: if (c == '.')
1846: {
1847: *p++ = c;
1848: *p = 0;
1849: return ELLIPSIS;
1850: }
1851: error ("parse error at `..'");
1852: }
1853: ungetc (c, finput);
1854: token_buffer[1] = 0;
1855: value = '.';
1856: goto done;
1857: }
1858: }
1859: else
1860: {
1861: /* It is not a decimal point.
1862: It should be a digit (perhaps a hex digit). */
1863:
1864: if (isdigit (c))
1865: {
1866: c = c - '0';
1867: }
1868: else if (base <= 10)
1869: {
1870: if ((c&~040) == 'E')
1871: {
1872: base = 10;
1873: floatflag = 1;
1874: break; /* start of exponent */
1875: }
1876: error ("nondigits in number and not hexadecimal");
1877: c = 0;
1878: }
1879: else if (c >= 'a')
1880: {
1881: c = c - 'a' + 10;
1882: }
1883: else
1884: {
1885: c = c - 'A' + 10;
1886: }
1887: if (c >= largest_digit)
1888: largest_digit = c;
1889: numdigits++;
1890:
1891: for (count = 0; count < 8; count++)
1892: {
1893: (shorts[count] *= base);
1894: if (count)
1895: {
1896: shorts[count] += (shorts[count-1] >> 8);
1897: shorts[count-1] &= (1<<8)-1;
1898: }
1899: else shorts[0] += c;
1900: }
1901:
1902: if (p >= token_buffer + maxtoken - 3)
1903: p = extend_token_buffer (p);
1904: *p++ = (c = getc (finput));
1905: }
1906: }
1907:
1908: if (numdigits == 0)
1909: error ("numeric constant with no digits");
1910:
1911: if (largest_digit >= base)
1912: error ("numeric constant contains digits beyond the radix");
1913:
1914: /* Remove terminating char from the token buffer and delimit the string */
1915: *--p = 0;
1916:
1917: if (floatflag)
1918: {
1919: tree type = double_type_node;
1920: char f_seen = 0;
1921: char l_seen = 0;
1922:
1923: /* Read explicit exponent if any, and put it in tokenbuf. */
1924:
1925: if ((c == 'e') || (c == 'E'))
1926: {
1927: if (p >= token_buffer + maxtoken - 3)
1928: p = extend_token_buffer (p);
1929: *p++ = c;
1930: c = getc (finput);
1931: if ((c == '+') || (c == '-'))
1932: {
1933: *p++ = c;
1934: c = getc (finput);
1935: }
1936: if (! isdigit (c))
1937: error ("floating constant exponent has no digits");
1938: while (isdigit (c))
1939: {
1940: if (p >= token_buffer + maxtoken - 3)
1941: p = extend_token_buffer (p);
1942: *p++ = c;
1943: c = getc (finput);
1944: }
1945: }
1946:
1947: *p = 0;
1948: yylval.ttype = build_real (atof (token_buffer));
1949:
1950: while (1)
1951: {
1952: if (c == 'f' || c == 'F')
1953: {
1954: if (f_seen)
1955: error ("two `f's in floating constant");
1956: f_seen = 1;
1957: type = float_type_node;
1958: }
1959: else if (c == 'l' || c == 'L')
1960: {
1961: if (l_seen)
1962: error ("two `l's in floating constant");
1963: l_seen = 1;
1964: type = long_double_type_node;
1965: }
1966: else
1967: {
1968: if (isalnum (c))
1969: {
1970: error ("garbage at end of number");
1971: while (isalnum (c))
1972: {
1973: if (p >= token_buffer + maxtoken - 3)
1974: p = extend_token_buffer (p);
1975: *p++ = c;
1976: c = getc (finput);
1977: }
1978: }
1979: break;
1980: }
1981: if (p >= token_buffer + maxtoken - 3)
1982: p = extend_token_buffer (p);
1983: *p++ = c;
1984: c = getc (finput);
1985: }
1986:
1987: ungetc (c, finput);
1988: *p = 0;
1989:
1990: TREE_TYPE (yylval.ttype) = type;
1991: }
1992: else
1993: {
1994: tree type;
1995: int spec_unsigned = 0;
1996: int spec_long = 0;
1997:
1998: while (1)
1999: {
2000: if (c == 'u' || c == 'U')
2001: {
2002: if (spec_unsigned)
2003: error ("two `u's in integer constant");
2004: spec_unsigned = 1;
2005: }
2006: else if (c == 'l' || c == 'L')
2007: {
2008: if (spec_long)
2009: error ("two `l's in integer constant");
2010: spec_long = 1;
2011: }
2012: else
2013: {
2014: if (isalnum (c))
2015: {
2016: error ("garbage at end of number");
2017: while (isalnum (c))
2018: {
2019: if (p >= token_buffer + maxtoken - 3)
2020: p = extend_token_buffer (p);
2021: *p++ = c;
2022: c = getc (finput);
2023: }
2024: }
2025: break;
2026: }
2027: if (p >= token_buffer + maxtoken - 3)
2028: p = extend_token_buffer (p);
2029: *p++ = c;
2030: c = getc (finput);
2031: }
2032:
2033: ungetc (c, finput);
2034:
2035: if (shorts[7] | shorts[6] | shorts[5] | shorts[4])
2036: warning ("integer constant out of range");
2037:
2038: /* This is simplified by the fact that our constant
2039: is always positive. */
2040: yylval.ttype
2041: = build_int_2 ((shorts[3]<<24) + (shorts[2]<<16) + (shorts[1]<<8) + shorts[0],
2042: 0);
2043:
2044: if (!spec_long && !spec_unsigned
2045: && int_fits_type_p (yylval.ttype, integer_type_node))
2046: type = integer_type_node;
2047:
2048: else if (!spec_long && base != 10
2049: && int_fits_type_p (yylval.ttype, unsigned_type_node))
2050: type = unsigned_type_node;
2051:
2052: else if (!spec_unsigned
2053: && int_fits_type_p (yylval.ttype, long_integer_type_node))
2054: type = long_integer_type_node;
2055:
2056: else
2057: {
2058: type = long_unsigned_type_node;
2059: if (! int_fits_type_p (yylval.ttype, long_unsigned_type_node))
2060: warning ("integer constant out of range");
2061: }
2062: TREE_TYPE (yylval.ttype) = type;
2063: }
2064:
2065: value = CONSTANT; break;
2066: }
2067:
2068: case '\'':
2069: char_constant:
2070: c = getc (finput);
2071: {
2072: register int code = 0;
2073:
2074: tryagain:
2075:
2076: if (c == '\\')
2077: {
2078: c = readescape ();
2079: if (c < 0)
2080: goto tryagain;
2081: }
2082: else if (c == '\n')
2083: {
2084: if (pedantic)
2085: warning ("ANSI C forbids newline in character constant");
2086: lineno++;
2087: }
2088:
2089: code = c;
2090: token_buffer[1] = c;
2091: token_buffer[2] = '\'';
2092: token_buffer[3] = 0;
2093:
2094: c = getc (finput);
2095: if (c != '\'')
2096: error ("malformatted character constant");
2097:
2098: /* If char type is signed, sign-extend the constant. */
2099: if (TREE_UNSIGNED (char_type_node)
2100: || ((code >> (BITS_PER_UNIT - 1)) & 1) == 0)
2101: yylval.ttype = build_int_2 (code & ((1 << BITS_PER_UNIT) - 1), 0);
2102: else
2103: yylval.ttype = build_int_2 (code | ((-1) << BITS_PER_UNIT), -1);
2104:
2105: TREE_TYPE (yylval.ttype) = integer_type_node;
2106: value = CONSTANT; break;
2107: }
2108:
2109: case '"':
2110: string_constant:
2111: {
2112: c = getc (finput);
2113: p = token_buffer + 1;
2114:
2115: while (c != '"')
2116: {
2117: if (c == '\\')
2118: {
2119: c = readescape ();
2120: if (c < 0)
2121: goto skipnewline;
2122: }
2123: else if (c == '\n')
2124: {
2125: if (pedantic)
2126: warning ("ANSI C forbids newline in string constant");
2127: lineno++;
2128: }
2129:
2130: if (p == token_buffer + maxtoken)
2131: p = extend_token_buffer (p);
2132: *p++ = c;
2133:
2134: skipnewline:
2135: c = getc (finput);
2136: }
2137:
2138: *p = 0;
2139:
2140: if (wide_flag)
2141: {
2142: /* If this is a L"..." wide-string, convert each char
2143: to an int, making a vector of ints. */
2144: int *widebuf = (int *) alloca (p - token_buffer);
2145: char *p1 = token_buffer + 1;
2146: for (; p1 == p; p1++)
2147: widebuf[p1 - token_buffer - 1] = *p1;
2148: yylval.ttype = build_string ((p - token_buffer) * sizeof (int),
2149: widebuf);
2150: TREE_TYPE (yylval.ttype) = int_array_type_node;
2151: }
2152: else
2153: {
2154: yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
2155: TREE_TYPE (yylval.ttype) = char_array_type_node;
2156: }
2157:
2158: *p++ = '"';
2159: *p = 0;
2160:
2161: value = STRING; break;
2162: }
2163:
2164: case '+':
2165: case '-':
2166: case '&':
2167: case '|':
2168: case '<':
2169: case '>':
2170: case '*':
2171: case '/':
2172: case '%':
2173: case '^':
2174: case '!':
2175: case '=':
2176: {
2177: register int c1;
2178:
2179: combine:
2180:
2181: switch (c)
2182: {
2183: case '+':
2184: yylval.code = PLUS_EXPR; break;
2185: case '-':
2186: yylval.code = MINUS_EXPR; break;
2187: case '&':
2188: yylval.code = BIT_AND_EXPR; break;
2189: case '|':
2190: yylval.code = BIT_IOR_EXPR; break;
2191: case '*':
2192: yylval.code = MULT_EXPR; break;
2193: case '/':
2194: yylval.code = TRUNC_DIV_EXPR; break;
2195: case '%':
2196: yylval.code = TRUNC_MOD_EXPR; break;
2197: case '^':
2198: yylval.code = BIT_XOR_EXPR; break;
2199: case LSHIFT:
2200: yylval.code = LSHIFT_EXPR; break;
2201: case RSHIFT:
2202: yylval.code = RSHIFT_EXPR; break;
2203: case '<':
2204: yylval.code = LT_EXPR; break;
2205: case '>':
2206: yylval.code = GT_EXPR; break;
2207: }
2208:
2209: token_buffer[1] = c1 = getc (finput);
2210: token_buffer[2] = 0;
2211:
2212: if (c1 == '=')
2213: {
2214: switch (c)
2215: {
2216: case '<':
2217: value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
2218: case '>':
2219: value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
2220: case '!':
2221: value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
2222: case '=':
2223: value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
2224: }
2225: value = ASSIGN; goto done;
2226: }
2227: else if (c == c1)
2228: switch (c)
2229: {
2230: case '+':
2231: value = PLUSPLUS; goto done;
2232: case '-':
2233: value = MINUSMINUS; goto done;
2234: case '&':
2235: value = ANDAND; goto done;
2236: case '|':
2237: value = OROR; goto done;
2238: case '<':
2239: c = LSHIFT;
2240: goto combine;
2241: case '>':
2242: c = RSHIFT;
2243: goto combine;
2244: }
2245: else if ((c == '-') && (c1 == '>'))
2246: { value = POINTSAT; goto done; }
2247: ungetc (c1, finput);
2248: token_buffer[1] = 0;
2249:
2250: if ((c == '<') || (c == '>'))
2251: value = ARITHCOMPARE;
2252: else value = c;
2253: goto done;
2254: }
2255:
2256: default:
2257: value = c;
2258: }
2259:
2260: done:
2261: yylloc.last_line = lineno;
2262:
2263: return value;
2264: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.