![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sub1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lex|
Return to sub1.c CVS log | Up to [Research Unix] / researchv10no / cmd / lex |
1.1 root 1: # include "ldefs.c"
2:
3: sharpline() /* print a #line lineno "filename" */
4: {
5: fprintf(fout, "\n#line %d \"%s\"\n", yyline, infile);
6: }
7:
8: char *
9: getl(p) /* return next line of input, throw away trailing '\n' */
10: /* returns 0 if eof is had immediately */
11: char *p;
12: {
13: register int c;
14: register char *s, *t;
15: t = s = p;
16: while(((c = gch()) != 0) && c != '\n')
17: *t++ = c;
18: *t = 0;
19: if(c == 0 && s == t) return((char *)0);
20: prev = '\n';
21: pres = '\n';
22: return(s);
23: }
24: space(ch)
25: {
26: switch(ch)
27: {
28: case ' ':
29: case '\t':
30: case '\n':
31: return(1);
32: }
33: return(0);
34: }
35:
36: digit(c)
37: {
38: return(c>='0' && c <= '9');
39: }
40: error(s,p,d)
41: {
42: if(!eof)fprintf(errorf,"%d: ",yyline);
43: fprintf(errorf,"(Error) ");
44: fprintf(errorf,s,p,d);
45: putc('\n',errorf);
46: # ifdef DEBUG
47: if(debug && sect != ENDSECTION) {
48: sect1dump();
49: sect2dump();
50: }
51: # endif
52: if(
53: # ifdef DEBUG
54: debug ||
55: # endif
56: report == 1) statistics();
57: exit(1); /* error return code */
58: }
59:
60: warning(s,p,d)
61: {
62: if(!eof)fprintf(errorf,"%d: ",yyline);
63: fprintf(errorf,"(Warning) ");
64: fprintf(errorf,s,p,d);
65: putc('\n',errorf);
66: fflush(errorf);
67: fflush(fout);
68: fflush(stdout);
69: }
70: index(a,s)
71: char *s;
72: {
73: register int k;
74: for(k=0; s[k]; k++)
75: if (s[k]== a)
76: return(k);
77: return(-1);
78: }
79:
80: alpha(c)
81: int c; {
82: # ifdef ASCII
83: return('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z');
84: # endif
85: # ifdef EBCDIC
86: return(index(c,"abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") >= 0);
87: # endif
88: }
89: printable(c)
90: {
91: # ifdef ASCII
92: return( c>040 && c < 0177);
93: # endif
94: # ifdef EBCDIC
95: return(index(c, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,;:><+*)('&%!-=\"")>=0);
96: # endif
97: }
98: lgate()
99: {
100: char fname[20];
101: if (lgatflg) return;
102: lgatflg=1;
103: if(fout == NULL){
104: sprintf(fname, "lex.yy.%c", ratfor ? 'r' : 'c' );
105: fout = fopen(fname, "w");
106: }
107: if(fout == NULL) error("Can't open %s",fname);
108: if(ratfor) fprintf( fout, "#\n");
109: phead1();
110: }
111: /* scopy(ptr to str, ptr to str) - copy first arg str to second */
112: /* returns ptr to second arg */
113: scopy(s,t)
114: char *s, *t; {
115: register char *i;
116: i = t;
117: while(*i++ = *s++);
118: return;
119: }
120: siconv(t) /* convert string t, return integer value */
121: char *t; {
122: register int i,sw;
123: register char *s;
124: s = t;
125: while(!(('0' <= *s && *s <= '9') || *s == '-') && *s) s++;
126: sw = 0;
127: if(*s == '-'){ /* neg */
128: sw = 1;
129: s++;
130: }
131: i = 0;
132: while('0' <= *s && *s <= '9')
133: i = i * 10 + (*(s++)-'0');
134: return(sw ? -i : i);
135: }
136: /* slength(ptr to str) - return integer length of string arg */
137: /* excludes '\0' terminator */
138: slength(s)
139: char *s; {
140: register int n;
141: register char *t;
142: t = s;
143: for (n = 0; *t++; n++);
144: return(n);
145: }
146: /* scomp(x,y) - return -1 if x < y,
147: 0 if x == y,
148: return 1 if x > y, all lexicographically */
149: scomp(x,y)
150: char *x,*y; {
151: register char *a,*d;
152: a = x;
153: d = y;
154: while(*a || *d){
155: if(*a > *d)
156: return(1); /* greater */
157: if(*a < *d)
158: return(-1); /* less */
159: a++;
160: d++;
161: }
162: return(0); /* equal */
163: }
164: ctrans(ss)
165: char **ss;
166: {
167: register int c, k;
168: if ((c = **ss) != '\\')
169: return(c);
170: switch(c= *++*ss)
171: {
172: case 'n': c = '\n'; break;
173: case 't': c = '\t'; break;
174: case 'r': c = '\r'; break;
175: case 'b': c = '\b'; break;
176: case 'f': c = 014; break; /* form feed for ascii */
177: case '\\': c = '\\'; break;
178: case '0': case '1': case '2': case '3':
179: case '4': case '5': case '6': case '7':
180: c -= '0';
181: while ((k = *(*ss+1)) >= '0' && k <= '7')
182: {
183: c = c*8 + k - '0';
184: (*ss)++;
185: }
186: break;
187: }
188: return(c);
189: }
190: cclinter(sw)
191: int sw; {
192: /* sw = 1 ==> ccl */
193: register int i, j, k;
194: int m;
195: if(!sw){ /* is NCCL */
196: for(i=1;i<NCH;i++)
197: symbol[i] ^= 1; /* reverse value */
198: }
199: for(i=1;i<NCH;i++)
200: if(symbol[i]) break;
201: if(i >= NCH) return;
202: i = cindex[i];
203: /* see if ccl is already in our table */
204: j = 0;
205: if(i){
206: for(j=1;j<NCH;j++){
207: if((symbol[j] && cindex[j] != i) ||
208: (!symbol[j] && cindex[j] == i)) break;
209: }
210: }
211: if(j >= NCH) return; /* already in */
212: m = 0;
213: k = 0;
214: for(i=1;i<NCH;i++)
215: if(symbol[i]){
216: if(!cindex[i]){
217: cindex[i] = ccount;
218: symbol[i] = 0;
219: m = 1;
220: }
221: else k = 1;
222: }
223: /* m == 1 implies last value of ccount has been used */
224: if(m)ccount++;
225: if(k == 0) return; /* is now in as ccount wholly */
226: /* intersection must be computed */
227: for(i=1;i<NCH;i++){
228: if(symbol[i]){
229: m = 0;
230: j = cindex[i]; /* will be non-zero */
231: for(k=1;k<NCH;k++){
232: if(cindex[k] == j){
233: if(symbol[k]) symbol[k] = 0;
234: else {
235: cindex[k] = ccount;
236: m = 1;
237: }
238: }
239: }
240: if(m)ccount++;
241: }
242: }
243: return;
244: }
245: usescape(c)
246: int c; {
247: register char d;
248: switch(c){
249: case 'n': c = '\n'; break;
250: case 'r': c = '\r'; break;
251: case 't': c = '\t'; break;
252: case 'b': c = '\b'; break;
253: case 'f': c = 014; break; /* form feed for ascii */
254: case '0': case '1': case '2': case '3':
255: case '4': case '5': case '6': case '7':
256: c -= '0';
257: while('0' <= (d=gch()) && d <= '7'){
258: c = c * 8 + (d-'0');
259: if(!('0' <= peek && peek <= '7')) break;
260: }
261: break;
262: }
263: return(c);
264: }
265: lookup(s,t)
266: char *s;
267: char **t; {
268: register int i;
269: i = 0;
270: while(*t){
271: if(scomp(s,*t) == 0)
272: return(i);
273: i++;
274: t++;
275: }
276: return(-1);
277: }
278: cpyact(){ /* copy C action to the next ; or closing } */
279: register int brac, c, mth;
280: int savline, sw;
281:
282: brac = 0;
283: sw = TRUE;
284:
285: while(!eof){
286: c = gch();
287: swt:
288: switch( c ){
289:
290: case '|': if(brac == 0 && sw == TRUE){
291: if(peek == '|')gch(); /* eat up an extra '|' */
292: return(0);
293: }
294: break;
295:
296: case ';':
297: if( brac == 0 ){
298: putc(c,fout);
299: putc('\n',fout);
300: return(1);
301: }
302: break;
303:
304: case '{':
305: brac++;
306: savline=yyline;
307: break;
308:
309: case '}':
310: brac--;
311: if( brac == 0 ){
312: putc(c,fout);
313: putc('\n',fout);
314: return(1);
315: }
316: break;
317:
318: case '/': /* look for comments */
319: putc(c,fout);
320: c = gch();
321: if( c != '*' ) goto swt;
322:
323: /* it really is a comment */
324:
325: putc(c,fout);
326: savline=yyline;
327: while( c=gch() ){
328: if( c=='*' ){
329: putc(c,fout);
330: if( (c=gch()) == '/' ) goto loop;
331: }
332: putc(c,fout);
333: }
334: yyline=savline;
335: error( "EOF inside comment" );
336:
337: case '\'': /* character constant */
338: mth = '\'';
339: goto string;
340:
341: case '"': /* character string */
342: mth = '"';
343:
344: string:
345:
346: putc(c,fout);
347: while( c=gch() ){
348: if( c=='\\' ){
349: putc(c,fout);
350: c=gch();
351: }
352: else if( c==mth ) goto loop;
353: putc(c,fout);
354: if (c == '\n')
355: {
356: yyline--;
357: error( "Non-terminated string or character constant");
358: }
359: }
360: error( "EOF in string or character constant" );
361:
362: case '\0':
363: yyline = savline;
364: error("Action does not terminate");
365: default:
366: break; /* usual character */
367: }
368: loop:
369: if(c != ' ' && c != '\t' && c != '\n') sw = FALSE;
370: putc(c,fout);
371: }
372: error("Premature EOF");
373: }
374: gch(){
375: register int c;
376: prev = pres;
377: c = pres = peek;
378: peek = pushptr > pushc ? *--pushptr : getc(fin);
379: if(peek == EOF && sargc > 1){
380: fclose(fin);
381: fin = fopen(sargv[++fptr],"r");
382: infile = sargv[fptr];
383: if(fin == NULL)
384: error("Cannot open file %s",sargv[fptr]);
385: peek = getc(fin);
386: sargc--;
387: sargv++;
388: }
389: if(c == EOF) {
390: eof = TRUE;
391: fclose(fin);
392: return(0);
393: }
394: if(c == '\n')yyline++;
395: return(c);
396: }
397: mn2(a,d,c)
398: int a,d,c;
399: {
400: name[tptr] = a;
401: left[tptr] = d;
402: right[tptr] = c;
403: parent[tptr] = 0;
404: nullstr[tptr] = 0;
405: switch(a){
406: case RSTR:
407: parent[d] = tptr;
408: break;
409: case BAR:
410: case RNEWE:
411: if(nullstr[d] || nullstr[c]) nullstr[tptr] = TRUE;
412: parent[d] = parent[c] = tptr;
413: break;
414: case RCAT:
415: case DIV:
416: if(nullstr[d] && nullstr[c])nullstr[tptr] = TRUE;
417: parent[d] = parent[c] = tptr;
418: break;
419: case RSCON:
420: parent[d] = tptr;
421: nullstr[tptr] = nullstr[d];
422: break;
423: # ifdef DEBUG
424: default:
425: warning("bad switch mn2 %d %d",a,d);
426: break;
427: # endif
428: }
429: if(tptr > treesize)
430: error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
431: return(tptr++);
432: }
433: mn1(a,d)
434: int a,d;
435: {
436: name[tptr] = a;
437: left[tptr] = d;
438: parent[tptr] = 0;
439: nullstr[tptr] = 0;
440: switch(a){
441: case RCCL:
442: case RNCCL:
443: if(slength(d) == 0) nullstr[tptr] = TRUE;
444: break;
445: case STAR:
446: case QUEST:
447: nullstr[tptr] = TRUE;
448: parent[d] = tptr;
449: break;
450: case PLUS:
451: case CARAT:
452: nullstr[tptr] = nullstr[d];
453: parent[d] = tptr;
454: break;
455: case S2FINAL:
456: nullstr[tptr] = TRUE;
457: break;
458: # ifdef DEBUG
459: case FINAL:
460: case S1FINAL:
461: break;
462: default:
463: warning("bad switch mn1 %d %d",a,d);
464: break;
465: # endif
466: }
467: if(tptr > treesize)
468: error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
469: return(tptr++);
470: }
471: mn0(a)
472: int a;
473: {
474: name[tptr] = a;
475: parent[tptr] = 0;
476: nullstr[tptr] = 0;
477: if(a >= NCH) switch(a){
478: case RNULLS: nullstr[tptr] = TRUE; break;
479: # ifdef DEBUG
480: default:
481: warning("bad switch mn0 %d",a);
482: break;
483: # endif
484: }
485: if(tptr > treesize)
486: error("Parse tree too big %s",(treesize == TREESIZE?"\nTry using %e num":""));
487: return(tptr++);
488: }
489: munput(t,p) /* implementation dependent */
490: char *p;
491: int t; {
492: register int i,j;
493: if(t == 'c'){
494: *pushptr++ = peek; /* watch out for this */
495: peek = (int)p;
496: }
497: else if(t == 's'){
498: *pushptr++ = peek;
499: peek = p[0];
500: i = slength(p);
501: for(j = i-1; j>=1; j--)
502: *pushptr++ = p[j];
503: }
504: # ifdef DEBUG
505: else error("Unrecognized munput option %c",t);
506: # endif
507: if(pushptr >= pushc+TOKENSIZE)
508: error("Too many characters pushed");
509: return;
510: }
511:
512: dupl(n)
513: int n; {
514: /* duplicate the subtree whose root is n, return ptr to it */
515: register int i;
516: i = name[n];
517: if(i < NCH) return(mn0(i));
518: switch(i){
519: case RNULLS:
520: return(mn0(i));
521: case RCCL: case RNCCL: case FINAL: case S1FINAL: case S2FINAL:
522: return(mn1(i,left[n]));
523: case STAR: case QUEST: case PLUS: case CARAT:
524: return(mn1(i,dupl(left[n])));
525: case RSTR: case RSCON:
526: return(mn2(i,dupl(left[n]),right[n]));
527: case BAR: case RNEWE: case RCAT: case DIV:
528: return(mn2(i,dupl(left[n]),dupl(right[n])));
529: # ifdef DEBUG
530: default:
531: warning("bad switch dupl %d",n);
532: # endif
533: }
534: return(0);
535: }
536: # ifdef DEBUG
537: allprint(c)
538: char c; {
539: switch(c){
540: case 014:
541: printf("\\f");
542: charc++;
543: break;
544: case '\n':
545: printf("\\n");
546: charc++;
547: break;
548: case '\t':
549: printf("\\t");
550: charc++;
551: break;
552: case '\b':
553: printf("\\b");
554: charc++;
555: break;
556: case ' ':
557: printf("\\\bb");
558: break;
559: default:
560: if(!printable(c)){
561: printf("\\%-3o",c);
562: charc += 3;
563: }
564: else
565: putchar(c);
566: break;
567: }
568: charc++;
569: return;
570: }
571: strpt(s)
572: char *s; {
573: charc = 0;
574: while(*s){
575: allprint(*s++);
576: if(charc > LINESIZE){
577: charc = 0;
578: printf("\n\t");
579: }
580: }
581: return;
582: }
583: sect1dump(){
584: register int i;
585: printf("Sect 1:\n");
586: if(def[0]){
587: printf("str trans\n");
588: i = -1;
589: while(def[++i])
590: printf("%s\t%s\n",def[i],subs[i]);
591: }
592: if(sname[0]){
593: printf("start names\n");
594: i = -1;
595: while(sname[++i])
596: printf("%s\n",sname[i]);
597: }
598: if(chset == TRUE){
599: printf("char set changed\n");
600: for(i=1;i<NCH;i++){
601: if(i != ctable[i]){
602: allprint(i);
603: putchar(' ');
604: printable(ctable[i]) ? putchar(ctable[i]) : printf("%d",ctable[i]);
605: putchar('\n');
606: }
607: }
608: }
609: }
610: sect2dump(){
611: printf("Sect 2:\n");
612: treedump();
613: }
614: treedump()
615: {
616: register int t;
617: register char *p;
618: printf("treedump %d nodes:\n",tptr);
619: for(t=0;t<tptr;t++){
620: printf("%4d ",t);
621: parent[t] ? printf("p=%4d",parent[t]) : printf(" ");
622: printf(" ");
623: if(name[t] < NCH) {
624: allprint(name[t]);
625: }
626: else switch(name[t]){
627: case RSTR:
628: printf("%d ",left[t]);
629: allprint(right[t]);
630: break;
631: case RCCL:
632: printf("ccl ");
633: strpt(left[t]);
634: break;
635: case RNCCL:
636: printf("nccl ");
637: strpt(left[t]);
638: break;
639: case DIV:
640: printf("/ %d %d",left[t],right[t]);
641: break;
642: case BAR:
643: printf("| %d %d",left[t],right[t]);
644: break;
645: case RCAT:
646: printf("cat %d %d",left[t],right[t]);
647: break;
648: case PLUS:
649: printf("+ %d",left[t]);
650: break;
651: case STAR:
652: printf("* %d",left[t]);
653: break;
654: case CARAT:
655: printf("^ %d",left[t]);
656: break;
657: case QUEST:
658: printf("? %d",left[t]);
659: break;
660: case RNULLS:
661: printf("nullstring");
662: break;
663: case FINAL:
664: printf("final %d",left[t]);
665: break;
666: case S1FINAL:
667: printf("s1final %d",left[t]);
668: break;
669: case S2FINAL:
670: printf("s2final %d",left[t]);
671: break;
672: case RNEWE:
673: printf("new %d %d",left[t],right[t]);
674: break;
675: case RSCON:
676: p = (char *)right[t];
677: printf("start %s",sname[*p++-1]);
678: while(*p)
679: printf(", %s",sname[*p++-1]);
680: printf(" %d",left[t]);
681: break;
682: default:
683: printf("unknown %d %d %d",name[t],left[t],right[t]);
684: break;
685: }
686: if(nullstr[t])printf("\t(null poss.)");
687: putchar('\n');
688: }
689: }
690: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.