/src/xxd/xxd.c

https://bitbucket.org/ultra_iter/vim-qt · C · 849 lines · 677 code · 62 blank · 110 comment · 286 complexity · 0190588920561aada1d09a63f29174fe MD5 · raw file 

    

  1. /* xxd: my hexdump facility. jw
    2. 

  2.  *
    3. 

  3.  *  2.10.90 changed to word output
    4. 

  4.  *  3.03.93 new indent style, dumb bug inserted and fixed.
    5. 

  5.  *	    -c option, mls
    6. 

  6.  * 26.04.94 better option parser, -ps, -l, -s added.
    7. 

  7.  *  1.07.94 -r badly needs - as input file.  Per default autoskip over
    8. 

  8.  *	       consecutive lines of zeroes, as unix od does.
    9. 

  9.  *	    -a shows them too.
    10. 

  10.  *	    -i dump as c-style #include "file.h"
    11. 

  11.  *  1.11.95 if "xxd -i" knows the filename, an 'unsigned char filename_bits[]'
    12. 

  12.  *	    array is written in correct c-syntax.
    13. 

  13.  *	    -s improved, now defaults to absolute seek, relative requires a '+'.
    14. 

  14.  *	    -r improved, now -r -s -0x... is supported.
    15. 

  15.  *	       change/suppress leading '\0' bytes.
    16. 

  16.  *	    -l n improved: stops exactly after n bytes.
    17. 

  17.  *	    -r improved, better handling of partial lines with trailing garbage.
    18. 

  18.  *	    -r improved, now -r -p works again!
    19. 

  19.  *	    -r improved, less flushing, much faster now! (that was silly)
    20. 

  20.  *  3.04.96 Per repeated request of a single person: autoskip defaults to off.
    21. 

  21.  * 15.05.96 -v added. They want to know the version.
    22. 

  22.  *	    -a fixed, to show last line inf file ends in all zeros.
    23. 

  23.  *	    -u added: Print upper case hex-letters, as preferred by unix bc.
    24. 

  24.  *	    -h added to usage message. Usage message extended.
    25. 

  25.  *	    Now using outfile if specified even in normal mode, aehem.
    26. 

  26.  *	    No longer mixing of ints and longs. May help doze people.
    27. 

  27.  *	    Added binify ioctl for same reason. (Enough Doze stress for 1996!)
    28. 

  28.  * 16.05.96 -p improved, removed occasional superfluous linefeed.
    29. 

  29.  * 20.05.96 -l 0 fixed. tried to read anyway.
    30. 

  30.  * 21.05.96 -i fixed. now honours -u, and prepends __ to numeric filenames.
    31. 

  31.  *	    compile -DWIN32 for NT or W95. George V. Reilly, * -v improved :-)
    32. 

  32.  *	    support --gnuish-longhorn-options
    33. 

  33.  * 25.05.96 MAC support added: CodeWarrior already uses ``outline'' in Types.h
    34. 

  34.  *	    which is included by MacHeaders (Axel Kielhorn). Renamed to
    35. 

  35.  *	    xxdline().
    36. 

  36.  *  7.06.96 -i printed 'int' instead of 'char'. *blush*
    37. 

  37.  *	    added Bram's OS2 ifdefs...
    38. 

  38.  * 18.07.96 gcc -Wall @ SunOS4 is now slient.
    39. 

  39.  *	    Added osver for MSDOS/DJGPP/WIN32.
    40. 

  40.  * 29.08.96 Added size_t to strncmp() for Amiga.
    41. 

  41.  * 24.03.97 Windows NT support (Phil Hanna). Clean exit for Amiga WB (Bram)
    42. 

  42.  * 02.04.97 Added -E option, to have EBCDIC translation instead of ASCII
    43. 

  43.  *	    (azc10@yahoo.com)
    44. 

  44.  * 22.05.97 added -g (group octets) option (jcook@namerica.kla.com).
    45. 

  45.  * 23.09.98 nasty -p -r misfeature fixed: slightly wrong output, when -c was
    46. 

  46.  *	    missing or wrong.
    47. 

  47.  * 26.09.98 Fixed: 'xxd -i infile outfile' did not truncate outfile.
    48. 

  48.  * 27.10.98 Fixed: -g option parser required blank.
    49. 

  49.  *	    option -b added: 01000101 binary output in normal format.
    50. 

  50.  * 16.05.00 Added VAXC changes by Stephen P. Wall
    51. 

  51.  * 16.05.00 Improved MMS file and merge for VMS by Zoltan Arpadffy
    52. 

  52.  * 2011 March  Better error handling by Florian Zumbiehl.
    53. 

  53.  * 2011 April  Formatting by Bram Moolenaar
    54. 

  54.  *
    55. 

  55.  * (c) 1990-1998 by Juergen Weigert (jnweiger@informatik.uni-erlangen.de)
    56. 

  56.  *
    57. 

  57.  * Small changes made afterwards by Bram Moolenaar et al.
    58. 

  58.  *
    59. 

  59.  * Distribute freely and credit me,
    60. 

  60.  * make money and share with me,
    61. 

  61.  * lose money and don't ask me.
    62. 

  62.  */
    63. 

  63. 

  64. /* Visual Studio 2005 has 'deprecated' many of the standard CRT functions */
    65. 

  65. #if _MSC_VER >= 1400
    66. 

  66. # define _CRT_SECURE_NO_DEPRECATE
    67. 

  67. # define _CRT_NONSTDC_NO_DEPRECATE
    68. 

  68. #endif
    69. 

  69. #if !defined(CYGWIN) && (defined(CYGWIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__))
    70. 

  70. # define CYGWIN
    71. 

  71. #endif
    72. 

  72. 

  73. #include <stdio.h>
    74. 

  74. #ifdef VAXC
    75. 

  75. # include <file.h>
    76. 

  76. #else
    77. 

  77. # include <fcntl.h>
    78. 

  78. #endif
    79. 

  79. #ifdef __TSC__
    80. 

  80. # define MSDOS
    81. 

  81. #endif
    82. 

  82. #if !defined(OS2) && defined(__EMX__)
    83. 

  83. # define OS2
    84. 

  84. #endif
    85. 

  85. #if defined(MSDOS) || defined(WIN32) || defined(OS2) || defined(__BORLANDC__) \
    86. 

  86.   || defined(CYGWIN)
    87. 

  87. # include <io.h>	/* for setmode() */
    88. 

  88. #else
    89. 

  89. # ifdef UNIX
    90. 

  90. #  include <unistd.h>
    91. 

  91. # endif
    92. 

  92. #endif
    93. 

  93. #include <stdlib.h>
    94. 

  94. #include <string.h>	/* for strncmp() */
    95. 

  95. #include <ctype.h>	/* for isalnum() */
    96. 

  96. #if __MWERKS__ && !defined(BEBOX)
    97. 

  97. # include <unix.h>	/* for fdopen() on MAC */
    98. 

  98. #endif
    99. 

  99. 

  100. #if defined(__BORLANDC__) && __BORLANDC__ <= 0x0410 && !defined(fileno)
    101. 

  101. /* Missing define and prototype grabbed from the BC 4.0 <stdio.h> */
    102. 

  102. # define fileno(f)       ((f)->fd)
    103. 

  103. FILE   _FAR *_Cdecl _FARFUNC fdopen(int __handle, char _FAR *__type);
    104. 

  104. #endif
    105. 

  105. 

  106. 

  107. /*  This corrects the problem of missing prototypes for certain functions
    108. 

  108.  *  in some GNU installations (e.g. SunOS 4.1.x).
    109. 

  109.  *  Darren Hiebert <darren@hmi.com> (sparc-sun-sunos4.1.3_U1/2.7.2.2)
    110. 

  110.  */
    111. 

  111. #if defined(__GNUC__) && defined(__STDC__)
    112. 

  112. # ifndef __USE_FIXED_PROTOTYPES__
    113. 

  113. #  define __USE_FIXED_PROTOTYPES__
    114. 

  114. # endif
    115. 

  115. #endif
    116. 

  116. 

  117. #ifndef __USE_FIXED_PROTOTYPES__
    118. 

  118. /*
    119. 

  119.  * This is historic and works only if the compiler really has no prototypes:
    120. 

  120.  *
    121. 

  121.  * Include prototypes for Sun OS 4.x, when using an ANSI compiler.
    122. 

  122.  * FILE is defined on OS 4.x, not on 5.x (Solaris).
    123. 

  123.  * if __SVR4 is defined (some Solaris versions), don't include this.
    124. 

  124.  */
    125. 

  125. #if defined(sun) && defined(FILE) && !defined(__SVR4) && defined(__STDC__)
    126. 

  126. #  define __P(a) a
    127. 

  127. /* excerpt from my sun_stdlib.h */
    128. 

  128. extern int fprintf __P((FILE *, char *, ...));
    129. 

  129. extern int fputs   __P((char *, FILE *));
    130. 

  130. extern int _flsbuf __P((unsigned char, FILE *));
    131. 

  131. extern int _filbuf __P((FILE *));
    132. 

  132. extern int fflush  __P((FILE *));
    133. 

  133. extern int fclose  __P((FILE *));
    134. 

  134. extern int fseek   __P((FILE *, long, int));
    135. 

  135. extern int rewind  __P((FILE *));
    136. 

  136. 

  137. extern void perror __P((char *));
    138. 

  138. # endif
    139. 

  139. #endif
    140. 

  140. 

  141. extern long int strtol();
    142. 

  142. extern long int ftell();
    143. 

  143. 

  144. char version[] = "xxd V1.10 27oct98 by Juergen Weigert";
    145. 

  145. #ifdef WIN32
    146. 

  146. char osver[] = " (Win32)";
    147. 

  147. #else
    148. 

  148. # ifdef DJGPP
    149. 

  149. char osver[] = " (dos 32 bit)";
    150. 

  150. # else
    151. 

  151. #  ifdef MSDOS
    152. 

  152. char osver[] = " (dos 16 bit)";
    153. 

  153. #  else
    154. 

  154. char osver[] = "";
    155. 

  155. #  endif
    156. 

  156. # endif
    157. 

  157. #endif
    158. 

  158. 

  159. #if defined(MSDOS) || defined(WIN32) || defined(OS2)
    160. 

  160. # define BIN_READ(yes)  ((yes) ? "rb" : "rt")
    161. 

  161. # define BIN_WRITE(yes) ((yes) ? "wb" : "wt")
    162. 

  162. # define BIN_CREAT(yes) ((yes) ? (O_CREAT|O_BINARY) : O_CREAT)
    163. 

  163. # define BIN_ASSIGN(fp, yes) setmode(fileno(fp), (yes) ? O_BINARY : O_TEXT)
    164. 

  164. # define PATH_SEP '\\'
    165. 

  165. #elif defined(CYGWIN)
    166. 

  166. # define BIN_READ(yes)  ((yes) ? "rb" : "rt")
    167. 

  167. # define BIN_WRITE(yes) ((yes) ? "wb" : "w")
    168. 

  168. # define BIN_CREAT(yes) ((yes) ? (O_CREAT|O_BINARY) : O_CREAT)
    169. 

  169. # define BIN_ASSIGN(fp, yes) ((yes) ? (void) setmode(fileno(fp), O_BINARY) : (void) (fp))
    170. 

  170. # define PATH_SEP '/'
    171. 

  171. #else
    172. 

  172. # ifdef VMS
    173. 

  173. #  define BIN_READ(dummy)  "r"
    174. 

  174. #  define BIN_WRITE(dummy) "w"
    175. 

  175. #  define BIN_CREAT(dummy) O_CREAT
    176. 

  176. #  define BIN_ASSIGN(fp, dummy) fp
    177. 

  177. #  define PATH_SEP ']'
    178. 

  178. #  define FILE_SEP '.'
    179. 

  179. # else
    180. 

  180. #  define BIN_READ(dummy)  "r"
    181. 

  181. #  define BIN_WRITE(dummy) "w"
    182. 

  182. #  define BIN_CREAT(dummy) O_CREAT
    183. 

  183. #  define BIN_ASSIGN(fp, dummy) fp
    184. 

  184. #  define PATH_SEP '/'
    185. 

  185. # endif
    186. 

  186. #endif
    187. 

  187. 

  188. /* open has only to arguments on the Mac */
    189. 

  189. #if __MWERKS__
    190. 

  190. # define OPEN(name, mode, umask) open(name, mode)
    191. 

  191. #else
    192. 

  192. # define OPEN(name, mode, umask) open(name, mode, umask)
    193. 

  193. #endif
    194. 

  194. 

  195. #ifdef AMIGA
    196. 

  196. # define STRNCMP(s1, s2, l) strncmp(s1, s2, (size_t)l)
    197. 

  197. #else
    198. 

  198. # define STRNCMP(s1, s2, l) strncmp(s1, s2, l)
    199. 

  199. #endif
    200. 

  200. 

  201. #ifndef __P
    202. 

  202. # if defined(__STDC__) || defined(MSDOS) || defined(WIN32) || defined(OS2) \
    203. 

  203. 		|| defined(__BORLANDC__)
    204. 

  204. #  define __P(a) a
    205. 

  205. # else
    206. 

  206. #  define __P(a) ()
    207. 

  207. # endif
    208. 

  208. #endif
    209. 

  209. 

  210. /* Let's collect some prototypes */
    211. 

  211. /* CodeWarrior is really picky about missing prototypes */
    212. 

  212. static void exit_with_usage __P((void));
    213. 

  213. static void die __P((int));
    214. 

  214. static int huntype __P((FILE *, FILE *, FILE *, int, int, long));
    215. 

  215. static void xxdline __P((FILE *, char *, int));
    216. 

  216. 

  217. #define TRY_SEEK	/* attempt to use lseek, or skip forward by reading */
    218. 

  218. #define COLS 256	/* change here, if you ever need more columns */
    219. 

  219. #define LLEN (11 + (9*COLS-1)/1 + COLS + 2)
    220. 

  220. 

  221. char hexxa[] = "0123456789abcdef0123456789ABCDEF", *hexx = hexxa;
    222. 

  222. 

  223. /* the different hextypes known by this program: */
    224. 

  224. #define HEX_NORMAL 0
    225. 

  225. #define HEX_POSTSCRIPT 1
    226. 

  226. #define HEX_CINCLUDE 2
    227. 

  227. #define HEX_BITS 3		/* not hex a dump, but bits: 01111001 */
    228. 

  228. 

  229. static char *pname;
    230. 

  230. 

  231.   static void
    232. 

  232. exit_with_usage()
    233. 

  233. {
    234. 

  234.   fprintf(stderr, "Usage:\n       %s [options] [infile [outfile]]\n", pname);
    235. 

  235.   fprintf(stderr, "    or\n       %s -r [-s [-]offset] [-c cols] [-ps] [infile [outfile]]\n", pname);
    236. 

  236.   fprintf(stderr, "Options:\n");
    237. 

  237.   fprintf(stderr, "    -a          toggle autoskip: A single '*' replaces nul-lines. Default off.\n");
    238. 

  238.   fprintf(stderr, "    -b          binary digit dump (incompatible with -ps,-i,-r). Default hex.\n");
    239. 

  239.   fprintf(stderr, "    -c cols     format <cols> octets per line. Default 16 (-i: 12, -ps: 30).\n");
    240. 

  240.   fprintf(stderr, "    -E          show characters in EBCDIC. Default ASCII.\n");
    241. 

  241.   fprintf(stderr, "    -g          number of octets per group in normal output. Default 2.\n");
    242. 

  242.   fprintf(stderr, "    -h          print this summary.\n");
    243. 

  243.   fprintf(stderr, "    -i          output in C include file style.\n");
    244. 

  244.   fprintf(stderr, "    -l len      stop after <len> octets.\n");
    245. 

  245.   fprintf(stderr, "    -ps         output in postscript plain hexdump style.\n");
    246. 

  246.   fprintf(stderr, "    -r          reverse operation: convert (or patch) hexdump into binary.\n");
    247. 

  247.   fprintf(stderr, "    -r -s off   revert with <off> added to file positions found in hexdump.\n");
    248. 

  248.   fprintf(stderr, "    -s %sseek  start at <seek> bytes abs. %sinfile offset.\n",
    249. 

  249. #ifdef TRY_SEEK
    250. 

  250. 	  "[+][-]", "(or +: rel.) ");
    251. 

  251. #else
    252. 

  252. 	  "", "");
    253. 

  253. #endif
    254. 

  254.   fprintf(stderr, "    -u          use upper case hex letters.\n");
    255. 

  255.   fprintf(stderr, "    -v          show version: \"%s%s\".\n", version, osver);
    256. 

  256.   exit(1);
    257. 

  257. }
    258. 

  258. 

  259.   static void
    260. 

  260. die(ret)
    261. 

  261.   int ret;
    262. 

  262. {
    263. 

  263.   fprintf(stderr, "%s: ", pname);
    264. 

  264.   perror(NULL);
    265. 

  265.   exit(ret);
    266. 

  266. }
    267. 

  267. 

  268. /*
    269. 

  269.  * Max. cols binary characters are decoded from the input stream per line.
    270. 

  270.  * Two adjacent garbage characters after evaluated data delimit valid data.
    271. 

  271.  * Everything up to the next newline is discarded.
    272. 

  272.  *
    273. 

  273.  * The name is historic and came from 'undo type opt h'.
    274. 

  274.  */
    275. 

  275.   static int
    276. 

  276. huntype(fpi, fpo, fperr, cols, hextype, base_off)
    277. 

  277.   FILE *fpi, *fpo, *fperr;
    278. 

  278.   int cols, hextype;
    279. 

  279.   long base_off;
    280. 

  280. {
    281. 

  281.   int c, ign_garb = 1, n1 = -1, n2 = 0, n3, p = cols;
    282. 

  282.   long have_off = 0, want_off = 0;
    283. 

  283. 

  284.   rewind(fpi);
    285. 

  285. 

  286.   while ((c = getc(fpi)) != EOF)
    287. 

  287.     {
    288. 

  288.       if (c == '\r')	/* Doze style input file? */
    289. 

  289. 	continue;
    290. 

  290. 

  291.       /* Allow multiple spaces.  This doesn't work when there is normal text
    292. 

  292.        * after the hex codes in the last line that looks like hex, thus only
    293. 

  293.        * use it for PostScript format. */
    294. 

  294.       if (hextype == HEX_POSTSCRIPT && (c == ' ' || c == '\n' || c == '\t'))
    295. 

  295. 	continue;
    296. 

  296. 

  297.       n3 = n2;
    298. 

  298.       n2 = n1;
    299. 

  299. 

  300.       if (c >= '0' && c <= '9')
    301. 

  301. 	n1 = c - '0';
    302. 

  302.       else if (c >= 'a' && c <= 'f')
    303. 

  303. 	n1 = c - 'a' + 10;
    304. 

  304.       else if (c >= 'A' && c <= 'F')
    305. 

  305. 	n1 = c - 'A' + 10;
    306. 

  306.       else
    307. 

  307. 	{
    308. 

  308. 	  n1 = -1;
    309. 

  309. 	  if (ign_garb)
    310. 

  310. 	    continue;
    311. 

  311. 	}
    312. 

  312. 

  313.       ign_garb = 0;
    314. 

  314. 

  315.       if (p >= cols)
    316. 

  316. 	{
    317. 

  317. 	  if (!hextype)
    318. 

  318. 	    {
    319. 

  319. 	      if (n1 < 0)
    320. 

  320. 		{
    321. 

  321. 		  p = 0;
    322. 

  322. 		  continue;
    323. 

  323. 		}
    324. 

  324. 	      want_off = (want_off << 4) | n1;
    325. 

  325. 	      continue;
    326. 

  326. 	    }
    327. 

  327. 	  else
    328. 

  328. 	    p = 0;
    329. 

  329. 	}
    330. 

  330. 

  331.       if (base_off + want_off != have_off)
    332. 

  332. 	{
    333. 

  333. 	  if (fflush(fpo) != 0)
    334. 

  334. 	    die(3);
    335. 

  335. #ifdef TRY_SEEK
    336. 

  336. 	  c = fseek(fpo, base_off + want_off - have_off, 1);
    337. 

  337. 	  if (c >= 0)
    338. 

  338. 	    have_off = base_off + want_off;
    339. 

  339. #endif
    340. 

  340. 	  if (base_off + want_off < have_off)
    341. 

  341. 	    {
    342. 

  342. 	      fprintf(fperr, "%s: sorry, cannot seek backwards.\n", pname);
    343. 

  343. 	      return 5;
    344. 

  344. 	    }
    345. 

  345. 	  for (; have_off < base_off + want_off; have_off++)
    346. 

  346. 	    if (putc(0, fpo) == EOF)
    347. 

  347. 	      die(3);
    348. 

  348. 	}
    349. 

  349. 

  350.       if (n2 >= 0 && n1 >= 0)
    351. 

  351. 	{
    352. 

  352. 	  if (putc((n2 << 4) | n1, fpo) == EOF)
    353. 

  353. 	    die(3);
    354. 

  354. 	  have_off++;
    355. 

  355. 	  want_off++;
    356. 

  356. 	  n1 = -1;
    357. 

  357. 	  if ((++p >= cols) && !hextype)
    358. 

  358. 	    {
    359. 

  359. 	      /* skip rest of line as garbage */
    360. 

  360. 	      want_off = 0;
    361. 

  361. 	      while ((c = getc(fpi)) != '\n' && c != EOF)
    362. 

  362. 		;
    363. 

  363. 	      if (c == EOF && ferror(fpi))
    364. 

  364. 		die(2);
    365. 

  365. 	      ign_garb = 1;
    366. 

  366. 	    }
    367. 

  367. 	}
    368. 

  368.       else if (n1 < 0 && n2 < 0 && n3 < 0)
    369. 

  369. 	{
    370. 

  370. 	  /* already stumbled into garbage, skip line, wait and see */
    371. 

  371. 	  if (!hextype)
    372. 

  372. 	    want_off = 0;
    373. 

  373. 	  while ((c = getc(fpi)) != '\n' && c != EOF)
    374. 

  374. 	    ;
    375. 

  375. 	  if (c == EOF && ferror(fpi))
    376. 

  376. 	    die(2);
    377. 

  377. 	  ign_garb = 1;
    378. 

  378. 	}
    379. 

  379.     }
    380. 

  380.   if (fflush(fpo) != 0)
    381. 

  381.     die(3);
    382. 

  382. #ifdef TRY_SEEK
    383. 

  383.   fseek(fpo, 0L, 2);
    384. 

  384. #endif
    385. 

  385.   if (fclose(fpo) != 0)
    386. 

  386.     die(3);
    387. 

  387.   if (fclose(fpi) != 0)
    388. 

  388.     die(2);
    389. 

  389.   return 0;
    390. 

  390. }
    391. 

  391. 

  392. /*
    393. 

  393.  * Print line l. If nz is false, xxdline regards the line a line of
    394. 

  394.  * zeroes. If there are three or more consecutive lines of zeroes,
    395. 

  395.  * they are replaced by a single '*' character.
    396. 

  396.  *
    397. 

  397.  * If the output ends with more than two lines of zeroes, you
    398. 

  398.  * should call xxdline again with l being the last line and nz
    399. 

  399.  * negative. This ensures that the last line is shown even when
    400. 

  400.  * it is all zeroes.
    401. 

  401.  *
    402. 

  402.  * If nz is always positive, lines are never suppressed.
    403. 

  403.  */
    404. 

  404.   static void
    405. 

  405. xxdline(fp, l, nz)
    406. 

  406.   FILE *fp;
    407. 

  407.   char *l;
    408. 

  408.   int nz;
    409. 

  409. {
    410. 

  410.   static char z[LLEN+1];
    411. 

  411.   static int zero_seen = 0;
    412. 

  412. 

  413.   if (!nz && zero_seen == 1)
    414. 

  414.     strcpy(z, l);
    415. 

  415. 

  416.   if (nz || !zero_seen++)
    417. 

  417.     {
    418. 

  418.       if (nz)
    419. 

  419. 	{
    420. 

  420. 	  if (nz < 0)
    421. 

  421. 	    zero_seen--;
    422. 

  422. 	  if (zero_seen == 2)
    423. 

  423. 	    if (fputs(z, fp) == EOF)
    424. 

  424. 	      die(3);
    425. 

  425. 	  if (zero_seen > 2)
    426. 

  426. 	    if (fputs("*\n", fp) == EOF)
    427. 

  427. 	      die(3);
    428. 

  428. 	}
    429. 

  429.       if (nz >= 0 || zero_seen > 0)
    430. 

  430. 	if (fputs(l, fp) == EOF)
    431. 

  431. 	  die(3);
    432. 

  432.       if (nz)
    433. 

  433. 	zero_seen = 0;
    434. 

  434.     }
    435. 

  435. }
    436. 

  436. 

  437. /* This is an EBCDIC to ASCII conversion table */
    438. 

  438. /* from a proposed BTL standard April 16, 1979 */
    439. 

  439. static unsigned char etoa64[] =
    440. 

  440. {
    441. 

  441.     0040,0240,0241,0242,0243,0244,0245,0246,
    442. 

  442.     0247,0250,0325,0056,0074,0050,0053,0174,
    443. 

  443.     0046,0251,0252,0253,0254,0255,0256,0257,
    444. 

  444.     0260,0261,0041,0044,0052,0051,0073,0176,
    445. 

  445.     0055,0057,0262,0263,0264,0265,0266,0267,
    446. 

  446.     0270,0271,0313,0054,0045,0137,0076,0077,
    447. 

  447.     0272,0273,0274,0275,0276,0277,0300,0301,
    448. 

  448.     0302,0140,0072,0043,0100,0047,0075,0042,
    449. 

  449.     0303,0141,0142,0143,0144,0145,0146,0147,
    450. 

  450.     0150,0151,0304,0305,0306,0307,0310,0311,
    451. 

  451.     0312,0152,0153,0154,0155,0156,0157,0160,
    452. 

  452.     0161,0162,0136,0314,0315,0316,0317,0320,
    453. 

  453.     0321,0345,0163,0164,0165,0166,0167,0170,
    454. 

  454.     0171,0172,0322,0323,0324,0133,0326,0327,
    455. 

  455.     0330,0331,0332,0333,0334,0335,0336,0337,
    456. 

  456.     0340,0341,0342,0343,0344,0135,0346,0347,
    457. 

  457.     0173,0101,0102,0103,0104,0105,0106,0107,
    458. 

  458.     0110,0111,0350,0351,0352,0353,0354,0355,
    459. 

  459.     0175,0112,0113,0114,0115,0116,0117,0120,
    460. 

  460.     0121,0122,0356,0357,0360,0361,0362,0363,
    461. 

  461.     0134,0237,0123,0124,0125,0126,0127,0130,
    462. 

  462.     0131,0132,0364,0365,0366,0367,0370,0371,
    463. 

  463.     0060,0061,0062,0063,0064,0065,0066,0067,
    464. 

  464.     0070,0071,0372,0373,0374,0375,0376,0377
    465. 

  465. };
    466. 

  466. 

  467.   int
    468. 

  468. main(argc, argv)
    469. 

  469.   int argc;
    470. 

  470.   char *argv[];
    471. 

  471. {
    472. 

  472.   FILE *fp, *fpo;
    473. 

  473.   int c, e, p = 0, relseek = 1, negseek = 0, revert = 0;
    474. 

  474.   int cols = 0, nonzero = 0, autoskip = 0, hextype = HEX_NORMAL;
    475. 

  475.   int ebcdic = 0;
    476. 

  476.   int octspergrp = -1;	/* number of octets grouped in output */
    477. 

  477.   int grplen;		/* total chars per octet group */
    478. 

  478.   long length = -1, n = 0, seekoff = 0;
    479. 

  479.   static char l[LLEN+1];  /* static because it may be too big for stack */
    480. 

  480.   char *pp;
    481. 

  481. 

  482. #ifdef AMIGA
    483. 

  483.   /* This program doesn't work when started from the Workbench */
    484. 

  484.   if (argc == 0)
    485. 

  485.     exit(1);
    486. 

  486. #endif
    487. 

  487. 

  488.   pname = argv[0];
    489. 

  489.   for (pp = pname; *pp; )
    490. 

  490.     if (*pp++ == PATH_SEP)
    491. 

  491.       pname = pp;
    492. 

  492. #ifdef FILE_SEP
    493. 

  493.   for (pp = pname; *pp; pp++)
    494. 

  494.     if (*pp == FILE_SEP)
    495. 

  495.       {
    496. 

  496. 	*pp = '\0';
    497. 

  497. 	break;
    498. 

  498.       }
    499. 

  499. #endif
    500. 

  500. 

  501.   while (argc >= 2)
    502. 

  502.     {
    503. 

  503.       pp = argv[1] + (!STRNCMP(argv[1], "--", 2) && argv[1][2]);
    504. 

  504. 	   if (!STRNCMP(pp, "-a", 2)) autoskip = 1 - autoskip;
    505. 

  505.       else if (!STRNCMP(pp, "-b", 2)) hextype = HEX_BITS;
    506. 

  506.       else if (!STRNCMP(pp, "-u", 2)) hexx = hexxa + 16;
    507. 

  507.       else if (!STRNCMP(pp, "-p", 2)) hextype = HEX_POSTSCRIPT;
    508. 

  508.       else if (!STRNCMP(pp, "-i", 2)) hextype = HEX_CINCLUDE;
    509. 

  509.       else if (!STRNCMP(pp, "-r", 2)) revert++;
    510. 

  510.       else if (!STRNCMP(pp, "-E", 2)) ebcdic++;
    511. 

  511.       else if (!STRNCMP(pp, "-v", 2))
    512. 

  512. 	{
    513. 

  513. 	  fprintf(stderr, "%s%s\n", version, osver);
    514. 

  514. 	  exit(0);
    515. 

  515. 	}
    516. 

  516.       else if (!STRNCMP(pp, "-c", 2))
    517. 

  517. 	{
    518. 

  518. 	  if (pp[2] && STRNCMP("ols", pp + 2, 3))
    519. 

  519. 	    cols = (int)strtol(pp + 2, NULL, 0);
    520. 

  520. 	  else
    521. 

  521. 	    {
    522. 

  522. 	      if (!argv[2])
    523. 

  523. 		exit_with_usage();
    524. 

  524. 	      cols = (int)strtol(argv[2], NULL, 0);
    525. 

  525. 	      argv++;
    526. 

  526. 	      argc--;
    527. 

  527. 	    }
    528. 

  528. 	}
    529. 

  529.       else if (!STRNCMP(pp, "-g", 2))
    530. 

  530. 	{
    531. 

  531. 	  if (pp[2] && STRNCMP("group", pp + 2, 5))
    532. 

  532. 	    octspergrp = (int)strtol(pp + 2, NULL, 0);
    533. 

  533. 	  else
    534. 

  534. 	    {
    535. 

  535. 	      if (!argv[2])
    536. 

  536. 		exit_with_usage();
    537. 

  537. 	      octspergrp = (int)strtol(argv[2], NULL, 0);
    538. 

  538. 	      argv++;
    539. 

  539. 	      argc--;
    540. 

  540. 	    }
    541. 

  541. 	}
    542. 

  542.       else if (!STRNCMP(pp, "-s", 2))
    543. 

  543. 	{
    544. 

  544. 	  relseek = 0;
    545. 

  545. 	  negseek = 0;
    546. 

  546. 	  if (pp[2] && STRNCMP("kip", pp+2, 3) && STRNCMP("eek", pp+2, 3))
    547. 

  547. 	    {
    548. 

  548. #ifdef TRY_SEEK
    549. 

  549. 	      if (pp[2] == '+')
    550. 

  550. 		relseek++;
    551. 

  551. 	      if (pp[2+relseek] == '-')
    552. 

  552. 		negseek++;
    553. 

  553. #endif
    554. 

  554. 	      seekoff = strtol(pp + 2+relseek+negseek, (char **)NULL, 0);
    555. 

  555. 	    }
    556. 

  556. 	  else
    557. 

  557. 	    {
    558. 

  558. 	      if (!argv[2])
    559. 

  559. 		exit_with_usage();
    560. 

  560. #ifdef TRY_SEEK
    561. 

  561. 	      if (argv[2][0] == '+')
    562. 

  562. 		relseek++;
    563. 

  563. 	      if (argv[2][relseek] == '-')
    564. 

  564. 		negseek++;
    565. 

  565. #endif
    566. 

  566. 	      seekoff = strtol(argv[2] + relseek+negseek, (char **)NULL, 0);
    567. 

  567. 	      argv++;
    568. 

  568. 	      argc--;
    569. 

  569. 	    }
    570. 

  570. 	}
    571. 

  571.       else if (!STRNCMP(pp, "-l", 2))
    572. 

  572. 	{
    573. 

  573. 	  if (pp[2] && STRNCMP("en", pp + 2, 2))
    574. 

  574. 	    length = strtol(pp + 2, (char **)NULL, 0);
    575. 

  575. 	  else
    576. 

  576. 	    {
    577. 

  577. 	      if (!argv[2])
    578. 

  578. 		exit_with_usage();
    579. 

  579. 	      length = strtol(argv[2], (char **)NULL, 0);
    580. 

  580. 	      argv++;
    581. 

  581. 	      argc--;
    582. 

  582. 	    }
    583. 

  583. 	}
    584. 

  584.       else if (!strcmp(pp, "--"))	/* end of options */
    585. 

  585. 	{
    586. 

  586. 	  argv++;
    587. 

  587. 	  argc--;
    588. 

  588. 	  break;
    589. 

  589. 	}
    590. 

  590.       else if (pp[0] == '-' && pp[1])	/* unknown option */
    591. 

  591. 	exit_with_usage();
    592. 

  592.       else
    593. 

  593. 	break;				/* not an option */
    594. 

  594. 

  595.       argv++;				/* advance to next argument */
    596. 

  596.       argc--;
    597. 

  597.     }
    598. 

  598. 

  599.   if (!cols)
    600. 

  600.     switch (hextype)
    601. 

  601.       {
    602. 

  602.       case HEX_POSTSCRIPT:	cols = 30; break;
    603. 

  603.       case HEX_CINCLUDE:	cols = 12; break;
    604. 

  604.       case HEX_BITS:		cols = 6; break;
    605. 

  605.       case HEX_NORMAL:
    606. 

  606.       default:			cols = 16; break;
    607. 

  607.       }
    608. 

  608. 

  609.   if (octspergrp < 0)
    610. 

  610.     switch (hextype)
    611. 

  611.       {
    612. 

  612.       case HEX_BITS:		octspergrp = 1; break;
    613. 

  613.       case HEX_NORMAL:		octspergrp = 2; break;
    614. 

  614.       case HEX_POSTSCRIPT:
    615. 

  615.       case HEX_CINCLUDE:
    616. 

  616.       default:			octspergrp = 0; break;
    617. 

  617.       }
    618. 

  618. 

  619.   if (cols < 1 || ((hextype == HEX_NORMAL || hextype == HEX_BITS)
    620. 

  620. 							    && (cols > COLS)))
    621. 

  621.     {
    622. 

  622.       fprintf(stderr, "%s: invalid number of columns (max. %d).\n", pname, COLS);
    623. 

  623.       exit(1);
    624. 

  624.     }
    625. 

  625. 

  626.   if (octspergrp < 1)
    627. 

  627.     octspergrp = cols;
    628. 

  628. 

  629.   if (argc > 3)
    630. 

  630.     exit_with_usage();
    631. 

  631. 

  632.   if (argc == 1 || (argv[1][0] == '-' && !argv[1][1]))
    633. 

  633.     BIN_ASSIGN(fp = stdin, !revert);
    634. 

  634.   else
    635. 

  635.     {
    636. 

  636.       if ((fp = fopen(argv[1], BIN_READ(!revert))) == NULL)
    637. 

  637. 	{
    638. 

  638. 	  fprintf(stderr,"%s: ", pname);
    639. 

  639. 	  perror(argv[1]);
    640. 

  640. 	  return 2;
    641. 

  641. 	}
    642. 

  642.     }
    643. 

  643. 

  644.   if (argc < 3 || (argv[2][0] == '-' && !argv[2][1]))
    645. 

  645.     BIN_ASSIGN(fpo = stdout, revert);
    646. 

  646.   else
    647. 

  647.     {
    648. 

  648.       int fd;
    649. 

  649.       int mode = revert ? O_WRONLY : (O_TRUNC|O_WRONLY);
    650. 

  650. 

  651.       if (((fd = OPEN(argv[2], mode | BIN_CREAT(revert), 0666)) < 0) ||
    652. 

  652. 	  (fpo = fdopen(fd, BIN_WRITE(revert))) == NULL)
    653. 

  653. 	{
    654. 

  654. 	  fprintf(stderr, "%s: ", pname);
    655. 

  655. 	  perror(argv[2]);
    656. 

  656. 	  return 3;
    657. 

  657. 	}
    658. 

  658.       rewind(fpo);
    659. 

  659.     }
    660. 

  660. 

  661.   if (revert)
    662. 

  662.     {
    663. 

  663.       if (hextype && (hextype != HEX_POSTSCRIPT))
    664. 

  664. 	{
    665. 

  665. 	  fprintf(stderr, "%s: sorry, cannot revert this type of hexdump\n", pname);
    666. 

  666. 	  return -1;
    667. 

  667. 	}
    668. 

  668.       return huntype(fp, fpo, stderr, cols, hextype,
    669. 

  669. 		negseek ? -seekoff : seekoff);
    670. 

  670.     }
    671. 

  671. 

  672.   if (seekoff || negseek || !relseek)
    673. 

  673.     {
    674. 

  674. #ifdef TRY_SEEK
    675. 

  675.       if (relseek)
    676. 

  676. 	e = fseek(fp, negseek ? -seekoff : seekoff, 1);
    677. 

  677.       else
    678. 

  678. 	e = fseek(fp, negseek ? -seekoff : seekoff, negseek ? 2 : 0);
    679. 

  679.       if (e < 0 && negseek)
    680. 

  680. 	{
    681. 

  681. 	  fprintf(stderr, "%s: sorry cannot seek.\n", pname);
    682. 

  682. 	  return 4;
    683. 

  683. 	}
    684. 

  684.       if (e >= 0)
    685. 

  685. 	seekoff = ftell(fp);
    686. 

  686.       else
    687. 

  687. #endif
    688. 

  688. 	{
    689. 

  689. 	  long s = seekoff;
    690. 

  690. 

  691. 	  while (s--)
    692. 

  692. 	    if (getc(fp) == EOF)
    693. 

  693. 	    {
    694. 

  694. 	      if (ferror(fp))
    695. 

  695. 		{
    696. 

  696. 		  die(2);
    697. 

  697. 		}
    698. 

  698. 	      else
    699. 

  699. 		{
    700. 

  700. 		  fprintf(stderr, "%s: sorry cannot seek.\n", pname);
    701. 

  701. 		  return 4;
    702. 

  702. 		}
    703. 

  703. 	    }
    704. 

  704. 	}
    705. 

  705.     }
    706. 

  706. 

  707.   if (hextype == HEX_CINCLUDE)
    708. 

  708.     {
    709. 

  709.       if (fp != stdin)
    710. 

  710. 	{
    711. 

  711. 	  if (fprintf(fpo, "unsigned char %s", isdigit((int)argv[1][0]) ? "__" : "") < 0)
    712. 

  712. 	    die(3);
    713. 

  713. 	  for (e = 0; (c = argv[1][e]) != 0; e++)
    714. 

  714. 	    if (putc(isalnum(c) ? c : '_', fpo) == EOF)
    715. 

  715. 	      die(3);
    716. 

  716. 	  if (fputs("[] = {\n", fpo) == EOF)
    717. 

  717. 	    die(3);
    718. 

  718. 	}
    719. 

  719. 

  720.       p = 0;
    721. 

  721.       c = 0;
    722. 

  722.       while ((length < 0 || p < length) && (c = getc(fp)) != EOF)
    723. 

  723. 	{
    724. 

  724. 	  if (fprintf(fpo, (hexx == hexxa) ? "%s0x%02x" : "%s0X%02X",
    725. 

  725. 		(p % cols) ? ", " : ",\n  "+2*!p,  c) < 0)
    726. 

  726. 	    die(3);
    727. 

  727. 	  p++;
    728. 

  728. 	}
    729. 

  729.       if (c == EOF && ferror(fp))
    730. 

  730. 	die(2);
    731. 

  731. 

  732.       if (p)
    733. 

  733. 	if (fputs("\n};\n" + 3 * (fp == stdin), fpo) == EOF)
    734. 

  734. 	  die(3);
    735. 

  735. 

  736.       if (fp != stdin)
    737. 

  737. 	{
    738. 

  738. 	  if (fprintf(fpo, "unsigned int %s", isdigit((int)argv[1][0]) ? "__" : "") < 0)
    739. 

  739. 	    die(3);
    740. 

  740. 	  for (e = 0; (c = argv[1][e]) != 0; e++)
    741. 

  741. 	    if (putc(isalnum(c) ? c : '_', fpo) == EOF)
    742. 

  742. 	      die(3);
    743. 

  743. 	  if (fprintf(fpo, "_len = %d;\n", p) < 0)
    744. 

  744. 	    die(3);
    745. 

  745. 	}
    746. 

  746. 

  747.       if (fclose(fp))
    748. 

  748. 	die(2);
    749. 

  749.       if (fclose(fpo))
    750. 

  750. 	die(3);
    751. 

  751.       return 0;
    752. 

  752.     }
    753. 

  753. 

  754.   if (hextype == HEX_POSTSCRIPT)
    755. 

  755.     {
    756. 

  756.       p = cols;
    757. 

  757.       e = 0;
    758. 

  758.       while ((length < 0 || n < length) && (e = getc(fp)) != EOF)
    759. 

  759. 	{
    760. 

  760. 	  if (putc(hexx[(e >> 4) & 0xf], fpo) == EOF
    761. 

  761. 		  || putc(hexx[e & 0xf], fpo) == EOF)
    762. 

  762. 	    die(3);
    763. 

  763. 	  n++;
    764. 

  764. 	  if (!--p)
    765. 

  765. 	    {
    766. 

  766. 	      if (putc('\n', fpo) == EOF)
    767. 

  767. 		die(3);
    768. 

  768. 	      p = cols;
    769. 

  769. 	    }
    770. 

  770. 	}
    771. 

  771.       if (e == EOF && ferror(fp))
    772. 

  772. 	die(2);
    773. 

  773.       if (p < cols)
    774. 

  774. 	if (putc('\n', fpo) == EOF)
    775. 

  775. 	  die(3);
    776. 

  776.       if (fclose(fp))
    777. 

  777. 	die(2);
    778. 

  778.       if (fclose(fpo))
    779. 

  779. 	die(3);
    780. 

  780.       return 0;
    781. 

  781.     }
    782. 

  782. 

  783.   /* hextype: HEX_NORMAL or HEX_BITS */
    784. 

  784. 

  785.   if (hextype == HEX_NORMAL)
    786. 

  786.     grplen = octspergrp + octspergrp + 1;	/* chars per octet group */
    787. 

  787.   else	/* hextype == HEX_BITS */
    788. 

  788.     grplen = 8 * octspergrp + 1;
    789. 

  789. 

  790.   e = 0;
    791. 

  791.   while ((length < 0 || n < length) && (e = getc(fp)) != EOF)
    792. 

  792.     {
    793. 

  793.       if (p == 0)
    794. 

  794. 	{
    795. 

  795. 	  sprintf(l, "%07lx: ", n + seekoff);
    796. 

  796. 	  for (c = 9; c < LLEN; l[c++] = ' ');
    797. 

  797. 	}
    798. 

  798.       if (hextype == HEX_NORMAL)
    799. 

  799. 	{
    800. 

  800. 	  l[c = (9 + (grplen * p) / octspergrp)] = hexx[(e >> 4) & 0xf];
    801. 

  801. 	  l[++c]			       = hexx[ e       & 0xf];
    802. 

  802. 	}
    803. 

  803.       else /* hextype == HEX_BITS */
    804. 

  804. 	{
    805. 

  805. 	  int i;
    806. 

  806. 

  807. 	  c = (9 + (grplen * p) / octspergrp) - 1;
    808. 

  808. 	  for (i = 7; i >= 0; i--)
    809. 

  809. 	    l[++c] = (e & (1 << i)) ? '1' : '0';
    810. 

  810. 	}
    811. 

  811.       if (ebcdic)
    812. 

  812. 	e = (e < 64) ? '.' : etoa64[e-64];
    813. 

  813.       /* When changing this update definition of LLEN above. */
    814. 

  814.       l[11 + (grplen * cols - 1)/octspergrp + p] =
    815. 

  815. #ifdef __MVS__
    816. 

  816. 	  (e >= 64)
    817. 

  817. #else
    818. 

  818. 	  (e > 31 && e < 127)
    819. 

  819. #endif
    820. 

  820. 	  ? e : '.';
    821. 

  821.       if (e)
    822. 

  822. 	nonzero++;
    823. 

  823.       n++;
    824. 

  824.       if (++p == cols)
    825. 

  825. 	{
    826. 

  826. 	  l[c = (11 + (grplen * cols - 1)/octspergrp + p)] = '\n'; l[++c] = '\0';
    827. 

  827. 	  xxdline(fpo, l, autoskip ? nonzero : 1);
    828. 

  828. 	  nonzero = 0;
    829. 

  829. 	  p = 0;
    830. 

  830. 	}
    831. 

  831.     }
    832. 

  832.   if (e == EOF && ferror(fp))
    833. 

  833.     die(2);
    834. 

  834.   if (p)
    835. 

  835.     {
    836. 

  836.       l[c = (11 + (grplen * cols - 1)/octspergrp + p)] = '\n'; l[++c] = '\0';
    837. 

  837.       xxdline(fpo, l, 1);
    838. 

  838.     }
    839. 

  839.   else if (autoskip)
    840. 

  840.     xxdline(fpo, l, -1);	/* last chance to flush out suppressed lines */
    841. 

  841. 

  842.   if (fclose(fp))
    843. 

  843.     die(2);
    844. 

  844.   if (fclose(fpo))
    845. 

  845.     die(3);
    846. 

  846.   return 0;
    847. 

  847. }
    848. 

  848. 

  849. /* vi:set ts=8 sw=4 sts=2 cino+={2 cino+=n-2 : */
    850.