TEST_F(CoreFixture, Zip_AppendFile)
{
openstudio::path p = resourcesPath()/openstudio::toPath("utilities/Zip/test1.zip");
openstudio::path outpath = openstudio::tempDir() / openstudio::toPath("AppendFileTest");
openstudio::path outzip = outpath / openstudio::toPath("new.zip");
boost::filesystem::remove_all(outpath);
{
boost::filesystem::create_directories(outzip.parent_path());
openstudio::ZipFile zf(outzip, false);
zf.addFile(p, openstudio::toPath("added.zip"));
}
{
openstudio::ZipFile zf(outzip, true);
zf.addFile(p, openstudio::toPath("in/some/subdir/added2.zip"));
}
openstudio::UnzipFile uf(outzip);
std::vector<openstudio::path> createdFiles = uf.extractAllFiles(outpath);
ASSERT_EQ(2u, createdFiles.size());
ASSERT_TRUE(boost::filesystem::exists(createdFiles[0]));
ASSERT_TRUE(boost::filesystem::exists(createdFiles[1]));
EXPECT_EQ(boost::filesystem::file_size(p), boost::filesystem::file_size(createdFiles[0]));
EXPECT_EQ(boost::filesystem::file_size(p), boost::filesystem::file_size(createdFiles[1]));
EXPECT_EQ(outpath / openstudio::toPath("in/some/subdir/added2.zip"), createdFiles[1]);
}
bool saveOpenRaster(const QString& filename, const paintcore::LayerStack *image)
{
KZip zf(filename);
if(!zf.open(QIODevice::WriteOnly))
return false;
// The first entry of an OpenRaster file must be a
// (uncompressed) file named "mimetype".
zf.setCompression(KZip::NoCompression);
if(!zf.writeFile("mimetype", QByteArray("image/openraster")))
return false;
// The stack XML contains the image structure
// definition.
writeStackXml(zf, image);
// Each layer is written as an individual PNG image
for(int i=image->layerCount()-1;i>=0;--i)
writeLayer(zf, image, i);
// Ready to use images for viewers
writePreviewImages(zf, image);
return zf.close();
}
void doRep()
{
if (rep != 0) {
setCX(cx() - 1);
repeating = cx() != 0 && zf() != (rep == 1);
}
}
int main(int argc, char **argv)
{
plan_tests(18);
ZeroFinderTest zf(fixed(-100), fixed(100), 0);
ok1(equals(zf.find_zero(fixed(-150)), fixed(-1)));
ok1(equals(zf.find_zero(fixed(0)), fixed(-1)));
// ok1(equals(zf.find_zero(fixed(140)), fixed(2.5))); ???
ok1(equals(zf.find_zero(fixed(140)), fixed(-1)));
ok1(equals(zf.find_min(fixed(-150)), fixed(0.75)));
ok1(equals(zf.find_min(fixed(0)), fixed(0.75)));
ok1(equals(zf.find_min(fixed(150)), fixed(0.75)));
ZeroFinderTest zf2(fixed(0), fixed(100), 0);
ok1(equals(zf2.find_zero(fixed(-150)), fixed(2.5)));
ok1(equals(zf2.find_zero(fixed(0)), fixed(2.5)));
ok1(equals(zf2.find_zero(fixed(140)), fixed(2.5)));
ZeroFinderTest zf3(fixed(0), fixed(10), 1);
ok1(equals(zf3.find_zero(fixed(-150)), fixed(1.584963)));
ok1(equals(zf3.find_zero(fixed(1)), fixed(1.584963)));
ok1(equals(zf3.find_zero(fixed(140)), fixed(1.584963)));
ZeroFinderTest zf4(fixed(0), fixed_pi + fixed(1), 2);
ok1(equals(zf4.find_zero(fixed(-150)), fixed_half_pi));
ok1(equals(zf4.find_zero(fixed(1)), fixed_half_pi));
ok1(equals(zf4.find_zero(fixed(140)), fixed_half_pi));
ok1(equals(zf4.find_min(fixed(-150)), fixed_pi));
ok1(equals(zf4.find_min(fixed(1)), fixed_pi));
ok1(equals(zf4.find_min(fixed(140)), fixed_pi));
return exit_status();
}
/**
TestZoomFactor::Test
Tests attributes associated with TZoomFactor for mapping twips to pixels/device-specifc units
*/
void TestZoomFactor::Test()
{
TZoomFactor zf((MGraphicsDeviceMap*)NULL);
zf.SetZoomFactor(iZoomFactor);
iTest->TEST(zf.ZoomFactor()==iZoomFactor);
zf.SetZoomFactor(iZoomFactor*10);
iTest->TEST(zf.ZoomFactor()==iZoomFactor*10);
zf.SetZoomFactor(iZoomFactor/10);
iTest->TEST(zf.ZoomFactor()==iZoomFactor/10);
zf.SetGraphicsDeviceMap(NULL);
}
bool Cartridge::load_file(const char *fn, uint8 *&data, unsigned &size, CompressionMode compression) const {
if(file::exists(fn) == false) return false;
Reader::Type filetype = Reader::Normal;
if(compression == CompressionInspect) filetype = Reader::detect(fn, true);
if(compression == CompressionAuto) filetype = Reader::detect(fn, snes.config.file.autodetect_type);
switch(filetype) { default:
case Reader::Normal: {
FileReader ff(fn);
if(!ff.ready()) return false;
size = ff.size();
data = ff.read();
} break;
#ifdef GZIP_SUPPORT
case Reader::GZIP: {
GZReader gf(fn);
if(!gf.ready()) return false;
size = gf.size();
data = gf.read();
} break;
case Reader::ZIP: {
ZipReader zf(fn);
if(!zf.ready()) return false;
size = zf.size();
data = zf.read();
} break;
#endif
#ifdef JMA_SUPPORT
case Reader::JMA: {
try {
JMAReader jf(fn);
size = jf.size();
data = jf.read();
} catch(JMA::jma_errors jma_error) {
return false;
}
} break;
#endif
}
return true;
}
FFMS_Index::FFMS_Index(const char *IndexFile)
: RefCount(1)
{
ZipFile zf(IndexFile, "rb");
// Read the index file header
if (zf.Read<uint32_t>() != INDEXID)
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ,
std::string("'") + IndexFile + "' is not a valid index file");
if (zf.Read<uint32_t>() != FFMS_VERSION)
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ,
std::string("'") + IndexFile + "' is not the expected index version");
uint32_t Tracks = zf.Read<uint32_t>();
Decoder = zf.Read<uint32_t>();
ErrorHandling = zf.Read<uint32_t>();
if (!(Decoder & FFMS_GetEnabledSources()))
throw FFMS_Exception(FFMS_ERROR_INDEX, FFMS_ERROR_NOT_AVAILABLE,
"The source which this index was created with is not available");
if (zf.Read<uint32_t>() != avutil_version() ||
zf.Read<uint32_t>() != avformat_version() ||
zf.Read<uint32_t>() != avcodec_version() ||
zf.Read<uint32_t>() != swscale_version())
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ,
std::string("A different FFmpeg build was used to create '") + IndexFile + "'");
Filesize = zf.Read<int64_t>();
zf.Read(Digest, sizeof(Digest));
reserve(Tracks);
try {
for (size_t i = 0; i < Tracks; ++i)
push_back(FFMS_Track(zf));
}
catch (FFMS_Exception const&) {
throw;
}
catch (...) {
throw FFMS_Exception(FFMS_ERROR_PARSER, FFMS_ERROR_FILE_READ,
std::string("Unknown error while reading index information in '") + IndexFile + "'");
}
}
void FFMS_Index::WriteIndex(const char *IndexFile) {
ZipFile zf(IndexFile, "wb");
// Write the index file header
zf.Write<uint32_t>(INDEXID);
zf.Write<uint32_t>(FFMS_VERSION);
zf.Write<uint32_t>(size());
zf.Write<uint32_t>(Decoder);
zf.Write<uint32_t>(ErrorHandling);
zf.Write<uint32_t>(avutil_version());
zf.Write<uint32_t>(avformat_version());
zf.Write<uint32_t>(avcodec_version());
zf.Write<uint32_t>(swscale_version());
zf.Write<int64_t>(Filesize);
zf.Write(Digest);
for (size_t i = 0; i < size(); ++i)
at(i).Write(zf);
zf.Finish();
}
int main(int argc, TCHAR **argv) {
// _tprintf(_T("sizeof(long double):%s\n"), FSZ(sizeof(long double)));
// _tprintf(_T("sizeof(Double80:%s\n"), FSZ(sizeof(Double80)));
unsigned __int64 ui64max = _UI64_MAX;
Double80 dui64 = ui64max;
unsigned __int64 rui64 = getUint64(dui64);
for (;;) {
double x = inputDouble(_T("Enter x:"));
// double y = inputDouble(_T("Enter y:"));
Double80 x80 = x; // , y80 = y;
// Double80 z80 = pow(x80, y80);
Double80 z80 = exp2(x80);
double z64 = getDouble(z80);
_tprintf(_T("exp2(%lg)=%le\n"), x, z64);
}
Double80 x;
Double80 y;
unsigned long l1 = 1;
x = 1;
y = 2.3;
Double80 z = x + y;
double z64 = getDouble(z);
_tprintf(_T("x+y:%le\n"), z64);
x = 9.7;
y = 4;
z = fmod(x, y);
z64 = getDouble(z);
x = M_PI;
x *= 2;
x /= 3;
double x64 = getDouble(x);
Double80 c = x, s;
sincos(c, s);
double c64 = getDouble(c);
double s64 = getDouble(s);
z = cos(x);
z64 = getDouble(z);
double e10 = 9.999e20;
Double80 d1080 = e10;
int expo10 = Double80::getExpo10(d1080);
Double80 exp80 = exp(z);
double exp64 = getDouble(exp80);
const long maxi32 = 0x7fffffff;
Double80 zi32(maxi32);
const long i32_1 = getInt(zi32);
const unsigned long ui32_a1 = maxi32;
Double80 dui32_a(ui32_a1);
const unsigned long ui32_a2 = getUint(dui32_a);
const unsigned long ui32_b1 = (unsigned long)maxi32 + 1;
Double80 dui32_b(ui32_b1);
const unsigned long ui32_b2 = getUint(dui32_b);
const __int64 maxi64 = 0x7fffffffffffffffui64;
Double80 di64(maxi64);
const __int64 i64_1 = getInt64(di64);
const unsigned __int64 ui64_a1 = maxi64;
Double80 dui64_a(ui64_a1);
const unsigned __int64 ui64_a2 = getUint64(dui64_a);
const unsigned __int64 ui64_b1 = (unsigned __int64)maxi64 + 1;
Double80 dui64_b(ui64_b1);
const unsigned __int64 ui64_b2 = getUint64(dui64_b);
const float f1 = 1.23456f;
Double80 zf(f1);
const float f2 = getFloat(zf);
return 0;
}
void calcx(FILE *fl,float freq,int z){
int i;
for(i=0;i<N*range;i++){
x[i]=xf(i,freq)+zf(i)*z;
fprintf(fl,"%d %e\n",i,x[i]);}}
int main(int argc, char* argv[])
{
if (argc < 2) {
printf("Usage: %s <program name>\n", argv[0]);
exit(0);
}
filename = argv[1];
FILE* fp = fopen(filename, "rb");
if (fp == 0)
error("opening");
ram = (Byte*)malloc(0x10000);
memset(ram, 0, 0x10000);
if (ram == 0) {
fprintf(stderr, "Out of memory\n");
exit(1);
}
if (fseek(fp, 0, SEEK_END) != 0)
error("seeking");
length = ftell(fp);
if (length == -1)
error("telling");
if (fseek(fp, 0, SEEK_SET) != 0)
error("seeking");
if (length > 0x10000 - 0x100) {
fprintf(stderr, "%s is too long to be a .com file\n", filename);
exit(1);
}
if (fread(&ram[0x100], length, 1, fp) != 1)
error("reading");
fclose(fp);
Word segment = 0x1000;
setAX(0x0000);
setCX(0x00FF);
setDX(segment);
registers[3] = 0x0000;
setSP(0xFFFE);
registers[5] = 0x091C;
setSI(0x0100);
setDI(0xFFFE);
for (int i = 0; i < 4; ++i)
registers[8 + i] = segment;
Byte* byteData = (Byte*)®isters[0];
int bigEndian = (byteData[2] == 0 ? 1 : 0);
int byteNumbers[8] = {0, 2, 4, 6, 1, 3, 5, 7};
for (int i = 0 ; i < 8; ++i)
byteRegisters[i] = &byteData[byteNumbers[i] ^ bigEndian];
bool prefix = false;
for (int i = 0; i < 1000000000; ++i) {
if (!repeating) {
if (!prefix) {
segmentOverride = -1;
rep = 0;
}
prefix = false;
opcode = fetchByte();
}
wordSize = ((opcode & 1) != 0);
bool sourceIsRM = ((opcode & 2) != 0);
int operation = (opcode >> 3) & 7;
bool jump;
switch (opcode) {
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x08: case 0x09: case 0x0a: case 0x0b:
case 0x10: case 0x11: case 0x12: case 0x13:
case 0x18: case 0x19: case 0x1a: case 0x1b:
case 0x20: case 0x21: case 0x22: case 0x23:
case 0x28: case 0x29: case 0x2a: case 0x2b:
case 0x30: case 0x31: case 0x32: case 0x33:
case 0x38: case 0x39: case 0x3a: case 0x3b: // alu rmv,rmv
data = readEA();
if (!sourceIsRM) {
destination = data;
source = getReg();
}
else {
destination = getReg();
source = data;
}
aluOperation = operation;
doALUOperation();
if (aluOperation != 7) {
if (!sourceIsRM)
finishWriteEA(data);
else
setReg(data);
}
break;
case 0x04: case 0x05: case 0x0c: case 0x0d:
case 0x14: case 0x15: case 0x1c: case 0x1d:
case 0x24: case 0x25: case 0x2c: case 0x2d:
case 0x34: case 0x35: case 0x3c: case 0x3d: // alu accum,i
destination = getAccum();
source = !wordSize ? fetchByte() : fetchWord();
aluOperation = operation;
doALUOperation();
if (aluOperation != 7)
setAccum();
break;
case 0x06: case 0x0e: case 0x16: case 0x1e: // PUSH segreg
push(registers[operation + 8]);
break;
case 0x07: case 0x17: case 0x1f: // POP segreg
registers[operation + 8] = pop();
break;
case 0x26: case 0x2e: case 0x36: case 0x3e: // segment override
segmentOverride = operation;
prefix = true;
break;
case 0x27: case 0x2f: // DA
if (af() || (al() & 0x0f) > 9) {
data = al() + (opcode == 0x27 ? 6 : -6);
setAL(data);
setAF(true);
if ((data & 0x100) != 0)
setCF(true);
}
setCF(cf() || al() > 0x9f);
if (cf())
setAL(al() + (opcode == 0x27 ? 0x60 : -0x60));
wordSize = false;
data = al();
setPZS();
break;
case 0x37: case 0x3f: // AA
if (af() || (al() & 0xf) > 9) {
setAL(al() + (opcode == 0x37 ? 6 : -6));
setAH(ah() + (opcode == 0x37 ? 1 : -1));
setCA();
}
else
clearCA();
setAL(al() & 0x0f);
break;
case 0x40: case 0x41: case 0x42: case 0x43:
case 0x44: case 0x45: case 0x46: case 0x47:
case 0x48: case 0x49: case 0x4a: case 0x4b:
case 0x4c: case 0x4d: case 0x4e: case 0x4f: // incdec rw
destination = rw();
wordSize = true;
setRW(incdec((opcode & 8) != 0));
break;
case 0x50: case 0x51: case 0x52: case 0x53:
case 0x54: case 0x55: case 0x56: case 0x57: // PUSH rw
push(rw());
break;
case 0x58: case 0x59: case 0x5a: case 0x5b:
case 0x5c: case 0x5d: case 0x5e: case 0x5f: // POP rw
setRW(pop());
break;
case 0x60: case 0x61: case 0x62: case 0x63:
case 0x64: case 0x65: case 0x66: case 0x67:
case 0x68: case 0x69: case 0x6a: case 0x6b:
case 0x6c: case 0x6d: case 0x6e: case 0x6f:
case 0xc0: case 0xc1: case 0xc8: case 0xc9: // invalid
case 0xcc: case 0xf0: case 0xf1: case 0xf4: // INT 3, LOCK, HLT
case 0x9b: case 0xce: case 0x0f: // WAIT, INTO, POP CS
case 0xd8: case 0xd9: case 0xda: case 0xdb:
case 0xdc: case 0xdd: case 0xde: case 0xdf: // escape
case 0xe4: case 0xe5: case 0xe6: case 0xe7:
case 0xec: case 0xed: case 0xee: case 0xef: // IN, OUT
fprintf(stderr, "Invalid opcode %02x", opcode);
runtimeError("");
break;
case 0x70: case 0x71: case 0x72: case 0x73:
case 0x74: case 0x75: case 0x76: case 0x77:
case 0x78: case 0x79: case 0x7a: case 0x7b:
case 0x7c: case 0x7d: case 0x7e: case 0x7f: // Jcond cb
switch (opcode & 0x0e) {
case 0x00: jump = of(); break;
case 0x02: jump = cf(); break;
case 0x04: jump = zf(); break;
case 0x06: jump = cf() || zf(); break;
case 0x08: jump = sf(); break;
case 0x0a: jump = pf(); break;
case 0x0c: jump = sf() != of(); break;
default: jump = sf() != of() || zf(); break;
}
jumpShort(fetchByte(), jump == ((opcode & 1) == 0));
break;
case 0x80: case 0x81: case 0x82: case 0x83: // alu rmv,iv
destination = readEA();
data = fetch(opcode == 0x81);
if (opcode != 0x83)
source = data;
else
source = signExtend(data);
aluOperation = modRMReg();
doALUOperation();
if (aluOperation != 7)
finishWriteEA(data);
break;
case 0x84: case 0x85: // TEST rmv,rv
data = readEA();
test(data, getReg());
break;
case 0x86: case 0x87: // XCHG rmv,rv
data = readEA();
finishWriteEA(getReg());
setReg(data);
break;
case 0x88: case 0x89: // MOV rmv,rv
ea();
finishWriteEA(getReg());
break;
case 0x8a: case 0x8b: // MOV rv,rmv
setReg(readEA());
break;
case 0x8c: // MOV rmw,segreg
ea();
wordSize = 1;
finishWriteEA(registers[modRMReg() + 8]);
break;
case 0x8d: // LEA
address = ea();
if (!useMemory)
runtimeError("LEA needs a memory address");
setReg(address);
break;
case 0x8e: // MOV segreg,rmw
wordSize = 1;
data = readEA();
registers[modRMReg() + 8] = data;
break;
case 0x8f: // POP rmw
writeEA(pop());
break;
case 0x90: case 0x91: case 0x92: case 0x93:
case 0x94: case 0x95: case 0x96: case 0x97: // XCHG AX,rw
data = ax();
setAX(rw());
setRW(data);
break;
case 0x98: // CBW
setAX(signExtend(al()));
break;
case 0x99: // CWD
setDX((ax() & 0x8000) == 0 ? 0x0000 : 0xffff);
break;
case 0x9a: // CALL cp
savedIP = fetchWord();
savedCS = fetchWord();
farCall();
break;
case 0x9c: // PUSHF
push((flags & 0x0fd7) | 0xf000);
break;
case 0x9d: // POPF
flags = pop() | 2;
break;
case 0x9e: // SAHF
flags = (flags & 0xff02) | ah();
break;
case 0x9f: // LAHF
setAH(flags & 0xd7);
break;
case 0xa0: case 0xa1: // MOV accum,xv
data = read(fetchWord());
setAccum();
break;
case 0xa2: case 0xa3: // MOV xv,accum
write(getAccum(), fetchWord());
break;
case 0xa4: case 0xa5: // MOVSv
stoS(lodS());
doRep();
break;
case 0xa6: case 0xa7: // CMPSv
lodDIS();
source = data;
sub();
doRep();
break;
case 0xa8: case 0xa9: // TEST accum,iv
data = fetch(wordSize);
test(getAccum(), data);
break;
case 0xaa: case 0xab: // STOSv
stoS(getAccum());
doRep();
break;
case 0xac: case 0xad: // LODSv
data = lodS();
setAccum();
doRep();
break;
case 0xae: case 0xaf: // SCASv
lodDIS();
destination = getAccum();
source = data;
sub();
doRep();
break;
case 0xb0: case 0xb1: case 0xb2: case 0xb3:
case 0xb4: case 0xb5: case 0xb6: case 0xb7:
setRB(fetchByte());
break;
case 0xb8: case 0xb9: case 0xba: case 0xbb:
case 0xbc: case 0xbd: case 0xbe: case 0xbf: // MOV rv,iv
setRW(fetchWord());
break;
case 0xc2: case 0xc3: case 0xca: case 0xcb: // RET
savedIP = pop();
savedCS = (opcode & 8) == 0 ? cs() : pop();
if (!wordSize)
setSP(sp() + fetchWord());
farJump();
break;
case 0xc4: case 0xc5: // LES/LDS
ea();
farLoad();
*modRMRW() = savedIP;
registers[8 + (!wordSize ? 0 : 3)] = savedCS;
break;
case 0xc6: case 0xc7: // MOV rmv,iv
ea();
finishWriteEA(fetch(wordSize));
break;
case 0xcd:
data = fetchByte();
if (data != 0x21) {
fprintf(stderr, "Unknown interrupt 0x%02x", data);
runtimeError("");
}
switch (ah()) {
case 2:
printf("%c", dl());
break;
case 0x4c:
printf("*** Bytes: %i\n", length);
printf("*** Cycles: %i\n", ios);
printf("*** EXIT code %i\n", al());
exit(0);
break;
default:
fprintf(stderr, "Unknown DOS call 0x%02x", data);
runtimeError("");
}
break;
case 0xcf:
ip = pop();
setCS(pop());
flags = pop() | 2;
break;
case 0xd0: case 0xd1: case 0xd2: case 0xd3: // rot rmv,n
data = readEA();
if ((opcode & 2) == 0)
source = 1;
else
source = cl();
while (source != 0) {
destination = data;
switch (modRMReg()) {
case 0: // ROL
data <<= 1;
doCF();
data |= (cf() ? 1 : 0);
setOFRotate();
break;
case 1: // ROR
setCF((data & 1) != 0);
data >>= 1;
if (cf())
data |= (!wordSize ? 0x80 : 0x8000);
setOFRotate();
break;
case 2: // RCL
data = (data << 1) | (cf() ? 1 : 0);
doCF();
setOFRotate();
break;
case 3: // RCR
data >>= 1;
if (cf())
data |= (!wordSize ? 0x80 : 0x8000);
setCF((destination & 1) != 0);
setOFRotate();
break;
case 4: // SHL
case 6:
data <<= 1;
doCF();
setOFRotate();
setPZS();
break;
case 5: // SHR
setCF((data & 1) != 0);
data >>= 1;
setOFRotate();
setAF(true);
setPZS();
break;
case 7: // SAR
setCF((data & 1) != 0);
data >>= 1;
if (!wordSize)
data |= (destination & 0x80);
else
data |= (destination & 0x8000);
setOFRotate();
setAF(true);
setPZS();
break;
}
--source;
}
finishWriteEA(data);
break;
case 0xd4: // AAM
data = fetchByte();
if (data == 0)
divideOverflow();
setAH(al() / data);
setAL(al() % data);
wordSize = true;
setPZS();
break;
case 0xd5: // AAD
data = fetchByte();
setAL(al() + ah()*data);
setAH(0);
setPZS();
break;
case 0xd6: // SALC
setAL(cf() ? 0xff : 0x00);
break;
case 0xd7: // XLATB
setAL(readByte(bx() + al()));
break;
case 0xe0: case 0xe1: case 0xe2: // LOOPc cb
setCX(cx() - 1);
jump = (cx() != 0);
switch (opcode) {
case 0xe0: if (zf()) jump = false; break;
case 0xe1: if (!zf()) jump = false; break;
}
jumpShort(fetchByte(), jump);
break;
case 0xe3: // JCXZ cb
jumpShort(fetchByte(), cx() == 0);
break;
case 0xe8: // CALL cw
call(ip + fetchWord());
break;
case 0xe9: // JMP cw
ip += fetchWord();
break;
case 0xea: // JMP cp
savedIP = fetchWord();
savedCS = fetchWord();
farJump();
break;
case 0xeb: // JMP cb
jumpShort(fetchByte(), true);
break;
case 0xf2: case 0xf3: // REP
rep = opcode == 0xf2 ? 1 : 2;
prefix = true;
break;
case 0xf5: // CMC
flags ^= 1;
break;
case 0xf6: case 0xf7: // math rmv
data = readEA();
switch (modRMReg()) {
case 0: case 1: // TEST rmv,iv
test(data, fetch(wordSize));
break;
case 2: // NOT iv
finishWriteEA(~data);
break;
case 3: // NEG iv
source = data;
destination = 0;
sub();
finishWriteEA(data);
break;
case 4: case 5: // MUL rmv, IMUL rmv
source = data;
destination = getAccum();
data = destination;
setSF();
setPF();
data *= source;
setAX(data);
if (!wordSize) {
if (modRMReg() == 4)
setCF(ah() != 0);
else {
if ((source & 0x80) != 0)
setAH(ah() - destination);
if ((destination & 0x80) != 0)
setAH(ah() - source);
setCF(ah() ==
((al() & 0x80) == 0 ? 0 : 0xff));
}
}
else {
setDX(data >> 16);
if (modRMReg() == 4) {
data |= dx();
setCF(dx() != 0);
}
else {
if ((source & 0x8000) != 0)
setDX(dx() - destination);
if ((destination & 0x8000) != 0)
setDX(dx() - source);
data |= dx();
setCF(dx() ==
((ax() & 0x8000) == 0 ? 0 : 0xffff));
}
}
setZF();
setOF(cf());
break;
case 6: case 7: // DIV rmv, IDIV rmv
source = data;
if (source == 0)
divideOverflow();
if (!wordSize) {
destination = ax();
if (modRMReg() == 6) {
div();
if (data > 0xff)
divideOverflow();
}
else {
destination = ax();
if ((destination & 0x8000) != 0)
destination |= 0xffff0000;
source = signExtend(source);
div();
if (data > 0x7f && data < 0xffffff80)
divideOverflow();
}
setAH(remainder);
setAL(data);
}
else {
destination = (dx() << 16) + ax();
div();
if (modRMReg() == 6) {
if (data > 0xffff)
divideOverflow();
}
else {
if (data > 0x7fff && data < 0xffff8000)
divideOverflow();
}
setDX(remainder);
setAX(data);
}
break;
}
break;
case 0xf8: case 0xf9: // STC/CLC
setCF(wordSize);
break;
case 0xfa: case 0xfb: // STI/CLI
setIF(wordSize);
break;
case 0xfc: case 0xfd: // STD/CLD
setDF(wordSize);
break;
case 0xfe: case 0xff: // misc
ea();
if ((!wordSize && modRMReg() >= 2 && modRMReg() <= 6) ||
modRMReg() == 7) {
fprintf(stderr, "Invalid instruction %02x %02x", opcode,
modRM);
runtimeError("");
}
switch (modRMReg()) {
case 0: case 1: // incdec rmv
destination = readEA2();
finishWriteEA(incdec(modRMReg() != 0));
break;
case 2: // CALL rmv
call(readEA2());
break;
case 3: // CALL mp
farLoad();
farCall();
break;
case 4: // JMP rmw
ip = readEA2();
break;
case 5: // JMP mp
farLoad();
farJump();
break;
case 6: // PUSH rmw
push(readEA2());
break;
}
break;
}
}
runtimeError("Timed out");
}