![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lalex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to lalex.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /* -*- Mode:C++ -*- */
2:
3: /*ident "@(#)ctrans:src/lalex.c 1.6.3.21" */
4: /*
5: $Source: /usr3/lang/benson/work/stripped_cfront/RCS/lalex.c,v $ $RCSfile: lalex.c,v $
6: $Revision: 1.2 $ $Date: 90/03/30 20:24:54 $
7: $Author: sam $ $Locker: $
8: $State: Exp $
9:
10:
11: */
12: /**************************************************************************
13:
14: C++ source for cfront, the C++ compiler front-end
15: written in the computer science research center of Bell Labs
16:
17: Copyright (c) 1984 AT&T, Inc. All Rights Reserved
18: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
19:
20: lalex.c:
21:
22: lookahead
23:
24: *****************************************************************************/
25: #include <stdio.h>
26: #include "cfront.h"
27: #include "yystype.h"
28: #include "tqueue.h"
29: #include "template.h"
30:
31: // external functions
32: extern void la_backup( TOK, YYSTYPE );
33: extern int la_decl();
34: extern int la_cast();
35: extern TOK lalex();
36: extern TOK la_look();
37:
38: static int laexpr( TOK );
39: static int latype( TOK );
40:
41: /* make this a toknode! */
42: static int lasttk = 0; // one token history
43: static YYSTYPE lastval; // yylval lasttk value
44:
45: int must_be_expr = 0; // handle redundant parentheses
46: int must_be_id = 0; // !0, TNAME => ID, i.e., int X
47:
48: extern int in_mem_fct;
49: extern int in_class_decl;
50: extern int in_arg_list;
51: extern int DECL_TYPE;
52:
53: toknode* latok; // current lookahead token
54: toknode* front = 0;
55: toknode* rear = 0;
56:
57: static toknode* free_toks = 0;
58: const TQCHUNK = 16;
59:
60: toknode::toknode(TOK t, YYSTYPE r)
61: {
62: if (free_toks == 0) {
63: // extern char* calloc(unsigned,unsigned);
64: register toknode* q;
65: int sz = sizeof( toknode );
66: free_toks = q = (toknode*)calloc( TQCHUNK, sz );
67: for (; q != &free_toks[TQCHUNK-1]; q->next = q+1, ++q);
68: }
69: this = free_toks; free_toks = free_toks->next;
70: tok = t;
71: retval = r;
72: next = last = 0;
73: }
74:
75: toknode::~toknode()
76: {
77: next = free_toks;
78: free_toks = this;
79: this = 0;
80: }
81:
82: void addtok(TOK t, YYSTYPE r)
83: {
84: toknode* T = new toknode(t,r);
85: if (front == 0)
86: front = rear = T;
87: else {
88: rear->next = T;
89: T->last = rear;
90: rear = T;
91: }
92: }
93:
94: extern TOK
95: deltok( int noset = 0 )
96: {
97: register toknode* T = front;
98: register TOK tk = T->tok;
99: if ( !noset ) yylval = T->retval;
100: if (front = front->next)
101: front->last = 0;
102: else
103: latok = rear = 0;
104: delete T;
105: return tk;
106: }
107:
108: static void
109: add_tokens()
110: /*
111: extend lookahead token queue when depleted
112: */
113: {
114: TOK tk = tlex();
115: if ( tk != ID )
116: return;
117:
118: while (tk == ID || tk == MEM || tk == DOT )
119: tk = tlex();
120: }
121:
122: extern TOK
123: la_look()
124: /*
125: peek at head of token queue
126: */
127: {
128: if ( front == 0 )
129: add_tokens();
130:
131: latok = front;
132: return latok->tok;
133: }
134:
135: static int
136: latype( TOK t )
137: {
138: switch ( t ) {
139: default: // includes friend, typedef, storage classes, etc.
140: return 0;
141: case CHAR: case SHORT: case INT: case LONG:
142: case FLOAT: case DOUBLE:
143: case UNSIGNED:
144: return 1;
145: }
146: }
147:
148: static int
149: laexpr( TOK t )
150: {
151: switch ( t ) {
152: default:
153: return 0;
154: case RETURN: case NEW: case AND: case ANDAND: case OR: case OROR:
155: case SIZEOF: case NOT: case COMPL: case MUL: case PLUS: case MINUS:
156: case ER: case ASSIGN: case ASOP: case RELOP: case EQUOP: case DIVOP:
157: case SHIFTOP: case ICOP:
158: return 1;
159: }
160: }
161:
162:
163: static toknode *get_next_token(toknode *t)
164: {
165: if (! t->next)
166: add_tokens() ;
167:
168: return t->next ;
169: }
170:
171:
172: // provide the looakhead for determining TSCOPE tokens when the name is a
173: // parametrized type name; the lookahead here is non-trivial, because it
174: // involves stepping over the template arguments.
175: static int template_tscope(Pname tn, toknode *lt) {
176: int nest = 0 ; // the LT has been fetched
177:
178: if (lt->tok != LT) error ('i', "a LT token was expected") ;
179:
180: // assume the worst, ensure that name strings are consed in the heap
181: templp->parameters_in_progress++ ;
182:
183: for (toknode *t = lt;; t = get_next_token(t))
184: switch (t->tok) {
185:
186: case LT:
187: nest ++ ;
188: continue ;
189:
190: case GT:
191: if (--nest == 0) {
192: t = get_next_token(t) ;
193: if (t->tok == MEM) {
194: // determine whether it is a memptr
195: if (t->next == 0)
196: add_tokens() ;
197: if (t->next->tok == MUL) {
198: t->tok = MEMPTR ;
199: t->next = t->next->next ;
200: }else t->tok = TSCOPE ;
201:
202: t->retval.pn = tn ;
203: templp->parameters_in_progress-- ;
204: return 1 ;
205: } else return 0 ;
206: }
207: continue ;
208:
209: case SM: case LC: case RC: // a quick exit in case of error
210: case EOFTOK:
211: templp->parameters_in_progress-- ;
212: return 0 ;
213:
214: default:
215: continue ;
216: }
217: }
218:
219:
220: static TOK
221: lookahead()
222: /*
223: advance lookahead pointer, lexing at end of Q
224: handle occurrences of TNAME and TSCOPE
225: (should be kept up to date with lalex())
226: */
227: {
228: TOK tk;
229: TOK prev_tk = 0;
230: YYSTYPE lastval;
231:
232: if ( latok == rear ) {
233: add_tokens();
234: if ( latok )
235: latok = latok->next;
236: else
237: latok = front;
238: }
239: else
240: latok = latok->next;
241:
242: if ( latok->last ) {
243: prev_tk = latok->last->tok;
244: lastval = latok->last->retval;
245: }
246:
247: nexttok:
248: tk = latok->tok;
249: if ( tk == ID || tk == TNAME )
250: {
251: if (latok->next == 0) add_tokens();
252: TOK tk2 = latok->next->tok;
253: if ( tk == TNAME ) {
254: if (tk2 == LT) {
255: // a parametrized type name
256: if (template_tscope(latok->retval.pn, latok->next))
257: // differentiate it from a TNAME, so that it can be dealt with
258: // in the grammar.
259: tk = PTNAME ;
260: }else if ( tk2 == MEM || tk2 == DOT ) {
261: tk = TSCOPE;
262: latok = latok->next;
263: if (latok->next == 0) add_tokens();
264: tk2 = latok->next->tok;
265: if ( tk2 == MUL )
266: {
267: tk = MEMPTR;
268: latok = latok->next;
269: }
270: }
271: else if (( prev_tk == MUL && tk2 != RP )
272: || prev_tk == AND )
273: {
274: tk = ID;
275: latok->retval.pn->hide();
276: latok->tok = ID;
277: latok->retval.s = latok->retval.pn->string;
278: }
279: }
280: else if ( tk2 == MEM ) {
281: // ID ::
282: latok = latok->next->next;
283: goto nexttok;
284: }
285:
286: if ( tk == ID &&
287: ( tk2 == ID ||
288: ( prev_tk == ID && ( tk2 == COLON || tk2 == LC )))) {
289: // ID ID
290: latok = latok->next;
291: goto nexttok;
292: }
293: }
294:
295: return tk;
296: }
297:
298: extern Ptype in_typedef;
299: extern Pname statStat;
300: static Pname mem_sel = 0;
301:
302: extern TOK
303: lalex()
304: /* return next token to grammar */
305: {
306: register TOK tk;
307: if ( front == 0 )
308: add_tokens(); // extend lookahead queue
309:
310: gettok:
311: tk = deltok();
312:
313: if ( tk == ID || tk == TNAME )
314: {
315: TOK tk2 = la_look();
316: extern int bl_level;
317: int lex_level = bl_level - in_class_decl - (tk2 == LC );
318:
319: if ( tk == TNAME )
320: {
321: // error('d', "lalex %n lasttk: %k tk2: %k must_be_id: %d", yylval.pn, lasttk, tk2, must_be_id );
322: if ( tk2 == LP
323: && (bl_level == 0 || in_class_decl )
324: && ( laexpr(lasttk) == 0 )
325: && must_be_expr == 0
326: && DECL_TYPE == 0 ) {
327: if (la_decl()) {
328: must_be_id = 0;
329: DECL_TYPE = tk;
330: tk = DECL_MARKER;
331: goto ret;
332: }
333: }
334:
335: if ( lasttk == AGGR || lasttk == ENUM ) {
336: if ( in_typedef == 0 ) {
337: TOK type_tk = yylval.pn->tp->base==COBJ
338: ? AGGR
339: : (yylval.pn->tp->base==EOBJ?ENUM:TYPEDEF);
340: if ( lasttk != type_tk )
341: error( "%nredefined: %k and %k", yylval.pn, type_tk, lasttk );
342: }
343:
344:
345: if ( lex_level && (tk2 == LC || tk2 == COLON)
346: // temporary
347: && lasttk != ENUM ) {
348: Pname bn = Pbase(yylval.pn->tp)->b_name;
349: Pclass cl = Pclass(bn->tp);
350: if ( yylval.pn->lex_level != lex_level || cl->lcl ) {
351: extern void local_hide( Pname ); // place in cfront.h
352: extern Plist local_blk; // place in cfront.h
353: local_hide( yylval.pn );
354: Pname n = new name( yylval.pn->string );
355: n->lex_level = lex_level>=0?lex_level:0;
356: n = n->tname( lastval.t );
357: modified_tn = modified_tn->l;
358: n->n_key = LOCAL;
359: local_class = new name_list( n, local_class );
360: local_blk = new name_list( n, local_blk );
361: yylval.pn = n;
362: }
363: // catch redefinition of local classes
364: else if ( lex_level == yylval.pn->lex_level && cl->defined )
365: error( "localC%nredefined", yylval.pn );
366: }
367: } // end: if (lasttk == AGGR or ENUM )
368:
369: if (tk2 == LT) {
370: // a parametrized type name
371: if (template_tscope(yylval.pn,latok))
372: // differentiate it from a TNAME, so that it can be dealt with
373: // in the grammar.
374: tk = PTNAME ;
375: }else if ( tk2 == MEM || (tk2 == DOT && mem_sel == 0 )) {
376: if (tk2==DOT)
377: error('w',"``.'' used for qualification, please use ``::''");
378: tk = TSCOPE;
379: tk2 = deltok(1);
380: tk2 = la_look();
381: if ( tk2 == MUL ) {
382: tk = MEMPTR;
383: tk2 = deltok(1);
384: }
385: }
386:
387: // Have a TNAME. Check to be sure.
388: else if ( must_be_id ){
389:
390: if ( in_class_decl
391: && lasttk == TYPE
392: && tk2 == LP
393: && strcmp(yylval.pn->string,ccl->string) == 0 )
394: error("%nK with returnT", yylval.pn);
395:
396: else if ( lasttk == TYPE && lastval.t == OVERLOAD
397: && ( tk2 == SM || tk2 == LP ) )
398: {
399: tk = ID;
400: yylval.pn->hide();
401: yylval.pn = new name( yylval.pn->string );
402: yylval.pn->n_oper = TNAME;
403: }
404: else if ( lasttk == OPERATOR )
405: must_be_id = 0;
406: else
407: // watch out for X::X
408: if ( lasttk != TSCOPE
409: || lastval.pn != yylval.pn
410: || ( in_typedef && in_typedef->check( yylval.pn->tp,0) == 0 ))
411: {
412: tk = ID;
413: extern int defer_check;
414: extern Pname in_tag;
415: if ( in_typedef && (lasttk == MUL || lasttk == REF)) {
416: defer_check = 1;
417: in_tag = yylval.pn;
418: }
419:
420: if ( lasttk == MEM && yylval.pn->lex_level ) {
421: Pname nn = gtbl->look( yylval.pn->string, 0 );
422: if (nn == 0 )
423: error( "%k%s undeclared", lasttk, yylval.pn->string);
424: else
425: yylval.pn = nn;
426: }
427: else {
428: // error('d',"lalex: else: lasttk: %k", lasttk );
429: if (lasttk!=DOT && lasttk!=REF && lasttk!=TSCOPE && lasttk !=GOTO) yylval.pn->hide();
430: yylval.pn = new name (yylval.pn->string);
431: if (lasttk!=DOT && lasttk!=REF && lasttk!=TSCOPE && lasttk !=GOTO) yylval.pn->n_oper = TNAME;
432: }
433: if ( defer_check ) defer_check = 0;
434: }
435: } // must_be_id
436:
437: if ((lasttk == SM || lasttk == RC || lasttk == LC)
438: && tk2 == COLON ) { // label
439: tk = ID;
440: yylval.pn = new name (yylval.pn->string);
441: }
442:
443: if ( in_class_decl &&
444: ccl->lex_level &&
445: yylval.pn->lex_level != 0 &&
446: yylval.pn->tp &&
447: (yylval.pn->tp->base != COBJ && yylval.pn->tp->base != EOBJ))
448: {
449: Pname n = gtbl->look( yylval.pn->string,0);
450: // error( 'd', "bl_level: %d in_mem_fct: %d", bl_level, in_mem_fct );
451: if ( in_mem_fct ) {
452: if (n && n->base == TNAME ) {
453: error('w', "local typedef %n(%t) is not in scope of local class %s members; using global (%t)", yylval.pn, yylval.pn->tp, ccl->string, n->tp );
454: yylval.pn = n;
455: }
456: else
457: error( "local typedef %sis not in scope of inline member function of local class %s", yylval.pn->string, ccl->string);
458: }
459: }
460: }
461: else
462: { // tk == ID
463: char *s = yylval.s;
464: Pname n = ktbl->look( s, HIDDEN );
465: //error( 'd', "n: %n, beenhid: %n, in_arg_list: %d", n, beenHid,in_ arg_list );
466: if (tk2 == MEM) {
467: // ID ::
468: if (n) {
469: tk = TSCOPE;
470: tk2 = deltok(1);
471: yylval.pn = n;
472: tk2 = la_look();
473: if ( tk2 == MUL ) {
474: tk = MEMPTR;
475: tk2 = deltok(1);
476: }
477: }
478: else {
479: error( "%s is not aTN", s);
480: tk2 = deltok(1);
481: goto gettok;
482: }
483: }
484: // Have an ID. Check last token to be sure.
485: else if (lasttk==ENUM ||
486: (lasttk==AGGR &&
487: // template <class id, class id>
488: (tk2 != GT) && tk2 != CM)) {
489: tk = TNAME;
490: if ((n==0) ||
491: (n->n_template_arg == name::template_type_formal))
492: { // new tag, define it
493: n = new name( s );
494: n->lex_level = lex_level>=0?lex_level:0;
495: n = n->tname( lastval.t );
496: modified_tn = modified_tn->l;
497: if (lex_level == 0 ) {
498: if (gtbl->look(n->string,0))
499: // don't know yet if n has ctor(): defer
500: statStat = n;
501: }
502: else if ( lex_level > 0
503: // temporary
504: && lasttk != ENUM ) {
505: n->n_key = LOCAL;
506: local_class = new name_list( n, local_class );
507: extern Plist local_blk; // place in cfront.h
508: local_blk = new name_list( n, local_blk );
509: }
510: }
511: else {
512: if (n->tp->base!=COBJ && n->tp->base!=EOBJ) {
513: error( 'i', "hidden%n:%t",n,n->tp );
514: goto gettok;
515: }
516:
517: if ( tk2 == LC || tk2 == COLON ) {
518: // class declared and hidden but not yet defined
519: // may have ctor defined which invalidates hiding
520: statStat = n;
521: n->n_key = 0; // inside class definition it cannot be hidden
522: }
523: }
524: yylval.pn = n;
525: }
526: else {
527: tk = ID;
528: yylval.pn = new name( s );
529: }
530:
531: if ( tk == ID )
532: {
533: if ( tk2 == ID ) {
534: Pname n = ktbl->look( s, HIDDEN );
535: if ( n ) {
536: // add handling of enum
537: if ( n->tp->base == COBJ )
538: error("%sis hidden: use struct %s%s", s,s,front->retval.s);
539: else if ( n->tp->base == EOBJ )
540: error("%sis hidden: use enum %s%s", s,s,front->retval.s);
541: else error("typedef %sis not visible in this scope", s );
542: }
543: else
544: error("%s%s: %sis not aTN", s,front->retval.s,s);
545: }
546: else
547: if ( tk2 == DOT || tk2 == REF )
548: mem_sel = yylval.pn;
549: else
550: if ( lasttk == TNAME && tk2 == LC )
551: {
552: error("T%s %k: %s is unexpected", s, tk2, s );
553: goto gettok;
554: }
555: }
556:
557: }
558: }
559:
560:
561: if ( tk == TNAME || ( tk == TYPE && latype(yylval.t) )
562: || tk == TSCOPE || tk == MEM
563: || tk == REF || tk == DOT || tk == GOTO
564: || tk == MEMPTR )
565: // TNAME cannot immediately follow a type name,
566: // scope operator, right curly, selection, or goto
567: must_be_id = 1;
568: else
569: must_be_id = 0;
570:
571: if( tk == SM) mem_sel = 0;
572:
573: ret:
574: lasttk = tk ;
575: lastval = yylval;
576: return tk;
577: }
578:
579: extern void
580: la_backup( TOK t, YYSTYPE r )
581: /*
582: called by parser to push token back on front of queue
583: */
584: {
585: if ( t == ID ) r.s = r.pn->string;
586: register toknode* T = new toknode(t,r);
587: if (front) {
588: front->last = T;
589: T->next = front;
590: T->last = 0;
591: front = T;
592: } else
593: front = rear = T;
594: }
595:
596: extern int
597: la_sctype( TOK t ) {
598:
599: if ( t != latok->tok && t != TSCOPE ) error( 'i', "la_sctype, lalex.c" );
600:
601: switch( latok->retval.t ) {
602: case TYPEDEF:
603: case EXTERN:
604: case STATIC:
605: case AUTO:
606: case REGISTER:
607: case OVERLOAD:
608: case INLINE:
609: case FRIEND:
610: case CONST:
611: case VOLATILE:
612: return 1;
613: default:
614: return 0;
615: }
616: }
617:
618: extern int
619: la_cast()
620: /*
621: called in reduction of term_lp to check for ambiguous prefix-style cast
622: if result is 1, caller inserts DECL_MARKER to force reduction of cast
623: */
624: {
625: // yychar already designates TYPE or TNAME
626: // LP must start the lookahead queue!
627: int tk, tk2 = latok->tok;
628:
629: for ( ; ; ) {
630: tk = tk2;
631: tk2 = lookahead();
632:
633: switch( tk ) {
634: case LP:
635: if ( tk2 == MUL || tk2 == AND ||
636: tk2 == TSCOPE || tk2 == MEMPTR )
637: // T ( * ...
638: // T ( C ::* ...
639: continue;
640: else
641: // T ( exp )
642: return 0;
643: case MUL: case AND:
644: //if ( tk2 == SCTYPE )
645: if ( la_sctype( tk2 ) )
646: // T ( * const ...
647: // T ( * volatile ...
648: tk2 = lookahead();
649: continue;
650: case TSCOPE:
651: if ( tk2 == MUL )
652: // T ( C :: * ...
653: continue;
654: else
655: // T ( exp )
656: return 0;
657: case RP: case LB:
658: // T (*)()
659: // T (*[])()
660: return 1;
661: case MEMPTR:
662: if ( tk2 == RP )
663: continue;
664: }
665:
666: return 0;
667: }
668: }
669:
670: extern int
671: la_decl()
672: /*
673: handles ambiguities
674: type (*x) ()
675: type (*x) []
676: at start of arg list / statement
677: return val == 1 if lookahead finds a declaration
678: (used for error messages only)
679: if declaration is "ambiguous" (i.e., can't be recognized with
680: 1-symbol lookahead), insert DECL_MARKER to force reduction
681: of "type"
682: */
683: {
684:
685: // LP must start the lookahead queue!
686: int tk, tk2 = latok->tok;
687: int paren = 0;
688: int ptr = 0;
689:
690: for ( ; ; ) {
691:
692: tk = tk2;
693: tk2 = lookahead();
694:
695: // fprintf(stderr,"\nla_decl:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]);
696: switch( tk ) {
697: case LP:
698: if ( tk2 == MUL || tk2 == AND || tk2 == TSCOPE ) {
699: // T ( * ...
700: ++paren;
701: ptr = 1;
702: continue;
703: } else
704: if ( tk2 == MEMPTR ) {
705: // T ( C ::* ...
706: return 1;
707: } else
708: // possible redundant parens
709: if ( tk2 == ID && lookahead() == RP ) {
710: TOK tp = lookahead();
711: // error( 'd', "tp %k tk: %k tk2: %k", tp, tk, tk2 );
712: // error( 'd', "bl_level: %d, in_class_decl: %d", bl_level,in_class_decl );
713: if ( tp == SM || tp == CM || tp == ASSIGN )
714: {
715: // member initialization list
716: if ( tp != SM && in_arg_list == 0 ) return 1;
717: }
718: else
719: if ( tp == RP && (bl_level-in_class_decl==0))
720: return 1;
721: if ( tp != LP )
722: return 0;
723: latok=latok->last; // restore lookahead
724: ++paren;
725: continue;
726: }
727: else
728: // T ( exp )
729: return 0;
730: case MUL: case AND:
731: //if ( tk2 == SCTYPE )
732: if ( la_sctype( tk2 ))
733: // T ( * const ...
734: // T ( * volatile ...
735: return 1;
736: else {
737: ptr = 0;
738: continue;
739: }
740: case TSCOPE:
741: if ( tk2 == MUL )
742: // T ( C :: * ...
743: return 1;
744: else if ( ptr )
745: // T ( exp )
746: return 0;
747: else if ( tk2 == ID || tk2 == OPERATOR )
748: // T ( * C :: id ...
749: continue;
750: else
751: // error
752: return 0;
753: }
754:
755: break;
756: }
757:
758: if ( tk == RP || tk == LB )
759: // T (*)()
760: // T (*[])()
761: return 1;
762:
763: if ( tk != ID && tk != OPERATOR )
764: // T ( exp )
765: return 0;
766:
767: if ( tk == OPERATOR )
768: switch ( tk2 ) {
769: case PLUS: case MINUS: case MUL: case REFMUL:
770: case AND: case OR: case ER: case SHIFTOP: case EQUOP:
771: case DIVOP: case RELOP: case ANDAND: case OROR:
772: case NOT: case COMPL: case ICOP: case ASSIGN:
773: case ASOP: case NEW: case GNEW: case DELETE:
774: // OPERATOR oper
775: tk2 = lookahead();
776: break;
777: case LP:
778: // OPERATOR ()
779: tk2 = lookahead();
780: if ( tk2 == RP ) {
781: tk2 = lookahead();
782: break;
783: } else
784: return 0;
785: case LB:
786: // OPERATOR []
787: tk2 = lookahead();
788: if ( tk2 == LB ) {
789: tk2 = lookahead();
790: break;
791: } else
792: return 0;
793: default: // illegal operator
794: return 0;
795: }
796:
797: int allow_lp = 1;
798: int allow_rp = 1;
799: for ( ; ; ) {
800: tk = tk2;
801: tk2 = lookahead();
802:
803: // fprintf(stderr,"\nla_decl2:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]);
804: switch( tk ) {
805: case LP:
806: if ( !allow_lp )
807: // T ( * id [ exp ] ( ...
808: return 0;
809:
810: // Current lookahead will be a decl if
811: // the next lookahead is an arg decl
812: if ( tk2 == RP || tk2 == ENUM || tk2==AGGR
813: || tk2==ELLIPSIS || la_sctype( tk2 ))
814: // T ( * id ()
815: // T ( * id ) ()
816: return 1;
817:
818: if ( tk2 == TYPE || tk2 == TNAME ) {
819: // T ( * id ) ( T2 ...
820: if ( lookahead() == LP && !la_decl() )
821: return 0;
822: return 1;
823: }
824:
825: return 0;
826: case LB:
827: if ( tk2 == RB || lookahead() == RB )
828: // T ( * id [] ...
829: return 1;
830: else {
831: // T ( * id [ exp ] ...
832: allow_lp = 0;
833: allow_rp = 1;
834: while ( lookahead() != RB );
835: tk2 = lookahead();
836: continue;
837: }
838: case RP:
839: // error ('d', "rp: allow_rp: %d paren: %d", allow_rp, paren );
840: if ( !allow_rp || !paren )
841: // T ( * id ) )
842: return 0;
843: // permit redundant parentheses
844: else
845: if ( tk2 == SM || tk2 == CM || tk2 == ASSIGN )
846: return 1;
847: else
848: if ( tk2 == RP && (bl_level-in_class_decl == 0))
849: return 1;
850: else
851: {
852: // T ( * id ) ...
853: allow_lp = 1;
854: allow_rp = 0;
855: --paren;
856: continue;
857: }
858: default:
859: return 0;
860: }
861: }
862: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.