static int
evalTerm(char *s,
struct tr *tr,
int *lenPtr,
value * covPtr)
{
int len;
int skip;
len = 0;
while (isspace(s[len]))
++len;
switch (s[len]) {
case '\0':
fprintf(stderr, "empty subexpression\n");
return -1;
case '(':
++len;
if (evalConj(s + len, tr, &skip, covPtr) == -1)
return -1;
len += skip;
while (isspace(s[len]))
++len;
if (s[len] != ')') {
fprintf(stderr, "unballanced parenthesis\n");
free(*covPtr);
return -1;
}
++len;
*lenPtr = len;
break;
case '!':
++len;
if (evalTerm(s + len, tr, &skip, covPtr) == -1)
return -1;
len += skip;
doNot(*covPtr, tr->covCount);
*lenPtr = len;
break;
default:
if (evalNames(s + len, tr, &skip, covPtr) == -1)
return -1;
len += skip;
*lenPtr = len;
break;
}
return 0;
}
void execute(pruCPU *cpu) {
aluInstruction inst;
fmt2InstructionHeader fmt2Hdr;
while(1) {
int didBranch = 0;
cgc_memcpy(&inst, (aluInstruction *)&cpu->code[cpu->pc], 4);
switch(inst.opFmt) {
case 0b000:
switch(inst.aluOp) {
case ADD:
doAdd(cpu, inst);
break;
case ADC:
doAdc(cpu, inst);
break;
case SUB:
doSub(cpu, inst);
break;
case SUC:
doSuc(cpu, inst);
break;
case LSL:
doLsl(cpu, inst);
break;
case LSR:
doLsr(cpu, inst);
break;
case RSB:
doRsb(cpu, inst);
break;
case RSC:
doRsc(cpu, inst);
break;
case AND:
doAnd(cpu, inst);
break;
case OR:
doOr(cpu, inst);
break;
case XOR:
doXor(cpu, inst);
break;
case NOT:
doNot(cpu, inst);
break;
case MIN:
doMin(cpu, inst);
break;
case MAX:
doMax(cpu, inst);
break;
case CLR:
doClr(cpu, inst);
break;
case SET:
doSet(cpu, inst);
break;
}
break;
case 0b001:
cgc_memcpy(&fmt2Hdr, &inst, sizeof(fmt2Hdr));
switch(fmt2Hdr.subOp)
{
case JMP:
case JAL:
;
fmt2BranchInstruction fmt2Branch;
cgc_memcpy(&fmt2Branch, &inst, 4);
doBranch(cpu, fmt2Branch);
didBranch = 1;
break;
case LDI:
;
fmt2LdiInstruction fmt2Ldi;
cgc_memcpy(&fmt2Ldi, &inst, 4);
doLdi(cpu, fmt2Ldi);
break;
case LMBD:
;
fmt2LmbdInstruction fmt2Lmbd;
cgc_memcpy(&fmt2Lmbd, &inst, 4);
doLmbd(cpu, fmt2Lmbd);
break;
case HALT:
return;
case SCAN:
;
fmt2ScanInstruction fmt2Scan;
cgc_memcpy(&fmt2Scan, &inst, 4);
doScan(cpu, fmt2Scan);
break;
case SLP:
case RESERVED_1:
case RESERVED_2:
case RESERVED_3:
case RESERVED_4:
case RESERVED_5:
case RESERVED_6:
case RESERVED_7:
case RESERVED_8:
case RESERVED_9:
return;
}
break;
case 0b11:
;
fmtQatbInstruction qatbInstruction;
cgc_memcpy(&qatbInstruction, &inst, 4);
doQATB(cpu, qatbInstruction);
default:
return;
}
if(didBranch == 0)
cpu->pc++;
cpu->numExecuted++;
if(cpu->numExecuted >= MAX_INSNS)
return;
}
}
bool Mission::checkBoolExpr(missionNode *node,int mode){
bool ok;
// no difference between parse/run
if(node->tag==DTAG_AND_EXPR){
ok=doAndOr(node,mode);
}
else if(node->tag==DTAG_OR_EXPR){
ok=doAndOr(node,mode);
}
else if(node->tag==DTAG_NOT_EXPR){
ok=doNot(node,mode);
}
else if(node->tag==DTAG_TEST_EXPR){
ok=doTest(node,mode);
}
else if(node->tag==DTAG_VAR_EXPR){
ok=doBooleanVar(node,mode);
}
else if(node->tag==DTAG_CONST){
varInst *vi=doConst(node,mode);
if(vi->type==VAR_BOOL){
ok=vi->bool_val;
}
else{
fatalError(node,mode,"expected a bool const, got a different one");
assert(0);
}
deleteVarInst(vi);
}
else if(node->tag==DTAG_CALL){
varInst *vi=doCall(node,mode);
if(vi->type==VAR_BOOL){
ok=vi->bool_val;
}
else if(vi->type==VAR_ANY && mode==SCRIPT_PARSE){
ok=vi->bool_val;
}
else{
fatalError(node,mode,"expected a bool call, got a different one");
assert(0);
}
deleteVarInst(vi);
}
else if(node->tag==DTAG_EXEC){
varInst *vi=doExec(node,mode);
if(vi==NULL){
fatalError(node,mode,"doExec returned NULL");
assert(0);
// parsing?
}
else if(node->script.vartype==VAR_BOOL){
ok=vi->bool_val;
}
else{
fatalError(node,mode,"expected a bool exec, got a different one");
assert(0);
}
deleteVarInst(vi);
}
else{
fatalError(node,mode,"no such boolean expression tag");
assert(0);
}
return ok;
}
