/*
|
/*
|
* epedit
|
* epedit
|
*
|
*
|
* binary file editer program
|
* binary file editer program
|
*/
|
*/
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <string.h>
|
#include <ctype.h>
|
#include <ctype.h>
|
/*
|
/*
|
* equates
|
* equates
|
*/
|
*/
|
#define EPROM_MAX (1<<16)
|
#define EPROM_MAX (1<<16)
|
#define CMD_LINE_MAX 80
|
#define CMD_LINE_MAX 80
|
#define FALSE 0
|
#define FALSE 0
|
#define TRUE !FALSE
|
#define TRUE !FALSE
|
#define BINARY 0
|
#define BINARY 0
|
#define MOTOROLA 1
|
#define MOTOROLA 1
|
#define INTEL 2
|
#define INTEL 2
|
#define SMAL32 3
|
#define SMAL32 3
|
#define VHDL_BIN 4
|
#define VHDL_BIN 4
|
#define VHDL_BYTE 5
|
#define VHDL_BYTE 5
|
#define VHDL_WORD 6
|
#define VHDL_WORD 6
|
|
|
/*
|
/*
|
* global variables
|
* global variables
|
*/
|
*/
|
FILE *cmdfp; /* command input pointer */
|
FILE *cmdfp; /* command input pointer */
|
char cmdbuff[CMD_LINE_MAX];
|
char cmdbuff[CMD_LINE_MAX];
|
unsigned char eprom_buff[EPROM_MAX]; /* eprom buffer */
|
unsigned char eprom_buff[EPROM_MAX]; /* eprom buffer */
|
int eprom_top; /* top of EPROM buffer */
|
int eprom_top; /* top of EPROM buffer */
|
int mod_flag; /* buffer has been modified */
|
int mod_flag; /* buffer has been modified */
|
int auxflag; /* Auxillary input file specified */
|
int auxflag; /* Auxillary input file specified */
|
int count;
|
int count;
|
int checksum;
|
int checksum;
|
int offset; /* Eprom Buffer memory offset */
|
int offset; /* Eprom Buffer memory offset */
|
int format_type; /* load / save format type */
|
int format_type; /* load / save format type */
|
char *hex_str = "0123456789ABCDEF";
|
char *hex_str = "0123456789ABCDEF";
|
|
|
/*
|
/*
|
* Read a command line into the command buffer
|
* Read a command line into the command buffer
|
*/
|
*/
|
void read_command( char *cb )
|
void read_command( char *cb )
|
{
|
{
|
int ch; /* character temp */
|
int ch; /* character temp */
|
int ci; /* command index */
|
int ci; /* command index */
|
|
|
ci = 0;
|
ci = 0;
|
printf( "\n>>> " );
|
printf( "\n>>> " );
|
|
|
fflush( stdout );
|
fflush( stdout );
|
while( (ch = getc( cmdfp )) != EOF )
|
while( (ch = getc( cmdfp )) != EOF )
|
{
|
{
|
if( (ch == '\n') || (ch == 0x0d) )
|
if( (ch == '\n') || (ch == 0x0d) )
|
{
|
{
|
cb[ci] = '\0';
|
cb[ci] = '\0';
|
return;
|
return;
|
} else if( ch == 0x8 )
|
} else if( ch == 0x8 )
|
{
|
{
|
if( ci > 0 )
|
if( ci > 0 )
|
ci--;
|
ci--;
|
} else
|
} else
|
{
|
{
|
cb[ci] = ch;
|
cb[ci] = ch;
|
if( ci < CMD_LINE_MAX )
|
if( ci < CMD_LINE_MAX )
|
ci++;
|
ci++;
|
}
|
}
|
fflush( stdout );
|
fflush( stdout );
|
}
|
}
|
if(( ch == EOF) && auxflag )
|
if(( ch == EOF) && auxflag )
|
{
|
{
|
/* revert back to stdin if using an auxillay file
|
/* revert back to stdin if using an auxillay file
|
* We can assume that the auxillary command file
|
* We can assume that the auxillary command file
|
* has not been terminated with "quit" command
|
* has not been terminated with "quit" command
|
*/
|
*/
|
fclose( cmdfp );
|
fclose( cmdfp );
|
cmdfp = stdin;
|
cmdfp = stdin;
|
auxflag = FALSE;
|
auxflag = FALSE;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* compare a string of specified length
|
* compare a string of specified length
|
* return TRUE if a match
|
* return TRUE if a match
|
* return FALSE if no match
|
* return FALSE if no match
|
* ignore case
|
* ignore case
|
*/
|
*/
|
int str_equal( char *s1, char *s2, int len )
|
int str_equal( char *s1, char *s2, int len )
|
{
|
{
|
int i;
|
int i;
|
|
|
i = 0;
|
i = 0;
|
while( i<len )
|
while( i<len )
|
{
|
{
|
if( toupper( s1[i] ) == toupper( s2[i] ) )
|
if( toupper( s1[i] ) == toupper( s2[i] ) )
|
i++;
|
i++;
|
else return FALSE;
|
else return FALSE;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/*
|
/*
|
* extract a file name from the command line
|
* extract a file name from the command line
|
*/
|
*/
|
int get_filename( char *cb, char *fn )
|
int get_filename( char *cb, char *fn )
|
{
|
{
|
int i;
|
int i;
|
|
|
i = 0;
|
i = 0;
|
while( !isspace( cb[i] ) && (cb[i] !='\n') && (cb[i] != '\0'))
|
while( !isspace( cb[i] ) && (cb[i] !='\n') && (cb[i] != '\0'))
|
{
|
{
|
fn[i] = cb[i];
|
fn[i] = cb[i];
|
i++;
|
i++;
|
}
|
}
|
fn[i] = '\0';
|
fn[i] = '\0';
|
if( i == 0 )
|
if( i == 0 )
|
return i;
|
return i;
|
while( isspace( cb[i] ))
|
while( isspace( cb[i] ))
|
i++;
|
i++;
|
return i;
|
return i;
|
}
|
}
|
|
|
int to_hexadecimal( char c )
|
int to_hexadecimal( char c )
|
{
|
{
|
int k;
|
int k;
|
|
|
for( k=0; k<16; k++ )
|
for( k=0; k<16; k++ )
|
{
|
{
|
if( toupper(c) == hex_str[k] )
|
if( toupper(c) == hex_str[k] )
|
return k;
|
return k;
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/*
|
/*
|
* extract an address from the command line
|
* extract an address from the command line
|
* returns an offset to the end of the argument.
|
* returns an offset to the end of the argument.
|
*/
|
*/
|
int get_address( char *cb, int *addr )
|
int get_address( char *cb, int *addr )
|
{
|
{
|
int i, j, k;
|
int i, j, k;
|
|
|
j = 0;
|
j = 0;
|
i = 0;
|
i = 0;
|
|
|
while((k = to_hexadecimal(cb[i])) != -1)
|
while((k = to_hexadecimal(cb[i])) != -1)
|
{
|
{
|
i++;
|
i++;
|
j = j *16 + k;
|
j = j *16 + k;
|
}
|
}
|
*addr = j;
|
*addr = j;
|
if( i == 0 )
|
if( i == 0 )
|
return i;
|
return i;
|
while( isspace( cb[i]) )
|
while( isspace( cb[i]) )
|
i++;
|
i++;
|
return i;
|
return i;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Motorola S1 format to Intel hex format
|
* Motorola S1 format to Intel hex format
|
* Usage
|
* Usage
|
* mot2hex <file_name>
|
* mot2hex <file_name>
|
*/
|
*/
|
|
|
int gethex( FILE *fp_in )
|
int gethex( FILE *fp_in )
|
{
|
{
|
int hex;
|
int hex;
|
|
|
hex = fgetc( fp_in );
|
hex = fgetc( fp_in );
|
return( to_hexadecimal( hex ) );
|
return( to_hexadecimal( hex ) );
|
}
|
}
|
|
|
int get2hex( FILE *fp_in )
|
int get2hex( FILE *fp_in )
|
{
|
{
|
int hexhi, hexlo, byte;
|
int hexhi, hexlo, byte;
|
|
|
hexhi = gethex( fp_in );
|
hexhi = gethex( fp_in );
|
if( hexhi != -1 )
|
if( hexhi != -1 )
|
{
|
{
|
hexlo = gethex( fp_in );
|
hexlo = gethex( fp_in );
|
if( hexlo != -1 )
|
if( hexlo != -1 )
|
{
|
{
|
byte = hexhi * 16 + hexlo;
|
byte = hexhi * 16 + hexlo;
|
checksum = (checksum + byte) & 0xff;
|
checksum = (checksum + byte) & 0xff;
|
return byte;
|
return byte;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
int get4hex( FILE *fp_in )
|
int get4hex( FILE *fp_in )
|
{
|
{
|
int bytehi, bytelo, addr;
|
int bytehi, bytelo, addr;
|
|
|
bytehi = get2hex( fp_in );
|
bytehi = get2hex( fp_in );
|
if( bytehi != -1 )
|
if( bytehi != -1 )
|
{
|
{
|
bytelo = get2hex( fp_in );
|
bytelo = get2hex( fp_in );
|
if( bytelo != -1 )
|
if( bytelo != -1 )
|
{
|
{
|
addr = (bytehi * 256) + bytelo;
|
addr = (bytehi * 256) + bytelo;
|
return addr;
|
return addr;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
int get6hex( FILE *fp_in )
|
int get6hex( FILE *fp_in )
|
{
|
{
|
int bytehi, bytemid, bytelow, addr;
|
int bytehi, bytemid, bytelow, addr;
|
|
|
bytehi = get2hex( fp_in );
|
bytehi = get2hex( fp_in );
|
if( bytehi != -1 )
|
if( bytehi != -1 )
|
{
|
{
|
bytemid = get2hex( fp_in );
|
bytemid = get2hex( fp_in );
|
if( bytemid != -1 )
|
if( bytemid != -1 )
|
{
|
{
|
bytelow = get2hex( fp_in );
|
bytelow = get2hex( fp_in );
|
if( bytelow != -1 )
|
if( bytelow != -1 )
|
{
|
{
|
addr = (bytehi << 16) + (bytemid << 8) + bytelow;
|
addr = (bytehi << 16) + (bytemid << 8) + bytelow;
|
return addr;
|
return addr;
|
}
|
}
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
long get8hex( FILE *fp_in )
|
long get8hex( FILE *fp_in )
|
{
|
{
|
int wordhi, wordlow;
|
int wordhi, wordlow;
|
long addr;
|
long addr;
|
|
|
wordhi = get4hex( fp_in );
|
wordhi = get4hex( fp_in );
|
if( wordhi != -1 )
|
if( wordhi != -1 )
|
{
|
{
|
wordlow = get4hex( fp_in );
|
wordlow = get4hex( fp_in );
|
if( wordlow != -1 )
|
if( wordlow != -1 )
|
{
|
{
|
addr = ((long)wordhi << 16) + (long)wordlow;
|
addr = ((long)wordhi << 16) + (long)wordlow;
|
return addr;
|
return addr;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Load Raw binary file
|
* Load Raw binary file
|
*/
|
*/
|
|
|
void load_binary( char *fname_in, int load_addr )
|
void load_binary( char *fname_in, int load_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte_count, addr;
|
int byte_count, addr;
|
int data_byte;
|
int data_byte;
|
|
|
if( (fp_in = fopen( fname_in, "rb" )) == NULL )
|
if( (fp_in = fopen( fname_in, "rb" )) == NULL )
|
{
|
{
|
printf( "\ncan't open %s for read", fname_in );
|
printf( "\ncan't open %s for read", fname_in );
|
return;
|
return;
|
} else
|
} else
|
{
|
{
|
byte_count = 0;
|
byte_count = 0;
|
addr = load_addr - offset;
|
addr = load_addr - offset;
|
printf( "\nReading file '%s' offset by %x", fname_in, offset );
|
printf( "\nReading file '%s' offset by %x", fname_in, offset );
|
while( (data_byte = fgetc( fp_in )) != EOF )
|
while( (data_byte = fgetc( fp_in )) != EOF )
|
{
|
{
|
eprom_buff[(addr + byte_count) % EPROM_MAX ] = (unsigned char) data_byte;
|
eprom_buff[(addr + byte_count) % EPROM_MAX ] = (unsigned char) data_byte;
|
byte_count++;
|
byte_count++;
|
}
|
}
|
|
|
fclose( fp_in );
|
fclose( fp_in );
|
printf( "\nbuffer loaded from %x to %x", addr, addr+byte_count-1 );
|
printf( "\nbuffer loaded from %x to %x", addr, addr+byte_count-1 );
|
if( (addr + byte_count) > eprom_top )
|
if( (addr + byte_count) > eprom_top )
|
eprom_top = addr + byte_count;
|
eprom_top = addr + byte_count;
|
}
|
}
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* load motorola formatted file
|
* load motorola formatted file
|
*/
|
*/
|
|
|
void load_mot( char *fname_in )
|
void load_mot( char *fname_in )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte, addr, i;
|
int byte, addr, i;
|
|
|
fp_in = fopen( fname_in, "r" );
|
fp_in = fopen( fname_in, "r" );
|
if( !fp_in )
|
if( !fp_in )
|
{
|
{
|
printf( "\nCan't open %s", fname_in );
|
printf( "\nCan't open %s", fname_in );
|
return;
|
return;
|
}
|
}
|
|
|
byte = 0;
|
byte = 0;
|
addr = 0;
|
addr = 0;
|
|
|
while( byte != -1 )
|
while( byte != -1 )
|
{
|
{
|
do {
|
do {
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
} while( (byte != 'S') && (byte != -1) );
|
} while( (byte != 'S') && (byte != -1) );
|
|
|
byte = fgetc( fp_in );
|
byte = fgetc( fp_in );
|
checksum = 0;
|
checksum = 0;
|
if( (byte == '1') || (byte == '2') )
|
if( (byte == '1') || (byte == '2') )
|
{
|
{
|
count = get2hex( fp_in );
|
count = get2hex( fp_in );
|
if( byte == '1' )
|
if( byte == '1' )
|
{
|
{
|
addr = get4hex( fp_in );
|
addr = get4hex( fp_in );
|
count -= 3;
|
count -= 3;
|
}
|
}
|
else
|
else
|
{
|
{
|
addr = get6hex( fp_in );
|
addr = get6hex( fp_in );
|
count -= 4;
|
count -= 4;
|
}
|
}
|
for( i=0; i<count; i++ )
|
for( i=0; i<count; i++ )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[( addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[( addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
}
|
}
|
byte = get2hex( fp_in);
|
byte = get2hex( fp_in);
|
checksum = (~checksum) & 0xff;
|
checksum = (~checksum) & 0xff;
|
if( checksum != 0 )
|
if( checksum != 0 )
|
printf( "\nchecksum error - read check = %02x", byte );
|
printf( "\nchecksum error - read check = %02x", byte );
|
}
|
}
|
}
|
}
|
close( fp_in );
|
close( fp_in );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* load smal32 .o formatted file
|
* load smal32 .o formatted file
|
*/
|
*/
|
|
|
void load_smal32( char *fname_in )
|
void load_smal32( char *fname_in )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte;
|
int byte;
|
long addr;
|
long addr;
|
int state;
|
int state;
|
|
|
fp_in = fopen( fname_in, "r" );
|
fp_in = fopen( fname_in, "r" );
|
if( !fp_in )
|
if( !fp_in )
|
{
|
{
|
printf( "\nCan't open %s", fname_in );
|
printf( "\nCan't open %s", fname_in );
|
return;
|
return;
|
}
|
}
|
|
|
byte = 0;
|
byte = 0;
|
addr = 0;
|
addr = 0;
|
state = 0;
|
state = 0;
|
|
|
while( byte != -1 )
|
while( byte != -1 )
|
{
|
{
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
switch( state )
|
switch( state )
|
{
|
{
|
case 0:
|
case 0:
|
switch( byte )
|
switch( byte )
|
{
|
{
|
case '.':
|
case '.':
|
state = 1;
|
state = 1;
|
break;
|
break;
|
case 'B':
|
case 'B':
|
state = 4;
|
state = 4;
|
break;
|
break;
|
case 'H':
|
case 'H':
|
state = 5;
|
state = 5;
|
break;
|
break;
|
case 'W':
|
case 'W':
|
state = 6;
|
state = 6;
|
break;
|
break;
|
default:
|
default:
|
state = 0;
|
state = 0;
|
}
|
}
|
break;
|
break;
|
case 1:
|
case 1:
|
if( byte == '=' )
|
if( byte == '=' )
|
state = 2;
|
state = 2;
|
else
|
else
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 2:
|
case 2:
|
if( byte == '#' )
|
if( byte == '#' )
|
{
|
{
|
addr = get8hex( fp_in );
|
addr = get8hex( fp_in );
|
printf( "\nload address = %08x", addr );
|
printf( "\nload address = %08x", addr );
|
}
|
}
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 3:
|
case 3:
|
break;
|
break;
|
case 4:
|
case 4:
|
if( byte == '#' )
|
if( byte == '#' )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
}
|
}
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 5:
|
case 5:
|
if( byte == '#' )
|
if( byte == '#' )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
}
|
}
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 6:
|
case 6:
|
if( byte == '#' )
|
if( byte == '#' )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
}
|
}
|
state = 0;
|
state = 0;
|
break;
|
break;
|
default :
|
default :
|
state = 0;
|
state = 0;
|
break;
|
break;
|
|
|
}
|
}
|
|
|
if( addr >= EPROM_MAX )
|
if( addr >= EPROM_MAX )
|
byte = -1;
|
byte = -1;
|
}
|
}
|
printf( "\nlast address = %08x", addr );
|
printf( "\nlast address = %08x", addr );
|
close( fp_in );
|
close( fp_in );
|
}
|
}
|
|
|
/*
|
/*
|
* Load Intel hex file
|
* Load Intel hex file
|
*/
|
*/
|
|
|
void load_intel( char *fname_in )
|
void load_intel( char *fname_in )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte, addr, i;
|
int byte, addr, i;
|
|
|
fp_in = fopen( fname_in, "r" );
|
fp_in = fopen( fname_in, "r" );
|
if( !fp_in )
|
if( !fp_in )
|
{
|
{
|
printf( "\nCan't open %s for input", fname_in );
|
printf( "\nCan't open %s for input", fname_in );
|
return;
|
return;
|
}
|
}
|
|
|
byte = 0;
|
byte = 0;
|
while( byte != -1)
|
while( byte != -1)
|
{
|
{
|
do {
|
do {
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
} while( (byte != ':') && (byte != -1) );
|
} while( (byte != ':') && (byte != -1) );
|
|
|
checksum = 0;
|
checksum = 0;
|
count = get2hex( fp_in ); /* read byte count */
|
count = get2hex( fp_in ); /* read byte count */
|
addr = get4hex( fp_in ); /* read address */
|
addr = get4hex( fp_in ); /* read address */
|
i = get2hex( fp_in ); /* read 00 to load a record */
|
i = get2hex( fp_in ); /* read 00 to load a record */
|
if( i == 0 ) /* read 01 to end record */
|
if( i == 0 ) /* read 01 to end record */
|
{
|
{
|
for( i=0; i<count; i++ )
|
for( i=0; i<count; i++ )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
|
addr++;
|
addr++;
|
}
|
}
|
byte = get2hex( fp_in);
|
byte = get2hex( fp_in);
|
if( checksum != 0 )
|
if( checksum != 0 )
|
{
|
{
|
printf( "\nchecksum read %02x, expected %02x", byte, (checksum - byte)&0xff );
|
printf( "\nchecksum read %02x, expected %02x", byte, (checksum - byte)&0xff );
|
byte = -1;
|
byte = -1;
|
} else if( addr >= EPROM_MAX )
|
} else if( addr >= EPROM_MAX )
|
byte = -1;
|
byte = -1;
|
} else if( i == 1 )
|
} else if( i == 1 )
|
byte = -1;
|
byte = -1;
|
}
|
}
|
close( fp_in );
|
close( fp_in );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* load VHDL Binary file
|
* load VHDL Binary file
|
*/
|
*/
|
|
|
void load_vhdl_bin( char *fname_in, int start_addr )
|
void load_vhdl_bin( char *fname_in, int start_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int addr;
|
int addr;
|
int i;
|
int i;
|
int byte, data;
|
int byte, data;
|
int state;
|
int state;
|
|
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for read ", fname_in );
|
printf( "\nCan't open '%s' for read ", fname_in );
|
return;
|
return;
|
}
|
}
|
byte = 0;
|
byte = 0;
|
state = 0;
|
state = 0;
|
addr = start_addr;
|
addr = start_addr;
|
while( byte != -1)
|
while( byte != -1)
|
{
|
{
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
switch( state )
|
switch( state )
|
{
|
{
|
case 0:
|
case 0:
|
if( byte == '"' )
|
if( byte == '"' )
|
{
|
{
|
data = 0;
|
data = 0;
|
state = 1;
|
state = 1;
|
i = 0;
|
i = 0;
|
}
|
}
|
break;
|
break;
|
case 1:
|
case 1:
|
data <<= 1;
|
data <<= 1;
|
if( byte == '1' )
|
if( byte == '1' )
|
data += 1;
|
data += 1;
|
else
|
else
|
{
|
{
|
if( byte != '0' )
|
if( byte != '0' )
|
{
|
{
|
state = 0;
|
state = 0;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
i++;
|
i++;
|
if( i == 8 )
|
if( i == 8 )
|
state = 2;
|
state = 2;
|
break;
|
break;
|
case 2:
|
case 2:
|
if( byte == '"' )
|
if( byte == '"' )
|
{
|
{
|
eprom_buff[ addr % EPROM_MAX ] = (unsigned char)data;
|
eprom_buff[ addr % EPROM_MAX ] = (unsigned char)data;
|
addr++;
|
addr++;
|
}
|
}
|
state = 0;
|
state = 0;
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
fclose( fp_in );
|
fclose( fp_in );
|
printf( "\nLoaded " );
|
printf( "\nLoaded " );
|
}
|
}
|
|
|
/*
|
/*
|
* load VHDL Hex file
|
* load VHDL Hex file
|
*/
|
*/
|
|
|
void load_vhdl_byte( char *fname_in, int start_addr )
|
void load_vhdl_byte( char *fname_in, int start_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int addr, i;
|
int addr, i;
|
int byte, data;
|
int byte, data;
|
int state;
|
int state;
|
|
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for read ", fname_in );
|
printf( "\nCan't open '%s' for read ", fname_in );
|
return;
|
return;
|
}
|
}
|
byte = 0;
|
byte = 0;
|
state = 0;
|
state = 0;
|
addr = start_addr;
|
addr = start_addr;
|
while( byte != -1)
|
while( byte != -1)
|
{
|
{
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
switch( state )
|
switch( state )
|
{
|
{
|
case 0:
|
case 0:
|
if( byte == 'x' )
|
if( byte == 'x' )
|
{
|
{
|
state = 1;
|
state = 1;
|
}
|
}
|
break;
|
break;
|
case 1:
|
case 1:
|
if( byte == '"' )
|
if( byte == '"' )
|
{
|
{
|
data = 0;
|
data = 0;
|
state = 2;
|
state = 2;
|
i = 31;
|
i = 31;
|
}
|
}
|
break;
|
break;
|
case 2:
|
case 2:
|
data = to_hexadecimal( (char)byte );
|
data = to_hexadecimal( (char)byte );
|
if( data != -1 )
|
if( data != -1 )
|
{
|
{
|
data <<= 4;
|
data <<= 4;
|
state = 3;
|
state = 3;
|
} else
|
} else
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 3:
|
case 3:
|
if( to_hexadecimal( byte ) != -1 )
|
if( to_hexadecimal( byte ) != -1 )
|
{
|
{
|
data += to_hexadecimal( (char)byte );
|
data += to_hexadecimal( (char)byte );
|
eprom_buff[ (addr + i ) % EPROM_MAX ] = (unsigned char)data;
|
eprom_buff[ (addr + i ) % EPROM_MAX ] = (unsigned char)data;
|
if( i == 0 )
|
if( i == 0 )
|
{
|
{
|
addr += 32;
|
addr += 32;
|
state = 0;
|
state = 0;
|
} else
|
} else
|
{
|
{
|
i--;
|
i--;
|
state = 2;
|
state = 2;
|
}
|
}
|
} else
|
} else
|
state = 0;
|
state = 0;
|
|
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
fclose( fp_in );
|
fclose( fp_in );
|
printf( "\nLoaded " );
|
printf( "\nLoaded " );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* load VHDL Word file
|
* load VHDL Word file
|
*/
|
*/
|
|
|
void load_vhdl_word( char *fname_in, int start_addr )
|
void load_vhdl_word( char *fname_in, int start_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int addr;
|
int addr;
|
int i;
|
int i;
|
int byte, data;
|
int byte, data;
|
int state;
|
int state;
|
|
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for read ", fname_in );
|
printf( "\nCan't open '%s' for read ", fname_in );
|
return;
|
return;
|
}
|
}
|
byte = 0;
|
byte = 0;
|
state = 0;
|
state = 0;
|
addr = start_addr;
|
addr = start_addr;
|
while( byte != -1)
|
while( byte != -1)
|
{
|
{
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
switch( state )
|
switch( state )
|
{
|
{
|
case 0:
|
case 0:
|
if( byte == 'x' )
|
if( byte == 'x' )
|
{
|
{
|
state = 1;
|
state = 1;
|
}
|
}
|
break;
|
break;
|
case 1:
|
case 1:
|
if( byte == '"' )
|
if( byte == '"' )
|
{
|
{
|
data = 0;
|
data = 0;
|
state = 2;
|
state = 2;
|
i = 30;
|
i = 30;
|
}
|
}
|
break;
|
break;
|
case 2:
|
case 2:
|
data = to_hexadecimal( (char)byte );
|
data = to_hexadecimal( (char)byte );
|
if( data != -1 )
|
if( data != -1 )
|
{
|
{
|
data <<= 4;
|
data <<= 4;
|
state = 3;
|
state = 3;
|
} else
|
} else
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 3:
|
case 3:
|
if( to_hexadecimal( (char)byte ) != -1 )
|
if( to_hexadecimal( (char)byte ) != -1 )
|
{
|
{
|
data += to_hexadecimal( (char)byte );
|
data += to_hexadecimal( (char)byte );
|
eprom_buff[ (addr + i) % EPROM_MAX ] = (unsigned char)data;
|
eprom_buff[ (addr + i) % EPROM_MAX ] = (unsigned char)data;
|
state = 4;
|
state = 4;
|
} else
|
} else
|
state = 0;
|
state = 0;
|
|
|
break;
|
break;
|
case 4:
|
case 4:
|
data = to_hexadecimal( (char)byte );
|
data = to_hexadecimal( (char)byte );
|
if( data != -1 )
|
if( data != -1 )
|
{
|
{
|
data <<= 4;
|
data <<= 4;
|
state = 5;
|
state = 5;
|
} else
|
} else
|
state = 0;
|
state = 0;
|
break;
|
break;
|
case 5:
|
case 5:
|
if( to_hexadecimal( (char)byte ) != -1 )
|
if( to_hexadecimal( (char)byte ) != -1 )
|
{
|
{
|
data += to_hexadecimal( (char)byte );
|
data += to_hexadecimal( (char)byte );
|
eprom_buff[ (addr + i + 1) % EPROM_MAX ] = (unsigned char)data;
|
eprom_buff[ (addr + i + 1) % EPROM_MAX ] = (unsigned char)data;
|
if( i == 0 )
|
if( i == 0 )
|
{
|
{
|
addr += 32;
|
addr += 32;
|
state = 0;
|
state = 0;
|
} else
|
} else
|
{
|
{
|
i -= 2;
|
i -= 2;
|
state = 2;
|
state = 2;
|
}
|
}
|
} else
|
} else
|
state = 0;
|
state = 0;
|
|
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
fclose( fp_in );
|
fclose( fp_in );
|
printf( "\nLoaded " );
|
printf( "\nLoaded " );
|
}
|
}
|
|
|
|
|
|
|
int put2hex( FILE *fp, int h )
|
int put2hex( FILE *fp, int h )
|
{
|
{
|
int i, hex;
|
int i, hex;
|
|
|
hex = (h & 0xf0)>>4;
|
hex = (h & 0xf0)>>4;
|
i = fputc( (int)hex_str[hex], fp );
|
i = fputc( (int)hex_str[hex], fp );
|
hex = (h & 0xf);
|
hex = (h & 0xf);
|
i = fputc( (int)hex_str[hex], fp );
|
i = fputc( (int)hex_str[hex], fp );
|
checksum = (checksum + h) & 0xff;
|
checksum = (checksum + h) & 0xff;
|
return i;
|
return i;
|
}
|
}
|
|
|
int put4hex( FILE * fp, int h )
|
int put4hex( FILE * fp, int h )
|
{
|
{
|
int i;
|
int i;
|
|
|
i = put2hex( fp, (h & 0xff00 )>>8 );
|
i = put2hex( fp, (h & 0xff00 )>>8 );
|
i = put2hex( fp, (h & 0xff) );
|
i = put2hex( fp, (h & 0xff) );
|
return i;
|
return i;
|
}
|
}
|
|
|
|
|
|
|
/*
|
/*
|
* save VHDL Binary file
|
* save VHDL Binary file
|
*/
|
*/
|
|
|
void save_vhdl_bin( char *fname_out, int start_addr, int end_addr )
|
void save_vhdl_bin( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int addr;
|
int addr;
|
int i;
|
int i;
|
int byte;
|
int byte;
|
|
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for write ", fname_out );
|
printf( "\nCan't open '%s' for write ", fname_out );
|
return;
|
return;
|
}
|
}
|
for( addr=start_addr; addr<=end_addr; addr++ )
|
for( addr=start_addr; addr<=end_addr; addr++ )
|
{
|
{
|
putc( '"', fp_out );
|
putc( '"', fp_out );
|
for(i=7; i>=0; i-- )
|
for(i=7; i>=0; i-- )
|
{
|
{
|
byte = (int)eprom_buff[(addr - offset) % EPROM_MAX];
|
byte = (int)eprom_buff[(addr - offset) % EPROM_MAX];
|
if(( byte & (1<<i)) == 0 )
|
if(( byte & (1<<i)) == 0 )
|
putc( '0', fp_out );
|
putc( '0', fp_out );
|
else
|
else
|
putc( '1', fp_out );
|
putc( '1', fp_out );
|
}
|
}
|
putc( '"', fp_out );
|
putc( '"', fp_out );
|
putc( ',', fp_out );
|
putc( ',', fp_out );
|
putc( '\n', fp_out );
|
putc( '\n', fp_out );
|
}
|
}
|
fclose( fp_out );
|
fclose( fp_out );
|
printf( "\nwritten successfully" );
|
printf( "\nwritten successfully" );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* save VHDL hexadecimal file
|
* save VHDL hexadecimal file
|
*/
|
*/
|
|
|
void save_vhdl_byte( char *fname_out, int start_addr, int end_addr )
|
void save_vhdl_byte( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int addr;
|
int addr;
|
int i,j;
|
int i,j;
|
int byte;
|
int byte;
|
|
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for write ", fname_out );
|
printf( "\nCan't open '%s' for write ", fname_out );
|
return;
|
return;
|
}
|
}
|
j=0;
|
j=0;
|
for( addr=start_addr; addr<=end_addr; addr+=32 )
|
for( addr=start_addr; addr<=end_addr; addr+=32 )
|
{
|
{
|
fprintf( fp_out, " INIT_%02x => x\"", j );
|
fprintf( fp_out, " INIT_%02x => x\"", j );
|
for(i=31; i>=0; i-- )
|
for(i=31; i>=0; i-- )
|
{
|
{
|
byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
}
|
}
|
fprintf( fp_out, "\",\n" );
|
fprintf( fp_out, "\",\n" );
|
j++;
|
j++;
|
}
|
}
|
fclose( fp_out );
|
fclose( fp_out );
|
printf( "\nwritten successfully" );
|
printf( "\nwritten successfully" );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* save VHDL hexadecimal Word file
|
* save VHDL hexadecimal Word file
|
*/
|
*/
|
|
|
void save_vhdl_word( char *fname_out, int start_addr, int end_addr )
|
void save_vhdl_word( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int addr;
|
int addr;
|
int i,j;
|
int i,j;
|
int byte;
|
int byte;
|
|
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
if( (fp_out = fopen( fname_out, "w" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for write ", fname_out );
|
printf( "\nCan't open '%s' for write ", fname_out );
|
return;
|
return;
|
}
|
}
|
j=0;
|
j=0;
|
for( addr=start_addr; addr<=end_addr; addr+=32 )
|
for( addr=start_addr; addr<=end_addr; addr+=32 )
|
{
|
{
|
fprintf( fp_out, " INIT_%02x => x\"" );
|
fprintf( fp_out, " INIT_%02x => x\"" );
|
for(i=30; i>=0; i-=2 )
|
for(i=30; i>=0; i-=2 )
|
{
|
{
|
/* MSByte first */
|
/* MSByte first */
|
byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
/* LSByte second */
|
/* LSByte second */
|
byte = (int)eprom_buff[(addr - offset + i + 1) % EPROM_MAX];
|
byte = (int)eprom_buff[(addr - offset + i + 1) % EPROM_MAX];
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[(byte >>4) & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
putc( hex_str[byte & 0xf], fp_out );
|
}
|
}
|
fprintf( fp_out, "\",\n" );
|
fprintf( fp_out, "\",\n" );
|
j++;
|
j++;
|
}
|
}
|
fclose( fp_out );
|
fclose( fp_out );
|
printf( "\nwritten successfully" );
|
printf( "\nwritten successfully" );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* save raw binary file
|
* save raw binary file
|
*/
|
*/
|
|
|
void save_binary( char *fname_out, int start_addr, int end_addr )
|
void save_binary( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int addr;
|
int addr;
|
|
|
if( (fp_out = fopen( fname_out, "wb" )) == NULL )
|
if( (fp_out = fopen( fname_out, "wb" )) == NULL )
|
{
|
{
|
printf( "\nCan't open '%s' for write ", fname_out );
|
printf( "\nCan't open '%s' for write ", fname_out );
|
return;
|
return;
|
}
|
}
|
for( addr=start_addr; addr<=end_addr; addr++ )
|
for( addr=start_addr; addr<=end_addr; addr++ )
|
{
|
{
|
putc( eprom_buff[(addr - offset) % EPROM_MAX ], fp_out );
|
putc( eprom_buff[(addr - offset) % EPROM_MAX ], fp_out );
|
}
|
}
|
fclose( fp_out );
|
fclose( fp_out );
|
printf( "\nwritten successfully" );
|
printf( "\nwritten successfully" );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Save Motorola S1 file
|
* Save Motorola S1 file
|
*/
|
*/
|
|
|
void save_mot( char *fname_out, int start_addr, int end_addr )
|
void save_mot( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int addr, start;
|
int addr, start;
|
int i;
|
int i;
|
int E_total;
|
int E_total;
|
int data_byte;
|
int data_byte;
|
|
|
fp_out = fopen( fname_out, "w" );
|
fp_out = fopen( fname_out, "w" );
|
if( !fp_out )
|
if( !fp_out )
|
{
|
{
|
printf( "\nCan't open %s for output", fname_out );
|
printf( "\nCan't open %s for output", fname_out );
|
return;
|
return;
|
}
|
}
|
|
|
addr = start_addr;
|
addr = start_addr;
|
while( addr <= end_addr)
|
while( addr <= end_addr)
|
{
|
{
|
if( (end_addr - addr + 1) > 0 )
|
if( (end_addr - addr + 1) > 0 )
|
E_total = 16;
|
E_total = 16;
|
else
|
else
|
E_total = end_addr - addr + 1;
|
E_total = end_addr - addr + 1;
|
fputc( 'S', fp_out); /* record header preamble */
|
fputc( 'S', fp_out); /* record header preamble */
|
fputc( '1', fp_out); /* record header preamble */
|
fputc( '1', fp_out); /* record header preamble */
|
checksum = 0;
|
checksum = 0;
|
put2hex( fp_out, E_total+3); /* byte count + 3 */
|
put2hex( fp_out, E_total+3); /* byte count + 3 */
|
put4hex( fp_out, addr); /* Program Counter */
|
put4hex( fp_out, addr); /* Program Counter */
|
for(i=0; i<E_total; i++)
|
for(i=0; i<E_total; i++)
|
{
|
{
|
data_byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
data_byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
|
put2hex( fp_out, data_byte);
|
put2hex( fp_out, data_byte);
|
}
|
}
|
checksum = ~checksum; /* one's complement */
|
checksum = ~checksum; /* one's complement */
|
put2hex( fp_out, (checksum & 0xff));
|
put2hex( fp_out, (checksum & 0xff));
|
fputc( '\n', fp_out); /* record header preamble */
|
fputc( '\n', fp_out); /* record header preamble */
|
addr += E_total;
|
addr += E_total;
|
}
|
}
|
checksum = 0;
|
checksum = 0;
|
fputc( 'S', fp_out); /* record header preamble */
|
fputc( 'S', fp_out); /* record header preamble */
|
fputc( '9', fp_out); /* record header preamble */
|
fputc( '9', fp_out); /* record header preamble */
|
put2hex( fp_out, 3); /* byte count + 3 */
|
put2hex( fp_out, 3); /* byte count + 3 */
|
put4hex( fp_out, 0); /* Program Counter */
|
put4hex( fp_out, 0); /* Program Counter */
|
put2hex( fp_out, 0xfc ); /* byte count + 3 */
|
put2hex( fp_out, 0xfc ); /* byte count + 3 */
|
fclose( fp_out );
|
fclose( fp_out );
|
}
|
}
|
|
|
/*
|
/*
|
* save Intelhex file
|
* save Intelhex file
|
*/
|
*/
|
|
|
void save_intel( char *fname_out, int start_addr, int end_addr )
|
void save_intel( char *fname_out, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_out;
|
FILE *fp_out;
|
int byte, addr, start, check, i;
|
int byte, addr, start, check, i;
|
|
|
fp_out = fopen( fname_out, "w" );
|
fp_out = fopen( fname_out, "w" );
|
if( fp_out == NULL )
|
if( fp_out == NULL )
|
{
|
{
|
printf( "\nCan't open %s for output", fname_out );
|
printf( "\nCan't open %s for output", fname_out );
|
return;
|
return;
|
}
|
}
|
|
|
addr = start_addr;
|
addr = start_addr;
|
start = addr;
|
start = addr;
|
while( addr <= end_addr )
|
while( addr <= end_addr )
|
{
|
{
|
check = 0;
|
check = 0;
|
count = 16;
|
count = 16;
|
fputc( ':', fp_out );
|
fputc( ':', fp_out );
|
put2hex( fp_out, count );
|
put2hex( fp_out, count );
|
check += count;
|
check += count;
|
put4hex( fp_out, addr );
|
put4hex( fp_out, addr );
|
check += (addr & 0xff);
|
check += (addr & 0xff);
|
check += ((addr>>8) & 0xff);
|
check += ((addr>>8) & 0xff);
|
put2hex( fp_out, 0 );
|
put2hex( fp_out, 0 );
|
check += 0;
|
check += 0;
|
for( i=0; i<count; i++ )
|
for( i=0; i<count; i++ )
|
{
|
{
|
byte = (int)eprom_buff[ (addr - offset) % EPROM_MAX ];
|
byte = (int)eprom_buff[ (addr - offset) % EPROM_MAX ];
|
if( addr == 0xfffe )
|
if( addr == 0xfffe )
|
start = byte * 256 ;
|
start = byte * 256 ;
|
if( addr == 0xffff )
|
if( addr == 0xffff )
|
start += byte;
|
start += byte;
|
put2hex( fp_out, byte );
|
put2hex( fp_out, byte );
|
check += byte;
|
check += byte;
|
addr ++;
|
addr ++;
|
}
|
}
|
check = (0-check) & 0xff;
|
check = (0-check) & 0xff;
|
put2hex( fp_out, check);
|
put2hex( fp_out, check);
|
fputc( '\n', fp_out );
|
fputc( '\n', fp_out );
|
}
|
}
|
fputc( ':', fp_out );
|
fputc( ':', fp_out );
|
put2hex( fp_out, 0 );
|
put2hex( fp_out, 0 );
|
put4hex( fp_out, start );
|
put4hex( fp_out, start );
|
put2hex( fp_out, 1 );
|
put2hex( fp_out, 1 );
|
close( fp_out );
|
close( fp_out );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Compare Raw binary file
|
* Compare Raw binary file
|
*/
|
*/
|
|
|
void compare_binary( char *fname_in, int load_addr, int start_addr, int end_addr)
|
void compare_binary( char *fname_in, int load_addr, int start_addr, int end_addr)
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int addr;
|
int addr;
|
int data_byte;
|
int data_byte;
|
int diff_count;
|
int diff_count;
|
|
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
if( (fp_in = fopen( fname_in, "r" )) == NULL )
|
{
|
{
|
printf( "\ncant open %s for read", fname_in );
|
printf( "\ncant open %s for read", fname_in );
|
return;
|
return;
|
} else
|
} else
|
{
|
{
|
diff_count = 0;
|
diff_count = 0;
|
addr = load_addr;
|
addr = load_addr;
|
while( (data_byte = fgetc( fp_in )) != EOF )
|
while( (data_byte = fgetc( fp_in )) != EOF )
|
{
|
{
|
if( (addr >= start_addr) && (addr <= end_addr) )
|
if( (addr >= start_addr) && (addr <= end_addr) )
|
{
|
{
|
if( (unsigned char)data_byte != eprom_buff[(addr -offset) % EPROM_MAX] )
|
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 );
|
printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX ], data_byte );
|
diff_count++;
|
diff_count++;
|
}
|
}
|
}
|
}
|
addr++;
|
addr++;
|
}
|
}
|
printf( "\nLast compared address %x ", addr-1 );
|
printf( "\nLast compared address %x ", addr-1 );
|
printf( "\nThere were %d differences ", diff_count );
|
printf( "\nThere were %d differences ", diff_count );
|
fclose( fp_in );
|
fclose( fp_in );
|
}
|
}
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Compare motorola formatted file
|
* Compare motorola formatted file
|
*/
|
*/
|
|
|
void compare_mot( char *fname_in, int start_addr, int end_addr )
|
void compare_mot( char *fname_in, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte, addr, start, check, i;
|
int byte, addr, start, check, i;
|
int diff_count;
|
int diff_count;
|
|
|
fp_in = fopen( fname_in, "r" );
|
fp_in = fopen( fname_in, "r" );
|
if( !fp_in )
|
if( !fp_in )
|
{
|
{
|
printf( "\nCan't open %s", fname_in );
|
printf( "\nCan't open %s", fname_in );
|
return;
|
return;
|
}
|
}
|
|
|
byte = 0;
|
byte = 0;
|
addr = start;
|
addr = start;
|
diff_count = 0;
|
diff_count = 0;
|
|
|
while( byte != -1 )
|
while( byte != -1 )
|
{
|
{
|
do {
|
do {
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
} while( (byte != 'S') && (byte != -1) );
|
} while( (byte != 'S') && (byte != -1) );
|
|
|
byte = fgetc( fp_in );
|
byte = fgetc( fp_in );
|
checksum = 0;
|
checksum = 0;
|
if( (byte == '1') || (byte == '2') )
|
if( (byte == '1') || (byte == '2') )
|
{
|
{
|
count = get2hex( fp_in );
|
count = get2hex( fp_in );
|
if( byte == '1' )
|
if( byte == '1' )
|
addr = get4hex( fp_in );
|
addr = get4hex( fp_in );
|
else
|
else
|
addr = get6hex( fp_in );
|
addr = get6hex( fp_in );
|
count -= 3;
|
count -= 3;
|
for( i=0; i<count; i++ )
|
for( i=0; i<count; i++ )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
if( (addr >= start_addr) && (addr <= end_addr ))
|
if( (addr >= start_addr) && (addr <= end_addr ))
|
{
|
{
|
if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX ] )
|
if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX ] )
|
{
|
{
|
printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX ], byte );
|
printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX ], byte );
|
diff_count++;
|
diff_count++;
|
}
|
}
|
}
|
}
|
addr++;
|
addr++;
|
}
|
}
|
byte = get2hex( fp_in);
|
byte = get2hex( fp_in);
|
if( addr >= EPROM_MAX )
|
if( addr >= EPROM_MAX )
|
byte = -1;
|
byte = -1;
|
}
|
}
|
}
|
}
|
close( fp_in );
|
close( fp_in );
|
printf( "\nLast compared address %x ", addr - 1 );
|
printf( "\nLast compared address %x ", addr - 1 );
|
printf( "\nThere were %d differences ", diff_count );
|
printf( "\nThere were %d differences ", diff_count );
|
}
|
}
|
|
|
/*
|
/*
|
* Load Intel hex file
|
* Load Intel hex file
|
*/
|
*/
|
|
|
void compare_intel( char *fname_in, int start_addr, int end_addr )
|
void compare_intel( char *fname_in, int start_addr, int end_addr )
|
{
|
{
|
FILE *fp_in;
|
FILE *fp_in;
|
int byte, addr, start, i;
|
int byte, addr, start, i;
|
int diff_count;
|
int diff_count;
|
|
|
fp_in = fopen( fname_in, "r" );
|
fp_in = fopen( fname_in, "r" );
|
if( !fp_in )
|
if( !fp_in )
|
{
|
{
|
printf( "\nCan't open %s for input", fname_in );
|
printf( "\nCan't open %s for input", fname_in );
|
return;
|
return;
|
}
|
}
|
|
|
byte = 0;
|
byte = 0;
|
diff_count = 0;
|
diff_count = 0;
|
while( byte != -1)
|
while( byte != -1)
|
{
|
{
|
do {
|
do {
|
byte = fgetc( fp_in);
|
byte = fgetc( fp_in);
|
} while( (byte != ':') && (byte != -1) );
|
} while( (byte != ':') && (byte != -1) );
|
|
|
checksum = 0;
|
checksum = 0;
|
count = get2hex( fp_in );
|
count = get2hex( fp_in );
|
addr = get4hex( fp_in );
|
addr = get4hex( fp_in );
|
i = get2hex( fp_in ); /* read 00 to load a record */
|
i = get2hex( fp_in ); /* read 00 to load a record */
|
if( i == 0 ) /* read 01 to end record */
|
if( i == 0 ) /* read 01 to end record */
|
{
|
{
|
for( i=0; i<count; i++ )
|
for( i=0; i<count; i++ )
|
{
|
{
|
byte = get2hex( fp_in );
|
byte = get2hex( fp_in );
|
if( (addr >= start_addr) && (addr <= end_addr ))
|
if( (addr >= start_addr) && (addr <= end_addr ))
|
{
|
{
|
if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX] )
|
if( (unsigned char)byte != eprom_buff[(addr - offset) % EPROM_MAX] )
|
{
|
{
|
printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX], byte );
|
printf( "\n%04x %02x %02x", addr, eprom_buff[(addr-offset) % EPROM_MAX], byte );
|
diff_count++;
|
diff_count++;
|
}
|
}
|
}
|
}
|
addr++;
|
addr++;
|
}
|
}
|
byte = get2hex( fp_in);
|
byte = get2hex( fp_in);
|
if( checksum != 0 )
|
if( checksum != 0 )
|
{
|
{
|
printf( "\nchecksum error detected, read %02x, expected %02x", byte, ((checksum - byte) & 0xff) );
|
printf( "\nchecksum error detected, read %02x, expected %02x", byte, ((checksum - byte) & 0xff) );
|
byte = -1;
|
byte = -1;
|
} else if( addr >= EPROM_MAX )
|
} else if( addr >= EPROM_MAX )
|
byte = -1;
|
byte = -1;
|
} else if( i == 1 ) /* test for end of record */
|
} else if( i == 1 ) /* test for end of record */
|
byte = -1;
|
byte = -1;
|
}
|
}
|
close( fp_in );
|
close( fp_in );
|
printf( "\nLast compared address %x ", addr - 1 );
|
printf( "\nLast compared address %x ", addr - 1 );
|
printf( "\nThere were %d differences ", diff_count );
|
printf( "\nThere were %d differences ", diff_count );
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* help menu
|
* help menu
|
*/
|
*/
|
void display_help()
|
void display_help()
|
{
|
{
|
printf( "\n*** Help Menu ***\n\n");
|
printf( "\n*** Help Menu ***\n\n");
|
printf( "All addresses are in hexadecimal\n" );
|
printf( "All addresses are in hexadecimal\n" );
|
printf( "H/?/help - This help menu\n" );
|
printf( "H/?/help - This help menu\n" );
|
printf( "T/type - Set Load & Save format\n" );
|
printf( "T/type - Set Load & Save format\n" );
|
printf( " <I/intel>\n");
|
printf( " <I/intel>\n");
|
printf( " <M/motorola>\n");
|
printf( " <M/motorola>\n");
|
printf( " <B/binary>\n" );
|
printf( " <B/binary>\n" );
|
printf( " <O/Smal32>\n" );
|
printf( " <O/Smal32>\n" );
|
printf( " <V/vhdl> VHDL Binary String \n" );
|
printf( " <V/vhdl> VHDL Binary String \n" );
|
printf( " <H/hex> VHDL Hexadecimal Byte String\n" );
|
printf( " <H/hex> VHDL Hexadecimal Byte String\n" );
|
printf( " <W/word> VHDL Hexadecimal Word String\n" );
|
printf( " <W/word> VHDL Hexadecimal Word String\n" );
|
printf( "O/offset <address> - Set Eprom buffer offset\n" );
|
printf( "O/offset <address> - Set Eprom buffer offset\n" );
|
printf( "L/load <filename> [<load_addr>] - Loads file into buffer\n" );
|
printf( "L/load <filename> [<load_addr>] - Loads file into buffer\n" );
|
printf( "S/save <filename> <start-address> <end-address> - Saves buffer to file\n" );
|
printf( "S/save <filename> <start-address> <end-address> - Saves buffer to file\n" );
|
printf( "C/compare <filename> [<load_addr>] - compare file to buffer\n" );
|
printf( "C/compare <filename> [<load_addr>] - compare file to buffer\n" );
|
/*
|
/*
|
printf( "R/read <address> - reads buffer data\n" );
|
printf( "R/read <address> - reads buffer data\n" );
|
*/
|
*/
|
printf( "W/write <address> <data> .... <data> - Write data to buffer\n" );
|
printf( "W/write <address> <data> .... <data> - Write data to buffer\n" );
|
printf( "F/fill <start-address> <end-address> <data> - fill buffer with data\n");
|
printf( "F/fill <start-address> <end-address> <data> - fill buffer with data\n");
|
printf( "M/move <start-address> <end-address> <dest-address> - block move\n" );
|
printf( "M/move <start-address> <end-address> <dest-address> - block move\n" );
|
printf( "D/dump <start_address> <end-address> - Hex buffer dump\n");
|
printf( "D/dump <start_address> <end-address> - Hex buffer dump\n");
|
printf( "E/echo <string> - echo string to console\n" );
|
printf( "E/echo <string> - echo string to console\n" );
|
printf( "X/excecute <command-file> - execute a command script\n");
|
printf( "X/excecute <command-file> - execute a command script\n");
|
printf( "Q/quit - quit program\n" );
|
printf( "Q/quit - quit program\n" );
|
}
|
}
|
|
|
/*
|
/*
|
* Parse command
|
* Parse command
|
* Return FALSE to exit
|
* Return FALSE to exit
|
*/
|
*/
|
int parse_command( char *cmdline )
|
int parse_command( char *cmdline )
|
{
|
{
|
int lineptr;
|
int lineptr;
|
char *cmdptr;
|
char *cmdptr;
|
int arglen;
|
int arglen;
|
FILE *fp;
|
FILE *fp;
|
char filename[64];
|
char filename[64];
|
int start_addr;
|
int start_addr;
|
int end_addr;
|
int end_addr;
|
int dest_addr;
|
int dest_addr;
|
int load_addr;
|
int load_addr;
|
int byte_count;
|
int byte_count;
|
int data_byte;
|
int data_byte;
|
int ch;
|
int ch;
|
int len;
|
int len;
|
|
|
lineptr = 0;
|
lineptr = 0;
|
start_addr = 0;
|
start_addr = 0;
|
end_addr = 0;
|
end_addr = 0;
|
|
|
/* skip leading white spaces */
|
/* skip leading white spaces */
|
while( isspace( cmdline[lineptr] ))
|
while( isspace( cmdline[lineptr] ))
|
lineptr++;
|
lineptr++;
|
/* point to the start of the command argument & extract command */
|
/* point to the start of the command argument & extract command */
|
cmdptr = &cmdline[lineptr];
|
cmdptr = &cmdline[lineptr];
|
len = 0;
|
len = 0;
|
while( isalpha( cmdline[lineptr] ) ||
|
while( isalpha( cmdline[lineptr] ) ||
|
(cmdline[lineptr] == '?'))
|
(cmdline[lineptr] == '?'))
|
{
|
{
|
lineptr++;
|
lineptr++;
|
len++;
|
len++;
|
}
|
}
|
/* skip trailing white spaces */
|
/* skip trailing white spaces */
|
while( isspace( cmdline[lineptr] ) )
|
while( isspace( cmdline[lineptr] ) )
|
lineptr++;
|
lineptr++;
|
if( len > 0 )
|
if( len > 0 )
|
{
|
{
|
|
|
if( str_equal( cmdptr, "T", len ) ||
|
if( str_equal( cmdptr, "T", len ) ||
|
str_equal( cmdptr, "type", len ) )
|
str_equal( cmdptr, "type", len ) )
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Specify file I/O format type
|
* Specify file I/O format type
|
*/
|
*/
|
cmdptr = &cmdline[lineptr];
|
cmdptr = &cmdline[lineptr];
|
len = 0;
|
len = 0;
|
while( isalpha( cmdline[lineptr] ))
|
while( isalpha( cmdline[lineptr] ))
|
{
|
{
|
lineptr++;
|
lineptr++;
|
len++;
|
len++;
|
}
|
}
|
if( len != 0 )
|
if( len != 0 )
|
{
|
{
|
if( str_equal( cmdptr, "B", len ) )
|
if( str_equal( cmdptr, "B", len ) )
|
format_type = BINARY;
|
format_type = BINARY;
|
else if( str_equal( cmdptr, "binary", len ) )
|
else if( str_equal( cmdptr, "binary", len ) )
|
format_type = BINARY;
|
format_type = BINARY;
|
else if( str_equal( cmdptr, "M", len ) )
|
else if( str_equal( cmdptr, "M", len ) )
|
format_type = MOTOROLA;
|
format_type = MOTOROLA;
|
else if( str_equal( cmdptr, "motorola", len ) )
|
else if( str_equal( cmdptr, "motorola", len ) )
|
format_type = MOTOROLA;
|
format_type = MOTOROLA;
|
else if( str_equal( cmdptr, "I", len ) )
|
else if( str_equal( cmdptr, "I", len ) )
|
format_type = INTEL;
|
format_type = INTEL;
|
else if( str_equal( cmdptr, "intel", len ) )
|
else if( str_equal( cmdptr, "intel", len ) )
|
format_type = INTEL;
|
format_type = INTEL;
|
else if( str_equal( cmdptr, "O", len ) )
|
else if( str_equal( cmdptr, "O", len ) )
|
format_type = SMAL32;
|
format_type = SMAL32;
|
else if( str_equal( cmdptr, "smal", len ) )
|
else if( str_equal( cmdptr, "smal", len ) )
|
format_type = SMAL32;
|
format_type = SMAL32;
|
else if( str_equal( cmdptr, "V", len ) )
|
else if( str_equal( cmdptr, "V", len ) )
|
format_type = VHDL_BIN;
|
format_type = VHDL_BIN;
|
else if( str_equal( cmdptr, "vhdl", len ) )
|
else if( str_equal( cmdptr, "vhdl", len ) )
|
format_type = VHDL_BIN;
|
format_type = VHDL_BIN;
|
else if( str_equal( cmdptr, "H", len ) )
|
else if( str_equal( cmdptr, "H", len ) )
|
format_type = VHDL_BYTE;
|
format_type = VHDL_BYTE;
|
else if( str_equal( cmdptr, "hex", len ) )
|
else if( str_equal( cmdptr, "hex", len ) )
|
format_type = VHDL_BYTE;
|
format_type = VHDL_BYTE;
|
else if( str_equal( cmdptr, "W", len ) )
|
else if( str_equal( cmdptr, "W", len ) )
|
format_type = VHDL_WORD;
|
format_type = VHDL_WORD;
|
else if( str_equal( cmdptr, "word", len ) )
|
else if( str_equal( cmdptr, "word", len ) )
|
format_type = VHDL_WORD;
|
format_type = VHDL_WORD;
|
else printf( "\nUnrecognised file format" );
|
else printf( "\nUnrecognised file format" );
|
}
|
}
|
printf( "\nFile format type is : " );
|
printf( "\nFile format type is : " );
|
switch( format_type ) {
|
switch( format_type ) {
|
case BINARY:
|
case BINARY:
|
printf( "Raw Binary" );
|
printf( "Raw Binary" );
|
break;
|
break;
|
case MOTOROLA:
|
case MOTOROLA:
|
printf( "Motorola S1" );
|
printf( "Motorola S1" );
|
break;
|
break;
|
case INTEL:
|
case INTEL:
|
printf( "Intel Hex" );
|
printf( "Intel Hex" );
|
break;
|
break;
|
case SMAL32:
|
case SMAL32:
|
printf( "Smal32 .o" );
|
printf( "Smal32 .o" );
|
break;
|
break;
|
case VHDL_BIN:
|
case VHDL_BIN:
|
printf( "vhdl binary" );
|
printf( "vhdl binary" );
|
break;
|
break;
|
case VHDL_BYTE:
|
case VHDL_BYTE:
|
printf( "vhdl hexadecimal byte" );
|
printf( "vhdl hexadecimal byte" );
|
break;
|
break;
|
case VHDL_WORD:
|
case VHDL_WORD:
|
printf( "vhdl hexadecimal word" );
|
printf( "vhdl hexadecimal word" );
|
break;
|
break;
|
default:
|
default:
|
printf( "Bad format - should not get here" );
|
printf( "Bad format - should not get here" );
|
break;
|
break;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
else if( str_equal( cmdptr, "L", len ) ||
|
else if( str_equal( cmdptr, "L", len ) ||
|
str_equal( cmdptr, "load", len ) )
|
str_equal( cmdptr, "load", len ) )
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Load file into buffer
|
* Load file into buffer
|
*/
|
*/
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
if( arglen == 0 )
|
if( arglen == 0 )
|
{
|
{
|
printf( "\nFile name expected " );
|
printf( "\nFile name expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
arglen = get_address( &cmdline[lineptr], &load_addr );
|
arglen = get_address( &cmdline[lineptr], &load_addr );
|
if( arglen == 0 )
|
if( arglen == 0 )
|
{
|
{
|
/* default binary load address = start of eprom */
|
/* default binary load address = start of eprom */
|
load_addr = offset;
|
load_addr = offset;
|
|
|
}
|
}
|
if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
|
if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nLoad address out of range" );
|
printf( "\nLoad address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
switch( format_type ) {
|
switch( format_type ) {
|
case BINARY:
|
case BINARY:
|
printf( "\nLoading binary file" );
|
printf( "\nLoading binary file" );
|
load_binary( filename, load_addr );
|
load_binary( filename, load_addr );
|
break;
|
break;
|
case MOTOROLA:
|
case MOTOROLA:
|
printf( "\nLoading Motorola S1 file" );
|
printf( "\nLoading Motorola S1 file" );
|
load_mot( filename );
|
load_mot( filename );
|
break;
|
break;
|
case INTEL:
|
case INTEL:
|
printf( "\nLoading intel hex file" );
|
printf( "\nLoading intel hex file" );
|
load_intel( filename );
|
load_intel( filename );
|
break;
|
break;
|
case SMAL32:
|
case SMAL32:
|
printf( "\nLoading Smal32 file" );
|
printf( "\nLoading Smal32 file" );
|
load_smal32( filename );
|
load_smal32( filename );
|
break;
|
break;
|
case VHDL_BIN:
|
case VHDL_BIN:
|
printf( "\nLoading VHDL binary format" );
|
printf( "\nLoading VHDL binary format" );
|
load_vhdl_bin( filename, load_addr );
|
load_vhdl_bin( filename, load_addr );
|
break;
|
break;
|
case VHDL_BYTE:
|
case VHDL_BYTE:
|
printf( "\nLoading VHDL hexadecimal byte format" );
|
printf( "\nLoading VHDL hexadecimal byte format" );
|
load_vhdl_byte( filename, load_addr );
|
load_vhdl_byte( filename, load_addr );
|
break;
|
break;
|
case VHDL_WORD:
|
case VHDL_WORD:
|
printf( "\nLoading VHDL hexadecimal word format" );
|
printf( "\nLoading VHDL hexadecimal word format" );
|
load_vhdl_word( filename, load_addr );
|
load_vhdl_word( filename, load_addr );
|
break;
|
break;
|
default:
|
default:
|
printf( "\nBad format - no load" );
|
printf( "\nBad format - no load" );
|
break;
|
break;
|
}
|
}
|
mod_flag = TRUE;
|
mod_flag = TRUE;
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "S", len ) ||
|
} else if( str_equal( cmdptr, "S", len ) ||
|
str_equal( cmdptr, "save", len ))
|
str_equal( cmdptr, "save", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Save buffer to file
|
* Save buffer to file
|
*
|
*
|
***********************************************************/
|
***********************************************************/
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
if( arglen == 0 )
|
if( arglen == 0 )
|
{
|
{
|
printf( "\nFile name expected " );
|
printf( "\nFile name expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
arglen = get_address( &cmdline[lineptr], &start_addr );
|
arglen = get_address( &cmdline[lineptr], &start_addr );
|
if( arglen == 0 )
|
if( arglen == 0 )
|
{
|
{
|
/* this could default to 0 */
|
/* this could default to 0 */
|
printf( "\nStart address expected " );
|
printf( "\nStart address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
{
|
{
|
/* this could default to eprom_top */
|
/* this could default to eprom_top */
|
printf( "\nEnd address expected " );
|
printf( "\nEnd address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nEnd address out of range" );
|
printf( "\nEnd address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
printf( "\nSaving buffer %x to %x to file %s ", start_addr, end_addr, filename );
|
printf( "\nSaving buffer %x to %x to file %s ", start_addr, end_addr, filename );
|
switch( format_type ) {
|
switch( format_type ) {
|
case BINARY:
|
case BINARY:
|
printf( "\nBinary format" );
|
printf( "\nBinary format" );
|
save_binary( filename, start_addr, end_addr );
|
save_binary( filename, start_addr, end_addr );
|
break;
|
break;
|
case MOTOROLA:
|
case MOTOROLA:
|
printf( "\nMotorola S1 format" );
|
printf( "\nMotorola S1 format" );
|
save_mot( filename, start_addr, end_addr );
|
save_mot( filename, start_addr, end_addr );
|
break;
|
break;
|
case INTEL:
|
case INTEL:
|
printf( "\nIntel hex format" );
|
printf( "\nIntel hex format" );
|
save_intel( filename, start_addr, end_addr );
|
save_intel( filename, start_addr, end_addr );
|
break;
|
break;
|
case VHDL_BIN:
|
case VHDL_BIN:
|
printf( "\nVHDL binary format" );
|
printf( "\nVHDL binary format" );
|
save_vhdl_bin( filename, start_addr, end_addr );
|
save_vhdl_bin( filename, start_addr, end_addr );
|
break;
|
break;
|
case VHDL_BYTE:
|
case VHDL_BYTE:
|
printf( "\nVHDL hexadecimal byte format" );
|
printf( "\nVHDL hexadecimal byte format" );
|
save_vhdl_byte( filename, start_addr, end_addr );
|
save_vhdl_byte( filename, start_addr, end_addr );
|
break;
|
break;
|
case VHDL_WORD:
|
case VHDL_WORD:
|
printf( "\nVHDL hexadecimal word format" );
|
printf( "\nVHDL hexadecimal word format" );
|
save_vhdl_word( filename, start_addr, end_addr );
|
save_vhdl_word( filename, start_addr, end_addr );
|
break;
|
break;
|
default:
|
default:
|
printf( "\nBad format - no save performed" );
|
printf( "\nBad format - no save performed" );
|
break;
|
break;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "D", len ) ||
|
} else if( str_equal( cmdptr, "D", len ) ||
|
str_equal( cmdptr, "dump", len ))
|
str_equal( cmdptr, "dump", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* dump buffer to the display
|
* dump buffer to the display
|
*/
|
*/
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
printf( "\nStart address expected " );
|
printf( "\nStart address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
{
|
{
|
printf( "\nEnd address expected " );
|
printf( "\nEnd address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nEnd address out of range" );
|
printf( "\nEnd address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
load_addr = 0;
|
load_addr = 0;
|
printf( "\n Memory Dump form %x to %x ", start_addr, end_addr );
|
printf( "\n Memory Dump form %x to %x ", start_addr, end_addr );
|
while( (start_addr + load_addr) <= end_addr )
|
while( (start_addr + load_addr) <= end_addr )
|
{
|
{
|
printf( "\n %04x - ", start_addr + load_addr );
|
printf( "\n %04x - ", start_addr + load_addr );
|
for( dest_addr = 0; dest_addr < 16; dest_addr++ )
|
for( dest_addr = 0; dest_addr < 16; dest_addr++ )
|
{
|
{
|
if( (start_addr + load_addr + dest_addr) <= end_addr )
|
if( (start_addr + load_addr + dest_addr) <= end_addr )
|
printf( "%02x ", eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX] );
|
printf( "%02x ", eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX] );
|
else
|
else
|
printf( " " );
|
printf( " " );
|
}
|
}
|
printf( " " );
|
printf( " " );
|
for( dest_addr = 0; dest_addr < 16; dest_addr++ )
|
for( dest_addr = 0; dest_addr < 16; dest_addr++ )
|
{
|
{
|
if( (start_addr + load_addr + dest_addr) <= end_addr )
|
if( (start_addr + load_addr + dest_addr) <= end_addr )
|
{
|
{
|
ch = eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX];
|
ch = eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX];
|
if( (ch > 0x20) && (ch < 0x7f) )
|
if( (ch > 0x20) && (ch < 0x7f) )
|
printf( "%c", ch );
|
printf( "%c", ch );
|
else
|
else
|
printf( "." );
|
printf( "." );
|
} else
|
} else
|
printf( " " );
|
printf( " " );
|
}
|
}
|
load_addr += dest_addr;
|
load_addr += dest_addr;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "C", len ) ||
|
} else if( str_equal( cmdptr, "C", len ) ||
|
str_equal( cmdptr, "compare", len ))
|
str_equal( cmdptr, "compare", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* compare file with buffer
|
* compare file with buffer
|
*
|
*
|
***********************************************************/
|
***********************************************************/
|
if( (arglen = get_filename( &cmdline[lineptr], &filename[0] )) == 0 )
|
if( (arglen = get_filename( &cmdline[lineptr], &filename[0] )) == 0 )
|
{
|
{
|
printf( "\nFile name expected " );
|
printf( "\nFile name expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
/* start/load address is optional - default to start of eprom */
|
/* start/load address is optional - default to start of eprom */
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
start_addr = offset;
|
start_addr = offset;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
|
|
/* the end/start address is optional */
|
/* the end/start address is optional */
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0 )
|
{
|
{
|
end_addr = EPROM_MAX + offset - 1;
|
end_addr = EPROM_MAX + offset - 1;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
|
|
/* the end/start address is optional */
|
/* the end/start address is optional */
|
if( (arglen = get_address( &cmdline[lineptr], &load_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &load_addr )) == 0 )
|
{
|
{
|
load_addr = EPROM_MAX + offset - 1;
|
load_addr = EPROM_MAX + offset - 1;
|
}
|
}
|
|
|
/* check for valid address range */
|
/* check for valid address range */
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nEnd address out of range" );
|
printf( "\nEnd address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
|
if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nLoad address out of range" );
|
printf( "\nLoad address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
printf( "\nComparing buffer to file %s", filename );
|
printf( "\nComparing buffer to file %s", filename );
|
switch( format_type ) {
|
switch( format_type ) {
|
case BINARY:
|
case BINARY:
|
printf( "\nBinary format" );
|
printf( "\nBinary format" );
|
dest_addr = load_addr;
|
dest_addr = load_addr;
|
load_addr = start_addr;
|
load_addr = start_addr;
|
start_addr = end_addr;
|
start_addr = end_addr;
|
end_addr = dest_addr;
|
end_addr = dest_addr;
|
if( start_addr == (EPROM_MAX + offset - 1) )
|
if( start_addr == (EPROM_MAX + offset - 1) )
|
start_addr = offset;
|
start_addr = offset;
|
compare_binary( filename, load_addr, start_addr, end_addr );
|
compare_binary( filename, load_addr, start_addr, end_addr );
|
break;
|
break;
|
case MOTOROLA:
|
case MOTOROLA:
|
printf( "\nMotorola S1 format" );
|
printf( "\nMotorola S1 format" );
|
compare_mot( filename, start_addr, end_addr );
|
compare_mot( filename, start_addr, end_addr );
|
break;
|
break;
|
case INTEL:
|
case INTEL:
|
printf( "\nIntel hex format" );
|
printf( "\nIntel hex format" );
|
compare_intel( filename, start_addr, end_addr );
|
compare_intel( filename, start_addr, end_addr );
|
break;
|
break;
|
default:
|
default:
|
printf( "\nBad format - no save performed" );
|
printf( "\nBad format - no save performed" );
|
break;
|
break;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "M", len ) ||
|
} else if( str_equal( cmdptr, "M", len ) ||
|
str_equal( cmdptr, "move", len ))
|
str_equal( cmdptr, "move", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* memory block move
|
* memory block move
|
*/
|
*/
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
printf( "\nStart address expected " );
|
printf( "\nStart address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
{
|
{
|
printf( "\nEnd address expected " );
|
printf( "\nEnd address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &dest_addr )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &dest_addr )) == 0)
|
{
|
{
|
printf( "\nDestination address expected " );
|
printf( "\nDestination address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
/* check that the range is around the right way */
|
/* check that the range is around the right way */
|
if( end_addr < start_addr )
|
if( end_addr < start_addr )
|
{
|
{
|
load_addr = start_addr;
|
load_addr = start_addr;
|
start_addr = end_addr;
|
start_addr = end_addr;
|
end_addr = load_addr;
|
end_addr = load_addr;
|
}
|
}
|
/* check for valid address range */
|
/* check for valid address range */
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nEnd address out of range" );
|
printf( "\nEnd address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (dest_addr < offset) || (dest_addr >= (offset + EPROM_MAX)))
|
if( (dest_addr < offset) || (dest_addr >= (offset + EPROM_MAX)))
|
|
|
{
|
{
|
printf( "\nDestination address out of range" );
|
printf( "\nDestination address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
byte_count = end_addr - start_addr;
|
byte_count = end_addr - start_addr;
|
printf( "\nTransfering memory block %04x thru %04x to %04x", start_addr, end_addr, dest_addr );
|
printf( "\nTransfering memory block %04x thru %04x to %04x", start_addr, end_addr, dest_addr );
|
if( start_addr > dest_addr )
|
if( start_addr > dest_addr )
|
{
|
{
|
for( load_addr=0; load_addr<=byte_count; load_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];
|
eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX];
|
} else
|
} else
|
{
|
{
|
for( load_addr=byte_count; load_addr>=0; load_addr-- )
|
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];
|
eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX];
|
}
|
}
|
printf( "\nDone" );
|
printf( "\nDone" );
|
mod_flag = TRUE;
|
mod_flag = TRUE;
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "F", len ) ||
|
} else if( str_equal( cmdptr, "F", len ) ||
|
str_equal( cmdptr, "fill", len ))
|
str_equal( cmdptr, "fill", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* fill memory with data
|
* fill memory with data
|
*/
|
*/
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
printf( "\nStart address expected " );
|
printf( "\nStart address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
|
{
|
{
|
printf( "\nEnd address expected " );
|
printf( "\nEnd address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
if( (arglen = get_address( &cmdline[lineptr], &data_byte )) == 0)
|
if( (arglen = get_address( &cmdline[lineptr], &data_byte )) == 0)
|
{
|
{
|
printf( "\nFill data byte expected " );
|
printf( "\nFill data byte expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nEnd address out of range" );
|
printf( "\nEnd address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
printf( "\nFilling address %x thru %x with %x ", start_addr, end_addr, data_byte );
|
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++ )
|
for( dest_addr=start_addr; dest_addr<=end_addr; dest_addr++ )
|
eprom_buff[(dest_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
|
eprom_buff[(dest_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
|
printf( "\nDone" );
|
printf( "\nDone" );
|
mod_flag = TRUE;
|
mod_flag = TRUE;
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "W", len ) ||
|
} else if( str_equal( cmdptr, "W", len ) ||
|
str_equal( cmdptr, "write", len ))
|
str_equal( cmdptr, "write", len ))
|
|
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Write to buffer location
|
* Write to buffer location
|
*/
|
*/
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
printf( "\nStart address expected " );
|
printf( "\nStart address expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
lineptr += arglen;
|
lineptr += arglen;
|
/* check for valid address range */
|
/* check for valid address range */
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
|
{
|
{
|
printf( "\nStart address out of range" );
|
printf( "\nStart address out of range" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
printf( "\nSetting buffer loaction %x", start_addr );
|
printf( "\nSetting buffer loaction %x", start_addr );
|
while( (arglen = get_address( &cmdline[lineptr], &data_byte )) != 0)
|
while( (arglen = get_address( &cmdline[lineptr], &data_byte )) != 0)
|
{
|
{
|
eprom_buff[(start_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
|
eprom_buff[(start_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
|
printf( "\n %04x = %02x ", start_addr, data_byte );
|
printf( "\n %04x = %02x ", start_addr, data_byte );
|
start_addr++;
|
start_addr++;
|
lineptr += arglen;
|
lineptr += arglen;
|
}
|
}
|
mod_flag = TRUE;
|
mod_flag = TRUE;
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "O", len ) ||
|
} else if( str_equal( cmdptr, "O", len ) ||
|
str_equal( cmdptr, "offset", len ))
|
str_equal( cmdptr, "offset", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Set Eprom base address offset
|
* Set Eprom base address offset
|
*/
|
*/
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
|
{
|
{
|
/* No argument, display offset */
|
/* No argument, display offset */
|
printf( "\nBase address offset = %04x", offset );
|
printf( "\nBase address offset = %04x", offset );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
offset = start_addr;
|
offset = start_addr;
|
mod_flag = TRUE;
|
mod_flag = TRUE;
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "H", len ) ||
|
} else if( str_equal( cmdptr, "H", len ) ||
|
str_equal( cmdptr, "?", len ) ||
|
str_equal( cmdptr, "?", len ) ||
|
str_equal( cmdptr, "help", len ))
|
str_equal( cmdptr, "help", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Display help menu
|
* Display help menu
|
*/
|
*/
|
display_help();
|
display_help();
|
return TRUE;
|
return TRUE;
|
} else if( str_equal( cmdptr, "Q", len ) ||
|
} else if( str_equal( cmdptr, "Q", len ) ||
|
str_equal( cmdptr, "quit", len ))
|
str_equal( cmdptr, "quit", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Quit program - return FALSE
|
* Quit program - return FALSE
|
*/
|
*/
|
printf( "\nQuitting program" );
|
printf( "\nQuitting program" );
|
return FALSE;
|
return FALSE;
|
} else if( str_equal( cmdptr, "E", len ) ||
|
} else if( str_equal( cmdptr, "E", len ) ||
|
str_equal( cmdptr, "echo", len ))
|
str_equal( cmdptr, "echo", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Echo string to the console
|
* Echo string to the console
|
*/
|
*/
|
printf( "\n" );
|
printf( "\n" );
|
while( (cmdline[lineptr] != '\0') && (cmdline[lineptr] != '\n'))
|
while( (cmdline[lineptr] != '\0') && (cmdline[lineptr] != '\n'))
|
printf( "%c", cmdline[lineptr++] );
|
printf( "%c", cmdline[lineptr++] );
|
printf( "\n" );
|
printf( "\n" );
|
return TRUE;
|
return TRUE;
|
|
|
} else if( str_equal( cmdptr, "X", len ) ||
|
} else if( str_equal( cmdptr, "X", len ) ||
|
str_equal( cmdptr, "execute", len ))
|
str_equal( cmdptr, "execute", len ))
|
{
|
{
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Execute command script
|
* Execute command script
|
* We can onle do this if we are using stdin
|
* We can onle do this if we are using stdin
|
*/
|
*/
|
if( cmdfp != stdin )
|
if( cmdfp != stdin )
|
{
|
{
|
printf( "\nWe cannot nest redirected input " );
|
printf( "\nWe cannot nest redirected input " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
arglen = get_filename( &cmdline[lineptr], &filename[0] );
|
if( arglen == 0 )
|
if( arglen == 0 )
|
{
|
{
|
printf( "\nFile name expected " );
|
printf( "\nFile name expected " );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
if( (cmdfp = fopen( &filename[0], "r" )) == NULL )
|
if( (cmdfp = fopen( &filename[0], "r" )) == NULL )
|
{
|
{
|
printf( "\ncan't open auxillary input file '%s'", &filename[0] );
|
printf( "\ncan't open auxillary input file '%s'", &filename[0] );
|
/* we had better revert to the original command file */
|
/* we had better revert to the original command file */
|
cmdfp = stdin;
|
cmdfp = stdin;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
/* every thing is ok, input is re-directed */
|
/* every thing is ok, input is re-directed */
|
auxflag = TRUE;
|
auxflag = TRUE;
|
return TRUE;
|
return TRUE;
|
}
|
}
|
}
|
}
|
/***********************************************************
|
/***********************************************************
|
*
|
*
|
* Command not understood
|
* Command not understood
|
*/
|
*/
|
printf( "\nUnrecognised command" );
|
printf( "\nUnrecognised command" );
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
/*
|
/*
|
* epedit main program
|
* epedit main program
|
*/
|
*/
|
main(int argc, char **argv)
|
main(int argc, char **argv)
|
{
|
{
|
|
|
auxflag = FALSE;
|
auxflag = FALSE;
|
offset = 0;
|
offset = 0;
|
format_type = BINARY;
|
format_type = BINARY;
|
|
|
if(argc >= 2)
|
if(argc >= 2)
|
{
|
{
|
/* check for auxillary command file */
|
/* check for auxillary command file */
|
if((cmdfp = fopen( argv[1], "r" )) == NULL)
|
if((cmdfp = fopen( argv[1], "r" )) == NULL)
|
{
|
{
|
printf(" can't open input on %s\n", argv[1] );
|
printf(" can't open input on %s\n", argv[1] );
|
printf("Usage: %s [command-file]\n",argv[0]);
|
printf("Usage: %s [command-file]\n",argv[0]);
|
exit(1);
|
exit(1);
|
}
|
}
|
auxflag = TRUE;
|
auxflag = TRUE;
|
} else
|
} else
|
{
|
{
|
/* no auxillary command file specified, use stdin */
|
/* no auxillary command file specified, use stdin */
|
cmdfp = stdin;
|
cmdfp = stdin;
|
}
|
}
|
|
|
eprom_top = 0;
|
eprom_top = 0;
|
printf( "*** EPROM Editor ***\n" );
|
printf( "*** EPROM Editor ***\n" );
|
printf( "type H/?/help for commands\n" );
|
printf( "type H/?/help for commands\n" );
|
do {
|
do {
|
read_command( cmdbuff );
|
read_command( cmdbuff );
|
} while( parse_command( cmdbuff ) );
|
} while( parse_command( cmdbuff ) );
|
printf( "\n*** exit epedit ***\n" );
|
printf( "\n*** exit epedit ***\n" );
|
exit( 0 );
|
exit( 0 );
|
}
|
}
|
|
|
|
|
