epedit.c

This is SOC system 09. Source code. very use fulcode for SOC beginners

/*
 * epedit
 *
 * binary file editer program
 */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/*
 * 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<len )
	{
		if( toupper( s1[i] ) == toupper( s2[i] ) )
			i++;
		else return FALSE;
	}
	return TRUE;
}	

/*
 * extract a file name from the command line
 */
int get_filename( char *cb, char *fn )
{
	int i;

	i = 0;
	while( !isspace( cb[i] ) && (cb[i] !='\n') && (cb[i] != '\0'))
	{
		fn[i] = cb[i];
		i++;
	}
	fn[i] = '\0';
	if( i == 0 )
		return i;
	while( isspace( cb[i] ))
		i++;
	return i;
}

int to_hexadecimal( char c )
{
	int k;
	
	for( k=0; k<16; k++ )
	{
		if( toupper(c) == hex_str[k] )
			return k;
	}
	return -1;
}			

/*
 * extract an address from the command line
 * returns an offset to the end of the argument.
 */
int get_address( char *cb, int *addr )
{
	int i, j, k;

	j = 0;
	i = 0;

	while((k = to_hexadecimal(cb[i])) != -1)
	{
		i++;
		j = j *16 + k;
	}
	*addr = j;
	if( i == 0 )
		return i;
	while( isspace( cb[i]) )
		i++;
	return i;
}


/*
 * Motorola S1 format to Intel hex format
 * Usage
 * mot2hex <file_name>
 */

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, "r" )) == 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<count; i++ )
	        {
		    byte = get2hex( fp_in );
		    eprom_buff[( addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		}
	        byte = get2hex( fp_in);
		checksum = (~checksum) & 0xff;
		if( checksum != 0 )
	           printf( "\nchecksum error - read check = %02x", byte );
	     }
	}
	fclose( fp_in );
}


/*
 * load smal32 .o formatted file
 */

void load_smal32( char *fname_in )
{
	FILE *fp_in;
	int byte;
        long addr;
        int state;

	fp_in = fopen( fname_in, "r" );
	if( !fp_in )
	{
	    printf( "\nCan't open %s", fname_in );
	    return; 
	}

	byte = 0;
	addr = 0;
        state = 0;

	while( byte != -1 )
	{
		byte = fgetc( fp_in);
                switch( state )
                {
                case 0:
                  switch( byte )
                  {
                   case '.':
                     state = 1;
		     break;
                   case 'B':
		     state = 4;
		     break;
                   case 'H':
		     state = 5;
		     break;
                   case 'W':
		     state = 6;
		     break;
                   default:
		     state = 0;
		  }
                  break;
                case 1:
                  if( byte == '=' )
                     state = 2;
                  else
                     state = 0;
                  break;
		case 2:
                  if( byte == '#' )
                  {
		     addr = get8hex( fp_in );
	             printf( "\nload address = %08x", addr );
                  }
                  state = 0;
                  break;
                case 3:
                  break;
                case 4:
                  if( byte == '#' )
                  {
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
                  }
                  state = 0;
                  break;
                case 5:
                  if( byte == '#' )
                  {
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
                  }
                  state = 0;
                  break;
                case 6:
                  if( byte == '#' )
                  {
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		    byte = get2hex( fp_in );
		    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
		    addr++;
		  }
                  state = 0;
                  break;
               default :
                 state = 0;
                 break;

	       }

	    if( addr >= EPROM_MAX  )
               byte = -1;
        }
	printf( "\nlast address = %08x", addr );
	fclose( 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<count; i++ )
	        	{
			    byte = get2hex( fp_in );
			    eprom_buff[ (addr - offset) % EPROM_MAX ] = (unsigned char)byte;
			    addr++;
			}
		        byte = get2hex( fp_in);
			if( checksum != 0 )
			{
				printf( "\nchecksum read %02x, expected %02x", byte, (checksum - byte)&0xff );
				byte = -1;
			} else if( addr >= EPROM_MAX )
			   byte = -1;
		} else if( i == 1 )
			byte = -1;
	}
	fclose( 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;