![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / picasso|
Return to y2.c CVS log | Up to [Research Unix] / researchv10no / cmd / picasso |
1.1 root 1: #ident "@(#)/usr/src/cmd/yacc/y2.c 1.3 6/6/85 02:44:35 - Amdahl/UTS"
2: /* @(#)y2.c 1.8 */
3: # include "dextern"
4: # define IDENTIFIER 257
5: # define MARK 258
6: # define TERM 259
7: # define LEFT 260
8: # define RIGHT 261
9: # define BINARY 262
10: # define PREC 263
11: # define LCURLY 264
12: # define C_IDENTIFIER 265 /* name followed by colon */
13: # define NUMBER 266
14: # define START 267
15: # define TYPEDEF 268
16: # define TYPENAME 269
17: # define UNION 270
18: # define ENDFILE 0
19:
20: /* communication variables between various I/O routines */
21:
22: char *infile; /* input file name */
23: int numbval; /* value of an input number */
24: char tokname[NAMESIZE]; /* input token name */
25:
26: /* storage of names */
27:
28: char cnames[CNAMSZ]; /* place where token and nonterminal names are stored */
29: int cnamsz = CNAMSZ; /* size of cnames */
30: char * cnamp = cnames; /* place where next name is to be put in */
31: int ndefout = 3; /* number of defined symbols output */
32:
33: /* storage of types */
34: int ntypes; /* number of types defined */
35: char * typeset[NTYPES]; /* pointers to type tags */
36:
37: /* symbol tables for tokens and nonterminals */
38:
39: int ntokens = 0;
40: struct toksymb tokset[NTERMS];
41: int toklev[NTERMS];
42: int nnonter = -1;
43: struct ntsymb nontrst[NNONTERM];
44: int start; /* start symbol */
45:
46: /* assigned token type values */
47: int extval = 0;
48:
49: /* input and output file descriptors */
50:
51: FILE * finput; /* yacc input file */
52: FILE * faction; /* file for saving actions */
53: FILE * fdefine; /* file for # defines */
54: FILE * ftable; /* y.tab.c file */
55: FILE * ftemp; /* tempfile to pass 2 */
56: FILE * fdebug; /* where the strings for debugging are stored */
57: FILE * foutput; /* y.output file */
58:
59: /* storage for grammar rules */
60:
61: int mem0[MEMSIZE] ; /* production storage */
62: int *mem = mem0;
63: int nprod= 1; /* number of productions */
64: int *prdptr[NPROD]; /* pointers to descriptions of productions */
65: int levprd[NPROD] ; /* precedence levels for the productions */
66: char had_act[NPROD]; /* set to 1 if the reduction has action code to do */
67:
68: int gen_lines = 1; /* flag for generating the # line's default is yes */
69: int gen_testing = 0; /* flag for whether to include runtime debugging */
70:
71: setup(argc,argv) int argc; char *argv[];
72: { int i,j,lev,t, ty;
73: int c;
74: int *p;
75: char actname[8];
76:
77: foutput = NULL;
78: fdefine = NULL;
79: i = 1;
80: while( argc >= 2 && argv[1][0] == '-' ) {
81: while( *++(argv[1]) ){
82: switch( *argv[1] ){
83: case 'v':
84: case 'V':
85: foutput = fopen(FILEU, "w" );
86: if( foutput == NULL ) error( "cannot open y.output" );
87: continue;
88: case 'D':
89: case 'd':
90: fdefine = fopen( FILED, "w" );
91: if ( fdefine == NULL ) error( "cannot open y.tab.h" );
92: continue;
93: case 'l':
94: case 'L':
95: gen_lines = !gen_lines;
96: case 't':
97: case 'T':
98: gen_testing = !gen_testing;
99: continue;
100: case 'o':
101: case 'O':
102: fprintf( stderr, "`o' flag now default in yacc\n" );
103: continue;
104:
105: case 'r':
106: case 'R':
107: error( "Ratfor Yacc is dead: sorry...\n" );
108:
109: default:
110: error( "illegal option: %c", *argv[1]);
111: }
112: }
113: argv++;
114: argc--;
115: }
116:
117: fdebug = fopen( DEBUGNAME, "w" );
118: if ( fdebug == NULL ) error( "cannot open yacc.debug" );
119: ftable = fopen( OFILE, "w" );
120: if( ftable == NULL ) error( "cannot open y.tab.c" );
121:
122: ftemp = fopen( TEMPNAME, "w" );
123: faction = fopen( ACTNAME, "w" );
124: if( ftemp==NULL || faction==NULL ) error( "cannot open temp file" );
125:
126: if( argc < 2 || ((finput=fopen( infile=argv[1], "r" )) == NULL ) ){
127: error( "cannot open input file" );
128: }
129:
130: cnamp = cnames;
131: defin(0,"$end");
132: extval = 0400;
133: defin(0,"error");
134: defin(1,"$accept");
135: mem=mem0;
136: lev = 0;
137: ty = 0;
138: i=0;
139: beg_debug(); /* initialize fdebug file */
140:
141: /* sorry -- no yacc parser here.....
142: we must bootstrap somehow... */
143:
144: for( t=gettok(); t!=MARK && t!= ENDFILE; ){
145: switch( t ){
146:
147: case ';':
148: t = gettok();
149: break;
150:
151: case START:
152: if( (t=gettok()) != IDENTIFIER ){
153: error( "bad %%start construction" );
154: }
155: start = chfind(1,tokname);
156: t = gettok();
157: continue;
158:
159: case TYPEDEF:
160: if( (t=gettok()) != TYPENAME ) error( "bad syntax in %%type" );
161: ty = numbval;
162: for(;;){
163: t = gettok();
164: switch( t ){
165:
166: case IDENTIFIER:
167: if( (t=chfind( 1, tokname ) ) < NTBASE ) {
168: j = TYPE( toklev[t] );
169: if( j!= 0 && j != ty ){
170: error( "type redeclaration of token %s",
171: tokset[t].name );
172: }
173: else SETTYPE( toklev[t],ty);
174: }
175: else {
176: j = nontrst[t-NTBASE].tvalue;
177: if( j != 0 && j != ty ){
178: error( "type redeclaration of nonterminal %s",
179: nontrst[t-NTBASE].name );
180: }
181: else nontrst[t-NTBASE].tvalue = ty;
182: }
183: case ',':
184: continue;
185:
186: case ';':
187: t = gettok();
188: break;
189: default:
190: break;
191: }
192: break;
193: }
194: continue;
195:
196: case UNION:
197: /* copy the union declaration to the output */
198: cpyunion();
199: t = gettok();
200: continue;
201:
202: case LEFT:
203: case BINARY:
204: case RIGHT:
205: ++i;
206: case TERM:
207: lev = t-TERM; /* nonzero means new prec. and assoc. */
208: ty = 0;
209:
210: /* get identifiers so defined */
211:
212: t = gettok();
213: if( t == TYPENAME ){ /* there is a type defined */
214: ty = numbval;
215: t = gettok();
216: }
217:
218: for(;;) {
219: switch( t ){
220:
221: case ',':
222: t = gettok();
223: continue;
224:
225: case ';':
226: break;
227:
228: case IDENTIFIER:
229: j = chfind(0,tokname);
230: if( lev ){
231: if( ASSOC(toklev[j]) ) error( "redeclaration of precedence of %s", tokname );
232: SETASC(toklev[j],lev);
233: SETPLEV(toklev[j],i);
234: }
235: if( ty ){
236: if( TYPE(toklev[j]) ) error( "redeclaration of type of %s", tokname );
237: SETTYPE(toklev[j],ty);
238: }
239: if( (t=gettok()) == NUMBER ){
240: tokset[j].value = numbval;
241: if( j < ndefout && j>2 ){
242: error( "please define type number of %s earlier",
243: tokset[j].name );
244: }
245: t=gettok();
246: }
247: continue;
248:
249: }
250:
251: break;
252: }
253:
254: continue;
255:
256: case LCURLY:
257: defout();
258: cpycode();
259: t = gettok();
260: continue;
261:
262: default:
263: error( "syntax error" );
264:
265: }
266:
267: }
268:
269: if( t == ENDFILE ){
270: error( "unexpected EOF before %%" );
271: }
272:
273: /* t is MARK */
274:
275: defout();
276: end_toks(); /* all tokens dumped - get ready for reductions */
277:
278: fprintf( ftable, "#define yyclearin yychar = -1\n" );
279: fprintf( ftable, "#define yyerrok yyerrflag = 0\n" );
280: fprintf( ftable, "extern int yychar;\nextern int yyerrflag;\n" );
281: fprintf( ftable, "#ifndef YYMAXDEPTH\n#define YYMAXDEPTH 150\n#endif\n" );
282: if( !ntypes ) fprintf( ftable, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n" );
283: fprintf( ftable, "YYSTYPE yylval, yyval;\n" );
284: fprintf( ftable, "typedef int yytabelem;\n" );
285:
286: prdptr[0]=mem;
287: /* added production */
288: *mem++ = NTBASE;
289: *mem++ = start; /* if start is 0, we will overwrite with the lhs of the first rule */
290: *mem++ = 1;
291: *mem++ = 0;
292: prdptr[1]=mem;
293:
294: while( (t=gettok()) == LCURLY ) cpycode();
295:
296: if( t != C_IDENTIFIER ) error( "bad syntax on first rule" );
297:
298: if( !start ) prdptr[0][1] = chfind(1,tokname);
299:
300: /* read rules */
301:
302: while( t!=MARK && t!=ENDFILE ){
303:
304: /* process a rule */
305:
306: if( t == '|' ){
307: rhsfill( (char *) 0 ); /* restart fill of rhs */
308: *mem++ = *prdptr[nprod-1];
309: }
310: else if( t == C_IDENTIFIER ){
311: *mem = chfind(1,tokname);
312: if( *mem < NTBASE ) error( "token illegal on LHS of grammar rule" );
313: ++mem;
314: lhsfill( tokname ); /* new rule: restart strings */
315: }
316: else error( "illegal rule: missing semicolon or | ?" );
317:
318: /* read rule body */
319:
320:
321: t = gettok();
322: more_rule:
323: while( t == IDENTIFIER ) {
324: *mem = chfind(1,tokname);
325: if( *mem<NTBASE ) levprd[nprod] = toklev[*mem];
326: ++mem;
327: rhsfill( tokname ); /* add to rhs string */
328: t = gettok();
329: }
330:
331:
332: if( t == PREC ){
333: if( gettok()!=IDENTIFIER) error( "illegal %%prec syntax" );
334: j = chfind(2,tokname);
335: if( j>=NTBASE)error("nonterminal %s illegal after %%prec", nontrst[j-NTBASE].name);
336: levprd[nprod]=toklev[j];
337: t = gettok();
338: }
339:
340: if( t == '=' ){
341: had_act[nprod] = 1;
342: levprd[nprod] |= ACTFLAG;
343: fprintf( faction, "\ncase %d:", nprod );
344: cpyact( mem-prdptr[nprod]-1 );
345: fprintf( faction, " break;" );
346: if( (t=gettok()) == IDENTIFIER ){
347: /* action within rule... */
348:
349: lrprnt(); /* dump lhs, rhs */
350: sprintf( actname, "$$%d", nprod );
351: j = chfind(1,actname); /* make it a nonterminal */
352:
353: /* the current rule will become rule number nprod+1 */
354: /* move the contents down, and make room for the null */
355:
356: for( p=mem; p>=prdptr[nprod]; --p ) p[2] = *p;
357: mem += 2;
358:
359: /* enter null production for action */
360:
361: p = prdptr[nprod];
362:
363: *p++ = j;
364: *p++ = -nprod;
365:
366: /* update the production information */
367:
368: levprd[nprod+1] = levprd[nprod] & ~ACTFLAG;
369: levprd[nprod] = ACTFLAG;
370:
371: if( ++nprod >= NPROD ) error( "more than %d rules", NPROD );
372: prdptr[nprod] = p;
373:
374: /* make the action appear in the original rule */
375: *mem++ = j;
376:
377: /* get some more of the rule */
378:
379: goto more_rule;
380: }
381:
382: }
383:
384: while( t == ';' ) t = gettok();
385:
386: *mem++ = -nprod;
387:
388: /* check that default action is reasonable */
389:
390: if( ntypes && !(levprd[nprod]&ACTFLAG) && nontrst[*prdptr[nprod]-NTBASE].tvalue ){
391: /* no explicit action, LHS has value */
392: register tempty;
393: tempty = prdptr[nprod][1];
394: if( tempty < 0 ) error( "must return a value, since LHS has a type" );
395: else if( tempty >= NTBASE ) tempty = nontrst[tempty-NTBASE].tvalue;
396: else tempty = TYPE( toklev[tempty] );
397: if( tempty != nontrst[*prdptr[nprod]-NTBASE].tvalue ){
398: error( "default action causes potential type clash" );
399: }
400: }
401:
402: if( ++nprod >= NPROD ) error( "more than %d rules", NPROD );
403: prdptr[nprod] = mem;
404: levprd[nprod]=0;
405:
406: }
407:
408: /* end of all rules */
409:
410: end_debug(); /* finish fdebug file's input */
411: finact();
412: if( t == MARK ){
413: if ( gen_lines )
414: fprintf( ftable, "\n# line %d \"%s\"\n",
415: lineno, infile );
416: while( (c=getc(finput)) != EOF ) putc( c, ftable );
417: }
418: fclose( finput );
419: }
420:
421: finact(){
422: /* finish action routine */
423:
424: fclose(faction);
425:
426: fprintf( ftable, "# define YYERRCODE %d\n", tokset[2].value );
427:
428: }
429:
430: defin( t, s ) register char *s; {
431: /* define s to be a terminal if t=0
432: or a nonterminal if t=1 */
433:
434: register val;
435:
436: if (t) {
437: if( ++nnonter >= NNONTERM ) error("too many nonterminals, limit %d",NNONTERM);
438: nontrst[nnonter].name = cstash(s);
439: return( NTBASE + nnonter );
440: }
441: /* must be a token */
442: if( ++ntokens >= NTERMS ) error("too many terminals, limit %d",NTERMS );
443: tokset[ntokens].name = cstash(s);
444:
445: /* establish value for token */
446:
447: if( s[0]==' ' && s[2]=='\0' ) /* single character literal */
448: val = s[1];
449: else if ( s[0]==' ' && s[1]=='\\' ) { /* escape sequence */
450: if( s[3] == '\0' ){ /* single character escape sequence */
451: switch ( s[2] ){
452: /* character which is escaped */
453: case 'n': val = '\n'; break;
454: case 'r': val = '\r'; break;
455: case 'b': val = '\b'; break;
456: case 't': val = '\t'; break;
457: case 'f': val = '\f'; break;
458: case '\'': val = '\''; break;
459: case '"': val = '"'; break;
460: case '\\': val = '\\'; break;
461: default: error( "invalid escape" );
462: }
463: }
464: else if( s[2] <= '7' && s[2]>='0' ){ /* \nnn sequence */
465: if( s[3]<'0' || s[3] > '7' || s[4]<'0' ||
466: s[4]>'7' || s[5] != '\0' ) error("illegal \\nnn construction" );
467: val = 64*s[2] + 8*s[3] + s[4] - 73*'0';
468: if( val == 0 ) error( "'\\000' is illegal" );
469: }
470: }
471: else {
472: val = extval++;
473: }
474: tokset[ntokens].value = val;
475: toklev[ntokens] = 0;
476: return( ntokens );
477: }
478:
479: defout(){ /* write out the defines (at the end of the declaration section) */
480:
481: register int i, c;
482: register char *cp;
483:
484: for( i=ndefout; i<=ntokens; ++i ){
485:
486: cp = tokset[i].name;
487: if( *cp == ' ' ) /* literals */
488: {
489: fprintf( fdebug, "\t\"%s\",\t%d,\n",
490: tokset[i].name + 1, tokset[i].value );
491: cp++; /* in my opinion, this should be continue */
492: }
493:
494: for( ; (c= *cp)!='\0'; ++cp ){
495:
496: if( islower(c) || isupper(c) || isdigit(c) || c=='_' ); /* VOID */
497: else goto nodef;
498: }
499:
500: if ( tokset[i].name[0] != ' ' )
501: fprintf( fdebug, "\t\"%s\",\t%d,\n",
502: tokset[i].name, tokset[i].value );
503: fprintf( ftable, "# define %s %d\n", tokset[i].name, tokset[i].value );
504: if( fdefine != NULL ) fprintf( fdefine, "# define %s %d\n", tokset[i].name, tokset[i].value );
505:
506: nodef: ;
507: }
508:
509: ndefout = ntokens+1;
510:
511: }
512:
513: char *
514: cstash( s ) register char *s; {
515: char *temp;
516:
517: temp = cnamp;
518: do {
519: if( cnamp >= &cnames[cnamsz] ) error("too many characters in id's and literals" );
520: else *cnamp++ = *s;
521: } while ( *s++ );
522: return( temp );
523: }
524:
525: gettok() {
526: register i, base;
527: static int peekline; /* number of '\n' seen in lookahead */
528: register c, match, reserve;
529:
530: begin:
531: reserve = 0;
532: lineno += peekline;
533: peekline = 0;
534: c = getc(finput);
535: while( c==' ' || c=='\n' || c=='\t' || c=='\f' ){
536: if( c == '\n' ) ++lineno;
537: c=getc(finput);
538: }
539: if( c == '/' ){ /* skip comment */
540: lineno += skipcom();
541: goto begin;
542: }
543:
544: switch(c){
545:
546: case EOF:
547: return(ENDFILE);
548: case '{':
549: ungetc( c, finput );
550: return( '=' ); /* action ... */
551: case '<': /* get, and look up, a type name (union member name) */
552: i = 0;
553: while( (c=getc(finput)) != '>' && c>=0 && c!= '\n' ){
554: tokname[i] = c;
555: if( ++i >= NAMESIZE ) --i;
556: }
557: if( c != '>' ) error( "unterminated < ... > clause" );
558: tokname[i] = '\0';
559: for( i=1; i<=ntypes; ++i ){
560: if( !strcmp( typeset[i], tokname ) ){
561: numbval = i;
562: return( TYPENAME );
563: }
564: }
565: typeset[numbval = ++ntypes] = cstash( tokname );
566: return( TYPENAME );
567:
568: case '"':
569: case '\'':
570: match = c;
571: tokname[0] = ' ';
572: i = 1;
573: for(;;){
574: c = getc(finput);
575: if( c == '\n' || c == EOF )
576: error("illegal or missing ' or \"" );
577: if( c == '\\' ){
578: c = getc(finput);
579: tokname[i] = '\\';
580: if( ++i >= NAMESIZE ) --i;
581: }
582: else if( c == match ) break;
583: tokname[i] = c;
584: if( ++i >= NAMESIZE ) --i;
585: }
586: break;
587:
588: case '%':
589: case '\\':
590:
591: switch(c=getc(finput)) {
592:
593: case '0': return(TERM);
594: case '<': return(LEFT);
595: case '2': return(BINARY);
596: case '>': return(RIGHT);
597: case '%':
598: case '\\': return(MARK);
599: case '=': return(PREC);
600: case '{': return(LCURLY);
601: default: reserve = 1;
602: }
603:
604: default:
605:
606: if( isdigit(c) ){ /* number */
607: numbval = c-'0' ;
608: base = (c=='0') ? 8 : 10 ;
609: for( c=getc(finput); isdigit(c) ; c=getc(finput) ){
610: numbval = numbval*base + c - '0';
611: }
612: ungetc( c, finput );
613: return(NUMBER);
614: }
615: else if( islower(c) || isupper(c) || c=='_' || c=='.' || c=='$' ){
616: i = 0;
617: while( islower(c) || isupper(c) || isdigit(c) || c=='_' || c=='.' || c=='$' ){
618: tokname[i] = c;
619: if( reserve && isupper(c) ) tokname[i] += 'a'-'A';
620: if( ++i >= NAMESIZE ) --i;
621: c = getc(finput);
622: }
623: }
624: else return(c);
625:
626: ungetc( c, finput );
627: }
628:
629: tokname[i] = '\0';
630:
631: if( reserve ){ /* find a reserved word */
632: if( !strcmp(tokname,"term")) return( TERM );
633: if( !strcmp(tokname,"token")) return( TERM );
634: if( !strcmp(tokname,"left")) return( LEFT );
635: if( !strcmp(tokname,"nonassoc")) return( BINARY );
636: if( !strcmp(tokname,"binary")) return( BINARY );
637: if( !strcmp(tokname,"right")) return( RIGHT );
638: if( !strcmp(tokname,"prec")) return( PREC );
639: if( !strcmp(tokname,"start")) return( START );
640: if( !strcmp(tokname,"type")) return( TYPEDEF );
641: if( !strcmp(tokname,"union")) return( UNION );
642: error("invalid escape, or illegal reserved word: %s", tokname );
643: }
644:
645: /* look ahead to distinguish IDENTIFIER from C_IDENTIFIER */
646:
647: c = getc(finput);
648: while( c==' ' || c=='\t'|| c=='\n' || c=='\f' || c== '/' ) {
649: if( c == '\n' ) ++peekline;
650: else if( c == '/' ){ /* look for comments */
651: peekline += skipcom();
652: }
653: c = getc(finput);
654: }
655: if( c == ':' ) return( C_IDENTIFIER );
656: ungetc( c, finput );
657: return( IDENTIFIER );
658: }
659:
660: fdtype( t ){ /* determine the type of a symbol */
661: register v;
662: if( t >= NTBASE ) v = nontrst[t-NTBASE].tvalue;
663: else v = TYPE( toklev[t] );
664: if( v <= 0 ) error( "must specify type for %s", (t>=NTBASE)?nontrst[t-NTBASE].name:
665: tokset[t].name );
666: return( v );
667: }
668:
669: chfind( t, s ) register char *s; {
670: int i;
671:
672: if (s[0]==' ')t=0;
673: TLOOP(i){
674: if(!strcmp(s,tokset[i].name)){
675: return( i );
676: }
677: }
678: NTLOOP(i){
679: if(!strcmp(s,nontrst[i].name)) {
680: return( i+NTBASE );
681: }
682: }
683: /* cannot find name */
684: if( t>1 )
685: error( "%s should have been defined earlier", s );
686: return( defin( t, s ) );
687: }
688:
689: cpyunion(){
690: /* copy the union declaration to the output, and the define file if present */
691:
692: int level, c;
693: if ( gen_lines )
694: fprintf( ftable, "\n# line %d \"%s\"\n", lineno, infile );
695: fprintf( ftable, "typedef union " );
696: if( fdefine ) fprintf( fdefine, "\ntypedef union " );
697:
698: level = 0;
699: for(;;){
700: if( (c=getc(finput)) < 0 ) error( "EOF encountered while processing %%union" );
701: putc( c, ftable );
702: if( fdefine ) putc( c, fdefine );
703:
704: switch( c ){
705:
706: case '\n':
707: ++lineno;
708: break;
709:
710: case '{':
711: ++level;
712: break;
713:
714: case '}':
715: --level;
716: if( level == 0 ) { /* we are finished copying */
717: fprintf( ftable, " YYSTYPE;\n" );
718: if( fdefine ) fprintf( fdefine, " YYSTYPE;\nextern YYSTYPE yylval;\n" );
719: return;
720: }
721: }
722: }
723: }
724:
725: cpycode(){ /* copies code between \{ and \} */
726:
727: int c;
728: c = getc(finput);
729: if( c == '\n' ) {
730: c = getc(finput);
731: lineno++;
732: }
733: if ( gen_lines )
734: fprintf( ftable, "\n# line %d \"%s\"\n", lineno, infile );
735: while( c>=0 ){
736: if( c=='\\' )
737: if( (c=getc(finput)) == '}' ) return;
738: else putc('\\', ftable );
739: if( c=='%' )
740: if( (c=getc(finput)) == '}' ) return;
741: else putc('%', ftable );
742: putc( c , ftable );
743: if( c == '\n' ) ++lineno;
744: c = getc(finput);
745: }
746: error("eof before %%}" );
747: }
748:
749: skipcom(){ /* skip over comments */
750: register c, i=0; /* i is the number of lines skipped */
751:
752: /* skipcom is called after reading a / */
753:
754: if( getc(finput) != '*' ) error( "illegal comment" );
755: c = getc(finput);
756: while( c != EOF ){
757: while( c == '*' ){
758: if( (c=getc(finput)) == '/' ) return( i );
759: }
760: if( c == '\n' ) ++i;
761: c = getc(finput);
762: }
763: error( "EOF inside comment" );
764: /* NOTREACHED */
765: }
766:
767: cpyact(offset){ /* copy C action to the next ; or closing } */
768: int brac, c, match, j, s, tok;
769:
770: if ( gen_lines )
771: fprintf( faction, "\n# line %d \"%s\"\n", lineno, infile );
772:
773: brac = 0;
774:
775: loop:
776: c = getc(finput);
777: swt:
778: switch( c ){
779:
780: case ';':
781: if( brac == 0 ){
782: putc( c , faction );
783: return;
784: }
785: goto lcopy;
786:
787: case '{':
788: brac++;
789: goto lcopy;
790:
791: case '$':
792: s = 1;
793: tok = -1;
794: c = getc(finput);
795: if( c == '<' ){ /* type description */
796: ungetc( c, finput );
797: if( gettok() != TYPENAME ) error( "bad syntax on $<ident> clause" );
798: tok = numbval;
799: c = getc(finput);
800: }
801: if( c == '$' ){
802: fprintf( faction, "yyval");
803: if( ntypes ){ /* put out the proper tag... */
804: if( tok < 0 ) tok = fdtype( *prdptr[nprod] );
805: fprintf( faction, ".%s", typeset[tok] );
806: }
807: goto loop;
808: }
809: if( c == '-' ){
810: s = -s;
811: c = getc(finput);
812: }
813: if( isdigit(c) ){
814: j=0;
815: while( isdigit(c) ){
816: j= j*10+c-'0';
817: c = getc(finput);
818: }
819:
820: j = j*s - offset;
821: if( j > 0 ){
822: error( "Illegal use of $%d", j+offset );
823: }
824:
825: fprintf( faction, "yypvt[-%d]", -j );
826: if( ntypes ){ /* put out the proper tag */
827: if( j+offset <= 0 && tok < 0 ) error( "must specify type of $%d", j+offset );
828: if( tok < 0 ) tok = fdtype( prdptr[nprod][j+offset] );
829: fprintf( faction, ".%s", typeset[tok] );
830: }
831: goto swt;
832: }
833: putc( '$' , faction );
834: if( s<0 ) putc('-', faction );
835: goto swt;
836:
837: case '}':
838: if( --brac ) goto lcopy;
839: putc( c, faction );
840: return;
841:
842:
843: case '/': /* look for comments */
844: putc( c , faction );
845: c = getc(finput);
846: if( c != '*' ) goto swt;
847:
848: /* it really is a comment */
849:
850: putc( c , faction );
851: c = getc(finput);
852: while( c != EOF ){
853: while( c=='*' ){
854: putc( c , faction );
855: if( (c=getc(finput)) == '/' ) goto lcopy;
856: }
857: putc( c , faction );
858: if( c == '\n' )++lineno;
859: c = getc(finput);
860: }
861: error( "EOF inside comment" );
862:
863: case '\'': /* character constant */
864: match = '\'';
865: goto string;
866:
867: case '"': /* character string */
868: match = '"';
869:
870: string:
871:
872: putc( c , faction );
873: while( c=getc(finput) ){
874:
875: if( c=='\\' ){
876: putc( c , faction );
877: c=getc(finput);
878: if( c == '\n' ) ++lineno;
879: }
880: else if( c==match ) goto lcopy;
881: else if( c=='\n' ) error( "newline in string or char. const." );
882: putc( c , faction );
883: }
884: error( "EOF in string or character constant" );
885:
886: case EOF:
887: error("action does not terminate" );
888:
889: case '\n': ++lineno;
890: goto lcopy;
891:
892: }
893:
894: lcopy:
895: putc( c , faction );
896: goto loop;
897: }
898:
899:
900: #define RHS_TEXT_LEN ( BUFSIZ * 4 ) /* length of rhstext */
901:
902: char lhstext[ BUFSIZ ]; /* store current lhs (non-terminal) name */
903: char rhstext[ RHS_TEXT_LEN ]; /* store current rhs list */
904:
905: lhsfill( s ) /* new rule, dump old (if exists), restart strings */
906: char *s;
907: {
908: rhsfill( (char *) 0 );
909: strcpy( lhstext, s ); /* don't worry about too long of a name */
910: }
911:
912:
913: rhsfill( s )
914: char *s; /* either name or 0 */
915: {
916: static char *loc = rhstext; /* next free location in rhstext */
917: register char *p;
918:
919: if ( !s ) /* print out and erase old text */
920: {
921: if ( *lhstext ) /* there was an old rule - dump it */
922: lrprnt();
923: ( loc = rhstext )[0] = '\0';
924: return;
925: }
926: /* add to stuff in rhstext */
927: p = s;
928: *loc++ = ' ';
929: if ( *s == ' ' ) /* special quoted symbol */
930: {
931: *loc++ = '\''; /* add first quote */
932: p++;
933: }
934: while ( *loc = *p++ )
935: if ( loc++ > &rhstext[ RHS_TEXT_LEN ] - 2 )
936: break;
937: if ( *s == ' ' )
938: *loc++ = '\'';
939: *loc = '\0'; /* terminate the string */
940: }
941:
942:
943: lrprnt() /* print out the left and right hand sides */
944: {
945: char *rhs;
946:
947: if ( !*rhstext ) /* empty rhs - print usual comment */
948: rhs = " /* empty */";
949: else
950: rhs = rhstext;
951: fprintf( fdebug, " \"%s :%s\",\n", lhstext, rhs );
952: }
953:
954:
955: beg_debug() /* dump initial sequence for fdebug file */
956: {
957: fprintf( fdebug,
958: "typedef struct { char *t_name; int t_val; } yytoktype;\n" );
959: fprintf( fdebug,
960: "#ifndef YYDEBUG\n#\tdefine YYDEBUG\t%d", gen_testing );
961: fprintf( fdebug, "\t/*%sallow debugging */\n#endif\n\n",
962: gen_testing ? " " : " don't " );
963: fprintf( fdebug, "#if YYDEBUG\n\nyytoktype yytoks[] =\n{\n" );
964: }
965:
966:
967: end_toks() /* finish yytoks array, get ready for yyred's strings */
968: {
969: fprintf( fdebug, "\t\"-unknown-\",\t-1\t/* ends search */\n" );
970: fprintf( fdebug, "};\n\nchar * yyreds[] =\n{\n" );
971: fprintf( fdebug, "\t\"-no such reduction-\",\n" );
972: }
973:
974:
975: end_debug() /* finish yyred array, close file */
976: {
977: lrprnt(); /* dump last lhs, rhs */
978: fprintf( fdebug, "};\n#endif /* YYDEBUG */\n" );
979: fclose( fdebug );
980: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.