![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / hexdump|
Return to display.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / hexdump |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that: (1) source distributions retain this entire copyright ! 7: * notice and comment, and (2) distributions including binaries display ! 8: * the following acknowledgement: ``This product includes software ! 9: * developed by the University of California, Berkeley and its contributors'' ! 10: * in the documentation or other materials provided with the distribution ! 11: * and in all advertising materials mentioning features or use of this ! 12: * software. Neither the name of the University nor the names of its ! 13: * contributors may be used to endorse or promote products derived ! 14: * from this software without specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: static char sccsid[] = "@(#)display.c 5.10 (Berkeley) 6/1/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #include <sys/param.h> ! 25: #include <sys/stat.h> ! 26: #include <unistd.h> ! 27: #include <errno.h> ! 28: #include <ctype.h> ! 29: #include <stdio.h> ! 30: #include <string.h> ! 31: #include "hexdump.h" ! 32: ! 33: enum _vflag vflag = FIRST; ! 34: ! 35: static off_t address; /* address/offset in stream */ ! 36: static off_t eaddress; /* end address */ ! 37: static off_t savaddress; /* saved address/offset in stream */ ! 38: ! 39: #define PRINT { \ ! 40: switch(pr->flags) { \ ! 41: case F_ADDRESS: \ ! 42: (void)printf(pr->fmt, address); \ ! 43: break; \ ! 44: case F_BPAD: \ ! 45: (void)printf(pr->fmt, ""); \ ! 46: break; \ ! 47: case F_C: \ ! 48: conv_c(pr, bp); \ ! 49: break; \ ! 50: case F_CHAR: \ ! 51: (void)printf(pr->fmt, *bp); \ ! 52: break; \ ! 53: case F_DBL: { \ ! 54: double dval; \ ! 55: float fval; \ ! 56: switch(pr->bcnt) { \ ! 57: case 4: \ ! 58: bcopy((char *)bp, (char *)&fval, sizeof(fval)); \ ! 59: (void)printf(pr->fmt, fval); \ ! 60: break; \ ! 61: case 8: \ ! 62: bcopy((char *)bp, (char *)&dval, sizeof(dval)); \ ! 63: (void)printf(pr->fmt, dval); \ ! 64: break; \ ! 65: } \ ! 66: break; \ ! 67: } \ ! 68: case F_INT: { \ ! 69: int ival; \ ! 70: short sval; \ ! 71: switch(pr->bcnt) { \ ! 72: case 1: \ ! 73: (void)printf(pr->fmt, (int)*bp); \ ! 74: break; \ ! 75: case 2: \ ! 76: bcopy((char *)bp, (char *)&sval, sizeof(sval)); \ ! 77: (void)printf(pr->fmt, (int)sval); \ ! 78: break; \ ! 79: case 4: \ ! 80: bcopy((char *)bp, (char *)&ival, sizeof(ival)); \ ! 81: (void)printf(pr->fmt, ival); \ ! 82: break; \ ! 83: } \ ! 84: break; \ ! 85: } \ ! 86: case F_P: \ ! 87: (void)printf(pr->fmt, isprint(*bp) ? *bp : '.'); \ ! 88: break; \ ! 89: case F_STR: \ ! 90: (void)printf(pr->fmt, (char *)bp); \ ! 91: break; \ ! 92: case F_TEXT: \ ! 93: (void)printf(pr->fmt); \ ! 94: break; \ ! 95: case F_U: \ ! 96: conv_u(pr, bp); \ ! 97: break; \ ! 98: case F_UINT: { \ ! 99: u_int ival; \ ! 100: u_short sval; \ ! 101: switch(pr->bcnt) { \ ! 102: case 1: \ ! 103: (void)printf(pr->fmt, (u_int)*bp); \ ! 104: break; \ ! 105: case 2: \ ! 106: bcopy((char *)bp, (char *)&sval, sizeof(sval)); \ ! 107: (void)printf(pr->fmt, (u_int)sval); \ ! 108: break; \ ! 109: case 4: \ ! 110: bcopy((char *)bp, (char *)&ival, sizeof(ival)); \ ! 111: (void)printf(pr->fmt, ival); \ ! 112: break; \ ! 113: } \ ! 114: break; \ ! 115: } \ ! 116: } \ ! 117: } ! 118: ! 119: display() ! 120: { ! 121: extern FU *endfu; ! 122: register FS *fs; ! 123: register FU *fu; ! 124: register PR *pr; ! 125: register int cnt; ! 126: register u_char *bp; ! 127: off_t saveaddress; ! 128: u_char savech, *savebp, *get(); ! 129: ! 130: while (bp = get()) ! 131: for (fs = fshead, savebp = bp, saveaddress = address; fs; ! 132: fs = fs->nextfs, bp = savebp, address = saveaddress) ! 133: for (fu = fs->nextfu; fu; fu = fu->nextfu) { ! 134: if (fu->flags&F_IGNORE) ! 135: break; ! 136: for (cnt = fu->reps; cnt; --cnt) ! 137: for (pr = fu->nextpr; pr; address += pr->bcnt, ! 138: bp += pr->bcnt, pr = pr->nextpr) { ! 139: if (eaddress && address >= eaddress && ! 140: !(pr->flags&(F_TEXT|F_BPAD))) ! 141: bpad(pr); ! 142: if (cnt == 1 && pr->nospace) { ! 143: savech = *pr->nospace; ! 144: *pr->nospace = '\0'; ! 145: } ! 146: PRINT; ! 147: if (cnt == 1 && pr->nospace) ! 148: *pr->nospace = savech; ! 149: } ! 150: } ! 151: if (endfu) { ! 152: /* ! 153: * if eaddress not set, error or file size was multiple of ! 154: * blocksize, and no partial block ever found. ! 155: */ ! 156: if (!eaddress) { ! 157: if (!address) ! 158: return; ! 159: eaddress = address; ! 160: } ! 161: for (pr = endfu->nextpr; pr; pr = pr->nextpr) ! 162: switch(pr->flags) { ! 163: case F_ADDRESS: ! 164: (void)printf(pr->fmt, eaddress); ! 165: break; ! 166: case F_TEXT: ! 167: (void)printf(pr->fmt); ! 168: break; ! 169: } ! 170: } ! 171: } ! 172: ! 173: bpad(pr) ! 174: PR *pr; ! 175: { ! 176: static char *spec = " -0+#"; ! 177: register char *p1, *p2; ! 178: ! 179: /* ! 180: * remove all conversion flags; '-' is the only one valid ! 181: * with %s, and it's not useful here. ! 182: */ ! 183: pr->flags = F_BPAD; ! 184: *pr->cchar = 's'; ! 185: for (p1 = pr->fmt; *p1 != '%'; ++p1); ! 186: for (p2 = ++p1; *p1 && index(spec, *p1); ++p1); ! 187: while (*p2++ = *p1++); ! 188: } ! 189: ! 190: static char **_argv; ! 191: ! 192: u_char * ! 193: get() ! 194: { ! 195: extern enum _vflag vflag; ! 196: extern int length; ! 197: static int ateof = 1; ! 198: static u_char *curp, *savp; ! 199: register int n; ! 200: int need, nread; ! 201: u_char *tmpp; ! 202: ! 203: if (!curp) { ! 204: curp = (u_char *)emalloc(blocksize); ! 205: savp = (u_char *)emalloc(blocksize); ! 206: } else { ! 207: tmpp = curp; ! 208: curp = savp; ! 209: savp = tmpp; ! 210: address = savaddress += blocksize; ! 211: } ! 212: for (need = blocksize, nread = 0;;) { ! 213: /* ! 214: * if read the right number of bytes, or at EOF for one file, ! 215: * and no other files are available, zero-pad the rest of the ! 216: * block and set the end flag. ! 217: */ ! 218: if (!length || ateof && !next((char **)NULL)) { ! 219: if (need == blocksize) ! 220: return((u_char *)NULL); ! 221: if (vflag != ALL && !bcmp(curp, savp, nread)) { ! 222: if (vflag != DUP) ! 223: (void)printf("*\n"); ! 224: return((u_char *)NULL); ! 225: } ! 226: bzero((char *)curp + nread, need); ! 227: eaddress = address + nread; ! 228: return(curp); ! 229: } ! 230: n = fread((char *)curp + nread, sizeof(u_char), ! 231: length == -1 ? need : MIN(length, need), stdin); ! 232: if (!n) { ! 233: if (ferror(stdin)) ! 234: (void)fprintf(stderr, "hexdump: %s: %s\n", ! 235: _argv[-1], strerror(errno)); ! 236: ateof = 1; ! 237: continue; ! 238: } ! 239: ateof = 0; ! 240: if (length != -1) ! 241: length -= n; ! 242: if (!(need -= n)) { ! 243: if (vflag == ALL || vflag == FIRST || ! 244: bcmp(curp, savp, blocksize)) { ! 245: if (vflag == DUP || vflag == FIRST) ! 246: vflag = WAIT; ! 247: return(curp); ! 248: } ! 249: if (vflag == WAIT) ! 250: (void)printf("*\n"); ! 251: vflag = DUP; ! 252: address = savaddress += blocksize; ! 253: need = blocksize; ! 254: nread = 0; ! 255: } ! 256: else ! 257: nread += n; ! 258: } ! 259: } ! 260: ! 261: extern off_t skip; /* bytes to skip */ ! 262: ! 263: next(argv) ! 264: char **argv; ! 265: { ! 266: extern int errno, exitval; ! 267: static int done; ! 268: int statok; ! 269: ! 270: if (argv) { ! 271: _argv = argv; ! 272: return(1); ! 273: } ! 274: for (;;) { ! 275: if (*_argv) { ! 276: if (!(freopen(*_argv, "r", stdin))) { ! 277: (void)fprintf(stderr, "hexdump: %s: %s\n", ! 278: *_argv, strerror(errno)); ! 279: exitval = 1; ! 280: ++_argv; ! 281: continue; ! 282: } ! 283: statok = done = 1; ! 284: } else { ! 285: if (done++) ! 286: return(0); ! 287: statok = 0; ! 288: } ! 289: if (skip) ! 290: doskip(statok ? *_argv : "stdin", statok); ! 291: if (*_argv) ! 292: ++_argv; ! 293: if (!skip) ! 294: return(1); ! 295: } ! 296: /* NOTREACHED */ ! 297: } ! 298: ! 299: doskip(fname, statok) ! 300: char *fname; ! 301: int statok; ! 302: { ! 303: extern int errno; ! 304: struct stat sbuf; ! 305: ! 306: if (statok) { ! 307: if (fstat(fileno(stdin), &sbuf)) { ! 308: (void)fprintf(stderr, "hexdump: %s: %s.\n", ! 309: fname, strerror(errno)); ! 310: exit(1); ! 311: } ! 312: if (skip >= sbuf.st_size) { ! 313: skip -= sbuf.st_size; ! 314: address += sbuf.st_size; ! 315: return; ! 316: } ! 317: } ! 318: if (fseek(stdin, skip, SEEK_SET)) { ! 319: (void)fprintf(stderr, "hexdump: %s: %s.\n", ! 320: fname, strerror(errno)); ! 321: exit(1); ! 322: } ! 323: savaddress = address += skip; ! 324: skip = 0; ! 325: } ! 326: ! 327: char * ! 328: emalloc(size) ! 329: int size; ! 330: { ! 331: char *p, *malloc(); ! 332: ! 333: if (!(p = malloc((u_int)size))) ! 334: nomem(); ! 335: bzero(p, size); ! 336: return(p); ! 337: } ! 338: ! 339: nomem() ! 340: { ! 341: extern int errno; ! 342: ! 343: (void)fprintf(stderr, "hexdump: %s.\n", strerror(errno)); ! 344: exit(1); ! 345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.