Return to ascii.c CVS log

Up to [Research Unix] / researchv10no / cmd

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

1.1       root        1: #include <stdio.h>
                      2: char *str[128]={
                      3:        "nul",  "soh",  "stx",  "etx",  "eot",  "enq",  "ack",  "bel",
                      4:        "bs ",  "ht ",  "nl ",  "vt ",  "np ",  "cr ",  "so ",  "si ",
                      5:        "dle",  "dc1",  "dc2",  "dc3",  "dc4",  "nak",  "syn",  "etb",
                      6:        "can",  "em ",  "sub",  "esc",  "fs ",  "gs ",  "rs ",  "us ",
                      7:        "sp ",  " ! ",  " \" ", " # ",  " $ ",  " % ",  " & ",  " ' ",
                      8:        " ( ",  " ) ",  " * ",  " + ",  " , ",  " - ",  " . ",  " / ",
                      9:        " 0 ",  " 1 ",  " 2 ",  " 3 ",  " 4 ",  " 5 ",  " 6 ",  " 7 ",
                     10:        " 8 ",  " 9 ",  " : ",  " ; ",  " < ",  " = ",  " > ",  " ? ",
                     11:        " @ ",  " A ",  " B ",  " C ",  " D ",  " E ",  " F ",  " G ",
                     12:        " H ",  " I ",  " J ",  " K ",  " L ",  " M ",  " N ",  " O ",
                     13:        " P ",  " Q ",  " R ",  " S ",  " T ",  " U ",  " V ",  " W ",
                     14:        " X ",  " Y ",  " Z ",  " [ ",  " \\ ", " ] ",  " ^ ",  " _ ",
                     15:        " ` ",  " a ",  " b ",  " c ",  " d ",  " e ",  " f ",  " g ",
                     16:        " h ",  " i ",  " j ",  " k ",  " l ",  " m ",  " n ",  " o ",
                     17:        " p ",  " q ",  " r ",  " s ",  " t ",  " u ",  " v ",  " w ",
                     18:        " x ",  " y ",  " z ",  " { ",  " | ",  " } ",  " ~ ",  "del",
                     19: };
                     20: #define        MAXBASE 36
                     21: char Ncol[]={
                     22:     0,0,7,5,4,4,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
                     23: };
                     24: int    base=8;
                     25: int    ncol;
                     26: int    text=1;
                     27: int    strip=0;
                     28: extern int     optind;
                     29: extern int     opterr;
                     30: extern char    *optarg;
                     31: extern int     optopt;
                     32: main(argc, argv)
                     33:        char *argv[];
                     34: {
                     35:        register i;
                     36:        opterr = 0;
                     37:        for(;;)
                     38:                switch(getopt(argc, argv, "xodntceb:")){
                     39:                case 'x':
                     40:                        base=16;
                     41:                        break;
                     42:                case 'o':
                     43:                        base=8;
                     44:                        break;
                     45:                case 'd':
                     46:                        base=10;
                     47:                        break;
                     48:                case 'b':
                     49:                        base=atoi(optarg);
                     50:                        if(base<2||base>MAXBASE)
                     51:                                usage();
                     52:                        break;
                     53:                case 'n':
                     54:                        text=0;
                     55:                        break;
                     56:                case 't':
                     57:                        strip=1;
                     58:                case 'c':
                     59:                        text=2;
                     60:                        break;
                     61:                case 'e':
                     62:                case EOF:
                     63:                        argc-=optind;
                     64:                        argv+=optind;
                     65:                        goto Done;
                     66:                default:
                     67:                        usage();
                     68:                }
                     69:  Done:
                     70:        ncol=Ncol[base];
                     71:        if(argc==0){
                     72:                for(i=0;i<128;i++){
                     73:                        put(i);
                     74:                        if((i&7)==7)
                     75:                                puts("|\n");
                     76:                }
                     77:        } else {
                     78:                if(text==1)
                     79:                        text=isnum(argv[0]);
                     80:                while(argc--)
                     81:                        if(text)
                     82:                                puttext(*argv++);
                     83:                        else
                     84:                                putnum(*argv++);
                     85:        }
                     86:        if(strip)
                     87:                putchar('\n');
                     88: }
                     89: usage(){
                     90:        fprintf(stderr, "usage: ascii [-xod | -b8] [-nct] [-e] [text]\n");
                     91:        exit(1);
                     92: }
                     93: put(i){
                     94:        putchar('|');
                     95:        putn(i, ncol);
                     96:        putchar(' ');
                     97:        puts(str[i]);
                     98: }
                     99: char dig[]="0123456789abcdefghijklmnopqrstuvwxyz";
                    100: putn(n, ndig)
                    101:        register n;
                    102: {
                    103:        if(ndig==0)
                    104:                return;
                    105:        putn(n/base, ndig-1);
                    106:        putchar(dig[n%base]);
                    107: }
                    108: puts(s)
                    109:        register char *s;
                    110: {
                    111:        fputs(s, stdout);       /* no newline!! */
                    112: }
                    113: puttext(s)
                    114:        register char *s;
                    115: {
                    116:        register n;
                    117:        n=btoi(s)&0177;
                    118:        if(strip)
                    119:                putchar(n);
                    120:        else{
                    121:                puts(str[n]);
                    122:                putchar('\n');
                    123:        }
                    124: }
                    125: putnum(s)
                    126:        register char *s;
                    127: {
                    128:        while(*s){
                    129:                putn(*s++&0177, ncol);
                    130:                putchar('\n');
                    131:        }
                    132: }
                    133: btoi(s)
                    134:        register char *s;
                    135: {
                    136:        register n;
                    137:        n=0;
                    138:        while(*s)
                    139:                n=n*base+value(*s++, 0);
                    140:        return(n);
                    141: }
                    142: value(c, f)
                    143:        register c;
                    144: {
                    145:        register char *s;
                    146:        for(s=dig; s<dig+base; s++)
                    147:                if(*s==c)
                    148:                        return(s-dig);
                    149:        if(f)
                    150:                return(-1);
                    151:        fputs("ascii: bad input char ", stderr);
                    152:        putc(c, stderr);
                    153:        putc('\n', stderr);
                    154:        exit(1);
                    155: }
                    156: isnum(s)
                    157:        register char *s;
                    158: {
                    159:        while(*s)
                    160:                if(value(*s++, 1)==-1)
                    161:                        return(0);
                    162:        return(1);
                    163: }

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