![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-spew.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-spew.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Type Analyzer for GNU C++.
2: Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
3: Hacked... nay, bludgeoned... by Mark Eichin ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* This file is the type analyzer for GNU C++. To debug it, define SPEW_DEBUG
23: when compiling cp-parse.c and cp-spew.c. */
24:
25: #include "config.h"
26: #include <stdio.h>
27: #include "input.h"
28: #include "tree.h"
29: #include "cp-lex.h"
30: #ifdef OBJCPLUS
31: #include "obcp-parse.h"
32: #else
33: #include "cp-parse.h"
34: #endif
35: #include "cp-tree.h"
36: #include "flags.h"
37: #include "obstack.h"
38:
39: /* This takes a token stream that hasn't decided much about types and
40: tries to figure out as much as it can, with excessive lookahead and
41: backtracking. */
42:
43: /* fifo of tokens recognized and available to parser. */
44: struct token {
45: /* The values for YYCHAR will fit in a short. */
46: short yychar;
47: short end_of_file;
48: YYSTYPE yylval;
49: };
50:
51: static int do_aggr ();
52: static struct token frob_identifier ();
53: static struct token hack_scope ();
54: static tree hack_ptype ();
55: static tree hack_more_ids ();
56:
57: /* From cp-lex.c: */
58: /* the declaration found for the last IDENTIFIER token read in.
59: yylex must look this up to detect typedefs, which get token type TYPENAME,
60: so it is left around in case the identifier is not a typedef but is
61: used in a context which makes it a reference to a variable. */
62: extern tree lastiddecl; /* let our brains leak out here too */
63: extern int yychar; /* the lookahead symbol */
64: extern YYSTYPE yylval; /* the semantic value of the */
65: /* lookahead symbol */
66: extern int end_of_file;
67:
68: struct obstack token_obstack;
69: int first_token;
70:
71: #ifdef SPEW_DEBUG
72: int spew_debug = 0;
73: static unsigned int yylex_ctr = 0;
74: static int debug_yychar ();
75: #endif
76:
77: static char follows_typename[END_OF_SAVED_INPUT+1];
78: static char follows_identifier[END_OF_SAVED_INPUT+1];
79:
80: /* This is a hack!!! TEMPLATE_TYPE_SEEN_BEFORE_SCOPE consists of the name
81: * of the last template_type parsed in cp-parse.y if it is followed by a
82: * scope operator. It will be reset inside the next invocation of yylex().
83: * This is used for recognizing nested types inside templates.
84: * - [email protected] */
85: tree template_type_seen_before_scope;
86:
87: /* Initialize token_obstack. Called once, from init_lex. */
88: void
89: init_spew ()
90: {
91: static char *chars_following_identifier = ".+-|/%^!?:";
92: short *ps;
93: static short toks_follow_ids[] =
94: { ASSIGN, RANGE, OROR, ANDAND, MIN_MAX, EQCOMPARE,
95: ARITHCOMPARE, LSHIFT, RSHIFT, UNARY, PLUSPLUS, MINUSMINUS, POINTSAT,
96: POINTSAT_STAR, DOT_STAR, CONSTANT, STRING, SIZEOF, ENUM, IF,
97: ELSE, WHILE, DO, FOR, SWITCH, CASE, DEFAULT, BREAK, CONTINUE,
98: RETURN, GOTO, ASM_KEYWORD, GCC_ASM_KEYWORD, TYPEOF, ALIGNOF, HEADOF,
99: CLASSOF, ATTRIBUTE, AGGR, VISSPEC, DELETE, RAISE, RERAISE, TRY, EXCEPT,
100: CATCH, THROW, ANSI_TRY, ANSI_THROW, DYNAMIC_CAST, TYPEID,
101: EXTERN_LANG_STRING, ALL, END_OF_SAVED_INPUT, -1 };
102: static short toks_follow_types[] =
103: { IDENTIFIER, TYPENAME, SCOPED_TYPENAME, SCSPEC, TYPESPEC, TYPE_QUAL,
104: ELLIPSIS, THIS, OPERATOR, TEMPLATE, SCOPE, START_DECLARATOR,
105: TYPENAME_COLON, PAREN_STAR_PAREN, TYPENAME_ELLIPSIS, PTYPENAME,
106: PRE_PARSED_FUNCTION_DECL, PRE_PARSED_CLASS_DECL, -1 };
107:
108: gcc_obstack_init(&token_obstack);
109:
110: /* Initialize the arrays saying what tokens are definitely
111: (or possibly) valid following typenames and identifiers. */
112: while (*chars_following_identifier)
113: follows_identifier[*chars_following_identifier++] = 1;
114: for (ps = toks_follow_ids; *ps != -1; ps++)
115: follows_identifier[*ps] = 1;
116: for (ps = toks_follow_types; *ps != -1; ps++)
117: follows_typename[*ps] = 1;
118: }
119:
120: #ifdef SPEW_DEBUG
121: /* Use functions for debugging... */
122:
123: /* Return the number of tokens available on the fifo. */
124: static int
125: num_tokens ()
126: {
127: return (obstack_object_size(&token_obstack)/sizeof(struct token))
128: - first_token;
129: }
130:
131: /* Fetch the token N down the line from the head of the fifo. */
132: static struct token*
133: nth_token (n)
134: int n;
135: {
136: /* could just have this do slurp_ implicitly, but this way is easier
137: * to debug... */
138: my_friendly_assert (n < num_tokens(), 298);
139: return ((struct token*)obstack_base(&token_obstack))+n+first_token;
140: }
141:
142: /* Add a token to the token fifo. */
143: static void
144: add_token (t)
145: struct token* t;
146: {
147: obstack_grow(&token_obstack,t,sizeof (struct token));
148: }
149:
150: /* Consume the next token out of the fifo. */
151: static void
152: consume_token()
153: {
154: if (num_tokens() == 1)
155: {
156: obstack_free(&token_obstack, obstack_base (&token_obstack));
157: first_token = 0;
158: }
159: else
160: first_token++;
161: }
162:
163: #else
164: /* ...otherwise use macros. */
165:
166: #define num_tokens() \
167: ((obstack_object_size(&token_obstack)/sizeof(struct token)) - first_token)
168:
169: #define nth_token(N) \
170: (((struct token*)obstack_base(&token_obstack))+(N)+first_token)
171:
172: #define add_token(T) obstack_grow(&token_obstack, (T), sizeof (struct token))
173:
174: #define consume_token() \
175: (num_tokens() == 1 \
176: ? (obstack_free (&token_obstack, obstack_base (&token_obstack)), \
177: (first_token = 0)) \
178: : first_token++)
179: #endif
180:
181: /* Pull in enough tokens from real_yylex that the queue is N long. */
182:
183: static void
184: scan_tokens (n)
185: int n;
186: {
187: int i;
188: struct token *tmp;
189:
190: /* We cannot read past certain tokens, so make sure we don't. */
191: i = num_tokens ();
192: if (i > n)
193: return;
194: while (i-- > 0)
195: {
196: tmp = nth_token (i);
197: /* Never read past these characters: they might separate
198: the current input stream from one we save away later. */
199: if (tmp->yychar == '{' || tmp->yychar == ':' || tmp->yychar == ';')
200: goto pad_tokens;
201: }
202:
203: while (num_tokens() <= n)
204: {
205: obstack_blank(&token_obstack,sizeof (struct token));
206: tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
207: tmp->yychar = real_yylex();
208: tmp->end_of_file = end_of_file;
209: tmp->yylval = yylval;
210: end_of_file = 0;
211: if (tmp->yychar == '{'
212: || tmp->yychar == ':'
213: || tmp->yychar == ';')
214: {
215: pad_tokens:
216: while (num_tokens () <= n)
217: {
218: obstack_blank(&token_obstack,sizeof (struct token));
219: tmp = ((struct token *)obstack_next_free (&token_obstack))-1;
220: tmp->yychar = EMPTY;
221: tmp->end_of_file = 0;
222: }
223: }
224: }
225: }
226:
227: /* Create room for N tokens at the front of the fifo. This is used
228: to insert new tokens into the stream ahead of the current token. */
229:
230: static void
231: shift_tokens (n)
232: int n;
233: {
234: if (first_token >= n)
235: first_token -= n;
236: else
237: {
238: int old_token_count = num_tokens ();
239: char *tmp;
240:
241: obstack_blank (&token_obstack, (n-first_token) * sizeof (struct token));
242: if (old_token_count)
243: {
244: tmp = (char *)alloca ((num_tokens () + (n-first_token))
245: * sizeof (struct token));
246: /* This move does not rely on the system being able to handle
247: overlapping moves. */
248: bcopy (nth_token (0), tmp, old_token_count * sizeof (struct token));
249: bcopy (tmp, nth_token (n), old_token_count * sizeof (struct token));
250: }
251: first_token = 0;
252: }
253: }
254:
255: static int
256: probe_obstack (h, obj, nlevels)
257: struct obstack *h;
258: tree obj;
259: unsigned int nlevels;
260: {
261: register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */
262: register struct _obstack_chunk* plp; /* point to previous chunk if any */
263:
264: lp = (h)->chunk;
265: /* We use >= rather than > since the object cannot be exactly at
266: the beginning of the chunk but might be an empty object exactly
267: at the end of an adjacent chunk. */
268: for (; nlevels != 0 && lp != 0 && ((tree)lp >= obj || (tree)lp->limit < obj);
269: nlevels -= 1)
270: {
271: plp = lp->prev;
272: lp = plp;
273: }
274: return nlevels != 0 && lp != 0;
275: }
276:
277: /* from cp-lex.c: */
278: /* Value is 1 if we should try to make the next identifier look like a
279: typename (when it may be a local variable or a class variable).
280: Value is 0 if we treat this name in a default fashion.
281: Value is -1 if we must not see a type name. */
282: extern int looking_for_typename;
283:
284: extern struct obstack *current_obstack, *saveable_obstack;
285:
286: int
287: yylex()
288: {
289: struct token tmp_token;
290: tree trrr;
291:
292: retry:
293: #ifdef SPEW_DEBUG
294: if (spew_debug)
295: {
296: yylex_ctr ++;
297: fprintf(stderr, "\t\t## %d ##",yylex_ctr);
298: }
299: #endif
300:
301: /* This is a kludge for recognizing nested types in templates */
302: if (template_type_seen_before_scope)
303: {
304: shift_tokens (2); /* Sync in hack_more_ids (yes, it's ugly) */
305: nth_token (1)->yychar = SCOPE;
306: yylval.ttype = hack_more_ids (0, template_type_seen_before_scope);
307: template_type_seen_before_scope = 0;
308: if (!yylval.ttype)
309: {
310: /* Sync back again, leaving SCOPE on the token stream, because we
311: * failed to substitute the original SCOPE token with a
312: * SCOPED_TYPENAME. See rule "template_type" in cp-parse.y */
313: consume_token ();
314: }
315: else
316: {
317: yychar = SCOPED_TYPENAME;
318: #ifdef SPEW_DEBUG
319: if (spew_debug)
320: debug_yychar(yychar);
321: #endif
322: return yychar;
323: }
324: }
325:
326: /* if we've got tokens, send them */
327: if (num_tokens())
328: {
329: tmp_token= *nth_token(0);
330:
331: /* TMP_TOKEN.YYLVAL.TTYPE may have been allocated on the wrong obstack.
332: If we don't find it in CURRENT_OBSTACK's current or immediately
333: previous chunk, assume it was and copy it to the current obstack. */
334: if ((tmp_token.yychar == CONSTANT
335: || tmp_token.yychar == STRING)
336: && ! TREE_PERMANENT (tmp_token.yylval.ttype)
337: && ! probe_obstack (current_obstack, tmp_token.yylval.ttype, 2)
338: && ! probe_obstack (saveable_obstack, tmp_token.yylval.ttype, 2))
339: tmp_token.yylval.ttype = copy_node (tmp_token.yylval.ttype);
340: }
341: else
342: {
343: /* if not, grab the next one and think about it */
344: tmp_token.yychar = real_yylex ();
345: tmp_token.yylval = yylval;
346: tmp_token.end_of_file = end_of_file;
347: add_token(&tmp_token);
348: }
349:
350: /* many tokens just need to be returned. At first glance, all we
351: * have to do is send them back up, but some of them are needed to
352: * figure out local context. */
353: switch(tmp_token.yychar)
354: {
355: case EMPTY:
356: /* This is a lexical no-op. */
357: consume_token ();
358: #ifdef SPEW_DEBUG
359: if (spew_debug)
360: debug_yychar (tmp_token.yychar);
361: #endif
362: goto retry;
363:
364: case IDENTIFIER:
365: /* Note: this calls arbitrate_lookup. */
366: trrr = lookup_name (tmp_token.yylval.ttype, -2);
367: if (trrr)
368: {
369: tmp_token.yychar = identifier_type (trrr);
370: switch (tmp_token.yychar)
371: {
372: case TYPENAME:
373: lastiddecl = identifier_typedecl_value (tmp_token.yylval.ttype);
374: if (lastiddecl == NULL_TREE)
375: lastiddecl = trrr;
376: break;
377: case IDENTIFIER:
378: lastiddecl = trrr;
379: break;
380: case PTYPENAME:
381: /* This is for cases like
382: template<class A> X<A>::operator[] ...
383: since "X" is (presumably) a PTYPENAME; we might want to
384: avoid seeing the entire thing as a type name, but X<A>
385: must be one.
386:
387: It might not work right if the thing after the ::
388: can be a typename nested in X<A>, but I don't think the
389: PT code would be up to dealing with that anyways. --KR */
390: if (looking_for_typename == -1)
391: {
392: scan_tokens (2);
393: if (nth_token(1)->yychar == '<')
394: looking_for_typename = 0;
395: }
396: break;
397: default:
398: my_friendly_abort (101);
399: }
400: }
401: else
402: lastiddecl = trrr;
403: /* and fall through to... */
404: case TYPENAME:
405: case PTYPENAME:
406: /* if (new_token) add_token (&tmp_token); */
407: *nth_token(0) = tmp_token;
408: tmp_token = frob_identifier ();
409: if (looking_for_typename < 0)
410: {
411: tmp_token.yychar = IDENTIFIER;
412: lastiddecl = 0;
413: looking_for_typename = 0;
414: }
415: else if (lastiddecl && TREE_CODE (lastiddecl) == TYPE_DECL)
416: {
417: scan_tokens (2);
418: if (nth_token(0)->yychar == IDENTIFIER
419: && nth_token (1)->yychar != SCOPE)
420: looking_for_typename = -1;
421: else
422: looking_for_typename = 0;
423: goto finish_typename_processing;
424: }
425: else
426: looking_for_typename = 0;
427: break;
428:
429: case TYPESPEC:
430: case SCSPEC:
431: consume_token ();
432: finish_typename_processing:
433: /* Now see if we should insert a START_DECLARATOR token.
434: Here are the cases caught:
435:
436: typespec ( * ID ) ( // ptr to function
437: typespec ( & ID ) ( // ref to function
438: typespec ( * ID ) [ // array of pointers
439: typespec ( & ID ) [ // array of references
440:
441: This is a terrible kludge. */
442:
443: scan_tokens (2);
444: if (nth_token (0)->yychar == '('
445: && (nth_token (1)->yychar == '*'
446: || nth_token (1)->yychar == '&'))
447: {
448: scan_tokens (5);
449: if (nth_token (3)->yychar == ')'
450: && (nth_token (4)->yychar == '('
451: || nth_token (4)->yychar == '['
452: || nth_token (4)->yychar == LEFT_RIGHT)
453: && (nth_token (2)->yychar == IDENTIFIER
454: || nth_token (2)->yychar == TYPENAME))
455: {
456: shift_tokens (1);
457: nth_token (0)->yychar = START_DECLARATOR;
458: }
459: }
460: /* Extend to handle:
461:
462: typespec (ID::* qf)( // ptr to member function
463: typespec (ID::* qf)[ // array of ptr to member functions
464:
465: */
466: if (nth_token (0)->yychar == '('
467: && (nth_token (1)->yychar == IDENTIFIER
468: || nth_token (1)->yychar == TYPENAME))
469: {
470: scan_tokens (7);
471: if (nth_token (2)->yychar == SCOPE
472: && nth_token (3)->yychar == '*'
473: && (nth_token (4)->yychar == IDENTIFIER
474: || nth_token (4)->yychar == TYPENAME)
475: && nth_token (5)->yychar == ')'
476: && (nth_token (6)->yychar == '('
477: || nth_token (6)->yychar == '['
478: || nth_token (6)->yychar == LEFT_RIGHT))
479: {
480: shift_tokens (1);
481: nth_token (0)->yychar = START_DECLARATOR;
482: }
483: }
484: break;
485:
486: #if 0
487: case '(':
488: /* Handle casts. We are looking for one of:
489: `( TYPENAME' followed by `)', or
490: `( TYPENAME *' followed by one of `[,*,&,)', or
491: `( TYPENAME &' followed by one of `[,*,&,)', or
492: `( TYPENAME [' followed by `]'. We are punting
493: generality on scanning casts to array types. */
494: scan_tokens (4);
495: if (nth_token (1)->yychar == IDENTIFIER)
496: {
497: tree type = identifier_typedecl_value (nth_token (1)->yylval.ttype);
498: if (type)
499: switch (nth_token (2)->yychar)
500: {
501: default:
502: break;
503: }
504: }
505: break;
506:
507: case SCOPE:
508: /* if (new_token) add_token (&tmp_token); */
509: *nth_token(0) = tmp_token;
510: tmp_token = hack_scope ();
511: break;
512: #endif
513:
514: case AGGR:
515: *nth_token(0) = tmp_token;
516: do_aggr ();
517: /* fall through to output... */
518: case ENUM:
519: /* Set this again, in case we are rescanning. */
520: looking_for_typename = 1;
521: /* fall through... */
522: default:
523: #ifdef SPEW_DEBUG
524: if (spew_debug)
525: debug_yychar(tmp_token.yychar);
526: #endif
527: consume_token();
528: yylval = tmp_token.yylval;
529: yychar = tmp_token.yychar;
530: end_of_file = tmp_token.end_of_file;
531: return tmp_token.yychar;
532: }
533:
534: if (tmp_token.yychar == SCOPED_TYPENAME)
535: {
536: #if 0
537: tree t2 = resolve_scope_to_name (NULL_TREE, tmp_token.yylval.ttype);
538: if (t2 != NULL_TREE)
539: {
540: tmp_token.yylval.ttype = t2;
541: tmp_token.yychar = TYPENAME;
542: }
543: else
544: {
545: /* unwind? */
546: }
547: }
548: else
549: {
550: /* couldn't get here, as is... */
551: #endif
552: tmp_token.yychar = TYPENAME;
553: }
554:
555: yylval = tmp_token.yylval;
556: yychar = tmp_token.yychar;
557: end_of_file = tmp_token.end_of_file;
558: #ifdef SPEW_DEBUG
559: if (spew_debug)
560: debug_yychar(yychar);
561: #endif
562: /* consume_token(); */ /* already eaten by frob_identifier?... */
563: return yychar;
564: }
565:
566: /* token[0] == AGGR (struct/union/enum)
567: * thus, token[1] is either a TYPENAME or a TYPENAME_DEFN
568: * if token[2] == '{' or ':' then it's TYPENAME_DEFN
569: */
570: static int
571: do_aggr ()
572: {
573: int yc1, yc2;
574:
575: scan_tokens (2);
576: yc1 = nth_token (1)->yychar;
577: if (yc1 != TYPENAME && yc1 != IDENTIFIER && yc1 != PTYPENAME)
578: return 0;
579: yc2 = nth_token (2)->yychar;
580: if (yc2 == '{' || yc2 == ':')
581: {
582: switch (yc1)
583: {
584: case TYPENAME:
585: nth_token (1)->yychar = TYPENAME_DEFN;
586: break;
587: case PTYPENAME:
588: nth_token (1)->yychar = PTYPENAME_DEFN;
589: break;
590: case IDENTIFIER:
591: nth_token (1)->yychar = IDENTIFIER_DEFN;
592: break;
593: default:
594: my_friendly_abort (102);
595: }
596: }
597: return 0;
598: }
599:
600: static struct token
601: frob_identifier ()
602: {
603: /* we could have a type, if it is followed by :: (if so, suck it all up); */
604: /* we could have a ptypename; */
605: /* we could have a normal identifier. */
606: tree t1;
607: struct token rt;
608:
609: scan_tokens(1);
610: rt = *nth_token(0);
611:
612: #if 0
613: if (nth_token(1)->yychar == '<')
614: {
615: t1 = hack_ptype(); /* suck up the whole thing */
616: if (t1)
617: {
618: rt.yylval.ttype = t1;
619: rt.yychar = TYPENAME;
620: *nth_token(0) = rt;
621: }
622: /* else fall out bottom */
623: }
624: #endif
625:
626: if (nth_token(1)->yychar == SCOPE)
627: {
628: #if 0
629: t1 = hack_more_ids(0);
630: if (t1 && TREE_CODE(t1) == SCOPE_REF)
631: #else
632: t1 = hack_more_ids(0, nth_token (0)->yylval.ttype);
633: if (t1)
634: #endif
635: {
636: rt.yylval.ttype = t1;
637: rt.yychar = SCOPED_TYPENAME ;
638: return rt;
639: }
640: else
641: {
642: /* deal with types (enums?) in classes... */
643: struct token *tok;
644: tree ta, tb;
645: scan_tokens(3);
646:
647: /* Have to check for a type conversion operator
648: to a nested type. */
649: if (nth_token (2)->yychar == OPERATOR)
650: tok = nth_token (3);
651: else
652: tok = nth_token(2);
653:
654: if (tok->yychar == IDENTIFIER || tok->yychar == TYPENAME)
655: {
656: ta = build_parse_node (SCOPE_REF,
657: nth_token(0)->yylval.ttype,
658: tok->yylval.ttype);
659: tb = resolve_scope_to_name (NULL_TREE, ta);
660:
661: if (tb != NULL_TREE)
662: {
663: if (nth_token (2)->yychar == OPERATOR)
664: {
665: /* Have to keep these tokens around
666: so we can finish parsing the declaration.
667: What do we do for
668:
669: int foo::operator bar::baz ();
670:
671: where bar is a nested class in foo? */
672: nth_token (3)->yychar = TYPENAME;
673: nth_token (3)->yylval.ttype = tb;
674: }
675: else
676: {
677: consume_token (); /* base type */
678: consume_token (); /* SCOPE */
679: consume_token (); /* member type */
680: rt.yychar = TYPENAME;
681: rt.yylval.ttype = tb;
682: rt.end_of_file = tok->end_of_file;
683: return rt;
684: }
685:
686: }
687: }
688: /* else fall out bottom */
689: }
690: }
691:
692: consume_token();
693: return rt;
694: }
695:
696: /* When this function is called, nth_token(0) is the current
697: token we are scanning. This means that the next token we'll
698: scan is nth_token (1). Usually the next token we'll scan
699: is nth_token (0) (and the current token is in [yylval,yychar]). */
700: tree
701: arbitrate_lookup (name, exp_decl, type_decl)
702: tree name, exp_decl, type_decl;
703: {
704: int ch;
705: tree t;
706: char *assume;
707:
708: scan_tokens (3);
709: ch = nth_token (1)->yychar;
710:
711: switch (ch)
712: {
713: case '(':
714: case LEFT_RIGHT:
715: /* If we guessed wrong here, `build_functional_cast' can fix it. */
716: return type_decl;
717:
718: case '=':
719: if (global_bindings_p ())
720: /* Probably a default parameter. */
721: return type_decl;
722: /* Probably not an initialization. */
723: return exp_decl;
724:
725: case '[':
726: /* This needs special help because an expression inside the
727: brackets means nothing. */
728: {
729: int i;
730:
731: for (i = 0; i < 42; i++)
732: {
733: int ith_yychar;
734:
735: scan_tokens (3+i);
736: ith_yychar = nth_token (2+i)->yychar;
737:
738: /* If we hit an undefined identifier, assume
739: the decl in arbitration is its type specifier. */
740: if (ith_yychar == IDENTIFIER
741: && lookup_name (nth_token (2+i)->yylval.ttype, 0) == 0)
742: return type_decl;
743: else if (ith_yychar == ']')
744: {
745: /* There are only a few things we expect after a ']'
746: in a declarator. */
747: i += 1;
748: scan_tokens (4+i);
749: ith_yychar = nth_token (2+i)->yychar;
750:
751: /* These are inconclusive. */
752: if (ith_yychar == LEFT_RIGHT
753: || ith_yychar == '('
754: || ith_yychar == '['
755: || ith_yychar == ',')
756: continue;
757: /* stmt or decl? We'll probably never know. */
758: else if (ith_yychar == ';')
759: goto warn_ambiguous;
760:
761: if (ith_yychar == '=')
762: {
763: if (nth_token (3+i)->yychar == '{')
764: return type_decl;
765: continue;
766: }
767:
768: /* Whatever it is, it looks like we're processing an expr. */
769: return exp_decl;
770: }
771: }
772: goto warn_ambiguous;
773: }
774:
775: case ',':
776: case ';':
777: case '&':
778: case '<':
779: case '*':
780: case ']':
781: case ')':
782: case '>':
783: /* see if the next token looks like it wants to be part
784: of a declaration list or an expression list. */
785: {
786: int i;
787:
788: /* Some heuristics: if we are inside a function definition,
789: prefer the local declaration. */
790: if (! global_bindings_p ())
791: {
792: if (IDENTIFIER_LOCAL_VALUE (name) == exp_decl)
793: return exp_decl;
794: if (IDENTIFIER_LOCAL_VALUE (name) != type_decl
795: && IDENTIFIER_CLASS_VALUE (name) == exp_decl)
796: return exp_decl;
797: }
798: /* If these symbols follow in a list, we know it's a list of
799: expressions. */
800: if (follows_identifier[nth_token (2)->yychar])
801: return exp_decl;
802:
803: /* If we see a id&, or id&) the we are probably in an argument list. */
804: if (ch=='&'
805: && (nth_token (2)->yychar == ',' || nth_token (2)->yychar == ')'))
806: return type_decl;
807:
808: /* Look for the first identifier or other distinguishing token
809: we find in the next several tokens. */
810: for (i = 0; i < 42; i++)
811: {
812: int ith_yychar;
813:
814: scan_tokens (3+i);
815: ith_yychar = nth_token (2+i)->yychar;
816:
817: if (ith_yychar == IDENTIFIER)
818: {
819: tree as_type = lookup_name (nth_token (2+i)->yylval.ttype, 1);
820: if (as_type && TREE_CODE (as_type) != TYPE_DECL)
821: return exp_decl;
822: /* An undeclared identifier or a typename means we're
823: probably looking at a typename. */
824: return type_decl;
825: }
826: else if (ith_yychar == EMPTY
827: || follows_identifier[ith_yychar])
828: return exp_decl;
829: else if (follows_typename[ith_yychar])
830: return type_decl;
831: /* stmt or decl? We'll probably never know. */
832: else if (ith_yychar == ';')
833: goto warn_ambiguous;
834: }
835: goto warn_ambiguous;
836: }
837:
838: default:
839: if (follows_identifier[ch])
840: return exp_decl;
841: if (follows_typename[ch])
842: return type_decl;
843:
844: /* Fall through... */
845: warn_ambiguous:
846: if (ch == '[')
847: {
848: assume = "expression";
849: t = exp_decl;
850: }
851: else
852: {
853: assume = "type";
854: t = type_decl;
855: }
856:
857: warning ("name `%s' could be type or expression; compiler assuming %s",
858: IDENTIFIER_POINTER (DECL_NAME (t)), assume);
859: return t;
860: }
861: }
862:
863: /* now returns decl_node */
864:
865: #if 0
866: static tree
867: hack_ptype()
868: {
869: /* when we get here, we know that [0] is a ptype and [1] is '<'.
870: * now we loop over simple parameters. */
871: struct token this_param;
872: int n = 2;
873: tree tplist = 0;
874: tree tc;
875: scan_tokens(n+1);
876:
877: while((this_param = *nth_token(n)).yychar != '>')
878: {
879: /* if it is a type, add it to the list */
880: tree thistype;
881:
882: switch(this_param.yychar)
883: {
884: case IDENTIFIER:
885: case TYPENAME:
886: case TYPESPEC:
887: break;
888: default:
889: return 0;
890: }
891:
892: thistype = this_param.yylval.ttype;
893: thistype = lookup_name(thistype, 1);
894: thistype = TREE_TYPE (thistype);
895:
896: if (tplist)
897: tplist = chainon (tplist, build_tree_list (NULL_TREE, thistype));
898: else
899: tplist = build_tree_list(NULL_TREE, thistype);
900:
901:
902: /* then suck up the comma */
903: n++;
904: scan_tokens(n+1);
905: this_param = *nth_token(n);
906: if (this_param.yychar == ',')
907: {
908: n++;
909: scan_tokens(n+1);
910: continue;
911: }
912: if (this_param.yychar == '>')
913: break;
914: return 0;
915: }
916:
917: /* once we're done, lookup_template_class -> identifier */
918: tc = lookup_template_class (nth_token(0)->yylval.ttype,tplist);
919: /* then lookup_name on that to get a type, if there is one */
920: tc = lookup_name (tc, 1);
921: if (tc)
922: {
923: int i;
924: /* don't actually eat the trailing '>'... we can replace it! */
925: for (i=0; i<n; i++)
926: consume_token();
927: /* IDENTIFIER_TYPE_VALUE (DECL_NAME (tc)) = */
928: return DECL_NAME (tc);
929: }
930: return NULL_TREE;
931: }
932: #endif
933:
934: #if 0
935: static tree
936: hack_more_ids (n)
937: int n;
938: {
939: /*
940: * The recursion should probably do consume_tokens(), since once we've started
941: * down an IDENTIFIER SCOPE ... chain, we don't need to back-track - we just
942: * get as much as we can, make SCOPE_REF's out of it, and return it.
943: */
944: struct token this_iter, this2_iter;
945: int tmp_y;
946:
947: scan_tokens(n+1);
948: this_iter = *nth_token(n);
949:
950: tmp_y = nth_token(n)->yychar;
951: if (tmp_y == IDENTIFIER || tmp_y == TYPENAME)
952: {
953: scan_tokens(n+2+2);
954: if (nth_token(n+1)->yychar == SCOPE)
955: {
956: if (nth_token(n+1+2)->yychar == SCOPE)
957: {
958: tree hmi;
959:
960: consume_token(); /* last IDENTIFIER (this_iter) */
961: consume_token(); /* last SCOPE */
962: this2_iter = *nth_token(n);
963:
964: hmi = hack_more_ids (n);
965:
966: if (hmi)
967: return build_parse_node (SCOPE_REF, this_iter.yylval.ttype, hmi);
968: consume_token(); /* last IDENTIFIER (this2_iter) */
969: return build_parse_node (SCOPE_REF, this_iter.yylval.ttype,
970: this2_iter.yylval.ttype);
971: }
972: else
973: {
974: /* consume_token(); */ /* last IDENTIFIER */
975: /* leave whatever else we got */
976: /* return this_iter.yylval.ttype; */
977: return NULL_TREE;
978: }
979: }
980: }
981: return NULL_TREE; /* @@ may need to backtrack */
982: }
983: #else
984: /* [email protected] says: I didn't understand how the code above was intended
985: * to work, so I rewrote it (also changed the interface a bit). This code
986: * dives down an IDENTIFIER/TYPENAME SCOPE ... chain as long as the parsed
987: * type prefix constitutes recognizable (by resolve_scope_to_name) types.
988: * Interface changed like this:
989: * 1. Takes an extra argument containing the name of the the type recognized
990: * so far.
991: * 2. Now returns the name of the type instead of a SCOPE_REF. */
992: static tree
993: hack_more_ids(n, outer)
994: int n;
995: tree outer;
996: {
997: int ch;
998: tree type, val;
999:
1000: scan_tokens (n + 2);
1001: if (nth_token (n + 1)->yychar != SCOPE
1002: || ((ch = nth_token (n + 2)->yychar) != IDENTIFIER && ch != TYPENAME))
1003: return NULL_TREE;
1004: val = build_parse_node (SCOPE_REF, outer, nth_token (n + 2)->yylval.ttype);
1005: type = resolve_scope_to_name (NULL_TREE, val);
1006: if (type == NULL_TREE)
1007: return NULL_TREE;
1008: consume_token ();
1009: consume_token ();
1010: val = hack_more_ids (n, type);
1011: if (! val)
1012: consume_token ();
1013: return val ? val : type;
1014: }
1015: #endif
1016:
1017: #if 0
1018: static struct token
1019: hack_scope ()
1020: {
1021: /* we've got a :: - what follows is either a global var or a type. */
1022: /* hmm, template names can be in the global scope too... */
1023: tree t1;
1024: struct token rt;
1025:
1026: scan_tokens(1);
1027: if (nth_token(1)->yychar == IDENTIFIER)
1028: {
1029: /* @@ this is probably not right, but doesn't get hit yet */
1030: t1 = build_parse_node (SCOPE_REF,
1031: NULL_TREE, /* to get "global" scope */
1032: hack_more_ids(0)); /* do some prefetching */
1033: rt.yylval.ttype = t1;
1034: rt.yychar = /*SCOPED_*/TYPENAME;
1035: return rt;
1036: }
1037: else
1038: {
1039: rt = *nth_token(0);
1040: consume_token();
1041: return rt;
1042: }
1043: }
1044: #endif
1045:
1046: /*
1047: * Generations:
1048: *
1049: * PINST: PTYPE { saved_arg_count = arg_count($1) }
1050: * '<' { arg_c = 0; } PARGS '>'
1051: * ;
1052: * PARG: TYPE
1053: * | VALUE
1054: * ;
1055: * (of course the arg counting doesn't work for recursion... Do it right.)
1056: * PARGS: PARG { assert(arg_c == saved_arg_count); }
1057: * | PARG ',' PARGS { arg_c++; }
1058: * ;
1059: * ATYPE: PINST
1060: * | TYPEID
1061: * ;
1062: * TYPE: ATYPE
1063: * | ATYPE { basetype = $1; } '::' TYPEKIDS
1064: * ;
1065: * TYPEKIDS: TYPE { assert ($1 is a member of basetype); }
1066: * | TYPEKIDS { basetype += $1} TYPE { assert( $3 is in basetype ); }
1067: * ;
1068: *
1069: *
1070: * state0: ; ATYPE
1071: * TYPE '<': ac = args($0), base = CALL state1, state3
1072: * TYPE '::': base=$0, state3
1073: * else return TYPE
1074: * state1: ; begin PARGS
1075: * if(ac < list length) punt
1076: * PARG ",": add to list, state1
1077: * PARG ">": add to list, return
1078: * else unravel
1079: * state3: ; begin TYPEKIDS
1080: * TYPE:
1081: */
1082:
1083:
1084: #ifdef SPEW_DEBUG
1085: /* debug_yychar takes a yychar (token number) value and prints its name. */
1086: static int
1087: debug_yychar (yy)
1088: int yy;
1089: {
1090: /* In cp-parse.y: */
1091: extern char *debug_yytranslate ();
1092:
1093: int i;
1094:
1095: if(yy<256) {
1096: fprintf (stderr, "<%d: %c >\n", yy, yy);
1097: return 0;
1098: }
1099: fprintf (stderr, "<%d:%s>\n", yy, debug_yytranslate (yy));
1100: return 1;
1101: }
1102:
1103: #endif
1104:
1105: #ifdef OBJCPLUS
1106: /* Search the lookahead tokens for protocol qualifiers and change them into
1107: ordinary identifiers. */
1108: void
1109: forget_saved_protocol_qualifiers ()
1110: {
1111:
1112: int i;
1113: struct token *tmp;
1114:
1115: i = num_tokens ();
1116: while (i-- > 0)
1117: {
1118: tmp = nth_token (i);
1119: if (tmp->yychar == TYPE_QUAL
1120: && TREE_CODE (tmp->yylval.ttype) == IDENTIFIER_NODE)
1121: {
1122: char *name = IDENTIFIER_POINTER (tmp->yylval.ttype);
1123: if (strcmp (name, "in") == 0
1124: || strcmp (name, "out") == 0
1125: || strcmp (name, "inout") == 0
1126: || strcmp (name, "bycopy") == 0
1127: || strcmp (name, "oneway") == 0)
1128: tmp->yychar = IDENTIFIER;
1129: }
1130: }
1131: }
1132: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.