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