/* s3_cpu.c: IBM System/3 CPU simulator

   Copyright (c) 2001-2012, Charles E. Owen
   HPL & SLC instruction code Copyright (c) 2001 by Henk Stegeman
   Decimal Arithmetic Copyright (c) 2000 by Roger Bowler

   Permission is hereby granted, free of charge, to any person obtaining a
   copy of this software and associated documentation files (the "Software"),
   to deal in the Software without restriction, including without limitation
   the rights to use, copy, modify, merge, publish, distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so, subject to the following conditions:

   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

   Except as contained in this notice, the name of Charles E. Owen shall not be
   used in advertising or otherwise to promote the sale, use or other dealings
   in this Software without prior written authorization from Charles E. Owen.

   ------------------------------------------------------------------------------

   cpu          System/3 (models 10 and 15)  central processor

   19-Mar-12    RMS     Changed int to int32 in declarations (Mark Pizzolato)

   The IBM System/3 was a popular small-business computing system introduced
   in 1969 as an entry-level system for businesses that could not afford
   the lowest rungs of the System/360.  Its architecture is inspired by and
   in some ways similar to the 360, but to save cost the instruction set is
   much smaller and the I/O channel system greatly simplified.  There is no
   compatibilty between the two systems.
   
   The original System/3 had two models, 6 and 10, and these came in two
   configurations:  card system and disk system.  The unique feature of
   the /3 was the use of 96-column cards, although traditional 80-column
   cards were supprted also via attachment of a 1442 reader/punch.
   System/3 is a batch-oriented system, controlled by an operating 
   system known as SCP (System Control Program), with it's own job control
   language known as OCL (simpler and more logical than the JCL used on
   the mainframes).  Original models did not support multiprogramming
   or any form of interactivity. (There was a hardware dual-program
   facility available on the model 10 at the high end).
   
   The line grew throughout the 1970s, overlapping the low end of the 360
   line with the introduction of the model 15.  The 15 (and later larger
   variations of the model 12) broke the 64K limit designed in the original
   models by adding a simple address translation unit to support up to 512K
   bytes.  The model 15 added a system of storage protection and allowed
   multiprogramming in up to 3 partitions.  Communications were added to
   allow support of multiple 3270 terminals and the models 12 and 15 broke
   the batch orientation and facilitated interactive use via the CCP 
   (communications control program).  The System/3 was effectively replaced
   by the much easier to manage and use System/34 and System/36 at the
   low and middle of the range, and by System/370 or System/38 at the
   high end.
   
   This simulator implements the model 10 and model 15.  Models 4, 6,
   8, and 12 are not supported (these were technical variations on the
   design which offered no functionality not present on either 10 or 15).
   
   The System/3 is a byte-oriented machine with a data path of 8 bits
   in all models, and an address width of 16 bits.

   The register state for the System/3 CPU is:

   BAR <0:15>           Operand 1 address register
   AAR <0:15>           Operand 2 address register
   XR1 <0:15>           Index Register 1
   XR2 <0:15>           Index Register 2
   PSR <0:15>           Condition Register
   IAR [0:9]<0:15>      Instruction Address Register (p1, p2, plus 1 for each interrupt)
   ARR [0:9]<0:15>      Address Recall Register (p1, p2, plus 1 for each interrupt)
                        (The P2 IAR & ARR are used for the Dual Program feature)
   
   Instruction formats follow the same basic pattern:  a 1-byte opcode, a
   1-byte "Q byte", and one or two addresses following in a format defined
   by the first 4 bits of the opcode:
   
           Op Code                    Q Byte                   Address(es)
   
     0  1  2  3  4  5  6  7      0  1  2  3  4  5  6  7
   +--+--+--+--+--+--+--+--+   +--+--+--+--+--+--+--+--+   +--+--+--+--+--+--+--... 
   | A 1 | A 2 | operation |   | (defined by operation)|   | Format based on A1, A2  
   +--+--+--+--+--+--+--+--+   +--+--+--+--+--+--+--+--+   +--+--+--+--+--+--+--...
                 
         { --- } <---------------- Bits 00 = Operand 2 specified by 2-byte direct addr
                                   Bits 01 = Operand 2 is 1-byte displacement + XR1
                                   Bits 10 = Operand 2 is 1-byte displacement + XR2
                                   Bits 11 = Operand 2 is not used
                                   
   { --- } <---------------------- Bits 00 = Operand 1 specified by 2-byte direct addr
                                   Bits 01 = Operand 1 is 1-byte displacement + XR1
                                   Bits 10 = Operand 1 is 1-byte displacement + XR2
                                   Bits 11 = Operand 1 is not used
   
   Instructions come in 3 basic formats, of varying lengths which are determined
   by the top 4 bits of opcode defined above.  Minimum instruction length is 3 bytes,
   maximum is 6.
   
   1) Command Format (Bits 0-3 are 1111):
   
   +------------+  +------------+   +------------+
   |   Opcode   |  |   Q-byte   |   |   R-byte   +
   +------------+  +------------+   +------------+
   
        (The meaning of Q-byte and R-byte defined by the operation)
        
        
   2) One Address Instructions (either bits 0-1 or bits 2-3 are 01):
   

        Direct Addressing Format:
      
   +------------+  +------------+  +-----------+----------+
   |   Opcode   |  |   Q-byte   |  |    MSB    +   LSB    +
   +------------+  +------------+  +-----------+----------+

        Base-Displacement Format:
   
   +------------+  +------------+  +------------+
   |   Opcode   |  |   Q-byte   |  |displacement+
   +------------+  +------------+  +------------+
                
        Opcodes are 0011xxxx or 1100xxxx.
        
        Q-byte can be:  1) An immediate operand
                        2) A mask
                        3) A branch condition
                        4) A data selection
                        
   2) Two Address Instructions (neither bits 0-1 nor bits 2-3 are both 11):
   
        Operand 1 Address Direct (opcodes 0001 or 0010):
   
   +------------+  +------------+  +----------+----------+  +------------+
   |   Opcode   |  |   Q-byte   |  |   MSB    +   LSB    +  |displacement|
   +------------+  +------------+  +----------+----------+  +------------+
   
        Operand 2 Address Direct (opcodes 0100 or 1000):
   
   +------------+  +------------+  +------------+  +----------+----------+  
   |   Opcode   |  |   Q-byte   |  |displacement|  |   MSB    +   LSB    +  
   +------------+  +------------+  +------------+  +----------+----------+
   
        Both Addresses Direct (opcode 0000):
   
   +------------+  +------------+  +----------+----------+  +-----------+----------+ 
   |   Opcode   |  |   Q-byte   |  |   MSB    +   LSB    +  +   MSB     +   LSB    + 
   +------------+  +------------+  +----------+----------+  +-----------+----------+
   
        Both Addresses Displacement (opcodes 0101, 0110, 1001, or 1010):

   +------------+  +------------+  +------------+  +------------+ 
   |   Opcode   |  |   Q-byte   |  |displacement|  |displacement|  
   +------------+  +------------+  +------------+  +------------+


Assembler Mnemonic Format
-------------------------

   The assembler format contains the same elements as the machine language operation,
but not always in the same format.  The operation code frequently specifies both
the opcode and the Q byte, and the top nybble of the opcode is determined by 
the format of the addresses.

   Addresses take two forms:  the direct address in hex, or a relative address
specified thusly:  (byte,XRx)  where 'byte' is a 1-byte offset, and XRx is 
either XR1 or XR2 for the two index registers.  Use these formats when
'address' is indicated below:

   When 'reg' is mentioned, a mnemonic may be used for the register, thusly:
        IAR     Instruction Address Register for the current program level
        ARR     Address Recall Register for the current program level
        P1IAR   IAR for Program Level 1
        P2IAR   IAR for Program Level 2
        PSR             Program Status Register
                                0x01 - Equal    
                                0x02 - Low
                                0x04 - High
                                0x08 - Decimal overflow
                                0x10 - Test false
                                0x20 - Binary overflow
                                0x40 - Not used
                                0x80 - Not used
        XR1             Index Register 1
        XR2     Index Register 2
        IARx    IAR for the interrupt level x (x = 0 thru 7)
           
   All other operands mentioned below are single-byte hex, except for the
length (len) operand of the two-address instructions, which is a decimal length
in the range 1-256.
   
   No-address formats:
   ------------------
   
   HPL hex,hex          Halt Program Level, the operands are the Q and R bytes
   
   
   One-address formats:
   -------------------
   
   A reg,address        Add to register
   CLI address,byte     Compare Logical Immediate
   MVI address,byte     Move Immediate
   TBF address,mask     Test Bits Off
   TBN address,mask     Test Bits On
   SBF address,mask     Set Bits Off
   SBN address,mask     Set Bits On
   ST reg,address       Store Register
   L reg,address        Load Register
   LA reg,address       Load Address
   JC address,cond      Jump on Condition
   BC address,cond      Branch on Condition
   
   These operations do not specify a qbyte, it is implicit in the opcode:
   
   B address            Unconditional branch to address
   BE address           Branch Equal
   BNE address          Branch Not Equal
   BH address           Branch High
   BNH address          Branch Not High
   BL address           Branch Low
   BNL address          Branch Not Low
   BT address           Branch True
   BF address           Branch False
   BP address           Branch Plus
   BM address           Branch Minus
   BNP address          Branch Not Plus
   BNM address          Branch Not Minus
   BZ address           Branch Zero
   BNZ address          Branch Not Zero
   BOZ address          Branch Overflow Zoned
   BOL address          Branch Overflow Logical
   BNOZ address         Branch No Overflow Zoned
   BNOL address         Branch No Overflow Logical
   NOPB address         No - never jump
   
   (substitute J for B above for a set of Jumps -- 1-byte operand (not 2),
    always jumps forward up to 255 bytes. In this case, 'address' cannot be
    less than the current address, nor greater than the current address + 255)  
   
   Two-address formats (first address is destination, len is decimal 1-256):
   -------------------
   
   MVC address,address,len      Move Characters
   CLC address,address,len      Compare Logical Characters
   ALC address,address,len      Add Logical Characters
   SLC address,address,len      Subtract Logical Characters
   ED address,address,len       Edit
   ITC address,address,len      Insert and Test Characters
   AZ address,address,len       Add Zoned Decimal
   SZ address,address,len       Subtract Zoned Decimal
   
   MNN address,address          Move Numeric to Numeric
   MNZ address,address          Move Numeric to Zone
   MZZ address,address          Move Zone to Zone
   MZN address,address          Move Zone to Numeric
   
   I/O Format
   ----------
   
   In the I/O format, there are always 3 fields:
   
        da - Device Address 0-15 (decimal)
        m - Modifier 0-1
        n - Function 0-7
        
   The meaning of these is entirely defined by the device addressed.    
        
   There may be an optional control byte, or an optional address (based on
the type of instruction).

        SNS da,m,n,address              Sense I/O
        LIO da,m,n,address              Load I/O
        TIO da,m,n,address              Test I/O
        
        SIO da,m,n,cc                   Start I/O -- cc is a control byte
        
        APL da,m,n                      Advance Program Level 



    --------------------------------------------- 
    Here is a handy opcode cross-reference table:
    ---------------------------------------------
    
   |  x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xA  xB  xC  xD  xE  xF
---+------------------------------------------------------------------
0x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
1x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
2x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
3x | SNS LIO  -   -   ST  L   A   -  TBN TBF SBN SBF MVI CLI  -   -
   |
4x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
5x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
6x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
7x | SNS LIO  -   -   ST  L   A   -  TBN TBF SBN SBF MVI CLI  -   -
   |
8x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
9x |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
Ax |  -   -   -   -  ZAZ  -   AZ  SZ MVX  -   ED ITC MVC CLC ALC SLC
Bx | SNS LIO  -   -   ST  L   A   -  TBN TBF SBN SBF MVI CLI  -   -
   |
Cx |  BC TIO  LA  -   -   -   -   -   -   -   -   -   -   -   -   -
Dx |  BC TIO  LA  -   -   -   -   -   -   -   -   -   -   -   -   -
Ex |  BC TIO  LA  -   -   -   -   -   -   -   -   -   -   -   -   -
Fx | HPL APL  JC SIO  -   -   -   -   -   -   -   -   -   -   -   -
    

   This routine is the instruction decode routine for System/3.
   It is called from the simulator control program to execute
   instructions in simulated memory, starting at the simulated PC.
   It runs until 'reason' is set non-zero.

   General notes:

   1. Reasons to stop.  The simulator can be stopped by:

        HALT instruction
        breakpoint encountered
        program check caused by invalid opcode or qbyte or address or I/O spec
        unknown I/O device and STOP_DEV flag set
        I/O error in I/O simulator

   2. Interrupts. 

      There are 8 levels of interrupt, each with it's own IAR (program
      counter).  When an interrupt occurs, execution begins at the
      location in the IAR for that level interrupt.  The program
      must save and restore state.  Each device is assigned both a
      level and a priority in hardware.  Interrupts are reset via
      an SIO instruction, when this happens, the program level
      IAR resumes control.
      
      Interrupts are maintained in the global variable int_req,
      which is zero if no interrupts are pending, otherwise, the
      lower 16 bits represent devices, rightmost bit being device
      0.  Each device requesting an interrupt sets its bit on.

 
   3. Non-existent memory.  On the System/3, any reference to non-existent
      memory (read or write) causes a program check and machine stop.

   4. Adding I/O devices.  These modules must be modified:

        ibms3_defs.h    add interrupt request definition
        ibms3_cpu.c     add IOT mask, PI mask, and routine to dev_table
        ibms3_sys.c     add pointer to data structures to sim_devices
*/

#include "s3_defs.h"

#define UNIT_V_M15      (UNIT_V_UF)                     /* Model 15 extensions */
#define UNIT_M15        (1 << UNIT_V_M15)
#define UNIT_V_DPF      (UNIT_V_UF+1)                   /* Dual Programming */
#define UNIT_DPF        (1 << UNIT_V_DPF)
#define UNIT_V_MSIZE    (UNIT_V_UF+3)                   /* dummy mask */
#define UNIT_MSIZE      (1 << UNIT_V_MSIZE)

uint8 M[MAXMEMSIZE] = { 0 };                            /* memory */
int32 AAR = 0;                                          /* Operand 1 addr reg */
int32 BAR = 0;                                          /* Operand 2 addr reg */
int32 XR1 = 0;                                          /* Index register 1 */
int32 XR2 = 0;                                          /* Index register 2 */
int32 PSR = 0;                                          /* Condition Register */
int32 IAR[10] = { 0 };                                  /* IAR 0-7 = int level 8=P1 9=P2 */
int32 ARR[10] = { 0 };                                  /* ARR 0-7 = int level 8=P1 9=P2 */
int32 dev_disable = 0;                                  /* interrupt disable mask */
int32 int_req = 0;                                      /* Interrupt request device bitmap */
int32 level = 8;                                        /* Current Execution Level*/
int32 stop_dev = 0;                                     /* stop on ill dev */
int32 SR = 0;                                           /* Switch Register */
int32 saved_PC;                                         /* Saved (old) PC) */
int32 debug_reg = 0;                                    /* set for debug/trace */
int32 debug_flag = 0;                                   /* 1 when trace.log open */
FILE *trace;

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_boot (int32 unitno, DEVICE *dptr1);
extern int32 pkb (int32 op, int32 m, int32 n, int32 data);
extern int32 crd (int32 op, int32 m, int32 n, int32 data);
extern int32 lpt (int32 op, int32 m, int32 n, int32 data);
extern int32 dsk1 (int32 op, int32 m, int32 n, int32 data);
extern int32 dsk2 (int32 op, int32 m, int32 n, int32 data);
extern int32 cpu (int32 op, int32 m, int32 n, int32 data);
int32 nulldev (int32 opcode, int32 m, int32 n, int32 data);
int32 add_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2);
int32 subtract_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2);
static int32 compare(int32 byte1, int32 byte2, int32 cond);
static int32 condition(int32 qbyte);
static void store_decimal (int32 addr, int32 len, uint8 *dec, int sign);
static void load_decimal (int32 addr, int32 len, uint8 *result, int *count, int *sign);
static void add_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count);
static void subtract_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count, int *sign);
int32 GetMem(int32 addr);
int32 PutMem(int32 addr, int32 data);

/* IOT dispatch table */

/* System/3 supports only 16 unique device addresses! */

struct ndev dev_table[16] = {
    { 0, 0, &cpu },                                     /* Device 0: CPU control */ 
    { 1, 0, &pkb },                                     /* Device 1: 5471 console printer/keyboard */
    { 0, 0, &nulldev },
    { 0, 0, &nulldev },
    { 0, 0, &nulldev },
    { 0, 0, &crd },                                     /* Device 5: 1442 card reader/punch */
    { 0, 0, &nulldev },                                 /* Device 6: 3410 Tape drives 1 & 2 */ 
    { 0, 0, &nulldev },                                 /* Device 7: 3410 Tape drives 3 & 4 */
    { 0, 0, &nulldev },
    { 0, 0, &nulldev },
    { 0, 0, &dsk1 },                                    /* Device 10: 5444 Disk Drive 1 */
    { 0, 0, &dsk2 },                                    /* Device 11: 5444 Disk Drive 2 */
    { 0, 0, &nulldev },                                 /* Device 12: 5448 Disk Drive 1 */
    { 0, 0, &nulldev },                                 /* DEvice 13: 5448 Disk Drive 2 */
    { 0, 0, &lpt },                                     /* Device 14: 1403/5203 Printer */
    { 0, 0, &nulldev }                                  /* Device 15: 5424 MFCU */
};

/* Priority assigned to interrupt levels */

int32 priority[8] = {8, 7, 5, 4, 3, 6, 2, 1};

/* 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 (NULL, UNIT_FIX + UNIT_BINK, MAXMEMSIZE) };

REG cpu_reg[] = {
    { HRDATA (IAR, saved_PC, 16), REG_RO },
    { HRDATA (IAR-P1, IAR[8], 16) },
    { HRDATA (IAR-P2, IAR[9], 16) },
    { HRDATA (ARR-P1, ARR[8], 16) },
    { HRDATA (ARR-P2, ARR[9], 16) },
    { HRDATA (AAR, AAR, 16) },
    { HRDATA (BAR, BAR, 16) },
    { HRDATA (XR1, XR1, 16) },
    { HRDATA (XR2, XR2, 16) },
    { HRDATA (PSR, PSR, 16) },
    { HRDATA (SR, SR, 16) },
    { HRDATA (INT, int_req, 16), REG_RO },
    { HRDATA (LEVEL, level, 16) },
    { HRDATA (IAR0, IAR[0], 16) },
    { HRDATA (IAR1, IAR[1], 16) },
    { HRDATA (IAR2, IAR[2], 16) },
    { HRDATA (IAR3, IAR[3], 16) },
    { HRDATA (IAR4, IAR[4], 16) },
    { HRDATA (IAR5, IAR[5], 16) },
    { HRDATA (IAR6, IAR[6], 16) },
    { HRDATA (IAR7, IAR[7], 16) },
    { HRDATA (ARR0, ARR[0], 16) },
    { HRDATA (ARR1, ARR[1], 16) },
    { HRDATA (ARR2, ARR[2], 16) },
    { HRDATA (ARR3, ARR[3], 16) },
    { HRDATA (ARR4, ARR[4], 16) },
    { HRDATA (ARR5, ARR[5], 16) },
    { HRDATA (ARR6, ARR[6], 16) },
    { HRDATA (ARR7, ARR[7], 16) },
    { HRDATA (DISABLE, dev_disable, 16), REG_RO },
    { FLDATA (STOP_DEV, stop_dev, 0) },
    { HRDATA (WRU, sim_int_char, 8) },
    { HRDATA (DEBUG, debug_reg, 16) },
    { NULL }
};

MTAB cpu_mod[] = {
    { UNIT_M15, UNIT_M15, "M15", "M15", NULL },
    { UNIT_M15, 0, "M10", "M10", NULL },
    { UNIT_DPF, UNIT_DPF, "DPF", "DPF", NULL },
    { UNIT_DPF, 0, "NODPF", "NODPF", NULL }, 
    { UNIT_MSIZE, 8192, NULL, "8K", &cpu_set_size },
    { UNIT_MSIZE, 16384, NULL, "16K", &cpu_set_size },
    { UNIT_MSIZE, 32768, NULL, "32K", &cpu_set_size },
    { UNIT_MSIZE, 49152, NULL, "48K", &cpu_set_size },
    { UNIT_MSIZE, 65535, NULL, "64K", &cpu_set_size },
    { 0 }
};

DEVICE cpu_dev = {
    "CPU", &cpu_unit, cpu_reg, cpu_mod,
    1, 16, 16, 1, 16, 8,
    &cpu_ex, &cpu_dep, &cpu_reset,
    NULL, NULL, NULL
};

t_stat sim_instr (void)
{
register int32 PC, IR;
int32 i, j, carry, zero, op1, op2;
int32 opcode = 0, qbyte = 0, rbyte = 0;
int32 opaddr, addr1, addr2, dlen1, dlen2, r;
int32 int_savelevel = 8, intpri, intlev, intdev, intmask;
int32 devno, devm, devn;
char display[3][9];
int32 val [32];
register t_stat reason;

/* Restore register state */

PC = IAR[level];                                        /* load local PC */
reason = 0;

/* Main instruction fetch/decode loop */

while (reason == 0) {                                   /* loop until halted */
if (sim_interval <= 0) {                                /* check clock queue */
    if ((reason = sim_process_event ())) break;
}

if (int_req) {                                          /* interrupt? */
    intpri = 16;
    for (i = 0; i < 16; i++) {                          /* Get highest priority device */
        if ((int_req >> i) & 0x01) {
            intlev = dev_table[i].level;
            if (priority[intlev] < intpri) {
                intdev = i;
                intpri = priority[intlev];
            }
        }                   
    }
    intmask = 1 << intdev;                              /* mask is interrupting dev bit */
    int_req = ~int_req & intmask;                       /* Turn off int_req for device */
    int_savelevel = level;                              /* save current level for reset */
    level = dev_table[intdev].level;                    /* get int level from device */
    PC = IAR[level];                                    /* Use int level IAR for new PC */
}                                                       /* end interrupt */

if (sim_brk_summ && sim_brk_test (PC, SWMASK ('E'))) {  /* breakpoint? */
    reason = STOP_IBKPT;                                /* stop simulation */
    break;
}

/* Machine Instruction Execution Here */

if ((debug_reg == 0) && debug_flag == 1) {
    fclose(trace);
    debug_flag = 0;
}   
if (debug_reg) {
    if (!debug_flag) {
        trace = fopen("trace.log", "w");
        debug_flag = 1;
    }
}

if (debug_reg & 0x01) {
    fprintf(trace, "ARR=%04X XR1=%04X XR2=%04X IAR=%04X ", ARR[level], XR1, XR2, PC);
    val[0] = GetMem(PC);
    val[1] = GetMem(PC+1);
    val[2] = GetMem(PC+2);
    val[3] = GetMem(PC+3);
    val[4] = GetMem(PC+4);
    val[5] = GetMem(PC+5);
    fprint_sym(trace, PC, (uint32 *) val, &cpu_unit, SWMASK('M'));
    fprintf(trace, "\n");   
}
    
saved_PC = PC;
opaddr = GetMem(PC) & 0xf0;                             /* fetch addressing mode */
opcode = GetMem(PC) & 0x0f;                             /* fetch opcode */
PC = (PC + 1) & AMASK;
sim_interval = sim_interval - 1;

qbyte = GetMem(PC) & 0xff;                              /* fetch qbyte */
PC = (PC + 1) & AMASK;

if (opaddr == 0xf0) {                                   /* Is it command format? */ 
    rbyte = GetMem(PC) & 0xff;
    PC = (PC + 1) & AMASK;
    switch (opcode) {
        case 0x00:                                      /* HPL:  Halt Program Level */
            for (i = 0; i < 3; i++) {
                for (j = 0; j < 9; j++) {
                    display[i][j] = ' ';
                }
            }
                                                        /* First line */ 
            if (qbyte & 0x04) display[0][2] = '_' ;
            if (rbyte & 0x04) display[0][6] = '_' ;
                                                        /* Second line */
            if (qbyte & 0x08) display[1][1] = '|' ;
            if (rbyte & 0x08) display[1][5] = '|' ;
            if (qbyte & 0x10) display[1][2] = '_' ;
            if (rbyte & 0x10) display[1][6] = '_' ;
            if (qbyte & 0x02) display[1][3] = '|' ;
            if (rbyte & 0x02) display[1][7] = '|' ;
                                                        /* Third line */
            if (qbyte & 0x20) display[2][1] = '|' ;
            if (rbyte & 0x20) display[2][5] = '|' ;
            if (qbyte & 0x40) display[2][2] = '_' ;
            if (rbyte & 0x40) display[2][6] = '_' ;
            if (qbyte & 0x01) display[2][3] = '|' ;
            if (rbyte & 0x01) display[2][7] = '|' ;
                                                        /* Print display segment array */
            sim_printf("\r\n");
            for (i = 0; i < 3; i++) {
                for (j = 0; j < 9; j++) {
                    sim_printf ("%c", display[i][j]);
                }
                sim_printf ("\r\n");
            }
            reason = STOP_HALT;
            break;
        case 0x01:                                      /* APL: Advance Program Level */
            devno = (qbyte >> 4) & 0x0f;
            devm = (qbyte >> 3) & 0x01;
            devn = qbyte & 0x07;
            op1 = dev_table[devno].routine(4, devm, devn, rbyte);
            if (op1 & 0x01) {       
                if (cpu_unit.flags & UNIT_DPF) {        /* Dual Programming? */
                    if (level == 8)                     /* Yes: switch program levels */
                        level = 9;
                        else
                        level = 8;
                    PC = IAR[level];    
                } else {                                /* No: Loop on this inst */
                    PC = PC - 3;
                }   
            }   
            reason = (op1 >> 16) & 0xffff;
            break;
        case 0x02:                                      /* JC: Jump on Condition */
            if (condition(qbyte) == 1) {
                PC = (PC + rbyte) & AMASK;
            }   
            break;
        case 0x03:                                      /* SIO: Start I/O */
            devno = (qbyte >> 4) & 0x0f;    
            devm = (qbyte >> 3) & 0x01;
            devn = qbyte & 0x07;
            reason = dev_table[devno].routine(0, devm, devn, rbyte);
            if (reason == RESET_INTERRUPT) {
                reason = SCPE_OK;
                IAR[level] = PC;
                level = int_savelevel;
                PC = IAR[level];
            }   
            break;
        default:
            reason = STOP_INVOP;
            break;
    }                                                   /* switch (opcode) */
    IAR[level] = PC;
    continue;
}

/* Not command format: fetch the addresses */

addr1 = (opaddr >> 6) & 3;
addr2 = (opaddr >> 4) & 3;

switch (addr1) {
    case 0:
        BAR = GetMem(PC) << 8;
        PC = (PC + 1) & AMASK;
        BAR |=GetMem(PC);
        PC = (PC + 1) & AMASK;
        break;
    case 1:
        BAR = GetMem(PC);   
        BAR = (BAR + XR1) & AMASK;
        PC = (PC + 1) & AMASK;
        break;
    case 2:
        BAR = GetMem(PC);
        BAR = (BAR + XR2) & AMASK;
        PC = (PC + 1) & AMASK;
        break;
    case 3:
        break;
    default:
        break;
}                                                       /* switch (addr1) */

switch (addr2) {
    case 0:
        AAR = GetMem(PC) << 8;
        PC = (PC + 1) & AMASK;
        AAR |= GetMem(PC);
        PC = (PC + 1) & AMASK;
        break;
    case 1:
        AAR = GetMem(PC);   
        AAR = (AAR + XR1) & AMASK;
        PC = (PC + 1) & AMASK;
        break;
    case 2:
        AAR = GetMem(PC);
        AAR = (AAR + XR2) & AMASK;
        PC = (PC + 1) & AMASK;
        break;
    case 3:
        break;
    default:
        break;
}                                                       /* switch (addr1) */

switch (opaddr) {
    case 0x00:
    case 0x10:
    case 0x20:
    case 0x40:
    case 0x50:
    case 0x60:
    case 0x80:
    case 0x90:
    case 0xa0:
        switch (opcode) {
            case 4:                                     /* ZAZ: Zero and Add Zoned */
                dlen2 = qbyte & 0x0f;
                dlen1 = (qbyte >> 4) & 0xf;
                dlen1 += dlen2;
                op1 = BAR;
                for (i = 0; i < (dlen1+1); i++) {
                    PutMem(op1, 0xf0);
                    op1--;
                }   
                r = add_zoned(BAR, dlen1+1, AAR, dlen2+1);
                PSR &= 0xF8;                            /* HJS mod */
                switch (r) {
                    case 0:
                        PSR |= 0x01;
                        break;
                    case 1:
                        PSR |= 0x02;
                        break;
                    case 2:
                        PSR |= 0x04;
                        break;
                    default:
                        break;
                }                       
                break;
            case 6:                                     /* AZ: Add Zoned */
                dlen2 = qbyte & 0x0f;
                dlen1 = (qbyte >> 4) & 0xf;
                dlen1 += dlen2;
                r = add_zoned(BAR, dlen1+1, AAR, dlen2+1);
                PSR &= 0xF0;
                switch (r) {
                    case 0:
                        PSR |= 0x01;
                        break;
                    case 1:
                        PSR |= 0x02;
                        break;
                    case 2:
                        PSR |= 0x04;
                        break;
                    case 3:
                        PSR |= 0x08;
                        break;
                    default:
                        break;
                }                       
                break;
            case 7:                                     /* SZ: Subtract Zoned */
                dlen2 = qbyte & 0x0f;
                dlen1 = (qbyte >> 4) & 0xf;
                dlen1 += dlen2;
                r = subtract_zoned(BAR, dlen1+1, AAR, dlen2+1);
                PSR &= 0xF0;
                switch (r) {
                    case 0:
                        PSR |= 0x01;
                        break;
                    case 1:
                        PSR |= 0x02;
                        break;
                    case 2:
                        PSR |= 0x04;
                        break;
                    case 3:
                        PSR |= 0x08;
                        break;
                    default:
                        break;
                }                       
                break;
            case 8:                                     /* MVX: Move Hex */
                op1 = GetMem(BAR);
                op2 = GetMem(AAR);
                switch (qbyte) {
                    case 0:                             /* Zone to zone */
                        op1 = (op1 & 0x0F) | (op2 & 0xF0);
                        break;
                    case 1:                             /* Numeric to zone */
                        op1 = (op1 & 0x0F) | (op2 << 4);
                        break;
                    case 2:                             /* Zone to numeric */
                        op1 = (op1 & 0xF0) | (op2 >> 4);
                        break;
                    case 3:                             /* Numeric to numeric */
                        op1 = (op1 & 0xF0) | (op2 & 0x0F);
                        break;
                    default:
                        reason = STOP_INVQ;
                        break;
                }
                PutMem(BAR, op1);                   
                break;
            case 0xa:                                   /* ED: Edit */
                zero = 1;
                PSR &= 0xF8;
                IR = GetMem(AAR);
                if ((IR & 0xf0) != 0xF0)
                    PSR |= 0x02;
                    else
                    PSR |= 0x04;
                while (qbyte > -1) {
                    op2 = GetMem(AAR);
                    op1 = GetMem(BAR);
                    if (op1 == 0x20) {
                        op2 |= 0xf0;    
                        PutMem(BAR, op2);
                        AAR--;
                        if (op2 != 0xF0) zero = 0;
                    }   
                    BAR--;
                    qbyte--;
                }
                if (zero)
                    PSR |= 0x01;
                break;
            case 0xb:                                   /* ITC: Insert and Test Chars */
                op2 = GetMem(AAR);
                while (qbyte > -1) {
                    op1 = GetMem(BAR);
                    if (op1 >= 0xF1 && op1 <= 0xF9)
                        break;
                    PutMem(BAR, op2);
                    BAR++;
                    qbyte--;
                }
                ARR[level] = BAR;
                break;
            case 0xc:                                   /* MVC: Move Characters */
                while (qbyte > -1) {
                    PutMem(BAR, GetMem(AAR));
                    BAR--;
                    AAR--;
                    qbyte--;
                }
                break;
            case 0xd:                                   /* CLC: Compare Characters */
                PSR &= 0xF8;
                i = BAR = BAR - qbyte;
                j = AAR = AAR - qbyte;
                while (qbyte > -1) {
                    if (GetMem(i) > GetMem(j)) {
                        PSR |= 0x04;
                        break;
                    }
                    if (GetMem(i) < GetMem(j)) {
                        PSR |= 0x02;
                        break;
                    }
                    i++;
                    j++;
                    qbyte--;
                }
                if (qbyte == -1)
                    PSR |= 0x01;
                break;
            case 0xe:                                   /* ALC: Add Logical Characters */   
                carry = 0;
                zero = 1;
                while (qbyte > -1) {
                    IR = GetMem(BAR) + GetMem(AAR) + carry;
                    if (IR & 0x100) 
                        carry = 1;
                        else
                        carry = 0;
                    if ((IR & 0xFF) != 0) zero = 0;     /* HJS mod */   
                    PutMem(BAR,(IR & 0xFF));
                    BAR--;
                    AAR--;
                    qbyte--;
                }
                PSR &= 0xD8;
                if (zero) 
                    PSR |= 0x01;                        /* Equal */
                if (!zero && !carry)
                    PSR |= 0x02;                        /* Low */
                if (!zero && carry)
                    PSR |= 0x04;                        /* High */
                if (carry)
                    PSR |= 0x20;                        /* Overflow */          
                break;
            case 0xf:                                   /* SLC: Subtract Logical Characters */
                carry = 1;
            zero = 1;
            while (qbyte > -1) {
               IR = GetMem(BAR) + (0xFF - GetMem(AAR)) + carry;
               if (IR & 0x100)
                  carry = 1;
                  else
                  carry = 0;
               if ((IR & 0xFF) != 0) zero = 0;          /* HJS mod */
               PutMem(BAR,(IR & 0xFF));
               BAR--;
               AAR--;
               qbyte--;
            }
                PSR &= 0xF8;
                if (zero)
               PSR |= 0x01;                             /* Equal */
            if (!zero && !carry)
               PSR |= 0x02;                             /* Low */
            if (!zero && carry)
               PSR |= 0x04;                             /* High */
                break;
            default:
                reason = STOP_INVOP;
                break;
        }
        IAR[level] = PC;
        continue;
        break;
    case 0x30:
    case 0x70:
    case 0xb0:
        switch (opcode) {
            case 0:                                     /* SNS: Sense I/O */
                devno = (qbyte >> 4) & 0x0f;
                devm = (qbyte >> 3) & 0x01;
                devn = qbyte & 0x07;
                i = dev_table[devno].routine(3, devm, devn, rbyte);
                PutMem(BAR, i & 0xff);
                BAR--;
                PutMem(BAR, (i >> 8) & 0xff);
                reason = (i >> 16) & 0xffff;
                break;
            case 1:                                     /* LIO: Load I/O */
                devno = (qbyte >> 4) & 0x0f;
                devm = (qbyte >> 3) & 0x01;
                devn = qbyte & 0x07;
                op1 = GetMem(BAR);
                BAR--;
                op1 |= (GetMem(BAR) << 8) & 0xff00;
                reason = dev_table[devno].routine(1, devm, devn, op1);
                break;
            case 4:                                     /* ST: Store Register */
                switch (qbyte) {
                    case 0x01:
                        PutMem(BAR, XR1 & 0xff);
                        BAR--;
                        PutMem(BAR, (XR1 >> 8) & 0xff);
                        break;
                    case 0x02:
                        PutMem(BAR, XR2 & 0xff);
                        BAR--;
                        PutMem(BAR, (XR2 >> 8) & 0xff);
                        break;
                    case 0x04:
                        PutMem(BAR, PSR & 0xFF);
                        BAR--;
                        PutMem(BAR, 0);                 /* LCRR, not imp. */
                        break;
                    case 0x08:
                        PutMem(BAR, ARR[level] & 0xff);
                        BAR--;
                        PutMem(BAR, (ARR[level] >> 8) & 0xff);
                        break;
                    case 0x10:
                        PutMem(BAR, IAR[level] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[level] >> 8) & 0xff);
                        break;
                    case 0x20:
                        PutMem(BAR, IAR[8] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[8] >> 8) & 0xff);
                        break;
                    case 0x40:
                        PutMem(BAR, IAR[9] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[9] >> 8) & 0xff);
                        break;
                    case 0x80:
                        PutMem(BAR, IAR[0] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[0] >> 8) & 0xff);
                        break;
                    case 0x81:
                        PutMem(BAR, IAR[7] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[7] >> 8) & 0xff);
                        break;
                    case 0x82:
                        PutMem(BAR, IAR[6] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[6] >> 8) & 0xff);
                        break;
                    case 0x84:
                        PutMem(BAR, IAR[5] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[5] >> 8) & 0xff);
                        break;
                    case 0x88:
                        PutMem(BAR, IAR[4] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[4] >> 8) & 0xff);
                        break;
                    case 0x90:
                        PutMem(BAR, IAR[3] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[3] >> 8) & 0xff);
                        break;
                    case 0xA0:
                        PutMem(BAR, IAR[2] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[2] >> 8) & 0xff);
                        break;
                    case 0xC0:
                        PutMem(BAR, IAR[1] & 0xff);
                        BAR--;
                        PutMem(BAR, (IAR[1] >> 8) & 0xff);
                        break;
                    default:
                        reason = STOP_INVQ;
                        break;
                }               
                break;
            case 5:                                     /* L: Load Register */
                switch (qbyte) {
                    case 0x01:
                        XR1 = GetMem(BAR) & 0xff;
                        BAR--;
                        XR1 |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x02:
                        XR2 = GetMem(BAR) & 0xff;
                        BAR--;
                        XR2 |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x04:
                        PSR = GetMem(BAR) & 0xff;
                        BAR--;
                        break;
                    case 0x08:
                        ARR[level] = GetMem(BAR) & 0xff;
                        BAR--;
                        ARR[level] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x10:
                        IAR[level] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[level] |= (GetMem(BAR) << 8) & 0xff00;
                        PC = IAR[level];
                        break;
                    case 0x20:
                        IAR[8] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[8] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x40:
                        IAR[9] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[9] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x80:
                        IAR[0] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[0] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x81:
                        IAR[7] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[7] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x82:
                        IAR[6] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[6] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x84:
                        IAR[5] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[5] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x88:
                        IAR[4] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[4] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0x90:
                        IAR[3] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[3] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0xA0:
                        IAR[2] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[2] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    case 0xC0:
                        IAR[1] = GetMem(BAR) & 0xff;
                        BAR--;
                        IAR[1] |= (GetMem(BAR) << 8) & 0xff00;
                        break;
                    default:
                        reason = STOP_INVQ;
                        break;
                }               
                break;
            case 6:                                     /* A: Add to Register */
                IR = GetMem(BAR) & 0x00ff;
                BAR--;
                IR |= (GetMem(BAR) << 8) & 0xff00;
                switch (qbyte) {
                    case 0x01:
                        IR += XR1;
                        XR1 = IR & AMASK;
                        break;
                    case 0x02:
                        IR += XR2;
                        XR2 = IR & AMASK;
                        break;
                    case 0x04:
                        IR += PSR;
                        PSR = IR & AMASK;
                        break;
                    case 0x08:
                        IR += ARR[level];
                        ARR[level] = IR & AMASK;
                        break;
                    case 0x10:
                        IR += IAR[level];
                        IAR[level] = IR & AMASK;
                        break;
                    case 0x20:
                        IR += IAR[8];
                        IAR[8] = IR & AMASK;
                        break;
                    case 0x40:
                        IR += IAR[9];
                        IAR[9] = IR & AMASK;
                        break;
                    case 0x80:
                        IR += IAR[0];
                        IAR[0] = IR & AMASK;
                        break;
                    case 0x81:
                        IR += IAR[7];
                        IAR[7] = IR & AMASK;
                        break;
                    case 0x82:
                        IR += IAR[6];
                        IAR[6] = IR & AMASK;
                        break;
                    case 0x84:
                        IR += IAR[5];
                        IAR[5] = IR & AMASK;
                        break;
                    case 0x88:
                        IR += IAR[4];
                        IAR[4] = IR & AMASK;
                        break;
                    case 0x90:
                        IR += IAR[3];
                        IAR[3] = IR & AMASK;
                        break;
                    case 0xA0:
                        IR += IAR[2];
                        IAR[2] = IR & AMASK;
                        break;
                    case 0xC0:
                        IR += IAR[1];
                        IAR[1] = IR & AMASK;
                        break;
                    default:
                        reason = STOP_INVQ;
                        break;
                }               
                PSR &= 0xD8;
                if ((IR & 0xffff) == 0)
                    PSR |= 0x01;                        /* Zero */
                if ((IR & 0xffff) != 0 && !(IR & 0x10000))
                    PSR |= 0x02;                        /* Low */
                if ((IR & 0xffff) != 0 && (IR & 0x10000))
                    PSR |= 0x04;                        /* High */
                if ((IR & 0x10000))
                    PSR |= 0x20;                        /* Bin overflow */  
                break;
            case 8:                                     /* TBN: Test Bits On */
                IR = GetMem(BAR);
                PSR &= 0xFF;
                if ((IR & qbyte) != qbyte)
                    PSR |= 0x10;
                break;
            case 9:                                     /* TBF: Test Bits Off */
                IR = GetMem(BAR);
                PSR &= 0xFF;
                if ((IR & qbyte))
                    PSR |= 0x10;
                break;
            case 0xa:                                   /* SBN: Set Bits On */
                IR = GetMem(BAR);
                IR |= qbyte;
                PutMem(BAR, IR);
                break;
            case 0xb:                                   /* SBF: Set Bits Off */
                IR = GetMem(BAR);
                IR &= ~qbyte;
                PutMem(BAR, IR);
                break;
            case 0xc:                                   /* MVI: Move Immediate */
                PutMem(BAR, qbyte);
                break;
            case 0xd:                                   /* CLI: Compare Immediate */
                PSR = compare(GetMem(BAR), qbyte, PSR);
                break;
            default:
                reason = STOP_INVOP;
                break;
        }               
        IAR[level] = PC;
        continue;
        break;  
    case 0xc0:              
    case 0xd0:
    case 0xe0:
        switch (opcode) {
            case 0:                                     /* BC: Branch on Condition */
                ARR[level] = AAR & AMASK;
                if (condition(qbyte) == 1) {
                    IR = ARR[level];
                    ARR[level] = PC & AMASK;
                    PC = IR;
                }   
                break;
            case 1:                                     /* TIO: Test I/O */
                devno = (qbyte >> 4) & 0x0f;
                devm = (qbyte >> 3) & 0x01;
                devn = qbyte & 0x07;
                op1 = dev_table[devno].routine(2, devm, devn, rbyte);
                if (op1 & 0x01) {
                    ARR[level] = AAR & AMASK;
                    IR = ARR[level];
                    ARR[level] = PC & AMASK;
                    PC = IR;
                }   
                reason = (op1 >> 16) & 0xffff;
                break;
            case 2:                                     /* LA: Load Address */
                switch (qbyte) {
                    case 1:
                        XR1 = AAR;
                        break;
                    case 2:
                        XR2 = AAR;
                        break;
                    default:
                        reason = STOP_INVQ;
                        break;
                }               
                break;      
            default:
                reason = STOP_INVOP;
                break;
        }                                               /* switch (opcode) */
        IAR[level] = PC;
        continue;
        
    default:
        reason = STOP_INVOP;
        break;
}                                                       /* switch (opaddr) */                               
                
}                                                       /* end while (reason == 0) */

/* Simulation halted */

saved_PC = PC;
return reason;
}

/* On models 4-12, these memory functions could be inline, but
   on a model 15 with ATU address mapping must be performed so
   they are in functions here for future expansion.
*/   

/* Fetch a byte from memory */

int32 GetMem(int32 addr)
{
    return M[addr] & 0xff;
}

/* Place a byte in memory */

int32 PutMem(int32 addr, int32 data)
{
    M[addr] = data & 0xff;
    return 0;
}

/* Check the condition register against the qbyte and return 1 if true */

static int32 condition(int32 qbyte)
{
    int32 r = 0, t, q;
    t = (qbyte & 0xf0) >> 4;
    q = qbyte & 0x0f;
    if (qbyte & 0x80) {                                 /* True if any condition tested = 1*/
        if (((qbyte & 0x3f) & PSR) != 0) r = 1;
    } else {                                            /* True if all conditions tested = 0 */
        if (((qbyte & 0x3f) & PSR) == 0) r = 1;
    }
                                                        /* these bits reset by a test */
    if (qbyte & 0x10)   
        PSR &= 0xEF;                                    /* Reset test false if used */
    if (qbyte & 0x08)
        PSR &= 0xF7;                                    /* Reset decimal overflow if tested */
    if (qbyte == 0x00)
        r = 1;                                          /* unconditional branch */
    if (qbyte == 0x80)
        r = 0;                                          /* force no branch */
    if (t >=0 && t < 8 && (q == 7 || q == 0xf))
        r = 0;                                          /* no-op */
    if (t > 7 && t < 0x10 && (q == 7 || q == 0xf))
        r = 1;                                          /* Force branch */
return (r);     
}
/* Given operand 1 and operand 2, compares the two and returns
   the System/3 condition register bits appropriately, given the
   condition register initial state in parameter 3
*/   

static int32 compare(int32 byte1, int32 byte2, int32 cond)
{
    int32 r;
    
    r = cond & 0xF8;                                    /* mask off all but unaffected bits 2,3,4 */
    if (byte1 == byte2)
        r |= 0x01;                                      /* set equal bit */
    if (byte1 < byte2)
        r |= 0x02;                                      /* set less-than bit */
    if (byte1 > byte2)
        r |= 0x04;                                      /* set greater than bit */
    return r;           
}

/*-------------------------------------------------------------------*/
/* Add two zoned decimal operands                                    */
/*                                                                   */
/* Input:                                                            */
/*      addr1   Logical address of packed decimal storage operand 1  */
/*      len1    Length minus one of storage operand 1 (range 0-15)   */
/*      addr2   Logical address of packed decimal storage operand 2  */
/*      len2    Length minus one of storage operand 2 (range 0-15)   */
/* Output:                                                           */
/*      The return value is the condition code:                      */
/*      0=result zero, 1=result -ve, 2=result +ve, 3=overflow        */
/*                                                                   */
/*      A program check may be generated if either logical address   */
/*      causes an addressing, translation, or fetch protection       */
/*      exception, or if either operand causes a data exception      */
/*      because of invalid decimal digits or sign, or if the         */
/*      first operand is store protected.  Depending on the PSW      */
/*      program mask, decimal overflow may cause a program check.    */
/*-------------------------------------------------------------------*/
int32 add_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2)
{
int     cc;                             /* Condition code            */
uint8   dec1[MAX_DECIMAL_DIGITS];       /* Work area for operand 1   */
uint8   dec2[MAX_DECIMAL_DIGITS];       /* Work area for operand 2   */
uint8   dec3[MAX_DECIMAL_DIGITS];       /* Work area for result      */
int     count1, count2, count3;         /* Significant digit counters*/
int     sign1, sign2, sign3;            /* Sign of operands & result */

    /* Load operands into work areas */
    load_decimal (addr1, len1, dec1, &count1, &sign1);
    load_decimal (addr2, len2, dec2, &count2, &sign2);

    /* Add or subtract operand values */
    if (count2 == 0)
    {
    /* If second operand is zero then result is first operand */
        memcpy (dec3, dec1, MAX_DECIMAL_DIGITS);
        count3 = count1;
        sign3 = sign1;
    }
    else if (count1 == 0)
    {
        /* If first operand is zero then result is second operand */
        memcpy (dec3, dec2, MAX_DECIMAL_DIGITS);
        count3 = count2;
        sign3 = sign2;
    }
    else if (sign1 == sign2)
    {
        /* If signs are equal then add operands */
        add_decimal (dec1, dec2, dec3, &count3);
        sign3 = sign1;
    }
    else
    {
        /* If signs are opposite then subtract operands */
        subtract_decimal (dec1, dec2, dec3, &count3, &sign3);
        if (sign1 < 0) sign3 = -sign3;
    }

    /* Set condition code */
    cc = (count3 == 0) ? 0 : (sign3 < 1) ? 1 : 2;

    /* Overflow if result exceeds first operand length */
    if (count3 > len1)
        cc = 3;

    /* Set positive sign if result is zero */
    if (count3 == 0)
        sign3 = 1;

    /* Store result into first operand location */
    store_decimal (addr1, len1, dec3, sign3);

    /* Return condition code */
    return cc;

}   /* end function add_packed */

/*-------------------------------------------------------------------*/
/* Subtract two zoned decimal operands                               */
/*                                                                   */
/* Input:                                                            */
/*      addr1   Logical address of packed decimal storage operand 1  */
/*      len1    Length minus one of storage operand 1 (range 0-15)   */
/*      addr2   Logical address of packed decimal storage operand 2  */
/*      len2    Length minus one of storage operand 2 (range 0-15)   */
/* Output:                                                           */
/*      The return value is the condition code:                      */
/*      0=result zero, 1=result -ve, 2=result +ve, 3=overflow        */
/*                                                                   */
/*      A program check may be generated if either logical address   */
/*      causes an addressing, translation, or fetch protection       */
/*      exception, or if either operand causes a data exception      */
/*      because of invalid decimal digits or sign, or if the         */
/*      first operand is store protected.  Depending on the PSW      */
/*      program mask, decimal overflow may cause a program check.    */
/*-------------------------------------------------------------------*/
int32 subtract_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2)
{
int     cc;                             /* Condition code            */
uint8   dec1[MAX_DECIMAL_DIGITS];       /* Work area for operand 1   */
uint8   dec2[MAX_DECIMAL_DIGITS];       /* Work area for operand 2   */
uint8   dec3[MAX_DECIMAL_DIGITS];       /* Work area for result      */
int     count1, count2, count3;         /* Significant digit counters*/
int     sign1, sign2, sign3;            /* Sign of operands & result */

    /* Load operands into work areas */
    load_decimal (addr1, len1, dec1, &count1, &sign1);
    load_decimal (addr2, len2, dec2, &count2, &sign2);

    /* Add or subtract operand values */
    if (count2 == 0)
    {
        /* If second operand is zero then result is first operand */
        memcpy (dec3, dec1, MAX_DECIMAL_DIGITS);
        count3 = count1;
        sign3 = sign1;
    }
    else if (count1 == 0)
    {
        /* If first operand is zero then result is -second operand */
        memcpy (dec3, dec2, MAX_DECIMAL_DIGITS);
        count3 = count2;
        sign3 = -sign2;
    }
    else if (sign1 != sign2)
    {
        /* If signs are opposite then add operands */
        add_decimal (dec1, dec2, dec3, &count3);
        sign3 = sign1;
    }
    else
    {
        /* If signs are equal then subtract operands */
        subtract_decimal (dec1, dec2, dec3, &count3, &sign3);
        if (sign1 < 0) sign3 = -sign3;
    }

    /* Set condition code */
    cc = (count3 == 0) ? 0 : (sign3 < 1) ? 1 : 2;

    /* Overflow if result exceeds first operand length */
    if (count3 > len1)
        cc = 3;

    /* Set positive sign if result is zero */
    if (count3 == 0)
        sign3 = 1;

    /* Store result into first operand location */
    store_decimal (addr1, len1, dec3, sign3);

    /* Return condition code */
    return cc;

}   /* end function subtract_packed */


/*-------------------------------------------------------------------*/
/* Add two decimal byte strings as unsigned decimal numbers          */
/*                                                                   */
/* Input:                                                            */
/*      dec1    A 31-byte area containing the decimal digits of      */
/*              the first operand.  Each byte contains one decimal   */
/*              digit in the low-order 4 bits of the byte.           */
/*      dec2    A 31-byte area containing the decimal digits of      */
/*              the second operand.  Each byte contains one decimal  */
/*              digit in the low-order 4 bits of the byte.           */
/* Output:                                                           */
/*      result  Points to a 31-byte area to contain the result       */
/*              digits. One decimal digit is placed in the low-order */
/*              4 bits of each byte.                                 */
/*      count   Points to an integer to receive the number of        */
/*              digits in the result excluding leading zeroes.       */
/*              This field is set to zero if the result is all zero, */
/*              or to MAX_DECIMAL_DIGITS+1 if overflow occurred.     */
/*-------------------------------------------------------------------*/
static void add_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count)
{
int     d;                              /* Decimal digit             */
int     i;                              /* Array subscript           */
int     n = 0;                          /* Significant digit counter */
int     carry = 0;                      /* Carry indicator           */

    /* Add digits from right to left */
    for (i = MAX_DECIMAL_DIGITS - 1; i >= 0; i--)
    {
        /* Add digits from first and second operands */
        d = dec1[i] + dec2[i] + carry;

         /* Check for carry into next digit */
        if (d > 9) {
            d -= 10;
            carry = 1;
        } else {
            carry = 0;
        }

        /* Check for significant digit */
        if (d != 0)
            n = MAX_DECIMAL_DIGITS - i;

        /* Store digit in result */
        result[i] = d;

    }   /* end for */

    /* Check for carry out of leftmost digit */
    if (carry)
        n = MAX_DECIMAL_DIGITS + 1;

    /* Return significant digit counter */
    *count = n;

}   /* end function add_decimal */

/*-------------------------------------------------------------------*/
/* Subtract two decimal byte strings as unsigned decimal numbers     */
/*                                                                   */
/* Input:                                                            */
/*      dec1    A 31-byte area containing the decimal digits of      */
/*              the first operand.  Each byte contains one decimal   */
/*              digit in the low-order 4 bits of the byte.           */
/*      dec2    A 31-byte area containing the decimal digits of      */
/*              the second operand.  Each byte contains one decimal  */
/*              digit in the low-order 4 bits of the byte.           */
/* Output:                                                           */
/*      result  Points to a 31-byte area to contain the result       */
/*              digits. One decimal digit is placed in the low-order */
/*              4 bits of each byte.                                 */
/*      count   Points to an integer to receive the number of        */
/*              digits in the result excluding leading zeroes.       */
/*              This field is set to zero if the result is all zero. */
/*      sign    -1 if the result is negative (operand2 > operand1)   */
/*              +1 if the result is positive (operand2 <= operand1)  */
/*-------------------------------------------------------------------*/
static void subtract_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count, int *sign)
{
int     d;                              /* Decimal digit             */
int     i;                              /* Array subscript           */
int     n = 0;                          /* Significant digit counter */
int     borrow = 0;                     /* Borrow indicator          */
int     rc;                             /* Return code               */
uint8   *higher;                        /* -> Higher value operand   */
uint8   *lower;                         /* -> Lower value operand    */

    /* Compare digits to find which operand has higher numeric value */
    rc = memcmp (dec1, dec2, MAX_DECIMAL_DIGITS);

    /* Return positive zero result if both operands are equal */
    if (rc == 0) {
        memset (result, 0, MAX_DECIMAL_DIGITS);
        *count = 0;
        *sign = +1;
        return;
    }

     /* Point to higher and lower value operands and set sign */
    if (rc > 0) {
        higher = dec1;
        lower = dec2;
       *sign = +1;
    } else {
        lower = dec1;
        higher = dec2;
       *sign = -1;
    }

    /* Subtract digits from right to left */
    for (i = MAX_DECIMAL_DIGITS - 1; i >= 0; i--)
    {
        /* Subtract lower operand digit from higher operand digit */
        d = higher[i] - lower[i] - borrow;

        /* Check for borrow from next digit */
        if (d < 0) {
            d += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }

        /* Check for significant digit */
        if (d != 0)
            n = MAX_DECIMAL_DIGITS - i;

        /* Store digit in result */
        result[i] = d;

    }   /* end for */

    /* Return significant digit counter */
    *count = n;

}   /* end function subtract_decimal */

/*-------------------------------------------------------------------*/
/* Load a zoned decimal storage operand into a decimal byte string   */
/*                                                                   */
/* Input:                                                            */
/*      addr    Logical address of zoned decimal storage operand     */
/*      len     Length minus one of storage operand (range 0-15)     */
/* Output:                                                           */
/*      result  Points to a 31-byte area into which the decimal      */
/*              digits are loaded.  One decimal digit is loaded      */
/*              into the low-order 4 bits of each byte, and the      */
/*              result is padded to the left with high-order zeroes  */
/*              if the storage operand contains less than 31 digits. */
/*      count   Points to an integer to receive the number of        */
/*              digits in the result excluding leading zeroes.       */
/*              This field is set to zero if the result is all zero. */
/*      sign    Points to an integer which will be set to -1 if a    */
/*              negative sign was loaded from the operand, or +1 if  */
/*              a positive sign was loaded from the operand.         */
/*                                                                   */
/*      A program check may be generated if the logical address      */
/*      causes an addressing, translation, or fetch protection       */
/*      exception, or if the operand causes a data exception         */
/*      because of invalid decimal digits or sign.                   */
/*-------------------------------------------------------------------*/
static void load_decimal (int32 addr, int32 len, uint8 *result, int *count, int *sign)
{
int     h;                              /* Hexadecimal digit         */
int     i, j;                           /* Array subscripts          */
int     n;                              /* Significant digit counter */

    if ((GetMem(addr) & 0xf0) == 0xD0) 
        *sign = -1;
        else 
        *sign = 1;
    j = len;
    for (i = MAX_DECIMAL_DIGITS; i > -1; i--) {
        if (j) {
            h = GetMem(addr) & 0x0f;
            addr--;
            j--;
        } else {
            h = 0;
        }
        result [i-1] = h;
        if (h > 0) n = i;
    }
    *count = 32 - n;                

}   /* end function load_decimal */

/*-------------------------------------------------------------------*/
/* Store decimal byte string into packed decimal storage operand     */
/*                                                                   */
/* Input:                                                            */
/*      addr    Logical address of packed decimal storage operand    */
/*      len     Length minus one of storage operand (range 0-15)     */
/*      dec     A 31-byte area containing the decimal digits to be   */
/*              stored.  Each byte contains one decimal digit in     */
/*              the low-order 4 bits of the byte.                    */
/*      sign    -1 if a negative sign is to be stored, or +1 if a    */
/*              positive sign is to be stored.                       */
/*                                                                   */
/*      A program check may be generated if the logical address      */
/*      causes an addressing, translation, or protection exception.  */
/*-------------------------------------------------------------------*/
static void store_decimal (int32 addr, int32 len, uint8 *dec, int sign)
{
int     i, j, a;                        /* Array subscripts          */

    j = len;
    a = addr;
    for (i = MAX_DECIMAL_DIGITS; i > -1; i--) {
        if (j) {
            PutMem(a, (dec[i-1] | 0xf0));
            a--;
            j--;
        } else {
            break;
        }       
    }
    if (sign == -1) {
        PutMem(addr, (GetMem(addr) & 0x0f));
        PutMem(addr, (GetMem(addr) | 0xf0)); 
    }
    
}   /* end function store_decimal */

/* CPU Device Control */

int32 cpu (int32 op, int32 m, int32 n, int32 data)
{
    int32 iodata = 0;
    
    switch (op) {
        case 0x00:                                      /* Start IO */
            return SCPE_OK;
        case 0x01:                                      /* LIO */
            return SCPE_OK;
        case 0x02:                                      /* TIO */
            break;
        case 0x03:                                      /* SNS */
                                                        /* SNS CPU gets the data switches */
            iodata = SR;
            break;
        case 0x04:                                      /* APL */
            break;
        default:
            break;
    }                                   
    return ((SCPE_OK << 16) | iodata);
}



/* Null device */

int32 nulldev (int32 opcode, int32 m, int32 n, int32 data)
{
if (opcode == 1)    
    return SCPE_OK;                                     /* Ok to LIO unconfigured devices? */
return STOP_INVDEV;
}

/* Reset routine */

t_stat cpu_reset (DEVICE *dptr)
{
int_req = 0;
level = 8;
sim_brk_types = sim_brk_dflt = SWMASK ('E');
return SCPE_OK;
}

/* Memory examine */

t_stat cpu_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw)
{
if (addr >= MEMSIZE) return SCPE_NXM;
if (vptr != NULL) *vptr = M[addr] & 0xff;
return SCPE_OK;
}

/* Memory deposit */

t_stat cpu_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw)
{
if (addr >= MEMSIZE) return SCPE_NXM;
M[addr] = val & 0xff;
return SCPE_OK;
}

t_stat cpu_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
int32 mc = 0;
uint32 i;

if ((val <= 0) || (val > MAXMEMSIZE) || ((val & 07777) != 0))
    return SCPE_ARG;
for (i = val; i < MEMSIZE; i++) mc = 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;
}

t_stat cpu_boot (int32 unitno, DEVICE *dptr)
{
level = 8;
IAR[8] = 0;
return SCPE_OK;
}
