epedit.c

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

			} 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<<i)) == 0 )
				putc( '0', fp_out );
			else
				putc( '1', fp_out );
		}
		putc( '"', fp_out );
		if (addr > end_addr-1)
			putc( ',', fp_out );
		putc( '\n', fp_out );
	}
	fclose( fp_out );
	printf( "\nwritten successfully" );
}


/*
 * save VHDL hexadecimal file
 */

void save_vhdl_byte( 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\"", 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 ); 
		}
 		if ( addr > (end_addr - 32) )
			fprintf( fp_out, "\"\n" );
		else
			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 ); 
		}
  		if ( addr > (end_addr - 32) )
			fprintf( fp_out, "\"\n" );
		else
			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, "w" )) == 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;
	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<E_total; i++)
		{
			data_byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
			put2hex( fp_out, data_byte);
		}
		checksum = ~checksum;	/* one's complement */
		put2hex( fp_out, (checksum & 0xff));
		fputc( '\n', fp_out);  	/* record header preamble */
		addr += E_total;
	}
	checksum = 0;
	fputc( 'S', fp_out);  		/* record header preamble */
	fputc( '9', fp_out);  		/* record header preamble */
	put2hex( fp_out, 3);		/* byte count + 3 */
	put4hex( fp_out, 0);		/* Program Counter */
	put2hex( fp_out, 0xfc );	/* byte count + 3 */
	fclose( fp_out );
}

/*
 * save Intelhex file
 */

void save_intel( char *fname_out, int start_addr, int end_addr )
{
	FILE *fp_out;
	int byte, addr, start, check, i;

	fp_out = fopen( fname_out, "w" );
	if( fp_out == NULL )
	{
		printf( "\nCan't open %s for output", fname_out );
		return;
	}

	addr = start_addr;
	start = addr;
	while( addr <= end_addr )
	{
		check = 0;
		count = 16;
	        fputc( ':', fp_out );
		put2hex( fp_out, count );
                check += count;
		put4hex( fp_out, addr );
                check += (addr & 0xff);
                check += ((addr>>8) & 0xff);
		put2hex( fp_out, 0 );
                check += 0;
	        for( i=0; i<count; i++ )
	        {
		    byte = (int)eprom_buff[ (addr - offset) % EPROM_MAX ];
		    if( addr == 0xfffe )
		        start = byte * 256 ;
	            if( addr == 0xffff )
		        start += byte;
		    put2hex( fp_out, byte );
		    check += byte;
		    addr ++;
		}
		check = (0-check) & 0xff;
	        put2hex( fp_out, check);
		fputc( '\n', fp_out );
	}
	fputc( ':', fp_out );
	put2hex( fp_out, 0 );
	put4hex( fp_out, start );
        put2hex( fp_out, 1 );
	fclose( fp_out );
}


/*
 * Compare Raw binary file
 */

void compare_binary( char *fname_in, int load_addr, int start_addr, int end_addr)
{
	FILE *fp_in;
	int addr;
	int data_byte;
	int diff_count;

	if( (fp_in = fopen( fname_in, "r" )) == NULL )
	{
		printf( "\ncant open %s for read", fname_in );
		return;
	} else
	{
		diff_count = 0;
		addr = load_addr;
		while( (data_byte = fgetc( fp_in )) != EOF )
		{
			if( (addr >= 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,  i;
	int diff_count;

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

	byte = 0;
	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<count; i++ )
	        {
		    	byte = get2hex( fp_in );
			if( (addr >= 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;
	     }
	}
	fclose( 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, 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<count; i++ )
		        {
			    	byte = get2hex( fp_in );
				if( (addr >= 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;
	}
	fclose( 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( "     <I/intel>\n");
        printf( "     <M/motorola>\n");
        printf( "     <B/binary>\n" );
        printf( "     <O/Smal32>\n" );
        printf( "     <V/vhdl> VHDL Binary String \n" );
        printf( "     <H/hex> VHDL Hexadecimal Byte String\n" );
        printf( "     <W/word> VHDL Hexadecimal Word String\n" );
	printf( "O/offset <address>                   - Set Eprom buffer offset\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( "C/compare <filename> [<load_addr>]   - compare file to buffer\n" );
/*
	printf( "R/read <address>                     - reads buffer data\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( "M/move <start-address> <end-address> <dest-address> - block move\n" );
	printf( "D/dump <start_address> <end-address> - Hex buffer dump\n");
	printf( "E/echo <string>                      - echo string to console\n" );
	printf( "X/excecute <command-file>            - 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;
	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;