Subversion Repositories cpu_lecture

#include "assert.h"
#include "stdio.h"
#include "stdint.h"
#include "string.h"
 
const char * hex_file = 0;
const char * vhdl_file = 0;
 
uint8_t buffer[0x10000];
 
//-----------------------------------------------------------------------------
uint32_t
get_byte(const char *  cp)
{
uint32_t value;
const char cc[3] = { cp[0], cp[1], 0 };
const int cnt = sscanf(cc, "%X", &value);
   assert(cnt == 1);
   return value;
}
//-----------------------------------------------------------------------------
void
read_file(FILE * in)
{
   memset(buffer, 0xFF, sizeof(buffer));
char line[200];
   for (;;)
       {
         const char * s = fgets(line, sizeof(line) - 2, in);
         if (s == 0)   return;
         assert(*s++ == ':');
         const uint32_t len     = get_byte(s);
         const uint32_t ah      = get_byte(s + 2);
         const uint32_t al      = get_byte(s + 4);
         const uint32_t rectype = get_byte(s + 6);
         const char * d = s + 8;
         const uint32_t addr = ah << 8 | al;
 
         uint32_t csum = len + ah + al + rectype;
         assert((addr + len) <= 0x10000);
         for (uint32_t l = 0; l < len; ++l)
             {
               const uint32_t byte = get_byte(d);
               d += 2;
               buffer[addr + l] = byte;
               csum += byte;
             }
 
         csum = 0xFF & -csum;
         const uint32_t sum = get_byte(d);
         assert(sum == csum);
       }
}
//-----------------------------------------------------------------------------
void
write_vector(FILE * out, bool odd, uint32_t mem, uint32_t v)
{
const uint8_t * base = buffer;
 
   // total memory is 2 even bytes, 2 odd bytes, 2 even bytes, ...
   //
   if (odd)   base += 2;
 
   // total memory is 4 kByte organized into 8 memories.
   // thus each of the 16 vectors covers 256 bytes.
   //
   base += v*256;
 
   // memories 0 and 1 are the low byte of the opcode while
   // memories 2 and 3 are the high byte.
   //
   if (mem >= 2)   ++base;
 
const char * px = odd ? "po" : "pe";
   fprintf(out, "constant %s_%u_%2.2X : BIT_VECTOR := X\"", px, mem, v);
   for (int32_t d = 63; d >= 0; --d)
       {
         uint32_t q = base[4*d];
         if (mem & 1)   q >>= 4;     // high nibble
         else           q &= 0x0F;   // low nibble
         fprintf(out, "%X", q);
       }
 
   fprintf(out, "\";\r\n");
}
//-----------------------------------------------------------------------------
void
write_mem(FILE * out, bool odd, uint32_t mem)
{
const char * px = odd ? "po" : "pe";
 
   fprintf(out, "-- content of %s_%u --------------------------------------"
                "--------------------------------------------\r\n", px, mem);
 
   for (uint32_t v = 0; v < 16; ++v)
       write_vector(out, odd, mem, v);
 
   fprintf(out, "\r\n");
}
//-----------------------------------------------------------------------------
void
write_file(FILE * out)
{
   fprintf(out,
"\r\n"
"library IEEE;\r\n"
"use IEEE.STD_LOGIC_1164.all;\r\n"
"\r\n"
"package prog_mem_content is\r\n"
"\r\n");
 
   for (uint32_t m = 0; m < 4; ++m)
       write_mem(out, false, m);
 
   for (uint32_t m = 0; m < 4; ++m)
       write_mem(out, true,  m);
 
   fprintf(out,
"end prog_mem_content;\r\n"
"\r\n");
}
//-----------------------------------------------------------------------------
int
main(int argc, char * argv[])
{
   if (argc > 1)   hex_file = argv[1];
   if (argc > 2)   vhdl_file = argv[2];
 
FILE * in = stdin;
   if (hex_file)   in = fopen(hex_file, "r");
   assert(in);
   read_file(in);
   fclose(in);
 
FILE * out = stdout;
   if (vhdl_file)   out = fopen(vhdl_file, "w");
   write_file(out);
   assert(out);
}
//-----------------------------------------------------------------------------