URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [rtems/] [tools/] [build/] [packhex.c] - Rev 611
Go to most recent revision | Compare with Previous | Blame | View Log
/***** 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 ); }
Go to most recent revision | Compare with Previous | Blame | View Log