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