//Execute cycle void execute(FILE *ofp) { fprintf(ofp, "%d\t%s\t%d\t%d\t", pc-1, opcodes[ir.op], ir.l, ir.m); switch( ir.op ) { case 1 : LIT(ir.l, ir.m); break; case 2 : OPR(ir.l, ir.m); break; case 3 : LOD(ir.l, ir.m); break; case 4 : STO(ir.l, ir.m); break; case 5 : CAL(ir.l, ir.m); break; case 6 : INC(ir.l, ir.m); break; case 7 : JMP(ir.l, ir.m); break; case 8 : JPC(ir.l, ir.m); break; case 9 : SIO(ir.l, ir.m); break; case 10 : SIO(ir.l, ir.m); break; case 11 : SIO(ir.l, ir.m); break; default : break; } fprintf(ofp, "%d\t%d\t%d\t", pc, bp, sp); int i = 1; int countAR = 0; for(i = 1; i <= sp; i++) { if(countAR < numAR && ar[countAR] < i) { countAR++; fprintf(ofp, " |"); } fprintf(ofp, " %d", stack[i]); } fprintf(ofp, "\n"); }
// Uses value in IR to determine course of action // Returns false if errors bool interpreter() { bool success = true; //While no error flag and no timer interrupt while (success && timer_interrupt < QUANTUM) { machine.IR = main_memory[MMU(machine.PC)]; machine.PC++; // Increment Program Counter unsigned short int op = getOpcode(machine.IR); switch (op) { case 0: success = LOD(); break; case 1: success = STO(); break; case 2: success = ADD(); break; case 3: success = SUB(); break; case 4: success = ADR(); break; case 5: success = SUR(); break; case 6: success = AND(); break; case 7: success = IOR(); break; case 8: success = NOT(); break; case 9: success = JMP(); break; case 10: success = JEQ(); break; case 11: success = JGT(); break; case 12: success = JLT(); break; case 13: success = CMP(); break; case 14: success = CLR(); break; case 15: return HLT(); break; //Quit early on HLT default: success = false; break; } usleep(1000000); // Sleep 1 second to allow easier instruction tracing (*sysclock)++; timer_interrupt++; } timer_interrupt = 0; return success; }
MVM_Object * create_array_literal_object(MVM_VirtualMachine *mvm, int size) { MVM_Object *array; int i; array = mvm_create_array_object_i(mvm, size); for (i = 0; i < size; i++) { array->u.array.u.object[i] = STO(mvm, -size+i); } return array; }
static void execute(MVM_VirtualMachine *mvm, Function *func, MVM_Byte *code, int code_size) { int base; MVM_Executable *exe; int pc; //MVM_Value ret; pc = mvm->pc; exe = mvm->current_executable; while (pc < code_size) { /*printf("%s sp(%d)\t\n", mvm_opcode_info[code[pc]].mnemonic, mvm->stack.stack_pointer);*/ switch (code[pc]) { case MVM_PUSH_INT_1BYTE: STI_WRITE(mvm, 0, code[pc+1]); //printf("int byte %d\n",code[pc+1]); mvm->stack.stack_pointer++; pc += 2; break; case MVM_PUSH_INT_2BYTE: STI_WRITE(mvm, 0, GET_2BYTE_INT(&code[pc+1])); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_INT: STI_WRITE(mvm, 0, exe->constant_pool[GET_2BYTE_INT(&code[pc+1])].u.c_integer); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_DOUBLE_0: STD_WRITE(mvm, 0, 0.0); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_DOUBLE_1: STD_WRITE(mvm, 0, 1.0); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_DOUBLE: STD_WRITE(mvm, 0, exe->constant_pool[GET_2BYTE_INT(&code[pc+1])].u.c_decimal); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STRING: STO_WRITE(mvm, 0, mvm_literal_to_mvm_string_i(mvm, exe->constant_pool [GET_2BYTE_INT(&code [pc+1])] .u.c_string)); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_NULL: STO_WRITE(mvm, 0, NULL); mvm->stack.stack_pointer++; pc++; break; case MVM_PUSH_STACK_INT: STI_WRITE(mvm, 0, STI_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STACK_DOUBLE: STD_WRITE(mvm, 0, STD_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STACK_OBJECT: STO_WRITE(mvm, 0, STO_I(mvm, base + GET_2BYTE_INT(&code[pc+1]))); mvm->stack.stack_pointer++; pc += 3; break; case MVM_POP_STACK_INT: STI_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STI(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STACK_DOUBLE: STD_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STD(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STACK_OBJECT: STO_WRITE_I(mvm, base + GET_2BYTE_INT(&code[pc+1]), STO(mvm, -1)); mvm->stack.stack_pointer--; pc += 3; break; case MVM_PUSH_STATIC_INT: STI_WRITE(mvm, 0, mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .int_value); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STATIC_DOUBLE: STD_WRITE(mvm, 0, mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .double_value); mvm->stack.stack_pointer++; pc += 3; break; case MVM_PUSH_STATIC_OBJECT: STO_WRITE(mvm, 0,mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].object); mvm->stack.stack_pointer++; pc += 3; break; case MVM_POP_STATIC_INT: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].int_value = STI(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STATIC_DOUBLE: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])] .double_value = STD(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_POP_STATIC_OBJECT: mvm->static_v.variable[GET_2BYTE_INT(&code[pc+1])].object = STO(mvm, -1); mvm->stack.stack_pointer--; pc += 3; break; case MVM_PUSH_ARRAY_INT: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); int int_value; restore_pc(mvm, exe, func, pc); int_value = MVM_array_get_int(mvm, array, index); STI_WRITE(mvm, -2, int_value); mvm->stack.stack_pointer--; pc++; break; } case MVM_PUSH_ARRAY_DOUBLE: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); double double_value; restore_pc(mvm, exe, func, pc); double_value = MVM_array_get_double(mvm, array, index); STD_WRITE(mvm, -2, double_value); mvm->stack.stack_pointer--; pc++; break; } case MVM_PUSH_ARRAY_OBJECT: { MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); MVM_Object *object; restore_pc(mvm, exe, func, pc); object = MVM_array_get_object(mvm, array, index); STO_WRITE(mvm, -2, object); mvm->stack.stack_pointer--; pc++; break; } case MVM_POP_ARRAY_INT: { int value = STI(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_int(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_POP_ARRAY_DOUBLE: { double value = STD(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_double(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_POP_ARRAY_OBJECT: { MVM_Object *value = STO(mvm, -3); MVM_Object *array = STO(mvm, -2); int index = STI(mvm, -1); restore_pc(mvm, exe, func, pc); MVM_array_set_object(mvm, array, index, value); mvm->stack.stack_pointer -= 3; pc++; break; } case MVM_PUSH_FIELD_INT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STI_WRITE(mvm, -1, obj->u.class_object.field[index].int_value); pc += 3; break; } case MVM_PUSH_FIELD_DOUBLE: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STD_WRITE(mvm, -1, obj->u.class_object.field[index].double_value); pc += 3; break; } case MVM_PUSH_FIELD_OBJECT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); STO_WRITE(mvm, -1, obj->u.class_object.field[index].object); pc += 3; break; } case MVM_POP_FIELD_INT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); obj->u.class_object.field[index].int_value = STI(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_POP_FIELD_DOUBLE: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); obj->u.class_object.field[index].double_value = STD(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_POP_FIELD_OBJECT: { MVM_Object *obj = STO(mvm, -1); int index = GET_2BYTE_INT(&code[pc+1]); //check_null_pointer(exe, func, pc, obj); obj->u.class_object.field[index].object = STO(mvm, -2); mvm->stack.stack_pointer -= 2; pc += 3; break; } case MVM_ADD_INT: STI(mvm, -2) = STI(mvm, -2) + STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_ADD_DOUBLE: STD(mvm, -2) = STD(mvm, -2) + STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_ADD_STRING: STO(mvm, -2) = chain_string(mvm, STO(mvm, -2), STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_SUB_INT: STI(mvm, -2) = STI(mvm, -2) - STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_SUB_DOUBLE: STD(mvm, -2) = STD(mvm, -2) - STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MUL_INT: STI(mvm, -2) = STI(mvm, -2) * STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MUL_DOUBLE: STD(mvm, -2) = STD(mvm, -2) * STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_DIV_INT: if (STI(mvm, -1) == 0) { //mvm_error(exe, func, pc, DIVISION_BY_ZERO_ERR, // MESSAGE_ARGUMENT_END); } STI(mvm, -2) = STI(mvm, -2) / STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_DIV_DOUBLE: STD(mvm, -2) = STD(mvm, -2) / STD(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MOD_INT: STI(mvm, -2) = STI(mvm, -2) % STI(mvm, -1); mvm->stack.stack_pointer--; pc++; break; case MVM_MOD_DOUBLE: STD(mvm, -2) = fmod(STD(mvm, -2), STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_MINUS_INT: STI(mvm, -1) = -STI(mvm, -1); pc++; break; case MVM_MINUS_DOUBLE: STD(mvm, -1) = -STD(mvm, -1); pc++; break; case MVM_INCREMENT: STI(mvm, -1)++; pc++; break; case MVM_DECREMENT: STI(mvm, -1)--; pc++; break; case MVM_CAST_INT_TO_DOUBLE: STD(mvm, -1) = (double)STI(mvm, -1); pc++; break; case MVM_CAST_DOUBLE_TO_INT: STI(mvm, -1) = (int)STD(mvm, -1); pc++; break; case MVM_CAST_BOOLEAN_TO_STRING: if (STI(mvm, -1)) { STO_WRITE(mvm, -1, mvm_literal_to_mvm_string_i(mvm, TRUE_STRING)); } else { STO_WRITE(mvm, -1, mvm_literal_to_mvm_string_i(mvm, FALSE_STRING)); } pc++; break; case MVM_CAST_INT_TO_STRING: { char buf[LINE_BUF_SIZE]; MVM_Char *str; sprintf(buf, "%d", STI(mvm, -1)); restore_pc(mvm, exe, func, pc); str = str_alloc(buf); STO_WRITE(mvm, -1, mvm_create_mvm_string_i(mvm, str)); pc++; break; } case MVM_CAST_DOUBLE_TO_STRING: { char buf[LINE_BUF_SIZE]; MVM_Char *str; sprintf(buf, "%f", STD(mvm, -1)); restore_pc(mvm, exe, func, pc); str = str_alloc(buf); STO_WRITE(mvm, -1, mvm_create_mvm_string_i(mvm, str)); pc++; break; } case MVM_EQ_INT: STI(mvm, -2) = (STI(mvm, -2) == STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) == STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_OBJECT: STI_WRITE(mvm, -2, STO(mvm, -2) == STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_EQ_STRING: STI_WRITE(mvm, -2, !strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_INT: STI(mvm, -2) = (STI(mvm, -2) > STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) > STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GT_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) > 0); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_INT: STI(mvm, -2) = (STI(mvm, -2) >= STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) >= STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_GE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) >= 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_INT: STI(mvm, -2) = (STI(mvm, -2) < STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) < STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LT_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) < 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_INT: STI(mvm, -2) = (STI(mvm, -2) <= STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) <= STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) <= 0); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_INT: STI(mvm, -2) = (STI(mvm, -2) != STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_DOUBLE: STI(mvm, -2) = (STD(mvm, -2) != STD(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_OBJECT: STI_WRITE(mvm, -2, STO(mvm, -2) != STO(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_NE_STRING: STI_WRITE(mvm, -2, strcmp(STO(mvm, -2)->u.string.string, STO(mvm, -1)->u.string.string) != 0); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_AND: STI(mvm, -2) = (STI(mvm, -2) && STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_OR: STI(mvm, -2) = (STI(mvm, -2) || STI(mvm, -1)); mvm->stack.stack_pointer--; pc++; break; case MVM_LOGICAL_NOT: STI(mvm, -1) = !STI(mvm, -1); pc++; break; case MVM_POP: mvm->stack.stack_pointer--; pc++; break; case MVM_DUPLICATE: mvm->stack.stack[mvm->stack.stack_pointer] = mvm->stack.stack[mvm->stack.stack_pointer-1]; mvm->stack.stack_pointer++; pc++; break; case MVM_JUMP: pc = GET_2BYTE_INT(&code[pc+1]); break; case MVM_JUMP_IF_TRUE: if (STI(mvm, -1)) { pc = GET_2BYTE_INT(&code[pc+1]); } else { pc += 3; } mvm->stack.stack_pointer--; break; case MVM_JUMP_IF_FALSE: if (!STI(mvm, -1)) { pc = GET_2BYTE_INT(&code[pc+1]); } else { pc += 3; } mvm->stack.stack_pointer--; break; case MVM_PUSH_FUNCTION: STI_WRITE(mvm, 0, GET_2BYTE_INT(&code[pc+1])); mvm->stack.stack_pointer++; pc += 3; break; case MVM_INVOKE: { int func_idx = STI(mvm, -1); if (mvm->function[func_idx].kind == NATIVE_FUNCTION) { invoke_native_function(mvm, &mvm->function[func_idx], &mvm->stack.stack_pointer); pc++; } else { invoke_minic_function(mvm, &func, &mvm->function[func_idx], &code, &code_size, &pc, &mvm->stack.stack_pointer, &base, &exe); } break; } case MVM_RETURN: return_function(mvm, &func, &code, &code_size, &pc, &mvm->stack.stack_pointer, &base, &exe); break; case MVM_NEW_ARRAY: { int dim = code[pc+1]; MVM_TypeSpecifier *type = &exe->type_specifier[GET_2BYTE_INT(&code[pc+2])]; MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array(mvm, dim, type); mvm->stack.stack_pointer -= dim; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 4; break; } case MVM_NEW_ARRAY_LITERAL_INT: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_int(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } case MVM_NEW_ARRAY_LITERAL_DOUBLE: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_double(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } case MVM_NEW_ARRAY_LITERAL_OBJECT: /* FALLTHRU */ { int size = GET_2BYTE_INT(&code[pc+1]); MVM_Object *array; restore_pc(mvm, exe, func, pc); array = create_array_literal_object(mvm, size); mvm->stack.stack_pointer -= size; STO_WRITE(mvm, 0, array); mvm->stack.stack_pointer++; pc += 3; break; } default: break; } /* MEM_check_all_blocks(); */ } //return ret; }
/* This is the messy part. This is what happens when you copy-paste one thing that works make the rest of it work */ int execute(int **mem, int *pc, int flow, int *areg, int *breg, int *creg){ int i; int *tryte; tryte = mem[*pc]; /* output instructions */ if (tryte[0]==-1&&tryte[1]==-1&&tryte[2]==0){ if(flow) puts("OUT A "); printf("PRINT %d\n",tern2dec(areg)); *pc+=1; }else if (tryte[0]==0&&tryte[1]==-1&&tryte[2]==0){ if(flow) puts("OUT B "); printf("PRINT %d\n",tern2dec(breg)); *pc+=1; }else if (tryte[0]==1&&tryte[1]==-1&&tryte[2]==0){ if(flow) puts("OUT C "); printf("PRINT %d\n",tern2dec(creg)); *pc+=1; /* input instructions */ }else if (tryte[0]==-1&&tryte[1]==0&&tryte[2]==1){ if(flow) puts("IN A "); printf("IN A? :"); scanf("%d",&i); dec2tern(i); for(i=0;i<WIDTH;i++){ areg[i] = itryte[i]; } *pc+=1; }else if (tryte[0]==0&&tryte[1]==0&&tryte[2]==1){ if(flow) puts("IN B "); printf("IN B? :"); scanf("%d",&i); dec2tern(i); for(i=0;i<WIDTH;i++){ breg[i] = itryte[i]; } *pc+=1; }else if (tryte[0]==1&&tryte[1]==0&&tryte[2]==1){ if(flow) puts("IN C "); scanf("%d",&i); dec2tern(i); for(i=0;i<WIDTH;i++){ creg[i] = itryte[i]; } *pc+=1; *pc+=1; /* load instructions */ }else if (tryte[0]==-1&&tryte[1]==-1&&tryte[2]==-1){ if(flow) puts("LD A "); for(i=0;i<WIDTH;i++){ areg[i]=mem[364+tern2dec(mem[*pc+1])][i]; } *pc+=2; }else if (tryte[0]==0&&tryte[1]==-1&&tryte[2]==-1){ if(flow) puts("LD B "); for(i=0;i<WIDTH;i++){ breg[i]=mem[364+tern2dec(mem[*pc+1])][i]; } *pc+=2; }else if (tryte[0]==1&&tryte[1]==-1&&tryte[2]==-1){ if(flow) puts("LD C "); for(i=0;i<WIDTH;i++){ creg[i]=mem[364+tern2dec(mem[*pc+1])][i]; } *pc+=2; /* increment instructions */ }else if (tryte[0]==-1 &&tryte[1]==0 &&tryte[2]==-1){ if(flow) puts("INC A"); incrTryte(areg); *pc+=1; }else if (tryte[0]==0 &&tryte[1]==0 &&tryte[2]==-1){ if(flow) puts("INC B"); incrTryte(breg); *pc+=1; }else if (tryte[0]==1 &&tryte[1]==0 &&tryte[2]==-1){ if(flow) puts("INC C"); incrTryte(creg); *pc+=1; /* conditional skip instructions */ }else if (tryte[0]==-1&&tryte[1]==1&&tryte[2]==-1){ if(flow) puts("SKP A "); if(condSkip(areg)) *pc+=3; else *pc+=1; }else if (tryte[0]==0&&tryte[1]==1&&tryte[2]==-1){ if(flow) puts("SKP B "); if(condSkip(breg)) *pc+=3; else *pc+=1; }else if (tryte[0]==1&&tryte[1]==1&&tryte[2]==-1){ if(flow) puts("SKP C "); if(condSkip(creg)) *pc+=3; else *pc+=1; /* 3 ADD instructions */ }else if(tryte[0]==-1 &&tryte[1]==1 &&tryte[2]==1){ if(flow) puts("ADD A"); addTryte(areg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; }else if(tryte[0]==0 &&tryte[1]==1 &&tryte[2]==1){ if(flow) puts("ADD B"); addTryte(breg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; }else if(tryte[0]==1 &&tryte[1]==1 &&tryte[2]==1){ if(flow) puts("ADD C"); addTryte(creg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; /* 3 STO instructions */ }else if(tryte[0]==-1 &&tryte[1]==-1 &&tryte[2]==1){ if(flow) puts("STO A"); STO(areg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; }else if(tryte[0]==0 &&tryte[1]==-1 &&tryte[2]==1){ if(flow) puts("STO B"); STO(breg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; }else if(tryte[0]==1 &&tryte[1]==-1 &&tryte[2]==1){ if(flow) puts("STO C"); STO(creg,mem[364+tern2dec(mem[*pc+1])]); *pc+=2; /* HALT Instruction */ }else if(tryte[0]==-1 &&tryte[1]==0 &&tryte[2]==0){ if(flow) puts("HALT"); return 1; /* Bitwise invert instructions */ }else if(tryte[0]==-1 &&tryte[1]==1 &&tryte[2]==0){ if(flow) puts("INV A"); invTryte(areg); *pc+=1; }else if(tryte[0]==0 &&tryte[1]==1 &&tryte[2]==0){ if(flow) puts("INV B"); invTryte(breg); *pc+=1; }else if(tryte[0]==1 &&tryte[1]==1 &&tryte[2]==0){ if(flow) puts("INV C"); invTryte(creg); *pc+=1; /* Unconditional JP instruction */ }else if (tryte[0]==1&&tryte[1]==0&&tryte[2]==0){ if(flow) puts("JP"); JP(mem[*pc+1],pc); /* NOOP instruction */ }else if (tryte[0]==0&&tryte[1]==0&&tryte[2]==0){ if(flow) puts("NOOP"); *pc+=1; }else{ if(flow){ dispTryte(tryte); puts("?"); } *pc+=1; } return 0; }