C++ PointerWrap类代码示例

void __KernelSemaDoState(PointerWrap &p)
{
	p.Do(semaWaitTimer);
	CoreTiming::RestoreRegisterEvent(semaWaitTimer, "SemaphoreTimeout", __KernelSemaTimeout);
	p.DoMarker("sceKernelSema");
}

	virtual void DoState(PointerWrap &p) {
		p.Do(moduleID_);
		p.Do(retValAddr);
		p.DoMarker("AfterModuleEntryCall");
	}

void __PowerDoState(PointerWrap &p) {
	p.DoArray(powerCbSlots, ARRAY_SIZE(powerCbSlots));
	p.Do(volatileMemLocked);
	p.DoMarker("scePower");
}

void __CtrlDoState(PointerWrap &p)
{
	std::lock_guard<std::recursive_mutex> guard(ctrlMutex);

	p.Do(analogEnabled);
	p.Do(ctrlLatchBufs);
	p.Do(ctrlOldButtons);

	p.DoVoid(ctrlBufs, sizeof(ctrlBufs));
	p.Do(ctrlCurrent);
	p.Do(ctrlBuf);
	p.Do(ctrlBufRead);
	p.Do(latch);

	p.Do(ctrlIdleReset);
	p.Do(ctrlIdleBack);

	p.Do(ctrlCycle);

	SceUID dv = 0;
	p.Do(waitingThreads, dv);

	p.Do(ctrlTimer);
	CoreTiming::RestoreRegisterEvent(ctrlTimer, "CtrlSampleTimer", __CtrlTimerUpdate);
	p.DoMarker("sceCtrl");
}

void StereoResampler::DoState(PointerWrap &p) {
	auto s = p.Section("resampler", 1);
	if (!s)
		return;
}

// This feels like a dubious proposition, mostly...
void __NetDoState(PointerWrap &p) {
	p.Do(netInited);
	p.Do(netAdhocInited);
	p.DoMarker("net");
}

void GameListItem::Banner::DoState(PointerWrap& p)
{
  p.Do(buffer);
  p.Do(width);
  p.Do(height);
}

	void DoState(PointerWrap &p)
	{
		Memory::DoState(p);
		p.DoMarker("Memory");
		VideoInterface::DoState(p);
		p.DoMarker("VideoInterface");
		SerialInterface::DoState(p);
		p.DoMarker("SerialInterface");
		ProcessorInterface::DoState(p);
		p.DoMarker("ProcessorInterface");
		DSP::DoState(p);
		p.DoMarker("DSP");
		DVDInterface::DoState(p);
		p.DoMarker("DVDInterface");
		GPFifo::DoState(p);
		p.DoMarker("GPFifo");
		ExpansionInterface::DoState(p);
		p.DoMarker("ExpansionInterface");
		AudioInterface::DoState(p);
		p.DoMarker("AudioInterface");

		if (SConfig::GetInstance().bWii)
		{
			WII_IPCInterface::DoState(p);
			p.DoMarker("WII_IPCInterface");
			WII_IPC_HLE_Interface::DoState(p);
			p.DoMarker("WII_IPC_HLE_Interface");
		}

		p.DoMarker("WIIHW");
	}

void PendingInterrupt::DoState(PointerWrap &p)
{
	p.Do(intr);
	p.Do(subintr);
	p.DoMarker("PendingInterrupt");
}

void __PsmfPlayerDoState(PointerWrap &p)
{
	p.Do(psmfPlayerMap);

	p.DoMarker("scePsmfPlayer");
}

void __KernelDoState(PointerWrap &p)
{
	{
		auto s = p.Section("Kernel", 1, 2);
		if (!s)
			return;

		p.Do(kernelRunning);
		kernelObjects.DoState(p);

		if (s >= 2)
			p.Do(registeredExitCbId);
	}

	{
		auto s = p.Section("Kernel Modules", 1);
		if (!s)
			return;

		__InterruptsDoState(p);
		// Memory needs to be after kernel objects, which may free kernel memory.
		__KernelMemoryDoState(p);
		__KernelThreadingDoState(p);
		__KernelAlarmDoState(p);
		__KernelVTimerDoState(p);
		__KernelEventFlagDoState(p);
		__KernelMbxDoState(p);
		__KernelModuleDoState(p);
		__KernelMsgPipeDoState(p);
		__KernelMutexDoState(p);
		__KernelSemaDoState(p);
		__KernelTimeDoState(p);
	}

	{
		auto s = p.Section("HLE Modules", 1);
		if (!s)
			return;

		__AtracDoState(p);
		__AudioDoState(p);
		__CccDoState(p);
		__CtrlDoState(p);
		__DisplayDoState(p);
		__FontDoState(p);
		__GeDoState(p);
		__ImposeDoState(p);
		__IoDoState(p);
		__JpegDoState(p);
		__Mp3DoState(p);
		__MpegDoState(p);
		__NetDoState(p);
		__NetAdhocDoState(p);
		__PowerDoState(p);
		__PsmfDoState(p);
		__PsmfPlayerDoState(p);
		__RtcDoState(p);
		__SasDoState(p);
		__SslDoState(p);
		__UmdDoState(p);
		__UtilityDoState(p);
		__UsbDoState(p);
		__VaudioDoState(p);
		__HeapDoState(p);

		__PPGeDoState(p);
		__CheatDoState(p);
		__sceAudiocodecDoState(p);
		__VideoPmpDoState(p);
		__AACDoState(p);
	}

	{
		auto s = p.Section("Kernel Cleanup", 1);
		if (!s)
			return;

		__InterruptsDoStateLate(p);
		__KernelThreadingDoStateLate(p);
		Reporting::DoState(p);
	}
}

void __CtrlDoState(PointerWrap &p)
{
	std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
	
	auto s = p.Section("sceCtrl", 1, 3);
	if (!s)
		return;

	p.Do(analogEnabled);
	p.Do(ctrlLatchBufs);
	p.Do(ctrlOldButtons);

	p.DoVoid(ctrlBufs, sizeof(ctrlBufs));
	if (s <= 2) {
		_ctrl_data dummy = {0};
		p.Do(dummy);
	}
	p.Do(ctrlBuf);
	p.Do(ctrlBufRead);
	p.Do(latch);
	if (s == 1) {
		dialogBtnMake = 0;
	} else {
		p.Do(dialogBtnMake);
	}

	p.Do(ctrlIdleReset);
	p.Do(ctrlIdleBack);

	p.Do(ctrlCycle);

	SceUID dv = 0;
	p.Do(waitingThreads, dv);

	p.Do(ctrlTimer);
	CoreTiming::RestoreRegisterEvent(ctrlTimer, "CtrlSampleTimer", __CtrlTimerUpdate);
}

void DSPHLE::DoState(PointerWrap &p)
{
	bool isHLE = true;
	p.Do(isHLE);
	if (isHLE != true && p.GetMode() == PointerWrap::MODE_READ)
	{
		Core::DisplayMessage("State is incompatible with current DSP engine. Aborting load state.", 3000);
		p.SetMode(PointerWrap::MODE_VERIFY);
		return;
	}

	p.DoPOD(m_DSPControl);
	p.DoPOD(m_dspState);

	int ucode_crc = UCodeInterface::GetCRC(m_pUCode);
	int ucode_crc_beforeLoad = ucode_crc;
	int lastucode_crc = UCodeInterface::GetCRC(m_lastUCode);
	int lastucode_crc_beforeLoad = lastucode_crc;

	p.Do(ucode_crc);
	p.Do(lastucode_crc);

	// if a different type of ucode was being used when the savestate was created,
	// we have to reconstruct the old type of ucode so that we have a valid thing to call DoState on.
	UCodeInterface*     ucode =     (ucode_crc ==     ucode_crc_beforeLoad) ?    m_pUCode : UCodeFactory(    ucode_crc, this, m_bWii);
	UCodeInterface* lastucode = (lastucode_crc != lastucode_crc_beforeLoad) ? m_lastUCode : UCodeFactory(lastucode_crc, this, m_bWii);

	if (ucode)
		ucode->DoState(p);
	if (lastucode)
		lastucode->DoState(p);

	// if a different type of ucode was being used when the savestate was created,
	// discard it if we're not loading, otherwise discard the old one and keep the new one.
	if (ucode != m_pUCode)
	{
		if (p.GetMode() != PointerWrap::MODE_READ)
		{
			delete ucode;
		}
		else
		{
			delete m_pUCode;
			m_pUCode = ucode;
		}
	}
	if (lastucode != m_lastUCode)
	{
		if (p.GetMode() != PointerWrap::MODE_READ)
		{
			delete lastucode;
		}
		else
		{
			delete m_lastUCode;
			m_lastUCode = lastucode;
		}
	}

	m_MailHandler.DoState(p);
}

	virtual void DoState(PointerWrap &p)
	{
		p.Do(nm);
		p.Do(memoryBlockAddr);
		p.DoMarker("Module");
	}

	void DoState(PointerWrap &p) {
		p.Do(type);
		p.Do(channel);
	}