![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront|
Return to lex.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/lex.c 1.5.1.1" */
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: lex.c:
11: lexical analyser based on pcc's and cpre's scanners
12: modified to handle classes:
13: new keywords: class
14: public
15: call
16: etc.
17: names are not entered in the symbol table by lex()
18: names can be of arbitrary length
19: error() is used to report errors
20: {} and () must match
21: numeric constants are not converted into internal representation
22: but stored as strings
23:
24: ****************************************************************************/
25:
26: #include "cfront.h"
27: #include "yystype.h"
28: #include "size.h"
29: #include "tqueue.h"
30: #include "template.h"
31:
32: # define CCTRANS(x) x
33:
34: #ifndef NULL
35: #define NULL 0
36: #endif
37:
38: char* strdup(const char* s1)
39: /* string duplication
40: returns pointer to a new string which is the duplicate of string
41: pointed to by s1
42: NULL is returned if new string can't be created
43: */
44: {
45: char * s2;
46:
47: s2 = malloc((unsigned) strlen(s1)+1) ;
48: return(s2==NULL ? NULL : strcpy(s2,s1) );
49: }
50:
51: #define copy_if_need_be(s) ((templp->in_progress || templp->parameters_in_progress) ? strdup(s) : (s))
52:
53: /* lexical actions */
54:
55: #define A_ERR 0 /* illegal character */
56: #define A_LET 1 /* saw a letter */
57: #define A_DIG 2 /* saw a digit */
58: #define A_1C 3 /* return a single character */
59: #define A_STR 4 /* string */
60: #define A_CC 5 /* character constant */
61: #define A_BCD 6 /* GCOS BCD constant */
62: #define A_SL 7 /* saw a / */
63: #define A_DOT 8 /* saw a . */
64: #define A_2C 9 /* possible two character symbol */
65: #define A_WS 10 /* whitespace (not \n) */
66: #define A_NL 11 /* \n */
67: #define A_LC 12 /* { */
68: #define A_RC 13 /* } */
69: #define A_L 14 /* ( */
70: #define A_R 15 /* ) */
71: #define A_EOF 16
72: #define A_ASS 17
73: #define A_LT 18
74: #define A_GT 19 /* > */
75: #define A_ER 20
76: #define A_OR 21
77: #define A_AND 22
78: #define A_MOD 23
79: #define A_NOT 24
80: #define A_MIN 25
81: #define A_MUL 26
82: #define A_PL 27
83: #define A_COL 28 /* : */
84: #define A_SHARP 29 /* # */
85: #define A_DOLL 30 /* $ */
86:
87: /* character classes */
88:
89: # define LEXLET 01
90: # define LEXDIG 02
91: /* no LEXOCT because 8 and 9 used to be octal digits */
92: # define LEXHEX 010
93: # define LEXWS 020
94: # define LEXDOT 040
95:
96: const FIRSTCHUNK = 8*1024-8;
97: const BUFCHUNK = 4*1024-8;
98:
99: /* text buffer */
100: static char inbuf[FIRSTCHUNK/*TBUFSZ*/];
101: static char* txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1];
102: static char* txtstart = 0;
103: static char* txtfree = 0;
104:
105: static struct buf* bufhead;
106: static buf* freebuf;
107: //static bufs;
108:
109: struct buf {
110: buf* next;
111: char chars[BUFCHUNK];
112: // buf() { next=bufhead; bufhead=this; }
113: };
114:
115: new_buf(char c)
116: {
117: //fprintf(stderr,"new_buf %d\n",bufs++);
118: buf* pbuf;
119: if (freebuf) {
120: pbuf = freebuf;
121: freebuf = freebuf->next;
122: }
123: else
124: pbuf = new buf; // allocate and register new chunk
125: pbuf->next = bufhead;
126: bufhead = pbuf;
127:
128: if (BUFCHUNK < txtmax-txtstart) error('l',"lexical token too long");
129:
130: // copy current token:
131: char* p = txtstart;
132: txtstart = txtfree = &pbuf->chars[0];
133: while (p<txtmax) *txtfree++ = *p++;
134: *txtfree++=c;
135: txtmax = &pbuf->chars[BUFCHUNK-1];
136: return 0;
137: }
138:
139:
140: #define pch(c) ((txtmax<=txtfree)?new_buf(c):(*txtfree++=c))
141: #define start_txt() txtstart = txtfree
142: #define del_txt() txtfree = txtstart
143:
144: static int Nfile;// = 1;
145: static char* file_name; // source file names
146:
147: Linkage linkage = linkage_default; // linkage is default C++
148: const LINKMAX = 10;
149: static Linkage lvec[LINKMAX] = { linkage_default };
150: static int lcount = 0;
151:
152: void set_linkage(char* p)
153: {
154: if (p==0 || *p == 0) { // resume previous linkage
155: if (lcount>0) linkage = lvec[--lcount];
156: }
157: else {
158: if (LINKMAX<=++lcount) {
159: error('l',"linkage directive nested too deep");
160: --lcount;
161: } else if (strcmp(p,"C")==0)
162: lvec[lcount] = linkage = linkage_C;
163: else if (strcmp(p,"C++")==0)
164: lvec[lcount] = linkage = linkage_Cplusplus;
165: else {
166: error("%s linkage",p);
167: --lcount;
168: }
169: }
170: }
171:
172: static struct loc tloc;
173: FILE * out_file = stdout;
174: FILE * in_file = stdin;
175: Ptable ktbl;
176: Ptable keyword_table;
177:
178: static int p_level = 0; /* number of unmatched ``(''s */
179: static int b_level = 0; /* number of unmatched ``{''s */
180:
181: # ifdef ibm
182:
183: # define CSMASK 0377
184: # define CSSZ 256
185:
186: # else
187:
188: # define CSMASK 0177
189: # define CSSZ 128
190:
191: # endif
192:
193: static short lxmask[CSSZ+1];
194:
195: int saved = 0; /* putback character, avoid ungetchar */
196: static int lxtitle();
197:
198: // overload rt;
199: inline YYSTYPE rt(char* x) { YYSTYPE y; y.s = x; return y; }
200: inline YYSTYPE rt(int x) { YYSTYPE y; y.t = x; return y; }
201: inline YYSTYPE rt(loc x) { YYSTYPE y; y.l = x; return y; }
202: inline YYSTYPE rt(void* x) { YYSTYPE y; y.pn = Pname(x); return y; }
203:
204: #define get(c) (c=getc(in_file))
205: #define unget(c) ungetc(c,in_file)
206:
207: #define reti(a,b) { addtok(a, rt(b), tloc); return a; }
208: #define retn(a,b) { addtok(a, rt((Pnode)b), tloc); return a; }
209: #define rets(a,b) { addtok(a, rt(b), tloc); return a; }
210: #define retl(a) { addtok(a, rt(tloc), tloc); return a; }
211:
212: // keys[] holds the external form for tokens with fixed representation
213: // illegal tokens and those with variable representation have 0 entries
214: char* keys[MAXTOK+1];
215:
216: static void
217: new_key(char* s, TOK toknum, TOK yyclass)
218: /*
219: make "s" a new keyword with the representation (token) "toknum"
220: "yyclass" is the yacc token (for example new_key("int",INT,TYPE); )
221: "yyclass==0" means yyclass=toknum;
222: */
223: {
224: Pname n = new name(s);
225:
226: keys[(toknum==LOC)?yyclass:toknum] = s;
227: n = new name(s);
228: Pname nn = keyword_table->insert(n,0);
229: // if (Nold) error('i',"keyword %sD twice",s);
230: nn->base = toknum;
231: nn->syn_class = (yyclass) ? yyclass : toknum;
232: delete n;
233: }
234:
235: const int keyword_count = 67;
236: static void
237: ktbl_init()
238: /*
239: enter keywords into keyword table for use by lex()
240: and into keyword representation table used for output
241:
242: ktbl is only for types. We put nothing in it.
243: keyword_table is for user-defined reserved words
244: */
245: {
246: ktbl = new table(KTBLSIZE,0,0);
247: keyword_table = new table(keyword_count,0,0);
248:
249: new_key("asm",ASM,0);
250: new_key("auto",AUTO,TYPE);
251: new_key("break",LOC,BREAK);
252: new_key("case",LOC,CASE);
253: new_key("continue",LOC,CONTINUE);
254: new_key("char",CHAR,TYPE);
255: new_key("do",LOC,DO);
256: new_key("double",DOUBLE,TYPE);
257: new_key("default",LOC,DEFAULT);
258: new_key("enum",ENUM,0);
259: new_key("else",LOC,ELSE);
260: new_key("extern",EXTERN,TYPE);
261: new_key("float",FLOAT,TYPE);
262: new_key("for",LOC,FOR);
263: new_key("goto",LOC,GOTO);
264: new_key("catch",CATCH,CATCH);
265: new_key("try",TRY,TRY);
266: new_key("if",LOC,IF);
267: new_key("int",INT,TYPE);
268: new_key("long",LONG,TYPE);
269: new_key("return",LOC,RETURN);
270: new_key("register",REGISTER,TYPE);
271: new_key("static",STATIC,TYPE);
272: new_key("struct",STRUCT,AGGR);
273: new_key("sizeof",SIZEOF,0);
274: new_key("short",SHORT,TYPE);
275: new_key("switch",LOC,SWITCH);
276: new_key("typedef",TYPEDEF,TYPE);
277: new_key("unsigned",UNSIGNED,TYPE);
278: new_key("union",UNION,AGGR);
279: new_key("void",VOID,TYPE);
280: new_key("while",LOC,WHILE);
281:
282: new_key("class",CLASS,AGGR);
283: new_key("const",CONST,TYPE);
284: new_key("delete",LOC,DELETE);
285: new_key("friend",FRIEND,TYPE);
286: new_key("inline",INLINE,TYPE);
287: new_key("new",NEW,0);
288: new_key("operator",OPERATOR,0);
289: new_key("overload",OVERLOAD,TYPE);
290: new_key("private",PRIVATE,PR);
291: new_key("protected",PROTECTED,PR);
292: new_key("public",PUBLIC,PR);
293: new_key("signed",SIGNED,TYPE);
294: new_key("template",TEMPLATE,0);
295: new_key("this",THIS,0);
296: new_key("virtual",VIRTUAL,TYPE);
297: new_key("volatile",VOLATILE,TYPE);
298:
299: new_key("__statement", STATEMENT, 0) ;
300: new_key("__expression", EXPRESSION, 0) ;
301: new_key("__template_test", TEMPLATE_TEST, 0) ;
302: }
303:
304: loc last_line;
305: loc noloc = { 0, 0 };
306:
307: void loc::putline()
308: {
309: if (file==0 && line==0) return;
310: // fix, Nfile, not MAXFILE; Nfile == MAXFILE*4
311: // if (0<=file && file<MAXFILE) {
312: if ( 0<=file && file <= Nfile ) {
313: char* f = file_name;
314: if (f==0) f = src_file_name;
315: fprintf(out_file,line_format,line,f);
316: last_line = *this;
317: }
318: }
319:
320: void loc::put(FILE* p)
321: {
322: // fix, Nfile, not MAXFILE; Nfile == MAXFILE*4
323: // if (0<=file && file<MAXFILE) {
324: if ( 0<=file && file <= Nfile ) {
325: char* f = file_name;
326: if (f==0) f = src_file_name;
327: fprintf(p,"\"%s\", line %d: ",f,line);
328: }
329: }
330:
331: void lxenter(register char* s, short m)
332: /* enter a mask into lxmask */
333: {
334: register c;
335:
336: while( c= *s++ ) lxmask[c+1] |= m;
337:
338: }
339:
340:
341: void lxget(register c, register m)
342: /*
343: put 'c' back then scan for members of character class 'm'
344: terminate the string read with \0
345: txtfree points to the character position after that \0
346: */
347: {
348: pch(c);
349: while ( (get(c), lxmask[c+1]&m) ) pch(c);
350: unget(c);
351: pch('\0');
352: }
353:
354: struct LXDOPE {
355: short lxch; /* the character */
356: short lxact; /* the action to be performed */
357: TOK lxtok; /* the token number to be returned */
358: } lxdope[] = {
359: #ifdef apollo
360: '@', A_ERR, 0, /* illegal characters go here... */
361: #else
362: '$', A_DOLL, 0,
363: // '$', A_ERR, 0, /* illegal characters go here... */
364: #endif
365: '_', A_LET, 0, /* letters point here */
366: '0', A_DIG, 0, /* digits point here */
367: ' ', A_WS, 0, /* whitespace goes here */
368: '\n', A_NL, 0,
369: '"', A_STR, 0, /* character string */
370: '\'', A_CC, 0, /* ASCII character constant */
371: '`', A_BCD, 0, /* 'foreign' character constant, e.g. BCD */
372: '(', A_L, LP,
373: ')', A_R, RP,
374: '{', A_LC, LC,
375: '}', A_RC, RC,
376: '[', A_1C, LB,
377: ']', A_1C, RB,
378: '*', A_MUL, MUL,
379: '?', A_1C, QUEST,
380: ':', A_COL, COLON,
381: '+', A_PL, PLUS,
382: '-', A_MIN, MINUS,
383: '/', A_SL, DIV,
384: '%', A_MOD, MOD,
385: '&', A_AND, AND,
386: '|', A_OR, OR,
387: '^', A_ER, ER,
388: '!', A_NOT, NOT,
389: '~', A_1C, COMPL,
390: ',', A_1C, CM,
391: ';', A_1C, SM,
392: '.', A_DOT, DOT,
393: '<', A_LT, LT,
394: '>', A_GT, GT,
395: '=', A_ASS, ASSIGN,
396: '#', A_SHARP, 0,
397: EOF, A_EOF, EOFTOK
398: };
399: /* note: EOF is used as sentinel, so must be <=0 and last entry in table */
400:
401: static struct LXDOPE *lxcp[CSSZ+1];
402:
403: void
404: lex_init()
405: {
406: register struct LXDOPE *p;
407: register i;
408: register char *cp;
409: /* set up character classes */
410:
411: /* first clear lexmask */
412: for(i=0; i<=CSSZ; i++) lxmask[i] = 0;
413:
414: #ifdef apollo
415: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$", LEXLET );
416: #else
417: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", LEXLET );
418: #endif
419: lxenter( "0123456789", LEXDIG );
420: lxenter( "0123456789abcdefABCDEF", LEXHEX );
421: /* \013 should become \v someday; \013 is OK for ASCII and EBCDIC */
422: lxenter( " \t\r\b\f\013", LEXWS );
423: lxmask['.'+1] |= LEXDOT;
424:
425: /* make lxcp point to appropriate lxdope entry for each character */
426:
427: /* initialize error entries */
428:
429: for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope;
430:
431: /* make unique entries */
432:
433: for( p=lxdope; ; ++p ) {
434: lxcp[p->lxch+1] = p;
435: if( p->lxch < 0 ) break;
436: }
437:
438: /* handle letters, digits, and whitespace */
439: /* by convention, first, second, and third places */
440:
441: cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
442: while( *cp ) lxcp[*cp++ + 1] = &lxdope[1];
443: cp = "123456789";
444: while( *cp ) lxcp[*cp++ + 1] = &lxdope[2];
445: cp = "\t\b\r\f\013";
446: while( *cp ) lxcp[*cp++ + 1] = &lxdope[3];
447:
448: file_name = src_file_name;
449: // set both curloc and tloc so curloc is valid at program startup
450: // curloc.file = tloc.file = 0;
451: curloc.line = tloc.line = 1;
452:
453: ktbl_init();
454: lex_clear();
455: saved = lxtitle();
456: }
457:
458: void lex_clear()
459: {
460: // delete extra buffers:
461: buf* p = bufhead;
462: bufhead = 0;
463: //if (p) {
464: //fprintf(stderr,"lex_clear\n");
465: //bufs=0;
466: //}
467: while (p) {
468: buf* pp = p;
469: p = p->next;
470: pp->next = freebuf;
471: freebuf = pp;
472: }
473:
474: // re-set to static buffer:
475: txtstart = txtfree = inbuf;
476: txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1];
477: }
478:
479: int int_val(char hex)
480: {
481: switch (hex) {
482: case '0': case '1': case '2': case '3': case '4':
483: case '5': case '6': case '7': case '8': case '9':
484: return hex-'0';
485: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
486: return hex-'a'+10;
487: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
488: return hex-'A'+10;
489: }
490: }
491:
492: void hex_to_oct()
493: /*
494: \x has been seen on input (in char const or string) and \ printed
495: read the following hexadecimal integer and replace it with an octal
496: */
497: {
498: int i = 0;
499: int c;
500: get(c);
501: if (lxmask[c+1] & LEXHEX) {
502: i = int_val(c);
503: get(c); // try for two
504: if (lxmask[c+1] & LEXHEX) {
505: i = (i<<4) + int_val(c);
506: get(c); // try for three
507: if (lxmask[c+1] & LEXHEX)
508: i = (i<<4) + int_val(c);
509: else
510: unget(c);
511: }
512: else
513: unget(c);
514: }
515: else {
516: error("hexadecimal digitE after \\x");
517: unget(c);
518: }
519:
520: // if (0377 < i) error('l',"hexadecimal constant too large");
521: i &= 0377;
522:
523: pch(('0'+(i>>6)));
524: pch(('0'+((i&070)>>3)));
525: pch(('0'+(i&7)));
526: }
527:
528:
529: char * chconst()
530: /*
531: read a character constant into inbuf
532: */
533: {
534: register c;
535: int nch = 0;
536:
537: pch('\'');
538:
539: for(;;) {
540: char* p;
541: char cc = 0;
542:
543: switch (get(c)) {
544: case '\'':
545: goto ex;
546: case EOF:
547: error("eof in char constant");
548: goto ex;
549: case '\n':
550: error("newline in char constant");
551: goto ex;
552: case '\\':
553: if (SZ_INT == nch++) error('l',"char constant too long");
554: pch(c);
555: switch (get(c)){
556: case '\n':
557: ++tloc.line;
558: default:
559: pch(c);
560: break;
561: case '4': case '5': case '6': case '7': // octal
562: p = txtfree;
563: cc = c-4;
564: case '0': case '1': case '2': case '3':
565: pch(c);
566: get(c); /* try for 2 */
567: if( lxmask[c+1] & LEXDIG && c<'8'){
568: pch(c);
569: get(c); /* try for 3 */
570: if (lxmask[c+1] & LEXDIG && c<'8') {
571: if (cc) *p = cc; // zap high bit
572: pch(c);
573: }
574: else
575: unget(c);
576: }
577: else
578: unget(c);
579: break;
580: case 'x': // hexadecimal
581: hex_to_oct();
582: break;
583: };
584: break;
585: default:
586: if (SZ_INT == nch++) error('l',"char constant too long");
587: pch(c);
588: }
589: }
590: ex:
591: if(nch==0)
592: error("empty char constant");
593: pch('\'');
594: pch('\0');
595: return txtstart;
596: }
597:
598: void lxcom()
599: /* process a "block comment" */
600: {
601: register c;
602:
603: for(;;)
604: switch (get(c)) {
605: case EOF:
606: error('w',"eof in comment");
607: return;
608: case '\n':
609: tloc.line++;
610: // Nline++;
611: break;
612: case '*':
613: if (get(c) == '/') return;
614: unget(c);
615: break;
616: case '/':
617: if (get(c) == '*') error('w',"``/*'' in comment");
618: unget(c);
619: break;
620: }
621: }
622:
623:
624: void linecom()
625: // process a "line comment"
626: {
627: register c;
628:
629: get(c);
630: #ifdef DBG
631: if ( c=='@' && get(c)=='!' ) {
632: while ( get(c) != '\n' && c != EOF ) pch(c);
633: pch('\0');
634: process_debug_flags(txtstart);
635: del_txt();
636: }
637: #endif
638: for(;;get(c))
639: switch (c) {
640: case EOF:
641: error('w',"eof in comment");
642: return;
643: case '\n':
644: tloc.line++;
645: // Nline++;
646: saved = lxtitle();
647: return;
648: }
649: }
650:
651: char eat_whitespace()
652: {
653:
654: for(;;) {
655: register c = get(c);
656: lx:
657:
658: switch (c) {
659: case EOF:
660: error('w',"unexpected comment");
661: return EOF;
662: case '/':
663: switch (get(c)) {
664: case '*':
665: lxcom();
666: break;
667: case '/':
668: linecom();
669: break;
670: default:
671: unget(c);
672: return '/';
673: }
674: break;
675: case '\n':
676: ++tloc.line;
677: c = lxtitle();
678: goto lx;
679: case ' ':
680: case '\t':
681: break;
682: default:
683: return c;
684: }
685: }
686: }
687:
688: void get_string()
689: {
690: int lxchar;
691:
692: for(;;)
693: switch (get(lxchar)) {
694: case '\\':
695: pch('\\');
696: switch (get(lxchar)){
697: case '\n':
698: ++tloc.line;
699: default:
700: pch(lxchar);
701: break;
702: case 'x': // hexadecimal
703: hex_to_oct();
704: break;
705: };
706: break;
707: case '"':
708: { char* p = txtstart; // eat_whitespace() moves txtstart
709: if ((lxchar = eat_whitespace()) == '"') {
710: // string catenation, break with
711: // newline to avoid merging characters
712: // (e.g. "\xAB" "C")
713: pch('\\');
714: pch('\n');
715:
716: continue; // eat '\"' and carry on
717: };
718:
719: txtstart = p;
720: unget(lxchar);
721: pch(0);
722: return;
723: }
724: case '\n':
725: error("newline in string");
726: pch(0);
727: return;
728: case EOF:
729: error("eof in string");
730: pch(0);
731: return;
732: default:
733: pch(lxchar);
734: }
735: }
736:
737: TOK tlex()
738: {
739: TOK ret;
740: Pname n;
741:
742: // Ntoken++;
743:
744: for(;;) {
745: register lxchar;
746: register struct LXDOPE *p;
747:
748: start_txt();
749:
750: if (saved) {
751: lxchar = saved;
752: saved = 0;
753: }
754: else
755: get(lxchar);
756:
757: if (lxchar+1 >= CSSZ )
758: error( "illegal input character encountered: %d", lxchar );
759:
760: switch( (p=lxcp[lxchar+1])->lxact ){
761:
762: case A_1C: // eat up a single character, and return an opcode
763: reti(p->lxtok,p->lxtok);
764:
765: case A_EOF:
766: if (p_level || b_level+lcount)
767: error("'%s' missing at end of input",(b_level+lcount) ? "}" : ")");
768:
769: reti(EOFTOK,0);
770:
771: case A_SHARP:
772: // cope with header file not ended with '\n'
773: unget('#');
774: saved = lxtitle();
775: continue;
776:
777: case A_ERR:
778: { if (' '<=lxchar && lxchar<='~') // ASCII printable
779: error("illegal character '%c' (ignored)",lxchar);
780: else
781: error("illegal character '0%o' (ignored)",lxchar);
782: continue;
783: }
784:
785: case A_DOLL:
786: { // lex a name of the for $id for template tree formals
787: Pname fn ;
788: lxget( lxchar, LEXLET|LEXDIG ) ;
789:
790: if (!templp->in_progress || !txtstart[1]) {
791: // no name string immediately follows, treat it
792: // like an illegal character
793: error("illegal character '0%o' (ignored)",lxchar);
794: continue;
795: }
796:
797: txtstart++ ;
798: if(fn=templ_compilation::tree_parameter(txtstart)) {
799: switch (fn->n_template_arg) {
800: case template_expr_tree_formal:
801: // retain the $ in the name
802: retn(ID, strdup(--txtstart)) ;
803:
804: case template_stmt_tree_formal:
805: retn(SM_PARAM, fn) ;
806: }
807: }
808: error("%s wasn't a statement or expression formal", txtstart);
809: rets(ID, copy_if_need_be(txtstart));
810: }
811:
812: case A_LET: // collect an identifier and check for keyword
813: {
814: char ll;
815: switch (ll = lxchar) {
816: // case 'l':
817: case 'L':
818: switch (get(lxchar)) {
819: case '\'':
820: error('s',"wide character constant");
821: unget(lxchar);
822: continue;
823: case '"':
824: error('s',"wide character string");
825: unget(lxchar);
826: continue;
827: }
828: unget(lxchar);
829: lxchar = ll;
830: }
831: }
832:
833: lxget( lxchar, LEXLET|LEXDIG );
834: /* look for a keyword or a global type */
835: if ((n = keyword_table->look(txtstart,0)) /* keyword */
836: || (n = ktbl->look(txtstart, 0))) /* local type */
837: {
838: TOK x;
839: del_txt();
840: switch (x=n->base) {
841: case TNAME:
842: rets(ID,n->string);
843: case LOC:
844: retl(n->syn_class);
845: case EXTERN:
846: if ((lxchar = eat_whitespace()) == '\"') {
847: // linkage directive
848: get_string();
849: rets(LINKAGE,txtstart);
850: }
851: unget(lxchar);
852: reti(TYPE,EXTERN);
853: case CATCH:
854: // case TEMPLATE:
855: error('s',"%k",n->syn_class);
856: continue;
857: case TRY:
858: {
859: static int warn_try;
860: if (!warn_try) {
861: Pname n = keyword_table->look("try",0);
862: n->n_key = DEFAULT;
863: error('w',&tloc,"%k is a future reserved keyword",n->syn_class);
864: warn_try++;
865: }
866: rets(ID,n->string);
867: }
868: default:
869: reti(n->syn_class,x);
870: }
871: }
872: // rets(ID,txtstart);
873: rets(ID, copy_if_need_be(txtstart)) ;
874:
875: case A_DIG:
876:
877: ret = ICON;
878:
879: if (lxchar=='0') {
880: int pkchar;
881: get(pkchar);
882: if(pkchar=='x' || pkchar=='X') { // hex
883: pch(lxchar);
884: lxget(pkchar,LEXHEX);
885: txtfree--;
886: if (txtfree-txtstart<3) // minimum "0Xd\0"
887: error("hex digitX after \"0x\"");
888: get(lxchar);
889: goto getsuffix;
890: }
891: unget(pkchar);
892: }
893:
894: lxget(lxchar,LEXDIG);
895: txtfree--;
896:
897: if (get(lxchar) == '.') {
898: getfp:
899: lxget('.', LEXDIG );
900: txtfree--;
901: ret = FCON;
902: get(lxchar);
903: };
904:
905: if (lxchar=='e' || lxchar=='E') {
906: pch(lxchar);
907: get(lxchar);
908: if(lxchar=='-' || lxchar=='+') {
909: pch(lxchar);
910: get(lxchar);
911: }
912: if (lxmask[lxchar+1] & LEXDIG) {
913: lxget( lxchar, LEXDIG );
914: txtfree--;
915: get(lxchar);
916: }
917: else
918: error("missing exponent digits?");
919: ret = FCON;
920: };
921:
922: if(*txtstart=='0' && ret==ICON) {
923: char *bch = txtstart;
924: while (++bch <= txtfree) {
925: if(*bch=='8' || *bch=='9')
926: error("%c used as octal digit",*bch);
927: }
928: }
929:
930: getsuffix:
931: switch (lxchar) {
932: case 'f':
933: case 'F':
934: if (ret==ICON)
935: error("%c suffix for integer constant",lxchar);
936: else
937: pch(lxchar);
938: break;
939: case 'u':
940: case 'U':
941: if (ret==FCON) {
942: error("%c suffix for floating constant",lxchar);
943: break;
944: }
945: pch(lxchar);
946: switch(get(lxchar)) {
947: case 'l':
948: case 'L':
949: pch(lxchar);
950: break;
951: default:
952: saved=lxchar;
953: break;
954: }
955: break;
956: case 'l':
957: case 'L':
958: pch(lxchar);
959: if (ret==FCON) {
960: break;
961: }
962: switch(get(lxchar)) {
963: case 'u':
964: case 'U':
965: pch(lxchar);
966: break;
967: default:
968: saved=lxchar;
969: break;
970: }
971: break;
972: default:
973: saved = lxchar;
974: break;
975: };
976:
977: if(*txtstart=='0' && txtfree-txtstart==1)
978: reti(ZERO,0); // plain zero
979:
980: pch(0);
981: rets(ret,txtstart);
982:
983:
984: case A_DOT:
985: switch (get(lxchar)) {
986: case '.': // look for ellipsis
987: if (get(lxchar) != '.') {
988: error("token .. ?");
989: saved = lxchar;
990: }
991: reti(ELLIPSIS,0);
992: case '*':
993: reti (REFMUL,DOT);
994: }
995:
996: if (lxmask[lxchar+1] & LEXDIG){// look for floating constant
997: unget(lxchar);
998: goto getfp;
999: }
1000: saved = lxchar;
1001: reti(DOT,0);
1002:
1003: case A_STR:
1004: /* save string constant in buffer */
1005: get_string();
1006: rets(STRING,txtstart);
1007:
1008: case A_CC:
1009: /* character constant */
1010: rets(CCON,chconst());
1011:
1012: case A_BCD:
1013: {
1014: register i;
1015: int j;
1016:
1017: pch('`');
1018:
1019: for (i=0; i<7; ++i) {
1020: pch(get(j));
1021: if (j == '`' ) break;
1022: }
1023: pch(0);
1024: if (6<i)
1025: error('l',"bcd constant exceeds 6 characters" );
1026: rets(CCON,txtstart);
1027: }
1028:
1029: case A_SL: /* / */
1030: switch (get(lxchar)) {
1031: case '*':
1032: lxcom();
1033: break;
1034: case '/':
1035: linecom();
1036: break;
1037: case '=':
1038: reti(ASOP,ASDIV);
1039: default:
1040: saved = lxchar;
1041: reti(DIVOP,DIV);
1042: }
1043:
1044: case A_WS:
1045: continue;
1046:
1047: case A_NL:
1048: ++tloc.line;
1049: // Nline++;
1050: saved = lxtitle();
1051: continue;
1052:
1053: case A_LC:
1054: if (BLMAX <= b_level++) {
1055: error('l',"blocks too deeply nested");
1056: ext(3);
1057: }
1058: retl(LC);
1059:
1060: case A_RC:
1061: if (lcount+b_level-- <= 0) {
1062: error("unexpected '}'");
1063: b_level = 0;
1064: }
1065: retl(RC);
1066:
1067: case A_L:
1068: p_level++;
1069: reti(LP,0);
1070:
1071: case A_R:
1072: if (p_level-- <= 0) {
1073: error("unexpected ')'");
1074: p_level = 0;
1075: }
1076: reti(RP,0);
1077:
1078: case A_ASS:
1079: switch (get(lxchar)) {
1080: case '=':
1081: reti(EQUOP,EQ);
1082: default:
1083: saved = lxchar;
1084: reti(ASSIGN,ASSIGN);
1085: }
1086:
1087: case A_COL:
1088: switch (get(lxchar)) {
1089: case ':':
1090: reti(MEM,0);
1091: case '=':
1092: error("':=' is not a c++ operator");
1093: reti(ASSIGN,ASSIGN);
1094: default:
1095: saved = lxchar;
1096: reti(COLON,COLON);
1097: }
1098: case A_NOT:
1099: switch (get(lxchar)) {
1100: case '=':
1101: reti(EQUOP,NE);
1102: default:
1103: saved = lxchar;
1104: reti(NOT,NOT);
1105: }
1106: case A_GT:
1107: switch(get(lxchar)) {
1108: case '>':
1109: switch (get(lxchar)) {
1110: case '=':
1111: reti(ASOP,ASRS);
1112: break;
1113: default:
1114: saved = lxchar;
1115: reti(SHIFTOP,RS);
1116: }
1117: case '=':
1118: reti(RELOP,GE);
1119: default:
1120: saved = lxchar;
1121: reti(GT,GT);
1122: }
1123: case A_LT:
1124: switch (get(lxchar)) {
1125: case '<':
1126: switch (get(lxchar)) {
1127: case '=':
1128: reti(ASOP,ASLS);
1129: default:
1130: saved = lxchar;
1131: reti(SHIFTOP,LS);
1132: }
1133: case '=':
1134: reti(RELOP,LE);
1135: default:
1136: saved = lxchar;
1137: reti(LT,LT);
1138: }
1139: case A_AND:
1140: switch (get(lxchar)) {
1141: case '&':
1142: reti(ANDAND,ANDAND);
1143: case '=':
1144: reti(ASOP,ASAND);
1145: default:
1146: saved = lxchar;
1147: reti(AND,AND);
1148: }
1149: case A_OR:
1150: switch (get(lxchar)) {
1151: case '|':
1152: reti(OROR,OROR);
1153: case '=':
1154: reti(ASOP,ASOR);
1155: default:
1156: saved = lxchar;
1157: reti(OR,OR);
1158: }
1159: case A_ER:
1160: switch (get(lxchar)) {
1161: case '=':
1162: reti(ASOP,ASER);
1163: default:
1164: saved = lxchar;
1165: reti(ER,ER);
1166: }
1167: case A_PL:
1168: switch (get(lxchar)) {
1169: case '=':
1170: reti(ASOP,ASPLUS);
1171: case '+':
1172: reti(ICOP,INCR);
1173: default:
1174: saved = lxchar;
1175: reti(PLUS,PLUS);
1176: }
1177: case A_MIN:
1178: switch (get(lxchar)) {
1179: case '=':
1180: reti(ASOP,ASMINUS);
1181: case '-':
1182: reti(ICOP,DECR);
1183: case '>':
1184: if (get(lxchar) == '*')
1185: {reti(REFMUL,REF);}
1186: else
1187: saved = lxchar;
1188: reti(REF,REF);
1189: default:
1190: saved = lxchar;
1191: reti(MINUS,MINUS);
1192: }
1193: case A_MUL:
1194: switch (get(lxchar)) {
1195: case '=':
1196: reti(ASOP,ASMUL);
1197: case '/':
1198: error('w',"*/ not as end of comment");
1199: default:
1200: saved = lxchar;
1201: reti(MUL,MUL);
1202: }
1203: case A_MOD:
1204: switch (get(lxchar)) {
1205: case '=':
1206: reti(ASOP,ASMOD);
1207: default:
1208: saved = lxchar;
1209: reti(DIVOP,MOD);
1210: }
1211: default:
1212: {error('i',"lex act==%d getc()->%d",p,lxchar);}
1213:
1214: }
1215:
1216: error('i',"lex, main switch");
1217: }
1218:
1219: }
1220:
1221: int lxtitle()
1222: /*
1223: called after a newline; set linenumber and file name
1224: */
1225: {
1226: register c;
1227:
1228: for(;;)
1229: switch ( get(c) ) {
1230: default: // e.g. not '\n', not '#'
1231: return c;
1232: case '\n':
1233: tloc.line++;
1234: // Nline++;
1235: ll:
1236: break;
1237: case '#': /* # lineno "filename" */
1238: { int cl = tloc.line;
1239: tloc.line = 0;
1240: for(;;)
1241: switch (get(c)) {
1242: case '"':
1243: start_txt();
1244: for(;;)
1245: switch (get(c)) {
1246: case '"':
1247: pch('\0');
1248:
1249: while (get(c) != '\n') ; // skip to eol.. ignore anything more
1250:
1251: if (*txtstart) { // stack file name
1252: if (curr_file == 0){
1253: char* p1 = new char[txtfree-txtstart + 1];
1254: (void) strcpy(p1,txtstart);
1255: file_name = p1;
1256: }
1257: else { //&& line is dummy #line "input.c"
1258: // ignore
1259: }
1260: del_txt();
1261: goto ll;
1262: }
1263: case '\n':
1264: error("unexpected end of line on '# line'");
1265: default:
1266: pch(c);
1267: }
1268: case ' ':
1269: break;
1270:
1271: case '0':
1272: case '1':
1273: case '2':
1274: case '3':
1275: case '4':
1276: case '5':
1277: case '6':
1278: case '7':
1279: case '8':
1280: case '9':
1281: tloc.line = tloc.line*10+c-'0';
1282: break;
1283:
1284: case 'l': // look for "#line ..." and then ignore "line"
1285: if (get(c)=='i' && get(c)=='n' && get(c)=='e') break;
1286: case '\n':
1287: tloc.putline();
1288: goto ll;
1289:
1290: default: // pass #rubbish through
1291: tloc.line = cl;
1292: pch('#');
1293: pch(c);
1294: while (get(c) != '\n') pch(c);
1295: pch('\0');
1296: fprintf(out_file,"\n%s\n",txtstart);
1297: start_txt();
1298: tloc.line++;
1299: // Nline++;
1300: goto ll;
1301: }
1302: }
1303: }
1304: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.