Return to od.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/od.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * od -- octal (also hex, decimal, and character) dump
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: 
        !             7: unsigned short word[8];
        !             8: unsigned short lastword[8];
        !             9: int    conv;
        !            10: int    base =  010;
        !            11: int    max;
        !            12: long   addr;
        !            13: 
        !            14: main(argc, argv)
        !            15: char **argv;
        !            16: {
        !            17:        register char *p;
        !            18:        register n, f, same;
        !            19: 
        !            20: 
        !            21:        argv++;
        !            22:        f = 0;
        !            23:        if(argc > 1) {
        !            24:                p = *argv;
        !            25:                if(*p == '-') {
        !            26:                        while(*p != '\0') {
        !            27:                                switch(*p++) {
        !            28:                                case 'o':
        !            29:                                        conv |= 001;
        !            30:                                        f = 6;
        !            31:                                        break;
        !            32:                                case 'd':
        !            33:                                        conv |= 002;
        !            34:                                        f = 5;
        !            35:                                        break;
        !            36:                                case 'x':
        !            37:                                case 'h':
        !            38:                                        conv |= 010;
        !            39:                                        f = 4;
        !            40:                                        break;
        !            41:                                case 'c':
        !            42:                                        conv |= 020;
        !            43:                                        f = 7;
        !            44:                                        break;
        !            45:                                case 'b':
        !            46:                                        conv |= 040;
        !            47:                                        f = 7;
        !            48:                                        break;
        !            49:                                }
        !            50:                                if(f > max)
        !            51:                                        max = f;
        !            52:                        }
        !            53:                        argc--;
        !            54:                        argv++;
        !            55:                }
        !            56:        }
        !            57:        if(!conv) {
        !            58:                max = 6;
        !            59:                conv = 1;
        !            60:        }
        !            61:        if(argc > 1)
        !            62:        if(**argv != '+') {
        !            63:                if (freopen(*argv, "r", stdin) == NULL) {
        !            64:                        printf("cannot open %s\n", *argv);
        !            65:                        exit(1);
        !            66:                }
        !            67:                argv++;
        !            68:                argc--;
        !            69:        }
        !            70:        if(argc > 1)
        !            71:                offset(*argv);
        !            72: 
        !            73:        same = -1;
        !            74:        for ( ; (n = fread((char *)word, 1, sizeof(word), stdin)) > 0; addr += n) {
        !            75:                if (same>=0) {
        !            76:                        for (f=0; f<8; f++)
        !            77:                                if (lastword[f] != word[f])
        !            78:                                        goto notsame;
        !            79:                        if (same==0) {
        !            80:                                printf("*\n");
        !            81:                                same = 1;
        !            82:                        }
        !            83:                        continue;
        !            84:                }
        !            85:        notsame:
        !            86:                line(addr, word, (n+sizeof(word[0])-1)/sizeof(word[0]));
        !            87:                same = 0;
        !            88:                for (f=0; f<8; f++)
        !            89:                        lastword[f] = word[f];
        !            90:                for (f=0; f<8; f++)
        !            91:                        word[f] = 0;
        !            92:        }
        !            93:        putn(addr, base, 7);
        !            94:        putchar('\n');
        !            95: }
        !            96: 
        !            97: line(a, w, n)
        !            98: long a;
        !            99: unsigned short *w;
        !           100: {
        !           101:        register i, f, c;
        !           102: 
        !           103:        f = 1;
        !           104:        for(c=1; c; c<<=1) {
        !           105:                if((c&conv) == 0)
        !           106:                        continue;
        !           107:                if(f) {
        !           108:                        putn(a, base, 7);
        !           109:                        putchar(' ');
        !           110:                        f = 0;
        !           111:                } else
        !           112:                        putchar('\t');
        !           113:                for (i=0; i<n; i++) {
        !           114:                        putx(w[i], c);
        !           115:                        putchar(i==n-1? '\n': ' ');
        !           116:                }
        !           117:        }
        !           118: }
        !           119: 
        !           120: putx(n, c)
        !           121: unsigned n;
        !           122: {
        !           123: 
        !           124:        switch(c) {
        !           125:        case 001:
        !           126:                pre(6);
        !           127:                putn((long)n, 8, 6);
        !           128:                break;
        !           129:        case 002:
        !           130:                pre(5);
        !           131:                putn((long)n, 10, 5);
        !           132:                break;
        !           133:        case 010:
        !           134:                pre(4);
        !           135:                putn((long)n, 16, 4);
        !           136:                break;
        !           137:        case 020:
        !           138:                pre(7);
        !           139:                {
        !           140:                        unsigned short sn = n;
        !           141:                        cput(*(char *)&sn);
        !           142:                        putchar(' ');
        !           143:                        cput(*((char *)&sn + 1));
        !           144:                        break;
        !           145:                }
        !           146:        case 040:
        !           147:                pre(7);
        !           148:                {
        !           149:                        unsigned short sn = n;
        !           150:                        putn((long)(*(char *)&sn)&0377, 8, 3);
        !           151:                        putchar(' ');
        !           152:                        putn((long)(*((char *)&sn + 1))&0377, 8, 3);
        !           153:                        break;
        !           154:                }
        !           155:        }
        !           156: }
        !           157: 
        !           158: cput(c)
        !           159: {
        !           160:        c &= 0377;
        !           161:        if(c>037 && c<0177) {
        !           162:                printf("  ");
        !           163:                putchar(c);
        !           164:                return;
        !           165:        }
        !           166:        switch(c) {
        !           167:        case '\0':
        !           168:                printf(" \\0");
        !           169:                break;
        !           170:        case '\b':
        !           171:                printf(" \\b");
        !           172:                break;
        !           173:        case '\f':
        !           174:                printf(" \\f");
        !           175:                break;
        !           176:        case '\n':
        !           177:                printf(" \\n");
        !           178:                break;
        !           179:        case '\r':
        !           180:                printf(" \\r");
        !           181:                break;
        !           182:        case '\t':
        !           183:                printf(" \\t");
        !           184:                break;
        !           185:        default:
        !           186:                putn((long)c, 8, 3);
        !           187:        }
        !           188: }
        !           189: 
        !           190: putn(n, b, c)
        !           191: long n;
        !           192: {
        !           193:        register d;
        !           194: 
        !           195:        if(!c)
        !           196:                return;
        !           197:        putn(n/b, b, c-1);
        !           198:        d = n%b;
        !           199:        if (d > 9)
        !           200:                putchar(d-10+'a');
        !           201:        else
        !           202:                putchar(d+'0');
        !           203: }
        !           204: 
        !           205: pre(n)
        !           206: {
        !           207:        int i;
        !           208: 
        !           209:        for(i=n; i<max; i++)
        !           210:                putchar(' ');
        !           211: }
        !           212: 
        !           213: offset(s)
        !           214: register char *s;
        !           215: {
        !           216:        register char *p;
        !           217:        long a;
        !           218:        register int d;
        !           219: 
        !           220:        if (*s=='+')
        !           221:                s++;
        !           222:        if (*s=='x') {
        !           223:                s++;
        !           224:                base = 16;
        !           225:        } else if (*s=='0' && s[1]=='x') {
        !           226:                s += 2;
        !           227:                base = 16;
        !           228:        } else if (*s == '0')
        !           229:                base = 8;
        !           230:        p = s;
        !           231:        while(*p) {
        !           232:                if (*p++=='.')
        !           233:                        base = 10;
        !           234:        }
        !           235:        for (a=0; *s; s++) {
        !           236:                d = *s;
        !           237:                if(d>='0' && d<='9')
        !           238:                        a = a*base + d - '0';
        !           239:                else if (d>='a' && d<='f' && base==16)
        !           240:                        a = a*base + d + 10 - 'a';
        !           241:                else
        !           242:                        break;
        !           243:        }
        !           244:        if (*s == '.')
        !           245:                s++;
        !           246:        if(*s=='b' || *s=='B')
        !           247:                a *= 512;
        !           248:        fseek(stdin, a, 0);
        !           249:        addr = a;
        !           250: }

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