URL https://opencores.org/ocsvn/System09/System09/trunk
Subversion Repositories System09

[/] [System09/] [branches/] [mkfiles_rev1/] [Tools/] [epedit/] [new/] [epedit.c] - Blame information for rev 177

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * 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;
                        } 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;
        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;
}
 
Line No.	Rev	Author	Line
1	19	dilbert57	`/*`
2			`* epedit`
3			`*`
4			`* binary file editer program`
5			`*/`
6			`#include <stdio.h>`
7			`#include <string.h>`
8			`#include <ctype.h>`
9			`/*`
10			`* equates`
11			`*/`
12			`#define EPROM_MAX (1<<16)`
13			`#define CMD_LINE_MAX 80`
14			`#define FALSE 0`
15			`#define TRUE !FALSE`
16			`#define BINARY 0`
17			`#define MOTOROLA 1`
18			`#define INTEL 2`
19			`#define SMAL32 3`
20			`#define VHDL_BIN 4`
21			`#define VHDL_BYTE 5`
22			`#define VHDL_WORD 6`
23
24			`/*`
25			`* global variables`
26			`*/`
27			`FILE cmdfp; / command input pointer */`
28			`char cmdbuff[CMD_LINE_MAX];`
29			`unsigned char eprom_buff[EPROM_MAX]; /* eprom buffer */`
30			`int eprom_top; /* top of EPROM buffer */`
31			`int mod_flag; /* buffer has been modified */`
32			`int auxflag; /* Auxillary input file specified */`
33			`int count;`
34			`int checksum;`
35			`int offset; /* Eprom Buffer memory offset */`
36			`int format_type; /* load / save format type */`
37			`char *hex_str = "0123456789ABCDEF";`
38
39			`/*`
40			`* Read a command line into the command buffer`
Browse

Tools

Subversion Repositories System09

[/] [System09/] [branches/] [mkfiles_rev1/] [Tools/] [epedit/] [new/] [epedit.c] - Blame information for rev 177
