diff options
Diffstat (limited to 'tools')
| -rw-r--r-- | tools/build/README | 32 | ||||
| -rw-r--r-- | tools/build/cklength.c | 364 | ||||
| -rw-r--r-- | tools/build/eolstrip.c | 351 | ||||
| -rw-r--r-- | tools/build/packhex.c | 513 | ||||
| -rw-r--r-- | tools/build/scripts/README | 32 | ||||
| -rw-r--r-- | tools/build/src/cklength.c | 364 | ||||
| -rw-r--r-- | tools/build/src/eolstrip.c | 351 | ||||
| -rw-r--r-- | tools/build/src/packhex.c | 513 | ||||
| -rw-r--r-- | tools/build/src/unhex.c | 719 | ||||
| -rw-r--r-- | tools/build/unhex.c | 719 | ||||
| -rw-r--r-- | tools/cpu/hppa1.1/genoffsets.c | 191 | ||||
| -rw-r--r-- | tools/update/310_to_320_list | 543 | ||||
| -rw-r--r-- | tools/update/README | 7 |
13 files changed, 4699 insertions, 0 deletions
diff --git a/tools/build/README b/tools/build/README new file mode 100644 index 0000000000..0436fc958d --- /dev/null +++ b/tools/build/README @@ -0,0 +1,32 @@ +# +# $Id$ +# + +Misc. support tools for RTEMS workspaces. +More will be added later as they are converted from Teamware +to CVS. + +install-if-change + Smart install script that also can append suffixes as it + installs (suffixes used for debug and profile variants). + Requires bash or ksh. + +rcs-clean + deletes all files from the current directory that can be + re-created from RCS. Careful to not delete locked files. + May be used by 'gmake clobber' + +lock-directory +unlock-directory + traverse a directory structure making it unwritable. + Useful to keep people from accidentally overwriting + "released" trees if they get confused about which + module they have loaded. + +rtems-glom + glom together all the rtems libraries in order to simplify + the link line used by applications. + Produces rtems.rel. + Not used by the RTEMS src tree at all. + Strictly optional. + diff --git a/tools/build/cklength.c b/tools/build/cklength.c new file mode 100644 index 0000000000..48801e1559 --- /dev/null +++ b/tools/build/cklength.c @@ -0,0 +1,364 @@ +/* + * cklength - check the length of lines in a file + * + * This program check to see if the files passed to it on the command line + * contain a line which exceeds the maximum allowable length. The default + * maximum line length is 80. + * + * usage: cklength [ -v ] [ arg ... ] files... + * -l length -- maximum line length + * -v -- verbose + * + * $Id$ + * $Log$ + */ + +#define GETOPTARGS "l:nNv" + +char *USAGE = "\ +usage: cklength [ -v ] [ arg ... ] files... \n\ + -l length -- maximum line length\n\ + -n -- report line numbers for offending lines\n\ + -N -- report line numbers and length for offending lines\n\ + -v -- verbose\n\ +\n\ +Print the name of files which have at least 1 line which exceeds the\n\ +maximum line length. The default maximum line length is 80.\n\ +"; + +#include <stdio.h> +#include <fcntl.h> +#include <ctype.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <memory.h> +#include <stdarg.h> + +#define BUFFER_SIZE 512 + +#define SUCCESS 0 +#define FAILURE -1 +#define Failed(x) (((int) (x)) == FAILURE) +#define TRUE 1 +#define FALSE 0 +#define STREQ(a,b) (strcmp(a,b) == 0) +#define NUMELEMS(arr) (sizeof(arr) / sizeof(arr[0])) + +/* + * Definitions for unsigned "ints"; especially for use in data structures + * that will be shared among (potentially) different cpu's (we punt on + * byte ordering problems tho) + */ + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned long u32; + +/* + * vars controlled by command line options + */ + +int verbose = FALSE; /* be verbose */ +int report_line_numbers = FALSE; /* report line numbers of offenders */ +int report_line_length = FALSE; /* report line length of offenders */ + +int line_length = 80; /* maximum allowable line length */ + +extern char *optarg; /* getopt(3) control vars */ +extern int optind, opterr; +extern int errno; + +char *progname; /* for error() */ + +int process(char *arg); +void error(int errn, ...); +long getparm(char *s, long min, long max, char *msg); + +#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */ +#define ERR_FATAL (ERR_ERRNO / 2) /* fatal error ; no return */ +#define ERR_ABORT (ERR_ERRNO / 4) /* fatal error ; abort */ +#define ERR_MASK (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */ + +#define stol(p) strtol(p, (char **) NULL, 0) +int Open(), Read(), Write(); + +int +main(int argc, char **argv, char **env) +{ + register int c; + int showusage = FALSE; /* usage error? */ + int rc = 0; + + /* + * 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. + */ + + opterr = 0; /* we'll report all errors */ + while ((c = getopt(argc, argv, GETOPTARGS)) != EOF) + switch (c) + { + case 'l': /* line length */ + line_length = atoi( optarg ); + if ( line_length < 0 || line_length > BUFFER_SIZE ) + error(ERR_FATAL, "(%d) is illegal line length\n",line_length); + break; + + case 'n': /* toggle report_line_numbers */ + report_line_numbers = ! report_line_numbers; + break; + + case 'N': /* toggle both reports */ + report_line_numbers = ! report_line_numbers; + report_line_length = ! report_line_length; + break; + + case 'v': /* toggle verbose */ + verbose = ! verbose; + break; + + case '?': + showusage = TRUE; + } + + if (showusage) + { + (void) fprintf(stderr, "%s", USAGE); + exit(1); + } + + /* + * traverse and process the arguments + */ + + for ( ; argv[optind]; optind++) + if (Failed(process(argv[optind]))) + rc = FAILURE; + + return rc; +} + + +/* + * process(arg) + */ + +int +process(char *arg) +{ + FILE *in; + char *bptr; + char buffer[ BUFFER_SIZE ]; + int line_number; + int length; + int count; + int rc = SUCCESS; /* succeed by default */ + + in = fopen( arg, "r" ); + if (!in) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + + count = 0; + + for ( line_number=1 ; ; line_number++ ) { + bptr = fgets( buffer, BUFFER_SIZE, in ); + if (!bptr) + break; + + /* + * Don't count the carriage return. + */ + + length = strlen( buffer ) - 1; + + if ( length <= line_length ) + continue; + + if ( count == 0 ) { + fprintf( stderr, "%s\n", arg ); + if ( !report_line_numbers ) + break; + } + + if ( verbose ) + fprintf( stderr, "TOO LONG:%d: %s\n", line_number, buffer ); + + if ( report_line_numbers ) { + if ( report_line_length ) + fprintf( stderr, "%d: %d\n" , line_number, length ); + else + fprintf( stderr, "%d\n" , line_number ); + } + + count++; + + } + + fclose( in ); + return rc; +} + +/* + * error(errn, arglist) + * report an error to stderr using printf(3) conventions. + * Any output is preceded by '<progname>: ' + * + * Uses ERR_FATAL 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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + +long +getparm(char *s, + long min, + long max, + char *msg) +{ + long val; + + if ( ! strchr("0123456789-", *s)) + { + error(ERR_FATAL, "'%s' is not a number", s); + return min; + } + + val = strtol(s, (char **) NULL, 0); + if ((val < min) || (val > max)) + { + if (min == max) + error(ERR_FATAL, "%s can only be %ld", s, min); + else + error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max); + } + + return val; +} + + +/* + * Open() + * Perform open(2), returning the file descriptor. Prints + * error message if open fails. + */ + +int +Open(char *file, + int oflag, + int mode) +{ + int O_fd; + + if (Failed(O_fd = open(file, oflag, mode))) + error( + ERR_ERRNO | ERR_FATAL, + "open('%s', 0x%x, 0%o) failed", file, oflag, mode + ); + + return O_fd; +} + +/* + * Read() + * Perform read(2); prints error message if fails. + */ + +int +Read(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = read(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "read(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} + +/* + * Write() + * Perform write(2); prints error message if fails. + */ + +int +Write(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = write(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "write(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} diff --git a/tools/build/eolstrip.c b/tools/build/eolstrip.c new file mode 100644 index 0000000000..0fa7af15d4 --- /dev/null +++ b/tools/build/eolstrip.c @@ -0,0 +1,351 @@ +/* + * eolstrip - strip white space from end of lines + * + * This program strips the white space from the end of every line in the + * specified program. + * + * usage: eolstrip [ -v ] [ arg ... ] files... + * -v -- verbose + * + * $Id$ + * $Log$ + */ + +#define GETOPTARGS "vt" + +char *USAGE = "\ +usage: cklength [ -v ] [ arg ... ] files... \n\ + -v -- verbose\n\ + -t -- test only .. DO NOT OVERWRITE FILE!!!\n\ +\n\ +Strip the white space from the end of every line on the list of files.\n\ +"; + +#include <stdio.h> +#include <fcntl.h> +#include <ctype.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <memory.h> +#include <stdarg.h> + +#define BUFFER_SIZE 2048 +#define MAX_PATH 2048 + +#define SUCCESS 0 +#define FAILURE -1 +#define Failed(x) (((int) (x)) == FAILURE) +#define TRUE 1 +#define FALSE 0 +#define STREQ(a,b) (strcmp(a,b) == 0) +#define NUMELEMS(arr) (sizeof(arr) / sizeof(arr[0])) + +/* + * Definitions for unsigned "ints"; especially for use in data structures + * that will be shared among (potentially) different cpu's (we punt on + * byte ordering problems tho) + */ + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned long u32; + +/* + * vars controlled by command line options + */ + +int verbose = FALSE; /* be verbose */ +int test_only = FALSE; /* test only */ + +extern char *optarg; /* getopt(3) control vars */ +extern int optind, opterr; +extern int errno; + +char *progname; /* for error() */ + +int process(char *arg); +void error(int errn, ...); +long getparm(char *s, long min, long max, char *msg); + +#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */ +#define ERR_FATAL (ERR_ERRNO / 2) /* fatal error ; no return */ +#define ERR_ABORT (ERR_ERRNO / 4) /* fatal error ; abort */ +#define ERR_MASK (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */ + +#define stol(p) strtol(p, (char **) NULL, 0) +int Open(), Read(), Write(); + +int +main(int argc, char **argv, char **env) +{ + register int c; + int showusage = FALSE; /* usage error? */ + int rc = 0; + + /* + * 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. + */ + + opterr = 0; /* we'll report all errors */ + while ((c = getopt(argc, argv, GETOPTARGS)) != EOF) + switch (c) + { + case 't': /* toggle test only mode */ + test_only = ! test_only; + break; + + case 'v': /* toggle verbose */ + verbose = ! verbose; + break; + + case '?': + showusage = TRUE; + } + + if (showusage) + { + (void) fprintf(stderr, "%s", USAGE); + exit(1); + } + + /* + * traverse and process the arguments + */ + + for ( ; argv[optind]; optind++) + if (Failed(process(argv[optind]))) + rc = FAILURE; + + return rc; +} + + +/* + * process(arg) + */ + +int +process(char *arg) +{ + FILE *in; + FILE *out = (FILE *) 0; + char outname[ MAX_PATH ]; + char *bptr; + char buffer[ BUFFER_SIZE ]; + int length; + int line_number; + int rc = SUCCESS; /* succeed by default */ + + in = fopen( arg, "r" ); + if (!in) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + + if ( !test_only ) { + sprintf( outname, "%s.eoltmp", arg ); + + out = fopen( outname, "w" ); + if (!out) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + } + + if ( verbose ) + fprintf( stderr, "Processing %s\n", arg ); + + for ( line_number=1 ; ; line_number++ ) { + bptr = fgets( buffer, BUFFER_SIZE, in ); + if (!bptr) + break; + + /* + * Don't count the carriage return. + */ + + length = strlen( buffer ) - 1; + + if ( buffer[ length ] != '\n' ) + error(ERR_ERRNO|ERR_FATAL, "Line %d too long in %s\n", line_number, arg); + + while ( isspace( buffer[ length ] ) ) + buffer[ length-- ] = '\0'; + + if ( test_only ) { + fprintf( stderr, "%s\n", arg ); + break; + } + + fprintf( out, "%s\n", buffer ); + } + + fclose( in ); + if ( !test_only ) { + fclose( out ); + rename( outname, arg ); + } + return rc; +} + +/* + * error(errn, arglist) + * report an error to stderr using printf(3) conventions. + * Any output is preceded by '<progname>: ' + * + * Uses ERR_FATAL 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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + +long +getparm(char *s, + long min, + long max, + char *msg) +{ + long val; + + if ( ! strchr("0123456789-", *s)) + { + error(ERR_FATAL, "'%s' is not a number", s); + return min; + } + + val = strtol(s, (char **) NULL, 0); + if ((val < min) || (val > max)) + { + if (min == max) + error(ERR_FATAL, "%s can only be %ld", s, min); + else + error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max); + } + + return val; +} + + +/* + * Open() + * Perform open(2), returning the file descriptor. Prints + * error message if open fails. + */ + +int +Open(char *file, + int oflag, + int mode) +{ + int O_fd; + + if (Failed(O_fd = open(file, oflag, mode))) + error( + ERR_ERRNO | ERR_FATAL, + "open('%s', 0x%x, 0%o) failed", file, oflag, mode + ); + + return O_fd; +} + +/* + * Read() + * Perform read(2); prints error message if fails. + */ + +int +Read(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = read(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "read(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} + +/* + * Write() + * Perform write(2); prints error message if fails. + */ + +int +Write(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = write(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "write(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} diff --git a/tools/build/packhex.c b/tools/build/packhex.c new file mode 100644 index 0000000000..ddd010c4a9 --- /dev/null +++ b/tools/build/packhex.c @@ -0,0 +1,513 @@ + +/***** 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: 5/93 Embedded Systems magazine + * + * Compiler: Microsoft C 6.0 + * cl /F 1000 packhex.c + * + * + * $Id$ + * + **************************************************************************/ + + +/* #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> + +#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 * ); +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. +* +*******************************************************************************/ + +void main( void ) +{ + + char inbuff[ MAX_LINE_SIZE ], outbuff[ MAX_LINE_SIZE ]; + char *in_dptr, *out_dptr; + int d_total, d_count, d_excess, n; + Ulong in_rec_addr, out_rec_addr = 0; + Rec_vitals *rptr; + + + /* Sift through file until first hex record is identified. */ + if ( ( rptr = identify_first_data_record( inbuff ) ) == NULL ) + { + fputs( "No hex records found.\n", stderr ); + exit( EXIT_FAILURE ); + } + + + /* Attempt data-record splicing until end-of-file is reached. */ + d_total = 0; + do + { + 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 ); + } + } while ( gets( inbuff ) != NULL ); + + + exit( 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 ) +{ + Rec_vitals ** ptr; + + while ( gets( buff_ptr ) != NULL ) + { + 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 ); +} diff --git a/tools/build/scripts/README b/tools/build/scripts/README new file mode 100644 index 0000000000..0436fc958d --- /dev/null +++ b/tools/build/scripts/README @@ -0,0 +1,32 @@ +# +# $Id$ +# + +Misc. support tools for RTEMS workspaces. +More will be added later as they are converted from Teamware +to CVS. + +install-if-change + Smart install script that also can append suffixes as it + installs (suffixes used for debug and profile variants). + Requires bash or ksh. + +rcs-clean + deletes all files from the current directory that can be + re-created from RCS. Careful to not delete locked files. + May be used by 'gmake clobber' + +lock-directory +unlock-directory + traverse a directory structure making it unwritable. + Useful to keep people from accidentally overwriting + "released" trees if they get confused about which + module they have loaded. + +rtems-glom + glom together all the rtems libraries in order to simplify + the link line used by applications. + Produces rtems.rel. + Not used by the RTEMS src tree at all. + Strictly optional. + diff --git a/tools/build/src/cklength.c b/tools/build/src/cklength.c new file mode 100644 index 0000000000..48801e1559 --- /dev/null +++ b/tools/build/src/cklength.c @@ -0,0 +1,364 @@ +/* + * cklength - check the length of lines in a file + * + * This program check to see if the files passed to it on the command line + * contain a line which exceeds the maximum allowable length. The default + * maximum line length is 80. + * + * usage: cklength [ -v ] [ arg ... ] files... + * -l length -- maximum line length + * -v -- verbose + * + * $Id$ + * $Log$ + */ + +#define GETOPTARGS "l:nNv" + +char *USAGE = "\ +usage: cklength [ -v ] [ arg ... ] files... \n\ + -l length -- maximum line length\n\ + -n -- report line numbers for offending lines\n\ + -N -- report line numbers and length for offending lines\n\ + -v -- verbose\n\ +\n\ +Print the name of files which have at least 1 line which exceeds the\n\ +maximum line length. The default maximum line length is 80.\n\ +"; + +#include <stdio.h> +#include <fcntl.h> +#include <ctype.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <memory.h> +#include <stdarg.h> + +#define BUFFER_SIZE 512 + +#define SUCCESS 0 +#define FAILURE -1 +#define Failed(x) (((int) (x)) == FAILURE) +#define TRUE 1 +#define FALSE 0 +#define STREQ(a,b) (strcmp(a,b) == 0) +#define NUMELEMS(arr) (sizeof(arr) / sizeof(arr[0])) + +/* + * Definitions for unsigned "ints"; especially for use in data structures + * that will be shared among (potentially) different cpu's (we punt on + * byte ordering problems tho) + */ + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned long u32; + +/* + * vars controlled by command line options + */ + +int verbose = FALSE; /* be verbose */ +int report_line_numbers = FALSE; /* report line numbers of offenders */ +int report_line_length = FALSE; /* report line length of offenders */ + +int line_length = 80; /* maximum allowable line length */ + +extern char *optarg; /* getopt(3) control vars */ +extern int optind, opterr; +extern int errno; + +char *progname; /* for error() */ + +int process(char *arg); +void error(int errn, ...); +long getparm(char *s, long min, long max, char *msg); + +#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */ +#define ERR_FATAL (ERR_ERRNO / 2) /* fatal error ; no return */ +#define ERR_ABORT (ERR_ERRNO / 4) /* fatal error ; abort */ +#define ERR_MASK (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */ + +#define stol(p) strtol(p, (char **) NULL, 0) +int Open(), Read(), Write(); + +int +main(int argc, char **argv, char **env) +{ + register int c; + int showusage = FALSE; /* usage error? */ + int rc = 0; + + /* + * 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. + */ + + opterr = 0; /* we'll report all errors */ + while ((c = getopt(argc, argv, GETOPTARGS)) != EOF) + switch (c) + { + case 'l': /* line length */ + line_length = atoi( optarg ); + if ( line_length < 0 || line_length > BUFFER_SIZE ) + error(ERR_FATAL, "(%d) is illegal line length\n",line_length); + break; + + case 'n': /* toggle report_line_numbers */ + report_line_numbers = ! report_line_numbers; + break; + + case 'N': /* toggle both reports */ + report_line_numbers = ! report_line_numbers; + report_line_length = ! report_line_length; + break; + + case 'v': /* toggle verbose */ + verbose = ! verbose; + break; + + case '?': + showusage = TRUE; + } + + if (showusage) + { + (void) fprintf(stderr, "%s", USAGE); + exit(1); + } + + /* + * traverse and process the arguments + */ + + for ( ; argv[optind]; optind++) + if (Failed(process(argv[optind]))) + rc = FAILURE; + + return rc; +} + + +/* + * process(arg) + */ + +int +process(char *arg) +{ + FILE *in; + char *bptr; + char buffer[ BUFFER_SIZE ]; + int line_number; + int length; + int count; + int rc = SUCCESS; /* succeed by default */ + + in = fopen( arg, "r" ); + if (!in) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + + count = 0; + + for ( line_number=1 ; ; line_number++ ) { + bptr = fgets( buffer, BUFFER_SIZE, in ); + if (!bptr) + break; + + /* + * Don't count the carriage return. + */ + + length = strlen( buffer ) - 1; + + if ( length <= line_length ) + continue; + + if ( count == 0 ) { + fprintf( stderr, "%s\n", arg ); + if ( !report_line_numbers ) + break; + } + + if ( verbose ) + fprintf( stderr, "TOO LONG:%d: %s\n", line_number, buffer ); + + if ( report_line_numbers ) { + if ( report_line_length ) + fprintf( stderr, "%d: %d\n" , line_number, length ); + else + fprintf( stderr, "%d\n" , line_number ); + } + + count++; + + } + + fclose( in ); + return rc; +} + +/* + * error(errn, arglist) + * report an error to stderr using printf(3) conventions. + * Any output is preceded by '<progname>: ' + * + * Uses ERR_FATAL 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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + +long +getparm(char *s, + long min, + long max, + char *msg) +{ + long val; + + if ( ! strchr("0123456789-", *s)) + { + error(ERR_FATAL, "'%s' is not a number", s); + return min; + } + + val = strtol(s, (char **) NULL, 0); + if ((val < min) || (val > max)) + { + if (min == max) + error(ERR_FATAL, "%s can only be %ld", s, min); + else + error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max); + } + + return val; +} + + +/* + * Open() + * Perform open(2), returning the file descriptor. Prints + * error message if open fails. + */ + +int +Open(char *file, + int oflag, + int mode) +{ + int O_fd; + + if (Failed(O_fd = open(file, oflag, mode))) + error( + ERR_ERRNO | ERR_FATAL, + "open('%s', 0x%x, 0%o) failed", file, oflag, mode + ); + + return O_fd; +} + +/* + * Read() + * Perform read(2); prints error message if fails. + */ + +int +Read(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = read(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "read(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} + +/* + * Write() + * Perform write(2); prints error message if fails. + */ + +int +Write(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = write(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "write(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} diff --git a/tools/build/src/eolstrip.c b/tools/build/src/eolstrip.c new file mode 100644 index 0000000000..0fa7af15d4 --- /dev/null +++ b/tools/build/src/eolstrip.c @@ -0,0 +1,351 @@ +/* + * eolstrip - strip white space from end of lines + * + * This program strips the white space from the end of every line in the + * specified program. + * + * usage: eolstrip [ -v ] [ arg ... ] files... + * -v -- verbose + * + * $Id$ + * $Log$ + */ + +#define GETOPTARGS "vt" + +char *USAGE = "\ +usage: cklength [ -v ] [ arg ... ] files... \n\ + -v -- verbose\n\ + -t -- test only .. DO NOT OVERWRITE FILE!!!\n\ +\n\ +Strip the white space from the end of every line on the list of files.\n\ +"; + +#include <stdio.h> +#include <fcntl.h> +#include <ctype.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <memory.h> +#include <stdarg.h> + +#define BUFFER_SIZE 2048 +#define MAX_PATH 2048 + +#define SUCCESS 0 +#define FAILURE -1 +#define Failed(x) (((int) (x)) == FAILURE) +#define TRUE 1 +#define FALSE 0 +#define STREQ(a,b) (strcmp(a,b) == 0) +#define NUMELEMS(arr) (sizeof(arr) / sizeof(arr[0])) + +/* + * Definitions for unsigned "ints"; especially for use in data structures + * that will be shared among (potentially) different cpu's (we punt on + * byte ordering problems tho) + */ + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned long u32; + +/* + * vars controlled by command line options + */ + +int verbose = FALSE; /* be verbose */ +int test_only = FALSE; /* test only */ + +extern char *optarg; /* getopt(3) control vars */ +extern int optind, opterr; +extern int errno; + +char *progname; /* for error() */ + +int process(char *arg); +void error(int errn, ...); +long getparm(char *s, long min, long max, char *msg); + +#define ERR_ERRNO (1<<((sizeof(int) * 8) - 2)) /* hi bit; use 'errno' */ +#define ERR_FATAL (ERR_ERRNO / 2) /* fatal error ; no return */ +#define ERR_ABORT (ERR_ERRNO / 4) /* fatal error ; abort */ +#define ERR_MASK (ERR_ERRNO | ERR_FATAL | ERR_ABORT) /* all */ + +#define stol(p) strtol(p, (char **) NULL, 0) +int Open(), Read(), Write(); + +int +main(int argc, char **argv, char **env) +{ + register int c; + int showusage = FALSE; /* usage error? */ + int rc = 0; + + /* + * 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. + */ + + opterr = 0; /* we'll report all errors */ + while ((c = getopt(argc, argv, GETOPTARGS)) != EOF) + switch (c) + { + case 't': /* toggle test only mode */ + test_only = ! test_only; + break; + + case 'v': /* toggle verbose */ + verbose = ! verbose; + break; + + case '?': + showusage = TRUE; + } + + if (showusage) + { + (void) fprintf(stderr, "%s", USAGE); + exit(1); + } + + /* + * traverse and process the arguments + */ + + for ( ; argv[optind]; optind++) + if (Failed(process(argv[optind]))) + rc = FAILURE; + + return rc; +} + + +/* + * process(arg) + */ + +int +process(char *arg) +{ + FILE *in; + FILE *out = (FILE *) 0; + char outname[ MAX_PATH ]; + char *bptr; + char buffer[ BUFFER_SIZE ]; + int length; + int line_number; + int rc = SUCCESS; /* succeed by default */ + + in = fopen( arg, "r" ); + if (!in) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + + if ( !test_only ) { + sprintf( outname, "%s.eoltmp", arg ); + + out = fopen( outname, "w" ); + if (!out) + error( ERR_ERRNO | ERR_FATAL, "Unable to open file (%s)\n", arg ); + } + + if ( verbose ) + fprintf( stderr, "Processing %s\n", arg ); + + for ( line_number=1 ; ; line_number++ ) { + bptr = fgets( buffer, BUFFER_SIZE, in ); + if (!bptr) + break; + + /* + * Don't count the carriage return. + */ + + length = strlen( buffer ) - 1; + + if ( buffer[ length ] != '\n' ) + error(ERR_ERRNO|ERR_FATAL, "Line %d too long in %s\n", line_number, arg); + + while ( isspace( buffer[ length ] ) ) + buffer[ length-- ] = '\0'; + + if ( test_only ) { + fprintf( stderr, "%s\n", arg ); + break; + } + + fprintf( out, "%s\n", buffer ); + } + + fclose( in ); + if ( !test_only ) { + fclose( out ); + rename( outname, arg ); + } + return rc; +} + +/* + * error(errn, arglist) + * report an error to stderr using printf(3) conventions. + * Any output is preceded by '<progname>: ' + * + * Uses ERR_FATAL 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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + +long +getparm(char *s, + long min, + long max, + char *msg) +{ + long val; + + if ( ! strchr("0123456789-", *s)) + { + error(ERR_FATAL, "'%s' is not a number", s); + return min; + } + + val = strtol(s, (char **) NULL, 0); + if ((val < min) || (val > max)) + { + if (min == max) + error(ERR_FATAL, "%s can only be %ld", s, min); + else + error(ERR_FATAL, "%s must be between %ld and %ld", msg, min, max); + } + + return val; +} + + +/* + * Open() + * Perform open(2), returning the file descriptor. Prints + * error message if open fails. + */ + +int +Open(char *file, + int oflag, + int mode) +{ + int O_fd; + + if (Failed(O_fd = open(file, oflag, mode))) + error( + ERR_ERRNO | ERR_FATAL, + "open('%s', 0x%x, 0%o) failed", file, oflag, mode + ); + + return O_fd; +} + +/* + * Read() + * Perform read(2); prints error message if fails. + */ + +int +Read(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = read(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "read(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} + +/* + * Write() + * Perform write(2); prints error message if fails. + */ + +int +Write(int file, + char *buffer, + unsigned int count) +{ + int nbytes; + + if (Failed(nbytes = write(file, buffer, count))) + error( + ERR_ERRNO | ERR_FATAL, + "write(%d, 0x%x, %d) failed", file, buffer, count + ); + + return nbytes; +} diff --git a/tools/build/src/packhex.c b/tools/build/src/packhex.c new file mode 100644 index 0000000000..ddd010c4a9 --- /dev/null +++ b/tools/build/src/packhex.c @@ -0,0 +1,513 @@ + +/***** 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: 5/93 Embedded Systems magazine + * + * Compiler: Microsoft C 6.0 + * cl /F 1000 packhex.c + * + * + * $Id$ + * + **************************************************************************/ + + +/* #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> + +#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 * ); +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. +* +*******************************************************************************/ + +void main( void ) +{ + + char inbuff[ MAX_LINE_SIZE ], outbuff[ MAX_LINE_SIZE ]; + char *in_dptr, *out_dptr; + int d_total, d_count, d_excess, n; + Ulong in_rec_addr, out_rec_addr = 0; + Rec_vitals *rptr; + + + /* Sift through file until first hex record is identified. */ + if ( ( rptr = identify_first_data_record( inbuff ) ) == NULL ) + { + fputs( "No hex records found.\n", stderr ); + exit( EXIT_FAILURE ); + } + + + /* Attempt data-record splicing until end-of-file is reached. */ + d_total = 0; + do + { + 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 ); + } + } while ( gets( inbuff ) != NULL ); + + + exit( 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 ) +{ + Rec_vitals ** ptr; + + while ( gets( buff_ptr ) != NULL ) + { + 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 ); +} diff --git a/tools/build/src/unhex.c b/tools/build/src/unhex.c new file mode 100644 index 0000000000..540095d6f4 --- /dev/null +++ b/tools/build/src/unhex.c @@ -0,0 +1,719 @@ +/* + * 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 + */ + +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> + +#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; +extern int errno; + +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 */ + +#define stol(p) strtol(p, (char **) NULL, 0) + +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(argc, argv) +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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + diff --git a/tools/build/unhex.c b/tools/build/unhex.c new file mode 100644 index 0000000000..540095d6f4 --- /dev/null +++ b/tools/build/unhex.c @@ -0,0 +1,719 @@ +/* + * 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 + */ + +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> + +#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; +extern int errno; + +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 */ + +#define stol(p) strtol(p, (char **) NULL, 0) + +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(argc, argv) +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; + extern char *sys_errlist[]; + extern int sys_nerr; + 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) + if ((local_errno > 0) && (local_errno < sys_nerr)) + (void) fprintf(stderr, " (%s)\n", sys_errlist[local_errno]); + else + (void) fprintf(stderr, " (unknown errno=%d)\n", local_errno); + else + (void) fprintf(stderr, "\n"); + + (void) fflush(stderr); + + if (error_flag & (ERR_FATAL | ERR_ABORT)) + { + if (error_flag & ERR_FATAL) + { + error(0, local_errno ? "fatal error, exiting" : "exiting"); + exit(local_errno); + } + else + { + error(0, "fatal error, aborting"); + abort(); + } + } +} + diff --git a/tools/cpu/hppa1.1/genoffsets.c b/tools/cpu/hppa1.1/genoffsets.c new file mode 100644 index 0000000000..6563681f11 --- /dev/null +++ b/tools/cpu/hppa1.1/genoffsets.c @@ -0,0 +1,191 @@ +/* + * @(#)genoffsets.c 1.3 - 95/03/15 + * + * + * genoffsets.c + * + * This file generates the offsets.h for the HP PA-RISC port of RTEMS. + * + * NOTE: It only prints the offset for structures actually used + * by the assembly code. + * + * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994. + * On-Line Applications Research Corporation (OAR). + * + * This material may be reproduced by or for the U.S. Government pursuant + * to the copyright license under the clause at DFARS 252.227-7013. This + * notice must appear in all copies of this file and its derivatives. + * + * $Id$ + * + */ + +#include <stdio.h> + +#include <rtems/system.h> + +int main( + int argc, + char **argv +) +{ + unsigned int size; + + /* + * Print the file header + */ + +printf( + "/* offsets.h\n" + " *\n" + " * This include file contains the offsets of elements in the\n" + " * C data structures used by the assembly language code for the\n" + " * HP PA-RISC 1.1 port of RTEMS.\n" + " *\n" + " * NOTE: THIS FILE IS AUTOMATICALLY GENERATED!!!!\n" + " * DO NOT EDIT THIS BY HAND!!!!\n" + " *\n" + " * COPYRIGHT (c) 1989, 1990, 1991, 1992, 1993, 1994.\n" + " * On-Line Applications Research Corporation (OAR).\n" + " * All rights assigned to U.S. Government, 1994.\n" + " *\n" + " * This material may be reproduced by or for the U.S. Government pursuant\n" + " * to the copyright license under the clause at DFARS 252.227-7013. This\n" + " * notice must appear in all copies of this file and its derivatives.\n" + " */\n" + "\n" + "#ifndef __OFFSETS_h\n" + "#define __OFFSETS_h\n" + "\n" +); + +/* + * Offsets of elements in the Context_control structure. + */ + +#define PRINT_IT( STRING, TYPE, FIELD ) \ + printf( "#define\t%s\t0x%p\t\t/* %d */\n", \ + STRING, \ + &((TYPE)0)->FIELD, \ + (int) &((TYPE)0)->FIELD ); + +#define PRINT_SIZE( STRING, item ) \ + printf( "#define\t%s\t%d\t\t/* 0x%x */\n", \ + STRING, \ + sizeof(item), \ + sizeof(item) ); + +#define PRINT_COMMENT( STRING ) \ + printf( \ + "\n" \ + "/*\n" \ + " * " STRING "\n" \ + " */\n" \ + "\n" \ + ); + + PRINT_COMMENT("Context_Control information"); + + PRINT_IT( "FLAGS_OFFSET", Context_Control *, flags ); + PRINT_IT( "R1_OFFSET", Context_Control *, gr1 ); + PRINT_IT( "R2_OFFSET", Context_Control *, gr2 ); + PRINT_IT( "R3_OFFSET", Context_Control *, gr3 ); + PRINT_IT( "R4_OFFSET", Context_Control *, gr4 ); + PRINT_IT( "R5_OFFSET", Context_Control *, gr5 ); + PRINT_IT( "R6_OFFSET", Context_Control *, gr6 ); + PRINT_IT( "R7_OFFSET", Context_Control *, gr7 ); + PRINT_IT( "R8_OFFSET", Context_Control *, gr8 ); + PRINT_IT( "R9_OFFSET", Context_Control *, gr9 ); + PRINT_IT( "R10_OFFSET", Context_Control *, gr10 ); + PRINT_IT( "R11_OFFSET", Context_Control *, gr11 ); + PRINT_IT( "R12_OFFSET", Context_Control *, gr12 ); + PRINT_IT( "R13_OFFSET", Context_Control *, gr13 ); + PRINT_IT( "R14_OFFSET", Context_Control *, gr14 ); + PRINT_IT( "R15_OFFSET", Context_Control *, gr15 ); + PRINT_IT( "R16_OFFSET", Context_Control *, gr16 ); + PRINT_IT( "R17_OFFSET", Context_Control *, gr17 ); + PRINT_IT( "R18_OFFSET", Context_Control *, gr18 ); + PRINT_IT( "R19_OFFSET", Context_Control *, gr19 ); + PRINT_IT( "R20_OFFSET", Context_Control *, gr20 ); + PRINT_IT( "R21_OFFSET", Context_Control *, gr21 ); + PRINT_IT( "R22_OFFSET", Context_Control *, gr22 ); + PRINT_IT( "R23_OFFSET", Context_Control *, gr23 ); + PRINT_IT( "R24_OFFSET", Context_Control *, gr24 ); + PRINT_IT( "R25_OFFSET", Context_Control *, gr25 ); + PRINT_IT( "R26_OFFSET", Context_Control *, gr26 ); + PRINT_IT( "R27_OFFSET", Context_Control *, gr27 ); + PRINT_IT( "R28_OFFSET", Context_Control *, gr28 ); + PRINT_IT( "R29_OFFSET", Context_Control *, gr29 ); + PRINT_IT( "R30_OFFSET", Context_Control *, sp ); + PRINT_IT( "R31_OFFSET", Context_Control *, gr31 ); + + /* + * And common aliases for the above + */ + + PRINT_COMMENT("Common aliases for above"); + + PRINT_IT( "RP_OFFSET", Context_Control *, gr2 ); + PRINT_IT( "ARG3_OFFSET", Context_Control *, gr23 ); + PRINT_IT( "ARG2_OFFSET", Context_Control *, gr24 ); + PRINT_IT( "ARG1_OFFSET", Context_Control *, gr25 ); + PRINT_IT( "ARG0_OFFSET", Context_Control *, gr26 ); + PRINT_IT( "SP_OFFSET", Context_Control *, sp ); + PRINT_IT( "DP_OFFSET", Context_Control *, gr27 ); + PRINT_IT( "RET0_OFFSET", Context_Control *, gr28 ); + PRINT_IT( "RET1_OFFSET", Context_Control *, gr29 ); + + PRINT_SIZE("CPU_CONTEXT_SIZE", Context_Control); + + PRINT_COMMENT("Context_Control_fp information"); + + PRINT_SIZE("CPU_CONTEXT_FP_SIZE", Context_Control_fp); + + /* + * And the control registers + */ + + PRINT_COMMENT("Control register portion of context"); + + PRINT_IT( "SAR_OFFSET", Context_Control *, sar ); + PRINT_IT( "IPSW_OFFSET", Context_Control *, ipsw ); + PRINT_IT( "IIR_OFFSET", Context_Control *, iir ); + PRINT_IT( "IOR_OFFSET", Context_Control *, ior ); + PRINT_IT( "ISR_OFFSET", Context_Control *, isr ); + PRINT_IT( "PCOQFRONT_OFFSET", Context_Control *, pcoqfront ); + PRINT_IT( "PCOQBACK_OFFSET", Context_Control *, pcoqback ); + PRINT_IT( "PCSQFRONT_OFFSET", Context_Control *, pcsqfront ); + PRINT_IT( "PCSQBACK_OFFSET", Context_Control *, pcsqback ); + PRINT_IT( "ITIMER_OFFSET", Context_Control *, itimer ); + + /* + * Full interrupt frame (integer + float) + */ + PRINT_COMMENT("Interrupt frame information"); + + PRINT_IT( "INTEGER_CONTEXT_OFFSET", CPU_Interrupt_frame *, Integer ); + PRINT_IT( "FP_CONTEXT_OFFSET", CPU_Interrupt_frame *, Floating_Point ); + size = sizeof( CPU_Interrupt_frame ); + + if ( size % CPU_STACK_ALIGNMENT ) + size += CPU_STACK_ALIGNMENT - (size % CPU_STACK_ALIGNMENT); + + printf( "#define\tCPU_INTERRUPT_FRAME_SIZE\t%d\t\t/* 0x%x */\n", size, size ); + +#undef PRINT_IT +#undef PRINT_SIZE +#undef PRINT_COMMENT + + /* + * Print the end of file stuff + */ + + printf( + "\n" + "#endif /* __OFFSETS_h */\n" + "\n" + "/* end of include file */\n" + ); + + return 0; +} diff --git a/tools/update/310_to_320_list b/tools/update/310_to_320_list new file mode 100644 index 0000000000..b4add28685 --- /dev/null +++ b/tools/update/310_to_320_list @@ -0,0 +1,543 @@ +# +# External API name +# +initialize_executive rtems_initialize_executive +initialize_executive_early rtems_initialize_executive_early +initialize_executive_late rtems_initialize_executive_late +shutdown_executive rtems_shutdown_executive +task_create rtems_task_create +task_ident rtems_task_ident +task_start rtems_task_start +task_restart rtems_task_restart +task_delete rtems_task_delete +task_suspend rtems_task_suspend +task_resume rtems_task_resume +task_set_priority rtems_task_set_priority +task_mode rtems_task_mode +task_get_note rtems_task_get_note +task_set_note rtems_task_set_note +task_wake_after rtems_task_wake_after +task_wake_when rtems_task_wake_when +interrupt_catch rtems_interrupt_catch +clock_set rtems_clock_set +clock_get rtems_clock_get +clock_tick rtems_clock_tick +extension_create rtems_extension_create +extension_ident rtems_extension_ident +extension_delete rtems_extension_delete +timer_create rtems_timer_create +timer_ident rtems_timer_ident +timer_cancel rtems_timer_cancel +timer_delete rtems_timer_delete +timer_fire_after rtems_timer_fire_after +timer_fire_when rtems_timer_fire_when +timer_reset rtems_timer_reset +semaphore_create rtems_semaphore_create +semaphore_ident rtems_semaphore_ident +semaphore_delete rtems_semaphore_delete +semaphore_obtain rtems_semaphore_obtain +semaphore_release rtems_semaphore_release +message_queue_create rtems_message_queue_create +message_queue_ident rtems_message_queue_ident +message_queue_delete rtems_message_queue_delete +message_queue_send rtems_message_queue_send +message_queue_urgent rtems_message_queue_urgent +message_queue_broadcast rtems_message_queue_broadcast +message_queue_receive rtems_message_queue_receive +message_queue_flush rtems_message_queue_flush +event_send rtems_event_send +event_receive rtems_event_receive +signal_catch rtems_signal_catch +signal_send rtems_signal_send +partition_create rtems_partition_create +partition_ident rtems_partition_ident +partition_delete rtems_partition_delete +partition_get_buffer rtems_partition_get_buffer +partition_return_buffer rtems_partition_return_buffer +region_create rtems_region_create +region_extend rtems_region_extend +region_ident rtems_region_ident +region_delete rtems_region_delete +region_get_segment rtems_region_get_segment +region_get_segment_size rtems_region_get_segment_size +region_return_segment rtems_region_return_segment +port_create rtems_port_create +port_ident rtems_port_ident +port_delete rtems_port_delete +port_external_to_internal rtems_port_external_to_internal +port_internal_to_external rtems_port_internal_to_external +io_initialize rtems_io_initialize +io_open rtems_io_open +io_close rtems_io_close +io_read rtems_io_read +io_write rtems_io_write +io_control rtems_io_control +fatal_error_occurred rtems_fatal_error_occurred +rate_monotonic_create rtems_rate_monotonic_create +rate_monotonic_ident rtems_rate_monotonic_ident +rate_monotonic_delete rtems_rate_monotonic_delete +rate_monotonic_cancel rtems_rate_monotonic_cancel +rate_monotonic_period rtems_rate_monotonic_period +multiprocessing_announce rtems_multiprocessing_announce +# +# Internal Names for API +# +_Initialize_Executive rtems_initialize_executive +_Initialize_Executive_early rtems_initialize_executive_early +_Initialize_Executive_late rtems_initialize_executive_late +_Shutdown_Executive rtems_shutdown_executive +_RTEMS_tasks_Create rtems_task_create +_RTEMS_tasks_Name_to_id rtems_task_ident +_RTEMS_tasks_Start rtems_task_start +_RTEMS_tasks_Restart rtems_task_restart +_RTEMS_tasks_Delete rtems_task_delete +_RTEMS_tasks_Suspend rtems_task_suspend +_RTEMS_tasks_Resume rtems_task_resume +_RTEMS_tasks_Set_priority rtems_task_set_priority +_RTEMS_tasks_Mode rtems_task_mode +_RTEMS_tasks_Get_note rtems_task_get_note +_RTEMS_tasks_Set_note rtems_task_set_note +_RTEMS_tasks_Wake_after rtems_task_wake_after +_RTEMS_tasks_Wake_when rtems_task_wake_when +_Interrupt_Catch rtems_interrupt_catch +_Clock_Set rtems_clock_set +_Clock_Get rtems_clock_get +_Clock_Tick rtems_clock_tick +_Extension_Create rtems_extension_create +_Extension_Name_to_id rtems_extension_ident +_Extension_Delete rtems_extension_delete +_Timer_Create rtems_timer_create +_Timer_Name_to_id rtems_timer_ident +_Timer_Cancel rtems_timer_cancel +_Timer_Delete rtems_timer_delete +_Timer_Fire_after rtems_timer_fire_after +_Timer_Fire_when rtems_timer_fire_when +_Timer_Reset rtems_timer_reset +_Semaphore_Create rtems_semaphore_create +_Semaphore_Name_to_id rtems_semaphore_ident +_Semaphore_Delete rtems_semaphore_delete +_Semaphore_Obtain rtems_semaphore_obtain +_Semaphore_Release rtems_semaphore_release +_Message_queue_Create rtems_message_queue_create +_Message_queue_Name_to_id rtems_message_queue_ident +_Message_queue_Delete rtems_message_queue_delete +_Message_queue_Send rtems_message_queue_send +_Message_queue_Urgent rtems_message_queue_urgent +_Message_queue_Broadcast rtems_message_queue_broadcast +_Message_queue_Receive rtems_message_queue_receive +_Message_queue_Flush rtems_message_queue_flush +_Event_Send rtems_event_send +_Event_Receive rtems_event_receive +_Signal_Catch rtems_signal_catch +_Signal_Send rtems_signal_send +_Partition_Create rtems_partition_create +_Partition_Name_to_id rtems_partition_ident +_Partition_Delete rtems_partition_delete +_Partition_Get_buffer rtems_partition_get_buffer +_Partition_Return_buffer rtems_partition_return_buffer +_Region_Create rtems_region_create +_Region_Extend rtems_region_extend +_Region_Name_to_id rtems_region_ident +_Region_Delete rtems_region_delete +_Region_Get_segment rtems_region_get_segment +_Region_Get_segment_size rtems_region_get_segment_size +_Region_Return_segment rtems_region_return_segment +_Dual_ported_memory_Create rtems_port_create +_Dual_ported_memory_Name_to_id rtems_port_ident +_Dual_ported_memory_Delete rtems_port_delete +_Dual_ported_memory_External_to_internal rtems_port_external_to_internal +_Dual_ported_memory_Internal_to_external rtems_port_internal_to_external +_IO_Initialize rtems_io_initialize +_IO_Open rtems_io_open +_IO_Close rtems_io_close +_IO_Read rtems_io_read +_IO_Write rtems_io_write +_IO_Control rtems_io_control +_Fatal_Error_occurred rtems_fatal_error_occurred +_Rate_monotonic_Create rtems_rate_monotonic_create +_Rate_monotonic_Name_to_id rtems_rate_monotonic_ident +_Rate_monotonic_Delete rtems_rate_monotonic_delete +_Rate_monotonic_Cancel rtems_rate_monotonic_cancel +_Rate_monotonic_Period rtems_rate_monotonic_period +_Multiprocessing_Announce rtems_multiprocessing_announce +# +# Status (API names) +# +SUCCESSFUL RTEMS_SUCCESSFUL +TASK_EXITTED RTEMS_TASK_EXITTED +MP_NOT_CONFIGURED RTEMS_MP_NOT_CONFIGURED +INVALID_NAME RTEMS_INVALID_NAME +INVALID_ID RTEMS_INVALID_ID +TOO_MANY RTEMS_TOO_MANY +TIMEOUT RTEMS_TIMEOUT +OBJECT_WAS_DELETED RTEMS_OBJECT_WAS_DELETED +INVALID_SIZE RTEMS_INVALID_SIZE +INVALID_ADDRESS RTEMS_INVALID_ADDRESS +INVALID_NUMBER RTEMS_INVALID_NUMBER +NOT_DEFINED RTEMS_NOT_DEFINED +RESOURCE_IN_USE RTEMS_RESOURCE_IN_USE +UNSATISFIED RTEMS_UNSATISFIED +INCORRECT_STATE RTEMS_INCORRECT_STATE +ALREADY_SUSPENDED RTEMS_ALREADY_SUSPENDED +ILLEGAL_ON_SELF RTEMS_ILLEGAL_ON_SELF +ILLEGAL_ON_REMOTE_OBJECT RTEMS_ILLEGAL_ON_REMOTE_OBJECT +CALLED_FROM_ISR RTEMS_CALLED_FROM_ISR +INVALID_PRIORITY RTEMS_INVALID_PRIORITY +INVALID_CLOCK RTEMS_INVALID_CLOCK +INVALID_NODE RTEMS_INVALID_NODE +NOT_CONFIGURED RTEMS_NOT_CONFIGURED +NOT_OWNER_OF_RESOURCE RTEMS_NOT_OWNER_OF_RESOURCE +NOT_IMPLEMENTED RTEMS_NOT_IMPLEMENTED +INTERNAL_ERROR RTEMS_INTERNAL_ERROR +PROXY_BLOCKING RTEMS_PROXY_BLOCKING +NO_MEMORY RTEMS_NO_MEMORY +STATUS_CODES_FIRST RTEMS_STATUS_CODES_FIRST +STATUS_CODES_LAST RTEMS_STATUS_CODES_LAST +# +# Status (Internal names) +# +STATUS_SUCCESSFUL RTEMS_SUCCESSFUL +STATUS_TASK_EXITTED RTEMS_TASK_EXITTED +STATUS_MP_NOT_CONFIGURED RTEMS_MP_NOT_CONFIGURED +STATUS_INVALID_NAME RTEMS_INVALID_NAME +STATUS_INVALID_ID RTEMS_INVALID_ID +STATUS_TOO_MANY RTEMS_TOO_MANY +STATUS_TIMEOUT RTEMS_TIMEOUT +STATUS_OBJECT_WAS_DELETED RTEMS_OBJECT_WAS_DELETED +STATUS_INVALID_SIZE RTEMS_INVALID_SIZE +STATUS_INVALID_ADDRESS RTEMS_INVALID_ADDRESS +STATUS_INVALID_NUMBER RTEMS_INVALID_NUMBER +STATUS_NOT_DEFINED RTEMS_NOT_DEFINED +STATUS_RESOURCE_IN_USE RTEMS_RESOURCE_IN_USE +STATUS_UNSATISFIED RTEMS_UNSATISFIED +STATUS_INCORRECT_STATE RTEMS_INCORRECT_STATE +STATUS_ALREADY_SUSPENDED RTEMS_ALREADY_SUSPENDED +STATUS_ILLEGAL_ON_SELF RTEMS_ILLEGAL_ON_SELF +STATUS_ILLEGAL_ON_REMOTE_OBJECT RTEMS_ILLEGAL_ON_REMOTE_OBJECT +STATUS_CALLED_FROM_ISR RTEMS_CALLED_FROM_ISR +STATUS_INVALID_PRIORITY RTEMS_INVALID_PRIORITY +STATUS_INVALID_CLOCK RTEMS_INVALID_CLOCK +STATUS_INVALID_NODE RTEMS_INVALID_NODE +STATUS_NOT_CONFIGURED RTEMS_NOT_CONFIGURED +STATUS_NOT_OWNER_OF_RESOURCE RTEMS_NOT_OWNER_OF_RESOURCE +STATUS_NOT_IMPLEMENTED RTEMS_NOT_IMPLEMENTED +STATUS_INTERNAL_ERROR RTEMS_INTERNAL_ERROR +STATUS_PROXY_BLOCKING RTEMS_PROXY_BLOCKING +STATUS_NO_MEMORY RTEMS_NO_MEMORY +# +# Attributes (External) +# +DEFAULT_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES +NO_FLOATING_POINT RTEMS_NO_FLOATING_POINT +FLOATING_POINT RTEMS_FLOATING_POINT +LOCAL RTEMS_LOCAL +GLOBAL RTEMS_GLOBAL +FIFO RTEMS_FIFO +PRIORITY RTEMS_PRIORITY +NO_LIMIT RTEMS_NO_LIMIT +LIMIT RTEMS_LIMIT +COUNTING_SEMAPHORE RTEMS_COUNTING_SEMAPHORE +BINARY_SEMAPHORE RTEMS_BINARY_SEMAPHORE +NO_INHERIT_PRIORITY RTEMS_NO_INHERIT_PRIORITY +INHERIT_PRIORITY RTEMS_INHERIT_PRIORITY +# +# Attributes (Internal) +# +ATTRIBUTES_DEFAULTS RTEMS_DEFAULT_ATTRIBUTES +ATTRIBUTES_NO_FLOATING_POINT RTEMS_NO_FLOATING_POINT +ATTRIBUTES_FLOATING_POINT RTEMS_FLOATING_POINT +ATTRIBUTES_LOCAL RTEMS_LOCAL +ATTRIBUTES_GLOBAL RTEMS_GLOBAL +ATTRIBUTES_FIFO RTEMS_FIFO +ATTRIBUTES_PRIORITY RTEMS_PRIORITY +ATTRIBUTES_NO_LIMIT RTEMS_NO_LIMIT +ATTRIBUTES_LIMIT RTEMS_LIMIT +ATTRIBUTES_COUNTING_SEMAPHORE RTEMS_COUNTING_SEMAPHORE +ATTRIBUTES_BINARY_SEMAPHORE RTEMS_BINARY_SEMAPHORE +ATTRIBUTES_NO_INHERIT_PRIORITY RTEMS_NO_INHERIT_PRIORITY +ATTRIBUTES_INHERIT_PRIORITY RTEMS_INHERIT_PRIORITY +# +# Options (External) +# +DEFAULT_OPTIONS RTEMS_DEFAULT_OPTIONS +WAIT RTEMS_WAIT +NO_WAIT RTEMS_NO_WAIT +EVENT_ALL RTEMS_EVENT_ALL +EVENT_ANY RTEMS_EVENT_ANY +# +# Options (Internal) +# +OPTIONS_DEFAULT RTEMS_DEFAULT_OPTIONS +OPTIONS_WAIT RTEMS_WAIT +OPTIONS_NO_WAIT RTEMS_NO_WAIT +OPTIONS_EVENT_ALL RTEMS_EVENT_ALL +OPTIONS_EVENT_ANY RTEMS_EVENT_ANY +# +# Masks (External) +# +ALL_MODE_MASKS RTEMS_ALL_MODE_MASKS +PREEMPT_MASK RTEMS_PREEMPT_MASK +TIMESLICE_MASK RTEMS_TIMESLICE_MASK +ASR_MASK RTEMS_ASR_MASK +INTERRUPT_MASK RTEMS_INTERRUPT_MASK +# +# Masks (Internal) +# +MODES_ALL_MASK RTEMS_ALL_MODE_MASKS +MODES_PREEMPT_MASK RTEMS_PREEMPT_MASK +MODES_TIMESLICE_MASK RTEMS_TIMESLICE_MASK +MODES_ASR_MASK RTEMS_ASR_MASK +MODES_INTERRUPT_MASK RTEMS_INTERRUPT_MASK +# +# Modes (Internal) +# +MODES_DEFAULTS RTEMS_DEFAULT_MODES +MODES_PREEMPT RTEMS_PREEMPT +MODES_NO_PREEMPT RTEMS_NO_PREEMPT +MODES_NO_TIMESLICE RTEMS_NO_TIMESLICE +MODES_TIMESLICE RTEMS_TIMESLICE +MODES_ASR RTEMS_ASR +MODES_NO_ASR RTEMS_NO_ASR +_Modes_Interrupt_level RTEMS_INTERRUPT_LEVEL +# +# Modes (External) +# +DEFAULT_MODES RTEMS_DEFAULT_MODES +PREEMPT RTEMS_PREEMPT +NO_PREEMPT RTEMS_NO_PREEMPT +NO_TIMESLICE RTEMS_NO_TIMESLICE +TIMESLICE RTEMS_TIMESLICE +ASR RTEMS_ASR +NO_ASR RTEMS_NO_ASR +INTERRUPT_LEVEL RTEMS_INTERRUPT_LEVEL +# +# Identification (External) +# +SEARCH_ALL_NODES RTEMS_SEARCH_ALL_NODES +SEARCH_OTHER_NODES RTEMS_SEARCH_OTHER_NODES +SEARCH_LOCAL_NODE RTEMS_SEARCH_LOCAL_NODE +WHO_AM_I RTEMS_WHO_AM_I +# +# Identification (Internal) +# +OBJECTS_SEARCH_ALL_NODES RTEMS_SEARCH_ALL_NODES +OBJECTS_SEARCH_OTHER_NODES RTEMS_SEARCH_OTHER_NODES +OBJECTS_SEARCH_LOCAL_NODE RTEMS_SEARCH_LOCAL_NODE +OBJECTS_WHO_AM_I RTEMS_WHO_AM_I +# +# Miscellaneous (External API) +# +CURRENT_MODE RTEMS_CURRENT_MODE +CURRENT_PRIORITY RTEMS_CURRENT_PRIORITY +PENDING_EVENTS RTEMS_PENDING_EVENTS +NO_TIMEOUT RTEMS_NO_TIMEOUT +SELF RTEMS_SELF +PERIOD_STATUS RTEMS_PERIOD_STATUS +YIELD_PROCESSOR RTEMS_YIELD_PROCESSOR +MINIMUM_PRIORITY RTEMS_MINIMUM_PRIORITY +MAXIMUM_PRIORITY RTEMS_MAXIMUM_PRIORITY +MINIMUM_STACK_SIZE RTEMS_MINIMUM_STACK_SIZE +# +# Miscellaneous (External API) +# +MODES_CURRENT RTEMS_CURRENT_MODE +PRIORITY_CURRENT RTEMS_CURRENT_PRIORITY +# +# Events +# +ALL_EVENTS RTEMS_ALL_EVENTS +EVENT_0 RTEMS_EVENT_0 +EVENT_1 RTEMS_EVENT_1 +EVENT_2 RTEMS_EVENT_2 +EVENT_3 RTEMS_EVENT_3 +EVENT_4 RTEMS_EVENT_4 +EVENT_5 RTEMS_EVENT_5 +EVENT_6 RTEMS_EVENT_6 +EVENT_7 RTEMS_EVENT_7 +EVENT_8 RTEMS_EVENT_8 +EVENT_9 RTEMS_EVENT_9 +EVENT_10 RTEMS_EVENT_10 +EVENT_11 RTEMS_EVENT_11 +EVENT_12 RTEMS_EVENT_12 +EVENT_13 RTEMS_EVENT_13 +EVENT_14 RTEMS_EVENT_14 +EVENT_15 RTEMS_EVENT_15 +EVENT_16 RTEMS_EVENT_16 +EVENT_17 RTEMS_EVENT_17 +EVENT_18 RTEMS_EVENT_18 +EVENT_19 RTEMS_EVENT_19 +EVENT_20 RTEMS_EVENT_20 +EVENT_21 RTEMS_EVENT_21 +EVENT_22 RTEMS_EVENT_22 +EVENT_23 RTEMS_EVENT_23 +EVENT_24 RTEMS_EVENT_24 +EVENT_25 RTEMS_EVENT_25 +EVENT_26 RTEMS_EVENT_26 +EVENT_27 RTEMS_EVENT_27 +EVENT_28 RTEMS_EVENT_28 +EVENT_29 RTEMS_EVENT_29 +EVENT_30 RTEMS_EVENT_30 +EVENT_31 RTEMS_EVENT_31 +# +# Signals +# +SIGNAL_0 RTEMS_SIGNAL_0 +SIGNAL_1 RTEMS_SIGNAL_1 +SIGNAL_2 RTEMS_SIGNAL_2 +SIGNAL_3 RTEMS_SIGNAL_3 +SIGNAL_4 RTEMS_SIGNAL_4 +SIGNAL_5 RTEMS_SIGNAL_5 +SIGNAL_6 RTEMS_SIGNAL_6 +SIGNAL_7 RTEMS_SIGNAL_7 +SIGNAL_8 RTEMS_SIGNAL_8 +SIGNAL_9 RTEMS_SIGNAL_9 +SIGNAL_10 RTEMS_SIGNAL_10 +SIGNAL_11 RTEMS_SIGNAL_11 +SIGNAL_12 RTEMS_SIGNAL_12 +SIGNAL_13 RTEMS_SIGNAL_13 +SIGNAL_14 RTEMS_SIGNAL_14 +SIGNAL_15 RTEMS_SIGNAL_15 +SIGNAL_16 RTEMS_SIGNAL_16 +SIGNAL_17 RTEMS_SIGNAL_17 +SIGNAL_18 RTEMS_SIGNAL_18 +SIGNAL_19 RTEMS_SIGNAL_19 +SIGNAL_20 RTEMS_SIGNAL_20 +SIGNAL_21 RTEMS_SIGNAL_21 +SIGNAL_22 RTEMS_SIGNAL_22 +SIGNAL_23 RTEMS_SIGNAL_23 +SIGNAL_24 RTEMS_SIGNAL_24 +SIGNAL_25 RTEMS_SIGNAL_25 +SIGNAL_26 RTEMS_SIGNAL_26 +SIGNAL_27 RTEMS_SIGNAL_27 +SIGNAL_28 RTEMS_SIGNAL_28 +SIGNAL_29 RTEMS_SIGNAL_29 +SIGNAL_30 RTEMS_SIGNAL_30 +SIGNAL_31 RTEMS_SIGNAL_31 +# +# Notepads +# +NOTEPAD_FIRST RTEMS_NOTEPAD_FIRST +NOTEPAD_0 RTEMS_NOTEPAD_0 +NOTEPAD_1 RTEMS_NOTEPAD_1 +NOTEPAD_2 RTEMS_NOTEPAD_2 +NOTEPAD_3 RTEMS_NOTEPAD_3 +NOTEPAD_4 RTEMS_NOTEPAD_4 +NOTEPAD_5 RTEMS_NOTEPAD_5 +NOTEPAD_6 RTEMS_NOTEPAD_6 +NOTEPAD_7 RTEMS_NOTEPAD_7 +NOTEPAD_8 RTEMS_NOTEPAD_8 +NOTEPAD_9 RTEMS_NOTEPAD_9 +NOTEPAD_10 RTEMS_NOTEPAD_10 +NOTEPAD_11 RTEMS_NOTEPAD_11 +NOTEPAD_12 RTEMS_NOTEPAD_12 +NOTEPAD_13 RTEMS_NOTEPAD_13 +NOTEPAD_14 RTEMS_NOTEPAD_14 +NOTEPAD_15 RTEMS_NOTEPAD_15 +NOTEPAD_LAST RTEMS_NOTEPAD_LAST +# +# Multiprocessing +# +MIN_PKTSIZE RTEMS_MINIMUM_PACKET_SIZE +MIN_HETERO_CONV RTEMS_MINIMUN_HETERO_CONVERSION +# +# Name and ID External +# +get_node rtems_get_node +get_index rtems_get_index +build_name rtems_build_name +name_to_characters rtems_name_to_characters +# +# Name and ID Internal +# +_Objects_Get_node rtems_get_node +_Objects_Get_index rtems_get_index +_Objects_Build_name rtems_build_name +_Objects_Name_to_characters rtems_name_to_characters +# +# clock_get +# +CLOCK_GET_TOD RTEMS_CLOCK_GET_TOD +CLOCK_GET_SECONDS_SINCE_EPOCH RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH +CLOCK_GET_TICKS_SINCE_BOOT RTEMS_CLOCK_GET_TICKS_SINCE_BOOT +CLOCK_GET_TICKS_PER_SECOND RTEMS_CLOCK_GET_TICKS_PER_SECOND +CLOCK_GET_TIME_VALUE RTEMS_CLOCK_GET_TIME_VALUE +# +# Status Code Support Routines (External) -- NO CHANGES +# +# +# Status Code Support Routines (Internal) +# +_Status_Is_successful rtems_is_status_successful +_Status_Is_equal rtems_are_statuses_equal +# +# Time Conversion Support Routines (External) -- NO CHANGES +# +# +# Time Conversion Support Routines (Internal) +# +_TOD_Milliseconds_to_microseconds RTEMS_MILLISECONDS_TO_MICROSECONDS +_TOD_Milliseconds_to_ticks RTEMS_MILLISECONDS_TO_MICROSECONDS +# +# MP packet +# +MP_PACKET_INTERNAL_THREADS RTEMS_MP_PACKET_INTERNAL_THREADS +MP_PACKET_RTEMS_TASKS RTEMS_MP_PACKET_TASKS +MP_PACKET_MESSAGE_QUEUE RTEMS_MP_PACKET_MESSAGE_QUEUE +MP_PACKET_SEMAPHORE RTEMS_MP_PACKET_SEMAPHORE +MP_PACKET_PARTITION RTEMS_MP_PACKET_PARTITION +MP_PACKET_REGION RTEMS_MP_PACKET_REGION +MP_PACKET_EVENT RTEMS_MP_PACKET_EVENT +MP_PACKET_SIGNAL RTEMS_MP_PACKET_SIGNAL +# +# +# +IO_Major_control rtems_device_major_number +IO_Minor_control rtems_device_minor_number +# +# Configuration Info +# +Configuration_Table rtems_configuration_table +Configuration_Initialization_tasks_table rtems_initialization_tasks_table +Configuration_Driver_address_table rtems_driver_address_table +Configuration_Extension_table rtems_extensions_table +rtems_tasks_create_extension rtems_task_create_extension +rtems_tasks_start_extension rtems_task_start_extension +rtems_tasks_restart_extension rtems_task_restart_extension +rtems_tasks_delete_extension rtems_task_delete_extension +rtems_tasks_switch_extension rtems_task_switch_extension +rtems_tasks_begin_extension rtems_task_begin_extension +rtems_tasks_exitted_extension rtems_task_exitted_extension +rtems_fatal_extension rtems_fatal_extension +Configuration_MPCI_table rtems_mpci_table +Configuration_Multiprocessing_table rtems_multiprocessing_table +CPU_Table rtems_cpu_table +# +Clock_Get_options rtems_clock_get_options +Clock_Time_value rtems_clock_time_value +MP_packet_Prefix rtems_packet_prefix +MP_packet_Classes rtems_mp_packet_classes +TOD_Control rtems_time_of_day +ISR_Vector rtems_vector_number +Watchdog_Interval rtems_interval +Watchdog_Service rtems_timer_service_routine_entry +Attributes_Control rtems_attribute +Modes_Control rtems_mode +Options_Control rtems_option +Priority_Control rtems_task_priority +PRIORITY_MINIMUM RTEMS_MINIMUM_PRIORITY +PRIORITY_MAXIMUM RTEMS_MAXIMUM_PRIORITY +Event_sets_Control rtems_event_set +ASR_Signal_set_control rtems_signal_set +Status_Codes rtems_status_code +RTEMS_TASKS_YIELD_PROCESSOR RTEMS_YIELD_PROCESSOR +RATE_MONOTONIC_PERIOD_STATUS RTEMS_PERIOD_STATUS +WATCHDOG_FOREVER RTEMS_NO_TIMEOUT +STACK_MINIMUM_SIZE RTEMS_MINIMUM_STACK_SIZE +# +ASR_Handler rtems_asr_entry +Thread_Entry rtems_task_entry +# +disable_intr rtems_interrupt_disable +enable_intr rtems_interrupt_enable +flash_intr rtems_interrupt_flash + diff --git a/tools/update/README b/tools/update/README new file mode 100644 index 0000000000..bbf99cb71d --- /dev/null +++ b/tools/update/README @@ -0,0 +1,7 @@ +# +# $Id$ +# + +This directory contains tools which aid in upgrading from RTEMS 3.1.0 +to RTEMS 3.2.0. + |