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