mirror of
https://github.com/aap/pdp6.git
synced 2026-01-24 11:31:15 +00:00
1411 lines
30 KiB
C
1411 lines
30 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <ctype.h>
|
|
#include <stdarg.h>
|
|
#include "pdp6common.h"
|
|
#include "pdp6bin.h"
|
|
#include "../args.h"
|
|
|
|
#define nil NULL
|
|
|
|
enum
|
|
{
|
|
MAXSYM = 4000,
|
|
MAXLINE = 256,
|
|
MAXOPND = 20
|
|
};
|
|
|
|
enum Toktype
|
|
{
|
|
Unused = 0,
|
|
Symbol,
|
|
Word,
|
|
Radix10,
|
|
Radix8,
|
|
Radix2,
|
|
Eol,
|
|
|
|
/* char classes */
|
|
Letter,
|
|
Digit,
|
|
Ignore,
|
|
};
|
|
|
|
enum Symtype
|
|
{
|
|
Undef = 000,
|
|
|
|
Local = 001, /* defined, Intern may modify this */
|
|
Intern = 002, /* exported */
|
|
Extern = 004, /* defined in other module */
|
|
|
|
Hide = 010, /* not visible to debugger */
|
|
Label = 020, /* to forbid redefinition */
|
|
|
|
Operator = 0100, /* primary instruction and opdef */
|
|
IoOperator, /* io instruction */
|
|
Pseudo
|
|
/* Macro etc... */
|
|
};
|
|
|
|
typedef struct Value Value;
|
|
struct Value
|
|
{
|
|
word val;
|
|
int rel; /* 0 = absolute, else relative */
|
|
};
|
|
|
|
typedef struct Sym Sym;
|
|
struct Sym
|
|
{
|
|
word name; /* sixbit */
|
|
int type; /* Symtype */
|
|
union {
|
|
Value v;
|
|
void (*f)(void);
|
|
};
|
|
};
|
|
Sym symtab[MAXSYM];
|
|
|
|
typedef struct Token Token;
|
|
struct Token
|
|
{
|
|
int type;
|
|
union {
|
|
word w;
|
|
Sym *s;
|
|
};
|
|
};
|
|
|
|
int ctab[] = {
|
|
Unused, Unused, Unused, Unused, Unused, Unused, Unused, Unused,
|
|
Unused, Unused, Unused, Unused, Unused, Unused, Unused, Unused,
|
|
Unused, Unused, Unused, Unused, Unused, Unused, Unused, Unused,
|
|
Unused, Unused, Unused, Unused, Unused, Unused, Unused, Unused,
|
|
|
|
Ignore, '!', Unused, Unused, Letter, Letter, '&', Unused,
|
|
'(', ')', '*', '+', Unused, '-', Letter, '/',
|
|
Digit, Digit, Digit, Digit, Digit, Digit, Digit, Digit,
|
|
Digit, Digit, Unused, ';', '<', Unused, '>', Unused,
|
|
|
|
Unused, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Unused, Unused, Unused, '^', '_',
|
|
|
|
Unused, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Letter, Letter, Letter, Letter, Letter,
|
|
Letter, Letter, Letter, Unused, Unused, Unused, Unused, Unused,
|
|
};
|
|
|
|
char *argv0;
|
|
char *filename;
|
|
FILE *infp;
|
|
char line[MAXLINE];
|
|
char *lp; /* pointer to input */
|
|
char *ops[MAXOPND]; /* tokenized operands */
|
|
int numops;
|
|
int lineno;
|
|
int passno;
|
|
int error;
|
|
Sym *dot;
|
|
Value absdot, reldot; /* saved values of dot */
|
|
int radix = 8;
|
|
Token peekt;
|
|
|
|
void
|
|
err(int n, char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
fprintf(stderr, "%s:%d: ", filename, lineno);
|
|
vfprintf(stderr, fmt, ap);
|
|
fprintf(stderr, "\n");
|
|
va_end(ap);
|
|
error |= n;
|
|
}
|
|
|
|
void
|
|
panic(char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vfprintf(stderr, fmt, ap);
|
|
fprintf(stderr, "\n");
|
|
va_end(ap);
|
|
exit(1);
|
|
}
|
|
|
|
FILE*
|
|
mustopen(const char *name, const char *mode)
|
|
{
|
|
FILE *f;
|
|
if(f = fopen(name, mode), f == nil)
|
|
panic("couldn't open file: %s", name);
|
|
return f;
|
|
}
|
|
|
|
void
|
|
putv(word w, int rel)
|
|
{
|
|
printf(" %06o%c %06o%c%06o%c\n",
|
|
right(dot->v.val), dot->v.rel ? '\'' : ' ',
|
|
left(w), rel & 2 ? '\'' : ' ',
|
|
right(w), rel & 1 ? '\'' : ' ');
|
|
dot->v.val++;
|
|
}
|
|
|
|
char*
|
|
getln(void)
|
|
{
|
|
int c;
|
|
char *s;
|
|
s = line;
|
|
lineno++;
|
|
while(c = getc(infp), c != EOF){
|
|
if(c == 037){ /* line continuation */
|
|
lineno++;
|
|
getc(infp);
|
|
continue;
|
|
}
|
|
if(c == '\n')
|
|
break;
|
|
if(s < &line[MAXLINE])
|
|
*s++ = c & 0177; /* force 7 bit */
|
|
}
|
|
if(s >= &line[MAXLINE])
|
|
err(0, "warning: line too long");
|
|
if(c == EOF)
|
|
return nil;
|
|
*s = '\0';
|
|
return line;
|
|
}
|
|
|
|
void
|
|
skipwhite(void)
|
|
{
|
|
while(isspace(*lp))
|
|
lp++;
|
|
}
|
|
|
|
/* Just find symbol, or return nil.
|
|
* TODO: improve linear search... */
|
|
Sym*
|
|
findsym(word name)
|
|
{
|
|
Sym *s;
|
|
for(s = symtab; s < &symtab[MAXSYM]; s++)
|
|
if(s->name == name)
|
|
return s;
|
|
return nil;
|
|
}
|
|
|
|
/* Get symbol, add to table if not present */
|
|
Sym*
|
|
getsym(word name)
|
|
{
|
|
Sym *s;
|
|
s = findsym(name);
|
|
if(s == nil){
|
|
for(s = symtab; s < &symtab[MAXSYM]; s++)
|
|
if(s->name == 0)
|
|
goto found;
|
|
panic("symbol table full");
|
|
found:
|
|
s->name = name;
|
|
s->type = Undef;
|
|
s->v = (Value){ 0, 0 };
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/* parse a potential number, fall back to symbol */
|
|
Token
|
|
symnum(char *s)
|
|
{
|
|
Token t;
|
|
int isnum;
|
|
word n;
|
|
char *symp;
|
|
|
|
isnum = 1;
|
|
symp = s;
|
|
n = 0;
|
|
while(*s){
|
|
if(!isdigit(*s))
|
|
isnum = 0;
|
|
else if(isnum){
|
|
symp++; /* ignore leading digits for symbols */
|
|
n = n*radix + *s-'0';
|
|
}
|
|
s++;
|
|
}
|
|
if(isnum){
|
|
t.type = Word;
|
|
t.w = n;
|
|
}else{
|
|
t.type = Symbol;
|
|
t.s = getsym(sixbit(symp));
|
|
}
|
|
return t;
|
|
}
|
|
|
|
Token
|
|
token(void)
|
|
{
|
|
Token t;
|
|
char tok[100];
|
|
char *p;
|
|
|
|
if(peekt.type != Unused){
|
|
t = peekt;
|
|
peekt.type = Unused;
|
|
return t;
|
|
}
|
|
|
|
skipwhite();
|
|
p = tok;
|
|
while(*lp)
|
|
switch(ctab[*lp]){
|
|
case Letter:
|
|
case Digit:
|
|
while(*lp && !isspace(*lp) && israd50(*lp))
|
|
*p++ = *lp++;
|
|
*p = '\0';
|
|
t = symnum(tok);
|
|
return t;
|
|
|
|
case ';':
|
|
while(*lp)
|
|
lp++;
|
|
t.type = Eol;
|
|
return t;
|
|
|
|
case '^':
|
|
lp++;
|
|
if(*lp == 'D')
|
|
t.type = Radix10;
|
|
else if(*lp == 'O')
|
|
t.type = Radix8;
|
|
else if(*lp == 'B')
|
|
t.type = Radix2;
|
|
else{
|
|
err(1, "error: unknown Radix ^%c\n", *lp);
|
|
t.type = Radix8;
|
|
}
|
|
lp++;
|
|
return t;
|
|
|
|
case Unused:
|
|
err(0, "warning: unknown char %c", *lp);
|
|
/* fallthrough */
|
|
case Ignore:
|
|
lp++;
|
|
break;
|
|
|
|
default:
|
|
t.type = *lp++;
|
|
return t;
|
|
}
|
|
t.type = Eol;
|
|
return t;
|
|
}
|
|
|
|
Value
|
|
apply(int op, Value v1, Value v2)
|
|
{
|
|
int shft;
|
|
shft = v2.val;
|
|
if(isneg(v2.val))
|
|
shft = -negw(v2.val);
|
|
switch(op){
|
|
case '_':
|
|
if(shft < 0)
|
|
v1.val >>= -shft;
|
|
else
|
|
v1.val <<= shft;
|
|
break;
|
|
case '!':
|
|
v1.val |= v2.val;
|
|
break;
|
|
case '&':
|
|
v1.val &= v2.val;
|
|
break;
|
|
case '*':
|
|
v1.val *= v2.val;
|
|
break;
|
|
case '/':
|
|
v1.val /= v2.val;
|
|
break;
|
|
case '+':
|
|
v1.val += v2.val;
|
|
break;
|
|
|
|
case '-':
|
|
v1.val -= v2.val;
|
|
if(v1.rel == v2.rel)
|
|
v1.rel = 0;
|
|
goto ret;
|
|
|
|
case 0:
|
|
return v2;
|
|
}
|
|
v1.rel += v2.rel;
|
|
if(v1.rel > 1){
|
|
err(1, "error: invalid expression type");
|
|
v1.rel = 0;
|
|
v1.val = 0;
|
|
}
|
|
ret:
|
|
v1.val &= 0777777777777;
|
|
return v1;
|
|
}
|
|
|
|
Value
|
|
expr(void)
|
|
{
|
|
/* -
|
|
* ^D ^O ^B ^F ^L
|
|
* B _
|
|
* logical ! &
|
|
* mul/div * /
|
|
* add/sub + -
|
|
* <>
|
|
*/
|
|
Token t;
|
|
Value v1, v2;;
|
|
int op;
|
|
int neg;
|
|
int first;
|
|
int oldradix;
|
|
|
|
v1.rel = 0;
|
|
v1.val = 0;
|
|
op = 0;
|
|
neg = 0;
|
|
first = 1;
|
|
|
|
oldradix = radix;
|
|
while(t = token(), t.type != Eol)
|
|
switch(t.type){
|
|
case Word:
|
|
v2.val = t.w;
|
|
v2.rel = 0;
|
|
goto opnd;
|
|
|
|
case Symbol:
|
|
v2 = t.s->v;
|
|
goto opnd;
|
|
|
|
case '<':
|
|
v2 = expr();
|
|
t = token();
|
|
if(t.type != '>'){
|
|
err(1, "error: '>' expected");
|
|
peekt = t;
|
|
}
|
|
goto opnd;
|
|
|
|
opnd:
|
|
radix = oldradix;
|
|
if(neg){
|
|
neg = 0;
|
|
v2.val = negw(v2.val);
|
|
}
|
|
v1 = apply(op, v1, v2);
|
|
first = 0;
|
|
op = 0;
|
|
break;
|
|
|
|
case Radix10:
|
|
radix = 10;
|
|
break;
|
|
case Radix8:
|
|
radix = 8;
|
|
break;
|
|
case Radix2:
|
|
radix = 2;
|
|
break;
|
|
|
|
case '^':
|
|
printf("%c\n", *lp);
|
|
return v1;
|
|
|
|
case '-':
|
|
if(op || first){
|
|
neg = 1;
|
|
break;
|
|
}else
|
|
op = t.type;
|
|
break;
|
|
case '_':
|
|
case '!':
|
|
case '&':
|
|
case '*':
|
|
case '/':
|
|
case '+':
|
|
if(op)
|
|
err(1, "error: bad expression");
|
|
op = t.type;
|
|
break;
|
|
|
|
default:
|
|
peekt = t;
|
|
return v1;
|
|
}
|
|
return v1;
|
|
}
|
|
|
|
/* split operands separated by ',' starting at lp; remove whitespace */
|
|
void
|
|
splitop(void)
|
|
{
|
|
int i;
|
|
int nparn;
|
|
|
|
numops = 0;
|
|
skipwhite();
|
|
if(*lp == ';' || *lp == '\0')
|
|
return;
|
|
|
|
/* this routine is terrible, null everything
|
|
* we don't care about and drag along pointers
|
|
* to the beginnig of operands */
|
|
ops[numops++] = lp;
|
|
for(; *lp && *lp != ';'; lp++){
|
|
if(isspace(*lp))
|
|
*lp = '\0';
|
|
else if(*lp == ','){
|
|
*lp = '\0';
|
|
ops[numops++] = lp;
|
|
if(numops >= MAXOPND){
|
|
err(0, "warning: operand overflow");
|
|
return;
|
|
}
|
|
}else if(*lp == '('){
|
|
/* read parenthesized operands as one */
|
|
if(*ops[numops-1] == '\0')
|
|
ops[numops-1] = lp;
|
|
lp++;
|
|
nparn = 1;
|
|
for(; *lp && *lp != ';' && nparn != 0; lp++)
|
|
if(*lp == '(')
|
|
nparn++;
|
|
else if(*lp == ')')
|
|
nparn--;
|
|
}else{
|
|
if(*ops[numops-1] == '\0')
|
|
ops[numops-1] = lp;
|
|
}
|
|
}
|
|
*lp = '\0';
|
|
// for(i = 0; i < numops; i++)
|
|
// printf("{%s} ", ops[i]);
|
|
// putchar('\n');
|
|
}
|
|
|
|
/* Primary and IO instruction statement */
|
|
void
|
|
opline(word w, int io)
|
|
{
|
|
char *acp, *ep;
|
|
Value ac, x, y;
|
|
Token t;
|
|
int i;
|
|
|
|
splitop();
|
|
/*
|
|
* OP AC,
|
|
* OP ,E
|
|
* OP E
|
|
* E: @Y(X)
|
|
*/
|
|
switch(numops){
|
|
case 0:
|
|
acp = "";
|
|
ep = "";
|
|
break;
|
|
case 1:
|
|
acp = "";
|
|
ep = ops[0];
|
|
break;
|
|
default:
|
|
err(0, "warning: too many operands");
|
|
case 2:
|
|
acp = ops[0];
|
|
ep = ops[1];
|
|
}
|
|
|
|
lp = acp;
|
|
ac = expr();
|
|
|
|
i = 0;
|
|
lp = ep;
|
|
if(*lp == '@'){
|
|
lp++;
|
|
i = 1;
|
|
}
|
|
y = expr();
|
|
|
|
x = (Value){ 0, 0 };
|
|
t = token();
|
|
if(t.type == '('){
|
|
x = expr();
|
|
t = token();
|
|
if(t.type != ')')
|
|
err(1, "error: ')' expected");
|
|
x.val = fw(right(x.val), left(x.val));
|
|
}
|
|
|
|
/* TODO: is this correct or should we mask out some stuff? */
|
|
if(io){
|
|
w += (ac.val&0774) << 24;
|
|
}else
|
|
w += (ac.val&017) << 23;
|
|
if(ac.rel)
|
|
err(0, "warning: AC relocation ignored");
|
|
if(i)
|
|
w |= 0000020000000;
|
|
w = fw(left(w), right(w)+right(y.val));
|
|
/* TODO: really warn about this? */
|
|
if(left(y.val))
|
|
err(0, "warning: address too large");
|
|
w = fw(left(w)+left(x.val), right(w)+right(x.val));
|
|
if(x.rel)
|
|
err(0, "warning: X relocation ignored");
|
|
putv(w, y.rel);
|
|
}
|
|
|
|
/*
|
|
* Pseudo Ops
|
|
*/
|
|
|
|
void
|
|
internal(void)
|
|
{
|
|
Sym *s;
|
|
int i;
|
|
splitop();
|
|
for(i = 0; i < numops; i++){
|
|
s = getsym(sixbit(ops[i]));
|
|
if(s->type >= Operator || s->type & Extern)
|
|
err(0, "warning: can't INTERN symbol %s", ops[i]);
|
|
else
|
|
s->type |= Intern;
|
|
}
|
|
}
|
|
|
|
void
|
|
external(void)
|
|
{
|
|
Sym *s;
|
|
int i;
|
|
splitop();
|
|
for(i = 0; i < numops; i++){
|
|
s = getsym(sixbit(ops[i]));
|
|
if(s->type >= Operator || s->type & Intern)
|
|
err(0, "warning: can't EXTERN symbol %s", ops[i]);
|
|
else
|
|
s->type |= Extern;
|
|
}
|
|
}
|
|
|
|
void
|
|
xwd(void)
|
|
{
|
|
Value l, r;
|
|
splitop();
|
|
l = (Value){ 0, 0 };
|
|
r = (Value){ 0, 0 };
|
|
if(numops != 2)
|
|
err(0, "warning: need two operands");
|
|
else{
|
|
lp = ops[0];
|
|
l = expr();
|
|
lp = ops[1];
|
|
r = expr();
|
|
}
|
|
putv(fw(right(l.val), right(r.val)), (l.rel<<1) | r.rel);
|
|
}
|
|
|
|
void
|
|
title(void)
|
|
{
|
|
/* TODO */
|
|
skipwhite();
|
|
printf("TITLE: %s\n", lp);
|
|
}
|
|
|
|
void
|
|
subttl(void)
|
|
{
|
|
/* TODO */
|
|
skipwhite();
|
|
printf("SUBTTL: %s\n", lp);
|
|
}
|
|
|
|
void
|
|
locOp(void)
|
|
{
|
|
skipwhite();
|
|
if(dot->v.rel) reldot = dot->v;
|
|
else absdot = dot->v;
|
|
if(*lp && *lp != ';'){
|
|
dot->v = expr();
|
|
dot->v.val &= 0777777;
|
|
dot->v.rel = 0;
|
|
}else
|
|
dot->v = absdot;
|
|
}
|
|
|
|
void
|
|
relocOp(void)
|
|
{
|
|
skipwhite();
|
|
if(dot->v.rel) reldot = dot->v;
|
|
else absdot = dot->v;
|
|
if(*lp && *lp != ';'){
|
|
dot->v = expr();
|
|
dot->v.val &= 0777777;
|
|
dot->v.rel = 1;
|
|
}else
|
|
dot->v = reldot;
|
|
}
|
|
|
|
int asciiz;
|
|
|
|
void
|
|
ascii(void)
|
|
{
|
|
char delim;
|
|
word w;
|
|
int i;
|
|
|
|
skipwhite();
|
|
delim = *lp++;
|
|
if(delim == ';' || delim == '\0'){
|
|
putv(0, 0);
|
|
return;
|
|
}
|
|
w = 0;
|
|
i = 0;
|
|
for(; *lp && *lp != delim; lp++){
|
|
w = (w<<7) | *lp;
|
|
if(++i == 5){
|
|
putv(w, 0);
|
|
i = 0;
|
|
w = 0;
|
|
}
|
|
}
|
|
if(*lp != delim)
|
|
err(1, "error: '%c' expected", delim);
|
|
if(asciiz){
|
|
i++;
|
|
w <<= 7;
|
|
}
|
|
w <<= 35-i*7;
|
|
if(w || asciiz)
|
|
putv(w, 0);
|
|
}
|
|
|
|
void
|
|
asciz(void)
|
|
{
|
|
asciiz = 1;
|
|
ascii();
|
|
asciiz = 0;
|
|
}
|
|
|
|
void
|
|
sixbitOp(void)
|
|
{
|
|
char delim;
|
|
char c;
|
|
word w;
|
|
int i;
|
|
|
|
skipwhite();
|
|
delim = *lp++;
|
|
if(delim == ';' || delim == '\0'){
|
|
putv(0, 0);
|
|
return;
|
|
}
|
|
w = 0;
|
|
i = 0;
|
|
for(; *lp && *lp != delim; lp++){
|
|
c = ascii2sixbit(*lp);
|
|
if(c < 0){
|
|
err(0, "warning: ignoring non-SIXBIT char %c", *lp);
|
|
continue;
|
|
}
|
|
w = (w<<6) | c;
|
|
if(++i == 6){
|
|
putv(w, 0);
|
|
i = 0;
|
|
w = 0;
|
|
}
|
|
}
|
|
if(*lp != delim)
|
|
err(1, "error: '%c' expected", delim);
|
|
w <<= 36-i*6;
|
|
if(w)
|
|
putv(w, 0);
|
|
}
|
|
|
|
void
|
|
radixOp(void)
|
|
{
|
|
int r;
|
|
Value v;
|
|
|
|
skipwhite();
|
|
if(*lp == '\0' || *lp == ';')
|
|
return;
|
|
r = radix;
|
|
radix = 10;
|
|
v = expr();
|
|
radix = r;
|
|
if(v.val < 2 || v.val > 10)
|
|
err(1, "error: invalid radix %d", v.val);
|
|
else
|
|
radix = v.val;
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
void
|
|
statement(void)
|
|
{
|
|
Token t;
|
|
Value val;
|
|
int type;
|
|
Sym *s;
|
|
char name[8];
|
|
|
|
while(t = token(), t.type != Eol)
|
|
switch(t.type){
|
|
case Symbol:
|
|
s = t.s;
|
|
unsixbit(s->name, name);
|
|
if(*lp == ':'){
|
|
/* label:
|
|
* : label
|
|
* :! label hide
|
|
* :: label internal
|
|
* ::! label internal hide
|
|
*/
|
|
lp++;
|
|
type = Label | Local;
|
|
if(*lp == ':'){
|
|
lp++;
|
|
type |= Intern;
|
|
}
|
|
if(*lp == '!'){
|
|
lp++;
|
|
type |= Hide;
|
|
}
|
|
if(s->type != Undef){
|
|
err(1, "error: redefinition of %s", name);
|
|
return;
|
|
}
|
|
s->type = type;
|
|
s->v = dot->v;
|
|
}else if(*lp == '='){
|
|
/* assignment:
|
|
* = assign
|
|
* == assign hide
|
|
* =: assign internal
|
|
* ==: assign internal hide
|
|
*/
|
|
lp++;
|
|
type = Local;
|
|
if(*lp == '='){
|
|
lp++;
|
|
type |= Hide;
|
|
}
|
|
if(*lp == ':'){
|
|
lp++;
|
|
type |= Intern;
|
|
}
|
|
val = expr();
|
|
if(s->type & Label){
|
|
err(1, "error: redefinition of %s", name);
|
|
return;
|
|
}
|
|
s->type = type;
|
|
s->v = val;
|
|
}else if(s->type == Operator){
|
|
unsixbit(s->name, name);
|
|
opline(s->v.val, 0);
|
|
return;
|
|
}else if(s->type == IoOperator){
|
|
unsixbit(s->name, name);
|
|
opline(s->v.val, 1);
|
|
return;
|
|
}else if(s->type == Pseudo){
|
|
s->f();
|
|
return;
|
|
}else
|
|
goto exp;
|
|
break;
|
|
|
|
exp:
|
|
case Word:
|
|
case Radix10: case Radix8: case Radix2:
|
|
case '-':
|
|
peekt = t;
|
|
val = expr();
|
|
putv(val.val, val.rel);
|
|
break;
|
|
|
|
default:
|
|
err(0, "unknown token %c(%o)", t.type, t.type);
|
|
}
|
|
}
|
|
|
|
void
|
|
dumpsymtab(void)
|
|
{
|
|
char name[8];
|
|
Sym *s;
|
|
for(s = symtab; s < &symtab[MAXSYM]; s++)
|
|
if(s->name && s->type != Operator && s->type != IoOperator){
|
|
unsixbit(s->name, name);
|
|
printf("%s %3o: %012lo %o\n", name, s->type, s->v.val, s->v.rel);
|
|
}
|
|
}
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
panic("usage: %s", argv0);
|
|
}
|
|
|
|
void initsymtab(void);
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
ARGBEGIN{
|
|
default:
|
|
usage();
|
|
break;
|
|
}ARGEND;
|
|
|
|
lineno = 0;
|
|
passno = 1;
|
|
infp = stdin;
|
|
filename = "stdin";
|
|
if(argc){
|
|
filename = argv[0];
|
|
infp = mustopen(filename, "r");
|
|
}
|
|
|
|
initsymtab();
|
|
|
|
{
|
|
Sym *s;
|
|
s = getsym(sixbit("HELLO"));
|
|
s->type = Local;
|
|
s->v.val = 0432100001234;
|
|
s->v.rel = 1;
|
|
s = getsym(sixbit("ASDF"));
|
|
s->type = Extern;
|
|
s->v.val = 0100;
|
|
s->v.rel = 1;
|
|
s = getsym(sixbit("QWERTY"));
|
|
s->type = Label;
|
|
s->v.val = 010;
|
|
s->v.rel = 1;
|
|
s = getsym(sixbit("QWERTYUIOP"));
|
|
}
|
|
|
|
while(lp = getln()){
|
|
peekt.type = Unused;
|
|
printf("%s:%d: %s\n", filename, lineno, lp);
|
|
statement();
|
|
}
|
|
dumpsymtab();
|
|
|
|
fclose(infp);
|
|
if(error)
|
|
panic("Error\n*****");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct Op Op;
|
|
struct Op
|
|
{
|
|
const char *name;
|
|
int type;
|
|
word val;
|
|
};
|
|
|
|
typedef struct Ps Ps;
|
|
struct Ps
|
|
{
|
|
const char *name;
|
|
void (*f)(void);
|
|
};
|
|
|
|
extern Op oplist[];
|
|
extern Ps pslist[];
|
|
void
|
|
initsymtab(void)
|
|
{
|
|
Op *op;
|
|
Ps *ps;
|
|
Sym *s;
|
|
|
|
dot = getsym(sixbit("."));
|
|
dot->type = Local | Hide;
|
|
absdot = (Value){ 0, 0 };
|
|
reldot = (Value){ 0, 1 };
|
|
dot->v = reldot;
|
|
|
|
for(op = oplist; op->name[0]; op++){
|
|
s = getsym(sixbit(op->name));
|
|
s->type = op->type;
|
|
s->v.val = op->val;
|
|
s->v.rel = 0;
|
|
}
|
|
for(ps = pslist; ps->name[0]; ps++){
|
|
s = getsym(sixbit(ps->name));
|
|
s->type = Pseudo;
|
|
s->f = ps->f;
|
|
}
|
|
}
|
|
|
|
Ps pslist[] = {
|
|
{ "INTERNAL", internal },
|
|
{ "EXTERNAL", external },
|
|
{ "XWD", xwd },
|
|
{ "TITLE", title },
|
|
{ "SUBTTL", subttl },
|
|
{ "LOC", locOp },
|
|
{ "RELOC", relocOp },
|
|
{ "ASCII", ascii },
|
|
{ "ASCIZ", asciz },
|
|
{ "SIXBIT", sixbitOp },
|
|
{ "RADIX", radixOp },
|
|
/*
|
|
" '
|
|
RADIX50 SQUOZE
|
|
DEC
|
|
OCT
|
|
EXP
|
|
BYTE
|
|
POINT
|
|
IOWD
|
|
INTEGER
|
|
ARRAY
|
|
BLOCK
|
|
END
|
|
LIT
|
|
ENTRY
|
|
OPDEF
|
|
*/
|
|
{ "", nil }
|
|
};
|
|
|
|
Op oplist[] = {
|
|
{ "Z", Operator, 0 },
|
|
|
|
{ "FSC", Operator, 0132000000000 },
|
|
{ "IBP", Operator, 0133000000000 },
|
|
{ "ILDB", Operator, 0134000000000 },
|
|
{ "LDB", Operator, 0135000000000 },
|
|
{ "IDPB", Operator, 0136000000000 },
|
|
{ "DPB", Operator, 0137000000000 },
|
|
|
|
{ "FAD", Operator, 0140000000000 },
|
|
{ "FADL", Operator, 0141000000000 },
|
|
{ "FADM", Operator, 0142000000000 },
|
|
{ "FADB", Operator, 0143000000000 },
|
|
{ "FADR", Operator, 0144000000000 },
|
|
{ "FADRL", Operator, 0145000000000 },
|
|
{ "FADRM", Operator, 0146000000000 },
|
|
{ "FADRB", Operator, 0147000000000 },
|
|
{ "FSB", Operator, 0150000000000 },
|
|
{ "FSBL", Operator, 0151000000000 },
|
|
{ "FSBM", Operator, 0152000000000 },
|
|
{ "FSBB", Operator, 0153000000000 },
|
|
{ "FSBR", Operator, 0154000000000 },
|
|
{ "FSBRL", Operator, 0155000000000 },
|
|
{ "FSBRM", Operator, 0156000000000 },
|
|
{ "FSBRB", Operator, 0157000000000 },
|
|
{ "FMP", Operator, 0160000000000 },
|
|
{ "FMPL", Operator, 0161000000000 },
|
|
{ "FMPM", Operator, 0162000000000 },
|
|
{ "FMPB", Operator, 0163000000000 },
|
|
{ "FMPR", Operator, 0164000000000 },
|
|
{ "FMPRL", Operator, 0165000000000 },
|
|
{ "FMPRM", Operator, 0166000000000 },
|
|
{ "FMPRB", Operator, 0167000000000 },
|
|
{ "FDV", Operator, 0170000000000 },
|
|
{ "FDVL", Operator, 0171000000000 },
|
|
{ "FDVM", Operator, 0172000000000 },
|
|
{ "FDVB", Operator, 0173000000000 },
|
|
{ "FDVR", Operator, 0174000000000 },
|
|
{ "FDVRL", Operator, 0175000000000 },
|
|
{ "FDVRM", Operator, 0176000000000 },
|
|
{ "FDVRB", Operator, 0177000000000 },
|
|
|
|
{ "MOVE", Operator, 0200000000000 },
|
|
{ "MOVEI", Operator, 0201000000000 },
|
|
{ "MOVEM", Operator, 0202000000000 },
|
|
{ "MOVES", Operator, 0203000000000 },
|
|
{ "MOVS", Operator, 0204000000000 },
|
|
{ "MOVSI", Operator, 0205000000000 },
|
|
{ "MOVSM", Operator, 0206000000000 },
|
|
{ "MOVSS", Operator, 0207000000000 },
|
|
{ "MOVN", Operator, 0210000000000 },
|
|
{ "MOVNI", Operator, 0211000000000 },
|
|
{ "MOVNM", Operator, 0212000000000 },
|
|
{ "MOVNS", Operator, 0213000000000 },
|
|
{ "MOVM", Operator, 0214000000000 },
|
|
{ "MOVMI", Operator, 0215000000000 },
|
|
{ "MOVMM", Operator, 0216000000000 },
|
|
{ "MOVMS", Operator, 0217000000000 },
|
|
|
|
{ "IMUL", Operator, 0220000000000 },
|
|
{ "IMULI", Operator, 0221000000000 },
|
|
{ "IMULM", Operator, 0222000000000 },
|
|
{ "IMULB", Operator, 0223000000000 },
|
|
{ "MUL", Operator, 0224000000000 },
|
|
{ "MULI", Operator, 0225000000000 },
|
|
{ "MULM", Operator, 0226000000000 },
|
|
{ "MULB", Operator, 0227000000000 },
|
|
{ "IDIV", Operator, 0230000000000 },
|
|
{ "IDIVI", Operator, 0231000000000 },
|
|
{ "IDIVM", Operator, 0232000000000 },
|
|
{ "IDIVB", Operator, 0233000000000 },
|
|
{ "DIV", Operator, 0234000000000 },
|
|
{ "DIVI", Operator, 0235000000000 },
|
|
{ "DIVM", Operator, 0236000000000 },
|
|
{ "DIVB", Operator, 0237000000000 },
|
|
|
|
{ "ASH", Operator, 0240000000000 },
|
|
{ "ROT", Operator, 0241000000000 },
|
|
{ "LSH", Operator, 0242000000000 },
|
|
{ "ASHC", Operator, 0244000000000 },
|
|
{ "ROTC", Operator, 0245000000000 },
|
|
{ "LSHC", Operator, 0246000000000 },
|
|
|
|
{ "EXCH", Operator, 0250000000000 },
|
|
{ "BLT", Operator, 0251000000000 },
|
|
{ "AOBJP", Operator, 0252000000000 },
|
|
{ "AOBJN", Operator, 0253000000000 },
|
|
{ "JRST", Operator, 0254000000000 },
|
|
{ "JFCL", Operator, 0255000000000 },
|
|
{ "XCT", Operator, 0256000000000 },
|
|
|
|
{ "PUSHJ", Operator, 0260000000000 },
|
|
{ "PUSH", Operator, 0261000000000 },
|
|
{ "POP", Operator, 0262000000000 },
|
|
{ "POPJ", Operator, 0263000000000 },
|
|
{ "JSR", Operator, 0264000000000 },
|
|
{ "JSP", Operator, 0265000000000 },
|
|
{ "JSA", Operator, 0266000000000 },
|
|
{ "JRA", Operator, 0267000000000 },
|
|
|
|
{ "ADD", Operator, 0270000000000 },
|
|
{ "ADDI", Operator, 0271000000000 },
|
|
{ "ADDM", Operator, 0272000000000 },
|
|
{ "ADDB", Operator, 0273000000000 },
|
|
{ "SUB", Operator, 0274000000000 },
|
|
{ "SUBI", Operator, 0275000000000 },
|
|
{ "SUBM", Operator, 0276000000000 },
|
|
{ "SUBB", Operator, 0277000000000 },
|
|
|
|
{ "CAI", Operator, 0300000000000 },
|
|
{ "CAIL", Operator, 0301000000000 },
|
|
{ "CAIE", Operator, 0302000000000 },
|
|
{ "CAILE", Operator, 0303000000000 },
|
|
{ "CAIA", Operator, 0304000000000 },
|
|
{ "CAIGE", Operator, 0305000000000 },
|
|
{ "CAIN", Operator, 0306000000000 },
|
|
{ "CAIG", Operator, 0307000000000 },
|
|
{ "CAM", Operator, 0310000000000 },
|
|
{ "CAML", Operator, 0311000000000 },
|
|
{ "CAME", Operator, 0312000000000 },
|
|
{ "CAMLE", Operator, 0313000000000 },
|
|
{ "CAMA", Operator, 0314000000000 },
|
|
{ "CAMGE", Operator, 0315000000000 },
|
|
{ "CAMN", Operator, 0316000000000 },
|
|
{ "CAMG", Operator, 0317000000000 },
|
|
{ "JUMP", Operator, 0320000000000 },
|
|
{ "JUMPL", Operator, 0321000000000 },
|
|
{ "JUMPE", Operator, 0322000000000 },
|
|
{ "JUMPLE",Operator, 0323000000000 },
|
|
{ "JUMPA", Operator, 0324000000000 },
|
|
{ "JUMPGE",Operator, 0325000000000 },
|
|
{ "JUMPN", Operator, 0326000000000 },
|
|
{ "JUMPG", Operator, 0327000000000 },
|
|
{ "SKIP", Operator, 0330000000000 },
|
|
{ "SKIPL", Operator, 0331000000000 },
|
|
{ "SKIPE", Operator, 0332000000000 },
|
|
{ "SKIPLE",Operator, 0333000000000 },
|
|
{ "SKIPA", Operator, 0334000000000 },
|
|
{ "SKIPGE",Operator, 0335000000000 },
|
|
{ "SKIPN", Operator, 0336000000000 },
|
|
{ "SKIPG", Operator, 0337000000000 },
|
|
{ "AOJ", Operator, 0340000000000 },
|
|
{ "AOJL", Operator, 0341000000000 },
|
|
{ "AOJE", Operator, 0342000000000 },
|
|
{ "AOJLE", Operator, 0343000000000 },
|
|
{ "AOJA", Operator, 0344000000000 },
|
|
{ "AOJGE", Operator, 0345000000000 },
|
|
{ "AOJN", Operator, 0346000000000 },
|
|
{ "AOJG", Operator, 0347000000000 },
|
|
{ "AOS", Operator, 0350000000000 },
|
|
{ "AOSL", Operator, 0351000000000 },
|
|
{ "AOSE", Operator, 0352000000000 },
|
|
{ "AOSLE", Operator, 0353000000000 },
|
|
{ "AOSA", Operator, 0354000000000 },
|
|
{ "AOSGE", Operator, 0355000000000 },
|
|
{ "AOSN", Operator, 0356000000000 },
|
|
{ "AOSG", Operator, 0357000000000 },
|
|
{ "SOJ", Operator, 0360000000000 },
|
|
{ "SOJL", Operator, 0361000000000 },
|
|
{ "SOJE", Operator, 0362000000000 },
|
|
{ "SOJLE", Operator, 0363000000000 },
|
|
{ "SOJA", Operator, 0364000000000 },
|
|
{ "SOJGE", Operator, 0365000000000 },
|
|
{ "SOJN", Operator, 0366000000000 },
|
|
{ "SOJG", Operator, 0367000000000 },
|
|
{ "SOS", Operator, 0370000000000 },
|
|
{ "SOSL", Operator, 0371000000000 },
|
|
{ "SOSE", Operator, 0372000000000 },
|
|
{ "SOSLE", Operator, 0373000000000 },
|
|
{ "SOSA", Operator, 0374000000000 },
|
|
{ "SOSGE", Operator, 0375000000000 },
|
|
{ "SOSN", Operator, 0376000000000 },
|
|
{ "SOSG", Operator, 0377000000000 },
|
|
|
|
{ "SETZ", Operator, 0400000000000 },
|
|
{ "SETZI", Operator, 0401000000000 },
|
|
{ "SETZM", Operator, 0402000000000 },
|
|
{ "SETZB", Operator, 0403000000000 },
|
|
{ "AND", Operator, 0404000000000 },
|
|
{ "ANDI", Operator, 0405000000000 },
|
|
{ "ANDM", Operator, 0406000000000 },
|
|
{ "ANDB", Operator, 0407000000000 },
|
|
{ "ANDCA", Operator, 0410000000000 },
|
|
{ "ANDCAI",Operator, 0411000000000 },
|
|
{ "ANDCAM",Operator, 0412000000000 },
|
|
{ "ANDCAB",Operator, 0413000000000 },
|
|
{ "SETM", Operator, 0414000000000 },
|
|
{ "SETMI", Operator, 0415000000000 },
|
|
{ "SETMM", Operator, 0416000000000 },
|
|
{ "SETMB", Operator, 0417000000000 },
|
|
{ "ANDCM", Operator, 0420000000000 },
|
|
{ "ANDCMI",Operator, 0421000000000 },
|
|
{ "ANDCMM",Operator, 0422000000000 },
|
|
{ "ANDCMB",Operator, 0423000000000 },
|
|
{ "SETA", Operator, 0424000000000 },
|
|
{ "SETAI", Operator, 0425000000000 },
|
|
{ "SETAM", Operator, 0426000000000 },
|
|
{ "SETAB", Operator, 0427000000000 },
|
|
{ "XOR", Operator, 0430000000000 },
|
|
{ "XORI", Operator, 0431000000000 },
|
|
{ "XORM", Operator, 0432000000000 },
|
|
{ "XORB", Operator, 0433000000000 },
|
|
{ "IOR", Operator, 0434000000000 },
|
|
{ "IORI", Operator, 0435000000000 },
|
|
{ "IORM", Operator, 0436000000000 },
|
|
{ "IORB", Operator, 0437000000000 },
|
|
{ "ANDCB", Operator, 0440000000000 },
|
|
{ "ANDCBI",Operator, 0441000000000 },
|
|
{ "ANDCBM",Operator, 0442000000000 },
|
|
{ "ANDCBB",Operator, 0443000000000 },
|
|
{ "EQV", Operator, 0444000000000 },
|
|
{ "EQVI", Operator, 0445000000000 },
|
|
{ "EQVM", Operator, 0446000000000 },
|
|
{ "EQVB", Operator, 0447000000000 },
|
|
{ "SETCA", Operator, 0450000000000 },
|
|
{ "SETCAI",Operator, 0451000000000 },
|
|
{ "SETCAM",Operator, 0452000000000 },
|
|
{ "SETCAB",Operator, 0453000000000 },
|
|
{ "ORCA", Operator, 0454000000000 },
|
|
{ "ORCAI", Operator, 0455000000000 },
|
|
{ "ORCAM", Operator, 0456000000000 },
|
|
{ "ORCAB", Operator, 0457000000000 },
|
|
{ "SETCM", Operator, 0460000000000 },
|
|
{ "SETCMI",Operator, 0461000000000 },
|
|
{ "SETCMM",Operator, 0462000000000 },
|
|
{ "SETCMB",Operator, 0463000000000 },
|
|
{ "ORCM", Operator, 0464000000000 },
|
|
{ "ORCMI", Operator, 0465000000000 },
|
|
{ "ORCMM", Operator, 0466000000000 },
|
|
{ "ORCMB", Operator, 0467000000000 },
|
|
{ "ORCB", Operator, 0470000000000 },
|
|
{ "ORCBI", Operator, 0471000000000 },
|
|
{ "ORCBM", Operator, 0472000000000 },
|
|
{ "ORCBB", Operator, 0473000000000 },
|
|
{ "SETO", Operator, 0474000000000 },
|
|
{ "SETOI", Operator, 0475000000000 },
|
|
{ "SETOM", Operator, 0476000000000 },
|
|
{ "SETOB", Operator, 0477000000000 },
|
|
|
|
{ "HLL", Operator, 0500000000000 },
|
|
{ "HLLI", Operator, 0501000000000 },
|
|
{ "HLLM", Operator, 0502000000000 },
|
|
{ "HLLS", Operator, 0503000000000 },
|
|
{ "HRL", Operator, 0504000000000 },
|
|
{ "HRLI", Operator, 0505000000000 },
|
|
{ "HRLM", Operator, 0506000000000 },
|
|
{ "HRLS", Operator, 0507000000000 },
|
|
{ "HLLZ", Operator, 0510000000000 },
|
|
{ "HLLZI", Operator, 0511000000000 },
|
|
{ "HLLZM", Operator, 0512000000000 },
|
|
{ "HLLZS", Operator, 0513000000000 },
|
|
{ "HRLZ", Operator, 0514000000000 },
|
|
{ "HRLZI", Operator, 0515000000000 },
|
|
{ "HRLZM", Operator, 0516000000000 },
|
|
{ "HRLZS", Operator, 0517000000000 },
|
|
{ "HLLO", Operator, 0520000000000 },
|
|
{ "HLLOI", Operator, 0521000000000 },
|
|
{ "HLLOM", Operator, 0522000000000 },
|
|
{ "HLLOS", Operator, 0523000000000 },
|
|
{ "HRLO", Operator, 0524000000000 },
|
|
{ "HRLOI", Operator, 0525000000000 },
|
|
{ "HRLOM", Operator, 0526000000000 },
|
|
{ "HRLOS", Operator, 0527000000000 },
|
|
{ "HLLE", Operator, 0530000000000 },
|
|
{ "HLLEI", Operator, 0531000000000 },
|
|
{ "HLLEM", Operator, 0532000000000 },
|
|
{ "HLLES", Operator, 0533000000000 },
|
|
{ "HRLE", Operator, 0534000000000 },
|
|
{ "HRLEI", Operator, 0535000000000 },
|
|
{ "HRLEM", Operator, 0536000000000 },
|
|
{ "HRLES", Operator, 0537000000000 },
|
|
{ "HRR", Operator, 0540000000000 },
|
|
{ "HRRI", Operator, 0541000000000 },
|
|
{ "HRRM", Operator, 0542000000000 },
|
|
{ "HRRS", Operator, 0543000000000 },
|
|
{ "HLR", Operator, 0544000000000 },
|
|
{ "HLRI", Operator, 0545000000000 },
|
|
{ "HLRM", Operator, 0546000000000 },
|
|
{ "HLRS", Operator, 0547000000000 },
|
|
{ "HRRZ", Operator, 0550000000000 },
|
|
{ "HRRZI", Operator, 0551000000000 },
|
|
{ "HRRZM", Operator, 0552000000000 },
|
|
{ "HRRZS", Operator, 0553000000000 },
|
|
{ "HLRZ", Operator, 0554000000000 },
|
|
{ "HLRZI", Operator, 0555000000000 },
|
|
{ "HLRZM", Operator, 0556000000000 },
|
|
{ "HLRZS", Operator, 0557000000000 },
|
|
{ "HRRO", Operator, 0560000000000 },
|
|
{ "HRROI", Operator, 0561000000000 },
|
|
{ "HRROM", Operator, 0562000000000 },
|
|
{ "HRROS", Operator, 0563000000000 },
|
|
{ "HLRO", Operator, 0564000000000 },
|
|
{ "HLROI", Operator, 0565000000000 },
|
|
{ "HLROM", Operator, 0566000000000 },
|
|
{ "HLROS", Operator, 0567000000000 },
|
|
{ "HRRE", Operator, 0570000000000 },
|
|
{ "HRREI", Operator, 0571000000000 },
|
|
{ "HRREM", Operator, 0572000000000 },
|
|
{ "HRRES", Operator, 0573000000000 },
|
|
{ "HLRE", Operator, 0574000000000 },
|
|
{ "HLREI", Operator, 0575000000000 },
|
|
{ "HLREM", Operator, 0576000000000 },
|
|
{ "HLRES", Operator, 0577000000000 },
|
|
|
|
{ "TRN", Operator, 0600000000000 },
|
|
{ "TLN", Operator, 0601000000000 },
|
|
{ "TRNE", Operator, 0602000000000 },
|
|
{ "TLNE", Operator, 0603000000000 },
|
|
{ "TRNA", Operator, 0604000000000 },
|
|
{ "TLNA", Operator, 0605000000000 },
|
|
{ "TRNN", Operator, 0606000000000 },
|
|
{ "TLNN", Operator, 0607000000000 },
|
|
{ "TDN", Operator, 0610000000000 },
|
|
{ "TSN", Operator, 0611000000000 },
|
|
{ "TDNE", Operator, 0612000000000 },
|
|
{ "TSNE", Operator, 0613000000000 },
|
|
{ "TDNA", Operator, 0614000000000 },
|
|
{ "TSNA", Operator, 0615000000000 },
|
|
{ "TDNN", Operator, 0616000000000 },
|
|
{ "TSNN", Operator, 0617000000000 },
|
|
{ "TRZ", Operator, 0620000000000 },
|
|
{ "TLZ", Operator, 0621000000000 },
|
|
{ "TRZE", Operator, 0622000000000 },
|
|
{ "TLZE", Operator, 0623000000000 },
|
|
{ "TRZA", Operator, 0624000000000 },
|
|
{ "TLZA", Operator, 0625000000000 },
|
|
{ "TRZN", Operator, 0626000000000 },
|
|
{ "TLZN", Operator, 0627000000000 },
|
|
{ "TDZ", Operator, 0630000000000 },
|
|
{ "TSZ", Operator, 0631000000000 },
|
|
{ "TDZE", Operator, 0632000000000 },
|
|
{ "TSZE", Operator, 0633000000000 },
|
|
{ "TDZA", Operator, 0634000000000 },
|
|
{ "TSZA", Operator, 0635000000000 },
|
|
{ "TDZN", Operator, 0636000000000 },
|
|
{ "TSZN", Operator, 0637000000000 },
|
|
{ "TRC", Operator, 0640000000000 },
|
|
{ "TLC", Operator, 0641000000000 },
|
|
{ "TRCE", Operator, 0642000000000 },
|
|
{ "TLCE", Operator, 0643000000000 },
|
|
{ "TRCA", Operator, 0644000000000 },
|
|
{ "TLCA", Operator, 0645000000000 },
|
|
{ "TRCN", Operator, 0646000000000 },
|
|
{ "TLCN", Operator, 0647000000000 },
|
|
{ "TDC", Operator, 0650000000000 },
|
|
{ "TSC", Operator, 0651000000000 },
|
|
{ "TDCE", Operator, 0652000000000 },
|
|
{ "TSCE", Operator, 0653000000000 },
|
|
{ "TDCA", Operator, 0654000000000 },
|
|
{ "TSCA", Operator, 0655000000000 },
|
|
{ "TDCN", Operator, 0656000000000 },
|
|
{ "TSCN", Operator, 0657000000000 },
|
|
{ "TRO", Operator, 0660000000000 },
|
|
{ "TLO", Operator, 0661000000000 },
|
|
{ "TROE", Operator, 0662000000000 },
|
|
{ "TLOE", Operator, 0663000000000 },
|
|
{ "TROA", Operator, 0664000000000 },
|
|
{ "TLOA", Operator, 0665000000000 },
|
|
{ "TRON", Operator, 0666000000000 },
|
|
{ "TLON", Operator, 0667000000000 },
|
|
{ "TDO", Operator, 0670000000000 },
|
|
{ "TSO", Operator, 0671000000000 },
|
|
{ "TDOE", Operator, 0672000000000 },
|
|
{ "TSOE", Operator, 0673000000000 },
|
|
{ "TDOA", Operator, 0674000000000 },
|
|
{ "TSOA", Operator, 0675000000000 },
|
|
{ "TDON", Operator, 0676000000000 },
|
|
{ "TSON", Operator, 0677000000000 },
|
|
|
|
{ "BLKI", IoOperator, 0700000000000 },
|
|
{ "BLKO", IoOperator, 0700100000000 },
|
|
{ "DATAI", IoOperator, 0700040000000 },
|
|
{ "DATAO", IoOperator, 0700140000000 },
|
|
{ "CONO", IoOperator, 0700200000000 },
|
|
{ "CONI", IoOperator, 0700240000000 },
|
|
{ "CONSZ", IoOperator, 0700300000000 },
|
|
{ "CONSO", IoOperator, 0700340000000 },
|
|
|
|
{ "JEN", Operator, 0254500000000 },
|
|
{ "HALT", Operator, 0254200000000 },
|
|
{ "JRSTF", Operator, 0254100000000 },
|
|
{ "JOV", Operator, 0255400000000 },
|
|
{ "JCRY0", Operator, 0255200000000 },
|
|
{ "JCRY1", Operator, 0255100000000 },
|
|
{ "JCRY", Operator, 0255300000000 },
|
|
{ "JFOV", Operator, 0255040000000 },
|
|
{ "RSW", IoOperator, 0700040000000 },
|
|
|
|
{ "", 0, 0 }
|
|
};
|