Subversion Repositories or1k

/*****  P A C K H E X . C  ************************************************

 *

 *   Packhex is a hex-file compaction utility.  It attempts to concatenate

 *   hex records to produce more size-efficient packaging.

 *

 *   Limitations: Input files must be correctly formatted.  This utility

 *                is not robust enough to detect hex-record formatting

 *                errors.

 *

 *   Published:   May 1993 Embedded Systems Programming magazine

 *                "Creating Faster Hex Files"

 *

 *   URL:         ESP magazine: http://www.embedded.com

 *                Source Code:  ftp://ftp.mfi.com/pub/espmag/1993/pakhex.zip

 *

 *   Author:      Mark Gringrich

 *

 *   Compiler:    Microsoft C 6.0

 *                cl /F 1000 packhex.c

 *

 *

 *   $Id: packhex.c,v 1.2 2001-09-27 12:02:53 chris Exp $

 *

 **************************************************************************/

/* #define SMALLER_RECORDS */

#ifdef SMALLER_RECORDS

#define MAX_LEN_S1_RECS 128

#define MAX_LEN_S2_RECS 128

#define MAX_LEN_S3_RECS 128

#else

#define MAX_LEN_S1_RECS 252

#define MAX_LEN_S2_RECS 251

#define MAX_LEN_S3_RECS 250

#endif

/*--------------------------------- includes ---------------------------------*/

#include <stdio.h>

#include <stdlib.h>

#include <string.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

#if defined(__unix__) && !defined(EXIT_FAILURE)

#define EXIT_FAILURE -1

#define EXIT_SUCCESS  0

#endif

/*--------------------------------- defines ----------------------------------*/

#define YES                   1

#define MAX_LINE_SIZE       600

#define EOS                 '\0'

/*---------------------------------- macros ----------------------------------*/

/* Convert ASCII hexadecimal digit to value. */

#define HEX_DIGIT( C )   ( ( ( ( C ) > '9' ) ? ( C ) + 25 : ( C ) ) & 0xF )

/*--------------------------------- typedefs ---------------------------------*/

typedef unsigned char   Boolean;

typedef unsigned char   Uchar;

typedef unsigned int    Uint;

typedef unsigned long   Ulong;

typedef struct   /* Functions and constant returning Hex-record vital stats. */

{

    Boolean    ( *is_data_record  )( char *              );

    Ulong      ( *get_address     )( char *              );

    Uint       ( *get_data_count  )( char *              );

    const Uint    max_data_count;

    char      *( *get_data_start  )( char *              );

    void       ( *put_data_record )( Uint, Ulong, char * );

} Rec_vitals;

/*--------------------------- function prototypes ----------------------------*/

Rec_vitals  * identify_first_data_record( char *, int );

Ulong         get_ndigit_hex( char *, int );

/*----------------------------- Intel Hex format -----------------------------*/

/*

 *    Intel Hex data-record layout

 *

 *    :aabbbbccd...dee

 *

 *    :      - header character

 *    aa     - record data byte count, a 2-digit hex value

 *    bbbb   - record address, a 4-digit hex value

 *    cc     - record type, a 2-digit hex value:

 *              "00" is a data record

 *              "01" is an end-of-data record

 *              "02" is an extended-address record

 *              "03" is a start record

 *    d...d  - data (always an even number of chars)

 *    ee     - record checksum, a 2-digit hex value

 *             checksum = 2's complement

 *                 [ (sum of bytes: aabbbbccd...d) modulo 256 ]

 */

Boolean is_intel_data_rec( char * rec_str )

{

    return( ( rec_str[ 0 ] == ':' )  &&  ( rec_str[ 8 ] == '0' ) );

}

Uint get_intel_rec_data_count( char * rec_str )

{

    return( ( Uint ) get_ndigit_hex( rec_str + 1, 2 ) );

}

Ulong get_intel_rec_address( char * rec_str )

{

    return( get_ndigit_hex( rec_str + 3, 4 ) );

}

char * get_intel_rec_data_start( char * rec_str )

{

    return( rec_str + 9 );

}

void put_intel_data_rec( Uint count, Ulong address, char * data_str )

{

    char    *ptr;

    Uint    sum = count + ( address >> 8 & 0xff ) + ( address & 0xff );

    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )

        sum += ( Uint ) get_ndigit_hex( ptr, 2 );

    printf(

      ":%02X%04lX00%s%02X\n", count, address, data_str, (~sum + 1) & 0xff

    );

}

Rec_vitals  intel_hex =

{

    is_intel_data_rec,

    get_intel_rec_address,

    get_intel_rec_data_count,

    255,                        /* Maximum data bytes in a record. */

    get_intel_rec_data_start,

    put_intel_data_rec

};

/*------------------------- Motorola S1-record format ------------------------*/

/*

 *    Motorola S-record data-record layout

 *

 *    Sabbc...cd...dee

 *

 *    S      - header character

 *    a      - record type, a 1-digit value:

 *               "0" is a header record

 *               "1" is a 2-byte-address data record

 *               "2" is a 3-byte-address data record

 *               "3" is a 4-byte-address data record

 *               "7" is a 4-byte-address end-of-data record

 *               "8" is a 3-byte-address end-of-data record

 *               "9" is a 2-byte-address end-of-data record

 *    bb     - record length in bytes, a 2-digit hex value

 *             (record length doesn't count the header/type

 *              chars and checksum byte)

 *    c...c  - record address, a 4-, 6-, or 8-digit value,

 *               depending on record type

 *    d...d  - data (always an even number of chars)

 *    ee     - record checksum, a 2-digit hex value

 *             checksum = 1's complement

 *             [ (sum of all bytes: bbc..cd...d) modulo 256 ]

 */

#define S1_COUNT_OFFSET         3

Boolean is_moto_s1_data_rec( char * rec_str )

{

    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '1' ) );

}

Uint get_moto_s1_rec_data_count( char * rec_str )

{

    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S1_COUNT_OFFSET );

}

Ulong get_moto_s1_rec_address( char * rec_str )

{

    return( get_ndigit_hex( rec_str + 4, 4 ) );

}

char * get_moto_s1_rec_data_start( char * rec_str )

{

    return( rec_str + 8 );

}

void put_moto_s1_data_rec( Uint count, Ulong address, char * data_str )

{

    char   *ptr;

    Uint    sum = S1_COUNT_OFFSET + count +

                    ( address >> 8 & 0xff ) + ( address & 0xff );

    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )

        sum += ( Uint ) get_ndigit_hex( ptr, 2 );

    printf(

      "S1%02X%04lX%s%02X\n",

      count + S1_COUNT_OFFSET, address, data_str, ~sum & 0xff

    );

}

Rec_vitals  motorola_s1_rec =

{

    is_moto_s1_data_rec,

    get_moto_s1_rec_address,

    get_moto_s1_rec_data_count,

    MAX_LEN_S1_RECS,            /* Maximum data bytes in a record. */

    get_moto_s1_rec_data_start,

    put_moto_s1_data_rec

};

/*------------------------- Motorola S2-record format ------------------------*/

#define S2_COUNT_OFFSET         4

Boolean is_moto_s2_data_rec( char * rec_str )

{

    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '2' ) );

}

Uint get_moto_s2_rec_data_count( char * rec_str )

{

    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S2_COUNT_OFFSET );

}

Ulong get_moto_s2_rec_address( char * rec_str )

{

    return( get_ndigit_hex( rec_str + 4, 6 ) );

}

char * get_moto_s2_rec_data_start( char * rec_str )

{

    return( rec_str + 10 );

}

void put_moto_s2_data_rec( Uint count, Ulong address, char * data_str )

{

    char    *ptr;

    Uint    sum = S2_COUNT_OFFSET + count + ( address >> 16 & 0xff ) +

                                            ( address >>  8 & 0xff ) +

                                            ( address       & 0xff );

    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )

        sum += ( Uint ) get_ndigit_hex( ptr, 2 );

    printf(

      "S2%02X%06lX%s%02X\n",

      count + S2_COUNT_OFFSET, address, data_str, ~sum & 0xff

    );

}

Rec_vitals  motorola_s2_rec =

{

    is_moto_s2_data_rec,

    get_moto_s2_rec_address,

    get_moto_s2_rec_data_count,

    MAX_LEN_S2_RECS,            /* Maximum data bytes in a record. */

    get_moto_s2_rec_data_start,

    put_moto_s2_data_rec

};

/*------------------------- Motorola S3-record format ------------------------*/

#define S3_COUNT_OFFSET         5

Boolean is_moto_s3_data_rec( char * rec_str )

{

    return ( ( rec_str[ 0 ] == 'S' )  &&  ( rec_str[ 1 ] == '3' ) );

}

Uint get_moto_s3_rec_data_count( char * rec_str )

{

    return( ( Uint ) get_ndigit_hex( rec_str + 2, 2 ) - S3_COUNT_OFFSET );

}

Ulong get_moto_s3_rec_address( char * rec_str )

{

    return( get_ndigit_hex( rec_str + 4, 8 ) );

}

char * get_moto_s3_rec_data_start( char * rec_str )

{

    return( rec_str + 12 );

}

void put_moto_s3_data_rec( Uint count, Ulong address, char * data_str )

{

    char    *ptr;

    Uint     sum = S3_COUNT_OFFSET + count + ( address >> 24 & 0xff ) +

                                             ( address >> 16 & 0xff ) +

                                             ( address >>  8 & 0xff ) +

                                             ( address       & 0xff );

    for ( ptr = data_str ; *ptr != EOS ; ptr += 2 )

        sum += ( Uint ) get_ndigit_hex( ptr, 2 );

    printf(

      "S3%02X%08lX%s%02X\n",

      count + S3_COUNT_OFFSET, address, data_str, ~sum & 0xff

   );

}

Rec_vitals  motorola_s3_rec =

{

    is_moto_s3_data_rec,

    get_moto_s3_rec_address,

    get_moto_s3_rec_data_count,

    MAX_LEN_S3_RECS,            /* Maximum data bytes in a record. */

    get_moto_s3_rec_data_start,

    put_moto_s3_data_rec

};

/*-------------------- Put your favorite hex format here ---------------------*/

/*

 *    * * *  The following is a template for an additional hex format:  * * *

 *

 *

 *    Boolean is_X_data_rec( char * rec_str ) {}

 *

 *    Uint get_X_rec_data_count( char * rec_str ) {}

 *

 *    Ulong get_X_rec_address( char * rec_str ) {}

 *

 *    char * get_X_rec_data_start( char * rec_str ) {}

 *

 *    void put_X_data_rec( Uint count, Ulong address, char * data_str ) {}

 *

 *    Rec_vitals  X_rec =

 *    {

 *        is_X_data_rec,

 *        get_X_rec_address,

 *        get_X_rec_data_count,

 *        MAXIMUM DATA BYTES IN A RECORD,

 *        get_X_rec_data_start,

 *        put_X_data_rec

 *    };

 *

 */

/*----------------------------------------------------------------------------*/

/*

 *   Put address of additional Rec_vitals structures

 *   in this array, before the NULL entry.

 */

Rec_vitals  *formats[] =

{

    &intel_hex,

    &motorola_s1_rec,

    &motorola_s2_rec,

    &motorola_s3_rec,

    ( Rec_vitals * ) NULL

};

/****   main   *****************************************************************

*

*

*       Expects: Nothing (no command-line parameters).

*

*       Returns: Exit status (EXIT_SUCCESS or EXIT_FAILURE).

*

*       Reads hex records on the standard input and attempts to

*       splice adjacent data fields together.  Results appear on

*       the standard output.

*

*******************************************************************************/

int main(

  int argc,

  char **argv

)

{

    char       inbuff[ MAX_LINE_SIZE ], outbuff[ MAX_LINE_SIZE ];

    char       *in_dptr, *out_dptr;

    int        d_total, d_count, d_excess, n;

    int        length;

    Ulong      in_rec_addr, out_rec_addr = 0;

    Rec_vitals *rptr;

    /* Sift through file until first hex record is identified.    */

    rptr = identify_first_data_record( inbuff, MAX_LINE_SIZE );

    if ( rptr == NULL )

    {

        fputs( "No hex records found.\n", stderr );

        exit( EXIT_FAILURE );

    }

    /* Attempt data-record splicing until end-of-file is reached. */

    d_total = 0;

    for (;;) {

        if ( rptr->is_data_record( inbuff ) == YES )

        { /* Input record is a data record. */

            d_count     = rptr->get_data_count( inbuff );

            in_rec_addr = rptr->get_address( inbuff );

            in_dptr     = rptr->get_data_start( inbuff );

            if ( d_total == 0  ||  in_rec_addr != out_rec_addr + d_total )

            { /* Begin a new output record. */

                if ( d_total != 0 )

                    rptr->put_data_record( d_total, out_rec_addr, outbuff );

                out_dptr     = outbuff;

                n = d_total  = d_count;

                out_rec_addr = in_rec_addr;

            }

            else if

              ( ( d_excess = d_total + d_count - rptr->max_data_count ) > 0 )

            { /* Output a maximum-length record, then start a new record. */

                strncat( outbuff, in_dptr, 2 * ( d_count - d_excess ) );

                rptr->put_data_record(

                  rptr->max_data_count, out_rec_addr, outbuff

                );

                in_dptr      += 2 * ( d_count - d_excess );

                out_dptr      = outbuff;

                n = d_total   = d_excess;

                out_rec_addr += rptr->max_data_count;

            }

            else

            { /* Append input record's data field with accumulated data. */

                out_dptr = outbuff + ( 2 * d_total );

                d_total += n = d_count;

            }

            strncpy( out_dptr, in_dptr, 2 * n );

            out_dptr[ 2 * n ] = EOS;

        }

        else

        { /* Not a data record;

           * flush accumulated data then echo non-data record.

           */

            if ( d_total != 0 )

            {

                rptr->put_data_record( d_total, out_rec_addr, outbuff );

                d_total = 0;

            }

            puts( inbuff );

        }

        inbuff[ MAX_LINE_SIZE - 1 ] = '\0';

        if ( !fgets( inbuff, MAX_LINE_SIZE, stdin ) )

           break;

        if ( inbuff[ MAX_LINE_SIZE - 1 ] ) {

           fprintf( stderr, "Input line too long" );

           exit( 1 );

        }

        length = strlen(inbuff);

        inbuff[length - 1] = '\0';

    }

    return ( EXIT_SUCCESS );

}

/****   identify_first_data_record   *******************************************

*

*       Expects: Pointer to hex-record line buffer.

*

*       Returns: Pointer to hex-record structure (NULL if no match found).

*

*       Reads the standard input, line by line, searching for a valid

*       record header character.  If a valid header is found, a pointer

*       to the hex-record's type structure is returned, otherwise NULL.

*

*       The input-stream pointer is left pointing to the first valid hex record.

*

*******************************************************************************/

Rec_vitals * identify_first_data_record( char * buff_ptr, int max_length )

{

    Rec_vitals  ** ptr;

    int            length;

    for ( ;; ) {

        buff_ptr[ max_length - 1 ] = '\0';

        if ( !fgets( buff_ptr, max_length, stdin ) )

           break;

        if ( buff_ptr[ max_length - 1 ] ) {

           fprintf( stderr, "Input line too long" );

           exit( 1 );

        }

        length = strlen(buff_ptr);

        buff_ptr[length - 1] = '\0';

        for ( ptr = formats ; *ptr != ( Rec_vitals * ) NULL ; ptr++ )

            if ( ( *ptr )->is_data_record( buff_ptr ) == YES )

                return( *ptr );        /* Successful return.        */

        puts( buff_ptr );              /* Echo non-hex-record line. */

    }

    return( ( Rec_vitals * ) NULL );   /* Unsuccessful return.      */

}

/****   get_ndigit_hex   *******************************************************

*

*       Expects: Pointer to first ASCII hexadecimal digit, number of digits.

*

*       Returns: Value of hexadecimal string as an unsigned long.

*

*******************************************************************************/

Ulong get_ndigit_hex( char * cptr, int digits )

{

    Ulong    value;

    for ( value = 0 ; --digits >= 0 ; cptr++ )

        value = ( value * 16L ) + HEX_DIGIT( *cptr );

    return( value );

}