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