Subversion Repositories System09

epedit.exe Property changes : Added: svn:mime-type ## -0,0 +1 ## +application/octet-stream \ No newline at end of property Index: old/epedit.exe =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Index: old/epedit.exe =================================================================== --- old/epedit.exe (nonexistent) +++ old/epedit.exe (revision 66)

old/epedit.exe Property changes : Added: svn:mime-type ## -0,0 +1 ## +application/octet-stream \ No newline at end of property Index: old/epedit.c =================================================================== --- old/epedit.c (nonexistent) +++ old/epedit.c (revision 66) @@ -0,0 +1,1817 @@ +/* + * epedit + * + * binary file editer program + */ +#include +#include +#include +/* + * equates + */ +#define EPROM_MAX (1<<16) +#define CMD_LINE_MAX 80 +#define FALSE 0 +#define TRUE !FALSE +#define BINARY 0 +#define MOTOROLA 1 +#define INTEL 2 +#define SMAL32 3 +#define VHDL_BIN 4 +#define VHDL_BYTE 5 +#define VHDL_WORD 6 + +/* + * global variables + */ +FILE *cmdfp; /* command input pointer */ +char cmdbuff[CMD_LINE_MAX]; +unsigned char eprom_buff[EPROM_MAX]; /* eprom buffer */ +int eprom_top; /* top of EPROM buffer */ +int mod_flag; /* buffer has been modified */ +int auxflag; /* Auxillary input file specified */ +int count; +int checksum; +int offset; /* Eprom Buffer memory offset */ +int format_type; /* load / save format type */ +char *hex_str = "0123456789ABCDEF"; + +/* + * Read a command line into the command buffer + */ +void read_command( char *cb ) +{ + int ch; /* character temp */ + int ci; /* command index */ + + ci = 0; + printf( "\n>>> " ); + + fflush( stdout ); + while( (ch = getc( cmdfp )) != EOF ) + { + if( (ch == '\n') || (ch == 0x0d) ) + { + cb[ci] = '\0'; + return; + } else if( ch == 0x8 ) + { + if( ci > 0 ) + ci--; + } else + { + cb[ci] = ch; + if( ci < CMD_LINE_MAX ) + ci++; + } + fflush( stdout ); + } + if(( ch == EOF) && auxflag ) + { + /* revert back to stdin if using an auxillay file + * We can assume that the auxillary command file + * has not been terminated with "quit" command + */ + fclose( cmdfp ); + cmdfp = stdin; + auxflag = FALSE; + } +} + +/* + * compare a string of specified length + * return TRUE if a match + * return FALSE if no match + * ignore case + */ +int str_equal( char *s1, char *s2, int len ) +{ + int i; + + i = 0; + while( i + */ + +int gethex( FILE *fp_in ) +{ + int hex; + + hex = fgetc( fp_in ); + return( to_hexadecimal( hex ) ); +} + +int get2hex( FILE *fp_in ) +{ + int hexhi, hexlo, byte; + + hexhi = gethex( fp_in ); + if( hexhi != -1 ) + { + hexlo = gethex( fp_in ); + if( hexlo != -1 ) + { + byte = hexhi * 16 + hexlo; + checksum = (checksum + byte) & 0xff; + return byte; + } + } + return -1; +} + +int get4hex( FILE *fp_in ) +{ + int bytehi, bytelo, addr; + + bytehi = get2hex( fp_in ); + if( bytehi != -1 ) + { + bytelo = get2hex( fp_in ); + if( bytelo != -1 ) + { + addr = (bytehi * 256) + bytelo; + return addr; + } + } + return -1; +} + +int get6hex( FILE *fp_in ) +{ + int bytehi, bytemid, bytelow, addr; + + bytehi = get2hex( fp_in ); + if( bytehi != -1 ) + { + bytemid = get2hex( fp_in ); + if( bytemid != -1 ) + { + bytelow = get2hex( fp_in ); + if( bytelow != -1 ) + { + addr = (bytehi << 16) + (bytemid << 8) + bytelow; + return addr; + } + } + } + return -1; +} + +long get8hex( FILE *fp_in ) +{ + int wordhi, wordlow; + long addr; + + wordhi = get4hex( fp_in ); + if( wordhi != -1 ) + { + wordlow = get4hex( fp_in ); + if( wordlow != -1 ) + { + addr = ((long)wordhi << 16) + (long)wordlow; + return addr; + } + } + return -1; +} + + +/* + * Load Raw binary file + */ + +void load_binary( char *fname_in, int load_addr ) +{ + FILE *fp_in; + int byte_count, addr; + int data_byte; + + if( (fp_in = fopen( fname_in, "rb" )) == NULL ) + { + printf( "\ncan't open %s for read", fname_in ); + return; + } else + { + byte_count = 0; + addr = load_addr - offset; + printf( "\nReading file '%s' offset by %x", fname_in, offset ); + while( (data_byte = fgetc( fp_in )) != EOF ) + { + eprom_buff[(addr + byte_count) % EPROM_MAX ] = (unsigned char) data_byte; + byte_count++; + } + + fclose( fp_in ); + printf( "\nbuffer loaded from %x to %x", addr, addr+byte_count-1 ); + if( (addr + byte_count) > eprom_top ) + eprom_top = addr + byte_count; + } +} + + +/* + * load motorola formatted file + */ + +void load_mot( char *fname_in ) +{ + FILE *fp_in; + int byte, addr, i; + + fp_in = fopen( fname_in, "r" ); + if( !fp_in ) + { + printf( "\nCan't open %s", fname_in ); + return; + } + + byte = 0; + addr = 0; + + while( byte != -1 ) + { + do { + byte = fgetc( fp_in); + } while( (byte != 'S') && (byte != -1) ); + + byte = fgetc( fp_in ); + checksum = 0; + if( (byte == '1') || (byte == '2') ) + { + count = get2hex( fp_in ); + if( byte == '1' ) + { + addr = get4hex( fp_in ); + count -= 3; + } + else + { + addr = get6hex( fp_in ); + count -= 4; + } + for( i=0; i= EPROM_MAX ) + byte = -1; + } + printf( "\nlast address = %08x", addr ); + close( fp_in ); +} + +/* + * Load Intel hex file + */ + +void load_intel( char *fname_in ) +{ + FILE *fp_in; + int byte, addr, i; + + fp_in = fopen( fname_in, "r" ); + if( !fp_in ) + { + printf( "\nCan't open %s for input", fname_in ); + return; + } + + byte = 0; + while( byte != -1) + { + do { + byte = fgetc( fp_in); + } while( (byte != ':') && (byte != -1) ); + + checksum = 0; + count = get2hex( fp_in ); /* read byte count */ + addr = get4hex( fp_in ); /* read address */ + i = get2hex( fp_in ); /* read 00 to load a record */ + if( i == 0 ) /* read 01 to end record */ + { + for( i=0; i= EPROM_MAX ) + byte = -1; + } else if( i == 1 ) + byte = -1; + } + close( fp_in ); +} + + +/* + * load VHDL Binary file + */ + +void load_vhdl_bin( char *fname_in, int start_addr ) +{ + FILE *fp_in; + int addr; + int i; + int byte, data; + int state; + + if( (fp_in = fopen( fname_in, "r" )) == NULL ) + { + printf( "\nCan't open '%s' for read ", fname_in ); + return; + } + byte = 0; + state = 0; + addr = start_addr; + while( byte != -1) + { + byte = fgetc( fp_in); + switch( state ) + { + case 0: + if( byte == '"' ) + { + data = 0; + state = 1; + i = 0; + } + break; + case 1: + data <<= 1; + if( byte == '1' ) + data += 1; + else + { + if( byte != '0' ) + { + state = 0; + break; + } + } + i++; + if( i == 8 ) + state = 2; + break; + case 2: + if( byte == '"' ) + { + eprom_buff[ addr % EPROM_MAX ] = (unsigned char)data; + addr++; + } + state = 0; + break; + default: + break; + } + } + fclose( fp_in ); + printf( "\nLoaded " ); +} + +/* + * load VHDL Hex file + */ + +void load_vhdl_byte( char *fname_in, int start_addr ) +{ + FILE *fp_in; + int addr, i; + int byte, data; + int state; + + if( (fp_in = fopen( fname_in, "r" )) == NULL ) + { + printf( "\nCan't open '%s' for read ", fname_in ); + return; + } + byte = 0; + state = 0; + addr = start_addr; + while( byte != -1) + { + byte = fgetc( fp_in); + switch( state ) + { + case 0: + if( byte == 'x' ) + { + state = 1; + } + break; + case 1: + if( byte == '"' ) + { + data = 0; + state = 2; + i = 31; + } + break; + case 2: + data = to_hexadecimal( (char)byte ); + if( data != -1 ) + { + data <<= 4; + state = 3; + } else + state = 0; + break; + case 3: + if( to_hexadecimal( byte ) != -1 ) + { + data += to_hexadecimal( (char)byte ); + eprom_buff[ (addr + i ) % EPROM_MAX ] = (unsigned char)data; + if( i == 0 ) + { + addr += 32; + state = 0; + } else + { + i--; + state = 2; + } + } else + state = 0; + + break; + default: + break; + } + } + fclose( fp_in ); + printf( "\nLoaded " ); +} + + +/* + * load VHDL Word file + */ + +void load_vhdl_word( char *fname_in, int start_addr ) +{ + FILE *fp_in; + int addr; + int i; + int byte, data; + int state; + + if( (fp_in = fopen( fname_in, "r" )) == NULL ) + { + printf( "\nCan't open '%s' for read ", fname_in ); + return; + } + byte = 0; + state = 0; + addr = start_addr; + while( byte != -1) + { + byte = fgetc( fp_in); + switch( state ) + { + case 0: + if( byte == 'x' ) + { + state = 1; + } + break; + case 1: + if( byte == '"' ) + { + data = 0; + state = 2; + i = 30; + } + break; + case 2: + data = to_hexadecimal( (char)byte ); + if( data != -1 ) + { + data <<= 4; + state = 3; + } else + state = 0; + break; + case 3: + if( to_hexadecimal( (char)byte ) != -1 ) + { + data += to_hexadecimal( (char)byte ); + eprom_buff[ (addr + i) % EPROM_MAX ] = (unsigned char)data; + state = 4; + } else + state = 0; + + break; + case 4: + data = to_hexadecimal( (char)byte ); + if( data != -1 ) + { + data <<= 4; + state = 5; + } else + state = 0; + break; + case 5: + if( to_hexadecimal( (char)byte ) != -1 ) + { + data += to_hexadecimal( (char)byte ); + eprom_buff[ (addr + i + 1) % EPROM_MAX ] = (unsigned char)data; + if( i == 0 ) + { + addr += 32; + state = 0; + } else + { + i -= 2; + state = 2; + } + } else + state = 0; + + break; + default: + break; + } + } + fclose( fp_in ); + printf( "\nLoaded " ); +} + + + +int put2hex( FILE *fp, int h ) +{ + int i, hex; + + hex = (h & 0xf0)>>4; + i = fputc( (int)hex_str[hex], fp ); + hex = (h & 0xf); + i = fputc( (int)hex_str[hex], fp ); + checksum = (checksum + h) & 0xff; + return i; +} + +int put4hex( FILE * fp, int h ) +{ + int i; + + i = put2hex( fp, (h & 0xff00 )>>8 ); + i = put2hex( fp, (h & 0xff) ); + return i; +} + + + +/* + * save VHDL Binary file + */ + +void save_vhdl_bin( char *fname_out, int start_addr, int end_addr ) +{ + FILE *fp_out; + int addr; + int i; + int byte; + + if( (fp_out = fopen( fname_out, "w" )) == NULL ) + { + printf( "\nCan't open '%s' for write ", fname_out ); + return; + } + for( addr=start_addr; addr<=end_addr; addr++ ) + { + putc( '"', fp_out ); + for(i=7; i>=0; i-- ) + { + byte = (int)eprom_buff[(addr - offset) % EPROM_MAX]; + if(( byte & (1< x\"", j ); + for(i=31; i>=0; i-- ) + { + byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX]; + putc( hex_str[(byte >>4) & 0xf], fp_out ); + putc( hex_str[byte & 0xf], fp_out ); + } + fprintf( fp_out, "\",\n" ); + j++; + } + fclose( fp_out ); + printf( "\nwritten successfully" ); +} + + +/* + * save VHDL hexadecimal Word file + */ + +void save_vhdl_word( char *fname_out, int start_addr, int end_addr ) +{ + FILE *fp_out; + int addr; + int i,j; + int byte; + + if( (fp_out = fopen( fname_out, "w" )) == NULL ) + { + printf( "\nCan't open '%s' for write ", fname_out ); + return; + } + j=0; + for( addr=start_addr; addr<=end_addr; addr+=32 ) + { + fprintf( fp_out, " INIT_%02x => x\"" ); + for(i=30; i>=0; i-=2 ) + { + /* MSByte first */ + byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX]; + putc( hex_str[(byte >>4) & 0xf], fp_out ); + putc( hex_str[byte & 0xf], fp_out ); + /* LSByte second */ + byte = (int)eprom_buff[(addr - offset + i + 1) % EPROM_MAX]; + putc( hex_str[(byte >>4) & 0xf], fp_out ); + putc( hex_str[byte & 0xf], fp_out ); + } + fprintf( fp_out, "\",\n" ); + j++; + } + fclose( fp_out ); + printf( "\nwritten successfully" ); +} + + +/* + * save raw binary file + */ + +void save_binary( char *fname_out, int start_addr, int end_addr ) +{ + FILE *fp_out; + int addr; + + if( (fp_out = fopen( fname_out, "wb" )) == NULL ) + { + printf( "\nCan't open '%s' for write ", fname_out ); + return; + } + for( addr=start_addr; addr<=end_addr; addr++ ) + { + putc( eprom_buff[(addr - offset) % EPROM_MAX ], fp_out ); + } + fclose( fp_out ); + printf( "\nwritten successfully" ); +} + + +/* + * Save Motorola S1 file + */ + +void save_mot( char *fname_out, int start_addr, int end_addr ) +{ + FILE *fp_out; + int addr, start; + int i; + int E_total; + int data_byte; + + fp_out = fopen( fname_out, "w" ); + if( !fp_out ) + { + printf( "\nCan't open %s for output", fname_out ); + return; + } + + addr = start_addr; + while( addr <= end_addr) + { + if( (end_addr - addr + 1) > 0 ) + E_total = 16; + else + E_total = end_addr - addr + 1; + fputc( 'S', fp_out); /* record header preamble */ + fputc( '1', fp_out); /* record header preamble */ + checksum = 0; + put2hex( fp_out, E_total+3); /* byte count + 3 */ + put4hex( fp_out, addr); /* Program Counter */ + for(i=0; i>8) & 0xff); + put2hex( fp_out, 0 ); + check += 0; + for( i=0; i= start_addr) && (addr <= end_addr) ) + { + if( (unsigned char)data_byte != eprom_buff[(addr -offset) % EPROM_MAX] ) + { + printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX ], data_byte ); + diff_count++; + } + } + addr++; + } + printf( "\nLast compared address %x ", addr-1 ); + printf( "\nThere were %d differences ", diff_count ); + fclose( fp_in ); + } +} + + +/* + * Compare motorola formatted file + */ + +void compare_mot( char *fname_in, int start_addr, int end_addr ) +{ + FILE *fp_in; + int byte, addr, start, check, i; + int diff_count; + + fp_in = fopen( fname_in, "r" ); + if( !fp_in ) + { + printf( "\nCan't open %s", fname_in ); + return; + } + + byte = 0; + addr = start; + diff_count = 0; + + while( byte != -1 ) + { + do { + byte = fgetc( fp_in); + } while( (byte != 'S') && (byte != -1) ); + + byte = fgetc( fp_in ); + checksum = 0; + if( (byte == '1') || (byte == '2') ) + { + count = get2hex( fp_in ); + if( byte == '1' ) + addr = get4hex( fp_in ); + else + addr = get6hex( fp_in ); + count -= 3; + for( i=0; i= start_addr) && (addr <= end_addr )) + { + if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX ] ) + { + printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX ], byte ); + diff_count++; + } + } + addr++; + } + byte = get2hex( fp_in); + if( addr >= EPROM_MAX ) + byte = -1; + } + } + close( fp_in ); + printf( "\nLast compared address %x ", addr - 1 ); + printf( "\nThere were %d differences ", diff_count ); +} + +/* + * Load Intel hex file + */ + +void compare_intel( char *fname_in, int start_addr, int end_addr ) +{ + FILE *fp_in; + int byte, addr, start, i; + int diff_count; + + fp_in = fopen( fname_in, "r" ); + if( !fp_in ) + { + printf( "\nCan't open %s for input", fname_in ); + return; + } + + byte = 0; + diff_count = 0; + while( byte != -1) + { + do { + byte = fgetc( fp_in); + } while( (byte != ':') && (byte != -1) ); + + checksum = 0; + count = get2hex( fp_in ); + addr = get4hex( fp_in ); + i = get2hex( fp_in ); /* read 00 to load a record */ + if( i == 0 ) /* read 01 to end record */ + { + for( i=0; i= start_addr) && (addr <= end_addr )) + { + if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX] ) + { + printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX], byte ); + diff_count++; + } + } + addr++; + } + byte = get2hex( fp_in); + if( checksum != 0 ) + { + printf( "\nchecksum error detected, read %02x, expected %02x", byte, ((checksum - byte) & 0xff) ); + byte = -1; + } else if( addr >= EPROM_MAX ) + byte = -1; + } else if( i == 1 ) /* test for end of record */ + byte = -1; + } + close( fp_in ); + printf( "\nLast compared address %x ", addr - 1 ); + printf( "\nThere were %d differences ", diff_count ); +} + + +/* + * help menu + */ +void display_help() +{ + printf( "\n*** Help Menu ***\n\n"); + printf( "All addresses are in hexadecimal\n" ); + printf( "H/?/help - This help menu\n" ); + printf( "T/type - Set Load & Save format\n" ); + printf( " \n"); + printf( " \n"); + printf( " \n" ); + printf( " \n" ); + printf( " VHDL Binary String \n" ); + printf( " VHDL Hexadecimal Byte String\n" ); + printf( " VHDL Hexadecimal Word String\n" ); + printf( "O/offset

- Set Eprom buffer offset\n" ); + printf( "L/load [] - Loads file into buffer\n" ); + printf( "S/save - Saves buffer to file\n" ); + printf( "C/compare [] - compare file to buffer\n" ); +/* + printf( "R/read

- reads buffer data\n" ); +*/ + printf( "W/write

.... - Write data to buffer\n" ); + printf( "F/fill - fill buffer with data\n"); + printf( "M/move - block move\n" ); + printf( "D/dump - Hex buffer dump\n"); + printf( "E/echo - echo string to console\n" ); + printf( "X/excecute - execute a command script\n"); + printf( "Q/quit - quit program\n" ); +} + +/* + * Parse command + * Return FALSE to exit + */ +int parse_command( char *cmdline ) +{ + int lineptr; + char *cmdptr; + int arglen; + FILE *fp; + char filename[64]; + int start_addr; + int end_addr; + int dest_addr; + int load_addr; + int byte_count; + int data_byte; + int ch; + int len; + + lineptr = 0; + start_addr = 0; + end_addr = 0; + + /* skip leading white spaces */ + while( isspace( cmdline[lineptr] )) + lineptr++; + /* point to the start of the command argument & extract command */ + cmdptr = &cmdline[lineptr]; + len = 0; + while( isalpha( cmdline[lineptr] ) || + (cmdline[lineptr] == '?')) + { + lineptr++; + len++; + } + /* skip trailing white spaces */ + while( isspace( cmdline[lineptr] ) ) + lineptr++; + if( len > 0 ) + { + + if( str_equal( cmdptr, "T", len ) || + str_equal( cmdptr, "type", len ) ) + { + /*********************************************************** + * + * Specify file I/O format type + */ + cmdptr = &cmdline[lineptr]; + len = 0; + while( isalpha( cmdline[lineptr] )) + { + lineptr++; + len++; + } + if( len != 0 ) + { + if( str_equal( cmdptr, "B", len ) ) + format_type = BINARY; + else if( str_equal( cmdptr, "binary", len ) ) + format_type = BINARY; + else if( str_equal( cmdptr, "M", len ) ) + format_type = MOTOROLA; + else if( str_equal( cmdptr, "motorola", len ) ) + format_type = MOTOROLA; + else if( str_equal( cmdptr, "I", len ) ) + format_type = INTEL; + else if( str_equal( cmdptr, "intel", len ) ) + format_type = INTEL; + else if( str_equal( cmdptr, "O", len ) ) + format_type = SMAL32; + else if( str_equal( cmdptr, "smal", len ) ) + format_type = SMAL32; + else if( str_equal( cmdptr, "V", len ) ) + format_type = VHDL_BIN; + else if( str_equal( cmdptr, "vhdl", len ) ) + format_type = VHDL_BIN; + else if( str_equal( cmdptr, "H", len ) ) + format_type = VHDL_BYTE; + else if( str_equal( cmdptr, "hex", len ) ) + format_type = VHDL_BYTE; + else if( str_equal( cmdptr, "W", len ) ) + format_type = VHDL_WORD; + else if( str_equal( cmdptr, "word", len ) ) + format_type = VHDL_WORD; + else printf( "\nUnrecognised file format" ); + } + printf( "\nFile format type is : " ); + switch( format_type ) { + case BINARY: + printf( "Raw Binary" ); + break; + case MOTOROLA: + printf( "Motorola S1" ); + break; + case INTEL: + printf( "Intel Hex" ); + break; + case SMAL32: + printf( "Smal32 .o" ); + break; + case VHDL_BIN: + printf( "vhdl binary" ); + break; + case VHDL_BYTE: + printf( "vhdl hexadecimal byte" ); + break; + case VHDL_WORD: + printf( "vhdl hexadecimal word" ); + break; + default: + printf( "Bad format - should not get here" ); + break; + } + return TRUE; + } + else if( str_equal( cmdptr, "L", len ) || + str_equal( cmdptr, "load", len ) ) + { + /*********************************************************** + * + * Load file into buffer + */ + arglen = get_filename( &cmdline[lineptr], &filename[0] ); + if( arglen == 0 ) + { + printf( "\nFile name expected " ); + return TRUE; + } + lineptr += arglen; + arglen = get_address( &cmdline[lineptr], &load_addr ); + if( arglen == 0 ) + { + /* default binary load address = start of eprom */ + load_addr = offset; + + } + if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX))) + { + printf( "\nLoad address out of range" ); + return TRUE; + } + switch( format_type ) { + case BINARY: + printf( "\nLoading binary file" ); + load_binary( filename, load_addr ); + break; + case MOTOROLA: + printf( "\nLoading Motorola S1 file" ); + load_mot( filename ); + break; + case INTEL: + printf( "\nLoading intel hex file" ); + load_intel( filename ); + break; + case SMAL32: + printf( "\nLoading Smal32 file" ); + load_smal32( filename ); + break; + case VHDL_BIN: + printf( "\nLoading VHDL binary format" ); + load_vhdl_bin( filename, load_addr ); + break; + case VHDL_BYTE: + printf( "\nLoading VHDL hexadecimal byte format" ); + load_vhdl_byte( filename, load_addr ); + break; + case VHDL_WORD: + printf( "\nLoading VHDL hexadecimal word format" ); + load_vhdl_word( filename, load_addr ); + break; + default: + printf( "\nBad format - no load" ); + break; + } + mod_flag = TRUE; + return TRUE; + } else if( str_equal( cmdptr, "S", len ) || + str_equal( cmdptr, "save", len )) + { + /*********************************************************** + * + * Save buffer to file + * + ***********************************************************/ + arglen = get_filename( &cmdline[lineptr], &filename[0] ); + if( arglen == 0 ) + { + printf( "\nFile name expected " ); + return TRUE; + } + lineptr += arglen; + arglen = get_address( &cmdline[lineptr], &start_addr ); + if( arglen == 0 ) + { + /* this could default to 0 */ + printf( "\nStart address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0) + { + /* this could default to eprom_top */ + printf( "\nEnd address expected " ); + return TRUE; + } + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX))) + { + printf( "\nEnd address out of range" ); + return TRUE; + } + printf( "\nSaving buffer %x to %x to file %s ", start_addr, end_addr, filename ); + switch( format_type ) { + case BINARY: + printf( "\nBinary format" ); + save_binary( filename, start_addr, end_addr ); + break; + case MOTOROLA: + printf( "\nMotorola S1 format" ); + save_mot( filename, start_addr, end_addr ); + break; + case INTEL: + printf( "\nIntel hex format" ); + save_intel( filename, start_addr, end_addr ); + break; + case VHDL_BIN: + printf( "\nVHDL binary format" ); + save_vhdl_bin( filename, start_addr, end_addr ); + break; + case VHDL_BYTE: + printf( "\nVHDL hexadecimal byte format" ); + save_vhdl_byte( filename, start_addr, end_addr ); + break; + case VHDL_WORD: + printf( "\nVHDL hexadecimal word format" ); + save_vhdl_word( filename, start_addr, end_addr ); + break; + default: + printf( "\nBad format - no save performed" ); + break; + } + return TRUE; + } else if( str_equal( cmdptr, "D", len ) || + str_equal( cmdptr, "dump", len )) + { + /*********************************************************** + * + * dump buffer to the display + */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + printf( "\nStart address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0) + { + printf( "\nEnd address expected " ); + return TRUE; + } + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX))) + { + printf( "\nEnd address out of range" ); + return TRUE; + } + load_addr = 0; + printf( "\n Memory Dump form %x to %x ", start_addr, end_addr ); + while( (start_addr + load_addr) <= end_addr ) + { + printf( "\n %04x - ", start_addr + load_addr ); + for( dest_addr = 0; dest_addr < 16; dest_addr++ ) + { + if( (start_addr + load_addr + dest_addr) <= end_addr ) + printf( "%02x ", eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX] ); + else + printf( " " ); + } + printf( " " ); + for( dest_addr = 0; dest_addr < 16; dest_addr++ ) + { + if( (start_addr + load_addr + dest_addr) <= end_addr ) + { + ch = eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX]; + if( (ch > 0x20) && (ch < 0x7f) ) + printf( "%c", ch ); + else + printf( "." ); + } else + printf( " " ); + } + load_addr += dest_addr; + } + return TRUE; + } else if( str_equal( cmdptr, "C", len ) || + str_equal( cmdptr, "compare", len )) + { + /*********************************************************** + * + * compare file with buffer + * + ***********************************************************/ + if( (arglen = get_filename( &cmdline[lineptr], &filename[0] )) == 0 ) + { + printf( "\nFile name expected " ); + return TRUE; + } + lineptr += arglen; + /* start/load address is optional - default to start of eprom */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + start_addr = offset; + } + lineptr += arglen; + + /* the end/start address is optional */ + if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0 ) + { + end_addr = EPROM_MAX + offset - 1; + } + lineptr += arglen; + + /* the end/start address is optional */ + if( (arglen = get_address( &cmdline[lineptr], &load_addr )) == 0 ) + { + load_addr = EPROM_MAX + offset - 1; + } + + /* check for valid address range */ + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX))) + { + printf( "\nEnd address out of range" ); + return TRUE; + } + if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX))) + { + printf( "\nLoad address out of range" ); + return TRUE; + } + printf( "\nComparing buffer to file %s", filename ); + switch( format_type ) { + case BINARY: + printf( "\nBinary format" ); + dest_addr = load_addr; + load_addr = start_addr; + start_addr = end_addr; + end_addr = dest_addr; + if( start_addr == (EPROM_MAX + offset - 1) ) + start_addr = offset; + compare_binary( filename, load_addr, start_addr, end_addr ); + break; + case MOTOROLA: + printf( "\nMotorola S1 format" ); + compare_mot( filename, start_addr, end_addr ); + break; + case INTEL: + printf( "\nIntel hex format" ); + compare_intel( filename, start_addr, end_addr ); + break; + default: + printf( "\nBad format - no save performed" ); + break; + } + return TRUE; + } else if( str_equal( cmdptr, "M", len ) || + str_equal( cmdptr, "move", len )) + { + /*********************************************************** + * + * memory block move + */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + printf( "\nStart address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0) + { + printf( "\nEnd address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &dest_addr )) == 0) + { + printf( "\nDestination address expected " ); + return TRUE; + } + /* check that the range is around the right way */ + if( end_addr < start_addr ) + { + load_addr = start_addr; + start_addr = end_addr; + end_addr = load_addr; + } + /* check for valid address range */ + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX))) + { + printf( "\nEnd address out of range" ); + return TRUE; + } + if( (dest_addr < offset) || (dest_addr >= (offset + EPROM_MAX))) + + { + printf( "\nDestination address out of range" ); + return TRUE; + } + byte_count = end_addr - start_addr; + printf( "\nTransfering memory block %04x thru %04x to %04x", start_addr, end_addr, dest_addr ); + if( start_addr > dest_addr ) + { + for( load_addr=0; load_addr<=byte_count; load_addr++ ) + eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX]; + } else + { + for( load_addr=byte_count; load_addr>=0; load_addr-- ) + eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX]; + } + printf( "\nDone" ); + mod_flag = TRUE; + return TRUE; + } else if( str_equal( cmdptr, "F", len ) || + str_equal( cmdptr, "fill", len )) + { + /*********************************************************** + * + * fill memory with data + */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + printf( "\nStart address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0) + { + printf( "\nEnd address expected " ); + return TRUE; + } + lineptr += arglen; + if( (arglen = get_address( &cmdline[lineptr], &data_byte )) == 0) + { + printf( "\nFill data byte expected " ); + return TRUE; + } + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX))) + { + printf( "\nEnd address out of range" ); + return TRUE; + } + printf( "\nFilling address %x thru %x with %x ", start_addr, end_addr, data_byte ); + for( dest_addr=start_addr; dest_addr<=end_addr; dest_addr++ ) + eprom_buff[(dest_addr-offset) % EPROM_MAX] = (unsigned char)data_byte; + printf( "\nDone" ); + mod_flag = TRUE; + return TRUE; + } else if( str_equal( cmdptr, "W", len ) || + str_equal( cmdptr, "write", len )) + + { + /*********************************************************** + * + * Write to buffer location + */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + printf( "\nStart address expected " ); + return TRUE; + } + lineptr += arglen; + /* check for valid address range */ + if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX))) + { + printf( "\nStart address out of range" ); + return TRUE; + } + printf( "\nSetting buffer loaction %x", start_addr ); + while( (arglen = get_address( &cmdline[lineptr], &data_byte )) != 0) + { + eprom_buff[(start_addr-offset) % EPROM_MAX] = (unsigned char)data_byte; + printf( "\n %04x = %02x ", start_addr, data_byte ); + start_addr++; + lineptr += arglen; + } + mod_flag = TRUE; + return TRUE; + } else if( str_equal( cmdptr, "O", len ) || + str_equal( cmdptr, "offset", len )) + { + /*********************************************************** + * + * Set Eprom base address offset + */ + if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 ) + { + /* No argument, display offset */ + printf( "\nBase address offset = %04x", offset ); + return TRUE; + } + offset = start_addr; + mod_flag = TRUE; + return TRUE; + } else if( str_equal( cmdptr, "H", len ) || + str_equal( cmdptr, "?", len ) || + str_equal( cmdptr, "help", len )) + { + /*********************************************************** + * + * Display help menu + */ + display_help(); + return TRUE; + } else if( str_equal( cmdptr, "Q", len ) || + str_equal( cmdptr, "quit", len )) + { + /*********************************************************** + * + * Quit program - return FALSE + */ + printf( "\nQuitting program" ); + return FALSE; + } else if( str_equal( cmdptr, "E", len ) || + str_equal( cmdptr, "echo", len )) + { + /*********************************************************** + * + * Echo string to the console + */ + printf( "\n" ); + while( (cmdline[lineptr] != '\0') && (cmdline[lineptr] != '\n')) + printf( "%c", cmdline[lineptr++] ); + printf( "\n" ); + return TRUE; + + } else if( str_equal( cmdptr, "X", len ) || + str_equal( cmdptr, "execute", len )) + { + /*********************************************************** + * + * Execute command script + * We can onle do this if we are using stdin + */ + if( cmdfp != stdin ) + { + printf( "\nWe cannot nest redirected input " ); + return TRUE; + } + + arglen = get_filename( &cmdline[lineptr], &filename[0] ); + if( arglen == 0 ) + { + printf( "\nFile name expected " ); + return TRUE; + } + + if( (cmdfp = fopen( &filename[0], "r" )) == NULL ) + { + printf( "\ncan't open auxillary input file '%s'", &filename[0] ); + /* we had better revert to the original command file */ + cmdfp = stdin; + return TRUE; + } + /* every thing is ok, input is re-directed */ + auxflag = TRUE; + return TRUE; + } + } + /*********************************************************** + * + * Command not understood + */ + printf( "\nUnrecognised command" ); + return TRUE; +} + +/* + * epedit main program + */ +main(int argc, char **argv) +{ + + auxflag = FALSE; + offset = 0; + format_type = BINARY; + + if(argc >= 2) + { + /* check for auxillary command file */ + if((cmdfp = fopen( argv[1], "r" )) == NULL) + { + printf(" can't open input on %s\n", argv[1] ); + printf("Usage: %s [command-file]\n",argv[0]); + exit(1); + } + auxflag = TRUE; + } else + { + /* no auxillary command file specified, use stdin */ + cmdfp = stdin; + } + + eprom_top = 0; + printf( "*** EPROM Editor ***\n" ); + printf( "type H/?/help for commands\n" ); + do { + read_command( cmdbuff ); + } while( parse_command( cmdbuff ) ); + printf( "\n*** exit epedit ***\n" ); + exit( 0 ); +} +