Annotation of researchv10dc/cmd/PDP11/11c/cvopt.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: int    tabflg;
                      4: int    labno   = 1;
                      5: int opno;
                      6: FILE   *curbuf;
                      7: FILE   *obuf;
                      8: FILE   *oobuf;
                      9: char  oname[]="/tmp/cvoptaXXXXXX";
                     10: char ooname[]="/tmp/cvoptbXXXXXX";
                     11: char lbuf[BUFSIZ];
                     12: char *lbufp = lbuf;
                     13: 
                     14: main(argc, argv)
                     15: char **argv;
                     16: {
                     17: /*
                     18:        A1 -> A
                     19:        A2    B
                     20:        A     O
                     21:        B1    C
                     22:        B2    D
                     23:        BE    L
                     24:        BF    P
                     25:        C1    E
                     26:        C2    F
                     27:        F     G
                     28:        H     H
                     29:        R     I
                     30:        R1    J
                     31:        S     K
                     32:        I     M
                     33:        M     N
                     34: 
                     35:                *       +1
                     36:                S       +2
                     37:                C       +4
                     38:                1       +8
                     39: 
                     40:        z  -> 4
                     41:        c     10
                     42:        a     14
                     43:        e     20
                     44:        n     63
                     45:        *       +0100
                     46: */
                     47: 
                     48:        int c, snlflg, nlflg, t, smode, m, ssmode, peekc, side;
                     49: 
                     50:        smode = nlflg = snlflg = ssmode = 0;
                     51:        if (argc>1)
                     52:                if (freopen(argv[1], "r", stdin) == NULL) {
                     53:                        fprintf(stderr, "%s?\n", argv[1]);
                     54:                        return(1);
                     55:                }
                     56:        if (argc>2) 
                     57:                if (freopen(argv[2], "w", stdout) == NULL) {
                     58:                        fprintf(stderr, "%s?\n", argv[2]);
                     59:                        return(1);
                     60:                }
                     61:        mktemp(oname);
                     62:        if ((obuf = fopen(oname, "w")) == NULL) {
                     63:                fprintf(stderr, "%s?\n", oname);
                     64:                exit(1);
                     65:        }
                     66:        mktemp(ooname);
                     67:        if ((oobuf = fopen(ooname, "w")) == NULL) {
                     68:                fprintf(stderr, "%s?\n", ooname);
                     69:                exit(1);
                     70:        }
                     71:        printf("#include \"c1.h\"");
                     72:        curbuf = obuf;
                     73: loop:
                     74:        c = getchar();
                     75:        if (c!='\n' && c!='\t')
                     76:                nlflg = 0;
                     77:        if (ssmode!=0 && c!='%') {
                     78:                ssmode = 0;
                     79:                curbuf = stdout;
                     80:                fprintf(curbuf, "\nstatic char L%d[]=\"", labno++);
                     81:        }
                     82:        switch(c) {
                     83: 
                     84:        case EOF:
                     85:                fprintf(obuf, "\t{0},\n};\n");
                     86:                fclose(obuf);
                     87:                if (freopen(oname, "r", stdin) == NULL) {
                     88:                        fprintf(stderr, "%s?\n",oname);
                     89:                        exit(1);
                     90:                }
                     91:                while ((c = getchar()) != EOF)
                     92:                        putchar(c);
                     93:                unlink(oname);
                     94:                fclose(oobuf);
                     95:                if (freopen(ooname, "r", stdin) == NULL) {
                     96:                        fprintf(stderr, "%s?\n",ooname);
                     97:                        exit(1);
                     98:                }
                     99:                while ((c = getchar()) != EOF)
                    100:                        putchar(c);
                    101:                unlink(ooname);
                    102:                return(0);
                    103: 
                    104:        case 'A':
                    105:                if ((c=getchar())=='1' || c=='2') {
                    106:                        put(c+'A'-'1');
                    107:                        goto loop;
                    108:                }
                    109:                put('O');
                    110:                ungetc(c, stdin);
                    111:                goto loop;
                    112: 
                    113:        case 'B':
                    114:                switch (getchar()) {
                    115: 
                    116:                case '1':
                    117:                        put('C');
                    118:                        goto loop;
                    119: 
                    120:                case '2':
                    121:                        put('D');
                    122:                        goto loop;
                    123: 
                    124:                case 'E':
                    125:                        put('L');
                    126:                        goto loop;
                    127: 
                    128:                case 'F':
                    129:                        put('P');
                    130:                        goto loop;
                    131:                }
                    132:                put('?');
                    133:                goto loop;
                    134: 
                    135:        case 'C':
                    136:                put(getchar()+'E'-'1');
                    137:                goto loop;
                    138: 
                    139:        case 'F':
                    140:                put('G');
                    141:                goto subtre;
                    142: 
                    143:        case 'R':
                    144:                if ((c=getchar()) == '1')
                    145:                put('J'); else {
                    146:                        put('I');
                    147:                        ungetc(c, stdin);
                    148:                }
                    149:                goto loop;
                    150: 
                    151:        case 'H':
                    152:                put('H');
                    153:                goto subtre;
                    154: 
                    155:        case 'I':
                    156:                put('M');
                    157:                goto loop;
                    158: 
                    159:        case 'S':
                    160:                put('K');
                    161: subtre:
                    162:                snlflg = 1;
                    163:                t = 'A';
                    164: l1:
                    165:                switch (c=getchar()) {
                    166: 
                    167:                case '*':
                    168:                        t++;
                    169:                        goto l1;
                    170: 
                    171:                case 'S':
                    172:                        t += 2;
                    173:                        goto l1;
                    174: 
                    175:                case 'C':
                    176:                        t += 4;
                    177:                        goto l1;
                    178: 
                    179:                case '1':
                    180:                        t += 8;
                    181:                        goto l1;
                    182: 
                    183:                case '2':
                    184:                        t += 16;
                    185:                        goto l1;
                    186:                }
                    187:                ungetc(c, stdin);
                    188:                put(t);
                    189:                goto loop;
                    190: 
                    191:        case '#':
                    192:                if(getchar()=='1')
                    193:                        put('#'); else
                    194:                        put('"');
                    195:                goto loop;
                    196: 
                    197:        case '%':
                    198:                if (smode)
                    199:                        curbuf = obuf;
                    200:                if (ssmode==0) {
                    201:                        if ((peekc=getchar())=='[') {
                    202:                                printf("\n#define ");
                    203:                                while((c=getchar())!=']' && c!=':')
                    204:                                        putchar(c);
                    205:                                printf(" L%d\n",labno);
                    206:                                if (c==':') getchar();
                    207:                                getchar();
                    208:                                curbuf = obuf;
                    209:                                goto loop;
                    210:                        }
                    211:                        ungetc(peekc, stdin);
                    212:                }
                    213:                side=0;
                    214: loop1:
                    215:                switch (c=getchar()) {
                    216: 
                    217:                case ' ':
                    218:                case '\t':
                    219:                        goto loop1;
                    220:                case 'a':
                    221:                        m = 16;
                    222:                        t = flag();
                    223:                        goto pf;
                    224: 
                    225:                case ',':
                    226:                        side=1;
                    227:                        goto loop1;
                    228: 
                    229:                case 'i':
                    230:                        m = 12;
                    231:                        t = flag();
                    232:                        goto pf;
                    233:                case 'z':
                    234:                        m = 4;
                    235:                        t = flag();
                    236:                        goto pf;
                    237: 
                    238:                case 'r':
                    239:                        m = 9;
                    240:                        t = flag();
                    241:                        goto pf;
                    242: 
                    243:                case '1':
                    244:                        m = 5;
                    245:                        t = flag();
                    246:                        goto pf;
                    247: 
                    248:                case 'c':
                    249:                        t = 0;
                    250:                        m = 8;
                    251:                        goto pf;
                    252: 
                    253:                case 'e':
                    254:                        t = flag();
                    255:                        m = 20;
                    256:                        goto pf;
                    257: 
                    258:                case 'n':
                    259:                        t = flag();
                    260:                        m = 63;
                    261: pf:
                    262:                        if ((c=getchar())=='*')
                    263:                                m += 0100; else
                    264:                                ungetc(c, stdin);
                    265:                        if (side==0) {
                    266:                                if (opno==0) fprintf(curbuf,"\nstruct optab optab[]={\n");
                    267:                                fprintf(curbuf,"\t{");
                    268:                        }
                    269:                        fprintf(curbuf, "%d,%d,", m, t);
                    270:                        goto loop1;
                    271:                case '[':
                    272:                        printf("\n#define L%d ", labno++);
                    273:                        while ((c=getchar())!=']')
                    274:                                putchar(c);
                    275:                        printf("\n");
                    276:                        ssmode = 0;
                    277:                        smode = 0;
                    278:                        goto loop;
                    279: 
                    280:                case '{':
                    281:                for(;;) {
                    282:                        while ((c=getchar())!='%') putc(c,oobuf);
                    283:                        if ((c=getchar())=='}') goto loop;
                    284:                        else {putc('%',oobuf); putc(c,oobuf);}
                    285:                }
                    286:                        
                    287:                case '\n':
                    288:                        fprintf(curbuf, "L%d},  /* %d */\n", labno,opno);
                    289:                        ++opno;
                    290:                        ssmode = 1;
                    291:                        nlflg = 1;
                    292:                        smode = 1;
                    293:                        goto loop;
                    294: 
                    295:                case '/':
                    296:                        comment(c); goto loop1;
                    297: 
                    298:                }
                    299:                put(c);
                    300:                goto loop1;
                    301: 
                    302:        case '\t':
                    303:                if (nlflg) {
                    304:                        nlflg = 0;
                    305:                        goto loop;
                    306:                }
                    307:                if (smode) {
                    308:                        tabflg++;
                    309:                        goto loop;
                    310:                }
                    311:                put('\t');
                    312:                goto loop;
                    313: 
                    314:        case '\n':
                    315:                lbufp=lbuf;
                    316:                if (!smode)  {
                    317:                        put('\n');
                    318:                        goto loop;
                    319:                }
                    320:                if (nlflg) {
                    321:                        nlflg = 0;
                    322:                        fprintf(curbuf, "\";");
                    323:                        curbuf = obuf;
                    324:                        smode = 0;
                    325:                        goto loop;
                    326:                }
                    327:                if (!snlflg)
                    328:                        fprintf(curbuf, "\\n");
                    329:                snlflg = 0;
                    330:                nlflg = 1;
                    331:                goto loop;
                    332: 
                    333:        case '/':
                    334:                comment(c); goto loop;
                    335: 
                    336:        case 'X':
                    337:        case 'Y':
                    338:        case 'T':
                    339:                snlflg++;
                    340:                break;
                    341: 
                    342:        case ':':
                    343:                fseek(curbuf,(long)(lbuf-lbufp),2);
                    344:                *lbufp='\0';
                    345:                if (opno!=0) {fprintf(curbuf,"\t{0},\n"); ++opno;}
                    346:                printf("\n#define %s &optab[%d]\n",lbuf,opno);
                    347:                fprintf(curbuf,"/* %s */",lbuf);
                    348:                lbufp=lbuf;
                    349:                goto loop;
                    350: 
                    351:        }
                    352:        *lbufp++=c;
                    353:        put(c);
                    354:        goto loop;
                    355: }
                    356: 
                    357: flag() {
                    358:        register c, f;
                    359: 
                    360:        f = 0;
                    361: l1:
                    362:        switch(c=getchar()) {
                    363: 
                    364:        case 'w':
                    365:                f = 1;
                    366:                goto l1;
                    367: 
                    368:        case 'i':
                    369:                f = 2;
                    370:                goto l1;
                    371: 
                    372:        case 'b':
                    373:                if (f==9)
                    374:                        f = 10;
                    375:                else
                    376:                        f = 3;
                    377:                goto l1;
                    378: 
                    379:        case 'f':
                    380:                f = 4;
                    381:                goto l1;
                    382: 
                    383:        case 'd':
                    384:                f = 5;
                    385:                goto l1;
                    386: 
                    387:        case 'u':
                    388:                if (f==3)
                    389:                        f = 10;
                    390:                else
                    391:                        f = 9;
                    392:                goto l1;
                    393: 
                    394:        case 's':
                    395:                f = 6;
                    396:                goto l1;
                    397: 
                    398:        case 'l':
                    399:                f = 8;
                    400:                goto l1;
                    401: 
                    402:        case 'p':
                    403:                f += 16;
                    404:                goto l1;
                    405:        }
                    406:        ungetc(c, stdin);
                    407:        return(f);
                    408: }
                    409: 
                    410: put(c)
                    411: {
                    412:        if (tabflg) {
                    413:                tabflg = 0;
                    414:                fprintf(curbuf, "\\%o", c+0200);
                    415:        } else {
                    416:                if (c=='"') putc('\\',curbuf);
                    417:                putc(c, curbuf);
                    418:        }
                    419: }
                    420: 
                    421: comment(c)
                    422: register char c;
                    423: {
                    424:        putc(c,curbuf);
                    425:        if ((c=getchar())=='*') for (;;) {
                    426:                do putc(c,curbuf); while ((c=getchar())!='*');
                    427:                putc(c,curbuf);
                    428:                if ((c=getchar())=='/') {putc(c,curbuf); break;}
                    429:        } else ungetc(c,stdin);
                    430: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.