cell.c

/* MIX simulator, copyright 1994 by Darius Bacon */ 
/* Corrections to multiply and divide, Nov. 1998, Larry Gately */
#include "mix.h"

#include <stdlib.h>
#include <stdio.h>

Cell ulong_to_cell(unsigned long n)
{
    if (CELL_MAX < n) {
        warn("Value out of range: %lu", n);
        return CELL_MAX;
    } else
        return n;
}

/* --- Field operations --- */

Byte get_byte(unsigned F, Cell cell)
{
    assert(F != 0);
    return (Byte) field(make_field_spec(F, F), cell);
}

Cell set_byte(Byte value, unsigned F, Cell into)
{
    assert(F != 0);
    return set_field((Cell) value, make_field_spec(F, F), into);
}

static Flag bad_field[64];  /* 64 = number of byte values */
static unsigned shift[64];
static long mask[64];

Cell field(Byte F, Cell cell)
{
    if (bad_field[F])
        error("Bad field spec: %02o", F);
    if (F < 8)      /* if F is of the form (0:R), retain the sign of -cell- */
        return ((cell & mask[F]) >> shift[F]) | sign_bit(cell);
    else
        return (cell & mask[F]) >> shift[F];
}

Cell set_field(Cell value, Byte F, Cell into)
{
    long m = mask[F];
    if (bad_field[F])
        error("Bad field spec: %02o", F);
    if (F < 8)      /* if F is of the form (0:R), use the sign of -value- */
        return (into & ~m & ~the_sign_bit) | ((value << shift[F]) & m) | sign_bit(value);
    else
        return (into & ~m) | ((value << shift[F]) & m);
}

void precompute_field_data(void)
{
    unsigned L, R;
    for (L = 0; L < 8; ++L)
        for (R = 0; R < 8; ++R) {
            unsigned F = 8 * L + R;
            bad_field[F] = R < L || 5 < R;
            if (bad_field[F])
                shift[F] = 0, mask[F] = 0;
            else {
                unsigned width = R - (L == 0 ? 1 : L) + 1;
                shift[F] = 6 * (5 - R);
                mask[F] = ((1L << (6 * width)) - 1) << shift[F];
            } 
        }
}

Byte make_field_spec(unsigned L, unsigned R)
{
    unsigned F = 8 * L + R;
    assert(!bad_field[F]);
    return F;
}

void assert_valid_field(Cell field_spec)
{
    if (is_negative(field_spec) 
        || 64 <= magnitude(field_spec)
        || bad_field[(unsigned)magnitude(field_spec)])
    {
        char buffer[16];
        unparse_cell(buffer, field_spec, false);
        error("Invalid field specifier: %s", buffer);
    }
}

/* --- Arithmetic --- */

Flag overflow = false;

Cell add(Cell x, Cell y)
{   /* This is kinda clumsy. Should I combine code at the cost (?) of speed */
    /* and functional style? */
    if (sign_bit(x) == sign_bit(y)) {
        long sum = magnitude(x) + magnitude(y);
        long magnitude_of_sum = magnitude(sum);
        if (magnitude_of_sum != sum) overflow = true;
        return sign_bit(x) | magnitude_of_sum;
    } else {
        long diff = magnitude(x) - magnitude(y);
        return diff < 0 ? sign_bit (y) | -diff : sign_bit (x) | diff;
    }
}

Cell sub(Cell x, Cell y)
{
    return add(x, negative(y));     /* should inline this, maybe */
}

void multiply(Cell x, Cell y, Cell *high_word, Cell *low_word)
{
    unsigned long sign = sign_bit(x) ^ sign_bit(y);

    /*
       x = x0 + x1 * 2 ^ 10 + x2 * 2 ^ 20
       y = y0 + y1 * 2 ^ 10 + y2 * 2 ^ 20
       x0, x1, x2, y0, y1, y2 are < 2 ^ 10
    */
    unsigned long x0 = (x & 0x000003FF);
    unsigned long x1 = (x & 0x000FFC00) >> 10;
    unsigned long x2 = (x & 0x3FF00000) >> 20;
    unsigned long y0 = (y & 0x000003FF);
    unsigned long y1 = (y & 0x000FFC00) >> 10;
    unsigned long y2 = (y & 0x3FF00000) >> 20;

    /*
       x * y = partial0 +
               partial1 * 2 ^ 10 +
               partial2 * 2 ^ 20 +
               partial3 * 2 ^ 30 +
               partial4 * 2 ^ 40
       partial0 and partial4 are <     2 ^ 20
       partial1 and partial3 are <     2 ^ 21
       partial2 is               < 3 * 2 ^ 20
    */
    unsigned long partial0 = x0 * y0;
    unsigned long partial1 = x0 * y1 + x1 * y0;
    unsigned long partial2 = x0 * y2 + x1 * y1 + x2 * y0;
    unsigned long partial3 = x1 * y2 + x2 * y1;
    unsigned long partial4 = x2 * y2;

    /*  sum1 has a place value of 1 and is < 2 ^ 32 */
    unsigned long sum1   = partial0 + (partial1 << 10);
    unsigned long carry1 = (sum1 & 0xFFF00000) >> 20;

    /* sum2 has a place value of 2 ^ 20 and is < 2 ^ 32 */
    unsigned long sum2   = partial2 + (partial3 << 10) + carry1;
    unsigned long carry2 = (sum2 & 0xFFF00000) >> 20;

    /* sum3 has a place value of 2 ^ 40 and is < 2 ^ 20 */
    unsigned long sum3   = partial4 + carry2;

    sum1 &= ~0xFFF00000;
    sum2 &= ~0xFFF00000;

    /*
       Now paste the three values back into two.
    */
    *low_word   = sum1 | ((sum2 & 0x000003FF) << 20);
    *low_word  |= sign;
    *high_word  = ((sum2 & 0x000FFC00) >> 10) | (sum3 << 10);
    *high_word |= sign;

}

Cell mul(Cell x, Cell y)
{
    Cell lo, hi;
    multiply(x, y, &hi, &lo);
    if (magnitude(hi) != 0) overflow = true;
    return lo;
}

void divide(Cell n1, Cell n0, Cell d, Cell *quotient, Cell *remainder)
{
    long magn1 = magnitude(n1);
    long magd = magnitude(d);
    if (magd == 0) {
        overflow = true;
        *quotient = *remainder = zero;  /* just so they have -some- valid value */
    } else if (magn1 == 0) {    /* special-cased for speed */
        *quotient = (sign_bit(n1) ^ sign_bit(d)) | (magnitude(n0) / magd);
        *remainder = sign_bit(n1) | (magnitude(n0) % magd);
    } else if (magd <= magn1) {
        overflow = true;
        *quotient = *remainder = zero;
    } else {
        long q = magnitude(n0);
        long r = magn1;
        unsigned i;
        for (i = 30; i != 0; --i) {
            r <<= 1;
            if (q & (1L << 29))
                ++r;
            q = (q << 1) & ((1L << 30) - 1);
            if (magd <= r)
                ++q, r -= magd;
        }
        *quotient = (sign_bit(n1) ^ sign_bit(d)) | q;
        *remainder = sign_bit(n1) | r;
    }
}

Cell slash(Cell x, Cell y)      /* the name 'div' is taken... */
{
    Cell quotient, remainder;
    divide(sign_bit(x), x, y, &quotient, &remainder);
    return quotient;
}

/* --- Logical operations --- */
Cell logical_sum(Cell x, Cell y)
{
    unsigned long sum = magnitude(x) | magnitude(y);
    return sign_bit(x) | sum;
}

Cell logical_difference(Cell x, Cell y)
{
    unsigned long diff = magnitude(x) ^ magnitude(y);
    return sign_bit(x) | diff;
}

Cell logical_product(Cell x, Cell y)
{
    unsigned long prod = magnitude(x) & magnitude(y);
    return sign_bit(x) | prod;
}

/* --- Shift operations --- */

void shift_right(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 5) {
        *pA |= magnitude(A) >> (6 * count);
        *pX |= CELL_MAX & ((magnitude(X) >> (6 * count))
            | (A << (30 - 6 * count)));
    } else if (count < 10)
        *pX |= magnitude(A) >> (6 * count - 30);
    else
        ;
}

void shift_left(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 5) {
        *pX |= CELL_MAX & (X << (6 * count));
        *pA |= CELL_MAX & ((A << (6 * count))
            | (magnitude(X) >> (30 - 6 * count)));
    } else if (count < 10)
        *pA |= CELL_MAX & (X << (6 * count - 30));
    else
        ;
}

void shift_right_binary(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 30) {
        *pA |= magnitude(A) >> count;
        *pX |= CELL_MAX & ((magnitude(X) >> count)
            | (A << (30 - count)));
    } else if (count < 60)
        *pX |= magnitude(A) >> (count - 30);
    else
        ;
}

void shift_left_binary(Cell A, Cell X, unsigned long count, Cell *pA, Cell *pX)
{
    *pX = sign_bit(X);
    *pA = sign_bit(A);
    if (count < 30) {
        *pX |= CELL_MAX & (X << count);
        *pA |= CELL_MAX & ((A << count)
            | (magnitude(X) >> (30 - count)));
    } else if (count < 60)
        *pA |= CELL_MAX & (X << (count - 30));
    else
        ;
}

/* Pre: count < 10 */
void shift_left_circular(Cell A, Cell X, unsigned count, Cell *pA, Cell *pX)
{
    Cell A1 = count < 5 ? A : X;
    Cell X1 = count < 5 ? X : A;
    unsigned c = 6 * (count < 5 ? count : count - 5);
    *pX = sign_bit(X)
        | (CELL_MAX & ((X1 << c) | (magnitude(A1) >> (30 - c))));
    *pA = sign_bit(A)
        | (CELL_MAX & ((A1 << c) | (magnitude(X1) >> (30 - c))));
}

/* --- Printable representation --- */

void print_cell(Cell cell)
{
    printf("%c%010lo", sign_bit(cell) ? '-' : '+', magnitude(cell));
}

const char *address_to_string(Address address)
{
    static char buf[16];

    if (memory_size > 4000)
        sprintf(buf, "%c%05o", address < 0 ? '-' : '+', abs(address));
    else
        sprintf(buf, "%c%04o", address < 0 ? '-' : '+', abs(address));

    return buf;
}

const char *index_to_string(Cell index)
{
    static char buf[16];

    if (memory_size > 4000)
        sprintf(buf, "%c%05lo", is_negative (index) ? '-' : '+', magnitude (index));
    else
        sprintf(buf, "%c%04lo", is_negative (index)  ? '-' : '+', magnitude (index));

    return buf;
}

void unparse_cell(char *buffer, Cell cell, Flag disasm)
{
    Byte I, F, C;
    Cell A;

    if (disasm) {
        destructure_cell (cell, A, I, F, C);
        sprintf(buffer, "%s%04lo %02o %02o %02o",
                is_negative (A) ? "-" : "+", magnitude (A),
                I, F, C);
    } else
        sprintf(buffer, "%s%010lo",
                is_negative (cell) ? "-" : "+", magnitude (cell));
}

/* --- Addresses --- */

Cell address_to_cell(Address addr) { return addr; }

Address cell_to_address(Cell cell)
{
    if ((sign_bit(cell) != 0 && magnitude(cell) != 0)
       || memory_size <= magnitude(cell))
    {
        char buffer[16];
        unparse_cell(buffer, cell, false);
        error("Value is not an address: %s", buffer);
        return 0;
    }
    return (Address) magnitude(cell);
}

/* --- Floating point operations --- */

Cell float_add(Cell x, Cell y)
{
    error("Not implemented yet!");
    return zero;
}

Cell float_subtract(Cell x, Cell y)
{
    error("Not implemented yet!");
    return zero;
}

Cell float_multiply(Cell x, Cell y)
{
    error("Not implemented yet!");
    return zero;
}

Cell float_divide(Cell x, Cell y)
{
    error("Not implemented yet!");
    return zero;
}

Cell float_flot(Cell x)
{
    error("Not implemented yet!");
    return zero;
}

Cell float_fix(Cell x)
{
    error("Not implemented yet!");
    return zero;
}

int float_compare(Cell x, Cell y)
{
    error("Not implemented yet!");
    return 0;
}

/* vim: set ts=4 sw=4 et: */