Return to ascii.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/ascii.c, revision 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.