aluop.cpp

mini mips 小型mips软件

	double temp;
	//scanf_s("%lf", &temp);
	cin >> temp;
	Data.floatingRegister.SetValueD(0, temp);
}

void ALUOp::read_string(CPUData& Data){
	unsigned address = Data.generalRegister["$a0"].UIntV;
	unsigned length = Data.generalRegister["$a1"].UIntV;
	RegisterType value;
	char ch;
	while (--length){
		if (!cin.get(ch)) break;
		if (ch == '\0') break;
		value = Data.Mem.Load(address & 0xfffffffc);
		value.CV[address & 3] = ch;
		Data.Mem.Save(address & 0xfffffffc, value);
		++address;
		if (ch == '\n') break;
	}
	value = Data.Mem.Load(address & 0xfffffffc);
	value.CV[address & 3] = '\0';
	Data.Mem.Save(address & 0xfffffffc, value);
}

//void ALUOp::print_int(CPUData& Data){
//	int offset;
//	sprintf_s(Data.writePointer, Data.SpaceWriteBuf(), "%d%n", Data.generalRegister["$a0"].IntV, &offset);
//	Data.writePointer += offset;
//}
//
//void ALUOp::print_float(CPUData& Data){
//	int offset;
//	sprintf_s(Data.writePointer, Data.SpaceWriteBuf(), "%f%n", Data.floatingRegister.GetValueF(12), &offset);
//	Data.writePointer += offset;
//}
//
//void ALUOp::print_double(CPUData& Data){
//	int offset;
//	sprintf_s(Data.writePointer, Data.SpaceWriteBuf(), "%lf", Data.floatingRegister.GetValueD(12), &offset);
//	Data.writePointer += offset;
//}
//
//void ALUOp::print_string(CPUData& Data){
//	unsigned address = Data.generalRegister["$a0"].UIntV;
//	RegisterType value = Data.Mem.Load(address & 0xfffffffc);
//	char ch = value.CV[address & 3];
//	while(ch != '\0'){
//		//putchar(ch);
//		sprintf_s(Data.writePointer, Data.SpaceWriteBuf(), "%c", ch);
//		++Data.writePointer;
//		++address;
//		value = Data.Mem.Load(address & 0xfffffffc);
//	    ch = value.CV[address & 3];
//	}
//}
//
//void ALUOp::read_int(CPUData& Data){
//	int offset;
//	sscanf_s(Data.readPointer, "%d%n", &Data.generalRegister["$v0"].IntV, &offset);
//	Data.readPointer += offset;
//}
//
//void ALUOp::read_float(CPUData& Data){
//	int offset;
//	float temp;
//	sscanf_s(Data.readPointer, "%f%n", &temp, &offset);
//	Data.floatingRegister.SetValueF(0, temp);
//	Data.readPointer += offset;
//}
//
//void ALUOp::read_double(CPUData& Data){
//	int offset;
//	double temp;
//	scanf_s(Data.readPointer, "%lf%n", &temp, &offset);
//	Data.floatingRegister.SetValueD(0, temp);
//	Data.readPointer += offset;
//}
//
//void ALUOp::read_string(CPUData& Data){
//	unsigned address = Data.generalRegister["$a0"].UIntV;
//	unsigned length = Data.generalRegister["$a1"].UIntV;
//	RegisterType value;
//	int ch;
//	while (--length){		
//		if ((ch = *(Data.readPointer)++) == '\0') break;
//		value = Data.Mem.Load(address & 0xfffffffc);
//		value.CV[address & 3] = (char) ch;
//		Data.Mem.Save(address & 0xfffffffc, value);
//		++address;
//		if (ch == '\n') break;
//	}
//	value.CV[address & 3] = '\0';
//	Data.Mem.Save(address & 0xfffffffc, value);
//}

void ALUOp::sbrk(CPUData& Data){
	int amount = Data.generalRegister["$a0"].UIntV;
	Data.generalRegister["$v0"].UIntV = Data.Mem.Malloc(amount);
}

void ALUOp::exit(CPUData& Data){
	Data.exit = true;
}

//void ALUOp::print_char(CPUData& Data){
//	sprintf_s(Data.writePointer, Data.SpaceWriteBuf(), "%c", Data.generalRegister["$a0"].IntV);
//	++Data.writePointer;
//}
//
//void ALUOp::read_char(CPUData& Data){
//	Data.generalRegister["$a0"].IntV = *(Data.readPointer)++;
//}

void ALUOp::print_char(CPUData& Data){
	//putchar(Data.generalRegister["$a0"].IntV);
	cout.put(Data.generalRegister["$a0"].IntV);
}

void ALUOp::read_char(CPUData& Data){
	//Data.generalRegister["$a0"].IntV = getchar();
	char ch;
	cin.get(ch);
	Data.generalRegister["$a0"].IntV = ch;
}

void ALUOp::open(CPUData& Data){
	string filename;
	int flags;
	int mode;
	int handle;

	unsigned address = Data.generalRegister["$a0"].UIntV;
	RegisterType value = Data.Mem.Load(address & 0xfffffffc);
	char ch = value.CV[address & 3];
	while(ch != '\0'){
		filename += ch;
		++address;
		value = Data.Mem.Load(address & 0xfffffffc);
	    ch = value.CV[address & 3];
	}
	
	flags = Data.generalRegister["$a1"].IntV;

	mode = Data.generalRegister["$a2"].IntV;

	handle = _open(filename.c_str(), flags, mode);

	Data.generalRegister["$v0"].IntV = handle;
}

void ALUOp::read(CPUData& Data){
	int handle = Data.generalRegister["$a0"].IntV;
	unsigned address = Data.generalRegister["$a1"].UIntV;
	unsigned length = Data.generalRegister["$a2"].UIntV;
	RegisterType value;

	char *buf = new char[length];
	_read(handle, buf, length);
	for (unsigned i = 0; i < length; ++i, ++address){
		value = Data.Mem.Load(address & 0xfffffffc);
		value.CV[address & 3] = buf[i];
		Data.Mem.Save(address & 0xfffffffc, value);
	}
}

void ALUOp::write(CPUData& Data){
	int handle = Data.generalRegister["$a0"].IntV;
	unsigned address = Data.generalRegister["$a1"].UIntV;
	unsigned length = Data.generalRegister["$a2"].UIntV;
	RegisterType value;
	char *buf = new char[length];

	for (unsigned i = 0; i < length; ++i, ++address){
		value = Data.Mem.Load(address & 0xfffffffc);
		buf[i] = value.CV[address & 3];
	}
	_write(handle, buf, length);
}

void ALUOp::close(CPUData& Data){
	int handle = Data.generalRegister["$a0"].IntV;
	_close(handle);
}

void ALUOp::exit2(CPUData& Data){
	Data.exit2 = true;
	Data.exit2val = Data.generalRegister["$a0"].IntV;
}

void ALUOp::swcl(int d, int s, int t, int i, int h, CPUData &Data){
	unsigned address = Data.generalRegister[s].UIntV + i;
	if (address & 3){
		RegisterType value, f;
		int offset = address & 3, i;
		value = Data.Mem.Load(address & 0xfffffffc);
		f.FloatV = Data.floatingRegister.GetValueF(t);
		for (i = 0; i + offset < 4; ++i) value.CV[i + offset] = f.CV[i];
		Data.Mem.Save(address & 0xfffffffc, value);
		value = Data.Mem.Load((address & 0xfffffffc) + 1);
		for (i = 0; i < offset; ++i) value.CV[i] = f.CV[i + 4 - offset];
		Data.Mem.Save((address & 0xfffffffc) + 1, value);
	}
	else{
		Data.Mem.Save(address, Data.generalRegister[t]);
	}
	Data.PC.advance_pc();
}

void ALUOp::sdcl(int d, int s, int t, int i, int h, CPUData &Data){
	PCType temp = Data.PC;
	swcl(d, s, t, i, h, Data);
	swcl(d, s, t + 1, i + 4, h, Data);
	Data.PC = temp;
	Data.PC.advance_pc();
}

void ALUOp::add_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueF(d, Data.floatingRegister.GetValueF(s) + Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::add_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueD(d, Data.floatingRegister.GetValueD(s) + Data.floatingRegister.GetValueD(t));
}

void ALUOp::div_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueF(d, Data.floatingRegister.GetValueF(s) / Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::div_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueD(d, Data.floatingRegister.GetValueD(s) / Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::mul_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueF(d, Data.floatingRegister.GetValueF(s) * Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::mul_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueD(d, Data.floatingRegister.GetValueD(s) * Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::sub_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueF(d, Data.floatingRegister.GetValueF(s) - Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::sub_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.floatingRegister.SetValueD(d, Data.floatingRegister.GetValueD(s) - Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::bclt(int d, int s, int t, int i, int h, CPUData& Data){
	if (Data.fCond[t]) Data.PC.advance_pc(i << 2); else Data.PC.advance_pc();
}

void ALUOp::bclf(int d, int s, int t, int i, int h, CPUData& Data){
	if (!Data.fCond[t]) Data.PC.advance_pc(i << 2); else Data.PC.advance_pc();
}

void ALUOp::c_eq_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueF(s) == Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::c_eq_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueD(s) == Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::c_lt_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueF(s) < Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::c_lt_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueD(s) < Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::c_le_s(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueF(s) <= Data.floatingRegister.GetValueF(t));
	Data.PC.advance_pc();
}

void ALUOp::c_le_d(int d, int s, int t, int i, int h, CPUData& Data){
	Data.fCond[d] = (Data.floatingRegister.GetValueD(s) <= Data.floatingRegister.GetValueD(t));
	Data.PC.advance_pc();
}

void ALUOp::mfc0(int d, int s, int t, int i, int h, CPUData &Data){
	Data.generalRegister[t] = Data.eIRegister[d];
	Data.PC.advance_pc();
}

void ALUOp::mfc1(int d, int s, int t, int i, int h, CPUData &Data){
	Data.generalRegister[t].FloatV = Data.floatingRegister.GetValueF(s);
	Data.PC.advance_pc();
}

void ALUOp::mtc0(int d, int s, int t, int i, int h, CPUData &Data){
	Data.eIRegister[d] = Data.generalRegister[t];
	Data.PC.advance_pc();
}

void ALUOp::mtc1(int d, int s, int t, int i, int h, CPUData &Data){
	Data.floatingRegister.SetValueF(s, Data.generalRegister[t].FloatV);
	Data.PC.advance_pc();
}