Subversion Repositories tms1000

/*
casm.c
 
CASM is an assembler for the tms1000 processor.
*/
 
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "symtab.h"
#include "casm.h"
 
char *progname;
int pass;
int lineno;
int errors;
int warnings;
 
int group;	/* current rom group */
int rom;	/* current rom */
int pc;		/* current pc */
 
int dsr;	/* delayed select rom */
int dsg;	/* delayed select group */
 
char flag_char;
 
int objflag;	/* used to remember args to emit() */
int objcode;
 
int symtab_flag;
 
int last_instruction_type;
 
 
int targflag;	/* used to remember args to target() */
int targgroup;
int targrom;
int targpc;
 
char linebuf [MAX_LINE];
char *lineptr;
 
#define MAX_ERRBUF 2048
char errbuf [MAX_ERRBUF];
char *errptr;
 
#define SRC_TAB 32
char listbuf [MAX_LINE];
char *listptr;
 
#ifndef PATH_MAX
#define PATH_MAX 256
#endif
 
char srcfn  [PATH_MAX];
char objfn  [PATH_MAX];
char listfn [PATH_MAX];
 
FILE *srcfile  = NULL;
FILE *objfile  = NULL;
FILE *listfile = NULL;
 
t_symtab symtab /*[MAXGROUP] [MAXROM]*/;  /* separate symbol tables for each ROM */
 
void format_listing (void)
{
  int i;
 
  sprintf (listptr, "%4d   ", lineno);
  listptr += strlen (listptr);
 
  if (objflag)
    {
      sprintf (listptr, "L%03x:  ", (rom << 6)+pc);
      listptr += strlen (listptr);
      for (i = 0x80; i; i >>= 1)
	*listptr++ = (objcode & i) ? '1' : '.';
      *listptr = '\0';
    }
  else
    {
      strcat (listptr, "                   ");
      listptr += strlen (listptr);
    }
 
  if (targflag)
    {
      sprintf (listptr, "  -> L%1o%1o%03o", targgroup, targrom, targpc);
      listptr += strlen (listptr);
    }
  else
    {
      strcat (listptr, "           ");
      listptr += strlen (listptr);
    }
 
  sprintf (listptr, "  %c%c%c%c%c    ", flag_char, flag_char, flag_char,
	   flag_char, flag_char);
  listptr += strlen (listptr);
 
  strcat (listptr, linebuf);
  listptr += strlen (listptr);
}
 
void do_pass (int p)
{
  int i;
 
  pass = p;
  lineno = 0;
  errors = 0;
  warnings = 0;
  pc = 0;
  dsr = rom;
  dsg = group;
  last_instruction_type = OTHER_INST;
 
  printf ("Pass %d rom", pass);
 
  while (fgets (linebuf, MAX_LINE, srcfile))
    {
      /* remove newline */
      i = strlen (linebuf);
      if (linebuf [i - 1] == '\n')
	linebuf [i - 1] = '\0';
 
      lineno++;
      lineptr = & linebuf [0];
 
      listptr = & listbuf [0];
      listbuf [0] = '\0';
 
      errptr = & errbuf [0];
      errbuf [0] = '\0';
 
      objflag = 0;
      targflag = 0;
      flag_char = ' ';
      symtab_flag = 0;
 
      yyparse ();
 
      if (pass == 2)
	{
	  if (symtab_flag)
	    print_symbol_table (symtab, listfile);
	  else
	    {
	      format_listing ();
	      fprintf (listfile, "%s\n", listbuf);
	      if (errptr != & errbuf [0])
		{
		  fprintf (stderr, "%s\n", listbuf);
		  fprintf (listfile, "%s", errbuf);
		  fprintf (stderr, "%s",   errbuf);
		}
	    }
	}
 
      if (objflag) {
        pc = ((pc != 31) && ((pc >> 4) != 0) && (((pc & 0xf) == 15) || ((pc >> 4) != 3))) ?  (pc << 1) : (pc << 1)+1;
        pc = pc & 0x3f;
      }
	//pc = (pc + 1) & 0xff;
    }
 
  printf ("\n");
}
 
void munge_filename (char *dst, char *src, char *ext)
{
  int i;
  int lastdot = 0;
  for (i = 0; src [i]; i++)
    {
      if (src [i] == '.')
	lastdot = i;
    }
  if (lastdot == 0)
    lastdot = strlen (src);
  memcpy (dst, src, lastdot);
  dst [lastdot] = '\0';
  strcat (dst, ext);
}
 
int main (int argc, char *argv[])
{
  progname = argv [0];
 
  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s sourcefile\n", progname);
      exit (1);
    }
 
  symtab = alloc_symbol_table ();
  if (! symtab )
    fatal ("symbol table allocation failed\n");
 
  strcpy (srcfn, argv [1]);
 
  srcfile = fopen (srcfn, "r");
 
  if (! srcfile)
    fatal ("can't open input file '%s'\n", srcfn);
 
  munge_filename (objfn, srcfn, ".mem");
  munge_filename (listfn, srcfn, ".lst");
 
  objfile = fopen (objfn, "w");
 
  if (! objfile)
    fatal ("can't open input file '%s'\n", objfn);
 
  listfile = fopen (listfn, "w");
 
  if (! listfile)
    fatal ("can't open listing file '%s'\n", listfn);
 
  rom = 0;
  group = 0;
 
  do_pass (1);
 
  rewind (srcfile);
 
  do_pass (2);
 
  err_printf ("%d errors, %d warnings\n", errors, warnings);
 
  fclose (srcfile);
  fclose (objfile);
  fclose (listfile);
}
 
void yyerror (char *s)
{
  error ("%s\n", s);
}
 
void do_label (char *s)
{
  int prev_val;
 
  if (pass == 1)
    {
      if (! create_symbol (symtab, s, (rom << 6) + pc, lineno))
	error ("multiply defined symbol '%s'\n", s);
    }
  else if (! lookup_symbol (symtab, s, & prev_val))
    error ("undefined symbol '%s'\n", s);
  else if (prev_val != ((rom << 6) + pc))
    error ("phase error for symbol '%s'\n", s);
}
 
static void emit_core (int op, int inst_type)
{
  objcode = op;
  objflag = 1;
  last_instruction_type = inst_type;
 
  if ((pass == 2) && objfile)
      fprintf (objfile, "@%03x %02x\n", (rom<<6)+pc, op);
}
 
void emit (int op)
{
  emit_core (op, OTHER_INST);
}
 
void emit_arith (int op)
{
  emit_core (op, ARITH_INST);
}
 
void emit_test (int op)
{
  emit_core (op, TEST_INST);
}
 
void target (int g, int r, int p)
{
  targflag = 1;
  targgroup = g;
  targrom = r;
  targpc = p;
}
 
int range (int val, int min, int max)
{
  if ((val < min) || (val > max))
    {
      error ("value out of range [%d to %d], using %d", min, max, min);
      return min;
    }
  return val;
}
 
char *newstr (char *orig)
{
  int len;
  char *r;
 
  len = strlen (orig);
  r = (char *) malloc (len + 1);
 
  if (! r)
    fatal ("memory allocation failed\n");
 
  memcpy (r, orig, len + 1);
  return (r);
}
 
/*
 * print to both listing error buffer and standard error
 *
 * Use this for general messages.  Don't use this for warnings or errors
 * generated by a particular line of the source file.  Use error() or
 * warning() for that.
 */
int err_vprintf (char *format, va_list ap)
{
  int res;
 
  if (listfile)
    vfprintf (listfile, format, ap);
  res = vfprintf (stderr, format, ap);
  return (res);
}
 
int err_printf (char *format, ...)
{
  int res;
  va_list ap;
 
  va_start (ap, format);
  res = err_vprintf (format, ap);
  va_end (ap);
  return (res);
}
 
 
/* generate fatal error message to stderr, doesn't return */
void fatal (char *format, ...)
{
  va_list ap;
 
  fprintf (stderr, "fatal error: ");
  va_start (ap, format);
  vfprintf (stderr, format, ap);
  va_end (ap);
  exit (2);
}
 
 
/* generate error or warning messages and increment appropriate counter */
/* actually just puts the message into the error buffer */
int error   (char *format, ...)
{
  int res;
  va_list ap;
 
  err_printf ("error in file %s line %d: ", srcfn, lineno);
  va_start (ap, format);
  res = err_vprintf (format, ap);
  va_end (ap);
  errptr += res;
  errors ++;
  return (res);
}
 
int warning (char *format, ...)
{
  int res;
  va_list ap;
 
  err_printf ("warning in file %s line %d: ", srcfn, lineno);
  va_start (ap, format);
  res = err_vprintf (format, ap);
  va_end (ap);
  errptr += res;
  warnings ++;
  return (res);
}