#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
 
#define DECIMAL 1
#define HEX     2
#define OCTAL   3
#define BINARY  4
 
#define CHAR    1	/* 1 byte */
#define SHORT   2	/* 2 bytes */
#define LONG    4	/* 4 bytes */
 
/*
 *      debug - an IBMPC like debug facility for UNIX
 *
 *      Spits out and accepts data in HEX, DECIMAL, or even OCTAL.
 *
 *	VERS  DATE      AUTHOR                     Description
 *	1.00  05/17/93  Greg @ Metrolight Studios  Initial implementation
 *	1.10  09/27/02  Greg Ercolano @ Rush       K+R -> C++
 *
 */
#define VERSION "1.10"
 
int G_mode    = HEX,		/* HEX, DECIMAL, OCTAL */
    G_width   = CHAR,		/* CHAR, SHORT, LONG */
    G_vpl     = 16,		/* values per line */
    G_more    = 0,
    G_noascii = 0;

char **G_filenames = NULL;
int    G_tfilenames = 0;

/***                    ***********************************/
/*** ONLINE HELP        ***********************************/
/***                    ***********************************/
 
char *cmdline_help[] = 
{
    "NAME",
    "    debug - a simple debug facility, V %s",
    "",
    "USAGE",
    "    debug -[options] filename [..]",
    "    debug -[options] < filename",
    "",
    "OPTIONS:",
    "   -h    ;Hex     mode (default)",
    "   -d    ;Decimal mode",
    "   -o    ;Octal   mode",
    "   -b    ;Binary  mode",
    "   -c    ;Char  [8 bit] mode (default)",
    "   -s    ;Short [16 bit] mode",
    "   -l    ;Long  [32 bit] mode",
    "   -m    ;More. Pauses listing every 256 bytes",
    "   -na   ;No ascii (don't show ascii conversion column",
    "",
    "EXAMPLES",
    "    debug file                    # hex dump 'file'",
    "    debug -d file                 # decimal dump 'file'",
    "    debug -d -m file              # decimal dump 'file' with MORE prompts",
    "    cat file | debug -m -d        # decimal dump 'file' with MORE prompts",
    "    perl -e '$|=1;for($t=0;1;$t++){printf(\"%%c\",($t%%0x100));}'|debug -m",
    "",
    "AUTHOR",
    "    erco@3dsite.com 09/27/02",
    NULL
};
 
void HelpAndExit(char **help, char *errmsg)
{ 
    for (int t=0; help[t]; t++)
        { fprintf(stderr, help[t], VERSION); fprintf(stderr, "\n"); }

    if ( errmsg ) 
        fprintf(stderr, "debug: '%s': bad/missing argument\n", errmsg);

    exit(1);
}
 
#define NEXTARG(t)  { if (++t >= argc) HelpAndExit(cmdline_help, argv[--t]); }
 
void ParseArgs(int argc, char **argv)
{
    G_filenames = (char**)malloc(sizeof(char*) * ( argc + 1 ) );
    G_tfilenames = 0;

    for (int t=1; t<argc; t++)
    {
        if ( argv[t][0] == '-' )
        {
	    if ( strcmp(argv[t], "-help" ) == 0 ) 
	        HelpAndExit(cmdline_help, NULL);

	    if ( strcmp(argv[t], "-na") == 0 )
	        G_noascii = 1;
 
            switch(argv[t][1])
            {
                case 'h': G_mode  = HEX;     break;
                case 'd': G_mode  = DECIMAL; break;
                case 'o': G_mode  = OCTAL;   break;
                case 'b': G_mode  = BINARY;  break;
                case 'c': G_width = CHAR;    break;
                case 's': G_width = SHORT;   break;
                case 'l': G_width = LONG;    break;
                case 'm': G_more  = 1;       break;
                case NULL: HelpAndExit(cmdline_help, NULL); break;
            }
        }
        else            /* arguments without - */
        {
	    G_filenames[G_tfilenames++] = argv[t];
        }
    }
 
    switch(G_width)
    {
        case CHAR:
	    switch(G_mode)
	    {
	        case     HEX: G_vpl = 16; break;
		case DECIMAL: G_vpl = 10; break;
		case  BINARY: G_vpl = 8;  break;
		case   OCTAL: G_vpl = 8;  break;
	    }
	    break;
 
        case SHORT:
	    switch(G_mode)
	    {
	        case     HEX: G_vpl = 8; break;
		case DECIMAL: G_vpl = 5; break;
		case  BINARY: G_vpl = 4; break;
		case   OCTAL: G_vpl = 4; break;
	    }
	    break;
 
        case LONG:
	    switch(G_mode)
	    {
	        case     HEX: G_vpl = 4; break;
		case DECIMAL: G_vpl = 5; break;
		case  BINARY: G_vpl = 2; break;
		case   OCTAL: G_vpl = 4; break;
	    }
	    break;
    }
}
 
static void BinaryPrint(unsigned long n, int digits)
{
    static long mask[] =
    {
        0x00000001, 0x00000002, 0x00000004, 0x00000008,
        0x00000010, 0x00000020, 0x00000040, 0x00000080,
        0x00000100, 0x00000200, 0x00000400, 0x00000800,
        0x00001000, 0x00002000, 0x00004000, 0x00008000,
        0x00010000, 0x00020000, 0x00040000, 0x00080000,
        0x00100000, 0x00200000, 0x00400000, 0x00800000,
        0x01000000, 0x02000000, 0x04000000, 0x08000000,
        0x10000000, 0x20000000, 0x40000000, 0x80000000,
    };
 
    for (int t=1; t<=digits; t++)
        printf("%c", (mask[digits-t]&n)?'1':'0');
}
 
void ShowBlank()
{
    switch(G_mode)
    {
        case HEX:
	    switch(G_width)
	    {
		case CHAR:  printf("%2s", ""); break;
		case SHORT: printf("%4s", ""); break;
		case LONG:  printf("%8s", ""); break;
	    }
	    break;

        case DECIMAL:
	    switch(G_width)
	    {
		case CHAR:  printf("%3s",  ""); break;
		case SHORT: printf("%5s",  ""); break;
		case LONG:  printf("%10s", ""); break;
	    }
	    break;

        case BINARY:
	    switch(G_width)
	    {
		case CHAR:  printf("%8s",  ""); break;
		case SHORT: printf("%16s", ""); break;
		case LONG:  printf("%32s", ""); break;
	    }
	    break;

        case OCTAL:
	    switch(G_width)
	    {
		case CHAR:  printf("%3s",  ""); break;
		case SHORT: printf("%6s",  ""); break;
		case LONG:  printf("%12s", ""); break;
	    }
	    break;
    }
}
 
void ShowUchar(unsigned long val)
{
    switch(G_mode)
    {
        case BINARY:  BinaryPrint((unsigned long)val, 8); break;
        case OCTAL:   printf("%.3o", (int)val); break;
        case DECIMAL: printf("%3u",  (int)val); break;
        case HEX:     printf("%.2x", (int)val); break;
    }
}
 
void ShowUshort(unsigned long val)
{
    switch(G_mode)
    {
        case BINARY:  BinaryPrint((unsigned long)val, 16); break;
        case OCTAL:   printf("%.6o",(int)val); break;
        case DECIMAL: printf("%5u", (int)val); break;
        case HEX:     printf("%.4x",(int)val); break;
    }
}
 
void ShowUlong(unsigned long val)
{
    switch(G_mode)
    {
        case BINARY:  BinaryPrint((unsigned long)val, 32); break;
        case OCTAL:   printf("%.12lo",val); break;
        case DECIMAL: printf("%10lu", val); break;
        case HEX:     printf("%.8lx", val); break;
    }
}
 
/* DUMP THE VALUES IN THE APPROPRIATE DISPLAY MODE, IE: 
 *
 *     CHAR:  41 42 43 44 45 00 00 00 00 00 00 00                abcde.......    
 *     SHORT: 4142 4344 4500 0000 0000 0000                  abcde......         
 *     LONG:  41424344 45000000 00000000                 abcde......             
 */
void Dump(unsigned char *buf, unsigned long from, unsigned long to)
{
    int t,
        leftover,
        count = (to-from+1);
 
    leftover = G_vpl;
 
    for (t=from; t<=to; t+=G_width)
    {
        leftover--;
 
        if ( t != from )
	    { printf(" "); }

        switch(G_width)
        {
	    case CHAR:
	    {
	        unsigned char *ucp = (unsigned char*)(buf+t);
	        ShowUchar((unsigned long)ucp[0]);
		break;
	    }
	    case SHORT:
	    {
	        unsigned short *usp = (unsigned short*)(buf+t);
		ShowUshort((unsigned long)usp[0]);
		break;
	    }
 
	    case LONG:  
	    {
	        unsigned long *ulp = (unsigned long*)(buf+t);
		ShowUlong(ulp[0]);
	    }
        }
    }
 
    if ( G_noascii == 0 )
    {
	for (t=0; t<leftover; t++)
	    { printf(" "); ShowBlank(); }
	printf("  ");
 
        for (t=from; t<=to; t+=G_width)
            if (buf[t]<' '||buf[t]>'~') printf(".");
            else                        printf("%c",buf[t]);
    }
    printf("\n");
    fflush(stdout);
}
 
int GetChar()
{
#ifdef IBMPC
    char *devname = "con";
#else /*IBMPC*/
    char *devname = "/dev/tty";
#endif /*IBMPC*/

    FILE *fp;
    unsigned char c;
    if ( ( fp = fopen(devname, "r" ) ) == NULL )
        return(0);
    fread(&c, 1, 1, fp);
    fclose(fp);
    return((int)c);
}

int DumpFilename(char *filename, FILE *fp)
{
    unsigned int count, linecount=0;
    unsigned char buf[1024];
    unsigned long address=0;
 
    while ( ( count = fread(buf, G_width, G_vpl, fp)) != 0 )
    {
        ShowUlong(address);
	printf(": ");
        Dump(buf, 0, ((count-1)*G_width));
	address += count;
 
        /* MORE THE FILE */
        if ( G_more && ((linecount++ % 16) == 15))
        {
	    while ( 1 )
	    {
		printf("--More--"); fflush(stdout);
		char c = GetChar();
		printf("\33[1A\r%20s\r", "");
		switch ( c )
		{
		    case 'q': 		/* q=quit */
		        return(0);

		    case 7: 		// ^G = show filename (VI)
			printf("Filename=%-40s\n", filename); 
			continue;
		}
		printf("\n");		// leave a blank line
		break;
	    }
        }
    }
    return(0);
}
 
main( int argc, char **argv )
{
    ParseArgs(argc, argv);

    /* NO FILENAMES? READ STDIN */
    if ( G_tfilenames == 0 )
        return(DumpFilename("[STDIN]", stdin));

    int t, err = 0;
    FILE *fp;
    for ( t=0; t<G_tfilenames; t++ )
    {
        /* PRING HEADER IF MORE THAN ONE FILE */
        if ( G_tfilenames > 1 )
	    printf("\n:::::::::::::::::\n%s\n:::::::::::::::::\n", G_filenames[t]);

        if ( ( fp = fopen(G_filenames[t], "r") ) == NULL )
	    { perror(G_filenames[t]); err = 1; continue; }
        DumpFilename(G_filenames[t], fp);
	fclose(fp);
    }
    return(err);
}