diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..8656dff --- /dev/null +++ b/.gitattributes @@ -0,0 +1,11 @@ +*.jpg binary +*.png binary +*.sln binary +*.vcproj binary +*.exe binary +*.lda binary +*.bin binary +*.imd binary +*.rim binary +sim_rev.h export-subst + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6babf4a --- /dev/null +++ b/.gitignore @@ -0,0 +1,48 @@ +.git-commit-id +#ignore thumbnails created by windows +Thumbs.db +#ignore Desktop Services Store created by OSX +.DS_Store +#Ignore files built by Visual Studio +*.obj +# VAX/vmb.exe is not a generated file and should be in the repository +!VAX/vmb.exe +*.exe +*.pdb +*.user +*.aps +*.pch +*.vspscc +*_i.c +*_p.c +*.ncb +*.suo +*.tlb +*.tlh +*.bak +*.cache +*.ilk +*.log +[Bb]in +[Dd]ebug*/ +*.lib +*.sbr +*.bak +obj/ +[Rr]elease*/ +_ReSharper*/ +[Tt]est[Rr]esult* +*.o +*~ +*# +BIN/ +ipch/ +# We only care about specific files in the Visual Studio Projects +# folder. Things which are there on the fly to support debugging +# or other things we don't want git to manage. +!Visual Studio Projects/*.vcproj +!Visual Studio Projects/*.sln +!Visual Studio Projects/0ReadMe_Projects.txt +Visual Studio Projects/* + + diff --git a/B5500/b5500_cpu.c b/B5500/b5500_cpu.c new file mode 100644 index 0000000..14d802e --- /dev/null +++ b/B5500/b5500_cpu.c @@ -0,0 +1,3969 @@ +/* b5500_cpu.c: burroughs 5500 cpu simulator + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "b5500_defs.h" +#include "sim_timer.h" +#include +#include + +#define UNIT_V_MSIZE (UNIT_V_UF + 0) +#define UNIT_MSIZE (7 << UNIT_V_MSIZE) +#define MEMAMOUNT(x) (x << UNIT_V_MSIZE) + +#define TMR_RTC 1 + +#define HIST_MAX 5000 +#define HIST_MIN 64 + +t_uint64 bit_mask[64] = { + 00000000000000001LL, + 00000000000000002LL, + 00000000000000004LL, + 00000000000000010LL, + 00000000000000020LL, + 00000000000000040LL, + 00000000000000100LL, + 00000000000000200LL, + 00000000000000400LL, + 00000000000001000LL, + 00000000000002000LL, + 00000000000004000LL, + 00000000000010000LL, + 00000000000020000LL, + 00000000000040000LL, + 00000000000100000LL, + 00000000000200000LL, + 00000000000400000LL, + 00000000001000000LL, + 00000000002000000LL, + 00000000004000000LL, + 00000000010000000LL, + 00000000020000000LL, + 00000000040000000LL, + 00000000100000000LL, + 00000000200000000LL, + 00000000400000000LL, + 00000001000000000LL, + 00000002000000000LL, + 00000004000000000LL, + 00000010000000000LL, + 00000020000000000LL, + 00000040000000000LL, + 00000100000000000LL, + 00000200000000000LL, + 00000400000000000LL, + 00001000000000000LL, + 00002000000000000LL, + 00004000000000000LL, + 00010000000000000LL, + 00020000000000000LL, + 00040000000000000LL, + 00100000000000000LL, + 00200000000000000LL, + 00400000000000000LL, + 01000000000000000LL, + 02000000000000000LL, + 04000000000000000LL, + 0 +}; + +uint8 bit_number[64] = { + /* 00 01 02 03 04 05 06 07 */ + 47, 46, 45, 44, 43, 42, 42, 42, /* 00 */ + 41, 40, 39, 38, 37, 36, 36, 36, /* 10 */ + 35, 34, 33, 32, 31, 30, 30, 30, /* 20 */ + 29, 28, 27, 26, 25, 24, 24, 24, /* 30 */ + 23, 22, 21, 20, 19, 18, 18, 18, /* 40 */ + 17, 16, 15, 14, 13, 12, 12, 12, /* 50 */ + 11, 10, 9, 8, 7, 6, 6, 6, /* 60 */ + 5, 4, 3, 2, 1, 0, 0, 0, /* 70 */ +}; + +uint8 rank[64] = { + /* 00 01 02 03 04 05 06 07 */ + 53, 54, 55, 56, 57, 58, 59, 60, /* 00 */ + /* 8 9 # @ ? : > ge */ + 61, 62, 19, 20, 63, 21, 22, 23, /* 10 */ + /* + A B C D E F G */ + 24, 25, 26, 27, 28, 29, 30, 31, /* 20 */ + /* H I . [ & ( < ar */ + 32, 33, 1, 2, 6, 3, 4, 5, /* 30 */ + /* ti J K L M N O P */ + 34, 35, 36, 37, 38, 39, 40, 41, /* 40 */ + /* Q R $ * - ) ; le */ + 42, 43, 7, 8, 12, 9, 10, 11, /* 50 */ + /* bl / S T U V W X */ + 0, 13, 45, 46, 47, 48, 49, 50, /* 60 */ + /* Y Z , % ne = ] " */ + 51, 52, 14, 15, 44, 16, 17, 18, /* 70 */ +}; + + +int cpu_index; /* Current running cpu */ +t_uint64 M[MAXMEMSIZE] = { 0 }; /* memory */ +t_uint64 a_reg[2]; /* A register */ +t_uint64 b_reg[2]; /* B register */ +t_uint64 x_reg[2]; /* extension to B */ +t_uint64 y_reg[2]; /* extension to A not original */ +uint8 arof_reg[2]; /* True if A full */ +uint8 brof_reg[2]; /* True if B full */ +uint8 gh_reg[2]; /* G & H source char selectors */ +uint8 kv_reg[2]; /* K & V dest char selectors */ +uint16 ma_reg[2]; /* M memory address regiser */ +uint16 s_reg[2]; /* S Stack pointer */ +uint16 f_reg[2]; /* F MCSV pointer */ +uint16 r_reg[2]; /* R PRT pointer */ +t_uint64 p_reg[2]; /* P insruction buffer */ +uint8 prof_reg[2]; /* True if P valid */ +uint16 t_reg[2]; /* T current instruction */ +uint8 trof_reg[2]; /* True if T valid */ +uint16 c_reg[2]; /* C program counter */ +uint16 l_reg[2]; /* L current syllable pointer */ +uint8 ncsf_reg[2]; /* True if normal state */ +uint8 salf_reg[2]; /* True if subrogram mode */ +uint8 cwmf_reg[2]; /* True if character mode */ +uint8 hltf[2]; /* True if processor halted */ +uint8 msff_reg[2]; /* Mark stack flag Word mode */ +#define TFFF MSFF /* True state in Char mode */ +uint8 varf_reg[2]; /* Variant Flag */ +uint8 q_reg[2]; /* Holds error code */ +uint16 IAR; /* Interrupt register */ +uint32 iostatus; /* Hold status of devices */ +uint8 RTC; /* Real time clock counter */ +uint8 loading; /* Set when loading */ +uint8 HALT; /* Set when halt requested */ +uint8 P1_run; /* Run flag for P1 */ +uint8 P2_run; /* Run flag for P2 */ +uint16 idle_addr = 0; /* Address of idle loop */ + + +struct InstHistory +{ + uint16 c; + uint16 op; + uint16 s; + uint16 f; + uint16 r; + uint16 ma; + t_uint64 a_reg; + t_uint64 b_reg; + t_uint64 x_reg; + uint8 flags; + uint8 gh; + uint8 kv; + uint16 l; + uint8 q; + uint8 cpu; + uint16 iar; +}; + +struct InstHistory *hst = NULL; +int32 hst_p = 0; +int32 hst_lnt = 0; + +#define F_AROF 00001 +#define F_BROF 00002 +#define F_CWMF 00004 +#define F_NCSF 00010 +#define F_SALF 00020 +#define F_MSFF 00040 +#define F_VARF 00100 +#define HIST_PC 0100000 + +t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, + int32 sw); +t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, + int32 sw); +t_stat cpu_reset(DEVICE * dptr); +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, + void *desc); +t_stat cpu_show_size(FILE * st, UNIT * uptr, int32 val, + CONST void *desc); +t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, + void *desc); +t_stat cpu_help(FILE *, DEVICE *, UNIT *, int32, const char *); +/* Interval timer */ +t_stat rtc_srv(UNIT * uptr); + +int32 rtc_tps = 60 ; + + +/* CPU data structures + + cpu_dev CPU device descriptor + cpu_unit CPU unit descriptor + cpu_reg CPU register list + cpu_mod CPU modifiers list +*/ + +UNIT cpu_unit[] = + {{ UDATA(rtc_srv, MEMAMOUNT(7)|UNIT_IDLE, MAXMEMSIZE ), 16667 }, + { UDATA(0, UNIT_DISABLE|UNIT_DIS, 0 ), 0 }}; + +REG cpu_reg[] = { + {BRDATAD(C, c_reg, 8,15,2, "Instruction pointer"), REG_FIT}, + {BRDATAD(L, l_reg, 8,2,2, "Sylable pointer")}, + {BRDATA(A, a_reg, 8,48,2), REG_FIT}, + {BRDATA(B, b_reg, 8,48,2), REG_FIT}, + {BRDATA(X, x_reg, 8,39,2), REG_FIT}, + {BRDATA(GH, gh_reg, 8,6,2)}, + {BRDATA(KV, kv_reg, 8,6,2)}, + {BRDATAD(MA, ma_reg, 8,15,2, "Memory address")}, + {BRDATAD(S, s_reg, 8,15,2, "Stack pointer")}, + {BRDATAD(F, f_reg, 8,15,2, "Frame pointer")}, + {BRDATAD(R, r_reg, 8,15,2, "PRT pointer/Tally")}, + {BRDATAD(P, p_reg, 8,48,2, "Last code word cache")}, + {BRDATAD(T, t_reg, 8,12,2, "Current instruction")}, + {BRDATAD(Q, q_reg, 8,9,2, "Error condition")}, + {BRDATA(AROF, arof_reg, 2,1,2)}, + {BRDATA(BROF, brof_reg, 2,1,2)}, + {BRDATA(PROF, prof_reg, 2,1,2)}, + {BRDATA(TROF, trof_reg, 2,1,2)}, + {BRDATA(NCSF, ncsf_reg, 2,1,2)}, + {BRDATA(SALF, salf_reg, 2,1,2)}, + {BRDATA(CWMF, cwmf_reg, 2,1,2)}, + {BRDATA(MSFF, msff_reg, 2,1,2)}, + {BRDATA(VARF, varf_reg, 2,1,2)}, + {BRDATA(HLTF, hltf, 2,1,2)}, + {ORDATAD(IAR, IAR, 15, "Interrupt pending")}, + {ORDATAD(TUS, iostatus, 32, "Perpherial ready status")}, + {FLDATA(HALT, HALT, 0)}, + {NULL} +}; + +MTAB cpu_mod[] = { + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(0), NULL, "4K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(1), NULL, "8K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(2), NULL, "12K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(3), NULL, "16K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(4), NULL, "20K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(5), NULL, "24K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(6), NULL, "28K", &cpu_set_size}, + {UNIT_MSIZE|MTAB_VDV, MEMAMOUNT(7), NULL, "32K", &cpu_set_size}, + {MTAB_VDV, 0, "MEMORY", NULL, NULL, &cpu_show_size}, + {MTAB_XTD|MTAB_VDV, 0, "IDLE", "IDLE", &sim_set_idle, &sim_show_idle }, + {MTAB_XTD|MTAB_VDV, 0, NULL, "NOIDLE", &sim_clr_idle, NULL }, + {MTAB_XTD | MTAB_VDV | MTAB_NMO | MTAB_SHP, 0, "HISTORY", "HISTORY", + &cpu_set_hist, &cpu_show_hist}, + {0} +}; + +DEVICE cpu_dev = { + "CPU", cpu_unit, cpu_reg, cpu_mod, + 2, 8, 15, 1, 8, 48, + &cpu_ex, &cpu_dep, &cpu_reset, NULL, NULL, NULL, + NULL, DEV_DEBUG, 0, dev_debug, + NULL, NULL, &cpu_help +}; + + + +/* Define registers */ +#define A a_reg[cpu_index] +#define B b_reg[cpu_index] +#define C c_reg[cpu_index] +#define L l_reg[cpu_index] +#define X x_reg[cpu_index] +#define Y y_reg[cpu_index] +#define Q q_reg[cpu_index] +#define GH gh_reg[cpu_index] +#define KV kv_reg[cpu_index] +#define Ma ma_reg[cpu_index] +#define S s_reg[cpu_index] +#define F f_reg[cpu_index] +#define R r_reg[cpu_index] +#define P p_reg[cpu_index] +#define T t_reg[cpu_index] +#define AROF arof_reg[cpu_index] +#define BROF brof_reg[cpu_index] +#define PROF prof_reg[cpu_index] +#define TROF trof_reg[cpu_index] +#define NCSF ncsf_reg[cpu_index] +#define SALF salf_reg[cpu_index] +#define CWMF cwmf_reg[cpu_index] +#define MSFF msff_reg[cpu_index] +#define VARF varf_reg[cpu_index] +#define HLTF hltf[cpu_index] + +/* Definitions to help extract fields */ +#define FF(x) (uint16)(((x) & FFIELD) >> FFIELD_V) +#define CF(x) (uint16) ((x) & CORE) +#define LF(x) (uint16)(((x) & RL) >> RL_V) +#define RF(x) (uint16)(((x) & RFIELD) >> RFIELD_V) + +#define toF(x) ((((t_uint64)(x)) << FFIELD_V) & FFIELD) +#define toC(x) (((t_uint64)(x)) & CORE) +#define toL(x) ((((t_uint64)(x)) << RL_V) & RL) +#define toR(x) ((((t_uint64)(x)) << RFIELD_V) & RFIELD) + +#define replF(y, x) ((y & ~FFIELD) | toF(x)) +#define replC(y, x) ((y & ~CORE) | toC(x)) + +#define next_addr(x) (x = (x + 1) & 077777) +#define prev_addr(x) (x = (x - 1) & 077777) + +/* Definitions to handle building of control words */ +#define MSCW (FLAG | DFLAG | toR(R) | toF(F) | \ + ((MSFF)?SMSFF:0) | ((SALF)?SSALF:0)) +#define ICW (FLAG | DFLAG | toR(R) | ((VARF)?SVARF:0) | \ + ((MSFF)?SMSFF:0) | ((SALF)?SSALF:0)) | toC(Ma) +#define Pointer(x) ((t_uint64)((((x) & 070) >> 3) | ((x & 07) << 8))) +#define RCW(x) (FLAG | DFLAG | toF(F) | toC(C) | toL(L) | \ + (Pointer(GH) << RGH_V) | (Pointer(KV) << RKV_V)) | \ + ((x)?PRESENT:0) +#define LCW(f, x) toF(f) | toC(C) | toL(L) | \ + (((t_uint64)(x) << REPFLD_V) & REPFLD) +#define VARIANT(x) ((x) >> 6) + + +/* E + 2 A = M[S] + 3 B = M[S] + 4 A = M[Ma] + 5 B = M[Ma] + 6 Ma = M[Ma]<18:32> + 10 M[S] = A 1010 + 11 M[S] = B 1011 + 12 M[Ma] = A 1100 + 13 M[Ma] = B 1101 + + 1 B/A + 2 S + 4 Ma + 8 Write/Read + 16 Fetch +*/ + +int memory_cycle(uint8 E) { + uint16 addr = 0; + + sim_interval--; + if (E & 2) + addr = S; + if (E & 4) + addr = Ma; + if (E & 020) + addr = C; + if (addr > MEMSIZE) { + Q |= INVALID_ADDR; + return 1; + } + if (NCSF && addr < 01000) { + Q |= INVALID_ADDR; + return 1; + } + if (E & 020) { + P = M[addr]; + PROF = 1; + return 0; + } + if (E & 010) { + if (E & 1) + M[addr] = B; + else + M[addr] = A; + } else { + if (E == 6) { + B = M[addr]; + Ma = FF(B); + } else if (E & 1) { + B = M[addr]; + BROF = 1; + } else { + A = M[addr]; + AROF = 1; + } + } + return 0; +} + + +/* Set registers based on MSCW */ +void set_via_MSCW(t_uint64 word) { + F = FF(word); + R = RF(word); + MSFF = (word & SMSFF) != 0; + SALF = (word & SSALF) != 0; +} + +/* Set registers based on RCW. + if no_set_lc is non-zero don't set LC from RCW. + if no_bits is non-zero don't set GH and KV, + return BROF flag */ +int set_via_RCW(t_uint64 word, int no_set_lc, int no_bits) { + if (!no_set_lc) { + L = LF(word); + C = CF(word); + PROF = 0; + } + F = FF(word); + if (!no_bits) { + uint16 t; + t = (uint16)((word & RGH) >> RGH_V); + GH = ((t << 3) & 070) | ((t >> 8) & 07); + t = (uint16)((word & RKV) >> RKV_V); + KV = ((t << 3) & 070) | ((t >> 8) & 07); + } + return (word & PRESENT) != 0; +} + +/* Set the stack pointer from INCW */ +void set_via_INCW(t_uint64 word) { + S = CF(word); + CWMF = (word & SCWMF) != 0; +} + +/* Set registers from ICW */ +void set_via_ICW(t_uint64 word) { + Ma = CF(word); + MSFF = (word & SMSFF) != 0; + SALF = (word & SSALF) != 0; + VARF = (word & SVARF) != 0; + R = RF(word); +} + +/* Make sure that B is empty */ +void B_empty() { + if (BROF) { + next_addr(S); + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(013); /* Save B */ + BROF = 0; + } +} + +/* Make sure A is empty, push to B if not */ +void A_empty() { + if (AROF) { + B_empty(); + B = A; + AROF = 0; + BROF = 1; + } +} + +/* Make sure both A and B are empty */ +void AB_empty() { + B_empty(); + if (AROF) { + next_addr(S); + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(012); /* Save A */ + AROF = 0; + } +} + +/* Make sure that A is valid, copy from B or memory */ +void A_valid() { + if (!AROF) { + if (BROF) { /* Transfer B to A */ + A = B; + AROF = 1; + BROF = 0; + } else { + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(2); /* Read A */ + prev_addr(S); + } + } +} + +/* Make sure both A and B are valid */ +void AB_valid() { + A_valid(); + if (!BROF) { + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(3); /* Read B */ + prev_addr(S); + } +} + +/* Make sure A is empty and B is valid */ +void B_valid() { + A_empty(); + if (!BROF) { + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(3); /* Read B */ + prev_addr(S); + } +} + +/* Make sure B is valid, don't care about A */ +void B_valid_and_A() { + if (!BROF) { + if (NCSF && (S & 077700) == R) { + Q |= STK_OVERFL; /* Stack fault */ + return; + } + memory_cycle(3); /* Read B */ + prev_addr(S); + } +} + +/* Saves the top word on the stack into MA */ +void save_tos() { + if (AROF) { + memory_cycle(014); /* Store A in Ma */ + AROF = 0; + } else if (BROF) { + memory_cycle(015); /* Store B in Ma */ + BROF = 0; + } else { /* Fetch B then Store */ + A_valid(); /* Use A register since it is quicker */ + memory_cycle(014); + AROF = 0; + } +} + +/* Enter a subroutine, flag true for descriptor, false for opdc */ +void enterSubr(int flag) { + /* Program descriptor */ + if ((A & ARGF) != 0 && MSFF == 0) { + return; + } + if ((A & MODEF) != 0 && (A & ARGF) == 0) { + return; + } + B_empty(); + /* Check if accidental entry */ + if ((A & ARGF) == 0) { + B = MSCW; + BROF = 1; + B_empty(); + F = S; + } + B = RCW(flag); + BROF = 1; + B_empty(); + C = CF(A); + L = 0; + if ((A & ARGF) == 0) { + F = FF(A); + } else { + F = S; + } + AROF = 0; + BROF = 0; + SALF = 1; + MSFF = 0; + PROF = 0; + if (A & MODEF) { + CWMF = 1; + R = 0; + X = toF(S); + S = 0; + } +} + +/* Make B register into an integer, return 1 if failed */ +int mkint() { + int exp_b; + int last_digit; + int f = 0; + + /* Extract exponent */ + exp_b = (B & EXPO) >> EXPO_V; + if (exp_b == 0) + return 0; + if (B & ESIGN) + exp_b = -exp_b; + if (B & MSIGN) + f = 1; + B &= MANT; + /* Adjust if exponent less then zero */ + last_digit = 0; + if (exp_b < 0) { + while (exp_b < 0 && B != 0) { + last_digit = B & 7; + B >>= 3; + exp_b++; + } + if (exp_b != 0) { + B = 0; + return 0; + } + if (f ? (last_digit > 4) : (last_digit >= 4)) + B++; + } else { + /* Now handle when exponent plus */ + while(exp_b > 0) { + if ((B & NORM) != 0) + return 1; + B <<= 3; + exp_b--; + } + if (exp_b != 0) { + B = 0; + return 1; + } + } + if (f && B != 0) + B |= MSIGN; + return 0; +} + +/* Compute an index word return true if failed. */ +int indexWord() { + if (A & WCOUNT) { + B_valid_and_A(); + if (mkint()) { + if (NCSF) + Q |= INT_OVER; + return 1; + } + if (B & MSIGN && (B & MANT) != 0) { + if (NCSF) + Q |= INDEX_ERROR; + return 1; + } + if ((B & 01777) >= ((A & WCOUNT) >> WCOUNT_V)) { + if (NCSF) + Q |= INDEX_ERROR; + return 1; + } + Ma = (A + (B & 01777)) & CORE; + A &= ~(WCOUNT|CORE); + A |= Ma; + BROF = 0; + } else { + Ma = CF(A); + } + return 0; +} + + +/* Character mode helper routines */ + +/* Adjust source bit pointers to point to char */ +void adjust_source() { + if (GH & 07) { + GH &= 070; + GH += 010; + if (GH > 077) { + AROF = 0; + GH = 0; + next_addr(Ma); + } + } +} + +/* Adjust destination bit pointers to point to char */ +void adjust_dest() { + if (KV & 07) { + KV &= 070; + KV += 010; + if (KV > 075) { + if (BROF) + memory_cycle(013); + BROF = 0; + KV = 0; + next_addr(S); + } + } +} + +/* Advance to next destination bit/char */ +void next_dest(int bit) { + if (bit) + KV += 1; + else + KV |= 7; + if ((KV & 07) > 5) { + KV &= 070; + KV += 010; + } + if (KV > 075) { + if (BROF) + memory_cycle(013); + BROF = 0; + KV = 0; + next_addr(S); + } +} + +/* Advance to previous destination bit/char */ +void prev_dest(int bit) { + if (bit) { + if ((KV & 07) == 0) { + if (KV == 0) { + if (BROF) + memory_cycle(013); + BROF = 0; + prev_addr(S); + KV = 076; + } else { + KV = ((KV - 010) & 070) | 06; + } + } + KV -= 1; + } else { + KV &= 070; + if (KV == 0) { + if (BROF) + memory_cycle(013); + BROF = 0; + prev_addr(S); + KV = 070; + } else + KV -= 010; + } +} + +/* Make sure destination have valid data */ +void fill_dest() { + if (BROF == 0) { + memory_cycle(3); + BROF = 1; + } +} + +/* Advance source to next bit/char */ +void next_src(int bit) { + if (bit) + GH += 1; + else + GH |= 7; + if ((GH & 07) > 5) { + GH &= 070; + GH += 010; + } + if (GH > 075) { + AROF = 0; + GH = 0; + next_addr(Ma); + } +} + +/* Advance source to previous bit/char */ +void prev_src(int bit) { + if (bit) { + if ((GH & 07) == 0) { + if (GH == 0) { + AROF = 0; + prev_addr(Ma); + GH = 076; + } else { + GH = ((GH - 010) & 070) | 06; + } + } + GH -= 1; + } else { + GH &= 070; + if (GH == 0) { + AROF = 0; + prev_addr(Ma); + GH = 070; + } else + GH -= 010; + } +} + +/* Make sure source has valid data */ +void fill_src() { + if (AROF == 0) { + memory_cycle(4); + AROF = 1; + } +} + + +/* Helper routines for managing processor */ + +/* Fetch next program sylable */ +void next_prog() { + if (!PROF) + memory_cycle(020); + T = (P >> ((3 - L) * 12)) & 07777; + if ( L++ == 3) { + C++; + L = 0; + PROF = 0; + } + TROF = 1; +} + +/* Initiate a processor, A must contain the ICW */ +void initiate() { + int brflg, arflg, temp; + + set_via_INCW(A); /* Set up Stack */ + AROF = 0; + memory_cycle(3); /* Fetch IRCW from stack */ + prev_addr(S); + brflg = set_via_RCW(B, 0, 0); + memory_cycle(3); /* Fetch ICW from stack */ + prev_addr(S); + set_via_ICW(B); + BROF = 0; /* Note memory_cycle set this */ + if (CWMF) { + memory_cycle(3); /* Fetch LCW from stack */ + prev_addr(S); + arflg = (B & PRESENT) != 0; + X = B & MANT; + if (brflg) { + memory_cycle(3); /* Load B via S */ + prev_addr(S); + } + if (arflg) { + memory_cycle(2); /* Load A via S */ + prev_addr(S); + } + AROF = arflg; + BROF = brflg; + temp = S; + S = FF(X); + X = replF(X, temp); + } + NCSF = 1; + PROF = 0; + TROF = 0; +} + +/* Save processor state in case of error or halt */ +void storeInterrupt(int forced, int test) { + int f; + t_uint64 temp; + + if (forced || test) + NCSF = 0; + f = BROF; + if (CWMF) { + int i = AROF; + temp = S; + S = FF(X); + X = replF(X, temp); + if (AROF || test) { /* Push A First */ + next_addr(S); + memory_cycle(10); + } + if (BROF || test) { /* Push B second */ + next_addr(S); + memory_cycle(11); + } + /* Make ILCW */ + B = X | ((i)? PRESENT : 0) | FLAG | DFLAG; + next_addr(S); /* Save B */ + memory_cycle(11); + } else { + if (BROF || test) { /* Push B First */ + next_addr(S); + memory_cycle(11); + } + if (AROF || test) { /* Push A Second */ + next_addr(S); + memory_cycle(10); + } + } + AROF = 0; + B = ICW; /* Set ICW into B */ + next_addr(S); /* Save B */ + memory_cycle(11); + B = RCW(f); /* Save IRCW */ + next_addr(S); /* Save B */ + memory_cycle(11); + if (CWMF) { + /* Get the correct value of R */ + Ma = F; + memory_cycle(6); /* Load B via Ma, Indirect */ + memory_cycle(5); /* Load B via Ma */ + R = RF(B); + B = FLAG|DFLAG|SCWMF|toC(S); + } else { + B = FLAG|DFLAG|toC(S); + } + B |= ((t_uint64)Q) << 35; + Ma = R | 010; + memory_cycle(015); /* Store B in Ma */ + R = 0; + BROF = 0; + MSFF = 0; + SALF = 0; + F = S; + if (forced || test) + CWMF = 0; + PROF = 0; + if (test) { + Ma = 0; + memory_cycle(5); /* Load location 0 to B. */ + BROF = 0; + C = CF(B); + L = 0; + KV = 0; + GH = 0; + } else if (forced) { + if (cpu_index) { + P2_run = 0; /* Clear halt flag */ + hltf[1] = 0; + cpu_index = 0; + } else { + T = WMOP_ITI; + TROF = 1; + } + } +} + +/* Check if in idle loop. + assume that current instruction is ITI */ +/* Typical idle loop for MCP is: + + -1 ITI 0211 + +0 TUS 2431 + +1 OPDC address1 xxx2 + +2 LOR 0215 + +3 OPDC address2 xxx2 + +4 NEQ 0425 + +5 LITC 010 LITC 1 0040 0004 + +6 BBC LBC 0131 2131 + +*/ + +int check_idle() { + static uint16 loop_data[7] = { + WMOP_TUS, WMOP_OPDC, WMOP_LOR, WMOP_OPDC, + WMOP_NEQ, WMOP_LITC, WMOP_BBC }; + static uint16 loop_mask[7] = { + 07777, 00003, 07777, 00003, + 07777, 07733, 05777}; + t_uint64 data; + uint16 addr = C; + int l = (3 - L) * 12; + uint16 word; + int i; + + /* Quick check to see if not correct location */ + if (idle_addr != 0 && idle_addr != addr) + return 0; + /* If address same, then idle loop */ + if (idle_addr == addr) + return 1; + + /* Not set, see if this could be loop */ + data = M[addr]; + for (i = 0; i < 7; i++) { + word = (uint16)(data >> l) & 07777; + if ((word & loop_mask[i]) != loop_data[i]) + return 0; + if (l == 0) { + addr++; + l = 3 * 12; + data = M[addr]; + } else { + l -= 12; + } + } + idle_addr = C; + return 1; +} + + +/* Math helper routines. */ + +/* Compare A and B, + return 1 if B = A. + return 2 if B > A + return 4 if B < A +*/ +uint8 compare() { + int sign_a, sign_b; + int exp_a, exp_b; + t_uint64 ma, mb; + + sign_a = (A & MSIGN) != 0; + sign_b = (B & MSIGN) != 0; + + /* next grab exponents and mantissa */ + ma = A & MANT; + mb = B & MANT; + if (ma == 0) { + if (mb == 0) + return 1; + return (sign_b ? 2 : 4); + } else { + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + } + if (mb == 0) { + return (sign_a ? 4 : 2); + } else { + exp_b = (B & EXPO) >> EXPO_V; + if (B & ESIGN) + exp_b = -exp_b; + } + + /* If signs are different return differnce */ + if (sign_a != sign_b) + return (sign_b ? 2 : 4); + + /* Normalize both */ + while((ma & NORM) == 0 && exp_a != exp_b) { + ma <<= 3; + exp_a--; + } + + while((mb & NORM) == 0 && exp_a != exp_b) { + mb <<= 3; + exp_b--; + } + + /* Check exponents first */ + if (exp_a != exp_b) { + if (exp_b > exp_a) { + return (sign_b ? 2 : 4); + } else { + return (sign_b ? 4 : 2); + } + } + + /* Exponents same, check mantissa */ + if (ma != mb) { + if (mb > ma) { + return (sign_b ? 2 : 4); + } else if (mb != ma) { + return (sign_b ? 4 : 2); + } + } + + /* Ok, must be identical */ + return 1; +} + +/* Handle addition instruction. + A & B valid. */ +void add(int opcode) { + int exp_a, exp_b; + int sa, sb; + int rnd; + + AB_valid(); + if (opcode == WMOP_SUB) /* Subtract */ + A ^= MSIGN; + AROF = 0; + X = 0; + /* Check if Either argument already zero */ + if ((A & MANT) == 0) { + if ((B & MANT) == 0) + B = 0; + return; + } + if ((B & MANT) == 0) { + B = A; + return; + } + + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + exp_b = (B & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + if (B & ESIGN) + exp_b = -exp_b; + /* Larger exponent to A */ + if (exp_b > exp_a) { + t_uint64 temp; + temp = A; + A = B; + B = temp; + sa = exp_a; + exp_a = exp_b; + exp_b = sa; + } + /* Extract signs, clear upper bits */ + sa = (A & MSIGN) != 0; + A &= MANT; + sb = (B & MSIGN) != 0; + B &= MANT; + /* While the exponents are not equal, adjust */ + while(exp_a != exp_b && (A & NORM) == 0) { + A <<= 3; + exp_a--; + } + while(exp_a != exp_b && B != 0) { + X |= (B & 07) << EXPO_V; + X >>= 3; + B >>= 3; + exp_b++; + } + if (exp_a != exp_b) { + exp_b = exp_a; + B = 0; + X = 0; + } + if (sa) { /* A is negative. */ + A ^= FWORD; + A++; + } + if (sb) { /* B is negative */ + X ^= MANT; + B ^= FWORD; + X++; + if (X & EXPO) { + B++; + X &= MANT; + } + } + B = A + B; /* Do final math. */ + if (B & MSIGN) { /* Result is negative, switch */ + sb = 1; + X ^= MANT; + B ^= FWORD; + X++; + if (X & EXPO) { + B++; + X &= MANT; + } + } else + sb = 0; + if (B & EXPO) { /* Handle overflow */ + rnd = B & 07; + B >>= 3; + exp_b++; + } else if ((B & NORM) == 0) { + if ((X & NORM) == 0) { + rnd = 0; + } else { + X <<= 3; + B <<= 3; + B |= (X >> EXPO_V) & 07; + X &= MANT; + rnd = X >> (EXPO_V - 3); + exp_b--; + } + } else { + rnd = X >> (EXPO_V - 3); + } + if (rnd >= 4 && B != MANT) { + B++; + } + + B &= MANT; + if ((exp_b != 0) && (exp_b < -64) && (B & NORM) == 0) { + B <<= 3; + exp_b--; + } + if (B == 0) + return; + if (exp_b < 0) { /* Handle underflow */ + if (exp_b < -64 && NCSF) + Q |= EXPO_UNDER; + exp_b = ((-exp_b) & 077)|0100; + } else { + if (exp_b > 64 && NCSF) + Q |= EXPO_OVER; + exp_b &= 077; + } + B = (B & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | + ((sb) ? MSIGN: 0); +} + +/* + * Perform a 40 bit multiply on A and B, result into B,X + */ +void mult_step(t_uint64 a, t_uint64 *b, t_uint64 *x) { + t_uint64 u0,u1,v0,v1,t,w1,w2,w3,k; + + /* Split into 32 bit and 8 bit */ + u0 = a >> 32; u1 = a & 0xffffffff; + v0 = *b >> 32; v1 = *b & 0xffffffff; + /* Multiply lower halfs to 64 bits */ + t = u1*v1; + /* Lower 32 bits to w3. */ + w3 = t & 0xffffffff; + /* Upper 32 bits to k */ + k = t >> 32; + /* Add in partial product of upper & lower */ + t = u0*v1 + k; + w2 = t & 0xffffffff; + w1 = t >> 32; + t = u1*v0 + w2; + k = t >> 32; + /* Put result back together */ + *b = u0*v0 + w1 + k; + *x = (t << 32) + w3; + /* Put into 2 40 bit numbers */ + *b <<= 25; + *b |= (*x >> EXPO_V); + *x &= MANT; +} + +/* Do multiply instruction */ +void multiply() { + int exp_a, exp_b; + int f; + int int_f; + + AB_valid(); + AROF = 0; + /* Check if Either argument already zero */ + if ((A & MANT) == 0 || (B & MANT) == 0) { + B = 0; + return; + } + + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + exp_b = (B & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + if (B & ESIGN) + exp_b = -exp_b; + /* Extract signs, clear upper bits */ + f = (A & MSIGN) != 0; + A &= MANT; + f ^= ((B & MSIGN) != 0); + B &= MANT; + /* Flag if both exponents zero */ + int_f = (exp_a == 0) & (exp_b == 0); + if (int_f == 0) { + while ((A & NORM) == 0) { + A <<= 3; + exp_a--; + } + while ((B & NORM) == 0) { + B <<= 3; + exp_b--; + } + } + + mult_step(A, &B, &X); + + /* If integer and B is zero */ + if (int_f && B == 0) { + B = X; + X = 0; + exp_b = 0; + } else { + exp_b = exp_a + exp_b + 13; + while ((B & NORM) == 0) { + if (exp_b < -64) + break; + B <<= 3; + X <<= 3; + B |= (X >> EXPO_V) & 07; + X &= MANT; + exp_b--; + } + } + /* After B is normalize, check high order digit of X */ + if (X & ROUND) { + B++; + if (B & EXPO) { + B >>= 3; + exp_b++; + } + } + /* Check for over/underflow */ + if (exp_b < 0) { + if (exp_b < -64) { + if (NCSF) + Q |= EXPO_UNDER; + B = 0; + return; + } + exp_b = ((-exp_b) & 077) | 0100; + } else { + if (exp_b > 64) { + if (NCSF) + Q |= EXPO_OVER; + } + exp_b &= 077; + } + /* Put the pieces back together */ + B = (B & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | (f? MSIGN: 0); +} + + +/* Do divide instruction */ +void divide(int op) { + int exp_a, exp_b, q, sa, sb; + t_uint64 t; + + AB_valid(); + AROF = 0; + t = B; + + if ((A & MANT) == 0) { /* if A mantissa is zero */ + if (NCSF) /* and we're in Normal State */ + Q |= DIV_ZERO; + return; + } + + if ((B & MANT) == 0) { /* otherwise, if B is zero, */ + A = B = 0; /* result is all zeroes */ + return; + } + + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + exp_b = (B & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + if (B & ESIGN) + exp_b = -exp_b; + + /* Extract signs, clear upper bits */ + sb = (B & MSIGN) != 0; + sa = (A & MSIGN) != 0; + A &= MANT; + B &= MANT; + /* Normalize A and B */ + while ((A & NORM) == 0) { + A <<= 3; + exp_a--; + } + while ((B & NORM) == 0) { + B <<= 3; + exp_b--; + } + + if (op != WMOP_DIV && exp_a > exp_b) { /* Divisor has greater magnitude */ + /* Quotent is < 1, so set result to zero */ + A = 0; + B = (op == WMOP_RDV)? (t & FWORD) : 0; + return; + } + + if (op != WMOP_RDV) + sb ^= sa; /* positive if signs are same, negative if different */ + X = 0; + /* Now we step through the development of the quotient one octade at a time, + tallying the shifts in n until the high-order octade of X is non-zero + (i.e., normalized). The divisor is in ma and the dividend (which becomes + the remainder) is in mb. Since the operands are normalized, this will + take either 13 or 14 shifts. We do the X shift at the top of the loop so + that the 14th (rounding) digit will be available in q at the end. + The initial shift has no effect, as it operates using zero values for X + and q. */ + do { + q = 0; /* initialize the quotient digit */ + while (B >= A) { + ++q; /* bump the quotient digit */ + B -= A; /* subtract divisor from reAinder */ + } + + if (op == WMOP_DIV) { + if ((X & NORM) != 0) { + break; /* quotient has become normalized */ + } else { + B <<= 3; /* shift the remainder left one octade */ + X = (X<<3) + (t_uint64)q; /* shift quotient digit into the + working quotient */ + --exp_b; + } + } else { + X = (X<<3) + (t_uint64)q; /* shift quotient digit into the + working quotient */ + if ((X & NORM) != 0) { + break; /* quotient has become normalized */ + } else if (exp_a >= exp_b) { + break; + } else { + B <<= 3; /* shift the remainder left one octade */ + --exp_b; /* decrement the B exponent */ + } + } + } while (1); + + if (op == WMOP_DIV) { + exp_b -= exp_a - 1; /* compute the exponent, accounting for the shifts*/ + + /* Round the result (it's already normalized) */ + if (q >= 4) { /* if high-order bit of last quotient digit is 1 */ + if (X < MANT) { /* if the rounding would not cause overflow */ + ++X; /* round up the result */ + } + } + } else if (op == WMOP_IDV) { + if (exp_a == exp_b) { + exp_b = 0; /* integer result developed */ + } else { + if (NCSF) /* integer overflow result */ + Q |= INT_OVER; + exp_b -= exp_a; + } + } else { + X = B; /* Result in B */ + if (exp_a == exp_b) { /* integer result developed */ + if (X == 0) /* if B mantissa is zero, then */ + exp_b = sb = 0; /* assure result will be all zeroes */ + } else { + if (NCSF) /* integer overflow result */ + Q |= INT_OVER; + X = exp_b = sb = 0; /* result in B will be all zeroes */ + } + } + + /* Check for exponent under/overflow */ + if (exp_b > 63) { + exp_b &= 077; + if (NCSF) { + Q |= EXPO_OVER; + } + } else if (exp_b < 0) { + if (exp_b < -63) { + if (NCSF) + Q |= EXPO_UNDER; + } + exp_b = ((-exp_b) & 077) | 0100; + } + + /* Put the pieces back together */ + B = (X & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | (sb? MSIGN: 0); +} + + +/* Double precision addition. + A & Y (not in real B5500) have operand 1. + B & X have operand 2 */ +void double_add(int opcode) { + int exp_a, exp_b; + int sa, sb; + int ld; + t_uint64 temp; + + AB_valid(); + X = A; /* Save registers. X = H, Y=L*/ + Y = B; + AROF = BROF = 0; + AB_valid(); /* Grab other operand */ + temp = A; /* Oprands A,Y and B,X */ + A = X; + X = B; + B = temp; + + if (opcode == WMOP_DLS) /* Double Precision Subtract */ + A ^= MSIGN; + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + exp_b = (B & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + if (B & ESIGN) + exp_b = -exp_b; + /* Larger exponent to A */ + if (exp_b > exp_a) { + t_uint64 temp; + temp = A; + A = B; + B = temp; + temp = Y; + Y = X; + X = temp; + sa = exp_a; + exp_a = exp_b; + exp_b = sa; + } + /* Extract signs, clear upper bits */ + sa = (A & MSIGN) != 0; + A &= MANT; + Y &= MANT; + sb = (B & MSIGN) != 0; + B &= MANT; + X &= MANT; + ld = 0; + /* While the exponents are not equal, adjust */ + while(exp_a != exp_b) { + if ((A & NORM) == 0) { + A <<= 3; + Y <<= 3; + A |= (Y >> EXPO_V) & 07; + Y &= MANT; + exp_a--; + } else { + X |= (B & 07) << EXPO_V; + ld = (X & 07); + X >>= 3; + B >>= 3; + exp_b++; + if (B == 0 && X == 0) + break; + } + } + if (exp_a != exp_b) { + exp_b = exp_a; + B = 0; + X = 0; + } + if (sa) { /* A is negative. */ + Y ^= MANT; + A ^= FWORD; + Y++; + if (Y & EXPO) { + Y &= MANT; + A++; + } + } + if (sb) { /* B is negative */ + X ^= MANT; + B ^= FWORD; + X++; + if (X & EXPO) { + X &= MANT; + B++; + } + } + X = Y + X; + B = A + B; /* Do final math. */ + if (X & EXPO) { + B += X >> (EXPO_V); + X &= MANT; + } + + if (B & MSIGN) { /* Result is negative, switch */ + sb = 1; + X ^= MANT; + B ^= FWORD; + X++; + if (X & EXPO) { + X &= MANT; + B++; + } + } else { + sb = 0; + } + + while (B & EXPO) { /* Handle overflow */ + X |= (B & 07) << EXPO_V; + ld = X & 07; + B >>= 3; + X >>= 3; + exp_b++; + } + + if (ld >= 4 && X != MANT && B != MANT) { + X++; + if (X & EXPO) { + X &= MANT; + B++; + } + } + + while(exp_b > -63 && (B & NORM) == 0) { + B <<= 3; + X <<= 3; + B |= (X >> EXPO_V) & 07; + X &= MANT; + exp_b--; + } + + B &= MANT; + X &= MANT; + if (exp_b < 0) { /* Handle underflow */ + if (exp_b < -64 && NCSF) + Q |= EXPO_UNDER; + exp_b = ((-exp_b) & 077)|0100; + } else { + if (exp_b > 64 && NCSF) + Q |= EXPO_OVER; + exp_b &= 077; + } + A = (B & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | + (sb ? MSIGN: 0); + B = X; +} + +/* Double precision multiply. + A & Y (not in real B5500) have operand 1. + B & X have operand 2 */ +void double_mult() { + int exp_a, exp_b; + int f; + int ld; + t_uint64 m7, m6; + + AB_valid(); + X = A; /* Save registers. X = H, Y=L*/ + Y = B; + AROF = BROF = 0; + AB_valid(); /* Grab other operand */ + m7 = A; /* Oprands A,Y and B,X */ + A = X; + X = B; + B = m7; + + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + exp_b = (B & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + if (B & ESIGN) + exp_b = -exp_b; + /* Extract signs, clear upper bits */ + f = (A & MSIGN) != 0; + A &= MANT; + Y &= MANT; + f ^= ((B & MSIGN) != 0); + B &= MANT; + X &= MANT; + + /* Normalize the operands */ + for(ld = 0; (B & NORM) == 0 && ld < 13 ; ld++) { + B <<= 3; + B |= (X >> 36) & 07; + X <<= 3; + X &= MANT; + exp_b--; + } + + for(ld = 0; (A & NORM) == 0 && ld < 13 ; ld++) { + A <<= 3; + A |= (Y >> 36) & 07; + Y <<= 3; + Y &= MANT; + exp_a--; + } + + if ((X == 0 && B == 0) || (Y == 0 && A == 0)) { + A = B = 0; + return; + } + exp_b += exp_a + 13; + /* A = M3, Y = m3 */ + /* B = M4, X = m4 */ + /* B * Y => M6(Y),m6(m6) */ + /* A * X => M7(X) m7(m7) */ + /* Add m6(m7) + m7(m6) save High order digit of m7 */ + /* X = M7(X) + M6(Y) */ + /* A * B => Mx(B),mx(m6) */ + /* Add M7 to mx => M8 + m8 */ + /* Add M6 to m8 => M9(M8) + m9 */ + /* M6 m6 = M4 * m3 */ + mult_step(B, &Y, &m6); /* Y = M6, m6 = m6 */ + /* M7 m7 = (M3 * m4) */ + mult_step(A, &X, &m7); /* X = M7, m7 = m7 */ + m6 += m7; + ld = m6 >> (EXPO_V-3); /* High order digit */ + /* M8 m8 = (M4 * M3) */ + mult_step(A, &B, &m6); /* B = M8, m6 = m8 */ + /* M8 m8 = (M4 * M3) + M7 + M6 */ + m6 += X + Y; + /* M9 m9 = M8 + (m8 + M6) */ + /* M10m10= M9 + m9 + (high order digit of m7) */ + A = B + (m6 >> EXPO_V); + B = m6 & MANT; + + if ((A & EXPO) != 0) { + ld = B&7; + B |= (A & 07) << EXPO_V; + B >>= 3; + A >>= 3; + exp_b ++; + } + if ((A & NORM) == 0) { + A <<= 3; + A |= (B >> 36) & 07; + B <<= 3; + B += ld; + ld = 0;; + B &= MANT; + exp_b --; + } + if (ld >= 4 && A != MANT && B != MANT) { + B++; + if (B & EXPO) { + B &= MANT; + A++; + } + } + + if (exp_b < 0) { /* Handle underflow */ + if (exp_b < -64 && NCSF) + Q |= EXPO_UNDER; + exp_b = ((-exp_b) & 077)|0100; + } else { + if (exp_b > 64 && NCSF) + Q |= EXPO_OVER; + exp_b &= 077; + } + A = (A & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | + (f ? MSIGN: 0); +} + +/* Double precision divide. + A & Y (not in real B5500) have operand 1. + B & X have operand 2 */ +void double_divide() { + int exp_a, exp_b; + int f; + int n; + int q; + t_uint64 Q1, q1; + + AB_valid(); + X = A; /* Save registers. X = H, Y=L*/ + Y = B; + AROF = BROF = 0; + AB_valid(); /* Grab other operand */ + Q1 = A; /* Oprands A,Y and B,X */ + A = X; + X = B; + B = Q1; + + /* Extract exponent */ + exp_a = (A & EXPO) >> EXPO_V; + if (A & ESIGN) + exp_a = -exp_a; + /* Extract signs, clear upper bits */ + f = (A & MSIGN) != 0; + A &= MANT; + Y &= MANT; + /* Normalize A */ + for(n = 0; (A & NORM) == 0 && n < 13 ; n++) { + A <<= 3; + A |= (Y >> 36) & 07; + Y <<= 3; + Y &= MANT; + exp_a--; + } + + /* Extract B */ + exp_b = (B & EXPO) >> EXPO_V; + if (B & ESIGN) + exp_b = -exp_b; + f ^= ((B & MSIGN) != 0); + B &= MANT; + X &= MANT; + for(n = 0; (B & NORM) == 0 && n < 13 ; n++) { + B <<= 3; + B |= (X >> 36) & 07; + X <<= 3; + X &= MANT; + exp_b--; + } + + /* Check for divisor of 0 */ + if ((B == 0) && (X == 0)) { + A = 0; + return; + } + + /* Check for divide by 0 */ + if ((A == 0) && (Y == 0)) { + if (NCSF) + Q |= DIV_ZERO; + A = B; + B = X; + return; + } + + exp_b = exp_b - exp_a + 1; + /* B,X = M4,m4 A,Y = M3,m3 */ + + /* Divide M4,m4 by M3 resulting in Q1, R1 */ + do { + q = 0; /* initialize the quotient digit */ + while (B >= A) { + ++q; /* bump the quotient digit */ + B -= A; /* subtract divisor from reAinder */ + } + + B <<= 3; /* shift the remainder left one octade */ + X = (X<<3) + (t_uint64)q; /* shift quotient digit into the + working quotient */ + --exp_b; + n++; + } while (n < 13); + + if (exp_b < 0) { /* Handle underflow */ + if (exp_b < -64 && NCSF) + Q |= EXPO_UNDER; + exp_b = ((-exp_b) & 077)|0100; + } else { + if (exp_b > 64 && NCSF) + Q |= EXPO_OVER; + exp_b &= 077; + } + + /* Save Q1 in x R1 in B */ + Q1 = (X & MANT) | ((t_uint64)(exp_b & 0177) << EXPO_V) | + (f ? MSIGN: 0); + X = 0; + /* Now divide R1 by M3 resulting in q1, R2 */ + /* A=M3, B=R1, X=q1, B=R2 */ + for (n = 0; n < 13; n++) { + q = 0; /* initialize the quotient digit */ + while (B >= A) { + ++q; /* bump the quotient digit */ + B -= A; /* subtract divisor from reAinder */ + } + + B <<= 3; /* shift the remainder left one octade */ + X = (X<<3) + (t_uint64)q; /* shift quotient digit into the + working quotient */ + } + + q1 = X; + B = Y; + Y = X; + X = 0; + /* Now divide m3 by M3 resulting in q2, R3 */ + /* q2 in X, R3 in B */ + for (n = 0; n < 13; n++) { + q = 0; /* initialize the quotient digit */ + while (B >= A) { + ++q; /* bump the quotient digit */ + B -= A; /* subtract divisor from reAinder */ + } + + B <<= 3; /* shift the remainder left one octade */ + X = (X<<3) + (t_uint64)q; /* shift quotient digit into the + working quotient */ + } + + if (X == 0) { + A = Q1; + B = q1; + } else { + /* Load in Q1,q1 into B */ + A = 01157777777777777; + Y = MANT ^ X; /* Load q2 into A */ + B = Q1; + X = q1; + double_mult(); + } +} + +void relativeAddr(int store) { + uint16 base = R; + uint16 addr = (uint16)(A & 01777); + + if (SALF) { + switch ((addr >> 7) & 7) { + case 0: + case 1: + case 2: + case 3: + default: /* To avoid compiler warnings */ + break; + + case 4: + case 5: + addr &= 0377; + if (MSFF) { + Ma = R+7; + memory_cycle(4); + base = FF(A); + } else + base = F; + break; + + case 6: + addr &= 0177; + base = (store)? R : ((L) ? C : C-1); + break; + + case 7: + addr = -(addr & 0177); + if (MSFF) { + Ma = R+7; + memory_cycle(4); + base = FF(A); + } else + base = F; + break; + } + } + Ma = (base + addr) & CORE; +} + +t_stat +sim_instr(void) +{ + t_stat reason; + t_uint64 temp = 0LL; + uint16 atemp; + uint8 opcode; + uint8 field; + int bit_a; + int bit_b; + int f; + int i; + int j; + + reason = 0; + hltf[0] = 0; + hltf[1] = 0; + P1_run = 1; + + while (reason == 0) { /* loop until halted */ + if (P1_run == 0) + return SCPE_STOP; + while (loading) { + sim_interval = -1; + reason = sim_process_event(); + if (reason != SCPE_OK) { + break; /* process */ + } + } + if (sim_interval <= 0) { /* event queue? */ + reason = sim_process_event(); + if (reason != SCPE_OK) { + break; /* process */ + } + } + + if (sim_brk_summ) { + if(sim_brk_test((C << 3) | L, SWMASK('E'))) { + reason = SCPE_STOP; + break; + } + + if (sim_brk_test((c_reg[0] << 3) | l_reg[0], + SWMASK('A'))) { + reason = SCPE_STOP; + break; + } + + if (sim_brk_test((c_reg[1] << 3) | l_reg[1], + SWMASK('B'))) { + reason = SCPE_STOP; + break; + } + } + + /* Toggle between two CPU's. */ + if (cpu_index == 0 && P2_run == 1) { + cpu_index = 1; + /* Check if interrupt pending. */ + if (TROF == 0 && NCSF && ((Q != 0) || HLTF)) + /* Force a SFI */ + storeInterrupt(1,0); + } else { + cpu_index = 0; + + /* Check if interrupt pending. */ + if (TROF == 0 && NCSF && ((Q != 0) || + (IAR != 0))) + /* Force a SFI */ + storeInterrupt(1,0); + } + if (TROF == 0) + next_prog(); + + /* TODO: Add support to detect IDLE loop */ +crf_loop: + opcode = T & 077; + field = (T >> 6) & 077; + TROF = 0; + + if (hst_lnt) { /* history enabled? */ + /* Ignore idle loop when recording history */ + /* DCMCP XIII */ + /* if ((C & 077774) != 01140) { */ + /* DCMCP XV */ + /* if ((C & 077774) != 01254) { */ + /* TSMCP XV */ + /* if ((C & 077774) != 01324) { */ + hst_p = (hst_p + 1); /* next entry */ + if (hst_p >= hst_lnt) { + hst_p = 0; + } + hst[hst_p].c = (C) | HIST_PC; + hst[hst_p].op = T; + hst[hst_p].s = S; + hst[hst_p].f = F; + hst[hst_p].r = R; + hst[hst_p].ma = Ma; + hst[hst_p].a_reg = A; + hst[hst_p].b_reg = B; + hst[hst_p].x_reg = X; + hst[hst_p].gh = GH; + hst[hst_p].kv = KV; + hst[hst_p].l = L; + hst[hst_p].q = Q; + hst[hst_p].cpu = cpu_index; + hst[hst_p].iar = IAR; + hst[hst_p].flags = ((AROF)? F_AROF : 0) | \ + ((BROF)? F_BROF : 0) | \ + ((CWMF)? F_CWMF : 0) | \ + ((NCSF)? F_NCSF : 0) | \ + ((SALF)? F_SALF : 0) | \ + ((MSFF)? F_MSFF : 0) | \ + ((VARF)? F_VARF : 0); + /* } */ + } + + /* Check if Character or Word Mode */ + if (CWMF) { + /* Character mode source word in A + addressed by M,G,H. + destination in B + addressed by S,K,V. + R = tally. + X = loop control. + F = return control word + */ + switch(opcode) { + case CMOP_EXC: /* EXIT char mode */ + if (BROF) { + memory_cycle(013); + } + S = F; + AROF = 0; + memory_cycle(3); /* Load B from S */ + if ((B & FLAG) == 0) { + if (NCSF) + Q |= FLAG_BIT; + break; + } + f = set_via_RCW(B, (field & 1), 0); + S = F; + memory_cycle(3); /* Load MSW from S to B */ + set_via_MSCW(B); + prev_addr(S); + CWMF = 0; + if (MSFF && SALF) { + Ma = F; + do { + /* B = M[FIELD], Ma = B[FIELD]; */ + memory_cycle(6); /* Grab previous MCSW */ + } while(B & SMSFF); + Ma = R | 7; + memory_cycle(015); /* Store B in Ma */ + } + BROF = 0; + X = 0; + if ((field & 1) == 0) + PROF = 0; + break; + + case CMOP_BSD: /* Skip Bit Destiniation */ + if (BROF) { + memory_cycle(013); + } + while(field > 0) { + field--; + next_dest(1); + } + break; + + case CMOP_SRS: /* Skip Reverse Source */ + adjust_source(); + while(field > 0) { + field--; + prev_src(0); + } + break; + + case CMOP_SFS: /* Skip Forward Source */ + adjust_source(); + while(field > 0) { + field--; + next_src(0); + } + break; + + case CMOP_BSS: /* SKip Bit Source */ + while(field > 0) { + field--; + next_src(1); + } + break; + + case CMOP_SFD: /* Skip Forward Destination */ + adjust_dest(); + while(field > 0) { + field--; + next_dest(0); + } + break; + + case CMOP_SRD: /* Skip Reverse Destination */ + adjust_dest(); + while(field > 0) { + field--; + prev_dest(0); + } + break; + + case CMOP_RSA: /* Recall Source Address */ + Ma = (F - field) & CORE; + memory_cycle(4); + AROF = 0; + if (A & FLAG) { + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + GH = 0; + } else { + GH = (A >> 12) & 070; + } + Ma = CF(A); + break; + + case CMOP_RDA: /* Recall Destination Address */ + if (BROF) + memory_cycle(013); + S = (F - field) & CORE; + memory_cycle(3); + BROF = 0; + if (B & FLAG) { + if ((B & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + KV = 0; + } else { + KV = (B >> 12) & 070; + } + S = CF(B); + break; + + case CMOP_RCA: /* Recall Control Address */ + AROF = BROF; + A = B; /* Save B temporarly */ + atemp = S; /* Save S */ + S = (F - field) & CORE; + memory_cycle(3); /* Load word in B */ + S = atemp; /* Restore S */ + if (B & FLAG) { + if ((B & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + C = CF(B); + L = 0; + } else { + C = CF(B); + L = LF(B) + 1; + if (L > 3) { + L = 0; + next_addr(C); + } + } + B = A; + BROF = AROF; + AROF = 0; + PROF = 0; + break; + + case CMOP_SED: /* Set Destination Address */ + if (BROF) + memory_cycle(013); + S = (F - field) & CORE; + KV = 0; + BROF = 0; + break; + + case CMOP_SES: /* Set Source Address */ + Ma = (F - field) & CORE; + GH = 0; + AROF = 0; + break; + + case CMOP_TSA: /* Transfer Source Address */ + if (BROF) + memory_cycle(013); + BROF = 0; + adjust_source(); + field = 3; + while(field > 0) { + fill_src(); + i = (A >> bit_number[GH | 07]) & 077; + B <<= 6; + B |= i; + next_src(0); + field--; + } + B &= FLAG|FWORD; + GH = (uint8)((B >> 12) & 070); + Ma = CF(B); + break; + + case CMOP_TDA: /* Transfer Destination Address */ + if (BROF) + memory_cycle(013); + BROF = 0; + adjust_dest(); + field = 3; + temp = 0; + while(field > 0) { + fill_dest(); + i = (B >> bit_number[KV | 07]) & 077; + temp <<= 6; + temp |= i; + next_dest(0); + field--; + } + BROF = 0; + KV = (uint8)((temp >> 12) & 070); + S = CF(temp); + break; + + case CMOP_SCA: /* Store Control Address */ + A = B; + AROF = BROF; + B = toF(F) | toL(L) | toC(C); + F = S; + S = FF(B); + S = (S - field) & CORE; + memory_cycle(013); /* Store B in S */ + S = F; + F = FF(B); + B = A; + BROF = AROF; + AROF = 0; + break; + + case CMOP_SDA: /* Store Destination Address */ + adjust_dest(); + A = B; + AROF = BROF; + B = ((t_uint64)(KV & 070) << (FFIELD_V - 3)) | toC(S); + S = (F - field) & CORE; + memory_cycle(013); /* Store B in S */ + S = CF(B); + B = A; + BROF = AROF; + AROF = 0; + break; + + case CMOP_SSA: /* Store Source Address */ + adjust_source(); + A = B; + AROF = BROF; + B = ((t_uint64)(GH & 070) << (FFIELD_V - 3)) | toC(Ma); + Ma = (F - field) & CORE; + memory_cycle(015); /* Store B in Ma */ + Ma = CF(B); + B = A; + BROF = AROF; + AROF = 0; + break; + + case CMOP_TRW: /* Transfer Words */ + if (BROF) { + memory_cycle(013); + BROF = 0; + } + if (GH != 0) { + next_addr(Ma); + GH = 0; + AROF = 0; + } + if (KV != 0) { + next_addr(S); + KV = 0; + } + while(field > 0) { + field--; + memory_cycle(4); + memory_cycle(012); + next_addr(Ma); + next_addr(S); + } + BROF = 0; + AROF = 0; + break; + + case CMOP_TEQ: /* Test for Equal 24 */ + case CMOP_TNE: /* Test for Not-Equal 25 */ + case CMOP_TEG: /* Test for Greater Or Equal 26 */ + case CMOP_TGR: /* Test For Greater 27 */ + case CMOP_TEL: /* Test For Equal or Less 34 */ + case CMOP_TLS: /* Test For Less 35 */ + case CMOP_TAN: /* Test for Alphanumeric 36 */ + adjust_source(); + fill_src(); + i = rank[(A >> bit_number[GH | 07]) & 077]; + j = rank[field]; + if (i == j) + f = 1; + else if (i < j) + f = 2; + else + f = 4; + switch(opcode) { + case CMOP_TEQ: /* Test for Equal 24 */ + TFFF = (f == 1); break; + case CMOP_TNE: /* Test for Not-Equal 25 */ + TFFF = (f != 1); break; + case CMOP_TEG: /* Test for Greater Or Equal 26 */ + TFFF = ((f & 5) != 0); break; + case CMOP_TGR: /* Test For Greater 27 */ + TFFF = (f == 4); break; + case CMOP_TEL: /* Test For Equal or Less 34 */ + TFFF = ((f & 3) != 0); break; + case CMOP_TLS: /* Test For Less 35 */ + TFFF = (f == 2); break; + case CMOP_TAN: /* Test for Alphanumeric 36 */ + if (f & 4) { + TFFF = !((i == 34) | (i == 44)); + } else { + TFFF = f & 1; + } + break; + } + break; + + case CMOP_BIS: /* Set Bit */ + case CMOP_BIR: /* Reet Bit */ + while(field > 0) { + field--; + fill_dest(); + temp = bit_mask[bit_number[KV]]; + if (opcode & 1) + B &= ~temp; + else + B |= temp; + next_dest(1); + } + break; + + case CMOP_BIT: /* Test Bit */ + fill_src(); + i = (A >> bit_number[GH]) & 01; + TFFF = (i == (field & 1)); + break; + + case CMOP_INC: /* Increase Tally */ + R = (R + (field<<6)) & 07700; + break; + + case CMOP_STC: /* Store Tally */ + if (BROF) + memory_cycle(11); + AROF = 0; + BROF = 0; + A = toC(F); + B = R >> 6; + F = S; + S = CF(A); + S = (S - field) & CORE; + memory_cycle(11); + S = F; + F = CF(A); + break; + + case CMOP_SEC: /* Set Tally */ + R = T & 07700; + break; + + case CMOP_CRF: /* Call repeat Field */ + /* Save B in A */ + AROF = BROF; + A = B; + /* Save F in B */ + atemp = F; + /* Exchange S & F */ + F = S; + /* Decrement S */ + S = (atemp - field) & CORE; + /* Read value to B, S <= F, F <= B */ + memory_cycle(3); + /* field = B & 077 */ + field = B & 077; + /* Restore B */ + S = F; + F = atemp; + B = A; + BROF = AROF; + AROF = 0; + /* fetch_next; */ + next_prog(); + /* If field == 0, opcode |= 4; field = T */ + if (field == 0) { + T &= 07700; + T |= CMOP_JFW; + } else { + T &= 077; + T |= field << 6; + } + /* Goto crf_loop */ + goto crf_loop; + + case CMOP_JNC: /* Jump Out Of Loop Conditional */ + if (TFFF) + break; + + /* Fall through */ + case CMOP_JNS: /* Jump out of loop unconditional */ + /* Read Loop/Return control word */ + atemp = S; + S = FF(X); + memory_cycle(2); /* Load S to A */ + AROF = 0; + X = (A & MANT); + S = atemp; + if (field > 0) { + i = (C << 2) | L; /* Make into syllable pointer */ + i += field; + L = i & 3; /* Convert back to pointer */ + C = (i >> 2) & CORE; + PROF = 0; + } + break; + + case CMOP_JFC: /* Jump Forward Conditional */ + case CMOP_JRC: /* Jump Reverse Conditional */ + if (TFFF != 0) + break; + + /* Fall through */ + case CMOP_JFW: /* Jump Forward Unconditional */ + case CMOP_JRV: /* Jump Reverse Unconditional */ + i = (C << 2) | L; /* Make into syllable pointer */ + if (opcode & 010) { /* Forward */ + i -= field; + } else { /* Backward */ + i += field; + } + L = i & 3; /* Convert back to pointer */ + C = (i >> 2) & CORE; + PROF = 0; + break; + + case CMOP_ENS: /* End Loop */ + A = B; + AROF = BROF; + B = X; + field = (uint8)((B & REPFLD) >> REPFLD_V); + if (field) { + X &= ~REPFLD; + X |= ((t_uint64)(field - 1) << REPFLD_V) & REPFLD; + L = LF(B); + C = CF(B); + PROF = 0; + memory_cycle(020); + } else { + atemp = S; + S = FF(X); + memory_cycle(3); /* Load B */ + X = B & MANT; + S = atemp; + } + B = A; + BROF = AROF; + AROF = 0; + break; + + case CMOP_BNS: /* Begin Loop */ + A = B; /* Save B */ + AROF = BROF; + B = X | FLAG | DFLAG; + if (field != 0) + field--; + atemp = S; + S = FF(B); + next_addr(S); + memory_cycle(013); + X = LCW(S, field); + S = atemp; + B = A; + BROF = AROF; + AROF = 0; + break; + + case CMOP_OCV: /* Output Convert */ + adjust_dest(); + if (BROF) { + memory_cycle(013); + BROF = 0; + } + /* Adjust source to word boundry */ + if (GH) { + GH = 0; + next_addr(Ma); + AROF = 0; + } + + if (field == 0) + break; + + /* Load word into A */ + fill_src(); + next_addr(Ma); + AROF = 0; + B = 0; + temp = 0; + f = (A & MSIGN) != 0; + TFFF = 1; + A &= MANT; + if (A == 0) + f = 0; + i = 39; + /* We loop over the bit in A and add one to B + each time we have the msb of A set. For each + step we BCD double the number in B */ + while(i > 0) { + /* Compute carry to next digit */ + temp = (B + 0x33333333LL) & 0x88888888LL; + B <<= 1; /* Double it */ + /* Add 6 from every digit that overflowed */ + temp = (temp >> 1) | (temp >> 2); + B += temp; + /* Lastly Add in new digit */ + j = (A & ROUND) != 0; + A &= ~ROUND; + B += (t_uint64)j; + A <<= 1; + i--; + } + A = B; + field = field & 07; + if (field == 0) + field = 8; + /* Now we put each digit into the destination string */ + for(i = 8; i >= 0; i--) { + j = (A >> (i * 4)) & 0xF; + if (i >= field) { + if (j != 0) + TFFF = 0; + } else { + fill_dest(); + temp = 077LL << bit_number[KV | 07]; + B &= ~temp; + if (i == 0 && f) + j |= 040; + B |= ((t_uint64)j) << bit_number[KV | 07]; + BROF = 1; + next_dest(0); + } + } + break; + + case CMOP_ICV: /* Input Convert */ + adjust_source(); + if (BROF) { + memory_cycle(013); + BROF = 0; + } + /* Align result to word boundry */ + if (KV) { + KV = 0; + next_addr(S); + } + + if (field == 0) + break; + B = 0; + temp = 0; + f = 0; + /* Collect the source field into a string of BCD digits */ + while(field > 0) { + fill_src(); + i = (int)(A >> bit_number[GH | 07]); + B = (B << 4) | (i & 017); + f = (i & 060) == 040; /* Keep sign */ + field = (field - 1) & 07; + next_src(0); + } + /* We loop over the BCD number in B, dividing it by 2 + each cycle, while shifting the lsb into the top of + the A register */ + field = 28; + A = 0; + while(field > 0) { + A >>= 1; + if (B & 1) + A |= ((t_uint64)1) << 27; + /* BCD divide by 2 */ + temp = B & 0x0011111110LL; + temp = (temp >> 4) | (temp >> 3); + B = (B >> 1) - temp; + field--; + } + if (f && A != 0) + A |= MSIGN; + memory_cycle(012); + AROF = 0; + next_addr(S); + break; + + case CMOP_CEQ: /* Compare Equal 60 */ + case CMOP_CNE: /* COmpare for Not Equal 61 */ + case CMOP_CEG: /* Compare For Greater Or Equal 62 */ + case CMOP_CGR: /* Compare For Greater 63 */ + case CMOP_CEL: /* Compare For Equal or Less 70 */ + case CMOP_CLS: /* Compare for Less 71 */ + case CMOP_FSU: /* Field Subtract 72 */ + case CMOP_FAD: /* Field Add 73 */ + adjust_source(); + adjust_dest(); + TFFF = 1; /* flag to show greater */ + f = 1; /* Still comparaing */ + while(field > 0) { + fill_src(); + fill_dest(); + if (f) { + i = (A >> bit_number[GH | 07]) & 077; + j = (B >> bit_number[KV | 07]) & 077; + if (i != j) { + switch(opcode) { + case CMOP_FSU: /* Field Subtract */ + case CMOP_FAD: /* Field Add */ + /* Do numeric compare */ + i &= 017; + j &= 017; + if (i != j) + f = 0; /* Different, so stop check */ + if (i < j) + TFFF = 0; + break; + case CMOP_CEQ: /* Compare Equal 60 */ + case CMOP_CNE: /* Compare for Not Equal 61 */ + case CMOP_CEG: /* Compare For Greater Or Equal 62 */ + case CMOP_CGR: /* Compare For Greater 63 */ + case CMOP_CEL: /* Compare For Equal or Less 70 */ + case CMOP_CLS: /* Compare for Less 71 */ + f = 0; /* No need to continue; */ + if (rank[i] < rank[j]) + TFFF = 0; + break; + } + } + } + next_src(0); + next_dest(0); + field--; + } + /* If F = 1, fields are equal. + If F = 0 and TFFF = 0 S < D. + If F = 0 and TFFF = 1 S > D. + */ + switch(opcode) { + case CMOP_FSU: /* Field Subtract */ + case CMOP_FAD: /* Field Add */ + { + int ss, sd, sub; + int c; + /* Back up one location */ + prev_src(0); + prev_dest(0); + fill_src(); + fill_dest(); + field = (T >> 6) & 077; + i = (A >> bit_number[GH | 07]) & 077; + j = (B >> bit_number[KV | 07]) & 077; + /* Compute Sign */ + ss = (i & 060) == 040; /* S */ + sd = (j & 060) == 040; /* D */ + sub = (ss == sd) ^ (opcode == CMOP_FAD); + /* + ss sd sub f=1 TFFF=0 TFFF=1 + add 0 0 0 0 0 0 + add 1 0 1 0 0 1 + add 0 1 1 0 1 0 + add 1 1 0 1 1 1 + sub 0 0 1 0 0 1 + sub 1 0 0 0 0 0 + sub 0 1 0 1 1 1 + sub 1 1 1 0 1 0 + */ + f = (f & sd & ss & (!sub)) | + (f & sd & (!ss) & (!sub)) | + ((!f) & (!TFFF) & sd) | + ((!f) & TFFF & (ss ^ (opcode == CMOP_FSU))); + c = 0; + if (sub) { + c = 1; + if (TFFF) { /* If S < D */ + ss = 0; + sd = 1; + } else { + ss = 1; + sd = 0; + } + } else { + sd = ss = 0; + } + /* Do the bulk of adding. */ + i &= 017; + j &= 017; + while (field > 0) { + i = (ss ? 9-i : i ) + (sd ? 9-j : j) + c; + if (i < 10) { + c = 0; + } else { + c = 1; + i -= 10; + } + if (f) { + i += 040; + f = 0; + } + temp = 077LL << bit_number[KV | 07]; + B &= ~temp; + B |= ((t_uint64)i) << bit_number[KV | 07]; + prev_src(0); + prev_dest(0); + fill_src(); + fill_dest(); + i = (A >> bit_number[GH | 07]) & 017; + j = (B >> bit_number[KV | 07]) & 017; + field--; + } + /* Set overflow flag */ + TFFF = sub ^ c; + } + /* Lastly back to end of field. */ + field = (T >> 6) & 077; + next_src(0); + next_dest(0); + while (field > 0) { + next_src(0); + next_dest(0); + field--; + } + break; + case CMOP_CEQ: /* Compare Equal 60 */ + TFFF = f; + break; + case CMOP_CNE: /* Compare for Not Equal 61 */ + TFFF = !f; + break; + case CMOP_CEG: /* Compare For Greater Or Equal 62 */ + TFFF |= f; + break; + case CMOP_CGR: /* Compare For Greater 63 */ + TFFF &= !f; + break; + case CMOP_CEL: /* Compare For Equal or Less 70 */ + TFFF = !TFFF; + TFFF |= f; + break; + case CMOP_CLS: /* Compare for Less 71 */ + TFFF = !TFFF; + TFFF &= !f; + break; + } + break; + + case CMOP_TRP: /* Transfer Program Characters 74 */ + adjust_dest(); + while(field > 0) { + fill_dest(); + if (!TROF) + next_prog(); + if (field & 1) { + i = T & 077; + TROF = 0; + } else { + i = (T >> 6) & 077; + } + temp = 077LL << bit_number[KV | 07]; + B &= ~temp; + B |= ((t_uint64)i) << bit_number[KV | 07]; + next_dest(0); + field--; + } + TROF = 0; + break; + + case CMOP_TRN: /* Transfer Numeric 75 */ + case CMOP_TRZ: /* Transfer Zones 76 */ + case CMOP_TRS: /* Transfer Source Characters 77 */ + adjust_source(); + adjust_dest(); + while(field > 0) { + fill_dest(); + fill_src(); + i = (int)(A >> bit_number[GH | 07]); + if (opcode == CMOP_TRS) { + i &= 077; + temp = 077LL << bit_number[KV | 07]; + } else if (opcode == CMOP_TRN) { + if (field == 1) { + if ((i & 060) == 040) + TFFF = 1; + else + TFFF = 0; + } + i &= 017; + temp = 077LL << bit_number[KV | 07]; + } else { + i &= 060; + temp = 060LL << bit_number[KV | 07]; + } + B &= ~temp; + B |= ((t_uint64)i) << bit_number[KV | 07]; + next_src(0); + next_dest(0); + field--; + } + break; + + case CMOP_TBN: /* Transfer Blanks for Non-Numerics 12 */ + adjust_dest(); + TFFF = 1; + while(field > 0) { + fill_dest(); + i = (B >> bit_number[KV | 07]) & 077; + if (i > 0 && i <= 9) { + TFFF = 0; + break; + } + B &= ~(077LL << bit_number[KV | 07]); + B |= 060LL << bit_number[KV | 07]; + next_dest(0); + field--; + } + break; + + case 0011: + goto control; + } + } else { + /* Word mode opcodes */ + switch(opcode & 03) { + case WMOP_LITC: /* Load literal */ + A_empty(); + A = toC(T >> 2); + AROF = 1; + break; + + case WMOP_OPDC: /* Load operand */ + A_empty(); + A = toC(T >> 2); + relativeAddr(0); + memory_cycle(4); + SALF |= VARF; + VARF = 0; +opdc: + if (A & FLAG) { + /* Check if it is a control word. */ + if ((A & DFLAG) != 0 && (A & PROGF) == 0) { + break; + } + /* Check if descriptor present */ + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + /* Program Descriptor */ + if ((A & (DFLAG|PROGF)) == (DFLAG|PROGF)) { + enterSubr(0); + } else { + if (indexWord()) + break; + memory_cycle(4); + if (NCSF && (A & FLAG)) + Q |= FLAG_BIT; + } + } + break; + + case WMOP_DESC: /* Load Descriptor */ + A_empty(); + A = toC(T >> 2); + relativeAddr(0); + memory_cycle(4); + SALF |= VARF; + VARF = 0; +desc: + if (A & FLAG) { + /* Check if it is a control word. */ + if ((A & DFLAG) != 0 && (A & PROGF) == 0) { + A = FLAG | PRESENT | toC(Ma); + break; + } + /* Check if descriptor present */ + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + /* Data descriptor */ + if ((A & (DFLAG|PROGF)) == (DFLAG|PROGF)) { + enterSubr(1); + } else { + if (indexWord()) + break; + A |= FLAG | PRESENT; + } + } else { + A = FLAG | PRESENT | toC(Ma); + } + break; + + case WMOP_OPR: /* All other operators */ + switch(opcode) { + case 0001: + switch(field) { + case VARIANT(WMOP_SUB): /* Subtract */ + case VARIANT(WMOP_ADD): /* Add */ + add(T); + break; + case VARIANT(WMOP_MUL): /* Multiply */ + multiply(); + break; + case VARIANT(WMOP_DIV): /* Divide */ + case VARIANT(WMOP_IDV): /* Integer Divide Integer */ + case VARIANT(WMOP_RDV): /* Remainder Divide */ + divide(T); + break; + } + break; + + case 0005: + switch(field) { + case VARIANT(WMOP_DLS): /* Double Precision Subtract */ + case VARIANT(WMOP_DLA): /* Double Precision Add */ + double_add(T); + break; + case VARIANT(WMOP_DLM): /* Double Precision Multiply */ + double_mult(); + break; + case VARIANT(WMOP_DLD): /* Double Precision Divide */ + double_divide(); + break; + } + break; + + case 0011: + /* Control functions same as Character mode, + although most operators do not make sense in + Character mode. */ +control: + switch(field) { + /* Different in Character mode */ + case VARIANT(WMOP_SFT): /* Store for Test */ + storeInterrupt(0,1); + break; + + case VARIANT(WMOP_SFI): /* Store for Interrupt */ + storeInterrupt(0,0); + break; + + case VARIANT(WMOP_ITI): /* Interrogate interrupt */ + if (NCSF) /* Nop in normal state */ + break; + + if (q_reg[0] & MEM_PARITY) { + C = PARITY_ERR; + q_reg[0] &= ~MEM_PARITY; + } else if (q_reg[0] & INVALID_ADDR) { + C = INVADR_ERR; + q_reg[0] &= ~INVALID_ADDR; + } else if (IAR) { + uint16 x; + C = INTER_TIME; + for(x = 1; (IAR & x) == 0; x <<= 1) + C++; + /* Release the channel after we got it */ + if (C >= IO1_FINISH && C <= IO4_FINISH) + chan_release(C - IO1_FINISH); + IAR &= ~x; + } else if ((q_reg[0] & 0170) != 0) { + C = 060 + (q_reg[0] >> 3); + q_reg[0] &= 07; + } else if (q_reg[0] & STK_OVERFL) { + C = STK_OVR_LOC; + q_reg[0] &= ~STK_OVERFL; + } else if (P2_run == 0 && q_reg[1] != 0) { + if (q_reg[1] & MEM_PARITY) { + C = PARITY_ERR2; + q_reg[1] &= ~MEM_PARITY; + } else if (q_reg[1] & INVALID_ADDR) { + C = INVADR_ERR2; + q_reg[1] &= ~INVALID_ADDR; + } else if ((q_reg[1] & 0170) != 0) { + C = 040 + (q_reg[1] >> 3); + q_reg[1] &= 07; + } else if (q_reg[1] & STK_OVERFL) { + C = STK_OVR_LOC2; + q_reg[1] &= ~STK_OVERFL; + } + } else { + /* Could be an idle loop, if P2 running, continue */ + if (P2_run) + break; + if (sim_idle_enab) { + /* Check if possible idle loop */ + if (check_idle()) + sim_idle (TMR_RTC, FALSE); + } + break; + } + sim_debug(DEBUG_DETAIL, &cpu_dev, "IAR=%05o Q=%03o\n\r", + IAR,Q); + L = 0; + S = 0100; + CWMF = 0; + PROF = 0; + break; + + case VARIANT(WMOP_IOR): /* I/O Release */ + if (NCSF) /* Nop in normal state */ + break; + + /* Fall through */ + case VARIANT(WMOP_PRL): /* Program Release */ + A_valid(); + if ((A & FLAG) == 0) { + relativeAddr(1); + } else if (A & PRESENT) { + Ma = CF(A); + } else { + if (NCSF) + Q |= PRES_BIT; + break; + } + memory_cycle(4); /* Read Ma to A */ + if (NCSF) { /* Can't occur for IOR */ + Q |= (A & CONTIN) ? CONT_BIT : PROG_REL; + A = toC(Ma); + Ma = R | 9; + } else { + if (field == VARIANT(WMOP_PRL)) + A &= ~PRESENT; + else + A |= PRESENT; + } + memory_cycle(014); /* Store A to Ma */ + AROF = 0; + break; + + case VARIANT(WMOP_RTR): /* Read Timer */ + if (!NCSF) { + A_empty(); + A = RTC; + if (IAR & IRQ_0) + A |= 0100; + AROF = 1; + } + break; + + case VARIANT(WMOP_COM): /* Communication operator */ + if (NCSF) { + Ma = R|9; + save_tos(); + Q |= COM_OPR; + } + break; + + case VARIANT(WMOP_ZP1): /* Conditional Halt */ + if (NCSF) + break; + if (!HLTF) + break; + if (!HALT) + break; + hltf[0] = 1; + P1_run = 0; + break; + + case VARIANT(WMOP_HP2): /* Halt P2 */ + /* Control state only */ + if (NCSF) + break; + /* If CPU 2 is not running, or disabled nop */ + if (P2_run == 0 || (cpu_unit[1].flags & UNIT_DIS)) { + break; + } + sim_debug(DEBUG_DETAIL, &cpu_dev, "HALT P2\n\r"); + /* Flag P2 to stop */ + hltf[1] = 1; + TROF = 1; /* Reissue until CPU2 stopped */ + break; + + case VARIANT(WMOP_IP1): /* Initiate P1 */ + if (NCSF) + break; + A_valid(); /* Load ICW */ + sim_debug(DEBUG_DETAIL, &cpu_dev, "INIT P1\n\r"); + initiate(); + break; + + case VARIANT(WMOP_IP2): /* Initiate P2 */ + if (NCSF) + break; + Ma = 010; + save_tos(); + /* If CPU is operating, or disabled, return busy */ + if (P2_run != 0 || (cpu_unit[1].flags & UNIT_DIS)) { + IAR |= IRQ_11; /* Set CPU 2 Busy */ + break; + } + /* Ok we are going to initiate B. + load the initiate word from 010. */ + hltf[1] = 0; + P2_run = 1; + cpu_index = 1; /* To CPU 2 */ + Ma = 010; + memory_cycle(4); + sim_debug(DEBUG_DETAIL, &cpu_dev, "INIT P2\n\r"); + initiate(); + break; + + case VARIANT(WMOP_IIO): /* Initiate I/O */ + if (NCSF) + break; + Ma = 010; + save_tos(); + start_io(); /* Start an I/O channel */ + break; + + /* Currently not implimented. */ + case VARIANT(WMOP_IFT): /* Test Initiate */ + /* Supports the ablity to start operand during any + cycle, since this simulator does not function the + same as the original hardware, this function can't + really be implemented. + It is currently only used in diagnostics. */ + /* Halt execution if this instruction attempted */ + reason = SCPE_NOFNC; + break; + } + break; + + case 0015: + switch(field) { + case VARIANT(WMOP_LNG): /* Logical Negate */ + A_valid(); + A = (A ^ FWORD); + break; + + case VARIANT(WMOP_LOR): /* Logical Or */ + AB_valid(); + A = (A & FWORD) | B; + BROF = 0; + break; + + case VARIANT(WMOP_LND): /* Logical And */ + AB_valid(); + A = (A & B & FWORD) | (B & FLAG); + BROF = 0; + break; + + case VARIANT(WMOP_LQV): /* Logical Equivalence */ + AB_valid(); + B = ((~(A ^ B) & FWORD)) | (B & FLAG); + AROF = 0; + break; + + case VARIANT(WMOP_MOP): /* Reset Flag bit */ + A_valid(); + A &= ~FLAG; + break; + + case VARIANT(WMOP_MDS): /* Set Flag Bit */ + A_valid(); + A |= FLAG; + break; + } + break; + + case 0021: + switch(field) { + case VARIANT(WMOP_CID): /* 01 Conditional Integer Store Destructive */ + case VARIANT(WMOP_CIN): /* 02 Conditional Integer Store non-destructive */ + case VARIANT(WMOP_ISD): /* 41 Interger Store Destructive */ + case VARIANT(WMOP_ISN): /* 42 Integer Store Non-Destructive */ + case VARIANT(WMOP_STD): /* 04 B Store Destructive */ + case VARIANT(WMOP_SND): /* 10 B Store Non-destructive */ + AB_valid(); + if (A & FLAG) { + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + Ma = CF(A); + } else { + relativeAddr(1); + } + SALF |= VARF; + VARF = 0; + if ((field & 03) != 0) { /* Integer store */ + if ((B & EXPO) != 0) { + /* Check if force to integer */ + if ((A & INTEGR) != 0 || (field & 040) != 0) { + if (mkint()) { + /* Fail if not an integer */ + if (NCSF) + Q |= INT_OVER; + break; + } + } + } + } + AROF = 0; + memory_cycle(015); /* Store B in Ma */ + if (field & 5) /* Destructive store */ + BROF = 0; + break; + + case VARIANT(WMOP_LOD): /* Load */ + A_valid(); + if (A & FLAG) { + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + Ma = CF(A); + } else { + relativeAddr(0); + } + SALF |= VARF; + VARF = 0; + memory_cycle(4); /* Read Ma to A */ + break; + } + break; + + case 0025: + switch(field) { + case VARIANT(WMOP_GEQ): /* B greater than or equal to A */ + case VARIANT(WMOP_GTR): /* B Greater than A */ + case VARIANT(WMOP_NEQ): /* B Not equal to A */ + case VARIANT(WMOP_LEQ): /* B Less Than or Equal to A */ + case VARIANT(WMOP_LSS): /* B Less Than A */ + case VARIANT(WMOP_EQL): /* B Equal A */ + AB_valid(); + f = 0; + i = compare(); + switch(field) { + case VARIANT(WMOP_GEQ): + if ((i & 5) != 0) f = 1; break; + case VARIANT(WMOP_GTR): + if (i == 4) f = 1; break; + case VARIANT(WMOP_NEQ): + if (i != 1) f = 1; break; + case VARIANT(WMOP_LEQ): + if ((i & 3) != 0) f = 1; break; + case VARIANT(WMOP_LSS): + if (i == 2) f = 1; break; + case VARIANT(WMOP_EQL): + if (i == 1) f = 1; break; + } + B = f; + AROF = 0; + break; + + case VARIANT(WMOP_XCH): /* Exchange */ + AB_valid(); + temp = A; + A = B; + B = temp; + break; + + case VARIANT(WMOP_FTF): /* Transfer F Field to F Field */ + AB_valid(); + B &= ~FFIELD; + B |= (A & FFIELD); + AROF = 0; + break; + + case VARIANT(WMOP_FTC): /* Transfer F Field to Core Field */ + AB_valid(); + B &= ~CORE; + B |= (A & FFIELD) >> FFIELD_V; + AROF = 0; + break; + + case VARIANT(WMOP_CTC): /* Transfer Core Field to Core Field */ + AB_valid(); + B &= ~CORE; + B |= (A & CORE); + AROF = 0; + break; + + case VARIANT(WMOP_CTF): /* Transfer Core Field to F Field */ + AB_valid(); + B &= ~FFIELD; + B |= FFIELD & (A << FFIELD_V); + AROF = 0; + break; + + case VARIANT(WMOP_DUP): /* Duplicate */ + if (AROF && BROF) { + B_empty(); + B = A; + BROF = 1; + } else if (AROF || BROF) { + if (AROF) + B = A; + else + A = B; + AROF = BROF = 1; + } else { + A_valid(); /* Make A Valid */ + B = A; + BROF = 1; + } + break; + } + break; + + case 0031: + switch(field) { + case VARIANT(WMOP_BFC): /* Branch Forward Conditional 0231 */ + case VARIANT(WMOP_BBC): /* Branch Backward Conditional 0131 */ + case VARIANT(WMOP_LFC): /* Word Branch Forward Conditional 2231 */ + case VARIANT(WMOP_LBC): /* Word Branch Backward Conditional 2131 */ + AB_valid(); + BROF = 0; + if (B & 1) { + AROF = 0; + break; + } + + /* Fall through */ + case VARIANT(WMOP_BFW): /* Branch Forward Unconditional 4231 */ + case VARIANT(WMOP_BBW): /* Banch Backward Unconditional 4131 */ + case VARIANT(WMOP_LFU): /* Word Branch Forward Unconditional 6231*/ + case VARIANT(WMOP_LBU): /* Word Branch Backward Unconditional 6131 */ + A_valid(); + if (A & FLAG) { + if ((A & PRESENT) == 0) { + if (L == 0) /* Back up to branch word */ + prev_addr(C); + if (NCSF) + Q |= PRES_BIT; + if (field & 020) + BROF = 1; + break; + } + C = CF(A); + L = 0; + } else { + if (L == 0) { /* Back up to branch op */ + prev_addr(C); + L = 3; + } else { + L--; + } + /* Follow logic based on real hardware */ + if ((field & 020) == 0) { /* Syllable branch */ + if (field & 02) { /* Forward */ + if (A & 1) { /* N = 0 */ + L++; C += (L >> 2); L &= 3; + } + A >>= 1; + if (A & 1) { /* Bump L by 2 */ + L+=2; C += (L >> 2); L &= 3; + } + A >>= 1; + } else { /* Backward */ + if (A & 1) { /* N = 0 */ + if (L == 0) { + C--; L = 3; + } else { + L--; + } + } + A >>= 1; + if (A & 1) { /* N = 1 */ + if (L < 2) { + C--; L += 2; + } else { + L -= 2; + } + } + A >>= 1; + } + /* Fix up for backward step */ + if (L == 3) { /* N = 3 */ + C++; L = 0; + } else { + L++; + } + } else { + L = 0; + } + if (field & 02) { /* Forward */ + C += A & 01777; + } else { /* Backward */ + C -= A & 01777; + } + C &= CORE; + } + AROF = 0; + PROF = 0; + break; + + case VARIANT(WMOP_SSN): /* Set Sign Bit */ + A_valid(); + A |= MSIGN; + break; + + case VARIANT(WMOP_CHS): /* Change sign bit */ + A_valid(); + A ^= MSIGN; + break; + + case VARIANT(WMOP_SSP): /* Reset Sign Bit */ + A_valid(); + A &= ~MSIGN; + break; + + case VARIANT(WMOP_TOP): /* Test Flag Bit */ + B_valid(); /* Move result to B */ + if (B & FLAG) + A = 0; + else + A = 1; + AROF = 1; + break; + + case VARIANT(WMOP_TUS): /* Interrogate Peripheral Status */ + A_empty(); + A = iostatus; + AROF = 1; + break; + + case VARIANT(WMOP_TIO): /* Interrogate I/O Channels */ + A_empty(); + A = find_chan(); + AROF = 1; + break; + + case VARIANT(WMOP_FBS): /* Flag Bit Search */ + A_valid(); + Ma = CF(A); + memory_cycle(4); /* Read A */ + while((A & FLAG) == 0) { + next_addr(Ma); + memory_cycle(4); + } + A = FLAG | PRESENT | toC(Ma); + break; + } + break; + + case 0035: + switch(field) { + case VARIANT(WMOP_BRT): /* Branch Return */ + B_valid(); + if ((B & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + f = set_via_RCW(B, 0, 1); /* Restore registers */ + L = 0; + S = F; + memory_cycle(3); /* Read B */ + prev_addr(S); + set_via_MSCW(B); + BROF = 0; + PROF = 0; + break; + + case VARIANT(WMOP_RTN): /* Return normal 02 */ + case VARIANT(WMOP_RTS): /* Return Special 12 */ + A_valid(); + if (A & FLAG) { + if ((A & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + } + + /* Fall through */ + case VARIANT(WMOP_XIT): /* Exit 04 */ + if (field & 04) + AROF = 0; + BROF = 0; + PROF = 0; + if ((field & 010) == 0) /* normal return & XIT */ + S = F; + memory_cycle(3); /* Restore RCW to B*/ + if ((B & FLAG) == 0) { + if (NCSF) + Q |= FLAG_BIT; + break; + } + f = set_via_RCW(B, 0, 0); /* Restore registers */ + S = F; + BROF = 0; + memory_cycle(3); /* Read B */ + prev_addr(S); + set_via_MSCW(B); + if (MSFF && SALF) { + Ma = F; + do { + /* B = M[FIELD], Ma = B[FIELD]; */ + memory_cycle(6); /* Grab previous MCSW */ + } while(B & SMSFF); + Ma = R | 7; + memory_cycle(015); /* Store B in Ma */ + } + BROF = 0; + if (field & 2) { /* RTS and RTN */ + if (f) + goto desc; + else + goto opdc; + } + break; + } + break; + + case 0041: + A_valid(); + switch(field) { + case VARIANT(WMOP_INX): /* Index */ + AB_valid(); + A = (A & (~CORE)) | ((A + B) & CORE); + BROF = 0; + break; + + case VARIANT(WMOP_COC): /* Construct Operand Call */ + case VARIANT(WMOP_CDC): /* Construct descriptor call */ + AB_valid(); + temp = A; + A = B | FLAG; + B = temp; + if (field & 010) /* COC or CDC */ + goto desc; + else + goto opdc; + /* Not reached */ + break; + + case VARIANT(WMOP_SSF): /* Set or Store S or F registers */ + AB_valid(); + switch( A & 03) { + case 0: /* F => B */ + B = replF(B, F); + break; + case 1: /* S => B */ + B = replC(B, S); + break; + case 2: + F = FF(B); + SALF = 1; + BROF = 0; + break; + case 3: + S = CF(B); + BROF = 0; + break; + } + AROF = 0; + break; + + case VARIANT(WMOP_LLL): /* Link List Look-up */ + AB_valid(); + A = MANT ^ A; + do { + Ma = CF(B); + memory_cycle(5); + temp = (B & MANT) + (A & MANT); + } while ((temp & EXPO) == 0); + A = FLAG | PRESENT | toC(Ma); + break; + + case VARIANT(WMOP_CMN): /* Enter Character Mode In Line */ + A_valid(); /* Make sure TOS is in A. */ + AB_empty(); /* Force A&B to stack */ + B = RCW(0); /* Build RCW word */ + BROF = 1; + B_empty(); /* Save return control word */ + CWMF = 1; + SALF = 1; + MSFF = 0; + B = A; /* A still had copy of TOS */ + AROF = 0; + BROF = 0; + R = 0; + F = S; /* Set F and X */ + X = toF(S); + if (B & FLAG) { + if ((B & PRESENT) == 0) { + if (NCSF) + Q |= PRES_BIT; + break; + } + KV = 0; + } else { + KV = (uint8)((B >> (FFIELD_V - 3)) & 070); + } + S = CF(B); + break; + + case VARIANT(WMOP_MKS): /* Mark Stack */ + AB_empty(); + B = MSCW; + BROF = 1; + B_empty(); + F = S; + if (!MSFF && SALF) { + Ma = R | 7; + memory_cycle(015); /* Store B in Ma */ + } + MSFF = 1; + break; + } + break; + + case 0051: /* Conditional bit field */ + if ((field & 074) == 0) { /* DEL Operator */ + if (AROF) + AROF = 0; + else if (BROF) + BROF = 0; + else + prev_addr(S); + break; + } + AB_valid(); + f = 0; + bit_b = bit_number[GH]; + if (field & 2) + BROF = 0; + for (i = (field >> 2) & 017; i > 0; i--) { + if (B & bit_mask[bit_b-i]) + f = 1; + } + if (f) { + T = (field & 1) ? WMOP_BBW : WMOP_BFW; + TROF = 1; + } else { + AROF = 0; + } + break; + + case WMOP_DIA: /* Dial A XX */ + if (field != 0) + GH = field; + break; + + case WMOP_DIB: /* Dial B XX Upper 6 not Zero */ + if (field != 0) + KV = field; + else { /* Set Variant */ + VARF |= SALF; + SALF = 0; + } + break; + + case WMOP_ISO: /* Variable Field Isolate XX */ + A_valid(); + if ((field & 070) != 0) { + bit_a = bit_number[GH | 07]; /* First Character */ + X = A >> bit_a; /* Get first char */ + X &= 077LL >> (GH & 07); /* Mask first character */ + GH &= 070; /* Clear H */ + while(field > 017) { /* Transfer chars. */ + bit_a -= 6; + X = (X << 6) | ((A >> bit_a) & 077); + field -= 010; + GH += 010; /* Bump G for each char */ + GH &= 070; + } + X >>= (field & 07); /* Align with remaining bits. */ + A = X & MANT; /* Max is 39 bits */ + } + break; + + case WMOP_TRB: /* Transfer Bits XX */ + case WMOP_FCL: /* Compare Field Low XX */ + case WMOP_FCE: /* Compare Field Equal XX */ + AB_valid(); + f = 1; + bit_a = bit_number[GH]; + bit_b = bit_number[KV]; + for(; field > 0 && bit_a >= 0 && bit_b >= 0; + field--, bit_a--, bit_b--) { + int ba, bb; + ba = (bit_mask[bit_a] & A) != 0; + switch(opcode) { + case WMOP_TRB: /* Just copy bit */ + B &= ~bit_mask[bit_b]; + if (ba) + B |= bit_mask[bit_b]; + break; + case WMOP_FCL: /* Loop until unequal */ + case WMOP_FCE: + bb = (bit_mask[bit_b] & B) != 0; + if (ba != bb) { + if (opcode == WMOP_FCL) + f = ba; + else + f = 0; + i = field; + } + break; + } + } + if (opcode != WMOP_TRB) { + A = f; + } else { + AROF = 0; + } + break; + } + } + } + } /* end while */ +/* Simulation halted */ + + return reason; +} + +/* Interval timer routines */ +t_stat +rtc_srv(UNIT * uptr) +{ + int32 t; + + t = sim_rtcn_calb(rtc_tps, TMR_RTC); + sim_activate_after(uptr, 1000000/rtc_tps); + tmxr_poll = t; + RTC++; + if (RTC & 0100) { + IAR |= IRQ_0; + } + RTC &= 077; + return SCPE_OK; +} +/* Reset routine */ + +t_stat +cpu_reset(DEVICE * dptr) +{ + /* Reset CPU 2 first */ + cpu_index = 1; + C = 020; + S = F = R = T = 0; + L = 0; + A = B = X = P = 0; + AROF = BROF = TROF = PROF = NCSF = SALF = CWMF = MSFF = VARF = 0; + GH = KV = Q = 0; + hltf[1] = 0; + P2_run = 0; + /* Reset CPU 1 now */ + cpu_index = 0; + C = 020; + S = F = R = T = IAR = 0; + L = 0; + A = B = X = P = 0; + AROF = BROF = TROF = PROF = NCSF = SALF = CWMF = MSFF = VARF = 0; + GH = KV = Q = 0; + hltf[0] = 0; + P1_run = 0; + + idle_addr = 0; + sim_brk_types = sim_brk_dflt = SWMASK('E') | SWMASK('A') | SWMASK('B'); + hst_p = 0; + + sim_register_clock_unit (&cpu_unit[0]); + sim_rtcn_init (cpu_unit[0].wait, TMR_RTC); + sim_activate(&cpu_unit[0], cpu_unit[0].wait) ; + + return SCPE_OK; +} + + +/* Memory examine */ + +t_stat +cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, int32 sw) +{ + if (addr >= MAXMEMSIZE) + return SCPE_NXM; + if (vptr != NULL) + *vptr = (t_value)(M[addr] & (FLAG|FWORD)); + + return SCPE_OK; +} + +/* Memory deposit */ + +t_stat +cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) +{ + if (addr >= MAXMEMSIZE) + return SCPE_NXM; + M[addr] = val & (FLAG|FWORD); + return SCPE_OK; +} + +t_stat +cpu_show_size(FILE *st, UNIT *uptr, int32 val, CONST void *desc) +{ + fprintf(st, "%dK", MEMSIZE/1024); + return SCPE_OK; +} + +t_stat +cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc) +{ + t_uint64 mc = 0; + uint32 i; + + cpu_unit[0].flags &= ~UNIT_MSIZE; + cpu_unit[0].flags |= val; + cpu_unit[1].flags &= ~UNIT_MSIZE; + cpu_unit[1].flags |= val; + val >>= UNIT_V_MSIZE; + val = (val + 1) * 4096; + if ((val < 0) || (val > MAXMEMSIZE)) + return SCPE_ARG; + for (i = val; i < MEMSIZE; i++) + mc |= M[i]; + if ((mc != 0) && (!get_yn("Really truncate memory [N]?", FALSE))) + return SCPE_OK; + MEMSIZE = val; + for (i = MEMSIZE; i < MAXMEMSIZE; i++) + M[i] = 0; + return SCPE_OK; +} + +/* Handle execute history */ + +/* Set history */ +t_stat +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) +{ + int32 i, lnt; + t_stat r; + + if (cptr == NULL) { + for (i = 0; i < hst_lnt; i++) + hst[i].c = 0; + hst_p = 0; + return SCPE_OK; + } + lnt = (int32) get_uint(cptr, 10, HIST_MAX, &r); + if ((r != SCPE_OK) || (lnt && (lnt < HIST_MIN))) + return SCPE_ARG; + hst_p = 0; + if (hst_lnt) { + free(hst); + hst_lnt = 0; + hst = NULL; + } + if (lnt) { + hst = (struct InstHistory *)calloc(sizeof(struct InstHistory), lnt); + + if (hst == NULL) + return SCPE_MEM; + hst_lnt = lnt; + } + return SCPE_OK; +} + +/* Show history */ + +t_stat +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) +{ + int32 k, di, lnt; + const char *cptr = (const char *) desc; + t_stat r; + t_value sim_eval; + struct InstHistory *h; + extern void print_opcode(FILE * ofile, t_value val, t_opcode *); + extern t_opcode word_ops[1], char_ops[1]; + char flags[] = "ABCNSMV"; + + if (hst_lnt == 0) + return SCPE_NOFNC; /* enabled? */ + if (cptr) { + lnt = (int32) get_uint(cptr, 10, hst_lnt, &r); + if ((r != SCPE_OK) || (lnt == 0)) + return SCPE_ARG; + } else + lnt = hst_lnt; + di = hst_p - lnt; /* work forward */ + if (di < 0) + di = di + hst_lnt; + fprintf(st, "P CL A B " + " X S F R M GH KV Flags" + " Q Intruction IAR\n\n"); + for (k = 0; k < lnt; k++) { /* print specified */ + h = &hst[(++di) % hst_lnt]; /* entry pointer */ + if (h->c & HIST_PC) { /* instruction? */ + int i; + fprintf(st, "%o %05o%o ", h->cpu, h->c & 077777, h->l); + sim_eval = (t_value)h->a_reg; + fprint_sym(st, 0, &sim_eval, &cpu_unit[0], SWMASK('B')); + fputc((h->flags & F_AROF) ? '^': ' ', st); + fputc(' ', st); + sim_eval = (t_value)h->b_reg; + fprint_sym(st, 0, &sim_eval, &cpu_unit[0], SWMASK('B')); + fputc((h->flags & F_BROF) ? '^': ' ', st); + fputc(' ', st); + fprint_val(st, (t_value)h->x_reg, 8, 39, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->s, 8, 15, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->f, 8, 15, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->r, 8, 15, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->ma, 8, 15, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->gh, 8, 6, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->kv, 8, 6, PV_RZRO); + fputc(' ', st); + for(i = 2; i < 8; i++) { + fputc (((1 << i) & h->flags) ? flags[i] : ' ', st); + } + fprint_val(st, h->q, 8, 9, PV_RZRO); + fputc(' ', st); + fprint_val(st, h->op, 8, 12, PV_RZRO); + fputc(' ', st); + print_opcode(st, h->op, + ((h->flags & F_CWMF) ? char_ops : word_ops)); + fputc(' ', st); + fprint_val(st, h->iar, 8, 16, PV_RZRO); + fputc('\n', st); /* end line */ + } /* end else instruction */ + } /* end for */ + return SCPE_OK; +} + + +t_stat cpu_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf(st, "B5500 CPU\n\n"); + fprintf(st, "The B5500 could support up to two CPU's the second CPU is disabled by\n"); + fprintf(st, "default. Use:\n"); + fprintf(st, " sim> SET CPU1 ENABLE enable second CPU\n"); + fprintf(st, "The primary CPU can't be disabled. Memory is shared between the two\n"); + fprintf(st, "CPU's. Memory can be configured in 4K increments up to 32K total.\n"); + fprint_set_help(st, dptr); + fprint_show_help(st, dptr); + return SCPE_OK; +} diff --git a/B5500/b5500_defs.h b/B5500/b5500_defs.h new file mode 100644 index 0000000..e79ddf5 --- /dev/null +++ b/B5500/b5500_defs.h @@ -0,0 +1,570 @@ +/* b5500_defs.h: Burroughs 5500 simulator definitions + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. +*/ + + +#ifndef _B5500_H_ +#define _B5500_H_ + +#include "sim_defs.h" /* simulator defns */ + +/* Definitions for each supported CPU */ + +#define NUM_DEVS_CDR 2 +#define NUM_DEVS_CDP 1 +#define NUM_DEVS_LPR 2 +#define NUM_DEVS_CON 1 +#define NUM_DEVS_DR 2 +#define NUM_DEVS_MT 16 +#define NUM_DEVS_DSK 2 +#define NUM_DEVS_DTC 1 +#define NUM_CHAN 4 +#define MAXMEMSIZE 32768 +#define CHARSPERWORD 8 + +extern t_uint64 M[]; /* Main Memory */ +extern uint16 IAR; /* Interrupt pending register */ +extern uint32 iostatus; /* Active device status register */ +extern uint8 loading; /* System booting flag */ + +/* Memory */ +#define MEMSIZE (cpu_unit[0].capac) /* actual memory size */ +#define MEMMASK (MEMSIZE - 1) /* Memory bits */ + + +/* Debuging controls */ +#define DEBUG_CHAN 0x0000001 /* Show channel fetchs */ +#define DEBUG_TRAP 0x0000002 /* Show CPU Traps */ +#define DEBUG_CMD 0x0000004 /* Show device commands */ +#define DEBUG_DATA 0x0000008 /* Show data transfers */ +#define DEBUG_DETAIL 0x0000010 /* Show details */ +#define DEBUG_EXP 0x0000020 /* Show error conditions */ +#define DEBUG_SNS 0x0000040 /* Shows sense data for 7909 devs */ +#define DEBUG_CTSS 0x0000080 /* Shows CTSS specail instructions */ +#define DEBUG_PROT 0x0000100 /* Protection traps */ + +extern DEBTAB dev_debug[]; + + +/* Returns from device commands */ +#define SCPE_BUSY (1) /* Device is active */ +#define SCPE_NODEV (2) /* No device exists */ + +/* Symbol tables */ +typedef struct _opcode +{ + uint16 op; + uint8 type; + const char *name; +} +t_opcode; + +/* I/O Command codes */ +#define IO_RDS 1 /* Read record */ +#define IO_BSR 2 /* Backspace one record */ +#define IO_BSF 3 /* Backspace one file */ +#define IO_WRS 4 /* Write one record */ +#define IO_WEF 5 /* Write eof */ +#define IO_REW 6 /* Rewind */ +#define IO_DRS 7 /* Set unit offline */ +#define IO_SDL 8 /* Set density low */ +#define IO_SDH 9 /* Set density high */ +#define IO_RUN 10 /* Rewind and unload unit */ +#define IO_TRS 11 /* Check it unit ready */ +#define IO_CTL 12 /* Io control device specific */ +#define IO_RDB 13 /* Read backwards */ +#define IO_SKR 14 /* Skip record forward */ +#define IO_ERG 15 /* Erase next records from tape */ + + +t_stat chan_reset(DEVICE *); +t_stat chan_boot(t_uint64); +int find_chan(); +void chan_release(int); +void start_io(); +void chan_set_end(int) ; +void chan_set_parity(int) ; +void chan_set_eof(int) ; +void chan_set_read(int) ; +void chan_set_wcflg(int) ; +void chan_set_gm(int) ; +void chan_set_error(int) ; +void chan_set_notrdy(int) ; +void chan_set_bot(int) ; +void chan_set_eot(int) ; +void chan_set_wrp(int) ; +void chan_set_blank(int) ; +void chan_set_wc(int, uint16); +int chan_write_char(int, uint8 *, int) ; +int chan_read_char(int, uint8 *, int) ; +int chan_read_disk(int, uint8 *, int) ; +int chan_write_drum(int, uint8 *, int) ; +int chan_read_drum(int, uint8 *, int) ; + +extern uint8 parity_table[64]; +extern uint8 mem_to_ascii[64]; +extern const char con_to_ascii[64]; +extern const char ascii_to_con[128]; +extern t_stat fprint_sym(FILE *, t_addr, t_value *, UNIT *, int32); +extern int32 tmxr_poll; + +/* Generic devices common to all */ +extern DEVICE cpu_dev; +extern UNIT cpu_unit[]; +extern REG cpu_reg[]; +extern DEVICE chan_dev; + +/* Global device definitions */ +#if (NUM_DEVS_CDR > 0) | (NUM_DEVS_CDP > 0) +extern DEVICE cdr_dev; +extern t_stat card_cmd(uint16, uint16, uint8, uint16 *); +#endif + +#if (NUM_DEVS_CDP > 0) +extern DEVICE cdp_dev; +#endif + +#if (NUM_DEVS_LPR > 0) +extern DEVICE lpr_dev; +extern t_stat lpr_cmd(uint16, uint16, uint8, uint16 *); +#endif + +#if (NUM_DEVS_CON > 0) +extern DEVICE con_dev; +extern t_stat con_cmd(uint16, uint16, uint8, uint16 *); +#endif + +#if (NUM_DEVS_DTC > 0) +extern DEVICE dtc_dev; +extern t_stat dtc_cmd(uint16, uint16, uint8, uint16 *); +#endif + +#if (NUM_DEVS_DR > 0) +extern DEVICE drm_dev; +extern t_stat drm_cmd(uint16, uint16, uint8, uint16 *, uint8); +#endif + +#if (NUM_DEVS_DSK > 0) +extern DEVICE dsk_dev; +extern t_stat dsk_cmd(uint16, uint16, uint8, uint16 *); +extern DEVICE esu_dev; +#endif + +#if (NUM_DEVS_MT > 0) +extern DEVICE mt_dev; +extern t_stat mt_cmd(uint16, uint16, uint8, uint16 *); +#endif /* NUM_DEVS_MT */ + +/* Character codes */ +#define CHR_ABLANK 000 +#define CHR_MARK CHR_ABLANK +#define CHR_1 001 +#define CHR_2 002 +#define CHR_3 003 +#define CHR_4 004 +#define CHR_5 005 +#define CHR_6 006 +#define CHR_7 007 +#define CHR_8 010 +#define CHR_9 011 +#define CHR_0 012 +#define CHR_EQ 013 +#define CHR_QUOT 014 /* Also @ */ +#define CHR_COL 015 +#define CHR_GT 016 +#define CHR_TRM 017 +#define CHR_BLANK 020 +#define CHR_SLSH 021 +#define CHR_S 022 +#define CHR_T 023 +#define CHR_U 024 +#define CHR_V 025 +#define CHR_W 026 +#define CHR_X 027 +#define CHR_Y 030 +#define CHR_Z 031 +#define CHR_RM 032 +#define CHR_COM 033 +#define CHR_RPARN 034 /* Also % */ +#define CHR_WM 035 +#define CHR_BSLSH 036 +#define CHR_UND 037 +#define CHR_MINUS 040 +#define CHR_J 041 +#define CHR_K 042 +#define CHR_L 043 +#define CHR_M 044 +#define CHR_N 045 +#define CHR_O 046 +#define CHR_P 047 +#define CHR_Q 050 +#define CHR_R 051 +#define CHR_EXPL 052 +#define CHR_DOL 053 +#define CHR_STAR 054 +#define CHR_LBRK 055 +#define CHR_SEMI 056 +#define CHR_CART 057 +#define CHR_PLUS 060 +#define CHR_A 061 +#define CHR_B 062 +#define CHR_C 063 +#define CHR_D 064 +#define CHR_E 065 +#define CHR_F 066 +#define CHR_G 067 +#define CHR_H 070 +#define CHR_I 071 +#define CHR_QUEST 072 +#define CHR_DOT 073 +#define CHR_LPARN 074 /* Also Square */ +#define CHR_RBRAK 075 +#define CHR_LESS 076 +#define CHR_GM 077 + +/* Word mode opcodes */ +#define WMOP_LITC 00000 /* Load literal */ +#define WMOP_OPDC 00002 /* Load operand */ +#define WMOP_DESC 00003 /* Load Descriptor */ +#define WMOP_OPR 00001 /* Operator */ +#define WMOP_DEL 00065 /* Delete top of stack */ +#define WMOP_NOP 00055 /* Nop operation */ +#define WMOP_XRT 00061 /* Set Variant */ +#define WMOP_ADD 00101 /* Add */ +#define WMOP_DLA 00105 /* Double Precision Add */ +#define WMOP_PRL 00111 /* Program Release */ +#define WMOP_LNG 00115 /* Logical Negate */ +#define WMOP_CID 00121 /* Conditional Integer Store Destructive */ +#define WMOP_GEQ 00125 /* WMOP_B greater than or equal to A */ +#define WMOP_BBC 00131 /* Branch Backward Conditional */ +#define WMOP_BRT 00135 /* Branch Return */ +#define WMOP_INX 00141 /* Index */ +#define WMOP_ITI 00211 /* Interrogate interrupt */ +#define WMOP_LOR 00215 /* Logical Or */ +#define WMOP_CIN 00221 /* Conditional Integer Store non-destructive */ +#define WMOP_GTR 00225 /* B Greater than A */ +#define WMOP_BFC 00231 /* Branch Forward Conditional */ +#define WMOP_RTN 00235 /* Return normal */ +#define WMOP_COC 00241 /* Construct Operand Call */ +#define WMOP_SUB 00301 /* Subtract */ +#define WMOP_DLS 00305 /* WMOP_Double Precision Subtract */ +#define WMOP_MUL 00401 /* Multiply */ +#define WMOP_DLM 00405 /* Double Precision Multiply */ +#define WMOP_RTR 00411 /* Read Timer */ +#define WMOP_LND 00415 /* Logical And */ +#define WMOP_STD 00421 /* B Store Destructive */ +#define WMOP_NEQ 00425 /* B Not equal to A */ +#define WMOP_SSN 00431 /* Set Sign Bit */ +#define WMOP_XIT 00435 /* Exit */ +#define WMOP_MKS 00441 /* Mark Stack */ +#define WMOP_DIV 01001 /* Divide */ +#define WMOP_DLD 01005 /* Double Precision Divide */ +#define WMOP_COM 01011 /* Communication operator */ +#define WMOP_LQV 01015 /* Logical Equivalence */ +#define WMOP_SND 01021 /* B Store Non-destructive */ +#define WMOP_XCH 01025 /* Exchange */ +#define WMOP_CHS 01031 /* Change sign bit */ +#define WMOP_RTS 01235 /* Return Special */ +#define WMOP_CDC 01241 /* Construct descriptor call */ +#define WMOP_FTC 01425 /* Transfer F Field to Core Field */ +#define WMOP_MOP 02015 /* Reset Flag bit */ +#define WMOP_LOD 02021 /* Load */ +#define WMOP_DUP 02025 /* Duplicate */ +#define WMOP_TOP 02031 /* Test Flag Bit */ +#define WMOP_IOR 02111 /* I/O Release */ +#define WMOP_LBC 02131 /* Word Branch Backward Conditional */ +#define WMOP_SSF 02141 /* Set or Store S or F registers */ +#define WMOP_HP2 02211 /* Halt P2 */ +#define WMOP_LFC 02231 /* Word Branch Forward Conditional */ +#define WMOP_ZP1 02411 /* Conditional Halt */ +#define WMOP_TUS 02431 /* Interrogate Peripheral Status */ +#define WMOP_LLL 02541 /* Link List Look-up */ +#define WMOP_IDV 03001 /* Integer Divide Integer */ +#define WMOP_SFI 03011 /* Store for Interrupt */ +#define WMOP_SFT 03411 /* Store for Test */ +#define WMOP_FTF 03425 /* Transfer F Field to F Field */ +#define WMOP_MDS 04015 /* Set Flag Bit */ +#define WMOP_IP1 04111 /* Initiate P1 */ +#define WMOP_ISD 04121 /* Interger Store Destructive */ +#define WMOP_LEQ 04125 /* B Less Than or Equal to A */ +#define WMOP_BBW 04131 /* Banch Backward Conditional */ +#define WMOP_IP2 04211 /* Initiate P2 */ +#define WMOP_ISN 04221 /* Integer Store Non-Destructive */ +#define WMOP_LSS 04225 /* B Less Than A */ +#define WMOP_BFW 04231 /* Branch Forward Unconditional */ +#define WMOP_IIO 04411 /* Initiate I/O */ +#define WMOP_EQL 04425 /* B Equal A */ +#define WMOP_SSP 04431 /* Reset Sign Bit */ +#define WMOP_CMN 04441 /* Enter Character Mode In Line */ +#define WMOP_IFT 05111 /* Test Initiate */ +#define WMOP_CTC 05425 /* Transfer Core Field to Core Field */ +#define WMOP_LBU 06131 /* Word Branch Backward Unconditional */ +#define WMOP_LFU 06231 /* Word Branch Forward Unconditional */ +#define WMOP_TIO 06431 /* Interrogate I/O Channels */ +#define WMOP_RDV 07001 /* Remainder Divide */ +#define WMOP_FBS 07031 /* Flag Bit Search */ +#define WMOP_CTF 07425 /* Transfer Core Field to F Field */ +#define WMOP_ISO 00045 /* Variable Field Isolate XX */ +#define WMOP_CBD 00351 /* Non-Zero Field Branch Backward Destructive Xy */ +#define WMOP_CBN 00151 /* Non-Zero Field Branch Backward Non-Destructive Xy */ +#define WMOP_CFD 00251 /* Non-Zero Field Branch Forward Destructive Xy */ +#define WMOP_CFN 00051 /* Non-Zero Field Branch Forward Non-Destructive Xy */ +#define WMOP_DIA 00055 /* Dial A XX */ +#define WMOP_DIB 00061 /* Dial B XX Upper 6 not Zero */ +#define WMOP_TRB 00065 /* Transfer Bits XX */ +#define WMOP_FCL 00071 /* Compare Field Low XX */ +#define WMOP_FCE 00075 /* Compare Field Equal XX */ + +/* Character Mode */ +#define CMOP_EXC 00000 /* CMOP_Exit Character Mode */ +#define CMOP_CMX 00100 /* Exit Character Mode In Line */ +#define CMOP_BSD 00002 /* Skip Bit Destiniation */ +#define CMOP_BSS 00003 /* SKip Bit Source */ +#define CMOP_RDA 00004 /* Recall Destination Address */ +#define CMOP_TRW 00005 /* Transfer Words */ +#define CMOP_SED 00006 /* Set Destination Address */ +#define CMOP_TDA 00007 /* Transfer Destination Address */ +#define CMOP_TBN 00012 /* Transfer Blanks for Non-Numerics */ +#define CMOP_SDA 00014 /* Store Destination Address */ +#define CMOP_SSA 00015 /* Store Source Address */ +#define CMOP_SFD 00016 /* Skip Forward Destination */ +#define CMOP_SRD 00017 /* Skip Reverse Destination */ +#define CMOP_SES 00022 /* Set Source Address */ +#define CMOP_TEQ 00024 /* Test for Equal */ +#define CMOP_TNE 00025 /* Test for Not-Equal */ +#define CMOP_TEG 00026 /* Test for Greater Or Equal */ +#define CMOP_TGR 00027 /* Test For Greater */ +#define CMOP_SRS 00030 /* Skip Reverse Source */ +#define CMOP_SFS 00031 /* Skip Forward Source */ +#define CMOP_TEL 00034 /* Test For Equal or Less */ +#define CMOP_TLS 00035 /* Test For Less */ +#define CMOP_TAN 00036 /* Test for Alphanumeric */ +#define CMOP_BIT 00037 /* Test Bit */ +#define CMOP_INC 00040 /* Increase Tally */ +#define CMOP_STC 00041 /* Store Tally */ +#define CMOP_SEC 00042 /* Set Tally */ +#define CMOP_CRF 00043 /* Call repeat Field */ +#define CMOP_JNC 00044 /* Jump Out Of Loop Conditional */ +#define CMOP_JFC 00045 /* Jump Forward Conditional */ +#define CMOP_JNS 00046 /* Jump out of loop unconditional */ +#define CMOP_JFW 00047 /* Jump Forward Unconditional */ +#define CMOP_RCA 00050 /* Recall Control Address */ +#define CMOP_ENS 00051 /* End Loop */ +#define CMOP_BNS 00052 /* Begin Loop */ +#define CMOP_RSA 00053 /* Recall Source Address */ +#define CMOP_SCA 00054 /* Store Control Address */ +#define CMOP_JRC 00055 /* Jump Reverse Conditional */ +#define CMOP_TSA 00056 /* Transfer Source Address */ +#define CMOP_JRV 00057 /* Jump Reverse Unconditional */ +#define CMOP_CEQ 00060 /* Compare Equal */ +#define CMOP_CNE 00061 /* COmpare for Not Equal */ +#define CMOP_CEG 00062 /* Compare For Greater Or Equal */ +#define CMOP_CGR 00063 /* Compare For Greater */ +#define CMOP_BIS 00064 /* Set Bit */ +#define CMOP_BIR 00065 /* Reet Bit */ +#define CMOP_OCV 00066 /* Output Convert */ +#define CMOP_ICV 00067 /* Input Convert */ +#define CMOP_CEL 00070 /* Compare For Equal or Less */ +#define CMOP_CLS 00071 /* Compare for Less */ +#define CMOP_FSU 00072 /* Field Subtract */ +#define CMOP_FAD 00073 /* Field Add */ +#define CMOP_TRP 00074 /* Transfer Program Characters */ +#define CMOP_TRN 00075 /* Transfer Numeric */ +#define CMOP_TRZ 00076 /* Transfer Zones */ +#define CMOP_TRS 00077 /* Transfer Source Characters */ + +/* Error codes for Q */ /* P1 P2 */ +#define MEM_PARITY 00001 /* 060 040 */ +#define INVALID_ADDR 00002 /* 061 041 */ +#define STK_OVERFL 00004 /* 062 042 */ +#define COM_OPR 00040 /* 064 +00 044 */ +#define PROG_REL 00050 /* 065 +01 045 */ +#define CONT_BIT 00060 /* 066 +02 046 */ +#define PRES_BIT 00070 /* 067 +03 047 */ +#define FLAG_BIT 00100 /* 070 +04 050 */ +#define INDEX_ERROR 00110 /* 071 +05 051 */ +#define EXPO_UNDER 00120 /* 072 +06 052 */ +#define EXPO_OVER 00130 /* 073 +07 053 */ +#define INT_OVER 00140 /* 074 +10 054 */ +#define DIV_ZERO 00150 /* 075 +11 055 */ + +/* Addresses for Interrupts */ +#define INTER_TIME 022 +#define IO_BUSY 023 +#define KEY_REQ 024 +#define PRT1_FINISH 025 +#define PRT2_FINISH 026 +#define IO1_FINISH 027 +#define IO2_FINISH 030 +#define IO3_FINISH 031 +#define IO4_FINISH 032 +#define INQ_REQ 033 +#define SPEC_IRQ1 035 +#define DSK1_RDCHK 036 +#define DSK2_RDCHK 037 +#define PARITY_ERR 060 +#define INVADR_ERR 061 +#define STK_OVR_LOC 062 +#define COM_OPR_LOC 064 +#define PROG_REL_LOC 065 +#define CONT_BIT_LOC 066 +#define PRES_BIT_LOC 067 +#define FLAG_BIT_LOC 070 +#define INDEX_BIT_LOC 071 +#define EXP_UND_LOC 072 +#define EXP_OVR_LOC 073 +#define INT_OVR_LOC 074 +#define DIV_ZER_LOC 075 +#define PARITY_ERR2 040 +#define INVADR_ERR2 041 +#define STK_OVR_LOC2 042 +#define COM_OPR_LOC2 044 +#define PROG_REL_LOC2 045 +#define CONT_BIT_LOC2 046 +#define PRES_BIT_LOC2 047 +#define FLAG_BIT_LOC2 050 +#define INDEX_BIT_LOC2 051 +#define EXP_UND_LOC2 052 +#define EXP_OVR_LOC2 053 +#define INT_OVR_LOC2 054 +#define DIV_ZER_LOC2 055 + +/* IAR BITS */ +#define IAR6 040 /* Set if IRQ from Q */ +#define IAR5 020 /* Set if IRQ from P1 */ +#define IAR4 010 /* Q bit 3 */ +#define IAR3 004 /* Q bit 4 */ +#define IAR2 002 /* Q bit 5 */ +#define IAR1 001 /* Q bit 6 or Q bit 2 */ +#define IAR0 000 /* Q bit 7 or Q bit 1 */ + +#define IRQ_0 000001 /* Interval Timer */ +#define IRQ_1 000002 /* I/O Busy */ +#define IRQ_2 000004 /* Keyboard Request */ +#define IRQ_3 000010 /* Printer 1 Finished */ +#define IRQ_4 000020 /* Printer 2 Finished */ +#define IRQ_5 000040 /* I/O Finish 1 */ +#define IRQ_6 000100 /* I/O Finish 2 */ +#define IRQ_7 000200 /* I/O Finish 3 */ +#define IRQ_10 000400 /* I/O Finish 4 */ +#define IRQ_11 001000 /* P2 Busy */ +#define IRQ_12 002000 /* Inquiry Request */ +#define IRQ_13 004000 /* Special IRQ 1 */ +#define IRQ_14 010000 /* Disk Read Check 1 */ +#define IRQ_15 020000 /* Disk Read Check 2 */ + +/* Masks */ +#define FLAG 04000000000000000LL /* Operand Flag */ +#define FWORD 03777777777777777LL /* Full word mask */ +#define MSIGN 02000000000000000LL /* Operator Word */ +#define ESIGN 01000000000000000LL +#define EXPO 00770000000000000LL +#define EXPO_V 39 +#define MANT 00007777777777777LL +#define NORM 00007000000000000LL +#define ROUND 00004000000000000LL +#define PRESENT 01000000000000000LL /* Oprand Type */ +#define DFLAG 02000000000000000LL /* Descriptor */ +#define WCOUNT 00017770000000000LL +#define WCOUNT_V 30 +#define INTEGR 00000002000000000LL +#define CONTIN 00000001000000000LL +#define CORE 00000000000077777LL +#define RFIELD 00077700000000000LL /* Mark Stack Control Word */ +#define RFIELD_V 27 /* Shift off by 6 bits */ +#define SMSFF 00000020000000000LL +#define SSALF 00000010000000000LL +#define SVARF 00000000100000000LL +#define SCWMF 00000000000100000LL +#define FFIELD 00000007777700000LL +#define FFIELD_V 15 +#define REPFLD 00000770000000000LL +#define REPFLD_V 30 +#define MODEF 00200000000000000LL /* Program Descriptor +FFIELD and CORE */ +#define ARGF 00100000000000000LL +#define PROGF 00400000000000000LL +#define RGH 00340700000000000LL /* Return Control Word +FFIELD and CORE */ +#define RGH_V 33 +#define RKV 00034070000000000LL +#define RKV_V 30 +#define RL 00003000000000000LL /* Save L register */ +#define RL_V 36 +#define LMASK 00000000007777777LL +#define HMASK 00007777770000000LL +#define DEV_DRUM_RD 01000000000000000LL +#define DEVMASK 00760000000000000LL +#define D_MASK 00777777777777777LL +#define DEV_V 40 +#define DEV_WC 00017770000000000LL +#define DEV_WC_V 30 +#define DEV_CMD 00000007777700000LL +#define DEV_CMD_V 15 +#define DEV_INHTRF 00000004000000000LL +#define DEV_XXX 00000002000000000LL +#define DEV_XXY 00000001000000000LL +#define DEV_BIN 00000000400000000LL +#define DEV_BACK 00000000200000000LL +#define DEV_WCFLG 00000000100000000LL +#define DEV_IORD 00000000040000000LL +#define DEV_OPT 00000000007700000LL /* Print Space, Disk Segments */ +#define CORE 00000000000077777LL + +#define DEV_BUSY 00000000000100000LL /* D16 */ +#define DEV_MEMPAR 00000000000200000LL /* D17 */ +#define DEV_NOTRDY 00000000000400000LL /* D18 */ +#define DEV_PARITY 00000000001000000LL /* D19 */ +#define DEV_ERROR 00000000002000000LL /* D20 */ +#define DEV_EOF 00000000004000000LL /* D21 */ +#define DEV_MEMERR 00000000010000000LL /* D22 */ +#define DEV_RESULT 00000000037700000LL +#define DEV_EOT 01000100001000000LL +#define DEV_BOT 01000200001000000LL +#define DEV_BLANK 01000400001000000LL + +#define DRUM1_DEV 004 /* 00100 (4) */ +#define DSK1_DEV 006 /* 00110 (6) */ +#define DRUM2_DEV 010 /* 01000 (8) */ +#define CARD1_DEV 012 /* 01010 (10) */ +#define DSK2_DEV 014 /* 01100 (12) */ +#define CARD2_DEV 016 /* 01110 (14) */ +#define DTC_DEV 020 /* 10000 (16) */ +#define PT1_DEV 022 /* 10010 (20) */ +#define PT2_DEV 024 /* 10100 (22) */ +#define PRT1_DEV 026 /* 10110 (24) */ +#define PRT2_DEV 032 /* 11010 (26) */ +#define SPO_DEV 036 /* 11110 (30) */ +#define DRUM1_FLAG 00000000000200000LL +#define DRUM2_FLAG 00000000000400000LL +#define DSK1_FLAG 00000000001000000LL +#define DSK2_FLAG 00000000002000000LL +#define PRT1_FLAG 00000000004000000LL +#define PRT2_FLAG 00000000010000000LL +#define PUNCH_FLAG 00000000020000000LL +#define CARD1_FLAG 00000000040000000LL +#define CARD2_FLAG 00000000100000000LL +#define SPO_FLAG 00000000200000000LL +#define PTP1_FLAG 00000000400000000LL +#define PTR1_FLAG 00000001000000000LL +#define PTR2_FLAG 00000002000000000LL +#define PTP2_FLAG 00000004000000000LL +#define DTC_FLAG 00000010000000000LL + +#endif /* _B5500_H_ */ diff --git a/B5500/b5500_dk.c b/B5500/b5500_dk.c new file mode 100644 index 0000000..1e0f67b --- /dev/null +++ b/B5500/b5500_dk.c @@ -0,0 +1,578 @@ +/* b5500_dk.c: Burrioughs 5500 Disk controller + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "b5500_defs.h" + +#if (NUM_DEVS_DSK > 0) + + +/* in u3 is device address */ +/* in u4 is current buffer position */ +/* in u5 Bits 30-16 of W */ +#define URCSTA_SKIP 000017 /* Skip mask */ +#define URCSTA_SINGLE 000020 /* Single space skip. */ +#define URCSTA_DOUBLE 000040 /* Double space skip */ +#define URCSTA_READ 000400 /* Read flag */ +#define URCSTA_WC 001000 /* Use word count */ +#define URCSTA_DIRECT 002000 /* Direction, Long line */ +#define URCSTA_BINARY 004000 /* Binary transfer */ +#define URCSTA_INHIBIT 040000 /* Inhibit transfer to memory */ + +#define DK_CHAN 0000003 /* Channel number */ +#define DK_CTRL 0000004 /* Disk controller unit attached too */ +#define DK_WC 0000010 /* Use word count */ +#define DK_BSY 0000020 /* Drive is busy. */ +#define DK_RD 0000040 /* Executing a read command */ +#define DK_WR 0000100 /* Executing a write command */ +#define DK_RDCK 0000200 /* Executing a read check command */ +#define DK_ADDR 0000400 /* Drive has an address. */ +#define DK_BIN 0001000 /* Binary mode */ +#define DK_WCZERO 0002000 /* Word count Zero */ +#define DK_SECMASK 0770000 /* Number of segments to transfer */ +#define DK_SECT 0010000 /* One segment */ +#define DK_SEC_SIZE 240 /* Sector size */ +#define DK_MAXSEGS 200000 /* Max segments for MOD I ESU */ +#define DK_MAXSEGS2 400000 /* Max segments for MOD IB ESU */ +#define DFX_V (UNIT_V_UF + 1) +#define MODIB_V (UNIT_V_UF + 2) +#define DFX (1 << DFX_V) +#define MODIB (1 << MODIB_V) + +t_stat dsk_cmd(uint16, uint16, uint8, uint16 *); +t_stat dsk_srv(UNIT *); +t_stat dsk_boot(int32, DEVICE *); +t_stat dsk_help (FILE *, DEVICE *, UNIT *, int32, const char *); +const char *dsk_description (DEVICE *); +t_stat esu_srv(UNIT *); +t_stat esu_attach(UNIT *, CONST char *); +t_stat esu_detach(UNIT *); +t_stat esu_help (FILE *, DEVICE *, UNIT *, int32, const char *); +const char *esu_description (DEVICE *); + +uint8 dsk_buffer[NUM_DEVS_DSK][DK_SEC_SIZE]; +t_stat set_mod(UNIT *uptr, int32 val, CONST char *cptr, + void *desc); + +#define ESU_TYPE UDATA(&esu_srv, UNIT_ATTABLE+UNIT_DISABLE+ \ + UNIT_FIX, DK_SEC_SIZE * DK_MAXSEGS) + +UNIT esu_unit[] = { + {ESU_TYPE, DK_MAXSEGS}, /* 0 */ + {ESU_TYPE, DK_MAXSEGS}, /* 1 */ + {ESU_TYPE, DK_MAXSEGS}, /* 2 */ + {ESU_TYPE, DK_MAXSEGS}, /* 3 */ + {ESU_TYPE, DK_MAXSEGS}, /* 4 */ + {ESU_TYPE, DK_MAXSEGS}, /* 5 */ + {ESU_TYPE, DK_MAXSEGS}, /* 6 */ + {ESU_TYPE, DK_MAXSEGS}, /* 7 */ + {ESU_TYPE, DK_MAXSEGS}, /* 8 */ + {ESU_TYPE, DK_MAXSEGS}, /* 9 */ + {ESU_TYPE, DK_MAXSEGS}, /* 10 */ + {ESU_TYPE, DK_MAXSEGS}, /* 11 */ + {ESU_TYPE, DK_MAXSEGS}, /* 12 */ + {ESU_TYPE, DK_MAXSEGS}, /* 13 */ + {ESU_TYPE, DK_MAXSEGS}, /* 14 */ + {ESU_TYPE, DK_MAXSEGS}, /* 15 */ + {ESU_TYPE, DK_MAXSEGS}, /* 16 */ + {ESU_TYPE, DK_MAXSEGS}, /* 17 */ + {ESU_TYPE, DK_MAXSEGS}, /* 18 */ + {ESU_TYPE, DK_MAXSEGS}, /* 19 */ +}; + +MTAB esu_mod[] = { + {MODIB, 0, "MODI", "MODI", &set_mod, NULL, NULL, + "Sets ESU to Fast Mod I drive"}, + {MODIB, MODIB, "MODIB", "MODIB", &set_mod, NULL, NULL, + "Sets ESU to Slow Mod IB drive"}, + {0} +}; + + +DEVICE esu_dev = { + "ESU", esu_unit, NULL, esu_mod, + 20, 8, 15, 1, 8, 8, + NULL, NULL, NULL, NULL, &esu_attach, &esu_detach, + NULL, DEV_DISABLE | DEV_DEBUG, 0, dev_debug, + NULL, NULL, &esu_help, NULL, NULL, &esu_description +}; + +MTAB dsk_mod[] = { + {DFX, 0, NULL, "NODFX", NULL, NULL, NULL, + "Disables drive sharing, use only on DK1"}, + {DFX, DFX, "DFX", "DFX", NULL, NULL, NULL, + "Enables drive sharing, use only on DK1"}, + {0} +}; + + +UNIT dsk_unit[] = { + {UDATA(&dsk_srv, UNIT_DISABLE, 0)}, /* DKA */ + {UDATA(&dsk_srv, UNIT_DIS | UNIT_DISABLE, 0)}, /* DKB */ +}; + +DEVICE dsk_dev = { + "DK", dsk_unit, NULL, dsk_mod, + NUM_DEVS_DSK, 8, 15, 1, 8, 8, + NULL, NULL, NULL, &dsk_boot, NULL, NULL, + NULL, DEV_DISABLE | DEV_DEBUG, 0, dev_debug, + NULL, NULL, &dsk_help, NULL, NULL, &dsk_description +}; + + + +/* Start off a disk command */ +t_stat dsk_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr; + int u = (dev==DSK1_DEV)? 0: 1; + + uptr = &dsk_unit[u]; + + /* If unit disabled return error */ + if (uptr->flags & UNIT_DIS) + return SCPE_NODEV; + + /* Check if drive is ready to recieve a command */ + if ((uptr->u5 & DK_BSY)) + return SCPE_BUSY; + + uptr->u5 = chan|DK_BSY; + if (dev == DSK2_DEV) + uptr->u5 |= DK_CTRL; + uptr->u5 |= (cmd & 077) << 12; + if (cmd & URCSTA_INHIBIT) + uptr->u5 |= DK_RDCK; + else if (cmd & URCSTA_READ) + uptr->u5 |= DK_RD; + else + uptr->u5 |= DK_WR; + if (cmd & URCSTA_WC) { + uptr->u5 |= DK_WC; + if (*wc == 0) + uptr->u5 |= DK_WCZERO; + } + if (cmd & URCSTA_BINARY) + uptr->u5 |= DK_BIN; + if (loading) { + uptr->u4 = 1; + uptr->u3 = 0; + } else { + uptr->u5 |= DK_ADDR; + } + sim_activate(uptr, 100); + return SCPE_OK; +} + + +/* Handle processing disk controller commands */ +t_stat dsk_srv(UNIT * uptr) +{ + int chan = uptr->u5 & DK_CHAN; + DEVICE *dptr = find_dev_from_unit(uptr); + int i; + int addr; + uint8 abuf[8]; /* x-esu-disk-track-segment */ + int u = uptr - dsk_unit; + int esu; + UNIT *eptr; + + if ((uptr->u5 & DK_BSY) == 0) + return SCPE_OK; + + /* Read in first word, which a address. */ + /* Note special read routine since address is not included + in the word count */ + if (uptr->u5 & DK_ADDR) { + /* Read in 8 characters which are the address */ + for (i = 0; i < 8; i++) { + if (chan_read_disk(chan, &abuf[i], 0)) + break; + abuf[i] &= 017; /* Mask zone out */ + if (abuf[i] == 012) /* Zero to zero */ + abuf[i] = 0; + } + + /* extract ESU and Address */ + esu = abuf[1]; + addr = 0; + for (i = 2; i < 8; i++) { + addr = (addr * 10) + abuf[i]; + } + uptr->u5 &= ~DK_ADDR; + uptr->u4 = addr; + + /* Map to ESU */ + if (u && (dsk_unit[u].flags & DFX) == 0) + esu += 10; + sim_debug(DEBUG_DETAIL, dptr, "Disk access %d %s %02o %d,%d\n\r", u, + (uptr->u5 & DK_RDCK) ? "rcheck" : + (uptr->u5 & DK_RD) ? "read" : + (uptr->u5 & DK_WR)? "write" : "nop", (uptr->u5 >> 9) & 077, + esu, addr); + + uptr->u3 = esu; + eptr = &esu_unit[uptr->u3]; + /* Check if valid */ + if ((eptr->flags & UNIT_DIS) || (eptr->flags & UNIT_ATT) == 0) { + /* Set not ready and end channel */ + chan_set_notrdy(chan); + uptr->u5 = 0; + return SCPE_OK; + } + + /* Check if Read Check or Write Check */ + if ((uptr->u5 & (DK_WCZERO|DK_WC|DK_SECMASK)) == (DK_WCZERO|DK_WC)) { + if (uptr->u4 >= eptr->wait) + chan_set_eof(chan); + + if (uptr->u5 & DK_WR) { + sim_debug(DEBUG_DETAIL, dptr, "Disk write int %d %d %o\n\r", + uptr->u3, uptr->u4, uptr->u5); + } + if (uptr->u5 & DK_RD) { + sim_debug(DEBUG_DETAIL, dptr, "Disk read int %d %d %o\n\r", + uptr->u3, uptr->u4, uptr->u5); + if (eptr->flags & MODIB) + chan_set_error(chan); + } + chan_set_end(chan); + uptr->u5 = 0; + return SCPE_OK; + } + + sim_activate(uptr, 5000); + return SCPE_OK; + } + + /* Kick off actual transfer to ESU */ + if (((uptr->u5 & DK_ADDR) == 0) && + ((uptr->u5 & (DK_RDCK|DK_RD|DK_WR)) != 0)) { + eptr = &esu_unit[uptr->u3]; + + /* Wait until unit is ready for new access */ + if ((eptr->u5 & DK_BSY) == 0) { + + eptr->u3 = (uptr->u5 & DK_WR) ? 0 : DK_SEC_SIZE; + eptr->u4 = uptr->u4; /* Disk address */ + eptr->u5 = uptr->u5; /* Command */ + if (uptr->u5 & DK_RDCK) { + uptr->u5 = 0; + chan_set_end(chan); + } else + uptr->u5 &= ~(DK_RDCK|DK_RD|DK_WR); + sim_activate(eptr, 500); + return SCPE_OK; + } + sim_activate(uptr, 100); + } + return SCPE_OK; +} + +void esu_set_end(UNIT *uptr, int err) { + int chan = uptr->u5 & DK_CHAN; + int dsk = ((uptr->u5 & DK_CTRL) != 0); + DEVICE *dptr = find_dev_from_unit(uptr); + + sim_debug(DEBUG_DETAIL, dptr, "Disk done %d %d %o\n\r", uptr->u3, + uptr->u4, uptr->u5); + if (err) + chan_set_error(chan); + uptr->u5 = 0; + dsk_unit[dsk].u5 = 0; + chan_set_end(chan); +} + +/* Handle processing esu controller commands */ +t_stat esu_srv(UNIT * uptr) +{ + int chan = uptr->u5 & DK_CHAN; + DEVICE *dptr = find_dev_from_unit(uptr); + int u = uptr - esu_unit; + int dsk = ((uptr->u5 & DK_CTRL) != 0); + int wc; + + + /* Process for each unit */ + if (uptr->u5 & DK_RD) { + /* Check if at start of segment */ + if (uptr->u3 >= DK_SEC_SIZE) { + int da = (uptr->u4 * DK_SEC_SIZE); + + /* Check if end of operation */ + if ((uptr->u5 & (DK_SECMASK)) == 0) { + esu_set_end(uptr, 0); + return SCPE_OK; + } + + /* Check if over end of disk */ + if (uptr->u4 >= uptr->wait) { + sim_debug(DEBUG_DETAIL, dptr, "Disk read over %d %d %o\n\r", + uptr->u3, uptr->u4, uptr->u5); + chan_set_eof(chan); + esu_set_end(uptr, 0); + return SCPE_OK; + } + sim_debug(DEBUG_DETAIL, dptr, "Disk read %d %d %d %o %d\n\r", + u,uptr->u3, uptr->u4, uptr->u5, da); + + if (sim_fseek(uptr->fileref, da, SEEK_SET) < 0) { + esu_set_end(uptr, 1); + return SCPE_OK; + } + wc = sim_fread(&dsk_buffer[dsk][0], 1, DK_SEC_SIZE, + uptr->fileref); + for (; wc < DK_SEC_SIZE; wc++) + dsk_buffer[dsk][wc] = (uptr->u5 & DK_BIN) ? 0 :020; + uptr->u3 = 0; + uptr->u4++; /* Advance disk address */ + uptr->u5 -= DK_SECT; + } + /* Transfer one Character */ + if (chan_write_char(chan, &dsk_buffer[dsk][uptr->u3], 0)) { + esu_set_end(uptr, 0); + return SCPE_OK; + } + uptr->u3++; + } + + if (uptr->u5 & DK_RDCK) { + if (uptr->u3 >= DK_SEC_SIZE) { + + /* Check if over end of disk */ + if (uptr->u4 >= uptr->wait) { + sim_debug(DEBUG_DETAIL, dptr, "Disk rdchk over %d %d %o\n\r", + uptr->u3, uptr->u4, uptr->u5); + uptr->u5 = 0; + IAR |= IRQ_14 << dsk; + return SCPE_OK; + } + sim_debug(DEBUG_DETAIL, dptr, "Disk rdchk %d %d %d %o\n\r", u, + uptr->u3, uptr->u4, uptr->u5); + + uptr->u4++; /* Advance disk address */ + uptr->u5 -= DK_SECT; + uptr->u3 = 0; + + /* Check if end of operation */ + if ((uptr->u5 & (DK_SECMASK)) == 0) { + uptr->u5 = 0; + IAR |= IRQ_14 << dsk; + return SCPE_OK; + } + } + /* Check if at end of segment */ + uptr->u3++; + } + + /* Process for each unit */ + if (uptr->u5 & DK_WR) { + /* Check if end of operation */ + if ((uptr->u5 & (DK_SECMASK)) == 0) { + esu_set_end(uptr, 0); + return SCPE_OK; + } + + /* Transfer one Character */ + if (chan_read_char(chan, &dsk_buffer[dsk][uptr->u3], 0)) { + if (uptr->u3 != 0) { + while (uptr->u3 < DK_SEC_SIZE) + dsk_buffer[dsk][uptr->u3++] = (uptr->u5 & DK_BIN) ? 0 :020; + } + } + uptr->u3++; + + /* Check if at end of segment */ + if (uptr->u3 >= DK_SEC_SIZE) { + int da = (uptr->u4 * DK_SEC_SIZE); + + /* Check if over end of disk */ + if (uptr->u4 >= uptr->wait) { + sim_debug(DEBUG_DETAIL, dptr, "Disk write over %d %d %o\n\r", + uptr->u3, uptr->u4, uptr->u5); + chan_set_eof(chan); + esu_set_end(uptr, 0); + return SCPE_OK; + } + + sim_debug(DEBUG_DETAIL, dptr, "Disk write %d %d %d %o %d\n\r", + u, uptr->u3, uptr->u4, uptr->u5, da); + if (sim_fseek(uptr->fileref, da, SEEK_SET) < 0) { + esu_set_end(uptr, 1); + return SCPE_OK; + } + + wc = sim_fwrite(&dsk_buffer[dsk][0], 1, DK_SEC_SIZE, + uptr->fileref); + if (wc != DK_SEC_SIZE) { + esu_set_end(uptr, 1); + return SCPE_OK; + } + uptr->u3 = 0; + uptr->u4++; /* Advance disk address */ + uptr->u5 -= DK_SECT; + } + } + sim_activate(uptr, (uptr->flags & MODIB) ? 200 :100); + return SCPE_OK; +} + +t_stat +set_mod(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { + if (uptr == NULL) return SCPE_IERR; + if (val == MODIB) + uptr->wait = DK_MAXSEGS2; + else + uptr->wait = DK_MAXSEGS; + uptr->capac = DK_SEC_SIZE * uptr->wait; + return SCPE_OK; +} + + +/* Boot from given device */ +t_stat +dsk_boot(int32 unit_num, DEVICE * dptr) +{ + int dev = (unit_num)? DSK2_DEV:DSK1_DEV; + t_uint64 desc; + int i; + + for(i = 0; i < 20; i++) + esu_unit[i].u5 = 0; + + desc = (((t_uint64)dev)<= 10 || (dsk_unit[1].flags & DFX) != 0) { + iostatus |= DSK2_FLAG; + } + return SCPE_OK; +} + +t_stat +esu_detach(UNIT * uptr) +{ + t_stat r; + int u = uptr-esu_unit; + int i, mask, lim; + + if ((r = detach_unit(uptr)) != SCPE_OK) + return r; + /* Determine which controller */ + if (u < 10) { + mask = DSK1_FLAG; + /* If DFX, then both controllers */ + if ((dsk_unit[1].flags & DFX) != 0) + mask |= DSK2_FLAG; + lim = 10; + i = 0; + } else { + /* If DFX, then drive not attached */ + if ((dsk_unit[1].flags & DFX) != 0) + return r; + mask = DSK2_FLAG; + lim = 20; + i = 10; + } + /* Scan to see if any disks still attached */ + while (i < lim) { + if (esu_unit[i].flags & UNIT_ATT) + return r; /* Something still there */ + i++; + } + /* There are no longer any drives attached to + this controller */ + iostatus &= ~mask; + return r; +} + +t_stat +dsk_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B5470 Disk Controller\n\n"); + fprintf (st, "By default the second disk controller is not enabled.\n\n"); + fprintf (st, " sim> SET DK1 ENABLE to enable second disk controller for use\n"); + fprintf (st, "The B5500 could have up to two disk controllers that could talk\n"); + fprintf (st, "to up to 10 ESU. Each ESU held up to 5 storage units. By uses of\n"); + fprintf (st, "a exchange unit (DFX), the second controller could talk to the\n"); + fprintf (st, "same drives as the first controller. To use the second disk controller\n"); + fprintf (st, "to share the same drives as the first (after enabling DK1):\n\n"); + fprintf (st, " sim> SET DK1 DFX enable disk exchange\n\n"); + fprintf (st, "If you want to support more then 10 ESU units you will first\n"); + fprintf (st, "need to generate a new version of MCP without the DFX option\n"); + fprintf (st, "for MCP XV you also need to SET DKBNODFX TRUE when building the\n"); + fprintf (st, "system file.\n"); + fprintf (st, "ESU units 0-9 attach to DK0, or DK1 if DFX\n"); + fprintf (st, "ESU units 10-19 attach to DK1 only\n\n"); + fprintf (st, "The DK unit supports the BOOT command.\n\n"); + fprint_set_help (st, dptr) ; + fprint_show_help (st, dptr) ; + return SCPE_OK; +} + +const char * +dsk_description (DEVICE *dptr) +{ + return "B5470 disk controller module"; +} + +t_stat +esu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B471 ESU with 5 B457 storage units\n\n"); + fprintf (st, "Each ESU unit represents the electronics unit and 5 storage units\n"); + fprintf (st, "MOD I units could handle about 48 million characters.\n"); + fprintf (st, "MOD IB units could handle about 96 million characters.\n"); + fprintf (st, "MOD IB units operated at half the speed of MOD I units.\n"); + fprintf (st, "ESU units can be added to a system after it has been booted,\n"); + fprintf (st, "however they can't be removed. The configuration of disks must\n"); + fprintf (st, "be the same each time the same system is booted.\n"); + fprintf (st, "To use larger slower drives do:\n"); + fprintf (st, " sim> SET ESUn MODIB before the unit is attached\n"); + fprintf (st, "To use smaller faster drives do (default):\n"); + fprintf (st, " sim> SET ESUn MODI before the unit is attached\n\n"); + fprint_set_help (st, dptr) ; + fprint_show_help (st, dptr) ; + return SCPE_OK; +} + +const char * +esu_description (DEVICE *dptr) +{ + return "B471 electrontics unit and 5 B457 storage units."; +} +#endif + + diff --git a/B5500/b5500_dr.c b/B5500/b5500_dr.c new file mode 100644 index 0000000..356adfd --- /dev/null +++ b/B5500/b5500_dr.c @@ -0,0 +1,258 @@ +/* b5500_dr.c: Burrioughs 5500 Drum controller + + Copyright (c) 2015, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "b5500_defs.h" + +#if (NUM_DEVS_DR > 0) + +#define UNIT_DR UNIT_ATTABLE | UNIT_DISABLE | UNIT_FIX | \ + UNIT_BUFABLE | UNIT_MUSTBUF + + +/* in u3 is device address */ +/* in u4 is current address */ +/* in u5 Bits 30-16 of W */ +#define DR_CHAN 000003 /* Channel number */ +#define DR_RD 000004 /* Executing a read command */ +#define DR_WR 000010 /* Executing a write command */ +#define DR_RDY 000040 /* Device Ready */ + +#define AUXMEM (1 << UNIT_V_UF) + +t_stat drm_srv(UNIT *); +t_stat drm_boot(int32, DEVICE *); +t_stat drm_attach(UNIT *, CONST char *); +t_stat drm_detach(UNIT *); +t_stat set_drum(UNIT * uptr, int32 val, CONST char *cptr, + void *desc); +t_stat set_auxmem(UNIT * uptr, int32 val, CONST char *cptr, + void *desc); +t_stat drm_help (FILE *, DEVICE *, UNIT *, int32, const char *); +const char *drm_description (DEVICE *); + + +MTAB drm_mod[] = { + {AUXMEM, 0, "DRUM", "DRUM", &set_drum, NULL, NULL, "Device is drum"}, + {AUXMEM, AUXMEM, "AUXMEM", "AUXMEM", &set_auxmem, NULL, NULL, "Device is memory unit"}, + {0} +}; + + +UNIT drm_unit[] = { + {UDATA(&drm_srv, UNIT_DR, 32*1024)}, /* DRA */ + {UDATA(&drm_srv, UNIT_DR, 32*1024)}, /* DRB */ +}; + +DEVICE drm_dev = { + "DR", drm_unit, NULL, drm_mod, + NUM_DEVS_DR, 8, 15, 1, 8, 64, + NULL, NULL, NULL, &drm_boot, &drm_attach, &drm_detach, + NULL, DEV_DISABLE | DEV_DEBUG, 0, dev_debug, + NULL, NULL, &drm_help, NULL, NULL, + &drm_description +}; + + + + +/* Start off a disk command */ +t_stat drm_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc, uint8 rd_flg) +{ + UNIT *uptr; + int u = (dev==DRUM1_DEV)? 0: 1; + + uptr = &drm_unit[u]; + + /* If unit disabled return error */ + if (uptr->flags & UNIT_DIS) { + return SCPE_NODEV; + } + + if ((uptr->flags & (UNIT_BUF)) == 0) { + sim_debug(DEBUG_CMD, &drm_dev, "Drum not buffered\n\r"); + return SCPE_UNATT; + } + + /* Check if drive is ready to recieve a command */ + if ((uptr->u5 & DR_RDY) == 0) + return SCPE_BUSY; + + uptr->u5 = chan; + if (rd_flg) + uptr->u5 |= DR_RD; + else + uptr->u5 |= DR_WR; + uptr->u4 = cmd << 3; + sim_debug(DEBUG_CMD, &drm_dev, "Drum access %s %06o\n\r", + (uptr->u5 & DR_RD) ? "read" : "write", uptr->u4); + sim_activate(uptr, 100); + return SCPE_OK; +} + + +/* Handle processing disk controller commands */ +t_stat drm_srv(UNIT * uptr) +{ + int chan = uptr->u5 & DR_CHAN; + uint8 *ch = &(((uint8 *)uptr->filebuf)[uptr->u4]); + + + /* Process for each unit */ + if (uptr->u5 & DR_RD) { + /* Transfer one Character */ + if (chan_write_drum(chan, ch, 0)) { + uptr->u5 = DR_RDY; + chan_set_end(chan); + return SCPE_OK; + } + uptr->u4++; + if (uptr->u4 > ((int32)uptr->capac << 3)) { + sim_debug(DEBUG_CMD, &drm_dev, "Drum overrun\n\r"); + uptr->u5 = DR_RDY; + chan_set_error(chan); + chan_set_end(chan); + return SCPE_OK; + } + sim_activate(uptr, 40); + } + + /* Process for each unit */ + if (uptr->u5 & DR_WR) { + /* Transfer one Character */ + if (chan_read_drum(chan, ch, 0)) { + uptr->u5 = DR_RDY; + chan_set_end(chan); + return SCPE_OK; + } + uptr->u4++; + if (uptr->u4 > ((int32)uptr->capac << 3)) { + sim_debug(DEBUG_CMD, &drm_dev, "Drum overrun\n\r"); + uptr->u5 = DR_RDY; + chan_set_error(chan); + chan_set_end(chan); + return SCPE_OK; + } + sim_activate(uptr, 40); + } + + return SCPE_OK; +} + +/* Boot from given device */ +t_stat +drm_boot(int32 unit_num, DEVICE * dptr) +{ + int dev = (unit_num)? DRUM2_DEV:DRUM1_DEV; + t_uint64 desc; + + desc = (((t_uint64)dev)<u5 |= DR_RDY; + uptr->hwmark = uptr->capac; + if (u) + iostatus |= DRUM2_FLAG; + else + iostatus |= DRUM1_FLAG; + return SCPE_OK; +} + +t_stat +drm_detach(UNIT * uptr) +{ + t_stat r; + int u = uptr - drm_unit; + if ((r = detach_unit(uptr)) != SCPE_OK) + return r; + uptr->u5 = 0; + if (u) + iostatus &= ~DRUM2_FLAG; + else + iostatus &= ~DRUM1_FLAG; + return SCPE_OK; +} + +t_stat +set_drum(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { + if ((uptr->flags & AUXMEM) == 0) + return SCPE_OK; + if (uptr->flags & UNIT_ATT) + drm_detach(uptr); + uptr->flags |= UNIT_ATTABLE; + return SCPE_OK; +} + +t_stat +set_auxmem(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { + int u = uptr - drm_unit; + + if (uptr->flags & AUXMEM) + return SCPE_OK; + if (uptr->flags & UNIT_ATT) + detach_unit(uptr); + uptr->flags &= ~UNIT_ATTABLE; + if (uptr->filebuf == 0) { + uptr->filebuf = calloc(uptr->capac, 8); + uptr->flags |= UNIT_BUF; + } + uptr->u5 = DR_RDY; + if (u) + iostatus |= DRUM2_FLAG; + else + iostatus |= DRUM1_FLAG; + + return SCPE_OK; +} + +t_stat +drm_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B430 Magnetic Drum or B6500 memory module\n\n"); + fprintf (st, "There are up to two drum units DR0 and DR1. These can either\n"); + fprintf (st, "be attached to a file or set to AUXMEM. Setting to AUXMEM causes\n"); + fprintf (st, "them to exist only during the given sim run. Setting back to DRUM\n"); + fprintf (st, "will clear whatever was stored on the drum. If the device is set\n"); + fprintf (st, "to DRUM it must be attached to a file which it will buffer until\n"); + fprintf (st, "the unit is detached, or the sim exits. MCP must be configured to\n"); + fprintf (st, "the drum\n\n"); + fprint_set_help (st, dptr) ; + fprint_show_help (st, dptr) ; + return SCPE_OK; +} + +const char * +drm_description (DEVICE *dptr) +{ + return "B430 Magnetic Drum or B6500 memory module"; +} +#endif diff --git a/B5500/b5500_dtc.c b/B5500/b5500_dtc.c new file mode 100644 index 0000000..7ba002e --- /dev/null +++ b/B5500/b5500_dtc.c @@ -0,0 +1,899 @@ +/* b5500_dtc.c: Burrioughs 5500 Data Communications + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "b5500_defs.h" +#include "sim_timer.h" +#include "sim_sock.h" +#include "sim_tmxr.h" + +#if (NUM_DEVS_DTC > 0) + +#define UNIT_DTC UNIT_ATTABLE | UNIT_DISABLE | UNIT_IDLE + +#define DTC_MLINES 32 /* mux lines */ +#define DTC_TLINES 8 +#define DTC_BUFSIZ 112 /* max chan transfer */ + + +#define DTCSTA_READ 000400 /* Read flag */ +#define DTCSTA_BINARY 004000 /* Bypass translation */ +#define DTCSTA_INHIBIT 040000 /* Interrogate or Read/Write */ + +/* Flags in WC Field */ +#define DTCSTA_TTU 0740 /* TTU number */ +#define DTCSTA_GM 0020 /* Ignore GM on transfer */ +#define DTCSTA_BUF 0017 /* Buffer Number */ + +/* Interrogate + D28 - Busy DEV_ERROR + D27 - Write Ready DEV_EOF + D24 - Read Ready DEV_IORD */ +/* Abnormal flag = DEV_WCFLG */ +/* Buffer full/GM flag = D25 */ +/* Buffer wrong state = DEV_EOF D27 */ +/* Buffer Busy = DEV_ERROR D28 */ +/* DTC not ready or buffer, DEV_NOTRDY D30 */ +/* in u3 is device address */ +/* in u4 is current address */ +/* in u5 Line number */ +#define DTC_CHAN 000003 /* Channel number */ +#define DTC_RD 000004 /* Executing a read command */ +#define DTC_WR 000010 /* Executing a write command */ +#define DTC_INQ 000020 /* Executing an interragte command */ +#define DTC_RDY 000040 /* Device Ready */ +#define DTC_BIN 000100 /* Transfer in Binary mode */ +#define DTC_IGNGM 000200 /* Ignore GM on transfer */ + +#define BufNotReady 0 /* Device not connected */ +#define BufIdle 1 /* Buffer in Idle state */ +#define BufInputBusy 2 /* Buffer being filled */ +#define BufReadRdy 3 /* Buffer ready to read */ +#define BufWrite 4 /* Buffer writing */ +#define BufWriteRdy 5 /* Buffer ready for write */ +#define BufOutBusy 6 /* Buffer outputing */ +#define BufRead 7 /* Buffer reading */ +#define BufSMASK 7 /* Buffer state mask */ +#define BufAbnormal 010 /* Abnornmal flag */ +#define BufGM 020 /* Buffer term with GM */ +#define BufIRQ 040 /* Buffer ready */ + +/* Not connected line: + BufNotReady. + + Write: + BufNotReady -> 0x34 (EOF,ERROR,NR) + BufIdle -> BufWrite (set GM if set.) + BufReadReady -> 0x20 (EOF). + BufInputBusy, BufWrite -> 0x30 + -> 0x34 (EOF,ERROR) + BufWriteRdy -> BufWrite. + + Write Done: + BufOutBusy. + + Read: + BufNotReady -> 0x34 (EOF,ERROR,NR) + BufIdle -> 0x34 (EOF,ERROR,NR) + BufInputBusy, BufOutBusy -> 0x30 (EOF,ERROR) + BufReadRdy -> return buffer. -> BufIdle + + Interogate: + return BufWriteRdy/BufWriteFull + return BufReadRdy. + + Recieve Char: + + Connect: + State BufWriteRdy. + + Output Done: + BufGM -> BufIdle + -> BufWriteRdy +*/ + +/* Translate chars + + output: + ! -> LF. + < -> RO. + > -> X-OFF + } -> Disconnect line + ~ -> End of message. + + input: + ~/_/CR -> End of message. + BufReadRdy, IRQ. + Back up one char. + !/ -> Disconnect insert } + BufReadRdy, IRQ. + ^B -> Clear input. + BufIdle + ^E -> set abnormal, buffer to BufWriteRdy. + ^L -> Clear input. + BufIdle + ? -> Set abnormal + Char: Buf to BufInputBsy. Insert char. + if Fullbuff, BufReadRdy, IRQ, + +*/ + + + +t_stat dtc_srv(UNIT *); +t_stat dtco_srv(UNIT *); +t_stat dtc_attach(UNIT *, CONST char *); +t_stat dtc_detach(UNIT *); +t_stat dtc_reset(DEVICE *); +t_stat dtc_setnl (UNIT *, int32, CONST char *, void *); +t_stat dtc_set_log (UNIT *, int32, CONST char *, void *); +t_stat dtc_set_nolog (UNIT *, int32, CONST char *, void *); +t_stat dtc_show_log (FILE *, UNIT *, int32, CONST void *); +t_stat dtc_help(FILE *, DEVICE *, UNIT *, int32, const char *); +t_stat dtc_help_attach (FILE *, DEVICE *, UNIT *, int32, const char *); +const char *dtc_description(DEVICE *); + + +int32 tmxr_poll; + +uint8 dtc_buf[DTC_MLINES][DTC_BUFSIZ]; +TMLN dtc_ldsc[DTC_MLINES]; /* line descriptors */ +TMXR dtc_desc = { DTC_TLINES, 0, 0, dtc_ldsc }; /* mux descriptor */ +uint8 dtc_lstatus[DTC_MLINES]; /* Line status */ +uint16 dtc_bufptr[DTC_MLINES]; /* Buffer pointer */ +uint16 dtc_bsize[DTC_MLINES]; /* Buffer size */ +uint16 dtc_blimit[DTC_MLINES]; /* Buffer size */ + + +MTAB dtc_mod[] = { + { MTAB_XTD|MTAB_VDV|MTAB_VALR, 1, NULL, "DISCONNECT", + &tmxr_dscln, NULL, &dtc_desc, "Disconnect a specific line" }, + { UNIT_ATT, UNIT_ATT, "SUMMARY", NULL, + NULL, &tmxr_show_summ, (void *) &dtc_desc, "Display a summary of line states" }, + { MTAB_XTD|MTAB_VDV|MTAB_NMO, 1, "CONNECTIONS", NULL, + NULL, &tmxr_show_cstat, (void *) &dtc_desc, "Display current connections" }, + { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "STATISTICS", NULL, + NULL, &tmxr_show_cstat, (void *) &dtc_desc, "Display multiplexer statistics" }, + { MTAB_XTD|MTAB_VDV|MTAB_VALR, 0, "LINES", "LINES=n", + &dtc_setnl, &tmxr_show_lines, (void *) &dtc_desc, "Display number of lines" }, + { MTAB_XTD|MTAB_VDV|MTAB_NC, 0, NULL, "LOG=n=file", + &dtc_set_log, NULL, &dtc_desc }, + { MTAB_XTD|MTAB_VDV|MTAB_VALR, 0, NULL, "NOLOG", + &dtc_set_nolog, NULL, &dtc_desc, "Disable logging on designated line" }, + { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "LOG", NULL, + NULL, &dtc_show_log, &dtc_desc, "Display logging for all lines" }, + {0} +}; + + +UNIT dtc_unit[] = { + {UDATA(&dtc_srv, UNIT_DTC, 0)}, /* DTC */ + {UDATA(&dtco_srv, UNIT_DIS, 0)}, /* DTC server process */ +}; + +DEVICE dtc_dev = { + "DTC", dtc_unit, NULL, dtc_mod, + 2, 8, 15, 1, 8, 64, + NULL, NULL, &dtc_reset, NULL, &dtc_attach, &dtc_detach, + NULL, DEV_DISABLE | DEV_DEBUG | DEV_MUX, 0, dev_debug, + NULL, NULL, &dtc_help, &dtc_help_attach, (void *)&dtc_desc, + &dtc_description +}; + + + + +/* Start off a terminal controller command */ +t_stat dtc_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr; + int ttu; + int buf; + + uptr = &dtc_unit[0]; + + /* If unit disabled return error */ + if (uptr->flags & UNIT_DIS) + return SCPE_NODEV; + + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; + + /* Check if drive is ready to recieve a command */ + if ((uptr->u5 & DTC_RDY) == 0) + return SCPE_BUSY; + + uptr->u5 = chan; + ttu = (*wc & DTCSTA_TTU) >> 5; + buf = (*wc & DTCSTA_BUF); + /* Set the Terminal unit. */ + if (ttu == 0) + uptr->u4 = -1; + else { + uptr->u4 = buf + ((ttu-1) * 15); + } + if (*wc & DTCSTA_GM) + uptr->u5 |= DTC_IGNGM; + if (cmd & DTCSTA_READ) + uptr->u5 |= DTC_RD; + else if (cmd & DTCSTA_INHIBIT) + uptr->u5 |= DTC_INQ; + else + uptr->u5 |= DTC_WR; + + if (cmd & DTCSTA_BINARY) + uptr->u5 |= DTC_BIN; + + sim_debug(DEBUG_CMD, &dtc_dev, "Datacomm access %s %06o %d %04o\n", + (uptr->u5 & DTC_RD) ? "read" : ((uptr->u5 & DTC_INQ) ? "inq" : + ((uptr->u5 & DTC_WR) ? "write" : "unknown")), + uptr->u5, uptr->u4, *wc); + sim_activate(uptr, 5000); + return SCPE_OK; +} + + +/* Handle processing terminal controller commands */ +t_stat dtc_srv(UNIT * uptr) +{ + int chan = uptr->u5 & DTC_CHAN; + uint8 ch; + int ttu; + int buf; + int i; + int line = uptr->u4; + + + + /* Process interrage command */ + if (uptr->u5 & DTC_INQ) { + if (line == -1) { + buf = -1; + for(i = 0; i < DTC_MLINES; i++) { + if (dtc_lstatus[i]& BufIRQ) { + if ((dtc_lstatus[i] & BufSMASK) == BufReadRdy) + buf = i; + if ((dtc_lstatus[i] & BufSMASK) == BufWriteRdy || + (dtc_lstatus[i] & BufSMASK) == BufIdle) { + line = i; + break; + } + } + } + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm inqury found %d %d ", + line, buf); + if (line != -1) { + chan_set_eof(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " writerdy "); + } else if (buf != -1) { + chan_set_read(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " readrdy "); + line = buf; + } + + if (line != -1) { + if (dtc_lstatus[line] & BufAbnormal) { + chan_set_wcflg(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " abnormal "); + } + dtc_lstatus[line] &= ~BufIRQ; + } + sim_debug(DEBUG_DETAIL, &dtc_dev, " %03o ", dtc_lstatus[i]); + } else { + if (line > dtc_desc.lines) { + chan_set_notrdy(chan); + } else { + switch(dtc_lstatus[line] & BufSMASK) { + case BufReadRdy: + chan_set_read(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " readrdy "); + break; + case BufWriteRdy: + chan_set_eof(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " writerdy "); + break; + default: + chan_set_error(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " busy "); + break; + } + } + if (dtc_lstatus[line] & BufAbnormal) { + chan_set_wcflg(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " abnormal "); + } + dtc_lstatus[line] &= ~BufIRQ; + chan_set_wc(uptr->u4, 0); + chan_set_end(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, " %03o ", dtc_lstatus[line]); + } + if (line != -1) { + for (ttu = 1; line > 15; ttu++) + line -= 15; + } else { + ttu = line = 0; + } + chan_set_wc(chan, (ttu << 5) | line); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm inqury %d %d\n", + ttu, line); + } + /* Process for each unit */ + if (uptr->u5 & DTC_WR) { + if (line > dtc_desc.lines || line == -1) { + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm write invalid %d\n", + line); + chan_set_notrdy(chan); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + return SCPE_OK; + } + /* Validate that we can send data to buffer */ + i = dtc_lstatus[line] & BufSMASK; + switch(i) { + case BufNotReady: + chan_set_notrdy(chan); + case BufInputBusy: + case BufRead: + case BufReadRdy: + chan_set_error(chan); + case BufOutBusy: + chan_set_eof(chan); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm write busy %d %d\n", + line, i); + return SCPE_OK; + + /* Ok to start filling */ + case BufIdle: + case BufWriteRdy: + dtc_lstatus[line] = BufWrite; + dtc_bufptr[line] = 0; + dtc_bsize[line] = 0; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm write start %d\n", + line); + break; + + /* Continue filling */ + case BufWrite: + break; + } + + if (chan_read_char(chan, &ch, dtc_bufptr[line] >= dtc_blimit[line])) { + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm write done %d %d ", + line, dtc_bufptr[line]); + dtc_bsize[line] = dtc_bufptr[line]; + dtc_bufptr[line] = 0; + if (dtc_lstatus[line] & BufAbnormal) { + chan_set_wcflg(chan); + } + dtc_lstatus[line] = BufOutBusy; + /* Check if we filled up buffer */ + if (dtc_bsize[line] >= dtc_blimit[line]) { + chan_set_gm(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, "full "); + /* Empty write, clears flags */ + } else if (dtc_bsize[line] == 0) { + sim_debug(DEBUG_DETAIL, &dtc_dev, "empty\n"); + dtc_lstatus[line] = BufIdle; + } else { + dtc_lstatus[line] |= BufGM; + sim_debug(DEBUG_DETAIL, &dtc_dev, "gm "); + } + sim_debug(DEBUG_DETAIL, &dtc_dev, "\n"); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + return SCPE_OK; + } else { + dtc_buf[line][dtc_bufptr[line]++] = ch & 077; + sim_debug(DEBUG_DATA, &dtc_dev, "Datacomm write data %d %02o %d\n", + line, ch&077, dtc_bufptr[line]); + } + sim_activate(uptr, 5000); + } + + if (uptr->u5 & DTC_RD) { + if (line > dtc_desc.lines || line == -1) { + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm read nothing %d\n", + line); + chan_set_notrdy(chan); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + return SCPE_OK; + } + /* Validate that we can send data to buffer */ + i = dtc_lstatus[line] & BufSMASK; + switch(i) { + case BufNotReady: + chan_set_notrdy(chan); + case BufInputBusy: + chan_set_error(chan); + case BufWriteRdy: + case BufOutBusy: + case BufIdle: + case BufWrite: + chan_set_eof(chan); + chan_set_end(chan); + uptr->u5 = DTC_RDY; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm read busy %d %d\n", + line, i); + return SCPE_OK; + + /* Ok to start filling */ + case BufReadRdy: + dtc_lstatus[line] = (dtc_lstatus[line] & 030) | BufRead; + dtc_bufptr[line] = 0; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm read starting %d\n", + line); + break; + + /* Continue filling */ + case BufRead: + break; + } + + ch = dtc_buf[line][dtc_bufptr[line]++]; + /* If no buffer, error out */ + if (chan_write_char(chan, &ch, dtc_bufptr[line] >= dtc_bsize[line])) { + /* Check if we filled up buffer */ + if (dtc_lstatus[line] & BufGM) { + chan_set_gm(chan); + sim_debug(DEBUG_DETAIL, &dtc_dev, "gm "); + } + if (dtc_lstatus[line] & BufAbnormal) + chan_set_wcflg(chan); + if (dtc_ldsc[line].conn == 0) /* connected? */ + dtc_lstatus[line] = BufNotReady; + else + dtc_lstatus[line] = BufIdle; + dtc_bsize[line] = 0; + chan_set_end(chan); + uptr->u5 = DTC_RDY; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm read done %d\n", + line); + return SCPE_OK; + } else { + sim_debug(DEBUG_DATA, &dtc_dev, "Datacomm read data %d %02o %d\n", + line, ch & 077, dtc_bufptr[line]); + } + sim_activate(uptr, 5000); + } + return SCPE_OK; +} + +/* Unit service - receive side + + Poll all active lines for input + Poll for new connections */ + +t_stat +dtco_srv(UNIT * uptr) +{ + int c, ln, t, c1; + + sim_clock_coschedule(uptr, tmxr_poll); + ln = tmxr_poll_conn(&dtc_desc); /* look for connect */ + if (ln >= 0) { /* got one? */ + dtc_blimit[ln] = DTC_BUFSIZ-1; + dtc_lstatus[ln] = BufIRQ|BufAbnormal|BufWriteRdy; + IAR |= IRQ_12; + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm connect %d\n", ln); + } + + /* For each line that is in idle state enable recieve */ + for (ln = 0; ln < dtc_desc.lines; ln++) { + if (dtc_ldsc[ln].conn && + (dtc_lstatus[ln] & BufSMASK) == BufIdle) { + dtc_ldsc[ln].rcve = 1; + } + } + tmxr_poll_rx(&dtc_desc); /* poll for input */ + for (ln = 0; ln < DTC_MLINES; ln++) { /* loop thru mux */ + /* Check for disconnect */ + if (dtc_ldsc[ln].conn == 0) { /* connected? */ + switch(dtc_lstatus[ln] & BufSMASK) { + case BufIdle: /* Idle, throw in EOT */ + case BufWriteRdy: /* Awaiting output, terminate */ + dtc_bufptr[ln] = 0; + case BufInputBusy: /* reading, terminate with EOT */ + dtc_buf[ln][dtc_bufptr[ln]++] = 017; + dtc_bsize[ln] = dtc_bufptr[ln]; + dtc_lstatus[ln] = BufIRQ|BufAbnormal|BufReadRdy; + IAR |= IRQ_12; + break; + case BufOutBusy: /* Terminate Output */ + dtc_lstatus[ln] = BufIRQ|BufIdle; + dtc_bsize[ln] = 0; + IAR |= IRQ_12; + break; + default: /* Other cases, ignore until + in better state */ + break; + break; + } + continue; /* Skip if not connected */ + } + switch(dtc_lstatus[ln] & BufSMASK) { + case BufIdle: + /* If we have any data to receive */ + if (tmxr_rqln(&dtc_ldsc[ln]) > 0) + dtc_lstatus[ln] = BufInputBusy; + else + break; /* Nothing to do */ + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm recieve %d idle\n", + ln); + dtc_bufptr[ln] = 0; + dtc_bsize[ln] = 0; + case BufInputBusy: + t = 1; + while (t && tmxr_rqln(&dtc_ldsc[ln]) != 0) { + c = tmxr_getc_ln(&dtc_ldsc[ln]) & 0x7f; /* get char */ + c1 = ascii_to_con[c]; + switch(c) { + case '\005': /* ^E ENQ who-are-you */ + dtc_lstatus[ln] &= ~(BufSMASK); + dtc_lstatus[ln] |= BufIRQ|BufAbnormal|BufWriteRdy; + IAR |= IRQ_12; + sim_debug(DEBUG_DETAIL, &dtc_dev, + "Datacomm recieve ENQ %d\n", ln); + t = 0; + break; + case '}': + dtc_buf[ln][dtc_bufptr[ln]++] = 017; + dtc_lstatus[ln] |= BufAbnormal; + /* Fall through to next */ + + case '\r': + case '\n': + case '~': + dtc_lstatus[ln] &= ~BufSMASK; + dtc_lstatus[ln] |= BufIRQ|BufReadRdy; + /* Force at least one character for GM */ + dtc_buf[ln][dtc_bufptr[ln]++] = 077; + dtc_bsize[ln] = dtc_bufptr[ln]; + IAR |= IRQ_12; + t = 0; + sim_debug(DEBUG_DETAIL, &dtc_dev, + "Datacomm recieve %d return\n", ln); + break; + case '\025': /* Control U clear input buffer. */ + dtc_bsize[ln] = 0; + c1 = 0; + break; + case '\b': + case 0x7f: + if (dtc_bufptr[ln] > 0) { + tmxr_putc_ln(&dtc_ldsc[ln], '\b'); + tmxr_putc_ln(&dtc_ldsc[ln], ' '); + tmxr_putc_ln(&dtc_ldsc[ln], '\b'); + dtc_bufptr[ln]--; + } else { + tmxr_putc_ln(&dtc_ldsc[ln], '\007'); + } + c1 = 0; + sim_debug(DEBUG_DATA, &dtc_dev, + "Datacomm recieve %d backspace\n", ln); + break; + case '?': + sim_debug(DEBUG_DATA, &dtc_dev, + "Datacomm recieve %d ?\n", ln); + dtc_lstatus[ln] |= BufAbnormal; + tmxr_putc_ln(&dtc_ldsc[ln], '?'); + dtc_buf[ln][dtc_bufptr[ln]++] = c1; + break; + default: + sim_debug(DEBUG_DATA, &dtc_dev, + "Datacomm recieve %d %02x %c %02o\n", ln, c, c, c1); + } + if (t && c1) { + tmxr_putc_ln(&dtc_ldsc[ln], con_to_ascii[c1]); + dtc_buf[ln][dtc_bufptr[ln]++] = c1; + } + if (dtc_bufptr[ln] >= dtc_blimit[ln]) { + sim_debug(DEBUG_DETAIL, &dtc_dev, + "Datacomm recieve %d full\n", ln); + dtc_lstatus[ln] &= ~(BufSMASK); + dtc_lstatus[ln] |= BufGM|BufIRQ|BufReadRdy; + dtc_bsize[ln] = dtc_bufptr[ln]; + IAR |= IRQ_12; + t = 0; + break; + } + } + + break; + case BufOutBusy: + /* Get next char and send to output */ + t = 1; + while(t && dtc_bufptr[ln] < dtc_bsize[ln] && dtc_ldsc[ln].xmte) { + c = dtc_buf[ln][dtc_bufptr[ln]++]; + c1 = con_to_ascii[c]; + switch(c) { + case 057: /* { */ + c1 = '\r'; /* CR */ + break; + case 032: /* ! */ + c1 = '\n'; /* LF */ + break; + case 076: /* < */ + c1 = 0; /* X-ON */ + break; + case 016: /* > */ + c1 = 0; /* DEL */ + break; + case 017: /* } */ + /* Disconnect line */ + tmxr_reset_ln(&dtc_ldsc[ln]); + sim_debug(DEBUG_DETAIL, &dtc_dev, + "Datacomm disconnect %d\n", ln); + t = 0; + continue; /* On to next line */ + } + sim_debug(DEBUG_DATA, &dtc_dev, + "Datacomm transmit %d %02o %c\n", ln, c&077, c1); + tmxr_putc_ln(&dtc_ldsc[ln], c1); + if (c1 == '\n') { + tmxr_putc_ln(&dtc_ldsc[ln], '\r'); + } + } + if (dtc_bufptr[ln] >= dtc_bsize[ln]) { + if (dtc_lstatus[ln] & BufGM) { + sim_debug(DEBUG_DETAIL, &dtc_dev, + "Datacomm idle %d\n", ln); + dtc_lstatus[ln] = BufIRQ|BufIdle; + } else { + sim_debug(DEBUG_DETAIL, &dtc_dev, "Datacomm writerdy %d\n", + ln); + dtc_lstatus[ln] = BufIRQ|BufWriteRdy; + } + IAR |= IRQ_12; + } + break; + default: + /* Other states are an ignore */ + break; + } + } /* end for */ + tmxr_poll_tx(&dtc_desc); /* poll xmt */ + + return SCPE_OK; +} + + +t_stat +dtc_reset(DEVICE *dptr) { + if (dtc_unit[0].flags & UNIT_ATT) { + sim_activate(&dtc_unit[1], 100); /* quick poll */ + iostatus |= DTC_FLAG; + } else { + sim_cancel(&dtc_unit[1]); + iostatus &= ~DTC_FLAG; + } + return SCPE_OK; +} + +/* Attach master unit */ +t_stat +dtc_attach(UNIT * uptr, CONST char *cptr) +{ + int i; + t_stat r; + + r = tmxr_attach(&dtc_desc, uptr, cptr); /* attach */ + if (r != SCPE_OK) + return r; /* error */ + sim_activate(&dtc_unit[1], 100); /* quick poll */ + for (i = 0; i < DTC_MLINES; i++) { + dtc_lstatus[i] = BufNotReady; /* Device not connected */ + } + uptr->u5 = DTC_RDY; + iostatus |= DTC_FLAG; + return SCPE_OK; +} + +/* Detach master unit */ + +t_stat +dtc_detach(UNIT * uptr) +{ + int i; + t_stat r; + + r = tmxr_detach(&dtc_desc, uptr); /* detach */ + for (i = 0; i < dtc_desc.lines; i++) + dtc_ldsc[i].rcve = 0; /* disable rcv */ + sim_cancel(uptr); /* stop poll */ + uptr->u5 = 0; + iostatus &= ~DTC_FLAG; + return r; +} + +/* SET LINES processor */ + +t_stat dtc_setnl (UNIT *uptr, int32 val, CONST char *cptr, void *desc) +{ + int32 newln, i, t; + t_stat r; + + if (cptr == NULL) + return SCPE_ARG; + newln = (int32) get_uint (cptr, 10, DTC_MLINES, &r); + if ((r != SCPE_OK) || (newln == dtc_desc.lines)) + return r; + if ((newln == 0) || (newln > DTC_MLINES)) + return SCPE_ARG; + if (newln < dtc_desc.lines) { + for (i = newln, t = 0; i < dtc_desc.lines; i++) + t = t | dtc_ldsc[i].conn; + if (t && !get_yn ("This will disconnect users; proceed [N]?", FALSE)) + return SCPE_OK; + for (i = newln; i < dtc_desc.lines; i++) { + if (dtc_ldsc[i].conn) { + tmxr_linemsg (&dtc_ldsc[i], "\r\nOperator disconnected line\r\n"); + tmxr_send_buffered_data (&dtc_ldsc[i]); + } + tmxr_detach_ln (&dtc_ldsc[i]); /* completely reset line */ + } + } + if (dtc_desc.lines < newln) + memset (dtc_ldsc + dtc_desc.lines, 0, sizeof(*dtc_ldsc)*(newln-dtc_desc.lines)); + dtc_desc.lines = newln; + return dtc_reset (&dtc_dev); /* setup lines and auto config */ +} + +/* SET LOG processor */ + +t_stat dtc_set_log (UNIT *uptr, int32 val, CONST char *cptr, void *desc) +{ + t_stat r; + char gbuf[CBUFSIZE]; + int32 ln; + + if (cptr == NULL) + return SCPE_ARG; + cptr = get_glyph (cptr, gbuf, '='); + if ((cptr == NULL) || (*cptr == 0) || (gbuf[0] == 0)) + return SCPE_ARG; + ln = (int32) get_uint (gbuf, 10, dtc_desc.lines, &r); + if ((r != SCPE_OK) || (ln >= dtc_desc.lines)) + return SCPE_ARG; + return tmxr_set_log (NULL, ln, cptr, desc); +} + +/* SET NOLOG processor */ + +t_stat dtc_set_nolog (UNIT *uptr, int32 val, CONST char *cptr, void *desc) +{ + t_stat r; + int32 ln; + + if (cptr == NULL) + return SCPE_ARG; + ln = (int32) get_uint (cptr, 10, dtc_desc.lines, &r); + if ((r != SCPE_OK) || (ln >= dtc_desc.lines)) + return SCPE_ARG; + return tmxr_set_nolog (NULL, ln, NULL, desc); +} + +/* SHOW LOG processor */ + +t_stat dtc_show_log (FILE *st, UNIT *uptr, int32 val, CONST void *desc) +{ + int32 i; + + for (i = 0; i < dtc_desc.lines; i++) { + fprintf (st, "line %d: ", i); + tmxr_show_log (st, NULL, i, desc); + fprintf (st, "\n"); + } + return SCPE_OK; +} + +/* Show summary processor */ + +t_stat +dtc_summ(FILE * st, UNIT * uptr, int32 val, CONST void *desc) +{ + uint32 i, t; + + t = 0; + for (i = 0; i < DTC_MLINES; i++) + t = t + (dtc_ldsc[i].conn != 0); + if (t == 1) + fprintf(st, "1 connection"); + else + fprintf(st, "%d connections", t); + return SCPE_OK; +} + +/* SHOW CONN/STAT processor */ + +t_stat +dtc_show(FILE * st, UNIT * uptr, int32 val, CONST void *desc) +{ + int32 i, cc; + + for (cc = 0; (cc < DTC_MLINES) && dtc_ldsc[cc].conn; cc++) ; + if (cc) { + for (i = 0; i < DTC_MLINES; i++) { + if (dtc_ldsc[i].conn) { + if (val) + tmxr_fconns(st, &dtc_ldsc[i], i); + else + tmxr_fstats(st, &dtc_ldsc[i], i); + } + } + } else + fprintf(st, "all disconnected\n"); + return SCPE_OK; +} + +t_stat dtc_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + +fprintf (st, "B249 Terminal Control Unit\n\n"); +fprintf (st, "The B249 is a terminal multiplexor. Up to %d lines are supported.\n", DTC_MLINES); +fprintf (st, "The default number of lines is %d. The number of lines can\n", DTC_MLINES); +fprintf (st, "be changed with the command\n\n"); +fprintf (st, " sim> SET %s LINES=n set line count to n\n\n", dptr->name); +fprintf (st, "The B249 supports logging on a per-line basis. The command\n\n"); +fprintf (st, " sim> SET %s LOG=n=filename\n\n", dptr->name); +fprintf (st, "enables logging for the specified line(n) to the indicated file. The command\n\n"); +fprintf (st, " sim> SET %s NOLOG=line\n\n", dptr->name); +fprintf (st, "disables logging for the specified line and closes any open log file. Finally,\n"); +fprintf (st, "the command:\n\n"); +fprintf (st, " sim> SHOW %s LOG\n\n", dptr->name); +fprintf (st, "displays logging information for all %s lines.\n\n", dptr->name); +fprintf (st, "Once the B249 is attached and the simulator is running, the B249 will listen for\n"); +fprintf (st, "connections on the specified port. It assumes that the incoming connections\n"); +fprintf (st, "are Telnet connections. The connection remains open until disconnected by the\n"); +fprintf (st, "simulated program, the Telnet client, a SET %s DISCONNECT command, or a\n", dptr->name); +fprintf (st, "DETACH %s command.\n\n", dptr->name); +fprintf (st, "Other special %s commands:\n\n", dptr->name); +fprintf (st, " sim> SHOW %s CONNECTIONS show current connections\n", dptr->name); +fprintf (st, " sim> SHOW %s STATISTICS show statistics for active connections\n", dptr->name); +fprintf (st, " sim> SET %s DISCONNECT=linenumber disconnects the specified line.\n\n\n", dptr->name); +fprintf (st, "All open connections are lost when the simulator shuts down or the %s is\n", dptr->name); +fprintf (st, "detached.\n\n"); +dtc_help_attach (st, dptr, uptr, flag, cptr); +return SCPE_OK; +} + +t_stat dtc_help_attach (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ +tmxr_attach_help (st, dptr, uptr, flag, cptr); +fprintf (st, "The terminal lines perform input and output through Telnet sessions connected\n"); +fprintf (st, "to a user-specified port. The ATTACH command specifies the port to be used:\n\n"); +fprintf (st, " sim> ATTACH %s {interface:}port set up listening port\n\n", dptr->name); +fprintf (st, "where port is a decimal number between 1 and 65535 that is not being used for\n"); +fprintf (st, "other TCP/IP activities. All terminals are considered Dialup to the B249.\n"); +return SCPE_OK; +} + +const char *dtc_description (DEVICE *dptr) +{ + return "B249 Terminal Control Unit"; +} + +#endif diff --git a/B5500/b5500_io.c b/B5500/b5500_io.c new file mode 100644 index 0000000..7ca3d4f --- /dev/null +++ b/B5500/b5500_io.c @@ -0,0 +1,795 @@ +/* B5500_io.c: Burroughs 5500 I/O System. + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "b5500_defs.h" + +#define EOR 1 +#define USEGM 2 + +t_stat chan_reset(DEVICE * dptr); + +/* Channel data structures + + chan_dev Channel device descriptor + chan_unit Channel unit descriptor + chan_reg Channel register list + chan_mod Channel modifiers list +*/ + +t_uint64 D[NUM_CHAN]; /* Current I/O instruction */ +uint8 CC[NUM_CHAN]; /* Channel character count */ +t_uint64 W[NUM_CHAN]; /* Assembly register */ +uint8 status[NUM_CHAN]; /* Channel status */ +uint8 cstatus; /* Active status */ + +#define WC(x) (uint16)(((x) & DEV_WC) >> DEV_WC_V) +#define toWC(x) (((t_uint64)(x) << DEV_WC_V) & DEV_WC) + + +UNIT chan_unit[] = { + /* Normal channels */ + {UDATA(NULL,UNIT_DISABLE,0)},/* A */ + {UDATA(NULL,UNIT_DISABLE,0)},/* B */ + {UDATA(NULL,UNIT_DISABLE,0)},/* C */ + {UDATA(NULL,UNIT_DISABLE,0)},/* D */ +}; + +REG chan_reg[] = { + {BRDATA(D, D, 8, 48, NUM_CHAN), REG_RO}, + {BRDATA(CC, CC, 7, 6, NUM_CHAN), REG_RO}, + {BRDATA(W, W, 8, 48, NUM_CHAN), REG_RO}, + {NULL} +}; + + +/* Simulator debug controls */ +DEBTAB chn_debug[] = { + {"CHANNEL", DEBUG_CHAN}, + {"DETAIL", DEBUG_DETAIL}, + {"DATA", DEBUG_DATA}, + {"CH0", 0x0100 << 0}, + {"CH1", 0x0100 << 1}, + {"CH2", 0x0100 << 2}, + {"CH3", 0x0100 << 3}, + {0, 0} +}; + +DEVICE chan_dev = { + "IO", chan_unit, chan_reg, NULL, + NUM_CHAN, 10, 18, 1, 10, 44, + NULL, NULL, &chan_reset, NULL, NULL, NULL, + NULL, DEV_DEBUG, 0, chn_debug +}; + + + +t_stat +chan_reset(DEVICE * dptr) +{ + int i; + int j = 1; + + cstatus = 0; + /* Clear channel assignment */ + for (i = 0; i < NUM_CHAN; i++) { + status[i] = 0; + D[i] = 0; + W[i] = 0; + CC[i] = 0; + if (chan_unit[i].flags & UNIT_DIS) + cstatus |= j; + j <<= 1; + } + return SCPE_OK; +} + +/* Boot from given device */ +t_stat +chan_boot(t_uint64 desc) +{ + M[020] = desc; + M[010] = 020; + loading = 1; + start_io(); + return SCPE_OK; +} + +int +find_chan() { + int i; + int chan; + + i = 1; + for(chan = 0; chan < NUM_CHAN; chan++) { + if ((cstatus & i) == 0) + break; + i <<= 1; + } + + if (chan == NUM_CHAN) { + return 0; + } + return chan + 1; +} + +void +chan_release(int chan) { + cstatus &= ~(1 << chan); +} + +int +chan_advance(int chan) { + uint16 addr = (uint16)(D[chan] & CORE); + + if (D[chan] & DEV_WCFLG) { + uint16 wc = WC(D[chan]); + if (wc == 0) { + status[chan] |= EOR; + return 1; + } + D[chan] &= ~DEV_WC; + D[chan] |= toWC(wc-1); + } + if (addr > MEMSIZE) { + D[chan] |= DEV_MEMERR; + status[chan] |= EOR; + return 1; + } + W[chan] = M[addr]; + D[chan] &= ~CORE; + if (D[chan] & DEV_BACK) + D[chan] |= (t_uint64)((addr - 1) & CORE); + else + D[chan] |= (t_uint64)((addr + 1) & CORE); + CC[chan] = 0; + return 0; +} + +void +start_io() { + int i; + int chan; + t_stat r; + uint16 dev; + uint16 cmd; + uint16 wc; + int addr; + + chan = find_chan(); + + addr = M[010] & CORE; + + if (chan == 0) { + IAR |= IRQ_1; + return; + } + chan--; + i = 1 << chan; + sim_debug(DEBUG_DETAIL, &chan_dev, "strtio(%016llo %d)\n", M[addr], chan); + D[chan] = M[addr] & D_MASK; + CC[chan] = 0; + W[chan] = 0; + dev = (uint16)((D[chan] & DEVMASK) >> DEV_V); + cmd = (uint16)((D[chan] & DEV_CMD) >> DEV_CMD_V); + wc = WC(D[chan]); + D[chan] &= ~DEV_RESULT; + status[chan] = 0; + if (dev & 1) { +#if (NUM_DEVS_MT > 0) + status[chan] = USEGM; + r = mt_cmd(cmd, dev, chan, &wc); +#else + r = SCPE_UNATT; +#endif + } else { + switch(dev) { +#if (NUM_DEVS_DR > 0) + case DRUM1_DEV: + case DRUM2_DEV: + r = drm_cmd(cmd, dev, chan, &wc, (uint8)((M[addr] & PRESENT)!=0)); + break; +#endif + +#if (NUM_DEVS_CDR > 0) | (NUM_DEVS_CDP > 0) + case CARD1_DEV: + case CARD2_DEV: + r = card_cmd(cmd, dev, chan, &wc); + break; +#endif + +#if (NUM_DEVS_DSK > 0) + case DSK1_DEV: + case DSK2_DEV: + /* Need to pass word count to identify interrogates */ + r = dsk_cmd(cmd, dev, chan, &wc); + break; +#endif + +#if (NUM_DEVS_DTC > 0) + case DTC_DEV: + status[chan] = USEGM; + /* Word count is TTU and BUF number */ + r = dtc_cmd(cmd, dev, chan, &wc); + if (r == SCPE_OK) + D[chan] &= ~DEV_WC; + D[chan] &= ~(DEV_BIN|DEV_WCFLG); + wc = 0; + break; +#endif + +#if (NUM_DEVS_LPR > 0) + case PRT1_DEV: + case PRT2_DEV: + r = lpr_cmd(cmd, dev, chan, &wc); + if (r == SCPE_OK) + D[chan] &= ~DEV_BACK; /* Clear this bit, since printer + uses this to determine 120/132 + char line */ + break; +#endif + +#if (NUM_DEVS_CON > 0) + case SPO_DEV: + status[chan] = USEGM; + r = con_cmd(cmd, dev, chan, &wc); + break; +#endif + default: + r = SCPE_UNATT; + break; + } + } + if (wc != 0) { + D[chan] &= ~DEV_WC; + D[chan] |= toWC(wc) | DEV_WCFLG; + } + switch(r) { + case SCPE_OK: + cstatus |= i; + return; + case SCPE_NXDEV: + case SCPE_UNATT: + D[chan] |= DEV_NOTRDY; + break; + case SCPE_BUSY: + D[chan] |= DEV_BUSY; + break; + case SCPE_EOF: + D[chan] |= DEV_EOF; + break; + } + chan_set_end(chan); +} + + +void +chan_set_end(int chan) { + uint16 dev; + dev = (uint16)((D[chan] & DEVMASK) >> DEV_V); + /* Set character count if reading and tape */ + if ((dev & 1) && (D[chan] & DEV_IORD)) { + D[chan] &= ~((7LL)< 1010 + 00 0001 00 0001 + 00 0010 00 0010 + 00 0011 00 0011 + 00 0100 00 0100 + 00 0101 00 0101 + 00 0110 00 0110 + 00 0111 00 0111 + 00 1000 00 1000 + 00 1001 00 1001 + 00 1010 00 1011 1010 -> 1011 + 00 1011 00 1100 1011 -> 1100 + 00 1100 00 0000 1100 -> 0000 + 00 1101 00 1101 + 00 1110 00 1110 + 00 1111 00 1111 + 01 0000 11 1010 0000 -> 1010 10 + 01 0001 11 0001 1 + 01 0010 11 0010 2 + 01 0011 11 0011 3 + 01 0100 11 0100 + 01 0101 11 0101 + 01 0110 11 0110 + 01 0111 11 0111 + 01 1000 11 1000 8 + 01 1001 11 1001 9 + 01 1010 11 1011 1010 -> 1011 10 + 01 1011 11 1100 1011 -> 1100 11 + 01 1100 11 0000 1100 -> 0000 12 + 01 1101 11 1101 13 + 01 1110 11 1110 14 + 01 1111 11 1111 15 + 10 0000 10 1010 0000 -> 1010 + 10 0001 10 0001 + 10 0010 10 0010 + 10 0011 10 0011 + 10 0100 10 0100 + 10 0101 10 0101 + 10 0110 10 0110 + 10 0111 10 0111 + 10 1000 10 1000 + 10 1001 10 1001 + 10 1010 10 1011 1010 -> 1011 + 10 1011 10 1100 1011 -> 1100 + 10 1100 10 0000 1100 -> 0000 + 10 1101 10 1101 + 10 1110 10 1110 + 10 1111 10 1111 + 11 0000 01 0000 + 11 0001 01 0001 + 11 0010 01 0010 + 11 0011 01 0011 + 11 0100 01 0100 + 11 0101 01 0101 + 11 0110 01 0110 + 11 0111 01 0111 + 11 1000 01 1000 + 11 1001 01 1001 + 11 1010 01 1011 1010 -> 1011 + 11 1011 01 1100 1011 -> 1100 + 11 1100 01 1010 1100 -> 1010 + 11 1101 01 1101 + 11 1110 01 1110 + 11 1111 01 1111 */ + +/* returns 1 when channel can take no more characters. + A return of 1 indicates that the character was not + processed. +*/ +int chan_write_char(int chan, uint8 *ch, int flags) { + uint8 c; + + if (status[chan] & EOR) + return 1; + + if (D[chan] & DEV_INHTRF) { + status[chan] |= EOR; + return 1; + } + + /* Check if first word */ + if (CC[chan] == 0) { + uint16 wc = WC(D[chan]); + + if (D[chan] & DEV_WCFLG && wc == 0) { + sim_debug(DEBUG_DATA, &chan_dev, "zerowc(%d)\n", chan); + status[chan] |= EOR; + return 1; + } + W[chan] = 0; + } + + c = *ch & 077; + if ((D[chan] & DEV_BIN) == 0) { + /* Translate BCL to BCD */ + uint8 cx = c & 060; + + c &= 017; + switch(c) { + case 0: + /* 11-0 -> 01 C */ + /* 10-0 -> 10 C */ + /* 01-0 -> 11 0 */ + /* 00-0 -> 00 C */ + if (cx != 020) + c = 0xc; + break; + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 0xd: + case 0xe: + case 0xf: + break; + case 0xa: + /* 11-A -> 01 0 */ + /* 10-A -> 10 0 */ + /* 01-A -> 11 C */ + /* 00-A -> 00 0 */ + if (cx == 020) + c = 0xc; + else + c = 0; + break; + case 0xb: + c = 0xa; + break; + case 0xc: + c = 0xb; + break; + } + c |= cx ^ ((cx & 020)<<1); + } + + if (D[chan] & DEV_BACK) + W[chan] |= ((t_uint64)c) << ((CC[chan]) * 6); + else + W[chan] |= ((t_uint64)c) << ((7 - CC[chan]) * 6); + CC[chan]++; + + if (CC[chan] == 8) { + uint16 addr = (uint16)(D[chan] & CORE); + + M[addr] = W[chan]; + sim_debug(DEBUG_DATA, &chan_dev, "write(%d, %05o, %016llo)\n", + chan, addr, W[chan]); + + if (chan_advance(chan)) + return 1; + } + if (flags) { + if ((D[chan] & (DEV_BIN|DEV_WCFLG)) == 0) { + /* Insert group mark */ + if (D[chan] & DEV_BACK) { + int i = CC[chan]; + W[chan] |= (t_uint64)037LL << ((CC[chan]) * 6); + + while(i < 8) { + W[chan] |= (t_uint64)014LL << (i * 6); + i++; + } + } else { + W[chan] |= 037LL << ((7 - CC[chan]) * 6); + } + CC[chan]++; + } + + /* Flush last word */ + if (CC[chan] != 0) { + uint16 addr = (uint16)(D[chan] & CORE); + + M[addr] = W[chan]; + sim_debug(DEBUG_DATA, &chan_dev, "write(%d, %05o, %016llo)\n", + chan, addr, W[chan]); + (void)chan_advance(chan); + } + status[chan] |= EOR; + return 1; + } + + return 0; +} + +/* Returns 1 on last character. If it returns 1, the + character in ch is not valid. If flag is set to 1, then + this is the last character the device will request. +*/ +int chan_read_char(int chan, uint8 *ch, int flags) { + uint8 c; + int gm; + + if (status[chan] & EOR) + return 1; + + if (D[chan] & DEV_INHTRF) { + status[chan] |= EOR; + return 1; + } + + if (CC[chan] == 0) { + uint16 addr = (uint16)(D[chan] & CORE); + if (chan_advance(chan)) + return 1; + sim_debug(DEBUG_DATA, &chan_dev, "read(%d, %05o, %016llo)\n", chan, + addr, W[chan]); + } + + if (D[chan] & DEV_BACK) + c = 077 & (W[chan] >> ((CC[chan]) * 6)); + else + c = 077 & (W[chan] >> ((7 - CC[chan]) * 6)); + gm = (c == 037); + CC[chan]++; + if (CC[chan] == 8) { + CC[chan] = 0; + } + if ((D[chan] & DEV_BIN) == 0) { + /* Translate BCD to BCL */ + uint8 cx = c & 060; + c &= 017; + switch(c) { + case 0: + if (cx != 060) + c = 0xa; + break; + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 0xd: + case 0xe: + case 0xf: + break; + case 0xa: + c = 0xb; + break; + case 0xb: + c = 0xc; + break; + case 0xc: + if (cx == 060) + c = 0xa; + else + c = 0; + break; + } + c |= cx ^ ((cx & 020)<<1); + } + *ch = c; + if ((status[chan] & USEGM) != 0 && (D[chan] & DEV_WCFLG) == 0 && gm) { + status[chan] |= EOR; + return 1; + } + if (flags) { + status[chan] |= EOR; + } + return 0; +} + +/* Same as chan_read_char, however we do not check word count + nor do we advance it. +*/ +int chan_read_disk(int chan, uint8 *ch, int flags) { + uint8 c; + + if (CC[chan] == 0) { + uint16 addr = (uint16)(D[chan] & CORE); + if (addr > MEMSIZE) { + D[chan] |= DEV_MEMERR; + return 1; + } + + W[chan] = M[addr]; + D[chan] &= ~CORE; + D[chan] |= (addr + 1) & CORE; + } + + c = 077 & (W[chan] >> ((7 - CC[chan]) * 6)); + CC[chan]++; + *ch = c; + if (CC[chan] == 8) { + CC[chan] = 0; + return 1; + } + return 0; +} + +int +chan_advance_drum(int chan) { + uint16 addr = (uint16)(D[chan] & CORE); + uint16 wc = WC(D[chan]); + if (wc == 0) { + status[chan] |= EOR; + return 1; + } + D[chan] &= ~DEV_WC; + D[chan] |= toWC(wc-1); + if (addr > MEMSIZE) { + D[chan] |= DEV_MEMERR; + status[chan] |= EOR; + return 1; + } + + W[chan] = M[addr]; + D[chan] &= ~CORE; + D[chan] |= (addr + 1) & CORE; + CC[chan] = 0; + return 0; +} + +/* returns 1 when channel can take no more characters. + A return of 1 indicates that the character was not + processed. +*/ +int chan_write_drum(int chan, uint8 *ch, int flags) { + uint8 c; + + if (status[chan] & EOR) + return 1; + + /* Check if first word */ + if (CC[chan] == 0) { + uint16 wc = WC(D[chan]); + + if (wc == 0) { + status[chan] |= EOR; + return 1; + } + W[chan] = 0; + } + + c = *ch; + c &= 077; + + W[chan] |= (t_uint64)c << ((7 - CC[chan]) * 6); + CC[chan]++; + + if (CC[chan] == 8) { + uint16 addr = (uint16)(D[chan] & CORE); + + M[addr] = W[chan]; + if (chan_advance_drum(chan)) + return 1; + } + if (flags) { + /* Flush last word */ + if (CC[chan] != 0) { + uint16 addr = (uint16)(D[chan] & CORE); + + M[addr] = W[chan]; + (void)chan_advance_drum(chan); + } + status[chan] |= EOR; + return 1; + } + + return 0; +} + +/* Returns 1 on last character. If it returns 1, the + character in ch is not valid. If flag is set to 1, then + this is the last character the device will request. +*/ +int chan_read_drum(int chan, uint8 *ch, int flags) { + uint8 c; + + if (status[chan] & EOR) + return 1; + + + if (CC[chan] == 0) { + if (chan_advance_drum(chan)) + return 1; + } + + c = 077 & (W[chan] >> ((7 - CC[chan]) * 6)); + CC[chan]++; + if (CC[chan] == 8) { + CC[chan] = 0; + } + *ch = c; + if (flags) { + status[chan] |= EOR; + } + return 0; +} + diff --git a/B5500/b5500_mt.c b/B5500/b5500_mt.c new file mode 100644 index 0000000..ac373a5 --- /dev/null +++ b/B5500/b5500_mt.c @@ -0,0 +1,632 @@ +/* b5500_mt.c: Burrioughs 5500 Magnetic tape controller + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + + Magnetic tapes are represented as a series of variable records + of the form: + + 32b byte count + byte 0 + byte 1 + : + byte n-2 + byte n-1 + 32b byte count + + If the byte count is odd, the record is padded with an extra byte + of junk. File marks are represented by a byte count of 0. +*/ + +#include "b5500_defs.h" +#include "sim_tape.h" + +#if (NUM_DEVS_MT > 0) + +#define BUFFSIZE 10240 +#define UNIT_MT UNIT_ATTABLE | UNIT_DISABLE | UNIT_ROABLE +#define HT 500 /* Time per char high density */ + +/* in u3 is device address */ +/* in u4 is current buffer position */ +/* in u5 Bits 30-16 of W */ +#define URCSTA_SKIP 000017 /* Skip mask */ +#define URCSTA_SINGLE 000020 /* Single space skip. */ +#define URCSTA_DOUBLE 000040 /* Double space skip */ +#define URCSTA_READ 000400 /* Read flag */ +#define URCSTA_WC 001000 /* Use word count */ +#define URCSTA_DIRECT 002000 /* Direction, Long line */ +#define URCSTA_BINARY 004000 /* Binary transfer */ +#define URCSTA_INHIBIT 040000 /* Inhibit transfer to memory */ + +#define MT_CHAN 0000003 /* Channel active on */ +#define MT_BIN 0000004 /* Binary/BCD */ +#define MT_BACK 0000010 /* Backwards */ +#define MT_CMD 0000070 /* Command to tape drive */ +#define MT_INT 0000010 /* Interrogate */ +#define MT_RD 0000020 /* Reading */ +#define MT_RDBK 0000030 /* Reading Backwards */ +#define MT_WR 0000040 /* Writing */ +#define MT_REW 0000050 /* Rewind */ +#define MT_FSR 0000060 /* Space Forward */ +#define MT_BSR 0000070 /* Space Backward record */ +#define MT_RDY 0000100 /* Device is ready for command */ +#define MT_IDLE 0000200 /* Tape still in motion */ +#define MT_MARK 0001000 /* Hit tape mark */ +#define MT_EOT 0002000 /* At End Of Tape */ +#define MT_BOT 0004000 /* At Beginning Of Tape */ +#define MT_EOR 0010000 /* Set EOR on next record */ +#define MT_BSY 0020000 /* Tape busy after operation */ +#define MT_LOADED 0040000 /* Tape loaded, return ready */ + + +#define BUF_EMPTY(u) (u->hwmark == 0xFFFFFFFF) +#define CLR_BUF(u) u->hwmark = 0xFFFFFFFF + +t_stat mt_srv(UNIT *); +t_stat mt_attach(UNIT *, CONST char *); +t_stat mt_detach(UNIT *); +t_stat mt_reset(DEVICE *); +t_stat mt_help(FILE *, DEVICE *, UNIT *, int32, const char *); +const char *mt_description(DEVICE *dptr); + +/* Channel level activity */ +uint8 mt_chan[NUM_CHAN]; + +uint16 mt_busy = 0; /* Busy bits */ + +/* One buffer per channel */ +uint8 mt_buffer[NUM_CHAN][BUFFSIZE]; + +UNIT mt_unit[] = { +/* Controller 1 */ +#if (NUM_DEVS_MT > 0) + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 0 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 1 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 2 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 3 */ +#if (NUM_DEVS_MT > 3) + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 4 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 5 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 6 */ + {UDATA(&mt_srv, UNIT_MT, 0), 0}, /* 7 */ +#if (NUM_DEVS_MT > 7) + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 8 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 9 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 10 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 11 */ +#if (NUM_DEVS_MT > 11) + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 12 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 13 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 14 */ + {UDATA(&mt_srv, UNIT_MT|UNIT_DIS, 0), 0}, /* 15 */ +#endif +#endif +#endif +#endif +}; + +MTAB mt_mod[] = { + {MTUF_WLK, 0, "write enabled", "WRITEENABLED", NULL, NULL, NULL, + "Write ring in place"}, + {MTUF_WLK, MTUF_WLK, "write locked", "LOCKED", NULL, NULL, NULL, + "no Write ring in place"}, + {MTAB_XTD | MTAB_VUN, 0, "FORMAT", "FORMAT", + &sim_tape_set_fmt, &sim_tape_show_fmt, NULL, + "Set/Display tape format (SIMH, E11, TPC, P7B)" }, + {MTAB_XTD | MTAB_VUN, 0, "LENGTH", "LENGTH", + &sim_tape_set_capac, &sim_tape_show_capac, NULL, + "Set unit n capacity to arg MB (0 = unlimited)" }, + {MTAB_XTD | MTAB_VUN, 0, "DENSITY", "DENSITY", + NULL, &sim_tape_show_dens, NULL}, + {0} +}; + + +DEVICE mt_dev = { + "MT", mt_unit, NULL, mt_mod, + NUM_DEVS_MT, 8, 15, 1, 8, 8, + NULL, NULL, &mt_reset, NULL, &mt_attach, &mt_detach, + NULL, DEV_DISABLE | DEV_DEBUG | DEV_TAPE, 0, dev_debug, + NULL, NULL, &mt_help, NULL, NULL, + &mt_description +}; + + + + +/* Start off a mag tape command */ +t_stat +mt_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr; + int unit = dev >> 1; + + /* Make sure valid drive number */ + if (unit > NUM_DEVS_MT || unit < 0) + return SCPE_NODEV; + + uptr = &mt_unit[unit]; + /* If unit disabled return error */ + if (uptr->flags & UNIT_DIS) + return SCPE_NODEV; + + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; + + /* Not there until loading done */ + if ((uptr->u5 & MT_LOADED)) + return SCPE_UNATT; + + /* Check if drive is ready to recieve a command */ + if ((uptr->u5 & MT_BSY) != 0) + return SCPE_BUSY; + + /* Determine actual command */ + uptr->u5 &= ~(MT_RDY|MT_CHAN|MT_CMD|MT_BIN); + uptr->u5 |= chan; + if (cmd & URCSTA_BINARY) + uptr->u5 |= MT_BIN; + if (cmd & URCSTA_READ) { + if ((cmd & URCSTA_WC) && *wc == 0) + uptr->u5 |= MT_FSR; + else + uptr->u5 |= MT_RD; + } else { + /* Erase gap not supported on sim, treat as + write of null record */ + if ((cmd & URCSTA_WC) && *wc == 0) + uptr->u5 |= MT_INT; + else + uptr->u5 |= MT_WR; + } + + *wc = 0; /* So no overide occurs */ + + /* Convert command to correct type */ + if (cmd & URCSTA_DIRECT) + uptr->u5 |= MT_BACK; + uptr->u6 = 0; + CLR_BUF(uptr); + sim_debug(DEBUG_CMD, &mt_dev, "Command %d %o %o\n", unit, uptr->u5, cmd); + if ((uptr->u5 & MT_IDLE) == 0) { + sim_activate(uptr,50000); + } + return SCPE_OK; +} + + + +/* Map simH errors into machine errors */ +t_stat mt_error(UNIT * uptr, int chan, t_stat r, DEVICE * dptr) +{ + switch (r) { + case MTSE_OK: /* no error */ + sim_debug(DEBUG_EXP, dptr, "OK "); + break; + + case MTSE_EOM: /* end of medium */ + sim_debug(DEBUG_EXP, dptr, "EOT "); + if (uptr->u5 & MT_BOT) { + chan_set_blank(chan); + } else { + uptr->u5 &= ~MT_BOT; + uptr->u5 |= MT_EOT; + chan_set_eot(chan); + } + break; + + case MTSE_TMK: /* tape mark */ + sim_debug(DEBUG_EXP, dptr, "MARK "); + uptr->u5 &= ~(MT_BOT|MT_EOT); + chan_set_eof(chan); + break; + + case MTSE_WRP: /* write protected */ + sim_debug(DEBUG_EXP, dptr, "WriteLocked "); + chan_set_wrp(chan); + break; + + case MTSE_INVRL: /* invalid rec lnt */ + case MTSE_IOERR: /* IO error */ + case MTSE_FMT: /* invalid format */ + case MTSE_RECE: /* error in record */ + chan_set_error(chan); /* Force redundency error */ + sim_debug(DEBUG_EXP, dptr, "ERROR %d ", r); + break; + case MTSE_BOT: /* beginning of tape */ + uptr->u5 &= ~MT_EOT; + uptr->u5 |= MT_BOT; + chan_set_bot(chan); /* Set flag */ + sim_debug(DEBUG_EXP, dptr, "BOT "); + break; + case MTSE_UNATT: /* unattached */ + default: + sim_debug(DEBUG_EXP, dptr, "%d ", r); + } + uptr->u5 &= ~(MT_CMD|MT_BIN); + uptr->u5 |= MT_RDY|MT_IDLE; + chan_set_end(chan); + return SCPE_OK; +} + +/* Handle processing of tape requests. */ +t_stat mt_srv(UNIT * uptr) +{ + int chan = uptr->u5 & MT_CHAN; + int unit = uptr - mt_unit; + int cmd = uptr->u5 & MT_CMD; + DEVICE *dptr = find_dev_from_unit(uptr); + t_mtrlnt reclen; + t_stat r = SCPE_ARG; /* Force error if not set */ + uint8 ch; + int mode; + t_mtrlnt loc; + + + /* Simulate tape load delay */ + if (uptr->u5 & MT_LOADED) { + uptr->u5 &= ~MT_LOADED; + uptr->u5 |= MT_BSY|MT_RDY; + sim_debug(DEBUG_DETAIL, dptr, "Unit=%d Loaded\n", unit); + sim_activate(uptr, 50000); + return SCPE_OK; + } + + if (uptr->u5 & MT_BSY) { + uptr->u5 &= ~MT_BSY; + sim_debug(DEBUG_DETAIL, dptr, "Unit=%d Online\n", unit); + iostatus |= 1 << (uptr - mt_unit); + if (uptr->u5 & MT_IDLE) + sim_activate(uptr, 50000); + return SCPE_OK; + } + + if (uptr->u5 & MT_IDLE) { + uptr->u5 &= ~MT_IDLE; + if (uptr->u5 & MT_RDY) { + sim_debug(DEBUG_DETAIL, dptr, "Unit=%d idling\n", unit); + return SCPE_OK; + } + sim_debug(DEBUG_DETAIL, dptr, "Unit=%d start %02o\n", unit, cmd); + } + + switch (cmd) { + /* Handle interrogate */ + case MT_INT: + if (sim_tape_wrp(uptr)) + chan_set_wrp(chan); + uptr->u5 &= ~(MT_CMD|MT_BIN); + uptr->u5 |= MT_RDY; + chan_set_end(chan); + sim_debug(DEBUG_DETAIL, dptr, "Status\n"); + return SCPE_OK; + + case MT_RD: /* Read */ + /* If at end of record, fill buffer */ + if (BUF_EMPTY(uptr)) { + sim_debug(DEBUG_DETAIL, dptr, "Read unit=%d %s ", unit, + (uptr->u5 & MT_BIN)? "bin": "bcd"); + if (sim_tape_eot(uptr)) { + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_EOM, dptr); + } + r = sim_tape_rdrecf(uptr, &mt_buffer[chan][0], &reclen, BUFFSIZE); + if (r != MTSE_OK) { + if (r == MTSE_TMK) { + sim_debug(DEBUG_DETAIL, dptr, "TM\n"); + ch = 017; + (void)chan_write_char(chan, &ch, 1); + sim_activate(uptr, 4000); + } else { + sim_debug(DEBUG_DETAIL, dptr, "r=%d\n", r); + sim_activate(uptr, 5000); + } + return mt_error(uptr, chan, r, dptr); + } else { + uptr->u5 &= ~(MT_BOT|MT_EOT); + uptr->hwmark = reclen; + } + sim_debug(DEBUG_DETAIL, dptr, "%d chars\n", uptr->hwmark); + uptr->u6 = 0; + if ((uptr->u5 & MT_BIN) == 0) + mode = 0100; + else + mode = 0; + for (loc = 0; loc < reclen; loc++) { + ch = mt_buffer[chan][loc] & 0177; + if (((parity_table[ch & 077]) ^ (ch & 0100) ^ mode) == 0) { + chan_set_error(chan); + break; + } + } + } + ch = mt_buffer[chan][uptr->u6++] & 0177; + /* 00 characters are not transfered in BCD mode */ + if (ch == 0) { + if (((uint32)uptr->u6) >= uptr->hwmark) { + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_OK, dptr); + } else { + sim_activate(uptr, HT); + return SCPE_OK; + } + } + + if (chan_write_char(chan, &ch, + (((uint32)uptr->u6) >= uptr->hwmark) ? 1 : 0)) { + sim_debug(DEBUG_DATA, dptr, "Read unit=%d %d EOR\n", unit, + uptr->hwmark-uptr->u6); + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_OK, dptr); + } else { + sim_debug(DEBUG_DATA, dptr, "Read data unit=%d %d %03o\n", + unit, uptr->u6, ch); + sim_activate(uptr, HT); + } + return SCPE_OK; + + case MT_RDBK: /* Read Backword */ + /* If at end of record, fill buffer */ + if (BUF_EMPTY(uptr)) { + sim_debug(DEBUG_DETAIL, dptr, "Read back unit=%d %s ", unit, + (uptr->u5 & MT_BIN)? "bin": "bcd"); + if (sim_tape_bot(uptr)) { + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_BOT, dptr); + } + r = sim_tape_rdrecr(uptr, &mt_buffer[chan][0], &reclen, BUFFSIZE); + if (r != MTSE_OK) { + if (r == MTSE_TMK) { + sim_debug(DEBUG_DETAIL, dptr, "TM\n"); + ch = 017; + (void)chan_write_char(chan, &ch, 1); + sim_activate(uptr, 4000); + } else { + uptr->u5 |= MT_BSY; + sim_debug(DEBUG_DETAIL, dptr, "r=%d\n", r); + sim_activate(uptr, 100); + } + return mt_error(uptr, chan, r, dptr); + } else { + uptr->u5 &= ~(MT_BOT|MT_EOT); + uptr->hwmark = reclen; + } + sim_debug(DEBUG_DETAIL, dptr, "%d chars\n", uptr->hwmark); + uptr->u6 = uptr->hwmark; + if ((uptr->u5 & MT_BIN) == 0) + mode = 0100; + else + mode = 0; + for (loc = 0; loc < reclen; loc++) { + ch = mt_buffer[chan][loc] & 0177; + if (((parity_table[ch & 077]) ^ (ch & 0100) ^ mode) == 0) { + chan_set_error(chan); + break; + } + } + } + ch = mt_buffer[chan][--uptr->u6] & 0177; + /* 00 characters are not transfered in BCD mode */ + if (ch == 0) { + if (uptr->u6 <= 0) { + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_OK, dptr); + } else { + sim_activate(uptr, HT); + return SCPE_OK; + } + } + + if (chan_write_char(chan, &ch, (uptr->u6 > 0) ? 0 : 1)) { + sim_debug(DEBUG_DATA, dptr, "Read back unit=%d %d EOR\n", + unit, uptr->hwmark-uptr->u6); + sim_activate(uptr, 100); + return mt_error(uptr, chan, MTSE_OK, dptr); + } else { + sim_debug(DEBUG_DATA, dptr, "Read back data unit=%d %d %03o\n", + unit, uptr->u6, ch); + sim_activate(uptr, HT); + } + return SCPE_OK; + + case MT_WR: /* Write */ + /* Check if write protected */ + if (uptr->u6 == 0 && sim_tape_wrp(uptr)) { + sim_activate(uptr, 100); + return mt_error(uptr, chan, MTSE_WRP, dptr); + } + if (chan_read_char(chan, &ch, + (uptr->u6 > BUFFSIZE) ? 1 : 0)) { + reclen = uptr->u6; + /* If no transfer, then either erase */ + if (reclen == 0) { + sim_debug(DEBUG_DETAIL, dptr, "Erase\n"); + r = MTSE_OK; + } else if ((reclen == 1) && (cmd & MT_BIN) == 0 && + (mt_buffer[chan][0] == 017)) { + /* Check if write rtape mark */ + sim_debug(DEBUG_DETAIL, dptr, "Write Mark unit=%d\n", unit); + r = sim_tape_wrtmk(uptr); + } else { + sim_debug(DEBUG_DETAIL, dptr, + "Write unit=%d Block %d %s chars\n", unit, reclen, + (uptr->u5 & MT_BIN)? "bin": "bcd"); + r = sim_tape_wrrecf(uptr, &mt_buffer[chan][0], reclen); + } + uptr->u5 &= ~(MT_BOT|MT_EOT); + sim_activate(uptr, 4000); + return mt_error(uptr, chan, r, dptr); /* Record errors */ + } else { + /* Copy data to buffer */ + ch &= 077; + ch |= parity_table[ch]; + if ((uptr->u5 & MT_BIN)) + ch ^= 0100; + /* Don't write out even parity zeros */ + if (ch != 0) + mt_buffer[chan][uptr->u6++] = ch; + sim_debug(DEBUG_DATA, dptr, "Write data unit=%d %d %03o\n", + unit, uptr->u6, ch); + uptr->hwmark = uptr->u6; + } + sim_activate(uptr, HT); + return SCPE_OK; + + case MT_FSR: /* Space forward one record */ + if (BUF_EMPTY(uptr)) { + /* If at end of record, fill buffer */ + sim_debug(DEBUG_DETAIL, dptr, "Space unit=%d ", unit); + if (sim_tape_eot(uptr)) { + uptr->u5 &= ~MT_BOT; + sim_debug(DEBUG_DETAIL, dptr, "EOT\n"); + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_EOM, dptr); + } + r = sim_tape_rdrecf(uptr, &mt_buffer[chan][0], &reclen, BUFFSIZE); + if (r != MTSE_OK) { + if (r == MTSE_TMK) { + sim_debug(DEBUG_DETAIL, dptr, "TM "); + reclen = 1; + chan_set_eof(chan); + } else { + sim_debug(DEBUG_DETAIL, dptr, "r=%d ", r); + reclen = 10; + } + } + uptr->u5 &= ~(MT_BOT|MT_EOT); + uptr->hwmark = reclen; + sim_debug(DEBUG_DETAIL, dptr, "%d chars\n", uptr->hwmark); + sim_activate(uptr, uptr->hwmark * HT); + return SCPE_OK; + } + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_OK, dptr); + + case MT_BSR: /* Backspace record */ + if (BUF_EMPTY(uptr)) { + /* If at end of record, fill buffer */ + sim_debug(DEBUG_DETAIL, dptr, "backspace unit=%d ", unit); + if (sim_tape_bot(uptr)) { + sim_debug(DEBUG_DETAIL, dptr, "BOT\n"); + sim_activate(uptr, 100); + return mt_error(uptr, chan, MTSE_BOT, dptr); + } + r = sim_tape_rdrecr(uptr, &mt_buffer[chan][0], &reclen, BUFFSIZE); + if (r != MTSE_OK) { + if (r == MTSE_TMK) { + sim_debug(DEBUG_DETAIL, dptr, "TM "); + reclen = 1; + chan_set_eof(chan); + } else { + reclen = 10; + sim_debug(DEBUG_DETAIL, dptr, "r=%d ", r); + } + } + uptr->u5 &= ~(MT_BOT|MT_EOT); + uptr->hwmark = reclen; + sim_debug(DEBUG_DETAIL, dptr, "%d chars\n", uptr->hwmark); + sim_activate(uptr, uptr->hwmark * HT); + return SCPE_OK; + } + sim_activate(uptr, 4000); + return mt_error(uptr, chan, MTSE_OK, dptr); + + case MT_REW: /* Rewind */ + sim_debug(DEBUG_DETAIL, dptr, "Rewind unit=%d pos=%d\n", unit, + uptr->pos); + uptr->u5 &= ~(MT_CMD | MT_BIN | MT_IDLE | MT_RDY); + uptr->u5 |= MT_BSY|MT_RDY; + iostatus &= ~(1 << (uptr - mt_unit)); + sim_activate(uptr, (uptr->pos/100) + 100); + r = sim_tape_rewind(uptr); + uptr->u5 &= ~MT_EOT; + uptr->u5 |= MT_BOT; + chan_set_end(chan); + return r; + } + return mt_error(uptr, chan, r, dptr); +} + + +t_stat +mt_attach(UNIT * uptr, CONST char *file) +{ + t_stat r; + + if ((r = sim_tape_attach(uptr, file)) != SCPE_OK) + return r; + uptr->u5 |= MT_LOADED|MT_BOT; + sim_activate(uptr, 50000); + return SCPE_OK; +} + +t_stat +mt_detach(UNIT * uptr) +{ + uptr->u5 = 0; + iostatus &= ~(1 << (uptr - mt_unit)); + return sim_tape_detach(uptr); +} + +t_stat +mt_reset(DEVICE *dptr) +{ + int i; + + /* Scan all devices and enable those that + are loaded. This is to allow tapes that + are mounted prior to boot to be recognized + at later. Also disconnect all devices no + longer connected. */ + for ( i = 0; i < NUM_DEVS_MT; i++) { + mt_unit[i].dynflags = MT_DENS_556 << UNIT_V_DF_TAPE; + if ((mt_unit[i].flags & UNIT_ATT) == 0) + iostatus &= ~(1 << i); + else if (mt_unit[i].u5 & (MT_LOADED|MT_RDY)) { + iostatus |= 1 << i; + mt_unit[i].u5 &= ~(MT_LOADED); + mt_unit[i].u5 |= MT_RDY; + } + } + return SCPE_OK; +} + +t_stat +mt_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B422/B423 Magnetic tape unit\n\n"); + fprintf (st, "The magnetic tape controller assumes that all tapes are 7 track\n"); + fprintf (st, "with valid parity. Tapes are assumed to be 555.5 characters per\n"); + fprintf (st, "inch. To simulate a standard 2400foot tape, do:\n"); + fprintf (st, " sim> SET MTn LENGTH 15\n\n"); + fprintf (st, "By default only 8 drives are enabled, additional units up to 15 supported.\n"); + fprint_set_help(st, dptr); + fprint_show_help(st, dptr); + return SCPE_OK; +} + +const char * +mt_description(DEVICE *dptr) +{ + return "B422/B423 Magnetic tape unit"; +} +#endif + + diff --git a/B5500/b5500_sys.c b/B5500/b5500_sys.c new file mode 100644 index 0000000..5dff902 --- /dev/null +++ b/B5500/b5500_sys.c @@ -0,0 +1,541 @@ +/* b5500_sys.c: Burroughs 5500 Simulator system interface. + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + +*/ + +#include "sim_defs.h" +#include "b5500_defs.h" +#include "sim_card.h" +#include + +t_stat parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); + +/* 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[] = "B5500"; + +REG *sim_PC = &cpu_reg[0]; + +int32 sim_emax = 1; + +DEVICE *sim_devices[] = { + &cpu_dev, + &chan_dev, +#if NUM_DEVS_CDR > 0 + &cdr_dev, +#endif +#if NUM_DEVS_CDP > 0 + &cdp_dev, +#endif +#if NUM_DEVS_LPR > 0 + &lpr_dev, +#endif +#if NUM_DEVS_CON > 0 + &con_dev, +#endif +#if NUM_DEVS_MT > 0 + &mt_dev, +#endif +#if NUM_DEVS_DR > 0 + &drm_dev, +#endif +#if NUM_DEVS_DSK > 0 + &esu_dev, + &dsk_dev, +#endif +#if NUM_DEVS_DTC > 0 + &dtc_dev, +#endif + NULL +}; + +/* Simulator stop codes */ +const char *sim_stop_messages[] = { + 0, +}; + +/* Simulator debug controls */ +DEBTAB dev_debug[] = { + {"CMD", DEBUG_CMD, "Show command execution to devices"}, + {"DATA", DEBUG_DATA, "Show data transfers"}, + {"DETAIL", DEBUG_DETAIL, "Show details about device"}, + {"EXP", DEBUG_EXP, "Show exception information"}, + {0, 0} +}; + + +uint8 parity_table[64] = { + /* 0 1 2 3 4 5 6 7 */ + 0000, 0100, 0100, 0000, 0100, 0000, 0000, 0100, + 0100, 0000, 0000, 0100, 0000, 0100, 0100, 0000, + 0100, 0000, 0000, 0100, 0000, 0100, 0100, 0000, + 0000, 0100, 0100, 0000, 0100, 0000, 0000, 0100, + 0100, 0000, 0000, 0100, 0000, 0100, 0100, 0000, + 0000, 0100, 0100, 0000, 0100, 0000, 0000, 0100, + 0000, 0100, 0100, 0000, 0100, 0000, 0000, 0100, + 0100, 0000, 0000, 0100, 0000, 0100, 0100, 0000 +}; + +uint8 mem_to_ascii[64] = { + /* x0 x1 x2 x3 x4 x5 x6 x7 */ + '0', '1', '2', '3', '4', '5', '6', '7', /* 0x */ + '8', '9', '#', '@', '?', ':', '>', '}', /* 1x */ + '+', 'A', 'B', 'C', 'D', 'E', 'F', 'G', /* 2x */ + 'H', 'I', '.', '[', '&', '(', '<', '~', /* 3x */ + '|', 'J', 'K', 'L', 'M', 'N', 'O', 'P', /* 4x */ + 'Q', 'R', '$', '*', '-', ')', ';', '{', /* 5x */ + ' ', '/', 'S', 'T', 'U', 'V', 'W', 'X', /* 6x */ + 'Y', 'Z', ',', '%', '!', '=', ']', '"' /* 7x */ +}; + +const char con_to_ascii[64] = { + '?', '1', '2', '3', '4', '5', '6', '7', + '8', '9', '0', '#', '@', ':', '>', '}', /* 17 = box */ + ' ', '/', 'S', 'T', 'U', 'V', 'W', 'X', + 'Y', 'Z', '!', ',', '%', '=', ']', '"', + '-', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', '|', '$', '*', ')', ';', '{', /* 57 = triangle */ + '&', 'A', 'B', 'C', 'D', 'E', 'F', 'G', + 'H', 'I', '+', '.', '[', '(', '<', '~', /* 37 = stop code */ +}; /* 72 = rec mark */ + /* 75 = squiggle, 77 = del */ + +const char ascii_to_con[128] = { + /* Control */ + -1, -1, -1, -1, -1, -1, -1, -1, /* 0 - 37 */ + /* Control */ + -1, -1, -1, -1, -1, -1, -1, -1, + /* Control */ + -1, -1, -1, -1, -1, -1, -1, -1, + /* Control */ + -1, -1, -1, -1, -1, -1, -1, -1, + /*sp ! " # $ % & ' */ + 020, 032, 037, 013, 053, 017, 060, 014, /* 40 - 77 */ + /* ( ) * + , - . / */ + 075, 055, 054, 072, 033, 040, 073, 021, + /* 0 1 2 3 4 5 6 7 */ + 012, 001, 002, 003, 004, 005, 006, 007, + /* 8 9 : ; < = > ? */ + 010, 011, 015, 056, 076, 035, 016, 000, + /* @ A B C D E F G */ + 014, 061, 062, 063, 064, 065, 066, 067, /* 100 - 137 */ + /* H I J K L M N O */ + 070, 071, 041, 042, 043, 044, 045, 046, + /* P Q R S T U V W */ + 047, 050, 051, 022, 023, 024, 025, 026, + /* X Y Z [ \ ] ^ _ */ + 027, 030, 031, 075, 036, 055, 057, 000, + /* ` a b c d e f g */ + 035, 061, 062, 063, 064, 065, 066, 067, /* 140 - 177 */ + /* h i j k l m n o */ + 070, 071, 041, 042, 043, 044, 045, 046, + /* p q r s t u v w */ + 047, 050, 051, 022, 023, 024, 025, 026, + /* x y z { | } ~ del*/ + 027, 030, 031, 057, 077, 017, -1, -1 +}; + + +/* Load a card image file into memory. */ + +t_stat +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) +{ + /* Currently not implimented until I know format of load files */ + return SCPE_NOFNC; +} + +#define TYPE_A 1 /* Full 12 bit opcode */ +#define TYPE_B 2 /* 6 Bit Opcode with 6 bit field */ +#define TYPE_C 3 /* 8 Bit opcode with 4 bit field */ +#define TYPE_D 4 /* 2 bit opcode, 10 bit field */ + +/* Opcodes */ +t_opcode word_ops[] = { +/* Word mode opcodes */ + WMOP_LITC, TYPE_D, "LITC", /* Load literal */ + WMOP_OPDC, TYPE_D, "OPDC", /* Load operand */ + WMOP_DESC, TYPE_D, "DESC", /* Load Descriptor */ + WMOP_DEL, TYPE_A, "DEL", /* Delete top of stack */ + WMOP_NOP, TYPE_A, "NOP", /* Nop operation */ + WMOP_XRT, TYPE_A, "XRT", /* Set Variant */ + WMOP_ADD, TYPE_A, "ADD", /* Add */ + WMOP_DLA, TYPE_A, "DLA", /* Double Precision Add */ + WMOP_PRL, TYPE_A, "PRL", /* Program Release */ + WMOP_LNG, TYPE_A, "LNG", /* Logical Negate */ + WMOP_CID, TYPE_A, "CID", /* Conditional Integer Store Destructive */ + WMOP_GEQ, TYPE_A, "GEQ", /* B greater than or equal to A */ + WMOP_BBC, TYPE_A, "BBC", /* Branch Backward Conditional */ + WMOP_BRT, TYPE_A, "BRT", /* Branch Return */ + WMOP_INX, TYPE_A, "INX", /* Index */ + WMOP_ITI, TYPE_A, "ITI", /* Interrogate interrupt */ + WMOP_LOR, TYPE_A, "LOR", /* Logical Or */ + WMOP_CIN, TYPE_A, "CIN", /* Conditional Integer Store non-destructive */ + WMOP_GTR, TYPE_A, "GTR", /* B Greater than A */ + WMOP_BFC, TYPE_A, "BFC", /* Branch Forward Conditional */ + WMOP_RTN, TYPE_A, "RTN", /* Return normal */ + WMOP_COC, TYPE_A, "COC", /* Construct Operand Call */ + WMOP_SUB, TYPE_A, "SUB", /* Subtract */ + WMOP_DLS, TYPE_A, "DLS", /* Double Precision Subtract */ + WMOP_MUL, TYPE_A, "MUL", /* Multiply */ + WMOP_DLM, TYPE_A, "DLM", /* Double Precision Multiply */ + WMOP_RTR, TYPE_A, "RTR", /* Read Timer */ + WMOP_LND, TYPE_A, "LND", /* Logical And */ + WMOP_STD, TYPE_A, "STD", /* B Store Destructive */ + WMOP_NEQ, TYPE_A, "NEQ", /* B Not equal to A */ + WMOP_SSN, TYPE_A, "SSN", /* Set Sign Bit */ + WMOP_XIT, TYPE_A, "XIT", /* Exit */ + WMOP_MKS, TYPE_A, "MKS", /* Mark Stack */ + WMOP_DIV, TYPE_A, "DIV", /* Divide */ + WMOP_DLD, TYPE_A, "DLD", /* Double Precision Divide */ + WMOP_COM, TYPE_A, "COM", /* Communication operator */ + WMOP_LQV, TYPE_A, "LQV", /* Logical Equivalence */ + WMOP_SND, TYPE_A, "SND", /* B Store Non-destructive */ + WMOP_XCH, TYPE_A, "XCH", /* Exchange */ + WMOP_CHS, TYPE_A, "CHS", /* Change sign bit */ + WMOP_RTS, TYPE_A, "RTS", /* Return Special */ + WMOP_CDC, TYPE_A, "CDC", /* Construct descriptor call */ + WMOP_FTC, TYPE_A, "FTC", /* Transfer F Field to Core Field */ + WMOP_MOP, TYPE_A, "MOP", /* Reset Flag bit */ + WMOP_LOD, TYPE_A, "LOD", /* Load */ + WMOP_DUP, TYPE_A, "DUP", /* Duplicate */ + WMOP_TOP, TYPE_A, "TOP", /* Test Flag Bit */ + WMOP_IOR, TYPE_A, "IOR", /* I/O Release */ + WMOP_LBC, TYPE_A, "LBC", /* Word Branch Backward Conditional */ + WMOP_SSF, TYPE_A, "SSF", /* Set or Store S or F registers */ + WMOP_HP2, TYPE_A, "HP2", /* Halt P2 */ + WMOP_LFC, TYPE_A, "LFC", /* Word Branch Forward Conditional */ + WMOP_ZP1, TYPE_A, "ZP1", /* Conditional Halt */ + WMOP_TUS, TYPE_A, "TUS", /* Interrogate Peripheral Status */ + WMOP_LLL, TYPE_A, "LLL", /* Link List Look-up */ + WMOP_IDV, TYPE_A, "IDV", /* Integer Divide Integer */ + WMOP_SFI, TYPE_A, "SFI", /* Store for Interrupt */ + WMOP_SFT, TYPE_A, "SFT", /* Store for Test */ + WMOP_FTF, TYPE_A, "FTF", /* Transfer F Field to F Field */ + WMOP_MDS, TYPE_A, "MDS", /* Set Flag Bit */ + WMOP_IP1, TYPE_A, "IP1", /* Initiate P1 */ + WMOP_ISD, TYPE_A, "ISD", /* Interger Store Destructive */ + WMOP_LEQ, TYPE_A, "LEQ", /* B Less Than or Equal to A */ + WMOP_BBW, TYPE_A, "BBW", /* Banch Backward Conditional */ + WMOP_IP2, TYPE_A, "IP2", /* Initiate P2 */ + WMOP_ISN, TYPE_A, "ISN", /* Integer Store Non-Destructive */ + WMOP_LSS, TYPE_A, "LSS", /* B Less Than A */ + WMOP_BFW, TYPE_A, "BFW", /* Branch Forward Unconditional */ + WMOP_IIO, TYPE_A, "IIO", /* Initiate I/O */ + WMOP_EQL, TYPE_A, "EQL", /* B Equal A */ + WMOP_SSP, TYPE_A, "SSP", /* Reset Sign Bit */ + WMOP_CMN, TYPE_A, "CMN", /* Enter Character Mode In Line */ + WMOP_IFT, TYPE_A, "IFT", /* Test Initiate */ + WMOP_CTC, TYPE_A, "CTC", /* Transfer Core Field to Core Field */ + WMOP_LBU, TYPE_A, "LBU", /* Word Branch Backward Unconditional */ + WMOP_LFU, TYPE_A, "LFU", /* Word Branch Forward Unconditional */ + WMOP_TIO, TYPE_A, "TIO", /* Interrogate I/O Channels */ + WMOP_RDV, TYPE_A, "RDV", /* Remainder Divide */ + WMOP_FBS, TYPE_A, "FBS", /* Flag Bit Search */ + WMOP_CTF, TYPE_A, "CTF", /* Transfer Core Field to F Field */ + WMOP_ISO, TYPE_B, "ISO", /* Variable Field Isolate XX */ + WMOP_CBD, TYPE_C, "CBD", /* Non-Zero Field Branch Backward Destructive Xy */ + WMOP_CBN, TYPE_C, "CBN", /* Non-Zero Field Branch Backward Non-Destructive Xy */ + WMOP_CFD, TYPE_C, "CFD", /* Non-Zero Field Branch Forward Destructive Xy */ + WMOP_CFN, TYPE_B, "CFN", /* Non-Zero Field Branch Forward Non-Destructive Xy */ + WMOP_DIA, TYPE_B, "DIA", /* Dial A XX */ + WMOP_DIB, TYPE_B, "DIB", /* Dial B XX Upper 6 not Zero */ + WMOP_TRB, TYPE_B, "TRB", /* Transfer Bits XX */ + WMOP_FCL, TYPE_B, "FCL", /* Compare Field Low XX */ + WMOP_FCE, TYPE_B, "FCE", /* Compare Field Equal XX */ + {0, 0, NULL}, +}; + +t_opcode char_ops[] = { +/* Character Mode */ + CMOP_EXC, TYPE_A, "EXC", /* Exit Character Mode */ + CMOP_CMX, TYPE_A, "CMX", /* Exit Character Mode In Line */ + CMOP_BSD, TYPE_B, "BSD", /* Skip Bit Destiniation */ + CMOP_BSS, TYPE_B, "BSS", /* SKip Bit Source */ + CMOP_RDA, TYPE_B, "RDA", /* Recall Destination Address */ + CMOP_TRW, TYPE_B, "TRW", /* Transfer Words */ + CMOP_SED, TYPE_B, "SED", /* Set Destination Address */ + CMOP_TDA, TYPE_B, "TDA", /* Transfer Destination Address */ + CMOP_TBN, TYPE_B, "TBN", /* Transfer Blanks for Non-Numerics */ + WMOP_ITI, TYPE_A, "ITI", /* Interrogate interrupt */ + WMOP_SFI, TYPE_A, "SFI", /* Store for Interrupt */ + WMOP_SFT, TYPE_A, "SFT", /* Store for Test */ + WMOP_ZP1, TYPE_A, "ZP1", /* Conditional Halt */ + WMOP_HP2, TYPE_A, "HP2", /* Halt P2 */ + CMOP_SDA, TYPE_B, "SDA", /* Store Destination Address */ + CMOP_SSA, TYPE_B, "SSA", /* Store Source Address */ + CMOP_SFD, TYPE_B, "SFD", /* Skip Forward Destination */ + CMOP_SRD, TYPE_B, "SRD", /* Skip Reverse Destination */ + CMOP_SES, TYPE_B, "SES", /* Set Source Address */ + CMOP_TEQ, TYPE_B, "TEQ", /* Test for Equal */ + CMOP_TNE, TYPE_B, "TNE", /* Test for Not-Equal */ + CMOP_TEG, TYPE_B, "TEG", /* Test for Greater Or Equal */ + CMOP_TGR, TYPE_B, "TGR", /* Test For Greater */ + CMOP_SRS, TYPE_B, "SRS", /* Skip Reverse Source */ + CMOP_SFS, TYPE_B, "SFS", /* Skip Forward Source */ + CMOP_TEL, TYPE_B, "TEL", /* Test For Equal or Less */ + CMOP_TLS, TYPE_B, "TLS", /* Test For Less */ + CMOP_TAN, TYPE_B, "TAN", /* Test for Alphanumeric */ + CMOP_BIT, TYPE_B, "BIT", /* Test Bit */ + CMOP_INC, TYPE_B, "INC", /* Increase Tally */ + CMOP_STC, TYPE_B, "STC", /* Store Tally */ + CMOP_SEC, TYPE_B, "SEC", /* Set Tally */ + CMOP_CRF, TYPE_B, "CRF", /* Call repeat Field */ + CMOP_JNC, TYPE_B, "JNC", /* Jump Out Of Loop Conditional */ + CMOP_JFC, TYPE_B, "JFC", /* Jump Forward Conditional */ + CMOP_JNS, TYPE_B, "JNS", /* Jump out of loop unconditional */ + CMOP_JFW, TYPE_B, "JFW", /* Jump Forward Unconditional */ + CMOP_RCA, TYPE_B, "RCA", /* Recall Control Address */ + CMOP_ENS, TYPE_B, "ENS", /* End Loop */ + CMOP_BNS, TYPE_B, "BNS", /* Begin Loop */ + CMOP_RSA, TYPE_B, "RSA", /* Recall Source Address */ + CMOP_SCA, TYPE_B, "SCA", /* Store Control Address */ + CMOP_JRC, TYPE_B, "JRC", /* Jump Reverse Conditional */ + CMOP_TSA, TYPE_B, "TSA", /* Transfer Source Address */ + CMOP_JRV, TYPE_B, "JRV", /* Jump Reverse Unconditional */ + CMOP_CEQ, TYPE_B, "CEQ", /* Compare Equal */ + CMOP_CNE, TYPE_B, "CNE", /* COmpare for Not Equal */ + CMOP_CEG, TYPE_B, "CEG", /* Compare For Greater Or Equal */ + CMOP_CGR, TYPE_B, "CGR", /* Compare For Greater */ + CMOP_BIS, TYPE_B, "BIS", /* Set Bit */ + CMOP_BIR, TYPE_B, "BIR", /* Reet Bit */ + CMOP_OCV, TYPE_B, "OCV", /* Output Convert */ + CMOP_ICV, TYPE_B, "ICV", /* Input Convert */ + CMOP_CEL, TYPE_B, "CEL", /* Compare For Equal or Less */ + CMOP_CLS, TYPE_B, "CLS", /* Compare for Less */ + CMOP_FSU, TYPE_B, "FSU", /* Field Subtract */ + CMOP_FAD, TYPE_B, "FAD", /* Field Add */ + CMOP_TRP, TYPE_B, "TRP", /* Transfer Program Characters */ + CMOP_TRN, TYPE_B, "TRN", /* Transfer Numeric */ + CMOP_TRZ, TYPE_B, "TRZ", /* Transfer Zones */ + CMOP_TRS, TYPE_B, "TRS", /* Transfer Source Characters */ + {0, 0, NULL}, +}; + + +/* Print out an instruction */ +void +print_opcode(FILE * of, t_value val, t_opcode * tab) +{ + uint16 op; + + op = val; + while (tab->name != NULL) { + switch(tab->type) { + case TYPE_A: + if (op != tab->op) + break; + fputs(tab->name, of); + fputs(" ",of); + return; + case TYPE_B: + if ((op & 077) != tab->op) + break; + fputs(tab->name, of); + fputc(' ',of); + fputc(' ',of); + fprint_val(of, (val >> 6), 8, 6, 0); + fputs(" ",of); + return; + case TYPE_C: + if ((op & 0377) != tab->op) + break; + fputs(tab->name, of); + fputc(' ',of); + fprint_val(of, (val >> 8), 8, 4, 0); + fputs(" ",of); + return; + case TYPE_D: + if ((op & 03) != tab->op) + break; + fputs(tab->name, of); + fputc(' ',of); + fprint_val(of, (val >> 2), 8, 10, 0); + fputc(' ',of); + return; + } + tab++; + } + fprintf(of, "*%04o uuo ", op); +} + +/* 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) +{ + t_value inst = *val; + int i; + + fputc(' ', of); + fprint_val(of, inst, 8, 48, PV_RZRO); + + if (sw & SWMASK('W')) { /* Word mode opcodes */ + fputs(" ", of); + for (i = 36; i >= 0; i-=12) { + int op = (int)(inst >> i) & 07777; + print_opcode(of, op, word_ops); + } + } + if (sw & SWMASK('C')) { /* Char mode opcodes */ + fputs(" ", of); + for (i = 36; i >= 0; i-=12) { + int op = (int)(inst >> i) & 07777; + print_opcode(of, op, char_ops); + } + } + if (sw & SWMASK('B')) { /* BCD mode */ + fputs(" '", of); + for (i = 42; i >= 0; i-=6) { + int ch; + + ch = (int)(inst >> i) & 077; + fputc(mem_to_ascii[ch], of); + } + fputc('\'', of); + } + if (sw & SWMASK('F')) { /* Floating point/Descriptor */ + } + return SCPE_OK; +} + +t_opcode * +find_opcode(char *op, t_opcode * tab) +{ + while (tab->name != NULL) { + if (*tab->name != '\0' && strcmp(op, tab->name) == 0) + return tab; + tab++; + } + return NULL; +} + +/* 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) +{ + int i; + t_value d; + int opr; + char opcode[100]; + + while (isspace(*cptr)) + cptr++; + d = 0; + if (sw & (SWMASK('W')|SWMASK('C'))) { + t_opcode *op; + + /* Grab opcode */ + cptr = get_glyph(cptr, opcode, 0); + + op = 0; + opr = -1; + if((op = find_opcode(opcode, + (SWMASK('W') ? word_ops : char_ops))) == 0) { + return SCPE_UNK; + } + + while (*cptr == ' ' || *cptr == '\t') + cptr++; + /* Collect first argument if there is one */ + while (*cptr >= '0' && *cptr <= '7') + opr = (opr << 3) + (*cptr++ - '0'); + /* Skip blanks */ + while (*cptr == ' ' || *cptr == '\t') + cptr++; + switch (op->type) { + case TYPE_A: + if (opr >= 0) + return SCPE_2MARG; + *val = op->op; + return SCPE_OK; + + case TYPE_B: + if (opr < 0 || opr > 64) + return SCPE_ARG; + *val = (opr << 6) | op->op; + return SCPE_OK; + + case TYPE_C: + if (opr < 0 || opr > 16) + return SCPE_ARG; + *val = (opr << 8) | op->op; + return SCPE_OK; + + case TYPE_D: + if (opr < 0 || opr > 1024) + return SCPE_ARG; + *val = (opr << 2) | op->op; + return SCPE_OK; + } + } else if (sw & SWMASK('B')) { + i = 0; + while (*cptr != '\0' && i < 8) { + d <<= 6; + d |= (int)sim_ascii_to_six[0177 & *cptr]; + cptr++; + i++; + } + d <<= 6 * (8 - i); + } else { + while (*cptr >= '0' && *cptr <= '7') { + d <<= 3; + d |= *cptr++ - '0'; + } + } + *val = d; + return SCPE_OK; + +/* Symbolic input, continued */ + + if (*cptr != 0) + return SCPE_ARG; /* junk at end? */ + return SCPE_OK; +} diff --git a/B5500/b5500_urec.c b/B5500/b5500_urec.c new file mode 100644 index 0000000..cf59744 --- /dev/null +++ b/B5500/b5500_urec.c @@ -0,0 +1,1007 @@ +/* b5500_urec.c: Burrioughs 5500 Unit record devices. + + Copyright (c) 2016, Richard Cornwell + + 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 + RICHARD CORNWELL 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. + + This is the standard card reader. 10,14 + This is the standard card punch. 10 + This is the standard line printer. 22,26 + This is the standard operators console. 30 + +*/ + +#include "b5500_defs.h" +#include "sim_card.h" +#include "sim_defs.h" +#include "sim_console.h" + +#define UNIT_CDR UNIT_ATTABLE | UNIT_RO | UNIT_DISABLE | UNIT_ROABLE | \ + MODE_029 +#define UNIT_CDP UNIT_ATTABLE | UNIT_DISABLE | MODE_029 +#define UNIT_LPR UNIT_ATTABLE | UNIT_DISABLE + +/* For Card reader, when set returns end of file at end of deck. */ +/* Reset after sent to system */ +#define MODE_EOF (0x40 << UNIT_V_MODE) + + + +/* std devices. data structures + + cdr_dev Card Reader device descriptor + cdr_unit Card Reader unit descriptor + cdr_reg Card Reader register list + cdr_mod Card Reader modifiers list +*/ + +/* Device status information stored in u5 */ +#define URCSTA_CHMASK 0003 /* Mask of I/O channel to send data on */ +#define URCSTA_CARD 0004 /* Unit has card in buffer */ +#define URCSTA_FULL 0004 /* Unit has full buffer */ +#define URCSTA_BUSY 0010 /* Device is busy */ +#define URCSTA_BIN 0020 /* Card reader in binary mode */ +#define URCSTA_ACTIVE 0040 /* Unit is active */ +#define URCSTA_EOF 0100 /* Flag the end of file */ +#define URCSTA_INPUT 0200 /* Console fill buffer from keyboard */ +#define URCSTA_FILL 010000 /* Fill unit buffer */ +#define URCSTA_CMD_V 16 + +#define URCSTA_SKIP 000017 /* Skip mask */ +#define URCSTA_DOUBLE 000020 /* Double space skip */ +#define URCSTA_SINGLE 000040 /* Single space skip. */ +#define URCSTA_READ 000400 /* Read flag */ +#define URCSTA_WC 001000 /* Use word count */ +#define URCSTA_DIRECT 002000 /* Direction, Long line */ +#define URCSTA_BINARY 004000 /* Binary transfer */ +#define URCSTA_INHIBIT 040000 /* Inhibit transfer to memory */ + +/* Simulator debug controls */ +DEBTAB cdr_debug[] = { + {"CMD", DEBUG_CMD, "Show command execution to devices"}, + {"DATA", DEBUG_DATA, "Show data transfers"}, + {"DETAIL", DEBUG_DETAIL, "Show details about device"}, + {"EXP", DEBUG_EXP, "Show console data"}, + {"CARD", DEBUG_CARD, "Show Card read/punches"}, + {0, 0} +}; + + +#if NUM_DEVS_CDR > 0 +t_stat cdr_boot(int32, DEVICE *); +t_stat cdr_srv(UNIT *); +t_stat cdr_attach(UNIT *, CONST char *); +t_stat cdr_detach(UNIT *); +t_stat cdr_help(FILE *, DEVICE *, UNIT *, int32, const char *); +const char *cdr_description(DEVICE *dptr); +#endif + +#if NUM_DEVS_CDP > 0 +t_stat cdp_srv(UNIT *); +t_stat cdp_attach(UNIT *, CONST char *); +t_stat cdp_detach(UNIT *); +t_stat cdp_help(FILE *, DEVICE *, UNIT *, int32, const char *); +const char *cdp_description(DEVICE *dptr); +#endif + +#if NUM_DEVS_LPR > 0 +struct _lpr_data +{ + uint8 lbuff[145]; /* Output line buffer */ +} +lpr_data[NUM_DEVS_LPR]; + +t_stat lpr_srv(UNIT *); +t_stat lpr_attach(UNIT *, CONST char *); +t_stat lpr_detach(UNIT *); +t_stat lpr_setlpp(UNIT *, int32, CONST char *, void *); +t_stat lpr_getlpp(FILE *, UNIT *, int32, CONST void *); +t_stat lpr_help(FILE *, DEVICE *, UNIT *, int32, const char *); +const char *lpr_description(DEVICE *dptr); +#endif + +#if NUM_DEVS_CON > 0 +struct _con_data +{ + uint8 ibuff[145]; /* Input line buffer */ + uint8 inptr; + uint8 outptr; +} +con_data[NUM_DEVS_CON]; + +t_stat con_ini(DEVICE *); +t_stat con_srv(UNIT *); +t_stat con_attach(UNIT *, CONST char *); +t_stat con_detach(UNIT *); +t_stat con_help(FILE *, DEVICE *, UNIT *, int32, const char *); +const char *con_description(DEVICE *dptr); +#endif + + + +#if NUM_DEVS_CDR > 0 +UNIT cdr_unit[] = { + {UDATA(cdr_srv, UNIT_CDR, 0)}, /* A */ +#if NUM_DEVS_CDR > 1 + {UDATA(cdr_srv, UNIT_CDR|UNIT_DIS, 0)}, /* B */ +#endif +}; + +MTAB cdr_mod[] = { + {MTAB_XTD | MTAB_VUN, 0, "FORMAT", "FORMAT", + &sim_card_set_fmt, &sim_card_show_fmt, NULL, + "Sets card format"}, + {MODE_EOF, MODE_EOF, "EOF", "EOF", NULL, NULL, NULL, + "Causes EOF to be set when reader empty"}, + {0} +}; + +DEVICE cdr_dev = { + "CR", cdr_unit, NULL, cdr_mod, + NUM_DEVS_CDR, 8, 15, 1, 8, 8, + NULL, NULL, NULL, &cdr_boot, &cdr_attach, &cdr_detach, + NULL, DEV_DISABLE | DEV_DEBUG, 0, cdr_debug, + NULL, NULL, &cdr_help, NULL, NULL, + &cdr_description +}; +#endif + +#if NUM_DEVS_CDP > 0 +UNIT cdp_unit[] = { + {UDATA(cdp_srv, UNIT_CDP, 0)}, /* A */ +}; + +MTAB cdp_mod[] = { + {MTAB_XTD | MTAB_VUN, 0, "FORMAT", "FORMAT", + &sim_card_set_fmt, &sim_card_show_fmt, NULL, + "Sets card format"}, + {0} +}; + +DEVICE cdp_dev = { + "CP", cdp_unit, NULL, cdp_mod, + NUM_DEVS_CDP, 8, 15, 1, 8, 8, + NULL, NULL, NULL, NULL, &cdp_attach, &cdp_detach, + NULL, DEV_DISABLE | DEV_DEBUG, 0, cdr_debug, + NULL, NULL, &cdp_help, NULL, NULL, + &cdp_description +}; + +#endif + +#if NUM_DEVS_LPR > 0 +UNIT lpr_unit[] = { + {UDATA(lpr_srv, UNIT_LPR, 59)}, /* A */ +#if NUM_DEVS_LPR > 1 + {UDATA(lpr_srv, UNIT_LPR|UNIT_DIS, 59)}, /* B */ +#endif +}; + +MTAB lpr_mod[] = { + {MTAB_XTD|MTAB_VUN|MTAB_VALR, 0, "LINESPERPAGE", "LINESPERPAGE", + &lpr_setlpp, &lpr_getlpp, NULL, + "Sets number of lines on a printed page"}, + {0} +}; + +DEVICE lpr_dev = { + "LP", lpr_unit, NULL, lpr_mod, + NUM_DEVS_LPR, 8, 15, 1, 8, 8, + NULL, NULL, NULL, NULL, &lpr_attach, &lpr_detach, + NULL, DEV_DISABLE | DEV_DEBUG, 0, dev_debug, + NULL, NULL, &lpr_help, NULL, NULL, + &lpr_description +}; +#endif + +#if NUM_DEVS_CON > 0 +UNIT con_unit[] = { + {UDATA(con_srv, 0, 0), 0}, /* A */ +}; + +DEVICE con_dev = { + "CON", con_unit, NULL, NULL, + NUM_DEVS_CON, 8, 15, 1, 8, 8, + NULL, NULL, con_ini, NULL, NULL, NULL, + NULL, DEV_DISABLE | DEV_DEBUG, 0, dev_debug, + NULL, NULL, &con_help, NULL, NULL, + &con_description +}; +#endif + + + +#if ((NUM_DEVS_CDR > 0) | (NUM_DEVS_CDP > 0)) +/* + * Device entry points for card reader. + * And Card punch. + */ +t_stat card_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr; + int u; + + if (dev == CARD1_DEV) + u = 0; + else if (dev == CARD2_DEV) + u = 1; + else + return SCPE_NXDEV; + /* Check if card reader or card punch */ + if (cmd & URCSTA_READ) { + uptr = &cdr_unit[u]; + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; + + /* Are we currently tranfering? */ + if (uptr->u5 & URCSTA_ACTIVE) + return SCPE_BUSY; + + /* Check if we ran out of cards */ + if (uptr->u5 & URCSTA_EOF) { + /* If end of file, return to system */ + if (uptr->flags & MODE_EOF) { + sim_debug(DEBUG_DETAIL, &cdr_dev, "cdr %d %d report eof\n", u, + chan); + chan_set_eof(chan); + uptr->flags &= ~MODE_EOF; + } + /* Clear unit ready */ + iostatus &= ~(CARD1_FLAG << u); + return SCPE_UNATT; + } + + if (cmd & URCSTA_BINARY) { + uptr->u5 |= URCSTA_BIN; + *wc = 20; + } else { + uptr->u5 &= ~URCSTA_BIN; + *wc = 10; + } + + uptr->u5 &= ~URCSTA_CHMASK; + uptr->u5 |= URCSTA_ACTIVE|chan; + uptr->u4 = 0; + + sim_activate(uptr, 500000); + return SCPE_OK; + } else { + /* Talking to punch */ + if (u != 0) + return SCPE_NXDEV; + sim_debug(DEBUG_DETAIL, &cdr_dev, "cdp %d %d start\n", u, chan); + uptr = &cdp_unit[0]; + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; + if (uptr->u5 & URCSTA_ACTIVE) + return SCPE_BUSY; + uptr->u5 &= ~URCSTA_CHMASK; + uptr->u5 |= URCSTA_ACTIVE|chan; + uptr->u4 = 0; + *wc = 10; + + sim_activate(uptr, 500000); + sim_debug(DEBUG_DETAIL, &cdr_dev, "cdp %d %d go\n", u, chan); + return SCPE_OK; + } + return SCPE_IOERR; +} + +/* Handle transfer of data for card reader */ +t_stat +cdr_srv(UNIT *uptr) { + int chan = URCSTA_CHMASK & uptr->u5; + int u = (uptr - cdr_unit); + + if (uptr->u5 & URCSTA_EOF) { + sim_debug(DEBUG_DETAIL, &cdr_dev, "cdr %d %d unready\n", u, chan); + iostatus &= ~(CARD1_FLAG << u); + uptr->u5 &= ~ URCSTA_EOF; + return SCPE_OK; + } + + + /* Check if new card requested. */ + if (uptr->u4 == 0 && uptr->u5 & URCSTA_ACTIVE && + (uptr->u5 & URCSTA_CARD) == 0) { + switch(sim_read_card(uptr)) { + case SCPE_UNATT: + iostatus &= ~(CARD1_FLAG << u); + uptr->u5 &= ~(URCSTA_ACTIVE); + iostatus &= ~(CARD1_FLAG << u); + chan_set_notrdy(chan); + break; + case SCPE_EOF: + /* If end of file, return to system */ + if (uptr->flags & MODE_EOF) { + sim_debug(DEBUG_DETAIL, &cdr_dev, "cdr %d %d set eof\n", u, chan); + chan_set_eof(chan); + uptr->flags &= ~MODE_EOF; + } + uptr->u5 &= ~(URCSTA_ACTIVE); + uptr->u5 |= URCSTA_EOF; + chan_set_notrdy(chan); + sim_activate(uptr, 500); + break; + case SCPE_IOERR: + chan_set_error(chan); + uptr->u5 &= ~(URCSTA_ACTIVE); + uptr->u5 |= URCSTA_EOF; + chan_set_end(chan); + break; + case SCPE_OK: + uptr->u5 |= URCSTA_CARD; + sim_activate(uptr, 500); + break; + } + return SCPE_OK; + } + + + /* Copy next column over */ + if (uptr->u5 & URCSTA_CARD && + uptr->u4 <= ((uptr->u5 & URCSTA_BIN) ? 160 : 80)) { + struct _card_data *data; + uint8 ch = 0; + int u = (uptr - cdr_unit); + + data = (struct _card_data *)uptr->up7; + + if (uptr->u5 & URCSTA_BIN) { + ch = (data->image[uptr->u4 >> 1] >> + ((uptr->u4 & 1)? 0 : 6)) & 077; + } else { + ch = sim_hol_to_bcd(data->image[uptr->u4]); + /* Remap some characters from 029 to BCL */ + switch(ch) { + case 0: ch = 020; break; /* Translate blanks */ + case 10: /* Check if 0 punch of 82 punch */ + if (data->image[uptr->u4] != 0x200) { + ch = 0; + if (uptr->u4 == 0) + chan_set_parity(chan); + } + break; + case 0111: + ch = 0; + /* Handle invalid punch */ + chan_set_parity(chan); + break; /* Translate ? to error*/ + } + } + if(chan_write_char(chan, &ch, 0)) { + uptr->u5 &= ~(URCSTA_ACTIVE|URCSTA_CARD); + chan_set_end(chan); + /* Drop ready a bit after the last card is read */ + if (sim_card_eof(uptr)) { + uptr->u5 |= URCSTA_EOF; + sim_activate(uptr, 100); + } + } else { + uptr->u4++; + sim_activate(uptr, 100); + } + sim_debug(DEBUG_DATA, &cdr_dev, "cdr %d: Char > %03o '%c' %d\n", u, ch, + sim_six_to_ascii[ch & 077], uptr->u4); + } + return SCPE_OK; +} + +/* Boot from given device */ +t_stat +cdr_boot(int32 unit_num, DEVICE * dptr) +{ + UNIT *uptr = &dptr->units[unit_num]; + uint8 dev; + t_uint64 desc; + + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; /* attached? */ + dev = (uptr == &cdr_unit[0]) ? CARD1_DEV : CARD2_DEV; + uptr->u5 &= ~URCSTA_ACTIVE; + desc = ((t_uint64)dev) << DEV_V | DEV_IORD| DEV_BIN | 020LL; + /* Read in one record */ + return chan_boot(desc); +} + +t_stat +cdr_attach(UNIT * uptr, CONST char *file) +{ + t_stat r; + int u = uptr-cdr_unit; + + if ((r = sim_card_attach(uptr, file)) != SCPE_OK) + return r; + uptr->u5 &= URCSTA_BUSY; + uptr->u4 = 0; + uptr->u6 = 0; + iostatus |= (CARD1_FLAG << u); + return SCPE_OK; +} + +t_stat +cdr_detach(UNIT * uptr) +{ + int u = uptr-cdr_unit; + + iostatus &= ~(CARD1_FLAG << u); + return sim_card_detach(uptr); +} + +t_stat +cdr_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B124 Card Reader\n\n"); + fprintf (st, "The system supports up to two card readers, the second one is disabled\n"); + fprintf (st, "by default. To have the card reader return the EOF flag when the deck\n"); + fprintf (st, "has finished reading do:\n"); + fprintf (st, " sim> SET CRn EOF\n"); + fprintf (st, "This flag is cleared each time a deck has been read, so it must be set\n"); + fprintf (st, "again after each deck. MCP does not require this to be set as long as\n"); + fprintf (st, "the deck includes a ?END card\n"); + fprint_set_help(st, dptr); + fprint_show_help(st, dptr); + return SCPE_OK; +} + +const char * +cdr_description(DEVICE *dptr) +{ + return "B124 Card Reader"; +} + +#endif + + + +#if NUM_DEVS_CDR > 0 | NUM_DEVS_CDP > 0 + +/* Handle transfer of data for card punch */ +t_stat +cdp_srv(UNIT *uptr) { + int chan = URCSTA_CHMASK & uptr->u5; + int u = (uptr - cdp_unit); + + if (uptr->u5 & URCSTA_BUSY) { + /* Done waiting, punch card */ + if (uptr->u5 & URCSTA_FULL) { + sim_debug(DEBUG_DETAIL, &cdp_dev, "cdp %d %d punch\n", u, chan); + switch(sim_punch_card(uptr, NULL)) { + case SCPE_EOF: + case SCPE_UNATT: + sim_debug(DEBUG_DETAIL, &cdp_dev, "cdp %d %d set eof\n", u, + chan); + chan_set_eof(chan); + break; + /* If we get here, something is wrong */ + case SCPE_IOERR: + chan_set_error(chan); + break; + case SCPE_OK: + break; + } + uptr->u5 &= ~URCSTA_FULL; + chan_set_end(chan); + } + uptr->u5 &= ~URCSTA_BUSY; + } + + /* Copy next column over */ + if (uptr->u5 & URCSTA_ACTIVE && uptr->u4 <= 80) { + struct _card_data *data; + uint8 ch = 0; + + data = (struct _card_data *)uptr->up7; + + if(chan_read_char(chan, &ch, 0)) { + uptr->u5 |= URCSTA_BUSY|URCSTA_FULL; + uptr->u5 &= ~URCSTA_ACTIVE; + } else { + sim_debug(DEBUG_DATA, &cdp_dev, "cdp %d: Char %d < %02o\n", u, + uptr->u4, ch); + data->image[uptr->u4++] = sim_bcd_to_hol(ch & 077); + } + sim_activate(uptr, 10); + } + return SCPE_OK; +} + + +t_stat +cdp_attach(UNIT * uptr, CONST char *file) +{ + t_stat r; + + if ((r = sim_card_attach(uptr, file)) != SCPE_OK) + return r; + uptr->u5 = 0; + iostatus |= PUNCH_FLAG; + return SCPE_OK; +} + +t_stat +cdp_detach(UNIT * uptr) +{ + if (uptr->u5 & URCSTA_FULL) + sim_punch_card(uptr, NULL); + iostatus &= ~PUNCH_FLAG; + return sim_card_detach(uptr); +} + +t_stat +cdp_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B303 Card Punch\n\n"); + fprintf (st, "The B303 Card Punch is only capable of punching text decks, binary decks\n"); + fprintf (st, "where not supported.\n"); + fprint_set_help(st, dptr); + fprint_show_help(st, dptr); + return SCPE_OK; +} + +const char * +cdp_description(DEVICE *dptr) +{ + return "B303 Card Punch"; +} + +#endif + + +/* Line printer routines +*/ + +#if NUM_DEVS_LPR > 0 +t_stat +lpr_setlpp(UNIT *uptr, int32 val, CONST char *cptr, void *desc) +{ + int i; + if (cptr == NULL) + return SCPE_ARG; + if (uptr == NULL) + return SCPE_IERR; + i = 0; + while(*cptr != '\0') { + if (*cptr < '0' || *cptr > '9') + return SCPE_ARG; + i = (i * 10) + (*cptr++) - '0'; + } + if (i < 20 || i > 100) + return SCPE_ARG; + uptr->capac = i; + uptr->u4 = 0; + return SCPE_OK; +} + +t_stat +lpr_getlpp(FILE *st, UNIT *uptr, int32 v, CONST void *desc) +{ + if (uptr == NULL) + return SCPE_IERR; + fprintf(st, "linesperpage=%d", uptr->capac); + return SCPE_OK; +} + +void +print_line(UNIT * uptr, int unit) +{ +/* Convert word record into column image */ +/* Check output type, if auto or text, try and convert record to bcd first */ +/* If failed and text report error and dump what we have */ +/* Else if binary or not convertable, dump as image */ + + char out[150]; /* Temp conversion buffer */ + int i; + int chan = uptr->u5 & URCSTA_CHMASK; + + if ((uptr->flags & (UNIT_ATT)) == 0) + return; /* attached? */ + + if (uptr->u3 > 0) { + /* Try to convert to text */ + memset(out, 0, sizeof(out)); + + /* Scan each column */ + for (i = 0; i < uptr->u3; i++) { + int bcd = lpr_data[unit].lbuff[i] & 077; + + out[i] = con_to_ascii[bcd]; + } + + /* Trim trailing spaces */ + for (--i; i > 0 && out[i] == ' '; i--) ; + out[i+1] = '\0'; + + sim_debug(DEBUG_DETAIL, &lpr_dev, "lpr print %s\n", out); + if (uptr->u5 & (URCSTA_DOUBLE << URCSTA_CMD_V)) { + out[++i] = '\r'; + out[++i] = '\n'; + uptr->u4 ++; + } + out[++i] = '\r'; + out[++i] = '\n'; + uptr->u4++; + out[++i] = '\0'; + + /* Print out buffer */ + sim_fwrite(&out, 1, i, uptr->fileref); + uptr->u5 &= ~URCSTA_EOF; + } + + + switch ((uptr->u5 >> URCSTA_CMD_V) & URCSTA_SKIP) { + case 0: /* No special skip */ + break; + case 1: + case 2: /* Skip to top of form */ + case 12: + uptr->u4 = uptr->capac+1; + break; + + case 3: /* Even lines */ + if ((uptr->u4 & 1) == 1) { + sim_fwrite("\r", 1, 1, uptr->fileref); + sim_fwrite("\n", 1, 1, uptr->fileref); + uptr->u4++; + uptr->u5 &= ~URCSTA_EOF; + } + break; + case 4: /* Odd lines */ + if ((uptr->u4 & 1) == 0) { + sim_fwrite("\r", 1, 1, uptr->fileref); + sim_fwrite("\n", 1, 1, uptr->fileref); + uptr->u4++; + uptr->u5 &= ~URCSTA_EOF; + } + break; + case 5: /* Half page */ + while((uptr->u4 != (uptr->capac/2)) || + (uptr->u4 != (uptr->capac))) { + sim_fwrite("\r", 1, 1, uptr->fileref); + sim_fwrite("\n", 1, 1, uptr->fileref); + uptr->u4++; + if (((uint32)uptr->u4) > uptr->capac) { + uptr->u4 = 1; + break; + } + uptr->u5 &= ~URCSTA_EOF; + } + break; + case 6: /* 1/4 Page */ + while((uptr->u4 != (uptr->capac/4)) || + (uptr->u4 != (uptr->capac/2)) || + (uptr->u4 != (uptr->capac/2+uptr->capac/4)) || + (uptr->u4 != (uptr->capac))) { + sim_fwrite("\r", 1, 1, uptr->fileref); + sim_fwrite("\n", 1, 1, uptr->fileref); + uptr->u4++; + if (((uint32)uptr->u4) > uptr->capac) { + uptr->u4 = 1; + break; + } + uptr->u5 &= ~URCSTA_EOF; + } + break; + case 7: /* User defined, now 1 line */ + case 8: + case 9: + case 10: + case 11: + sim_fwrite("\r", 1, 1, uptr->fileref); + sim_fwrite("\n", 1, 1, uptr->fileref); + uptr->u4++; + break; + } + + + if (((uint32)uptr->u4) > uptr->capac) { + uptr->u4 = 1; + uptr->u5 |= URCSTA_EOF; + sim_fwrite("\f", 1, 1, uptr->fileref); + sim_fseek(uptr->fileref, 0, SEEK_CUR); + sim_debug(DEBUG_DETAIL, &lpr_dev, "lpr %d page\n", unit); + } + +} + + + +t_stat lpr_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr; + int u; + + if (dev == PRT1_DEV) + u = 0; + else if (dev == PRT2_DEV) + u = 1; + else + return SCPE_NXDEV; + uptr = &lpr_unit[u]; + + /* Are we currently tranfering? */ + if (uptr->u5 & URCSTA_BUSY) + return SCPE_BUSY; + + if ((uptr->flags & UNIT_ATT) == 0) + return SCPE_UNATT; + + if (*wc == 0 && (cmd & URCSTA_INHIBIT) == 0) + *wc = (cmd & URCSTA_DIRECT) ? 17 : 15; + + /* Remember not to drop the FULL */ + uptr->u5 &= ~((077 << URCSTA_CMD_V) | URCSTA_CHMASK); + uptr->u5 |= URCSTA_BUSY|chan; + uptr->u5 |= (cmd & (URCSTA_SKIP|URCSTA_SINGLE|URCSTA_DOUBLE)) + << URCSTA_CMD_V; + uptr->u3 = 0; + sim_debug(DEBUG_CMD, &lpr_dev, "%d: Cmd WRS %d %02o %o\n", u, chan, + cmd & (URCSTA_SKIP|URCSTA_SINGLE|URCSTA_DOUBLE),uptr->u5); + sim_activate(uptr, 100); + return SCPE_OK; +} + +/* Handle transfer of data for printer */ +t_stat +lpr_srv(UNIT *uptr) { + int chan = URCSTA_CHMASK & uptr->u5; + int u = (uptr - lpr_unit); + + if (uptr->u5 & URCSTA_FULL) { + sim_debug(DEBUG_CMD, &lpr_dev, "lpr %d: done\n", u); + uptr->u5 &= ~URCSTA_FULL; + IAR |= (IRQ_3 << u); + } + + /* Copy next column over */ + if ((uptr->u5 & URCSTA_BUSY) != 0) { + if(chan_read_char(chan, &lpr_data[u].lbuff[uptr->u3], 0)) { + /* Done waiting, print line */ + print_line(uptr, u); + memset(&lpr_data[u].lbuff[0], 0, 144); + uptr->u5 |= URCSTA_FULL; + uptr->u5 &= ~URCSTA_BUSY; + chan_set_wc(chan, (uptr->u3/8)); + chan_set_end(chan); + sim_activate(uptr, 20000); + return SCPE_OK; + } else { + sim_debug(DEBUG_DATA, &lpr_dev, "lpr %d: Char < %02o\n", u, + lpr_data[u].lbuff[uptr->u3]); + uptr->u3++; + } + sim_activate(uptr, 50); + } + return SCPE_OK; +} + +t_stat +lpr_attach(UNIT * uptr, CONST char *file) +{ + t_stat r; + int u = (uptr - lpr_unit); + + if ((r = attach_unit(uptr, file)) != SCPE_OK) + return r; + uptr->u5 = 0; + uptr->u4 = 0; + uptr->u3 = 0; + iostatus |= PRT1_FLAG << u; + return SCPE_OK; +} + +t_stat +lpr_detach(UNIT * uptr) +{ + int u = (uptr - lpr_unit); + if (uptr->u5 & URCSTA_FULL) + print_line(uptr, u); + iostatus &= ~(PRT1_FLAG << u); + return detach_unit(uptr); +} + +t_stat +lpr_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "B320 Line Printer\n\n"); + fprintf (st, "The system supports up to two line printers, the second one is disabled\n"); + fprintf (st, "by default. The B320 Line printer can be configured to any number of\n"); + fprintf (st, "lines per page with the:\n"); + fprintf (st, " sim> SET LPn LINESPERPAGE=n\n\n"); + fprintf (st, "The default is 59 lines per page. The Line Printer has the following\n"); + fprintf (st, "control tape attached.\n"); + fprintf (st, " Channel 1: Skip to top of page\n"); + fprintf (st, " Channel 2: Skip to top of page\n"); + fprintf (st, " Channel 3: Skip to next even line\n"); + fprintf (st, " Channel 4: Skip to next odd line\n"); + fprintf (st, " Channel 5: Skip to middle or top of page\n"); + fprintf (st, " Channel 6: Skip 1/4 of page\n"); + fprintf (st, " Channel 7: Skip one linee\n"); + fprintf (st, " Channel 8: Skip one linetop of page\n"); + fprintf (st, " Channel 9: Skip one linetop of page\n"); + fprintf (st, " Channel 10: Skip one linetop of page\n"); + fprintf (st, " Channel 11: Skip one linetop of page\n"); + fprintf (st, " Channel 12: Skip to top of page\n"); + fprint_set_help(st, dptr); + fprint_show_help(st, dptr); + return SCPE_OK; +} + +const char * +lpr_description(DEVICE *dptr) +{ + return "B320 Line Printer"; +} + +#endif + + + + +#if NUM_DEVS_CON > 0 +/* + * Console printer routines. + */ +t_stat +con_ini(DEVICE *dptr) { + UNIT *uptr = &con_unit[0]; + uptr->u5 = 0; + iostatus |= SPO_FLAG; + if (!sim_is_active(uptr)) + sim_activate(uptr, 1000); + return SCPE_OK; +} + +t_stat +con_cmd(uint16 cmd, uint16 dev, uint8 chan, uint16 *wc) +{ + UNIT *uptr = &con_unit[0]; + + /* Are we currently tranfering? */ + if (uptr->u5 & (URCSTA_READ|URCSTA_FILL|URCSTA_BUSY|URCSTA_INPUT)) + return SCPE_BUSY; + + if (cmd & URCSTA_READ) { + if (uptr->u5 & (URCSTA_INPUT|URCSTA_FILL)) + return SCPE_BUSY; + /* Activate input so we can get response */ + uptr->u5 = 0; + uptr->u5 |= URCSTA_INPUT|chan; + sim_putchar('I'); + sim_putchar(' '); + sim_debug(DEBUG_CMD, &con_dev, ": Cmd RDS\n"); + uptr->u3 = 0; + } else { + if (uptr->u5 & (URCSTA_INPUT|URCSTA_FILL)) + return SCPE_BUSY; + sim_putchar('R'); + sim_putchar(' '); + sim_debug(DEBUG_CMD, &con_dev, ": Cmd WRS\n"); + uptr->u5 = 0; + uptr->u5 |= URCSTA_FILL|chan; + uptr->u3 = 0; + } + return SCPE_OK; +} + +/* Handle transfer of data for printer */ +t_stat +con_srv(UNIT *uptr) { + t_stat r; + uint8 ch; + int chan = uptr->u5 & URCSTA_CHMASK; + + + uptr->u5 &= ~URCSTA_BUSY; /* Clear busy */ + + /* Copy next column over */ + if (uptr->u5 & URCSTA_FILL) { + if(chan_read_char(chan, &ch, 0)) { + sim_putchar('\r'); + sim_putchar('\n'); + sim_debug(DEBUG_EXP, &con_dev, "\n\r"); + uptr->u5 &= ~URCSTA_FILL; + chan_set_end(chan); + } else { + ch &= 077; + sim_debug(DEBUG_EXP, &con_dev, "%c", con_to_ascii[ch]); + sim_putchar((int32)con_to_ascii[ch]); + } + } + + if (uptr->u5 & URCSTA_READ) { + ch = con_data[0].ibuff[con_data[0].outptr++]; + + if(chan_write_char(chan, &ch, + (con_data[0].inptr == con_data[0].outptr))) { + sim_putchar('\r'); + sim_putchar('\n'); + sim_debug(DEBUG_EXP, &con_dev, "\n\r"); + uptr->u5 &= ~URCSTA_READ; + chan_set_end(chan); + } + } + + r = sim_poll_kbd(); + if (r & SCPE_KFLAG) { + ch = r & 0377; + if (uptr->u5 & URCSTA_INPUT) { + /* Handle end of buffer */ + switch (ch) { + case 033: + con_data[0].inptr = 0; + case '\r': + case '\n': + uptr->u5 &= ~URCSTA_INPUT; + uptr->u5 |= URCSTA_READ; + break; + case '\b': + case 0x7f: + if (con_data[0].inptr != 0) { + con_data[0].inptr--; + sim_putchar('\b'); + sim_putchar(' '); + sim_putchar('\b'); + } + break; + default: + if (con_data[0].inptr < sizeof(con_data[0].ibuff)) { + ch = ascii_to_con[0177&ch]; + if (ch == 0xff) { + sim_putchar('\007'); + break; + } + sim_putchar((int32)con_to_ascii[ch]); + con_data[0].ibuff[con_data[0].inptr++] = ch; + } + break; + } + } else { + if (ch == 033) { + IAR |= IRQ_2; + con_data[0].inptr = 0; + con_data[0].outptr = 0; + } + } + } + sim_activate(uptr, 1000); + return SCPE_OK; +} + +t_stat +con_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "Supervisory Printer\n\n"); + fprintf (st, "This is the interface from the operator to the system. The printer\n"); + fprintf (st, "operated in a half duplex mode. To request the system to accept input\n"); + fprintf (st, "press the key and wait until the system responds with a line with\n"); + fprintf (st, "I as the first character. When you have finished typing your line, press\n"); + fprintf (st, "return or enter key. Backspace will delete the last character.\n"); + fprintf (st, "All responses from the system are prefixed with a R and blank as the\n"); + fprintf (st, "first character\n"); + return SCPE_OK; +} + +const char * +con_description(DEVICE *dptr) +{ + return "Supervisory Printer"; +} + +#endif + diff --git a/I7000/i7000_cdp.c b/I7000/i7000_cdp.c index a9016ab..282092c 100644 --- a/I7000/i7000_cdp.c +++ b/I7000/i7000_cdp.c @@ -85,7 +85,7 @@ uint32 cdp_cmd(UNIT *, uint16, uint16); void cdp_ini(UNIT *, t_bool); t_stat cdp_srv(UNIT *); t_stat cdp_reset(DEVICE *); -t_stat cdp_attach(UNIT *, char *); +t_stat cdp_attach(UNIT *, CONST char *); t_stat cdp_detach(UNIT *); t_stat cdp_help(FILE *, DEVICE *, UNIT *, int32, const char *); const char *cdp_description(DEVICE *dptr); @@ -300,7 +300,7 @@ cdp_ini(UNIT *uptr, t_bool f) { } t_stat -cdp_attach(UNIT * uptr, char *file) +cdp_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7000_cdr.c b/I7000/i7000_cdr.c index 1711e52..d672f80 100644 --- a/I7000/i7000_cdr.c +++ b/I7000/i7000_cdr.c @@ -84,12 +84,12 @@ uint32 cdr_cmd(UNIT *, uint16, uint16); t_stat cdr_boot(int32, DEVICE *); t_stat cdr_srv(UNIT *); t_stat cdr_reset(DEVICE *); -t_stat cdr_attach(UNIT *, char *); +t_stat cdr_attach(UNIT *, CONST char *); t_stat cdr_detach(UNIT *); extern t_stat chan_boot(int32, DEVICE *); #ifdef I7070 -t_stat cdr_setload(UNIT *, int32, char *, void *); -t_stat cdr_getload(FILE *, UNIT *, int32, void *); +t_stat cdr_setload(UNIT *, int32, CONST char *, void *); +t_stat cdr_getload(FILE *, UNIT *, int32, CONST void *); #endif t_stat cdr_help(FILE *, DEVICE *, UNIT *, int32, const char *); const char *cdr_description(DEVICE *dptr); @@ -326,7 +326,7 @@ cdr_boot(int32 unit_num, DEVICE * dptr) } t_stat -cdr_attach(UNIT * uptr, char *file) +cdr_attach(UNIT * uptr, CONST char *file) { t_stat r; @@ -342,7 +342,7 @@ cdr_attach(UNIT * uptr, char *file) } #ifdef I7070 t_stat -cdr_setload(UNIT *uptr, int32 val, char *cptr, void *desc) +cdr_setload(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int i; if (cptr == NULL) @@ -362,7 +362,7 @@ cdr_setload(UNIT *uptr, int32 val, char *cptr, void *desc) } t_stat -cdr_getload(FILE *st, UNIT *uptr, int32 v, void *desc) +cdr_getload(FILE *st, UNIT *uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; diff --git a/I7000/i7000_chan.c b/I7000/i7000_chan.c index 2978783..393b2ab 100644 --- a/I7000/i7000_chan.c +++ b/I7000/i7000_chan.c @@ -142,7 +142,7 @@ chan_set_devs(DEVICE * dptr) /* Sets the device onto a given channel */ t_stat -set_chan(UNIT * uptr, int32 val, char *cptr, void *desc) +set_chan(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { DEVICE *dptr; DIB *dibp; @@ -274,7 +274,7 @@ set_chan(UNIT * uptr, int32 val, char *cptr, void *desc) /* Print devices on channel */ t_stat -print_chan(FILE * st, UNIT * uptr, int32 v, void *desc) +print_chan(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { int chan = uptr - chan_unit; int i; @@ -312,7 +312,7 @@ print_chan(FILE * st, UNIT * uptr, int32 v, void *desc) } t_stat -get_chan(FILE * st, UNIT * uptr, int32 v, void *desc) +get_chan(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { DEVICE *dptr; DIB *dibp; @@ -331,7 +331,7 @@ get_chan(FILE * st, UNIT * uptr, int32 v, void *desc) } t_stat -chan9_set_select(UNIT * uptr, int32 val, char *cptr, void *desc) +chan9_set_select(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int newsel; DEVICE *dptr; @@ -377,7 +377,7 @@ chan9_set_select(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -chan9_get_select(FILE * st, UNIT * uptr, int32 v, void *desc) +chan9_get_select(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; diff --git a/I7000/i7000_chron.c b/I7000/i7000_chron.c index fbb98e7..e27ef05 100644 --- a/I7000/i7000_chron.c +++ b/I7000/i7000_chron.c @@ -48,8 +48,8 @@ uint32 chron_cmd(UNIT *, uint16, uint16); t_stat chron_srv(UNIT *); t_stat chron_reset(DEVICE *); -t_stat set_addr(UNIT * uptr, int32 val, char *cptr, void *desc); -t_stat get_addr(FILE * st, UNIT *uptr, int32 v, void *desc); +t_stat set_addr(UNIT * uptr, int32 val, CONST char *cptr, void *desc); +t_stat get_addr(FILE * st, UNIT *uptr, int32 v, CONST void *desc); t_stat chron_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flags, const char *ctxt); const char *chron_description (DEVICE *dptr); @@ -232,7 +232,7 @@ chron_reset(DEVICE * dptr) /* Sets the address of the chrono clock */ t_stat -set_addr(UNIT * uptr, int32 val, char *cptr, void *desc) +set_addr(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int i; @@ -255,7 +255,7 @@ set_addr(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -get_addr(FILE * st, UNIT * uptr, int32 v, void *desc) +get_addr(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; diff --git a/I7000/i7000_com.c b/I7000/i7000_com.c index a2c4008..dae219f 100644 --- a/I7000/i7000_com.c +++ b/I7000/i7000_com.c @@ -286,10 +286,10 @@ t_stat como_svc(UNIT * uptr); t_stat comti_svc(UNIT * uptr); t_stat comto_svc(UNIT * uptr); t_stat com_reset(DEVICE * dptr); -t_stat com_attach(UNIT * uptr, char *cptr); +t_stat com_attach(UNIT * uptr, CONST char *cptr); t_stat com_detach(UNIT * uptr); -t_stat com_summ(FILE * st, UNIT * uptr, int32 val, void *desc); -t_stat com_show(FILE * st, UNIT * uptr, int32 val, void *desc); +t_stat com_summ(FILE * st, UNIT * uptr, int32 val, CONST void *desc); +t_stat com_show(FILE * st, UNIT * uptr, int32 val, CONST void *desc); void com_reset_ln(uint32 i); t_stat com_queue_in(uint32 ln, uint16 ch); uint32 com_queue_out(uint32 ln, uint16 * c1); @@ -1212,7 +1212,7 @@ com_reset(DEVICE * dptr) /* Attach master unit */ t_stat -com_attach(UNIT * uptr, char *cptr) +com_attach(UNIT * uptr, CONST char *cptr) { t_stat r; @@ -1242,7 +1242,7 @@ com_detach(UNIT * uptr) /* Show summary processor */ t_stat -com_summ(FILE * st, UNIT * uptr, int32 val, void *desc) +com_summ(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { uint32 i, t; @@ -1259,7 +1259,7 @@ com_summ(FILE * st, UNIT * uptr, int32 val, void *desc) /* SHOW CONN/STAT processor */ t_stat -com_show(FILE * st, UNIT * uptr, int32 val, void *desc) +com_show(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 i, cc; diff --git a/I7000/i7000_con.c b/I7000/i7000_con.c index 672896c..fae54d8 100644 --- a/I7000/i7000_con.c +++ b/I7000/i7000_con.c @@ -89,7 +89,7 @@ uint32 con_cmd(UNIT *, uint16, uint16); void con_ini(UNIT *, t_bool); t_stat con_srv(UNIT *); t_stat con_reset(DEVICE *); -t_stat con_attach(UNIT *, char *); +t_stat con_attach(UNIT *, CONST char *); t_stat con_detach(UNIT *); t_stat con_help(FILE *, DEVICE *, UNIT *, int32, const char *); const char *con_description(DEVICE *dptr); diff --git a/I7000/i7000_defs.h b/I7000/i7000_defs.h index b8a8804..89d4663 100644 --- a/I7000/i7000_defs.h +++ b/I7000/i7000_defs.h @@ -321,12 +321,12 @@ t_stat chan_boot(int32 unit_num, DEVICE *dptr); /* Sets the device onto a given channel */ t_stat chan_set_devs(DEVICE *dptr); -t_stat set_chan(UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat set_cchan(UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat print_chan(FILE *st, UNIT *uptr, int32 v, void *desc); -t_stat get_chan(FILE *st, UNIT *uptr, int32 v, void *desc); -t_stat chan9_set_select(UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat chan9_get_select(FILE *st, UNIT *uptr, int32 v, void *desc); +t_stat set_chan(UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat set_cchan(UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat print_chan(FILE *st, UNIT *uptr, int32 v, CONST void *desc); +t_stat get_chan(FILE *st, UNIT *uptr, int32 v, CONST void *desc); +t_stat chan9_set_select(UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat chan9_get_select(FILE *st, UNIT *uptr, int32 v, CONST void *desc); /* Check channel for error */ int chan_error(int chan); diff --git a/I7000/i7000_dsk.c b/I7000/i7000_dsk.c index 2aa06e4..dded9da 100644 --- a/I7000/i7000_dsk.c +++ b/I7000/i7000_dsk.c @@ -107,14 +107,14 @@ t_stat dsk_srv(UNIT *); t_stat dsk_boot(int32, DEVICE *); void dsk_ini(UNIT *, t_bool); t_stat dsk_reset(DEVICE *); -t_stat dsk_set_module(UNIT * uptr, int32 val, char *cptr, +t_stat dsk_set_module(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat dsk_get_module(FILE * st, UNIT * uptr, int32 v, - void *desc); -t_stat dsk_set_type(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat dsk_set_type(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat dsk_get_type(FILE * st, UNIT * uptr, int32 v, - void *desc); + CONST void *desc); t_stat dsk_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *dsk_description (DEVICE *dptr); @@ -1751,7 +1751,7 @@ dsk_reset(DEVICE * dptr) /* Disk option setting commands */ t_stat -dsk_set_type(UNIT * uptr, int32 val, char *cptr, void *desc) +dsk_set_type(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int i, u; @@ -1788,7 +1788,7 @@ dsk_set_type(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -dsk_get_type(FILE * st, UNIT * uptr, int32 v, void *desc) +dsk_get_type(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; @@ -1797,7 +1797,7 @@ dsk_get_type(FILE * st, UNIT * uptr, int32 v, void *desc) } t_stat -dsk_set_module(UNIT * uptr, int32 val, char *cptr, void *desc) +dsk_set_module(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int u; @@ -1829,7 +1829,7 @@ dsk_set_module(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -dsk_get_module(FILE * st, UNIT * uptr, int32 v, void *desc) +dsk_get_module(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; diff --git a/I7000/i7000_ht.c b/I7000/i7000_ht.c index 1b1966f..a296df7 100644 --- a/I7000/i7000_ht.c +++ b/I7000/i7000_ht.c @@ -129,7 +129,7 @@ void ht_tape_cmd(DEVICE *, UNIT *); t_stat ht_error(UNIT *, int, t_stat); t_stat ht_boot(int32, DEVICE *); t_stat ht_reset(DEVICE *); -t_stat ht_attach(UNIT *, char *); +t_stat ht_attach(UNIT *, CONST char *); t_stat ht_detach(UNIT *); t_stat ht_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -950,7 +950,7 @@ ht_reset(DEVICE * dptr) t_stat -ht_attach(UNIT * uptr, char *file) +ht_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7000_lpr.c b/I7000/i7000_lpr.c index b3c0827..5d77e16 100644 --- a/I7000/i7000_lpr.c +++ b/I7000/i7000_lpr.c @@ -91,10 +91,10 @@ uint32 lpr_cmd(UNIT *, uint16, uint16); void lpr_ini(UNIT *, t_bool); t_stat lpr_srv(UNIT *); t_stat lpr_reset(DEVICE *); -t_stat lpr_attach(UNIT *, char *); +t_stat lpr_attach(UNIT *, CONST char *); t_stat lpr_detach(UNIT *); -t_stat lpr_setlpp(UNIT *, int32, char *, void *); -t_stat lpr_getlpp(FILE *, UNIT *, int32, void *); +t_stat lpr_setlpp(UNIT *, int32, CONST char *, void *); +t_stat lpr_getlpp(FILE *, UNIT *, int32, CONST void *); t_stat lpr_help(FILE *, DEVICE *, UNIT *, int32, const char *); const char *lpr_description(DEVICE *dptr); @@ -142,7 +142,7 @@ DEVICE lpr_dev = { */ t_stat -lpr_setlpp(UNIT *uptr, int32 val, char *cptr, void *desc) +lpr_setlpp(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int i; if (cptr == NULL) @@ -163,7 +163,7 @@ lpr_setlpp(UNIT *uptr, int32 val, char *cptr, void *desc) } t_stat -lpr_getlpp(FILE *st, UNIT *uptr, int32 v, void *desc) +lpr_getlpp(FILE *st, UNIT *uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; @@ -479,7 +479,7 @@ lpr_ini(UNIT *uptr, t_bool f) { } t_stat -lpr_attach(UNIT * uptr, char *file) +lpr_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7000_mt.c b/I7000/i7000_mt.c index 3d8f7ac..64240ab 100644 --- a/I7000/i7000_mt.c +++ b/I7000/i7000_mt.c @@ -86,10 +86,10 @@ t_stat mt_srv(UNIT *); t_stat mt_boot(int32, DEVICE *); void mt_ini(UNIT *, t_bool); t_stat mt_reset(DEVICE *); -t_stat mt_attach(UNIT *, char *); +t_stat mt_attach(UNIT *, CONST char *); t_stat mt_detach(UNIT *); -t_stat mt_rew(UNIT * uptr, int32 val, char *cptr, void *desc); -t_stat mt_tape_density(UNIT * uptr, int32 val, char *cptr, void *desc); +t_stat mt_rew(UNIT * uptr, int32 val, CONST char *cptr, void *desc); +t_stat mt_tape_density(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat mt_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *mt_description (DEVICE *dptr); @@ -320,7 +320,7 @@ uint8 parity_table[64] = { /* Rewind tape drive */ t_stat -mt_rew(UNIT * uptr, int32 val, char *cptr, void *desc) +mt_rew(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { /* If drive is offline or not attached return not ready */ if ((uptr->flags & (UNIT_ATT | MTUF_ONLINE)) == 0) @@ -1271,13 +1271,13 @@ mt_reset(DEVICE * dptr) } t_stat -mt_tape_density(UNIT * uptr, int32 val, char *cptr, void *desc) +mt_tape_density(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { return SCPE_OK; } t_stat -mt_attach(UNIT * uptr, char *file) +mt_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7010_chan.c b/I7000/i7010_chan.c index 647409d..d0f4c71 100644 --- a/I7000/i7010_chan.c +++ b/I7000/i7010_chan.c @@ -42,8 +42,8 @@ extern uint8 chan_seek_done[NUM_CHAN]; /* Channel seek finished */ #define CHAN_DEF UNIT_DISABLE|CHAN_SET -t_stat set_urec(UNIT * uptr, int32 val, char *cptr, void *desc); -t_stat get_urec(FILE * st, UNIT * uptr, int32 v, void *desc); +t_stat set_urec(UNIT * uptr, int32 val, CONST char *cptr, void *desc); +t_stat get_urec(FILE * st, UNIT * uptr, int32 v, CONST void *desc); t_stat chan_reset(DEVICE * dptr); t_stat chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -145,7 +145,7 @@ struct { /* Sets the device that will interrupt on the channel. */ t_stat -set_urec(UNIT * uptr, int32 val, char *cptr, void *desc) +set_urec(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int chan = UNIT_G_CHAN(uptr->flags); int i; @@ -166,7 +166,7 @@ set_urec(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -get_urec(FILE * st, UNIT * uptr, int32 v, void *desc) +get_urec(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { int chan = UNIT_G_CHAN(uptr->flags); int i; @@ -669,6 +669,7 @@ chan9_set_error(int chan, uint32 mask) t_stat chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) { +return SCPE_OK; } const char * diff --git a/I7000/i7010_cpu.c b/I7000/i7010_cpu.c index 377e5b5..f288228 100644 --- a/I7000/i7010_cpu.c +++ b/I7000/i7010_cpu.c @@ -90,11 +90,11 @@ t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw); t_stat cpu_reset(DEVICE * dptr); -t_stat cpu_set_size(UNIT * uptr, int32 val, char *cptr, +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, - void *desc); -t_stat cpu_set_hist(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -3767,7 +3767,7 @@ cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) } t_stat -cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { uint8 mc = 0; int32 i; @@ -3793,7 +3793,7 @@ cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) /* Set history */ t_stat -cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -3826,7 +3826,7 @@ cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) /* Show history */ t_stat -cpu_show_hist(FILE * st, UNIT * uptr, int32 val, void *desc) +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 k, i, di, lnt, pc; char *cptr = (char *) desc; diff --git a/I7000/i7010_sys.c b/I7000/i7010_sys.c index 4b14c86..9f2d790 100644 --- a/I7000/i7010_sys.c +++ b/I7000/i7010_sys.c @@ -205,7 +205,7 @@ const char mem_to_ascii[64] = { /* Load a card image file into memory. */ t_stat -sim_load(FILE * fileref, char *cptr, char *fnam, int flag) +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) { return SCPE_NOFNC; } @@ -927,7 +927,7 @@ find_opcode(char *op, t_opcode * tab) */ t_stat -parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) +parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) { int i; t_value d; diff --git a/I7000/i701_cpu.c b/I7000/i701_cpu.c index c69db30..eac12df 100644 --- a/I7000/i701_cpu.c +++ b/I7000/i701_cpu.c @@ -104,11 +104,11 @@ t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw); t_stat cpu_reset(DEVICE * dptr); -t_stat cpu_set_size(UNIT * uptr, int32 val, char *cptr, +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, - void *desc); -t_stat cpu_set_hist(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -818,7 +818,7 @@ cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) /* Set history */ t_stat -cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -851,7 +851,7 @@ cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) /* Show history */ t_stat -cpu_show_hist(FILE * st, UNIT * uptr, int32 val, void *desc) +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 k, di, lnt; char *cptr = (char *) desc; diff --git a/I7000/i701_sys.c b/I7000/i701_sys.c index 95ad88e..87b20d4 100644 --- a/I7000/i701_sys.c +++ b/I7000/i701_sys.c @@ -24,7 +24,7 @@ #include "i7090_defs.h" #include -t_stat parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); +t_stat parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); /* SCP data structures and interface routines @@ -117,7 +117,7 @@ extern const char sim_ascii_to_six[128]; /* Load a card image file into memory. */ t_stat -sim_load(FILE * fileref, char *cptr, char *fnam, int flag) +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) { t_uint64 wd; t_uint64 mask; @@ -214,7 +214,7 @@ sim_load(FILE * fileref, char *cptr, char *fnam, int flag) typedef struct _opcode { uint16 opbase; - char *name; + CONST char *name; } t_opcode; @@ -329,7 +329,7 @@ fprint_sym(FILE * of, t_addr addr, t_value * val, UNIT * uptr, int32 sw) fprint_val(of, inst, 8, 36, PV_RZRO); if (sw & SWMASK('M')) { - int op = (inst >> (12+18)); + int op = (int)(inst >> (12+18)); int i; fputs(" rt ", of); if (op != (040 + 13)) @@ -401,7 +401,7 @@ find_opcode(char *op, t_opcode * tab) */ t_stat -parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) +parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) { int i; int f; diff --git a/I7000/i7070_chan.c b/I7000/i7070_chan.c index 457cd19..5525ee7 100644 --- a/I7000/i7070_chan.c +++ b/I7000/i7070_chan.c @@ -1566,6 +1566,7 @@ chan9_set_error(int chan, uint32 mask) t_stat chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) { +return SCPE_OK; } const char * diff --git a/I7000/i7070_cpu.c b/I7000/i7070_cpu.c index a2ef282..c969c96 100644 --- a/I7000/i7070_cpu.c +++ b/I7000/i7070_cpu.c @@ -97,11 +97,11 @@ t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw); t_stat cpu_reset(DEVICE * dptr); -t_stat cpu_set_size(UNIT * uptr, int32 val, char *cptr, +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, - void *desc); -t_stat cpu_set_hist(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -2833,7 +2833,7 @@ cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) } t_stat -cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { t_uint64 mc = 0; uint32 i; @@ -2858,7 +2858,7 @@ cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) /* Set history */ t_stat -cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -2891,7 +2891,7 @@ cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) /* Show history */ t_stat -cpu_show_hist(FILE * st, UNIT * uptr, int32 val, void *desc) +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 k, di, lnt; char *cptr = (char *) desc; diff --git a/I7000/i7070_sys.c b/I7000/i7070_sys.c index 4e13dd1..660e931 100644 --- a/I7000/i7070_sys.c +++ b/I7000/i7070_sys.c @@ -25,7 +25,7 @@ #include "sim_card.h" #include -t_stat parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); +t_stat parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); /* SCP data structures and interface routines @@ -211,7 +211,7 @@ char mem_ascii[256] = { /* Load a card image file into memory. */ t_stat -sim_load(FILE * fileref, char *cptr, char *fnam, int flag) +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) { /* Currently not implimented until I know format of load files */ return SCPE_NOFNC; @@ -838,7 +838,7 @@ find_opcode(char *op, t_opcode * tab) */ t_stat -parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) +parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) { int i; int idx; diff --git a/I7000/i7080_chan.c b/I7000/i7080_chan.c index 0cd6782..cfb3b70 100644 --- a/I7000/i7080_chan.c +++ b/I7000/i7080_chan.c @@ -73,7 +73,7 @@ extern uint8 ioflags[5000/8]; -t_stat set_chan_type(UNIT *uptr, int32 val, char *cptr, void *desc); +t_stat set_chan_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc); t_stat chan_reset(DEVICE * dptr); t_stat chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -172,7 +172,7 @@ DEVICE chan_dev = { t_stat -set_chan_type(UNIT *uptr, int32 val, char *cptr, void *desc) { +set_chan_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { if ((uptr->flags & CHAN_MOD) == 0) return SCPE_ARG; uptr->flags &= ~CHAN_MODEL; @@ -1217,6 +1217,7 @@ chan9_set_error(int chan, uint32 mask) t_stat chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) { +return SCPE_OK; } const char * diff --git a/I7000/i7080_cpu.c b/I7000/i7080_cpu.c index f9a5854..bc99730 100644 --- a/I7000/i7080_cpu.c +++ b/I7000/i7080_cpu.c @@ -103,11 +103,11 @@ t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw); t_stat cpu_reset(DEVICE * dptr); -t_stat cpu_set_size(UNIT * uptr, int32 val, char *cptr, +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, - void *desc); -t_stat cpu_set_hist(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -3283,7 +3283,7 @@ cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) } t_stat -cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { t_uint64 mc = 0; uint32 size; @@ -3310,7 +3310,7 @@ cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) /* Set history */ t_stat -cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -3343,7 +3343,7 @@ cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) /* Show history */ t_stat -cpu_show_hist(FILE * st, UNIT * uptr, int32 val, void *desc) +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 k, di, lnt; char *cptr = (char *) desc; diff --git a/I7000/i7080_sys.c b/I7000/i7080_sys.c index 2c81845..10f5e42 100644 --- a/I7000/i7080_sys.c +++ b/I7000/i7080_sys.c @@ -181,7 +181,7 @@ const char mem_to_ascii[64] = { /*Sq*/ /*GM*/ }; -t_stat parse_sym(char *, t_addr, UNIT *, t_value *, int32); +t_stat parse_sym(CONST char *, t_addr, UNIT *, t_value *, int32); @@ -226,7 +226,7 @@ load_rec(uint8 *image) { /* Load a card image file into memory. */ t_stat -sim_load(FILE * fileref, char *cptr, char *fnam, int flag) +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) { char *p; char buffer[160]; @@ -590,7 +590,7 @@ find_opcode(char *op, t_opcode * tab) */ t_stat -parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) +parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) { int i; t_value d; diff --git a/I7000/i7090_cdp.c b/I7000/i7090_cdp.c index 82fd8e7..7552d3d 100644 --- a/I7000/i7090_cdp.c +++ b/I7000/i7090_cdp.c @@ -48,7 +48,7 @@ t_stat cdp_srv(UNIT *); t_stat cdp_reset(DEVICE *); -t_stat cdp_attach(UNIT *, char *); +t_stat cdp_attach(UNIT *, CONST char *); t_stat cdp_detach(UNIT *); t_stat cdp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -255,7 +255,7 @@ cdp_reset(DEVICE * dptr) } t_stat -cdp_attach(UNIT * uptr, char *file) +cdp_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7090_cdr.c b/I7000/i7090_cdr.c index f14d9aa..83852df 100644 --- a/I7000/i7090_cdr.c +++ b/I7000/i7090_cdr.c @@ -55,7 +55,7 @@ t_stat cdr_srv(UNIT *); t_stat cdr_boot(int32, DEVICE *); t_stat cdr_reset(DEVICE *); -t_stat cdr_attach(UNIT *, char *); +t_stat cdr_attach(UNIT *, CONST char *); t_stat cdr_detach(UNIT *); t_stat cdr_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -293,7 +293,7 @@ cdr_reset(DEVICE * dptr) } t_stat -cdr_attach(UNIT * uptr, char *file) +cdr_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7090_chan.c b/I7000/i7090_chan.c index e6128d7..fd0bce2 100644 --- a/I7000/i7090_chan.c +++ b/I7000/i7090_chan.c @@ -1674,6 +1674,7 @@ chan_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) { #ifdef I7090 #endif +return SCPE_OK; } const char * diff --git a/I7000/i7090_cpu.c b/I7000/i7090_cpu.c index 852de4d..ecd1948 100644 --- a/I7000/i7090_cpu.c +++ b/I7000/i7090_cpu.c @@ -208,11 +208,11 @@ t_stat cpu_ex(t_value * vptr, t_addr addr, UNIT * uptr, t_stat cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw); t_stat cpu_reset(DEVICE * dptr); -t_stat cpu_set_size(UNIT * uptr, int32 val, char *cptr, +t_stat cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc); t_stat cpu_show_hist(FILE * st, UNIT * uptr, int32 val, - void *desc); -t_stat cpu_set_hist(UNIT * uptr, int32 val, char *cptr, + CONST void *desc); +t_stat cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc); uint32 cpu_cmd(UNIT * uptr, uint16 cmd, uint16 dev); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, @@ -4219,7 +4219,7 @@ cpu_dep(t_value val, t_addr addr, UNIT * uptr, int32 sw) } t_stat -cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_size(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { t_uint64 mc = 0; uint32 i; @@ -4247,7 +4247,7 @@ cpu_set_size(UNIT * uptr, int32 val, char *cptr, void *desc) /* Set history */ t_stat -cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) +cpu_set_hist(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -4280,7 +4280,7 @@ cpu_set_hist(UNIT * uptr, int32 val, char *cptr, void *desc) /* Show history */ t_stat -cpu_show_hist(FILE * st, UNIT * uptr, int32 val, void *desc) +cpu_show_hist(FILE * st, UNIT * uptr, int32 val, CONST void *desc) { int32 k, di, lnt; char *cptr = (char *) desc; diff --git a/I7000/i7090_drum.c b/I7000/i7090_drum.c index a1d22fa..73efd75 100644 --- a/I7000/i7090_drum.c +++ b/I7000/i7090_drum.c @@ -47,12 +47,12 @@ void drm_ini(UNIT *, t_bool); t_stat drm_reset(DEVICE *); extern t_stat chan_boot(int32, DEVICE *); uint32 drum_addr; /* Read/write drum address */ -t_stat set_units(UNIT * uptr, int32 val, char *cptr, +t_stat set_units(UNIT * uptr, int32 val, CONST char *cptr, void *desc); -t_stat drm_attach(UNIT * uptr, char *file); +t_stat drm_attach(UNIT * uptr, CONST char *file); t_stat drm_detach(UNIT * uptr); -t_stat get_units(FILE * st, UNIT * uptr, int32 v, void *desc); +t_stat get_units(FILE * st, UNIT * uptr, int32 v, CONST void *desc); t_stat drm_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *drm_description (DEVICE *dptr); @@ -209,7 +209,7 @@ drm_reset(DEVICE * dptr) /* Sets the number of drum units */ t_stat -set_units(UNIT * uptr, int32 val, char *cptr, void *desc) +set_units(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int i; @@ -233,7 +233,7 @@ set_units(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -get_units(FILE * st, UNIT * uptr, int32 v, void *desc) +get_units(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; @@ -242,7 +242,7 @@ get_units(FILE * st, UNIT * uptr, int32 v, void *desc) } t_stat -drm_attach(UNIT * uptr, char *file) +drm_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7090_hdrum.c b/I7000/i7090_hdrum.c index af9b1cd..1d0a4e7 100644 --- a/I7000/i7090_hdrum.c +++ b/I7000/i7090_hdrum.c @@ -42,9 +42,9 @@ t_stat hsdrm_srv(UNIT *); void hsdrm_ini(UNIT *, t_bool); t_stat hsdrm_reset(DEVICE *); uint32 hsdrm_addr; /* Read/write drum address */ -t_stat set_hunits(UNIT * uptr, int32 val, char *cptr, void *desc); -t_stat get_hunits(FILE * st, UNIT * uptr, int32 v, void *desc); -t_stat hsdrm_attach(UNIT * uptr, char *file); +t_stat set_hunits(UNIT * uptr, int32 val, CONST char *cptr, void *desc); +t_stat get_hunits(FILE * st, UNIT * uptr, int32 v, CONST void *desc); +t_stat hsdrm_attach(UNIT * uptr, CONST char *file); t_stat hsdrm_detach(UNIT * uptr); t_stat hsdrm_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -180,7 +180,7 @@ hsdrm_reset(DEVICE * dptr) /* Sets the number of drum units */ t_stat -set_hunits(UNIT * uptr, int32 val, char *cptr, void *desc) +set_hunits(UNIT * uptr, int32 val, CONST char *cptr, void *desc) { int i; @@ -204,7 +204,7 @@ set_hunits(UNIT * uptr, int32 val, char *cptr, void *desc) } t_stat -get_hunits(FILE * st, UNIT * uptr, int32 v, void *desc) +get_hunits(FILE * st, UNIT * uptr, int32 v, CONST void *desc) { if (uptr == NULL) return SCPE_IERR; @@ -213,7 +213,7 @@ get_hunits(FILE * st, UNIT * uptr, int32 v, void *desc) } t_stat -hsdrm_attach(UNIT * uptr, char *file) +hsdrm_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7090_lpr.c b/I7000/i7090_lpr.c index 18beece..dc83a93 100644 --- a/I7000/i7090_lpr.c +++ b/I7000/i7090_lpr.c @@ -79,7 +79,7 @@ uint32 lpr_cmd(UNIT *, uint16, uint16); t_stat lpr_srv(UNIT *); void lpr_ini(UNIT *, t_bool); t_stat lpr_reset(DEVICE *); -t_stat lpr_attach(UNIT *, char *); +t_stat lpr_attach(UNIT *, CONST char *); t_stat lpr_detach(UNIT *); t_stat lpr_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -577,7 +577,7 @@ lpr_reset(DEVICE * dptr) } t_stat -lpr_attach(UNIT * uptr, char *file) +lpr_attach(UNIT * uptr, CONST char *file) { t_stat r; diff --git a/I7000/i7090_sys.c b/I7000/i7090_sys.c index 72a9ef7..42abb9b 100644 --- a/I7000/i7090_sys.c +++ b/I7000/i7090_sys.c @@ -24,7 +24,7 @@ #include "i7090_defs.h" #include -t_stat parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); +t_stat parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw); /* SCP data structures and interface routines @@ -205,7 +205,7 @@ const char ascii_to_mem[128] = { /* Load a card image file into memory. */ t_stat -sim_load(FILE * fileref, char *cptr, char *fnam, int flag) +sim_load(FILE * fileref, CONST char *cptr, CONST char *fnam, int flag) { t_uint64 wd; t_uint64 mask; @@ -215,13 +215,7 @@ sim_load(FILE * fileref, char *cptr, char *fnam, int flag) char *p; int i, j; - p = strrchr(fnam, '.'); - - if (p == NULL) - return SCPE_ARG; - - p++; - if (strcasecmp(p, "crd") == 0) { + if (match_ext(cptr, "crd")) { int firstcard = 1; uint16 image[80]; t_uint64 lbuff[24]; @@ -263,7 +257,7 @@ sim_load(FILE * fileref, char *cptr, char *fnam, int flag) dlen--; } } - } else if (strcasecmp(p, "cbn") == 0) { + } else if (match_ext(cptr, "cbn")) { int firstcard = 1; uint16 image[80]; t_uint64 lbuff[24]; @@ -305,7 +299,7 @@ sim_load(FILE * fileref, char *cptr, char *fnam, int flag) dlen--; } } - } else if (strcasecmp(p, "oct") == 0) { + } else if (match_ext(cptr, "oct")) { while (fgets(buffer, 80, fileref) != 0) { for(p = buffer; *p == ' ' || *p == '\t'; p++); /* Grab address */ @@ -320,7 +314,7 @@ sim_load(FILE * fileref, char *cptr, char *fnam, int flag) } } - } else if (strcasecmp(p, "sym") == 0) { + } else if (match_ext(cptr, "sym")) { while (fgets(buffer, 80, fileref) != 0) { for(p = buffer; *p == ' ' || *p == '\t'; p++); /* Grab address */ @@ -936,7 +930,7 @@ find_opcode(char *op, t_opcode * tab) */ t_stat -parse_sym(char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) +parse_sym(CONST char *cptr, t_addr addr, UNIT * uptr, t_value * val, int32 sw) { int i; t_value d, tag; diff --git a/PDP10/ka10_cpu.c b/PDP10/ka10_cpu.c index 4880c5c..08f45f6 100644 --- a/PDP10/ka10_cpu.c +++ b/PDP10/ka10_cpu.c @@ -176,9 +176,9 @@ InstHistory *hst = NULL; /* instruction history * t_stat cpu_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw); t_stat cpu_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw); t_stat cpu_reset (DEVICE *dptr); -t_stat cpu_set_size (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat cpu_set_hist (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat cpu_show_hist (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat cpu_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat cpu_set_hist (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat cpu_show_hist (FILE *st, UNIT *uptr, int32 val, CONST void *desc); t_stat cpu_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *cpu_description (DEVICE *dptr); @@ -2801,7 +2801,7 @@ return SCPE_OK; /* Memory size change */ -t_stat cpu_set_size (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat cpu_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { uint64 mc = 0; uint32 i; @@ -2857,7 +2857,7 @@ return FALSE; /* Set history */ -t_stat cpu_set_hist (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat cpu_set_hist (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int32 i, lnt; t_stat r; @@ -2888,7 +2888,7 @@ return SCPE_OK; /* Show history */ -t_stat cpu_show_hist (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat cpu_show_hist (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { int32 k, di, lnt; char *cptr = (char *) desc; diff --git a/PDP10/ka10_cty.c b/PDP10/ka10_cty.c index c7eea89..89045fe 100644 --- a/PDP10/ka10_cty.c +++ b/PDP10/ka10_cty.c @@ -33,8 +33,8 @@ extern int32 tmxr_poll; t_stat ctyi_svc (UNIT *uptr); t_stat ctyo_svc (UNIT *uptr); t_stat cty_reset (DEVICE *dptr); -t_stat cty_stop_os (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat tty_set_mode (UNIT *uptr, int32 val, char *cptr, void *desc); +t_stat cty_stop_os (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat tty_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc); t_stat cty_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *cty_description (DEVICE *dptr); @@ -166,13 +166,13 @@ return SCPE_OK; /* Stop operating system */ -t_stat cty_stop_os (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat cty_stop_os (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { M[CTY_SWITCH] = 1; /* tell OS to stop */ return SCPE_OK; } -t_stat tty_set_mode (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat tty_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { cty_unit[0].flags = (cty_unit[0].flags & ~TT_MODE) | val; cty_unit[1].flags = (cty_unit[1].flags & ~TT_MODE) | val; diff --git a/PDP10/ka10_dc.c b/PDP10/ka10_dc.c index 4ee75bd..ec40f71 100644 --- a/PDP10/ka10_dc.c +++ b/PDP10/ka10_dc.c @@ -80,7 +80,7 @@ t_stat dc_devio(uint32 dev, uint64 *data); t_stat dc_svc (UNIT *uptr); t_stat dc_doscan (UNIT *uptr); t_stat dc_reset (DEVICE *dptr); -t_stat dc_attach (UNIT *uptr, char *cptr); +t_stat dc_attach (UNIT *uptr, CONST char *cptr); t_stat dc_detach (UNIT *uptr); t_stat dc_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -297,7 +297,7 @@ return SCPE_OK; /* Attach routine */ -t_stat dc_attach (UNIT *uptr, char *cptr) +t_stat dc_attach (UNIT *uptr, CONST char *cptr) { t_stat reason; diff --git a/PDP10/ka10_dp.c b/PDP10/ka10_dp.c index 9237230..2230a92 100644 --- a/PDP10/ka10_dp.c +++ b/PDP10/ka10_dp.c @@ -162,9 +162,9 @@ t_stat dp_svc(UNIT *); t_stat dp_boot(int32, DEVICE *); void dp_ini(UNIT *, t_bool); t_stat dp_reset(DEVICE *); -t_stat dp_attach(UNIT *, char *); +t_stat dp_attach(UNIT *, CONST char *); t_stat dp_detach(UNIT *); -t_stat dp_set_type(UNIT *uptr, int32 val, char *cptr, void *desc); +t_stat dp_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc); t_stat dp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *dp_description (DEVICE *dptr); @@ -625,7 +625,7 @@ t_stat dp_svc (UNIT *uptr) t_stat -dp_set_type(UNIT *uptr, int32 val, char *cptr, void *desc) +dp_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int i; if (uptr == NULL) return SCPE_IERR; @@ -684,7 +684,7 @@ dp_boot(int32 unit_num, DEVICE * dptr) /* Device attach */ -t_stat dp_attach (UNIT *uptr, char *cptr) +t_stat dp_attach (UNIT *uptr, CONST char *cptr) { int32 drv, i, p; t_stat r; diff --git a/PDP10/ka10_dt.c b/PDP10/ka10_dt.c index e9c70e0..fbc83f1 100644 --- a/PDP10/ka10_dt.c +++ b/PDP10/ka10_dt.c @@ -367,7 +367,7 @@ t_stat dt_devio(uint32 dev, uint64 *data); int32 dt_iors (void); t_stat dt_svc (UNIT *uptr); t_stat dt_reset (DEVICE *dptr); -t_stat dt_attach (UNIT *uptr, char *cptr); +t_stat dt_attach (UNIT *uptr, CONST char *cptr); t_stat dt_detach (UNIT *uptr); void dt_deselect (int32 oldf); void dt_newsa (int32 newf); @@ -1438,7 +1438,7 @@ return 0; If 18b/36b, read data into buffer */ -t_stat dt_attach (UNIT *uptr, char *cptr) +t_stat dt_attach (UNIT *uptr, CONST char *cptr) { #if 0 uint16 pdp8b[D8_NBSIZE]; diff --git a/PDP10/ka10_lp.c b/PDP10/ka10_lp.c index d2f2405..6ef95d4 100644 --- a/PDP10/ka10_lp.c +++ b/PDP10/ka10_lp.c @@ -59,7 +59,7 @@ DEVICE lpt_dev; t_stat lpt_devio(uint32 dev, uint64 *data); t_stat lpt_svc (UNIT *uptr); t_stat lpt_reset (DEVICE *dptr); -t_stat lpt_attach (UNIT *uptr, char *cptr); +t_stat lpt_attach (UNIT *uptr, CONST char *cptr); t_stat lpt_detach (UNIT *uptr); t_stat lpt_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -211,7 +211,7 @@ return SCPE_OK; /* Attach routine */ -t_stat lpt_attach (UNIT *uptr, char *cptr) +t_stat lpt_attach (UNIT *uptr, CONST char *cptr) { t_stat reason; diff --git a/PDP10/ka10_mt.c b/PDP10/ka10_mt.c index 368cf47..385d1a9 100644 --- a/PDP10/ka10_mt.c +++ b/PDP10/ka10_mt.c @@ -135,10 +135,10 @@ t_stat mt_devio(uint32 dev, uint64 *data); t_stat mt_srv(UNIT *); t_stat mt_boot(int32, DEVICE *); void mt_ini(UNIT *, t_bool); -t_stat set_mta (UNIT *uptr, int32 val, char *cptr, void *desc) ; -t_stat show_mta (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat set_mta (UNIT *uptr, int32 val, CONST char *cptr, void *desc) ; +t_stat show_mta (FILE *st, UNIT *uptr, int32 val, CONST void *desc); t_stat mt_reset(DEVICE *); -t_stat mt_attach(UNIT *, char *); +t_stat mt_attach(UNIT *, CONST char *); t_stat mt_detach(UNIT *); t_stat mt_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -745,7 +745,7 @@ mt_boot(int32 unit_num, DEVICE * dptr) return SCPE_OK; } -t_stat set_mta (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat set_mta (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { DEVICE *dptr; dptr = find_dev_from_unit (uptr); @@ -759,7 +759,7 @@ t_stat set_mta (UNIT *uptr, int32 val, char *cptr, void *desc) return SCPE_OK; } -t_stat show_mta (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat show_mta (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { DEVICE *dptr; @@ -793,7 +793,7 @@ mt_reset(DEVICE * dptr) } t_stat -mt_attach(UNIT * uptr, char *file) +mt_attach(UNIT * uptr, CONST char *file) { return sim_tape_attach(uptr, file); } diff --git a/PDP10/ka10_pt.c b/PDP10/ka10_pt.c index c853101..c6e33f0 100644 --- a/PDP10/ka10_pt.c +++ b/PDP10/ka10_pt.c @@ -57,7 +57,7 @@ DEVICE ptp_dev; t_stat ptp_devio(uint32 dev, uint64 *data); t_stat ptp_svc (UNIT *uptr); t_stat ptp_reset (DEVICE *dptr); -t_stat ptp_attach (UNIT *uptr, char *cptr); +t_stat ptp_attach (UNIT *uptr, CONST char *cptr); t_stat ptp_detach (UNIT *uptr); t_stat ptp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *ptp_description (DEVICE *dptr); @@ -67,7 +67,7 @@ DEVICE ptr_dev; t_stat ptr_devio(uint32 dev, uint64 *data); t_stat ptr_svc (UNIT *uptr); t_stat ptr_reset (DEVICE *dptr); -t_stat ptr_attach (UNIT *uptr, char *cptr); +t_stat ptr_attach (UNIT *uptr, CONST char *cptr); t_stat ptr_detach (UNIT *uptr); t_stat ptr_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *ptr_description (DEVICE *dptr); @@ -207,7 +207,7 @@ return SCPE_OK; /* Attach routine */ -t_stat ptp_attach (UNIT *uptr, char *cptr) +t_stat ptp_attach (UNIT *uptr, CONST char *cptr) { t_stat reason; @@ -318,7 +318,7 @@ return SCPE_OK; /* Attach routine */ -t_stat ptr_attach (UNIT *uptr, char *cptr) +t_stat ptr_attach (UNIT *uptr, CONST char *cptr) { t_stat reason; diff --git a/PDP10/ka10_rc.c b/PDP10/ka10_rc.c index 3f8f9ea..1dc07e8 100644 --- a/PDP10/ka10_rc.c +++ b/PDP10/ka10_rc.c @@ -123,9 +123,9 @@ t_stat rc_svc(UNIT *); t_stat rc_boot(int32, DEVICE *); void rc_ini(UNIT *, t_bool); t_stat rc_reset(DEVICE *); -t_stat rc_attach(UNIT *, char *); +t_stat rc_attach(UNIT *, CONST char *); t_stat rc_detach(UNIT *); -t_stat rc_set_type(UNIT *uptr, int32 val, char *cptr, void *desc); +t_stat rc_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc); t_stat rc_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *rc_description (DEVICE *dptr); @@ -391,7 +391,7 @@ t_stat rc_svc (UNIT *uptr) t_stat -rc_set_type(UNIT *uptr, int32 val, char *cptr, void *desc) +rc_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int i; if (uptr == NULL) return SCPE_IERR; @@ -454,7 +454,7 @@ rc_boot(int32 unit_num, DEVICE * dptr) /* Device attach */ -t_stat rc_attach (UNIT *uptr, char *cptr) +t_stat rc_attach (UNIT *uptr, CONST char *cptr) { int32 drv, i, p; t_stat r; diff --git a/PDP10/ka10_rp.c b/PDP10/ka10_rp.c index 6c3f3db..d72b21a 100644 --- a/PDP10/ka10_rp.c +++ b/PDP10/ka10_rp.c @@ -299,9 +299,9 @@ t_stat rp_svc(UNIT *); t_stat rp_boot(int32, DEVICE *); void rp_ini(UNIT *, t_bool); t_stat rp_reset(DEVICE *); -t_stat rp_attach(UNIT *, char *); +t_stat rp_attach(UNIT *, CONST char *); t_stat rp_detach(UNIT *); -t_stat rp_set_type(UNIT *uptr, int32 val, char *cptr, void *desc); +t_stat rp_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc); t_stat rp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); const char *rp_description (DEVICE *dptr); @@ -862,7 +862,7 @@ t_stat rp_svc (UNIT *uptr) t_stat -rp_set_type(UNIT *uptr, int32 val, char *cptr, void *desc) +rp_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int i; if (uptr == NULL) return SCPE_IERR; @@ -915,7 +915,7 @@ rp_boot(int32 unit_num, DEVICE * rptr) /* Device attach */ -t_stat rp_attach (UNIT *uptr, char *cptr) +t_stat rp_attach (UNIT *uptr, CONST char *cptr) { int32 drv, i, p; t_stat r; diff --git a/PDP10/ka10_sys.c b/PDP10/ka10_sys.c index 3b31210..2f1c201 100644 --- a/PDP10/ka10_sys.c +++ b/PDP10/ka10_sys.c @@ -359,7 +359,7 @@ return SCPE_OK; /* Master loader */ -t_stat sim_load (FILE *fileref, char *cptr, char *fnam, int flag) +t_stat sim_load (FILE *fileref, CONST char *cptr, CONST char *fnam, int flag) { uint64 data; int32 wc, fmt; @@ -779,21 +779,18 @@ return (ind | (xr << 18) | val); status = error status */ -t_stat parse_sym (char *cptr, t_addr addr, UNIT *uptr, t_value *val, int32 sw) +t_stat parse_sym (CONST char *cptr, t_addr addr, UNIT *uptr, t_value *val, int32 sw) { int32 cflag, i, j; t_value ac, dev; t_stat r; -char gbuf[CBUFSIZE]; +char gbuf[CBUFSIZE], cbuf[2*CBUFSIZE]; cflag = (uptr == NULL) || (uptr == &cpu_unit); while (isspace (*cptr)) cptr++; -for (i = 0; i < 6; i++) { - if (cptr[i] == 0) { - for (j = i + 1; j <= 6; j++) cptr[j] = 0; - break; - } - } +memset (cbuf, '\0', sizeof(cbuf)); +strncpy (cbuf, cptr, sizeof(cbuf)-7); +cptr = cbuf; if ((sw & SWMASK ('A')) || ((*cptr == '\'') && cptr++)) { /* ASCII char? */ if (cptr[0] == 0) /* must have 1 char */ return SCPE_ARG; diff --git a/Visual Studio Projects/0ReadMe_Projects.txt b/Visual Studio Projects/0ReadMe_Projects.txt new file mode 100644 index 0000000..f349b7b --- /dev/null +++ b/Visual Studio Projects/0ReadMe_Projects.txt @@ -0,0 +1,56 @@ +This dirctory contains a set of Visual Studio 2008 build projects for the +current simh code base. When used (with Visual Studio Express 2008 or +Visual Studio Express 2010) it populates a directory tree under the BIN +directory of the Simh distribution for temporary build files and produces +resulting executables in the BIN/NT/Win32-Debug or BIN/NT/Win32-Release +directories (depending on whether you target a Debug or Release build). + +The Visual Studio Projects expect that a winpcap developer pack and the +Posix threads for windows package are available in a directory parallel +to the simh directory. + +For Example, the directory structure should look like: + + .../simh/sim-master/VAX/vax_cpu.c + .../simh/sim-master/scp.c + .../simh/sim-master/Visual Studio Projects/simh.sln + .../simh/sim-master/Visual Studio Projects/VAX.vcproj + .../simh/sim-master/BIN/Nt/Win32-Release/vax.exe + .../simh/windows-build/pthreads/pthread.h + .../simh/windows-build/winpcap/WpdPack/Include/pcap.h + .../simh/windows-build/libSDL/SDL2-2.0.3/include/SDL.h + +The contents of the windows-build directory can be downloaded from: + + https://github.com/simh/windows-build/archive/windows-build.zip + +Download and extract the contents of this zip file into the appropriate +place in your directory structure. You do not need to do anything else +but have this directory properly located. + +Network devices are capable of using pthreads to enhance their performance. +To realize these benefits, you must build the desire simulator with +USE_READER_THREAD defined. The relevant simulators which have network +support are all of the VAX simulators and the PDP11 simulator. + +Additionally, simulators which contain devices which use the asynchronous +APIs in sim_disk.c and sim_tape.c can also achieve greater performance by +leveraging pthreads to perform blocking I/O in separate threads. Currently +the simulators which have such devices are all of the VAX simulators and +the PDP11. To achieve these benefits the simulators must be built with +SIM_ASYNCH_IO defined. + +The project files in this directory build these simulators with support for +both network and asynchronous I/O. + +To build any of the supported simulators you should open the simh.sln file +in this directory. + +The installer for Visual Studio 2008 SP1 is available from: + +http://download.microsoft.com/download/E/8/E/E8EEB394-7F42-4963-A2D8-29559B738298/VS2008ExpressWithSP1ENUX1504728.iso + +If you are using a version of Visual Studio beyond Visual Studio 2008, then +your later version of Visual Studio will automatically convert the Visual +Studio 2008 project files. You should ignore any warnings produced by the +conversion process. diff --git a/Visual Studio Projects/ALTAIR.vcproj b/Visual Studio Projects/ALTAIR.vcproj new file mode 100644 index 0000000..49e56a4 --- /dev/null +++ b/Visual Studio Projects/ALTAIR.vcproj @@ -0,0 +1,325 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/AltairZ80.vcproj b/Visual Studio Projects/AltairZ80.vcproj new file mode 100644 index 0000000..2379aee --- /dev/null +++ b/Visual Studio Projects/AltairZ80.vcproj @@ -0,0 +1,473 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/B5500.vcproj b/Visual Studio Projects/B5500.vcproj new file mode 100644 index 0000000..dc7a958 --- /dev/null +++ b/Visual Studio Projects/B5500.vcproj @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/BESM6.vcproj b/Visual Studio Projects/BESM6.vcproj new file mode 100644 index 0000000..83f2c96 --- /dev/null +++ b/Visual Studio Projects/BESM6.vcproj @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/BuildROMs.vcproj b/Visual Studio Projects/BuildROMs.vcproj new file mode 100644 index 0000000..64c9512 --- /dev/null +++ b/Visual Studio Projects/BuildROMs.vcproj @@ -0,0 +1,209 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/ECLIPSE.vcproj b/Visual Studio Projects/ECLIPSE.vcproj new file mode 100644 index 0000000..9cda28e --- /dev/null +++ b/Visual Studio Projects/ECLIPSE.vcproj @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/FrontPanelTest.sln b/Visual Studio Projects/FrontPanelTest.sln new file mode 100644 index 0000000..024e047 --- /dev/null +++ b/Visual Studio Projects/FrontPanelTest.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual C++ Express 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FrontPanelTest", "FrontPanelTest.vcproj", "{F9583457-34AD-44BD-9A55-ECBF3016292A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F9583457-34AD-44BD-9A55-ECBF3016292A}.Debug|Win32.ActiveCfg = Debug|Win32 + {F9583457-34AD-44BD-9A55-ECBF3016292A}.Debug|Win32.Build.0 = Debug|Win32 + {F9583457-34AD-44BD-9A55-ECBF3016292A}.Release|Win32.ActiveCfg = Release|Win32 + {F9583457-34AD-44BD-9A55-ECBF3016292A}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Visual Studio Projects/FrontPanelTest.vcproj b/Visual Studio Projects/FrontPanelTest.vcproj new file mode 100644 index 0000000..e684a37 --- /dev/null +++ b/Visual Studio Projects/FrontPanelTest.vcproj @@ -0,0 +1,234 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/GRI.vcproj b/Visual Studio Projects/GRI.vcproj new file mode 100644 index 0000000..237b159 --- /dev/null +++ b/Visual Studio Projects/GRI.vcproj @@ -0,0 +1,317 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/H316.vcproj b/Visual Studio Projects/H316.vcproj new file mode 100644 index 0000000..300bf8e --- /dev/null +++ b/Visual Studio Projects/H316.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/HP2100.vcproj b/Visual Studio Projects/HP2100.vcproj new file mode 100644 index 0000000..a21e1cf --- /dev/null +++ b/Visual Studio Projects/HP2100.vcproj @@ -0,0 +1,445 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/HP3000.vcproj b/Visual Studio Projects/HP3000.vcproj new file mode 100644 index 0000000..6d81a85 --- /dev/null +++ b/Visual Studio Projects/HP3000.vcproj @@ -0,0 +1,385 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I1401.vcproj b/Visual Studio Projects/I1401.vcproj new file mode 100644 index 0000000..6d69a58 --- /dev/null +++ b/Visual Studio Projects/I1401.vcproj @@ -0,0 +1,337 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I1620.vcproj b/Visual Studio Projects/I1620.vcproj new file mode 100644 index 0000000..e63b4d7 --- /dev/null +++ b/Visual Studio Projects/I1620.vcproj @@ -0,0 +1,337 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7000.vcproj b/Visual Studio Projects/I7000.vcproj new file mode 100644 index 0000000..192e32b --- /dev/null +++ b/Visual Studio Projects/I7000.vcproj @@ -0,0 +1,311 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I701.vcproj b/Visual Studio Projects/I701.vcproj new file mode 100644 index 0000000..63940c6 --- /dev/null +++ b/Visual Studio Projects/I701.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7010.vcproj b/Visual Studio Projects/I7010.vcproj new file mode 100644 index 0000000..ce60cad --- /dev/null +++ b/Visual Studio Projects/I7010.vcproj @@ -0,0 +1,373 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I704.vcproj b/Visual Studio Projects/I704.vcproj new file mode 100644 index 0000000..3047759 --- /dev/null +++ b/Visual Studio Projects/I704.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7070.vcproj b/Visual Studio Projects/I7070.vcproj new file mode 100644 index 0000000..982a81e --- /dev/null +++ b/Visual Studio Projects/I7070.vcproj @@ -0,0 +1,373 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7080.vcproj b/Visual Studio Projects/I7080.vcproj new file mode 100644 index 0000000..95c79b4 --- /dev/null +++ b/Visual Studio Projects/I7080.vcproj @@ -0,0 +1,377 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7090.vcproj b/Visual Studio Projects/I7090.vcproj new file mode 100644 index 0000000..9d5778c --- /dev/null +++ b/Visual Studio Projects/I7090.vcproj @@ -0,0 +1,377 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/I7094.vcproj b/Visual Studio Projects/I7094.vcproj new file mode 100644 index 0000000..93bef6c --- /dev/null +++ b/Visual Studio Projects/I7094.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/IBM1130.vcproj b/Visual Studio Projects/IBM1130.vcproj new file mode 100644 index 0000000..1eb1f1e --- /dev/null +++ b/Visual Studio Projects/IBM1130.vcproj @@ -0,0 +1,425 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/ID16.vcproj b/Visual Studio Projects/ID16.vcproj new file mode 100644 index 0000000..4d59ef2 --- /dev/null +++ b/Visual Studio Projects/ID16.vcproj @@ -0,0 +1,365 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/ID32.vcproj b/Visual Studio Projects/ID32.vcproj new file mode 100644 index 0000000..405ed92 --- /dev/null +++ b/Visual Studio Projects/ID32.vcproj @@ -0,0 +1,365 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/MicroVAX1.vcproj b/Visual Studio Projects/MicroVAX1.vcproj new file mode 100644 index 0000000..b0f1ad5 --- /dev/null +++ b/Visual Studio Projects/MicroVAX1.vcproj @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/MicroVAX2.vcproj b/Visual Studio Projects/MicroVAX2.vcproj new file mode 100644 index 0000000..87e24f6 --- /dev/null +++ b/Visual Studio Projects/MicroVAX2.vcproj @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/NOVA.vcproj b/Visual Studio Projects/NOVA.vcproj new file mode 100644 index 0000000..d310702 --- /dev/null +++ b/Visual Studio Projects/NOVA.vcproj @@ -0,0 +1,353 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP1.vcproj b/Visual Studio Projects/PDP1.vcproj new file mode 100644 index 0000000..ef20bc8 --- /dev/null +++ b/Visual Studio Projects/PDP1.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP10-KA.vcproj b/Visual Studio Projects/PDP10-KA.vcproj new file mode 100644 index 0000000..b76efb2 --- /dev/null +++ b/Visual Studio Projects/PDP10-KA.vcproj @@ -0,0 +1,363 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP10-KI.vcproj b/Visual Studio Projects/PDP10-KI.vcproj new file mode 100644 index 0000000..2869776 --- /dev/null +++ b/Visual Studio Projects/PDP10-KI.vcproj @@ -0,0 +1,315 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP10.vcproj b/Visual Studio Projects/PDP10.vcproj new file mode 100644 index 0000000..7665a58 --- /dev/null +++ b/Visual Studio Projects/PDP10.vcproj @@ -0,0 +1,576 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP11.vcproj b/Visual Studio Projects/PDP11.vcproj new file mode 100644 index 0000000..15308d5 --- /dev/null +++ b/Visual Studio Projects/PDP11.vcproj @@ -0,0 +1,728 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP15.vcproj b/Visual Studio Projects/PDP15.vcproj new file mode 100644 index 0000000..97e3799 --- /dev/null +++ b/Visual Studio Projects/PDP15.vcproj @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP4.vcproj b/Visual Studio Projects/PDP4.vcproj new file mode 100644 index 0000000..e1ddc7f --- /dev/null +++ b/Visual Studio Projects/PDP4.vcproj @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP7.vcproj b/Visual Studio Projects/PDP7.vcproj new file mode 100644 index 0000000..3f02df4 --- /dev/null +++ b/Visual Studio Projects/PDP7.vcproj @@ -0,0 +1,357 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP8.vcproj b/Visual Studio Projects/PDP8.vcproj new file mode 100644 index 0000000..dcb4229 --- /dev/null +++ b/Visual Studio Projects/PDP8.vcproj @@ -0,0 +1,377 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDP9.vcproj b/Visual Studio Projects/PDP9.vcproj new file mode 100644 index 0000000..b8f94e2 --- /dev/null +++ b/Visual Studio Projects/PDP9.vcproj @@ -0,0 +1,353 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/PDQ3.vcproj b/Visual Studio Projects/PDQ3.vcproj new file mode 100644 index 0000000..25db7ce --- /dev/null +++ b/Visual Studio Projects/PDQ3.vcproj @@ -0,0 +1,337 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/Pre-Build-Event.cmd b/Visual Studio Projects/Pre-Build-Event.cmd new file mode 100644 index 0000000..2d591ef --- /dev/null +++ b/Visual Studio Projects/Pre-Build-Event.cmd @@ -0,0 +1,301 @@ +rem +rem This script performs several maintenance functions prior to building +rem simh projects. Some of these funtions are optional and depend on the +rem needs of the project being built, and others are generic and are always +rem performed. +rem +rem The optional activities are invoked by passing parameters to this +rem procedure. The parameters are: +rem ROM To run the BuildROMs program prior to executing a project +rem build. This program verifies that the include files containing +rem ROM images are consistent with the ROM images from which they +rem are derived. +rem BUILD To validate that the required dependent libraries and include +rem files are available in the directory ..\..\windows-build\ +rem These libraries currently include winpcap and pthreads and +rem optionally SDL and LIBPCRE. +rem LIBSDL To validate that the required dependent SDL libraries and include +rem files are available in the directory ..\..\windows-build\ +rem LIBPCRE To validate that the required dependent PCRE libraries and include +rem files are available in the directory ..\..\windows-build\ +rem +rem In addition to the optional activities mentioned above, other activities +rem are also performed. These include: +rem - confirming that if the current source is a clone of the simh +rem git repository, then then git hooks which manage making the +rem git commit hash available during builds are properly installed +rem in the repository hooks directory. When the githooks are installed +rem the current commit id is generated if git.exe is available in the +rem current path. +rem - performing the activities which make the git repository commit id +rem available in an include file during compiles. +rem - Converting Visual Studio Projects to a form which will produce +rem binaries which run on Windows XP if the current build environment +rem supports it and the correct components are installed. +rem This activity is triggered by the first argument being the name +rem of a the current Visual Studio project file. This argument MUST +rem only be provided on a single project which invokes this procedure +rem AND that project should be one which all other projects in a +rem solution are dependent on. +rem +rem + +if "%~x1" == ".vcproj" goto _done_xp_check +if not "%~x1" == ".vcxproj" goto _done_project +if exist PlatformToolset.fix goto _project_cleanup +findstr PlatformToolset %1 >NUL +if ERRORLEVEL 1 goto _next_arg +findstr PlatformToolset %1 | findstr _xp >NUL +if not ERRORLEVEL 1 goto _done_xp_check +echo warning: The %~n1.exe binary can't run on windows XP. +set _XP_Support_Available= +for /r "%PROGRAMDATA%" %%z in (packages\XPSupport\Win_XPSupport.msi) do if exist "%%z" set _XP_Support_Available=1 +if "" == "%_XP_Support_Available%" goto _done_xp_check +if exist PlatformToolset.fix exit /b 1 +echo. >>PlatformToolset.fix +if ERRORLEVEL 1 exit /B 1 +echo warning: Adding Windows XP suppport to all project files at %TIME% + +echo Set objFSO = CreateObject("Scripting.FileSystemObject") >>%1.fix.vbs +echo Set objFile = objFSO.OpenTextFile(Wscript.Arguments(0), 1) >>%1.fix.vbs +echo. >>%1.fix.vbs +echo strText = objFile.ReadAll >>%1.fix.vbs +echo objFile.Close >>%1.fix.vbs +echo strNewText = Replace(strText, "", "_xp") >>%1.fix.vbs +echo. >>%1.fix.vbs +echo Set objFile = objFSO.OpenTextFile(Wscript.Arguments(0), 2) >>%1.fix.vbs +echo objFile.Write strNewText >>%1.fix.vbs +echo objFile.Close >>%1.fix.vbs + +call :_Fix_PlatformToolset %1 %1 +for %%f in (*.vcxproj) do call :_Fix_PlatformToolset %1 %%f +call :_GitHooks +del %1.fix.vbs +rem wait a bit here to allow a parallel build of the to complete additional projects +echo Error: Reload the changed projects and start the build again +exit /B 1 +:_Fix_PlatformToolset +findstr PlatformToolset %2 >NUL +if ERRORLEVEL 1 exit /B 0 +findstr PlatformToolset %2 | findstr _xp >NUL +if not ERRORLEVEL 1 exit /B 0 +echo Adding XP support to project %2 +cscript %1.fix.vbs %2 > NUL 2>&1 +exit /B 0 +:_done_xp_check +shift +goto _done_project +:_project_cleanup +shift +del PlatformToolset.fix +:_done_project +if exist PlatformToolset.fix echo error: Reload any changed projects and rebuild again, +if exist PlatformToolset.fix exit /b 1 + + +:_next_arg +if "%1" == "" goto _done_args +set _arg= +if /I "%1" == "ROM" set _arg=ROM +if /I "%1" == "BUILD" set _arg=BUILD +if /I "%1" == "LIBSDL" set _arg=LIBSDL +if /I "%1" == "LIBPCRE" set _arg=LIBPCRE +if /I "%1" == "FINDFONT" set _arg=FINDFONT +if "%_arg%" == "" echo *** warning *** unknown parameter %1 +if /I "%1" == "FINDFONT" set _X_FontName=%2 +if /I "%1" == "FINDFONT" set _X_FontIncludeName=%3 +if /I "%_arg%" == "FINDFONT" shift +if /I "%_arg%" == "FINDFONT" shift +if not "%_arg%" == "" set _X_%_arg%=%_arg% +shift +goto _next_arg +:_done_args +rem some arguments implicitly require BUILD to also be set to have +rem any meaning. These are LIBSDL, LIBPCRE and FINDFONT +if not "%_X_FINDFONT%" == "" set _X_BUILD=BUILD +if not "%_X_LIBSDL%" == "" set _X_BUILD=BUILD +if not "%_X_LIBPCRE%" == "" set _X_BUILD=BUILD + + +:_do_rom +if "%_X_ROM%" == "" goto _done_rom +pushd .. +SET _BLD= +if exist BIN\NT\Win32-Debug\BuildROMs.exe SET _BLD=BIN\NT\Win32-Debug\BuildROMs.exe +if exist BIN\NT\Win32-Release\BuildROMs.exe SET _BLD=BIN\NT\Win32-Release\BuildROMs.exe +if "%_BLD%" == "" echo ************************************************ +if "%_BLD%" == "" echo ************************************************ +if "%_BLD%" == "" echo ** Project dependencies not correct. ** +if "%_BLD%" == "" echo ** This project should depend on BuildROMs. ** +if "%_BLD%" == "" echo ************************************************ +if "%_BLD%" == "" echo ************************************************ +if "%_BLD%" == "" exit 1 +%_BLD% +popd +:_done_rom + +:_check_build +if "%_X_BUILD%" == "" goto _done_build +if not exist ../../windows-build-windows-build goto _check_files +rem This is a newly extracted windows-build.zip file with the +rem top level directory named as it existed in the zip file. +rem We rename that top level directory. If a previous one already +rem exists, that will be an older version, so we try to remove +rem that one first. +if exist ..\..\windows-build rmdir /s /q ..\..\windows-build +ren ..\..\windows-build-windows-build windows-build +if errorlevel 1 goto _notice3 +if exist ../../windows-build-windows-build goto _notice3 +:_check_files +if not exist ../../windows-build/winpcap/Wpdpack/Include/pcap.h goto _notice1 +if not exist ../../windows-build/pthreads/pthread.h goto _notice1 +findstr "/c:_MSC_VER >= 1900" ..\..\windows-build\pthreads\pthread.h >NUL +if ERRORLEVEL 1 goto _notice2 +if "%_X_LIBSDL%" == "" goto _done_libsdl +if not exist ../../windows-build/libSDL/SDL2-2.0.3/include/SDL.h goto _notice2 +if not exist "..\..\windows-build\libpng-1.6.18\projects\vstudio\Release Library\*" goto _notice2 +if not exist "../../windows-build/libSDL/Microsoft DirectX SDK (June 2010)/Lib/x86/dxguid.lib" goto _notice2 +findstr "/c:LIBSDL_FTOL2_SSE" ..\..\windows-build\Windows-Build_Versions.txt >NUL +if ERRORLEVEL 1 goto _notice2 +findstr "/c:LIBSDL_ALLMUL" ..\..\windows-build\Windows-Build_Versions.txt >NUL +if ERRORLEVEL 1 goto _notice2 +:_done_libsdl +if "%_X_LIBPCRE%" == "" goto _done_libpcre +if not exist ../../windows-build/PCRE/include/pcreposix.h goto _notice2 +:_done_libpcre +if "%_X_FINDFONT%" == "" goto _done_findfont +if not exist ../../windows-build/libSDL/SDL2_ttf-2.0.12/SDL_ttf.h goto _notice2 +if "%_X_FontName%" == "" goto _done_findfont +echo. >%_X_FontIncludeName%.temp +set FONTFILE=%windir%\Fonts\%_X_FontName% +if not exist "%FONTFILE%" echo Can't find font %_X_FontName% +if not exist "%FONTFILE%" goto _done_findfont +set FONTFILE=%FONTFILE:\=/% +echo #define FONTFILE %FONTFILE% >>%_X_FontIncludeName%.temp +if not exist %_X_FontIncludeName% goto _found_font +fc %_X_FontIncludeName%.temp %_X_FontIncludeName% >NUL +if NOT ERRORLEVEL 1 goto _done_findfont +:_found_font +echo Found: %FONTFILE% +move /Y %_X_FontIncludeName%.temp %_X_FontIncludeName% >NUL +:_done_findfont +if exist %_X_FontIncludeName%.temp del %_X_FontIncludeName%.temp +call :FindVCVersion _VC_VER +if not exist "..\..\windows-build\libpng-1.6.18\projects\Release Library" goto _setup_library +if not exist "..\..\windows-build\libpng-1.6.18\projects\Release Library\VisualC.version" set _LIB_VC_VER=9 +if exist "..\..\windows-build\libpng-1.6.18\projects\Release Library\VisualC.version" for /f "usebackq delims=." %%v in (`type "..\..\windows-build\libpng-1.6.18\projects\Release Library\VisualC.version"`) do set _LIB_VC_VER=%%v +if %_LIB_VC_VER% EQU %_VC_VER% goto _done_library +if %_VC_VER% GEQ 14 goto _check_new_library +if %_LIB_VC_VER% LSS 14 goto _done_library +goto _setup_library +:_check_new_library +if %_LIB_VC_VER% GEQ 14 godo _done_library +:_setup_library +if %_VC_VER% LSS 14 set _VCLIB_DIR_=vstudio 2008 +if %_VC_VER% GEQ 14 set _VCLIB_DIR_=vstudio +if exist "..\..\windows-build\libpng-1.6.18\projects\Release Library" rmdir/s/q "..\..\windows-build\libpng-1.6.18\projects\Release Library" +if exist "..\..\windows-build\libpng-1.6.18\projects\Debug Library" rmdir/s/q "..\..\windows-build\libpng-1.6.18\projects\Debug Library" +xcopy /S /I "..\..\windows-build\libpng-1.6.18\projects\%_VCLIB_DIR_%\Release Library\*" "..\..\windows-build\libpng-1.6.18\projects\Release Library\" > NUL 2>&1 +xcopy /S /I "..\..\windows-build\libpng-1.6.18\projects\%_VCLIB_DIR_%\Debug Library\*" "..\..\windows-build\libpng-1.6.18\projects\Debug Library\" > NUL 2>&1 +set _VCLIB_DIR_= +set _LIB_VC_VER= +:_done_library +goto _done_build +:_notice1 +echo ***************************************************** +echo ***************************************************** +echo ** The required build support is not available. ** +echo ***************************************************** +echo ***************************************************** +set _exit_reason=The required build support is not available. +goto _ProjectInfo +:_notice2 +echo ***************************************************** +echo ***************************************************** +echo ** The required build support is out of date. ** +echo ***************************************************** +echo ***************************************************** +set _exit_reason=The required build support is out of date. +goto _ProjectInfo +:_notice3 +echo ***************************************************** +echo ***************************************************** +echo ** Can't rename ../../windows-build-windows-build ** +echo ** to ../../windows-build ** +echo ***************************************************** +echo ***************************************************** +set _exit_reason=Can't rename ../../windows-build-windows-build to ../../windows-build +goto _ProjectInfo +:_ProjectInfo +type 0ReadMe_Projects.txt +echo error: %_exit_reason% +echo error: Review the Output Tab for more details. +exit 1 +:_done_build + +:_GitHooks +if not exist ..\.git goto _done_hooks +if exist ..\.git\hooks\post-commit goto _done_hooks +echo ***************************************************** +echo ***************************************************** +echo ** Installing git hooks in newly cloned repository ** +echo ***************************************************** +echo ***************************************************** +copy /y git-hooks\post* ..\.git\hooks\ +call :WhereInPath git.exe > NUL 2>&1 +if %ERRORLEVEL% neq 0 goto _done_hooks +pushd .. +git log -1 "--pretty=%%H" >.git-commit-id +popd +:_done_hooks + +:_SetId +rem +rem A race condition exists while creating the .git-commit-id.h file. +rem This race can happen at the beginning of a parallel build where +rem several projects can start execution at almost the same time. +rem +SET GIT_COMMIT_ID= +if not exist ..\.git-commit-id goto _NoId +for /F %%i in (..\.git-commit-id) do SET GIT_COMMIT_ID=%%i +:_NoId +SET OLD_GIT_COMMIT_ID= +if not exist .git-commit-id.h echo.>.git-commit-id.h +for /F "tokens=3" %%i in (.git-commit-id.h) do SET OLD_GIT_COMMIT_ID=%%i +if "%GIT_COMMIT_ID%" equ "%OLD_GIT_COMMIT_ID%" goto _IdGood +echo Generating updated .git-commit-id.h containing id %GIT_COMMIT_ID% +echo #define SIM_GIT_COMMIT_ID %GIT_COMMIT_ID% >.git-commit-id.h +if errorlevel 1 echo Retrying... +if errorlevel 1 goto _SetId +:_IdGood +:_done_id +goto :EOF + +:WhereInPath +if "%~$PATH:1" NEQ "" exit /B 0 +exit /B 1 + +:WhichInPath +if "%~$PATH:1" EQU "" exit /B 1 +set %2=%~$PATH:1 +exit /B 0 + +:FindVCVersion +call :WhichInPath cl.exe _VC_CL_ +for /f "tokens=2-8 delims=\" %%a in ("%_VC_CL_%") do call :VCCheck _VC_VER_NUM_ "%%a" "%%b" "%%c" "%%d" "%%e" "%%f" "%%g" +for /f "delims=." %%a in ("%_VC_VER_NUM_%") do set %1=%%a +set _VC_CL= +exit /B 0 + +:VCCheck +set _VC_TMP=%1 +:_VCCheck_Next +shift +set _VC_TMP_=%~1 +if "%_VC_TMP_%" equ "" goto _VCCheck_Done +if "%_VC_TMP_:~0,24%" EQU "Microsoft Visual Studio " set %_VC_TMP%=%_VC_TMP_:Microsoft Visual Studio =% +goto _VCCheck_Next +:_VCCheck_Done +set _VC_TMP_= +set _VC_TMP= +exit /B 0 diff --git a/Visual Studio Projects/S3.vcproj b/Visual Studio Projects/S3.vcproj new file mode 100644 index 0000000..63ffafc --- /dev/null +++ b/Visual Studio Projects/S3.vcproj @@ -0,0 +1,329 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/SAGE.vcproj b/Visual Studio Projects/SAGE.vcproj new file mode 100644 index 0000000..771c22e --- /dev/null +++ b/Visual Studio Projects/SAGE.vcproj @@ -0,0 +1,388 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/SDS.vcproj b/Visual Studio Projects/SDS.vcproj new file mode 100644 index 0000000..d160a44 --- /dev/null +++ b/Visual Studio Projects/SDS.vcproj @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/SSEM.vcproj b/Visual Studio Projects/SSEM.vcproj new file mode 100644 index 0000000..192e32b --- /dev/null +++ b/Visual Studio Projects/SSEM.vcproj @@ -0,0 +1,311 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/Simh.sln b/Visual Studio Projects/Simh.sln new file mode 100644 index 0000000..89aa850 --- /dev/null +++ b/Visual Studio Projects/Simh.sln @@ -0,0 +1,473 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual C++ Express 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VAX", "VAX.vcproj", "{D5D873F7-D286-43E7-958A-3D838FAA0856}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VAX780", "VAX780.vcproj", "{D5D873F7-D286-43E7-958A-3D83DEADBEEF}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AltairZ80", "AltairZ80.vcproj", "{BC7F37AD-7414-43C3-829D-214CD1113D67}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ALTAIR", "ALTAIR.vcproj", "{1C602310-C406-4446-85C3-E5AE0E836120}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GRI", "GRI.vcproj", "{611E140C-8403-4FD8-AF53-CE01C8452B34}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HP2100", "HP2100.vcproj", "{7A9428F5-593C-4217-B8FE-980E249D3DB9}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "H316", "H316.vcproj", "{C915B408-80D8-4925-BF7B-0469436B33BF}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ID16", "ID16.vcproj", "{D90C77B3-A3E7-40D3-BB88-18A4EF1C001D}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ID32", "ID32.vcproj", "{324EF17B-1683-48B5-824D-FACF17AEB27B}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP8", "PDP8.vcproj", "{5EB65E13-1E6A-46A4-B7FE-EC87F8702067}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP10", "PDP10.vcproj", "{A39C0AFE-BDE5-4236-B740-AC710FCA1DA2}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "S3", "S3.vcproj", "{927C3BD9-BD0C-4A23-99F9-573A40236509}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDS", "SDS.vcproj", "{750762C6-A2AF-40BA-A006-5E68002C1E87}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP11", "PDP11.vcproj", "{49499E1B-5019-4B98-9DC7-2E73306D5578}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP1", "PDP1.vcproj", "{CB017838-5DC5-4B9D-A8F7-7B36AA4A3331}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I1401", "I1401.vcproj", "{C92737AD-07CC-492F-AA76-D169CEF5BBAB}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I1620", "I1620.vcproj", "{089C9C0B-C4F7-4923-86C4-F14BF5D61821}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IBM1130", "IBM1130.vcproj", "{D593C954-5115-4D15-ABDB-01B66006FF6F}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP15", "PDP15.vcproj", "{44C07AA4-6D56-45ED-8393-18A23E76B758}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP9", "PDP9.vcproj", "{9D589BCA-9E10-4FFA-B43F-DDFA91C1C098}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP7", "PDP7.vcproj", "{0F8B9E39-56A7-45BE-A68F-04F7EB8EF8A3}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP4", "PDP4.vcproj", "{C51841F3-BD47-41C3-946C-20F893FB5A23}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NOVA", "NOVA.vcproj", "{9B55ACBB-C29A-40EB-98BF-D1047912389E}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ECLIPSE", "ECLIPSE.vcproj", "{FF632F3D-9F62-481D-A5C7-AD090F46143C}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lgp", "lgp.vcproj", "{927C3BD9-BD0C-4A23-99F9-5ABC40236509}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I7094", "I7094.vcproj", "{927C3BD9-BD0C-4A23-99F9-DEAD402BEEF9}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "swtp6800mp-a", "swtp6800mp-a.vcproj", "{0ABAF350-853E-4A8F-8435-B583E29FB78C}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "swtp6800mp-a2", "swtp6800mp-a2.vcproj", "{A0BAF350-853E-4A8F-8435-B583E29FFACE}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BuildROMs", "BuildROMs.vcproj", "{D40F3AF1-EEE7-4432-9807-2AD287B490F8}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VAX730", "VAX730.vcproj", "{C526F7F2-9476-44BC-B1E9-9522B693BEA7}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VAX750", "VAX750.vcproj", "{43A9CF64-5705-4FB7-B837-ED9AAFF97DAC}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MicroVAX1", "MicroVAX1.vcproj", "{B3671ABB-4FFF-4EEB-8A5B-06716C9BCE9E}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rtVAX1000", "rtVAX1000.vcproj", "{E359921B-DC18-42ED-AFB9-1FC603B9C1B3}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MicroVAX2", "MicroVAX2.vcproj", "{3048F582-98C9-447D-BBB9-6F969467D4EA}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TX-0", "TX-0.vcproj", "{24BC7F75-FB56-44A9-BB7C-78AE6A694D0C}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VAX8600", "VAX8600.vcproj", "{F5C22D72-460E-43CD-9AC6-6D6AC517BD1F}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SSEM", "SSEM.vcproj", "{48DA6BA8-23E1-4F0D-959C-48C8576494DA}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "alpha", "alpha.vcproj", "{14C5D369-E4A1-4DA2-B23C-B49367874F7B}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sigma", "sigma.vcproj", "{7DDB6DF6-3837-4DE3-80D7-63181195021F}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SAGE", "SAGE.vcproj", "{9D0DAC36-2C75-41CD-905C-93B2F5ADF9E2}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDQ3", "PDQ3.vcproj", "{D4F5761A-B543-40ED-9892-12A0255C2B6D}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BESM6", "BESM6.vcproj", "{A8D46C10-8F3F-47CA-AD5F-E3BB7C4A3678}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "isys8010", "isys8010.vcproj", "{2FB5B6EE-796F-429F-980E-14E822837105}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "isys8020", "isys8020.vcproj", "{9BBA76FE-45DD-4902-9421-BEA3EC2DCDB0}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "B5500", "B5500.vcproj", "{BA514FA1-D029-4D25-91CC-255E5953FF6E}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HP3000", "HP3000.vcproj", "{B3E35063-CB41-4F77-BFCA-49BB316B0EDB}" + ProjectSection(ProjectDependencies) = postProject + {D40F3AF1-EEE7-4432-9807-2AD287B490F8} = {D40F3AF1-EEE7-4432-9807-2AD287B490F8} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I7090", "I7090.vcproj", "{33EE34FC-A12F-47FE-9FD6-8B74D08718C7}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I7010", "I7010.vcproj", "{55A727F0-B5C8-48E8-9EF2-D5DAF679C520}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I7070", "I7070.vcproj", "{F55D43D3-AD63-4B19-B67A-47064227F3E3}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I704", "I704.vcproj", "{91A7D475-1238-4872-BEAE-143E1FCEA297}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I701", "I701.vcproj", "{F1F44607-FB9E-428C-AD8F-56F98699D121}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "I7080", "I7080.vcproj", "{BF1E708D-D374-4DE1-A0D3-6D8DB4B4F7FA}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP10-KA", "PDP10-KA.vcproj", "{01F75DE5-8049-4C73-A325-B1F9964CE709}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PDP10-KI", "PDP10-KI.vcproj", "{0BA63EC5-BD4F-44FB-AE89-7DD2C84CB1D9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D5D873F7-D286-43E7-958A-3D838FAA0856}.Debug|Win32.ActiveCfg = Debug|Win32 + {D5D873F7-D286-43E7-958A-3D838FAA0856}.Debug|Win32.Build.0 = Debug|Win32 + {D5D873F7-D286-43E7-958A-3D838FAA0856}.Release|Win32.ActiveCfg = Release|Win32 + {D5D873F7-D286-43E7-958A-3D838FAA0856}.Release|Win32.Build.0 = Release|Win32 + {D5D873F7-D286-43E7-958A-3D83DEADBEEF}.Debug|Win32.ActiveCfg = Debug|Win32 + {D5D873F7-D286-43E7-958A-3D83DEADBEEF}.Debug|Win32.Build.0 = Debug|Win32 + {D5D873F7-D286-43E7-958A-3D83DEADBEEF}.Release|Win32.ActiveCfg = Release|Win32 + {D5D873F7-D286-43E7-958A-3D83DEADBEEF}.Release|Win32.Build.0 = Release|Win32 + {BC7F37AD-7414-43C3-829D-214CD1113D67}.Debug|Win32.ActiveCfg = Debug|Win32 + {BC7F37AD-7414-43C3-829D-214CD1113D67}.Debug|Win32.Build.0 = Debug|Win32 + {BC7F37AD-7414-43C3-829D-214CD1113D67}.Release|Win32.ActiveCfg = Release|Win32 + {BC7F37AD-7414-43C3-829D-214CD1113D67}.Release|Win32.Build.0 = Release|Win32 + {1C602310-C406-4446-85C3-E5AE0E836120}.Debug|Win32.ActiveCfg = Debug|Win32 + {1C602310-C406-4446-85C3-E5AE0E836120}.Debug|Win32.Build.0 = Debug|Win32 + {1C602310-C406-4446-85C3-E5AE0E836120}.Release|Win32.ActiveCfg = Release|Win32 + {1C602310-C406-4446-85C3-E5AE0E836120}.Release|Win32.Build.0 = Release|Win32 + {611E140C-8403-4FD8-AF53-CE01C8452B34}.Debug|Win32.ActiveCfg = Debug|Win32 + {611E140C-8403-4FD8-AF53-CE01C8452B34}.Debug|Win32.Build.0 = Debug|Win32 + {611E140C-8403-4FD8-AF53-CE01C8452B34}.Release|Win32.ActiveCfg = Release|Win32 + {611E140C-8403-4FD8-AF53-CE01C8452B34}.Release|Win32.Build.0 = Release|Win32 + {7A9428F5-593C-4217-B8FE-980E249D3DB9}.Debug|Win32.ActiveCfg = Debug|Win32 + {7A9428F5-593C-4217-B8FE-980E249D3DB9}.Debug|Win32.Build.0 = Debug|Win32 + {7A9428F5-593C-4217-B8FE-980E249D3DB9}.Release|Win32.ActiveCfg = Release|Win32 + {7A9428F5-593C-4217-B8FE-980E249D3DB9}.Release|Win32.Build.0 = Release|Win32 + {C915B408-80D8-4925-BF7B-0469436B33BF}.Debug|Win32.ActiveCfg = Debug|Win32 + {C915B408-80D8-4925-BF7B-0469436B33BF}.Debug|Win32.Build.0 = Debug|Win32 + {C915B408-80D8-4925-BF7B-0469436B33BF}.Release|Win32.ActiveCfg = Release|Win32 + {C915B408-80D8-4925-BF7B-0469436B33BF}.Release|Win32.Build.0 = Release|Win32 + {D90C77B3-A3E7-40D3-BB88-18A4EF1C001D}.Debug|Win32.ActiveCfg = Debug|Win32 + {D90C77B3-A3E7-40D3-BB88-18A4EF1C001D}.Debug|Win32.Build.0 = Debug|Win32 + {D90C77B3-A3E7-40D3-BB88-18A4EF1C001D}.Release|Win32.ActiveCfg = Release|Win32 + {D90C77B3-A3E7-40D3-BB88-18A4EF1C001D}.Release|Win32.Build.0 = Release|Win32 + {324EF17B-1683-48B5-824D-FACF17AEB27B}.Debug|Win32.ActiveCfg = Debug|Win32 + {324EF17B-1683-48B5-824D-FACF17AEB27B}.Debug|Win32.Build.0 = Debug|Win32 + {324EF17B-1683-48B5-824D-FACF17AEB27B}.Release|Win32.ActiveCfg = Release|Win32 + {324EF17B-1683-48B5-824D-FACF17AEB27B}.Release|Win32.Build.0 = Release|Win32 + {5EB65E13-1E6A-46A4-B7FE-EC87F8702067}.Debug|Win32.ActiveCfg = Debug|Win32 + {5EB65E13-1E6A-46A4-B7FE-EC87F8702067}.Debug|Win32.Build.0 = Debug|Win32 + {5EB65E13-1E6A-46A4-B7FE-EC87F8702067}.Release|Win32.ActiveCfg = Release|Win32 + {5EB65E13-1E6A-46A4-B7FE-EC87F8702067}.Release|Win32.Build.0 = Release|Win32 + {A39C0AFE-BDE5-4236-B740-AC710FCA1DA2}.Debug|Win32.ActiveCfg = Debug|Win32 + {A39C0AFE-BDE5-4236-B740-AC710FCA1DA2}.Debug|Win32.Build.0 = Debug|Win32 + {A39C0AFE-BDE5-4236-B740-AC710FCA1DA2}.Release|Win32.ActiveCfg = Release|Win32 + {A39C0AFE-BDE5-4236-B740-AC710FCA1DA2}.Release|Win32.Build.0 = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-573A40236509}.Debug|Win32.ActiveCfg = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-573A40236509}.Debug|Win32.Build.0 = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-573A40236509}.Release|Win32.ActiveCfg = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-573A40236509}.Release|Win32.Build.0 = Release|Win32 + {750762C6-A2AF-40BA-A006-5E68002C1E87}.Debug|Win32.ActiveCfg = Debug|Win32 + {750762C6-A2AF-40BA-A006-5E68002C1E87}.Debug|Win32.Build.0 = Debug|Win32 + {750762C6-A2AF-40BA-A006-5E68002C1E87}.Release|Win32.ActiveCfg = Release|Win32 + {750762C6-A2AF-40BA-A006-5E68002C1E87}.Release|Win32.Build.0 = Release|Win32 + {49499E1B-5019-4B98-9DC7-2E73306D5578}.Debug|Win32.ActiveCfg = Debug|Win32 + {49499E1B-5019-4B98-9DC7-2E73306D5578}.Debug|Win32.Build.0 = Debug|Win32 + {49499E1B-5019-4B98-9DC7-2E73306D5578}.Release|Win32.ActiveCfg = Release|Win32 + {49499E1B-5019-4B98-9DC7-2E73306D5578}.Release|Win32.Build.0 = Release|Win32 + {CB017838-5DC5-4B9D-A8F7-7B36AA4A3331}.Debug|Win32.ActiveCfg = Debug|Win32 + {CB017838-5DC5-4B9D-A8F7-7B36AA4A3331}.Debug|Win32.Build.0 = Debug|Win32 + {CB017838-5DC5-4B9D-A8F7-7B36AA4A3331}.Release|Win32.ActiveCfg = Release|Win32 + {CB017838-5DC5-4B9D-A8F7-7B36AA4A3331}.Release|Win32.Build.0 = Release|Win32 + {C92737AD-07CC-492F-AA76-D169CEF5BBAB}.Debug|Win32.ActiveCfg = Debug|Win32 + {C92737AD-07CC-492F-AA76-D169CEF5BBAB}.Debug|Win32.Build.0 = Debug|Win32 + {C92737AD-07CC-492F-AA76-D169CEF5BBAB}.Release|Win32.ActiveCfg = Release|Win32 + {C92737AD-07CC-492F-AA76-D169CEF5BBAB}.Release|Win32.Build.0 = Release|Win32 + {089C9C0B-C4F7-4923-86C4-F14BF5D61821}.Debug|Win32.ActiveCfg = Debug|Win32 + {089C9C0B-C4F7-4923-86C4-F14BF5D61821}.Debug|Win32.Build.0 = Debug|Win32 + {089C9C0B-C4F7-4923-86C4-F14BF5D61821}.Release|Win32.ActiveCfg = Release|Win32 + {089C9C0B-C4F7-4923-86C4-F14BF5D61821}.Release|Win32.Build.0 = Release|Win32 + {D593C954-5115-4D15-ABDB-01B66006FF6F}.Debug|Win32.ActiveCfg = Debug|Win32 + {D593C954-5115-4D15-ABDB-01B66006FF6F}.Debug|Win32.Build.0 = Debug|Win32 + {D593C954-5115-4D15-ABDB-01B66006FF6F}.Release|Win32.ActiveCfg = Release|Win32 + {D593C954-5115-4D15-ABDB-01B66006FF6F}.Release|Win32.Build.0 = Release|Win32 + {44C07AA4-6D56-45ED-8393-18A23E76B758}.Debug|Win32.ActiveCfg = Debug|Win32 + {44C07AA4-6D56-45ED-8393-18A23E76B758}.Debug|Win32.Build.0 = Debug|Win32 + {44C07AA4-6D56-45ED-8393-18A23E76B758}.Release|Win32.ActiveCfg = Release|Win32 + {44C07AA4-6D56-45ED-8393-18A23E76B758}.Release|Win32.Build.0 = Release|Win32 + {9D589BCA-9E10-4FFA-B43F-DDFA91C1C098}.Debug|Win32.ActiveCfg = Debug|Win32 + {9D589BCA-9E10-4FFA-B43F-DDFA91C1C098}.Debug|Win32.Build.0 = Debug|Win32 + {9D589BCA-9E10-4FFA-B43F-DDFA91C1C098}.Release|Win32.ActiveCfg = Release|Win32 + {9D589BCA-9E10-4FFA-B43F-DDFA91C1C098}.Release|Win32.Build.0 = Release|Win32 + {0F8B9E39-56A7-45BE-A68F-04F7EB8EF8A3}.Debug|Win32.ActiveCfg = Debug|Win32 + {0F8B9E39-56A7-45BE-A68F-04F7EB8EF8A3}.Debug|Win32.Build.0 = Debug|Win32 + {0F8B9E39-56A7-45BE-A68F-04F7EB8EF8A3}.Release|Win32.ActiveCfg = Release|Win32 + {0F8B9E39-56A7-45BE-A68F-04F7EB8EF8A3}.Release|Win32.Build.0 = Release|Win32 + {C51841F3-BD47-41C3-946C-20F893FB5A23}.Debug|Win32.ActiveCfg = Debug|Win32 + {C51841F3-BD47-41C3-946C-20F893FB5A23}.Debug|Win32.Build.0 = Debug|Win32 + {C51841F3-BD47-41C3-946C-20F893FB5A23}.Release|Win32.ActiveCfg = Release|Win32 + {C51841F3-BD47-41C3-946C-20F893FB5A23}.Release|Win32.Build.0 = Release|Win32 + {9B55ACBB-C29A-40EB-98BF-D1047912389E}.Debug|Win32.ActiveCfg = Debug|Win32 + {9B55ACBB-C29A-40EB-98BF-D1047912389E}.Debug|Win32.Build.0 = Debug|Win32 + {9B55ACBB-C29A-40EB-98BF-D1047912389E}.Release|Win32.ActiveCfg = Release|Win32 + {9B55ACBB-C29A-40EB-98BF-D1047912389E}.Release|Win32.Build.0 = Release|Win32 + {FF632F3D-9F62-481D-A5C7-AD090F46143C}.Debug|Win32.ActiveCfg = Debug|Win32 + {FF632F3D-9F62-481D-A5C7-AD090F46143C}.Debug|Win32.Build.0 = Debug|Win32 + {FF632F3D-9F62-481D-A5C7-AD090F46143C}.Release|Win32.ActiveCfg = Release|Win32 + {FF632F3D-9F62-481D-A5C7-AD090F46143C}.Release|Win32.Build.0 = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-5ABC40236509}.Debug|Win32.ActiveCfg = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-5ABC40236509}.Debug|Win32.Build.0 = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-5ABC40236509}.Release|Win32.ActiveCfg = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-5ABC40236509}.Release|Win32.Build.0 = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-DEAD402BEEF9}.Debug|Win32.ActiveCfg = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-DEAD402BEEF9}.Debug|Win32.Build.0 = Debug|Win32 + {927C3BD9-BD0C-4A23-99F9-DEAD402BEEF9}.Release|Win32.ActiveCfg = Release|Win32 + {927C3BD9-BD0C-4A23-99F9-DEAD402BEEF9}.Release|Win32.Build.0 = Release|Win32 + {0ABAF350-853E-4A8F-8435-B583E29FB78C}.Debug|Win32.ActiveCfg = Debug|Win32 + {0ABAF350-853E-4A8F-8435-B583E29FB78C}.Debug|Win32.Build.0 = Debug|Win32 + {0ABAF350-853E-4A8F-8435-B583E29FB78C}.Release|Win32.ActiveCfg = Release|Win32 + {0ABAF350-853E-4A8F-8435-B583E29FB78C}.Release|Win32.Build.0 = Release|Win32 + {A0BAF350-853E-4A8F-8435-B583E29FFACE}.Debug|Win32.ActiveCfg = Debug|Win32 + {A0BAF350-853E-4A8F-8435-B583E29FFACE}.Debug|Win32.Build.0 = Debug|Win32 + {A0BAF350-853E-4A8F-8435-B583E29FFACE}.Release|Win32.ActiveCfg = Release|Win32 + {A0BAF350-853E-4A8F-8435-B583E29FFACE}.Release|Win32.Build.0 = Release|Win32 + {D40F3AF1-EEE7-4432-9807-2AD287B490F8}.Debug|Win32.ActiveCfg = Debug|Win32 + {D40F3AF1-EEE7-4432-9807-2AD287B490F8}.Debug|Win32.Build.0 = Debug|Win32 + {D40F3AF1-EEE7-4432-9807-2AD287B490F8}.Release|Win32.ActiveCfg = Release|Win32 + {D40F3AF1-EEE7-4432-9807-2AD287B490F8}.Release|Win32.Build.0 = Release|Win32 + {C526F7F2-9476-44BC-B1E9-9522B693BEA7}.Debug|Win32.ActiveCfg = Debug|Win32 + {C526F7F2-9476-44BC-B1E9-9522B693BEA7}.Debug|Win32.Build.0 = Debug|Win32 + {C526F7F2-9476-44BC-B1E9-9522B693BEA7}.Release|Win32.ActiveCfg = Release|Win32 + {C526F7F2-9476-44BC-B1E9-9522B693BEA7}.Release|Win32.Build.0 = Release|Win32 + {43A9CF64-5705-4FB7-B837-ED9AAFF97DAC}.Debug|Win32.ActiveCfg = Debug|Win32 + {43A9CF64-5705-4FB7-B837-ED9AAFF97DAC}.Debug|Win32.Build.0 = Debug|Win32 + {43A9CF64-5705-4FB7-B837-ED9AAFF97DAC}.Release|Win32.ActiveCfg = Release|Win32 + {43A9CF64-5705-4FB7-B837-ED9AAFF97DAC}.Release|Win32.Build.0 = Release|Win32 + {B3671ABB-4FFF-4EEB-8A5B-06716C9BCE9E}.Debug|Win32.ActiveCfg = Debug|Win32 + {B3671ABB-4FFF-4EEB-8A5B-06716C9BCE9E}.Debug|Win32.Build.0 = Debug|Win32 + {B3671ABB-4FFF-4EEB-8A5B-06716C9BCE9E}.Release|Win32.ActiveCfg = Release|Win32 + {B3671ABB-4FFF-4EEB-8A5B-06716C9BCE9E}.Release|Win32.Build.0 = Release|Win32 + {E359921B-DC18-42ED-AFB9-1FC603B9C1B3}.Debug|Win32.ActiveCfg = Debug|Win32 + {E359921B-DC18-42ED-AFB9-1FC603B9C1B3}.Debug|Win32.Build.0 = Debug|Win32 + {E359921B-DC18-42ED-AFB9-1FC603B9C1B3}.Release|Win32.ActiveCfg = Release|Win32 + {E359921B-DC18-42ED-AFB9-1FC603B9C1B3}.Release|Win32.Build.0 = Release|Win32 + {3048F582-98C9-447D-BBB9-6F969467D4EA}.Debug|Win32.ActiveCfg = Debug|Win32 + {3048F582-98C9-447D-BBB9-6F969467D4EA}.Debug|Win32.Build.0 = Debug|Win32 + {3048F582-98C9-447D-BBB9-6F969467D4EA}.Release|Win32.ActiveCfg = Release|Win32 + {3048F582-98C9-447D-BBB9-6F969467D4EA}.Release|Win32.Build.0 = Release|Win32 + {24BC7F75-FB56-44A9-BB7C-78AE6A694D0C}.Debug|Win32.ActiveCfg = Debug|Win32 + {24BC7F75-FB56-44A9-BB7C-78AE6A694D0C}.Debug|Win32.Build.0 = Debug|Win32 + {24BC7F75-FB56-44A9-BB7C-78AE6A694D0C}.Release|Win32.ActiveCfg = Release|Win32 + {24BC7F75-FB56-44A9-BB7C-78AE6A694D0C}.Release|Win32.Build.0 = Release|Win32 + {F5C22D72-460E-43CD-9AC6-6D6AC517BD1F}.Debug|Win32.ActiveCfg = Debug|Win32 + {F5C22D72-460E-43CD-9AC6-6D6AC517BD1F}.Debug|Win32.Build.0 = Debug|Win32 + {F5C22D72-460E-43CD-9AC6-6D6AC517BD1F}.Release|Win32.ActiveCfg = Release|Win32 + {F5C22D72-460E-43CD-9AC6-6D6AC517BD1F}.Release|Win32.Build.0 = Release|Win32 + {48DA6BA8-23E1-4F0D-959C-48C8576494DA}.Debug|Win32.ActiveCfg = Debug|Win32 + {48DA6BA8-23E1-4F0D-959C-48C8576494DA}.Debug|Win32.Build.0 = Debug|Win32 + {48DA6BA8-23E1-4F0D-959C-48C8576494DA}.Release|Win32.ActiveCfg = Release|Win32 + {48DA6BA8-23E1-4F0D-959C-48C8576494DA}.Release|Win32.Build.0 = Release|Win32 + {14C5D369-E4A1-4DA2-B23C-B49367874F7B}.Debug|Win32.ActiveCfg = Debug|Win32 + {14C5D369-E4A1-4DA2-B23C-B49367874F7B}.Debug|Win32.Build.0 = Debug|Win32 + {14C5D369-E4A1-4DA2-B23C-B49367874F7B}.Release|Win32.ActiveCfg = Release|Win32 + {14C5D369-E4A1-4DA2-B23C-B49367874F7B}.Release|Win32.Build.0 = Release|Win32 + {7DDB6DF6-3837-4DE3-80D7-63181195021F}.Debug|Win32.ActiveCfg = Debug|Win32 + {7DDB6DF6-3837-4DE3-80D7-63181195021F}.Debug|Win32.Build.0 = Debug|Win32 + {7DDB6DF6-3837-4DE3-80D7-63181195021F}.Release|Win32.ActiveCfg = Release|Win32 + {7DDB6DF6-3837-4DE3-80D7-63181195021F}.Release|Win32.Build.0 = Release|Win32 + {9D0DAC36-2C75-41CD-905C-93B2F5ADF9E2}.Debug|Win32.ActiveCfg = Debug|Win32 + {9D0DAC36-2C75-41CD-905C-93B2F5ADF9E2}.Debug|Win32.Build.0 = Debug|Win32 + {9D0DAC36-2C75-41CD-905C-93B2F5ADF9E2}.Release|Win32.ActiveCfg = Release|Win32 + {9D0DAC36-2C75-41CD-905C-93B2F5ADF9E2}.Release|Win32.Build.0 = Release|Win32 + {D4F5761A-B543-40ED-9892-12A0255C2B6D}.Debug|Win32.ActiveCfg = Debug|Win32 + {D4F5761A-B543-40ED-9892-12A0255C2B6D}.Debug|Win32.Build.0 = Debug|Win32 + {D4F5761A-B543-40ED-9892-12A0255C2B6D}.Release|Win32.ActiveCfg = Release|Win32 + {D4F5761A-B543-40ED-9892-12A0255C2B6D}.Release|Win32.Build.0 = Release|Win32 + {A8D46C10-8F3F-47CA-AD5F-E3BB7C4A3678}.Debug|Win32.ActiveCfg = Debug|Win32 + {A8D46C10-8F3F-47CA-AD5F-E3BB7C4A3678}.Debug|Win32.Build.0 = Debug|Win32 + {A8D46C10-8F3F-47CA-AD5F-E3BB7C4A3678}.Release|Win32.ActiveCfg = Release|Win32 + {A8D46C10-8F3F-47CA-AD5F-E3BB7C4A3678}.Release|Win32.Build.0 = Release|Win32 + {2FB5B6EE-796F-429F-980E-14E822837105}.Debug|Win32.ActiveCfg = Debug|Win32 + {2FB5B6EE-796F-429F-980E-14E822837105}.Debug|Win32.Build.0 = Debug|Win32 + {2FB5B6EE-796F-429F-980E-14E822837105}.Release|Win32.ActiveCfg = Release|Win32 + {2FB5B6EE-796F-429F-980E-14E822837105}.Release|Win32.Build.0 = Release|Win32 + {9BBA76FE-45DD-4902-9421-BEA3EC2DCDB0}.Debug|Win32.ActiveCfg = Debug|Win32 + {9BBA76FE-45DD-4902-9421-BEA3EC2DCDB0}.Debug|Win32.Build.0 = Debug|Win32 + {9BBA76FE-45DD-4902-9421-BEA3EC2DCDB0}.Release|Win32.ActiveCfg = Release|Win32 + {9BBA76FE-45DD-4902-9421-BEA3EC2DCDB0}.Release|Win32.Build.0 = Release|Win32 + {BA514FA1-D029-4D25-91CC-255E5953FF6E}.Debug|Win32.ActiveCfg = Debug|Win32 + {BA514FA1-D029-4D25-91CC-255E5953FF6E}.Debug|Win32.Build.0 = Debug|Win32 + {BA514FA1-D029-4D25-91CC-255E5953FF6E}.Release|Win32.ActiveCfg = Release|Win32 + {BA514FA1-D029-4D25-91CC-255E5953FF6E}.Release|Win32.Build.0 = Release|Win32 + {B3E35063-CB41-4F77-BFCA-49BB316B0EDB}.Debug|Win32.ActiveCfg = Debug|Win32 + {B3E35063-CB41-4F77-BFCA-49BB316B0EDB}.Debug|Win32.Build.0 = Debug|Win32 + {B3E35063-CB41-4F77-BFCA-49BB316B0EDB}.Release|Win32.ActiveCfg = Release|Win32 + {B3E35063-CB41-4F77-BFCA-49BB316B0EDB}.Release|Win32.Build.0 = Release|Win32 + {33EE34FC-A12F-47FE-9FD6-8B74D08718C7}.Debug|Win32.ActiveCfg = Debug|Win32 + {33EE34FC-A12F-47FE-9FD6-8B74D08718C7}.Debug|Win32.Build.0 = Debug|Win32 + {33EE34FC-A12F-47FE-9FD6-8B74D08718C7}.Release|Win32.ActiveCfg = Release|Win32 + {33EE34FC-A12F-47FE-9FD6-8B74D08718C7}.Release|Win32.Build.0 = Release|Win32 + {55A727F0-B5C8-48E8-9EF2-D5DAF679C520}.Debug|Win32.ActiveCfg = Debug|Win32 + {55A727F0-B5C8-48E8-9EF2-D5DAF679C520}.Debug|Win32.Build.0 = Debug|Win32 + {55A727F0-B5C8-48E8-9EF2-D5DAF679C520}.Release|Win32.ActiveCfg = Release|Win32 + {55A727F0-B5C8-48E8-9EF2-D5DAF679C520}.Release|Win32.Build.0 = Release|Win32 + {F55D43D3-AD63-4B19-B67A-47064227F3E3}.Debug|Win32.ActiveCfg = Debug|Win32 + {F55D43D3-AD63-4B19-B67A-47064227F3E3}.Debug|Win32.Build.0 = Debug|Win32 + {F55D43D3-AD63-4B19-B67A-47064227F3E3}.Release|Win32.ActiveCfg = Release|Win32 + {F55D43D3-AD63-4B19-B67A-47064227F3E3}.Release|Win32.Build.0 = Release|Win32 + {91A7D475-1238-4872-BEAE-143E1FCEA297}.Debug|Win32.ActiveCfg = Debug|Win32 + {91A7D475-1238-4872-BEAE-143E1FCEA297}.Debug|Win32.Build.0 = Debug|Win32 + {91A7D475-1238-4872-BEAE-143E1FCEA297}.Release|Win32.ActiveCfg = Release|Win32 + {91A7D475-1238-4872-BEAE-143E1FCEA297}.Release|Win32.Build.0 = Release|Win32 + {F1F44607-FB9E-428C-AD8F-56F98699D121}.Debug|Win32.ActiveCfg = Debug|Win32 + {F1F44607-FB9E-428C-AD8F-56F98699D121}.Debug|Win32.Build.0 = Debug|Win32 + {F1F44607-FB9E-428C-AD8F-56F98699D121}.Release|Win32.ActiveCfg = Release|Win32 + {F1F44607-FB9E-428C-AD8F-56F98699D121}.Release|Win32.Build.0 = Release|Win32 + {BF1E708D-D374-4DE1-A0D3-6D8DB4B4F7FA}.Debug|Win32.ActiveCfg = Debug|Win32 + {BF1E708D-D374-4DE1-A0D3-6D8DB4B4F7FA}.Debug|Win32.Build.0 = Debug|Win32 + {BF1E708D-D374-4DE1-A0D3-6D8DB4B4F7FA}.Release|Win32.ActiveCfg = Release|Win32 + {BF1E708D-D374-4DE1-A0D3-6D8DB4B4F7FA}.Release|Win32.Build.0 = Release|Win32 + {01F75DE5-8049-4C73-A325-B1F9964CE709}.Debug|Win32.ActiveCfg = Debug|Win32 + {01F75DE5-8049-4C73-A325-B1F9964CE709}.Debug|Win32.Build.0 = Debug|Win32 + {01F75DE5-8049-4C73-A325-B1F9964CE709}.Release|Win32.ActiveCfg = Release|Win32 + {01F75DE5-8049-4C73-A325-B1F9964CE709}.Release|Win32.Build.0 = Release|Win32 + {0BA63EC5-BD4F-44FB-AE89-7DD2C84CB1D9}.Debug|Win32.ActiveCfg = Debug|Win32 + {0BA63EC5-BD4F-44FB-AE89-7DD2C84CB1D9}.Debug|Win32.Build.0 = Debug|Win32 + {0BA63EC5-BD4F-44FB-AE89-7DD2C84CB1D9}.Release|Win32.ActiveCfg = Release|Win32 + {0BA63EC5-BD4F-44FB-AE89-7DD2C84CB1D9}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Visual Studio Projects/TX-0.vcproj b/Visual Studio Projects/TX-0.vcproj new file mode 100644 index 0000000..ff8826f --- /dev/null +++ b/Visual Studio Projects/TX-0.vcproj @@ -0,0 +1,331 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/VAX.vcproj b/Visual Studio Projects/VAX.vcproj new file mode 100644 index 0000000..6b43e13 --- /dev/null +++ b/Visual Studio Projects/VAX.vcproj @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/VAX730.vcproj b/Visual Studio Projects/VAX730.vcproj new file mode 100644 index 0000000..a19a0ec --- /dev/null +++ b/Visual Studio Projects/VAX730.vcproj @@ -0,0 +1,659 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/VAX750.vcproj b/Visual Studio Projects/VAX750.vcproj new file mode 100644 index 0000000..2425dfb --- /dev/null +++ b/Visual Studio Projects/VAX750.vcproj @@ -0,0 +1,667 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/VAX780.vcproj b/Visual Studio Projects/VAX780.vcproj new file mode 100644 index 0000000..556ee4e --- /dev/null +++ b/Visual Studio Projects/VAX780.vcproj @@ -0,0 +1,676 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/VAX8600.vcproj b/Visual Studio Projects/VAX8600.vcproj new file mode 100644 index 0000000..75edf38 --- /dev/null +++ b/Visual Studio Projects/VAX8600.vcproj @@ -0,0 +1,668 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/alpha.vcproj b/Visual Studio Projects/alpha.vcproj new file mode 100644 index 0000000..db25417 --- /dev/null +++ b/Visual Studio Projects/alpha.vcproj @@ -0,0 +1,353 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/git-hooks/0ReadMe_git-hooks.txt b/Visual Studio Projects/git-hooks/0ReadMe_git-hooks.txt new file mode 100644 index 0000000..d9126d7 --- /dev/null +++ b/Visual Studio Projects/git-hooks/0ReadMe_git-hooks.txt @@ -0,0 +1,28 @@ +This dirctory contains a set of git hook scripts which are useful when +working with this repository to make the git commit id available when +building simulators to uniquely identify the inputs to that build. + +It is ONLY useful for folks who clone this as a repository and build +in the working directory of that repository. + +Folks who download zip archives of the repository do not currently +have the ability to get the commit id which the archive is a snapshot +of. Work is being done to solve this issue for uses of the archive +snapshots as well. + +To use these scripts automatically, copy these files to the .git/hooks +directory of the current repository. This can be done with the +following commands: + + $ cd Visual\ Studio\ Projects/git-hooks + $ chmod +x post* + $ cp post* ../../.git/hooks/ + + + +Note: You ONLY need to copy these hook scripts once for a particular + clone of the repository. Once these are installed they will + survive as you pull subsequent revisions from the github repo. + + If you clone the repository to another platform, then you'll + need to copy the hooks to the .git/hooks directory again. diff --git a/Visual Studio Projects/git-hooks/post-checkout b/Visual Studio Projects/git-hooks/post-checkout new file mode 100644 index 0000000..05588ba --- /dev/null +++ b/Visual Studio Projects/git-hooks/post-checkout @@ -0,0 +1,5 @@ +#!/bin/sh +# +# A hook script that is called after a successful +# checkout to record the commit-id in the working directory. +git log -1 --pretty="%H" >.git-commit-id diff --git a/Visual Studio Projects/git-hooks/post-commit b/Visual Studio Projects/git-hooks/post-commit new file mode 100644 index 0000000..32d3e49 --- /dev/null +++ b/Visual Studio Projects/git-hooks/post-commit @@ -0,0 +1,5 @@ +#!/bin/sh +# +# A hook script that is called after a successful +# commit is made to record the commit-id in the working directory. +git log -1 --pretty="%H" >.git-commit-id diff --git a/Visual Studio Projects/git-hooks/post-merge b/Visual Studio Projects/git-hooks/post-merge new file mode 100644 index 0000000..9de878e --- /dev/null +++ b/Visual Studio Projects/git-hooks/post-merge @@ -0,0 +1,5 @@ +#!/bin/sh +# +# A hook script that is called after a successful merge +# to record the commit-id in the working directory. +git log -1 --pretty="%H" >.git-commit-id diff --git a/Visual Studio Projects/isys8010.vcproj b/Visual Studio Projects/isys8010.vcproj new file mode 100644 index 0000000..b5558a1 --- /dev/null +++ b/Visual Studio Projects/isys8010.vcproj @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/isys8020.vcproj b/Visual Studio Projects/isys8020.vcproj new file mode 100644 index 0000000..391a762 --- /dev/null +++ b/Visual Studio Projects/isys8020.vcproj @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/lgp.vcproj b/Visual Studio Projects/lgp.vcproj new file mode 100644 index 0000000..21ea5e3 --- /dev/null +++ b/Visual Studio Projects/lgp.vcproj @@ -0,0 +1,317 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/rtVAX1000.vcproj b/Visual Studio Projects/rtVAX1000.vcproj new file mode 100644 index 0000000..c98e289 --- /dev/null +++ b/Visual Studio Projects/rtVAX1000.vcproj @@ -0,0 +1,654 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/sigma.vcproj b/Visual Studio Projects/sigma.vcproj new file mode 100644 index 0000000..d30dab7 --- /dev/null +++ b/Visual Studio Projects/sigma.vcproj @@ -0,0 +1,369 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/swtp6800mp-a.vcproj b/Visual Studio Projects/swtp6800mp-a.vcproj new file mode 100644 index 0000000..cda3c82 --- /dev/null +++ b/Visual Studio Projects/swtp6800mp-a.vcproj @@ -0,0 +1,341 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Visual Studio Projects/swtp6800mp-a2.vcproj b/Visual Studio Projects/swtp6800mp-a2.vcproj new file mode 100644 index 0000000..6150da7 --- /dev/null +++ b/Visual Studio Projects/swtp6800mp-a2.vcproj @@ -0,0 +1,345 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/descrip.mms b/descrip.mms new file mode 100644 index 0000000..48bec0e --- /dev/null +++ b/descrip.mms @@ -0,0 +1,2223 @@ +# DESCRIP.MMS +# Written By: Robert Alan Byer / byer@mail.ourservers.net +# Modified By: Mark Pizzolato / mark@infocomm.com +# Norman Lastovica / norman.lastovica@oracle.com +# Camiel Vanderhoeven / camiel@camicom.com +# Matt Burke / scope.matthew@btinternet.com +# +# This MMS/MMK build script is used to compile the various simulators in +# the SIMH package for OpenVMS using DEC C v6.0-001(AXP), v6.5-001(AXP), +# HP C V7.3-009-48GBT (AXP), HP C V7.2-001 (IA64) and v6.4-005(VAX). +# +# Notes: On VAX, the PDP-10, Eclipse, IBM 7094 and BESM6 simulators will +# not be built due to the fact that INT64 is required for these +# simulators. +# +# This build script will accept the following build options. +# +# ALL Just Build "Everything". +# ALTAIR Just Build The MITS Altair. +# ALTAIRZ80 Just Build The MITS Altair Z80. +# BESM6 Just Build The BESM-6. +# B5500 Just Build The B5500. +# ECLIPSE Just Build The Data General Eclipse. +# GRI Just Build The GRI Corporation GRI-909. +# LGP Just Build The Royal-McBee LGP-30. +# H316 Just Build The Honewell 316/516. +# HP2100 Just Build The Hewlett-Packard HP-2100. +# HP3000 Just Build The Hewlett-Packard HP-3000. +# I1401 Just Build The IBM 1401. +# I1620 Just Build The IBM 1620. +# I7094 Just Build The IBM 7094. +# IBM1130 Just Build The IBM 1130. +# ID16 Just Build The Interdata 16-bit CPU. +# ID32 Just Build The Interdata 32-bit CPU. +# NOVA Just Build The Data General Nova. +# PDP1 Just Build The DEC PDP-1. +# PDP4 Just Build The DEC PDP-4. +# PDP7 Just Build The DEC PDP-7. +# PDP8 Just Build The DEC PDP-8. +# PDP9 Just Build The DEC PDP-9. +# PDP10 Just Build The DEC PDP-10. +# PDP11 Just Build The DEC PDP-11. +# PDP15 Just Build The DEC PDP-15. +# S3 Just Build The IBM System 3. +# SDS Just Build The SDS 940. +# SSEM Just Build the Manchester University SSEM. +# SWTP6800MP-A Just Build The SWTP6800MP-A. +# SWTP6800MP-A2 Just Build The SWTP6800MP-A2. +# VAX Just Build The DEC MicroVAX3900 (aka VAX). +# MicroVAX3900 Just Build The DEC MicroVAX3900 (aka VAX). +# MicroVAX1 Just Build The DEC MicroVAX1 (MicroVAX I). +# rtVAX1000 Just Build The DEC rtVAX1000 (rtVAX 1000). +# MicroVAX2 Just Build The DEC MicroVAX2 (MicroVAX II). +# VAX730 Just Build The DEC VAX730. +# VAX750 Just Build The DEC VAX750. +# VAX780 Just Build The DEC VAX780. +# VAX8600 Just Build The DEC VAX8600. +# CLEAN Will Clean Files Back To Base Kit. +# +# To build with debugging enabled (which will also enable traceback +# information) use.. +# +# MMK/MACRO=(DEBUG=1) +# +# This will produce an executable named {Simulator}-{I64|VAX|AXP}-DBG.EXE +# +# To build on older Alpha VMS platforms, SIM_ASYNCH_IO must be disabled. +# use.. +# +# MMK/MACRO=(NOASYNCH=1) +# +# On AXP and IA64 the VMS PCAP components are built and used to provide +# network support for the VAX and PDP11 simulators. +# +# The AXP PCAP components can only be built using a version of the +# DEC/Compaq/HP Compiler version V6.5-001 or later. To build using an +# older compiler, networking support must be disabled. Use... +# +# MMK/MACRO=(NONETWORK=1) +# +# The PCAP-VMS components are presumed (by this procedure) to be located +# in a directory at the same level as the directory containing the +# simh source files. For example, if these exist here: +# +# []descrip.mms +# []scp.c +# etc. +# +# Then the following should exist: +# [-.PCAP-VMS]BUILD_ALL.COM +# [-.PCAP-VMS.PCAP-VCI] +# [-.PCAP-VMS.PCAPVCM] +# etc. + +# Let's See If We Are Going To Build With DEBUG Enabled. Always compile +# /DEBUG so that the traceback and debug information is always available +# in the object files. + +CC_DEBUG = /DEBUG + +.IFDEF DEBUG +CC_OPTIMIZE = /NOOPTIMIZE +NEST_DEBUG = ,DEBUG=1 + +.IFDEF MMSALPHA +ALPHA_OR_IA64 = 1 +CC_FLAGS = /PREF=ALL +.IFDEF NOASYNCH +ARCH = AXP-NOASYNCH-DBG +CC_DEFS = "_LARGEFILE" +LINK_DEBUG = /DEBUG/TRACEBACK +.ELSE +ARCH = AXP-DBG +CC_DEFS = "_LARGEFILE","SIM_ASYNCH_IO=1" +LINK_DEBUG = /DEBUG/TRACEBACK/THREADS_ENABLE +.ENDIF +.ENDIF + +.IFDEF MMSIA64 +ALPHA_OR_IA64 = 1 +CC_FLAGS = /PREF=ALL +.IFDEF NOASYNCH +ARCH = I64-NOASYNCH-DBG +CC_DEFS = "_LARGEFILE" +LINK_DEBUG = /DEBUG/TRACEBACK +.ELSE +ARCH = I64-DBG +CC_DEFS = "_LARGEFILE","SIM_ASYNCH_IO=1" +LINK_DEBUG = /DEBUG/TRACEBACK/THREADS_ENABLE +.ENDIF +.ENDIF + +.IFDEF MMSVAX +CC_FLAGS = $(CC_FLAGS) +ARCH = VAX-DBG +CC_DEFS = "__VAX" +LINK_DEBUG = /DEBUG/TRACEBACK +.ENDIF + +.ELSE +# !DEBUG + +.IFDEF MMSALPHA +ALPHA_OR_IA64 = 1 +CC_OPTIMIZE = /OPT=(LEV=5)/ARCH=HOST +CC_FLAGS = /PREF=ALL +.IFDEF NOASYNCH +ARCH = AXP-NOASYNCH +CC_DEFS = "_LARGEFILE" +LINK_DEBUG = /NODEBUG/NOTRACEBACK +.ELSE +ARCH = AXP +CC_DEFS = "_LARGEFILE","SIM_ASYNCH_IO=1" +LINK_DEBUG = /NODEBUG/NOTRACEBACK/THREADS_ENABLE +.ENDIF +LINK_SECTION_BINDING = /SECTION_BINDING +.ENDIF + +.IFDEF MMSIA64 +ALPHA_OR_IA64 = 1 +CC_OPTIMIZE = /OPT=(LEV=5) +CC_FLAGS = /PREF=ALL +.IFDEF NOASYNCH +ARCH = I64-NOASYNCH +CC_DEFS = "_LARGEFILE" +LINK_DEBUG = /NODEBUG/NOTRACEBACK +.ELSE +ARCH = I64 +CC_DEFS = "_LARGEFILE","SIM_ASYNCH_IO=1" +LINK_DEBUG = /NODEBUG/NOTRACEBACK/THREADS_ENABLE +.ENDIF +.ENDIF + +.IFDEF MMSVAX +CC_OPTIMIZE = /OPTIMIZE +CC_FLAGS = $(CC_FLAGS) +ARCH = VAX +CC_DEFS = "__VAX" +LINK_DEBUG = /NODEBUG/NOTRACEBACK +.ENDIF + +.ENDIF + + +# Define Our Compiler Flags & Define The Compile Command +OUR_CC_FLAGS = $(CC_FLAGS)$(CC_DEBUG)$(CC_OPTIMIZE) \ + /NEST=PRIMARY/NAME=(AS_IS,SHORT) +CC = CC/DECC$(OUR_CC_FLAGS) + +# Define The BIN Directory Where The Executables Will Go. +# Define Our Library Directory. +# Define The platform specific Build Directory Where The Objects Will Go. +# +BIN_DIR = SYS$DISK:[.BIN] +LIB_DIR = SYS$DISK:[.BIN.VMS.LIB] +BLD_DIR = SYS$DISK:[.BIN.VMS.LIB.BLD-$(ARCH)] + + +# Core SIMH File Definitions. +# +SIMH_DIR = SYS$DISK:[] +SIMH_LIB = $(LIB_DIR)SIMH-$(ARCH).OLB +SIMH_NONET_LIB = $(LIB_DIR)SIMH-NONET-$(ARCH).OLB +SIMH_SOURCE = $(SIMH_DIR)SIM_CONSOLE.C,$(SIMH_DIR)SIM_SOCK.C,\ + $(SIMH_DIR)SIM_TMXR.C,$(SIMH_DIR)SIM_ETHER.C,\ + $(SIMH_DIR)SIM_TAPE.C,$(SIMH_DIR)SIM_FIO.C,\ + $(SIMH_DIR)SIM_TIMER.C,$(SIMH_DIR)SIM_DISK.C,\ + $(SIMH_DIR)SIM_SERIAL.C,$(SIMH_DIR)SIM_VIDEO.C +SIMH_MAIN = SCP.C +.IFDEF ALPHA_OR_IA64 +SIMH_LIB64 = $(LIB_DIR)SIMH64-$(ARCH).OLB +.ENDIF + +# VMS PCAP File Definitions. +# +PCAP_DIR = SYS$DISK:[-.PCAP-VMS.PCAP-VCI] +PCAP_LIB = $(LIB_DIR)PCAP-$(ARCH).OLB +PCAP_SOURCE = $(PCAP_DIR)PCAPVCI.C,$(PCAP_DIR)VCMUTIL.C,\ + $(PCAP_DIR)BPF_DUMP.C,$(PCAP_DIR)BPF_FILTER.C,\ + $(PCAP_DIR)BPF_IMAGE.C,$(PCAP_DIR)ETHERENT.C,\ + $(PCAP_DIR)FAD-GIFC.C,$(PCAP_DIR)GENCODE.C,\ + $(PCAP_DIR)GRAMMAR.C,$(PCAP_DIR)INET.C,\ + $(PCAP_DIR)NAMETOADDR.C,$(PCAP_DIR)OPTIMIZE.C,\ + $(PCAP_DIR)PCAP.C,$(PCAP_DIR)SAVEFILE.C,\ + $(PCAP_DIR)SCANNER.C,$(PCAP_DIR)SNPRINTF.C,\ + $(PCAP_DIR)PCAP-VMS.C +PCAP_VCMDIR = SYS$DISK:[-.PCAP-VMS.PCAPVCM] +PCAP_VCM_SOURCES = $(PCAP_VCMDIR)PCAPVCM.C,$(PCAP_VCMDIR)PCAPVCM_INIT.MAR,\ + $(PCAP_VCMDIR)VCI_JACKET.MAR,$(PCAP_VCMDIR)VCMUTIL.C +PCAP_VCI = SYS$COMMON:[SYS$LDR]PCAPVCM.EXE + +# PCAP is not available on OpenVMS VAX +# +.IFDEF ALPHA_OR_IA64 +.IFDEF NONETWORK +# Network Capabilities disabled +.ELSE +PCAP_EXECLET = $(PCAP_VCI) +PCAP_INC = ,$(PCAP_DIR) +PCAP_LIBD = $(PCAP_LIB) +PCAP_LIBR = ,$(PCAP_LIB)/LIB/SYSEXE +PCAP_DEFS = ,"USE_NETWORK=1","HAVE_PCAP_NETWORK=1" +PCAP_SIMH_INC = /INCL=($(PCAP_DIR)) +.ENDIF +.ENDIF + +# Check To Make Sure We Have SYS$DISK:[.BIN] & SYS$DISK:[.LIB] Directory. +# +.FIRST + @ IF "".NES."''CC'" THEN DELETE/SYMBOL/GLOBAL CC + @ EXIT_ON_ERROR := IF (ERROR_CONDITION) THEN EXIT %X10000004 + @ ERROR_CONDITION = ((F$GETSYI("ARCH_NAME").EQS."Alpha").AND.(F$GETSYI("VERSION").LTS."V8.0").AND.("$(NOASYNCH)".EQS."")) + @ IF (ERROR_CONDITION) THEN WRITE SYS$OUTPUT "*** WARNING **** Build should be invoked with /MACRO=NOASYNCH=1 on this platform" + @ 'EXIT_ON_ERROR + @ DEFINE/USER SYS$ERROR NLA0: + @ DEFINE/USER SYS$OUTPUT CC_VERSION.DAT + @ CC/DECC/VERSION + @ OPEN /READ VERSION CC_VERSION.DAT + @ READ VERSION CC_VERSION + @ CLOSE VERSION + @ DELETE CC_VERSION.DAT; + @ CC_VERSION = F$ELEMENT(2," ",CC_VERSION) + @ BAD_CC_VERSION = ((F$GETSYI("ARCH_NAME").EQS."Alpha").AND.(CC_VERSION.LTS."V6.5-001").AND.("$(NONETWORK)".EQS."")) + @ IF (BAD_CC_VERSION) THEN WRITE SYS$OUTPUT "*** WARNING *** C Compiler is: ''CC_VERSION'" + @ IF (BAD_CC_VERSION.AND.(F$GETSYI("VERSION").GES."V8.0")) THEN - + WRITE SYS$OUTPUT "*** WARNING *** Build should be invoked with /MACRO=NONETWORK=1 with this compiler" + @ IF (BAD_CC_VERSION.AND.(F$GETSYI("VERSION").LTS."V8.0")) THEN - + WRITE SYS$OUTPUT "*** WARNING *** Build should be invoked with /MACRO=(NONETWORK=1,NOASYNCH=1) with this compiler" + @ ERROR_CONDITION = BAD_CC_VERSION + @ 'EXIT_ON_ERROR + @ MISSING_PCAP = (("$(PCAP_EXECLET)".NES."").AND.("$(NONETWORK)".EQS."").AND.(F$SEARCH("$(PCAP_DIR)PCAP-VMS.C").EQS."")) + @ MISS_SAY := IF (MISSING_PCAP) THEN WRITE SYS$OUTPUT + @ 'MISS_SAY' "*** Error *** Attempting a Network Build but the VMS-PCAP components are not" + @ 'MISS_SAY' "*** Error *** available" + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** The vms-pcap.zip file can be downloaded from:" + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** https://github.com/markpizz/simh/downloads" + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** Be sure to ""unzip -a vms-pcap"" to properly set the file attributes" + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** The PCAP-VMS components are presumed (by this procedure) to be" + @ 'MISS_SAY' "*** Error *** located in a directory at the same level as the directory" + @ 'MISS_SAY' "*** Error *** containing the simh source files." + @ 'MISS_SAY' "*** Error *** For example, if these exist here:" + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** []descrip.mms" + @ 'MISS_SAY' "*** Error *** []scp.c" + @ 'MISS_SAY' "*** Error *** etc." + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** Then the following should exist:" + @ 'MISS_SAY' "*** Error *** [-.PCAP-VMS]BUILD_ALL.COM" + @ 'MISS_SAY' "*** Error *** [-.PCAP-VMS.PCAP-VCI]" + @ 'MISS_SAY' "*** Error *** [-.PCAP-VMS.PCAPVCM]" + @ 'MISS_SAY' "*** Error *** etc." + @ 'MISS_SAY' "*** Error *** " + @ 'MISS_SAY' "*** Error *** Aborting Build" + @ ERROR_CONDITION = MISSING_PCAP + @ 'EXIT_ON_ERROR + @ IF (F$SEARCH("SYS$DISK:[]BIN.DIR").EQS."") THEN CREATE/DIRECTORY $(BIN_DIR) + @ IF (F$SEARCH("SYS$DISK:[.BIN]VMS.DIR").EQS."") THEN CREATE/DIRECTORY $(LIB_DIR) + @ IF (F$SEARCH("SYS$DISK:[.BIN.VMS]LIB.DIR").EQS."") THEN CREATE/DIRECTORY $(LIB_DIR) + @ IF (F$SEARCH("SYS$DISK:[.BIN.VMS.LIB]BLD-$(ARCH).DIR").EQS."") THEN CREATE/DIRECTORY $(BLD_DIR) + @ IF (F$SEARCH("$(BLD_DIR)*.*").NES."") THEN DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.*;* + @ IF (("$(BUILDING_ROMS)".EQS."").AND.(F$SEARCH("$(BIN_DIR)BuildROMs-$(ARCH).EXE").EQS."")) THEN $(MMS) BUILDROMS/MACRO=(BUILDING_ROMS=1$(NEST_DEBUG)) + + +# MITS Altair Simulator Definitions. +# +ALTAIR_DIR = SYS$DISK:[.ALTAIR] +ALTAIR_LIB = $(LIB_DIR)ALTAIR-$(ARCH).OLB +ALTAIR_SOURCE = $(ALTAIR_DIR)ALTAIR_SIO.C,$(ALTAIR_DIR)ALTAIR_CPU.C,\ + $(ALTAIR_DIR)ALTAIR_DSK.C,$(ALTAIR_DIR)ALTAIR_SYS.C +ALTAIR_OPTIONS = /INCL=($(SIMH_DIR),$(ALTAIR_DIR))/DEF=($(CC_DEFS)) + +# +# MITS Altair Z80 Simulator Definitions. +# +ALTAIRZ80_DIR = SYS$DISK:[.ALTAIRZ80] +ALTAIRZ80_LIB1 = $(LIB_DIR)ALTAIRZ80L1-$(ARCH).OLB +ALTAIRZ80_SOURCE1 = $(ALTAIRZ80_DIR)ALTAIRZ80_CPU.C,$(ALTAIRZ80_DIR)ALTAIRZ80_CPU_NOMMU.C,\ + $(ALTAIRZ80_DIR)ALTAIRZ80_DSK.C,$(ALTAIRZ80_DIR)DISASM.C,\ + $(ALTAIRZ80_DIR)ALTAIRZ80_SIO.C,$(ALTAIRZ80_DIR)ALTAIRZ80_SYS.C,\ + $(ALTAIRZ80_DIR)ALTAIRZ80_HDSK.C,$(ALTAIRZ80_DIR)ALTAIRZ80_NET.C,\ + $(ALTAIRZ80_DIR)FLASHWRITER2.C,$(ALTAIRZ80_DIR)I86_DECODE.C,\ + $(ALTAIRZ80_DIR)I86_OPS.C,$(ALTAIRZ80_DIR)I86_PRIM_OPS.C,\ + $(ALTAIRZ80_DIR)I8272.C,$(ALTAIRZ80_DIR)INSNSD.C,\ + $(ALTAIRZ80_DIR)MFDC.C,$(ALTAIRZ80_DIR)N8VEM.C,\ + $(ALTAIRZ80_DIR)S100_MDSA.C,$(ALTAIRZ80_DIR)VFDHD.C +ALTAIRZ80_LIB2 = $(LIB_DIR)ALTAIRZ80L2-$(ARCH).OLB +ALTAIRZ80_SOURCE2 = $(ALTAIRZ80_DIR)S100_DISK1A.C,$(ALTAIRZ80_DIR)S100_DISK2.C,\ + $(ALTAIRZ80_DIR)S100_FIF.C,$(ALTAIRZ80_DIR)S100_MDRIVEH.C,\ + $(ALTAIRZ80_DIR)S100_MDSAD.C,$(ALTAIRZ80_DIR)S100_SELCHAN.C,\ + $(ALTAIRZ80_DIR)S100_SS1.C,$(ALTAIRZ80_DIR)S100_64FDC.C,\ + $(ALTAIRZ80_DIR)S100_SCP300F.C,$(SIMH_DIR)SIM_IMD.C,\ + $(ALTAIRZ80_DIR)WD179X.C,$(ALTAIRZ80_DIR)S100_DISK3.C,\ + $(ALTAIRZ80_DIR)S100_ADCS6.C,$(ALTAIRZ80_DIR)S100_HDC1001.C,\ + $(ALTAIRZ80_DIR)S100_IF3.C,$(ALTAIRZ80_DIR)ALTAIRZ80_MHDSK.C,\ + $(ALTAIRZ80_DIR)M68KCPU.C,$(ALTAIRZ80_DIR)M68KDASM.C,\ + $(ALTAIRZ80_DIR)M68KOPAC.C,$(ALTAIRZ80_DIR)M68KOPDM.C,\ + $(ALTAIRZ80_DIR)M68KOPNZ.C,$(ALTAIRZ80_DIR)M68KOPS.C,$(ALTAIRZ80_DIR)M68KSIM.C +ALTAIRZ80_OPTIONS = /INCL=($(SIMH_DIR),$(ALTAIRZ80_DIR))/DEF=($(CC_DEFS),"USE_SIM_IMD=1") + +# +# Data General Nova Simulator Definitions. +# +NOVA_DIR = SYS$DISK:[.NOVA] +NOVA_LIB = $(LIB_DIR)NOVA-$(ARCH).OLB +NOVA_SOURCE = $(NOVA_DIR)NOVA_SYS.C,$(NOVA_DIR)NOVA_CPU.C,\ + $(NOVA_DIR)NOVA_DKP.C,$(NOVA_DIR)NOVA_DSK.C,\ + $(NOVA_DIR)NOVA_LP.C,$(NOVA_DIR)NOVA_MTA.C,\ + $(NOVA_DIR)NOVA_PLT.C,$(NOVA_DIR)NOVA_PT.C,\ + $(NOVA_DIR)NOVA_CLK.C,$(NOVA_DIR)NOVA_TT.C,\ + $(NOVA_DIR)NOVA_TT1.C,$(NOVA_DIR)NOVA_QTY.C +NOVA_OPTIONS = /INCL=($(SIMH_DIR),$(NOVA_DIR))/DEF=($(CC_DEFS)) + +# +# Data General Eclipse Simulator Definitions. +# +ECLIPSE_LIB = $(LIB_DIR)ECLIPSE-$(ARCH).OLB +ECLIPSE_SOURCE = $(NOVA_DIR)ECLIPSE_CPU.C,$(NOVA_DIR)ECLIPSE_TT.C,\ + $(NOVA_DIR)NOVA_SYS.C,$(NOVA_DIR)NOVA_DKP.C,\ + $(NOVA_DIR)NOVA_DSK.C,$(NOVA_DIR)NOVA_LP.C,\ + $(NOVA_DIR)NOVA_MTA.C,$(NOVA_DIR)NOVA_PLT.C,\ + $(NOVA_DIR)NOVA_PT.C,$(NOVA_DIR)NOVA_CLK.C,\ + $(NOVA_DIR)NOVA_TT1.C,$(NOVA_DIR)NOVA_QTY.C +ECLIPSE_OPTIONS = /INCL=($(SIMH_DIR),$(NOVA_DIR))\ + /DEF=($(CC_DEFS),"ECLIPSE=1") + +# +# GRI Corporation GRI-909 Simulator Definitions. +# +GRI_DIR = SYS$DISK:[.GRI] +GRI_LIB = $(LIB_DIR)GRI-$(ARCH).OLB +GRI_SOURCE = $(GRI_DIR)GRI_CPU.C,$(GRI_DIR)GRI_STDDEV.C,$(GRI_DIR)GRI_SYS.C +GRI_OPTIONS = /INCL=($(SIMH_DIR),$(GRI_DIR))/DEF=($(CC_DEFS)) + +# +# Royal-McBee LGP-30 Simulator Definitions. +# +LGP_DIR = SYS$DISK:[.LGP] +LGP_LIB = $(LIB_DIR)LGP-$(ARCH).OLB +LGP_SOURCE = $(LGP_DIR)LGP_CPU.C,$(LGP_DIR)LGP_STDDEV.C,$(LGP_DIR)LGP_SYS.C +LGP_OPTIONS = /INCL=($(SIMH_DIR),$(LGP_DIR))/DEF=($(CC_DEFS)) + +# +# Honeywell 316/516 Simulator Definitions. +# +H316_DIR = SYS$DISK:[.H316] +H316_LIB = $(LIB_DIR)H316-$(ARCH).OLB +H316_SOURCE = $(H316_DIR)H316_STDDEV.C,$(H316_DIR)H316_LP.C,\ + $(H316_DIR)H316_CPU.C,$(H316_DIR)H316_SYS.C,\ + $(H316_DIR)H316_FHD.C,$(H316_DIR)H316_MT.C,\ + $(H316_DIR)H316_DP.C,$(H316_DIR)H316_RTC.C,\ + $(H316_DIR)H316_IMP.C,$(H316_DIR)H316_HI.C,\ + $(H316_DIR)H316_MI.C,$(H316_DIR)H316_UDP.C +H316_OPTIONS = /INCL=($(SIMH_DIR),$(H316_DIR))/DEF=($(CC_DEFS),"VM_IMPTIP=1") + +# +# Hewlett-Packard HP-2100 Simulator Definitions. +# +HP2100_DIR = SYS$DISK:[.HP2100] +HP2100_LIB1 = $(LIB_DIR)HP2100L1-$(ARCH).OLB +HP2100_SOURCE1 = $(HP2100_DIR)HP2100_STDDEV.C,$(HP2100_DIR)HP2100_DP.C,\ + $(HP2100_DIR)HP2100_DQ.C,$(HP2100_DIR)HP2100_DR.C,\ + $(HP2100_DIR)HP2100_LPS.C,$(HP2100_DIR)HP2100_MS.C,\ + $(HP2100_DIR)HP2100_MT.C,$(HP2100_DIR)HP2100_MUX.C,\ + $(HP2100_DIR)HP2100_CPU.C,$(HP2100_DIR)HP2100_FP.C,\ + $(HP2100_DIR)HP2100_SYS.C,$(HP2100_DIR)HP2100_LPT.C,\ + $(HP2100_DIR)HP2100_IPL.C,$(HP2100_DIR)HP2100_DS.C,\ + $(HP2100_DIR)HP2100_CPU0.C,$(HP2100_DIR)HP2100_CPU1.C,\ + $(HP2100_DIR)HP2100_CPU2.C,$(HP2100_DIR)HP2100_CPU3.C,\ + $(HP2100_DIR)HP2100_CPU4.C,$(HP2100_DIR)HP2100_CPU5.C,\ + $(HP2100_DIR)HP2100_CPU6.C,$(HP2100_DIR)HP2100_CPU7.C +HP2100_LIB2 = $(LIB_DIR)HP2100L2-$(ARCH).OLB +HP2100_SOURCE2 = $(HP2100_DIR)HP2100_FP1.C,$(HP2100_DIR)HP2100_BACI.C,\ + $(HP2100_DIR)HP2100_MPX.C,$(HP2100_DIR)HP2100_PIF.C,\ + $(HP2100_DIR)HP2100_DI.C,$(HP2100_DIR)HP2100_DI_DA.C,\ + $(HP2100_DIR)HP2100_DISCLIB.C +.IFDEF ALPHA_OR_IA64 +HP2100_OPTIONS = /INCL=($(SIMH_DIR),$(HP2100_DIR))\ + /DEF=($(CC_DEFS),"HAVE_INT64=1") +.ELSE +HP2100_OPTIONS = /INCL=($(SIMH_DIR),$(HP2100_DIR))/DEF=($(CC_DEFS)) +.ENDIF + +# +# Hewlett-Packard HP-3000 Simulator Definitions. +# +HP3000_DIR = SYS$DISK:[.HP3000] +HP3000_LIB1 = $(LIB_DIR)HP3000L1-$(ARCH).OLB +HP3000_SOURCE1 = $(HP3000_DIR)HP3000_ATC.C,$(HP3000_DIR)HP3000_CLK.C,\ + $(HP3000_DIR)HP3000_CPU.C,$(HP3000_DIR)HP3000_CPU_BASE.C,\ + $(HP3000_DIR)HP3000_CPU_FP.C,$(HP3000_DIR)HP3000_DS.C,\ + $(HP3000_DIR)HP3000_IOP.C,$(HP3000_DIR)HP3000_MPX.C,\ + $(HP3000_DIR)HP3000_MS.C,$(HP3000_DIR)HP3000_SCMB.C,\ + $(HP3000_DIR)HP3000_SEL.C,$(HP3000_DIR)HP3000_SYS.C +HP3000_LIB2 = $(LIB_DIR)HP3000L2-$(ARCH).OLB +HP3000_SOURCE2 = $(HP3000_DIR)HP_TAPELIB.C,$(HP3000_DIR)HP_DISCLIB.C +.IFDEF ALPHA_OR_IA64 +HP3000_OPTIONS = /INCL=($(SIMH_DIR),$(HP3000_DIR))\ + /DEF=($(CC_DEFS),"HAVE_INT64=1") +.ELSE +HP3000_OPTIONS = /INCL=($(SIMH_DIR),$(HP3000_DIR))/DEF=($(CC_DEFS)) +.ENDIF + +# +# Interdata 16-bit CPU. +# +ID16_DIR = SYS$DISK:[.INTERDATA] +ID16_LIB = $(LIB_DIR)ID16-$(ARCH).OLB +ID16_SOURCE = $(ID16_DIR)ID16_CPU.C,$(ID16_DIR)ID16_SYS.C,$(ID16_DIR)ID_DP.C,\ + $(ID16_DIR)ID_FD.C,$(ID16_DIR)ID_FP.C,$(ID16_DIR)ID_IDC.C,\ + $(ID16_DIR)ID_IO.C,$(ID16_DIR)ID_LP.C,$(ID16_DIR)ID_MT.C,\ + $(ID16_DIR)ID_PAS.C,$(ID16_DIR)ID_PT.C,$(ID16_DIR)ID_TT.C,\ + $(ID16_DIR)ID_UVC.C,$(ID16_DIR)ID16_DBOOT.C,$(ID16_DIR)ID_TTP.C +ID16_OPTIONS = /INCL=($(SIMH_DIR),$(ID16_DIR))/DEF=($(CC_DEFS)) + +# +# Interdata 32-bit CPU. +# +ID32_DIR = SYS$DISK:[.INTERDATA] +ID32_LIB = $(LIB_DIR)ID32-$(ARCH).OLB +ID32_SOURCE = $(ID32_DIR)ID32_CPU.C,$(ID32_DIR)ID32_SYS.C,$(ID32_DIR)ID_DP.C,\ + $(ID32_DIR)ID_FD.C,$(ID32_DIR)ID_FP.C,$(ID32_DIR)ID_IDC.C,\ + $(ID32_DIR)ID_IO.C,$(ID32_DIR)ID_LP.C,$(ID32_DIR)ID_MT.C,\ + $(ID32_DIR)ID_PAS.C,$(ID32_DIR)ID_PT.C,$(ID32_DIR)ID_TT.C,\ + $(ID32_DIR)ID_UVC.C,$(ID32_DIR)ID32_DBOOT.C,$(ID32_DIR)ID_TTP.C +ID32_OPTIONS = /INCL=($(SIMH_DIR),$(ID32_DIR))/DEF=($(CC_DEFS)) + +# +# IBM 1130 Simulator Definitions. +# +IBM1130_DIR = SYS$DISK:[.IBM1130] +IBM1130_LIB = $(LIB_DIR)IBM1130-$(ARCH).OLB +IBM1130_SOURCE = $(IBM1130_DIR)IBM1130_CPU.C,$(IBM1130_DIR)IBM1130_CR.C,\ + $(IBM1130_DIR)IBM1130_DISK.C,$(IBM1130_DIR)IBM1130_STDDEV.C,\ + $(IBM1130_DIR)IBM1130_SYS.C,$(IBM1130_DIR)IBM1130_GDU.C,\ + $(IBM1130_DIR)IBM1130_GUI.C,$(IBM1130_DIR)IBM1130_PRT.C,\ + $(IBM1130_DIR)IBM1130_FMT.C,$(IBM1130_DIR)IBM1130_PTRP.C,\ + $(IBM1130_DIR)IBM1130_PLOT.C,$(IBM1130_DIR)IBM1130_SCA.C,\ + $(IBM1130_DIR)IBM1130_T2741.C +IBM1130_OPTIONS = /INCL=($(SIMH_DIR),$(IBM1130_DIR))/DEF=($(CC_DEFS)) + +# +# IBM 1401 Simulator Definitions. +# +I1401_DIR = SYS$DISK:[.I1401] +I1401_LIB = $(LIB_DIR)I1401-$(ARCH).OLB +I1401_SOURCE = $(I1401_DIR)I1401_LP.C,$(I1401_DIR)I1401_CPU.C,\ + $(I1401_DIR)I1401_IQ.C,$(I1401_DIR)I1401_CD.C,\ + $(I1401_DIR)I1401_MT.C,$(I1401_DIR)I1401_DP.C,\ + $(I1401_DIR)I1401_SYS.C +I1401_OPTIONS = /INCL=($(SIMH_DIR),$(I1401_DIR))/DEF=($(CC_DEFS)) + + +# +# IBM 1620 Simulators Definitions. +# +I1620_DIR = SYS$DISK:[.I1620] +I1620_LIB = $(LIB_DIR)I1620-$(ARCH).OLB +I1620_SOURCE = $(I1620_DIR)I1620_CD.C,$(I1620_DIR)I1620_DP.C,\ + $(I1620_DIR)I1620_PT.C,$(I1620_DIR)I1620_TTY.C,\ + $(I1620_DIR)I1620_CPU.C,$(I1620_DIR)I1620_LP.C,\ + $(I1620_DIR)I1620_FP.C,$(I1620_DIR)I1620_SYS.C +I1620_OPTIONS = /INCL=($(SIMH_DIR),$(I1620_DIR))/DEF=($(CC_DEFS)) + +# +# PDP-1 Simulator Definitions. +# +PDP1_DIR = SYS$DISK:[.PDP1] +PDP1_LIB = $(LIB_DIR)PDP1-$(ARCH).OLB +PDP1_SOURCE = $(PDP1_DIR)PDP1_LP.C,$(PDP1_DIR)PDP1_CPU.C,\ + $(PDP1_DIR)PDP1_STDDEV.C,$(PDP1_DIR)PDP1_SYS.C,\ + $(PDP1_DIR)PDP1_DT.C,$(PDP1_DIR)PDP1_DRM.C,\ + $(PDP1_DIR)PDP1_CLK.C,$(PDP1_DIR)PDP1_DCS.C, \ + $(PDP1_DIR)PDP1_DPY.C +PDP1_OPTIONS = /INCL=($(SIMH_DIR),$(PDP1_DIR))/DEF=($(CC_DEFS)) + +# +# Digital Equipment PDP-8 Simulator Definitions. +# +PDP8_DIR = SYS$DISK:[.PDP8] +PDP8_LIB = $(LIB_DIR)PDP8-$(ARCH).OLB +PDP8_SOURCE = $(PDP8_DIR)PDP8_CPU.C,$(PDP8_DIR)PDP8_CLK.C,\ + $(PDP8_DIR)PDP8_DF.C,$(PDP8_DIR)PDP8_DT.C,\ + $(PDP8_DIR)PDP8_LP.C,$(PDP8_DIR)PDP8_MT.C,\ + $(PDP8_DIR)PDP8_PT.C,$(PDP8_DIR)PDP8_RF.C,\ + $(PDP8_DIR)PDP8_RK.C,$(PDP8_DIR)PDP8_RX.C,\ + $(PDP8_DIR)PDP8_SYS.C,$(PDP8_DIR)PDP8_TT.C,\ + $(PDP8_DIR)PDP8_TTX.C,$(PDP8_DIR)PDP8_RL.C,\ + $(PDP8_DIR)PDP8_TSC.C,$(PDP8_DIR)PDP8_TD.C,\ + $(PDP8_DIR)PDP8_CT.C,$(PDP8_DIR)PDP8_FPP.C +PDP8_OPTIONS = /INCL=($(SIMH_DIR),$(PDP8_DIR))/DEF=($(CC_DEFS)) + +# +# Digital Equipment PDP-4, PDP-7, PDP-9 And PDP-15 Simulator Definitions. +# +PDP18B_DIR = SYS$DISK:[.PDP18B] +PDP4_LIB = $(LIB_DIR)PDP4-$(ARCH).OLB +PDP7_LIB = $(LIB_DIR)PDP7-$(ARCH).OLB +PDP9_LIB = $(LIB_DIR)PDP9-$(ARCH).OLB +PDP15_LIB = $(LIB_DIR)PDP15-$(ARCH).OLB +PDP18B_SOURCE = $(PDP18B_DIR)PDP18B_DT.C,$(PDP18B_DIR)PDP18B_DRM.C,\ + $(PDP18B_DIR)PDP18B_CPU.C,$(PDP18B_DIR)PDP18B_LP.C,\ + $(PDP18B_DIR)PDP18B_MT.C,$(PDP18B_DIR)PDP18B_RF.C,\ + $(PDP18B_DIR)PDP18B_RP.C,$(PDP18B_DIR)PDP18B_STDDEV.C,\ + $(PDP18B_DIR)PDP18B_SYS.C,$(PDP18B_DIR)PDP18B_TT1.C,\ + $(PDP18B_DIR)PDP18B_RB.C,$(PDP18B_DIR)PDP18B_FPP.C,\ + $(PDP18B_DIR)PDP18B_G2TTY.C +PDP4_OPTIONS = /INCL=($(SIMH_DIR),$(PDP18B_DIR))/DEF=($(CC_DEFS),"PDP4=1") +PDP7_OPTIONS = /INCL=($(SIMH_DIR),$(PDP18B_DIR))/DEF=($(CC_DEFS),"PDP7=1") +PDP9_OPTIONS = /INCL=($(SIMH_DIR),$(PDP18B_DIR))/DEF=($(CC_DEFS),"PDP9=1") +PDP15_OPTIONS = /INCL=($(SIMH_DIR),$(PDP18B_DIR))/DEF=($(CC_DEFS),"PDP15=1") + +# +# Digital Equipment PDP-11 Simulator Definitions. +# +PDP11_DIR = SYS$DISK:[.PDP11] +PDP11_LIB1 = $(LIB_DIR)PDP11L1-$(ARCH).OLB +PDP11_SOURCE1 = $(PDP11_DIR)PDP11_FP.C,$(PDP11_DIR)PDP11_CPU.C,\ + $(PDP11_DIR)PDP11_DZ.C,$(PDP11_DIR)PDP11_CIS.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_RK.C,\ + $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RP.C,\ + $(PDP11_DIR)PDP11_RX.C,$(PDP11_DIR)PDP11_STDDEV.C,\ + $(PDP11_DIR)PDP11_SYS.C,$(PDP11_DIR)PDP11_TC.C, \ + $(PDP11_DIR)PDP11_CPUMOD.C,$(PDP11_DIR)PDP11_CR.C,\ + $(PDP11_DIR)PDP11_TA.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_DUP.C,$(PDP11_DIR)PDP11_RS.C,\ + $(PDP11_DIR)PDP11_VT.C,$(PDP11_DIR)PDP11_KMC.C,\ + $(PDP11_DIR)PDP11_IO_LIB.C +PDP11_LIB2 = $(LIB_DIR)PDP11L2-$(ARCH).OLB +PDP11_SOURCE2 = $(PDP11_DIR)PDP11_TM.C,$(PDP11_DIR)PDP11_TS.C,\ + $(PDP11_DIR)PDP11_IO.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,$(PDP11_DIR)PDP11_PCLK.C,\ + $(PDP11_DIR)PDP11_RY.C,$(PDP11_DIR)PDP11_PT.C,\ + $(PDP11_DIR)PDP11_HK.C,$(PDP11_DIR)PDP11_XQ.C,\ + $(PDP11_DIR)PDP11_VH.C,$(PDP11_DIR)PDP11_RH.C,\ + $(PDP11_DIR)PDP11_XU.C,$(PDP11_DIR)PDP11_TU.C,\ + $(PDP11_DIR)PDP11_DL.C,$(PDP11_DIR)PDP11_RF.C, \ + $(PDP11_DIR)PDP11_RC.C,$(PDP11_DIR)PDP11_KG.C,\ + $(PDP11_DIR)PDP11_KE.C,$(PDP11_DIR)PDP11_DC.C +PDP11_OPTIONS = /INCL=($(SIMH_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_PDP11=1"$(PCAP_DEFS)) + +# +# Digital Equipment PDP-10 Simulator Definitions. +# +PDP10_DIR = SYS$DISK:[.PDP10] +PDP10_LIB = $(LIB_DIR)PDP10-$(ARCH).OLB +PDP10_SOURCE = $(PDP10_DIR)PDP10_FE.C,\ + $(PDP10_DIR)PDP10_CPU.C,$(PDP10_DIR)PDP10_KSIO.C,\ + $(PDP10_DIR)PDP10_LP20.C,$(PDP10_DIR)PDP10_MDFP.C,\ + $(PDP10_DIR)PDP10_PAG.C,$(PDP10_DIR)PDP10_XTND.C,\ + $(PDP10_DIR)PDP10_RP.C,$(PDP10_DIR)PDP10_SYS.C,\ + $(PDP10_DIR)PDP10_TIM.C,$(PDP10_DIR)PDP10_TU.C,\ + $(PDP11_DIR)PDP11_PT.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_RY.C,$(PDP11_DIR)PDP11_CR.C,\ + $(PDP11_DIR)PDP11_DUP.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_KMC.C,$(PDP11_DIR)PDP11_XU.C +PDP10_OPTIONS = /INCL=($(SIMH_DIR),$(PDP10_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"USE_INT64=1","VM_PDP10=1"$(PCAP_DEFS)) + +# +# IBM System 3 Simulator Definitions. +# +S3_DIR = SYS$DISK:[.S3] +S3_LIB = $(LIB_DIR)S3-$(ARCH).OLB +S3_SOURCE = $(S3_DIR)S3_CD.C,$(S3_DIR)S3_CPU.C,$(S3_DIR)S3_DISK.C,\ + $(S3_DIR)S3_LP.C,$(S3_DIR)S3_PKB.C,$(S3_DIR)S3_SYS.C +S3_OPTIONS = /INCL=($(SIMH_DIR),$(S3_DIR))/DEF=($(CC_DEFS)) + +# +# SDS 940 +# +SDS_DIR = SYS$DISK:[.SDS] +SDS_LIB = $(LIB_DIR)SDS-$(ARCH).OLB +SDS_SOURCE = $(SDS_DIR)SDS_CPU.C,$(SDS_DIR)SDS_DRM.C,$(SDS_DIR)SDS_DSK.C,\ + $(SDS_DIR)SDS_IO.C,$(SDS_DIR)SDS_LP.C,$(SDS_DIR)SDS_MT.C,\ + $(SDS_DIR)SDS_MUX.C,$(SDS_DIR)SDS_RAD.C,$(SDS_DIR)SDS_STDDEV.C,\ + $(SDS_DIR)SDS_SYS.C +SDS_OPTIONS = /INCL=($(SIMH_DIR),$(SDS_DIR))/DEF=($(CC_DEFS)) + +# +# SSEM +# +SSEM_DIR = SYS$DISK:[.SSEM] +SSEM_LIB = $(LIB_DIR)SSEM-$(ARCH).OLB +SSEM_SOURCE = $(SSEM_DIR)SSEM_CPU.C,$(SSEM_DIR)SSEM_SYS.C +SSEM_OPTIONS = /INCL=($(SIMH_DIR),$(SSEM_DIR))/DEF=($(CC_DEFS)) + +# +# SWTP 6800MP A +# +SWTP6800MP_A_DIR = SYS$DISK:[.SWTP6800.SWTP6800] +SWTP6800MP_A_COMMON = SYS$DISK:[.SWTP6800.COMMON] +SWTP6800MP_A_LIB = $(LIB_DIR)SWTP6800MP-A-$(ARCH).OLB +SWTP6800MP_A_SOURCE = $(SWTP6800MP_A_COMMON)mp-a.c,$(SWTP6800MP_A_COMMON)m6800.c,\ + $(SWTP6800MP_A_COMMON)m6810.c,$(SWTP6800MP_A_COMMON)bootrom.c,$(SWTP6800MP_A_COMMON)dc-4.c,\ + $(SWTP6800MP_A_COMMON)mp-s.c,$(SWTP6800MP_A_DIR)mp-a_sys.c,$(SWTP6800MP_A_COMMON)mp-b2.c,\ + $(SWTP6800MP_A_COMMON)mp-8m.c +SWTP6800MP_A_OPTIONS = /INCL=($(SIMH_DIR),$(SWTP6800MP_A_DIR))/DEF=($(CC_DEFS)) + +# +# SWTP 6800MP A2 +# +SWTP6800MP_A2_DIR = SYS$DISK:[.SWTP6800.SWTP6800] +SWTP6800MP_A2_COMMON = SYS$DISK:[.SWTP6800.COMMON] +SWTP6800MP_A2_LIB = $(LIB_DIR)SWTP6800MP-A2-$(ARCH).OLB +SWTP6800MP_A2_SOURCE = $(SWTP6800MP_A2_COMMON)mp-a2.c,$(SWTP6800MP_A2_COMMON)m6800.c,\ + $(SWTP6800MP_A2_COMMON)m6810.c,$(SWTP6800MP_A2_COMMON)bootrom.c,$(SWTP6800MP_A2_COMMON)dc-4.c,\ + $(SWTP6800MP_A2_COMMON)mp-s.c,$(SWTP6800MP_A2_DIR)mp-a2_sys.c,$(SWTP6800MP_A2_COMMON)mp-b2.c,\ + $(SWTP6800MP_A2_COMMON)mp-8m.c,$(SWTP6800MP_A2_COMMON)i2716.c +SWTP6800MP_A2_OPTIONS = /INCL=($(SIMH_DIR),$(SWTP6800MP_A2_DIR))/DEF=($(CC_DEFS)) + +# +# BESM6 +# +BESM6_DIR = SYS$DISK:[.BESM6] +BESM6_LIB = $(LIB_DIR)BESM6-$(ARCH).OLB +BESM6_SOURCE = $(BESM6_DIR)BESM6_CPU.C,$(BESM6_DIR)BESM6_SYS.C,$(BESM6_DIR)BESM6_MMU.C,\ + $(BESM6_DIR)BESM6_ARITH.C,$(BESM6_DIR)BESM6_DISK.C,$(BESM6_DIR)BESM6_DRUM.C,\ + $(BESM6_DIR)BESM6_TTY.C,$(BESM6_DIR)BESM6_PANEL.C,$(BESM6_DIR)BESM6_PRINTER.C,\ + $(BESM6_DIR)BESM6_PUNCH.C +BESM6_OPTIONS = /INCL=($(SIMH_DIR),$(BESM6_DIR))/DEF=($(CC_DEFS),"USE_INT64=1") + +# +# B5500 +# +B5500_DIR = SYS$DISK:[.B5500] +B5500_LIB = $(LIB_DIR)B5500-$(ARCH).OLB +B5500_SOURCE = $(B5500_DIR)B5500_CPU.C,$(B5500_DIR)B5500_DK.C,$(B5500_DIR)B5500_DR.C,\ + $(B5500_DIR)B5500_DTC.C,$(B5500_DIR)B5500_IO.C,$(B5500_DIR)B5500_MT.C,\ + $(B5500_DIR)B5500_SYS.C,$(B5500_DIR)B5500_UREC.C,$(SIMH_DIR)SIM_CARD.C +B5500_OPTIONS = /INCL=($(SIMH_DIR),$(B5500_DIR))/DEF=($(CC_DEFS),"USE_INT64=1","USE_SIM_CARD=1") + +# +# Digital Equipment VAX 3900 Simulator Definitions. +# +VAX_DIR = SYS$DISK:[.VAX] +VAX_LIB1 = $(LIB_DIR)VAXL1-$(ARCH).OLB +VAX_LIB2 = $(LIB_DIR)VAXL2-$(ARCH).OLB +VAX_SOURCE1 = $(VAX_DIR)VAX_CIS.C,$(VAX_DIR)VAX_CMODE.C,\ + $(VAX_DIR)VAX_CPU.C,$(VAX_DIR)VAX_CPU1.C,\ + $(VAX_DIR)VAX_FPA.C,$(VAX_DIR)VAX_MMU.C,\ + $(VAX_DIR)VAX_OCTA.C,$(VAX_DIR)VAX_SYS.C,\ + $(VAX_DIR)VAX_SYSCM.C,$(VAX_DIR)VAX_SYSDEV.C,\ + $(VAX_DIR)VAX_SYSLIST.C,$(VAX_DIR)VAX_IO.C,\ + $(VAX_DIR)VAX_STDDEV.C +VAX_SOURCE2 = $(PDP11_DIR)PDP11_IO_LIB.C,\ + $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XQ.C,$(PDP11_DIR)PDP11_VH.C,\ + $(PDP11_DIR)PDP11_CR.C,\ + $(VAX_DIR)VAX_VC.C,$(VAX_DIR)VAX_LK.C,\ + $(VAX_DIR)VAX_VS.C,$(VAX_DIR)VAX_2681.C +.IFDEF ALPHA_OR_IA64 +VAX_OPTIONS = /INCL=($(SIMH_DIR),$(VAX_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS)) +VAX_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX_OPTIONS = /INCL=($(SIMH_DIR),$(VAX_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS)) +VAX_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX610 (MicroVAX I) Simulator Definitions. +# +VAX610_DIR = SYS$DISK:[.VAX] +VAX610_LIB1 = $(LIB_DIR)VAX610L1-$(ARCH).OLB +VAX610_SOURCE1 = $(VAX610_DIR)VAX_CPU.C,$(VAX610_DIR)VAX_CPU1.C,\ + $(VAX610_DIR)VAX_FPA.C,$(VAX610_DIR)VAX_CIS.C,\ + $(VAX610_DIR)VAX_OCTA.C,$(VAX610_DIR)VAX_CMODE.C,\ + $(VAX610_DIR)VAX_MMU.C,$(VAX610_DIR)VAX_SYS.C,\ + $(VAX610_DIR)VAX_SYSCM.C,$(VAX610_DIR)VAX610_STDDEV.C,\ + $(VAX610_DIR)VAX610_MEM.C,$(VAX610_DIR)VAX610_SYSDEV.C,\ + $(VAX610_DIR)VAX610_IO.C,$(VAX610_DIR)VAX610_SYSLIST.C +VAX610_LIB2 = $(LIB_DIR)VAX610L2-$(ARCH).OLB +VAX610_SOURCE2 = $(PDP11_DIR)PDP11_IO_LIB.C,\ + $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XQ.C,$(PDP11_DIR)PDP11_VH.C,\ + $(PDP11_DIR)PDP11_CR.C,$(VAX610_DIR)VAX_VC.C,\ + $(VAX610_DIR)VAX_LK.C,$(VAX610_DIR)VAX_VS.C,\ + $(VAX610_DIR)VAX_2681.C +.IFDEF ALPHA_OR_IA64 +VAX610_OPTIONS = /INCL=($(SIMH_DIR),$(VAX610_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_610=1") +VAX610_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX610_OPTIONS = /INCL=($(SIMH_DIR),$(VAX610_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_610=1") +VAX610_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX630 (MicroVAX II) Simulator Definitions. +# +VAX630_DIR = SYS$DISK:[.VAX] +VAX630_LIB1 = $(LIB_DIR)VAX630L1-$(ARCH).OLB +VAX630_SOURCE1 = $(VAX630_DIR)VAX_CPU.C,$(VAX630_DIR)VAX_CPU1.C,\ + $(VAX630_DIR)VAX_FPA.C,$(VAX630_DIR)VAX_CIS.C,\ + $(VAX630_DIR)VAX_OCTA.C,$(VAX630_DIR)VAX_CMODE.C,\ + $(VAX630_DIR)VAX_MMU.C,$(VAX630_DIR)VAX_SYS.C,\ + $(VAX630_DIR)VAX_SYSCM.C,$(VAX630_DIR)VAX_WATCH.C,\ + $(VAX630_DIR)VAX630_STDDEV.C,$(VAX630_DIR)VAX630_SYSDEV.C,\ + $(VAX630_DIR)VAX630_IO.C,$(VAX630_DIR)VAX630_SYSLIST.C +VAX630_LIB2 = $(LIB_DIR)VAX630L2-$(ARCH).OLB +VAX630_SOURCE2 = $(PDP11_DIR)PDP11_IO_LIB.C,\ + $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XQ.C,$(PDP11_DIR)PDP11_VH.C,\ + $(PDP11_DIR)PDP11_CR.C,$(VAX630_DIR)VAX_VC.C,\ + $(VAX630_DIR)VAX_LK.C,$(VAX630_DIR)VAX_VS.C,\ + $(VAX630_DIR)VAX_2681.C +.IFDEF ALPHA_OR_IA64 +VAX630_OPTIONS = /INCL=($(SIMH_DIR),$(VAX630_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_630=1") +VAX630_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX630_OPTIONS = /INCL=($(SIMH_DIR),$(VAX630_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_630=1") +VAX630_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment rtVAX1000 (rtVAX 1000) Simulator Definitions. +# +VAX620_DIR = SYS$DISK:[.VAX] +VAX620_LIB1 = $(LIB_DIR)VAX620L1-$(ARCH).OLB +VAX620_SOURCE1 = $(VAX620_DIR)VAX_CPU.C,$(VAX620_DIR)VAX_CPU1.C,\ + $(VAX620_DIR)VAX_FPA.C,$(VAX620_DIR)VAX_CIS.C,\ + $(VAX620_DIR)VAX_OCTA.C,$(VAX620_DIR)VAX_CMODE.C,\ + $(VAX620_DIR)VAX_MMU.C,$(VAX620_DIR)VAX_SYS.C,\ + $(VAX620_DIR)VAX_SYSCM.C,$(VAX630_DIR)VAX_WATCH.C,\ + $(VAX620_DIR)VAX630_STDDEV.C,$(VAX620_DIR)VAX630_SYSDEV.C,\ + $(VAX620_DIR)VAX630_IO.C,$(VAX620_DIR)VAX630_SYSLIST.C +VAX620_LIB2 = $(LIB_DIR)VAX620L2-$(ARCH).OLB +VAX620_SOURCE2 = $(PDP11_DIR)PDP11_IO_LIB.C,\ + $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XQ.C,$(PDP11_DIR)PDP11_VH.C,\ + $(PDP11_DIR)PDP11_CR.C,$(VAX620_DIR)VAX_VC.C,\ + $(VAX620_DIR)VAX_LK.C,$(VAX620_DIR)VAX_VS.C,\ + $(VAX620_DIR)VAX_2681.C +.IFDEF ALPHA_OR_IA64 +VAX620_OPTIONS = /INCL=($(SIMH_DIR),$(VAX620_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_620=1") +VAX620_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX620_OPTIONS = /INCL=($(SIMH_DIR),$(VAX620_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_620=1") +VAX620_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX730 Simulator Definitions. +# +VAX730_DIR = SYS$DISK:[.VAX] +VAX730_LIB1 = $(LIB_DIR)VAX730L1-$(ARCH).OLB +VAX730_SOURCE1 = $(VAX730_DIR)VAX_CPU.C,$(VAX730_DIR)VAX_CPU1.C,\ + $(VAX730_DIR)VAX_FPA.C,$(VAX730_DIR)VAX_CIS.C,\ + $(VAX730_DIR)VAX_OCTA.C,$(VAX730_DIR)VAX_CMODE.C,\ + $(VAX730_DIR)VAX_MMU.C,$(VAX730_DIR)VAX_SYS.C,\ + $(VAX730_DIR)VAX_SYSCM.C,$(VAX730_DIR)VAX730_STDDEV.C,\ + $(VAX730_DIR)VAX730_SYS.C,$(VAX730_DIR)VAX730_MEM.C,\ + $(VAX730_DIR)VAX730_UBA.C,$(VAX730_DIR)VAX730_RB.C,\ + $(VAX730_DIR)VAX730_SYSLIST.C +VAX730_LIB2 = $(LIB_DIR)VAX730L2-$(ARCH).OLB +VAX730_SOURCE2 = $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XU.C,$(PDP11_DIR)PDP11_RY.C,\ + $(PDP11_DIR)PDP11_CR.C,$(PDP11_DIR)PDP11_HK.C,\ + $(PDP11_DIR)PDP11_VH.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_TC.C,$(PDP11_DIR)PDP11_RK.C,$(PDP11_DIR)PDP11_IO_LIB.C +.IFDEF ALPHA_OR_IA64 +VAX730_OPTIONS = /INCL=($(SIMH_DIR),$(VAX730_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_730=1") +VAX730_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX730_OPTIONS = /INCL=($(SIMH_DIR),$(VAX730_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_730=1") +VAX730_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX750 Simulator Definitions. +# +VAX750_DIR = SYS$DISK:[.VAX] +VAX750_LIB1 = $(LIB_DIR)VAX750L1-$(ARCH).OLB +VAX750_SOURCE1 = $(VAX750_DIR)VAX_CPU.C,$(VAX750_DIR)VAX_CPU1.C,\ + $(VAX750_DIR)VAX_FPA.C,$(VAX750_DIR)VAX_CIS.C,\ + $(VAX750_DIR)VAX_OCTA.C,$(VAX750_DIR)VAX_CMODE.C,\ + $(VAX750_DIR)VAX_MMU.C,$(VAX750_DIR)VAX_SYS.C,\ + $(VAX750_DIR)VAX_SYSCM.C,$(VAX750_DIR)VAX750_STDDEV.C,\ + $(VAX750_DIR)VAX750_CMI.C,$(VAX750_DIR)VAX750_MEM.C,\ + $(VAX750_DIR)VAX750_UBA.C,$(VAX750_DIR)VAX7X0_MBA.C,\ + $(VAX750_DIR)VAX750_SYSLIST.C +VAX750_LIB2 = $(LIB_DIR)VAX750L2-$(ARCH).OLB +VAX750_SOURCE2 = $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XU.C,$(PDP11_DIR)PDP11_RY.C,\ + $(PDP11_DIR)PDP11_CR.C,$(PDP11_DIR)PDP11_HK.C,\ + $(PDP11_DIR)PDP11_RP.C,$(PDP11_DIR)PDP11_TU.C,\ + $(PDP11_DIR)PDP11_VH.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_TC.C,$(PDP11_DIR)PDP11_RK.C,$(PDP11_DIR)PDP11_IO_LIB.C +.IFDEF ALPHA_OR_IA64 +VAX750_OPTIONS = /INCL=($(SIMH_DIR),$(VAX750_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_750=1") +VAX750_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX750_OPTIONS = /INCL=($(SIMH_DIR),$(VAX750_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_750=1") +VAX750_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX780 Simulator Definitions. +# +VAX780_DIR = SYS$DISK:[.VAX] +VAX780_LIB1 = $(LIB_DIR)VAX780L1-$(ARCH).OLB +VAX780_SOURCE1 = $(VAX780_DIR)VAX_CPU.C,$(VAX780_DIR)VAX_CPU1.C,\ + $(VAX780_DIR)VAX_FPA.C,$(VAX780_DIR)VAX_CIS.C,\ + $(VAX780_DIR)VAX_OCTA.C,$(VAX780_DIR)VAX_CMODE.C,\ + $(VAX780_DIR)VAX_MMU.C,$(VAX780_DIR)VAX_SYS.C,\ + $(VAX780_DIR)VAX_SYSCM.C,$(VAX780_DIR)VAX780_STDDEV.C,\ + $(VAX780_DIR)VAX780_SBI.C,$(VAX780_DIR)VAX780_MEM.C,\ + $(VAX780_DIR)VAX780_UBA.C,$(VAX780_DIR)VAX7X0_MBA.C,\ + $(VAX780_DIR)VAX780_FLOAD.C,$(VAX780_DIR)VAX780_SYSLIST.C +VAX780_LIB2 = $(LIB_DIR)VAX780L2-$(ARCH).OLB +VAX780_SOURCE2 = $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XU.C,$(PDP11_DIR)PDP11_RY.C,\ + $(PDP11_DIR)PDP11_CR.C,$(PDP11_DIR)PDP11_RP.C,\ + $(PDP11_DIR)PDP11_TU.C,$(PDP11_DIR)PDP11_HK.C,\ + $(PDP11_DIR)PDP11_VH.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_TC.C,$(PDP11_DIR)PDP11_RK.C,$(PDP11_DIR)PDP11_IO_LIB.C +.IFDEF ALPHA_OR_IA64 +VAX780_OPTIONS = /INCL=($(SIMH_DIR),$(VAX780_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_780=1") +VAX780_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX780_OPTIONS = /INCL=($(SIMH_DIR),$(VAX780_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_780=1") +VAX780_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# Digital Equipment VAX8600 Simulator Definitions. +# +VAX8600_DIR = SYS$DISK:[.VAX] +VAX8600_LIB1 = $(LIB_DIR)VAX860L1-$(ARCH).OLB +VAX8600_SOURCE1 = $(VAX8600_DIR)VAX_CPU.C,$(VAX8600_DIR)VAX_CPU1.C,\ + $(VAX8600_DIR)VAX_FPA.C,$(VAX8600_DIR)VAX_CIS.C,\ + $(VAX8600_DIR)VAX_OCTA.C,$(VAX8600_DIR)VAX_CMODE.C,\ + $(VAX8600_DIR)VAX_MMU.C,$(VAX8600_DIR)VAX_SYS.C,\ + $(VAX8600_DIR)VAX_SYSCM.C,$(VAX8600_DIR)VAX860_STDDEV.C,\ + $(VAX8600_DIR)VAX860_SBIA.C,$(VAX8600_DIR)VAX860_ABUS.C,\ + $(VAX8600_DIR)VAX780_UBA.C,$(VAX8600_DIR)VAX7X0_MBA.C,\ + $(VAX8600_DIR)VAX860_SYSLIST.C +VAX8600_LIB2 = $(LIB_DIR)VAX860L2-$(ARCH).OLB +VAX8600_SOURCE2 = $(PDP11_DIR)PDP11_RL.C,$(PDP11_DIR)PDP11_RQ.C,\ + $(PDP11_DIR)PDP11_TS.C,$(PDP11_DIR)PDP11_DZ.C,\ + $(PDP11_DIR)PDP11_LP.C,$(PDP11_DIR)PDP11_TD.C,$(PDP11_DIR)PDP11_TQ.C,\ + $(PDP11_DIR)PDP11_XU.C,$(PDP11_DIR)PDP11_RY.C,\ + $(PDP11_DIR)PDP11_CR.C,$(PDP11_DIR)PDP11_RP.C,\ + $(PDP11_DIR)PDP11_TU.C,$(PDP11_DIR)PDP11_HK.C,\ + $(PDP11_DIR)PDP11_VH.C,$(PDP11_DIR)PDP11_DMC.C,\ + $(PDP11_DIR)PDP11_TC.C,$(PDP11_DIR)PDP11_RK.C,$(PDP11_DIR)PDP11_IO_LIB.C +.IFDEF ALPHA_OR_IA64 +VAX8600_OPTIONS = /INCL=($(SIMH_DIR),$(VAX8600_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1","USE_ADDR64=1","USE_INT64=1"$(PCAP_DEFS),"VAX_860=1") +VAX8600_SIMH_LIB = $(SIMH_LIB64) +.ELSE +VAX8600_OPTIONS = /INCL=($(SIMH_DIR),$(VAX8600_DIR),$(PDP11_DIR)$(PCAP_INC))\ + /DEF=($(CC_DEFS),"VM_VAX=1"$(PCAP_DEFS),"VAX_860=1") +VAX8600_SIMH_LIB = $(SIMH_LIB) +.ENDIF + +# IBM 7094 Simulator Definitions. +# +I7094_DIR = SYS$DISK:[.I7094] +I7094_LIB = $(LIB_DIR)I7094-$(ARCH).OLB +I7094_SOURCE = $(I7094_DIR)I7094_CPU.C,$(I7094_DIR)I7094_CPU1.C,\ + $(I7094_DIR)I7094_IO.C,$(I7094_DIR)I7094_CD.C,\ + $(I7094_DIR)I7094_CLK.C,$(I7094_DIR)I7094_COM.C,\ + $(I7094_DIR)I7094_DRM.C,$(I7094_DIR)I7094_DSK.C,\ + $(I7094_DIR)I7094_SYS.C,$(I7094_DIR)I7094_LP.C,\ + $(I7094_DIR)I7094_MT.C,$(I7094_DIR)I7094_BINLOADER.C +I7094_OPTIONS = /INCL=($(SIMH_DIR),$(I7094_DIR))/DEF=($(CC_DEFS)) + +# If we're not a VAX, Build Everything +# +.IFDEF ALPHA_OR_IA64 +ALL : ALTAIR ALTAIRZ80 ECLIPSE GRI LGP H316 HP2100 HP3000 I1401 I1620 IBM1130 ID16 \ + ID32 NOVA PDP1 PDP4 PDP7 PDP8 PDP9 PDP10 PDP11 PDP15 S3 \ + VAX MICROVAX3900 MICROVAX1 RTVAX1000 MICROVAX2 VAX730 VAX750 VAX780 VAX8600 \ + SDS I7094 SWTP6800MP-A SWTP6800MP-A2 SSEM BESM6 B5500 + $! No further actions necessary +.ELSE +# +# Else We Are On VAX And Build Everything EXCEPT the 64b simulators +# +ALL : ALTAIR ALTAIRZ80 GRI H316 HP2100 I1401 I1620 IBM1130 ID16 ID32 \ + NOVA PDP1 PDP4 PDP7 PDP8 PDP9 PDP11 PDP15 S3 \ + VAX MICROVAX3900 MICROVAX1 RTVAX1000 MICROVAX2 VAX730 VAX750 VAX780 VAX8600 \ + SDS SWTP6800MP-A SWTP6800MP-A2 SSEM + $! No further actions necessary +.ENDIF + +CLEAN : + $! + $! Clean out all targets and building Remnants + $! + $ IF (F$SEARCH("$(BIN_DIR)*.EXE;*").NES."") THEN - + DELETE/NOLOG/NOCONFIRM $(BIN_DIR)*.EXE;* + $ IF (F$SEARCH("$(LIB_DIR)*.OLB;*").NES."") THEN - + DELETE/NOLOG/NOCONFIRM $(LIB_DIR)*.OLB;* + $ IF (F$SEARCH("SYS$DISK:[...]*.OBJ;*").NES."") THEN - + DELETE/NOLOG/NOCONFIRM SYS$DISK:[...]*.OBJ;* + $ IF (F$SEARCH("SYS$DISK:[...]*.LIS;*").NES."") THEN - + DELETE/NOLOG/NOCONFIRM SYS$DISK:[...]*.LIS;* + $ IF (F$SEARCH("SYS$DISK:[...]*.MAP;*").NES."") THEN - + DELETE/NOLOG/NOCONFIRM SYS$DISK:[...]*.MAP;* + +# +# ROM support +# +BUILDROMS : $(BIN_DIR)BuildROMs-$(ARCH).EXE + $! BuildROMs done + +$(BIN_DIR)BuildROMs-$(ARCH).EXE : sim_BuildROMs.c + $! + $! Building The $(BIN_DIR)BuildROMs-$(ARCH).EXE Tool. + $! + $ $(CC)/OBJ=$(BLD_DIR) SIM_BUILDROMS.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)BUILDROMS-$(ARCH).EXE - + $(BLD_DIR)SIM_BUILDROMS.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + +# +# Build The Libraries. +# +$(SIMH_LIB) : $(SIMH_SOURCE) + $! + $! Building The $(SIMH_LIB) Library. + $! + $ $(CC)/DEF=($(CC_DEFS)$(PCAP_DEFS))$(PCAP_SIMH_INC) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(SIMH_NONET_LIB) : $(SIMH_SOURCE) + $! + $! Building The $(SIMH_NONET_LIB) Library. + $! + $ $(CC)/DEF=($(CC_DEFS)) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +.IFDEF ALPHA_OR_IA64 +$(SIMH_LIB64) : $(SIMH_SOURCE) + $! + $! Building The $(SIMH_LIB64) Library. + $! + $ $(CC)/DEF=($(CC_DEFS)$(PCAP_DEFS),"USE_ADDR64=1","USE_INT64=1")$(PCAP_SIMH_INC) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ENDIF + +$(ALTAIR_LIB) : $(ALTAIR_SOURCE) + $! + $! Building The $(ALTAIR_LIB) Library. + $! + $ $(CC)$(ALTAIR_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(ALTAIRZ80_LIB1) : $(ALTAIRZ80_SOURCE1) + $! + $! Building The $(ALTAIRZ80_LIB1) Library. + $! + $ $(CC)$(ALTAIRZ80_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(ALTAIRZ80_LIB2) : $(ALTAIRZ80_SOURCE2) + $! + $! Building The $(ALTAIRZ80_LIB2) Library. + $! + $ $(CC)$(ALTAIRZ80_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The Eclipse Library. +# +.IFDEF ALPHA_OR_IA64 +$(ECLIPSE_LIB) : $(ECLIPSE_SOURCE) + $! + $! Building The $(ECLIPSE_LIB) Library. + $! + $ $(CC)$(ECLIPSE_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# We Are On VAX And Due To The Use of INT64 We Can't Build It. +# +$(ECLIPSE_LIB) : + $! Due To The Use Of INT64 We Can't Build The + $! $(MMS$TARGET) Library On VAX. +.ENDIF + +$(GRI_LIB) : $(GRI_SOURCE) + $! + $! Building The $(GRI_LIB) Library. + $! + $ $(CC)$(GRI_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(LGP_LIB) : $(LGP_SOURCE) + $! + $! Building The $(LGP_LIB) Library. + $! + $ $(CC)$(LGP_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(H316_LIB) : $(H316_SOURCE) + $! + $! Building The $(H316_LIB) Library. + $! + $ $(CC)$(H316_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(HP2100_LIB1) : $(HP2100_SOURCE1) + $! + $! Building The $(HP2100_LIB1) Library. + $! + $ $(CC)$(HP2100_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(HP2100_LIB2) : $(HP2100_SOURCE2) + $! + $! Building The $(HP2100_LIB2) Library. + $! + $ $(CC)$(HP2100_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(HP3000_LIB1) : $(HP3000_SOURCE1) + $! + $! Building The $(HP3000_LIB1) Library. + $! + $ $(CC)$(HP3000_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(HP3000_LIB2) : $(HP3000_SOURCE2) + $! + $! Building The $(HP3000_LIB2) Library. + $! + $ $(CC)$(HP3000_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(I1401_LIB) : $(I1401_SOURCE) + $! + $! Building The $(I1401_LIB) Library. + $! + $ $(CC)$(I1401_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(I1620_LIB) : $(I1620_SOURCE) + $! + $! Building The $(I1620_LIB) Library. + $! + $ $(CC)$(I1620_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(IBM1130_LIB) : $(IBM1130_SOURCE) + $! + $! Building The $(IBM1130_LIB) Library. + $! + $ $(CC)$(IBM1130_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(ID16_LIB) : $(ID16_SOURCE) + $! + $! Building The $(ID16_LIB) Library. + $! + $ $(CC)$(ID16_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(ID32_LIB) : $(ID32_SOURCE) + $! + $! Building The $(ID32_LIB) Library. + $! + $ $(CC)$(ID32_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(NOVA_LIB) : $(NOVA_SOURCE) + $! + $! Building The $(NOVA_LIB) Library. + $! + $ $(CC)$(NOVA_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP1_LIB) : $(PDP1_SOURCE) + $! + $! Building The $(PDP1_LIB) Library. + $! + $ $(CC)$(PDP1_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP4_LIB) : $(PDP18B_SOURCE) + $! + $! Building The $(PDP4_LIB) Library. + $! + $ $(CC)$(PDP4_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP7_LIB) : $(PDP18B_SOURCE) + $! + $! Building The $(PDP7_LIB) Library. + $! + $ $(CC)$(PDP7_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP8_LIB) : $(PDP8_SOURCE) + $! + $! Building The $(PDP8_LIB) Library. + $! + $ $(CC)$(PDP8_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP9_LIB) : $(PDP18B_SOURCE) + $! + $! Building The $(PDP9_LIB) Library. + $! + $ $(CC)$(PDP9_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The PDP-10 Library. +# +.IFDEF ALPHA_OR_IA64 +$(PDP10_LIB) : $(PDP10_SOURCE) + $! + $! Building The $(PDP10_LIB) Library. + $! + $ $(CC)$(PDP10_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# We Are On VAX And Due To The Use of INT64 We Can't Build It. +# +$(PDP10_LIB) : + $! Due To The Use Of INT64 We Can't Build The + $! $(MMS$TARGET) Library On VAX. +.ENDIF + +$(PDP11_LIB1) : $(PDP11_SOURCE1) + $! + $! Building The $(PDP11_LIB1) Library. + $! + $ $(CC)$(PDP11_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP11_LIB2) : $(PDP11_SOURCE2) + $! + $! Building The $(PDP11_LIB2) Library. + $! + $ $(CC)$(PDP11_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PDP15_LIB) : $(PDP18B_SOURCE) + $! + $! Building The $(PDP15_LIB) Library. + $! + $ $(CC)$(PDP15_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(S3_LIB) : $(S3_SOURCE) + $! + $! Building The $(S3_LIB) Library. + $! + $ $(CC)$(S3_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(SDS_LIB) : $(SDS_SOURCE) + $! + $! Building The $(SDS_LIB) Library. + $! + $ $(CC)$(SDS_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(SSEM_LIB) : $(SSEM_SOURCE) + $! + $! Building The $(SSEM_LIB) Library. + $! + $ $(CC)$(SSEM_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(SWTP6800MP_A_LIB) : $(SWTP6800MP_A_SOURCE) + $! + $! Building The $(SWTP6800MP_A_LIB) Library. + $! + $ $(CC)$(SWTP6800MP_A_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(SWTP6800MP_A2_LIB) : $(SWTP6800MP_A2_SOURCE) + $! + $! Building The $(SWTP6800MP_A2_LIB) Library. + $! + $ $(CC)$(SWTP6800MP_A2_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The BESM6 Library. +# +.IFDEF ALPHA_OR_IA64 +$(BESM6_LIB) : $(BESM6_SOURCE) + $! + $! Building The $(BESM6_LIB) Library. + $! + $ $(CC)$(BESM6_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# We Are On VAX And Due To The Use of INT64 We Can't Build It. +# +$(BESM6_LIB) : + $! Due To The Use Of INT64 We Can't Build The + $! $(MMS$TARGET) Library On VAX. +.ENDIF + +# +# If Not On VAX, Build The Burroughs B5500 Library. +# +.IFDEF ALPHA_OR_IA64 +$(B5500_LIB) : $(B5500_SOURCE) + $! + $! Building The $(B5500_LIB) Library. + $! + $ $(CC)$(B5500_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# We Are On VAX And Due To The Use of INT64 We Can't Build It. +# +$(B5500_LIB) : + $! Due To The Use Of INT64 We Can't Build The + $! $(MMS$TARGET) Library On VAX. +.ENDIF + +$(VAX_LIB1) : $(VAX_SOURCE1) + $! + $! Building The $(VAX_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX_OPTIONS)/OBJ=$(VAX_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX_LIB2) : $(VAX_SOURCE2) + $! + $! Building The $(VAX_LIB2) Library. + $! + $ $(CC)$(VAX_OPTIONS)/OBJ=$(VAX_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX610_LIB1) : $(VAX610_SOURCE1) + $! + $! Building The $(VAX610_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX610_OPTIONS)/OBJ=$(VAX610_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX610_LIB2) : $(VAX610_SOURCE2) + $! + $! Building The $(VAX610_LIB2) Library. + $! + $ $(CC)$(VAX610_OPTIONS)/OBJ=$(VAX610_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX630_LIB1) : $(VAX630_SOURCE1) + $! + $! Building The $(VAX630_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX630_OPTIONS)/OBJ=$(VAX630_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX630_LIB2) : $(VAX630_SOURCE2) + $! + $! Building The $(VAX630_LIB2) Library. + $! + $ $(CC)$(VAX630_OPTIONS)/OBJ=$(VAX630_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX620_LIB1) : $(VAX620_SOURCE1) + $! + $! Building The $(VAX620_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX620_OPTIONS)/OBJ=$(VAX620_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX620_LIB2) : $(VAX620_SOURCE2) + $! + $! Building The $(VAX620_LIB2) Library. + $! + $ $(CC)$(VAX620_OPTIONS)/OBJ=$(VAX620_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX730_LIB1) : $(VAX730_SOURCE1) + $! + $! Building The $(VAX730_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX730_OPTIONS)/OBJ=$(VAX730_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX730_LIB2) : $(VAX730_SOURCE2) + $! + $! Building The $(VAX730_LIB2) Library. + $! + $ $(CC)$(VAX730_OPTIONS)/OBJ=$(VAX730_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX750_LIB1) : $(VAX750_SOURCE1) + $! + $! Building The $(VAX750_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX750_OPTIONS)/OBJ=$(VAX750_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX750_LIB2) : $(VAX750_SOURCE2) + $! + $! Building The $(VAX750_LIB2) Library. + $! + $ $(CC)$(VAX750_OPTIONS)/OBJ=$(VAX750_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX780_LIB1) : $(VAX780_SOURCE1) + $! + $! Building The $(VAX780_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX780_OPTIONS)/OBJ=$(VAX780_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX780_LIB2) : $(VAX780_SOURCE2) + $! + $! Building The $(VAX780_LIB2) Library. + $! + $ $(CC)$(VAX780_OPTIONS)/OBJ=$(VAX780_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX8600_LIB1) : $(VAX8600_SOURCE1) + $! + $! Building The $(VAX8600_LIB1) Library. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(VAX8600_OPTIONS)/OBJ=$(VAX8600_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(VAX8600_LIB2) : $(VAX8600_SOURCE2) + $! + $! Building The $(VAX8600_LIB2) Library. + $! + $ $(CC)$(VAX8600_OPTIONS)/OBJ=$(VAX8600_DIR) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +$(PCAP_LIB) : $(PCAP_SOURCE) + $! + $! Building The $(PCAP_LIB) Library. + $! + $ Saved_Default = F$Environment("DEFAULT") + $ SET DEFAULT $(PCAP_DIR) + $ @VMS_PCAP $(DEBUG) + $ SET DEFAULT 'Saved_Default + $ IF (F$SEARCH("$(PCAP_LIB)").NES."") THEN - + DELETE $(PCAP_LIB); + $ COPY $(PCAP_DIR)PCAP.OLB $(PCAP_LIB) + $ DELETE/NOLOG/NOCONFIRM $(PCAP_DIR)*.OBJ;*,$(PCAP_DIR)*.OLB;* + +# +# If Not On VAX, Build The IBM 7094 Library. +# +.IFDEF ALPHA_OR_IA64 +$(I7094_LIB) : $(I7094_SOURCE) + $! + $! Building The $(I7094_LIB) Library. + $! + $ $(CC)$(I7094_OPTIONS) - + /OBJ=$(BLD_DIR) $(MMS$CHANGED_LIST) + $ IF (F$SEARCH("$(MMS$TARGET)").EQS."") THEN - + LIBRARY/CREATE $(MMS$TARGET) + $ LIBRARY/REPLACE $(MMS$TARGET) $(BLD_DIR)*.OBJ + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# We Are On VAX And Due To The Use of INT64 We Can't Build It. +# +$(I7094_LIB) : + $! Due To The Use Of INT64 We Can't Build The + $! $(MMS$TARGET) Library On VAX. +.ENDIF + +# +# Individual Simulator Builds. +# +ALTAIR : $(BIN_DIR)ALTAIR-$(ARCH).EXE + $! ALTAIR done + +$(BIN_DIR)ALTAIR-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(ALTAIR_LIB) + $! + $! Building The $(BIN_DIR)ALTAIR-$(ARCH).EXE Simulator. + $! + $ $(CC)$(ALTAIR_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)ALTAIR-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(ALTAIR_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +ALTAIRZ80 : $(BIN_DIR)ALTAIRZ80-$(ARCH).EXE + $! ALTAIRZ80 done + +$(BIN_DIR)ALTAIRZ80-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(ALTAIRZ80_LIB1) $(ALTAIRZ80_LIB2) + $! + $! Building The $(BIN_DIR)ALTAIRZ80-$(ARCH).EXE Simulator. + $! + $ $(CC)$(ALTAIRZ80_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)ALTAIRZ80-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(ALTAIRZ80_LIB1)/LIBRARY, - + $(ALTAIRZ80_LIB2)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +# +# If Not On VAX, Build The Eclipse Simulator. +# +.IFDEF ALPHA_OR_IA64 +ECLIPSE : $(BIN_DIR)ECLIPSE-$(ARCH).EXE + $! ECLIPSE done +.ELSE +# +# Else We Are On VAX And Tell The User We Can't Build On VAX +# Due To The Use Of INT64. +# +ECLIPSE : + $! Sorry, Can't Build $(BIN_DIR)ECLIPSE-$(ARCH).EXE Simulator + $! Because It Requires The Use Of INT64. +.ENDIF + +$(BIN_DIR)ECLIPSE-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(ECLIPSE_LIB) + $! + $! Building The $(BIN_DIR)ECLIPSE-$(ARCH).EXE Simulator. + $! + $ $(CC)$(ECLIPSE_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)ECLIPSE-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(ECLIPSE_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +GRI : $(BIN_DIR)GRI-$(ARCH).EXE + $! GRI done + +$(BIN_DIR)GRI-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(GRI_LIB) + $! + $! Building The $(BIN_DIR)GRI-$(ARCH).EXE Simulator. + $! + $ $(CC)$(GRI_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)GRI-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(GRI_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +LGP : $(BIN_DIR)LGP-$(ARCH).EXE + $! LGP done + +$(BIN_DIR)LGP-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(LGP_LIB) + $! + $! Building The $(BIN_DIR)LGP-$(ARCH).EXE Simulator. + $! + $ $(CC)$(LGP_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)LGP-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(LGP_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +H316 : $(BIN_DIR)H316-$(ARCH).EXE + $! H316 done + +$(BIN_DIR)H316-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(H316_LIB) + $! + $! Building The $(BIN_DIR)H316-$(ARCH).EXE Simulator. + $! + $ $(CC)$(H316_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)H316-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(H316_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +HP2100 : $(BIN_DIR)HP2100-$(ARCH).EXE + $! HP2100 done + +$(BIN_DIR)HP2100-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(HP2100_LIB1) $(HP2100_LIB2) + $! + $! Building The $(BIN_DIR)HP2100-$(ARCH).EXE Simulator. + $! + $ $(CC)$(HP2100_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)HP2100-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(HP2100_LIB1)/LIBRARY, - + $(HP2100_LIB2)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +HP3000 : $(BIN_DIR)HP3000-$(ARCH).EXE + $! HP3000 done + +$(BIN_DIR)HP3000-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(HP3000_LIB1) $(HP3000_LIB2) + $! + $! Building The $(BIN_DIR)HP3000-$(ARCH).EXE Simulator. + $! + $ $(CC)$(HP3000_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)HP3000-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(HP3000_LIB1)/LIBRARY, - + $(HP3000_LIB2)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +I1401 : $(BIN_DIR)I1401-$(ARCH).EXE + $! I1401 done + +$(BIN_DIR)I1401-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(I1401_LIB) + $! + $! Building The $(BIN_DIR)I1401-$(ARCH).EXE Simulator. + $! + $ $(CC)$(I1401_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)I1401-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(I1401_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +I1620 : $(BIN_DIR)I1620-$(ARCH).EXE + $! I1620 done + +$(BIN_DIR)I1620-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(I1620_LIB) + $! + $! Building The $(BIN_DIR)I1620-$(ARCH).EXE Simulator. + $! + $ $(CC)$(I1620_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)I1620-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(I1620_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +IBM1130 : $(BIN_DIR)IBM1130-$(ARCH).EXE + $! IBM1130 done + +$(BIN_DIR)IBM1130-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(IBM1130_LIB) + $! + $! Building The $(BIN_DIR)IBM1130-$(ARCH).EXE Simulator. + $! + $ $(CC)$(IBM1130_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)IBM1130-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(IBM1130_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +ID16 : $(BIN_DIR)ID16-$(ARCH).EXE + $! ID16 done + +$(BIN_DIR)ID16-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(ID16_LIB) + $! + $! Building The $(BIN_DIR)ID16-$(ARCH).EXE Simulator. + $! + $ $(CC)$(ID16_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)ID16-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(ID16_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +ID32 : $(BIN_DIR)ID32-$(ARCH).EXE + $! ID32 done + +$(BIN_DIR)ID32-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(ID32_LIB) + $! + $! Building The $(BIN_DIR)ID32-$(ARCH).EXE Simulator. + $! + $ $(CC)$(ID32_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)ID32-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(ID32_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +NOVA : $(BIN_DIR)NOVA-$(ARCH).EXE + $! NOVA done + +$(BIN_DIR)NOVA-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(NOVA_LIB) + $! + $! Building The $(BIN_DIR)NOVA-$(ARCH).EXE Simulator. + $! + $ $(CC)$(NOVA_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)NOVA-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(NOVA_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP1 : $(BIN_DIR)PDP1-$(ARCH).EXE + $! PDP1 done + +$(BIN_DIR)PDP1-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP1_LIB) + $! + $! Building The $(BIN_DIR)PDP1-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP1_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP1-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP1_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP4 : $(BIN_DIR)PDP4-$(ARCH).EXE + $! PDP4 done + +$(BIN_DIR)PDP4-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP4_LIB) + $! + $! Building The $(BIN_DIR)PDP4-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP4_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP4-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP4_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP7 : $(BIN_DIR)PDP7-$(ARCH).EXE + $! PDP7 done + +$(BIN_DIR)PDP7-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP7_LIB) + $! + $! Building The $(BIN_DIR)PDP7-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP7_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP7-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP7_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP8 : $(BIN_DIR)PDP8-$(ARCH).EXE + $! PDP8 done + +$(BIN_DIR)PDP8-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP8_LIB) + $! + $! Building The $(BIN_DIR)PDP8-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP8_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP8-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP8_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP9 : $(BIN_DIR)PDP9-$(ARCH).EXE + $! PDP9 done + +$(BIN_DIR)PDP9-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP9_LIB) + $! + $! Building The $(BIN_DIR)PDP9-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP9_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP9-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP9_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The PDP-10 Simulator. +# +.IFDEF ALPHA_OR_IA64 +PDP10 : $(BIN_DIR)PDP10-$(ARCH).EXE + $! PDP10 done + +$(BIN_DIR)PDP10-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PCAP_LIBD) $(PDP10_LIB) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)PDP10-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP10_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP10-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP10_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# Else We Are On VAX And Tell The User We Can't Build On VAX +# Due To The Use Of INT64. +# +PDP10 : + $! Sorry, Can't Build $(BIN_DIR)PDP10-$(ARCH).EXE Simulator + $! Because It Requires The Use Of INT64. +.ENDIF + +PDP11 : $(BIN_DIR)PDP11-$(ARCH).EXE + $! PDP11 done + +$(BIN_DIR)PDP11-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_LIB) $(PCAP_LIBD) $(PDP11_LIB1) $(PDP11_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)PDP11-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP11_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP11-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP11_LIB1)/LIBRARY,$(PDP11_LIB2)/LIBRARY,$(SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +PDP15 : $(BIN_DIR)PDP15-$(ARCH).EXE + $! PDP15 done + +$(BIN_DIR)PDP15-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(PDP15_LIB) + $! + $! Building The $(BIN_DIR)PDP15-$(ARCH).EXE Simulator. + $! + $ $(CC)$(PDP15_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)PDP15-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(PDP15_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +S3 : $(BIN_DIR)S3-$(ARCH).EXE + $! S3 done + +$(BIN_DIR)S3-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(S3_LIB) + $! + $! Building The $(BIN_DIR)S3-$(ARCH).EXE Simulator. + $! + $ $(CC)$(S3_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)S3-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(S3_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +SDS : $(BIN_DIR)SDS-$(ARCH).EXE + $! SDS done + +$(BIN_DIR)SDS-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(SDS_LIB) + $! + $! Building The $(BIN_DIR)SDS-$(ARCH).EXE Simulator. + $! + $ $(CC)$(SDS_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)SDS-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(SDS_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +SSEM : $(BIN_DIR)SSEM-$(ARCH).EXE + $! SSEM done + +$(BIN_DIR)SSEM-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(SSEM_LIB) + $! + $! Building The $(BIN_DIR)SSEM-$(ARCH).EXE Simulator. + $! + $ $(CC)$(SSEM_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)SSEM-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(SDS_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +SWTP6800MP-A : $(BIN_DIR)SWTP6800MP-A-$(ARCH).EXE + $! SWTP6800MP-A done + +$(BIN_DIR)SWTP6800MP-A-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(SWTP6800MP_A_LIB) + $! + $! Building The $(BIN_DIR)SWTP6800MP-A-$(ARCH).EXE Simulator. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(SWTP6800MP_A_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)SWTP6800MP-A-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(SWTP6800MP_A_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +SWTP6800MP-A2 : $(BIN_DIR)SWTP6800MP-A2-$(ARCH).EXE + $! SWTP6800MP-A2 done + +$(BIN_DIR)SWTP6800MP-A2-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(SWTP6800MP_A2_LIB) + $! + $! Building The $(BIN_DIR)SWTP6800MP-A2-$(ARCH).EXE Simulator. + $! + $ RUN/NODEBUG $(BIN_DIR)BuildROMs-$(ARCH).EXE + $ $(CC)$(SWTP6800MP_A2_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)SWTP6800MP-A2-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(SWTP6800MP_A2_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The BESM6 Simulator. +# +.IFDEF ALPHA_OR_IA64 +BESM6 : $(BIN_DIR)BESM6-$(ARCH).EXE + $! BESM6 done + +$(BIN_DIR)BESM6-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(BESM6_LIB) + $! + $! Building The $(BIN_DIR)BESM6-$(ARCH).EXE Simulator. + $! + $ $(CC)$(BESM6_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)BESM6-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(BESM6_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# Else We Are On VAX And Tell The User We Can't Build On VAX +# Due To The Use Of INT64. +# +BESM6 : + $! Sorry, Can't Build $(BIN_DIR)BESM6-$(ARCH).EXE Simulator + $! Because It Requires The Use Of INT64. +.ENDIF + + +# +# If Not On VAX, Build The Burroughs B5500 Simulator. +# +.IFDEF ALPHA_OR_IA64 +B5500 : $(BIN_DIR)B5500-$(ARCH).EXE + $! B5500 done + +$(BIN_DIR)B5500-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(B5500_LIB) + $! + $! Building The $(BIN_DIR)B5500-$(ARCH).EXE Simulator. + $! + $ $(CC)$(B5500_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)B5500-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(B5500_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# Else We Are On VAX And Tell The User We Can't Build On VAX +# Due To The Use Of INT64. +# +B5500 : + $! Sorry, Can't Build $(BIN_DIR)B5500-$(ARCH).EXE Simulator + $! Because It Requires The Use Of INT64. +.ENDIF + + +VAX : MICROVAX3900 + $! MICROVAX3900 aka VAX done + +MICROVAX3900 : $(BIN_DIR)MICROVAX3900-$(ARCH).EXE + $! MICROVAX3900 done + +$(BIN_DIR)MICROVAX3900-$(ARCH).EXE : $(SIMH_MAIN) $(VAX_SIMH_LIB) $(PCAP_LIBD) $(VAX_LIB1) $(VAX_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)MICROVAX3900-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(VAX_LIB1)/LIBRARY,$(VAX_LIB2)/LIBRARY,- + $(VAX_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + $ COPY $(BIN_DIR)MICROVAX3900-$(ARCH).EXE $(BIN_DIR)VAX-$(ARCH).EXE + +MICROVAX1 : $(BIN_DIR)MICROVAX1-$(ARCH).EXE + $! MICROVAX1 done + +$(BIN_DIR)MICROVAX1-$(ARCH).EXE : $(SIMH_MAIN) $(VAX610_SIMH_LIB) $(PCAP_LIBD) $(VAX610_LIB1) $(VAX610_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX610-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX610_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)MICROVAX1-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX610_LIB1)/LIBRARY,$(VAX610_LIB2)/LIBRARY,- + $(VAX610_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +MICROVAX2 : $(BIN_DIR)MICROVAX2-$(ARCH).EXE + $! MICROVAX2 done + +$(BIN_DIR)MICROVAX2-$(ARCH).EXE : $(SIMH_MAIN) $(VAX630_SIMH_LIB) $(PCAP_LIBD) $(VAX630_LIB1) $(VAX630_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX630-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX630_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)MICROVAX2-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX630_LIB1)/LIBRARY,$(VAX630_LIB2)/LIBRARY,- + $(VAX630_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +RTVAX1000 : $(BIN_DIR)RTVAX1000-$(ARCH).EXE + $! RTVAX1000 done + +$(BIN_DIR)RTVAX1000-$(ARCH).EXE : $(SIMH_MAIN) $(VAX620_SIMH_LIB) $(PCAP_LIBD) $(VAX620_LIB1) $(VAX620_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX620-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX620_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)RTVAX1000-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX620_LIB1)/LIBRARY,$(VAX620_LIB2)/LIBRARY,- + $(VAX620_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +VAX730 : $(BIN_DIR)VAX730-$(ARCH).EXE + $! VAX730 done + +$(BIN_DIR)VAX730-$(ARCH).EXE : $(SIMH_MAIN) $(VAX730_SIMH_LIB) $(PCAP_LIBD) $(VAX730_LIB1) $(VAX730_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX730-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX730_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)VAX730-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX730_LIB1)/LIBRARY,$(VAX730_LIB2)/LIBRARY,- + $(VAX730_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +VAX750 : $(BIN_DIR)VAX750-$(ARCH).EXE + $! VAX750 done + +$(BIN_DIR)VAX750-$(ARCH).EXE : $(SIMH_MAIN) $(VAX750_SIMH_LIB) $(PCAP_LIBD) $(VAX750_LIB1) $(VAX750_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX750-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX750_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)VAX750-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX750_LIB1)/LIBRARY,$(VAX750_LIB2)/LIBRARY,- + $(VAX750_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +VAX780 : $(BIN_DIR)VAX780-$(ARCH).EXE + $! VAX780 done + +$(BIN_DIR)VAX780-$(ARCH).EXE : $(SIMH_MAIN) $(VAX780_SIMH_LIB) $(PCAP_LIBD) $(VAX780_LIB1) $(VAX780_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX780-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX780_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)VAX780-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX780_LIB1)/LIBRARY,$(VAX780_LIB2)/LIBRARY,- + $(VAX780_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +VAX8600 : $(BIN_DIR)VAX8600-$(ARCH).EXE + $! VAX8600 done + +$(BIN_DIR)VAX8600-$(ARCH).EXE : $(SIMH_MAIN) $(VAX8600_SIMH_LIB) $(PCAP_LIBD) $(VAX8600_LIB1) $(VAX8600_LIB2) $(PCAP_EXECLET) + $! + $! Building The $(BIN_DIR)VAX8600-$(ARCH).EXE Simulator. + $! + $ $(CC)$(VAX8600_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)$(LINK_SECTION_BINDING)- + /EXE=$(BIN_DIR)VAX8600-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,- + $(VAX8600_LIB1)/LIBRARY,$(VAX8600_LIB2)/LIBRARY,- + $(VAX8600_SIMH_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* + +# +# If Not On VAX, Build The IBM 7094 Simulator. +# +.IFDEF ALPHA_OR_IA64 +I7094 : $(BIN_DIR)I7094-$(ARCH).EXE + $! I7094 done + +$(BIN_DIR)I7094-$(ARCH).EXE : $(SIMH_MAIN) $(SIMH_NONET_LIB) $(I7094_LIB) + $! + $! Building The $(BIN_DIR)I7094-$(ARCH).EXE Simulator. + $! + $ $(CC)$(I7094_OPTIONS)/OBJ=$(BLD_DIR) SCP.C + $ LINK $(LINK_DEBUG)/EXE=$(BIN_DIR)I7094-$(ARCH).EXE - + $(BLD_DIR)SCP.OBJ,$(I7094_LIB)/LIBRARY,$(SIMH_NONET_LIB)/LIBRARY$(PCAP_LIBR) + $ DELETE/NOLOG/NOCONFIRM $(BLD_DIR)*.OBJ;* +.ELSE +# +# Else We Are On VAX And Tell The User We Can't Build On VAX +# Due To The Use Of INT64. +# +I7094 : + $! Sorry, Can't Build $(BIN_DIR)I7094-$(ARCH).EXE Simulator + $! Because It Requires The Use Of INT64. +.ENDIF + +# +# PCAP VCI Components +# +$(PCAP_VCI) : $(PCAP_VCMDIR)PCAPVCM.EXE + $! + $! Installing the PCAP VCI Execlet in SYS$LOADABLE_IMAGES + $! + $ COPY $(PCAP_VCMDIR)PCAPVCM.EXE SYS$COMMON:[SYS$LDR]PCAPVCM.EXE + +$(PCAP_VCMDIR)PCAPVCM.EXE : $(PCAP_VCM_SOURCES) + $! + $! Building The PCAP VCI Execlet + $! + $ @SYS$DISK:[-.PCAP-VMS.PCAPVCM]BUILD_PCAPVCM + $ DELETE/NOLOG/NOCONFIRM $(PCAP_VCMDIR)*.OBJ;*,$(PCAP_VCMDIR)*.MAP;* diff --git a/makefile b/makefile new file mode 100644 index 0000000..8a9edf5 --- /dev/null +++ b/makefile @@ -0,0 +1,1927 @@ +# +# This GNU make makefile has been tested on: +# Linux (x86 & Sparc & PPC) +# OS X +# Solaris (x86 & Sparc) (gcc and Sun C) +# OpenBSD +# NetBSD +# FreeBSD +# HP-UX +# AIX +# Windows (MinGW & cygwin) +# Linux x86 targeting Android (using agcc script) +# Haiku x86 (with gcc4) +# +# Android targeted builds should invoke GNU make with GCC=agcc on +# the command line. +# +# In general, the logic below will detect and build with the available +# features which the host build environment provides. +# +# Dynamic loading of libpcap is the preferred default behavior if pcap.h +# is available at build time. Support to statically linking against libpcap +# is deprecated and may be removed in the future. Static linking against +# libpcap can be enabled if GNU make is invoked with USE_NETWORK=1 on the +# command line. +# +# Some platforms may not have vendor supplied libpcap available. HP-UX is +# one such example. The packages which are available for this platform +# install include files and libraries in user specified directories. In +# order for this makefile to locate where these components may have been +# installed, gmake should be invoked with LPATH=/usr/lib:/usr/local/lib +# defined (adjusted as needed depending on where they may be installed). +# +# The default build will build compiler optimized binaries. +# If debugging is desired, then GNU make can be invoked with +# DEBUG=1 on the command line. +# +# simh project support is provided for simulators that are built with +# dependent packages provided with the or by the operating system +# distribution OR for platforms where that isn't directly available (OS X) +# by packages from specific package management systems (MacPorts). Users +# wanting to build simulators with locally build dependent packages or +# packages provided by an unsupported package management system can +# override where this procedure looks for include files and/or libraries. +# Overrides can be specified by define exported environment variables or +# GNU make command line arguments which specify INCLUDES and/or LIBRARIES. +# Each of these, if specified, must be the complete list include directories +# or library directories that should be used with each element separated by +# colons. (i.e. INCLUDES=/usr/include/:/usr/local/include/:...) +# +# Some environments may have the LLVM (clang) compiler installed as +# an alternate to gcc. If you want to build with the clang compiler, +# invoke make with GCC=clang. +# +# Internal ROM support can be disabled if GNU make is invoked with +# DONT_USE_ROMS=1 on the command line. +# +# Asynchronous I/O support can be disabled if GNU make is invoked with +# NOASYNCH=1 on the command line. +# +# For linting (or other code analyzers) make may be invoked similar to: +# +# make GCC=cppcheck CC_OUTSPEC= LDFLAGS= CFLAGS_G="--enable=all --template=gcc" CC_STD=--std=c99 +# +# CC Command (and platform available options). (Poor man's autoconf) +# +ifeq (old,$(shell gmake --version /dev/null 2>&1 | grep 'GNU Make' | awk '{ if ($$3 < "3.81") {print "old"} }')) + GMAKE_VERSION = $(shell gmake --version /dev/null 2>&1 | grep 'GNU Make' | awk '{ print $$3 }') + $(warning *** Warning *** GNU Make Version $(GMAKE_VERSION) is too old to) + $(warning *** Warning *** fully process this makefile) +endif +BUILD_SINGLE := $(MAKECMDGOALS) $(BLANK_SUFFIX) +# building the pdp1, pdp11, tx-0, or any microvax simulator could use video support +ifneq (,$(or $(findstring XXpdp1XX,$(addsuffix XX,$(addprefix XX,$(MAKECMDGOALS)))),$(findstring pdp11,$(MAKECMDGOALS)),$(findstring tx-0,$(MAKECMDGOALS)),$(findstring microvax1,$(MAKECMDGOALS)),$(findstring microvax2,$(MAKECMDGOALS)),$(findstring microvax3900,$(MAKECMDGOALS)),$(findstring XXvaxXX,$(addsuffix XX,$(addprefix XX,$(MAKECMDGOALS)))))) + VIDEO_USEFUL = true +endif +# building the besm6 needs both video support and fontfile support +ifneq (,$(findstring besm6,$(MAKECMDGOALS))) + VIDEO_USEFUL = true + BESM6_BUILD = true +endif +# building the pdp11, pdp10, or any vax simulator could use networking support +ifneq (,$(or $(findstring pdp11,$(MAKECMDGOALS)),$(findstring pdp10,$(MAKECMDGOALS)),$(findstring vax,$(MAKECMDGOALS)),$(findstring all,$(MAKECMDGOALS)))) + NETWORK_USEFUL = true + ifneq (,$(findstring all,$(MAKECMDGOALS))$(word 2,$(MAKECMDGOALS))) + BUILD_MULTIPLE = s + VIDEO_USEFUL = true + BESM6_BUILD = true + endif +else + ifeq ($(MAKECMDGOALS),) + # default target is all + NETWORK_USEFUL = true + VIDEO_USEFUL = true + BUILD_MULTIPLE = s + BUILD_SINGLE := all $(BUILD_SINGLE) + BESM6_BUILD = true + endif +endif +find_exe = $(abspath $(strip $(firstword $(foreach dir,$(strip $(subst :, ,$(PATH))),$(wildcard $(dir)/$(1)))))) +find_lib = $(abspath $(strip $(firstword $(foreach dir,$(strip $(LIBPATH)),$(wildcard $(dir)/lib$(1).$(LIBEXT)))))) +find_include = $(abspath $(strip $(firstword $(foreach dir,$(strip $(INCPATH)),$(wildcard $(dir)/$(1).h))))) +ifneq ($(findstring Windows,$(OS)),) + ifeq ($(findstring .exe,$(SHELL)),.exe) + # MinGW + WIN32 := 1 + else # Msys or cygwin + ifeq (MINGW,$(findstring MINGW,$(shell uname))) + $(info *** This makefile can not be used with the Msys bash shell) + $(error *** Use build_mingw.bat $(MAKECMDGOALS) from a Windows command prompt) + endif + endif +endif +ifeq ($(WIN32),) #*nix Environments (&& cygwin) + ifeq ($(GCC),) + ifeq (,$(shell which gcc 2>/dev/null)) + $(info *** Warning *** Using local cc since gcc isn't available locally.) + $(info *** Warning *** You may need to install gcc to build working simulators.) + GCC = cc + else + GCC = gcc + endif + endif + OSTYPE = $(shell uname) + # OSNAME is used in messages to indicate the source of libpcap components + OSNAME = $(OSTYPE) + ifeq (SunOS,$(OSTYPE)) + TEST = /bin/test + else + TEST = test + endif + ifeq (CYGWIN,$(findstring CYGWIN,$(OSTYPE))) # uname returns CYGWIN_NT-n.n-ver + OSTYPE = cygwin + OSNAME = windows-build + endif + ifeq (,$(shell $(GCC) -v /dev/null 2>&1 | grep 'clang')) + GCC_VERSION = $(shell $(GCC) -v /dev/null 2>&1 | grep 'gcc version' | awk '{ print $$3 }') + COMPILER_NAME = GCC Version: $(GCC_VERSION) + ifeq (,$(GCC_VERSION)) + ifeq (SunOS,$(OSTYPE)) + ifneq (,$(shell $(GCC) -V 2>&1 | grep 'Sun C')) + SUNC_VERSION = $(shell $(GCC) -V 2>&1 | grep 'Sun C') + COMPILER_NAME = $(wordlist 2,10,$(SUNC_VERSION)) + CC_STD = -std=c99 + endif + endif + ifeq (HP-UX,$(OSTYPE)) + ifneq (,$(shell what `which $(firstword $(GCC)) 2>&1`| grep -i compiler)) + COMPILER_NAME = $(strip $(shell what `which $(firstword $(GCC)) 2>&1` | grep -i compiler)) + CC_STD = -std=gnu99 + endif + endif + else + ifeq (,$(findstring ++,$(GCC))) + CC_STD = -std=gnu99 + else + CPP_BUILD = 1 + endif + endif + else + ifeq (Apple,$(shell $(GCC) -v /dev/null 2>&1 | grep 'Apple' | awk '{ print $$1 }')) + COMPILER_NAME = $(shell $(GCC) -v /dev/null 2>&1 | grep 'Apple' | awk '{ print $$1 " " $$2 " " $$3 " " $$4 }') + CLANG_VERSION = $(word 4,$(COMPILER_NAME)) + else + COMPILER_NAME = $(shell $(GCC) -v /dev/null 2>&1 | grep 'clang version' | awk '{ print $$1 " " $$2 " " $$3 }') + CLANG_VERSION = $(word 3,$(COMPILER_NAME)) + ifeq (,$(findstring .,$(CLANG_VERSION))) + COMPILER_NAME = $(shell $(GCC) -v /dev/null 2>&1 | grep 'clang version' | awk '{ print $$1 " " $$2 " " $$3 " " $$4 }') + CLANG_VERSION = $(word 4,$(COMPILER_NAME)) + endif + endif + ifeq (,$(findstring ++,$(GCC))) + CC_STD = -std=c99 + else + CPP_BUILD = 1 + endif + endif + ifeq (git-repo,$(shell if $(TEST) -d ./.git; then echo git-repo; fi)) + ifeq (need-hooks,$(shell if $(TEST) ! -e ./.git/hooks/post-checkout; then echo need-hooks; fi)) + $(info *** Installing git hooks in local repository ***) + GIT_HOOKS += $(shell /bin/cp './Visual Studio Projects/git-hooks/post-commit' ./.git/hooks/) + GIT_HOOKS += $(shell /bin/cp './Visual Studio Projects/git-hooks/post-checkout' ./.git/hooks/) + GIT_HOOKS += $(shell /bin/cp './Visual Studio Projects/git-hooks/post-merge' ./.git/hooks/) + GIT_HOOKS += $(shell ./.git/hooks/post-checkout) + ifneq (,$(strip $(GIT_HOOKS))) + $(info *** Warning - Error installing git hooks *** $(GIT_HOOKS)) + endif + endif + endif + LTO_EXCLUDE_VERSIONS = + PCAPLIB = pcap + ifeq (agcc,$(findstring agcc,$(GCC))) # Android target build? + OS_CCDEFS = -D_GNU_SOURCE + ifeq (,$(NOASYNCH)) + OS_CCDEFS += -DSIM_ASYNCH_IO + endif + OS_LDFLAGS = -lm + else # Non-Android Builds + ifeq (,$(INCLUDES)$(LIBRARIES)) + INCPATH:=/usr/include + LIBPATH:=/usr/lib + else + $(info *** Warning ***) + ifeq (,$(INCLUDES)) + INCPATH:=$(shell LANG=C; $(GCC) -x c -v -E /dev/null 2>&1 | grep -A 10 '> search starts here' | grep '^ ' | tr -d '\n') + else + $(info *** Warning *** Unsupported build with INCLUDES defined as: $(INCLUDES)) + INCPATH:=$(strip $(subst :, ,$(INCLUDES))) + UNSUPPORTED_BUILD := include + endif + ifeq (,$(LIBRARIES)) + LIBPATH:=/usr/lib + else + $(info *** Warning *** Unsupported build with LIBRARIES defined as: $(LIBRARIES)) + LIBPATH:=$(strip $(subst :, ,$(LIBRARIES))) + ifeq (include,$(UNSUPPORTED_BUILD)) + UNSUPPORTED_BUILD := include+lib + else + UNSUPPORTED_BUILD := lib + endif + endif + $(info *** Warning ***) + endif + OS_CCDEFS = -D_GNU_SOURCE + GCC_OPTIMIZERS_CMD = $(GCC) -v --help 2>&1 + GCC_WARNINGS_CMD = $(GCC) -v --help 2>&1 + LD_ELF = $(shell echo | $(GCC) -E -dM - | grep __ELF__) + ifeq (Darwin,$(OSTYPE)) + OSNAME = OSX + LIBEXT = dylib + ifneq (include,$(findstring include,$(UNSUPPORTED_BUILD))) + INCPATH:=$(shell LANG=C; $(GCC) -x c -v -E /dev/null 2>&1 | grep -A 10 '> search starts here' | grep '^ ' | grep -v 'framework directory' | tr -d '\n') + endif + ifeq (incopt,$(shell if $(TEST) -d /opt/local/include; then echo incopt; fi)) + INCPATH += /opt/local/include + OS_CCDEFS += -I/opt/local/include + endif + ifeq (libopt,$(shell if $(TEST) -d /opt/local/lib; then echo libopt; fi)) + LIBPATH += /opt/local/lib + OS_LDFLAGS += -L/opt/local/lib + endif + ifeq (libXt,$(shell if $(TEST) -d /usr/X11/lib; then echo libXt; fi)) + LIBPATH += /usr/X11/lib + OS_LDFLAGS += -L/usr/X11/lib + endif + else + ifeq (Linux,$(OSTYPE)) + ifneq (lib,$(findstring lib,$(UNSUPPORTED_BUILD))) + LIBPATH := $(sort $(foreach lib,$(shell /sbin/ldconfig -p | grep ' => /' | sed 's/^.* => //'),$(dir $(lib)))) + endif + LIBEXT = so + else + ifeq (SunOS,$(OSTYPE)) + OSNAME = Solaris + ifneq (lib,$(findstring lib,$(UNSUPPORTED_BUILD))) + LIBPATH := $(shell LANG=C; crle | grep 'Default Library Path' | awk '{ print $$5 }' | sed 's/:/ /g') + endif + LIBEXT = so + OS_LDFLAGS += -lsocket -lnsl + ifeq (incsfw,$(shell if $(TEST) -d /opt/sfw/include; then echo incsfw; fi)) + INCPATH += /opt/sfw/include + OS_CCDEFS += -I/opt/sfw/include + endif + ifeq (libsfw,$(shell if $(TEST) -d /opt/sfw/lib; then echo libsfw; fi)) + LIBPATH += /opt/sfw/lib + OS_LDFLAGS += -L/opt/sfw/lib -R/opt/sfw/lib + endif + OS_CCDEFS += -D_LARGEFILE_SOURCE + else + ifeq (cygwin,$(OSTYPE)) + # use 0readme_ethernet.txt documented Windows pcap build components + INCPATH += ../windows-build/winpcap/WpdPack/include + LIBPATH += ../windows-build/winpcap/WpdPack/lib + PCAPLIB = wpcap + LIBEXT = a + else + ifneq (,$(findstring AIX,$(OSTYPE))) + OS_LDFLAGS += -lm -lrt + ifeq (incopt,$(shell if $(TEST) -d /opt/freeware/include; then echo incopt; fi)) + INCPATH += /opt/freeware/include + OS_CCDEFS += -I/opt/freeware/include + endif + ifeq (libopt,$(shell if $(TEST) -d /opt/freeware/lib; then echo libopt; fi)) + LIBPATH += /opt/freeware/lib + OS_LDFLAGS += -L/opt/freeware/lib + endif + else + ifneq (,$(findstring Haiku,$(OSTYPE))) + HAIKU_ARCH=$(shell getarch) + ifeq ($(HAIKU_ARCH),) + $(error Missing getarch command, your Haiku release is probably too old) + endif + ifeq ($(HAIKU_ARCH),x86_gcc2) + $(error Unsupported arch x86_gcc2. Run setarch x86 and retry) + endif + INCPATH := $(shell findpaths -e -a $(HAIKU_ARCH) B_FIND_PATH_HEADERS_DIRECTORY) + INCPATH += $(shell findpaths -e B_FIND_PATH_HEADERS_DIRECTORY posix) + LIBPATH := $(shell findpaths -e -a $(HAIKU_ARCH) B_FIND_PATH_DEVELOP_LIB_DIRECTORY) + OS_LDFLAGS += -lnetwork + else + ifeq (,$(findstring NetBSD,$(OSTYPE))) + ifneq (no ldconfig,$(findstring no ldconfig,$(shell which ldconfig 2>&1))) + LDSEARCH :=$(shell LANG=C; ldconfig -r | grep 'search directories' | awk '{print $$3}' | sed 's/:/ /g') + endif + ifneq (,$(LDSEARCH)) + LIBPATH := $(LDSEARCH) + else + ifeq (,$(strip $(LPATH))) + $(info *** Warning ***) + $(info *** Warning *** The library search path on your $(OSTYPE) platform can't be) + $(info *** Warning *** determined. This should be resolved before you can expect) + $(info *** Warning *** to have fully working simulators.) + $(info *** Warning ***) + $(info *** Warning *** You can specify your library paths via the LPATH environment) + $(info *** Warning *** variable.) + $(info *** Warning ***) + else + LIBPATH = $(subst :, ,$(LPATH)) + endif + endif + OS_LDFLAGS += $(patsubst %,-L%,$(LIBPATH)) + endif + endif + endif + ifeq (usrpkglib,$(shell if $(TEST) -d /usr/pkg/lib; then echo usrpkglib; fi)) + LIBPATH += /usr/pkg/lib + INCPATH += /usr/pkg/include + OS_LDFLAGS += -L/usr/pkg/lib -R/usr/pkg/lib + OS_CCDEFS += -I/usr/pkg/include + endif + ifeq (X11R7,$(shell if $(TEST) -d /usr/X11R7/lib; then echo X11R7; fi)) + LIBPATH += /usr/X11R7/lib + INCPATH += /usr/X11R7/include + OS_LDFLAGS += -L/usr/X11R7/lib -R/usr/X11R7/lib + OS_CCDEFS += -I/usr/X11R7/include + endif + ifeq (/usr/local/lib,$(findstring /usr/local/lib,$(LIBPATH))) + INCPATH += /usr/local/include + OS_CCDEFS += -I/usr/local/include + endif + ifneq (,$(findstring NetBSD,$(OSTYPE))$(findstring FreeBSD,$(OSTYPE))$(findstring AIX,$(OSTYPE))) + LIBEXT = so + else + ifeq (HP-UX,$(OSTYPE)) + ifeq (ia64,$(shell uname -m)) + LIBEXT = so + else + LIBEXT = sl + endif + OS_CCDEFS += -D_HPUX_SOURCE -D_LARGEFILE64_SOURCE + OS_LDFLAGS += -Wl,+b: + NO_LTO = 1 + else + LIBEXT = a + endif + endif + endif + endif + endif + endif + # Some gcc versions don't support LTO, so only use LTO when the compiler is known to support it + ifeq (,$(NO_LTO)) + ifneq (,$(GCC_VERSION)) + ifeq (,$(shell $(GCC) -v /dev/null 2>&1 | grep '\-\-enable-lto')) + LTO_EXCLUDE_VERSIONS += $(GCC_VERSION) + endif + endif + endif + endif + $(info lib paths are: $(LIBPATH)) + $(info include paths are: $(INCPATH)) + need_search = $(strip $(shell ld -l$(1) /dev/null 2>&1 | grep $(1) | sed s/$(1)//)) + LD_SEARCH_NEEDED := $(call need_search,ZzzzzzzZ) + ifneq (,$(call find_lib,m)) + OS_LDFLAGS += -lm + $(info using libm: $(call find_lib,m)) + endif + ifneq (,$(call find_lib,rt)) + OS_LDFLAGS += -lrt + $(info using librt: $(call find_lib,rt)) + endif + ifneq (,$(call find_include,pthread)) + ifneq (,$(call find_lib,pthread)) + OS_CCDEFS += -DUSE_READER_THREAD + ifeq (,$(NOASYNCH)) + OS_CCDEFS += -DSIM_ASYNCH_IO + endif + OS_LDFLAGS += -lpthread + $(info using libpthread: $(call find_lib,pthread) $(call find_include,pthread)) + else + LIBEXTSAVE := $(LIBEXT) + LIBEXT = a + ifneq (,$(call find_lib,pthread)) + OS_CCDEFS += -DUSE_READER_THREAD + ifeq (,$(NOASYNCH)) + OS_CCDEFS += -DSIM_ASYNCH_IO + endif + OS_LDFLAGS += -lpthread + $(info using libpthread: $(call find_lib,pthread) $(call find_include,pthread)) + else + ifneq (,$(findstring Haiku,$(OSTYPE))) + OS_CCDEFS += -DUSE_READER_THREAD + ifeq (,$(NOASYNCH)) + OS_CCDEFS += -DSIM_ASYNCH_IO + endif + $(info using libpthread: $(call find_include,pthread)) + endif + endif + LIBEXT = $(LIBEXTSAVE) + endif + endif + # Find available RegEx library. Prefer libpcreposix. + ifneq (,$(call find_include,pcreposix)) + ifneq (,$(call find_lib,pcreposix)) + OS_CCDEFS += -DHAVE_PCREPOSIX_H + OS_LDFLAGS += -lpcreposix + $(info using libpcreposix: $(call find_lib,pcreposix) $(call find_include,pcreposix)) + ifeq ($(LD_SEARCH_NEEDED),$(call need_search,pcreposix)) + OS_LDFLAGS += -L$(dir $(call find_lib,pcreposix)) + endif + endif + else + # If libpcreposix isn't available, fall back to the local regex.h + # Presume that the local regex support is available in the C runtime + # without a specific reference to a library. This may not be true on + # some platforms. + ifneq (,$(call find_include,regex)) + OS_CCDEFS += -DHAVE_REGEX_H + $(info using regex: $(call find_include,regex)) + endif + endif + ifneq (,$(call find_include,dlfcn)) + ifneq (,$(call find_lib,dl)) + OS_CCDEFS += -DHAVE_DLOPEN=$(LIBEXT) + OS_LDFLAGS += -ldl + $(info using libdl: $(call find_lib,dl) $(call find_include,dlfcn)) + else + ifneq (,$(findstring BSD,$(OSTYPE))$(findstring AIX,$(OSTYPE))$(findstring Haiku,$(OSTYPE))) + OS_CCDEFS += -DHAVE_DLOPEN=so + $(info using libdl: $(call find_include,dlfcn)) + else + ifneq (,$(call find_lib,dld)) + OS_CCDEFS += -DHAVE_DLOPEN=$(LIBEXT) + OS_LDFLAGS += -ldld + $(info using libdld: $(call find_lib,dld) $(call find_include,dlfcn)) + endif + endif + endif + endif + ifneq (,$(call find_include,png)) + ifneq (,$(call find_lib,png)) + OS_CCDEFS += -DHAVE_LIBPNG + OS_LDFLAGS += -lpng + $(info using libpng: $(call find_lib,png) $(call find_include,png)) + endif + endif + ifneq (,$(call find_include,glob)) + OS_CCDEFS += -DHAVE_GLOB + else + ifneq (,$(call find_include,fnmatch)) + OS_CCDEFS += -DHAVE_FNMATCH + endif + endif + ifneq (,$(call find_include,sys/mman)) + ifneq (,$(shell grep shm_open $(call find_include,sys/mman))) + OS_CCDEFS += -DHAVE_SHM_OPEN + $(info using mman: $(call find_include,sys/mman)) + endif + endif + ifneq (,$(VIDEO_USEFUL)) + ifeq (cygwin,$(OSTYPE)) + LIBEXTSAVE := $(LIBEXT) + LIBEXT = dll.a + endif + ifneq (,$(call find_include,SDL2/SDL)) + ifneq (,$(call find_lib,SDL2)) + VIDEO_CCDEFS += -DHAVE_LIBSDL -DUSE_SIM_VIDEO `$(realpath $(dir $(call find_include,SDL2/SDL))../../bin/sdl2-config) --cflags` + VIDEO_LDFLAGS += `$(realpath $(dir $(call find_include,SDL2/SDL))../../bin/sdl2-config) --libs` + VIDEO_FEATURES = - video capabilities provided by libSDL2 (Simple Directmedia Layer) + DISPLAYL = ${DISPLAYD}/display.c $(DISPLAYD)/sim_ws.c + DISPLAYVT = ${DISPLAYD}/vt11.c + DISPLAY_OPT += -DUSE_DISPLAY $(VIDEO_CCDEFS) $(VIDEO_LDFLAGS) + $(info using libSDL2: $(call find_include,SDL2/SDL)) + ifeq (Darwin,$(OSTYPE)) + VIDEO_CCDEFS += -DSDL_MAIN_AVAILABLE + endif + endif + else + ifneq (,$(call find_include,SDL/SDL)) + ifneq (,$(call find_lib,SDL)) + VIDEO_CCDEFS += -DHAVE_LIBSDL -DUSE_SIM_VIDEO `$(realpath $(dir $(call find_include,SDL/SDL))../../bin/sdl-config) --cflags` + VIDEO_LDFLAGS += `$(realpath $(dir $(call find_include,SDL/SDL))../../bin/sdl-config) --libs` + VIDEO_FEATURES = - video capabilities provided by libSDL (Simple Directmedia Layer) + DISPLAYL = ${DISPLAYD}/display.c $(DISPLAYD)/sim_ws.c + DISPLAYVT = ${DISPLAYD}/vt11.c + DISPLAY_OPT += -DUSE_DISPLAY $(VIDEO_CCDEFS) $(VIDEO_LDFLAGS) + $(info using libSDL: $(call find_include,SDL/SDL)) + ifeq (Darwin,$(OSTYPE)) + VIDEO_CCDEFS += -DSDL_MAIN_AVAILABLE + endif + endif + endif + endif + ifeq (cygwin,$(OSTYPE)) + LIBEXT = $(LIBEXTSAVE) + endif + ifeq (,$(findstring HAVE_LIBSDL,$(VIDEO_CCDEFS))) + $(info *** Info ***) + $(info *** Info *** The simulator$(BUILD_MULTIPLE) you are building could provide more) + $(info *** Info *** functionality if video support were available on your system.) + ifeq (Darwin,$(OSTYPE)) + $(info *** Info *** Install the MacPorts libSDL2 packaged to provide this) + $(info *** Info *** functionality for your OS X system:) + $(info *** Info *** # port install libsdl2) + else + ifneq (,$(and $(findstring Linux,$(OSTYPE)),$(call find_exe,apt-get))) + $(info *** Info *** Install the development components of libSDL or libSDL2) + $(info *** Info *** packaged for your operating system distribution for) + $(info *** Info *** your Linux system:) + $(info *** Info *** # apt-get install libsdl2-dev) + $(info *** Info *** or) + $(info *** Info *** # apt-get install libsdl-dev) + else + $(info *** Info *** Install the development components of libSDL packaged by your) + $(info *** Info *** operating system distribution and rebuild your simulator to) + $(info *** Info *** enable this extra functionality.) + endif + endif + $(info *** Info ***) + endif + endif + ifneq (,$(NETWORK_USEFUL)) + ifneq (,$(call find_include,pcap)) + ifneq (,$(shell grep 'pcap/pcap.h' $(call find_include,pcap) | grep include)) + PCAP_H_PATH = $(dir $(call find_include,pcap))pcap/pcap.h + else + PCAP_H_PATH = $(call find_include,pcap) + endif + ifneq (,$(shell grep pcap_compile $(PCAP_H_PATH) | grep const)) + BPF_CONST_STRING = -DBPF_CONST_STRING + endif + NETWORK_CCDEFS += -DHAVE_PCAP_NETWORK -I$(dir $(call find_include,pcap)) $(BPF_CONST_STRING) + NETWORK_LAN_FEATURES += PCAP + ifneq (,$(call find_lib,$(PCAPLIB))) + ifneq ($(USE_NETWORK),) # Network support specified on the GNU make command line + NETWORK_CCDEFS += -DUSE_NETWORK + ifeq (,$(findstring Linux,$(OSTYPE))$(findstring Darwin,$(OSTYPE))) + $(info *** Warning ***) + $(info *** Warning *** Statically linking against libpcap is provides no measurable) + $(info *** Warning *** benefits over dynamically linking libpcap.) + $(info *** Warning ***) + $(info *** Warning *** Support for linking this way is currently deprecated and may be removed) + $(info *** Warning *** in the future.) + $(info *** Warning ***) + else + $(info *** Error ***) + $(info *** Error *** Statically linking against libpcap is provides no measurable) + $(info *** Error *** benefits over dynamically linking libpcap.) + $(info *** Error ***) + $(info *** Error *** Support for linking statically has been removed on the $(OSTYPE)) + $(info *** Error *** platform.) + $(info *** Error ***) + $(error Retry your build without specifying USE_NETWORK=1) + endif + ifeq (cygwin,$(OSTYPE)) + # cygwin has no ldconfig so explicitly specify pcap object library + NETWORK_LDFLAGS = -L$(dir $(call find_lib,$(PCAPLIB))) -Wl,-R,$(dir $(call find_lib,$(PCAPLIB))) -l$(PCAPLIB) + else + NETWORK_LDFLAGS = -l$(PCAPLIB) + endif + $(info using libpcap: $(call find_lib,$(PCAPLIB)) $(call find_include,pcap)) + NETWORK_FEATURES = - static networking support using $(OSNAME) provided libpcap components + else # default build uses dynamic libpcap + NETWORK_CCDEFS += -DUSE_SHARED + $(info using libpcap: $(call find_include,pcap)) + NETWORK_FEATURES = - dynamic networking support using $(OSNAME) provided libpcap components + endif + else + LIBEXTSAVE := $(LIBEXT) + LIBEXT = a + ifneq (,$(call find_lib,$(PCAPLIB))) + NETWORK_CCDEFS += -DUSE_NETWORK + NETWORK_LDFLAGS := -L$(dir $(call find_lib,$(PCAPLIB))) -l$(PCAPLIB) + NETWORK_FEATURES = - static networking support using $(OSNAME) provided libpcap components + $(info using libpcap: $(call find_lib,$(PCAPLIB)) $(call find_include,pcap)) + endif + LIBEXT = $(LIBEXTSAVE) + endif + else + # On non-Linux platforms, we'll still try to provide deprecated support for libpcap in /usr/local + INCPATHSAVE := $(INCPATH) + ifeq (,$(findstring Linux,$(OSTYPE))) + # Look for package built from tcpdump.org sources with default install target (or cygwin winpcap) + INCPATH += /usr/local/include + PCAP_H_FOUND = $(call find_include,pcap) + endif + ifneq (,$(strip $(PCAP_H_FOUND))) + ifneq (,$(shell grep 'pcap/pcap.h' $(call find_include,pcap) | grep include)) + PCAP_H_PATH = $(dir $(call find_include,pcap))pcap/pcap.h + else + PCAP_H_PATH = $(call find_include,pcap) + endif + ifneq (,$(shell grep pcap_compile $(PCAP_H_PATH) | grep const)) + BPF_CONST_STRING = -DBPF_CONST_STRING + endif + LIBEXTSAVE := $(LIBEXT) + # first check if binary - shared objects are available/installed in the linker known search paths + ifneq (,$(call find_lib,$(PCAPLIB))) + NETWORK_CCDEFS = -DUSE_SHARED -I$(dir $(call find_include,pcap)) $(BPF_CONST_STRING) + NETWORK_FEATURES = - dynamic networking support using libpcap components from www.tcpdump.org and locally installed libpcap.$(LIBEXT) + $(info using libpcap: $(call find_include,pcap)) + else + LIBPATH += /usr/local/lib + LIBEXT = a + ifneq (,$(call find_lib,$(PCAPLIB))) + $(info using libpcap: $(call find_lib,$(PCAPLIB)) $(call find_include,pcap)) + ifeq (cygwin,$(OSTYPE)) + NETWORK_CCDEFS = -DUSE_NETWORK -DHAVE_PCAP_NETWORK -I$(dir $(call find_include,pcap)) $(BPF_CONST_STRING) + NETWORK_LDFLAGS = -L$(dir $(call find_lib,$(PCAPLIB))) -Wl,-R,$(dir $(call find_lib,$(PCAPLIB))) -l$(PCAPLIB) + NETWORK_FEATURES = - static networking support using libpcap components located in the cygwin directories + else + NETWORK_CCDEFS := -DUSE_NETWORK -DHAVE_PCAP_NETWORK -isystem -I$(dir $(call find_include,pcap)) $(BPF_CONST_STRING) $(call find_lib,$(PCAPLIB)) + NETWORK_FEATURES = - networking support using libpcap components from www.tcpdump.org + $(info *** Warning ***) + $(info *** Warning *** $(BUILD_SINGLE)Simulator$(BUILD_MULTIPLE) being built with networking support using) + $(info *** Warning *** libpcap components from www.tcpdump.org.) + $(info *** Warning *** Some users have had problems using the www.tcpdump.org libpcap) + $(info *** Warning *** components for simh networking. For best results, with) + $(info *** Warning *** simh networking, it is recommended that you install the) + $(info *** Warning *** libpcap-dev (or libpcap-devel) package from your $(OSNAME) distribution) + $(info *** Warning ***) + $(info *** Warning *** Building with the components manually installed from www.tcpdump.org) + $(info *** Warning *** is officially deprecated. Attempting to do so is unsupported.) + $(info *** Warning ***) + endif + else + $(error using libpcap: $(call find_include,pcap) missing $(PCAPLIB).$(LIBEXT)) + endif + NETWORK_LAN_FEATURES += PCAP + endif + LIBEXT = $(LIBEXTSAVE) + else + INCPATH = $(INCPATHSAVE) + $(info *** Warning ***) + $(info *** Warning *** $(BUILD_SINGLE)Simulator$(BUILD_MULTIPLE) are being built WITHOUT) + $(info *** Warning *** libpcap networking support) + $(info *** Warning ***) + $(info *** Warning *** To build simulator(s) with libpcap networking support you) + ifneq (,$(and $(findstring Linux,$(OSTYPE)),$(call find_exe,apt-get))) + $(info *** Warning *** should install the libpcap development components for) + $(info *** Warning *** for your Linux system:) + $(info *** Warning *** # apt-get install libpcap-dev) + else + $(info *** Warning *** should read 0readme_ethernet.txt and follow the instructions) + $(info *** Warning *** regarding the needed libpcap development components for your) + $(info *** Warning *** $(OSTYPE) platform) + endif + $(info *** Warning ***) + endif + endif + # Consider other network connections + ifneq (,$(call find_lib,vdeplug)) + # libvdeplug requires the use of the OS provided libpcap + ifeq (,$(findstring usr/local,$(NETWORK_CCDEFS))) + ifneq (,$(call find_include,libvdeplug)) + # Provide support for vde networking + NETWORK_CCDEFS += -DHAVE_VDE_NETWORK + NETWORK_LAN_FEATURES += VDE + ifeq (,$(findstring USE_NETWORK,$(NETWORK_CCDEFS))$(findstring USE_SHARED,$(NETWORK_CCDEFS))) + NETWORK_CCDEFS += -DUSE_NETWORK + endif + ifeq (Darwin,$(OSTYPE)) + NETWORK_LDFLAGS += -lvdeplug -L$(dir $(call find_lib,vdeplug)) + else + NETWORK_LDFLAGS += -lvdeplug -Wl,-R,$(dir $(call find_lib,vdeplug)) -L$(dir $(call find_lib,vdeplug)) + endif + $(info using libvdeplug: $(call find_lib,vdeplug) $(call find_include,libvdeplug)) + endif + endif + endif + ifeq (,$(findstring HAVE_VDE_NETWORK,$(NETWORK_CCDEFS))) + # Support is available on Linux for libvdeplug. Advise on its usage + ifneq (,$(findstring Linux,$(OSTYPE))) + ifneq (,$(findstring USE_NETWORK,$(NETWORK_CCDEFS))$(findstring USE_SHARED,$(NETWORK_CCDEFS))) + $(info *** Info ***) + $(info *** Info *** $(BUILD_SINGLE)Simulator$(BUILD_MULTIPLE) are being built with) + $(info *** Info *** minimal libpcap networking support) + $(info *** Info ***) + endif + $(info *** Info ***) + $(info *** Info *** Simulators on your $(OSNAME) platform can also be built with) + $(info *** Info *** extended LAN Ethernet networking support by using VDE Ethernet.) + $(info *** Info ***) + $(info *** Info *** To build simulator(s) with extended networking support you) + ifeq (Darwin,$(OSTYPE)) + $(info *** Info *** should install the MacPorts vde2 package to provide this) + $(info *** Info *** functionality for your OS X system:) + $(info *** Info *** # port install vde2) + else + ifneq (,$(and $(findstring Linux,$(OSTYPE)),$(call find_exe,apt-get))) + $(info *** Info *** should install the vde2 package to provide this) + $(info *** Info *** functionality for your $(OSNAME) system:) + $(info *** Info *** # apt-get install vde2) + else + $(info *** Info *** should read 0readme_ethernet.txt and follow the instructions) + $(info *** Info *** regarding the needed libvdeplug components for your $(OSNAME)) + $(info *** Info *** platform) + endif + endif + $(info *** Info ***) + endif + endif + ifneq (,$(call find_include,linux/if_tun)) + # Provide support for Tap networking on Linux + NETWORK_CCDEFS += -DHAVE_TAP_NETWORK + NETWORK_LAN_FEATURES += TAP + ifeq (,$(findstring USE_NETWORK,$(NETWORK_CCDEFS))$(findstring USE_SHARED,$(NETWORK_CCDEFS))) + NETWORK_CCDEFS += -DUSE_NETWORK + endif + endif + ifeq (bsdtuntap,$(shell if $(TEST) -e /usr/include/net/if_tun.h -o -e /Library/Extensions/tap.kext; then echo bsdtuntap; fi)) + # Provide support for Tap networking on BSD platforms (including OS X) + NETWORK_CCDEFS += -DHAVE_TAP_NETWORK -DHAVE_BSDTUNTAP + NETWORK_LAN_FEATURES += TAP + ifeq (,$(findstring USE_NETWORK,$(NETWORK_CCDEFS))$(findstring USE_SHARED,$(NETWORK_CCDEFS))) + NETWORK_CCDEFS += -DUSE_NETWORK + endif + endif + ifeq (slirp,$(shell if $(TEST) -e slirp_glue/sim_slirp.c; then echo slirp; fi)) + NETWORK_CCDEFS += -Islirp -Islirp_glue -Islirp_glue/qemu -DHAVE_SLIRP_NETWORK -DUSE_SIMH_SLIRP_DEBUG slirp/*.c slirp_glue/*.c + NETWORK_LAN_FEATURES += NAT(SLiRP) + endif + ifeq (,$(findstring USE_NETWORK,$(NETWORK_CCDEFS))$(findstring USE_SHARED,$(NETWORK_CCDEFS))$(findstring HAVE_VDE_NETWORK,$(NETWORK_CCDEFS))) + NETWORK_CCDEFS += -DUSE_NETWORK + NETWORK_FEATURES = - WITHOUT Local LAN networking support + $(info *** Warning ***) + $(info *** Warning *** $(BUILD_SINGLE)Simulator$(BUILD_MULTIPLE) are being built WITHOUT LAN networking support) + $(info *** Warning ***) + $(info *** Warning *** To build simulator(s) with networking support you should read) + $(info *** Warning *** 0readme_ethernet.txt and follow the instructions regarding the) + $(info *** Warning *** needed libpcap components for your $(OSTYPE) platform) + $(info *** Warning ***) + endif + NETWORK_OPT = $(NETWORK_CCDEFS) + endif + ifneq (binexists,$(shell if $(TEST) -e BIN; then echo binexists; fi)) + MKDIRBIN = mkdir -p BIN + endif + ifeq (commit-id-exists,$(shell if $(TEST) -e .git-commit-id; then echo commit-id-exists; fi)) + GIT_COMMIT_ID=$(shell cat .git-commit-id) + else + ifeq (,$(shell grep 'define SIM_GIT_COMMIT_ID' sim_rev.h | grep 'Format:')) + GIT_COMMIT_ID=$(shell grep 'define SIM_GIT_COMMIT_ID' sim_rev.h | awk '{ print $$3 }') + endif + endif +else + #Win32 Environments (via MinGW32) + GCC := gcc + GCC_Path := $(abspath $(dir $(word 1,$(wildcard $(addsuffix /$(GCC).exe,$(subst ;, ,$(PATH))))))) + ifeq (rename-build-support,$(shell if exist ..\windows-build-windows-build echo rename-build-support)) + REMOVE_OLD_BUILD := $(shell if exist ..\windows-build rmdir/s/q ..\windows-build) + FIXED_BUILD := $(shell move ..\windows-build-windows-build ..\windows-build >NUL) + endif + GCC_VERSION = $(word 3,$(shell $(GCC) --version)) + COMPILER_NAME = GCC Version: $(GCC_VERSION) + CC_STD = -std=gnu99 + LTO_EXCLUDE_VERSIONS = 4.5.2 + ifeq (,$(PATH_SEPARATOR)) + PATH_SEPARATOR := ; + endif + INCPATH = $(abspath $(wildcard $(GCC_Path)\..\include $(subst $(PATH_SEPARATOR), ,$(CPATH)) $(subst $(PATH_SEPARATOR), ,$(C_INCLUDE_PATH)))) + LIBPATH = $(abspath $(wildcard $(GCC_Path)\..\lib $(subst :, ,$(LIBRARY_PATH)))) + $(info lib paths are: $(LIBPATH)) + $(info include paths are: $(INCPATH)) + # Give preference to any MinGW provided threading (if available) + ifneq (,$(call find_include,pthread)) + PTHREADS_CCDEFS = -DUSE_READER_THREAD + ifeq (,$(NOASYNCH)) + PTHREADS_CCDEFS += -DSIM_ASYNCH_IO + endif + PTHREADS_LDFLAGS = -lpthread + else + ifeq (pthreads,$(shell if exist ..\windows-build\pthreads\Pre-built.2\include\pthread.h echo pthreads)) + PTHREADS_CCDEFS = -DUSE_READER_THREAD -DPTW32_STATIC_LIB -D_POSIX_C_SOURCE -I../windows-build/pthreads/Pre-built.2/include + ifeq (,$(NOASYNCH)) + PTHREADS_CCDEFS += -DSIM_ASYNCH_IO + endif + PTHREADS_LDFLAGS = -lpthreadGC2 -L..\windows-build\pthreads\Pre-built.2\lib + endif + endif + ifeq (pcap,$(shell if exist ..\windows-build\winpcap\Wpdpack\include\pcap.h echo pcap)) + NETWORK_LDFLAGS = + NETWORK_OPT = -DUSE_SHARED -I../windows-build/winpcap/Wpdpack/include + NETWORK_FEATURES = - dynamic networking support using windows-build provided libpcap components + NETWORK_LAN_FEATURES += PCAP + else + ifneq (,$(call find_include,pcap)) + NETWORK_LDFLAGS = + NETWORK_OPT = -DUSE_SHARED + NETWORK_FEATURES = - dynamic networking support using libpcap components found in the MinGW directories + NETWORK_LAN_FEATURES += PCAP + endif + endif + ifneq (,$(VIDEO_USEFUL)) + SDL_INCLUDE = $(word 1,$(shell dir /b /s ..\windows-build\libSDL\SDL.h)) + ifeq (SDL.h,$(findstring SDL.h,$(SDL_INCLUDE))) + VIDEO_CCDEFS += -DHAVE_LIBSDL -I$(abspath $(dir $(SDL_INCLUDE))) + VIDEO_LDFLAGS += -lSDL2 -L$(abspath $(dir $(SDL_INCLUDE))\..\lib) + VIDEO_FEATURES = - video capabilities provided by libSDL2 (Simple Directmedia Layer) + else + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info ** This build could produce simulators with video capabilities. **) + $(info ** However, the required files to achieve this can't be found on **) + $(info ** this system. Download the file: **) + $(info ** https://github.com/simh/windows-build/archive/windows-build.zip **) + $(info ** Extract the windows-build-windows-build folder it contains to **) + $(info ** $(abspath ..\) **) + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info .) + endif + endif + OS_CCDEFS += -fms-extensions $(PTHREADS_CCDEFS) + OS_LDFLAGS += -lm -lwsock32 -lwinmm $(PTHREADS_LDFLAGS) + EXE = .exe + ifneq (binexists,$(shell if exist BIN echo binexists)) + MKDIRBIN = if not exist BIN mkdir BIN + endif + ifneq ($(USE_NETWORK),) + NETWORK_OPT += -DUSE_SHARED + endif + ifneq (,$(shell if exist .git-commit-id type .git-commit-id)) + GIT_COMMIT_ID=$(shell if exist .git-commit-id type .git-commit-id) + else + ifeq (,$(shell findstr /C:"define SIM_GIT_COMMIT_ID" sim_rev.h | findstr Format)) + GIT_COMMIT_ID=$(shell for /F "tokens=3" %%i in ("$(shell findstr /C:"define SIM_GIT_COMMIT_ID" sim_rev.h)") do echo %%i) + endif + endif + ifneq (windows-build,$(shell if exist ..\windows-build\README.md echo windows-build)) + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info ** This build is operating without the required windows-build **) + $(info ** components and therefore will produce less than optimal **) + $(info ** simulator operation and features. **) + $(info ** Download the file: **) + $(info ** https://github.com/simh/windows-build/archive/windows-build.zip **) + $(info ** Extract the windows-build-windows-build folder it contains to **) + $(info ** $(abspath ..\) **) + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info .) + else + # Version check on windows-build + WINDOWS_BUILD = $(shell findstr WINDOWS-BUILD ..\windows-build\Windows-Build_Versions.txt) + ifeq (,$(WINDOWS_BUILD)) + WINDOWS_BUILD = 00000000 + endif + ifneq (,$(shell if 20150412 GTR $(WINDOWS_BUILD) echo old-windows-build)) + $(info .) + $(info windows-build components at: $(abspath ..\windows-build)) + $(info .) + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info ** This currently available windows-build components are out of **) + $(info ** date. For the most functional and stable features you shoud **) + $(info ** Download the file: **) + $(info ** https://github.com/simh/windows-build/archive/windows-build.zip **) + $(info ** Extract the windows-build-windows-build folder it contains to **) + $(info ** $(abspath ..\) **) + $(info ***********************************************************************) + $(info ***********************************************************************) + $(info .) + endif + ifeq (pcre,$(shell if exist ..\windows-build\PCRE\include\pcre.h echo pcre)) + OS_CCDEFS += -DHAVE_PCREPOSIX_H -DPCRE_STATIC -I$(abspath ../windows-build/PCRE/include) + OS_LDFLAGS += -lpcreposix -lpcre -L../windows-build/PCRE/lib/ + $(info using libpcreposix: $(abspath ../windows-build/PCRE/lib/pcreposix.a) $(abspath ../windows-build/PCRE/include/pcreposix.h)) + endif + ifeq (slirp,slirp) + NETWORK_OPT += -Islirp -Islirp_glue -Islirp_glue/qemu -DHAVE_SLIRP_NETWORK -DUSE_SIMH_SLIRP_DEBUG slirp/*.c slirp_glue/*.c -lIphlpapi + NETWORK_LAN_FEATURES += NAT(SLiRP) + endif + endif +endif # Win32 (via MinGW) +ifneq (,$(GIT_COMMIT_ID)) + CFLAGS_GIT = -DSIM_GIT_COMMIT_ID=$(GIT_COMMIT_ID) +endif +ifneq (,$(UNSUPPORTED_BUILD)) + CFLAGS_GIT += -DSIM_BUILD=Unsupported=$(UNSUPPORTED_BUILD) +endif +ifneq ($(DEBUG),) + CFLAGS_G = -g -ggdb -g3 + CFLAGS_O = -O0 + BUILD_FEATURES = - debugging support +else + ifneq (clang,$(findstring clang,$(COMPILER_NAME))) + CFLAGS_O = -O2 + ifeq (Darwin,$(OSTYPE)) + NO_LTO = 1 + endif + else + NO_LTO = 1 + ifeq (Darwin,$(OSTYPE)) + CFLAGS_O += -O4 -fno-strict-overflow -flto -fwhole-program + else + CFLAGS_O := -O2 -fno-strict-overflow + endif + endif + LDFLAGS_O = + GCC_MAJOR_VERSION = $(firstword $(subst ., ,$(GCC_VERSION))) + ifneq (3,$(GCC_MAJOR_VERSION)) + ifeq (,$(GCC_OPTIMIZERS_CMD)) + GCC_OPTIMIZERS_CMD = $(GCC) --help=optimizers + endif + GCC_OPTIMIZERS = $(shell $(GCC_OPTIMIZERS_CMD)) + endif + ifneq (,$(findstring $(GCC_VERSION),$(LTO_EXCLUDE_VERSIONS))) + NO_LTO = 1 + endif + ifneq (,$(findstring -finline-functions,$(GCC_OPTIMIZERS))) + CFLAGS_O += -finline-functions + endif + ifneq (,$(findstring -fgcse-after-reload,$(GCC_OPTIMIZERS))) + CFLAGS_O += -fgcse-after-reload + endif + ifneq (,$(findstring -fpredictive-commoning,$(GCC_OPTIMIZERS))) + CFLAGS_O += -fpredictive-commoning + endif + ifneq (,$(findstring -fipa-cp-clone,$(GCC_OPTIMIZERS))) + CFLAGS_O += -fipa-cp-clone + endif + ifneq (,$(findstring -funsafe-loop-optimizations,$(GCC_OPTIMIZERS))) + CFLAGS_O += -fno-unsafe-loop-optimizations + endif + ifneq (,$(findstring -fstrict-overflow,$(GCC_OPTIMIZERS))) + CFLAGS_O += -fno-strict-overflow + endif + ifeq (,$(NO_LTO)) + ifneq (,$(findstring -flto,$(GCC_OPTIMIZERS))) + CFLAGS_O += -flto -fwhole-program + LDFLAGS_O += -flto -fwhole-program + endif + endif + BUILD_FEATURES = - compiler optimizations and no debugging support +endif +ifneq (3,$(GCC_MAJOR_VERSION)) + ifeq (,$(GCC_WARNINGS_CMD)) + GCC_WARNINGS_CMD = $(GCC) --help=warnings + endif + ifneq (,$(findstring -Wunused-result,$(shell $(GCC_WARNINGS_CMD)))) + CFLAGS_O += -Wno-unused-result + endif +endif +ifneq (clean,$(MAKECMDGOALS)) + BUILD_FEATURES := $(BUILD_FEATURES). $(COMPILER_NAME) + $(info ***) + $(info *** $(BUILD_SINGLE)Simulator$(BUILD_MULTIPLE) being built with:) + $(info *** $(BUILD_FEATURES).) + ifneq (,$(NETWORK_FEATURES)) + $(info *** $(NETWORK_FEATURES).) + endif + ifneq (,$(NETWORK_LAN_FEATURES)) + $(info *** - Local LAN packet transports: $(NETWORK_LAN_FEATURES)) + endif + ifneq (,$(VIDEO_FEATURES)) + $(info *** $(VIDEO_FEATURES).) + endif + ifneq (,$(GIT_COMMIT_ID)) + $(info ***) + $(info *** git commit id is $(GIT_COMMIT_ID).) + endif + $(info ***) +endif +ifneq ($(DONT_USE_ROMS),) + ROMS_OPT = -DDONT_USE_INTERNAL_ROM +else + BUILD_ROMS = ${BIN}BuildROMs${EXE} +endif +ifneq ($(DONT_USE_READER_THREAD),) + NETWORK_OPT += -DDONT_USE_READER_THREAD +endif + +CC_OUTSPEC = -o $@ +CC := $(GCC) $(CC_STD) -U__STRICT_ANSI__ $(CFLAGS_G) $(CFLAGS_O) $(CFLAGS_GIT) -DSIM_COMPILER="$(COMPILER_NAME)" -I . $(OS_CCDEFS) $(ROMS_OPT) +LDFLAGS := $(OS_LDFLAGS) $(NETWORK_LDFLAGS) $(LDFLAGS_O) + +# +# Common Libraries +# +BIN = BIN/ +SIM = scp.c sim_console.c sim_fio.c sim_timer.c sim_sock.c \ + sim_tmxr.c sim_ether.c sim_tape.c sim_disk.c sim_serial.c \ + sim_video.c sim_imd.c sim_card.c + +DISPLAYD = display + +# +# Emulator source files and compile time options +# +PDP1D = PDP1 +ifneq (,$(DISPLAY_OPT)) + PDP1_DISPLAY_OPT = -DDISPLAY_TYPE=DIS_TYPE30 -DPIX_SCALE=RES_HALF +endif +PDP1 = ${PDP1D}/pdp1_lp.c ${PDP1D}/pdp1_cpu.c ${PDP1D}/pdp1_stddev.c \ + ${PDP1D}/pdp1_sys.c ${PDP1D}/pdp1_dt.c ${PDP1D}/pdp1_drm.c \ + ${PDP1D}/pdp1_clk.c ${PDP1D}/pdp1_dcs.c ${PDP1D}/pdp1_dpy.c ${DISPLAYL} +PDP1_OPT = -I ${PDP1D} $(DISPLAY_OPT) $(PDP1_DISPLAY_OPT) + + +NOVAD = NOVA +NOVA = ${NOVAD}/nova_sys.c ${NOVAD}/nova_cpu.c ${NOVAD}/nova_dkp.c \ + ${NOVAD}/nova_dsk.c ${NOVAD}/nova_lp.c ${NOVAD}/nova_mta.c \ + ${NOVAD}/nova_plt.c ${NOVAD}/nova_pt.c ${NOVAD}/nova_clk.c \ + ${NOVAD}/nova_tt.c ${NOVAD}/nova_tt1.c ${NOVAD}/nova_qty.c +NOVA_OPT = -I ${NOVAD} + + +ECLIPSE = ${NOVAD}/eclipse_cpu.c ${NOVAD}/eclipse_tt.c ${NOVAD}/nova_sys.c \ + ${NOVAD}/nova_dkp.c ${NOVAD}/nova_dsk.c ${NOVAD}/nova_lp.c \ + ${NOVAD}/nova_mta.c ${NOVAD}/nova_plt.c ${NOVAD}/nova_pt.c \ + ${NOVAD}/nova_clk.c ${NOVAD}/nova_tt1.c ${NOVAD}/nova_qty.c +ECLIPSE_OPT = -I ${NOVAD} -DECLIPSE + + +PDP18BD = PDP18B +PDP18B = ${PDP18BD}/pdp18b_dt.c ${PDP18BD}/pdp18b_drm.c ${PDP18BD}/pdp18b_cpu.c \ + ${PDP18BD}/pdp18b_lp.c ${PDP18BD}/pdp18b_mt.c ${PDP18BD}/pdp18b_rf.c \ + ${PDP18BD}/pdp18b_rp.c ${PDP18BD}/pdp18b_stddev.c ${PDP18BD}/pdp18b_sys.c \ + ${PDP18BD}/pdp18b_rb.c ${PDP18BD}/pdp18b_tt1.c ${PDP18BD}/pdp18b_fpp.c \ + ${PDP18BD}/pdp18b_g2tty.c + +PDP4_OPT = -DPDP4 -I ${PDP18BD} +PDP7_OPT = -DPDP7 -I ${PDP18BD} +PDP9_OPT = -DPDP9 -I ${PDP18BD} +PDP15_OPT = -DPDP15 -I ${PDP18BD} + + +PDP11D = PDP11 +PDP11 = ${PDP11D}/pdp11_fp.c ${PDP11D}/pdp11_cpu.c ${PDP11D}/pdp11_dz.c \ + ${PDP11D}/pdp11_cis.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_rk.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rp.c ${PDP11D}/pdp11_rx.c \ + ${PDP11D}/pdp11_stddev.c ${PDP11D}/pdp11_sys.c ${PDP11D}/pdp11_tc.c \ + ${PDP11D}/pdp11_tm.c ${PDP11D}/pdp11_ts.c ${PDP11D}/pdp11_io.c \ + ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_tq.c ${PDP11D}/pdp11_pclk.c \ + ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_pt.c ${PDP11D}/pdp11_hk.c \ + ${PDP11D}/pdp11_xq.c ${PDP11D}/pdp11_xu.c ${PDP11D}/pdp11_vh.c \ + ${PDP11D}/pdp11_rh.c ${PDP11D}/pdp11_tu.c ${PDP11D}/pdp11_cpumod.c \ + ${PDP11D}/pdp11_cr.c ${PDP11D}/pdp11_rf.c ${PDP11D}/pdp11_dl.c \ + ${PDP11D}/pdp11_ta.c ${PDP11D}/pdp11_rc.c ${PDP11D}/pdp11_kg.c \ + ${PDP11D}/pdp11_ke.c ${PDP11D}/pdp11_dc.c ${PDP11D}/pdp11_dmc.c \ + ${PDP11D}/pdp11_kmc.c ${PDP11D}/pdp11_dup.c ${PDP11D}/pdp11_rs.c \ + ${PDP11D}/pdp11_vt.c ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_io_lib.c $(DISPLAYL) $(DISPLAYVT) +PDP11_OPT = -DVM_PDP11 -I ${PDP11D} ${NETWORK_OPT} $(DISPLAY_OPT) + + +VAXD = VAX +VAX = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c ${VAXD}/vax_io.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_stddev.c ${VAXD}/vax_sysdev.c \ + ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c ${VAXD}/vax_syslist.c \ + ${VAXD}/vax_vc.c ${VAXD}/vax_lk.c ${VAXD}/vax_vs.c ${VAXD}/vax_2681.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xq.c ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_io_lib.c +VAX_OPT = -DVM_VAX -DUSE_INT64 -DUSE_ADDR64 -DUSE_SIM_VIDEO -I ${VAXD} -I ${PDP11D} ${NETWORK_OPT} ${VIDEO_CCDEFS} ${VIDEO_LDFLAGS} + + +VAX610 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax610_stddev.c ${VAXD}/vax610_sysdev.c ${VAXD}/vax610_io.c \ + ${VAXD}/vax610_syslist.c ${VAXD}/vax610_mem.c ${VAXD}/vax_vc.c \ + ${VAXD}/vax_lk.c ${VAXD}/vax_vs.c ${VAXD}/vax_2681.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xq.c ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_io_lib.c +VAX610_OPT = -DVM_VAX -DVAX_610 -DUSE_INT64 -DUSE_ADDR64 -DUSE_SIM_VIDEO -I ${VAXD} -I ${PDP11D} ${NETWORK_OPT} ${VIDEO_CCDEFS} ${VIDEO_LDFLAGS} + +VAX630 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax_watch.c ${VAXD}/vax630_stddev.c ${VAXD}/vax630_sysdev.c \ + ${VAXD}/vax630_io.c ${VAXD}/vax630_syslist.c ${VAXD}/vax_vc.c \ + ${VAXD}/vax_lk.c ${VAXD}/vax_vs.c ${VAXD}/vax_2681.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xq.c ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_io_lib.c +VAX620_OPT = -DVM_VAX -DVAX_620 -DUSE_INT64 -DUSE_ADDR64 -I ${VAXD} -I ${PDP11D} ${NETWORK_OPT} +VAX630_OPT = -DVM_VAX -DVAX_630 -DUSE_INT64 -DUSE_ADDR64 -DUSE_SIM_VIDEO -I ${VAXD} -I ${PDP11D} ${NETWORK_OPT} ${VIDEO_CCDEFS} ${VIDEO_LDFLAGS} + + +VAX730 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax730_stddev.c ${VAXD}/vax730_sys.c \ + ${VAXD}/vax730_mem.c ${VAXD}/vax730_uba.c ${VAXD}/vax730_rb.c \ + ${VAXD}/vax730_syslist.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xu.c ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_hk.c ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_dmc.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_tc.c ${PDP11D}/pdp11_rk.c \ + ${PDP11D}/pdp11_io_lib.c +VAX730_OPT = -DVM_VAX -DVAX_730 -DUSE_INT64 -DUSE_ADDR64 -I VAX -I ${PDP11D} ${NETWORK_OPT} + + +VAX750 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax750_stddev.c ${VAXD}/vax750_cmi.c \ + ${VAXD}/vax750_mem.c ${VAXD}/vax750_uba.c ${VAXD}/vax7x0_mba.c \ + ${VAXD}/vax750_syslist.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xu.c ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_hk.c ${PDP11D}/pdp11_rp.c ${PDP11D}/pdp11_tu.c \ + ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_dmc.c ${PDP11D}/pdp11_dup.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_tc.c ${PDP11D}/pdp11_rk.c \ + ${PDP11D}/pdp11_io_lib.c +VAX750_OPT = -DVM_VAX -DVAX_750 -DUSE_INT64 -DUSE_ADDR64 -I VAX -I ${PDP11D} ${NETWORK_OPT} + + +VAX780 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax780_stddev.c ${VAXD}/vax780_sbi.c \ + ${VAXD}/vax780_mem.c ${VAXD}/vax780_uba.c ${VAXD}/vax7x0_mba.c \ + ${VAXD}/vax780_fload.c ${VAXD}/vax780_syslist.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xu.c ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_rp.c ${PDP11D}/pdp11_tu.c ${PDP11D}/pdp11_hk.c \ + ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_dmc.c ${PDP11D}/pdp11_dup.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_tc.c ${PDP11D}/pdp11_rk.c \ + ${PDP11D}/pdp11_io_lib.c +VAX780_OPT = -DVM_VAX -DVAX_780 -DUSE_INT64 -DUSE_ADDR64 -I VAX -I ${PDP11D} ${NETWORK_OPT} + + +VAX8600 = ${VAXD}/vax_cpu.c ${VAXD}/vax_cpu1.c ${VAXD}/vax_fpa.c \ + ${VAXD}/vax_cis.c ${VAXD}/vax_octa.c ${VAXD}/vax_cmode.c \ + ${VAXD}/vax_mmu.c ${VAXD}/vax_sys.c ${VAXD}/vax_syscm.c \ + ${VAXD}/vax860_stddev.c ${VAXD}/vax860_sbia.c \ + ${VAXD}/vax860_abus.c ${VAXD}/vax780_uba.c ${VAXD}/vax7x0_mba.c \ + ${VAXD}/vax860_syslist.c \ + ${PDP11D}/pdp11_rl.c ${PDP11D}/pdp11_rq.c ${PDP11D}/pdp11_ts.c \ + ${PDP11D}/pdp11_dz.c ${PDP11D}/pdp11_lp.c ${PDP11D}/pdp11_tq.c \ + ${PDP11D}/pdp11_xu.c ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_rp.c ${PDP11D}/pdp11_tu.c ${PDP11D}/pdp11_hk.c \ + ${PDP11D}/pdp11_vh.c ${PDP11D}/pdp11_dmc.c ${PDP11D}/pdp11_dup.c \ + ${PDP11D}/pdp11_td.c ${PDP11D}/pdp11_tc.c ${PDP11D}/pdp11_rk.c \ + ${PDP11D}/pdp11_io_lib.c +VAX8600_OPT = -DVM_VAX -DVAX_860 -DUSE_INT64 -DUSE_ADDR64 -I VAX -I ${PDP11D} ${NETWORK_OPT} + + +PDP10D = PDP10 +PDP10 = ${PDP10D}/pdp10_fe.c ${PDP11D}/pdp11_dz.c ${PDP10D}/pdp10_cpu.c \ + ${PDP10D}/pdp10_ksio.c ${PDP10D}/pdp10_lp20.c ${PDP10D}/pdp10_mdfp.c \ + ${PDP10D}/pdp10_pag.c ${PDP10D}/pdp10_rp.c ${PDP10D}/pdp10_sys.c \ + ${PDP10D}/pdp10_tim.c ${PDP10D}/pdp10_tu.c ${PDP10D}/pdp10_xtnd.c \ + ${PDP11D}/pdp11_pt.c ${PDP11D}/pdp11_ry.c ${PDP11D}/pdp11_cr.c \ + ${PDP11D}/pdp11_dup.c ${PDP11D}/pdp11_dmc.c ${PDP11D}/pdp11_kmc.c \ + ${PDP11D}/pdp11_xu.c +PDP10_OPT = -DVM_PDP10 -DUSE_INT64 -I ${PDP10D} -I ${PDP11D} ${NETWORK_OPT} + + +KA10D = PDP10 +KA10 = ${KA10D}/ka10_cpu.c ${KA10D}/ka10_sys.c ${KA10D}/ka10_df.c \ + ${KA10D}/ka10_dp.c ${KA10D}/ka10_mt.c ${KA10D}/ka10_cty.c \ + ${KA10D}/ka10_lp.c ${KA10D}/ka10_pt.c ${KA10D}/ka10_dc.c \ + ${KA10D}/ka10_rp.c ${KA10D}/ka10_rc.c ${KA10D}/ka10_dt.c +KA10_OPT = -DKA=1 -DUSE_INT64 -I $(KA10D) + + +KI10D = PDP10 +KI10 = ${KA10D}/ka10_cpu.c ${KA10D}/ka10_sys.c ${KA10D}/ka10_df.c \ + ${KA10D}/ka10_dp.c ${KA10D}/ka10_mt.c ${KA10D}/ka10_cty.c \ + ${KA10D}/ka10_lp.c ${KA10D}/ka10_pt.c ${KA10D}/ka10_dc.c \ + ${KA10D}/ka10_rp.c ${KA10D}/ka10_rc.c ${KA10D}/ka10_dt.c +KI10_OPT = -DKI=1 -DUSE_INT64 -I $(KA10D) + + +PDP8D = PDP8 +PDP8 = ${PDP8D}/pdp8_cpu.c ${PDP8D}/pdp8_clk.c ${PDP8D}/pdp8_df.c \ + ${PDP8D}/pdp8_dt.c ${PDP8D}/pdp8_lp.c ${PDP8D}/pdp8_mt.c \ + ${PDP8D}/pdp8_pt.c ${PDP8D}/pdp8_rf.c ${PDP8D}/pdp8_rk.c \ + ${PDP8D}/pdp8_rx.c ${PDP8D}/pdp8_sys.c ${PDP8D}/pdp8_tt.c \ + ${PDP8D}/pdp8_ttx.c ${PDP8D}/pdp8_rl.c ${PDP8D}/pdp8_tsc.c \ + ${PDP8D}/pdp8_td.c ${PDP8D}/pdp8_ct.c ${PDP8D}/pdp8_fpp.c +PDP8_OPT = -I ${PDP8D} + + +H316D = H316 +H316 = ${H316D}/h316_stddev.c ${H316D}/h316_lp.c ${H316D}/h316_cpu.c \ + ${H316D}/h316_sys.c ${H316D}/h316_mt.c ${H316D}/h316_fhd.c \ + ${H316D}/h316_dp.c ${H316D}/h316_rtc.c ${H316D}/h316_imp.c \ + ${H316D}/h316_hi.c ${H316D}/h316_mi.c ${H316D}/h316_udp.c +H316_OPT = -I ${H316D} -D VM_IMPTIP + + +HP2100D = HP2100 +HP2100 = ${HP2100D}/hp2100_stddev.c ${HP2100D}/hp2100_dp.c ${HP2100D}/hp2100_dq.c \ + ${HP2100D}/hp2100_dr.c ${HP2100D}/hp2100_lps.c ${HP2100D}/hp2100_ms.c \ + ${HP2100D}/hp2100_mt.c ${HP2100D}/hp2100_mux.c ${HP2100D}/hp2100_cpu.c \ + ${HP2100D}/hp2100_fp.c ${HP2100D}/hp2100_sys.c ${HP2100D}/hp2100_lpt.c \ + ${HP2100D}/hp2100_ipl.c ${HP2100D}/hp2100_ds.c ${HP2100D}/hp2100_cpu0.c \ + ${HP2100D}/hp2100_cpu1.c ${HP2100D}/hp2100_cpu2.c ${HP2100D}/hp2100_cpu3.c \ + ${HP2100D}/hp2100_cpu4.c ${HP2100D}/hp2100_cpu5.c ${HP2100D}/hp2100_cpu6.c \ + ${HP2100D}/hp2100_cpu7.c ${HP2100D}/hp2100_fp1.c ${HP2100D}/hp2100_baci.c \ + ${HP2100D}/hp2100_mpx.c ${HP2100D}/hp2100_pif.c ${HP2100D}/hp2100_di.c \ + ${HP2100D}/hp2100_di_da.c ${HP2100D}/hp2100_disclib.c +HP2100_OPT = -DHAVE_INT64 -I ${HP2100D} + +HP3000D = HP3000 +HP3000 = ${HP3000D}/hp_disclib.c ${HP3000D}/hp_tapelib.c ${HP3000D}/hp3000_atc.c \ + ${HP3000D}/hp3000_clk.c ${HP3000D}/hp3000_cpu.c ${HP3000D}/hp3000_cpu_base.c \ + ${HP3000D}/hp3000_cpu_fp.c ${HP3000D}/hp3000_ds.c ${HP3000D}/hp3000_iop.c \ + ${HP3000D}/hp3000_mpx.c ${HP3000D}/hp3000_ms.c \ + ${HP3000D}/hp3000_scmb.c ${HP3000D}/hp3000_sel.c ${HP3000D}/hp3000_sys.c +HP3000_OPT = -I ${HP3000D} + + +I1401D = I1401 +I1401 = ${I1401D}/i1401_lp.c ${I1401D}/i1401_cpu.c ${I1401D}/i1401_iq.c \ + ${I1401D}/i1401_cd.c ${I1401D}/i1401_mt.c ${I1401D}/i1401_dp.c \ + ${I1401D}/i1401_sys.c +I1401_OPT = -I ${I1401D} + + +I1620D = I1620 +I1620 = ${I1620D}/i1620_cd.c ${I1620D}/i1620_dp.c ${I1620D}/i1620_pt.c \ + ${I1620D}/i1620_tty.c ${I1620D}/i1620_cpu.c ${I1620D}/i1620_lp.c \ + ${I1620D}/i1620_fp.c ${I1620D}/i1620_sys.c +I1620_OPT = -I ${I1620D} + + +I7094D = I7094 +I7094 = ${I7094D}/i7094_cpu.c ${I7094D}/i7094_cpu1.c ${I7094D}/i7094_io.c \ + ${I7094D}/i7094_cd.c ${I7094D}/i7094_clk.c ${I7094D}/i7094_com.c \ + ${I7094D}/i7094_drm.c ${I7094D}/i7094_dsk.c ${I7094D}/i7094_sys.c \ + ${I7094D}/i7094_lp.c ${I7094D}/i7094_mt.c ${I7094D}/i7094_binloader.c +I7094_OPT = -DUSE_INT64 -I ${I7094D} + + +IBM1130D = Ibm1130 +IBM1130 = ${IBM1130D}/ibm1130_cpu.c ${IBM1130D}/ibm1130_cr.c \ + ${IBM1130D}/ibm1130_disk.c ${IBM1130D}/ibm1130_stddev.c \ + ${IBM1130D}/ibm1130_sys.c ${IBM1130D}/ibm1130_gdu.c \ + ${IBM1130D}/ibm1130_gui.c ${IBM1130D}/ibm1130_prt.c \ + ${IBM1130D}/ibm1130_fmt.c ${IBM1130D}/ibm1130_ptrp.c \ + ${IBM1130D}/ibm1130_plot.c ${IBM1130D}/ibm1130_sca.c \ + ${IBM1130D}/ibm1130_t2741.c +IBM1130_OPT = -I ${IBM1130D} +ifneq ($(WIN32),) +IBM1130_OPT += -DGUI_SUPPORT -lgdi32 +endif + + +ID16D = Interdata +ID16 = ${ID16D}/id16_cpu.c ${ID16D}/id16_sys.c ${ID16D}/id_dp.c \ + ${ID16D}/id_fd.c ${ID16D}/id_fp.c ${ID16D}/id_idc.c ${ID16D}/id_io.c \ + ${ID16D}/id_lp.c ${ID16D}/id_mt.c ${ID16D}/id_pas.c ${ID16D}/id_pt.c \ + ${ID16D}/id_tt.c ${ID16D}/id_uvc.c ${ID16D}/id16_dboot.c ${ID16D}/id_ttp.c +ID16_OPT = -I ${ID16D} + + +ID32D = Interdata +ID32 = ${ID32D}/id32_cpu.c ${ID32D}/id32_sys.c ${ID32D}/id_dp.c \ + ${ID32D}/id_fd.c ${ID32D}/id_fp.c ${ID32D}/id_idc.c ${ID32D}/id_io.c \ + ${ID32D}/id_lp.c ${ID32D}/id_mt.c ${ID32D}/id_pas.c ${ID32D}/id_pt.c \ + ${ID32D}/id_tt.c ${ID32D}/id_uvc.c ${ID32D}/id32_dboot.c ${ID32D}/id_ttp.c +ID32_OPT = -I ${ID32D} + + +S3D = S3 +S3 = ${S3D}/s3_cd.c ${S3D}/s3_cpu.c ${S3D}/s3_disk.c ${S3D}/s3_lp.c \ + ${S3D}/s3_pkb.c ${S3D}/s3_sys.c +S3_OPT = -I ${S3D} + + +ALTAIRD = ALTAIR +ALTAIR = ${ALTAIRD}/altair_sio.c ${ALTAIRD}/altair_cpu.c ${ALTAIRD}/altair_dsk.c \ + ${ALTAIRD}/altair_sys.c +ALTAIR_OPT = -I ${ALTAIRD} + + +ALTAIRZ80D = AltairZ80 +ALTAIRZ80 = ${ALTAIRZ80D}/altairz80_cpu.c ${ALTAIRZ80D}/altairz80_cpu_nommu.c \ + ${ALTAIRZ80D}/altairz80_dsk.c ${ALTAIRZ80D}/disasm.c \ + ${ALTAIRZ80D}/altairz80_sio.c ${ALTAIRZ80D}/altairz80_sys.c \ + ${ALTAIRZ80D}/altairz80_hdsk.c ${ALTAIRZ80D}/altairz80_net.c \ + ${ALTAIRZ80D}/flashwriter2.c ${ALTAIRZ80D}/i86_decode.c \ + ${ALTAIRZ80D}/i86_ops.c ${ALTAIRZ80D}/i86_prim_ops.c \ + ${ALTAIRZ80D}/i8272.c ${ALTAIRZ80D}/insnsd.c ${ALTAIRZ80D}/altairz80_mhdsk.c \ + ${ALTAIRZ80D}/mfdc.c ${ALTAIRZ80D}/n8vem.c ${ALTAIRZ80D}/vfdhd.c \ + ${ALTAIRZ80D}/s100_disk1a.c ${ALTAIRZ80D}/s100_disk2.c ${ALTAIRZ80D}/s100_disk3.c \ + ${ALTAIRZ80D}/s100_fif.c ${ALTAIRZ80D}/s100_mdriveh.c \ + ${ALTAIRZ80D}/s100_mdsa.c \ + ${ALTAIRZ80D}/s100_mdsad.c ${ALTAIRZ80D}/s100_selchan.c \ + ${ALTAIRZ80D}/s100_ss1.c ${ALTAIRZ80D}/s100_64fdc.c \ + ${ALTAIRZ80D}/s100_scp300f.c \ + ${ALTAIRZ80D}/wd179x.c ${ALTAIRZ80D}/s100_hdc1001.c \ + ${ALTAIRZ80D}/s100_if3.c ${ALTAIRZ80D}/s100_adcs6.c \ + ${ALTAIRZ80D}/m68kcpu.c ${ALTAIRZ80D}/m68kdasm.c \ + ${ALTAIRZ80D}/m68kopac.c ${ALTAIRZ80D}/m68kopdm.c \ + ${ALTAIRZ80D}/m68kopnz.c ${ALTAIRZ80D}/m68kops.c ${ALTAIRZ80D}/m68ksim.c +ALTAIRZ80_OPT = -I ${ALTAIRZ80D} -DUSE_SIM_IMD + + +GRID = GRI +GRI = ${GRID}/gri_cpu.c ${GRID}/gri_stddev.c ${GRID}/gri_sys.c +GRI_OPT = -I ${GRID} + + +LGPD = LGP +LGP = ${LGPD}/lgp_cpu.c ${LGPD}/lgp_stddev.c ${LGPD}/lgp_sys.c +LGP_OPT = -I ${LGPD} + + +SDSD = SDS +SDS = ${SDSD}/sds_cpu.c ${SDSD}/sds_drm.c ${SDSD}/sds_dsk.c ${SDSD}/sds_io.c \ + ${SDSD}/sds_lp.c ${SDSD}/sds_mt.c ${SDSD}/sds_mux.c ${SDSD}/sds_rad.c \ + ${SDSD}/sds_stddev.c ${SDSD}/sds_sys.c +SDS_OPT = -I ${SDSD} + + +SWTP6800D = swtp6800/swtp6800 +SWTP6800C = swtp6800/common +SWTP6800MP-A = ${SWTP6800C}/mp-a.c ${SWTP6800C}/m6800.c ${SWTP6800C}/m6810.c \ + ${SWTP6800C}/bootrom.c ${SWTP6800C}/dc-4.c ${SWTP6800C}/mp-s.c ${SWTP6800D}/mp-a_sys.c \ + ${SWTP6800C}/mp-b2.c ${SWTP6800C}/mp-8m.c +SWTP6800MP-A2 = ${SWTP6800C}/mp-a2.c ${SWTP6800C}/m6800.c ${SWTP6800C}/m6810.c \ + ${SWTP6800C}/bootrom.c ${SWTP6800C}/dc-4.c ${SWTP6800C}/mp-s.c ${SWTP6800D}/mp-a2_sys.c \ + ${SWTP6800C}/mp-b2.c ${SWTP6800C}/mp-8m.c ${SWTP6800C}/i2716.c +SWTP6800_OPT = -I ${SWTP6800D} + + +ISYS8010D = Intel-Systems/isys8010 +ISYS8010C = Intel-Systems/common +ISYS8010 = ${ISYS8010C}/i8080.c ${ISYS8010D}/isys8010_sys.c \ + ${ISYS8010C}/i8251.c ${ISYS8010C}/i8255.c \ + ${ISYS8010C}/ieprom.c ${ISYS8010C}/iram8.c \ + ${ISYS8010C}/multibus.c ${ISYS8010C}/isbc80-10.c \ + ${ISYS8010C}/isbc064.c ${ISYS8010C}/isbc208.c +ISYS8010_OPT = -I ${ISYS8010D} + + +ISYS8020D = Intel-Systems/isys8020 +ISYS8020C = Intel-Systems/common +ISYS8020 = ${ISYS8020C}/i8080.c ${ISYS8020D}/isys8020_sys.c \ + ${ISYS8020C}/i8251.c ${ISYS8020C}/i8255.c \ + ${ISYS8020C}/ieprom.c ${ISYS8020C}/iram8.c \ + ${ISYS8020C}/multibus.c ${ISYS8020C}/isbc80-20.c \ + ${ISYS8020C}/isbc064.c ${ISYS8020C}/isbc208.c \ + ${ISYS8020C}/i8259.c +ISYS8020_OPT = -I ${ISYS8020D} + + +TX0D = TX-0 +TX0 = ${TX0D}/tx0_cpu.c ${TX0D}/tx0_dpy.c ${TX0D}/tx0_stddev.c \ + ${TX0D}/tx0_sys.c ${TX0D}/tx0_sys_orig.c ${DISPLAYL} +TX0_OPT = -I ${TX0D} $(DISPLAY_OPT) + + +SSEMD = SSEM +SSEM = ${SSEMD}/ssem_cpu.c ${SSEMD}/ssem_sys.c +SSEM_OPT = -I ${SSEMD} + +B5500D = B5500 +B5500 = ${B5500D}/b5500_cpu.c ${B5500D}/b5500_io.c ${B5500D}/b5500_sys.c \ + ${B5500D}/b5500_dk.c ${B5500D}/b5500_mt.c ${B5500D}/b5500_urec.c \ + ${B5500D}/b5500_dr.c ${B5500D}/b5500_dtc.c +B5500_OPT = -I.. -DUSE_INT64 -DB5500 -DUSE_SIM_CARD + +### +### Experimental simulators +### + +BESM6D = BESM6 +BESM6 = ${BESM6D}/besm6_cpu.c ${BESM6D}/besm6_sys.c ${BESM6D}/besm6_mmu.c \ + ${BESM6D}/besm6_arith.c ${BESM6D}/besm6_disk.c ${BESM6D}/besm6_drum.c \ + ${BESM6D}/besm6_tty.c ${BESM6D}/besm6_panel.c ${BESM6D}/besm6_printer.c \ + ${BESM6D}/besm6_punch.c + +ifneq (,$(and ${VIDEO_LDFLAGS}, $(BESM6_BUILD))) + ifeq (,${FONTFILE}) + FONTPATH += /usr/share/fonts /Library/Fonts /usr/lib/jvm /System/Library/Frameworks/JavaVM.framework/Versions C:/Windows/Fonts + FONTPATH := $(dir $(foreach dir,$(strip $(FONTPATH)),$(wildcard $(dir)/.))) + FONTNAME += DejaVuSans.ttf LucidaSansRegular.ttf FreeSans.ttf AppleGothic.ttf tahoma.ttf + $(info font paths are: $(FONTPATH)) + $(info font names are: $(FONTNAME)) + find_fontfile = $(strip $(firstword $(foreach dir,$(strip $(FONTPATH)),$(wildcard $(dir)/$(1))$(wildcard $(dir)/*/$(1))$(wildcard $(dir)/*/*/$(1))$(wildcard $(dir)/*/*/*/$(1))))) + find_font = $(abspath $(strip $(firstword $(foreach font,$(strip $(FONTNAME)),$(call find_fontfile,$(font)))))) + ifneq (,$(call find_font)) + FONTFILE=$(call find_font) + else + $(info ***) + $(info *** No font file available, BESM-6 video panel disabled.) + $(info ***) + $(info *** To enable the panel display please specify one of:) + $(info *** a font path with FONTNAME=path) + $(info *** a font name with FONTNAME=fontname.ttf) + $(info *** a font file with FONTFILE=path/fontname.ttf) + $(info ***) + endif + endif +endif +ifeq (,$(and ${VIDEO_LDFLAGS}, ${FONTFILE})) + BESM6_OPT = -I ${BESM6D} -DUSE_INT64 +else ifneq (,$(and $(findstring SDL2,${VIDEO_LDFLAGS}),$(call find_include,SDL2/SDL_ttf),$(call find_lib,SDL2_ttf))) + $(info using libSDL2_ttf: $(call find_lib,SDL2_ttf) $(call find_include,SDL2/SDL_ttf)) + $(info ***) + BESM6_OPT = -I ${BESM6D} -DFONTFILE=${FONTFILE} -DUSE_INT64 ${VIDEO_CCDEFS} ${VIDEO_LDFLAGS} -lSDL2_ttf +else ifneq (,$(and $(call find_include,SDL/SDL_ttf),$(call find_lib,SDL_ttf))) + $(info using libSDL_ttf: $(call find_lib,SDL_ttf) $(call find_include,SDL/SDL_ttf)) + $(info ***) + BESM6_OPT = -I ${BESM6D} -DFONTFILE=${FONTFILE} -DUSE_INT64 ${VIDEO_CCDEFS} ${VIDEO_LDFLAGS} -lSDL_ttf +else + BESM6_OPT = -I ${BESM6D} -DUSE_INT64 +endif + +### +### Unsupported/Incomplete simulators +### + +SIGMAD = sigma +SIGMA = ${SIGMAD}/sigma_cpu.c ${SIGMAD}/sigma_sys.c ${SIGMAD}/sigma_cis.c \ + ${SIGMAD}/sigma_coc.c ${SIGMAD}/sigma_dk.c ${SIGMAD}/sigma_dp.c \ + ${SIGMAD}/sigma_fp.c ${SIGMAD}/sigma_io.c ${SIGMAD}/sigma_lp.c \ + ${SIGMAD}/sigma_map.c ${SIGMAD}/sigma_mt.c ${SIGMAD}/sigma_pt.c \ + ${SIGMAD}/sigma_rad.c ${SIGMAD}/sigma_rtc.c ${SIGMAD}/sigma_tt.c +SIGMA_OPT = -I ${SIGMAD} + +ALPHAD = alpha +ALPHA = ${ALPHAD}/alpha_500au_syslist.c ${ALPHAD}/alpha_cpu.c \ + ${ALPHAD}/alpha_ev5_cons.c ${ALPHAD}/alpha_ev5_pal.c \ + ${ALPHAD}/alpha_ev5_tlb.c ${ALPHAD}/alpha_fpi.c \ + ${ALPHAD}/alpha_fpv.c ${ALPHAD}/alpha_io.c \ + ${ALPHAD}/alpha_mmu.c ${ALPHAD}/alpha_sys.c +ALPHA_OPT = -I ${ALPHAD} -DUSE_ADDR64 -DUSE_INT64 + +SAGED = SAGE +SAGE = ${SAGED}/sage_cpu.c ${SAGED}/sage_sys.c ${SAGED}/sage_stddev.c \ + ${SAGED}/sage_cons.c ${SAGED}/sage_fd.c ${SAGED}/sage_lp.c \ + ${SAGED}/m68k_cpu.c ${SAGED}/m68k_mem.c ${SAGED}/m68k_scp.c \ + ${SAGED}/m68k_parse.tab.c ${SAGED}/m68k_sys.c \ + ${SAGED}/i8251.c ${SAGED}/i8253.c ${SAGED}/i8255.c ${SAGED}/i8259.c ${SAGED}/i8272.c +SAGE_OPT = -I ${SAGED} -DHAVE_INT64 -DUSE_SIM_IMD + +PDQ3D = PDQ-3 +PDQ3 = ${PDQ3D}/pdq3_cpu.c ${PDQ3D}/pdq3_sys.c ${PDQ3D}/pdq3_stddev.c \ + ${PDQ3D}/pdq3_mem.c ${PDQ3D}/pdq3_debug.c ${PDQ3D}/pdq3_fdc.c +PDQ3_OPT = -I ${PDQ3D} -DUSE_SIM_IMD + +# +# Emulator source files and compile time options +# +I7000D = I7000 +I7090 = ${I7000D}/i7090_cpu.c ${I7000D}/i7090_sys.c ${I7000D}/i7090_chan.c \ + ${I7000D}/i7090_cdr.c ${I7000D}/i7090_cdp.c ${I7000D}/i7090_lpr.c \ + ${I7000D}/i7000_chan.c ${I7000D}/i7000_mt.c ${I7000D}/i7090_drum.c \ + ${I7000D}/i7090_hdrum.c ${I7000D}/i7000_chron.c ${I7000D}/i7000_dsk.c \ + ${I7000D}/i7000_com.c ${I7000D}/i7000_ht.c +I7090_OPT = -I $(I7000D) -DUSE_INT64 -DI7090 -DUSE_SIM_CARD + +I7080D = I7000 +I7080 = ${I7000D}/i7080_cpu.c ${I7000D}/i7080_sys.c ${I7000D}/i7080_chan.c \ + ${I7000D}/i7080_drum.c ${I7000D}/i7000_cdp.c ${I7000D}/i7000_cdr.c \ + ${I7000D}/i7000_con.c ${I7000D}/i7000_chan.c ${I7000D}/i7000_lpr.c \ + ${I7000D}/i7000_mt.c ${I7000D}/i7000_chron.c ${I7000D}/i7000_dsk.c \ + ${I7000D}/i7000_com.c ${I7000D}/i7000_ht.c +I7080_OPT = -I $(I7000D) -DI7080 -DUSE_SIM_CARD + +I7070D = I7000 +I7070 = ${I7000D}/i7070_cpu.c ${I7000D}/i7070_sys.c ${I7000D}/i7070_chan.c \ + ${I7000D}/i7000_cdp.c ${I7000D}/i7000_cdr.c ${I7000D}/i7000_con.c \ + ${I7000D}/i7000_chan.c ${I7000D}/i7000_lpr.c ${I7000D}/i7000_mt.c \ + ${I7000D}/i7000_chron.c ${I7000D}/i7000_dsk.c ${I7000D}/i7000_com.c \ + ${I7000D}/i7000_ht.c +I7070_OPT = -I $(I7000D) -DUSE_INT64 -DI7070 -DUSE_SIM_CARD + +I7010D = I7000 +I7010 = ${I7000D}/i7010_cpu.c ${I7000D}/i7010_sys.c ${I7000D}/i7010_chan.c \ + ${I7000D}/i7000_cdp.c ${I7000D}/i7000_cdr.c ${I7000D}/i7000_con.c \ + ${I7000D}/i7000_chan.c ${I7000D}/i7000_lpr.c ${I7000D}/i7000_mt.c \ + ${I7000D}/i7000_chron.c ${I7000D}/i7000_dsk.c ${I7000D}/i7000_com.c \ + ${I7000D}/i7000_ht.c +I7010_OPT = -I $(I7010D) -DI7010 -DUSE_SIM_CARD + +I704D = I7000 +I704 = ${I7000D}/i7090_cpu.c ${I7000D}/i7090_sys.c ${I7000D}/i7090_chan.c \ + ${I7000D}/i7090_cdr.c ${I7000D}/i7090_cdp.c ${I7000D}/i7090_lpr.c \ + ${I7000D}/i7000_mt.c ${I7000D}/i7090_drum.c ${I7000D}/i7000_chan.c +I704_OPT = -I $(I7000D) -DUSE_INT64 -DI704 -DUSE_SIM_CARD + + +I701D = I7000 +I701 = ${I7000D}/i701_cpu.c ${I7000D}/i701_sys.c ${I7000D}/i701_chan.c \ + ${I7000D}/i7090_cdr.c ${I7000D}/i7090_cdp.c ${I7000D}/i7090_lpr.c \ + ${I7000D}/i7000_mt.c ${I7000D}/i7090_drum.c ${I7000D}/i7000_chan.c +I701_OPT = -I $(I7000D) -DUSE_INT64 -DI701 -DUSE_SIM_CARD + + +# +# Build everything (not the unsupported/incomplete simulators) +# +ALL = pdp1 pdp4 pdp7 pdp8 pdp9 pdp15 pdp11 pdp10 \ + vax microvax3900 microvax1 rtvax1000 microvax2 vax730 vax750 vax780 vax8600 \ + nova eclipse hp2100 hp3000 i1401 i1620 s3 altair altairz80 gri \ + i7094 ibm1130 id16 id32 sds lgp h316 \ + swtp6800mp-a swtp6800mp-a2 tx-0 ssem isys8010 isys8020 \ + b5500 i7090 i7080 i7070 i7010 i704 i701 pdp10-ka pdp10-ki + + +all : ${ALL} + +clean : +ifeq ($(WIN32),) + ${RM} -r ${BIN} +else + if exist BIN\*.exe del /q BIN\*.exe + if exist BIN rmdir BIN +endif + +${BIN}BuildROMs${EXE} : + ${MKDIRBIN} +ifeq (agcc,$(findstring agcc,$(firstword $(CC)))) + gcc $(wordlist 2,1000,${CC}) sim_BuildROMs.c $(CC_OUTSPEC) +else + ${CC} sim_BuildROMs.c $(CC_OUTSPEC) +endif +ifeq ($(WIN32),) + $@ + ${RM} $@ + ifeq (Darwin,$(OSTYPE)) # remove Xcode's debugging symbols folder too + ${RM} -rf $@.dSYM + endif +else + $(@D)\$(@F) + del $(@D)\$(@F) +endif + +# +# Individual builds +# +pdp1 : ${BIN}pdp1${EXE} + +${BIN}pdp1${EXE} : ${PDP1} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP1} ${SIM} ${PDP1_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp4 : ${BIN}pdp4${EXE} + +${BIN}pdp4${EXE} : ${PDP18B} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP18B} ${SIM} ${PDP4_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp7 : ${BIN}pdp7${EXE} + +${BIN}pdp7${EXE} : ${PDP18B} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP18B} ${SIM} ${PDP7_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp8 : ${BIN}pdp8${EXE} + +${BIN}pdp8${EXE} : ${PDP8} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP8} ${SIM} ${PDP8_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp9 : ${BIN}pdp9${EXE} + +${BIN}pdp9${EXE} : ${PDP18B} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP18B} ${SIM} ${PDP9_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp15 : ${BIN}pdp15${EXE} + +${BIN}pdp15${EXE} : ${PDP18B} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP18B} ${SIM} ${PDP15_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdp10 : ${BIN}pdp10${EXE} + +${BIN}pdp10${EXE} : ${PDP10} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP10} ${SIM} ${PDP10_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +ka10 : pdp10-ka + +pdp10-ka : ${BIN}pdp10-ka${EXE} + +${BIN}pdp10-ka${EXE} : ${KA10} ${SIM} + ${MKDIRBIN} + ${CC} ${KA10} ${SIM} ${KA10_OPT} $(CC_OUTSPEC) ${LDFLAGS} +ifeq ($(WIN32),) + cp ${BIN}pdp10-ka${EXE} ${BIN}ka10${EXE} +else + copy $(@D)\pdp10-ka${EXE} $(@D)\ka10${EXE} +endif + +ki10 : pdp10-ki + +pdp10-ki : ${BIN}pdp10-ki${EXE} + +${BIN}pdp10-ki${EXE} : ${KI10} ${SIM} + ${MKDIRBIN} + ${CC} ${KA10} ${SIM} ${KI10_OPT} $(CC_OUTSPEC) ${LDFLAGS} +ifeq ($(WIN32),) + cp ${BIN}pdp10-ki${EXE} ${BIN}ki10${EXE} +else + copy $(@D)\pdp10-ki${EXE} $(@D)\ki10${EXE} +endif + +pdp11 : ${BIN}BuildROMs${EXE} ${BIN}pdp11${EXE} + +${BIN}pdp11${EXE} : ${PDP11} ${SIM} + ${MKDIRBIN} + ${CC} ${PDP11} ${SIM} ${PDP11_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +vax : microvax3900 + +microvax3900 : ${BIN}BuildROMs${EXE} ${BIN}microvax3900${EXE} + +${BIN}microvax3900${EXE} : ${VAX} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX} ${SIM} ${VAX_OPT} $(CC_OUTSPEC) ${LDFLAGS} +ifeq ($(WIN32),) + cp ${BIN}microvax3900${EXE} ${BIN}vax${EXE} +else + copy $(@D)\microvax3900${EXE} $(@D)\vax${EXE} +endif + +microvax1 : ${BIN}BuildROMs${EXE} ${BIN}microvax1${EXE} + +${BIN}microvax1${EXE} : ${VAX610} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX610} ${SIM} ${VAX610_OPT} -o $@ ${LDFLAGS} + +rtvax1000 : ${BIN}BuildROMs${EXE} ${BIN}rtvax1000${EXE} + +${BIN}rtvax1000${EXE} : ${VAX630} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX630} ${SIM} ${VAX620_OPT} -o $@ ${LDFLAGS} + +microvax2 : ${BIN}BuildROMs${EXE} ${BIN}microvax2${EXE} + +${BIN}microvax2${EXE} : ${VAX630} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX630} ${SIM} ${VAX630_OPT} -o $@ ${LDFLAGS} + +vax730 : ${BIN}BuildROMs${EXE} ${BIN}vax730${EXE} + +${BIN}vax730${EXE} : ${VAX730} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX730} ${SIM} ${VAX730_OPT} -o $@ ${LDFLAGS} + +vax750 : ${BIN}BuildROMs${EXE} ${BIN}vax750${EXE} + +${BIN}vax750${EXE} : ${VAX750} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX750} ${SIM} ${VAX750_OPT} -o $@ ${LDFLAGS} + +vax780 : ${BIN}BuildROMs${EXE} ${BIN}vax780${EXE} + +${BIN}vax780${EXE} : ${VAX780} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX780} ${SIM} ${VAX780_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +vax8600 : ${BIN}BuildROMs${EXE} ${BIN}vax8600${EXE} + +${BIN}vax8600${EXE} : ${VAX8600} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${VAX8600} ${SIM} ${VAX8600_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +nova : ${BIN}nova${EXE} + +${BIN}nova${EXE} : ${NOVA} ${SIM} + ${MKDIRBIN} + ${CC} ${NOVA} ${SIM} ${NOVA_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +eclipse : ${BIN}eclipse${EXE} + +${BIN}eclipse${EXE} : ${ECLIPSE} ${SIM} + ${MKDIRBIN} + ${CC} ${ECLIPSE} ${SIM} ${ECLIPSE_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +h316 : ${BIN}h316${EXE} + +${BIN}h316${EXE} : ${H316} ${SIM} + ${MKDIRBIN} + ${CC} ${H316} ${SIM} ${H316_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +hp2100 : ${BIN}hp2100${EXE} + +${BIN}hp2100${EXE} : ${HP2100} ${SIM} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} + ${CC} ${HP2100} ${SIM} ${HP2100_OPT} $(CC_OUTSPEC) ${LDFLAGS} +else + $(info hp2100 can't be built using C++) +endif + +hp3000 : ${BIN}hp3000${EXE} + +${BIN}hp3000${EXE} : ${HP3000} ${SIM} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} + ${CC} ${HP3000} ${SIM} ${HP3000_OPT} $(CC_OUTSPEC) ${LDFLAGS} +else + $(info hp3000 can't be built using C++) +endif + +i1401 : ${BIN}i1401${EXE} + +${BIN}i1401${EXE} : ${I1401} ${SIM} + ${MKDIRBIN} + ${CC} ${I1401} ${SIM} ${I1401_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i1620 : ${BIN}i1620${EXE} + +${BIN}i1620${EXE} : ${I1620} ${SIM} + ${MKDIRBIN} + ${CC} ${I1620} ${SIM} ${I1620_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i7094 : ${BIN}i7094${EXE} + +${BIN}i7094${EXE} : ${I7094} ${SIM} + ${MKDIRBIN} + ${CC} ${I7094} ${SIM} ${I7094_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +ibm1130 : ${BIN}ibm1130${EXE} + +${BIN}ibm1130${EXE} : ${IBM1130} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} +ifneq ($(WIN32),) + windres ${IBM1130D}/ibm1130.rc $(BIN)ibm1130.o + ${CC} ${IBM1130} ${SIM} ${IBM1130_OPT} $(BIN)ibm1130.o $(CC_OUTSPEC) ${LDFLAGS} + del BIN\ibm1130.o +else + ${CC} ${IBM1130} ${SIM} ${IBM1130_OPT} $(CC_OUTSPEC) ${LDFLAGS} +endif +else + $(info ibm1130 can't be built using C++) +endif + +s3 : ${BIN}s3${EXE} + +${BIN}s3${EXE} : ${S3} ${SIM} + ${MKDIRBIN} + ${CC} ${S3} ${SIM} ${S3_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +altair : ${BIN}altair${EXE} + +${BIN}altair${EXE} : ${ALTAIR} ${SIM} + ${MKDIRBIN} + ${CC} ${ALTAIR} ${SIM} ${ALTAIR_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +altairz80 : ${BIN}altairz80${EXE} + +${BIN}altairz80${EXE} : ${ALTAIRZ80} ${SIM} + ${MKDIRBIN} + ${CC} ${ALTAIRZ80} ${SIM} ${ALTAIRZ80_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +gri : ${BIN}gri${EXE} + +${BIN}gri${EXE} : ${GRI} ${SIM} + ${MKDIRBIN} + ${CC} ${GRI} ${SIM} ${GRI_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +lgp : ${BIN}lgp${EXE} + +${BIN}lgp${EXE} : ${LGP} ${SIM} + ${MKDIRBIN} + ${CC} ${LGP} ${SIM} ${LGP_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +id16 : ${BIN}id16${EXE} + +${BIN}id16${EXE} : ${ID16} ${SIM} + ${MKDIRBIN} + ${CC} ${ID16} ${SIM} ${ID16_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +id32 : ${BIN}id32${EXE} + +${BIN}id32${EXE} : ${ID32} ${SIM} + ${MKDIRBIN} + ${CC} ${ID32} ${SIM} ${ID32_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +sds : ${BIN}sds${EXE} + +${BIN}sds${EXE} : ${SDS} ${SIM} + ${MKDIRBIN} + ${CC} ${SDS} ${SIM} ${SDS_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +swtp6800mp-a : ${BIN}BuildROMs${EXE} ${BIN}swtp6800mp-a${EXE} + +${BIN}swtp6800mp-a${EXE} : ${SWTP6800MP-A} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${SWTP6800MP-A} ${SIM} ${SWTP6800_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +swtp6800mp-a2 : ${BIN}BuildROMs${EXE} ${BIN}swtp6800mp-a2${EXE} + +${BIN}swtp6800mp-a2${EXE} : ${SWTP6800MP-A2} ${SIM} ${BUILD_ROMS} + ${MKDIRBIN} + ${CC} ${SWTP6800MP-A2} ${SIM} ${SWTP6800_OPT} $(CC_OUTSPEC) ${LDFLAGS} + + +isys8010: ${BIN}isys8010${EXE} + +${BIN}isys8010${EXE} : ${ISYS8010} ${SIM} ${BUILD_ROMS} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} + ${CC} ${ISYS8010} ${SIM} ${ISYS8010_OPT} $(CC_OUTSPEC) ${LDFLAGS} +else + $(info isys8010 can't be built using C++) +endif + +isys8020: ${BIN}isys8020${EXE} + +${BIN}isys8020${EXE} : ${ISYS8020} ${SIM} ${BUILD_ROMS} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} + ${CC} ${ISYS8020} ${SIM} ${ISYS8020_OPT} $(CC_OUTSPEC) ${LDFLAGS} +else + $(info isys8020 can't be built using C++) +endif + +tx-0 : ${BIN}tx-0${EXE} + +${BIN}tx-0${EXE} : ${TX0} ${SIM} + ${MKDIRBIN} + ${CC} ${TX0} ${SIM} ${TX0_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +ssem : ${BIN}ssem${EXE} + +${BIN}ssem${EXE} : ${SSEM} ${SIM} + ${MKDIRBIN} + ${CC} ${SSEM} ${SIM} ${SSEM_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +besm6 : ${BIN}besm6${EXE} + +${BIN}besm6${EXE} : ${BESM6} ${SIM} +ifneq (1,$(CPP_BUILD)$(CPP_FORCE)) + ${MKDIRBIN} + ${CC} ${BESM6} ${SIM} ${BESM6_OPT} $(CC_OUTSPEC) ${LDFLAGS} +else + $(info besm6 can't be built using C++) +endif + +sigma : ${BIN}sigma${EXE} + +${BIN}sigma${EXE} : ${SIGMA} ${SIM} + ${MKDIRBIN} + ${CC} ${SIGMA} ${SIM} ${SIGMA_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +alpha : ${BIN}alpha${EXE} + +${BIN}alpha${EXE} : ${ALPHA} ${SIM} + ${MKDIRBIN} + ${CC} ${ALPHA} ${SIM} ${ALPHA_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +sage : ${BIN}sage${EXE} + +${BIN}sage${EXE} : ${SAGE} ${SIM} + ${MKDIRBIN} + ${CC} ${SAGE} ${SIM} ${SAGE_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +pdq3 : ${BIN}pdq3${EXE} + +${BIN}pdq3${EXE} : ${PDQ3} ${SIM} + ${MKDIRBIN} + ${CC} ${PDQ3} ${SIM} ${PDQ3_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +b5500 : $(BIN)b5500$(EXE) + +${BIN}b5500${EXE} : ${B5500} ${SIM} + ${MKDIRBIN} + ${CC} ${B5500} ${SIM} ${B5500_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i7090 : $(BIN)i7090$(EXE) + +${BIN}i7090${EXE} : ${I7090} ${SIM} + ${MKDIRBIN} + ${CC} ${I7090} ${SIM} ${I7090_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i7080 : $(BIN)i7080$(EXE) + +${BIN}i7080${EXE} : ${I7080} ${SIM} + ${MKDIRBIN} + ${CC} ${I7080} ${SIM} ${I7080_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i7070 : $(BIN)i7070$(EXE) + +${BIN}i7070${EXE} : ${I7070} ${SIM} + ${MKDIRBIN} + ${CC} ${I7070} ${SIM} ${I7070_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i7010 : $(BIN)i7010$(EXE) + +${BIN}i7010${EXE} : ${I7010} ${SIM} + ${MKDIRBIN} + ${CC} ${I7010} ${SIM} ${I7010_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i704 : $(BIN)i704$(EXE) + +${BIN}i704${EXE} : ${I704} ${SIM} + ${MKDIRBIN} + ${CC} ${I704} ${SIM} ${I704_OPT} $(CC_OUTSPEC) ${LDFLAGS} + +i701 : $(BIN)i701$(EXE) + +${BIN}i701${EXE} : ${I701} ${SIM} + ${MKDIRBIN} + ${CC} ${I701} ${SIM} ${I701_OPT} $(CC_OUTSPEC) ${LDFLAGS} + + +# Front Panel API Demo/Test program + +frontpaneltest : ${BIN}frontpaneltest${EXE} + +${BIN}frontpaneltest${EXE} : frontpanel/FrontPanelTest.c sim_sock.c sim_frontpanel.c + ${MKDIRBIN} + ${CC} frontpanel/FrontPanelTest.c sim_sock.c sim_frontpanel.c $(CC_OUTSPEC) ${LDFLAGS} + diff --git a/scp.c b/scp.c index d155ceb..cbbc45f 100644 --- a/scp.c +++ b/scp.c @@ -328,7 +328,6 @@ pthread_t sim_asynch_main_threadid; UNIT * volatile sim_asynch_queue; UNIT * volatile sim_wallclock_queue; UNIT * volatile sim_wallclock_entry; -UNIT * volatile sim_clock_cosched_queue[SIM_NTIMERS]; t_bool sim_asynch_enabled = TRUE; int32 sim_asynch_check; int32 sim_asynch_latency = 4000; /* 4 usec interrupt latency */ @@ -340,12 +339,12 @@ t_bool sim_asynch_enabled = FALSE; /* The per-simulator init routine is a weak global that defaults to NULL The other per-simulator pointers can be overrriden by the init routine */ -void (*sim_vm_init) (void); +WEAK void (*sim_vm_init) (void); char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream) = NULL; void (*sim_vm_post) (t_bool from_scp) = NULL; CTAB *sim_vm_cmd = NULL; void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr) = NULL; -t_addr (*sim_vm_parse_addr) (DEVICE *dptr, const char *cptr, const char **tptr) = NULL; +t_addr (*sim_vm_parse_addr) (DEVICE *dptr, CONST char *cptr, CONST char **tptr) = NULL; t_value (*sim_vm_pc_value) (void) = NULL; t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs) = NULL; t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason) = NULL; @@ -354,57 +353,57 @@ t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason) = NULL; /* Set and show command processors */ -t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat ssh_break (FILE *st, char *cptr, int32 flg); -t_stat show_cmd_fi (FILE *ofile, int32 flag, char *cptr); -t_stat show_config (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_queue (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_mod_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_log_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); +t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat ssh_break (FILE *st, const char *cptr, int32 flg); +t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr); +t_stat show_config (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_queue (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_mod_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_log_names (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); t_stat show_device (FILE *st, DEVICE *dptr, int32 flag); t_stat show_unit (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag); t_stat show_all_mods (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flg, int32 *toks); -t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr, char *cptr, int32 flag); +t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr, CONST char *cptr, int32 flag); t_stat sim_save (FILE *sfile); t_stat sim_rest (FILE *rfile); /* Breakpoint package */ t_stat sim_brk_init (void); -t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, char *act); +t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act); t_stat sim_brk_clr (t_addr loc, int32 sw); t_stat sim_brk_clrall (int32 sw); t_stat sim_brk_show (FILE *st, t_addr loc, int32 sw); t_stat sim_brk_showall (FILE *st, int32 sw); -char *sim_brk_getact (char *buf, int32 size); +CONST char *sim_brk_getact (char *buf, int32 size); void sim_brk_npc (uint32 cnt); BRKTAB *sim_brk_new (t_addr loc); FILE *stdnul; /* Command support routines */ -SCHTAB *get_rsearch (const char *cptr, int32 radix, SCHTAB *schptr); -SCHTAB *get_asearch (const char *cptr, int32 radix, SCHTAB *schptr); +SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr); +SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr); int32 test_search (t_value *val, SCHTAB *schptr); static const char *get_glyph_gen (const char *iptr, char *optr, char mchar, t_bool uc, t_bool quote, char escape_char); -int32 get_switches (char *cptr); -char *get_sim_sw (char *cptr); +int32 get_switches (const char *cptr); +CONST char *get_sim_sw (CONST char *cptr); t_stat get_aval (t_addr addr, DEVICE *dptr, UNIT *uptr); t_value get_rval (REG *rptr, uint32 idx); void put_rval (REG *rptr, uint32 idx, t_value val); @@ -414,43 +413,43 @@ void fprint_capac (FILE *st, DEVICE *dptr, UNIT *uptr); void fprint_sep (FILE *st, int32 *tokens); char *read_line (char *ptr, int32 size, FILE *stream); char *read_line_p (const char *prompt, char *ptr, int32 size, FILE *stream); -REG *find_reg_glob (const char *ptr, const char **optr, DEVICE **gdptr); +REG *find_reg_glob (CONST char *ptr, CONST char **optr, DEVICE **gdptr); char *sim_trim_endspc (char *cptr); /* Forward references */ -t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, char *cptr); +t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr); t_stat scp_detach_unit (DEVICE *dptr, UNIT *uptr); t_bool qdisable (DEVICE *dptr); t_stat attach_err (UNIT *uptr, t_stat stat); t_stat detach_all (int32 start_device, t_bool shutdown); -t_stat assign_device (DEVICE *dptr, char *cptr); +t_stat assign_device (DEVICE *dptr, const char *cptr); t_stat deassign_device (DEVICE *dptr); -t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, char *aptr); -t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, char *cptr, +t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr); +t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr, REG *lowr, REG *highr, uint32 lows, uint32 highs); t_stat ex_reg (FILE *ofile, t_value val, int32 flag, REG *rptr, uint32 idx); -t_stat dep_reg (int32 flag, char *cptr, REG *rptr, uint32 idx); -t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, char *cptr, +t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx); +t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr, t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr); t_stat ex_addr (FILE *ofile, int32 flag, t_addr addr, DEVICE *dptr, UNIT *uptr); -t_stat dep_addr (int32 flag, char *cptr, t_addr addr, DEVICE *dptr, +t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr, UNIT *uptr, int32 dfltinc); void fprint_fields (FILE *stream, t_value before, t_value after, BITFIELD* bitdefs); t_stat step_svc (UNIT *ptr); t_stat expect_svc (UNIT *ptr); t_stat shift_args (char *do_arg[], size_t arg_count); -t_stat set_on (int32 flag, char *cptr); -t_stat set_verify (int32 flag, char *cptr); -t_stat set_message (int32 flag, char *cptr); -t_stat set_quiet (int32 flag, char *cptr); -t_stat set_asynch (int32 flag, char *cptr); -t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat do_cmd_label (int32 flag, char *cptr, char *label); +t_stat set_on (int32 flag, CONST char *cptr); +t_stat set_verify (int32 flag, CONST char *cptr); +t_stat set_message (int32 flag, CONST char *cptr); +t_stat set_quiet (int32 flag, CONST char *cptr); +t_stat set_asynch (int32 flag, CONST char *cptr); +t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat do_cmd_label (int32 flag, CONST char *cptr, CONST char *label); void int_handler (int signal); -t_stat set_prompt (int32 flag, char *cptr); -t_stat sim_set_asynch (int32 flag, char *cptr); -t_stat sim_set_environment (int32 flag, char *cptr); +t_stat set_prompt (int32 flag, CONST char *cptr); +t_stat sim_set_asynch (int32 flag, CONST char *cptr); +t_stat sim_set_environment (int32 flag, CONST char *cptr); static const char *get_dbg_verb (uint32 dbits, DEVICE* dptr); /* Global data */ @@ -507,8 +506,8 @@ static int32 sim_do_depth = 0; static int32 sim_on_check[MAX_DO_NEST_LVL+1]; static char *sim_on_actions[MAX_DO_NEST_LVL+1][SCPE_MAX_ERR+1]; static char sim_do_filename[MAX_DO_NEST_LVL+1][CBUFSIZE]; -static char *sim_do_ocptr[MAX_DO_NEST_LVL+1]; -static char *sim_do_label[MAX_DO_NEST_LVL+1]; +static const char *sim_do_ocptr[MAX_DO_NEST_LVL+1]; +static const char *sim_do_label[MAX_DO_NEST_LVL+1]; t_stat sim_last_cmd_stat; /* Command Status */ @@ -1991,7 +1990,7 @@ else if (*argv[0]) { /* sim name arg? */ char *np; /* "path.ini" */ nbuf[0] = '"'; /* starting " */ strncpy (nbuf + 1, argv[0], PATH_MAX + 1); /* copy sim name */ - if ((np = match_ext (nbuf, "EXE"))) /* remove .exe */ + if ((np = (char *)match_ext (nbuf, "EXE"))) /* remove .exe */ *np = 0; strcat (nbuf, ".ini\""); /* add .ini" */ stat = do_cmd (-1, nbuf) & ~SCPE_NOMESSAGE; /* proc default cmd file */ @@ -2025,7 +2024,8 @@ return 0; t_stat process_stdin_commands (t_stat stat, char *argv[]) { -char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *cptr; +char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE]; +CONST char *cptr; t_stat stat_nomessage; CTAB *cmdp; @@ -2073,9 +2073,9 @@ return stat; /* Set prompt routine */ -t_stat set_prompt (int32 flag, char *cptr) +t_stat set_prompt (int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE]; +char gbuf[CBUFSIZE], *gptr; if ((!cptr) || (*cptr == '\0')) return SCPE_ARG; @@ -2084,9 +2084,9 @@ cptr = get_glyph_nc (cptr, gbuf, '"'); /* get quote delimited t if (gbuf[0] == '\0') { /* Token started with quote */ gbuf[sizeof (gbuf)-1] = '\0'; strncpy (gbuf, cptr, sizeof (gbuf)-1); - cptr = strchr (gbuf, '"'); - if (cptr) - *cptr = '\0'; + gptr = strchr (gbuf, '"'); + if (gptr) + *gptr = '\0'; } sim_prompt = (char *)realloc (sim_prompt, strlen (gbuf) + 2); /* nul terminator and trailing blank */ sprintf (sim_prompt, "%s ", gbuf); @@ -2108,7 +2108,7 @@ return cmdp; /* Exit command */ -t_stat exit_cmd (int32 flag, char *cptr) +t_stat exit_cmd (int32 flag, CONST char *cptr) { return SCPE_EXIT; } @@ -2190,7 +2190,7 @@ t_bool found = FALSE; t_bool all_unique = TRUE; size_t max_namelen = 0; DEVICE *tdptr; -const char *tptr; +CONST char *tptr; char *namebuf; char rangebuf[32]; @@ -2409,13 +2409,13 @@ void fprint_show_help (FILE *st, DEVICE *dptr) fprint_show_help_ex (st, dptr, TRUE); } -t_stat help_dev_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat help_dev_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) { char gbuf[CBUFSIZE]; CTAB *cmdp; if (*cptr) { - char *gptr = get_glyph (cptr, gbuf, 0); + const char *gptr = get_glyph (cptr, gbuf, 0); if ((cmdp = find_cmd (gbuf))) { if (cmdp->action == &exdep_cmd) { if (dptr->help) /* Shouldn't this pass cptr so the device knows which command invoked? */ @@ -2481,7 +2481,7 @@ switch (help[0]) { return SCPE_OK; } -t_stat help_cmd (int32 flag, char *cptr) +t_stat help_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; CTAB *cmdp; @@ -2607,7 +2607,7 @@ return SCPE_OK; /* Spawn command */ -t_stat spawn_cmd (int32 flag, char *cptr) +t_stat spawn_cmd (int32 flag, CONST char *cptr) { t_stat status; if ((cptr == NULL) || (strlen (cptr) == 0)) @@ -2633,7 +2633,7 @@ return status; /* Screenshot command */ -t_stat screenshot_cmd (int32 flag, char *cptr) +t_stat screenshot_cmd (int32 flag, CONST char *cptr) { if ((cptr == NULL) || (strlen (cptr) == 0)) return SCPE_ARG; @@ -2647,7 +2647,7 @@ return SCPE_UNK|SCPE_NOMESSAGE; /* Echo command */ -t_stat echo_cmd (int32 flag, char *cptr) +t_stat echo_cmd (int32 flag, CONST char *cptr) { sim_printf ("%s\n", cptr); return SCPE_OK; @@ -2679,7 +2679,7 @@ return SCPE_OK; >1 = nested "DO" command */ -t_stat do_cmd (int32 flag, char *fcptr) +t_stat do_cmd (int32 flag, CONST char *fcptr) { return do_cmd_label (flag, fcptr, NULL); } @@ -2692,9 +2692,10 @@ sprintf (cbuf, "%s%s%s-%d", sim_do_filename[sim_do_depth], sim_do_label[sim_do_d return cbuf; } -t_stat do_cmd_label (int32 flag, char *fcptr, char *label) +t_stat do_cmd_label (int32 flag, CONST char *fcptr, CONST char *label) { -char *cptr, cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *c, quote, *do_arg[11]; +char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], abuf[4*CBUFSIZE], quote, *c, *do_arg[11]; +CONST char *cptr; FILE *fpin; CTAB *cmdp = NULL; int32 echo, nargs, errabort, i; @@ -2715,7 +2716,9 @@ sim_on_inherit =(sim_switches & SWMASK ('O')) || sim_on_inherit; /* -o means inh errabort = sim_switches & SWMASK ('E'); /* -e means abort on error */ -c = fcptr; +abuf[sizeof(abuf)-1] = '\0'; +strncpy (abuf, fcptr, sizeof(abuf)-1); +c = abuf; do_arg[10] = NULL; /* make sure the argument list always ends with a NULL */ for (nargs = 0; nargs < 10; ) { /* extract arguments */ while (sim_isspace (*c)) /* skip blanks */ @@ -2947,7 +2950,8 @@ return stat | SCPE_NOMESSAGE; /* suppress message sinc void sim_sub_args (char *instr, size_t instr_size, char *do_arg[]) { char gbuf[CBUFSIZE]; -char *ip = instr, *op, *ap, *oend, *istart, *tmpbuf; +char *ip = instr, *op, *oend, *istart, *tmpbuf; +const char *ap; char rbuf[CBUFSIZE]; int i; time_t now; @@ -3245,27 +3249,28 @@ return 1; >= - greater than or equal GEQ - greater than or equal */ -t_stat assert_cmd (int32 flag, char *cptr) +t_stat assert_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE], gbuf2[CBUFSIZE]; -const char *tptr, *gptr; +CONST char *tptr, *gptr; REG *rptr; uint32 idx; t_value val; t_stat r; -t_bool not = FALSE; +t_bool Not = FALSE; t_bool result; t_addr addr; t_stat reason; -cptr = get_sim_opt (CMD_OPT_SW|CMD_OPT_DFT, cptr, &r); /* get sw, default */ +cptr = (CONST char *)get_sim_opt (CMD_OPT_SW|CMD_OPT_DFT, (CONST char *)cptr, &r); + /* get sw, default */ sim_stabr.boolop = sim_staba.boolop = -1; /* no relational op dflt */ if (*cptr == 0) /* must be more */ return SCPE_2FARG; tptr = get_glyph (cptr, gbuf, 0); /* get token */ if (!strcmp (gbuf, "NOT")) { /* Conditional Inversion? */ - not = TRUE; /* remember that, and */ - cptr = (char *)tptr; + Not = TRUE; /* remember that, and */ + cptr = (CONST char *)tptr; } if (*cptr == '"') { /* quoted string comparison? */ char op[CBUFSIZE]; @@ -3285,12 +3290,13 @@ if (*cptr == '"') { /* quoted string compari {"<=", 0, -1, FALSE}, {"LEQ", 0, -1, FALSE}, {">", 1, 1, FALSE}, - {"GTR", 1, 1, FALSE}, + {"GTR", 1, 1, FALSE}, {">=", 0, 1, FALSE}, {"GEQ", 0, 1, FALSE}, {NULL}}; - tptr = (char *)get_glyph_gen (cptr, gbuf, '=', (sim_switches & SWMASK ('I')), TRUE, '\\');/* get first string */ + tptr = (CONST char *)get_glyph_gen (cptr, gbuf, '=', (sim_switches & SWMASK ('I')), TRUE, '\\'); + /* get first string */ if (!*tptr) return SCPE_2FARG; cptr += strlen (gbuf); @@ -3305,7 +3311,8 @@ if (*cptr == '"') { /* quoted string compari cptr += strlen (op); while (sim_isspace (*cptr)) /* skip spaces */ ++cptr; - cptr = (char *)get_glyph_gen (cptr, gbuf2, 0, (sim_switches & SWMASK ('I')), TRUE, '\\');/* get second string */ + cptr = (CONST char *)get_glyph_gen (cptr, gbuf2, 0, (sim_switches & SWMASK ('I')), TRUE, '\\'); + /* get second string */ if (*cptr) { /* more? */ if (flag) /* ASSERT has no more args */ return SCPE_2MARG; @@ -3374,7 +3381,7 @@ else { result = test_search (sim_eval, &sim_staba); /* test condition */ } } -if (not ^ result) { +if (Not ^ result) { if (!flag) sim_brk_setact (cptr); /* set up IF actions */ } @@ -3417,9 +3424,10 @@ return SCPE_OK; \xh{h} where each h is a hex digit (0-9A-Fa-f) */ -t_stat send_cmd (int32 flag, char *cptr) +t_stat send_cmd (int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE], *tptr; +char gbuf[CBUFSIZE]; +CONST char *tptr; uint8 dbuf[CBUFSIZE]; uint32 dsize = 0; uint32 delay = 0; @@ -3475,9 +3483,10 @@ if ((dsize == 0) && (delay == 0) && (after == 0)) return sim_send_input (snd, dbuf, dsize, after, delay); } -t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_send (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE], *tptr; +char gbuf[CBUFSIZE]; +CONST char *tptr; t_stat r; SEND *snd; @@ -3495,9 +3504,10 @@ if (*cptr) return sim_show_send_input (st, snd); } -t_stat expect_cmd (int32 flag, char *cptr) +t_stat expect_cmd (int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE], *tptr; +char gbuf[CBUFSIZE]; +CONST char *tptr; t_stat r; EXPECT *exp; @@ -3517,9 +3527,10 @@ else return sim_set_noexpect (exp, cptr); } -t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE], *tptr; +char gbuf[CBUFSIZE]; +CONST char *tptr; t_stat r; EXPECT *exp; @@ -3545,9 +3556,10 @@ return sim_exp_show (st, exp, gbuf); /* Goto command */ -t_stat goto_cmd (int32 flag, char *fcptr) +t_stat goto_cmd (int32 flag, CONST char *fcptr) { -char *cptr, cbuf[CBUFSIZE], gbuf[CBUFSIZE], gbuf1[CBUFSIZE]; +char cbuf[CBUFSIZE], gbuf[CBUFSIZE], gbuf1[CBUFSIZE]; +const char *cptr; long fpos; int32 saved_do_echo = sim_do_echo; int32 saved_goto_line = sim_goto_line[sim_do_depth]; @@ -3588,7 +3600,7 @@ return SCPE_ARG; /* and not dispatched here, so if we get here a return has been issued from */ /* interactive input */ -t_stat return_cmd (int32 flag, char *fcptr) +t_stat return_cmd (int32 flag, CONST char *fcptr) { return SCPE_UNK; /* only valid inside of do_cmd */ } @@ -3600,7 +3612,7 @@ return SCPE_UNK; /* only valid inside of /* interactive input (it is not valid interactively since it would have to */ /* mess with the program's argv which is owned by the C runtime library */ -t_stat shift_cmd (int32 flag, char *fcptr) +t_stat shift_cmd (int32 flag, CONST char *fcptr) { return SCPE_UNK; /* only valid inside of do_cmd */ } @@ -3611,9 +3623,10 @@ return SCPE_UNK; /* only valid inside of /* and not dispatched here, so if we get here a call has been issued from */ /* interactive input */ -t_stat call_cmd (int32 flag, char *fcptr) +t_stat call_cmd (int32 flag, CONST char *fcptr) { -char *cptr, cbuf[CBUFSIZE], gbuf[CBUFSIZE]; +char cbuf[CBUFSIZE], gbuf[CBUFSIZE]; +const char *cptr; if (NULL == sim_gotofile) return SCPE_UNK; /* only valid inside of do_cmd */ cptr = get_glyph (fcptr, gbuf, 0); @@ -3625,7 +3638,7 @@ return do_cmd_label (flag, cbuf, gbuf); /* On command */ -t_stat on_cmd (int32 flag, char *cptr) +t_stat on_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; t_stat cond; @@ -3651,7 +3664,7 @@ return SCPE_OK; /* noop command */ /* The noop command (IGNORE, PROCEED) does nothing */ -t_stat noop_cmd (int32 flag, char *cptr) +t_stat noop_cmd (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -3660,7 +3673,7 @@ return SCPE_OK; /* we're happy doing not /* Set on/noon routine */ -t_stat set_on (int32 flag, char *cptr) +t_stat set_on (int32 flag, CONST char *cptr) { if ((flag) && (cptr) && (*cptr)) { /* Set ON with arg */ char gbuf[CBUFSIZE]; @@ -3696,7 +3709,7 @@ return SCPE_OK; /* Set verify/noverify routine */ -t_stat set_verify (int32 flag, char *cptr) +t_stat set_verify (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -3708,7 +3721,7 @@ return SCPE_OK; /* Set message/nomessage routine */ -t_stat set_message (int32 flag, char *cptr) +t_stat set_message (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -3720,7 +3733,7 @@ return SCPE_OK; /* Set quiet/noquiet routine */ -t_stat set_quiet (int32 flag, char *cptr) +t_stat set_quiet (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -3732,7 +3745,7 @@ return SCPE_OK; /* Set asynch/noasynch routine */ -t_stat sim_set_asynch (int32 flag, char *cptr) +t_stat sim_set_asynch (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -3773,7 +3786,7 @@ return SCPE_NOFNC; /* Show asynch routine */ -t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_asynch (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -3793,7 +3806,7 @@ return SCPE_OK; /* Set environment routine */ -t_stat sim_set_environment (int32 flag, char *cptr) +t_stat sim_set_environment (int32 flag, CONST char *cptr) { char varname[CBUFSIZE]; @@ -3806,11 +3819,12 @@ return SCPE_OK; /* Set command */ -t_stat set_cmd (int32 flag, char *cptr) +t_stat set_cmd (int32 flag, CONST char *cptr) { uint32 lvl = 0; t_stat r; -char gbuf[CBUFSIZE], *cvptr, *svptr; +char gbuf[CBUFSIZE], *cvptr; +CONST char *svptr; DEVICE *dptr; UNIT *uptr; MTAB *mptr; @@ -3956,7 +3970,7 @@ return NULL; /* Set device data radix routine */ -t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat set_dev_radix (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (cptr) return SCPE_ARG; @@ -3966,7 +3980,7 @@ return SCPE_OK; /* Set device enabled/disabled routine */ -t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat set_dev_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { UNIT *up; uint32 i; @@ -3997,7 +4011,7 @@ else return SCPE_OK; /* Set unit enabled/disabled routine */ -t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat set_unit_enbdis (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (cptr) return SCPE_ARG; @@ -4016,7 +4030,7 @@ return SCPE_OK; /* Set device debug enabled/disabled routine */ -t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; DEBTAB *dep; @@ -4051,11 +4065,12 @@ return SCPE_OK; /* Show command */ -t_stat show_cmd (int32 flag, char *cptr) +t_stat show_cmd (int32 flag, CONST char *cptr) { t_stat r; -cptr = get_sim_opt (CMD_OPT_SW|CMD_OPT_OF, cptr, &r); /* get sw, ofile */ +cptr = get_sim_opt (CMD_OPT_SW|CMD_OPT_OF, cptr, &r); + /* get sw, ofile */ if (!cptr) /* error? */ return r; if (sim_ofile) { /* output file? */ @@ -4072,10 +4087,11 @@ else { return r; } -t_stat show_cmd_fi (FILE *ofile, int32 flag, char *cptr) +t_stat show_cmd_fi (FILE *ofile, int32 flag, CONST char *cptr) { uint32 lvl = 0xFFFFFFFF; -char gbuf[CBUFSIZE], *cvptr, *svptr; +char gbuf[CBUFSIZE], *cvptr; +CONST char *svptr; DEVICE *dptr; UNIT *uptr; MTAB *mptr; @@ -4314,10 +4330,16 @@ return; /* Show processors */ -t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { int32 vmaj = SIM_MAJOR, vmin = SIM_MINOR, vpat = SIM_PATCH, vdelt = SIM_DELTA; +const char *cpp; +#ifdef __cplusplus +cpp = "C++"; +#else +cpp = "C"; +#endif if (cptr && (*cptr != 0)) return SCPE_2MARG; fprintf (st, "%s simulator V%d.%d-%d", sim_name, vmaj, vmin, vpat); @@ -4369,7 +4391,7 @@ if (flag) { #undef S_xstr #endif #if defined (__DATE__) && defined (__TIME__) - fprintf (st, "\n\t\tSimulator Compiled: %s at %s", __DATE__, __TIME__); + fprintf (st, "\n\t\tSimulator Compiled as %s: %s at %s", cpp, __DATE__, __TIME__); #endif fprintf (st, "\n\t\tMemory Access: %s Endian", sim_end ? "Little" : "Big"); fprintf (st, "\n\t\tMemory Pointer Size: %d bits", (int)sizeof(dptr)*8); @@ -4456,7 +4478,7 @@ fprintf (st, "\n"); return SCPE_OK; } -t_stat show_config (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat show_config (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { int32 i; DEVICE *dptr; @@ -4471,7 +4493,7 @@ for (i = 0; (dptr = sim_devices[i]) != NULL; i++) return SCPE_OK; } -t_stat show_log_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat show_log_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { int32 i; DEVICE *dptr; @@ -4483,7 +4505,7 @@ for (i = 0; (dptr = sim_devices[i]) != NULL; i++) return SCPE_OK; } -t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_dev_logicals (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (dptr->lname) fprintf (st, "%s -> %s\n", dptr->lname, dptr->name); @@ -4492,7 +4514,7 @@ else if (!flag) return SCPE_OK; } -t_stat show_queue (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat show_queue (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { DEVICE *dptr; UNIT *uptr; @@ -4549,7 +4571,7 @@ pthread_mutex_unlock (&sim_asynch_lock); return SCPE_OK; } -t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_time (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -4557,7 +4579,7 @@ fprintf (st, "Time:\t%.0f\n", sim_gtime()); return SCPE_OK; } -t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_break (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { t_stat r; @@ -4567,13 +4589,13 @@ else r = sim_brk_showall (st, sim_switches); return r; } -t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_dev_radix (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { fprintf (st, "Radix=%d\n", dptr->dradix); return SCPE_OK; } -t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { int32 any = 0; DEBTAB *dep; @@ -4602,7 +4624,7 @@ else return SCPE_NOFNC; /* Show On actions */ -t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_on (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { int32 lvl, i; @@ -4630,7 +4652,7 @@ return SCPE_OK; /* Show modifiers */ -t_stat show_mod_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat show_mod_names (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { int32 i; DEVICE *dptr; @@ -4644,7 +4666,7 @@ for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) return SCPE_OK; } -t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_dev_modifiers (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { fprint_set_help (st, dptr); return SCPE_OK; @@ -4675,13 +4697,13 @@ return SCPE_OK; } t_stat show_one_mod (FILE *st, DEVICE *dptr, UNIT *uptr, MTAB *mptr, - char *cptr, int32 flag) + CONST char *cptr, int32 flag) { t_stat r = SCPE_OK; //t_value val; if (mptr->disp) - r = mptr->disp (st, uptr, mptr->match, cptr? cptr: mptr->desc); + r = mptr->disp (st, uptr, mptr->match, (CONST void *)(cptr? cptr: mptr->desc)); //else if ((mptr->mask & MTAB_XTD) && (mptr->mask & MTAB_VAL)) { // REG *rptr = (REG *) mptr->desc; // fprintf (st, "%s=", mptr->pstring); @@ -4697,7 +4719,7 @@ return r; /* Show show commands */ -t_stat show_show_commands (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat show_show_commands (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { int32 i; DEVICE *dptr; @@ -4711,7 +4733,7 @@ for (i = 0; sim_internal_device_count && (dptr = sim_internal_devices[i]); ++i) return SCPE_OK; } -t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_dev_show_commands (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { fprint_show_help (st, dptr); return SCPE_OK; @@ -4719,7 +4741,7 @@ return SCPE_OK; /* Show/change the current working directiory commands */ -t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat show_default (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { char buffer[PATH_MAX]; char *wd = getcwd(buffer, PATH_MAX); @@ -4727,26 +4749,30 @@ fprintf (st, "%s\n", wd); return SCPE_OK; } -t_stat set_default_cmd (int32 flg, char *cptr) +t_stat set_default_cmd (int32 flg, CONST char *cptr) { +char gbuf[4*CBUFSIZE]; + if (sim_is_running) return SCPE_INVREM; if ((!cptr) || (*cptr == 0)) return SCPE_2FARG; -sim_trim_endspc(cptr); -if (chdir(cptr) != 0) - return sim_messagef(SCPE_IOERR, "Unable to directory change to: %s\n", cptr); +gbuf[sizeof(gbuf)-1] = '\0'; +strncpy (gbuf, cptr, sizeof(gbuf)-1); +sim_trim_endspc(gbuf); +if (chdir(gbuf) != 0) + return sim_messagef(SCPE_IOERR, "Unable to directory change to: %s\n", gbuf); return SCPE_OK; } -t_stat pwd_cmd (int32 flg, char *cptr) +t_stat pwd_cmd (int32 flg, CONST char *cptr) { return show_cmd (0, "DEFAULT"); } #if defined (_WIN32) -t_stat dir_cmd (int32 flg, char *cptr) +t_stat dir_cmd (int32 flg, CONST char *cptr) { HANDLE hFind; WIN32_FIND_DATAA File; @@ -4763,10 +4789,11 @@ if ((hFind = FindFirstFileA (cptr, &File)) != INVALID_HANDLE_VALUE) { t_int64 FileSize, TotalSize = 0; int DirCount = 0, FileCount = 0; char DirName[PATH_MAX + 1], FileName[PATH_MAX + 1]; - char *c, pathsep = '/'; + const char *c; + char pathsep = '/'; struct tm *local; - GetFullPathNameA(cptr, sizeof(DirName), DirName, &c); + GetFullPathNameA(cptr, sizeof(DirName), DirName, (char **)&c); c = strrchr(DirName, pathsep); if (NULL == c) { pathsep = '\\'; @@ -4826,7 +4853,7 @@ return SCPE_OK; #endif #endif /* defined (HAVE_GLOB) */ -t_stat dir_cmd (int32 flg, char *cptr) +t_stat dir_cmd (int32 flg, CONST char *cptr) { #if defined (HAVE_GLOB) glob_t paths; @@ -4838,8 +4865,9 @@ char *c; char DirName[PATH_MAX + 1], WholeName[PATH_MAX + 1], WildName[PATH_MAX + 1]; if (*cptr == '\0') - cptr = "./*"; -strcpy (WildName, cptr); + strcpy (WildName, "./*"); +else + strcpy (WildName, cptr); cptr = WildName; while (strlen(WildName) && sim_isspace(WildName[strlen(WildName)-1])) WildName[strlen(WildName)-1] = '\0'; @@ -4959,15 +4987,17 @@ return SCPE_OK; #endif /* !defined(_WIN32) */ -t_stat type_cmd (int32 flg, char *cptr) +t_stat type_cmd (int32 flg, CONST char *cptr) { FILE *file; -char lbuf[CBUFSIZE*2]; +char lbuf[4*CBUFSIZE]; if ((!cptr) || (*cptr == 0)) return SCPE_2FARG; -sim_trim_endspc(cptr); -file = sim_fopen (cptr, "r"); +lbuf[sizeof(lbuf)-1] = '\0'; +strncpy (lbuf, cptr, sizeof(lbuf)-1); +sim_trim_endspc(lbuf); +file = sim_fopen (lbuf, "r"); if (file == NULL) /* open failed? */ return SCPE_OPENERR; lbuf[sizeof(lbuf)-1] = '\0'; @@ -4979,16 +5009,16 @@ return SCPE_OK; /* Breakpoint commands */ -t_stat brk_cmd (int32 flg, char *cptr) +t_stat brk_cmd (int32 flg, CONST char *cptr) { GET_SWITCHES (cptr); /* get switches */ return ssh_break (NULL, cptr, flg); /* call common code */ } -t_stat ssh_break (FILE *st, char *cptr, int32 flg) +t_stat ssh_break (FILE *st, const char *cptr, int32 flg) { -char gbuf[CBUFSIZE], *aptr; -const char *tptr, *t1ptr; +char gbuf[CBUFSIZE], *aptr, abuf[4*CBUFSIZE]; +CONST char *tptr, *t1ptr; DEVICE *dptr = sim_dflt_dev; UNIT *uptr = dptr->units; t_stat r; @@ -4999,7 +5029,10 @@ if (sim_brk_types == 0) return SCPE_NOFNC; if ((dptr == NULL) || (uptr == NULL)) return SCPE_IERR; -if ((aptr = strchr (cptr, ';'))) { /* ;action? */ +abuf[sizeof(abuf)-1] = '\0'; +strncpy (abuf, cptr, sizeof(abuf)-1); +cptr = abuf; +if ((aptr = strchr (abuf, ';'))) { /* ;action? */ if (flg != SSH_ST) /* only on SET */ return SCPE_ARG; *aptr++ = 0; /* separate strings */ @@ -5040,7 +5073,7 @@ while (*cptr) { return SCPE_OK; } -t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, char *aptr) +t_stat ssh_break_one (FILE *st, int32 flg, t_addr lo, int32 cnt, CONST char *aptr) { switch (flg) { @@ -5068,7 +5101,7 @@ switch (flg) { re[set] device reset specific device */ -t_stat reset_cmd (int32 flag, char *cptr) +t_stat reset_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; DEVICE *dptr; @@ -5179,7 +5212,7 @@ else } -t_stat load_cmd (int32 flag, char *cptr) +t_stat load_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; FILE *loadfile = NULL; @@ -5195,7 +5228,7 @@ if (!mem_data) { return SCPE_OPENERR; } GET_SWITCHES (cptr); /* get switches */ -reason = sim_load (loadfile, cptr, gbuf, flag); /* load or dump */ +reason = sim_load (loadfile, (CONST char *)cptr, gbuf, flag);/* load or dump */ if (loadfile) fclose (loadfile); return reason; @@ -5206,9 +5239,9 @@ return reason; at[tach] unit file attach specified unit to file */ -t_stat attach_cmd (int32 flag, char *cptr) +t_stat attach_cmd (int32 flag, CONST char *cptr) { -char gbuf[CBUFSIZE]; +char gbuf[4*CBUFSIZE]; DEVICE *dptr; UNIT *uptr; t_stat r; @@ -5237,22 +5270,24 @@ if (uptr->flags & UNIT_ATT) { /* already attached? */ return SCPE_ALATT; /* Already attached */ } } -sim_trim_endspc (cptr); /* trim trailing spc */ -return scp_attach_unit (dptr, uptr, cptr); /* attach */ +gbuf[sizeof(gbuf)-1] = '\0'; +strncpy (gbuf, cptr, sizeof(gbuf)-1); +sim_trim_endspc (gbuf); /* trim trailing spc */ +return scp_attach_unit (dptr, uptr, gbuf); /* attach */ } /* Call device-specific or file-oriented attach unit routine */ -t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, char *cptr) +t_stat scp_attach_unit (DEVICE *dptr, UNIT *uptr, const char *cptr) { if (dptr->attach != NULL) /* device routine? */ - return dptr->attach (uptr, cptr); /* call it */ -return attach_unit (uptr, cptr); /* no, std routine */ + return dptr->attach (uptr, (CONST char *)cptr); /* call it */ +return attach_unit (uptr, (CONST char *)cptr); /* no, std routine */ } /* Attach unit to file */ -t_stat attach_unit (UNIT *uptr, char *cptr) +t_stat attach_unit (UNIT *uptr, CONST char *cptr) { DEVICE *dptr; @@ -5350,7 +5385,7 @@ return stat; det[ach] unit detach specified unit */ -t_stat detach_cmd (int32 flag, char *cptr) +t_stat detach_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; DEVICE *dptr; @@ -5468,7 +5503,7 @@ return SCPE_OK; as[sign] device name assign logical name to device */ -t_stat assign_cmd (int32 flag, char *cptr) +t_stat assign_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; DEVICE *dptr; @@ -5492,12 +5527,12 @@ deassign_device (dptr); /* release current */ return assign_device (dptr, gbuf); } -t_stat assign_device (DEVICE *dptr, char *cptr) +t_stat assign_device (DEVICE *dptr, const char *cptr) { -dptr->lname = (char *) calloc (CBUFSIZE, sizeof (char)); +dptr->lname = (char *) calloc (1 + strlen (cptr), sizeof (char)); if (dptr->lname == NULL) return SCPE_MEM; -strncpy (dptr->lname, cptr, CBUFSIZE); +strcpy (dptr->lname, cptr); return SCPE_OK; } @@ -5506,7 +5541,7 @@ return SCPE_OK; dea[ssign] device deassign logical name */ -t_stat deassign_cmd (int32 flag, char *cptr) +t_stat deassign_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; DEVICE *dptr; @@ -5525,8 +5560,7 @@ return deassign_device (dptr); t_stat deassign_device (DEVICE *dptr) { -if (dptr->lname) - free (dptr->lname); +free (dptr->lname); dptr->lname = NULL; return SCPE_OK; } @@ -5558,15 +5592,19 @@ return uname; sa[ve] filename save state to specified file */ -t_stat save_cmd (int32 flag, char *cptr) +t_stat save_cmd (int32 flag, CONST char *cptr) { FILE *sfile; t_stat r; +char gbuf[4*CBUFSIZE]; + GET_SWITCHES (cptr); /* get switches */ if (*cptr == 0) /* must be more */ return SCPE_2FARG; -sim_trim_endspc (cptr); -if ((sfile = sim_fopen (cptr, "wb")) == NULL) +gbuf[sizeof(gbuf)-1] = '\0'; +strncpy (gbuf, cptr, sizeof(gbuf)-1); +sim_trim_endspc (gbuf); +if ((sfile = sim_fopen (gbuf, "wb")) == NULL) return SCPE_OPENERR; r = sim_save (sfile); fclose (sfile); @@ -5706,16 +5744,19 @@ return (ferror (sfile))? SCPE_IOERR: SCPE_OK; /* error during save? */ re[store] filename restore state from specified file */ -t_stat restore_cmd (int32 flag, char *cptr) +t_stat restore_cmd (int32 flag, CONST char *cptr) { FILE *rfile; t_stat r; +char gbuf[4*CBUFSIZE]; GET_SWITCHES (cptr); /* get switches */ if (*cptr == 0) /* must be more */ return SCPE_2FARG; -sim_trim_endspc (cptr); -if ((rfile = sim_fopen (cptr, "rb")) == NULL) +gbuf[sizeof(gbuf)-1] = '\0'; +strncpy (gbuf, cptr, sizeof(gbuf)-1); +sim_trim_endspc (gbuf); +if ((rfile = sim_fopen (gbuf, "rb")) == NULL) return SCPE_OPENERR; r = sim_rest (rfile); fclose (rfile); @@ -6037,10 +6078,10 @@ return r; be a number of microseconds to run for */ -t_stat run_cmd (int32 flag, char *cptr) +t_stat run_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; -const char *tptr; +CONST char *tptr; uint32 i, j; int32 sim_next; int32 unitno; @@ -6408,11 +6449,11 @@ return; STATE all registers */ -t_stat exdep_cmd (int32 flag, char *cptr) +t_stat exdep_cmd (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; -const char *gptr; -const char *tptr = NULL; +CONST char *gptr; +CONST char *tptr = NULL; int32 opt; t_addr low, high; t_stat reason; @@ -6499,7 +6540,7 @@ return reason; exdep_addr_loop examine/deposit range of addresses */ -t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, char *cptr, +t_stat exdep_reg_loop (FILE *ofile, SCHTAB *schptr, int32 flag, CONST char *cptr, REG *lowr, REG *highr, uint32 lows, uint32 highs) { t_stat reason; @@ -6585,7 +6626,7 @@ for (rptr = lowr; rptr <= highr; rptr++) { return SCPE_OK; } -t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, char *cptr, +t_stat exdep_addr_loop (FILE *ofile, SCHTAB *schptr, int32 flag, const char *cptr, t_addr low, t_addr high, DEVICE *dptr, UNIT *uptr) { t_addr i, mask; @@ -6731,12 +6772,12 @@ return val; return = error status */ -t_stat dep_reg (int32 flag, char *cptr, REG *rptr, uint32 idx) +t_stat dep_reg (int32 flag, CONST char *cptr, REG *rptr, uint32 idx) { t_stat r; t_value val, mask; int32 rdx; -const char *tptr; +CONST char *tptr; char gbuf[CBUFSIZE]; if ((cptr == NULL) || (rptr == NULL)) @@ -6761,7 +6802,7 @@ if ((rptr->flags & REG_VMAD) && sim_vm_parse_addr) { /* address form? */ } else if (!(rptr->flags & REG_VMFLAGS) || /* dont use sym? */ - (parse_sym (cptr, (rptr->flags & REG_UFMASK) | rdx, NULL, + (parse_sym ((CONST char *)cptr, (rptr->flags & REG_UFMASK) | rdx, NULL, &val, sim_switches | SIM_SW_REG) > SCPE_OK)) { val = get_uint (cptr, rdx, mask, &r); if (r != SCPE_OK) @@ -6966,7 +7007,7 @@ return SCPE_OK; if <= 0, -number of extra address units retired */ -t_stat dep_addr (int32 flag, char *cptr, t_addr addr, DEVICE *dptr, +t_stat dep_addr (int32 flag, const char *cptr, t_addr addr, DEVICE *dptr, UNIT *uptr, int32 dfltinc) { int32 i, count, rdx; @@ -6992,7 +7033,7 @@ if (uptr->flags & UNIT_RO) /* read only? */ mask = width_mask[dptr->dwidth]; GET_RADIX (rdx, dptr->dradix); -if ((reason = parse_sym (cptr, addr, uptr, sim_eval, sim_switches)) > 0) { +if ((reason = parse_sym ((CONST char *)cptr, addr, uptr, sim_eval, sim_switches)) > 0) { sim_eval[0] = get_uint (cptr, rdx, mask, &reason); if (reason != SCPE_OK) return reason; @@ -7036,7 +7077,7 @@ return reason; /* Evaluate command */ -t_stat eval_cmd (int32 flg, char *cptr) +t_stat eval_cmd (int32 flg, CONST char *cptr) { DEVICE *dptr = sim_dflt_dev; int32 i, rdx, a, lim; @@ -7048,7 +7089,7 @@ for (i = 0; i < sim_emax; i++) sim_eval[i] = 0; if (*cptr == 0) return SCPE_2FARG; -if ((r = parse_sym (cptr, 0, dptr->units, sim_eval, sim_switches)) > 0) { +if ((r = parse_sym ((CONST char *)cptr, 0, dptr->units, sim_eval, sim_switches)) > 0) { sim_eval[0] = get_uint (cptr, rdx, width_mask[dptr->dwidth], &r); if (r != SCPE_OK) return r; @@ -7237,19 +7278,19 @@ while (sim_isspace (*iptr)) /* absorb spaces */ return iptr; } -char *get_glyph (const char *iptr, char *optr, char mchar) +CONST char *get_glyph (const char *iptr, char *optr, char mchar) { -return (char *)get_glyph_gen (iptr, optr, mchar, TRUE, FALSE, 0); +return (CONST char *)get_glyph_gen (iptr, optr, mchar, TRUE, FALSE, 0); } -char *get_glyph_nc (const char *iptr, char *optr, char mchar) +CONST char *get_glyph_nc (const char *iptr, char *optr, char mchar) { -return (char *)get_glyph_gen (iptr, optr, mchar, FALSE, FALSE, 0); +return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, FALSE, 0); } -char *get_glyph_quoted (const char *iptr, char *optr, char mchar) +CONST char *get_glyph_quoted (const char *iptr, char *optr, char mchar) { -return (char *)get_glyph_gen (iptr, optr, mchar, FALSE, TRUE, '\\'); +return (CONST char *)get_glyph_gen (iptr, optr, mchar, FALSE, TRUE, '\\'); } /* Trim trailing spaces from a string @@ -7316,7 +7357,8 @@ return (c & 0x80) ? 0 : isalnum (c); t_stat get_yn (const char *ques, t_stat deflt) { -char cbuf[CBUFSIZE], *cptr; +char cbuf[CBUFSIZE]; +const char *cptr; if (sim_switches & SWMASK ('Y')) return TRUE; @@ -7346,10 +7388,10 @@ return FALSE; t_value get_uint (const char *cptr, uint32 radix, t_value max, t_stat *status) { t_value val; -const char *tptr; +CONST char *tptr; *status = SCPE_OK; -val = strtotv (cptr, &tptr, radix); +val = strtotv ((CONST char *)cptr, &tptr, radix); if ((cptr == tptr) || (val > max)) *status = SCPE_ARG; else { @@ -7375,10 +7417,10 @@ return val; NULL if error */ -const char *get_range (DEVICE *dptr, const char *cptr, t_addr *lo, t_addr *hi, +CONST char *get_range (DEVICE *dptr, CONST char *cptr, t_addr *lo, t_addr *hi, uint32 rdx, t_addr max, char term) { -const char *tptr; +CONST char *tptr; if (max && strncmp (cptr, "ALL", strlen ("ALL")) == 0) { /* ALL? */ tptr = cptr + strlen ("ALL"); @@ -7803,7 +7845,7 @@ return (dptr->flags & DEV_DIS? TRUE: FALSE); *gdptr = pointer to device where found */ -REG *find_reg_glob (const char *cptr, const char **optr, DEVICE **gdptr) +REG *find_reg_glob (CONST char *cptr, CONST char **optr, DEVICE **gdptr) { int32 i; DEVICE *dptr; @@ -7834,9 +7876,9 @@ return srptr; *optr = pointer to next character in input string */ -REG *find_reg (const char *cptr, const char **optr, DEVICE *dptr) +REG *find_reg (CONST char *cptr, CONST char **optr, DEVICE *dptr) { -const char *tptr; +CONST char *tptr; REG *rptr; size_t slnt; @@ -7867,7 +7909,7 @@ return NULL; 0 if no switches, -1 if error */ -int32 get_switches (char *cptr) +int32 get_switches (const char *cptr) { int32 sw; @@ -7891,7 +7933,7 @@ return sw; NULL if error */ -char *get_sim_sw (char *cptr) +CONST char *get_sim_sw (CONST char *cptr) { int32 lsw; char gbuf[CBUFSIZE]; @@ -7916,10 +7958,11 @@ return cptr; *stat = error status */ -char *get_sim_opt (int32 opt, char *cptr, t_stat *st) +CONST char *get_sim_opt (int32 opt, CONST char *cptr, t_stat *st) { int32 t; -char *svptr, gbuf[CBUFSIZE]; +char gbuf[CBUFSIZE]; +CONST char *svptr; DEVICE *tdptr; UNIT *tuptr; @@ -7996,9 +8039,9 @@ return cptr; cp = pointer to final '.' if match, NULL if not */ -char *match_ext (char *fnam, const char *ext) +CONST char *match_ext (CONST char *fnam, const char *ext) { -char *pptr, *fptr; +CONST char *pptr, *fptr; const char *eptr; if ((fnam == NULL) || (ext == NULL)) /* bad arguments? */ @@ -8032,12 +8075,12 @@ return pptr; schptr if valid search specification */ -SCHTAB *get_rsearch (const char *cptr, int32 radix, SCHTAB *schptr) +SCHTAB *get_rsearch (CONST char *cptr, int32 radix, SCHTAB *schptr) { int32 c, logop, cmpop; t_value logval, cmpval; const char *sptr; -const char *tptr; +CONST char *tptr; const char logstr[] = "|&^", cmpstr[] = "=!><"; logval = cmpval = 0; @@ -8093,12 +8136,12 @@ return schptr; schptr if valid search specification */ -SCHTAB *get_asearch (const char *cptr, int32 radix, SCHTAB *schptr) +SCHTAB *get_asearch (CONST char *cptr, int32 radix, SCHTAB *schptr) { int32 c, logop, cmpop; t_value *logval, *cmpval; t_stat reason; -const char *ocptr = cptr; +CONST char *ocptr = cptr; const char *sptr; char gbuf[CBUFSIZE]; const char logstr[] = "|&^", cmpstr[] = "=!><"; @@ -8257,7 +8300,7 @@ return ret; On an error, the endptr will equal the inptr. */ -t_value strtotv (const char *inptr, const char **endptr, uint32 radix) +t_value strtotv (CONST char *inptr, CONST char **endptr, uint32 radix) { int32 nodigit; t_value val; @@ -8853,7 +8896,7 @@ return bp; /* Set a breakpoint of type sw */ -t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, char *act) +t_stat sim_brk_set (t_addr loc, int32 sw, int32 ncnt, CONST char *act) { BRKTAB *bp; @@ -9014,14 +9057,14 @@ return 0; /* Get next pending action, if any */ -char *sim_brk_getact (char *buf, int32 size) +CONST char *sim_brk_getact (char *buf, int32 size) { char *ep; size_t lnt; if (sim_brk_act[sim_do_depth] == NULL) /* any action? */ return NULL; -while (sim_isspace (*sim_brk_act[sim_do_depth])) /* skip spaces */ +while (sim_isspace (*sim_brk_act[sim_do_depth])) /* skip spaces */ sim_brk_act[sim_do_depth]++; if (*sim_brk_act[sim_do_depth] == 0) { /* now empty? */ return sim_brk_clract (); @@ -9131,10 +9174,11 @@ return SCPE_OK; /* Set expect */ -t_stat sim_set_expect (EXPECT *exp, const char *cptr) +t_stat sim_set_expect (EXPECT *exp, CONST char *cptr) { -char gbuf[CBUFSIZE], *tptr; -const char *c1ptr; +char gbuf[CBUFSIZE]; +CONST char *tptr; +CONST char *c1ptr; uint32 after = exp->after; int32 cnt = 0; t_stat r; @@ -9181,7 +9225,7 @@ return sim_exp_clr (exp, gbuf); /* clear one rule */ /* Search for an expect rule in an expect context */ -EXPTAB *sim_exp_fnd (EXPECT *exp, const char *match) +CONST EXPTAB *sim_exp_fnd (CONST EXPECT *exp, const char *match) { int32 i; @@ -9220,7 +9264,7 @@ return SCPE_OK; t_stat sim_exp_clr (EXPECT *exp, const char *match) { -return sim_exp_clr_tab (exp, sim_exp_fnd (exp, match)); +return sim_exp_clr_tab (exp, (EXPTAB *)sim_exp_fnd (exp, match)); } /* Clear all expect rules */ @@ -9296,7 +9340,7 @@ else { } } free (match_buf); -ep = sim_exp_fnd (exp, match); /* present? */ +ep = (EXPTAB *)sim_exp_fnd (exp, match); /* present? */ if (ep) /* no, allocate */ sim_exp_clr_tab (exp, ep); /* clear it */ if (after && exp->size) @@ -9357,7 +9401,7 @@ return SCPE_OK; /* Show an expect rule */ -t_stat sim_exp_show_tab (FILE *st, EXPECT *exp, EXPTAB *ep) +t_stat sim_exp_show_tab (FILE *st, const EXPECT *exp, const EXPTAB *ep) { if (!ep) return SCPE_OK; @@ -9379,9 +9423,9 @@ fprintf (st, "\n"); return SCPE_OK; } -t_stat sim_exp_show (FILE *st, EXPECT *exp, const char *match) +t_stat sim_exp_show (FILE *st, CONST EXPECT *exp, const char *match) { -EXPTAB *ep = sim_exp_fnd (exp, match); +CONST EXPTAB *ep = (CONST EXPTAB *)sim_exp_fnd (exp, match); if (exp->buf_size) { char *bstr = sim_encode_quoted_string (exp->buf, exp->buf_ins); @@ -9404,7 +9448,7 @@ return sim_exp_show_tab (st, exp, ep); /* Show all expect rules */ -t_stat sim_exp_showall (FILE *st, EXPECT *exp) +t_stat sim_exp_showall (FILE *st, const EXPECT *exp) { int32 i; @@ -9618,7 +9662,7 @@ return SCPE_OK; /* Display console Queued input data status */ -t_stat sim_show_send_input (FILE *st, SEND *snd) +t_stat sim_show_send_input (FILE *st, const SEND *snd) { if (snd->extoff < snd->insoff) { fprintf (st, "%d bytes of pending input Data:\n ", snd->insoff-snd->extoff); @@ -9682,7 +9726,7 @@ sprintf(msgbuf, "Error %d", stat); return msgbuf; } -t_stat sim_string_to_stat (char *cptr, t_stat *stat) +t_stat sim_string_to_stat (const char *cptr, t_stat *stat) { char gbuf[CBUFSIZE]; int32 cond; @@ -9991,9 +10035,13 @@ return stat | SCPE_NOMESSAGE; Callers should be calling sim_debug() which is a macro defined in scp.h which evaluates the action condition before incurring call overhead. */ - -void _sim_debug (uint32 dbits, DEVICE* dptr, const char* fmt, ...) +#if defined(__cplusplus) +void _sim_debug (uint32 dbits, void* vdptr, const char* fmt, ...) +#else +void _sim_debug (uint32 dbits, DEVICE* vdptr, const char* fmt, ...) +#endif { +DEVICE *dptr = (DEVICE *)vdptr; if (sim_deb && dptr && (dptr->dctrl & dbits)) { char stackbuf[STACKBUFSIZE]; @@ -10073,7 +10121,7 @@ if (sim_deb && (dptr->dctrl & reason)) { char outbuf[80], strbuf[28], rad50buf[36], ebcdicbuf[32]; static char hex[] = "0123456789ABCDEF"; static char rad50[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$._0123456789"; - static char ebcdic2ascii[] = { + static unsigned char ebcdic2ascii[] = { 0000,0001,0002,0003,0234,0011,0206,0177, 0227,0215,0216,0013,0014,0015,0016,0017, 0020,0021,0022,0023,0235,0205,0010,0207, @@ -10275,7 +10323,7 @@ size_t n, ilvl; #define VSMAX 100 char *vstrings[VSMAX]; size_t vsnum = 0; -char *astrings[VSMAX+1]; +char * astrings[VSMAX+1]; size_t asnum = 0; char *const *hblock; const char *ep; @@ -10287,8 +10335,8 @@ t_bool excluded = FALSE; * If you try to violate this, there ARE machines that WILL break. */ -memset (vstrings, 0, VSMAX * sizeof (char *)); -memset (astrings, 0, VSMAX * sizeof (char *)); +memset (vstrings, 0, sizeof (vstrings)); +memset (astrings, 0, sizeof (astrings)); astrings[asnum++] = (char *) htext; for (hblock = astrings; (htext = *hblock) != NULL; hblock++) { @@ -10962,7 +11010,7 @@ if (fp == NULL) { * of the executable. Failing that, we're out of luck. */ strncpy (fbuf, sim_argv[0], sizeof (fbuf)); - if ((p = match_ext (fbuf, "EXE"))) + if ((p = (char *)match_ext (fbuf, "EXE"))) *p = '\0'; if ((p = strrchr (fbuf, '\\'))) { p[1] = '\0'; diff --git a/scp.h b/scp.h index 7fe16b7..e849326 100644 --- a/scp.h +++ b/scp.h @@ -37,6 +37,10 @@ #ifndef SIM_SCP_H_ #define SIM_SCP_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + /* run_cmd parameters */ #define RU_RUN 0 /* run */ @@ -67,40 +71,40 @@ /* Command processors */ -t_stat reset_cmd (int32 flag, char *ptr); -t_stat exdep_cmd (int32 flag, char *ptr); -t_stat eval_cmd (int32 flag, char *ptr); -t_stat load_cmd (int32 flag, char *ptr); -t_stat run_cmd (int32 flag, char *ptr); +t_stat reset_cmd (int32 flag, CONST char *ptr); +t_stat exdep_cmd (int32 flag, CONST char *ptr); +t_stat eval_cmd (int32 flag, CONST char *ptr); +t_stat load_cmd (int32 flag, CONST char *ptr); +t_stat run_cmd (int32 flag, CONST char *ptr); void run_cmd_message (const char *unechod_cmdline, t_stat r); -t_stat attach_cmd (int32 flag, char *ptr); -t_stat detach_cmd (int32 flag, char *ptr); -t_stat assign_cmd (int32 flag, char *ptr); -t_stat deassign_cmd (int32 flag, char *ptr); -t_stat save_cmd (int32 flag, char *ptr); -t_stat restore_cmd (int32 flag, char *ptr); -t_stat exit_cmd (int32 flag, char *ptr); -t_stat set_cmd (int32 flag, char *ptr); -t_stat show_cmd (int32 flag, char *ptr); -t_stat set_default_cmd (int32 flg, char *cptr); -t_stat pwd_cmd (int32 flg, char *cptr); -t_stat dir_cmd (int32 flg, char *cptr); -t_stat type_cmd (int32 flg, char *cptr); -t_stat brk_cmd (int32 flag, char *ptr); -t_stat do_cmd (int32 flag, char *ptr); -t_stat goto_cmd (int32 flag, char *ptr); -t_stat return_cmd (int32 flag, char *ptr); -t_stat shift_cmd (int32 flag, char *ptr); -t_stat call_cmd (int32 flag, char *ptr); -t_stat on_cmd (int32 flag, char *ptr); -t_stat noop_cmd (int32 flag, char *ptr); -t_stat assert_cmd (int32 flag, char *ptr); -t_stat send_cmd (int32 flag, char *ptr); -t_stat expect_cmd (int32 flag, char *ptr); -t_stat help_cmd (int32 flag, char *ptr); -t_stat screenshot_cmd (int32 flag, char *ptr); -t_stat spawn_cmd (int32 flag, char *ptr); -t_stat echo_cmd (int32 flag, char *ptr); +t_stat attach_cmd (int32 flag, CONST char *ptr); +t_stat detach_cmd (int32 flag, CONST char *ptr); +t_stat assign_cmd (int32 flag, CONST char *ptr); +t_stat deassign_cmd (int32 flag, CONST char *ptr); +t_stat save_cmd (int32 flag, CONST char *ptr); +t_stat restore_cmd (int32 flag, CONST char *ptr); +t_stat exit_cmd (int32 flag, CONST char *ptr); +t_stat set_cmd (int32 flag, CONST char *ptr); +t_stat show_cmd (int32 flag, CONST char *ptr); +t_stat set_default_cmd (int32 flg, CONST char *cptr); +t_stat pwd_cmd (int32 flg, CONST char *cptr); +t_stat dir_cmd (int32 flg, CONST char *cptr); +t_stat type_cmd (int32 flg, CONST char *cptr); +t_stat brk_cmd (int32 flag, CONST char *ptr); +t_stat do_cmd (int32 flag, CONST char *ptr); +t_stat goto_cmd (int32 flag, CONST char *ptr); +t_stat return_cmd (int32 flag, CONST char *ptr); +t_stat shift_cmd (int32 flag, CONST char *ptr); +t_stat call_cmd (int32 flag, CONST char *ptr); +t_stat on_cmd (int32 flag, CONST char *ptr); +t_stat noop_cmd (int32 flag, CONST char *ptr); +t_stat assert_cmd (int32 flag, CONST char *ptr); +t_stat send_cmd (int32 flag, CONST char *ptr); +t_stat expect_cmd (int32 flag, CONST char *ptr); +t_stat help_cmd (int32 flag, CONST char *ptr); +t_stat screenshot_cmd (int32 flag, CONST char *ptr); +t_stat spawn_cmd (int32 flag, CONST char *ptr); +t_stat echo_cmd (int32 flag, CONST char *ptr); /* Allow compiler to help validate printf style format arguments */ #if !defined __GNUC__ @@ -128,9 +132,9 @@ t_stat sim_run_boot_prep (void); double sim_gtime (void); uint32 sim_grtime (void); int32 sim_qcount (void); -t_stat attach_unit (UNIT *uptr, char *cptr); +t_stat attach_unit (UNIT *uptr, CONST char *cptr); t_stat detach_unit (UNIT *uptr); -t_stat assign_device (DEVICE *dptr, char *cptr); +t_stat assign_device (DEVICE *dptr, const char *cptr); t_stat deassign_device (DEVICE *dptr); t_stat reset_all (uint32 start_device); t_stat reset_all_p (uint32 start_device); @@ -144,17 +148,17 @@ int sim_isprint (char c); int sim_isdigit (char c); int sim_isgraph (char c); int sim_isalnum (char c); -char *get_sim_opt (int32 opt, char *cptr, t_stat *st); -char *get_glyph (const char *iptr, char *optr, char mchar); -char *get_glyph_nc (const char *iptr, char *optr, char mchar); -char *get_glyph_quoted (const char *iptr, char *optr, char mchar); +CONST char *get_sim_opt (int32 opt, CONST char *cptr, t_stat *st); +CONST char *get_glyph (const char *iptr, char *optr, char mchar); +CONST char *get_glyph_nc (const char *iptr, char *optr, char mchar); +CONST char *get_glyph_quoted (const char *iptr, char *optr, char mchar); t_value get_uint (const char *cptr, uint32 radix, t_value max, t_stat *status); -const char *get_range (DEVICE *dptr, const char *cptr, t_addr *lo, t_addr *hi, +CONST char *get_range (DEVICE *dptr, CONST char *cptr, t_addr *lo, t_addr *hi, uint32 rdx, t_addr max, char term); t_stat sim_decode_quoted_string (const char *iptr, uint8 *optr, uint32 *osize); char *sim_encode_quoted_string (const uint8 *iptr, uint32 size); void fprint_buffer_string (FILE *st, const uint8 *buf, uint32 size); -t_value strtotv (const char *cptr, const char **endptr, uint32 radix); +t_value strtotv (CONST char *cptr, CONST char **endptr, uint32 radix); int Fprintf (FILE *f, const char* fmt, ...) GCC_FMT_ATTR(2, 3); t_stat sim_set_memory_load_file (const unsigned char *data, size_t size); int Fgetc (FILE *f); @@ -170,7 +174,7 @@ DEVICE *find_unit (const char *ptr, UNIT **uptr); DEVICE *find_dev_from_unit (UNIT *uptr); t_stat sim_register_internal_device (DEVICE *dptr); void sim_sub_args (char *in_str, size_t in_str_size, char *do_arg[]); -REG *find_reg (const char *ptr, const char **optr, DEVICE *dptr); +REG *find_reg (CONST char *ptr, CONST char **optr, DEVICE *dptr); CTAB *find_ctab (CTAB *tab, const char *gbuf); C1TAB *find_c1tab (C1TAB *tab, const char *gbuf); SHTAB *find_shtab (SHTAB *tab, const char *gbuf); @@ -181,23 +185,23 @@ void sim_brk_clrspc (uint32 spc); char *sim_brk_clract (void); void sim_brk_setact (const char *action); t_stat sim_send_input (SEND *snd, uint8 *data, size_t size, uint32 after, uint32 delay); -t_stat sim_show_send_input (FILE *st, SEND *snd); +t_stat sim_show_send_input (FILE *st, const SEND *snd); t_bool sim_send_poll_data (SEND *snd, t_stat *stat); t_stat sim_send_clear (SEND *snd); -t_stat sim_set_expect (EXPECT *exp, const char *cptr); +t_stat sim_set_expect (EXPECT *exp, CONST char *cptr); t_stat sim_set_noexpect (EXPECT *exp, const char *cptr); t_stat sim_exp_set (EXPECT *exp, const char *match, int32 cnt, uint32 after, int32 switches, const char *act); t_stat sim_exp_clr (EXPECT *exp, const char *match); t_stat sim_exp_clrall (EXPECT *exp); -t_stat sim_exp_show (FILE *st, EXPECT *exp, const char *match); -t_stat sim_exp_showall (FILE *st, EXPECT *exp); +t_stat sim_exp_show (FILE *st, CONST EXPECT *exp, const char *match); +t_stat sim_exp_showall (FILE *st, const EXPECT *exp); t_stat sim_exp_check (EXPECT *exp, uint8 data); -char *match_ext (char *fnam, const char *ext); -t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); +CONST char *match_ext (CONST char *fnam, const char *ext); +t_stat show_version (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat set_dev_debug (DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat show_dev_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); const char *sim_error_text (t_stat stat); -t_stat sim_string_to_stat (char *cptr, t_stat *cond); +t_stat sim_string_to_stat (const char *cptr, t_stat *cond); t_stat sim_cancel_step (void); void sim_printf (const char* fmt, ...) GCC_FMT_ATTR(1, 2); void sim_perror (const char* msg); @@ -210,6 +214,15 @@ void sim_debug_bits (uint32 dbits, DEVICE* dptr, BITFIELD* bitdefs, #if defined (__DECC) && defined (__VMS) && (defined (__VAX) || (__DECC_VER < 60590001)) #define CANT_USE_MACRO_VA_ARGS 1 #endif +#if defined(__cplusplus) +#ifdef CANT_USE_MACRO_VA_ARGS +#define _sim_debug sim_debug +void sim_debug (uint32 dbits, void* dptr, const char* fmt, ...) GCC_FMT_ATTR(3, 4); +#else +void _sim_debug (uint32 dbits, void* dptr, const char* fmt, ...) GCC_FMT_ATTR(3, 4); +#define sim_debug(dbits, dptr, ...) do { if (sim_deb && dptr && ((dptr)->dctrl & dbits)) _sim_debug (dbits, dptr, __VA_ARGS__);} while (0) +#endif +#else #ifdef CANT_USE_MACRO_VA_ARGS #define _sim_debug sim_debug void sim_debug (uint32 dbits, DEVICE* dptr, const char* fmt, ...) GCC_FMT_ATTR(3, 4); @@ -217,6 +230,7 @@ void sim_debug (uint32 dbits, DEVICE* dptr, const char* fmt, ...) GCC_FMT_ATTR(3 void _sim_debug (uint32 dbits, DEVICE* dptr, const char* fmt, ...) GCC_FMT_ATTR(3, 4); #define sim_debug(dbits, dptr, ...) do { if (sim_deb && dptr && ((dptr)->dctrl & dbits)) _sim_debug (dbits, dptr, __VA_ARGS__);} while (0) #endif +#endif void fprint_stopped_gen (FILE *st, t_stat v, REG *pc, DEVICE *dptr); #define SCP_HELP_FLAT (1u << 31) /* Force flat help when prompting is not possible */ #define SCP_HELP_ONECMD (1u << 30) /* Display one topic, do not prompt */ @@ -268,24 +282,28 @@ extern DEVICE *sim_devices[]; extern REG *sim_PC; extern const char *sim_stop_messages[]; extern t_stat sim_instr (void); -extern t_stat sim_load (FILE *ptr, char *cptr, char *fnam, int flag); +extern t_stat sim_load (FILE *ptr, CONST char *cptr, CONST char *fnam, int flag); extern int32 sim_emax; extern t_stat fprint_sym (FILE *ofile, t_addr addr, t_value *val, UNIT *uptr, int32 sw); -extern t_stat parse_sym (char *cptr, t_addr addr, UNIT *uptr, t_value *val, +extern t_stat parse_sym (CONST char *cptr, t_addr addr, UNIT *uptr, t_value *val, int32 sw); /* The per-simulator init routine is a weak global that defaults to NULL The other per-simulator pointers can be overrriden by the init routine */ -extern void (*sim_vm_init) (void); +WEAK extern void (*sim_vm_init) (void); extern char* (*sim_vm_read) (char *ptr, int32 size, FILE *stream); extern void (*sim_vm_post) (t_bool from_scp); extern CTAB *sim_vm_cmd; extern void (*sim_vm_fprint_addr) (FILE *st, DEVICE *dptr, t_addr addr); -extern t_addr (*sim_vm_parse_addr) (DEVICE *dptr, const char *cptr, const char **tptr); +extern t_addr (*sim_vm_parse_addr) (DEVICE *dptr, CONST char *cptr, CONST char **tptr); extern t_bool (*sim_vm_fprint_stopped) (FILE *st, t_stat reason); extern t_value (*sim_vm_pc_value) (void); extern t_bool (*sim_vm_is_subroutine_call) (t_addr **ret_addrs); +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_card.c b/sim_card.c index 4a0df40..f428320 100644 --- a/sim_card.c +++ b/sim_card.c @@ -62,6 +62,8 @@ and the backward translation table. Which is generated from the table. */ +#if defined(USE_SIM_CARD) + #include #include "sim_defs.h" #include "sim_card.h" @@ -904,7 +906,7 @@ sim_punch_card(UNIT * uptr, UNIT *stkuptr) } /* Set card format */ -t_stat sim_card_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_card_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { int f; @@ -921,7 +923,7 @@ t_stat sim_card_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc) /* Show card format */ -t_stat sim_card_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_card_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { int f; @@ -937,7 +939,7 @@ t_stat sim_card_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc) t_stat -sim_card_attach(UNIT * uptr, char *cptr) +sim_card_attach(UNIT * uptr, CONST char *cptr) { t_stat r; struct _card_data *data; @@ -1033,4 +1035,4 @@ t_stat sim_card_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, cons return SCPE_OK; } - +#endif /* USE_SIM_CARD */ diff --git a/sim_card.h b/sim_card.h index a1f23c4..ae67347 100644 --- a/sim_card.h +++ b/sim_card.h @@ -60,6 +60,14 @@ */ + +#ifndef SIM_CARD_H_ +#define SIM_CARD_H_ 0 + +#ifdef __cplusplus +extern "C" { +#endif + #define DEBUG_CARD 0x0000010 /* Show details */ /* Flags for punch and reader. */ @@ -91,7 +99,7 @@ struct _card_data t_stat sim_read_card(UNIT * uptr); int sim_card_eof(UNIT * uptr); t_stat sim_punch_card(UNIT * uptr, UNIT *stkptr); -t_stat sim_card_attach(UNIT * uptr, char *file); +t_stat sim_card_attach(UNIT * uptr, CONST char *file); t_stat sim_card_detach(UNIT *uptr); /* Conversion routines to save code */ @@ -101,8 +109,8 @@ uint8 sim_hol_to_bcd(uint16 hol); uint8 sim_hol_to_ebbcd(uint16 hol); /* Format control routines. */ -t_stat sim_card_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_card_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat sim_card_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_card_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc); /* Help information */ t_stat sim_card_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -111,3 +119,9 @@ t_stat sim_card_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, cons const char sim_six_to_ascii[64]; const char sim_ascii_to_six[128]; const uint8 sim_parity_table[64]; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/sim_console.c b/sim_console.c index 8a27195..5b03055 100644 --- a/sim_console.c +++ b/sim_console.c @@ -146,15 +146,15 @@ static t_stat sim_os_ttcmd (void); static t_stat sim_os_ttclose (void); static t_bool sim_os_ttisatty (void); -static t_stat sim_set_rem_telnet (int32 flag, char *cptr); -static t_stat sim_set_rem_connections (int32 flag, char *cptr); -static t_stat sim_set_rem_timeout (int32 flag, char *cptr); -static t_stat sim_set_rem_master (int32 flag, char *cptr); +static t_stat sim_set_rem_telnet (int32 flag, CONST char *cptr); +static t_stat sim_set_rem_connections (int32 flag, CONST char *cptr); +static t_stat sim_set_rem_timeout (int32 flag, CONST char *cptr); +static t_stat sim_set_rem_master (int32 flag, CONST char *cptr); /* Deprecated CONSOLE HALT, CONSOLE RESPONSE and CONSOLE DELAY support */ -static t_stat sim_set_halt (int32 flag, char *cptr); -static t_stat sim_set_response (int32 flag, char *cptr); -static t_stat sim_set_delay (int32 flag, char *cptr); +static t_stat sim_set_halt (int32 flag, CONST char *cptr); +static t_stat sim_set_response (int32 flag, CONST char *cptr); +static t_stat sim_set_delay (int32 flag, CONST char *cptr); #define KMAP_WRU 0 @@ -337,7 +337,7 @@ static int32 *cons_kmap[] = { /* SET CONSOLE command */ -t_stat sim_set_console (int32 flag, char *cptr) +t_stat sim_set_console (int32 flag, CONST char *cptr) { char *cvptr, gbuf[CBUFSIZE]; CTAB *ctptr; @@ -362,7 +362,7 @@ return SCPE_OK; /* SHOW CONSOLE command */ -t_stat sim_show_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; SHTAB *shptr; @@ -427,7 +427,7 @@ static t_offset sim_rem_cmd_log_start = 0; /* Log File saved position */ /* SET REMOTE CONSOLE command */ -t_stat sim_set_remote_console (int32 flag, char *cptr) +t_stat sim_set_remote_console (int32 flag, CONST char *cptr) { char *cvptr, gbuf[CBUFSIZE]; CTAB *ctptr; @@ -452,7 +452,7 @@ return SCPE_OK; /* SHOW REMOTE CONSOLE command */ -t_stat sim_show_remote_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_remote_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { int32 i, connections; TMLN *lp; @@ -529,22 +529,22 @@ if (sim_con_ldsc.conn) return SCPE_OK; } -static t_stat x_continue_cmd (int32 flag, char *cptr) +static t_stat x_continue_cmd (int32 flag, CONST char *cptr) { return SCPE_IERR; /* This routine should never be called */ } -static t_stat x_step_cmd (int32 flag, char *cptr) +static t_stat x_step_cmd (int32 flag, CONST char *cptr) { return SCPE_IERR; /* This routine should never be called */ } -static t_stat x_run_cmd (int32 flag, char *cptr) +static t_stat x_run_cmd (int32 flag, CONST char *cptr) { return SCPE_IERR; /* This routine should never be called */ } -static t_stat x_help_cmd (int32 flag, char *cptr); +static t_stat x_help_cmd (int32 flag, CONST char *cptr); static CTAB allowed_remote_cmds[] = { { "EXAMINE", &exdep_cmd, EX_E }, @@ -610,7 +610,7 @@ static CTAB allowed_single_remote_cmds[] = { { NULL, NULL } }; -static t_stat x_help_cmd (int32 flag, char *cptr) +static t_stat x_help_cmd (int32 flag, CONST char *cptr) { CTAB *cmdp, *cmdph; @@ -675,7 +675,8 @@ if (sim_log) { void sim_remote_process_command (void) { -char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *cptr, *argv[1] = {NULL}; +char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *argv[1] = {NULL}; +CONST char *cptr; int32 saved_switches = sim_switches; t_stat stat; @@ -710,7 +711,8 @@ t_bool was_active_command = (sim_rem_cmd_active_line != -1); t_bool got_command; t_bool close_session = FALSE; TMLN *lp; -char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *cptr, *argv[1] = {NULL}; +char cbuf[4*CBUFSIZE], gbuf[CBUFSIZE], *argv[1] = {NULL}; +CONST char *cptr; CTAB *cmdp = NULL; CTAB *basecmdp = NULL; uint32 read_start_time = 0; @@ -1113,7 +1115,7 @@ if (sim_rem_con_tmxr.lines) { return SCPE_OK; } -static t_stat sim_set_rem_telnet (int32 flag, char *cptr) +static t_stat sim_set_rem_telnet (int32 flag, CONST char *cptr) { t_stat r; @@ -1150,7 +1152,7 @@ else { return SCPE_OK; } -static t_stat sim_set_rem_connections (int32 flag, char *cptr) +static t_stat sim_set_rem_connections (int32 flag, CONST char *cptr) { int32 lines; t_stat r; @@ -1183,7 +1185,7 @@ memset (sim_rem_command_buf, 0, 4*CBUFSIZE+1); return SCPE_OK; } -static t_stat sim_set_rem_timeout (int32 flag, char *cptr) +static t_stat sim_set_rem_timeout (int32 flag, CONST char *cptr) { int32 timeout; t_stat r; @@ -1208,7 +1210,7 @@ return SCPE_OK; mode or the simulator exits */ -static t_stat sim_set_rem_master (int32 flag, char *cptr) +static t_stat sim_set_rem_master (int32 flag, CONST char *cptr) { t_stat stat = SCPE_OK; @@ -1267,7 +1269,7 @@ return stat; /* Set keyboard map */ -t_stat sim_set_kmap (int32 flag, char *cptr) +t_stat sim_set_kmap (int32 flag, CONST char *cptr) { DEVICE *dptr = sim_devices[0]; int32 val, rdx; @@ -1287,7 +1289,7 @@ return SCPE_OK; /* Show keyboard map */ -t_stat sim_show_kmap (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_kmap (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (sim_devices[0]->dradix == 16) fprintf (st, "%s = %X\n", show_con_tab[flag].name, *(cons_kmap[flag & KMAP_MASK])); @@ -1297,7 +1299,7 @@ return SCPE_OK; /* Set printable characters */ -t_stat sim_set_pchar (int32 flag, char *cptr) +t_stat sim_set_pchar (int32 flag, CONST char *cptr) { DEVICE *dptr = sim_devices[0]; uint32 val, rdx; @@ -1317,16 +1319,16 @@ return SCPE_OK; /* Show printable characters */ -t_stat sim_show_pchar (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_pchar (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (sim_devices[0]->dradix == 16) fprintf (st, "pchar mask = %X", sim_tt_pchar); else fprintf (st, "pchar mask = %o", sim_tt_pchar); if (sim_tt_pchar) { - static char *pchars[] = {"NUL(^@)", "SOH(^A)", "STX(^B)", "ETX(^C)", "EOT(^D)", "ENQ(^E)", "ACK(^F)", "BEL(^G)", - "BS(^H)" , "HT(^I)", "LF(^J)", "VT(^K)", "FF(^L)", "CR(^M)", "SO(^N)", "SI(^O)", - "DLE(^P)", "DC1(^Q)", "DC2(^R)", "DC3(^S)", "DC4(^T)", "NAK(^U)", "SYN(^V)", "ETB(^W)", - "CAN(^X)", "EM(^Y)", "SUB(^Z)", "ESC", "FS", "GS", "RS", "US"}; + static const char *pchars[] = {"NUL(^@)", "SOH(^A)", "STX(^B)", "ETX(^C)", "EOT(^D)", "ENQ(^E)", "ACK(^F)", "BEL(^G)", + "BS(^H)" , "HT(^I)", "LF(^J)", "VT(^K)", "FF(^L)", "CR(^M)", "SO(^N)", "SI(^O)", + "DLE(^P)", "DC1(^Q)", "DC2(^R)", "DC3(^S)", "DC4(^T)", "NAK(^U)", "SYN(^V)", "ETB(^W)", + "CAN(^X)", "EM(^Y)", "SUB(^Z)", "ESC", "FS", "GS", "RS", "US"}; int i; t_bool found = FALSE; @@ -1344,12 +1346,12 @@ return SCPE_OK; /* Set input speed (bps) */ -t_stat sim_set_cons_speed (int32 flag, char *cptr) +t_stat sim_set_cons_speed (int32 flag, CONST char *cptr) { return tmxr_set_line_speed (&sim_con_ldsc, cptr); } -t_stat sim_show_cons_speed (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_cons_speed (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (sim_con_ldsc.rxbps) { fprintf (st, "Speed = %d", sim_con_ldsc.rxbps); @@ -1362,7 +1364,7 @@ return SCPE_OK; /* Set log routine */ -t_stat sim_set_logon (int32 flag, char *cptr) +t_stat sim_set_logon (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; t_stat r; @@ -1389,7 +1391,7 @@ return SCPE_OK; /* Set nolog routine */ -t_stat sim_set_logoff (int32 flag, char *cptr) +t_stat sim_set_logoff (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -1405,7 +1407,7 @@ return SCPE_OK; /* Show log status */ -t_stat sim_show_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -1418,7 +1420,7 @@ return SCPE_OK; /* Set debug routine */ -t_stat sim_set_debon (int32 flag, char *cptr) +t_stat sim_set_debon (int32 flag, CONST char *cptr) { char gbuf[CBUFSIZE]; t_stat r; @@ -1488,7 +1490,7 @@ return SCPE_OK; /* Set nodebug routine */ -t_stat sim_set_deboff (int32 flag, char *cptr) +t_stat sim_set_deboff (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* now eol? */ return SCPE_2MARG; @@ -1504,7 +1506,7 @@ return SCPE_OK; /* Show debug routine */ -t_stat sim_show_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { int32 i; @@ -1544,7 +1546,7 @@ return SCPE_OK; /* Set console to Telnet port (and parameters) */ -t_stat sim_set_telnet (int32 flag, char *cptr) +t_stat sim_set_telnet (int32 flag, CONST char *cptr) { char *cvptr, gbuf[CBUFSIZE]; CTAB *ctptr; @@ -1577,7 +1579,7 @@ return SCPE_OK; /* Close console Telnet port */ -t_stat sim_set_notelnet (int32 flag, char *cptr) +t_stat sim_set_notelnet (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* too many arguments? */ return SCPE_2MARG; @@ -1588,7 +1590,7 @@ return tmxr_close_master (&sim_con_tmxr); /* close master socket * /* Show console Telnet status */ -t_stat sim_show_telnet (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, char *cptr) +t_stat sim_show_telnet (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -1615,7 +1617,7 @@ return SCPE_OK; /* Set console to Buffering */ -t_stat sim_set_cons_buff (int32 flg, char *cptr) +t_stat sim_set_cons_buff (int32 flg, CONST char *cptr) { char cmdbuf[CBUFSIZE]; @@ -1625,7 +1627,7 @@ return tmxr_open_master (&sim_con_tmxr, cmdbuf); /* open master socket */ /* Set console to NoBuffering */ -t_stat sim_set_cons_unbuff (int32 flg, char *cptr) +t_stat sim_set_cons_unbuff (int32 flg, CONST char *cptr) { char cmdbuf[CBUFSIZE]; @@ -1635,7 +1637,7 @@ return tmxr_open_master (&sim_con_tmxr, cmdbuf); /* open master socket */ /* Set console to Logging */ -t_stat sim_set_cons_log (int32 flg, char *cptr) +t_stat sim_set_cons_log (int32 flg, CONST char *cptr) { char cmdbuf[CBUFSIZE]; @@ -1645,7 +1647,7 @@ return tmxr_open_master (&sim_con_tmxr, cmdbuf); /* open master socket */ /* Set console to NoLogging */ -t_stat sim_set_cons_nolog (int32 flg, char *cptr) +t_stat sim_set_cons_nolog (int32 flg, CONST char *cptr) { char cmdbuf[CBUFSIZE]; @@ -1653,7 +1655,7 @@ sprintf(cmdbuf, "NOLOG%c%s", cptr ? '=' : '\0', cptr ? cptr : ""); return tmxr_open_master (&sim_con_tmxr, cmdbuf); /* open master socket */ } -t_stat sim_show_cons_log (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, char *cptr) +t_stat sim_show_cons_log (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -1664,7 +1666,7 @@ else return SCPE_OK; } -t_stat sim_show_cons_buff (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, char *cptr) +t_stat sim_show_cons_buff (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -1677,12 +1679,12 @@ return SCPE_OK; /* Set console Debug Mode */ -t_stat sim_set_cons_debug (int32 flg, char *cptr) +t_stat sim_set_cons_debug (int32 flg, CONST char *cptr) { return set_dev_debug (&sim_con_telnet, &sim_con_unit, flg, cptr); } -t_stat sim_show_cons_debug (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, char *cptr) +t_stat sim_show_cons_debug (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) return SCPE_2MARG; @@ -1691,7 +1693,7 @@ return show_dev_debug (st, &sim_con_telnet, &sim_con_unit, flag, cptr); /* Set console to Serial port (and parameters) */ -t_stat sim_set_serial (int32 flag, char *cptr) +t_stat sim_set_serial (int32 flag, CONST char *cptr) { char *cvptr, gbuf[CBUFSIZE], ubuf[CBUFSIZE]; CTAB *ctptr; @@ -1734,7 +1736,7 @@ return SCPE_OK; /* Close console Serial port */ -t_stat sim_set_noserial (int32 flag, char *cptr) +t_stat sim_set_noserial (int32 flag, CONST char *cptr) { if (cptr && (*cptr != 0)) /* too many arguments? */ return SCPE_2MARG; @@ -1745,7 +1747,7 @@ return tmxr_close_master (&sim_con_tmxr); /* close master socket * /* Show the console expect rules and state */ -t_stat sim_show_cons_expect (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, char *cptr) +t_stat sim_show_cons_expect (FILE *st, DEVICE *dunused, UNIT *uunused, int32 flag, CONST char *cptr) { return sim_exp_show (st, &sim_con_expect, cptr); } @@ -1754,9 +1756,10 @@ return sim_exp_show (st, &sim_con_expect, cptr); /* Open log file */ -t_stat sim_open_logfile (char *filename, t_bool binary, FILE **pf, FILEREF **pref) +t_stat sim_open_logfile (const char *filename, t_bool binary, FILE **pf, FILEREF **pref) { -char *tptr, gbuf[CBUFSIZE]; +char gbuf[CBUFSIZE]; +const char *tptr; if ((filename == NULL) || (*filename == 0)) /* too few arguments? */ return SCPE_2FARG; @@ -1938,7 +1941,7 @@ return &sim_con_expect; /* Display console Queued input data status */ -t_stat sim_show_cons_send_input (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_cons_send_input (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { return sim_show_send_input (st, &sim_con_send); } @@ -2091,7 +2094,7 @@ return c; Columns with tabs set are non-zero; columns without tabs are 0 */ -t_stat sim_tt_settabs (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_tt_settabs (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { uint8 *temptabs, *tabs = (uint8 *) desc; int32 i, d; @@ -2121,9 +2124,9 @@ free (temptabs); return SCPE_OK; } -t_stat sim_tt_showtabs (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_tt_showtabs (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { -uint8 *tabs = (uint8 *) desc; +const uint8 *tabs = (const uint8 *) desc; int32 i, any; if ((st == NULL) || (val == 0) || (desc == NULL)) @@ -3185,7 +3188,7 @@ return; /* Set console halt */ -static t_stat sim_set_halt (int32 flag, char *cptr) +static t_stat sim_set_halt (int32 flag, CONST char *cptr) { if (flag == 0) /* no halt? */ sim_exp_clrall (&sim_con_expect); /* disable halt checks */ @@ -3218,7 +3221,7 @@ return SCPE_OK; /* Set console response */ -static t_stat sim_set_response (int32 flag, char *cptr) +static t_stat sim_set_response (int32 flag, CONST char *cptr) { if (flag == 0) /* no response? */ sim_send_clear (&sim_con_send); @@ -3240,7 +3243,7 @@ return SCPE_OK; /* Set console delay */ -static t_stat sim_set_delay (int32 flag, char *cptr) +static t_stat sim_set_delay (int32 flag, CONST char *cptr) { int32 val; t_stat r; diff --git a/sim_console.h b/sim_console.h index a1ff8f6..a36d452 100644 --- a/sim_console.h +++ b/sim_console.h @@ -35,6 +35,10 @@ #ifndef SIM_CONSOLE_H_ #define SIM_CONSOLE_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + #define TTUF_V_MODE (UNIT_V_UF + 0) #define TTUF_W_MODE 2 #define TTUF_MODE_7B 0 @@ -67,47 +71,47 @@ since they together are passed into sim_tt_inpcvt() */ #define TT_GET_MODE(x) (((x) >> TTUF_V_MODE) & (TTUF_M_MODE | (TTUF_M_PAR << TTUF_W_MODE))) -t_stat sim_set_console (int32 flag, char *cptr); -t_stat sim_set_remote_console (int32 flag, char *cptr); +t_stat sim_set_console (int32 flag, CONST char *cptr); +t_stat sim_set_remote_console (int32 flag, CONST char *cptr); void sim_remote_process_command (void); -t_stat sim_set_kmap (int32 flag, char *cptr); -t_stat sim_set_telnet (int32 flag, char *cptr); -t_stat sim_set_notelnet (int32 flag, char *cptr); -t_stat sim_set_serial (int32 flag, char *cptr); -t_stat sim_set_noserial (int32 flag, char *cptr); -t_stat sim_set_logon (int32 flag, char *cptr); -t_stat sim_set_logoff (int32 flag, char *cptr); -t_stat sim_set_debon (int32 flag, char *cptr); -t_stat sim_set_cons_debug (int32 flg, char *cptr); -t_stat sim_set_cons_buff (int32 flg, char *cptr); -t_stat sim_set_cons_unbuff (int32 flg, char *cptr); -t_stat sim_set_cons_log (int32 flg, char *cptr); -t_stat sim_set_cons_nolog (int32 flg, char *cptr); -t_stat sim_set_deboff (int32 flag, char *cptr); -t_stat sim_set_cons_expect (int32 flg, char *cptr); -t_stat sim_set_cons_noexpect (int32 flg, char *cptr); +t_stat sim_set_kmap (int32 flag, CONST char *cptr); +t_stat sim_set_telnet (int32 flag, CONST char *cptr); +t_stat sim_set_notelnet (int32 flag, CONST char *cptr); +t_stat sim_set_serial (int32 flag, CONST char *cptr); +t_stat sim_set_noserial (int32 flag, CONST char *cptr); +t_stat sim_set_logon (int32 flag, CONST char *cptr); +t_stat sim_set_logoff (int32 flag, CONST char *cptr); +t_stat sim_set_debon (int32 flag, CONST char *cptr); +t_stat sim_set_cons_debug (int32 flg, CONST char *cptr); +t_stat sim_set_cons_buff (int32 flg, CONST char *cptr); +t_stat sim_set_cons_unbuff (int32 flg, CONST char *cptr); +t_stat sim_set_cons_log (int32 flg, CONST char *cptr); +t_stat sim_set_cons_nolog (int32 flg, CONST char *cptr); +t_stat sim_set_deboff (int32 flag, CONST char *cptr); +t_stat sim_set_cons_expect (int32 flg, CONST char *cptr); +t_stat sim_set_cons_noexpect (int32 flg, CONST char *cptr); t_stat sim_debug_flush (void); -t_stat sim_set_pchar (int32 flag, char *cptr); -t_stat sim_set_cons_speed (int32 flag, char *cptr); -t_stat sim_show_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_remote_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_kmap (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_telnet (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_pchar (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_cons_speed (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_cons_buff (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_cons_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_cons_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); -t_stat sim_show_cons_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); +t_stat sim_set_pchar (int32 flag, CONST char *cptr); +t_stat sim_set_cons_speed (int32 flag, CONST char *cptr); +t_stat sim_show_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_remote_console (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_kmap (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_telnet (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_pchar (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_cons_speed (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_cons_buff (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_cons_log (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_cons_debug (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); +t_stat sim_show_cons_expect (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); t_stat sim_check_console (int32 sec); -t_stat sim_open_logfile (char *filename, t_bool binary, FILE **pf, FILEREF **pref); +t_stat sim_open_logfile (const char *filename, t_bool binary, FILE **pf, FILEREF **pref); t_stat sim_close_logfile (FILEREF **pref); const char *sim_logfile_name (FILE *st, FILEREF *ref); SEND *sim_cons_get_send (void); EXPECT *sim_cons_get_expect (void); -t_stat sim_show_cons_send_input (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); +t_stat sim_show_cons_send_input (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); t_stat sim_set_noconsole_port (void); t_stat sim_poll_kbd (void); t_stat sim_putchar (int32 c); @@ -119,8 +123,8 @@ t_stat sim_ttclose (void); t_bool sim_ttisatty (void); int32 sim_tt_inpcvt (int32 c, uint32 mode); int32 sim_tt_outcvt (int32 c, uint32 mode); -t_stat sim_tt_settabs (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_tt_showtabs (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat sim_tt_settabs (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_tt_showtabs (FILE *st, UNIT *uptr, int32 val, CONST void *desc); extern int32 sim_rem_cmd_active_line; /* command in progress on line # */ @@ -129,4 +133,8 @@ extern int32 sim_brk_char; /* break character * extern int32 sim_tt_pchar; /* printable character mask */ extern int32 sim_del_char; /* delete character */ +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_defs.h b/sim_defs.h index 9cca1b7..37dea61 100644 --- a/sim_defs.h +++ b/sim_defs.h @@ -135,6 +135,10 @@ #define USE_REGEX 1 #endif +#ifdef __cplusplus +extern "C" { +#endif + /* avoid macro names collisions */ #ifdef MAX #undef MAX @@ -158,6 +162,18 @@ #define FALSE 0 #endif +/* SCP API shim. + + The SCP API for version 4.0 introduces a number of "pointer-to-const" + parameter qualifiers that were not present in the 3.x versions. To maintain + compatibility with the earlier versions, the new qualifiers are expressed as + "CONST" rather than "const". This allows macro removal of the qualifiers + when compiling for SIMH 3.x. +*/ +#ifndef CONST +#define CONST const +#endif + /* Length specific integer declarations */ #if defined (VMS) @@ -257,6 +273,20 @@ typedef uint32 t_addr; #define SIM_INLINE #endif +/* Storage class modifier for weak link definition for sim_vm_init() */ + +#if defined(__cplusplus) +#if defined(__GNUC__) +#define WEAK __attribute__((weak)) +#elif defined(_MSC_VER) +#define WEAK __declspec(selectany) +#else +#define WEAK extern +#endif +#else +#define WEAK +#endif + /* System independent definitions */ #define FLIP_SIZE (1 << 16) /* flip buf size */ @@ -417,14 +447,14 @@ struct DEVICE { t_stat (*reset)(DEVICE *dp); /* reset routine */ t_stat (*boot)(int32 u, DEVICE *dp); /* boot routine */ - t_stat (*attach)(UNIT *up, char *cp); + t_stat (*attach)(UNIT *up, CONST char *cp); /* attach routine */ t_stat (*detach)(UNIT *up); /* detach routine */ void *ctxt; /* context */ uint32 flags; /* flags */ uint32 dctrl; /* debug control */ DEBTAB *debflags; /* debug flags */ - t_stat (*msize)(UNIT *up, int32 v, char *cp, void *dp); + t_stat (*msize)(UNIT *up, int32 v, CONST char *cp, void *dp); /* mem size routine */ char *lname; /* logical name */ t_stat (*help)(FILE *st, DEVICE *dptr, @@ -434,8 +464,7 @@ struct DEVICE { UNIT *uptr, int32 flag, const char *cptr); /* attach help */ void *help_ctx; /* Context available to help routines */ - const char *(*description)(DEVICE *dptr); - /* Device Description */ + const char *(*description)(DEVICE *dptr); /* Device Description */ }; /* Device flags */ @@ -578,7 +607,7 @@ struct BITFIELD { /* Register data structure */ struct REG { - const char *name; /* name */ + CONST char *name; /* name */ void *loc; /* location */ uint32 radix; /* radix */ uint32 width; /* width */ @@ -613,7 +642,7 @@ struct REG { struct CTAB { const char *name; /* name */ - t_stat (*action)(int32 flag, char *cptr); + t_stat (*action)(int32 flag, CONST char *cptr); /* action routine */ int32 arg; /* argument */ const char *help; /* help string/structured locator */ @@ -625,7 +654,7 @@ struct CTAB { struct C1TAB { const char *name; /* name */ t_stat (*action)(DEVICE *dptr, UNIT *uptr, - int32 flag, char *cptr); /* action routine */ + int32 flag, CONST char *cptr);/* action routine */ int32 arg; /* argument */ const char *help; /* help string */ }; @@ -633,7 +662,7 @@ struct C1TAB { struct SHTAB { const char *name; /* name */ t_stat (*action)(FILE *st, DEVICE *dptr, - UNIT *uptr, int32 flag, char *cptr); + UNIT *uptr, int32 flag, CONST char *cptr); int32 arg; /* argument */ const char *help; /* help string */ }; @@ -645,9 +674,9 @@ struct MTAB { uint32 match; /* match */ const char *pstring; /* print string */ const char *mstring; /* match string */ - t_stat (*valid)(UNIT *up, int32 v, char *cp, void *dp); + t_stat (*valid)(UNIT *up, int32 v, CONST char *cp, void *dp); /* validation routine */ - t_stat (*disp)(FILE *st, UNIT *up, int32 v, void *dp); + t_stat (*disp)(FILE *st, UNIT *up, int32 v, CONST void *dp); /* display routine */ void *desc; /* value descriptor */ /* REG * if MTAB_VAL */ @@ -866,7 +895,6 @@ struct FILEREF { #define STRDATADF(nm,loc,rdx,wd,off,dep,siz,fl,desc,flds) \ REGDATA(nm,(loc),(rdx),(wd),(off),(dep),(desc),(flds),((fl) | REG_STRUCT),0,(siz)) - /* Function prototypes */ #include "scp.h" @@ -1177,8 +1205,8 @@ extern int32 sim_asynch_inst_latency; #else #error "Implementation of function InterlockedCompareExchangePointer() is needed to build with USE_AIO_INTRINSICS" #endif -#define AIO_QUEUE_VAL (UNIT *)(InterlockedCompareExchangePointer(&sim_asynch_queue, sim_asynch_queue, NULL)) -#define AIO_QUEUE_SET(val, queue) (UNIT *)(InterlockedCompareExchangePointer(&sim_asynch_queue, val, queue)) +#define AIO_QUEUE_VAL (UNIT *)(InterlockedCompareExchangePointer((void * volatile *)&sim_asynch_queue, (void *)sim_asynch_queue, NULL)) +#define AIO_QUEUE_SET(val, queue) (UNIT *)(InterlockedCompareExchangePointer((void * volatile *)&sim_asynch_queue, (void *)val, queue)) #define AIO_UPDATE_QUEUE \ if (AIO_QUEUE_VAL != QUEUE_LIST_END) { /* List !Empty */ \ UNIT *q, *uptr; \ @@ -1402,4 +1430,8 @@ extern int32 sim_asynch_inst_latency; #define AIO_TLS #endif /* SIM_ASYNCH_IO */ +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_disk.c b/sim_disk.c index bbda60d..5bc0de8 100644 --- a/sim_disk.c +++ b/sim_disk.c @@ -309,7 +309,7 @@ static struct sim_disk_fmt fmts[DKUF_N_FMT] = { /* Set disk format */ -t_stat sim_disk_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_disk_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { uint32 f; @@ -331,7 +331,7 @@ return SCPE_ARG; /* Show disk format */ -t_stat sim_disk_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_disk_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { int32 f = DK_GET_FMT (uptr); size_t i; @@ -347,7 +347,7 @@ return SCPE_OK; /* Set disk capacity */ -t_stat sim_disk_set_capac (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_disk_set_capac (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { t_offset cap; t_stat r; @@ -366,7 +366,7 @@ return SCPE_OK; /* Show disk capacity */ -t_stat sim_disk_show_capac (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_disk_show_capac (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { const char *cap_units = "B"; DEVICE *dptr = find_dev_from_unit (uptr); @@ -842,11 +842,12 @@ return stat; } -t_stat sim_disk_attach (UNIT *uptr, char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, +t_stat sim_disk_attach (UNIT *uptr, const char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, uint32 dbit, const char *dtype, uint32 pdp11tracksize, int completion_delay) { struct disk_context *ctx; DEVICE *dptr; +char tbuf[4*CBUFSIZE]; FILE *(*open_function)(const char *filename, const char *mode) = sim_fopen; FILE *(*create_function)(const char *filename, t_offset desiredsize) = NULL; t_offset (*size_function)(FILE *file); @@ -1010,7 +1011,9 @@ if (sim_switches & SWMASK ('C')) { /* create vhd disk & cop if (r == SCPE_OK) { created = TRUE; copied = TRUE; - strcpy (cptr, gbuf); + tbuf[sizeof(tbuf)-1] = '\0'; + strncpy (tbuf, gbuf, sizeof(tbuf)-1); + cptr = tbuf; sim_disk_set_fmt (uptr, 0, "VHD", NULL); sim_switches = saved_sim_switches; } @@ -1781,7 +1784,7 @@ if (strchr (openmode, 'w') || strchr (openmode, '+')) We handle the RAW device name case here by prepending paths beginning with \.\ with an extra \. */ if (!memcmp ("\\.\\", rawdevicename, 3)) { - char *tmpname = malloc (2 + strlen (rawdevicename)); + char *tmpname = (char *)malloc (2 + strlen (rawdevicename)); if (tmpname == NULL) return NULL; diff --git a/sim_disk.h b/sim_disk.h index a95ff36..b8cf5f8 100644 --- a/sim_disk.h +++ b/sim_disk.h @@ -30,6 +30,10 @@ #ifndef SIM_DISK_H_ #define SIM_DISK_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + /* SIMH/Disk format */ typedef uint32 t_seccnt; /* disk sector count */ @@ -64,7 +68,7 @@ typedef void (*DISK_PCALLBACK)(UNIT *unit, t_stat status); /* Prototypes */ -t_stat sim_disk_attach (UNIT *uptr, char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, +t_stat sim_disk_attach (UNIT *uptr, const char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, uint32 debugbit, const char *drivetype, uint32 pdp11_tracksize, int completion_delay); t_stat sim_disk_detach (UNIT *uptr); t_stat sim_disk_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -73,10 +77,10 @@ t_stat sim_disk_rdsect_a (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectsread t_stat sim_disk_wrsect (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectswritten, t_seccnt sects); t_stat sim_disk_wrsect_a (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectswritten, t_seccnt sects, DISK_PCALLBACK callback); t_stat sim_disk_unload (UNIT *uptr); -t_stat sim_disk_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_disk_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat sim_disk_set_capac (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_disk_show_capac (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat sim_disk_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_disk_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat sim_disk_set_capac (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_disk_show_capac (FILE *st, UNIT *uptr, int32 val, CONST void *desc); t_stat sim_disk_set_asynch (UNIT *uptr, int latency); t_stat sim_disk_clr_asynch (UNIT *uptr); t_stat sim_disk_reset (UNIT *uptr); @@ -90,4 +94,8 @@ t_bool sim_disk_vhd_support (void); t_bool sim_disk_raw_support (void); void sim_disk_data_trace (UNIT *uptr, const uint8 *data, size_t lba, size_t len, const char* txt, int detail, uint32 reason); +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_ether.c b/sim_ether.c index 54d0966..1fe49ee 100644 --- a/sim_ether.c +++ b/sim_ether.c @@ -374,7 +374,7 @@ /* OS-independant ethernet routines */ /*============================================================================*/ -t_stat eth_mac_scan (ETH_MAC* mac, char* strmac) +t_stat eth_mac_scan (ETH_MAC* mac, const char* strmac) { unsigned int a0, a1, a2, a3, a4, a5; const ETH_MAC zeros = {0,0,0,0,0,0}; @@ -406,9 +406,9 @@ t_stat eth_mac_scan (ETH_MAC* mac, char* strmac) return SCPE_OK; } -void eth_mac_fmt(ETH_MAC* mac, char* buff) +void eth_mac_fmt(const ETH_MAC* mac, char* buff) { - uint8* m = (uint8*) mac; + const uint8* m = (const uint8*) mac; sprintf(buff, "%02X:%02X:%02X:%02X:%02X:%02X", m[0], m[1], m[2], m[3], m[4], m[5]); return; } @@ -519,16 +519,16 @@ void eth_packet_trace_ex(ETH_DEV* dev, const uint8 *msg, int len, const char* tx if (dev->dptr->dctrl & reason) { char src[20]; char dst[20]; - unsigned short* proto = (unsigned short*) &msg[12]; + const unsigned short* proto = (const unsigned short*) &msg[12]; uint32 crc = eth_crc32(0, msg, len); - eth_mac_fmt((ETH_MAC*)&msg[0], dst); - eth_mac_fmt((ETH_MAC*)&msg[6], src); + eth_mac_fmt((const ETH_MAC*)msg, dst); + eth_mac_fmt((const ETH_MAC*)(msg+6), src); sim_debug(reason, dev->dptr, "%s dst: %s src: %s proto: 0x%04X len: %d crc: %X\n", txt, dst, src, ntohs(*proto), len, crc); if (detail) { int i, same, group, sidx, oidx; char outbuf[80], strbuf[18]; - static char hex[] = "0123456789ABCDEF"; + static const char hex[] = "0123456789ABCDEF"; for (i=same=0; i 0) && (0 == memcmp(&msg[i], &msg[i-16], 16))) { @@ -570,7 +570,7 @@ void eth_packet_trace_detail(ETH_DEV* dev, const uint8 *msg, int len, const char eth_packet_trace_ex(dev, msg, len, txt, 1 , dev->dbit); } -char* eth_getname(int number, char* name, char *desc) +const char* eth_getname(int number, char* name, char *desc) { ETH_LIST list[ETH_MAX_DEVICE]; int count = eth_devices(ETH_MAX_DEVICE, list); @@ -582,7 +582,7 @@ char* eth_getname(int number, char* name, char *desc) return name; } -char* eth_getname_bydesc(char* desc, char* name, char *ndesc) +const char* eth_getname_bydesc(const char* desc, char* name, char *ndesc) { ETH_LIST list[ETH_MAX_DEVICE]; int count = eth_devices(ETH_MAX_DEVICE, list); @@ -609,7 +609,7 @@ char* eth_getname_bydesc(char* desc, char* name, char *ndesc) } /* strncasecmp() is not available on all platforms */ -int eth_strncasecmp(char* string1, char* string2, size_t len) +int eth_strncasecmp(const char* string1, const char* string2, size_t len) { size_t i; unsigned char s1, s2; @@ -629,7 +629,7 @@ int eth_strncasecmp(char* string1, char* string2, size_t len) return 0; } -char* eth_getname_byname(char* name, char* temp, char *desc) +char* eth_getname_byname(const char* name, char* temp, char *desc) { ETH_LIST list[ETH_MAX_DEVICE]; int count = eth_devices(ETH_MAX_DEVICE, list); @@ -702,7 +702,7 @@ for (i=0; ioversize ? pack->oversize : pack->msg, pack->u #if !defined (USE_NETWORK) && !defined (USE_SHARED) const char *eth_capabilities(void) {return "no Ethernet";} -t_stat eth_open(ETH_DEV* dev, char* name, DEVICE* dptr, uint32 dbit) +t_stat eth_open(ETH_DEV* dev, const char* name, DEVICE* dptr, uint32 dbit) {return SCPE_NOFNC;} t_stat eth_close (ETH_DEV* dev) {return SCPE_NOFNC;} @@ -952,7 +952,13 @@ typedef void * pcap_t; /* Pseudo Type to avoid compiler errors */ #endif /* HAVE_TAP_NETWORK */ #ifdef HAVE_VDE_NETWORK +#ifdef __cplusplus +extern "C" { +#endif #include +#ifdef __cplusplus +} +#endif #endif /* HAVE_VDE_NETWORK */ #ifdef HAVE_SLIRP_NETWORK @@ -1277,7 +1283,7 @@ typedef struct _PACKET_OID_DATA PACKET_OID_DATA, *PPACKET_OID_DATA; typedef void **LPADAPTER; #define OID_802_3_CURRENT_ADDRESS 0x01010102 /* Extracted from ntddmdis.h */ -static int pcap_mac_if_win32(char *AdapterName, unsigned char MACAddress[6]) +static int pcap_mac_if_win32(const char *AdapterName, unsigned char MACAddress[6]) { LPADAPTER lpAdapter; PPACKET_OID_DATA OidData; @@ -1289,13 +1295,13 @@ static int pcap_mac_if_win32(char *AdapterName, unsigned char MACAddress[6]) static void *hDll = NULL; /* handle to Library */ typedef int BOOLEAN; #endif - LPADAPTER (*p_PacketOpenAdapter)(char *AdapterName); + LPADAPTER (*p_PacketOpenAdapter)(const char *AdapterName); void (*p_PacketCloseAdapter)(LPADAPTER lpAdapter); int (*p_PacketRequest)(LPADAPTER AdapterObject,BOOLEAN Set,PPACKET_OID_DATA OidData); #ifdef _WIN32 hDll = LoadLibraryA("packet.dll"); - p_PacketOpenAdapter = (LPADAPTER (*)(char *AdapterName))GetProcAddress(hDll, "PacketOpenAdapter"); + p_PacketOpenAdapter = (LPADAPTER (*)(const char *AdapterName))GetProcAddress(hDll, "PacketOpenAdapter"); p_PacketCloseAdapter = (void (*)(LPADAPTER lpAdapter))GetProcAddress(hDll, "PacketCloseAdapter"); p_PacketRequest = (int (*)(LPADAPTER AdapterObject,BOOLEAN Set,PPACKET_OID_DATA OidData))GetProcAddress(hDll, "PacketRequest"); #else @@ -1444,7 +1450,7 @@ static int pcap_mac_if_vms(char *AdapterName, unsigned char MACAddress[6]) } #endif /* defined (__VMS) && !defined(__VAX) */ -static void eth_get_nic_hw_addr(ETH_DEV* dev, char *devname) +static void eth_get_nic_hw_addr(ETH_DEV* dev, const char *devname) { memset(&dev->host_nic_phy_hw_addr, 0, sizeof(dev->host_nic_phy_hw_addr)); dev->have_host_nic_phy_addr = 0; @@ -1724,7 +1730,7 @@ static void * _eth_writer(void *arg) { ETH_DEV* volatile dev = (ETH_DEV*)arg; -struct write_request *request; +ETH_WRITE_REQUEST *request; int sched_policy; struct sched_param sched_priority; @@ -1832,7 +1838,7 @@ memset(errbuf, 0, PCAP_ERRBUF_SIZE); if (0 == strncmp("tap:", savname, 4)) { int tun = -1; /* TUN/TAP Socket */ int on = 1; - char *devname = savname + 4; + const char *devname = savname + 4; while (isspace(*devname)) ++devname; @@ -1919,7 +1925,7 @@ else { /* !tap: */ if (0 == strncmp("vde:", savname, 4)) { #if defined(HAVE_VDE_NETWORK) struct vde_open_args voa; - char *devname = savname + 4; + const char *devname = savname + 4; memset(&voa, 0, sizeof(voa)); if (!strcmp(savname, "vde:vdedevice")) { @@ -1928,7 +1934,7 @@ else { /* !tap: */ } while (isspace(*devname)) ++devname; - if (!(*handle = (void*) vde_open(devname, "simh", &voa))) + if (!(*handle = (void*) vde_open((char *)devname, (char *)"simh", &voa))) strncpy(errbuf, strerror(errno), PCAP_ERRBUF_SIZE-1); else { *eth_api = ETH_API_VDE; @@ -1941,7 +1947,7 @@ else { /* !tap: */ else { /* !vde: */ if (0 == strncmp("nat:", savname, 4)) { #if defined(HAVE_SLIRP_NETWORK) - char *devname = savname + 4; + const char *devname = savname + 4; while (isspace(*devname)) ++devname; @@ -1959,7 +1965,7 @@ else { /* !tap: */ if (0 == strncmp("udp:", savname, 4)) { char localport[CBUFSIZE], host[CBUFSIZE], port[CBUFSIZE]; char hostport[2*CBUFSIZE]; - char *devname = savname + 4; + const char *devname = savname + 4; if (!strcmp(savname, "udp:sourceport:remotehost:remoteport")) { sim_printf ("Eth: Must specify actual udp host and ports(i.e. udp:1224:somehost.com:2234)\r\n"); @@ -2067,13 +2073,14 @@ if (bpf_filter && (*eth_api == ETH_API_PCAP)) { return SCPE_OK; } -t_stat eth_open(ETH_DEV* dev, char* name, DEVICE* dptr, uint32 dbit) +t_stat eth_open(ETH_DEV* dev, const char* name, DEVICE* dptr, uint32 dbit) { t_stat r; int bufsz = (BUFSIZ < ETH_MAX_PACKET) ? ETH_MAX_PACKET : BUFSIZ; char errbuf[PCAP_ERRBUF_SIZE]; char temp[1024], desc[1024] = ""; -char* savname = name; +const char* savname = name; +char namebuf[4*CBUFSIZE]; int num; if (bufsz < ETH_MAX_JUMBO_FRAME) @@ -2107,7 +2114,10 @@ else { } } -r = _eth_open_port(savname, &dev->eth_api, &dev->handle, &dev->fd_handle, errbuf, NULL, (void *)dev, dptr, dbit); +namebuf[sizeof(namebuf)-1] = '\0'; +strncpy (namebuf, savname, sizeof(namebuf)-1); +savname = namebuf; +r = _eth_open_port(namebuf, &dev->eth_api, &dev->handle, &dev->fd_handle, errbuf, NULL, (void *)dev, dptr, dbit); if (errbuf[0]) { sim_printf ("Eth: open error - %s\r\n", errbuf); @@ -2215,7 +2225,7 @@ pthread_mutex_destroy (&dev->self_lock); pthread_mutex_destroy (&dev->writer_lock); pthread_cond_destroy (&dev->writer_cond); if (1) { - struct write_request *buffer; + ETH_WRITE_REQUEST *buffer; while (NULL != (buffer = dev->write_buffers)) { dev->write_buffers = buffer->next; free(buffer); @@ -2369,7 +2379,7 @@ eth_filter(dev, 1, (ETH_MAC *)mac, 0, 0); /* send the packet */ status = _eth_write (dev, &send, NULL); if (status != SCPE_OK) { - char *msg; + const char *msg; msg = (dev->eth_api == ETH_API_PCAP) ? "Eth: Error Transmitting packet: %s\r\n" "You may need to run as root, or install a libpcap version\r\n" @@ -2607,7 +2617,7 @@ return ((status == 0) ? SCPE_OK : SCPE_IOERR); t_stat eth_write(ETH_DEV* dev, ETH_PACK* packet, ETH_PCALLBACK routine) { #ifdef USE_READER_THREAD -struct write_request *request; +ETH_WRITE_REQUEST *request; int write_queue_size = 1; /* make sure device exists */ @@ -2619,7 +2629,7 @@ if (NULL != (request = dev->write_buffers)) dev->write_buffers = request->next; pthread_mutex_unlock (&dev->writer_lock); if (NULL == request) - request = (struct write_request *)malloc(sizeof(*request)); + request = (ETH_WRITE_REQUEST *)malloc(sizeof(*request)); /* Copy buffer contents */ request->packet.len = packet->len; @@ -2633,7 +2643,7 @@ memcpy(request->packet.msg, packet->msg, packet->len); pthread_mutex_lock (&dev->writer_lock); request->next = NULL; if (dev->write_requests) { - struct write_request *last_request = dev->write_requests; + ETH_WRITE_REQUEST *last_request = dev->write_requests; ++write_queue_size; while (last_request->next) { @@ -2844,9 +2854,9 @@ return (uint16)(~sum); } static void -_eth_fix_ip_jumbo_offload(ETH_DEV* dev, const u_char* msg, int len) +_eth_fix_ip_jumbo_offload(ETH_DEV* dev, u_char* msg, int len) { -unsigned short* proto = (unsigned short*) &msg[12]; +const unsigned short* proto = (const unsigned short*) &msg[12]; struct IPHeader *IP; struct TCPHeader *TCP = NULL; struct UDPHeader *UDP; @@ -3035,7 +3045,7 @@ switch (IP->proto) { static void _eth_fix_ip_xsum_offload(ETH_DEV* dev, const u_char* msg, int len) { -unsigned short* proto = (unsigned short*) &msg[12]; +const unsigned short* proto = (const unsigned short*) &msg[12]; struct IPHeader *IP; struct TCPHeader *TCP; struct UDPHeader *UDP; @@ -3235,8 +3245,12 @@ if ((LOOPBACK_SELF_FRAME(dev->physical_addr, data)) || if (bpf_used ? to_me : (to_me && !from_me)) { if (header->len > ETH_MIN_JUMBO_FRAME) { - if (header->len <= header->caplen) /* Whole Frame captured? */ - _eth_fix_ip_jumbo_offload(dev, data, header->len); + if (header->len <= header->caplen) {/* Whole Frame captured? */ + u_char *datacopy = (u_char *)malloc(header->len); + memcpy(datacopy, data, header->len); + _eth_fix_ip_jumbo_offload(dev, datacopy, header->len); + free(datacopy); + } else ++dev->jumbo_truncated; return; diff --git a/sim_ether.h b/sim_ether.h index e046010..75b70d1 100644 --- a/sim_ether.h +++ b/sim_ether.h @@ -69,6 +69,10 @@ #include "sim_defs.h" #include "sim_sock.h" +#ifdef __cplusplus +extern "C" { +#endif + /* make common BSD code a bit easier to read in this file */ /* OS/X seems to define and compile using one of these BSD types */ #if defined(__NetBSD__) || defined (__OpenBSD__) || defined (__FreeBSD__) @@ -235,6 +239,11 @@ typedef void (*ETH_PCALLBACK)(int status); typedef struct eth_list ETH_LIST; typedef struct eth_queue ETH_QUE; typedef struct eth_item ETH_ITEM; +struct eth_write_request { + struct eth_write_request *next; + ETH_PACK packet; + }; +typedef struct eth_write_request ETH_WRITE_REQUEST; struct eth_device { char* name; /* name of ethernet device */ @@ -303,12 +312,9 @@ struct eth_device { pthread_mutex_t writer_lock; pthread_mutex_t self_lock; pthread_cond_t writer_cond; - struct write_request { - struct write_request *next; - ETH_PACK packet; - } *write_requests; + ETH_WRITE_REQUEST *write_requests; int write_queue_peak; - struct write_request *write_buffers; + ETH_WRITE_REQUEST *write_buffers; t_stat write_status; #endif }; @@ -317,7 +323,7 @@ typedef struct eth_device ETH_DEV; /* prototype declarations*/ -t_stat eth_open (ETH_DEV* dev, char* name, /* open ethernet interface */ +t_stat eth_open (ETH_DEV* dev, const char* name, /* open ethernet interface */ DEVICE* dptr, uint32 dbit); t_stat eth_close (ETH_DEV* dev); /* close ethernet interface */ t_stat eth_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -346,13 +352,13 @@ uint32 eth_crc32(uint32 crc, const void* vbuf, size_t len); /* Compute Ethernet void eth_packet_trace (ETH_DEV* dev, const uint8 *msg, int len, const char* txt); /* trace ethernet packet header+crc */ void eth_packet_trace_ex (ETH_DEV* dev, const uint8 *msg, int len, const char* txt, int detail, uint32 reason); /* trace ethernet packet */ t_stat eth_show (FILE* st, UNIT* uptr, /* show ethernet devices */ - int32 val, void* desc); + int32 val, CONST void* desc); t_stat eth_show_devices (FILE* st, DEVICE *dptr, /* show ethernet devices */ - UNIT* uptr, int32 val, char* desc); + UNIT* uptr, int32 val, CONST char* desc); void eth_show_dev (FILE*st, ETH_DEV* dev); /* show ethernet device state */ -void eth_mac_fmt (ETH_MAC* add, char* buffer); /* format ethernet mac address */ -t_stat eth_mac_scan (ETH_MAC* mac, char* strmac); /* scan string for mac, put in mac */ +void eth_mac_fmt (const ETH_MAC* add, char* buffer); /* format ethernet mac address */ +t_stat eth_mac_scan (ETH_MAC* mac, const char* strmac); /* scan string for mac, put in mac */ t_stat ethq_init (ETH_QUE* que, int max); /* initialize FIFO queue */ void ethq_clear (ETH_QUE* que); /* clear FIFO queue */ @@ -366,4 +372,8 @@ t_stat ethq_destroy(ETH_QUE* que); /* release FIFO queue */ const char *eth_capabilities(void); +#ifdef __cplusplus +} +#endif + #endif /* _SIM_ETHER_H */ diff --git a/sim_fio.c b/sim_fio.c index e6a9608..008db86 100644 --- a/sim_fio.c +++ b/sim_fio.c @@ -125,11 +125,11 @@ sim_buf_swap_data (bptr, size, count); return c; } -void sim_buf_copy_swapped (void *dbuf, void *sbuf, size_t size, size_t count) +void sim_buf_copy_swapped (void *dbuf, const void *sbuf, size_t size, size_t count) { size_t j; int32 k; -unsigned char *sptr = (unsigned char *)sbuf; +const unsigned char *sptr = (const unsigned char *)sbuf; unsigned char *dptr = (unsigned char *)dbuf; if (sim_end || (size == sizeof (char))) { @@ -143,11 +143,11 @@ for (j = 0; j < count; j++) { /* loop on items */ } } -size_t sim_fwrite (void *bptr, size_t size, size_t count, FILE *fptr) +size_t sim_fwrite (const void *bptr, size_t size, size_t count, FILE *fptr) { size_t c, nelem, nbuf, lcnt, total; int32 i; -unsigned char *sptr; +const unsigned char *sptr; unsigned char *sim_flip; if ((size == 0) || (count == 0)) /* check arguments */ @@ -163,7 +163,7 @@ lcnt = count % nelem; /* count in last buf */ if (lcnt) nbuf = nbuf + 1; else lcnt = nelem; total = 0; -sptr = (unsigned char *) bptr; /* init input ptr */ +sptr = (const unsigned char *) bptr; /* init input ptr */ for (i = (int32)nbuf; i > 0; i--) { /* loop on buffers */ c = (i == 1)? lcnt: nelem; sim_buf_copy_swapped (sim_flip, sptr, size, c); @@ -198,7 +198,7 @@ sim_fseeko (fp, pos, SEEK_SET); return sz; } -t_offset sim_fsize_name_ex (char *fname) +t_offset sim_fsize_name_ex (const char *fname) { FILE *fp; t_offset sz; @@ -210,7 +210,7 @@ fclose (fp); return sz; } -uint32 sim_fsize_name (char *fname) +uint32 sim_fsize_name (const char *fname) { return (uint32)(sim_fsize_name_ex (fname)); } diff --git a/sim_fio.h b/sim_fio.h index 01ee079..32d5ce8 100644 --- a/sim_fio.h +++ b/sim_fio.h @@ -33,6 +33,10 @@ #ifndef SIM_FIO_H_ #define SIM_FIO_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + #define FLIP_SIZE (1 << 16) /* flip buf size */ #define fxread(a,b,c,d) sim_fread (a, b, c, d) #define fxwrite(a,b,c,d) sim_fwrite (a, b, c, d) @@ -56,14 +60,14 @@ int sim_fseeko (FILE *st, t_offset offset, int whence); int sim_set_fsize (FILE *fptr, t_addr size); int sim_set_fifo_nonblock (FILE *fptr); size_t sim_fread (void *bptr, size_t size, size_t count, FILE *fptr); -size_t sim_fwrite (void *bptr, size_t size, size_t count, FILE *fptr); +size_t sim_fwrite (const void *bptr, size_t size, size_t count, FILE *fptr); uint32 sim_fsize (FILE *fptr); -uint32 sim_fsize_name (char *fname); +uint32 sim_fsize_name (const char *fname); t_offset sim_ftell (FILE *st); t_offset sim_fsize_ex (FILE *fptr); -t_offset sim_fsize_name_ex (char *fname); +t_offset sim_fsize_name_ex (const char *fname); void sim_buf_swap_data (void *bptr, size_t size, size_t count); -void sim_buf_copy_swapped (void *dptr, void *bptr, size_t size, size_t count); +void sim_buf_copy_swapped (void *dptr, const void *bptr, size_t size, size_t count); typedef struct SHMEM SHMEM; t_stat sim_shmem_open (const char *name, size_t size, SHMEM **shmem, void **addr); void sim_shmem_close (SHMEM *shmem); @@ -72,4 +76,8 @@ extern t_bool sim_taddr_64; /* t_addr is > 32b and Large File Support av extern t_bool sim_toffset_64; /* Large File (>2GB) file I/O support */ extern t_bool sim_end; /* TRUE = little endian, FALSE = big endian */ +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_imd.c b/sim_imd.c index 71a8c91..b1d0949 100644 --- a/sim_imd.c +++ b/sim_imd.c @@ -339,7 +339,7 @@ t_stat diskClose(DISK_INFO **myDisk) * * If the IMD file already exists, the user will be given the option of overwriting it. */ -t_stat diskCreate(FILE *fileref, char *ctlr_comment) +t_stat diskCreate(FILE *fileref, const char *ctlr_comment) { DISK_INFO *myDisk = NULL; char *comment; @@ -361,7 +361,7 @@ t_stat diskCreate(FILE *fileref, char *ctlr_comment) } } - if((curptr = comment = calloc(1, MAX_COMMENT_LEN)) == 0) { + if((curptr = comment = (char *)calloc(1, MAX_COMMENT_LEN)) == 0) { sim_printf("Memory allocation failure.\n"); return (SCPE_MEM); } @@ -735,7 +735,7 @@ t_stat trackWrite(DISK_INFO *myDisk, * data with the fillbyte. */ dataLen = sectorLen + 1; - sectorData = malloc(dataLen); + sectorData = (uint8 *)malloc(dataLen); memset(sectorData, fillbyte, dataLen); sectorData[0] = SECT_RECORD_NORM; diff --git a/sim_imd.h b/sim_imd.h index f02388b..2c72972 100644 --- a/sim_imd.h +++ b/sim_imd.h @@ -122,7 +122,7 @@ typedef struct { extern DISK_INFO *diskOpen(FILE *fileref, uint32 isVerbose); extern DISK_INFO *diskOpenEx(FILE *fileref, uint32 isVerbose, DEVICE *device, uint32 debugmask, uint32 verbosedebugmask); extern t_stat diskClose(DISK_INFO **myDisk); -extern t_stat diskCreate(FILE *fileref, char *ctlr_comment); +extern t_stat diskCreate(FILE *fileref, const char *ctlr_comment); extern uint32 imdGetSides(DISK_INFO *myDisk); extern uint32 imdIsWriteLocked(DISK_INFO *myDisk); diff --git a/sim_serial.c b/sim_serial.c index 2cce47b..b7251d6 100644 --- a/sim_serial.c +++ b/sim_serial.c @@ -115,7 +115,7 @@ enumerates the available host serial ports - t_stat sim_show_serial (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, void* desc) + t_stat sim_show_serial (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, const void* desc) --------------------------------- displays the available host serial ports @@ -352,7 +352,7 @@ for (i=0; i @@ -126,4 +130,8 @@ int sim_getnames_sock (SOCKET sock, char **socknamebuf, char **peernamebuf); void sim_init_sock (void); void sim_cleanup_sock (void); +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_tape.c b/sim_tape.c index 09f54cf..9d9139a 100644 --- a/sim_tape.c +++ b/sim_tape.c @@ -438,12 +438,12 @@ fflush (uptr->fileref); /* Attach tape unit */ -t_stat sim_tape_attach (UNIT *uptr, char *cptr) +t_stat sim_tape_attach (UNIT *uptr, CONST char *cptr) { return sim_tape_attach_ex (uptr, cptr, 0, 0); } -t_stat sim_tape_attach_ex (UNIT *uptr, char *cptr, uint32 dbit, int completion_delay) +t_stat sim_tape_attach_ex (UNIT *uptr, const char *cptr, uint32 dbit, int completion_delay) { struct tape_context *ctx; uint32 objc; @@ -465,7 +465,7 @@ if (sim_switches & SWMASK ('F')) { /* format spec? */ } if (MT_GET_FMT (uptr) == MTUF_F_TPC) sim_switches |= SWMASK ('R'); /* Force ReadOnly attach for TPC tapes */ -r = attach_unit (uptr, cptr); /* attach unit */ +r = attach_unit (uptr, (CONST char *)cptr); /* attach unit */ if (r != SCPE_OK) /* error? */ return sim_messagef (r, "Can't open tape image: %s\n", cptr); switch (MT_GET_FMT (uptr)) { /* case on format */ @@ -2108,7 +2108,7 @@ return MTSE_IOERR; /* Set tape format */ -t_stat sim_tape_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_tape_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { uint32 f; @@ -2130,7 +2130,7 @@ return SCPE_ARG; /* Show tape format */ -t_stat sim_tape_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_tape_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { int32 f = MT_GET_FMT (uptr); @@ -2156,8 +2156,8 @@ DEVICE *dptr = find_dev_from_unit (uptr); if ((uptr == NULL) || (uptr->fileref == NULL)) return 0; -countmap = calloc (65536, sizeof(*countmap)); -recbuf = malloc (65536); +countmap = (uint32 *)calloc (65536, sizeof(*countmap)); +recbuf = (uint8 *)malloc (65536); tape_size = (t_addr)sim_fsize (uptr->fileref); sim_debug (MTSE_DBG_STR, dptr, "tpc_map: tape_size: %" T_ADDR_FMT "u\n", tape_size); for (objc = 0, sizec = 0, tpos = 0;; ) { @@ -2265,7 +2265,7 @@ return ((p == 0)? map[p]: map[p - 1]); /* Set tape capacity */ -t_stat sim_tape_set_capac (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_tape_set_capac (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { t_addr cap; t_stat r; @@ -2283,7 +2283,7 @@ return SCPE_OK; /* Show tape capacity */ -t_stat sim_tape_show_capac (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_tape_show_capac (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { if (uptr->capac) { if (uptr->capac >= (t_addr) 1000000) @@ -2319,7 +2319,7 @@ return SCPE_OK; structure, and SCPE_OK is returned. */ -t_stat sim_tape_set_dens (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_tape_set_dens (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { uint32 density, new_bpi; t_stat result = SCPE_OK; @@ -2345,7 +2345,7 @@ else { /* otherwise a v else for (density = 0; density < BPI_COUNT; density++) /* otherwise validate the density */ if (new_bpi == bpi [density] /* if it matches a value in the list */ - && ((1 << density) & *(int32 *) desc)) { /* and it's an allowed value */ + && ((1 << density) & *(const int32 *) desc)) { /* and it's an allowed value */ uptr->dynflags = (uptr->dynflags & ~MTVF_DENS_MASK) /* then store the index of the value */ | density << UNIT_V_DF_TAPE; /* in the unit flags */ return SCPE_OK; /* and return success */ @@ -2359,7 +2359,7 @@ return result; /* return the re /* Show the tape density */ -t_stat sim_tape_show_dens (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_tape_show_dens (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { uint32 tape_density; diff --git a/sim_tape.h b/sim_tape.h index 629ab17..c1cf6a0 100644 --- a/sim_tape.h +++ b/sim_tape.h @@ -34,6 +34,10 @@ #ifndef SIM_TAPE_H_ #define SIM_TAPE_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + /* SIMH/E11 tape format */ typedef uint32 t_mtrlnt; /* magtape rec lnt */ @@ -148,8 +152,8 @@ typedef void (*TAPE_PCALLBACK)(UNIT *unit, t_stat status); /* Prototypes */ -t_stat sim_tape_attach_ex (UNIT *uptr, char *cptr, uint32 dbit, int completion_delay); -t_stat sim_tape_attach (UNIT *uptr, char *cptr); +t_stat sim_tape_attach_ex (UNIT *uptr, const char *cptr, uint32 dbit, int completion_delay); +t_stat sim_tape_attach (UNIT *uptr, CONST char *cptr); t_stat sim_tape_detach (UNIT *uptr); t_stat sim_tape_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); t_stat sim_tape_rdrecf (UNIT *uptr, uint8 *buf, t_mtrlnt *bc, t_mtrlnt max); @@ -190,13 +194,17 @@ t_stat sim_tape_reset (UNIT *uptr); t_bool sim_tape_bot (UNIT *uptr); t_bool sim_tape_wrp (UNIT *uptr); t_bool sim_tape_eot (UNIT *uptr); -t_stat sim_tape_set_fmt (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_tape_show_fmt (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat sim_tape_set_capac (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_tape_show_capac (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat sim_tape_set_dens (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_tape_show_dens (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat sim_tape_set_fmt (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_tape_show_fmt (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat sim_tape_set_capac (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_tape_show_capac (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat sim_tape_set_dens (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_tape_show_dens (FILE *st, UNIT *uptr, int32 val, CONST void *desc); t_stat sim_tape_set_asynch (UNIT *uptr, int latency); t_stat sim_tape_clr_asynch (UNIT *uptr); +#ifdef __cplusplus +} +#endif + #endif diff --git a/sim_timer.c b/sim_timer.c index 8188a6b..ce3b6f1 100644 --- a/sim_timer.c +++ b/sim_timer.c @@ -103,7 +103,7 @@ static uint32 sim_throt_state = 0; static uint32 sim_throt_sleep_time = 0; static int32 sim_throt_wait = 0; static UNIT *sim_clock_unit[SIM_NTIMERS] = {NULL}; -UNIT *sim_clock_cosched_queue[SIM_NTIMERS] = {NULL}; +UNIT * volatile sim_clock_cosched_queue[SIM_NTIMERS] = {NULL}; t_bool sim_asynch_timer = #if defined (SIM_ASYNCH_CLOCKS) TRUE; @@ -760,7 +760,7 @@ return (sim_idle_rate_ms != 0); /* sim_show_timers - show running timer information */ -t_stat sim_show_timers (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc) +t_stat sim_show_timers (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc) { int tmr, clocks; @@ -800,7 +800,7 @@ if (clocks == 0) return SCPE_OK; } -t_stat sim_show_clock_queues (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr) +t_stat sim_show_clock_queues (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr) { #if defined (SIM_ASYNCH_IO) int tmr; @@ -999,7 +999,7 @@ return TRUE; /* Set idling - implicitly disables throttling */ -t_stat sim_set_idle (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_set_idle (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { t_stat r; uint32 v; @@ -1024,7 +1024,7 @@ return SCPE_OK; /* Clear idling */ -t_stat sim_clr_idle (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat sim_clr_idle (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { sim_idle_enab = FALSE; return SCPE_OK; @@ -1032,7 +1032,7 @@ return SCPE_OK; /* Show idling */ -t_stat sim_show_idle (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat sim_show_idle (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { if (sim_idle_enab) fprintf (st, "idle enabled"); @@ -1045,9 +1045,9 @@ return SCPE_OK; /* Throttling package */ -t_stat sim_set_throt (int32 arg, char *cptr) +t_stat sim_set_throt (int32 arg, CONST char *cptr) { -const char *tptr; +CONST char *tptr; char c; t_value val, val2 = 0; @@ -1098,7 +1098,7 @@ else { return SCPE_OK; } -t_stat sim_show_throt (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr) +t_stat sim_show_throt (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr) { if (sim_idle_rate_ms == 0) fprintf (st, "Throttling not available\n"); diff --git a/sim_timer.h b/sim_timer.h index 4de825e..1dc28a3 100644 --- a/sim_timer.h +++ b/sim_timer.h @@ -31,6 +31,11 @@ #ifndef SIM_TIMER_H_ #define SIM_TIMER_H_ 0 + +#ifdef __cplusplus +extern "C" { +#endif + /* Pick up a struct timespec definition if it is available */ #include #if defined(__struct_timespec_defined) @@ -106,14 +111,14 @@ void sim_rtcn_init_all (void); int32 sim_rtcn_calb (int32 ticksper, int32 tmr); int32 sim_rtc_init (int32 time); int32 sim_rtc_calb (int32 ticksper); -t_stat sim_show_timers (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc); -t_stat sim_show_clock_queues (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, char *cptr); +t_stat sim_show_timers (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc); +t_stat sim_show_clock_queues (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, CONST char *cptr); t_bool sim_idle (uint32 tmr, t_bool sin_cyc); -t_stat sim_set_throt (int32 arg, char *cptr); -t_stat sim_show_throt (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, char *cptr); -t_stat sim_set_idle (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_clr_idle (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat sim_show_idle (FILE *st, UNIT *uptr, int32 val, void *desc); +t_stat sim_set_throt (int32 arg, CONST char *cptr); +t_stat sim_show_throt (FILE *st, DEVICE *dnotused, UNIT *unotused, int32 flag, CONST char *cptr); +t_stat sim_set_idle (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_clr_idle (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat sim_show_idle (FILE *st, UNIT *uptr, int32 val, CONST void *desc); void sim_throt_sched (void); void sim_throt_cancel (void); uint32 sim_os_msec (void); @@ -136,5 +141,11 @@ extern t_bool sim_idle_enab; /* idle enabled flag */ extern volatile t_bool sim_idle_wait; /* idle waiting flag */ extern t_bool sim_asynch_timer; extern DEVICE sim_timer_dev; +extern UNIT * volatile sim_clock_cosched_queue[SIM_NTIMERS]; +extern const t_bool rtc_avail; + +#ifdef __cplusplus +} +#endif #endif diff --git a/sim_tmxr.c b/sim_tmxr.c index edfee4b..4397b76 100644 --- a/sim_tmxr.c +++ b/sim_tmxr.c @@ -746,7 +746,7 @@ return; at each call, rather than depending on the DEVICE pointer stored in the TMXR. */ -static TMLN *tmxr_find_ldsc (UNIT *uptr, int32 val, TMXR *mp) +static TMLN *tmxr_find_ldsc (UNIT *uptr, int32 val, const TMXR *mp) { if (mp == NULL) /* invalid multiplexer descriptor? */ return NULL; /* programming error! */ @@ -778,7 +778,7 @@ return mp->ldsc + val; /* line descriptor */ invalid pointer or an invalid unit). */ -static TMLN *tmxr_get_ldsc (UNIT *uptr, char *cptr, TMXR *mp, t_stat *status) +static TMLN *tmxr_get_ldsc (UNIT *uptr, const char *cptr, TMXR *mp, t_stat *status) { t_value ln; TMLN *lp = NULL; @@ -1601,7 +1601,7 @@ t_bool tmxr_get_line_halfduplex (TMLN *lp) return (lp->halfduplex != FALSE); } -t_stat tmxr_set_config_line (TMLN *lp, const char *config) +t_stat tmxr_set_config_line (TMLN *lp, CONST char *config) { t_stat r; @@ -1989,7 +1989,7 @@ return; /* Return count of available characters for line */ -int32 tmxr_rqln_bare (TMLN *lp, t_bool speed) +int32 tmxr_rqln_bare (const TMLN *lp, t_bool speed) { if ((speed) && (lp->rxbps)) { /* consider speed and rate limiting? */ if (sim_gtime () < lp->rxnexttime) /* too soon? */ @@ -2000,7 +2000,7 @@ if ((speed) && (lp->rxbps)) { /* consider speed and rate limit return (lp->rxbpi - lp->rxbpr + ((lp->rxbpi < lp->rxbpr)? lp->rxbsz: 0)); } -int32 tmxr_rqln (TMLN *lp) +int32 tmxr_rqln (const TMLN *lp) { return tmxr_rqln_bare (lp, TRUE); } @@ -2198,21 +2198,21 @@ return tmxr_tqln(lp) + tmxr_tpqln(lp); /* Return count of buffered characters for line */ -int32 tmxr_tqln (TMLN *lp) +int32 tmxr_tqln (const TMLN *lp) { return (lp->txbpi - lp->txbpr + ((lp->txbpi < lp->txbpr)? lp->txbsz: 0)); } /* Return count of buffered packet characters for line */ -int32 tmxr_tpqln (TMLN *lp) +int32 tmxr_tpqln (const TMLN *lp) { return (lp->txppsize - lp->txppoffset); } /* Return transmit packet busy status for line */ -t_bool tmxr_tpbusyln (TMLN *lp) +t_bool tmxr_tpbusyln (const TMLN *lp) { return (0 != (lp->txppsize - lp->txppoffset)); } @@ -2273,7 +2273,7 @@ if (uptr && uptr->filename) { return SCPE_OK; } -static int32 _tmln_speed_delta (const char *cptr) +static int32 _tmln_speed_delta (CONST char *cptr) { struct { const char *bps; @@ -2319,10 +2319,10 @@ while (1) { return -1; } -t_stat tmxr_set_line_speed (TMLN *lp, const char *speed) +t_stat tmxr_set_line_speed (TMLN *lp, CONST char *speed) { UNIT *uptr; -const char *cptr; +CONST char *cptr; t_stat r; if (!speed || !*speed) @@ -2361,7 +2361,7 @@ return SCPE_OK; */ -t_stat tmxr_open_master (TMXR *mp, char *cptr) +t_stat tmxr_open_master (TMXR *mp, CONST char *cptr) { int32 i, line, nextline = -1; char tbuf[CBUFSIZE], listen[CBUFSIZE], destination[CBUFSIZE], @@ -2369,7 +2369,7 @@ char tbuf[CBUFSIZE], listen[CBUFSIZE], destination[CBUFSIZE], port[CBUFSIZE], option[CBUFSIZE], speed[CBUFSIZE]; SOCKET sock; SERHANDLE serport; -char *tptr = cptr; +CONST char *tptr = cptr; t_bool nolog, notelnet, listennotelnet, modem_control, loopback, datagram, packet; TMLN *lp; t_stat r = SCPE_OK; @@ -2408,7 +2408,7 @@ while (*tptr) { cptr = tbuf; if (!isdigit(*cptr)) { char gbuf[CBUFSIZE]; - char *init_cptr = cptr; + CONST char *init_cptr = cptr; cptr = get_glyph (cptr, gbuf, '='); if (0 == MATCH_CMD (gbuf, "LINE")) { @@ -2502,14 +2502,15 @@ while (*tptr) { if (sim_parse_addr (port, NULL, 0, NULL, NULL, 0, NULL, NULL)) return sim_messagef (SCPE_ARG, "Invalid Port Specifier: %s\n", port); if (cptr) { - get_glyph (cptr, cptr, 0); /* upcase this string */ + char *tptr = gbuf + (cptr - gbuf); + get_glyph (cptr, tptr, 0); /* upcase this string */ if (0 == MATCH_CMD (cptr, "NOTELNET")) listennotelnet = TRUE; else if (0 == MATCH_CMD (cptr, "TELNET")) listennotelnet = FALSE; else - return sim_messagef (SCPE_ARG, "Invalid Specifier: %s\n", cptr); + return sim_messagef (SCPE_ARG, "Invalid Specifier: %s\n", tptr); } cptr = init_cptr; } @@ -2542,22 +2543,24 @@ while (*tptr) { return sim_messagef (SCPE_ARG, "Serial line parameters must be set within simulated OS: %s\n", 1 + strchr (destination, ';')); } else { + char *eptr; + memset (hostport, '\0', sizeof(hostport)); strncpy (hostport, destination, sizeof(hostport)-1); - if ((cptr = strchr (hostport, ';'))) - *(cptr++) = '\0'; - if (cptr) { - get_glyph (cptr, cptr, 0); /* upcase this string */ - if (0 == MATCH_CMD (cptr, "NOTELNET")) + if ((eptr = strchr (hostport, ';'))) + *(eptr++) = '\0'; + if (eptr) { + get_glyph (eptr, eptr, 0); /* upcase this string */ + if (0 == MATCH_CMD (eptr, "NOTELNET")) notelnet = TRUE; else - if (0 == MATCH_CMD (cptr, "TELNET")) + if (0 == MATCH_CMD (eptr, "TELNET")) if (datagram) return sim_messagef (SCPE_ARG, "Telnet invalid on Datagram socket\n"); else notelnet = FALSE; else - return sim_messagef (SCPE_ARG, "Unexpected specifier: %s\n", cptr); + return sim_messagef (SCPE_ARG, "Unexpected specifier: %s\n", eptr); } sock = sim_connect_sock_ex (NULL, hostport, "localhost", NULL, (datagram ? SIM_SOCK_OPT_DATAGRAM : 0) | (packet ? SIM_SOCK_OPT_NODELAY : 0)); if (sock != INVALID_SOCKET) @@ -3612,7 +3615,7 @@ return SCPE_OK; /* Attach unit to master socket */ -t_stat tmxr_attach_ex (TMXR *mp, UNIT *uptr, char *cptr, t_bool async) +t_stat tmxr_attach_ex (TMXR *mp, UNIT *uptr, CONST char *cptr, t_bool async) { t_stat r; int32 i; @@ -3665,7 +3668,7 @@ if (tmxr_open_device_count) return SCPE_OK; } -t_stat tmxr_show_open_devices (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc) +t_stat tmxr_show_open_devices (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc) { int i, j; @@ -4249,7 +4252,7 @@ return; /* Print connections - used only in named SHOW command */ -void tmxr_fconns (FILE *st, TMLN *lp, int32 ln) +void tmxr_fconns (FILE *st, const TMLN *lp, int32 ln) { int32 hr, mn, sc; uint32 ctime; @@ -4318,7 +4321,7 @@ return; /* Print statistics - used only in named SHOW command */ -void tmxr_fstats (FILE *st, TMLN *lp, int32 ln) +void tmxr_fstats (FILE *st, const TMLN *lp, int32 ln) { static const char *enab = "on"; static const char *dsab = "off"; @@ -4380,7 +4383,7 @@ return; 1. This function is usually called as an MTAB processing routine. */ -t_stat tmxr_dscln (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat tmxr_dscln (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { TMXR *mp = (TMXR *) desc; TMLN *lp; @@ -4408,7 +4411,7 @@ return SCPE_OK; /* Enable logging for line */ -t_stat tmxr_set_log (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat tmxr_set_log (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { TMXR *mp = (TMXR *) desc; TMLN *lp; @@ -4437,7 +4440,7 @@ return SCPE_OK; /* Disable logging for line */ -t_stat tmxr_set_nolog (UNIT *uptr, int32 val, char *cptr, void *desc) +t_stat tmxr_set_nolog (UNIT *uptr, int32 val, CONST char *cptr, void *desc) { TMXR *mp = (TMXR *) desc; TMLN *lp; @@ -4460,9 +4463,9 @@ return SCPE_OK; /* Show logging status for line */ -t_stat tmxr_show_log (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat tmxr_show_log (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { -TMXR *mp = (TMXR *) desc; +const TMXR *mp = (const TMXR *) desc; TMLN *lp; lp = tmxr_find_ldsc (uptr, val, mp); /* find line desc */ @@ -4503,12 +4506,12 @@ return SCPE_OK; If an error occurs, the original line order is not disturbed. */ -t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, char *carg, void *desc) +t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, CONST char *carg, void *desc) { TMXR *mp = (TMXR *) desc; char *tbuf; char *tptr; -const char *cptr; +CONST char *cptr; t_addr low, high, max = (t_addr) mp->lines - 1; int32 *list; t_bool *set; @@ -4602,10 +4605,10 @@ return result; where possible to shorten the output. */ -t_stat tmxr_show_lnorder (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat tmxr_show_lnorder (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { int32 i, j, low, last; -TMXR *mp = (TMXR *) desc; +const TMXR *mp = (const TMXR *) desc; int32 *iptr = mp->lnorder; t_bool first = TRUE; @@ -4654,9 +4657,9 @@ return SCPE_OK; /* Show summary processor */ -t_stat tmxr_show_summ (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat tmxr_show_summ (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { -TMXR *mp = (TMXR *) desc; +const TMXR *mp = (const TMXR *) desc; int32 i, t; if (mp == NULL) @@ -4673,9 +4676,9 @@ return SCPE_OK; /* Show conn/stat processor */ -t_stat tmxr_show_cstat (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat tmxr_show_cstat (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { -TMXR *mp = (TMXR *) desc; +const TMXR *mp = (const TMXR *) desc; int32 i, any; if (mp == NULL) @@ -4699,9 +4702,9 @@ return SCPE_OK; /* Show number of lines */ -t_stat tmxr_show_lines (FILE *st, UNIT *uptr, int32 val, void *desc) +t_stat tmxr_show_lines (FILE *st, UNIT *uptr, int32 val, CONST void *desc) { -TMXR *mp = (TMXR *) desc; +const TMXR *mp = (const TMXR *) desc; if (mp == NULL) return SCPE_IERR; diff --git a/sim_tmxr.h b/sim_tmxr.h index 4ecef78..b90b3f4 100644 --- a/sim_tmxr.h +++ b/sim_tmxr.h @@ -47,6 +47,10 @@ #ifndef SIM_TMXR_H_ #define SIM_TMXR_H_ 0 +#ifdef __cplusplus +extern "C" { +#endif + #ifndef SIMH_SERHANDLE_DEFINED #define SIMH_SERHANDLE_DEFINED 0 #if defined (_WIN32) /* Windows definitions */ @@ -234,10 +238,10 @@ t_stat tmxr_put_packet_ln (TMLN *lp, const uint8 *buf, size_t size); t_stat tmxr_put_packet_ln_ex (TMLN *lp, const uint8 *buf, size_t size, uint8 frame_byte); void tmxr_poll_tx (TMXR *mp); int32 tmxr_send_buffered_data (TMLN *lp); -t_stat tmxr_open_master (TMXR *mp, char *cptr); +t_stat tmxr_open_master (TMXR *mp, CONST char *cptr); t_stat tmxr_close_master (TMXR *mp); t_stat tmxr_connection_poll_interval (TMXR *mp, uint32 seconds); -t_stat tmxr_attach_ex (TMXR *mp, UNIT *uptr, char *cptr, t_bool async); +t_stat tmxr_attach_ex (TMXR *mp, UNIT *uptr, CONST char *cptr, t_bool async); t_stat tmxr_detach (TMXR *mp, UNIT *uptr); t_stat tmxr_attach_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); char *tmxr_line_attach_string(TMLN *lp); @@ -248,8 +252,8 @@ t_stat tmxr_set_line_loopback (TMLN *lp, t_bool enable_loopback); t_bool tmxr_get_line_loopback (TMLN *lp); t_stat tmxr_set_line_halfduplex (TMLN *lp, t_bool enable_loopback); t_bool tmxr_get_line_halfduplex (TMLN *lp); -t_stat tmxr_set_line_speed (TMLN *lp, const char *speed); -t_stat tmxr_set_config_line (TMLN *lp, const char *config); +t_stat tmxr_set_line_speed (TMLN *lp, CONST char *speed); +t_stat tmxr_set_config_line (TMLN *lp, CONST char *config); t_stat tmxr_set_line_unit (TMXR *mp, int line, UNIT *uptr_poll); t_stat tmxr_set_line_output_unit (TMXR *mp, int line, UNIT *uptr_poll); t_stat tmxr_set_console_units (UNIT *rxuptr, UNIT *txuptr); @@ -259,22 +263,22 @@ void tmxr_msg (SOCKET sock, const char *msg); void tmxr_linemsg (TMLN *lp, const char *msg); void tmxr_linemsgf (TMLN *lp, const char *fmt, ...); void tmxr_linemsgvf (TMLN *lp, const char *fmt, va_list args); -void tmxr_fconns (FILE *st, TMLN *lp, int32 ln); -void tmxr_fstats (FILE *st, TMLN *lp, int32 ln); -t_stat tmxr_set_log (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat tmxr_set_nolog (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat tmxr_show_log (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat tmxr_dscln (UNIT *uptr, int32 val, char *cptr, void *desc); -int32 tmxr_rqln (TMLN *lp); -int32 tmxr_tqln (TMLN *lp); -int32 tmxr_tpqln (TMLN *lp); -t_bool tmxr_tpbusyln (TMLN *lp); -t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, char *cptr, void *desc); -t_stat tmxr_show_lnorder (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat tmxr_show_summ (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat tmxr_show_cstat (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat tmxr_show_lines (FILE *st, UNIT *uptr, int32 val, void *desc); -t_stat tmxr_show_open_devices (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc); +void tmxr_fconns (FILE *st, const TMLN *lp, int32 ln); +void tmxr_fstats (FILE *st, const TMLN *lp, int32 ln); +t_stat tmxr_set_log (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat tmxr_set_nolog (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat tmxr_show_log (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat tmxr_dscln (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +int32 tmxr_rqln (const TMLN *lp); +int32 tmxr_tqln (const TMLN *lp); +int32 tmxr_tpqln (const TMLN *lp); +t_bool tmxr_tpbusyln (const TMLN *lp); +t_stat tmxr_set_lnorder (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat tmxr_show_lnorder (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat tmxr_show_summ (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat tmxr_show_cstat (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat tmxr_show_lines (FILE *st, UNIT *uptr, int32 val, CONST void *desc); +t_stat tmxr_show_open_devices (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc); t_stat tmxr_activate (UNIT *uptr, int32 interval); t_stat tmxr_activate_after (UNIT *uptr, uint32 usecs_walltime); t_stat tmxr_activate_after_abs (UNIT *uptr, uint32 usecs_walltime); @@ -314,4 +318,8 @@ void _tmxr_debug (uint32 dbits, TMLN *lp, const char *msg, char *buf, int bufsiz #endif +#ifdef __cplusplus +} +#endif + #endif /* _SIM_TMXR_H_ */ diff --git a/sim_video.c b/sim_video.c index e4ddd4a..a519392 100644 --- a/sim_video.c +++ b/sim_video.c @@ -46,7 +46,7 @@ vid_quit_callback = callback; return SCPE_OK; } -t_stat vid_show (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc) +t_stat vid_show (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc) { return vid_show_video (st, uptr, val, desc); } @@ -1420,7 +1420,7 @@ int vid_video_events (void) { SDL_Event event; #if SDL_MAJOR_VERSION == 1 -static char *eventtypes[] = { +static const char *eventtypes[] = { "NOEVENT", /**< Unused (do not remove) */ "ACTIVEEVENT", /**< Application loses/gains visibility */ "KEYDOWN", /**< Keys pressed */ @@ -1819,19 +1819,19 @@ else return (const char *)SDLVersion; } -t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { return SCPE_NOFNC; } -t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { if (vid_flags & SIM_VID_INPUTCAPTURED) fprintf (st, "ReleaseKey=%s", vid_release_key); return SCPE_OK; } -static t_stat _vid_show_video (FILE* st, UNIT* uptr, int32 val, void* desc) +static t_stat _vid_show_video (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { int i; @@ -2073,14 +2073,14 @@ static t_stat _show_stat; static FILE *_show_st; static UNIT *_show_uptr; static int32 _show_val; -static void *_show_desc; +static CONST void *_show_desc; void vid_show_video_event (void) { _show_stat = _vid_show_video (_show_st, _show_uptr, _show_val, _show_desc); } -t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { SDL_Event user_event; @@ -2114,7 +2114,7 @@ if (!vid_active) { sim_printf ("No video display is active\n"); return SCPE_UDIS | SCPE_NOMESSAGE; } -fullname = malloc (strlen(filename) + 5); +fullname = (char *)malloc (strlen(filename) + 5); if (!filename) return SCPE_MEM; #if SDL_MAJOR_VERSION == 1 @@ -2320,20 +2320,20 @@ const char *vid_version (void) return "No Video Support"; } -t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { return SCPE_NOFNC; } -t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { fprintf (st, "no release key"); return SCPE_OK; } -t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, void* desc) +t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, CONST void* desc) { -fprintf (st, "video support unavailable\n"); +fprintf (st, "video support unavailable"); return SCPE_OK; } diff --git a/sim_video.h b/sim_video.h index 365ffd8..815507a 100644 --- a/sim_video.h +++ b/sim_video.h @@ -32,6 +32,10 @@ #include "sim_defs.h" +#ifdef __cplusplus +extern "C" { +#endif + #define SIM_KEYPRESS_DOWN 0 /* key states */ #define SIM_KEYPRESS_UP 1 #define SIM_KEYPRESS_REPEAT 2 @@ -184,10 +188,10 @@ void vid_beep (void); void vid_refresh (void); const char *vid_version (void); t_stat vid_set_cursor (t_bool visible, uint32 width, uint32 height, uint8 *data, uint8 *mask, uint32 hot_x, uint32 hot_y); -t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, void* desc); -t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, void* desc); -t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, void* desc); -t_stat vid_show (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, char* desc); +t_stat vid_set_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc); +t_stat vid_show_release_key (FILE* st, UNIT* uptr, int32 val, CONST void* desc); +t_stat vid_show_video (FILE* st, UNIT* uptr, int32 val, CONST void* desc); +t_stat vid_show (FILE* st, DEVICE *dptr, UNIT* uptr, int32 val, CONST char* desc); t_stat vid_screenshot (const char *filename); extern t_bool vid_active; @@ -204,6 +208,10 @@ void vid_set_cursor_position (int32 x, int32 y); /* cursor position (set #define SIM_VID_DBG_KEY 0x04000000 #define SIM_VID_DBG_VIDEO 0x08000000 +#ifdef __cplusplus +} +#endif + #if defined(USE_SIM_VIDEO) && defined(HAVE_LIBSDL) #include #endif /* HAVE_LIBSDL */