Return to sub1.c CVS log

Up to [Research Unix] / researchv10no / cmd / lex

Annotation of researchv10no/cmd/lex/sub1.c, revision 1.1

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.