Power-Programmierung/CD2.mdf/c/library/xplatfrm/tierra/parse.c

C/C++ Source or Header | 1992-04-26 | 10.4 KB | 400 lines

/* parse.c  28-10-91  parser functions for the tierra simulator */
/** Tierra Simulator V3.0: Copyright (c) 1991 Thomas S. Ray **/

#include "license.h"

#ifndef lint
static char     sccsid[] = "%W%     %G%";
#endif

#include "tierra.h"
#include "extern.h"

#if INST == 1

/* in INST == 1, the array of registers maps into the registers ax, bx, cx, dx
   as follows:  c.re[0] = ax, c.re[1] = bx, c.re[2] = cx, c.re[3] = dx */

void SetFlag(ce)
Pcells  ce;
{   ce->c.fl = 1; }

void pnop(ci) /* do nothing */
I32s  ci;
{   is.iip = is.dib = 1; }

void por1(ci) /* flip low order bit of cx */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.dval = ce->c.re[2];
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void pshl(ci) /* shift left all register of cx */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.dval = ce->c.re[2];
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void pzero(ci) /* cx = 0 */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.sval = 0;
    is.iip = is.dib = 1;
}

void pif_cz(ci) /* execute next instruction only if cx == 0 */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.sval = ce->c.re[2];
    is.iip = is.dib = 1;
}

void psub_ab(ci) /* cx = ax - bx */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.sval = ce->c.re[0];
    is.sval2 = -ce->c.re[1];
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void psub_ac(ci) /* ax = ax - cx */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[0]);
    is.sval = ce->c.re[0];
    is.sval2 = -ce->c.re[2];
    is.iip = is.dib = 1;
    is.dmod = SoupSize;
}

void pinc_a(ci) /* ax++ */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[0]);
    is.sval = ce->c.re[0];
    is.sval2 = 1;
    is.iip = is.dib = 1;
    is.dmod = SoupSize;
}

void pinc_b(ci) /* bx++ */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[1]);
    is.sval = ce->c.re[1];
    is.sval2 = 1;
    is.iip = is.dib = 1;
    is.dmod = SoupSize;
}

void pdec_c(ci) /* cx-- */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.sval = ce->c.re[2];
    is.sval2 = -1;
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void pinc_c(ci) /* cx++ */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.sval = ce->c.re[2];
    is.sval2 = 1;
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void ppush_ax(ci) /* push ax onto stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.sval = ce->c.re[0];
    is.iip = is.dib = 1;
}

void ppush_bx(ci) /* push bx onto stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.sval = ce->c.re[1];
    is.iip = is.dib = 1;
}

void ppush_cx(ci) /* push cx onto stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.sval = ce->c.re[2];
    is.iip = is.dib = 1;
}

void ppush_dx(ci) /* push dx onto stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.sval = ce->c.re[3];
    is.iip = is.dib = 1;
}

void ppop_ax(ci) /* pop ax off of stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[0]);
    is.iip = is.dib = 1;
    is.dmod = SoupSize;
}

void ppop_bx(ci) /* pop bx off of stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[1]);
    is.iip = is.dib = 1;
    is.dmod = SoupSize;
}

void ppop_cx(ci) /* pop cx off of stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[2]);
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void ppop_dx(ci) /* pop dx off of stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[3]);
    is.iip = is.dib = 1;
    is.dran = SoupSize;
}

void ptjmp(ci) /* outward template jump */
I32s  ci;
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.ip); /* destination register for address */
    is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 0; /* outward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = 0; is.dib = 1;
}

void ptjmpb(ci) /* backward template jump */
I32s  ci;
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.ip); /* destination register for address */
    is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 2; /* backward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = 0; is.dib = 1;
}

void ptcall(ci) /* push ip to stack, outward template jump */
I32s  ci;
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.ip); /* destination register for address */
    is.dreg2 = &(ce->c.re[3]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval  = ce->c.ip + s + 1;    /* address to be pushed onto stack */
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 0; /* outward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = 0; is.dib = 1;
}

void pret(ci) /* pop ip from stack */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.ip);
    is.iip = 0; is.dib = 1;
    is.dmod = SoupSize;
}

void pmov_dc(ci) /* dx = cx */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[3]);
    is.sval = ce->c.re[2];
    is.iip = is.dib = 1;
}

void pmov_ba(ci) /* bx = ax */
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[1]);
    is.sval = ce->c.re[0];
    is.iip = is.dib = 1;
}

void pmov_iab(ci)
I32s  ci;
{   Pcells  ce = cells + ci;

    is.dins = &soup[ce->c.re[0]][ce->c.tr];
    is.sins = &soup[ce->c.re[1]][ce->c.tr];
    is.dval = ce->c.re[0];
    is.sval = ce->c.re[1];
    is.dtra = is.stra = ce->c.tr;
    is.iip = is.dib = 1;
}

void padr(ci) /* search outward for template, return address in ax */
I32s  ci; /* return template size in cx */
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.re[0]); /* destination register for address */
    is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 0; /* outward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = 0; is.dib = 1;
}

void padrb(ci) /* search backward for template, return address in ax */
I32s  ci; /* return template size in cx */
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.re[0]); /* destination register for address */
    is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 2; /* backward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = s + 1; is.dib = 1;
}

void padrf(ci) /* search forward for template, return address in ax */
I32s  ci; /* return template size in cx */
{   Pcells  ce = cells + ci;
    I32s    a, s = 0;

    is.dreg  = &(ce->c.re[0]); /* destination register for address */
    is.dreg2 = &(ce->c.re[2]); /* destination register for template size */
    a = ad(ce->c.ip + 1); /* a = address of start of template */
    while(1) /* find size of template, s = size */
    {   if(soup[ad(a + s)][ce->c.tr].inst != 0 &&
           soup[ad(a + s)][ce->c.tr].inst != 1)
            break;
        s++;
    }
    is.sval2 = s;  /* size of template */
    is.dran2 = SoupSize;
    is.dmod  = SoupSize;
    is.dval  = ad(a + s + 1); /* start address for forward search */
    is.dval2 = ad(a - s - 1); /* start address for backward search */
    is.mode  = 1; /* forward jump */
    is.mode2 = 0; /* complementary templates */
    is.iip = s + 1; is.dib = 1;
}

void pmal(ci)  /* allocate space for a new cell */
I32s  ci;  /* allocate space for a new cell */
{   Pcells  ce = cells + ci;

    is.dreg = &(ce->c.re[0]);
    is.sval = ce->c.re[2];
    is.dmod = SoupSize;
    is.dtra = ce->c.tr;
    is.mode = 2; /* only write privelages protected */
    is.iip = is.dib = 1;
}

void pdivide(ci)  /* give life to new cell by puting in queue */
I32s  ci;
{   is.mode = 2;  /* full division */
    is.iip = is.dib = 1;
}

#endif  /* end of INST 1 */