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