URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [tools/] [build/] [unhex.c] - Blame information for rev 210

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * unhex
 *      convert a hex file to binary equivalent.  If more than one file name
 *      is given, then the output will be logically concatenated together.
 *      stdin and stdout are defaults. Verbose will enable checksum output.
 *
 *  Supported input formats are Intel hex, Motorola S records, and TI 'B'
 *  records.
 *
 * Intel hex input format is
 *      Byte
 *       1          Colon :
 *       2..3       Record length, eg: "20"
 *       4..7       load address nibbles
 *       8..9       record type: "00" (data) or "02" base addr
 *       10..x      data bytes in ascii-hex
 *       x+1..x+2   cksum (2's compl of (len+addr+data))
 *       x+3        \n -- newline
 *
 *  $Id: unhex.c,v 1.2 2001-09-27 12:02:53 chris Exp $
 */
 
char *USAGE = "\
usage:    unhex [-va] [ -o file ] [ file [file ... ] ]\n\
                -v          -- verbose\n\
                -a base     -- 1st byte of output corresponds to this address\n\
                -l          -- linear, just writes data out\n\
                -o file     -- output file; must not be input file\n\
                -F k_bits   -- \"holes\" in input will be filled with 0xFF's\n\
                                  up to \"k_bits\" * 1024 bits\n\
";
 
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
 
#include "config.h"
 
#ifndef VMS
#ifndef HAVE_STRERROR
extern int sys_nerr;
extern char *sys_errlist[];
 
#define strerror( _err ) \
  ((_err) < sys_nerr) ? sys_errlist [(_err)] : "unknown error"
 
#else   /* HAVE_STRERROR */
char *strerror ();
#endif
#else   /* VMS */
char *strerror (int,...);
#endif
 
 
#define OK      0
#define FAILURE (-1)
#define Failed(x)       ((x) == FAILURE)
#define TRUE    1
#define FALSE   0
typedef char bool;
#define STREQ(a,b)      (strcmp(a,b) == 0)
 
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned long u32;
 
/*
 * Pick out designated bytes
 */
 
#define B0(x)       ((x) & 0xff)
#define B1(x)       B0((x) >> 8)
#define B2(x)       B0((x) >> 16)
#define B3(x)       B0((x) >> 24)
 
typedef struct buffer_rec {
    u32 dl_destaddr;
    u32 dl_jumpaddr;
    int dl_count;
    u8  dl_buf[512];
} buffer_rec;
 
/*
 * vars controlled by command line options
 */
 
bool verbose = FALSE;                   /* be verbose */
bool linear = FALSE;                    /* just write out linear data */
char *outfilename = "-";                /* default output is stdout */
u32 base = 0L;                         /* base address */
u32 FFfill = 0L;                       /* how far to fill w 0xFF's */
 
extern char *optarg;                    /* getopt(3) control vars */
extern int optind;
 
char *progname;                         /* for error() */
 
void error(int errn, ...);
#define ERR_ERRNO  (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */
#define ERR_FATAL  (ERR_ERRNO / 2)              /* error is fatal; no return */
#define ERR_ABORT  (ERR_ERRNO / 4)              /* error is fatal; abort */
#define ERR_MASK   (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */
 
#ifdef HAVE_STRTOUL
#define stol(p) strtoul(p, (char **) NULL, 0)
#else
#define stol(p) strtol(p, (char **) NULL, 0)
#endif
 
int   unhex(FILE *ifp, char *inm, FILE *ofp, char *onm);
int   convert_Intel_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
int   convert_S_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
int   convert_TI_records(FILE *ifp, char *inm, FILE *ofp, char *onm);
void  write_record(buffer_rec *tb, FILE *fp);
int   getnibble(char **p);
int   getbyte(char **p);
long  getNbytes(char **p, int n);
void  badformat(char *s, char *fname, char *msg);
 
#define get1bytes(p)    ((int) getbyte(p))
#define get2bytes(p)    ((int) getNbytes(p, 2))
#define get3bytes(p)    getNbytes(p, 3)
#define get4bytes(p)    getNbytes(p, 4)
 
char *BADADDR = "Invalid record address";
char *BADLEN  = "Invalid record length";
char *BADBASE = "Bad base or starting address";
char *BADFMT =  "Unrecognized record type";
char *BADDATA = "Invalid data byte";
char *BADCSUM = "Invalid checksum";
char *MISCSUM = "Checksum mismatch";
char *BADTYPE = "Unrecognized record type";
char *MISTYPE = "Incompatible record types";
 
int main(
  int argc,
  char **argv
)
{
    register int c;
    bool showusage = FALSE;                     /* usage error? */
    int rc = 0;
    FILE *outfp, *infp;
 
    /*
     * figure out invocation leaf-name
     */
 
    if ((progname = strrchr(argv[0], '/')) == (char *) NULL)
        progname = argv[0];
    else
        progname++;
 
    argv[0] = progname;                         /* for getopt err reporting */
 
    /*
     *  Check options and arguments.
     */
 
    progname = argv[0];
    while ((c = getopt(argc, argv, "F:a:o:vl")) != EOF)
        switch (c)
        {
            case 'a':                           /* base address */
                base = stol(optarg);
                break;
 
            case 'l':                           /* linear output */
                linear = TRUE;
                break;
 
            case 'v':                           /* toggle verbose */
                verbose = ! verbose;
                break;
 
            case 'o':                           /* output file */
                outfilename = optarg;
                break;
 
            case 'F':                           /* 0xFF fill amount (bytes) */
                FFfill = stol(optarg) * 1024L / 8L;
                break;
 
            case '?':
                showusage = TRUE;
        }
 
    if (showusage)
    {
        (void) fprintf(stderr, "%s", USAGE);
        exit(1);
    }
 
    if (linear && (base != 0))
    {
        error(0, "-l and -a may not be specified in combination");
        exit(1);
    }
 
    if (STREQ(outfilename, "-"))
    {
        outfp = stdout;
        outfilename = "stdout";
    }
    else
        if ((outfp = fopen(outfilename, "w")) == (FILE *) NULL)
        {
            error(-1, "couldn't open '%s' for output", outfilename);
            exit(1);
        }
 
    /*
     * Now process the input files (or stdin, if none specified)
     */
 
    if (argv[optind] == (char *) NULL)          /* just stdin */
        exit(unhex(stdin, "stdin", outfp, outfilename));
    else
        for (; (optarg = argv[optind]); optind++)
        {
            if (STREQ(optarg, "-"))
                rc += unhex(stdin, "stdin", outfp, outfilename);
            else
            {
                if ((infp = fopen(optarg, "r")) == (FILE *) NULL)
                {
                    error(-1, "couldn't open '%s' for input", optarg);
                    exit(1);
                }
                rc += unhex(infp, optarg, outfp, outfilename);
            }
        }
 
    return(rc);
}
 
u16 filesum;
 
int
unhex(FILE *ifp,
      char *inm,
      FILE *ofp,
      char *onm)
{
    int c;
 
    filesum = 0;
 
    /*
     * Make sure holes will be filled with 0xFF's if requested.  We
     *  do this the easy way by just filling the file with FF's before
     *  getting started.  To do it more optimally would be quite a bit
     *  more difficult since the user can skip around as much as he/she
     *  likes in the input hex file addressing.
     *
     *  We'll clean this up later (after this program has run) with
     *  'stripffs'
     */
 
    if (FFfill)
    {
        (void) fseek(ofp, 0, 0);
        for (c = FFfill; c > 0; c--)
            (void) fputc(0xFF, ofp);
    }
 
    /*
     * Read the first char from file and determine record types
     */
 
    if ((c = getc(ifp)) != EOF)
    {
        ungetc(c, ifp);
        switch(c)
        {
            case 'S':
                convert_S_records(ifp, inm, ofp, onm);
                break;
 
            case ':':
                convert_Intel_records(ifp, inm, ofp, onm);
                break;
 
            case '9':
            case 'B':
                convert_TI_records(ifp, inm, ofp, onm);
                break;
 
            default:
            {
                char tmp[2];
                tmp[0] = c; tmp[1] = 0;
                badformat(tmp, inm, BADFMT);
            }
        }
    }
 
    if (verbose)
        fprintf(stderr, "'%s' checksum is 0x%04x\n", inm, filesum);
 
    return 0;
}
 
int
convert_Intel_records(
    FILE *ifp,
    char *inm,
    FILE *ofp,
    char *onm)
{
    char buff[512];
    char *p;
    u8 cksum;
    int incksum;
    int c;
    int rectype;                    /* record type */
    int len;                        /* data length of current line */
    u32 addr;
    u32 base_address = 0;
    bool endrecord = FALSE;
    buffer_rec tb;
 
    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
    {
        p = &buff[0];
 
        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
            p[strlen(p)-1] = '\0';
 
        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
            p[strlen(p)-1] = '\0';
 
        tb.dl_count = 0;
 
        if (*p != ':')
            badformat(p, inm, BADFMT);
        p++;
 
        if ((len = getbyte(&p)) == -1)      /* record len */
            badformat(buff, inm, BADLEN);
 
        if ((addr = get2bytes(&p)) == -1L)          /* record addr */
            badformat(buff, inm, BADADDR);
 
        rectype = getbyte(&p);
 
        cksum = len + B0(addr) + B1(addr) + rectype;
 
        switch (rectype)
        {
            case 0x00:                  /* normal data record */
                tb.dl_destaddr = base_address + addr;
                while (len--)
                {
                    if ((c = getbyte(&p)) == -1)
                        badformat(buff, inm, BADDATA);
                    cksum += c;
                    filesum += c;
                    tb.dl_buf[tb.dl_count++] = c;
                }
                break;
 
            case 0x01:                  /* execution start address */
                base_address = addr;
                endrecord = TRUE;
                break;
 
            case 0x02:                  /* new base */
                if ((base_address = get2bytes(&p)) == -1L)
                    badformat(buff, inm, BADBASE);
                cksum += B0(base_address) + B1(base_address);
                base_address <<= 4;
                break;
 
            case 0x03:                  /* seg/off execution start address */
            {
                u32 seg, off;
 
                seg = get2bytes(&p);
                off = get2bytes(&p);
                if ((seg == -1L) || (off == -1L))
                    badformat(buff, inm, BADADDR);
 
                cksum += B0(seg) + B1(seg) + B0(off) + B1(off);
 
                tb.dl_jumpaddr = (seg << 4) + off;
                break;
            }
 
            default:
                error(0, "unknown Intel-hex record type: 0x%02x", rectype);
                badformat(buff, inm, BADTYPE);
        }
 
        /*
         * Verify checksums are correct in file.
         */
 
        cksum = (-cksum) & 0xff;
        if ((incksum = getbyte(&p)) == -1)
            badformat(buff, inm, BADCSUM);
        if (((u8) incksum) != cksum)
            badformat(buff, inm, MISCSUM);
 
        if (tb.dl_count)
            write_record(&tb, ofp);
    }
    return 0;
}
 
int
convert_S_records(
    FILE *ifp,
    char *inm,
    FILE *ofp,
    char *onm)
{
    char buff[512];
    char *p;
    u8 cksum;
    int incksum;
    int c;
    int len;                        /* data length of current line */
    int rectype;                    /* record type */
    u32 addr;
    bool endrecord = FALSE;
    buffer_rec tb;
 
    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
    {
        p = &buff[0];
 
        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
            p[strlen(p)-1] = '\0';
 
        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
            p[strlen(p)-1] = '\0';
 
        tb.dl_count = 0;
 
        if (*p != 'S')
            badformat(p, inm, BADFMT);
        p++;
 
        if ((rectype = getnibble(&p)) == -1)        /* record type */
            badformat(buff, inm, BADTYPE);
 
        if ((len = getbyte(&p)) == -1)              /* record len */
            badformat(buff, inm, BADLEN);
        cksum = len;
 
        switch (rectype)
        {
            case 0x00:                  /* comment field, ignored */
                goto write_it;
 
            case 0x01:                          /* data record, 16 bit addr */
                if ((addr = get2bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
                len -= 3;
                goto doit;
 
            case 0x02:                          /* ... 24 bit addr */
                if ((addr = get3bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
                len -= 4;
                goto doit;
 
            case 0x03:                          /* ... 32 bit addr */
                if ((addr = get4bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
                len -= 5;
    doit:
                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
 
                tb.dl_destaddr = addr;
                while (len--)
                {
                    if ((c = getbyte(&p)) == -1)
                        badformat(buff, inm, BADDATA);
                    cksum += c;
                    filesum += c;
                    tb.dl_buf[tb.dl_count++] = c;
                }
                break;
 
            case 0x07:                  /* 32 bit end record */
                if ((addr = get4bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
                goto end_rec;
 
            case 0x08:                  /* 24 bit end record */
                if ((addr = get3bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
                goto end_rec;
 
            case 0x09:                  /* 16 bit end record */
                if ((addr = get2bytes(&p)) == -1L)
                    badformat(buff, inm, BADADDR);
 
end_rec:
                cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);
                tb.dl_jumpaddr = addr;
                break;
 
            default:
                error(0, "unknown Motorola-S record type: 0x%02x", rectype);
                badformat(buff, inm, BADTYPE);
                break;
        }
 
        /*
         * Verify checksums are correct in file.
         */
 
        cksum = (~cksum) & 0xff;
        if ((incksum = getbyte(&p)) == -1)
            badformat(buff, inm, BADCSUM);
        if (((u8) incksum) != cksum)
            badformat(buff, inm, MISCSUM);
 
write_it:
        if (tb.dl_count)
            write_record(&tb, ofp);
    }
    return 0;
}
 
int
convert_TI_records(
    FILE *ifp,
    char *inm,
    FILE *ofp,
    char *onm)
{
    char buff[512];
    char *p;
    int c;
    bool endrecord = FALSE;
    bool eol;
    buffer_rec tb;
 
    while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))
    {
        if (p[strlen(p)-1] == '\n')                 /* get rid of newline */
            p[strlen(p)-1] = '\0';
 
        if (p[strlen(p)-1] == '\r')                 /* get rid of any CR */
            p[strlen(p)-1] = '\0';
 
        tb.dl_count = 0;
 
        p = &buff[0];
        eol = FALSE;
        while ( ! eol && ! endrecord)
        {
            switch (*p++)
            {
                case '9':
                    if (tb.dl_count)
                        write_record(&tb, ofp);
                    tb.dl_destaddr = get2bytes(&p);
                    break;
 
                case 'B':
                    c = getbyte(&p);
                    filesum += c;
                    tb.dl_buf[tb.dl_count++] = c;
                    c = getbyte(&p);
                    filesum += c;
                    tb.dl_buf[tb.dl_count++] = c;
                    break;
 
                case 'F':
                    eol = TRUE;
                    break;
 
                case ':':
                    endrecord = TRUE;
                    break;
 
                default:
                    badformat(p, inm, BADFMT);
            }
        }
        if (tb.dl_count)
            write_record(&tb, ofp);
    }
    return 0;
}
 
void
write_record(buffer_rec *tb,
             FILE *fp)
{
    if ( ! linear)
    {
        if (tb->dl_destaddr < base)
            error(ERR_FATAL, "record at address 0x%x precedes base of 0x%x",
                     tb->dl_destaddr, base);
        (void) fseek(fp, tb->dl_destaddr - base, 0);
    }
 
    (void) fwrite(tb->dl_buf, tb->dl_count, 1, fp);
    tb->dl_destaddr += tb->dl_count;
    tb->dl_count = 0;
}
 
int
getnibble(char **p)
{
    register int val;
 
    **p = toupper(**p);
    switch (**p)
    {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            val = **p - '0';
            break;
 
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            val = 10 + (**p - 'A');
            break;
 
        default:
            return(-1);
    }
    *p += 1;
 
    return(val & 0x0f);
}
 
int
getbyte(char **p)
{
    int n0, n1;
 
    if ((n0 = getnibble(p)) == -1)
        return(-1);
    if ((n1 = getnibble(p)) == -1)
        return(-1);
 
    return(((n0 << 4) + n1) & 0xff);
}
 
long
getNbytes(char **p,
          int n)
{
    int t;
    u32 val = 0;
 
    while (n--)
    {
        if ((t = getbyte(p)) == -1)
            return(-1L);
        val <<= 8;
        val += t;
    }
 
    return(val);
}
 
void
badformat(char *s,
          char *fname,
          char *msg)
{
    if (s[strlen(s)-1] == '\n')             /* get rid of newline */
        s[strlen(s)-1] = '\0';
    error(0, "line '%s'::\n\tfrom file '%s'; %s", s, fname, msg);
    exit(1);
}
 
/*
 * error(errn, arglist)
 *      report an error to stderr using printf(3) conventions.
 *      Any output is preceded by '<progname>: '
 *
 * Uses ERR_EXIT  bit to request exit(errn)
 *      ERR_ABORT to request abort()
 *      ERR_ERRNO to indicate use of errno instead of argument.
 *
 * If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its
 *      associated error message is appended to the output.
 */
 
/*VARARGS*/
 
void
error(int error_flag, ...)
{
    va_list arglist;
    register char *format;
    int local_errno;
 
    extern int errno;
 
    (void) fflush(stdout);          /* in case stdout/stderr same */
 
    local_errno = error_flag & ~ERR_MASK;
    if (error_flag & ERR_ERRNO)     /* use errno? */
        local_errno = errno;
 
    va_start(arglist, error_flag);
    format = va_arg(arglist, char *);
    (void) fprintf(stderr, "%s: ", progname);
    (void) vfprintf(stderr, format, arglist);
    va_end(arglist);
 
    if (local_errno)
      (void) fprintf(stderr, " (%s)\n", strerror(local_errno));
    else
      (void) fprintf(stderr, "\n");
 
    (void) fflush(stderr);
 
    if (error_flag & (ERR_FATAL | ERR_ABORT))
    {
        if (error_flag & ERR_FATAL)
        {
            error(0, "fatal error, exiting");
            exit(local_errno ? local_errno : 1);
        }
        else
        {
            error(0, "fatal error, aborting");
            abort();
        }
    }
}
 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [tools/] [build/] [unhex.c] - Blame information for rev 210

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`* unhex`
3			`* convert a hex file to binary equivalent. If more than one file name`
4			`* is given, then the output will be logically concatenated together.`
5			`* stdin and stdout are defaults. Verbose will enable checksum output.`
6			`*`
7			`* Supported input formats are Intel hex, Motorola S records, and TI 'B'`
8			`* records.`
9			`*`
10			`* Intel hex input format is`
11			`* Byte`
12			`* 1 Colon :`
13			`* 2..3 Record length, eg: "20"`
14			`* 4..7 load address nibbles`
15			`* 8..9 record type: "00" (data) or "02" base addr`
16			`* 10..x data bytes in ascii-hex`
17			`* x+1..x+2 cksum (2's compl of (len+addr+data))`
18			`* x+3 \n -- newline`
19			`*`
20			`* $Id: unhex.c,v 1.2 2001-09-27 12:02:53 chris Exp $`
21			`*/`
22
23			`char *USAGE = "\`
24			`usage: unhex [-va] [ -o file ] [ file [file ... ] ]\n\`
25			`-v -- verbose\n\`
26			`-a base -- 1st byte of output corresponds to this address\n\`
27			`-l -- linear, just writes data out\n\`
28			`-o file -- output file; must not be input file\n\`
29			`-F k_bits -- \"holes\" in input will be filled with 0xFF's\n\`
30			`up to \"k_bits\" * 1024 bits\n\`
31			`";`
32
33			`#include <stdio.h>`
34			`#include <fcntl.h>`
35			`#include <ctype.h>`
36			`#include <string.h>`
37			`#include <unistd.h>`
38			`#include <stdlib.h>`
39			`#include <stdarg.h>`
40			`#include <errno.h>`
41
42			`#include "config.h"`
43
44			`#ifndef VMS`
45			`#ifndef HAVE_STRERROR`
46			`extern int sys_nerr;`
47			`extern char *sys_errlist[];`
48
49			`#define strerror( _err ) \`
50			`((_err) < sys_nerr) ? sys_errlist [(_err)] : "unknown error"`
51
52			`#else /* HAVE_STRERROR */`
53			`char *strerror ();`
54			`#endif`
55			`#else /* VMS */`
56			`char *strerror (int,...);`
57			`#endif`
58
59
60			`#define OK 0`
61			`#define FAILURE (-1)`
62			`#define Failed(x) ((x) == FAILURE)`
63			`#define TRUE 1`
64			`#define FALSE 0`
65			`typedef char bool;`
66			`#define STREQ(a,b) (strcmp(a,b) == 0)`
67
68			`typedef unsigned char u8;`
69			`typedef unsigned short u16;`
70			`typedef unsigned long u32;`
71
72			`/*`
73			`* Pick out designated bytes`
74			`*/`
75
76			`#define B0(x) ((x) & 0xff)`
77			`#define B1(x) B0((x) >> 8)`
78			`#define B2(x) B0((x) >> 16)`
79			`#define B3(x) B0((x) >> 24)`
80
81			`typedef struct buffer_rec {`
82			`u32 dl_destaddr;`
83			`u32 dl_jumpaddr;`
84			`int dl_count;`
85			`u8 dl_buf[512];`
86			`} buffer_rec;`
87
88			`/*`
89			`* vars controlled by command line options`
90			`*/`
91
92			`bool verbose = FALSE; /* be verbose */`
93			`bool linear = FALSE; /* just write out linear data */`
94			`char outfilename = "-"; / default output is stdout */`
95			`u32 base = 0L; /* base address */`
96			`u32 FFfill = 0L; /* how far to fill w 0xFF's */`
97
98			`extern char optarg; / getopt(3) control vars */`
99			`extern int optind;`
100
101			`char progname; / for error() */`
102
103			`void error(int errn, ...);`
104			`#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */`
105			`#define ERR_FATAL (ERR_ERRNO / 2) /* error is fatal; no return */`
106			`#define ERR_ABORT (ERR_ERRNO / 4) /* error is fatal; abort */`
107			`#define ERR_MASK (ERR_ERRNO \| ERR_FATAL \| ERR_ABORT) /* all */`
108
109			`#ifdef HAVE_STRTOUL`
110			`#define stol(p) strtoul(p, (char **) NULL, 0)`
111			`#else`
112			`#define stol(p) strtol(p, (char **) NULL, 0)`
113			`#endif`
114
115			`int unhex(FILE ifp, char inm, FILE ofp, char onm);`
116			`int convert_Intel_records(FILE ifp, char inm, FILE ofp, char onm);`
117			`int convert_S_records(FILE ifp, char inm, FILE ofp, char onm);`
118			`int convert_TI_records(FILE ifp, char inm, FILE ofp, char onm);`
119			`void write_record(buffer_rec tb, FILE fp);`
120			`int getnibble(char **p);`
121			`int getbyte(char **p);`
122			`long getNbytes(char **p, int n);`
123			`void badformat(char s, char fname, char *msg);`
124
125			`#define get1bytes(p) ((int) getbyte(p))`
126			`#define get2bytes(p) ((int) getNbytes(p, 2))`
127			`#define get3bytes(p) getNbytes(p, 3)`
128			`#define get4bytes(p) getNbytes(p, 4)`
129
130			`char *BADADDR = "Invalid record address";`
131			`char *BADLEN = "Invalid record length";`
132			`char *BADBASE = "Bad base or starting address";`
133			`char *BADFMT = "Unrecognized record type";`
134			`char *BADDATA = "Invalid data byte";`
135			`char *BADCSUM = "Invalid checksum";`
136			`char *MISCSUM = "Checksum mismatch";`
137			`char *BADTYPE = "Unrecognized record type";`
138			`char *MISTYPE = "Incompatible record types";`
139
140			`int main(`
141			`int argc,`
142			`char **argv`
143			`)`
144			`{`
145			`register int c;`
146			`bool showusage = FALSE; /* usage error? */`
147			`int rc = 0;`
148			`FILE outfp, infp;`
149
150			`/*`
151			`* figure out invocation leaf-name`
152			`*/`
153
154			`if ((progname = strrchr(argv[0], '/')) == (char *) NULL)`
155			`progname = argv[0];`
156			`else`
157			`progname++;`
158
159			`argv[0] = progname; /* for getopt err reporting */`
160
161			`/*`
162			`* Check options and arguments.`
163			`*/`
164
165			`progname = argv[0];`
166			`while ((c = getopt(argc, argv, "F:a:o:vl")) != EOF)`
167			`switch (c)`
168			`{`
169			`case 'a': /* base address */`
170			`base = stol(optarg);`
171			`break;`
172
173			`case 'l': /* linear output */`
174			`linear = TRUE;`
175			`break;`
176
177			`case 'v': /* toggle verbose */`
178			`verbose = ! verbose;`
179			`break;`
180
181			`case 'o': /* output file */`
182			`outfilename = optarg;`
183			`break;`
184
185			`case 'F': /* 0xFF fill amount (bytes) */`
186			`FFfill = stol(optarg) * 1024L / 8L;`
187			`break;`
188
189			`case '?':`
190			`showusage = TRUE;`
191			`}`
192
193			`if (showusage)`
194			`{`
195			`(void) fprintf(stderr, "%s", USAGE);`
196			`exit(1);`
197			`}`
198
199			`if (linear && (base != 0))`
200			`{`
201			`error(0, "-l and -a may not be specified in combination");`
202			`exit(1);`
203			`}`
204
205			`if (STREQ(outfilename, "-"))`
206			`{`
207			`outfp = stdout;`
208			`outfilename = "stdout";`
209			`}`
210			`else`
211			`if ((outfp = fopen(outfilename, "w")) == (FILE *) NULL)`
212			`{`
213			`error(-1, "couldn't open '%s' for output", outfilename);`
214			`exit(1);`
215			`}`
216
217			`/*`
218			`* Now process the input files (or stdin, if none specified)`
219			`*/`
220
221			`if (argv[optind] == (char ) NULL) / just stdin */`
222			`exit(unhex(stdin, "stdin", outfp, outfilename));`
223			`else`
224			`for (; (optarg = argv[optind]); optind++)`
225			`{`
226			`if (STREQ(optarg, "-"))`
227			`rc += unhex(stdin, "stdin", outfp, outfilename);`
228			`else`
229			`{`
230			`if ((infp = fopen(optarg, "r")) == (FILE *) NULL)`
231			`{`
232			`error(-1, "couldn't open '%s' for input", optarg);`
233			`exit(1);`
234			`}`
235			`rc += unhex(infp, optarg, outfp, outfilename);`
236			`}`
237			`}`
238
239			`return(rc);`
240			`}`
241
242			`u16 filesum;`
243
244			`int`
245			`unhex(FILE *ifp,`
246			`char *inm,`
247			`FILE *ofp,`
248			`char *onm)`
249			`{`
250			`int c;`
251
252			`filesum = 0;`
253
254			`/*`
255			`* Make sure holes will be filled with 0xFF's if requested. We`
256			`* do this the easy way by just filling the file with FF's before`
257			`* getting started. To do it more optimally would be quite a bit`
258			`* more difficult since the user can skip around as much as he/she`
259			`* likes in the input hex file addressing.`
260			`*`
261			`* We'll clean this up later (after this program has run) with`
262			`* 'stripffs'`
263			`*/`
264
265			`if (FFfill)`
266			`{`
267			`(void) fseek(ofp, 0, 0);`
268			`for (c = FFfill; c > 0; c--)`
269			`(void) fputc(0xFF, ofp);`
270			`}`
271
272			`/*`
273			`* Read the first char from file and determine record types`
274			`*/`
275
276			`if ((c = getc(ifp)) != EOF)`
277			`{`
278			`ungetc(c, ifp);`
279			`switch(c)`
280			`{`
281			`case 'S':`
282			`convert_S_records(ifp, inm, ofp, onm);`
283			`break;`
284
285			`case ':':`
286			`convert_Intel_records(ifp, inm, ofp, onm);`
287			`break;`
288
289			`case '9':`
290			`case 'B':`
291			`convert_TI_records(ifp, inm, ofp, onm);`
292			`break;`
293
294			`default:`
295			`{`
296			`char tmp[2];`
297			`tmp[0] = c; tmp[1] = 0;`
298			`badformat(tmp, inm, BADFMT);`
299			`}`
300			`}`
301			`}`
302
303			`if (verbose)`
304			`fprintf(stderr, "'%s' checksum is 0x%04x\n", inm, filesum);`
305
306			`return 0;`
307			`}`
308
309			`int`
310			`convert_Intel_records(`
311			`FILE *ifp,`
312			`char *inm,`
313			`FILE *ofp,`
314			`char *onm)`
315			`{`
316			`char buff[512];`
317			`char *p;`
318			`u8 cksum;`
319			`int incksum;`
320			`int c;`
321			`int rectype; /* record type */`
322			`int len; /* data length of current line */`
323			`u32 addr;`
324			`u32 base_address = 0;`
325			`bool endrecord = FALSE;`
326			`buffer_rec tb;`
327
328			`while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))`
329			`{`
330			`p = &buff[0];`
331
332			`if (p[strlen(p)-1] == '\n') /* get rid of newline */`
333			`p[strlen(p)-1] = '\0';`
334
335			`if (p[strlen(p)-1] == '\r') /* get rid of any CR */`
336			`p[strlen(p)-1] = '\0';`
337
338			`tb.dl_count = 0;`
339
340			`if (*p != ':')`
341			`badformat(p, inm, BADFMT);`
342			`p++;`
343
344			`if ((len = getbyte(&p)) == -1) /* record len */`
345			`badformat(buff, inm, BADLEN);`
346
347			`if ((addr = get2bytes(&p)) == -1L) /* record addr */`
348			`badformat(buff, inm, BADADDR);`
349
350			`rectype = getbyte(&p);`
351
352			`cksum = len + B0(addr) + B1(addr) + rectype;`
353
354			`switch (rectype)`
355			`{`
356			`case 0x00: /* normal data record */`
357			`tb.dl_destaddr = base_address + addr;`
358			`while (len--)`
359			`{`
360			`if ((c = getbyte(&p)) == -1)`
361			`badformat(buff, inm, BADDATA);`
362			`cksum += c;`
363			`filesum += c;`
364			`tb.dl_buf[tb.dl_count++] = c;`
365			`}`
366			`break;`
367
368			`case 0x01: /* execution start address */`
369			`base_address = addr;`
370			`endrecord = TRUE;`
371			`break;`
372
373			`case 0x02: /* new base */`
374			`if ((base_address = get2bytes(&p)) == -1L)`
375			`badformat(buff, inm, BADBASE);`
376			`cksum += B0(base_address) + B1(base_address);`
377			`base_address <<= 4;`
378			`break;`
379
380			`case 0x03: /* seg/off execution start address */`
381			`{`
382			`u32 seg, off;`
383
384			`seg = get2bytes(&p);`
385			`off = get2bytes(&p);`
386			`if ((seg == -1L) \|\| (off == -1L))`
387			`badformat(buff, inm, BADADDR);`
388
389			`cksum += B0(seg) + B1(seg) + B0(off) + B1(off);`
390
391			`tb.dl_jumpaddr = (seg << 4) + off;`
392			`break;`
393			`}`
394
395			`default:`
396			`error(0, "unknown Intel-hex record type: 0x%02x", rectype);`
397			`badformat(buff, inm, BADTYPE);`
398			`}`
399
400			`/*`
401			`* Verify checksums are correct in file.`
402			`*/`
403
404			`cksum = (-cksum) & 0xff;`
405			`if ((incksum = getbyte(&p)) == -1)`
406			`badformat(buff, inm, BADCSUM);`
407			`if (((u8) incksum) != cksum)`
408			`badformat(buff, inm, MISCSUM);`
409
410			`if (tb.dl_count)`
411			`write_record(&tb, ofp);`
412			`}`
413			`return 0;`
414			`}`
415
416			`int`
417			`convert_S_records(`
418			`FILE *ifp,`
419			`char *inm,`
420			`FILE *ofp,`
421			`char *onm)`
422			`{`
423			`char buff[512];`
424			`char *p;`
425			`u8 cksum;`
426			`int incksum;`
427			`int c;`
428			`int len; /* data length of current line */`
429			`int rectype; /* record type */`
430			`u32 addr;`
431			`bool endrecord = FALSE;`
432			`buffer_rec tb;`
433
434			`while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))`
435			`{`
436			`p = &buff[0];`
437
438			`if (p[strlen(p)-1] == '\n') /* get rid of newline */`
439			`p[strlen(p)-1] = '\0';`
440
441			`if (p[strlen(p)-1] == '\r') /* get rid of any CR */`
442			`p[strlen(p)-1] = '\0';`
443
444			`tb.dl_count = 0;`
445
446			`if (*p != 'S')`
447			`badformat(p, inm, BADFMT);`
448			`p++;`
449
450			`if ((rectype = getnibble(&p)) == -1) /* record type */`
451			`badformat(buff, inm, BADTYPE);`
452
453			`if ((len = getbyte(&p)) == -1) /* record len */`
454			`badformat(buff, inm, BADLEN);`
455			`cksum = len;`
456
457			`switch (rectype)`
458			`{`
459			`case 0x00: /* comment field, ignored */`
460			`goto write_it;`
461
462			`case 0x01: /* data record, 16 bit addr */`
463			`if ((addr = get2bytes(&p)) == -1L)`
464			`badformat(buff, inm, BADADDR);`
465			`len -= 3;`
466			`goto doit;`
467
468			`case 0x02: /* ... 24 bit addr */`
469			`if ((addr = get3bytes(&p)) == -1L)`
470			`badformat(buff, inm, BADADDR);`
471			`len -= 4;`
472			`goto doit;`
473
474			`case 0x03: /* ... 32 bit addr */`
475			`if ((addr = get4bytes(&p)) == -1L)`
476			`badformat(buff, inm, BADADDR);`
477			`len -= 5;`
478			`doit:`
479			`cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);`
480
481			`tb.dl_destaddr = addr;`
482			`while (len--)`
483			`{`
484			`if ((c = getbyte(&p)) == -1)`
485			`badformat(buff, inm, BADDATA);`
486			`cksum += c;`
487			`filesum += c;`
488			`tb.dl_buf[tb.dl_count++] = c;`
489			`}`
490			`break;`
491
492			`case 0x07: /* 32 bit end record */`
493			`if ((addr = get4bytes(&p)) == -1L)`
494			`badformat(buff, inm, BADADDR);`
495			`goto end_rec;`
496
497			`case 0x08: /* 24 bit end record */`
498			`if ((addr = get3bytes(&p)) == -1L)`
499			`badformat(buff, inm, BADADDR);`
500			`goto end_rec;`
501
502			`case 0x09: /* 16 bit end record */`
503			`if ((addr = get2bytes(&p)) == -1L)`
504			`badformat(buff, inm, BADADDR);`
505
506			`end_rec:`
507			`cksum += B0(addr) + B1(addr) + B2(addr) + B3(addr);`
508			`tb.dl_jumpaddr = addr;`
509			`break;`
510
511			`default:`
512			`error(0, "unknown Motorola-S record type: 0x%02x", rectype);`
513			`badformat(buff, inm, BADTYPE);`
514			`break;`
515			`}`
516
517			`/*`
518			`* Verify checksums are correct in file.`
519			`*/`
520
521			`cksum = (~cksum) & 0xff;`
522			`if ((incksum = getbyte(&p)) == -1)`
523			`badformat(buff, inm, BADCSUM);`
524			`if (((u8) incksum) != cksum)`
525			`badformat(buff, inm, MISCSUM);`
526
527			`write_it:`
528			`if (tb.dl_count)`
529			`write_record(&tb, ofp);`
530			`}`
531			`return 0;`
532			`}`
533
534			`int`
535			`convert_TI_records(`
536			`FILE *ifp,`
537			`char *inm,`
538			`FILE *ofp,`
539			`char *onm)`
540			`{`
541			`char buff[512];`
542			`char *p;`
543			`int c;`
544			`bool endrecord = FALSE;`
545			`bool eol;`
546			`buffer_rec tb;`
547
548			`while ( ! endrecord && (fgets(buff, sizeof(buff), ifp)))`
549			`{`
550			`if (p[strlen(p)-1] == '\n') /* get rid of newline */`
551			`p[strlen(p)-1] = '\0';`
552
553			`if (p[strlen(p)-1] == '\r') /* get rid of any CR */`
554			`p[strlen(p)-1] = '\0';`
555
556			`tb.dl_count = 0;`
557
558			`p = &buff[0];`
559			`eol = FALSE;`
560			`while ( ! eol && ! endrecord)`
561			`{`
562			`switch (*p++)`
563			`{`
564			`case '9':`
565			`if (tb.dl_count)`
566			`write_record(&tb, ofp);`
567			`tb.dl_destaddr = get2bytes(&p);`
568			`break;`
569
570			`case 'B':`
571			`c = getbyte(&p);`
572			`filesum += c;`
573			`tb.dl_buf[tb.dl_count++] = c;`
574			`c = getbyte(&p);`
575			`filesum += c;`
576			`tb.dl_buf[tb.dl_count++] = c;`
577			`break;`
578
579			`case 'F':`
580			`eol = TRUE;`
581			`break;`
582
583			`case ':':`
584			`endrecord = TRUE;`
585			`break;`
586
587			`default:`
588			`badformat(p, inm, BADFMT);`
589			`}`
590			`}`
591			`if (tb.dl_count)`
592			`write_record(&tb, ofp);`
593			`}`
594			`return 0;`
595			`}`
596
597			`void`
598			`write_record(buffer_rec *tb,`
599			`FILE *fp)`
600			`{`
601			`if ( ! linear)`
602			`{`
603			`if (tb->dl_destaddr < base)`
604			`error(ERR_FATAL, "record at address 0x%x precedes base of 0x%x",`
605			`tb->dl_destaddr, base);`
606			`(void) fseek(fp, tb->dl_destaddr - base, 0);`
607			`}`
608
609			`(void) fwrite(tb->dl_buf, tb->dl_count, 1, fp);`
610			`tb->dl_destaddr += tb->dl_count;`
611			`tb->dl_count = 0;`
612			`}`
613
614			`int`
615			`getnibble(char **p)`
616			`{`
617			`register int val;`
618
619			`p = toupper(p);`
620			`switch (**p)`
621			`{`
622			`case '0': case '1': case '2': case '3': case '4':`
623			`case '5': case '6': case '7': case '8': case '9':`
624			`val = **p - '0';`
625			`break;`
626
627			`case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':`
628			`val = 10 + (**p - 'A');`
629			`break;`
630
631			`default:`
632			`return(-1);`
633			`}`
634			`*p += 1;`
635
636			`return(val & 0x0f);`
637			`}`
638
639			`int`
640			`getbyte(char **p)`
641			`{`
642			`int n0, n1;`
643
644			`if ((n0 = getnibble(p)) == -1)`
645			`return(-1);`
646			`if ((n1 = getnibble(p)) == -1)`
647			`return(-1);`
648
649			`return(((n0 << 4) + n1) & 0xff);`
650			`}`
651
652			`long`
653			`getNbytes(char **p,`
654			`int n)`
655			`{`
656			`int t;`
657			`u32 val = 0;`
658
659			`while (n--)`
660			`{`
661			`if ((t = getbyte(p)) == -1)`
662			`return(-1L);`
663			`val <<= 8;`
664			`val += t;`
665			`}`
666
667			`return(val);`
668			`}`
669
670			`void`
671			`badformat(char *s,`
672			`char *fname,`
673			`char *msg)`
674			`{`
675			`if (s[strlen(s)-1] == '\n') /* get rid of newline */`
676			`s[strlen(s)-1] = '\0';`
677			`error(0, "line '%s'::\n\tfrom file '%s'; %s", s, fname, msg);`
678			`exit(1);`
679			`}`
680
681			`/*`
682			`* error(errn, arglist)`
683			`* report an error to stderr using printf(3) conventions.`
684			`* Any output is preceded by '<progname>: '`
685			`*`
686			`* Uses ERR_EXIT bit to request exit(errn)`
687			`* ERR_ABORT to request abort()`
688			`* ERR_ERRNO to indicate use of errno instead of argument.`
689			`*`
690			`* If resulting 'errn' is non-zero, it is assumed to be an 'errno' and its`
691			`* associated error message is appended to the output.`
692			`*/`
693
694			`/VARARGS/`
695
696			`void`
697			`error(int error_flag, ...)`
698			`{`
699			`va_list arglist;`
700			`register char *format;`
701			`int local_errno;`
702
703			`extern int errno;`
704
705			`(void) fflush(stdout); /* in case stdout/stderr same */`
706
707			`local_errno = error_flag & ~ERR_MASK;`
708			`if (error_flag & ERR_ERRNO) /* use errno? */`
709			`local_errno = errno;`
710
711			`va_start(arglist, error_flag);`
712			`format = va_arg(arglist, char *);`
713			`(void) fprintf(stderr, "%s: ", progname);`
714			`(void) vfprintf(stderr, format, arglist);`
715			`va_end(arglist);`
716
717			`if (local_errno)`
718			`(void) fprintf(stderr, " (%s)\n", strerror(local_errno));`
719			`else`
720			`(void) fprintf(stderr, "\n");`
721
722			`(void) fflush(stderr);`
723
724			`if (error_flag & (ERR_FATAL \| ERR_ABORT))`
725			`{`
726			`if (error_flag & ERR_FATAL)`
727			`{`
728			`error(0, "fatal error, exiting");`
729			`exit(local_errno ? local_errno : 1);`
730			`}`
731			`else`
732			`{`
733			`error(0, "fatal error, aborting");`
734			`abort();`
735			`}`
736			`}`
737			`}`
738