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