Return to mtab.c CVS log

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

Annotation of researchv10no/cmd/cref/mtab.c, revision 1.1

1.1     ! root        1: # include "econs.h"
        !             2: struct {
        !             3:                int     cl[NUMC];
        !             4:        }tab[NUMS];
        !             5: char   state[NUMS][8];
        !             6: char   class[NUMC][8];
        !             7: char   act[NUMA][8];
        !             8: char   def[NUMS][8];
        !             9: char   temp[8];
        !            10: 
        !            11: char   *st[NUMS];
        !            12: char   *df[NUMS];
        !            13: char   *cl[NUMC];
        !            14: char   *ac[NUMA];
        !            15: 
        !            16: int    t1;
        !            17: int    t2;
        !            18: 
        !            19: 
        !            20: main(argc,argv)        char    **argv;
        !            21: {
        !            22: 
        !            23:        extern  fin;
        !            24:        char    fl,nlfl,c,bfl,fo,brk;
        !            25:        int     cs,ca,cc,i,j,cd;
        !            26: 
        !            27:        if(argc != 3) {
        !            28:                printf("Usage: mtab input output\n");
        !            29:                exit();
        !            30:        }
        !            31: 
        !            32:        if((fo = creat(argv[2],0644)) < 0) {
        !            33:                printf("Output file.\n");
        !            34:                exit();
        !            35:        }
        !            36:        if((fin = open(argv[1],0)) < 0) {
        !            37:                printf("Input file.\n");
        !            38:                exit();
        !            39:        }
        !            40: 
        !            41: 
        !            42: 
        !            43:        nlfl = 1;
        !            44:        i = -1;
        !            45:        while(brk = rword()) {
        !            46:                switch (brk) {
        !            47:                        case '\n':
        !            48:                                if(nlfl) {
        !            49:                                        move(temp,state[++i]);
        !            50:                                        st[i] = &state[i];
        !            51:                                } else {
        !            52:                                        move(temp,def[i]);
        !            53:                                        df[i] = &def[i];
        !            54:                                        nlfl = 1;
        !            55:                                }
        !            56:                                continue;
        !            57:                        case ' ':
        !            58:                                if(nlfl) {
        !            59:                                        move(temp,state[++i]);
        !            60:                                        st[i] = &state[i];
        !            61:                                        nlfl = 0;
        !            62:                                } else {
        !            63:                                        error(7);
        !            64:                                }
        !            65:                                continue;
        !            66:                }
        !            67:        }
        !            68: 
        !            69: 
        !            70:        i = 128;
        !            71:        while(--i) {
        !            72:                class[i][0] = i;
        !            73:                class[i][1] = '\0';
        !            74:                cl[i] = &class[i];
        !            75:        }
        !            76:        cl[0] = &class[0];
        !            77: 
        !            78: 
        !            79:        bfl = nlfl = 0;
        !            80:        t1 = 0;
        !            81:        t2 = -1;
        !            82:        while(c = getchar()) {
        !            83: 
        !            84:                switch(c) {
        !            85: 
        !            86:                        default:
        !            87:                                if(t1 >= NUMA)  error(4);
        !            88:                                bfl = nlfl = 0;
        !            89:                                act[t1][++t2<8?t2:7] = c;
        !            90:                                continue;
        !            91: 
        !            92:                        case '\n':
        !            93:                                if(nlfl)        break;
        !            94:                                nlfl = 1;
        !            95: 
        !            96:                        case ' ':
        !            97:                                if(bfl) continue;
        !            98:                                bfl = 1;
        !            99:                                act[t1][++t2<8?t2:7] = '\0';
        !           100:                                ac[t1] = &act[t1];
        !           101:                                t1++;
        !           102:                                t2 = -1;
        !           103:                                continue;
        !           104:                }
        !           105:        break;
        !           106:        }
        !           107:        if(c == '\0')   exit();
        !           108: 
        !           109:        i = -1;
        !           110:        while(++i < NUMS) {
        !           111:                if(df[i]) {
        !           112:                        cd = find(ac,df[i],NUMA);
        !           113:                        j = -1;
        !           114:                        while(++j < NUMC)
        !           115:                                tab[i].cl[j] = cd;
        !           116:                }
        !           117:        }
        !           118: 
        !           119: 
        !           120:        fl = 0;
        !           121:        i = -1;
        !           122:        while(c = getchar()) {
        !           123: 
        !           124:                switch(c) {
        !           125: 
        !           126:                        case '\\':
        !           127:                                temp[++i] = getchar();
        !           128:                                continue;
        !           129: 
        !           130:                        case '\n':
        !           131:                                if(fl != 1)     continue;
        !           132: 
        !           133:                        default:
        !           134:                                temp[++i] = c;
        !           135:                                continue;
        !           136: 
        !           137:                        case '/':
        !           138:                                temp[++i] = '\0';
        !           139:                                i = -1;
        !           140:                                switch(fl) {
        !           141:                                        case 0:
        !           142:                                                cs = find(st,temp,NUMS);
        !           143:                                                fl = 1;
        !           144:                                                continue;
        !           145: 
        !           146:                                        case 1:
        !           147:                                                cc = find(cl,temp,NUMC);
        !           148:                                                fl = 2;
        !           149:                                                continue;
        !           150: 
        !           151:                                        default:
        !           152:                                                error(1);
        !           153: 
        !           154:                                }
        !           155: 
        !           156:                        case ';':
        !           157: 
        !           158:                                if(fl != 2)     error(2);
        !           159: 
        !           160:                                temp[++i] = '\0';
        !           161:                                i = -1;
        !           162:                                ca = find(ac,temp,NUMA);
        !           163: 
        !           164: /*printf("%o %o %o\n",cs,cc,ca); /*DEBUG*/
        !           165:                                tab[cs].cl[cc] = ca;
        !           166: 
        !           167:                                fl = 0;
        !           168:                                continue;
        !           169: 
        !           170: 
        !           171:                }
        !           172:        }
        !           173: 
        !           174:        i = -1;
        !           175:        while(++i < NUMS)
        !           176:                write(fo,tab[i].cl,256);
        !           177: 
        !           178: }
        !           179: 
        !           180: error(a)
        !           181: {
        !           182: 
        !           183:        printf("Error %d\n",a);
        !           184:        exit();
        !           185: 
        !           186: }
        !           187: 
        !           188: find(a, b, c)
        !           189: char   *a[];
        !           190: char   b[];
        !           191: int    c;
        !           192: {
        !           193:        int     i,j;
        !           194: 
        !           195: /*     printf("%s\n",b); /*DEBUG*/
        !           196:        i = -1;
        !           197:        while(++i < c) {
        !           198: /*     printf("        %s\n",a[i]); /*DEBUG*/
        !           199:                j = 0;
        !           200:                while(b[j] == a[i][j]) {
        !           201:                        if(b[j] == '\0')        goto found;
        !           202:                        j++;
        !           203:                }
        !           204:        }
        !           205: found:
        !           206:        return(i);
        !           207: }
        !           208: 
        !           209: rword() {
        !           210: 
        !           211:        char    c;
        !           212:        int     ct;
        !           213: 
        !           214:        ct = -1;
        !           215:        while(c = getchar()) {
        !           216:                switch(c) {
        !           217: 
        !           218:                        default:
        !           219:                                temp[++ct] = c;
        !           220:                                continue;
        !           221: 
        !           222:                        case '\n':
        !           223:                                if(ct == -1)    return('\0');
        !           224:                        case ' ':
        !           225:                                temp[++ct] = '\0';
        !           226:                                return(c);
        !           227:                }
        !           228:        }
        !           229: }
        !           230: 
        !           231: move(a,b)      char    *a;
        !           232:                char    *b;
        !           233: {
        !           234:        while((*b++ = *a++) != '\0');
        !           235:        return;
        !           236: }
        !           237: 

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