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