home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource3 / 121_01 / xd.c < prev    next >
Encoding:
Text File  |  1985-08-21  |  3.4 KB  |  165 lines
  1. /*
  2. HEADER: CUG 121.??;
  3.  
  4.     TITLE:    Xd - hexadecimal dump;
  5.     VERSION:    1.0;
  6.     DATE:    09/01/85;
  7.     DESCRIPTION: "This program dumps a file to the console in one or more
  8.         of three formats: ascii, hex (2 digits/byte) or word
  9.         (standard 8080 format, assuming low byte first).";
  10.     KEYWORDS:    file, dump, hex;
  11.     SYSTEM:    CP/M;
  12.     FILENAME:    XD.C;
  13.     WARNINGS:    "Copyright (c) 1981, Mike W. Meyer."
  14.     AUTHORS:    Mike W. Meyer;
  15.     COMPILERS:    BDS-C 1.50;
  16. */
  17.  
  18. /*    Xd (the eXtended Dump program) replaces DR's dump program.
  19.  *
  20.  *    usage notes: xd [-wba] filename
  21.  *        w - dump in word format (hex)
  22.  *        b - dump in byte format (hex)
  23.  *        a - dump as ascii
  24.  *    you can ask for more that one format at a time, and the default
  25.  *    is ba.
  26.  *
  27.  *    Dumps ascii as:
  28.  *        control chars - ^ followed by uppercase char
  29.  *        high bit on - use a | followed by the character in
  30.  *            the low 7 bits. If this should be a control character,
  31.  *            use a $ instead of a ^ in the standard control char
  32.  *            format, & no | is output.
  33.  *        special - 7f (del) is output as "^ " (control - space),
  34.  *            and ff is "$ " (control space with the high bit on)
  35.  */
  36. #include <bdscio.h>
  37. #define INPUT    0
  38. #define LINELEN    16
  39.  
  40. /* Global flags to tell if we do/don't print things */
  41. char byte, word, ascii ;
  42.  
  43. main(argc, argv) char **argv; {
  44.     char i, buf[SECSIZ] ;
  45.     int file, addr ;
  46.  
  47.     byte = ascii = 1 ;
  48.     word = 0 ;
  49.     if (argc == 1)
  50.         usage();
  51.     while (**++argv == '-') {
  52.         argc--;
  53.         byte = word = ascii = 0 ;
  54.         while (*++*argv)
  55.             switch (toupper(**argv)) {
  56.                 case 'A': ascii++ ;
  57.                     break ;
  58.                 case 'W': word++ ;
  59.                     break ;
  60.                 case 'B': byte++ ;
  61.                     break ;
  62.                 default:
  63.                     usage();
  64.                 }
  65.         }
  66.     if (argc != 2)
  67.         usage();
  68.     if ((file = open(*argv, INPUT)) == ERROR) {
  69.         printf("can't open file %s!\n", *argv) ;
  70.         exit(1) ;
  71.         }
  72.     addr = 0 ;
  73.     while (read(file, buf, 1) > 0) {
  74.         for (i = 0; i < SECSIZ; i += LINELEN)
  75.             put16(buf + i, addr + i) ;
  76.         addr += SECSIZ ;
  77.         }
  78.     }
  79.  
  80. /*
  81.  * put16 - output a line of 16 bytes
  82.  */
  83. put16(cline, addr) char *cline; {
  84.     char pad[LINELEN] ;
  85.  
  86.     sprintf(pad, "%04x   ", addr) ;
  87.     if (byte) {
  88.         putpad(pad) ;
  89.         bytedump(cline) ;
  90.         }
  91.     if (ascii) {
  92.         putpad(pad) ;
  93.         ascdump(cline) ;
  94.         }
  95.     if (word) {
  96.         putpad(pad) ;
  97.         worddump(cline) ;
  98.         }
  99.     }
  100.  
  101. /*
  102.  * putpad - output the string in pad, and make it a string
  103.  *    of blanks...
  104.  */
  105. putpad(string) char *string; {
  106.  
  107.     puts(string) ;
  108.     strcpy(string, "       ") ;
  109.     }
  110.  
  111. /*
  112.  * bytedump - dump a string of LINELEN bytes as hex
  113.  */
  114. bytedump(a) char *a; {
  115.     char x ;
  116.  
  117.     x = LINELEN ;
  118.     while (x--)
  119.         printf("%02x ", *a++) ;
  120.     putchar('\n') ;
  121.     }
  122.  
  123. /*
  124.  * ascdump - dump a string of LINELEN bytes as ascii
  125.  */
  126. ascdump(a) char *a; {
  127.     char x, c, c2, low, hflg, cflg ;
  128.  
  129.     for (x = LINELEN; x--; a++) {
  130.         hflg = *a & 0x80 ;
  131.         cflg = (low = *a & 0x7f) < 0x20 ;
  132.         if (low != 0x7f)
  133.             c2 = cflg ? (*a & 0x5f) | 0x40
  134.                   : low ;
  135.         else {
  136.             c2 = ' ' ;
  137.             cflg++ ;
  138.             }
  139.         c = " |^$"[(hflg ? 1 : 0) + (cflg ? 2 : 0)] ;
  140.         printf("%c%c ", c, c2) ;
  141.         }
  142.     putchar('\n') ;
  143.     }
  144.  
  145. /*
  146.  * worddump - dump a string of LINELEN bytes as words
  147.  */
  148. worddump(a) int *a; {
  149.     char x ;
  150.  
  151.     x = LINELEN / 2;    /*only half as many if words */
  152.     while (x--)
  153.         printf("%04x  ", *a++) ;
  154.     putchar('\n') ;
  155.     }
  156.  
  157. /*
  158.  * usage - print usage message & exit
  159.  */
  160. usage()
  161. {
  162.     puts("usage: xd [-wba] <filename>\n") ;
  163.     exit(1) ;
  164. }
  165.