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