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