Return to od.c CVS log

Up to [Research Unix] / researchv9 / cmd

Annotation of researchv9/cmd/od.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)od.c        4.2 (Berkeley) 2/7/81";
        !             2: /*
        !             3:  * od -- octal (also hex, decimal, and character) dump
        !             4:  */
        !             5: 
        !             6: #include <stdio.h>
        !             7: 
        !             8: typedef        unsigned long   ulong;
        !             9: 
        !            10: unsigned short word[16];
        !            11: unsigned short lastword[16];
        !            12: short nword =  8;
        !            13: int    conv;
        !            14: int    base =  010;
        !            15: int    max;
        !            16: ulong  addr;
        !            17: #define        DWORD   0700    /* bitmask for double word output formats */
        !            18: 
        !            19: main(argc, argv)
        !            20: char **argv;
        !            21: {
        !            22:        register char *p;
        !            23:        register n, f, same;
        !            24:        char outbuf[BUFSIZ];
        !            25: 
        !            26: #ifdef STANDALONE
        !            27:        if (argv[0][0] == '\0')
        !            28:                argc = getargv("od", &argv, 0);
        !            29: #else
        !            30:        setbuf(stdout, outbuf);
        !            31: #endif
        !            32: 
        !            33:        argv++;
        !            34:        f = 0;
        !            35:        if(argc > 1)
        !            36:        {
        !            37:                p = *argv;
        !            38:                if(*p == '-')
        !            39:                {
        !            40:                        while(*p != '\0')
        !            41:                        {
        !            42:                                switch(*p++)
        !            43:                                {
        !            44:                                case 'o':
        !            45:                                        conv |= 001;
        !            46:                                        f = 6;
        !            47:                                        break;
        !            48:                                case 'd':
        !            49:                                        conv |= 002;
        !            50:                                        f = 5;
        !            51:                                        break;
        !            52:                                case 'x':
        !            53:                                case 'h':
        !            54:                                        conv |= 010;
        !            55:                                        f = 4;
        !            56:                                        break;
        !            57:                                case 'c':
        !            58:                                        conv |= 020;
        !            59:                                        f = 7;
        !            60:                                        break;
        !            61:                                case 'b':
        !            62:                                        conv |= 040;
        !            63:                                        f = 7;
        !            64:                                        break;
        !            65:                                case 'O':
        !            66:                                        conv |= 0100;
        !            67:                                        f = 6;
        !            68:                                        break;
        !            69:                                case 'D':
        !            70:                                        conv |= 0200;
        !            71:                                        f = 5;
        !            72:                                        break;
        !            73:                                case 'H':
        !            74:                                case 'X':
        !            75:                                        conv |= 0400;
        !            76:                                        f = 4;
        !            77:                                        break;
        !            78:                                case 'w':
        !            79:                                        nword = 16;
        !            80:                                        break;
        !            81:                                }
        !            82:                                if(f > max)
        !            83:                                        max = f;
        !            84:                        }
        !            85:                        argc--;
        !            86:                        argv++;
        !            87:                }
        !            88:        }
        !            89:        if(!conv)
        !            90:        {
        !            91:                max = 6;
        !            92:                conv = 1;
        !            93:        }
        !            94:        if(argc > 1)
        !            95:                if(**argv != '+')
        !            96:                {
        !            97:                        if (freopen(*argv, "r", stdin) == NULL)
        !            98:                        {
        !            99:                                fprintf(stderr, "od: cannot open %s\n", *argv);
        !           100:                                exit(2);
        !           101:                        }
        !           102:                        argv++;
        !           103:                        argc--;
        !           104:                }
        !           105:        if(argc > 1)
        !           106:                offset(*argv);
        !           107: 
        !           108:        same = -1;
        !           109:        for ( ; (n = fread((char *)word, 1, sizeof(word[0])*nword, stdin)) > 0; addr += n)
        !           110:        {
        !           111:                if (same>=0)
        !           112:                {
        !           113:                        for (f=0; f<nword; f++)
        !           114:                                if (lastword[f] != word[f])
        !           115:                                        goto notsame;
        !           116:                        if (same==0)
        !           117:                        {
        !           118:                                printf("*\n");
        !           119:                                same = 1;
        !           120:                        }
        !           121:                        continue;
        !           122:                }
        !           123: notsame:
        !           124:                line(addr, word, (n+sizeof(word[0])-1)/sizeof(word[0]));
        !           125:                same = 0;
        !           126:                for (f=0; f<nword; f++)
        !           127:                        lastword[f] = word[f];
        !           128:                for (f=0; f<nword; f++)
        !           129:                        word[f] = 0;
        !           130:        }
        !           131:        putn(addr, base, 7);
        !           132:        putchar('\n');
        !           133:        exit(0);
        !           134: }
        !           135: 
        !           136: line(a, w, n)
        !           137: ulong a;
        !           138: unsigned short *w;
        !           139: {
        !           140:        register i, f, c;
        !           141: 
        !           142:        f = 1;
        !           143:        for(c=1; c; c<<=1)
        !           144:        {
        !           145:                if((c&conv) == 0)
        !           146:                        continue;
        !           147:                if(f)
        !           148:                {
        !           149:                        putn(a, base, 7);
        !           150:                        putchar(' ');
        !           151:                        f = 0;
        !           152:                } 
        !           153:                else
        !           154:                        putchar('\t');
        !           155:                if ( c&DWORD && conv&~DWORD )
        !           156:                        putchar(' ');
        !           157:                for (i=0; i<n; i++)
        !           158:                {
        !           159:                        if(c&DWORD)
        !           160:                        {
        !           161:                                if ((i&01) == 0)
        !           162:                                        putlx((ulong *)(w+i), c);
        !           163:                        }
        !           164:                        else
        !           165:                                putx(w[i], c);
        !           166:                        putchar(i==n-1? '\n': ' ');
        !           167:                }
        !           168:        }
        !           169: }
        !           170: 
        !           171: putx(n, c)
        !           172: unsigned n;
        !           173: {
        !           174: 
        !           175:        switch(c)
        !           176:        {
        !           177:        case 001:
        !           178:                pre(6);
        !           179:                putn((ulong)n, 8, 6);
        !           180:                break;
        !           181:        case 002:
        !           182:                pre(5);
        !           183:                putn((ulong)n, 10, 5);
        !           184:                break;
        !           185:        case 010:
        !           186:                pre(4);
        !           187:                putn((ulong)n, 16, 4);
        !           188:                break;
        !           189:        case 020:
        !           190:                pre(7);
        !           191:                {
        !           192:                        unsigned short sn = n;
        !           193:                        cput(*(char *)&sn);
        !           194:                        putchar(' ');
        !           195:                        cput(*((char *)&sn + 1));
        !           196:                        break;
        !           197:                }
        !           198:        case 040:
        !           199:                pre(7);
        !           200:                {
        !           201:                        unsigned short sn = n;
        !           202:                        putn((ulong)(*(char *)&sn)&0377, 8, 3);
        !           203:                        putchar(' ');
        !           204:                        putn((ulong)(*((char *)&sn + 1))&0377, 8, 3);
        !           205:                        break;
        !           206:                }
        !           207:        }
        !           208: }
        !           209: 
        !           210: putlx(n, c)
        !           211: ulong *n;
        !           212: {
        !           213:        switch(c)
        !           214:        {
        !           215:        case 0100:
        !           216:                pre(6); pre(6);
        !           217:                putn(*n, 8, 12);
        !           218:                break;
        !           219:        case 0200:
        !           220:                pre(5); pre(5);
        !           221:                putn(*n, 10, 10);
        !           222:                break;
        !           223:        case 0400:
        !           224:                pre(4); pre(4);
        !           225:                putn(*n, 16, 8);
        !           226:                break;
        !           227:        }
        !           228: }
        !           229: 
        !           230: cput(c)
        !           231: {
        !           232:        c &= 0377;
        !           233:        if(c>037 && c<0177)
        !           234:        {
        !           235:                printf("  ");
        !           236:                putchar(c);
        !           237:                return;
        !           238:        }
        !           239:        switch(c)
        !           240:        {
        !           241:        case '\0':
        !           242:                printf(" \\0");
        !           243:                break;
        !           244:        case '\b':
        !           245:                printf(" \\b");
        !           246:                break;
        !           247:        case '\f':
        !           248:                printf(" \\f");
        !           249:                break;
        !           250:        case '\n':
        !           251:                printf(" \\n");
        !           252:                break;
        !           253:        case '\r':
        !           254:                printf(" \\r");
        !           255:                break;
        !           256:        case '\t':
        !           257:                printf(" \\t");
        !           258:                break;
        !           259:        default:
        !           260:                putn((ulong)c, 8, 3);
        !           261:        }
        !           262: }
        !           263: 
        !           264: putn(n, b, c)
        !           265: ulong n;
        !           266: unsigned b;
        !           267: {
        !           268:        unsigned d;
        !           269: 
        !           270:        if(!c)
        !           271:                return;
        !           272:        putn(n/b, b, c-1);
        !           273:        d = n%b;
        !           274:        if (d > 9)
        !           275:                putchar(d-10+'a');
        !           276:        else
        !           277:                putchar(d+'0');
        !           278: }
        !           279: 
        !           280: pre(n)
        !           281: {
        !           282:        int i;
        !           283: 
        !           284:        for(i=n; i<max; i++)
        !           285:                putchar(' ');
        !           286: }
        !           287: 
        !           288: offset(s)
        !           289: register char *s;
        !           290: {
        !           291:        register char *p;
        !           292:        ulong a;
        !           293:        register int d;
        !           294: 
        !           295:        if (*s=='+')
        !           296:                s++;
        !           297:        if (*s=='x')
        !           298:        {
        !           299:                s++;
        !           300:                base = 16;
        !           301:        } 
        !           302:        else if (*s=='0' && s[1]=='x')
        !           303:        {
        !           304:                s += 2;
        !           305:                base = 16;
        !           306:        } 
        !           307:        else if (*s == '0')
        !           308:                base = 8;
        !           309:        p = s;
        !           310:        while(*p)
        !           311:        {
        !           312:                if (*p++=='.')
        !           313:                        base = 10;
        !           314:        }
        !           315:        for (a=0; *s; s++)
        !           316:        {
        !           317:                d = *s;
        !           318:                if(d>='0' && d<='9')
        !           319:                        a = a*base + d - '0';
        !           320:                else if (d>='a' && d<='f' && base==16)
        !           321:                        a = a*base + d + 10 - 'a';
        !           322:                else
        !           323:                        break;
        !           324:        }
        !           325:        if (*s == '.')
        !           326:                s++;
        !           327:        if(*s=='b' || *s=='B')
        !           328:                a *= 512;
        !           329:        fseek(stdin, a, 0);
        !           330:        addr = a;
        !           331: }

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