epedit.c

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

	while( isalpha( cmdline[lineptr] ) ||
	      (cmdline[lineptr] == '?'))
	{
		lineptr++;
		len++;
	}
	/* skip trailing white spaces */
	while( isspace( cmdline[lineptr] ) )
		lineptr++;
    if( len > 0 )
    {

	if( str_equal( cmdptr, "T", len ) ||
	    str_equal( cmdptr, "type", len ) )
	{
		/***********************************************************
		 *
		 * Specify file I/O format type
		 */
		cmdptr = &cmdline[lineptr];
		len = 0;
		while( isalpha( cmdline[lineptr] ))
		{
			lineptr++;
			len++;
		}
		if( len != 0 )
		{
			if( str_equal( cmdptr, "B", len ) ) 
				format_type = BINARY; 
			else if( str_equal( cmdptr, "binary", len ) )
				format_type = BINARY; 
			else if( str_equal( cmdptr, "M", len ) ) 
				format_type = MOTOROLA; 
			else if( str_equal( cmdptr, "motorola", len ) ) 
				format_type = MOTOROLA; 
			else if( str_equal( cmdptr, "I", len ) )
				format_type = INTEL; 
			else if( str_equal( cmdptr, "intel", len ) ) 
				format_type = INTEL;
			else if( str_equal( cmdptr, "O", len ) )
				format_type = SMAL32; 
			else if( str_equal( cmdptr, "smal", len ) ) 
				format_type = SMAL32;
			else if( str_equal( cmdptr, "V", len ) )
				format_type = VHDL_BIN; 
			else if( str_equal( cmdptr, "vhdl", len ) ) 
				format_type = VHDL_BIN;
			else if( str_equal( cmdptr, "H", len ) )
				format_type = VHDL_BYTE; 
			else if( str_equal( cmdptr, "hex", len ) ) 
				format_type = VHDL_BYTE;
			else if( str_equal( cmdptr, "W", len ) )
				format_type = VHDL_WORD; 
			else if( str_equal( cmdptr, "word", len ) ) 
				format_type = VHDL_WORD;
			else printf( "\nUnrecognised file format" );
		}
		printf( "\nFile format type is : " );
		switch( format_type ) {
		case BINARY:
			printf( "Raw Binary" );
			break;
		case MOTOROLA:
			printf( "Motorola S1" );
			break;
		case INTEL:
			printf( "Intel Hex" );
			break;
		case SMAL32:
			printf( "Smal32 .o" );
			break;
		case VHDL_BIN:
			printf( "vhdl binary" );
			break;
		case VHDL_BYTE:
			printf( "vhdl hexadecimal byte" );
			break;
		case VHDL_WORD:
			printf( "vhdl hexadecimal word" );
			break;
		default:
			printf( "Bad format - should not get here" );
			break;
		}
		return TRUE;
	}
	else if( str_equal( cmdptr, "L", len ) ||
	         str_equal( cmdptr, "load", len ) )
	{
		/***********************************************************
		 *
		 * Load file into buffer
		 */
		arglen = get_filename( &cmdline[lineptr], &filename[0] );
		if( arglen == 0 )
		{
			printf( "\nFile name expected " );
			return TRUE;
		}
		lineptr += arglen;
		arglen = get_address( &cmdline[lineptr], &load_addr );
		if( arglen == 0 )
		{
			/* default binary load address = start of eprom */
			load_addr =  offset;

		}
		if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nLoad address out of range" );
			return TRUE;
		}
		switch( format_type ) {
		case BINARY:
			printf( "\nLoading binary file" );
			load_binary( filename, load_addr );
			break;
		case MOTOROLA:
			printf( "\nLoading Motorola S1 file" );
			load_mot( filename );
			break;
		case INTEL:
			printf( "\nLoading intel hex file" );
			load_intel( filename );
			break;
		case SMAL32:
			printf( "\nLoading Smal32 file" );
			load_smal32( filename );
			break;
		case VHDL_BIN:
			printf( "\nLoading VHDL binary format" );
			load_vhdl_bin( filename, load_addr );
			break;
		case VHDL_BYTE:
			printf( "\nLoading VHDL hexadecimal byte format" );
			load_vhdl_byte( filename, load_addr );
			break;
		case VHDL_WORD:
			printf( "\nLoading VHDL hexadecimal word format" );
			load_vhdl_word( filename, load_addr );
			break;
		default:
			printf( "\nBad format - no load" );
			break;
		}
		mod_flag = TRUE;
		return TRUE;
	} else if( str_equal( cmdptr, "S", len ) ||
		   str_equal( cmdptr, "save", len ))
	{
		/***********************************************************
		 *
		 * Save buffer to file
		 *
		 ***********************************************************/
		arglen = get_filename( &cmdline[lineptr], &filename[0] );
		if( arglen == 0 )
		{
			printf( "\nFile name expected " );
			return TRUE;
		}
		lineptr += arglen;
		arglen = get_address( &cmdline[lineptr], &start_addr );
		if( arglen == 0 )
		{
			/* this could default to 0 */
			printf( "\nStart address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
		{
			/* this could default to eprom_top */
			printf( "\nEnd address expected " );
			return TRUE;
		}
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nEnd address out of range" );
			return TRUE;
		}
		printf( "\nSaving buffer %x to %x to file %s ", start_addr, end_addr, filename );
		switch( format_type ) {
		case BINARY:
			printf( "\nBinary format" );
			save_binary( filename, start_addr, end_addr );
			break;
		case MOTOROLA:
			printf( "\nMotorola S1 format" );
			save_mot( filename, start_addr, end_addr );
			break;
		case INTEL:
			printf( "\nIntel hex format" );
			save_intel( filename, start_addr, end_addr );
			break;
		case VHDL_BIN:
			printf( "\nVHDL binary format" );
			save_vhdl_bin( filename, start_addr, end_addr );
			break;
		case VHDL_BYTE:
			printf( "\nVHDL hexadecimal byte format" );
			save_vhdl_byte( filename, start_addr, end_addr );
			break;
		case VHDL_WORD:
			printf( "\nVHDL hexadecimal word format" );
			save_vhdl_word( filename, start_addr, end_addr );
			break;
		default:
			printf( "\nBad format - no save performed" );
			break;
		}
		return TRUE;
	} else if( str_equal( cmdptr, "D", len ) ||
		   str_equal( cmdptr, "dump", len ))
	{
		/***********************************************************
		 *
		 * dump buffer to the display
		 */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			printf( "\nStart address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
		{
			printf( "\nEnd address expected " );
			return TRUE;
		}
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nEnd address out of range" );
			return TRUE;
		}
		load_addr = 0;
		printf( "\n Memory Dump form %x to %x ", start_addr, end_addr );
		while( (start_addr + load_addr) <= end_addr )
		{
			printf( "\n  %04x - ", start_addr + load_addr );
			for( dest_addr = 0; dest_addr < 16; dest_addr++ )
			{
				if( (start_addr + load_addr + dest_addr) <= end_addr )
					printf( "%02x ", eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX] );
				else
					printf( "   " );
			}
			printf( "  " );
			for( dest_addr = 0; dest_addr < 16; dest_addr++ )
			{
				if( (start_addr + load_addr + dest_addr) <= end_addr )
				{
					ch = eprom_buff[(start_addr+load_addr+dest_addr) % EPROM_MAX];
					if( (ch > 0x20) && (ch < 0x7f) )
						printf( "%c", ch );
					else
						printf( "." );
				} else
					printf( " " );
			}
			load_addr += dest_addr;
		}
		return TRUE;
	} else if( str_equal( cmdptr, "C", len ) ||
		   str_equal( cmdptr, "compare", len ))
	{
		/***********************************************************
		 *
		 * compare file with buffer
		 *
		 ***********************************************************/
		if( (arglen = get_filename( &cmdline[lineptr], &filename[0] )) == 0 )
		{
			printf( "\nFile name expected " );
			return TRUE;
		}
		lineptr += arglen;
		/* start/load address is optional - default to start of eprom */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			start_addr = offset;
		}
		lineptr += arglen;

		/* the end/start address is optional */
		if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0 )
		{
			end_addr = EPROM_MAX + offset - 1;
		}
		lineptr += arglen;

		/* the end/start address is optional */
		if( (arglen = get_address( &cmdline[lineptr], &load_addr )) == 0 )
		{
			load_addr = EPROM_MAX + offset - 1;
		}

		/* check for valid address range */
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nEnd address out of range" );
			return TRUE;
		}
		if( (load_addr < offset) || (load_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nLoad address out of range" );
			return TRUE;
		}
		printf( "\nComparing buffer to file %s", filename );
		switch( format_type ) {
		case BINARY:
			printf( "\nBinary format" );
			dest_addr = load_addr;
			load_addr = start_addr;
			start_addr = end_addr;
			end_addr = dest_addr;
			if( start_addr == (EPROM_MAX + offset - 1) )
				start_addr = offset;
			compare_binary( filename, load_addr, start_addr, end_addr );
			break;
		case MOTOROLA:
			printf( "\nMotorola S1 format" );
			compare_mot( filename, start_addr, end_addr );
			break;
		case INTEL:
			printf( "\nIntel hex format" );
			compare_intel( filename, start_addr, end_addr );
			break;
		default:
			printf( "\nBad format - no save performed" );
			break;
		}
		return TRUE;
	} else if( str_equal( cmdptr, "M", len ) ||
		   str_equal( cmdptr, "move", len ))
	{
		/***********************************************************
		 *
		 * memory block move
		 */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			printf( "\nStart address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
		{
			printf( "\nEnd address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &dest_addr )) == 0)
		{
			printf( "\nDestination address expected " );
			return TRUE;
		}
		/* check that the range is around the right way */
		if( end_addr < start_addr )
		{
			load_addr = start_addr;
			start_addr = end_addr;
			end_addr = load_addr;
		}
		/* check for valid address range */
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nEnd address out of range" );
			return TRUE;
		}
		if( (dest_addr < offset) || (dest_addr >= (offset + EPROM_MAX)))

		{
			printf( "\nDestination address out of range" );
			return TRUE;
		}
		byte_count = end_addr - start_addr;
		printf( "\nTransfering memory block %04x thru %04x to %04x", start_addr, end_addr, dest_addr );
		if( start_addr > dest_addr  )
		{
			for( load_addr=0; load_addr<=byte_count; load_addr++ )
				eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX];
		} else
		{
			for( load_addr=byte_count; load_addr>=0; load_addr-- )
				eprom_buff[(dest_addr-offset+load_addr) % EPROM_MAX] = eprom_buff[(start_addr-offset+load_addr) % EPROM_MAX];
		}	
		printf( "\nDone" );
		mod_flag = TRUE;
		return TRUE;
	} else if( str_equal( cmdptr, "F", len ) ||
		   str_equal( cmdptr, "fill", len ))
	{
		/***********************************************************
		 *
		 * fill memory with data
		 */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			printf( "\nStart address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &end_addr )) == 0)
		{
			printf( "\nEnd address expected " );
			return TRUE;
		}
		lineptr += arglen;
		if( (arglen = get_address( &cmdline[lineptr], &data_byte )) == 0)
		{
			printf( "\nFill data byte expected " );
			return TRUE;
		}
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		if( (end_addr < offset) || (end_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nEnd address out of range" );
			return TRUE;
		}
		printf( "\nFilling address %x thru %x with %x ", start_addr, end_addr, data_byte );
		for( dest_addr=start_addr; dest_addr<=end_addr; dest_addr++ )
			eprom_buff[(dest_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
		printf( "\nDone" );
		mod_flag = TRUE;
		return TRUE;
	} else if( str_equal( cmdptr, "W", len ) ||
		   str_equal( cmdptr, "write", len ))

	{
		/***********************************************************
		 *
		 * Write to buffer location
		 */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			printf( "\nStart address expected " );
			return TRUE;
		}
		lineptr += arglen;
		/* check for valid address range */
		if( (start_addr < offset) || (start_addr >= (offset + EPROM_MAX)))
		{
			printf( "\nStart address out of range" );
			return TRUE;
		}
		printf( "\nSetting buffer loaction %x", start_addr );
		while( (arglen = get_address( &cmdline[lineptr], &data_byte )) != 0)
		{
			eprom_buff[(start_addr-offset) % EPROM_MAX] = (unsigned char)data_byte;
			printf( "\n %04x = %02x ", start_addr, data_byte );
			start_addr++;
			lineptr += arglen;
		}
		mod_flag = TRUE;
		return TRUE;
	} else if( str_equal( cmdptr, "O", len ) ||
		   str_equal( cmdptr, "offset", len ))
	{
		/***********************************************************
		 *
		 * Set Eprom base address offset
		 */
		if( (arglen = get_address( &cmdline[lineptr], &start_addr )) == 0 )
		{
			/* No argument, display offset */
			printf( "\nBase address offset = %04x", offset );
			return TRUE;
		}
		offset = start_addr;
		mod_flag = TRUE;
		return TRUE;
	} else if( str_equal( cmdptr, "H", len ) ||
		   str_equal( cmdptr, "?", len ) ||
		   str_equal( cmdptr, "help", len ))
	{
		/***********************************************************
		 *
		 * Display help menu
		 */
		display_help();
		return TRUE;
	} else if( str_equal( cmdptr, "Q", len ) ||
		   str_equal( cmdptr, "quit", len ))
	{
		/***********************************************************
		 *
		 * Quit program - return FALSE
		 */
		printf( "\nQuitting program" );
		return FALSE;
	} else if( str_equal( cmdptr, "E", len ) ||
		   str_equal( cmdptr, "echo", len ))
	{
		/***********************************************************
		 *
		 * Echo string to the console
		 */
		printf( "\n" );
		while( (cmdline[lineptr] != '\0') && (cmdline[lineptr] != '\n'))
			printf( "%c", cmdline[lineptr++] );
		printf( "\n" );
		return TRUE;

	} else if( str_equal( cmdptr, "X", len ) ||
		   str_equal( cmdptr, "execute", len ))
	{
		/***********************************************************
		 *
		 * Execute command script
		 * We can onle do this if we are using stdin
		 */
		if( cmdfp != stdin )
		{
			printf( "\nWe cannot nest redirected input " );
			return TRUE;
		}

		arglen = get_filename( &cmdline[lineptr], &filename[0] );
		if( arglen == 0 )
		{
			printf( "\nFile name expected " );
			return TRUE;
		}

		if( (cmdfp = fopen( &filename[0], "r" )) == NULL )
		{
			printf( "\ncan't open auxillary input file '%s'", &filename[0] );
			/* we had better revert to the original command file */
			cmdfp = stdin;	
			return TRUE;
		}
		/* every thing is ok, input is re-directed */
		auxflag = TRUE;
		return TRUE;
	}
    }
	/***********************************************************
	 *
	 * Command not understood
	 */
	printf( "\nUnrecognised command" );
	return TRUE;
}

/*
 * epedit main program
 */
int main(int argc, char **argv)
{
	
	auxflag = FALSE;
	offset = 0;
	format_type = BINARY;

	if(argc >= 2)
	{
		/* check for auxillary command file */
		if((cmdfp = fopen( argv[1], "r" )) == NULL)
		{
			printf(" can't open input on %s\n", argv[1] );
			printf("Usage: %s [command-file]\n",argv[0]);
			return 1;
		}
		auxflag = TRUE;
	} else 
	{
		/* no auxillary command file specified, use stdin */
		cmdfp = stdin;
	}

	eprom_top = 0;
	printf( "*** EPROM Editor ***\n" );
	printf( "type H/?/help for commands\n" );
	do {
		read_command( cmdbuff );
	} while( parse_command( cmdbuff ) );
	printf( "\n*** exit epedit ***\n" );
	return 0;
}