/* $OpenBSD: ncr53cxxx.c,v 1.4 2003/04/06 18:54:20 ho Exp $ */
/*
* Copyright (c) 1995 Michael L. Hitch
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Michael L. Hitch.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* scc.c - SCSI SCRIPTS Compiler */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef AMIGA
#define strcmpi strcasecmp
#endif
#define MAXTOKENS 16
#define MAXINST 1024
#define MAXSYMBOLS 128
struct {
long type;
char *name;
} tokens[MAXTOKENS];
int ntokens;
int tokenix;
void f_proc (void);
void f_pass (void);
void f_list (void); /* ENTRY, EXTERNAL label list */
void f_define (void); /* ABSOLUTE, RELATIVE label list */
void f_move (void);
void f_jump (void);
void f_call (void);
void f_return (void);
void f_int (void);
void f_select (void);
void f_reselect (void);
void f_wait (void);
void f_disconnect (void);
void f_set (void);
void f_clear (void);
void f_arch (void);
struct {
char *name;
void (*func)(void);
} directives[] = {
"PROC", f_proc,
"PASS", f_pass,
"ENTRY", f_list,
"ABSOLUTE", f_define,
"EXTERN", f_list,
"EXTERNAL", f_list,
"RELATIVE", f_define,
"MOVE", f_move,
"JUMP", f_jump,
"CALL", f_call,
"RETURN", f_return,
"INT", f_int,
"SELECT", f_select,
"RESELECT", f_reselect,
"WAIT", f_wait,
"DISCONNECT", f_disconnect,
"SET", f_set,
"CLEAR", f_clear,
"ARCH", f_arch,
NULL};
unsigned long script[MAXINST];
int dsps;
char *script_name = "SCRIPT";
unsigned long inst0, inst1, inst2;
unsigned long ninsts;
unsigned long npatches;
struct patchlist {
struct patchlist *next;
unsigned offset;
};
#define S_LABEL 0x0000
#define S_ABSOLUTE 0x0001
#define S_RELATIVE 0x0002
#define S_EXTERNAL 0x0003
#define F_DEFINED 0x0001
#define F_ENTRY 0x0002
struct {
short type;
short flags;
unsigned long value;
struct patchlist *patchlist;
char *name;
} symbols[MAXSYMBOLS];
int nsymbols;
char *stypes[] = {"Label", "Absolute", "Relative", "External"};
char *phases[] = {
"data_out", "data_in", "cmd", "status",
"res4", "res5", "msg_out", "msg_in"
};
char *regs710[] = {
"scntl0", "scntl1", "sdid", "sien",
"scid", "sxfer", "sodl", "socl",
"sfbr", "sidl", "sbdl", "sbcl",
"dstat", "sstat0", "sstat1", "sstat2",
"dsa0", "dsa1", "dsa2", "dsa3",
"ctest0", "ctest1", "ctest2", "ctest3",
"ctest4", "ctest5", "ctest6", "ctest7",
"temp0", "temp1", "temp2", "temp3",
"dfifo", "istat", "ctest8", "lcrc",
"dbc0", "dbc1", "dbc2", "dcmd",
"dnad0", "dnad1", "dnad2", "dnad3",
"dsp0", "dsp1", "dsp2", "dsp3",
"dsps0", "dsps1", "dsps2", "dsps3",
"scratch0", "scratch1", "scratch2", "scratch3",
"dmode", "dien", "dwt", "dcntl",
"addr0", "addr1", "addr2", "addr3"
};
char *regs720[] = {
"scntl0", "scntl1", "scntl2", "scntl3",
"scid", "sxfer", "sdid", "gpreg",
"sfbr", "socl", "ssid", "sbcl",
"dstat", "sstat0", "sstat1", "sstat2",
"dsa0", "dsa1", "dsa2", "dsa3",
"istat", "", "", "",
"ctest0", "ctest1", "ctest2", "ctest3",
"temp0", "temp1", "temp2", "temp3",
"dfifo", "ctest4", "ctest5", "ctest6",
"dbc0", "dbc1", "dbc2", "dcmd",
"dnad0", "dnad1", "dnad2", "dnad3",
"dsp0", "dsp1", "dsp2", "dsp3",
"dsps0", "dsps1", "dsps2", "dsps3",
"scratcha0", "scratcha1", "scratcha2", "scratcha3",
"dmode", "dien", "dwt", "dcntl",
"addr0", "addr1", "addr2", "addr3",
"sien0", "sien1", "sist0", "sist1",
"slpar", "swide", "macntl", "gpcntl",
"stime0", "stime1", "respid0", "respid1",
"stest0", "stest1", "stest2", "stest3",
"sidl0", "sidl1", "", "",
"sodl0", "sodl1", "", "",
"sbdl0", "sbdl1", "", "",
"scratchb0", "scratchb1", "scratchb2", "scratchb3",
};
int lineno;
int err_listed;
int arch;
char inbuf[128];
char *sourcefile;
char *outputfile;
char *listfile;
char *errorfile;
FILE *infp;
FILE *outfp;
FILE *listfp;
FILE *errfp;
void parse (void);
void process (void);
void emit_symbols (void);
void list_symbols (void);
void errout (char *);
void define_symbol (char *, unsigned long, short, short);
void close_script (void);
void new_script (char *);
void store_inst (void);
int expression (int *);
int evaluate (int);
int number (char *);
int lookup (char *);
int reserved (char *, int);
int CheckPhase (int);
int CheckRegister (int);
void transfer (int, int);
void select_reselect (int);
void set_clear (unsigned long);
void block_move (void);
void register_write (void);
void memory_to_memory (void);
void error_line(void);
char *makefn(char *, char *);
void usage(void);
main (int argc, char *argv[])
{
int i;
if (argc < 2 || argv[1][0] == '-')
usage();
sourcefile = argv[1];
infp = fopen (sourcefile, "r");
if (infp == NULL) {
perror ("open source");
fprintf (stderr, "scc: error opening source file %s\n", argv[1]);
exit (1);
}
/*
* process options
* -l [listfile]
* -o [outputfile]
* -z [debugfile]
* -e [errorfile]
* -a arch
* -v
* -u
*/
for (i = 2; i < argc; ++i) {
if (argv[i][0] != '-')
usage();
switch (argv[i][1]) {
case 'o':
if (i + 1 >= argc || argv[i + 1][0] == '-')
outputfile = makefn (sourcefile, "out");
else {
outputfile = argv[i + 1];
++i;
}
break;
case 'l':
if (i + 1 >= argc || argv[i + 1][0] == '-')
listfile = makefn (sourcefile, "lis");
else {
listfile = argv[i + 1];
++i;
}
break;
case 'e':
if (i + 1 >= argc || argv[i + 1][0] == '-')
errorfile = makefn (sourcefile, "err");
else {
errorfile = argv[i + 1];
++i;
}
break;
case 'a':
if (i + 1 == argc)
usage();
arch = 0;
arch = atoi(argv[i +1]);
if(arch != 720 && arch != 710) {
fprintf(stderr,"%s: bad arch '%s'\n",
argv[0], argv[i +1]);
exit(1);
}
++i;
break;
default:
fprintf (stderr, "scc: unrecognized option '%c'\n",
argv[i][1]);
usage();
}
}
if (outputfile)
outfp = fopen (outputfile, "w");
if (listfile)
listfp = fopen (listfile, "w");
if (errorfile)
errfp = fopen (errorfile, "w");
else
errfp = stderr;
while (fgets (inbuf, sizeof (inbuf), infp)) {
++lineno;
if (listfp)
fprintf (listfp, "%3d: %s", lineno, inbuf);
err_listed = 0;
parse ();
if (ntokens) {
#ifdef DUMP_TOKENS
int i;
fprintf (listfp, " %d tokens\n", ntokens);
for (i = 0; i < ntokens; ++i) {
fprintf (listfp, " %d: ", i);
if (tokens[i].type)
fprintf (listfp,"'%c'\n", tokens[i].type);
else
fprintf (listfp, "%s\n", tokens[i].name);
}
#endif
if (ntokens >= 2 && tokens[0].type == 0 &&
tokens[1].type == ':') {
define_symbol (tokens[0].name, dsps, S_LABEL, F_DEFINED);
tokenix += 2;
}
if (tokenix < ntokens)
process ();
}
}
close_script ();
emit_symbols ();
if (outfp) {
fprintf (outfp, "\nunsigned long INSTRUCTIONS = 0x%08x;\n", ninsts);
fprintf (outfp, "unsigned long PATCHES = 0x%08x;\n", npatches);
}
list_symbols ();
}
void emit_symbols ()
{
int i;
struct patchlist *p;
if (nsymbols == 0 || outfp == NULL)
return;
for (i = 0; i < nsymbols; ++i) {
char *code;
if (symbols[i].type == S_ABSOLUTE)
code = "A_";
else if (symbols[i].type == S_RELATIVE)
code = "R_";
else if (symbols[i].type == S_EXTERNAL)
code = "E_";
else if (symbols[i].flags & F_ENTRY)
code = "Ent_";
else
continue;
fprintf (outfp, "#define\t%s%s\t0x%08x\n", code, symbols[i].name,
symbols[i].value);
if (symbols[i].flags & F_ENTRY || symbols[i].patchlist == NULL)
continue;
fprintf (outfp, "unsigned long %s%s_Used[] = {\n", code, symbols[i].name);
#if 1
p = symbols[i].patchlist;
while (p) {
fprintf (outfp, "\t%08x,\n", p->offset / 4);
p = p->next;
}
#endif
fprintf (outfp, "};\n\n");
}
/* patches ? */
}
void list_symbols ()
{
int i;
if (nsymbols == 0 || listfp == NULL)
return;
fprintf (listfp, "\n\nValue Type Symbol\n");
for (i = 0; i < nsymbols; ++i) {
fprintf (listfp, "%08x: %-8s %s\n", symbols[i].value,
stypes[symbols[i].type], symbols[i].name);
}
}
void errout (char *text)
{
error_line();
fprintf (errfp, "*** %s ***\n", text);
}
void parse ()
{
char *p = inbuf;
char c;
char string[64];
char *s;
size_t len;
ntokens = tokenix = 0;
while (1) {
while ((c = *p++) && c != '\n' && c <= ' ' || c == '\t')
;
if (c == '\n' || c == 0 || c == ';')
break;
if (ntokens >= MAXTOKENS) {
errout ("Token table full");
break;
}
if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') || c == '$' || c == '_') {
s = string;
*s++ = c;
while (((c = *p) >= '0' && c <= '9') ||
(c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
c == '_' || c == '$') {
*s++ = *p++;
}
*s = 0;
len = strlen (string) + 1;
tokens[ntokens].name = malloc (len);
strlcpy (tokens[ntokens].name, string, len);
tokens[ntokens].type = 0;
}
else {
tokens[ntokens].type = c;
}
++ntokens;
}
return;
}
void process ()
{
int i;
if (tokens[tokenix].type) {
error_line();
fprintf (errfp, "Error: expected directive, found '%c'\n",
tokens[tokenix].type);
return;
}
for (i = 0; directives[i].name; ++i) {
if (strcmpi (directives[i].name, tokens[tokenix].name) == 0)
break;
}
if (directives[i].name == NULL) {
error_line();
fprintf (errfp, "Error: expected directive, found \"%s\"\n",
tokens[tokenix].name);
return;
}
if (directives[i].func == NULL) {
error_line();
fprintf (errfp, "No function for directive \"%s\"\n", tokens[tokenix].name);
} else {
#if 0
fprintf (listfp, "Processing directive \"%s\"\n", directives[i].name);
#endif
++tokenix;
(*directives[i].func) ();
}
}
void define_symbol (char *name, unsigned long value, short type, short flags)
{
int i;
struct patchlist *p;
size_t len;
for (i = 0; i < nsymbols; ++i) {
if (symbols[i].type == type && strcmp (symbols[i].name, name) == 0) {
if (symbols[i].flags & F_DEFINED) {
error_line();
fprintf (errfp, "*** Symbol \"%s\" multiply defined\n",
name);
} else {
symbols[i].flags |= flags;
symbols[i].value = value;
p = symbols[i].patchlist;
while (p) {
if (p->offset > dsps)
errout ("Whoops\007");
else
script[p->offset / 4] = dsps - p->offset - 4;
p = p->next;
}
}
return;
}
}
if (nsymbols >= MAXSYMBOLS) {
errout ("Symbol table full");
return;
}
symbols[nsymbols].type = type;
symbols[nsymbols].flags = flags;
symbols[nsymbols].value = value;
symbols[nsymbols].patchlist = NULL;
len = strlen (name) + 1;
symbols[nsymbols].name = malloc (len);
strlcpy (symbols[nsymbols].name, name, len);
++nsymbols;
}
void close_script ()
{
int i;
if (dsps == 0)
return;
if (outfp) {
fprintf (outfp, "unsigned long %s[] = {\n", script_name);
for (i = 0; i < dsps / 4; i += 2) {
fprintf (outfp, "\t0x%08x, 0x%08x", script[i],
script[i + 1]);
/* check for memory move instruction */
if (script[i] >> 30 == 3)
fprintf (outfp, ", 0x%08x,", script[i + 2]);
else
if ((i + 2) <= dsps / 4) fprintf (outfp, ",\t\t");
fprintf (outfp, "\t/* %03x - %3d */\n", i * 4, i * 4);
if (script[i] >> 30 == 3)
++i;
}
fprintf (outfp, "};\n\n");
}
dsps = 0;
}
void new_script (char *name)
{
size_t len = strlen (name) + 1;
close_script ();
script_name = malloc (len);
strlcpy (script_name, name, len);
}
int reserved (char *string, int t)
{
if (tokens[t].type == 0 && strcmpi (tokens[t].name, string) == 0)
return (1);
return (0);
}
int CheckPhase (int t)
{
int i;
for (i = 0; i < 8; ++i) {
if (reserved (phases[i], t)) {
inst0 |= i << 24;
return (1);
}
}
return (0);
}
int CheckRegister (int t)
{
int i;
if(arch == 710) {
for (i = 0; i < 64; ++i)
if (reserved (regs710[i], t))
return i;
}
else if (arch == 720) {
for (i = 0; i < 96; ++i)
if (reserved (regs720[i], t))
return i;
}
else {
errout("'ARCH' statement missing");
}
return (-1);
}
int expression (int *t)
{
int value;
int i = *t;
value = evaluate (i++);
while (i < ntokens) {
if (tokens[i].type == '+')
value += evaluate (i + 1);
else if (tokens[i].type == '-')
value -= evaluate (i + 1);
else
errout ("Unknown identifier");
i += 2;
}
*t = i;
return (value);
}
int evaluate (t)
{
int value;
char *name;
if (tokens[t].type) {
errout ("Expected an identifier");
return (0);
}
name = tokens[t].name;
if (*name >= '0' && *name <= '9')
value = number (name);
else
value = lookup (name);
return (value);
}
int number (char *s)
{
int value;
int n;
int radix;
radix = 10;
if (*s == '0') {
++s;
radix = 8;
switch (*s) {
case 'x':
case 'X':
radix = 16;
break;
case 'b':
case 'B':
radix = 2;
}
if (radix != 8)
++s;
}
value = 0;
while (*s) {
n = *s++;
if (n >= '0' && n <= '9')
n -= '0';
else if (n >= 'a' && n <= 'f')
n -= 'a' - 10;
else if (n >= 'A' && n <= 'F')
n -= 'A' - 10;
else {
error_line();
fprintf (errfp, "*** Expected digit\n", n = 0);
}
if (n >= radix)
errout ("Expected digit");
else
value = value * radix + n;
}
return (value);
}
int lookup (char *name)
{
int i;
struct patchlist *p;
size_t len;
for (i = 0; i < nsymbols; ++i) {
if (strcmp (name, symbols[i].name) == 0) {
if ((symbols[i].flags & F_DEFINED) == 0) {
p = (struct patchlist *) &symbols[i].patchlist;
while (p->next)
p = p->next;
p->next = (struct patchlist *) malloc (sizeof (struct patchlist));
p = p->next;
p->next = NULL;
p->offset = dsps + 4;
}
return ((int) symbols[i].value);
}
}
if (nsymbols >= MAXSYMBOLS) {
errout ("Symbol table full");
return (0);
}
symbols[nsymbols].type = S_LABEL; /* assume forward reference */
symbols[nsymbols].flags = 0;
symbols[nsymbols].value = 0;
p = (struct patchlist *) malloc (sizeof (struct patchlist));
symbols[nsymbols].patchlist = p;
p->next = NULL;
p->offset = dsps + 4;
len = strlen (name) + 1;
symbols[nsymbols].name = malloc (len);
strlcpy (symbols[nsymbols].name, name, len);
++nsymbols;
return (0);
}
void f_arch (void)
{
int i, archsave;
i = tokenix;
archsave = arch;
arch = 0;
arch = atoi(tokens[i].name);
if( arch != 710 && arch != 720) {
errout("Unrecognized ARCH");
arch = archsave;
}
}
void f_proc (void)
{
if (tokens[tokenix].type != 0 || tokens[tokenix + 1].type != ':')
errout ("Invalid PROC statement");
else
new_script (tokens[tokenix].name);
}
void f_pass (void)
{
errout ("PASS option not implemented");
}
/*
* f_list: process list of symbols for the ENTRY and EXTERNAL directive
*/
void f_list (void)
{
int i;
short type;
short flags;
type = strcmpi (tokens[tokenix-1].name, "ENTRY") ? S_EXTERNAL : S_LABEL;
flags = type == S_LABEL ? F_ENTRY : 0;
for (i = tokenix; i < ntokens; ++i) {
if (tokens[i].type != 0) {
errout ("Expected an identifier");
return;
}
define_symbol (tokens[i].name, 0, type, flags);
if (i + 1 < ntokens) {
if (tokens[++i].type == ',')
continue;
errout ("Expected a separator");
return;
}
}
}
/*
* f_define: process list of definitions for ABSOLUTE and RELATIVE directive
*/
void f_define (void)
{
int i;
char *name;
unsigned long value;
int type;
type = strcmpi (tokens[tokenix-1].name, "ABSOLUTE") ? S_RELATIVE : S_ABSOLUTE;
i = tokenix;
while (i < ntokens) {
if (tokens[i].type) {
errout ("Expected an identifier");
return;
}
if (tokens[i + 1].type != '=') {
errout ("Expected a separator");
return;
}
name = tokens[i].name;
i += 2;
value = expression (&i);
define_symbol (name, value, type, F_DEFINED);
}
}
void store_inst ()
{
int i = dsps / 4;
int l = 8;
if ((inst0 & 0xc0000000) == 0xc0000000)
l = 12; /* Memory to memory move is 12 bytes */
if ((dsps + l) / 4 > MAXINST) {
errout ("Instruction table overflow");
return;
}
script[i++] = inst0;
script[i++] = inst1;
if (l == 12)
script[i] = inst2;
if (listfp) {
fprintf (listfp, "\t%04x: %08x %08x", dsps, inst0, inst1);
if (l == 12)
fprintf (listfp, " %08x", inst2);
fprintf (listfp, "\n");
}
dsps += l;
inst0 = inst1 = inst2 = 0;
++ninsts;
}
void f_move (void)
{
if (reserved ("memory", tokenix))
memory_to_memory ();
else if (reserved ("from", tokenix) || tokens[tokenix+1].type == ',')
block_move ();
else
register_write ();
store_inst ();
}
void f_jump (void)
{
transfer (0x80000000, 0);
}
void f_call (void)
{
transfer (0x88000000, 0);
}
void f_return (void)
{
transfer (0x90000000, 1);
}
void f_int (void)
{
transfer (0x98000000, 2);
}
void f_select (void)
{
int t = tokenix;
if (reserved ("atn", t)) {
inst0 = 0x01000000;
++t;
}
select_reselect (t);
}
void f_reselect (void)
{
select_reselect (tokenix);
}
void f_wait (void)
{
int i = tokenix;
inst1 = 0;
if (reserved ("disconnect", i)) {
inst0 = 0x48000000;
}
else {
if (reserved ("reselect", i))
inst0 = 0x50000000;
else if (reserved ("select", i))
inst0 = 0x50000000;
else
errout ("Expected SELECT or RESELECT");
++i;
if (reserved ("rel", i)) {
i += 2;
inst1 = evaluate (i) - dsps - 8;
inst0 |= 0x04000000;
}
else
inst1 = evaluate (i);
}
store_inst ();
}
void f_disconnect (void)
{
inst0 = 0x48000000;
store_inst ();
}
void f_set (void)
{
set_clear (0x58000000);
}
void f_clear (void)
{
set_clear (0x60000000);
}
void transfer (int word0, int type)
{
int i;
i = tokenix;
inst0 = word0;
if (type == 0 && reserved ("rel", i)) {
inst1 = evaluate (i + 2) - dsps - 8;
i += 3;
inst0 |= 0x00800000;
}
else if (type != 1) {
inst1 = evaluate (i);
}
++i;
if (i >= ntokens) {
inst0 |= 0x00080000;
store_inst ();
return;
}
if (tokens[i].type != ',')
errout ("Expected a separator, ',' assumed");
else
++i;
if (reserved("when", i))
inst0 |= 0x00010000;
else if (reserved ("if", i) == 0) {
errout ("Expected a reserved word");
store_inst ();
return;
}
if (reserved ("not", ++i))
++i;
else
inst0 |= 0x00080000;
if (reserved ("atn", i)) {
inst0 |= 0x00020000;
++i;
} else if (CheckPhase (i)) {
inst0 |= 0x00020000;
++i;
}
if (i < ntokens && tokens[i].type != ',') {
if (inst0 & 0x00020000) {
if (inst0 & 0x00080000 && reserved ("and", i)) {
++i;
}
else if ((inst0 & 0x00080000) == 0 && reserved ("or", i)) {
++i;
}
else
errout ("Expected a reserved word");
}
inst0 |= 0x00040000 + (evaluate (i++) & 0xff);
}
if (i < ntokens) {
if (tokens[i].type == ',')
++i;
else
errout ("Expected a separator, ',' assumed");
if (reserved ("and", i) && reserved ("mask", i + 1))
inst0 |= ((evaluate (i + 2) & 0xff) << 8);
else
errout ("Expected , AND MASK");
}
store_inst ();
}
void select_reselect (int t)
{
inst0 |= 0x40000000; /* ATN may be set from SELECT */
if (reserved ("from", t)) {
++t;
inst0 |= 0x02000000 | evaluate (t++);
}
else
inst0 |= (evaluate (t++) & 0xff) << 16;
if (tokens[t++].type == ',') {
if (reserved ("rel", t)) {
inst0 |= 0x04000000;
inst1 = evaluate (t + 2) - dsps - 8;
}
else
inst1 = evaluate (t);
}
else
errout ("Expected separator");
store_inst ();
}
void set_clear (unsigned long code)
{
int i = tokenix;
short need_and = 0;
inst0 = code;
while (i < ntokens) {
if (need_and) {
if (reserved ("and", i))
++i;
else
errout ("Expected AND");
}
if (reserved ("atn", i)) {
inst0 |= 0x0008;
++i;
}
else if (reserved ("ack", i)) {
inst0 |= 0x0040;
++i;
}
else if (reserved ("target", i)) {
inst0 |= 0x0200;
++i;
}
else
errout ("Expected ATN, ACK, or TARGET");
need_and = 1;
}
store_inst ();
}
void block_move ()
{
int t;
if (reserved ("from", tokenix)) {
inst1 = evaluate (tokenix+1);
inst0 |= 0x10000000 | inst1; /*** ??? to match Zeus script */
tokenix += 2;
}
else {
inst0 |= evaluate (tokenix++); /* count */
tokenix++; /* skip ',' */
if (reserved ("ptr", tokenix)) {
++ tokenix;
inst0 |= 0x20000000;
}
inst1 = evaluate (tokenix++); /* address */
}
if (tokens[tokenix].type != ',')
errout ("Expected separator");
if (reserved ("when", tokenix + 1)) {
inst0 |= 0x08000000;
CheckPhase (tokenix + 2);
}
else if (reserved ("with", tokenix + 1)) {
CheckPhase (tokenix + 2);
}
else
errout ("Expected WITH or WHEN");
}
void register_write ()
{
/*
* MOVE reg/data8 TO reg register write
* MOVE reg <op> data8 TO reg register write
*/
int op;
int reg;
int data;
if (reserved ("to", tokenix+1))
op = 0;
else if (tokens[tokenix+1].type == '|')
op = 1;
else if (tokens[tokenix+1].type == '&')
op = 2;
else if (tokens[tokenix+1].type == '+')
op = 3;
else if (tokens[tokenix+1].type == '-')
op = 4;
else
errout ("Unknown register operator");
if (op && reserved ("to", tokenix+3) == 0)
errout ("Register command expected TO");
reg = CheckRegister (tokenix);
if (reg < 0) { /* Not register, must be data */
data = evaluate (tokenix);
if (op)
errout ("Register operator not move");
reg = CheckRegister (tokenix+2);
if (reg < 0)
errout ("Expected register");
inst0 = 0x78000000 | (data << 8) | reg;
#if 0
fprintf (listfp, "Move data to register: %02x %d\n", data, reg);
#endif
}
else if (op) { /* A register read/write operator */
data = evaluate (tokenix+2);
if (op == 4) {
data = -data;
op = 3;
}
inst0 = (data & 0xff) << 8;
data = CheckRegister (tokenix+4);
if (data < 0)
errout ("Expected register");
if (reg != data && reg != 8 && data != 8)
errout ("One register MUST be SBFR");
if (reg == data) { /* A register read/modify/write */
#if 0
fprintf (listfp, "Read/modify register: %02x %d %d\n", inst0 >> 8, op, reg);
#endif
inst0 |= 0x78000000 | (op << 25) | (reg << 16);
}
else { /* A move to/from SFBR */
if (reg == 8) { /* MOVE SFBR <> TO reg */
#if 0
fprintf (listfp, "Move SFBR to register: %02x %d %d\n", inst0 >> 8, op, data);
#endif
inst0 |= 0x68000000 | (op << 25) | (data << 16);
}
else {
#if 0
fprintf (listfp, "Move register to SFBR: %02x %d %d\n", inst0 >> 8, op, reg);
#endif
inst0 |= 0x70000000 | (op << 25) | (reg << 16);
}
}
}
else { /* register to register */
data = CheckRegister (tokenix+2);
if (reg == 8) /* move SFBR to reg */
inst0 = 0x6a000000 | (data << 16);
else if (data == 8) /* move reg to SFBR */
inst0 = 0x72000000 | (reg << 16);
else
errout ("One register must be SFBR");
}
}
void memory_to_memory ()
{
inst0 = 0xc0000000 + evaluate (tokenix+1);
inst1 = evaluate (tokenix+3);
inst2 = evaluate (tokenix+5);
}
void error_line()
{
if (errfp != listfp && errfp && err_listed == 0) {
fprintf (errfp, "%3d: %s", lineno, inbuf);
err_listed = 1;
}
}
char * makefn (base, sub)
char *base;
char *sub;
{
char *fn;
size_t len = strlen (base) + strlen (sub) + 2;
fn = malloc (len);
strlcpy (fn, base, len);
base = strrchr(fn, '.');
if (base)
*base = 0;
strlcat (fn, ".", len);
strlcat (fn, sub, len);
return (fn);
}
void usage()
{
fprintf (stderr, "usage: scc sourcfile [options]\n");
exit(1);
}
![[BACK]](/icons/back.gif){kind=icon}
Return to ncr53cxxx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / microcode / ncr53cxxx