////////////////////////////////////////////////////////////////////////////
// Function: Load the document from memory encoded bytes.
////////////////////////////////////////////////////////////////////////////
HRESULT CXMLDocument::LoadFromMemory(PBYTE pData, ULONG ulLen)
{
// Create a stream and write the bytes to it
IStreamPtr pStream = NULL;
HRESULT hr = ::CreateStreamOnHGlobal(NULL, true/*fDeleteOnRelease*/, &pStream);
hr = CheckHR(hr, "load from memory");
ULONG ulWritten;
pStream->Write(pData, ulLen, &ulWritten);
// Reset the stream back to the beginning
LARGE_INTEGER li = {0, 0};
hr = pStream->Seek(li, STREAM_SEEK_SET, NULL);
hr = CheckHR(hr, "in load from memory seek");
// Now, load the document from the stream
IPersistStreamInitPtr pPSI = m_pDoc;
if (pPSI == NULL)
return E_FAIL;
hr = pPSI->Load(pStream);
hr = CheckHR(hr, "load from memory load");
hr = CheckLoad();
return hr;
}
////////////////////////////////////////////////////////////////////////////
// Function: Load an XML document from a given stream object
////////////////////////////////////////////////////////////////////////////
HRESULT CXMLDocument::LoadStream(CString strFileName)
{
HRESULT hr = S_OK;
// Create an IStream object for reading the specified URL.
char szURL[MAX_PATH];
if (!strncmp(strFileName, "http:", 5))
strcpy(szURL, strFileName);
else
::GetFullPathNameA(strFileName, MAX_PATH, szURL, NULL);
IStreamPtr pStream = NULL;
hr = ::URLOpenBlockingStreamA(0, szURL, &pStream, 0, 0);
hr = CheckHR(hr, "in load stream: URLOpenBlockingStreamA");
IPersistStreamInitPtr pPSI = m_pDoc;
if (pPSI == NULL)
return E_FAIL;
hr = pPSI->Load(pStream);
hr = CheckHR(hr, "in load stream");
// Since we don't know whether this was a URLStream or not.
WaitForCompletion();
hr = CheckLoad();
return hr;
}
// Test Autonomous
void Autonomous()
{
robotDrive.SetSafetyEnabled(false);
// STEP 1: Set all of the states.
// SAFETY AND SANITY - SET ALL TO ZERO
loaded = winchSwitch.Get();
loading = false;
intake.Set(0.0);
rightWinch.Set(0.0);
leftWinch.Set(0.0);
// STEP 2: Move forward to optimum shooting position
Drive(-AUTO_DRIVE_SPEED, SHOT_POSN_DIST);
// STEP 3: Drop the arm for a clean shot
arm.Set(DoubleSolenoid::kForward);
Wait(1.0); // Ken
// STEP 4: Launch the catapult
LaunchCatapult();
Wait (1.0); // Ken
if (ds->GetDigitalIn(1))
{
// STEP 5: Start the intake motor and backup to our origin position to pick up another ball
InitiateLoad();
intake.Set(-INTAKE_COLLECT);
while (CheckLoad());
Drive(AUTO_DRIVE_SPEED, SHOT_POSN_DIST);
Wait(1.0); // For the ball to collect
// STEP 6: Shut off the intake, bring up the arm and move to shooting position
intake.Set(0.0);
arm.Set(DoubleSolenoid::kReverse);
Wait (1.0); // "Settle down"
Drive(-AUTO_DRIVE_SPEED, SHOT_POSN_DIST);
// Step 7: drop the arm for a clean shot and shoot
arm.Set(DoubleSolenoid::kForward);
Drive(AUTO_DRIVE_SPEED, SHOT_POSN_DIST);
// UNTESTED KICKED OFF FIELD
Wait(1.0); // For arm to go down
LaunchCatapult();
}
// Get us fully into the zone for 5 points
Drive(-AUTO_DRIVE_SPEED, INTO_ZONE_DIST - SHOT_POSN_DIST);
// SAFETY AND SANITY - SET ALL TO ZERO
intake.Set(0.0);
rightWinch.Set(0.0);
leftWinch.Set(0.0);
}
HRESULT CXMLDocument::LoadString(CString strXML)
{
HRESULT hr = S_OK;
VARIANT_BOOL vbIsSuccessful = false;
hr = m_pDoc->put_validateOnParse(VARIANT_TRUE);
hr = m_pDoc->loadXML(CComBSTR(strXML), &vbIsSuccessful);
hr = CheckHR(hr, "in load");
hr = CheckLoad();
return hr;
}
// HandleShooter
// * Manage winch motor state.
// * Toggles collection and eject mode (Gamepad button 4)
// ----> ASSUMES positive values = collecting
void HandleShooter()
{
if (gamepad.GetEvent(BUTTON_LOAD) == kEventClosed)
{
InitiateLoad();
}
if (loading)
{
CheckLoad();
}
if (gamepad.GetEvent(BUTTON_SHOOT) == kEventClosed)
{
LaunchCatapult();
}
}
////////////////////////////////////////////////////////////////////////////
// Function: Load an XML Document from the specified file or URL synchronously.
////////////////////////////////////////////////////////////////////////////
HRESULT CXMLDocument::Load(CString strURLFileName, bool bAsync)
{
// set asynchronous loading flag
HRESULT hr = m_pDoc->put_async(bAsync ? VARIANT_TRUE : VARIANT_FALSE);
hr = CheckHR(hr, "in load: put_async");
// Load xml document from the given URL or file path
VARIANT_BOOL vbIsSuccessful = false;
hr = m_pDoc->load(CComVariant(strURLFileName), &vbIsSuccessful);
hr = CheckHR(hr, "in load");
// Now wait for download to complete!
if (bAsync)
WaitForCompletion();
hr = CheckLoad();
return hr;
}
void EmulOp(M68kRegisters *r, uint32 pc, int selector)
{
D(bug("EmulOp %04x at %08x\n", selector, pc));
switch (selector) {
case OP_BREAK: // Breakpoint
printf("*** Breakpoint\n");
Dump68kRegs(r);
break;
case OP_XPRAM1: { // Read/write from/to XPRam
uint32 len = r->d[3];
uint8 *adr = Mac2HostAddr(r->a[3]);
D(bug("XPRAMReadWrite d3: %08lx, a3: %p\n", len, adr));
int ofs = len & 0xffff;
len >>= 16;
if (len & 0x8000) {
len &= 0x7fff;
for (uint32 i=0; i<len; i++)
XPRAM[((ofs + i) & 0xff) + 0x1300] = *adr++;
} else {
for (uint32 i=0; i<len; i++)
*adr++ = XPRAM[((ofs + i) & 0xff) + 0x1300];
}
break;
}
case OP_XPRAM2: // Read from XPRam
r->d[1] = XPRAM[(r->d[1] & 0xff) + 0x1300];
break;
case OP_XPRAM3: // Write to XPRam
XPRAM[(r->d[1] & 0xff) + 0x1300] = r->d[2];
break;
case OP_NVRAM1: { // Read from NVRAM
int ofs = r->d[0];
r->d[0] = XPRAM[ofs & 0x1fff];
bool localtalk = !(XPRAM[0x13e0] || XPRAM[0x13e1]); // LocalTalk enabled?
switch (ofs) {
case 0x13e0: // Disable LocalTalk (use EtherTalk instead)
if (localtalk)
r->d[0] = 0x00;
break;
case 0x13e1:
if (localtalk)
r->d[0] = 0x01;
break;
case 0x13e2:
if (localtalk)
r->d[0] = 0x00;
break;
case 0x13e3:
if (localtalk)
r->d[0] = 0x0a;
break;
}
break;
}
case OP_NVRAM2: // Write to NVRAM
XPRAM[r->d[0] & 0x1fff] = r->d[1];
break;
case OP_NVRAM3: // Read/write from/to NVRAM
if (r->d[3]) {
r->d[0] = XPRAM[(r->d[4] + 0x1300) & 0x1fff];
} else {
XPRAM[(r->d[4] + 0x1300) & 0x1fff] = r->d[5];
r->d[0] = 0;
}
break;
case OP_FIX_MEMTOP: // Fixes MemTop in BootGlobs during startup
D(bug("Fix MemTop\n"));
WriteMacInt32(BootGlobsAddr - 20, RAMBase + RAMSize); // MemTop
r->a[6] = RAMBase + RAMSize;
break;
case OP_FIX_MEMSIZE: { // Fixes physical/logical RAM size during startup
D(bug("Fix MemSize\n"));
uint32 diff = ReadMacInt32(0x1ef8) - ReadMacInt32(0x1ef4);
WriteMacInt32(0x1ef8, RAMSize); // Physical RAM size
WriteMacInt32(0x1ef4, RAMSize - diff); // Logical RAM size
break;
}
case OP_FIX_BOOTSTACK: // Fixes boot stack pointer in boot 3 resource
D(bug("Fix BootStack\n"));
r->a[1] = r->a[7] = RAMBase + RAMSize * 3 / 4;
break;
case OP_SONY_OPEN: // Floppy driver functions
r->d[0] = SonyOpen(r->a[0], r->a[1]);
break;
case OP_SONY_PRIME:
r->d[0] = SonyPrime(r->a[0], r->a[1]);
break;
case OP_SONY_CONTROL:
r->d[0] = SonyControl(r->a[0], r->a[1]);
break;
case OP_SONY_STATUS:
r->d[0] = SonyStatus(r->a[0], r->a[1]);
break;
case OP_DISK_OPEN: // Disk driver functions
r->d[0] = DiskOpen(r->a[0], r->a[1]);
break;
case OP_DISK_PRIME:
r->d[0] = DiskPrime(r->a[0], r->a[1]);
break;
case OP_DISK_CONTROL:
r->d[0] = DiskControl(r->a[0], r->a[1]);
break;
case OP_DISK_STATUS:
r->d[0] = DiskStatus(r->a[0], r->a[1]);
break;
case OP_CDROM_OPEN: // CD-ROM driver functions
r->d[0] = CDROMOpen(r->a[0], r->a[1]);
break;
case OP_CDROM_PRIME:
r->d[0] = CDROMPrime(r->a[0], r->a[1]);
break;
case OP_CDROM_CONTROL:
r->d[0] = CDROMControl(r->a[0], r->a[1]);
break;
case OP_CDROM_STATUS:
r->d[0] = CDROMStatus(r->a[0], r->a[1]);
break;
case OP_AUDIO_DISPATCH: // Audio component functions
r->d[0] = gMacAudio->Dispatch(r->a[3], r->a[4]);
break;
case OP_SOUNDIN_OPEN: // Sound input driver functions
r->d[0] = gMacAudio->InOpen(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_PRIME:
r->d[0] = gMacAudio->InPrime(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_CONTROL:
r->d[0] = gMacAudio->InControl(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_STATUS:
r->d[0] = gMacAudio->InStatus(r->a[0], r->a[1]);
break;
case OP_SOUNDIN_CLOSE:
r->d[0] = gMacAudio->InClose(r->a[0], r->a[1]);
break;
case OP_ADBOP: // ADBOp() replacement
gADBInput->Op(r->d[0], Mac2HostAddr(ReadMacInt32(r->a[0])));
break;
case OP_INSTIME: // InsTime() replacement
r->d[0] = InsTime(r->a[0], r->d[1]);
break;
case OP_RMVTIME: // RmvTime() replacement
r->d[0] = RmvTime(r->a[0]);
break;
case OP_PRIMETIME: // PrimeTime() replacement
r->d[0] = PrimeTime(r->a[0], r->d[0]);
break;
case OP_MICROSECONDS: // Microseconds() replacement
Microseconds(r->a[0], r->d[0]);
break;
case OP_PUT_SCRAP: // PutScrap() patch
PutScrap(ReadMacInt32(r->a[7] + 8), Mac2HostAddr(ReadMacInt32(r->a[7] + 4)), ReadMacInt32(r->a[7] + 12));
break;
case OP_GET_SCRAP: // GetScrap() patch
GetScrap((void **)Mac2HostAddr(ReadMacInt32(r->a[7] + 4)), ReadMacInt32(r->a[7] + 8), ReadMacInt32(r->a[7] + 12));
break;
case OP_DEBUG_STR: // DebugStr() shows warning message
if (PrefsFindBool("nogui")) {
uint8 *pstr = Mac2HostAddr(ReadMacInt32(r->a[7] + 4));
char str[256];
int i;
for (i=0; i<pstr[0]; i++)
str[i] = pstr[i+1];
str[i] = 0;
WarningAlert(str);
}
break;
case OP_INSTALL_DRIVERS: { // Patch to install our own drivers during startup
// Install drivers
InstallDrivers();
// Patch MakeExecutable()
MakeExecutableTvec = FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable");
D(bug("MakeExecutable TVECT at %08x\n", MakeExecutableTvec));
WriteMacInt32(MakeExecutableTvec, NativeFunction(NATIVE_MAKE_EXECUTABLE));
#if defined(__powerpc__) /* Native PowerPC */
WriteMacInt32(MakeExecutableTvec + 4, (uint32)TOC);
#endif
// Patch DebugStr()
static const uint8 proc_template[] = {
M68K_EMUL_OP_DEBUG_STR >> 8, M68K_EMUL_OP_DEBUG_STR & 0xFF,
0x4e, 0x74, // rtd #4
0x00, 0x04
};
BUILD_SHEEPSHAVER_PROCEDURE(proc);
WriteMacInt32(0x1dfc, proc);
break;
}
case OP_NAME_REGISTRY: // Patch Name Registry and initialize CallUniversalProc
r->d[0] = (uint32)-1;
PatchNameRegistry();
InitCallUniversalProc();
break;
case OP_RESET: // Early in MacOS reset
D(bug("*** RESET ***\n"));
TimerReset();
MacOSUtilReset();
gMacAudio->Reset();
// Enable DR emulator (disabled for now)
if (PrefsFindBool("jit68k") && 0) {
D(bug("DR activated\n"));
WriteMacInt32(KernelDataAddr + 0x17a0, 3); // Prepare for DR emulator activation
WriteMacInt32(KernelDataAddr + 0x17c0, DR_CACHE_BASE);
WriteMacInt32(KernelDataAddr + 0x17c4, DR_CACHE_SIZE);
WriteMacInt32(KernelDataAddr + 0x1b04, DR_CACHE_BASE);
WriteMacInt32(KernelDataAddr + 0x1b00, DR_EMULATOR_BASE);
memcpy((void *)DR_EMULATOR_BASE, (void *)(ROMBase + 0x370000), DR_EMULATOR_SIZE);
MakeExecutable(0, DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
}
break;
case OP_IRQ: // Level 1 interrupt
WriteMacInt16(ReadMacInt32(KernelDataAddr + 0x67c), 0); // Clear interrupt
r->d[0] = 0;
if (HasMacStarted()) {
if (InterruptFlags & INTFLAG_VIA) {
ClearInterruptFlag(INTFLAG_VIA);
#if !PRECISE_TIMING
TimerInterrupt();
#endif
ExecuteNative(NATIVE_VIDEO_VBL);
static int tick_counter = 0;
if (++tick_counter >= 60) {
tick_counter = 0;
SonyInterrupt();
DiskInterrupt();
CDROMInterrupt();
}
r->d[0] = 1; // Flag: 68k interrupt routine executes VBLTasks etc.
}
if (InterruptFlags & INTFLAG_SERIAL) {
ClearInterruptFlag(INTFLAG_SERIAL);
SerialInterrupt();
}
if (InterruptFlags & INTFLAG_ETHER) {
ClearInterruptFlag(INTFLAG_ETHER);
ExecuteNative(NATIVE_ETHER_IRQ);
}
if (InterruptFlags & INTFLAG_TIMER) {
ClearInterruptFlag(INTFLAG_TIMER);
TimerInterrupt();
}
if (InterruptFlags & INTFLAG_AUDIO) {
ClearInterruptFlag(INTFLAG_AUDIO);
gMacAudio->Interrupt();
}
if (InterruptFlags & INTFLAG_ADB) {
ClearInterruptFlag(INTFLAG_ADB);
gADBInput->Interrupt();
}
} else
r->d[0] = 1;
break;
case OP_SCSI_DISPATCH: { // SCSIDispatch() replacement
uint32 ret = ReadMacInt32(r->a[7]);
uint16 sel = ReadMacInt16(r->a[7] + 4);
r->a[7] += 6;
// D(bug("SCSIDispatch(%d)\n", sel));
int stack;
switch (sel) {
case 0: // SCSIReset
WriteMacInt16(r->a[7], SCSIReset());
stack = 0;
break;
case 1: // SCSIGet
WriteMacInt16(r->a[7], SCSIGet());
stack = 0;
break;
case 2: // SCSISelect
case 11: // SCSISelAtn
WriteMacInt16(r->a[7] + 2, SCSISelect(ReadMacInt8(r->a[7] + 1)));
stack = 2;
break;
case 3: // SCSICmd
WriteMacInt16(r->a[7] + 6, SCSICmd(ReadMacInt16(r->a[7]), Mac2HostAddr(ReadMacInt32(r->a[7] + 2))));
stack = 6;
break;
case 4: // SCSIComplete
WriteMacInt16(r->a[7] + 12, SCSIComplete(ReadMacInt32(r->a[7]), ReadMacInt32(r->a[7] + 4), ReadMacInt32(r->a[7] + 8)));
stack = 12;
break;
case 5: // SCSIRead
case 8: // SCSIRBlind
WriteMacInt16(r->a[7] + 4, SCSIRead(ReadMacInt32(r->a[7])));
stack = 4;
break;
case 6: // SCSIWrite
case 9: // SCSIWBlind
WriteMacInt16(r->a[7] + 4, SCSIWrite(ReadMacInt32(r->a[7])));
stack = 4;
break;
case 10: // SCSIStat
WriteMacInt16(r->a[7], SCSIStat());
stack = 0;
break;
case 12: // SCSIMsgIn
WriteMacInt16(r->a[7] + 4, 0);
stack = 4;
break;
case 13: // SCSIMsgOut
WriteMacInt16(r->a[7] + 2, 0);
stack = 2;
break;
case 14: // SCSIMgrBusy
WriteMacInt16(r->a[7], SCSIMgrBusy());
stack = 0;
break;
default:
printf("FATAL: SCSIDispatch: illegal selector\n");
stack = 0;
//!! SysError(12)
}
r->a[0] = ret;
r->a[7] += stack;
break;
}
case OP_SCSI_ATOMIC: // SCSIAtomic() replacement
D(bug("SCSIAtomic\n"));
r->d[0] = (uint32)-7887;
break;
case OP_CHECK_SYSV: { // Check we are not using MacOS < 8.1 with a NewWorld ROM
r->a[1] = r->d[1];
r->a[0] = ReadMacInt32(r->d[1]);
uint32 sysv = ReadMacInt16(r->a[0]);
D(bug("Detected MacOS version %d.%d.%d\n", (sysv >> 8) & 0xf, (sysv >> 4) & 0xf, sysv & 0xf));
if (ROMType == ROMTYPE_NEWWORLD && sysv < 0x0801)
r->d[1] = 0;
break;
}
case OP_NTRB_17_PATCH:
r->a[2] = ReadMacInt32(r->a[7]);
r->a[7] += 4;
if (ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH2:
r->a[7] += 8;
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH3:
r->a[2] = ReadMacInt32(r->a[7]);
r->a[7] += 4;
D(bug("%d %d\n", ReadMacInt16(r->a[2]), ReadMacInt16(r->a[2] + 6)));
if (ReadMacInt16(r->a[2]) == 11 && ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_NTRB_17_PATCH4:
r->d[0] = ReadMacInt16(r->a[7]);
r->a[7] += 2;
D(bug("%d %d\n", ReadMacInt16(r->a[2]), ReadMacInt16(r->a[2] + 6)));
if (ReadMacInt16(r->a[2]) == 11 && ReadMacInt16(r->a[2] + 6) == 17)
PatchNativeResourceManager();
break;
case OP_CHECKLOAD: { // vCheckLoad() patch
uint32 type = ReadMacInt32(r->a[7]);
r->a[7] += 4;
int16 id = ReadMacInt16(r->a[2]);
if (r->a[0] == 0)
break;
uint32 adr = ReadMacInt32(r->a[0]);
if (adr == 0)
break;
uint16 *p = (uint16 *)Mac2HostAddr(adr);
uint32 size = ReadMacInt32(adr - 8) & 0xffffff;
CheckLoad(type, id, p, size);
break;
}
case OP_EXTFS_COMM: // External file system routines
WriteMacInt16(r->a[7] + 14, ExtFSComm(ReadMacInt16(r->a[7] + 12), ReadMacInt32(r->a[7] + 8), ReadMacInt32(r->a[7] + 4)));
break;
case OP_EXTFS_HFS:
WriteMacInt16(r->a[7] + 20, ExtFSHFS(ReadMacInt32(r->a[7] + 16), ReadMacInt16(r->a[7] + 14), ReadMacInt32(r->a[7] + 10), ReadMacInt32(r->a[7] + 6), ReadMacInt16(r->a[7] + 4)));
break;
case OP_IDLE_TIME:
// Sleep if no events pending
if (ReadMacInt32(0x14c) == 0)
idle_wait();
r->a[0] = ReadMacInt32(0x2b6);
break;
case OP_IDLE_TIME_2:
// Sleep if no events pending
if (ReadMacInt32(0x14c) == 0)
idle_wait();
r->d[0] = (uint32)-2;
break;
default:
printf("FATAL: EMUL_OP called with bogus selector %08x\n", selector);
QuitEmulator();
break;
}
}
