URL
https://opencores.org/ocsvn/System09/System09/trunk
Subversion Repositories System09
Compare Revisions
- This comparison shows the changes necessary to convert path
/System09/branches/mkfiles_rev1/Tools/epedit/old
- from Rev 26 to Rev 66
- ↔ Reverse comparison
Rev 26 → Rev 66
/epedit.exe
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
epedit.exe
Property changes :
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Index: epedit.c
===================================================================
--- epedit.c (nonexistent)
+++ 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 );
+}
+