![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / ccom / common|
Return to scan.c CVS log | Up to [Research Unix] / researchv8dc / cmd / ccom / common |
1.1 root 1: /* @(#) scan.c: 1.2 2/27/84 */
2:
3: # include "mfile1.h"
4: # include <ctype.h>
5: /* temporarily */
6:
7: /* character-set translation */
8: # ifndef CCTRANS
9: # define CCTRANS(x) (x)
10: # endif
11:
12: int flflag = 0;
13: # ifndef FLOATCVT
14: double atof();
15: # define FLOATCVT(x) atof(x)
16: # endif
17:
18: # ifndef ASMBUF
19: # define ASMBUF 200
20: # endif
21: char asmbuf[ASMBUF];
22: char *asmp;
23: int asm_esc = 0; /* asm escaped used in file */
24: /* lexical actions */
25:
26: # define A_ERR 0 /* illegal character */
27: # define A_LET 1 /* saw a letter */
28: # define A_DIG 2 /* saw a digit */
29: # define A_1C 3 /* return a single character */
30: # define A_STR 4 /* string */
31: # define A_CC 5 /* character constant */
32: # define A_BCD 6 /* GCOS BCD constant */
33: # define A_SL 7 /* saw a / */
34: # define A_DOT 8 /* saw a . */
35: # define A_PL 9 /* + */
36: # define A_MI 10 /* - */
37: # define A_EQ 11 /* = */
38: # define A_NOT 12 /* ! */
39: # define A_LT 13 /* < */
40: # define A_GT 14 /* > */
41: # define A_AND 16 /* & */
42: # define A_OR 17 /* | */
43: # define A_WS 18 /* whitespace (not \n) */
44: # define A_NL 19 /* \n */
45:
46: /* character classes */
47:
48: # define LEXLET 01
49: # define LEXDIG 02
50: # define LEXOCT 04
51: # define LEXHEX 010
52: # define LEXWS 020
53: # define LEXDOT 040
54:
55: /* reserved word actions */
56:
57: # define AR_TY 0 /* type word */
58: # define AR_RW 1 /* simple reserved word */
59: # define AR_CL 2 /* storage class word */
60: # define AR_S 3 /* struct */
61: # define AR_U 4 /* union */
62: # define AR_E 5 /* enum */
63: # define AR_A 6 /* asm */
64:
65: /* text buffer */
66: # define LXTSZ BUFSIZ /* lots of room for FLEXNAMES */
67: char yytext[LXTSZ];
68: char * lxgcp;
69: /* If TRUNCATE is undefined, let -T determine whether symbols are truncated.
70: ** Otherwise, forcibly truncate all names.
71: */
72:
73: static int truncate_flag =
74: #ifndef TRUNCATE
75: 0; /* truncate based on -T (non-zero to truncate */
76: #else
77: 1; /* force all names <= NCHNAM chars */
78: #endif
79:
80: int zflag = 0;
81:
82:
83: /* ARGSUSED */
84: mainp1( argc, argv )
85: int argc;
86: char *argv[];
87: {
88: /* control multiple files */
89:
90: register i;
91: register char *cp;
92: extern int idebug, bdebug, tdebug, edebug, ddebug, xdebug, opdebug;
93: extern int asdebug, nowarn, proflag, bothdebug, syncstdio, Pflag;
94: extern unsigned int maxoffset;
95: int fdef = 0;
96:
97: unsigned int temp = 1;
98: i = 0;
99: do {
100: temp <<= 1;
101: ++i;
102: } while ( temp != 0 );
103: maxoffset = 1 << (i-1);
104:
105: for( i=1; i<argc; ++i ) {
106: if( *(cp=argv[i]) == '-' && *++cp == 'X' ) {
107: while( *++cp ) switch(++syncstdio, *cp) {
108: case 'P': ++Pflag; break;
109: case 'B':
110: ++bothdebug; break;
111: case 'd':
112: ++ddebug; break;
113: case 'i':
114: ++idebug; break;
115: case 'b':
116: ++bdebug; break;
117: case 't':
118: ++tdebug; break;
119: case 'e':
120: ++edebug; break;
121: case 'x':
122: ++xdebug; break;
123: case 'o':
124: ++opdebug; break;
125: case 'p':
126: ++proflag; break;
127: case 's':
128: ++asdebug; --syncstdio; break;
129: case 'w':
130: ++nowarn; --syncstdio; break;
131: case 'z': /* stin file debug info */
132: ++zflag; break;
133: case 'T': /* truncate names */
134: ++truncate_flag; break;
135: default:
136: cerror( "bad option: X%c", *cp );
137: }
138: } else {
139: if( *(argv[i]) != '-' ) switch( fdef++ ) {
140: case 0:
141: close(0);
142: if (open(argv[i], 0) == 0) break;
143: fprintf(stderr, "ccom: can't open %s\n", argv[i]);
144: exit(1);
145:
146: case 1:
147: if (freopen(argv[i], "w", stdout)) break;
148: fprintf(stderr, "ccom: can't open %s\n", argv[i]);
149: exit(1);
150:
151: default:
152: ;
153: }
154: }
155: }
156: if (isatty(1)) ++syncstdio;
157:
158: p2init( argc, argv );
159:
160: for( i=0; i<SYMTSZ; ++i ) stab[i].stype = TNULL;
161:
162: lxinit();
163: tinit();
164: mkdope();
165:
166: /* dimension table initialization */
167:
168: dimtab[NULL] = 0;
169: dimtab[VOID] = 0;
170: dimtab[CHAR] = SZCHAR;
171: dimtab[INT] = SZINT;
172: dimtab[FLOAT] = SZFLOAT;
173: dimtab[DOUBLE] = SZDOUBLE;
174: dimtab[LONG] = SZLONG;
175: dimtab[SHORT] = SZSHORT;
176: dimtab[UCHAR] = SZCHAR;
177: dimtab[USHORT] = SZSHORT;
178: dimtab[UNSIGNED] = SZINT;
179: dimtab[ULONG] = SZLONG;
180: /* starts past any of the above */
181: curdim = 16;
182: reached = 1;
183:
184: yyparse();
185: yyaccpt();
186:
187: # ifdef GDEBUG
188: ejsdb();
189: # endif
190: # ifdef ENDJOB
191: ENDJOB(nerrors?1:0);
192: # endif
193: return(nerrors?1:0);
194:
195: }
196:
197: # ifdef ibm
198:
199: # define CSMASK 0377
200: # define CSSZ 256
201:
202: # else
203:
204: # define CSMASK 0177
205: # define CSSZ 128
206:
207: # endif
208:
209: /*
210: * We buffer the input on a line by line basis
211: * so that we can output the ``C'' source as comments
212: * in the assembly language
213: */
214: int asdebug = 0;
215: static char linebuf[BUFSIZ+1];
216: static char *linecp = &linebuf[0], *endcp = &linebuf[0];
217: #undef ungetc
218: #undef getchar
219:
220: #define getchar() (*linecp ? *linecp++ : eatline() )
221: #define ungetchar() --linecp
222: #define ungetc(c) *--linecp=(c)
223:
224: eatline()
225: {
226: static int savechar; char *index(), *memcpy();
227: register n; register char *cp;
228: if (asdebug) for (*linecp = savechar, n = 0;;) {
229: if ((cp = index(linecp, '\n')) || (cp = endcp-1, n)) {
230: savechar = *++cp;
231: *cp = '\0';
232: spitline(linecp);
233: return *linecp++;
234: }
235: linecp = memcpy(linebuf, linecp, n = endcp - linecp);
236: if ((n = read(0, endcp = linebuf + n, BUFSIZ - n)) <= 0) {
237: *(endcp = linebuf) = '\0';
238: return EOF;
239: }
240: *(endcp += n) = '\0';
241: } else {
242: if ((n = read(0, linebuf, BUFSIZ)) <= 0) {
243: (linecp = linebuf)[0] = 0;
244: return EOF;
245: } else {
246: (linecp = linebuf)[n] = 0;
247: return *linecp++;
248: }
249: }
250: }
251:
252: /*
253: ** add the original C line to the assembler output as comment,
254: ** unless it is empty.
255: */
256: #define MARKERCNT 20 /* how often to spit out line markers */
257: spitline(l)
258: register char *l;
259: {
260: extern int lineno;
261:
262: if( !(lineno%MARKERCNT) )
263: printx( "%s -- line %d %s\n", COMMENTSTR, lineno, ftitle );
264: /* line marker */
265: while( isspace( *l ) )
266: l++;
267: if( *l )
268: printx( "%s %s", COMMENTSTR, l );
269: }
270:
271: short lxmask[CSSZ+1];
272:
273: lxenter( s, m )
274: register char *s;
275: register short m;
276: {
277: /* enter a mask into lxmask */
278: register c;
279:
280: while( c= *s++ ) lxmask[c+1] |= m;
281:
282: }
283:
284:
285: # define lxget(c,m) (lxgcp=yytext,lxmore(c,m))
286:
287: lxmore( c, m )
288: register c, m;
289: {
290: register char *cp;
291:
292: *(cp = lxgcp) = c;
293: while ((c = getchar()), lxmask[c+1]&m) {
294: if( cp < &yytext[LXTSZ-1])
295: *++cp = c;
296: }
297: ungetchar();
298: *(lxgcp = cp+1) = '\0';
299: }
300:
301: struct lxdope
302: {
303: short lxch; /* the character */
304: short lxact; /* the action to be performed */
305: short lxtok; /* the token number to be returned */
306: short lxval; /* the value to be returned */
307: } lxdope[] =
308: {
309: '$', A_ERR, 0, 0, /* illegal characters go here... */
310: '_', A_LET, 0, 0, /* letters point here */
311: '0', A_DIG, 0, 0, /* digits point here */
312: ' ', A_WS, 0, 0, /* whitespace goes here */
313: '\n', A_NL, 0, 0,
314: '"', A_STR, 0, 0, /* character string */
315: '\'', A_CC, 0, 0, /* character constant */
316: '`', A_BCD, 0, 0, /* GCOS BCD constant */
317: '(', A_1C, LP, 0,
318: ')', A_1C, RP, 0,
319: '{', A_1C, LC, 0,
320: '}', A_1C, RC, 0,
321: '[', A_1C, LB, 0,
322: ']', A_1C, RB, 0,
323: '*', A_1C, MUL, MUL,
324: '?', A_1C, QUEST, 0,
325: ':', A_1C, COLON, 0,
326: '+', A_PL, PLUS, PLUS,
327: '-', A_MI, MINUS, MINUS,
328: '/', A_SL, DIVOP, DIV,
329: '%', A_1C, DIVOP, MOD,
330: '&', A_AND, AND, AND,
331: '|', A_OR, OR, OR,
332: '^', A_1C, ER, ER,
333: '!', A_NOT, UNOP, NOT,
334: '~', A_1C, UNOP, COMPL,
335: ',', A_1C, CM, CM,
336: ';', A_1C, SM, 0,
337: '.', A_DOT, STROP, DOT,
338: '<', A_LT, RELOP, LT,
339: '>', A_GT, RELOP, GT,
340: '=', A_EQ, ASSIGN, ASSIGN,
341: -1, A_1C, 0, 0,
342: };
343:
344: struct lxdope *lxcp[CSSZ+1];
345:
346: lxinit()
347: {
348: register struct lxdope *p;
349: register i;
350: register char *cp;
351: /* set up character classes */
352:
353: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", LEXLET );
354: lxenter( "0123456789", LEXDIG );
355: lxenter( "0123456789abcdefABCDEF", LEXHEX );
356: /* \013 should become \v someday; \013 is OK for ASCII and EBCDIC */
357: lxenter( " \t\r\b\f\013", LEXWS );
358: lxenter( "01234567", LEXOCT );
359: lxmask['.'+1] |= LEXDOT;
360: lxhinit();
361:
362: /* make lxcp point to appropriate lxdope entry for each character */
363:
364: /* initialize error entries */
365:
366: for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope;
367:
368: /* make unique entries */
369:
370: for( p=lxdope; ; ++p )
371: {
372: lxcp[p->lxch+1] = p;
373: if( p->lxch < 0 ) break;
374: }
375:
376: /* handle letters, digits, and whitespace */
377: /* by convention, first, second, and third places */
378:
379: cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
380: while( *cp ) lxcp[*cp++ + 1] = &lxdope[1];
381: cp = "123456789";
382: while( *cp ) lxcp[*cp++ + 1] = &lxdope[2];
383: cp = "\t\b\r\f\013";
384: while( *cp ) lxcp[*cp++ + 1] = &lxdope[3];
385:
386: /* first line might have title */
387: lineno = 1;
388: lxtitle();
389:
390: }
391:
392: int lxmatch; /* character to be matched in char or string constant */
393:
394: lxstr(ct)
395: register ct;
396: {
397: /* match a string or character constant, up to lxmatch */
398:
399: register c, val, i = 0;
400:
401: while ((c = getchar()) != lxmatch) {
402: switch( c ) {
403:
404: case EOF:
405: uerror( "lxstr() unexpected EOF" );
406: break;
407:
408: case '\n':
409: uerror( "newline in string or char constant" );
410: ++lineno;
411: break;
412:
413: case '\\':
414: switch (c = getchar()) {
415: case '\n':
416: ++lineno; continue;
417: default:
418: val = c; goto mkcc;
419: case 'n':
420: val = '\n'; goto mkcc;
421: case 'r':
422: val = '\r'; goto mkcc;
423: case 'b':
424: val = '\b'; goto mkcc;
425: case 't':
426: val = '\t'; goto mkcc;
427: case 'f':
428: val = '\f'; goto mkcc;
429: case 'v':
430: val = '\013'; goto mkcc;
431: case '0': case '1': case '2': case '3':
432: case '4': case '5': case '6': case '7':
433: val = c-'0';
434: c = getchar(); /* try for 2 */
435: if (lxmask[c+1] & LEXOCT) {
436: val = (val<<3) | (c-'0');
437: c = getchar(); /* try for 3 */
438: if (lxmask[c+1] & LEXOCT)
439: val = (val<<3) | (c-'0');
440: else
441: ungetchar();
442: } else
443: ungetchar();
444: goto mkcc1;
445: }
446: default:
447: val =c;
448: mkcc:
449: val = CCTRANS(val);
450: mkcc1:
451: if (lxmatch == '\'') {
452: /* it is, after all, a "character" constant */
453: val = ccast((CONSZ)val,CHAR);
454: if (i == 0)
455: lastcon = val;
456: else {
457: # ifdef MAKECC
458: MAKECC( val, i );
459: # else
460: # ifdef RTOLBYTES
461: lastcon <<= SZCHAR;
462: lastcon |= (val&BITMASK(SZCHAR));
463: # else
464: lastcon &= BITMASK(SZCHAR*i);
465: lastcon |= val << (SZCHAR*i);
466: # endif
467: # endif
468: }
469: } else {
470: /* stash the byte into the string */
471: if (strflg) {
472: if (ct==0 || i<ct)
473: putbyte( val );
474: else
475: if( i == ct )
476: werror(
477: "non-null byte ignored in string initializer" );
478: } else
479: bycode( val, i );
480: }
481: ++i;
482: continue;
483: }
484: break;
485: }
486: /* end of string or char constant */
487:
488: if (lxmatch == '"') {
489: if (strflg) { /* end the string */
490: if (ct==0 || i<ct)
491: putbyte( 0 ); /* the null at the end */
492: } else { /* the initializer gets a null byte */
493: bycode( 0, i++ );
494: bycode( -1, i );
495: dimtab[curdim] = i; /* in case of later sizeof ... */
496: }
497: } else { /* end the character constant */
498: if (i == 0)
499: uerror( "empty character constant" );
500: if (i>(SZINT/SZCHAR) || ((pflag||hflag)&&i>1))
501: uerror( "too many characters in character constant" );
502: }
503: }
504:
505: lxcom()
506: {
507: register c;
508: /* saw a /*: process a comment */
509:
510: for (;;) {
511: switch (c = getchar()) {
512:
513: case EOF:
514: uerror( "lxcom() unexpected EOF" );
515: return;
516:
517: case '\n':
518: ++lineno;
519:
520: default:
521: continue;
522:
523: case '*':
524: if( (c = getchar()) == '/' ) return;
525: else ungetchar();
526: continue;
527:
528: }
529: }
530: }
531:
532: #define Return(e) return(yylval.lineno = lineno, (e))
533:
534: yylex()
535: {
536: for(;;)
537: {
538:
539: register lxchar;
540: register struct lxdope *p;
541: register struct symtab *sp;
542: register char *cp;
543: register id;
544:
545: switch( (p = lxcp[(lxchar = getchar())+1])->lxact )
546: {
547:
548: onechar:
549: ungetc( lxchar );
550:
551: case A_1C:
552: /* eat up a single character, and return an opcode */
553:
554: yylval.intval = p->lxval;
555: Return( p->lxtok );
556:
557: case A_ERR:
558: uerror( "illegal character: %03o (octal)", lxchar );
559: break;
560:
561: case A_LET:
562: /* collect an identifier, and check for reserved word */
563: lxget( lxchar, LEXLET|LEXDIG );
564:
565: /* 0 means some kind of low level error, >0 reserved,
566: ** <0 means id
567: */
568: if( (lxchar=lxres()) > 0 ) Return( lxchar );
569: if( lxchar== 0 ) continue;
570:
571: if (truncate_flag )
572: yytext[NCHNAM] = '\0'; /* truncate name */
573: id = lookup( hash(yytext),
574: /* tag name for struct/union/enum */
575: (stwart&TAGNAME)? STAG:
576: /* member name for struct/union */
577: (stwart&(INSTRUCT|INUNION|FUNNYNAME))?SMOS:0 );
578: sp = &stab[id];
579: if( sp->sclass == TYPEDEF && !stwart )
580: {
581: stwart = instruct;
582: yylval.nodep = mkty( sp->stype, sp->dimoff,
583: sp->sizoff );
584: Return( TYPE );
585: }
586: stwart = (stwart&SEENAME) ? instruct : 0;
587: yylval.intval = id;
588: Return( NAME );
589:
590: case A_DIG:
591: /* collect a digit string, then look at last one... */
592: lastcon = 0;
593: lxget( lxchar, LEXDIG );
594: switch( lxchar = getchar() )
595: {
596:
597: case 'x':
598: case 'X':
599: if( yytext[0] != '0' && !yytext[1] )
600: uerror( "illegal hex constant" );
601: lxmore( lxchar, LEXHEX );
602: /* convert the value */
603: {
604: for( cp = yytext+2; *cp; ++cp )
605: {
606: /* this code won't work for all character sets,
607: ** but seems ok for ascii and ebcdic
608: */
609: lastcon <<= 4;
610: if( isdigit( *cp ) )
611: lastcon += *cp-'0';
612: else if( isupper( *cp ) )
613: lastcon += *cp - 'A'+ 10;
614: else
615: lastcon += *cp - 'a'+ 10;
616: }
617: }
618:
619: hexlong:
620: /* hex and octal constants are long if they
621: ** fit within 0177777
622: */
623: if( lastcon & ~0177777L ) yylval.intval = 1;
624: else yylval.intval = 0;
625:
626: goto islong;
627:
628: case '.':
629: lxmore( lxchar, LEXDIG );
630:
631: getfp:
632: if( (lxchar = getchar()) == 'e' || lxchar == 'E' )
633: {
634: /* exponent */
635: case 'e':
636: case 'E':
637: if( (lxchar = getchar()) == '+' ||
638: lxchar == '-' )
639: {
640: *lxgcp++ = 'e';
641: }
642: else
643: {
644: ungetc(lxchar);
645: lxchar = 'e';
646: }
647: lxmore( lxchar, LEXDIG );
648: /* now have the whole thing... */
649: }
650: else
651: {
652: /* no exponent */
653: ungetc( lxchar );
654: }
655: # ifdef NOFLOAT
656: if( !flflag )
657: {
658: flflag = 1;
659: werror( "sorry, no floating point" );
660: }
661: for( cp = yytext; *cp; ++cp )
662: {
663: if( *cp == 'e' || *cp == 'E' ||
664: *cp == '.' )
665: {
666: *cp = '\0';
667: break;
668: }
669: }
670: goto conv10;
671: # else
672: flflag = 1;
673: dcon = FLOATCVT(yytext);
674: Return( FCON );
675: # endif
676:
677: default:
678: ungetc( lxchar );
679: if( yytext[0] == '0' )
680: {
681: /* convert in octal */
682: for( cp = yytext+1; *cp; ++cp )
683: {
684: lastcon <<= 3;
685: lastcon += *cp - '0';
686: }
687: goto hexlong;
688: }
689: else
690: {
691: /* convert in decimal */
692: # ifdef NOFLOAT
693: conv10:
694: # endif
695: for( cp = yytext; *cp; ++cp )
696: {
697: lastcon = lastcon*10 + *cp - '0';
698: }
699: }
700:
701: /* decide if it is long or not (decimal case) */
702:
703: /* if it is positive and fits in 15 bits,
704: ** or negative and and fits in 15 bits
705: ** with an extended sign, it is int;
706: ** otherwise long
707: */
708: /* if there is an l or L following,
709: ** all bets are off...
710: */
711:
712: {
713: register CONSZ v;
714: v = lastcon & ~077777L;
715: if( v == 0 || v == ~077777L )
716: yylval.intval = 0;
717: else yylval.intval = 1;
718: }
719:
720: islong:
721: /* finally, look for trailing L or l */
722: if( (lxchar=getchar()) == 'L' || lxchar == 'l' )
723: yylval.intval = 1;
724: else ungetc( lxchar );
725: Return( ICON );
726: }
727:
728: case A_DOT:
729: /* a dot: if followed by a digit, floating point */
730: lxchar = getchar();
731: if( lxmask[lxchar+1] & LEXDIG )
732: {
733: ungetc(lxchar);
734: lxget( '.', LEXDIG );
735: goto getfp;
736: }
737: stwart = FUNNYNAME;
738: goto onechar;
739:
740: case A_STR:
741: /* string constant */
742: lxmatch = '"';
743: Return( STRING );
744:
745: case A_CC:
746: /* character constant */
747: lxmatch = '\'';
748: lastcon = 0;
749: lxstr(0);
750: yylval.intval = 0;
751: Return( ICON );
752:
753: case A_SL:
754: /* / */
755: if( (lxchar = getchar()) != '*' ) goto onechar;
756: lxcom();
757: case A_WS:
758: continue;
759:
760: case A_NL:
761: ++lineno;
762: lxtitle();
763: continue;
764:
765: case A_NOT:
766: /* ! */
767: if( (lxchar = getchar()) != '=' ) goto onechar;
768: yylval.intval = NE;
769: Return( EQUOP );
770:
771: case A_MI:
772: /* - */
773: if( (lxchar = getchar()) == '-' )
774: {
775: yylval.intval = DECR;
776: Return( INCOP );
777: }
778: if( lxchar != '>' ) goto onechar;
779: stwart = FUNNYNAME;
780: yylval.intval=STREF;
781: Return( STROP );
782:
783: case A_PL:
784: /* + */
785: if( (lxchar = getchar()) != '+' ) goto onechar;
786: yylval.intval = INCR;
787: Return( INCOP );
788:
789: case A_AND:
790: /* & */
791: if( (lxchar = getchar()) != '&' ) goto onechar;
792: Return( yylval.intval = ANDAND );
793:
794: case A_OR:
795: /* | */
796: if( (lxchar = getchar()) != '|' ) goto onechar;
797: Return( yylval.intval = OROR );
798:
799: case A_LT:
800: /* < */
801: if( (lxchar = getchar()) == '<' )
802: {
803: yylval.intval = LS;
804: Return( SHIFTOP );
805: }
806: if( lxchar != '=' ) goto onechar;
807: yylval.intval = LE;
808: Return( RELOP );
809:
810: case A_GT:
811: /* > */
812: if( (lxchar = getchar()) == '>' )
813: {
814: yylval.intval = RS;
815: Return(SHIFTOP );
816: }
817: if( lxchar != '=' ) goto onechar;
818: yylval.intval = GE;
819: Return( RELOP );
820:
821: case A_EQ:
822: /* = */
823: switch( lxchar = getchar() )
824: {
825:
826: case '=':
827: yylval.intval = EQ;
828: Return( EQUOP );
829:
830: default:
831: goto onechar;
832:
833: }
834:
835:
836: default:
837: cerror( "yylex error, character %03o (octal)", lxchar );
838:
839: }
840:
841: /* ordinarily, repeat here... */
842: cerror( "out of switch in yylex" );
843:
844: }
845:
846: }
847:
848: struct lxrdope
849: {
850: /* dope for reserved, in alphabetical order */
851:
852: char *lxrch; /* name of reserved word */
853: short lxhash;
854: short lxract; /* reserved word action */
855: short lxrval; /* value to be returned */
856: } lxrdope[] =
857: {
858: "asm", 0, AR_A, 0,
859: "auto", 0, AR_CL, AUTO,
860: "break", 0, AR_RW, BREAK,
861: "case", 0, AR_RW, CASE,
862: "char", 0, AR_TY, CHAR,
863: "continue", 0, AR_RW, CONTINUE,
864: "default", 0, AR_RW, DEFAULT,
865: "do", 0, AR_RW, DO,
866: "double", 0, AR_TY, DOUBLE,
867: "else", 0, AR_RW, ELSE,
868: "enum", 0, AR_E, ENUM,
869: "extern", 0, AR_CL, EXTERN,
870: #ifdef ONEFLOAT
871: "float", 0, AR_TY, DOUBLE,
872: #else
873: "float", 0, AR_TY, FLOAT,
874: #endif
875: "for", 0, AR_RW, FOR,
876: "fortran", 0, AR_CL, FORTRAN,
877: "goto", 0, AR_RW, GOTO,
878: "if", 0, AR_RW, IF,
879: "int", 0, AR_TY, INT,
880: "long", 0, AR_TY, LONG,
881: "register", 0, AR_CL, REGISTER,
882: "return", 0, AR_RW, RETURN,
883: "short", 0, AR_TY, SHORT,
884: "sizeof", 0, AR_RW, SIZEOF,
885: "static", 0, AR_CL, STATIC,
886: "struct", 0, AR_S, 0,
887: "switch", 0, AR_RW, SWITCH,
888: "typedef", 0, AR_CL, TYPEDEF,
889: "union", 0, AR_U, 0,
890: "unsigned", 0, AR_TY, UNSIGNED,
891: "void", 0, AR_TY, VOID,
892: "while", 0, AR_RW, WHILE,
893: 0, 0, 0, 0,
894: };
895:
896: #define HASH(s) (((lxrch0[(s)[0]&037]<<4) | lxrch2[(s)[2]&037]) & 0377)
897:
898: unsigned char lxrch0[040], lxrch2[040], lxrindx[0400];
899:
900: lxhinit()
901: {
902: register struct lxrdope *lp; struct lxrdope dptemp;
903: register char *s; register j;
904: int k0, k2;
905: for (lp = lxrdope; s = lp->lxrch; ++lp) {
906: ++lxrch0[s[0] & 037];
907: ++lxrch2[s[2] & 037];
908: }
909: for (k0=k2=j=0; j<040; j++) {
910: if (lxrch0[j]) lxrch0[j] = ++k0;
911: if (lxrch2[j]) lxrch2[j] = ++k2;
912: }
913: for (lp = lxrdope; s = lp->lxrch; ++lp)
914: lp->lxhash = HASH(s);
915: do {
916: j = 0;
917: for (lp = lxrdope+1; lp->lxrch; ++lp)
918: if (lp->lxhash < (lp-1)->lxhash) {
919: dptemp = *lp;
920: *lp = *(lp-1);
921: *(lp-1) = dptemp;
922: ++j;
923: }
924: } while (j);
925: for (k0 = 1, lp = lxrdope; s = lp->lxrch; ++lp, ++k0)
926: if (lxrindx[j = lp->lxhash] == 0)
927: lxrindx[j] = k0;
928: /*
929: for (lp = lxrdope; lp->lxrch; ++lp)
930: printf("%d %d %s\n", lxrindx[lp->lxhash], lp->lxhash, lp->lxrch);
931: */
932: }
933:
934: lxres()
935: {
936: /*
937: ** check to see of yytext is reserved; if so,
938: ** do the appropriate action and return
939: ** otherwise, return -1
940: */
941: register c;
942: register struct lxrdope *p;
943:
944: if (yytext[1] == 0) return -1;
945:
946: if ((c = HASH(yytext)) == 0 || (c = lxrindx[c]) == 0) return -1;
947:
948: p = lxrdope + c - 1;
949: do if (strcmp(yytext, p->lxrch) == 0) switch (p->lxract) {
950:
951: case AR_TY: /* type word */
952: stwart = instruct;
953: yylval.nodep = mkty( (TWORD)p->lxrval, 0, p->lxrval );
954: if (p->lxrval==FLOAT || p->lxrval==DOUBLE) {
955: # ifdef NOFLOAT
956: if (!flflag)
957: werror( "sorry, no floating point" );
958: yylval.nodep->tn.type = LONG;
959: # endif
960: flflag = 1;
961: }
962: return( TYPE );
963:
964: case AR_RW: /* ordinary reserved word */
965: return( yylval.intval = p->lxrval );
966:
967: case AR_CL: /* class word */
968: yylval.intval = p->lxrval;
969: return( CLASS );
970:
971: case AR_S: /* struct */
972: stwart = INSTRUCT|SEENAME|TAGNAME;
973: yylval.intval = INSTRUCT;
974: return( STRUCT );
975:
976: case AR_U: /* union */
977: stwart = INUNION|SEENAME|TAGNAME;
978: yylval.intval = INUNION;
979: return( STRUCT );
980:
981: case AR_E: /* enums */
982: stwart = SEENAME|TAGNAME;
983: return( yylval.intval = ENUM );
984:
985: case AR_A: /* asm */
986: asm_esc = 1; /* warn the world! */
987: lxget(' ', LEXWS);
988: if (getchar() != '(') goto badasm;
989: lxget(' ', LEXWS);
990: if (getchar() != '"') goto badasm;
991: asmp = asmbuf;
992: while ((c = getchar()) != '"') {
993: if (c=='\n' || c==EOF) goto badasm;
994: *asmp++ = c;
995: if (asmp >= &asmbuf[ASMBUF-1])
996: uerror( "asm > %d chars", ASMBUF);
997: }
998: lxget(' ', LEXWS);
999: if( getchar() != ')' ) goto badasm;
1000: *asmp++ = '\0';
1001: return( ASM );
1002: badasm:
1003: uerror( "bad asm construction" );
1004: return( 0 );
1005:
1006: default:
1007: cerror("bad AR_?? action");
1008: } while ((++p)->lxhash == c);
1009: return -1;
1010: }
1011:
1012: lxtitle()
1013: {
1014: /* called after a newline; set linenumber and file name */
1015:
1016: register c, val; register char *cp;
1017:
1018: for(;;) { /* might be several such lines in a row */
1019: if ((c = getchar()) != '#') {
1020: if (c != EOF) ungetchar();
1021: return;
1022: }
1023: lxget( ' ', LEXWS);
1024: val = 0;
1025: for (c = getchar(); isdigit(c); c = getchar())
1026: val = val*10+ c - '0';
1027: ungetchar();
1028: lineno = val;
1029: lxget(' ', LEXWS);
1030: if ((c = getchar()) != '\n') {
1031: cp = ftitle; *cp++ = c;
1032: while ((c=getchar()) != '\n')
1033: *cp++ = c;
1034: *cp = '\0';
1035: }
1036: }
1037: }
1038:
1039: # ifndef MYASMOUT
1040: asmout()
1041: {
1042: #ifdef GDEBUG
1043: dbline();
1044: #endif
1045: printx("%s\n%s\n%s\n", ASM_COMMENT, asmbuf, ASM_END);
1046: }
1047: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.