/* sigma_cis.c: Sigma decimal instructions

   Copyright (c) 2007-2018, Robert M Supnik

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

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

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

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

   Questions:

   1. On the Sigma 9, in ASCII mode, is an ASCII blank used in EBS?

   02-Jun-2018  RMS     Fixed unsigned < 0 in decimal compare (Mark Pizzolato)
*/

#include "sigma_defs.h"

/* Decimal string structure */

#define DSTRLNT         4                               /* words per dec string */
#define DECA            12                              /* first dec accum reg */

/* Standard characters */

#define ZONE_E          0xF0                            /* EBCDIC zone bits */
#define ZONE_A          0x30                            /* ASCII zone bits */
#define ZONE            ((PSW1 & PSW1_AS)? ZONE_A: ZONE_E)
#define PKPLUS_E        0xC                             /* EBCDIC preferred plus */
#define PKPLUS_A        0xA                             /* ASCII preferred plus */
#define PKPLUS          ((PSW1 & PSW1_AS)? PKPLUS_A: PKPLUS_E)
#define BLANK_E         0x40                            /* EBCDIC blank */
#define BLANK_A         0x20                            /* ASCII blank */
#define BLANK           ((PSW1 & PSW1_AS)? BLANK_A: BLANK_E)

/* Edit special characters */

#define ED_DS           0x20                            /* digit select */
#define ED_SS           0x21                            /* start significance */
#define ED_FS           0x22                            /* field separator */
#define ED_SI           0x23                            /* immediate significance */

/* Decimal strings run low order (word 0/R15) to high order (word 3/R12) */

typedef struct {
    uint32              sign;
    uint32              val[DSTRLNT];
    } dstr_t;

/* Copy decimal accumulator to decimal string, no validation or sign separation */

#define ReadDecA(src)   for (i = 0; i < DSTRLNT; i++) \
                            src.val[DSTRLNT - 1 - i] = R[DECA + i];

static dstr_t Dstr_zero = { 0, { 0, 0, 0, 0 } };

extern uint32 *R;
extern uint32 CC;
extern uint32 PSW1;
extern uint32 bvamqrx;
extern uint32 cpu_model;

uint32 ReadDstr (uint32 lnt, uint32 addr, dstr_t *dec);
uint32 WriteDstr (uint32 lnt, uint32 addr, dstr_t *dec);
void WriteDecA (dstr_t *dec, t_bool cln);
void SetCC2Dstr (uint32 lnt, dstr_t *dst);
uint32 TestDstrValid (dstr_t *src);
uint32 DstrInvd (void);
uint32 AddDstr (dstr_t *src1, dstr_t *src2, dstr_t *dst, uint32 cin);
void SubDstr (dstr_t *src1, dstr_t *src2, dstr_t *dst);
int32 CmpDstr (dstr_t *src1, dstr_t *src2);
uint32 LntDstr (dstr_t *dsrc);
uint32 NibbleLshift (dstr_t *dsrc, uint32 sc, uint32 cin);
uint32 NibbleRshift (dstr_t *dsrc, uint32 sc, uint32 cin);
t_bool GenLshift (dstr_t *dsrc, uint32 sc);
void GenRshift (dstr_t *dsrc, uint32 sc);
uint32 ed_getsrc (uint32 sa, uint32 *c, uint32 *d);
void ed_advsrc (uint32 rn, uint32 c);
t_bool cis_test_int (dstr_t *src1, uint32 *kint);
void cis_dm_int (dstr_t *src, dstr_t *dst, uint32 kint);
void cis_dd_int (dstr_t *src, dstr_t *dst, uint32 t, uint32 *kint);

/* Decimal instructions */

uint32 cis_dec (uint32 op, uint32 lnt, uint32 bva)
{
dstr_t src1, src2, src2x, dst;
uint32 i, t, kint, ldivr, ldivd, ad, c, d, end;
int32 sc, scmp;
uint32 tr;

if (lnt == 0)                                           /* adjust length */
    lnt = 16;
CC &= ~(CC1|CC2);                                       /* clear CC1, CC2 */

switch (op) {                                           /* case on opcode */

    case OP_DL:                                         /* decimal load */
        if ((tr = ReadDstr (lnt, bva, &dst)) != 0)      /* read mem string */
            return tr;
        WriteDecA (&dst, FALSE);                        /* store result */
        break;

    case OP_DST:                                        /* decimal store */
        ReadDecA (dst);                                 /* read dec accum */
        if ((tr = TestDstrValid (&dst)) != 0)           /* valid? */
            return tr;
        if ((tr = WriteDstr (lnt, bva, &dst)) != 0)     /* write to mem */
            return tr;
        break;

    case OP_DS:                                         /* decimal subtract */
    case OP_DA:                                         /* decimal add */
        ReadDecA (src1);                                /* read dec accum */
        if ((tr = TestDstrValid (&src1)) != 0)          /* valid? */ 
            return tr;
        if ((tr = ReadDstr (lnt, bva, &src2)) != 0)     /* read mem string */
            return tr;
        if (op == OP_DS)                                /* sub? invert sign */
            src2.sign = src2.sign ^ 1;
        if (src1.sign ^ src2.sign) {                    /* opp signs? sub */
            if (CmpDstr (&src1, &src2) < 0) {           /* src1 < src2? */
                SubDstr (&src1, &src2, &dst);           /* src2 - src1 */
                dst.sign = src2.sign;                   /* sign = src2 */
                }
            else {
                SubDstr (&src2, &src1, &dst);           /* src1 - src2 */
                dst.sign = src1.sign;                   /* sign = src1 */
                }
            }
        else {                                          /* addition */
            if (AddDstr (&src1, &src2, &dst, 0)) {      /* add, overflow? */
                CC |= CC2;                              /* set CC2 */
                return (PSW1 & PSW1_DM)? TR_DEC: 0;     /* trap if enabled */
                }
            dst.sign = src1.sign;                       /* set result sign */
            }
        WriteDecA (&dst, TRUE);                         /* store result */
        break;

    case OP_DC:                                         /* decimal compare */
        ReadDecA ( src1);                               /* read dec accum */
        if ((tr = TestDstrValid (&src1)) != 0)          /* valid? */ 
            return tr;
        if ((tr = ReadDstr (lnt, bva, &src2)) != 0)     /* read mem string */
            return tr;
        LntDstr (&src1);                                /* clean -0 */
        LntDstr (&src2);
        if (src1.sign ^ src2.sign)                      /* signs differ? */
            CC = src1.sign? CC4: CC3;                   /* set < or > */
        else {                                          /* same signs */
            scmp = CmpDstr (&src1, &src2);              /* compare strings */
            if (scmp < 0)
                CC = (src1.sign? CC3: CC4);
            else if (scmp > 0)
                CC = (src1.sign? CC4: CC3);
            else CC = 0;
            }
        break;

/* Decimal multiply - algorithm from George Plue.

   The Sigma does decimal multiply one digit at a time, using the multiplicand
   and a doubled copy of the multiplicand. Multiplying by digits 1-5 is
   synthesized by 1-3 adds; multiplying by digits 6-9 is synthesized by 1-2
   subtractions, and adding 1 to the next multiplier digit. (That is,
   multiplying by 7 is done by multiplying by "10 - 3".) This requires at
   most one extra add to fixup the last digit, and minimizes the overall
   number of adds (average 1.5 adds per multiplier digit). Note that
   multiplication proceeds from right to left.

   The Sigma 5-9 allowed decimal multiply to be interrupted; the 5X0 series
   did not. An interrupted multiply uses a sign digit in R12 and R13 as the
   divider between the remaining multiplier (to the left of the sign, and
   in the low-order digit of R15) and the partial product (to the right of
   the sign). Because the partial product may be negative, leading 0x99's
   may have been stripped and need to be restored.
   
   The real Sigma's probably didn't run a validty test after separation of
   the partial product and multiplier, but it doesn't hurt, and prevents
   certain corner cases from causing errors. */

    case OP_DM:                                         /* decimal multiply */
        if (lnt >= 9)                                   /* invalid length? */
            return DstrInvd ();
        ReadDecA (src1);                                /* get dec accum */
        if ((tr = ReadDstr (lnt, bva, &src2)) != 0)     /* read mem string */
            return tr;
        dst = Dstr_zero;                                /* clear result */
        kint = 0;                                       /* assume no int */
        if (!QCPU_5X0 &&                                /* S5-9? */
            (cis_test_int (&src1, &kint))) {            /* interrupted? */
                src1.sign = 0;
                cis_dm_int (&src1, &dst, kint);         /* restore */
                }
        else if ((tr = TestDstrValid (&src1)) != 0)     /* mpyr valid? */ 
             return tr;
        if (LntDstr (&src1) && LntDstr (&src2)) {       /* both opnds != 0? */
            dst.sign = src1.sign ^ src2.sign;           /* sign of result */
            AddDstr (&src2, &src2, &src2x, 0);          /* get 2*mplcnd */
            for (i = 1; i <= 16; i++) {                 /* 16 iterations */
                if (i >= kint) {                        /* past int point? */
                    NibbleRshift (&src1, 1, 0);         /* mpyr right 4 */
                    d = src1.val[0] & 0xF;              /* get digit */
                    switch (d) {                        /* case */
                    case 5:                             /* + 2 + 2 + 1 */
                        AddDstr (&src2x, &dst, &dst, 0);
                    case 3:                             /* + 2 + 1 */
                        AddDstr (&src2x, &dst, &dst, 0);
                    case 1:                             /* + 1 */
                        AddDstr (&src2, &dst, &dst, 0);
                    case 0:
                        break;
                    case 4:                             /* + 2 + 2 */
                        AddDstr (&src2x, &dst, &dst, 0);
                    case 2:                             /* + 2 */
                        AddDstr (&src2x, &dst, &dst, 0);
                        break;
                    case 6:                             /* - 2 - 2 + 10 */
                        SubDstr (&src2x, &dst, &dst);
                    case 8:                             /* - 2 + 10 */
                        SubDstr (&src2x, &dst, &dst);
                        src1.val[0] += 0x10;            /* + 10 */
                        break;
                    case 7:                             /* -2 - 1 + 10 */
                        SubDstr (&src2x, &dst, &dst);
                    case 9:                             /* -1 + 10 */
                        SubDstr (&src2, &dst, &dst);
                    default:                            /* + 10 */
                        src1.val[0] += 0x10;
                        }                               /* end switch */
                    }                                   /* end if >= kint */
                NibbleLshift (&src2, 1, 0);             /* shift mplcnds */
                NibbleLshift (&src2x, 1, 0);
                }                                       /* end for */
            }                                           /* end if != 0 */
        WriteDecA (&dst, TRUE);                         /* store result */
        break;

/* Decimal divide overflow calculation - if the dividend has true length d,
   and the divisor true length r, then the quotient will have (d - r) or
   (d - r + 1) digits. Therefore, if (d - r) > 15, the quotient will not
   fit. However, if (d - r) == 15, it may or may not fit, depending on 
   whether the first subtract succeeds. Therefore, it's necessary to test
   after the divide to see if the quotient has one extra digit. */

    case OP_DD:                                         /* decimal divide */
        if (lnt >= 9)                                   /* invalid length? */
            return DstrInvd ();
        ReadDecA (src1);                                /* read dec accum */
        if ((tr = ReadDstr (lnt, bva, &src2)) != 0)     /* read mem string */
            return tr;
        dst = Dstr_zero;                                /* clear result */
        kint = 0;                                       /* no interrupt */
        if (!QCPU_5X0 &&                                /* S5-9? */
            (cis_test_int (&src1, &t))) {               /* interrupted? */
                src1.sign = 0;
                cis_dd_int (&src1, &dst, t, &kint);     /* restore */
                t = t - 1;
                }
        else {                                          /* normal start? */
            if ((tr = TestDstrValid (&src1)) != 0)      /* divd valid? */ 
                return tr;
            ldivr = LntDstr (&src2);                    /* divr lnt */
            ldivd = LntDstr (&src1);                    /* divd lnt */
            if ((ldivr == 0) ||                         /* div by zero? */
                (ldivd > (ldivr + 15))) {               /* quo too big? */
                CC |= CC2;                              /* divide check */
                return (PSW1 & PSW1_DM)? TR_DEC: 0;     /* trap if enabled */
                }
            if (CmpDstr (&src1, &src2) < 0) {           /* no divide? */
                R[12] = src1.val[1];                    /* remainder */
                R[13] = src1.val[0] | (PKPLUS + src1.sign);
                R[14] = 0;                             /* quotient */
                R[15] = PKPLUS;
                CC = 0;
                return SCPE_OK;
                }
            t = ldivd - ldivr;
            }
        dst.sign = src1.sign ^ src2.sign;               /* calculate sign */
        GenLshift (&src2, t);                           /* align */
        for (i = 0; i <= t; i++) {                      /* divide loop */
            for (d = kint;                              /* find digit */
                (d < 10) && (CmpDstr (&src1, &src2) >= 0);
                d++)
                SubDstr (&src2, &src1, &src1);
            dst.val[0] = (dst.val[0] & ~0xF) | d;       /* insert quo dig */
            NibbleLshift (&dst, 1, 0);                  /* shift quotient */
            NibbleRshift (&src2, 1, 0);                 /* shift divisor */
            kint = 0;                                   /* no more int */
            }                                           /* end divide loop */
        if (dst.val[2]) {                               /* quotient too big? */
            CC |= CC2;                                  /* divide check */
            return (PSW1 & PSW1_DM)? TR_DEC: 0;         /* trap if enabled */
            }
        CC = dst.sign? CC4: CC3;                        /* set CC's */
        R[12] = src1.val[1];                            /* remainder */
        R[13] = src1.val[0] | (PKPLUS + src1.sign);
        R[14] = dst.val[1];                             /* quotient */
        R[15] = dst.val[0] | (PKPLUS + dst.sign);
        break;

    case OP_DSA:                                        /* decimal shift */
        ReadDecA (dst);                                 /* read dec accum */
        if ((tr = TestDstrValid (&dst)) != 0)           /* valid? */
            return tr;
        CC = 0;                                         /* clear CC's */
        sc = SEXT_H_W (bva >> 2);                       /* shift count */
        if (sc > 31)                                    /* sc in [-31,31] */
            sc = 31;
        if (sc < -31)
            sc = -31;
        if (sc < 0) {                                   /* right shift? */
            sc = -sc;                                   /* |shift| */
            GenRshift (&dst, sc);                       /* do shift */    
            dst.val[0] = dst.val[0] & ~0xF;             /* clear sign */
            }                                           /* end right shift */
        else if (sc) {                                  /* left shift? */
            if (GenLshift (&dst, sc))                   /* do shift */
                CC |= CC2;
            }                                           /* end left shift */
        WriteDecA (&dst, FALSE);                        /* store result */
        break;

    case OP_PACK:                                       /* zoned to packed */
        dst = Dstr_zero;                                /* clear result */
        end = (2 * lnt) - 1;                            /* zoned length */
        for (i = 1; i <= end; i++) {                    /* loop thru char */
            ad = (bva + end - i) & bvamqrx;             /* zoned character */
            if ((tr = ReadB (ad, &c, VR)) != 0)         /* read char */
                return tr;
            if (i == 1) {                               /* sign + digit? */
                uint32 s;
                s = (c >> 4) & 0xF;                     /* get sign */
                if (s < 0xA)
                    return DstrInvd ();
                if ((s == 0xB) || (s == 0xD))           /* negative */
                    dst.sign = 1;
                }
            d = c & 0xF;                                /* get digit */
            if (d > 0x9)
                return DstrInvd ();
            dst.val[i / 8] = dst.val[i / 8] | (d << ((i % 8) * 4));
            }
        WriteDecA (&dst, FALSE);                        /* write result */
        break;

    case OP_UNPK:                                       /* packed to zoned */
        ReadDecA (dst);                                 /* read dec accum */
        if ((tr = TestDstrValid (&dst)) != 0)           /* valid? */
            return tr;
        end = (2 * lnt) - 1;                            /* zoned length */
        if ((tr = ReadB (bva, &c, VW)) != 0)            /* prove writeable */
            return tr;
        for (i = 1; i <= end; i++) {                    /* loop thru chars */
            c = (dst.val[i / 8] >> ((i % 8) * 4)) & 0xF; /* get digit */
            if (i == 1)                                 /* first? */
                c |= ((PKPLUS + dst.sign) << 4);        /* or in sign */
            else c |= ZONE;                             /* no, or in zone */
            ad = (bva + end - i) & bvamqrx;
            if ((tr = WriteB (ad, c, VW)) != 0)         /* write to memory */
                return tr;
            }
        SetCC2Dstr (lnt, &dst);                         /* see if too long */
        break;
        }
return 0;
}

/* Test for interrupted multiply or divide */

t_bool cis_test_int (dstr_t *src, uint32 *kint)
{
int32 i;
uint32 wd, sc, d;

for (i = 15; i >= 1; i--) {                             /* test 15 nibbles */
    wd = (DSTRLNT/2) + (i / 8);
    sc = (i % 8) * 4;
    d = (src->val[wd] >> sc) & 0xF;
    if (d >= 0xA) {
        *kint = (uint32) i;
        return TRUE;
        }
    }
return FALSE;
}

/* Resume interrupted multiply

   The sign that was found is the "fence" between the the remaining multiplier
   and the partial product:
                                R   val
   +--+--+--+--+--+--+--+--+
   |   mpyer         |sn|pp|    12  3
   +--+--+--+--+--+--+--+--+
   |    partial product    |    13  2
   +--+--+--+--+--+--+--+--+
   |    partial product    |    14  1
   +--+--+--+--+--+--+--+--+
   |    partial product |mp|    15  0
   +--+--+--+--+--+--+--+--+

   This routine separates the multiplier and partial product, returns the
   multiplier as a valid decimal string in src, and the partial product
   as a value with no sign in dst */

void cis_dm_int (dstr_t *src, dstr_t *dst, uint32 kint)
{
uint32 ppneg, wd, sc, d, curd;
int32 k;

*dst = *src;                                            /* copy input */
wd = (DSTRLNT/2) + (kint / 8);
sc = (kint % 8) * 4;
d = (src->val[wd] >> sc) & 0xF;                         /* get sign fence */
ppneg = ((d >> 2) & 1) ^ 1;                             /* partial prod neg? */
curd = (src->val[0] & 0xF) + ppneg;                     /* bias cur digit */
src->val[wd] = (src->val[wd] & ~(0xF << sc)) |          /* replace sign */
                (curd << sc);                           /* with digit */
GenRshift (src, kint + 15);                             /* right justify */
src->sign = ((d == 0xB) || (d == 0xD))? 1: 0;           /* set mpyr sign */
src->val[0] = src->val[0] & ~0xF;                       /* clear sign pos */

/* Mask out multiplier */

for (k = DSTRLNT - 1; k >= (int32) wd; k--)             /* words hi to lo */
    dst->val[k] &= ~(0xFFFFFFFFu <<
        ((k > (int32) wd)? 0: sc));

/* Recreate missing high order digits for negative partial product */

if (ppneg) {                                            /* negative? */
    for (k = (DSTRLNT * 4) - 1; k != 0; k--) {          /* bytes hi to lo */
        wd = k / 4;
        sc = (k % 4) * 8;
        if (((dst->val[wd] >> sc) & 0xFF) != 0)
            break;
        dst->val[wd] |= (0x99 << sc);                   /* repl 00 with 99 */
        }                                               /* end for */  
    }
dst->val[0] &= ~0xF;                                    /* clear pp sign */
return;
}

/* Resume interrupted divide

   The sign that was found is the "fence" between the the quotient and the
   remaining dividend product:
                                R   val
   +--+--+--+--+--+--+--+--+
   |   quotient      |sn|dv|    12  3
   +--+--+--+--+--+--+--+--+
   |       dividend        |    13  2
   +--+--+--+--+--+--+--+--+
   |       dividend        |    14  1
   +--+--+--+--+--+--+--+--+
   |       dividend     |qu|    15  0
   +--+--+--+--+--+--+--+--+

   This routine separates the quotient and the remaining dividend, returns
   the dividend as a valid decimal string, the quotient as a decimal string
   without sign, and kint is the partial value of the last quotient digit. */

void cis_dd_int (dstr_t *src, dstr_t *dst, uint32 nib, uint32 *kint)
{
uint32 wd, sc, d, curd;
int32 k;

wd = (DSTRLNT/2) + (nib / 8);
sc = (nib % 8) * 4;
curd = src->val[0] & 0xF;                               /* last quo digit */
*dst = *src;                                            /* copy input */
GenRshift (dst, nib + 16);                              /* right justify quo */
d = dst->val[0] & 0xF;                                  /* get sign fence */
dst->val[0] = (dst->val[0] & ~0xF) | curd;              /* repl with digit */
*kint = curd;

/* Mask out quotient */

for (k = DSTRLNT - 1; k >= (int32) wd; k--)             /* words hi to lo */
    src->val[k] &= ~(0xFFFFFFFFu <<
        ((k > (int32) wd)? 0: sc));
src->sign = ((d == 0xB) || (d == 0xD))? 1: 0;           /* set divd sign */
src->val[0] = src->val[0] & ~0xF;                       /* clr sign digit */
return;
}

/* Get packed decimal string from memory

   Arguments:
        lnt     =       decimal string length
        adr     =       decimal string address
        src     =       decimal string structure
   Output:
        trap or abort signal

   Per the Sigma spec, bad digits or signs cause a fault or abort */

uint32 ReadDstr (uint32 lnt, uint32 adr, dstr_t *src)
{
uint32 i, c, bva;
uint32 tr;

*src = Dstr_zero;                                       /* clear result */
for (i = 0; i < lnt; i++) {                             /* loop thru string */
    bva = (adr + lnt - i - 1) & bvamqrx;                /* from low to high */
    if ((tr = ReadB (bva, &c, VR)) != 0)                /* read byte */
        return tr;
    src->val[i / 4] = src->val[i / 4] | (c << ((i % 4) * 8));
    }                                                   /* end for */
return TestDstrValid (src);
}

/* Separate sign, validate sign and digits of decimal string */

uint32 TestDstrValid (dstr_t *src)
{
uint32 i, j, s, t;

s = src->val[0] & 0xF;                                  /* get sign */
if (s < 0xA)                                            /* valid? */
    return DstrInvd ();
if ((s == 0xB) || (s == 0xD))                           /* negative? */
    src->sign = 1;
else src->sign = 0;
src->val[0] &= ~0xF;                                    /* clear sign */

for (i = 0; i < DSTRLNT; i++) {                         /* check 4 words */
    for (j = 0; j < 8; j++) {                           /* 8 digit/word */
        t = (src->val[i] >> (28 - (j * 4))) & 0xF;      /* get digit */
        if (t > 0x9)                                    /* invalid digit? */
            return DstrInvd ();                         /* exception */
        }
    }
return 0;
}

/* Invalid digit or sign: set CC1, trap or abort instruction */

uint32 DstrInvd (void)
{
CC |= CC1;                                              /* set CC1 */
if (PSW1 & PSW1_DM)                                     /* if enabled, trap */
    return TR_DEC;
return WSIGN;                                           /* otherwise, abort */
}
       
/* Store decimal string

   Arguments:
        lnt     =       decimal string length
        adr     =       decimal string address
        dst     =       decimal string structure

   Returns memory management traps (if any)
   Bad digits and invalid sign are impossible
*/

uint32 WriteDstr (uint32 lnt, uint32 adr, dstr_t *dst)
{
uint32 i, bva, c;
uint32 tr;

dst->val[0] = dst->val[0] | (PKPLUS + dst->sign);       /* set sign */
if ((tr = ReadB (adr, &c, VW)) != 0)                    /* prove writeable */
    return tr;
for (i = 0; i < lnt; i++) {                             /* loop thru bytes */
    c = (dst->val[i / 4] >> ((i % 4) * 8)) & 0xFF;      /* from low to high */
    bva = (adr + lnt - i - 1) & bvamqrx;
    if ((tr = WriteB (bva, c, VW)) != 0)                /* store byte */
        return tr;
    }                                                   /* end for */
SetCC2Dstr (lnt, dst);                                  /* check overflow */
return 0;
}

/* Store result in decimal accumulator

   Arguments:
        dst     =       decimal string structure
        cln     =       clean -0 if true

   Sets condition codes CC3 and CC4
   Bad digits and invalid sign are impossible */

void WriteDecA (dstr_t *dst, t_bool cln)
{
uint32 i, nz;

CC &= ~(CC3|CC4);                                       /* assume zero */
for (i = 0, nz = 0; i < DSTRLNT; i++) {                 /* save 32 digits */
    R[DECA + i] = dst->val[DSTRLNT - 1 - i];
    nz |= dst->val[DSTRLNT - 1 - i];
    }
if (nz)                                                 /* non-zero? */
    CC |= (dst->sign)? CC4: CC3;                        /* set CC3 or CC4 */
else if (cln)                                           /* zero, clean? */
    dst->sign = 0;                                      /* clear sign */
R[DECA + DSTRLNT - 1] |= (PKPLUS + dst->sign);          /* or in sign */
return;
}

/* Set CC2 for decimal string store

   Arguments:
        lnt     =       string length
        dst     =       decimal string structure
   Output:
        sets CC2 if information won't fit */

void SetCC2Dstr (uint32 lnt, dstr_t *dst)
{
uint32 i, limit, mask;
static uint32 masktab[8] = {
    0xFFFFFFF0, 0xFFFFFF00, 0xFFFFF000, 0xFFFF0000,
    0xFFF00000, 0xFF000000, 0xF0000000, 0x00000000
    };

lnt = (lnt * 2) - 1;                                    /* number of digits */
mask = 0;                                               /* can't ovflo */
limit = lnt / 8;                                        /* limit for test */
for (i = 0; i < DSTRLNT; i++) {                         /* loop thru value */
    if (i == limit)                                     /* @limit, get mask */
        mask = masktab[lnt % 8];
    else if (i > limit)                                 /* >limit, test all */
        mask = 0xFFFFFFFF;
    if (dst->val[i] & mask)                             /* test for ovflo */
        CC |= CC2;
    }
return;
}

/* Add decimal string magnitudes

   Arguments:
        s1      =       src1 decimal string
        s2      =       src2 decimal string
        ds      =       dest decimal string
        cy      =       carry in
   Output:
        1 if carry, 0 if no carry

   This algorithm courtesy Anton Chernoff, circa 1992 or even earlier.

   We trace the history of a pair of adjacent digits to see how the
   carry is fixed; each parenthesized item is a 4b digit.

   Assume we are adding:

        (a)(b)  I
   +    (x)(y)  J

   First compute I^J:

        (a^x)(b^y)      TMP

   Note that the low bit of each digit is the same as the low bit of
   the sum of the digits, ignoring the carry, since the low bit of the
   sum is the xor of the bits.

   Now compute I+J+66 to get decimal addition with carry forced left
   one digit:

        (a+x+6+carry mod 16)(b+y+6 mod 16)      SUM

   Note that if there was a carry from b+y+6, then the low bit of the
   left digit is different from the expected low bit from the xor.
   If we xor this SUM into TMP, then the low bit of each digit is 1
   if there was a carry, and 0 if not.  We need to subtract 6 from each
   digit that did not have a carry, so take ~(SUM ^ TMP) & 0x11, shift
   it right 4 to the digits that are affected, and subtract 6*adjustment
   (actually, shift it right 3 and subtract 3*adjustment).
*/

uint32 AddDstr (dstr_t *s1, dstr_t *s2, dstr_t *ds, uint32 cy)
{
uint32 i;
uint32 sm1, sm2, tm1, tm2, tm3, tm4;

for (i = 0; i < DSTRLNT; i++) {                         /* loop low to high */
    tm1 = s1->val[i] ^ (s2->val[i] + cy);               /* xor operands */
    sm1 = s1->val[i] + (s2->val[i] + cy);               /* sum operands */
    sm2 = sm1 + 0x66666666;                             /* force carry out */
    cy = ((sm1 < s1->val[i]) || (sm2 < sm1));           /* check for ovflo */
    tm2 = tm1 ^ sm2;                                    /* get carry flags */
    tm3 = (tm2 >> 3) | (cy << 29);                      /* compute adjust */
    tm4 = 0x22222222 & ~tm3;                            /* clrr where carry */
    ds->val[i] = (sm2 - (3 * tm4)) & WMASK;             /* final result */
    }
return cy;
}

/* Subtract decimal string magnitudes

   Arguments:
        s1      =       src1 decimal string
        s2      =       src2 decimal string
        ds      =       dest decimal string

   Note: the routine assumes that s1 <= s2

*/

void SubDstr (dstr_t *s1, dstr_t *s2, dstr_t *ds)
{
uint32 i;
dstr_t complm;

for (i = 0; i < DSTRLNT; i++)                           /* 9's comp s2 */
    complm.val[i] = 0x99999999 - s1->val[i];
AddDstr (&complm, s2, ds, 1);                           /* s1 + ~s2 + 1 */
return;
}

/* Compare decimal string magnitudes

   Arguments:
        s1      =       src1 decimal string
        s2      =       src2 decimal string
   Output:
        1 if >, 0 if =, -1 if <
*/

int32 CmpDstr (dstr_t *s1, dstr_t *s2)
{
int32 i;

for (i = DSTRLNT - 1; i >=0; i--) {
    if (s1->val[i] > s2->val[i])
        return 1;
    if (s1->val[i] < s2->val[i])
        return -1;
    }
return 0;
}

/* Get exact length of decimal string, clean -0

   Arguments:
        dst     =       decimal string structure
   Output:
        number of non-zero digits
*/

uint32 LntDstr (dstr_t *dst)
{
int32 nz, i;

for (nz = DSTRLNT - 1; nz >= 0; nz--) {
    if (dst->val[nz]) {
        for (i = 7; i >= 0; i--) {
            if ((dst->val[nz] >> (i * 4)) & 0xF)
                return (nz * 8) + i;
            }
        }
    }
dst->sign = 0;
return 0;
}

/* Word shift right

   Arguments:
        dsrc    =       decimal string structure
        sc      =       shift count in nibbles
*/

void GenRshift (dstr_t *dsrc, uint32 cnt)
{
uint32 i, sc, sc1;

sc = cnt / 8;
sc1 = cnt % 8;
if (sc) {
    for (i = 0; i < DSTRLNT; i++) {
        if ((i + sc) < DSTRLNT)
            dsrc->val[i] = dsrc->val[i + sc];
        else dsrc->val[i] = 0;
        }
    }
if (sc1)
    NibbleRshift (dsrc, sc1, 0);
return;
}

/* General shift left

   Arguments:
        dsrc    =       decimal string structure
        cnt      =      shift count in nibbles
*/

t_bool GenLshift (dstr_t *dsrc, uint32 cnt)
{
t_bool i, c, sc, sc1;

c = 0;
sc = cnt / 8;
sc1 = cnt % 8;
if (sc) {
    for (i = DSTRLNT - 1; (int32) i >= 0; i--) {
        if (i >= sc)
            dsrc->val[i] = dsrc->val[i - sc];
        else {
            c |= dsrc->val[i];
            dsrc->val[i] = 0;
            }
        }
    }
if (sc1)
    c |= NibbleLshift (dsrc, sc1, 0);
return (c? TRUE: FALSE);
}               

/* Nibble shift right

   Arguments:
        dsrc    =       decimal string structure
        sc      =       shift count in nibbles
        cin     =       carry in
*/

uint32 NibbleRshift (dstr_t *dsrc, uint32 sc, uint32 cin)
{
int32 i;
uint32 s, nc;

if ((s = sc * 4)) {
    for (i = DSTRLNT - 1; (int32) i >= 0; i--) {
        nc = (dsrc->val[i] << (32 - s)) & WMASK;
        dsrc->val[i] = ((dsrc->val[i] >> s) |
            cin) & WMASK;
        cin = nc;
        }
    return cin;
    }
return 0;
}

/* Nibble shift left

   Arguments:
        dsrc    =       decimal string structure
        sc      =       shift count in nibbles
        cin     =       carry in
*/

uint32 NibbleLshift (dstr_t *dsrc, uint32 sc, uint32 cin)
{
uint32 i, s, nc;

if ((s = sc * 4)) {
    for (i = 0; i < DSTRLNT; i++) {
        nc = dsrc->val[i] >> (32 - s);
        dsrc->val[i] = ((dsrc->val[i] << s) |
            cin) & WMASK;
        cin = nc;
        }
    return cin;
    }
return 0;
}
/* Edit instruction */

uint32 cis_ebs (uint32 rn, uint32 disp)
{
uint32 sa, da, c, d, dst, fill, pat;
uint32 tr;

disp = SEXT_LIT_W (disp) & WMASK;                       /* sext operand */
fill = S_GETMCNT (R[rn]);                               /* fill char */
while (S_GETMCNT (R[rn|1])) {                           /* while pattern */
    sa = (disp + R[rn]) & bvamqrx;                      /* dec str addr */
    da = R[rn|1] & bvamqrx;                             /* pattern addr */
    if ((tr = ReadB (da, &pat, VR)) != 0)               /* get pattern byte */
        return tr;
    switch (pat) {                                      /* case on pattern */

    case ED_DS:                                         /* digit select */
        if ((tr = ed_getsrc (sa, &c, &d)) != 0)         /* get src digit */
            return tr;
        if (CC & CC4)                                   /* signif? unpack */
            dst = ZONE | d;
        else if (d) {                                   /* non-zero? */
            R[1] = da;                                  /* save addr */
            dst = ZONE | d;                             /* unpack */
            CC |= CC4;                                  /* set signif */
            }
        else dst = fill;                                /* otherwise fill */
        if ((tr = WriteB (da, dst, VW)) != 0)           /* overwrite dst */
            return tr;
        ed_advsrc (rn, c);                              /* next src digit */
        break;

    case ED_SS:                                         /* signif start */
        if ((tr = ed_getsrc (sa, &c, &d)) != 0)         /* get src digit */
            return tr;
        if (CC & CC4)                                   /* signif? unpack */
            dst = ZONE | d;
        else if (d) {                                   /* non-zero? */
            R[1] = da;                                  /* save addr */
            dst = ZONE | d;                             /* unpack */
            }
        else {                                          /* otherwise */
            R[1] = da + 1;                              /* save next */
            dst = fill;                                 /* fill */
            }
        CC |= CC4;                                      /* set signif */
        if ((tr = WriteB (da, dst, VW)) != 0)           /* overwrite dst */
            return tr;
        ed_advsrc (rn, c);                              /* next src digit */
        break;

    case ED_SI:                                         /* signif immediate */
        if ((tr = ed_getsrc (sa, &c, &d)) != 0)         /* get src digit */
            return tr;
        R[1] = da;                                      /* save addr */
        dst = ZONE | d;                                 /* unpack */
        CC |= CC4;                                      /* set signif */
        if ((tr = WriteB (da, dst, VW)) != 0)           /* overwrite dst */
            return tr;
        ed_advsrc (rn, c);                              /* next src digit */
        break;

    case ED_FS:                                         /* field separator */
        CC &= ~(CC1|CC3|CC4);                           /* clr all exc CC2 */
        if ((tr = WriteB (da, fill, VW)) != 0)          /* overwrite dst */
            return tr;
        break;

    default:                                            /* all others */
        if ((CC & CC4) == 0) {                          /* signif off? */
            dst = (CC & CC1)? BLANK: fill;              /* blank or fill */
            if ((tr = WriteB (da, dst, VW)) != 0)       /* overwrite dst */
                return tr;
            }
         break;
         }                                              /* end switch dst */
    R[rn|1] = (R[rn|1] + S_ADDRINC) & WMASK;            /* next pattern */
    }                                                   /* end while */
return 0;
}

/* Routine to get and validate the next source digit */

uint32 ed_getsrc (uint32 sa, uint32 *c, uint32 *d)
{
uint32 tr;

if ((tr = ReadB (sa, c, VR)) != 0)                      /* read source byte */
    return tr;
*d = ((CC & CC2)? *c: *c >> 4) & 0xF;                   /* isolate digit */
if (*d > 0x9)                                           /* invalid? */
    return TR_DEC;
if (*d)                                                 /* non-zero? */
    CC |= CC3;
return 0;
}

/* Routine to advance source string */

void ed_advsrc (uint32 rn, uint32 c)
{
c = c & 0xF;                                            /* get low digit */
if (((CC & CC2) == 0) && (c > 0x9)) {                   /* sel left, with sign? */
    if ((c == 0xB) || (c == 0xD))                       /* minus? */
        CC = CC | (CC1|CC4);                            /* CC1, CC4 */
    else CC = (CC | CC1) & ~CC4;                        /* no, CC1, ~CC4 */
    R[rn] = R[rn] + 1;                                  /* skip two digits */
    }
else {                                                  /* adv 1 digit */
    if (CC & CC2)
        R[rn] = R[rn] + 1;
    CC = CC ^ CC2;
    }
return;
}
