792 lines
32 KiB
C
792 lines
32 KiB
C
/* sds_sys.c: SDS 940 simulator interface
|
|
|
|
Copyright (c) 2001-2016, Robert M Supnik
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and associated documentation files (the "Software"),
|
|
to deal in the Software without restriction, including without limitation
|
|
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
and/or sell copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of Robert M Supnik shall not be
|
|
used in advertising or otherwise to promote the sale, use or other dealings
|
|
in this Software without prior written authorization from Robert M Supnik.
|
|
|
|
05-May-16 RMS Fixed ascii-to-sds940 data (Mark Pizzolato)
|
|
19-Mar-12 RMS Fixed declarations of CCT arrays (Mark Pizzolato)
|
|
*/
|
|
|
|
#include "sds_defs.h"
|
|
#include <ctype.h>
|
|
#define FMTASC(x) ((x) < 040)? "<%03o>": "%c", (x)
|
|
|
|
extern DEVICE cpu_dev;
|
|
extern DEVICE chan_dev;
|
|
extern DEVICE ptr_dev;
|
|
extern DEVICE ptp_dev;
|
|
extern DEVICE tti_dev;
|
|
extern DEVICE tto_dev;
|
|
extern DEVICE lpt_dev;
|
|
extern DEVICE rtc_dev;
|
|
extern DEVICE drm_dev;
|
|
extern DEVICE rad_dev;
|
|
extern DEVICE dsk_dev;
|
|
extern DEVICE mt_dev;
|
|
extern DEVICE mux_dev, muxl_dev;
|
|
extern UNIT cpu_unit;
|
|
extern REG cpu_reg[];
|
|
extern uint32 cpu_mode;
|
|
extern uint32 M[MAXMEMSIZE];
|
|
|
|
/* SCP data structures and interface routines
|
|
|
|
sim_name simulator name string
|
|
sim_PC pointer to saved PC register descriptor
|
|
sim_emax number of words for examine
|
|
sim_devices array of pointers to simulated devices
|
|
sim_stop_messages array of pointers to stop messages
|
|
sim_load binary loader
|
|
*/
|
|
|
|
char sim_name[] = "SDS 940";
|
|
|
|
REG *sim_PC = &cpu_reg[0];
|
|
|
|
int32 sim_emax = 1;
|
|
|
|
DEVICE *sim_devices[] = {
|
|
&cpu_dev,
|
|
&chan_dev,
|
|
&ptr_dev,
|
|
&ptp_dev,
|
|
&tti_dev,
|
|
&tto_dev,
|
|
&lpt_dev,
|
|
&rtc_dev,
|
|
&drm_dev,
|
|
&rad_dev,
|
|
&dsk_dev,
|
|
&mt_dev,
|
|
&mux_dev,
|
|
&muxl_dev,
|
|
NULL
|
|
};
|
|
|
|
const char *sim_stop_messages[] = {
|
|
"Unknown error",
|
|
"IO device not ready",
|
|
"HALT instruction",
|
|
"Breakpoint",
|
|
"Invalid IO device",
|
|
"Invalid instruction",
|
|
"Invalid I/O operation",
|
|
"Nested indirects exceed limit",
|
|
"Nested EXU's exceed limit",
|
|
"Memory management trap during interrupt",
|
|
"Memory management trap during trap",
|
|
"Trap instruction not BRM or BRU",
|
|
"RTC instruction not MIN or SKR",
|
|
"Interrupt vector zero",
|
|
"Runaway carriage control tape",
|
|
"Monitor-mode Breakpoint",
|
|
"Normal-mode Breakpoint",
|
|
"User-mode Breakpoint",
|
|
"Next expired"
|
|
};
|
|
|
|
/* SDS 930 character conversion tables. Per 930 Ref Man Appendix A */
|
|
|
|
const int8 sds930_to_ascii[64] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', ' ', '=', '\'', ':', '>', '%', /* 17 = check mark */
|
|
'+', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
|
|
'H', 'I', '?', '.', ')', '[', '<', '@', /* 37 = stop code */
|
|
'-', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
|
|
'Q', 'R', '!', '$', '*', ']', ';', '^', /* 57 = triangle */
|
|
'_', '/', 'S', 'T', 'U', 'V', 'W', 'X',
|
|
'Y', 'Z', '?', ',', '(', '~', '\\', '#' /* 72 = rec mark */
|
|
}; /* 75 = squiggle, 77 = del */
|
|
|
|
const int8 ascii_to_sds930[128] = {
|
|
-1, -1, -1, -1, -1, -1, -1, -1, /* 00 - 37 */
|
|
032, 072, -1, -1, -1, 052, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
012, 052, -1, 077, 053, 017, -1, 014, /* 40 - 77 */
|
|
074, 034, 054, 020, 073, 040, 033, 061,
|
|
000, 001, 002, 003, 004, 005, 006, 007,
|
|
010, 011, 015, 056, 036, 013, 016, 072,
|
|
037, 021, 022, 023, 024, 025, 026, 027, /* 100 - 137 */
|
|
030, 031, 041, 042, 043, 044, 045, 046,
|
|
047, 050, 051, 062, 063, 064, 065, 066,
|
|
067, 070, 071, 035, 076, 055, 057, 060,
|
|
-1, 021, 022, 023, 024, 025, 026, 027, /* 140 - 177 */
|
|
030, 031, 041, 042, 043, 044, 045, 046, /* fold lower case to upper */
|
|
047, 050, 051, 062, 063, 064, 065, 066,
|
|
067, 070, 071, -1, -1, -1, -1, -1
|
|
};
|
|
|
|
/* SDS 940 character conversion tables. Per 940 Ref Man Appendix A */
|
|
|
|
const int8 sds940_to_ascii[64] = {
|
|
' ', '!', '"', '#', '$', '%', '&', '\'', /* 00 - 17 */
|
|
'(', ')', '*', '+', ',', '-', '.', '/',
|
|
'0', '1', '2', '3', '4', '5', '6', '7', /* 20 - 37 */
|
|
'8', '9', ':', ';', '<', '=', '>', '?',
|
|
'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', /* 40 - 57 */
|
|
'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
|
|
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', /* 60 - 77 */
|
|
'X', 'Y', 'Z', '[', '\\', ']', '^', '_'
|
|
};
|
|
|
|
const int8 ascii_to_sds940[128] = {
|
|
-1, 0141, 0142, 0143, 0144, 0145, 0146, 0147, /* 00 - 37 */
|
|
-1, 0151, 0152, 0153, 0154, 0155, -1, -1,
|
|
-1, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
|
|
0170, 0171, 0172, -1, -1, -1, -1, -1,
|
|
000, 001, 002, 003, 004, 005, 006, 007, /* 40 - 77 */
|
|
010, 011, 012, 013, 014, 015, 016, 017,
|
|
020, 021, 022, 023, 024, 025, 026, 027,
|
|
030, 031, 032, 033, 034, 035, 036, 037,
|
|
040, 041, 042, 043, 044, 045, 046, 047, /* 100 - 137 */
|
|
050, 051, 052, 053, 054, 055, 056, 057,
|
|
060, 061, 062, 063, 064, 065, 066, 067,
|
|
070, 071, 072, 073, 074, 075, 076, 077,
|
|
-1, 041, 042, 043, 044, 045, 046, 047, /* 140 - 177 */
|
|
050, 051, 052, 053, 054, 055, 056, 057, /* fold lower case to upper */
|
|
060, 061, 062, 063, 064, 065, 066, 067,
|
|
070, 071, 072, -1, -1, -1, -1, -1
|
|
};
|
|
|
|
const int8 odd_par[64] = {
|
|
0100, 0001, 0002, 0103, 0004, 0105, 0106, 0007,
|
|
0010, 0111, 0112, 0013, 0114, 0015, 0016, 0117,
|
|
0020, 0121, 0122, 0023, 0124, 0025, 0026, 0127,
|
|
0130, 0031, 0032, 0133, 0034, 0135, 0136, 0037,
|
|
0040, 0141, 0142, 0043, 0144, 0045, 0046, 0147,
|
|
0150, 0051, 0052, 0153, 0054, 0155, 0156, 0057,
|
|
0160, 0061, 0062, 0163, 0064, 0165, 0166, 0067,
|
|
0070, 0171, 0172, 0073, 0174, 0075, 0076, 0177
|
|
};
|
|
|
|
/* Load carriage control tape
|
|
|
|
A carriage control tape consists of entries of the form
|
|
|
|
(repeat count) column number,column number,column number,...
|
|
|
|
The CCT entries are stored in lpt_cct[0:lnt-1], lpt_ccl contains the
|
|
number of entries
|
|
*/
|
|
|
|
t_stat sim_load_cct (FILE *fileref)
|
|
{
|
|
int32 col, rpt, ptr, mask, cctbuf[CCT_LNT];
|
|
t_stat r;
|
|
extern int32 lpt_ccl, lpt_ccp;
|
|
extern uint8 lpt_cct[CCT_LNT];
|
|
CONST char *cptr;
|
|
char cbuf[CBUFSIZE], gbuf[CBUFSIZE];
|
|
|
|
ptr = 0;
|
|
for ( ; (cptr = fgets (cbuf, CBUFSIZE, fileref)) != NULL; ) { /* until eof */
|
|
mask = 0;
|
|
if (*cptr == '(') { /* repeat count? */
|
|
cptr = get_glyph (cptr + 1, gbuf, ')'); /* get 1st field */
|
|
rpt = get_uint (gbuf, 10, CCT_LNT, &r); /* repeat count */
|
|
if (r != SCPE_OK)
|
|
return SCPE_FMT;
|
|
}
|
|
else rpt = 1;
|
|
while (*cptr != 0) { /* get col no's */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
col = get_uint (gbuf, 10, 7, &r); /* column number */
|
|
if (r != SCPE_OK)
|
|
return SCPE_FMT;
|
|
mask = mask | (1 << col); /* set bit */
|
|
}
|
|
for ( ; rpt > 0; rpt--) { /* store vals */
|
|
if (ptr >= CCT_LNT)
|
|
return SCPE_FMT;
|
|
cctbuf[ptr++] = mask;
|
|
}
|
|
}
|
|
if (ptr == 0) return SCPE_FMT;
|
|
lpt_ccl = ptr;
|
|
lpt_ccp = 0;
|
|
for (rpt = 0; rpt < lpt_ccl; rpt++)
|
|
lpt_cct[rpt] = cctbuf[rpt];
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Load command. -l means load a line printer tape. Otherwise, load
|
|
a bootstrap paper tape.
|
|
*/
|
|
|
|
int32 get_word (FILE *fileref, int32 *ldr)
|
|
{
|
|
int32 i, c, wd;
|
|
|
|
for (i = wd = 0; i < 4; ) {
|
|
if ((c = fgetc (fileref)) == EOF)
|
|
return -1;
|
|
if ((c == 0) && (*ldr == 0))
|
|
return -1;
|
|
if (c == 0)
|
|
continue;
|
|
*ldr = 0;
|
|
wd = (wd << 6) | (c & 077);
|
|
i++;
|
|
}
|
|
return wd;
|
|
}
|
|
|
|
t_stat sim_load (FILE *fileref, CONST char *cptr, CONST char *fnam, int flag)
|
|
{
|
|
int32 i, wd, buf[8];
|
|
int32 ldr = 1;
|
|
extern uint32 P;
|
|
|
|
if ((*cptr != 0) || (flag != 0))
|
|
return SCPE_ARG;
|
|
if (sim_switches & SWMASK ('L'))
|
|
return sim_load_cct (fileref);
|
|
for (i = 0; i < 8; i++) { /* read boot */
|
|
if ((wd = get_word (fileref, &ldr)) < 0)
|
|
return SCPE_FMT;
|
|
buf[i] = wd;
|
|
}
|
|
if ((buf[0] != 023200012) || /* 2 = WIM 12,2 */
|
|
(buf[1] != 004100002) || /* 3 = BRX 2 */
|
|
(buf[2] != 007100011) || /* 4 = LDX 11 */
|
|
((buf[3] & ~VA_MASK) != 023200000) || /* 5 = WIM xxxxx,2 */
|
|
(buf[4] != 004021000) || /* 6 = SKS 21000 */
|
|
(buf[5] != 004100005)) /* 7 = BRX 5 */
|
|
return SCPE_FMT;
|
|
for (i = 0; i < 8; i++) /* copy boot */
|
|
M[i + 2] = buf[i];
|
|
if (I_GETOP (buf[6]) == BRU)
|
|
P = buf[6] & VA_MASK;
|
|
for (i = (buf[3]+buf[7]) & VA_MASK; i <= VA_MASK; i++) {/* load data */
|
|
if ((wd = get_word (fileref, &ldr)) < 0)
|
|
return SCPE_OK;
|
|
M[i] = wd;
|
|
}
|
|
return SCPE_NXM;
|
|
}
|
|
|
|
/* Symbol tables */
|
|
|
|
#define I_V_FL 24 /* inst class */
|
|
#define I_M_FL 017 /* class mask */
|
|
#define I_V_NPN 000 /* no operand */
|
|
#define I_V_PPO 001 /* POP */
|
|
#define I_V_IOI 002 /* IO */
|
|
#define I_V_MRF 003 /* memory reference */
|
|
#define I_V_REG 004 /* register change */
|
|
#define I_V_SHF 005 /* shift */
|
|
#define I_V_OPO 006 /* operand optional */
|
|
#define I_V_CHC 007 /* chan cmd */
|
|
#define I_V_CHT 010 /* chan test */
|
|
#define I_V_SPP 011 /* system POP */
|
|
#define I_NPN (I_V_NPN << I_V_FL)
|
|
#define I_PPO (I_V_PPO << I_V_FL)
|
|
#define I_IOI (I_V_IOI << I_V_FL)
|
|
#define I_MRF (I_V_MRF << I_V_FL)
|
|
#define I_REG (I_V_REG << I_V_FL)
|
|
#define I_SHF (I_V_SHF << I_V_FL)
|
|
#define I_OPO (I_V_OPO << I_V_FL)
|
|
#define I_CHC (I_V_CHC << I_V_FL)
|
|
#define I_CHT (I_V_CHT << I_V_FL)
|
|
#define I_SPP (I_V_SPP << I_V_FL)
|
|
|
|
static const int32 masks[] = {
|
|
037777777, 010000000, 017700000, /* NPN, PPO, IOI */
|
|
017740000, 017700000, 017774000, /* MRF, REG, SHF */
|
|
017740000, 017377677, 027737677, /* OPO, CHC, CHT */
|
|
057740000 /* SPP */
|
|
};
|
|
|
|
static const char *opcode[] = { /* Note: syspops must preceed generic pop */
|
|
"WSI", "SWI", "BKPT","STO",
|
|
"WCD", "STI", "GCD", "SIC",
|
|
"ISC", "DBI", "DBO", "DWI",
|
|
"DWO", "LAS", "SAS", "IST",
|
|
"OST", "EXS", "FDV", "FMP",
|
|
"FSB", "FAD", "WCI", "WIO",
|
|
"CIO", "SKSG","SKSE","WCH",
|
|
"GCI", "LDP", "STP", "SBRM",
|
|
"SBRR","CTRL","BRS", "TCI",
|
|
"TCO", "BIO",
|
|
|
|
"WSI*", "SWI*", "BKPT*","STO*",
|
|
"WCD*", "STI*", "GCD*", "SIC*",
|
|
"ISC*", "DBI*", "DBO*", "DWI*",
|
|
"DWO*", "LAS*", "SAS*", "IST*",
|
|
"OST*", "EXS*", "FDV*", "FMP*",
|
|
"FSB*", "FAD*", "WCI*", "WIO*",
|
|
"CIO*", "SKSG*","SKSE*","WCH*",
|
|
"GCI*", "LDP*", "STP*", "SBRM*",
|
|
"SBRR*","CTRL*","BRS*", "TCI*",
|
|
"TCO*", "BIO*",
|
|
|
|
"POP", "EIR", "DIR",
|
|
"ROV", "REO", "OTO", "OVT",
|
|
"IDT", "IET",
|
|
"BPT4", "BPT3", "BPT2", "BPT1",
|
|
"CLAB", "ABC", "BAC", "XAB",
|
|
"XXB", "STE", "LDE", "XEE",
|
|
"CLEAR",
|
|
|
|
"HLT", "BRU", "EOM", "EOD",
|
|
"MIY", "BRI", "MIW", "POT",
|
|
"ETR", "MRG", "EOR",
|
|
"NOP", "EXU",
|
|
"YIM", "WIM", "PIN",
|
|
"STA", "STB", "STX",
|
|
"SKS", "BRX", "BRM",
|
|
"SKE", "BRR", "SKB", "SKN",
|
|
"SUB", "ADD", "SUC", "ADC",
|
|
"SKR", "MIN", "XMA", "ADM",
|
|
"MUL", "DIV",
|
|
"SKM", "LDX", "SKA", "SKG",
|
|
"SKD", "LDB", "LDA", "EAX",
|
|
|
|
"BRU*",
|
|
"MIY*", "BRI*", "MIW*", "POT*",
|
|
"ETR*", "MRG*", "EOR*",
|
|
"NOP*", "EXU*",
|
|
"YIM*", "WIM*", "PIN*",
|
|
"STA*", "STB*", "STX*",
|
|
"BRX*", "BRM*",
|
|
"SKE*", "BRR*", "SKB*", "SKN*",
|
|
"SUB*", "ADD*", "SUC*", "ADC*",
|
|
"SKR*", "MIN*", "XMA*", "ADM*",
|
|
"MUL*", "DIV*",
|
|
"SKM*", "LDX*", "SKA*", "SKG*",
|
|
"SKD*", "LDB*", "LDA*", "EAX*",
|
|
|
|
"RSH", "RCY", "LRSH",
|
|
"LSH", "NOD", "LCY",
|
|
"RSH*", "LSH*",
|
|
|
|
"ALC", "DSC", "ASC", "TOP",
|
|
"CAT", "CET", "CZT", "CIT",
|
|
|
|
"CLA", "CLB", "CAB", /* encode only */
|
|
"CBA", "CBX", "CXB",
|
|
"XPO", "CXA", "CAX",
|
|
"CNA", "CLX", NULL,
|
|
NULL
|
|
};
|
|
|
|
static const int32 opc_val[] = {
|
|
050000000+I_SPP, 050100000+I_SPP, 053300000+I_SPP, 053400000+I_SPP, /* WSI, SWI, BKPT, STO, */
|
|
053500000+I_SPP, 053600000+I_SPP, 053700000+I_SPP, 054000000+I_SPP, /* WCD, STI, GCD, SIC, */
|
|
054100000+I_SPP, 054200000+I_SPP, 054300000+I_SPP, 054400000+I_SPP, /* ISC, DBI, DBO, DWI, */
|
|
054500000+I_SPP, 054600000+I_SPP, 054700000+I_SPP, 055000000+I_SPP, /* DWO, LAS, SAS, IST, */
|
|
055100000+I_SPP, 055200000+I_SPP, 055300000+I_SPP, 055400000+I_SPP, /* OST, EXS, FDV, FMP, */
|
|
055500000+I_SPP, 055600000+I_SPP, 055700000+I_SPP, 056000000+I_SPP, /* FSB, FAD, WCI, WIO, */
|
|
056100000+I_SPP, 056200000+I_SPP, 056300000+I_SPP, 056400000+I_SPP, /* CIO, SKSG, SKSE, WCH, */
|
|
056500000+I_SPP, 056600000+I_SPP, 056700000+I_SPP, 057000000+I_SPP, /* GCI, LDP, STP, SBRM,*/
|
|
057100000+I_SPP, 057200000+I_SPP, 057300000+I_SPP, 057400000+I_SPP, /* SBRR, CTRL, BRS, TCI, */
|
|
057500000+I_SPP, 057600000+I_SPP, /* TCO, BIO, */
|
|
|
|
054000000+I_SPP, 050140000+I_SPP, 053340000+I_SPP, 053440000+I_SPP, /* WSI*, SWI*, BKPT*, STO*, */
|
|
053540000+I_SPP, 053640000+I_SPP, 053740000+I_SPP, 054400000+I_SPP, /* WCD*, STI*, GCD*, SIC*, */
|
|
054140000+I_SPP, 054240000+I_SPP, 054340000+I_SPP, 054440000+I_SPP, /* ISC*, DBI*, DBO*, DWI*, */
|
|
054540000+I_SPP, 054640000+I_SPP, 054740000+I_SPP, 055400000+I_SPP, /* DWO*, LAS*, SAS*, IST*, */
|
|
055140000+I_SPP, 055240000+I_SPP, 055340000+I_SPP, 055440000+I_SPP, /* OST*, EXS*, FDV*, FMP*, */
|
|
055540000+I_SPP, 055640000+I_SPP, 055740000+I_SPP, 056400000+I_SPP, /* FSB*, FAD*, WCI*, WIO*, */
|
|
056140000+I_SPP, 056240000+I_SPP, 056340000+I_SPP, 056440000+I_SPP, /* CIO*, SKSG*, SKSE*, WCH*, */
|
|
056540000+I_SPP, 056640000+I_SPP, 056740000+I_SPP, 057400000+I_SPP, /* GCI*, LDP*, STP*, SBRM*,*/
|
|
057140000+I_SPP, 057240000+I_SPP, 057340000+I_SPP, 057440000+I_SPP, /* SBRR*, CTRL*, BRS*, TCI*, */
|
|
057540000+I_SPP, 057640000+I_SPP, /* TCO*, BIO*, */
|
|
|
|
010000000+I_PPO, 000220002+I_NPN, 000220004+I_NPN, /* POP, EIR, DIR, */
|
|
002200001+I_NPN, 002200010+I_NPN, 002200100+I_NPN, 002200101+I_NPN, /* ROV, REO, OTO, OVT, */
|
|
004020002+I_NPN, 004020004+I_NPN, /* IDT, IET, */
|
|
004020040+I_NPN, 004020100+I_NPN, 004020200+I_NPN, 004020400+I_NPN, /* BPT4, BPT3, BPT2, BPT1, */
|
|
004600003+I_NPN, 004600005+I_NPN, 004600012+I_NPN, 004600014+I_NPN, /* CLAB, ABC, BAC, XAB, */
|
|
004600060+I_NPN, 004600122+I_NPN, 004600140+I_NPN, 004600160+I_NPN, /* XXB, STE, LDE, XEE, */
|
|
024600003+I_NPN, /* CLEAR, */
|
|
|
|
000000000+I_NPN, 000100000+I_MRF, 000200000+I_IOI, 000600000+I_IOI, /* HLT, BRU, EOM, EOD, */
|
|
001000000+I_MRF, 001100000+I_MRF, 001200000+I_MRF, 001300000+I_MRF, /* MIY, BRI, MIW, POT, */
|
|
001400000+I_MRF, 001600000+I_MRF, 001700000+I_MRF, /* ETR, MRG, EOR, */
|
|
002000000+I_OPO, 002300000+I_MRF, /* NOP, EXU, */
|
|
003000000+I_MRF, 003200000+I_MRF, 003300000+I_MRF, /* YIM, WIM, PIN, */
|
|
003500000+I_MRF, 003600000+I_MRF, 003700000+I_MRF, /* STA, STB, STX, */
|
|
004000000+I_IOI, 004100000+I_MRF, 004300000+I_MRF, /* SKS, BRX, BRM, */
|
|
005000000+I_MRF, 005100000+I_MRF, 005200000+I_MRF, 005300000+I_MRF, /* SKE, BRR, SKB, SKN, */
|
|
005400000+I_MRF, 005500000+I_MRF, 005600000+I_MRF, 005700000+I_MRF, /* SUB, ADD, SUC, ADC, */
|
|
006000000+I_MRF, 006100000+I_MRF, 006200000+I_MRF, 006300000+I_MRF, /* SKR, MIN, XMA, ADM, */
|
|
006400000+I_MRF, 006500000+I_MRF, /* MUL, DIV, */
|
|
007000000+I_MRF, 007100000+I_MRF, 007200000+I_MRF, 007300000+I_MRF, /* SKM, LDX, SKA, SKG, */
|
|
007400000+I_MRF, 007500000+I_MRF, 007600000+I_MRF, 007700000+I_MRF, /* SKD, LDB, LDA, EAX, */
|
|
|
|
000140000+I_MRF, /* BRU*, */
|
|
001040000+I_MRF, 001140000+I_MRF, 001240000+I_MRF, 001340000+I_MRF, /* MIY*, BRI*, MIW*, POT*, */
|
|
001440000+I_MRF, 001640000+I_MRF, 001740000+I_MRF, /* ETR*, MRG*, EOR*, */
|
|
002040000+I_OPO, 002340000+I_MRF, /* NOP*, EXU*, */
|
|
003040000+I_MRF, 003240000+I_MRF, 003340000+I_MRF, /* YIM*, WIM*, PIN*, */
|
|
003540000+I_MRF, 003640000+I_MRF, 003740000+I_MRF, /* STA*, STB*, STX*, */
|
|
004140000+I_MRF, 004340000+I_MRF, /* BRX*, BRM*, */
|
|
005040000+I_MRF, 005140000+I_MRF, 005240000+I_MRF, 005340000+I_MRF, /* SKE*, BRR*, SKB*, SKN*, */
|
|
005440000+I_MRF, 005540000+I_MRF, 005640000+I_MRF, 005740000+I_MRF, /* SUB*, ADD*, SUC*, ADC*, */
|
|
006040000+I_MRF, 006140000+I_MRF, 006240000+I_MRF, 006340000+I_MRF, /* SKR*, MIN*, XMA*, ADM*, */
|
|
006440000+I_MRF, 006540000+I_MRF, /* MUL*, DIV*, */
|
|
007040000+I_MRF, 007140000+I_MRF, 007240000+I_MRF, 007340000+I_MRF, /* SKM*, LDX*, SKA*, SKG*, */
|
|
007440000+I_MRF, 007540000+I_MRF, 007640000+I_MRF, 007740000+I_MRF, /* SKD*, LDB*, LDA*, EAX*, */
|
|
|
|
006600000+I_SHF, 006620000+I_SHF, 006624000+I_SHF, /* RSH, RCY, LRSH, */
|
|
006700000+I_SHF, 006710000+I_SHF, 006720000+I_SHF, /* LSH, NOD, LCY, */
|
|
006640000+I_MRF, 006740000+I_MRF, /* RSH*, LSH*, */
|
|
|
|
000250000+I_CHC, 000200000+I_CHC, 000212000+I_CHC, 000214000+I_CHC, /* ALC, DSC, ASC, TOP, */
|
|
004014000+I_CHT, 004011000+I_CHT, 004012000+I_CHT, 004010400+I_CHT, /* CAT, CET, CZT, CIT, */
|
|
|
|
004600001+I_REG, 004600002+I_REG, 004600004+I_REG, /* CLA, CLB, CAB, */
|
|
004600010+I_REG, 004600020+I_REG, 004600040+I_REG, /* CBA, CBX, CXB, */
|
|
004600100+I_REG, 004600200+I_REG, 004600400+I_REG, /* XPO, CXA, CAX, */
|
|
004601000+I_REG, 024600000+I_REG, 004600000+I_REG, /* CNA, CLX, NULL, */
|
|
-1
|
|
};
|
|
|
|
static const char *chname[] = {
|
|
"W", "Y", "C", "D", "E", "F", "G", "H", NULL
|
|
};
|
|
|
|
/* Register change decode
|
|
|
|
Inputs:
|
|
*of = output stream
|
|
inst = mask bits
|
|
*/
|
|
|
|
void fprint_reg (FILE *of, int32 inst)
|
|
{
|
|
int32 i, j, sp;
|
|
|
|
inst = inst & ~(I_M_OP << I_V_OP); /* clear opcode */
|
|
for (i = sp = 0; opc_val[i] >= 0; i++) { /* loop thru ops */
|
|
j = (opc_val[i] >> I_V_FL) & I_M_FL; /* get class */
|
|
if ((j == I_V_REG) && (opc_val[i] & inst)) { /* reg class? */
|
|
inst = inst & ~opc_val[i]; /* mask bit set? */
|
|
fprintf (of, (sp? " %s": "%s"), opcode[i]);
|
|
sp = 1;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Convert from SDS internal character code to ASCII depending upon cpu mode. */
|
|
int8 sds_to_ascii(int8 ch)
|
|
{
|
|
ch &= 077;
|
|
if (cpu_mode == NML_MODE)
|
|
return sds930_to_ascii[ch];
|
|
else
|
|
return sds940_to_ascii[ch];
|
|
}
|
|
|
|
/* Convert from ASCII to SDS internal character code depending upon cpu mode. */
|
|
int8 ascii_to_sds(int8 ch)
|
|
{
|
|
ch &= 0177;
|
|
if (cpu_mode == NML_MODE)
|
|
return ascii_to_sds930[ch];
|
|
else
|
|
return ascii_to_sds940[ch];
|
|
}
|
|
|
|
/* Symbolic decode
|
|
|
|
Inputs:
|
|
*of = output stream
|
|
addr = current PC
|
|
*val = pointer to values
|
|
*uptr = pointer to unit
|
|
sw = switches
|
|
Outputs:
|
|
return = status code
|
|
*/
|
|
|
|
t_stat fprint_sym (FILE *of, t_addr addr, t_value *val,
|
|
UNIT *uptr, int32 sw)
|
|
{
|
|
int32 i, j, ch;
|
|
int32 inst, op, tag, va, shf, nonop;
|
|
|
|
inst = val[0]; /* get inst */
|
|
op = I_GETOP (inst); /* get fields */
|
|
tag = (inst >> 21) & 06;
|
|
va = inst & VA_MASK;
|
|
shf = inst & I_SHFMSK;
|
|
nonop = inst & 077777;
|
|
|
|
if (sw & SWMASK ('A')) { /* SDS internal ASCII? */
|
|
for (i = 16; i >= 0; i -= 8) {
|
|
ch = (inst >> i) & 0377; /* map printable chars */
|
|
if (ch <= 0137)
|
|
ch += 040; /* from int. to ext. ASCII */
|
|
else
|
|
ch = '.'; /* or indicate not displayable */
|
|
fprintf (of, "%c", ch);
|
|
}
|
|
return SCPE_OK;
|
|
}
|
|
if (sw & SWMASK ('C')) { /* six-bit character? */
|
|
for (i = 18; i >= 0; i -= 6)
|
|
fprintf (of, "%c", sds_to_ascii(inst >> i));
|
|
return SCPE_OK;
|
|
}
|
|
if (!(sw & SWMASK ('M'))) return SCPE_ARG;
|
|
|
|
/* Instruction decode */
|
|
|
|
for (i = 0; opc_val[i] >= 0; i++) { /* loop thru ops */
|
|
j = (opc_val[i] >> I_V_FL) & I_M_FL; /* get class */
|
|
if ((opc_val[i] & DMASK) == (inst & masks[j])) { /* match? */
|
|
|
|
switch (j) { /* case on class */
|
|
|
|
case I_V_NPN: /* no operand */
|
|
fprintf (of, "%s", opcode[i]); /* opcode */
|
|
break;
|
|
|
|
case I_V_SHF: /* shift */
|
|
fprintf (of, "%s %-o", opcode[i], shf);
|
|
if (tag)
|
|
fprintf (of, ",%-o", tag);
|
|
break;
|
|
|
|
case I_V_SPP: /* syspop */
|
|
fprintf (of, "%s %-o", opcode[i], va);
|
|
if (tag & 2)
|
|
fprintf (of, ",2");
|
|
break;
|
|
|
|
case I_V_PPO: /* pop */
|
|
fprintf (of, "POP %-o,%-o", op, nonop);
|
|
if (tag)
|
|
fprintf (of, ",%-o", tag);
|
|
break;
|
|
|
|
case I_V_IOI: /* I/O */
|
|
fprintf (of, "%s %-o", opcode[i], nonop);
|
|
if (tag)
|
|
fprintf (of, ",%-o", tag);
|
|
break;
|
|
|
|
case I_V_OPO: /* operand optional */
|
|
if (!tag && !va)
|
|
{
|
|
fprintf (of, "%s", opcode[i]); /* opcode only */
|
|
break;
|
|
} /* or fall through to MRF */
|
|
|
|
case I_V_MRF: /* mem ref */
|
|
fprintf (of, "%s %-o", opcode[i], va);
|
|
if (tag)
|
|
fprintf (of, ",%-o", tag);
|
|
break;
|
|
|
|
case I_V_REG: /* reg change */
|
|
fprint_reg (of, inst); /* decode */
|
|
break;
|
|
|
|
case I_V_CHC: /* chan cmd */
|
|
ch = I_GETEOCH (inst); /* get chan */
|
|
fprintf (of, "%s %s", opcode[i], chname[ch]);
|
|
break;
|
|
|
|
case I_V_CHT: /* chan test */
|
|
ch = I_GETSKCH (inst); /* get chan */
|
|
fprintf (of, "%s %s", opcode[i], chname[ch]);
|
|
break;
|
|
} /* end case */
|
|
|
|
return SCPE_OK;
|
|
} /* end if */
|
|
} /* end for */
|
|
return SCPE_ARG;
|
|
}
|
|
|
|
/* Get (optional) tag
|
|
|
|
Inputs:
|
|
*cptr = pointer to input string
|
|
*tag = pointer to tag
|
|
Outputs:
|
|
cptr = updated pointer to input string
|
|
*/
|
|
|
|
CONST char *get_tag (CONST char *cptr, t_value *tag)
|
|
{
|
|
CONST char *tptr;
|
|
char gbuf[CBUFSIZE];
|
|
t_stat r;
|
|
|
|
tptr = get_glyph (cptr, gbuf, 0); /* get next field */
|
|
*tag = get_uint (gbuf, 8, 07, &r) << I_V_TAG; /* parse */
|
|
if (r == SCPE_OK) /* ok? advance */
|
|
return tptr;
|
|
*tag = 0;
|
|
return cptr; /* no change */
|
|
}
|
|
|
|
/* Symbolic input
|
|
|
|
Inputs:
|
|
*cptr = pointer to input string
|
|
addr = current PC
|
|
uptr = pointer to unit
|
|
*val = pointer to output values
|
|
sw = switches
|
|
Outputs:
|
|
status = error status
|
|
*/
|
|
|
|
t_stat parse_sym (CONST char *cptr, t_addr addr, UNIT *uptr, t_value *val, int32 sw)
|
|
{
|
|
int32 i, j, k, ch;
|
|
t_value d, tag;
|
|
t_stat r;
|
|
char gbuf[CBUFSIZE], cbuf[2*CBUFSIZE];
|
|
|
|
while (isspace (*cptr)) cptr++;
|
|
memset (cbuf, '\0', sizeof(cbuf));
|
|
strncpy (cbuf, cptr, sizeof(cbuf)-5);
|
|
cptr = cbuf;
|
|
if ((sw & SWMASK ('A')) || ((*cptr == '\'') && cptr++)) { /* ASCII char? */
|
|
if (cptr[0] == 0) /* must have 1 char */
|
|
return SCPE_ARG;
|
|
for (i = j = 0, val[0] = 0; i < 3; i++) {
|
|
if (cptr[i] == 0) /* latch str end */
|
|
j = 1;
|
|
ch = cptr[i] & 0377;
|
|
if (ch <= 037 || ch >= 0200)
|
|
k = -1;
|
|
else
|
|
k = ch - 040; /* map ext. to int. ASCII */
|
|
if (j || (k < 0)) /* bad, end? spc */
|
|
k = 0;
|
|
val[0] = (val[0] << 8) | k;
|
|
}
|
|
return SCPE_OK;
|
|
}
|
|
if ((sw & SWMASK ('C')) || ((*cptr == '"') && cptr++)) { /* string of 6-bit chars? */
|
|
if (cptr[0] == 0) /* must have 1 char */
|
|
return SCPE_ARG;
|
|
for (i = j = 0, val[0] = 0; i < 4; i++) {
|
|
if (cptr[i] == 0) /* latch str end */
|
|
j = 1;
|
|
k = ascii_to_sds(cptr[i]); /* cvt char */
|
|
if (j || (k < 0)) /* bad, end? spc */
|
|
k = 0;
|
|
val[0] = (val[0] << 6) | k;
|
|
}
|
|
return SCPE_OK;
|
|
}
|
|
|
|
cptr = get_glyph (cptr, gbuf, 0); /* get opcode */
|
|
for (i = 0; (opcode[i] != NULL) && (strcmp (opcode[i], gbuf) != 0) ; i++) ;
|
|
if (opcode[i] == NULL)
|
|
return SCPE_ARG;
|
|
val[0] = opc_val[i] & DMASK; /* get value */
|
|
j = (opc_val[i] >> I_V_FL) & I_M_FL; /* get class */
|
|
|
|
switch (j) { /* case on class */
|
|
|
|
case I_V_NPN: /* no operand */
|
|
break;
|
|
|
|
case I_V_SHF: /* shift */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
d = get_uint (gbuf, 8, I_SHFMSK, &r); /* shift count */
|
|
if (r != SCPE_OK)
|
|
return SCPE_ARG;
|
|
cptr = get_tag (cptr, &tag); /* get opt tag */
|
|
val[0] = val[0] | d | tag;
|
|
break;
|
|
|
|
case I_V_PPO: /* pop */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
d = get_uint (gbuf, 8, 077, &r); /* opcode */
|
|
if (r != SCPE_OK)
|
|
return SCPE_ARG;
|
|
val[0] = val[0] | d; /* fall thru */
|
|
|
|
case I_V_IOI: /* I/O */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
d = get_uint (gbuf, 8, 077777, &r); /* 15b address */
|
|
if (r != SCPE_OK)
|
|
return SCPE_ARG;
|
|
cptr = get_tag (cptr, &tag); /* get opt tag */
|
|
val[0] = val[0] | d | tag;
|
|
break;
|
|
|
|
case I_V_OPO: /* operand optional */
|
|
case I_V_SPP: /* syspop */
|
|
case I_V_MRF: /* mem ref */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
if (gbuf[0]=='\0' && j==I_V_OPO) /* operand optional */
|
|
break;
|
|
d = get_uint (gbuf, 8, VA_MASK, &r); /* virt address */
|
|
if (r != SCPE_OK)
|
|
return SCPE_ARG;
|
|
cptr = get_tag (cptr, &tag); /* get opt tag */
|
|
val[0] = val[0] | d | tag;
|
|
break;
|
|
|
|
case I_V_REG: /* register */
|
|
for (cptr = get_glyph (cptr, gbuf, 0); gbuf[0] != 0;
|
|
cptr = get_glyph (cptr, gbuf, 0)) {
|
|
for (i = 0; (opcode[i] != NULL) &&
|
|
(strcmp (opcode[i], gbuf) != 0); i++) ;
|
|
if (opcode[i] != NULL) {
|
|
k = opc_val[i] & DMASK;;
|
|
if (I_GETOP (k) != RCH)
|
|
return SCPE_ARG;
|
|
val[0] = val[0] | k;
|
|
}
|
|
else {
|
|
d = get_uint (gbuf, 8, 077777, &r);
|
|
if (r != SCPE_OK)
|
|
return SCPE_ARG;
|
|
else val[0] = val[0] | d;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case I_V_CHC: case I_V_CHT: /* channel */
|
|
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
|
|
for (i = 0; (chname[i] != NULL) && (strcmp (chname[i], gbuf) != 0);
|
|
i++);
|
|
if (chname[i] != NULL) /* named chan */
|
|
d = i;
|
|
else {
|
|
d = get_uint (gbuf, 8, NUM_CHAN - 1, &r);
|
|
if (r != SCPE_OK) /* numbered chan */
|
|
return SCPE_ARG;
|
|
}
|
|
val[0] = val[0] | ((j == I_V_CHC)? I_SETEOCH (d): I_SETSKCH (d));
|
|
break;
|
|
} /* end case */
|
|
|
|
if (*cptr != 0) /* junk at end? */
|
|
return SCPE_ARG;
|
|
return SCPE_OK;
|
|
}
|