print command

[hexdump.git] / hexdump.c

/* depend: */
/* cflags: */
/* linker: debug.o */

#include <assert.h>
#include <getopt.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "debug.h"

/* macros */

#define CEIL(x, y) (((x) + (y) - 1) / (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MAX(x, y) (((x) > (y)) ? (x) : (y))

//#define BUFFERSIZE 4096
#define BUFFERSIZE 256
#define NBCOLS 8

/* gobal variables */

char *progname = NULL;

/* help function */

void usage (int ret)
{
    FILE *fd = ret ? stderr : stdout;
    fprintf (fd, "usage: %s [-i file] [-h] [-n nbcols] [-o file] [-v]\n", progname);
    fprintf (fd, " -i: input file\n");
    fprintf (fd, " -h: help message\n");
    fprintf (fd, " -n: number of columns\n");
    fprintf (fd, " -e: commands\n");
    fprintf (fd, " -o: output file\n");
    fprintf (fd, " -v: verbose level (%d)\n", verbose);
    fprintf (fd, "\n");
    fprintf (fd, "commands: [/hstr/|0xaddr] [a hstr] [d nb|-] [i hstr] [p nb|-] [s/h1/h2/[g]]\n");
    fprintf (fd, " 0x: move to address addr\n");
    fprintf (fd, " //: move to hexa stringi hstr\n");
    fprintf (fd, " a : append hexa string hstr to current address\n");
    fprintf (fd, " d : delete nb bytes (- until end file)\n");
    fprintf (fd, " i : insert hexa string hstr to current address\n");
    fprintf (fd, " p : print nb bytes (- until end file)\n");
    fprintf (fd, " s : substitute h1 by h2 (g for globally)\n");

    exit (ret);
}

/* get number of digits */

int getnbdigits (long int l) {
    int n = 0;
    while (l) {
        n += 2;
        l /= 256;
    }
    return n;
}

/* print a line */

void printline (char *buffer, int nbcols, int nb, int addr, int nbdigits) {
    int i;

    printf ("0x%0*x:", nbdigits, addr);
    for (i = 0; i < nb; i++) {
        printf (" %02x", buffer[i]);
    }
    for (i = nb; i < nbcols; i++) {
        printf ("   ");
    }
    printf ("  ");
    for (i = 0; i < nb; i++) {
        char c = buffer[i];
        printf ("%c", (c > 31) && (c < 127) ? c : '.');
    }
    printf ("\n");
}

/* indent function */

int hexdump (FILE *fin, int nbcols, int len) {
    char buffer[BUFFERSIZE] = {0};
    int i;

    char *pt = buffer;

    /* get file size */
    int nbdigits = 0;
    if (fin != stdin) {
        fseek (fin, 0 , SEEK_END);
        long int filesize = ftell (fin);
        fseek (fin, 0 , SEEK_SET);
        nbdigits = getnbdigits (filesize);
    } else {
        nbdigits = 6;
    }

    int addr = 0;
    int nb = 0;
    while (!feof (fin)) {
        int nbtoread = BUFFERSIZE - (pt - buffer);
        if ((len > 0) && (nbtoread > len)) {
            nbtoread = len;
        }
        int nbread = fread (pt, 1, nbtoread, fin);
        if (len > 0) {
            len -= nbread;
        }
        nb += nbread;
        pt = buffer;

        /* print line */
        while ((nb - (int)(pt - buffer)) / nbcols > 0) {
            printline (pt, nbcols, nbcols, addr, nbdigits);
            pt += nbcols;
            addr += nbcols;
        }

        /* copy end buffer */
        nb -= pt - buffer;
        for (i = 0; i < nb; i++) {
            buffer[i] = pt[i];
        }
        pt = buffer + nb;

        /* end partial reading */
        if (len == 0) {
            break;
        }
    }

    /* last line */
    if (nb > 0) {
        printline (buffer, nbcols, nb, addr, nbdigits);
    }

    return 0;
}

/* main function */

int main (int argc, char *argv[]) 
{
    int rc = 0;
    char *input = NULL;
    char *output = NULL;
    int nbcols = NBCOLS;
    char *commands = NULL;
    int printlen = -1;
   
    /* get basename */
    char *pt = progname = argv[0];
    while (*pt) {
        if ((*pt == '/') || (*pt == '\\')) {
           progname = pt + 1;
        }
        pt++;
    }

    int c;
    while ((c = getopt(argc, argv, "e:i:hn:o:v:")) != EOF) {
        switch (c) {
        case 'i':
            input = optarg;
            break;
        case 'e':
            if (commands == NULL) {
                commands = optarg;
            } else {
                strcat (commands, " ");
                strcat (commands, optarg);
            }
            break;
        case 'n':
            nbcols = atoi (optarg);
            break;
        case 'o':
            output = optarg;
            break;
        case 'v':
            verbose = atoi (optarg);
            break;
        case 'h':
        default:
            usage (c != 'h');
        }
    }
    if (argc - optind != 0) {
        fprintf (stderr, "%s: invalid option -- %s\n", progname, argv[optind]);
        usage (1);
    }

    /* check input */
    FILE *fin = NULL;
    if (input) {
        fin = fopen (input, "rb");
        if (!fin) {
            VERBOSE (ERROR, fprintf (stderr, "error: can't open file '%s'\n", input));
            return 1;
        }
    } else {
        fin = stdin;
    }

    /* check output */
    FILE *fout = NULL;
    if (output) {
        fout = fopen (input, "wb");
        if (!fout) {
            VERBOSE (ERROR, fprintf (stderr, "error: can't open file '%s'\n", output));
            fclose (fin);
            return 1;
        }
    } else {
        fout = stdout;
    }

    if (commands == NULL) {
        hexdump (fin, nbcols, -1);
    } else {
        VERBOSE (DEBUG, printf ("commands: %s\n", commands));
        while ((*commands != '\0') && (rc == 0)) {
            switch (*commands++) {
            case ' ':
            case '\t':
                break;

            case '/': /* read patern */
                break;

            case '0': /* read address */
                break;

            case 'a': /* append mode */
                break;

            case 'd': /* delete mode */
                break;

            case 'i': /* insert mode */
                break;

            case 'p': /* print mode */
                printlen = -1;
                while (*commands != '\0') {
                    if ((*commands == ' ') || (*commands == '\t')) {
                        commands++;
                    } else if ((*commands >= '0') && (*commands <= '9')) {
                        printlen = strtol (commands, &commands, 10);
                        break;
                    } else if (*commands == '-') {
                        printlen = -1;
                        commands++;
                        break;
                    } else {
                        VERBOSE (ERROR, fprintf (stderr, "unkown print lenght (%s)\n", commands));
                        rc = 1;
                        break;
                    }
                }
                if (rc == 0) hexdump (fin, nbcols, printlen);
                break;

            case 's': /* substitute mode */
                break;

            default:
                VERBOSE (ERROR, fprintf (stderr, "unknown command (%c)\n", commands[-1]));
                rc = 1;
            }
        }
    }

    /* close all */
    if (fin) fclose (fin);
    if (fout) fclose (fout);

    return rc;
}

// test: hexdump.exe -h
// test: hexdump.exe -h | awk '/usage:/ { rc=1 } END { exit (1-rc) }'
// test: hexdump.exe -_ 2> /dev/null | awk 'END { if (NR == 0) { exit(0) } else exit (1) }'
// test: hexdump.exe -_ 2>&1 | awk '/usage:/ { rc=1 } END { exit (1-rc) }'
// test: hexdump.exe -i hexdump.c | grep -q '0x[0-9a-f]*: '
// test: hexdump.exe -i hexdump.c -n 3|head -2|tail -1| grep '0x0003: 64 65 70  dep'

/* vim: set ts=4 sw=4 et: */