Subversion Repositories marca

/* This file is part of the assembler "spar" for marca.
   Copyright (C) 2007 Wolfgang Puffitsch
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "spar.h"
#include "ui.h"
#include "output.h"
#include "segtab.h"
#include "code.h"
 
char *itob(uint32_t val, uint8_t width)
{
  char *retval = xmalloc(width+1);
  retval[width] = '\0';
  while (width-- > 0)
    {
      retval[width] = (val & 1) ? '1' : '0';
      val >>= 1;
    }
  return retval;
}
 
void print_download(FILE *f, FILE *r0, FILE *r1)
{
  struct seg *seg = get_current_seg();
  uint32_t pos;
 
  if (!nostart)
    {
      fprintf(f, "%c%c", 'U', '\n');
    }
  for (pos = 0; pos < seg->pos; pos++)
    {
      uint16_t data = get_code(seg, pos);
      fprintf(f, "%c%c%c%c%c%c",
	      (uint8_t)((pos >> 8) & 0xFF),
	      (uint8_t)(pos & 0xFF),
	      0,
	      (uint8_t)((data >> 8) & 0xFF),
	      (uint8_t)(data & 0xFF),
	      '\n');
    }
  for ( ; pos < codesize; pos++)
    {
      fprintf(f, "%c%c%c%c%c%c",
	      (uint8_t)((pos >> 8) & 0xFF),
	      (uint8_t)(pos & 0xFF),
	      0,
	      (uint8_t)((filler >> 8) & 0xFF),
	      (uint8_t)(filler & 0xFF),
	      '\n');
    }
  if (!noend)
    {
      fprintf(f, "%c%c%c", 0x55, 0xFF, 1);
    }
}
 
void print_intel(FILE *f, FILE *r0, FILE *r1)
{
  struct seg *seg;
  uint32_t pos;
 
  /* instructions */
  seg = get_seg(SEG_PILE);
  for (pos = 0; pos < seg->pos; pos++)
    {
      uint16_t data = get_code(seg, pos);
      uint8_t chksum = -(2 + ((pos >> 8) & 0xFF) + (pos & 0xFF)
			 + ((data >> 8) & 0xFF) + (data & 0xFF));
      fprintf(f, ":%02x%04x%02x%04x%02x%c",
	      2, (uint16_t)pos, 0, data, chksum, '\n');
    }
  for ( ; pos < codesize; pos++)
    {
      uint8_t chksum = -(2 + ((pos >> 8) & 0xFF) + (pos & 0xFF)
			 + ((filler >> 8) & 0xFF) + (filler & 0xFF));
      fprintf(f, ":%02x%04x%02x%04x%02x%c",
	      2, (uint16_t)pos, 0, filler, chksum, '\n');
    }
  fprintf(f, ":00000001ff\n");
 
  /* even ROM adresses */
  seg = get_seg(SEG_DATA);
  for (pos = 0; pos < seg->pos; pos+=2)
    {
      uint16_t data = get_code(seg, pos);
      uint8_t chksum = -(1 + ((pos/2 >> 8) & 0xFF) + (pos/2 & 0xFF)
			 + (data & 0xFF));
      fprintf(r0, ":%02x%04x%02x%02x%02x%c",
	      1, (uint16_t)pos/2, 0, data & 0xFF, chksum, '\n');
    }
  for ( ; pos < romsize; pos+=2)
    {
      uint8_t chksum = -(1 + ((pos/2 >> 8) & 0xFF) + (pos/2 & 0xFF)
			 + (filler & 0xFF));
      fprintf(r0, ":%02x%04x%02x%02x%02x%c",
	      1, (uint16_t)pos/2, 0, filler & 0xFF, chksum, '\n');
    }
  fprintf(r0, ":00000001ff\n");
 
  /* odd ROM adresses */
  seg = get_seg(SEG_DATA);
  for (pos = 1; pos < seg->pos; pos+=2)
    {
      uint16_t data = get_code(seg, pos);
      uint8_t chksum = -(1 + ((pos/2 >> 8) & 0xFF) + (pos/2 & 0xFF)
			 + (data & 0xFF));
      fprintf(r1, ":%02x%04x%02x%02x%02x%c",
	      1, (uint16_t)pos/2, 0, data & 0xFF, chksum, '\n');
    }
  for ( ; pos < romsize; pos+=2)
    {
      uint8_t chksum = -(1 + ((pos/2 >> 8) & 0xFF) + (pos/2 & 0xFF)
			 + ((filler >> 8) & 0xFF) + (filler & 0xFF));
      fprintf(r1, ":%02x%04x%02x%02x%02x%c",
	      1, (uint16_t)pos/2, 0, filler & 0xFF, chksum, '\n');
    }
  fprintf(r1, ":00000001ff\n");
}
 
void print_mif(FILE *f, FILE *r0, FILE *r1)
{
  struct seg *seg;
  uint32_t pos;
 
  /* instructions */
  seg = get_seg(SEG_PILE);
 
  fprintf(f, "DEPTH=%lu;\n", codesize);
  fprintf(f, "WIDTH=16;\n");
  fprintf(f, "ADDRESS_RADIX=HEX;\n");
  fprintf(f, "DATA_RADIX=BIN;\n\n");
  fprintf(f, "CONTENT\nBEGIN\n\n");
 
  fprintf(f, "%% Assembly output\t%%\n");
 
  for (pos = 0; pos < seg->pos; pos++)
    {
      uint16_t data = get_code(seg, pos);
      fprintf(f, "%4x:\t%s;\t%% %s\t%%\n", (uint16_t)pos,
	      itob(data, 16), get_listing(seg, pos));
    }
 
  if (seg->pos < codesize)
    {
      fprintf(f, "\n[%4x..%4x]:\t%s;\t%% Filler\t%%\n",
	      (uint16_t)seg->pos, (uint16_t)(codesize-1),
	      itob(filler, 16));
    }
 
  fprintf(f, "\nEND;\n");
 
  /* even ROM addresses */
  seg = get_seg(SEG_DATA);
 
  fprintf(r0, "DEPTH=%lu;\n", romsize/2);
  fprintf(r0, "WIDTH=8;\n");
  fprintf(r0, "ADDRESS_RADIX=HEX;\n");
  fprintf(r0, "DATA_RADIX=BIN;\n\n");
  fprintf(r0, "CONTENT\nBEGIN\n\n");
 
  fprintf(r0, "%% Assembly output\t%%\n");
 
  for (pos = 0; pos < seg->pos; pos += 2)
    {
      uint16_t data = get_code(seg, pos);
      fprintf(r0, "%4x:\t%s;\t%% %s\t%%\n", (uint16_t)pos/2,
	      itob(data, 8), get_listing(seg, pos));
    }
 
  if (seg->pos < romsize)
    {
      fprintf(r0, "\n[%4x..%4x]:\t%s;\t%% Filler\t%%\n",
	      (uint16_t)seg->pos/2, (uint16_t)(romsize/2-1),
	      itob(filler, 8));
    }
 
  fprintf(r0, "\nEND;\n");
 
  /* odd ROM addresses */
  seg = get_seg(SEG_DATA);
 
  fprintf(r1, "DEPTH=%lu;\n", romsize/2);
  fprintf(r1, "WIDTH=8;\n");
  fprintf(r1, "ADDRESS_RADIX=HEX;\n");
  fprintf(r1, "DATA_RADIX=BIN;\n\n");
  fprintf(r1, "CONTENT\nBEGIN\n\n");
 
  fprintf(r1, "%% Assembly output\t%%\n");
 
  for (pos = 1; pos < seg->pos; pos += 2)
    {
      uint16_t data = get_code(seg, pos);
      fprintf(r1, "%4x:\t%s;\t%% %s\t%%\n", (uint16_t)pos/2,
	      itob(data, 8), get_listing(seg, pos));
    }
 
  if (seg->pos < romsize)
    {
      fprintf(r1, "\n[%4x..%4x]:\t%s;\t%% Filler\t%%\n",
	      (uint16_t)seg->pos/2, (uint16_t)(romsize/2-1),
	      itob(filler, 8));
    }
 
  fprintf(r1, "\nEND;\n");
}