void read(matrice *a)
{
int n, m, i, j;
a->n = 0;
a->lin = NULL;
a->col = NULL;
a->x = NULL;
scanf("%d %d", &n, &m);
a->l = n;
a->c = m;
a->n = 0;
for (i = 0; i < n; ++ i)
for (j = 0; j < m; ++ j)
{
float t;
scanf("%f", &t);
if (t != 0)
{
a->n+=1;
a->x = pushf(a->x, t, a->n);
a->lin = pushi(a->lin, i, a->n);
a->col = pushi(a->col, j, a->n);
}
}
}
int control(int a, int b)
{
int j, k;
extern Contab *contabp;
numerr.type = RQERR;
numerr.req = a;
if (a == 0 || (j = findmn(a)) == -1)
return(0);
if (contabp[j].f == 0) {
if (trace & TRMAC)
fprintf(stderr, "invoke macro %s\n", unpair(a));
if (dip != d)
for (k = dilev; k; k--)
if (d[k].curd == a) {
ERROR "diversion %s invokes itself during diversion",
unpair(a) WARN;
edone(0100);
}
nxf->nargs = 0;
if (b)
collect();
flushi();
return pushi(contabp[j].mx, a); /* BUG??? all that matters is 0/!0 */
}
if (b) {
if (trace & TRREQ)
fprintf(stderr, "invoke request %s\n", unpair(a));
(*contabp[j].f)();
}
return(0);
}
/* assign input vector */
void assign_input_affix ()
{ int nr = popi ();
affix_node affx = popa ();
value new_val = my_ivals[nr];
if (affx -> val != value_nil)
{ if (equal_value (new_val, affx -> val)) callq ();
}
else
{ affx -> val = rdup_value (new_val);
if (affx -> mfunc != NULL)
{ /* check metadefinition */
pushv (new_val);
pushq (affx -> mfunc);
callq ();
pop (2);
}
else callq ();
rfre_value (new_val);
affx -> val = value_nil;
};
pusha (affx);
pushi (nr);
pushq (assign_input_affix);
};
void
caserd(void)
{
lgf++;
skip(0);
getname();
if (!iflg) {
if (quiet) {
#ifdef NROFF
echo_off();
flusho();
#endif /* NROFF */
fdprintf(stderr, "\007"); /*bell*/
} else {
if (nextf[0]) {
fdprintf(stderr, "%s:", nextf);
} else {
fdprintf(stderr, "\007"); /*bell*/
}
}
}
collect();
tty++;
pushi(-1, PAIR('r','d'), 0);
}
void semipred_showfield ()
{ int i,j;
fprintf (stderr, "Field:\n");
for (i = 0; i < height; i++)
{ for (j = 0; j < width; j++)
fputc ((field [i*width +j])?'X':' ', stderr);
fputc ('\n', stderr);
};
fputc ('\n', stderr);
pushi (0);
pushi (0);
pushi (mk_nodenr (alib_modnr, 3));
pushq (make_semipredicate_node);
callq ();
pop (4);
pushq (semipred_showfield);
};
/*
Reserve space to collect output affixes
*/
void reserve_collection_space ()
{ my_nrps = popi ();
my_cvals = (value **) ckcalloc (1, sizeof (value *));
room = 1;
allocated = 0;
callq ();
pushi (my_nrps);
pushq (reserve_collection_space);
};
void collect_output_affix ()
{ int nr = popi ();
affix_node affx = popa ();
value new_val = affx -> val;
check_for_space ();
my_cvals[nrofparses][nr] = rdup_value (new_val);
callq ();
pusha (affx);
pushi (nr);
pushq (collect_output_affix);
};
void pred_makeemptyfield ()
{ affix_node af1 = new_affix_node ("makeemptyfield_af1");
affix_node af2 = new_affix_node ("makeemptyfield_af2");
pushq (delayed_makeemptyfield);
pushq (make_node_delayed);
pusha (af2);
pushi (tag_single);
pusha (af1);
pushi (tag_single);
pushi (2);
pushi (0);
pushi (mk_nodenr (alib_modnr, 0));
pushq (make_predicate_node);
callq ();
pop (10);
rfre_value (af1 -> val);
free_affix_node (af1);
rfre_value (af2 -> val);
free_affix_node (af2);
pushq (pred_makeemptyfield);
};
main()
{
initstack();
r1 = 7;
r2 = 13;
r3 = 100;
printString ("Now is the time for all good people ...\n");
L1:
r2 = r1 * r2;
*(fp + 4) = r2;
printInt (r2);
printString (" ");
if( r3 > r2 ) goto L1;
printline ();
pushi(r2);
}
Offset setstr(void)
{
int i, j;
lgf++;
if ((i = getsn()) == 0 || (j = findmn(i)) == -1 || !contabp[j].mx) {
lgf--;
return(0);
} else {
SPACETEST(nxf, sizeof(Stack));
nxf->nargs = 0;
strflg++;
lgf--;
return pushi(contabp[j].mx, i);
}
}
void pushvar(stack * st, var variable)
{
if(variable.type == 0)
{
pushi(st, variable.value.literalI);
}
else if(variable.type == 1)
{
pushf(st, variable.value.literalF);
}
else if(variable.type == 2)
{
pushs(st, variable.value.literalS);
}
else
{
printf("Unknown variable type, cannot push.\n");
exit(4);
}
}
void
casewhile(void)
{
tchar c;
int k, level, nl;
filep newip;
if (dip != d)
wbfl();
if ((nextb = alloc()) == 0) {
errprint("out of space");
edone(04);
return;
}
newip = offset = nextb;
wbf(mkxfunc(CC, 0));
wbf(XFUNC); /* caseif */
wbf(' ');
copyf++, clonef++;
nl = level = 0;
do {
nlflg = 0;
k = cbits(c = getch());
switch (k) {
case LEFT:
level++;
break;
case RIGHT:
level--;
break;
}
wbf(c);
} while (!nlflg || level > 0);
if (level < 0 && warn & WARN_DELIM)
errprint("%d excess delimiter(s)", -level);
wbt(0);
copyf--, clonef--;
pushi(newip, LOOP, 0);
offset = dip->op;
}
int toResult(){
int val = 0;
int i = 0;
int len = getlength(poly_exp);
int result = 0;
for(i = 0; i < len; i++){
char c = poly_exp[i];
if(isint(c)){
val = val*10+(c-'0');
}
if(c == '~'){
pushi(val);
val = 0;
}
if(isint(c) && (1-isint(poly_exp[i+1])) && poly_exp[i+1] != '~'){
pushi(val);
val = 0;
}
if(c == '+'){
int x = popi();
int y = popi();
pushi(x+y);
}
if(c == '-'){
int x = popi();
int y = popi();
pushi(y-x);
}
if(c == '*'){
int x = popi();
int y = popi();
pushi(y*x);
}
if(c == '/'){
int x = popi();
int y = popi();
pushi(y/x);
}
}
result = popi();
return result;
}
void ExecFrame::execute_ops(int num)
{
int opcode, param;
floatval fa,fb;
int ia, ib, ifor, iparam, ijmp;
//char opfor,pfor;
Vec2 *v1,*v2;
Vec2 v;
VMInterface* obj;
ExecFrame* frame;
CodeObj* cobj;
while(num-- != 0)
{
opcode = (int)code->code[iptr++];
param = (int)code->code[iptr++];
//std::cout << opcode << ':' << param << std::endl;
switch(opcode) {
case OPC_EXIT:
iptr-=2;
return;
case OPC_VMCALL:
cobj = (CodeObj*)popp();
ia = popi();
frame = new ExecFrame(cobj);
frame->restart();
if (param > 0) move(param, frame);
frame->execute();
if (ia > 0) frame->move(ia, this);
delete frame;
break;
case OPC_CONSTF:
pushf(code->conarray_f[param]);
break;
case OPC_CONSTI:
pushi(code->conarray_i[param]);
break;
case OPC_CONSTV:
pushv(code->conarray_v[param]);
break;
case OPC_CONSTP:
pushp(code->conarray_p[param]);
break;
case OPC_PUSHVARF:
pushf(vararray_f[param]);
break;
case OPC_PUSHVARI:
pushi(vararray_i[param]);
break;
case OPC_PUSHVARV:
pushv(vararray_v[param]);
break;
case OPC_PUSHVARP:
pushp(vararray_p[param]);
break;
case OPC_POP:
top -= param;
break;
case OPC_SETVARF:
vararray_f[param] = popf();
break;
case OPC_SETVARI:
vararray_i[param] = popi();
break;
case OPC_SETVARV:
fb = popf();
fa = popf();
vararray_v[param].set(fa,fb);
break;
case OPC_SETVARP:
vararray_p[param] = popp();
break;
case OPC_GETPROP:
obj = (VMInterface*)popp();
obj->VM_GetProp(this, param);
break;
case OPC_SETPROP:
obj = (VMInterface*)popp();
obj->VM_SetProp(this, param);
break;
case OPC_METCALL:
obj = (VMInterface*)popp();
obj->VM_MetCall(this, param);
break;
case OPC_GETPROPV:
v1 = (Vec2*)popp();
v1->VM_GetProp(this, param);
break;
case OPC_SETPROPV:
v1 = (Vec2*)popp();
v1->VM_SetProp(this, param);
break;
case OPC_METCALLV:
v1 = (Vec2*)popp();
v1->VM_MetCall(this, param);
break;
case OPC_JUMP:
iptr += param*2;
break;
case OPC_IFJUMP:
ia = popi();
if (ia == 0) iptr += param*2;
break;
case OPC_INITFOR:
ib = popi();
ia = popi();
++iptr;
iparam = code->code[iptr++];
ijmp = iptr;
for(ifor=ia;ifor<ib;++ifor)
{
iptr = ijmp;
vararray_i[param] = ifor;
execute_ops(iparam);
/*for(iptr=ijmp;iptr<ijmp+iparam*2;++iptr)
{
opfor = code->code[iptr];
pfor = code->code[++iptr];
if (opfor == OPC_EXIT)
{
--iptr;
return;
}
execute_op(opfor, pfor);
}*/
}
break;
case OPC_LOOP:
; // TODO
break;
case OPC_I2F:
// this will break is floatval uses doubles !!
/* ia = *((int*)top);
*((floatval*)top) = (float)ia;*/
ia = popi();
pushf((floatval)ia);
break;
case OPC_F2I:
/*fa = *((floatval*)top);
*((int*)top) = (int)fa;*/
fa = popf();
pushi((int)fa);
break;
case OPC_VEC2P:
fb = popf();
fa = popf();
v1 = vectemp + (vecidx % 5);
++vecidx;
v1->set(fa,fb);
pushp(v1);
break;
case OPC_P2VEC:
v1 = popv();
pushv(*v1);
break;
case OPC_LASTVEC:
v1 = vectemp + ((vecidx-1)%5);
pushv(*v1);
break;
// --------------------------------------------------
// -------------------- OPERATORS -------------------
// --------------------------------------------------
case OPC_OP_ADDFF:
fa = popf();
*(((floatval*)top)-1) += fa;
break;
case OPC_OP_ADDII:
ia = popi();
*(((int*)top)-1) += ia;
break;
case OPC_OP_ADDVV:
v2 = popv();
v1 = popv();
v.set(*v1);
v.add(*v2);
pushv(v);
break;
case OPC_OP_ANDBB:
ib = popi();
ia = popi();
pushi(ia & ib);
break;
case OPC_OP_DIVFF:
fa = popf();
*(((floatval*)top)-1) /= fa;
break;
case OPC_OP_DIVII:
ia = popi();
*(((int*)top)-1) /= ia;
break;
case OPC_OP_DIVVF:
fa = popf();
v1 = (Vec2*)popp();
v.set(*v1);
v.div(fa);
pushv(v);
break;
case OPC_OP_EQFF:
fb = popf();
fa = popf();
pushi((int)(fa == fb));
break;
case OPC_OP_EQII:
ib = popi();
ia = popi();
pushi((int)(ia == ib));
break;
case OPC_OP_EQVV:
v2 = popv();
v1 = popv();
pushi((int)(ia == ib));
break;
case OPC_OP_GEFF:
fb = popf();
fa = popf();
pushi((int)(fa >= fb));
break;
case OPC_OP_GEII:
ib = popi();
ia = popi();
pushi((int)(ia >= ib));
break;
case OPC_OP_GTFF:
fb = popf();
fa = popf();
pushi((int)(fa > fb));
break;
case OPC_OP_GTII:
ib = popi();
ia = popi();
pushi((int)(ia > ib));
break;
case OPC_OP_LEFF:
fb = popf();
fa = popf();
pushi((int)(fa <= fb));
break;
case OPC_OP_LEII:
ib = popi();
ia = popi();
pushi((int)(ia <= ib));
break;
case OPC_OP_LTFF:
fb = popf();
fa = popf();
pushi((int)(fa < fb));
break;
case OPC_OP_LTII:
ib = popi();
ia = popi();
pushi((int)(ia < ib));
break;
case OPC_OP_MULFF:
fa = popf();
*(((floatval*)top)-1) *= fa;
break;
case OPC_OP_MULII:
ia = popi();
*(((int*)top)-1) *= ia;
break;
case OPC_OP_MULVF:
fa = popf();
v1 = popv();
v.set(*v1);
v.mul(fa);
pushv(v);
break;
case OPC_OP_NEFF:
fb = popf();
fa = popf();
pushi((int)(fa != fb));
break;
case OPC_OP_NEGF:
*(((floatval*)top)-1) = -(*((floatval*)top));
break;
case OPC_OP_NEGI:
*(((int*)top)-1) = -(*((int*)top));
break;
case OPC_OP_NEGV:
v1 = popv();
v.set(-v1->x, -v1->y);
pushv(v);
break;
case OPC_OP_NEII:
ib = popi();
ia = popi();
pushi((int)(ia != ib));
break;
case OPC_OP_NEVV:
v2 = popv();
v1 = popv();
pushi((int)(ia != ib));
break;
case OPC_OP_NOTBB:
; // TODO
break;
case OPC_OP_ORBB:
; // TODO
break;
case OPC_OP_SUBFF:
fa = popf();
*(((floatval*)top)-1) -= fa;
break;
case OPC_OP_SUBII:
ia = popi();
*(((int*)top)-1) -= ia;
break;
case OPC_OP_SUBVV:
v2 = (Vec2*)popp();
v1 = (Vec2*)popp();
v.set(*v1);
v.sub(*v2);
pushv(v);
break;
case OPC_OP_XORBB:
; // TODO
break;
}
}
}
static void _startOrStopModule(MstpId id, bool start)
{
static const struct {
int id:9;
uint8_t reg:2;
uint8_t bit:5;
} t[] = {
{MstpIdEXDMAC, 0, 29},
{MstpIdEXDMAC0, 0, 29},
{MstpIdEXDMAC1, 0, 29},
{MstpIdDMAC, 0, 28},
{MstpIdDMAC0, 0, 28},
{MstpIdDMAC1, 0, 28},
{MstpIdDMAC2, 0, 28},
{MstpIdDMAC3, 0, 28},
{MstpIdDTC, 0, 28},
{MstpIdA27, 0, 27},
{MstpIdA24, 0, 24},
{MstpIdAD, 0, 23},
{MstpIdDA, 0, 19},
{MstpIdS12AD, 0, 17},
{MstpIdCMT0, 0, 15},
{MstpIdCMT1, 0, 15},
{MstpIdCMT2, 0, 14},
{MstpIdCMT3, 0, 14},
{MstpIdTPU0, 0, 13},
{MstpIdTPU1, 0, 13},
{MstpIdTPU2, 0, 13},
{MstpIdTPU3, 0, 13},
{MstpIdTPU4, 0, 13},
{MstpIdTPU5, 0, 13},
{MstpIdTPU6, 0, 12},
{MstpIdTPU7, 0, 12},
{MstpIdTPU8, 0, 12},
{MstpIdTPU9, 0, 12},
{MstpIdTPU10, 0, 12},
{MstpIdTPU11, 0, 12},
{MstpIdPPG0, 0, 11},
{MstpIdPPG1, 0, 10},
{MstpIdMTU, 0, 9},
{MstpIdMTU0, 0, 9},
{MstpIdMTU1, 0, 9},
{MstpIdMTU2, 0, 9},
{MstpIdMTU3, 0, 9},
{MstpIdMTU4, 0, 9},
{MstpIdMTU5, 0, 9},
{MstpIdTMR0, 0, 5},
{MstpIdTMR1, 0, 5},
{MstpIdTMR01, 0, 5},
{MstpIdTMR2, 0, 4},
{MstpIdTMR3, 0, 4},
{MstpIdTMR23, 0, 4},
{MstpIdSCI0, 1, 31},
{MstpIdSMCI0, 1, 31},
{MstpIdSCI1, 1, 30},
{MstpIdSMCI1, 1, 30},
{MstpIdSCI2, 1, 29},
{MstpIdSMCI2, 1, 29},
{MstpIdSCI3, 1, 28},
{MstpIdSMCI3, 1, 28},
{MstpIdSCI4, 1, 27},
{MstpIdSMCI4, 1, 27},
{MstpIdSCI5, 1, 26},
{MstpIdSMCI5, 1, 26},
{MstpIdSCI6, 1, 25},
{MstpIdSMCI6, 1, 25},
{MstpIdSCI7, 1, 24},
{MstpIdSMCI7, 1, 24},
{MstpIdCRC, 1, 23},
{MstpIdPDC, 1, 22},
{MstpIdRIIC0, 1, 21},
{MstpIdRIIC1, 1, 20},
{MstpIdUSB0, 1, 19},
{MstpIdUSB1, 1, 18},
{MstpIdRSPI0, 1, 17},
{MstpIdRSPI1, 1, 16},
{MstpIdEDMAC, 1, 15},
{MstpIdTEMPS, 1, 8},
{MstpIdSCI12, 1, 4},
{MstpIdSMCI12, 1, 4},
{MstpIdCAN2, 1, 2},
{MstpIdCAN1, 1, 1},
{MstpIdCAN0, 1, 0},
{MstpIdSCI8, 2, 27},
{MstpIdSMCI8, 2, 27},
{MstpIdSCI9, 2, 26},
{MstpIdSMCI9, 2, 26},
{MstpIdSCI10, 2, 25},
{MstpIdSMCI10, 2, 25},
{MstpIdSCI11, 2, 24},
{MstpIdSMCI11, 2, 24},
{MstpIdRSPI2, 2, 22},
{MstpIdMCK, 2, 19},
{MstpIdIEB, 2, 18},
{MstpIdRIIC2, 2, 17},
{MstpIdRIIC3, 2, 16},
{MstpIdRAM1, 2, 1},
{MstpIdRAM0, 2, 0},
{MstpIdDEU, 3, 31},
};
static uint8_t f[(NumOfMstpId + __CHAR_BIT__ - 1) / __CHAR_BIT__] = {0};
if (id >= 0 && id < NumOfMstpId) {
int reg;
volatile uint32_t* mstpcr = NULL;
int bit;
int i;
for (i = 0; i < (int)(sizeof(t) / sizeof(*t)); i++) {
if (t[i].id == id) {
reg = t[i].reg;
mstpcr = (volatile uint32_t*)((uint32_t*)&SYSTEM.MSTPCRA.LONG + reg);
bit = t[i].bit;
break;
}
}
if (mstpcr != NULL) {
int c = 0;
int j;
for (j = 0; j < (int)(sizeof(t) / sizeof(*t)); j++) {
if (t[j].id != id && (t[j].reg == reg && t[j].bit == bit)) {
if ((f[t[j].id / __CHAR_BIT__] & (1 << (t[j].id % __CHAR_BIT__))) != 0) {
c++;
}
}
}
if (start) {
if ((f[id / __CHAR_BIT__] & (1 << (id % __CHAR_BIT__))) == 0) {
f[id / __CHAR_BIT__] |= (1 << (id % __CHAR_BIT__));
if (c == 0) {
pushi();
cli();
*mstpcr &= ~(1U << bit);
popi();
}
}
} else {
if ((f[id / __CHAR_BIT__] & (1 << (id % __CHAR_BIT__))) != 0) {
f[id / __CHAR_BIT__] &= ~(1 << (id % __CHAR_BIT__));
if (c == 0) {
pushi();
cli();
*mstpcr |= (1U << bit);
popi();
}
}
}
}
}
}
