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

1.1       root        1: #include <fio.h>
                      2: 
                      3: unsigned char  odata[16];
                      4: unsigned char  data[16];
                      5: int            ndata;
                      6: unsigned long  addr;
                      7: Fbuffer                buf;
                      8: int            repeats;
                      9: int            swizzle;
                     10: int            abase=2;
                     11: 
                     12: enum{
                     13:        Narg=10
                     14: };
                     15: typedef struct Arg Arg;
                     16: struct Arg{
                     17:        int     ascii;          /* 0==none, 1==ascii */
                     18:        int     loglen;         /* 0==1, 1==2, 2==4 */
                     19:        int     base;           /* 0==8, 1==10, 2==16 */
                     20:        int     (*fn)();        /* function to call with data */
                     21:        char    *afmt;          /* format to use to print address */
                     22:        char    *fmt;           /* format to use to print data */
                     23: }arg[Narg];
                     24: int    narg;
                     25: 
                     26: extern int     fmt0(), fmt1(), fmt2(), fmtc();
                     27: 
                     28: int (*fmt[3])()={
                     29:        fmt0,   fmt1,   fmt2,
                     30: };
                     31: char *dfmt[3][3]={
                     32:        " %.3uo",       " %.3ud",       " %.2ux",
                     33:        " %.6uo",       " %.5ud",       " %.4ux",
                     34:        " %.11luo",     " %.10lud",     " %.8lux",
                     35: };
                     36: char *cfmt[3][3]={
                     37:        "   %c",        "   %c",        "  %c",
                     38:        " %.3s",        " %.3s",        " %.2s",
                     39:        " %.3uo",       " %.3ud",       " %.2ux",
                     40: };
                     41: char *afmt[2][3]={
                     42:        "%.7luo ",      "%.7lud ",      "%.7lux ",
                     43:        "%7luo ",       "%7lud ",       "%7lux ",
                     44: };
                     45: main(argc, argv)
                     46:        char *argv[];
                     47: {
                     48:        int err=0;
                     49:        register Arg *ap;
                     50:        while(argc>1 && argv[1][0]=='-' && argv[1][1]){
                     51:                --argc;
                     52:                argv++;
                     53:                argv[0]++;
                     54:                if(argv[0][0]=='r'){
                     55:                        repeats=1;
                     56:                        if(argv[0][1])
                     57:                                goto Usage;
                     58:                        continue;
                     59:                }
                     60:                if(argv[0][0]=='s'){
                     61:                        swizzle=1;
                     62:                        if(argv[0][1])
                     63:                                goto Usage;
                     64:                        continue;
                     65:                }
                     66:                if(argv[0][0]=='a'){
                     67:                        argv[0]++;
                     68:                        switch(argv[0][0]){
                     69:                        case 'o':
                     70:                                abase=0;
                     71:                                break;
                     72:                        case 'd':
                     73:                                abase=1;
                     74:                                break;
                     75:                        case 'x':
                     76:                                abase=2;
                     77:                                break;
                     78:                        default:
                     79:                                goto Usage;
                     80:                        }
                     81:                        if(argv[0][1])
                     82:                                goto Usage;
                     83:                        continue;
                     84:                }
                     85:                ap=&arg[narg];
                     86:                initarg();
                     87:                while(argv[0][0]){
                     88:                        switch(argv[0][0]){
                     89:                        case 'c':
                     90:                                ap->ascii=1;
                     91:                                ap->loglen=0;
                     92:                                if(argv[0][1] || argv[0][-1]!='-')
                     93:                                        goto Usage;
                     94:                                break;
                     95:                        case 'o':
                     96:                                ap->base=0;
                     97:                                break;
                     98:                        case 'd':
                     99:                                ap->base=1;
                    100:                                break;
                    101:                        case 'x':
                    102:                                ap->base=2;
                    103:                                break;
                    104:                        case 'b':
                    105:                        case '1':
                    106:                                ap->loglen=0;
                    107:                                break;
                    108:                        case 'w':
                    109:                        case '2':
                    110:                                ap->loglen=1;
                    111:                                break;
                    112:                        case 'l':
                    113:                        case '4':
                    114:                                ap->loglen=2;
                    115:                                break;
                    116:                        default:
                    117:                        Usage:
                    118:    fprint(2, "usage: xd [-r] [-s] [-a{odx}] [-c|{b1w2l4}{odx}] ... file ...\n");
                    119:                                return 1;
                    120:                        }
                    121:                        argv[0]++;
                    122:                }
                    123:                if(ap->ascii)
                    124:                        ap->fn=fmtc;
                    125:                else
                    126:                        ap->fn=fmt[ap->loglen];
                    127:                ap->fmt=dfmt[ap->loglen][ap->base];
                    128:                ap->afmt=afmt[ap>arg][abase];
                    129:        }
                    130:        if(narg==0)
                    131:                initarg();
                    132:        if(argc==1)
                    133:                err=xd((char *)0, 0);
                    134:        else if(argc==2)
                    135:                err=xd(argv[1], 0);
                    136:        else while(argc-->1)
                    137:                err|=xd(argv[1], 1);
                    138:        return err;
                    139: }
                    140: initarg(){
                    141:        register Arg *ap;
                    142:        ap=&arg[narg++];
                    143:        if(narg>=Narg){
                    144:                fprint(2, "xd: too many formats (max %d)\n", Narg);
                    145:                exit(1);
                    146:        }
                    147:        ap->ascii=0;
                    148:        ap->loglen=2;
                    149:        ap->base=2;
                    150:        ap->fn=fmt2;
                    151:        ap->fmt=dfmt[ap->loglen][ap->base];
                    152:        ap->afmt=afmt[narg>1][abase];
                    153: }
                    154: xd(name, title)
                    155:        char *name;
                    156:        int title;
                    157: {
                    158:        register fd=name? open(name, 0) : 0;
                    159:        register i, star;
                    160:        register Arg *ap;
                    161:        if(fd<0){
                    162:                fprint(2, "xd: can't open %s\n", name);
                    163:                return 1;
                    164:        }
                    165:        if(title)
                    166:                Fprint(1, "%s\n", name);
                    167:        Finit(fd, &buf);
                    168:        addr=0;
                    169:        star=0;
                    170:        while((ndata=Fread(fd, data, 16L))>=0){
                    171:                if(ndata<16)
                    172:                        for(i=ndata; i<16; i++)
                    173:                                data[i]=0;
                    174:                if(swizzle)
                    175:                        swizz();
                    176:                if(ndata==16 && repeats){
                    177:                        if(addr>0 && data[0]==odata[0]){
                    178:                                for(i=1; i<16; i++)
                    179:                                        if(data[i]!=odata[i])
                    180:                                                break;
                    181:                                if(i==16){
                    182:                                        addr+=16;
                    183:                                        if(star==0){
                    184:                                                star++;
                    185:                                                Fprint(1, "*\n");
                    186:                                        }
                    187:                                        continue;
                    188:                                }
                    189:                        }
                    190:                        for(i=0; i<16; i++)
                    191:                                odata[i]=data[i];
                    192:                        star=0;
                    193:                }
                    194:                for(ap=arg; ap<&arg[narg]; ap++){
                    195:                        Fprint(1, ap->afmt, addr);
                    196:                        (*ap->fn)(ap->fmt);
                    197:                        Fprint(1, "\n");
                    198:                }
                    199:                addr+=ndata;
                    200:                if(ndata<16){
                    201:                        Fprint(1, afmt[0][abase], addr);
                    202:                        Fprint(1, "\n");
                    203:                        break;
                    204:                }
                    205:        }
                    206:        return 0;
                    207: }
                    208: swizz(){
                    209:        unsigned char *p, *q;
                    210:        int i;
                    211:        unsigned char swdata[16];
                    212:        p=data;
                    213:        q=swdata;
                    214:        for(i=0; i<16; i++)
                    215:                *q++=*p++;
                    216:        p=data;
                    217:        q=swdata;
                    218:        for(i=0; i<4; i++, q+=4){
                    219:                *p++=q[3];
                    220:                *p++=q[2];
                    221:                *p++=q[1];
                    222:                *p++=q[0];
                    223:        }
                    224: }
                    225: fmt0(f)
                    226:        char *f;
                    227: {
                    228:        register i;
                    229:        for(i=0; i<ndata; i++)
                    230:                Fprint(1, f, data[i]);
                    231: }
                    232: fmt1(f)
                    233:        char *f;
                    234: {
                    235:        register i;
                    236:        for(i=0; i<ndata; i+=sizeof(unsigned short))
                    237:                Fprint(1, f, *(unsigned short *)&data[i]);
                    238: }
                    239: fmt2(f)
                    240:        char *f;
                    241: {
                    242:        register i;
                    243:        for(i=0; i<ndata; i+=sizeof(unsigned long))
                    244:                Fprint(1, f, *(unsigned long *)&data[i]);
                    245: }
                    246: fmtc()
                    247: {
                    248:        register i;
                    249:        for(i=0; i<ndata; i++)
                    250:                switch(data[i]){
                    251:                case '\t':
                    252:                        Fprint(1, cfmt[1][2], "\\t");
                    253:                        break;
                    254:                case '\r':
                    255:                        Fprint(1, cfmt[1][2], "\\r");
                    256:                        break;
                    257:                case '\n':
                    258:                        Fprint(1, cfmt[1][2], "\\n");
                    259:                        break;
                    260:                case '\b':
                    261:                        Fprint(1, cfmt[1][2], "\\b");
                    262:                        break;
                    263:                default:
                    264:                        if(data[i]>=0x7F || ' '>data[i])
                    265:                                Fprint(1, cfmt[2][2], data[i]);
                    266:                        else
                    267:                                Fprint(1, cfmt[0][2], data[i]);
                    268:                        break;
                    269:                }
                    270: }

unix.superglobalmegacorp.com

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