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 "spar.h"
#include "ui.h"
#include "checks.h"
#include "code.h"
#include "exprs.h"
#include "optab.h"
#include "segtab.h"
#include "symtab.h"
 
int check_premature(void)
{
  if (args_to_match > 0)
    {
      fprintf(stderr, "not enough valid items in line %lu\n", line_count);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_arg_count(void)
{
  if (args_to_match == 0)
    {
      fprintf(stderr, "too many items in line %lu\n", line_count);
      error_count++;
      return 1;
    } 
  else if (args_to_match == -1)
    {
      fprintf(stderr, "no valid mnemonic in line %lu\n", line_count);
      args_to_match = -2;
      error_count++;
      return 1;
    }
  else if ((args_to_match & 1) == 0)
    {
      fprintf(stderr, "missing colon in line %lu\n", line_count);
      error_count++;
      return 1;
    } 
 
  return 0;
}
 
int check_org_advances(struct seg *seg, uint32_t org)
{
  if (seg->pos > org)
    {
      fprintf(stderr, "trying to move .org backwards in line %lu\n", line_count);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_colon_ok(void)
{
 if ((args_to_match & 1) != 0)
    {
      fprintf(stderr, "superfluous colon in line %lu\n", line_count);
      error_count++;
      return 1;
    } 
 
  return 0;
}
 
int check_arg_type(struct seg* seg, uint32_t pos, uint8_t index, char type)
{
  if (((type == 'r')
       && (get_arg_type(seg, pos, index) != 'r'))
      || ((type == 'n')
	  && (get_arg_type(seg, pos, index) != 'n')
	  && (get_arg_type(seg, pos, index) != 'a')))
 
    {
      fprintf(stderr, "wrong argtype `%c' in line %lu\n", type, line_count);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_sym_dup(const char *s)
{
  if (get_sym(s) != NULL)
    {
      fprintf(stderr, "duplicate symbol `%s' in line %lu\n", s, line_count);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_code_size(void)
{
  if (get_seg(SEG_TEXT)->pos > codesize)
    {
      fprintf(stderr,
	      "code (%lu instrucions) is too large for instruction ROM (%lu instructions)\n",
	      get_seg(SEG_TEXT)->pos, codesize);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_data_size(void)
{
  if (output_mode == MODE_DOWNLOAD
      && get_seg(SEG_DATA)->pos > 0)
    {
      fprintf(stderr,
	      "initialized data (%lu words) not supported for download format\n",
	      get_seg(SEG_DATA)->pos, romsize);
      error_count++;
      return 1;
    }
 
  if (get_seg(SEG_DATA)->pos > romsize)
    {
      fprintf(stderr,
	      "initialized data (%lu words) is too large for data ROM (%lu words)\n",
	      get_seg(SEG_DATA)->pos, romsize);
      error_count++;
      return 1;
    }
 
  if ((get_seg(SEG_DATA)->pos+get_seg(SEG_BSS)->pos) > datasize)
    {
      fprintf(stderr,
	      "data (%lu words) is too large for RAM (%lu words)\n",
	      (get_seg(SEG_DATA)->pos+get_seg(SEG_BSS)->pos), datasize);
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_mnemonic(struct seg* seg, uint32_t pos)
{
  if (0)
    {
      fprintf(stderr, "mnemonic reserved, but not supported\n");
      error_count++;
      return 1;
    }
  return 0;
}
 
int check_ranges(struct seg* seg, uint32_t pos)
{
  uint8_t count = get_arg_count(seg, pos);
  uint8_t index;
  int retval = 0;
 
  for (index = 0; index < count; index++)
    {
      switch (get_arg_type(seg, pos, index))
	{
	case 'r': 
	  if ((get_regnum(seg, pos, index) < get_arg_min(seg, pos, index))
	      || (get_regnum(seg, pos, index) > get_arg_max(seg, pos, index)))
	    {
	      fprintf(stderr, "invalid register: r%d\n", get_regnum(seg, pos, index));
	      error_count++;
	      retval = 1;
	    }
	  break;
	case 'n': 
	  if (get_expr(seg, pos, index) == NULL)
	    {
	      fprintf(stderr, "missing expression, probably confused by prior errors\n");
	      error_count++;
	      retval = 1;
	    }
	  else if ((expr_evaluate(get_expr(seg, pos, index)) < get_arg_min(seg, pos, index))
	      || (expr_evaluate(get_expr(seg, pos, index)) > get_arg_max(seg, pos, index)))
	    {
	      fprintf(stderr, "number out of range [%ld..%ld]: %lld\n",
		      get_arg_min(seg, pos, index), get_arg_max(seg, pos, index),
		      expr_evaluate(get_expr(seg, pos, index)));
	      error_count++;
	      retval = 1;
	    }
	  break;
	case 'a':
	  if ((expr_evaluate(get_expr(seg, pos, index)) < get_arg_min(seg, pos, index))
	      || (expr_evaluate(get_expr(seg, pos, index)) > get_arg_max(seg, pos, index)))
	    {
	      fprintf(stderr, "relative address out of range [%ld..%ld]: %lld\n",
		      get_arg_min(seg, pos, index), get_arg_max(seg, pos, index),
		      expr_evaluate(get_expr(seg, pos, index)));
	      error_count++;
	      retval = 1;
	    }
	  break;
	default:
	  fprintf(stderr, "invalid operand constraint: %c\n",
		  get_arg_type(seg, pos, index));
	  error_count++;
	  retval = 1;
	}
    }
 
  return retval;
}