Annotation of researchv10no/cmd/pti.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: #define DBL 0200
                      4: /*
                      5: C version of pti
                      6: */
                      7: 
                      8: char *ap;
                      9: int esc;
                     10: int escd;
                     11: int verd;
                     12: int esct;
                     13: int osize = 02;
                     14: int size = 02;
                     15: int leadtot;
                     16: int railmag;
                     17: int lead;
                     18: int mcase;
                     19: int stab[] = {010,0,01,07,02,03,04,05,0211,06,0212,0213,0214,0215,0216,0217};
                     20: int rtab[] = {6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 28, 36, 18};
                     21: 
                     22: char *asctab[128] = {
                     23: "(blank)",     /*blank*/
                     24: "h",   /*h*/
                     25: "t",   /*t*/
                     26: "n",   /*n*/
                     27: "m",   /*m*/
                     28: "l",   /*l*/
                     29: "i",   /*i*/
                     30: "z",   /*z*/
                     31: "s",   /*s*/
                     32: "d",   /*d*/
                     33: "b",   /*b*/
                     34: "x",   /*x*/
                     35: "f",   /*f*/
                     36: "j",   /*j*/
                     37: "u",   /*u*/
                     38: "k",   /*k*/
                     39: "(blank)",     /*blank*/
                     40: "p",   /*p*/
                     41: "em dash",     /*3/4 em dash*/
                     42: ";",   /*;*/
                     43: "(blank)",     /*blank*/
                     44: "a",   /*a*/
                     45: "_ (baseline)",        /*rule*/
                     46: "c",   /*c*/
                     47: "` (open)",    /*` open*/
                     48: "e",   /*e*/
                     49: "' (close)",   /*' close*/
                     50: "o",   /*o*/
                     51: "1/4", /*1/4*/
                     52: "r",   /*r*/
                     53: "1/2", /*1/2*/
                     54: "v",   /*v*/
                     55: "hyphen",      /*- hyphen*/
                     56: "w",   /*w*/
                     57: "q",   /*q*/
                     58: "/",   /*/*/
                     59: ".",   /*.*/
                     60: "g",   /*g*/
                     61: "3/4", /*3/4*/
                     62: ",",   /*,*/
                     63: "&",   /*&*/
                     64: "y",   /*y*/
                     65: "(blank)",     /*blank*/
                     66: "%",   /*%*/
                     67: "(blank)",     /*blank*/
                     68: "Q",   /*Q*/
                     69: "T",   /*T*/
                     70: "O",   /*O*/
                     71: "H",   /*H*/
                     72: "N",   /*N*/
                     73: "M",   /*M*/
                     74: "L",   /*L*/
                     75: "R",   /*R*/
                     76: "G",   /*G*/
                     77: "I",   /*I*/
                     78: "P",   /*P*/
                     79: "C",   /*C*/
                     80: "V",   /*V*/
                     81: "E",   /*E*/
                     82: "Z",   /*Z*/
                     83: "D",   /*D*/
                     84: "B",   /*B*/
                     85: "S",   /*S*/
                     86: "Y",   /*Y*/
                     87: "(blank)",     /*blank*/
                     88: "F",   /*F*/
                     89: "X",   /*X*/
                     90: "A",   /*A*/
                     91: "W",   /*W*/
                     92: "J",   /*J*/
                     93: "U",   /*U*/
                     94: "K",   /*K*/
                     95: "0",   /*0*/
                     96: "1",   /*1*/
                     97: "2",   /*2*/
                     98: "3",   /*3*/
                     99: "4",   /*4*/
                    100: "5",   /*5*/
                    101: "6",   /*6*/
                    102: "7",   /*7*/
                    103: "8",   /*8*/
                    104: "9",   /*9*/
                    105: "*",   /***/
                    106: "-",   /*minus*/
                    107: "fi",  /*fi*/
                    108: "fl",  /*fl*/
                    109: "ff",  /*ff*/
                    110: "cent",        /*cent sign*/
                    111: "ffl", /*ffl*/
                    112: "ffi", /*ffi*/
                    113: "(",   /*(*/
                    114: ")",   /*)*/
                    115: "[",   /*[*/
                    116: "]",   /*]*/
                    117: "degree",      /*degree*/
                    118: "dagger",      /*dagger*/
                    119: "=",   /*=*/
                    120: "registered",  /*registered*/
                    121: ":",   /*:*/
                    122: "+",   /*+*/
                    123: "(blank)",     /*blank*/
                    124: "!",   /*!*/
                    125: "bullet",      /*bullet*/
                    126: "?",   /*?*/
                    127: "' (foot)",    /*foot mark*/
                    128: "|",   /*|*/
                    129: "(blank)",     /*blank*/
                    130: "copyright",   /*copyright*/
                    131: "[]",  /*square*/
                    132: "$" }; /*$*/
                    133: 
                    134: char *spectab[128] = {
                    135: "(blank)",     /*blank*/
                    136: "psi", /*psi*/
                    137: "theta",       /*theta*/
                    138: "nu",  /*nu*/
                    139: "mu",  /*mu*/
                    140: "lambda",      /*lambda*/
                    141: "iota",        /*iota*/
                    142: "zeta",        /*zeta*/
                    143: "sigma",       /*sigma*/
                    144: "delta",       /*delta*/
                    145: "beta",        /*beta*/
                    146: "xi",  /*xi*/
                    147: "eta", /*eta*/
                    148: "phi", /*phi*/
                    149: "upsilon",     /*upsilon*/
                    150: "kappa",       /*kappa*/
                    151: "(blank)",     /*blank*/
                    152: "pi",  /*pi*/
                    153: "@",   /*at-sign*/
                    154: "down arrow",  /*down arrow*/
                    155: "(blank)",     /*blank*/
                    156: "alpha",       /*alpha*/
                    157: "| or",        /*or*/
                    158: "chi", /*chi*/
                    159: "\"",  /*"*/
                    160: "epsilon",     /*epsilon*/
                    161: "= math",      /*=*/
                    162: "omicron",     /*omicron*/
                    163: "left arrow",  /*left arrow*/
                    164: "rho", /*rho*/
                    165: "up arrow",    /*up arrow*/
                    166: "tau", /*tau*/
                    167: "_ (under)",   /*underrule*/
                    168: "\\",  /*\*/
                    169: "Psi", /*Psi*/
                    170: "bell system sign",    /*bell system sign*/
                    171: "infinity",    /*infinity*/
                    172: "gamma",       /*gamma*/
                    173: "improper superset",   /*improper superset*/
                    174: "proportional to",     /*proportional to*/
                    175: "right hand",  /*right hand*/
                    176: "omega",       /*omega*/
                    177: "(blank)",     /*blank*/
                    178: "gradient",    /*gradient*/
                    179: "(blank)",     /*blank*/
                    180: "Phi", /*Phi*/
                    181: "Theta",       /*Theta*/
                    182: "Omega",       /*Omega*/
                    183: "cup (union)", /*cup (union)*/
                    184: "root en",     /*root en*/
                    185: "terminal sigma",      /*terminal sigma*/
                    186: "Lambda",      /*Lambda*/
                    187: "- math",      /*minus*/
                    188: "Gamma",       /*Gamma*/
                    189: "integral sign",       /*integral sign*/
                    190: "Pi",  /*Pi*/
                    191: "subset of",   /*subset of*/
                    192: "superset of", /*superset of*/
                    193: "approximates",        /*approximates*/
                    194: "partial",     /*partial derivative*/
                    195: "Delta",       /*Delta*/
                    196: "square root", /*square root*/
                    197: "Sigma",       /*Sigma*/
                    198: "approx =",    /*approx =*/
                    199: "(blank)",     /*blank*/
                    200: ">",   /*>*/
                    201: "Xi",  /*Xi*/
                    202: "<",   /*<*/
                    203: "/ (match \\)",        /*slash (longer)*/
                    204: "cap (intersection)",  /*cap (intersection)*/
                    205: "Upsilon",     /*Upsilon*/
                    206: "not", /*not*/
                    207: "right ceiling",       /*right ceiling (rt of ")*/
                    208: "left top curly",      /*left top (of big curly)*/
                    209: "bold vertical",       /*bold vertical*/
                    210: "left center curley",  /*left center of big curly bracket*/
                    211: "left bottom curley",  /*left bottom*/
                    212: "right top curley",    /*right top*/
                    213: "right center curley", /*right center of big curly bracket*/
                    214: "right bottom curley", /*right bot*/
                    215: "right floor", /*right floor (rb of ")*/
                    216: "left floor",  /*left floor (left bot of big sq bract)*/
                    217: "left ceiling",        /*left ceiling (lt of ")*/
                    218: "multiply",    /*multiply*/
                    219: "divide",      /*divide*/
                    220: "+-",  /*plus-minus*/
                    221: "<=",  /*<=*/
                    222: ">=",  /*>=*/
                    223: "==",  /*identically equal*/
                    224: "not equal",   /*not equal*/
                    225: "{",   /*{*/
                    226: "}",   /*}*/
                    227: "'",   /*' acute accent*/
                    228: "`",   /*` grave accent*/
                    229: "^",   /*^*/
                    230: "#",   /*sharp*/
                    231: "left hand",   /*left hand*/
                    232: "member of",   /*member of*/
                    233: "~",   /*~*/
                    234: "empty set",   /*empty set*/
                    235: "(blank)",     /*blank*/
                    236: "dbl dagger",  /*dbl dagger*/
                    237: "| (box rule)",        /*box rule*/
                    238: "*",   /*asterisk*/
                    239: "improper subset",     /*improper subset*/
                    240: "circle",      /*circle*/
                    241: "(blank)",     /*blank*/
                    242: "+ math",      /*eqn plus*/
                    243: "right arrow", /*right arrow*/
                    244: "section mark" };      /*section mark*/
                    245: 
                    246: long offset;
                    247: int lflg;
                    248: 
                    249: main(argc,argv)
                    250: int argc;
                    251: char **argv;
                    252: {
                    253:        register i, j;
                    254:        register char *k;
                    255:        extern ex();
                    256: 
                    257:        while((--argc > 0) && ((++argv)[0][0]=='-')){
                    258:                switch(argv[0][1]){
                    259:                        case 'l':
                    260:                                lflg++;
                    261:                                continue;
                    262:                        default:
                    263:                                ap = &argv[0][1];
                    264:                                while(((j = *ap++ - '0') >= 0)
                    265:                                        && (j <= 9))offset = 8*offset +j;
                    266:                                continue;
                    267:                }
                    268:        }
                    269:        if(argc){
                    270:                if (freopen(argv[0], "r", stdin) == NULL) {
                    271:                        printf("Cannot open: %s\n",argv[0]);
                    272:                        exit(1);
                    273:                }
                    274:        }
                    275:        if (offset)
                    276:                fseek(stdin, offset, 0);
                    277:        while((i = getchar()) != EOF){
                    278:                if(i & 0200){
                    279:                        if(!lflg)printf("%o ",i);
                    280:                        esc += (~i) & 0177;
                    281:                        continue;
                    282:                }
                    283:                if(esc){
                    284:                        if(escd){
                    285:                                if(!lflg)printf("< %d\n",esc);
                    286:                                esc = -esc;
                    287:                        }else{
                    288:                                if(!lflg)printf("> %d\n",esc);
                    289:                        }
                    290:                        esct += esc;
                    291:                        esc = 0;
                    292:                }
                    293:                if(!lflg)printf("%o ",i);
                    294:                if(!i){if(!lflg)printf("\n"); continue;}
                    295:                switch(i){
                    296:                        case 0100:      /*init*/
                    297:                                escd = verd = mcase = railmag = 0;
                    298:                                if(!lflg)printf("Initialize\n");
                    299:                                continue;
                    300:                        case 0101:      /*lower rail*/
                    301:                                railmag &= ~01;
                    302:                                if(!lflg)printf("Lower rail\n");
                    303:                                continue;
                    304:                        case 0102:      /*upper rail*/
                    305:                                railmag |= 01;
                    306:                                if(!lflg)printf("Upper rail\n");
                    307:                                continue;
                    308:                        case 0103:      /*upper mag*/
                    309:                                railmag |= 02;
                    310:                                if(!lflg)printf("Upper mag\n");
                    311:                                continue;
                    312:                        case 0104:      /*lower mag*/
                    313:                                railmag &= ~02;
                    314:                                if(!lflg)printf("Lower mag\n");
                    315:                                continue;
                    316:                        case 0105:      /*lower case*/
                    317:                                mcase = 0;
                    318:                                if(!lflg)printf("Lower case\n");
                    319:                                continue;
                    320:                        case 0106:      /*upper case*/
                    321:                                mcase = 0100;
                    322:                                if(!lflg)printf("Upper case\n");
                    323:                                continue;
                    324:                        case 0107:      /*escape forward*/
                    325:                                escd = 0;
                    326:                                if(!lflg)printf("> mode, %d\n",esct);
                    327:                                continue;
                    328:                        case 0110:      /*escape backward*/
                    329:                                escd = 1;
                    330:                                if(!lflg)printf("< mode, %d\n",esct);
                    331:                                continue;
                    332:                        case 0111:      /*stop*/
                    333:                                if(!lflg)printf("STOP\n");
                    334:                                continue;
                    335:                        case 0112:      /*lead forward*/
                    336:                                verd = 0;
                    337:                                if(!lflg)printf("Lead forward, %d\n",leadtot);
                    338:                                continue;
                    339:                        case 0114:      /*lead backward*/
                    340:                                verd = 1;
                    341:                                if(!lflg)printf("Lead backward, %d\n",leadtot);
                    342:                                continue;
                    343:                        case 0115:      /*undefined*/
                    344:                        case 0116:
                    345:                        case 0117:
                    346:                        case 0113:
                    347:                                if(!lflg)printf("Undefined code\n");
                    348:                                continue;
                    349:                }
                    350:                if((i & 0340) == 0140){ /*leading*/
                    351:                        lead = (~i) & 037;
                    352:                        if(!lflg)printf("Lead %d\n",lead);
                    353:                        if(verd)lead = -lead;
                    354:                        leadtot += lead;
                    355:                        continue;
                    356:                }
                    357:                if((i & 0360) == 0120){ /*size change*/
                    358:                        i &= 017;
                    359:                        for(j = 0; i != (stab[j] & 017); j++);
                    360:                        osize = size;
                    361:                        size = stab[j];
                    362:                        if(!lflg){
                    363:                                printf("Size %d",rtab[j]);
                    364:                                if(!(osize & DBL) && (size & DBL))printf(", double\n");
                    365:                                else if((osize & DBL) && !(size & DBL))printf(", single\n");
                    366:                                else printf("\n");
                    367:                        }
                    368:                        continue;
                    369:                }
                    370:                if(i & 0300)continue;
                    371:                i = (i & 077) | mcase;
                    372:                if(railmag != 03)k = asctab[i];
                    373:                else k = spectab[i];
                    374:                if(!lflg)printf("%s\n",k);
                    375:                continue;
                    376:        }
                    377:        ex();
                    378: }
                    379: ex(){
                    380:        printf("Total lead %d\n",leadtot);
                    381:        exit(0);
                    382: }

unix.superglobalmegacorp.com

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