Archive/Play-
0
0
Fork 0
mirror of https://github.com/jpd002/Play-.git synced 2025-04-28 13:47:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Apply CZipArchiveWriter refactoring.

Browse source
This commit is contained in:
Jean-Philip Desjardins 2023-07-23 17:22:18 -04:00
parent df317c49c5
commit 8c543186da
37 changed files with 109 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Source/FrameDump.cpp
View file

@ -136,29 +136,29 @@ void CFrameDump::Write(Framework::CStream& output) const
{
Framework::CZipArchiveWriter archive;
archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE));
archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX));
{
auto privRegsStateFile = new CRegisterStateFile(STATE_INITIAL_GSPRIVREGS);
auto privRegsStateFile = std::make_unique<CRegisterStateFile>(STATE_INITIAL_GSPRIVREGS);
privRegsStateFile->SetRegister64(STATE_PRIVREG_SMODE2, m_initialSMODE2);
archive.InsertFile(privRegsStateFile);
archive.InsertFile(std::move(privRegsStateFile));
}
unsigned int currentPacket = 0;
for(const auto& packet : m_packets)
{
auto packetMetadataFileName = STATE_PACKET_METADATA_PREFIX + std::to_string(currentPacket);
archive.InsertFile(new CMemoryStateFile(packetMetadataFileName.c_str(), &packet.metadata, sizeof(CGsPacketMetadata)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(packetMetadataFileName.c_str(), &packet.metadata, sizeof(CGsPacketMetadata)));
if(!packet.registerWrites.empty())
{
auto packetRegisterWritesFileName = STATE_PACKET_REGISTERWRITES_PREFIX + std::to_string(currentPacket);
archive.InsertFile(new CMemoryStateFile(packetRegisterWritesFileName.c_str(), packet.registerWrites.data(), packet.registerWrites.size() * sizeof(CGSHandler::RegisterWrite)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(packetRegisterWritesFileName.c_str(), packet.registerWrites.data(), packet.registerWrites.size() * sizeof(CGSHandler::RegisterWrite)));
}
if(!packet.imageData.empty())
{
auto packetImageDataName = STATE_PACKET_IMAGEDATA_PREFIX + std::to_string(currentPacket);
archive.InsertFile(new CMemoryStateFile(packetImageDataName.c_str(), packet.imageData.data(), packet.imageData.size()));
archive.InsertFile(std::make_unique<CMemoryStateFile>(packetImageDataName.c_str(), packet.imageData.data(), packet.imageData.size()));
}
currentPacket++;
}

4
Source/PS2VM.cpp
View file

@ -563,12 +563,12 @@ bool CPS2VM::LoadVMState(const fs::path& statePath)
void CPS2VM::SaveVmTimingState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_VM_TIMING_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VM_TIMING_XML);
registerFile->SetRegister32(STATE_VM_TIMING_VBLANK_TICKS, m_vblankTicks);
registerFile->SetRegister32(STATE_VM_TIMING_IN_VBLANK, m_inVblank);
registerFile->SetRegister32(STATE_VM_TIMING_EE_EXECUTION_TICKS, m_eeExecutionTicks);
registerFile->SetRegister32(STATE_VM_TIMING_IOP_EXECUTION_TICKS, m_iopExecutionTicks);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CPS2VM::LoadVmTimingState(Framework::CZipArchiveReader& archive)

4
Source/ee/DMAC.cpp
View file

@ -1025,7 +1025,7 @@ void CDMAC::LoadState(Framework::CZipArchiveReader& archive)
void CDMAC::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REGS_CTRL, m_D_CTRL);
registerFile->SetRegister32(STATE_REGS_STAT, m_D_STAT);
registerFile->SetRegister32(STATE_REGS_ENABLE, m_D_ENABLE);
@ -1046,7 +1046,7 @@ void CDMAC::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REGS_D6_TADR, m_D6_TADR);
registerFile->SetRegister32(STATE_REGS_D8_SADR, m_D8_SADR);
registerFile->SetRegister32(STATE_REGS_D9_SADR, m_D9_SADR);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
m_D0.SaveState(archive);
m_D1.SaveState(archive);

4
Source/ee/Dmac_Channel.cpp
View file

@ -43,7 +43,7 @@ void CChannel::Reset()
void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
{
auto path = string_format(STATE_REGS_XML_FORMAT, m_number);
CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR);
registerFile->SetRegister32(STATE_REGS_MADR, m_nMADR);
registerFile->SetRegister32(STATE_REGS_QWC, m_nQWC);
@ -51,7 +51,7 @@ void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REGS_SCCTRL, m_nSCCTRL);
registerFile->SetRegister32(STATE_REGS_ASR0, m_nASR[0]);
registerFile->SetRegister32(STATE_REGS_ASR1, m_nASR[1]);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CChannel::LoadState(Framework::CZipArchiveReader& archive)

4
Source/ee/Ee_LibMc2.cpp
View file

@ -49,12 +49,12 @@ void CLibMc2::Reset()
void CLibMc2::SaveState(Framework::CZipArchiveWriter& archive)
{
auto registerFile = new CRegisterStateFile(STATE_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
registerFile->SetRegister32(STATE_LAST_CMD, m_lastCmd);
registerFile->SetRegister32(STATE_LAST_RESULT, m_lastResult);
registerFile->SetRegister32(STATE_WAIT_THREADID, m_waitThreadId);
registerFile->SetRegister32(STATE_WAIT_VBLANK_COUNT, m_waitVBlankCount);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CLibMc2::LoadState(Framework::CZipArchiveReader& archive)

18
Source/ee/Ee_SubSystem.cpp
View file

@ -362,15 +362,15 @@ void CSubSystem::NotifyVBlankEnd()
void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive)
{
archive.InsertFile(new CMemoryStateFile(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(new CMemoryStateFile(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(new CMemoryStateFile(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, PS2::EE_RAM_SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_SPR, m_spr, PS2::EE_SPR_SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, m_ram, PS2::EE_RAM_SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SPR, m_spr, PS2::EE_SPR_SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE));
m_dmac.SaveState(archive);
m_intc.SaveState(archive);

4
Source/ee/GIF.cpp
View file

@ -77,7 +77,7 @@ void CGIF::LoadState(Framework::CZipArchiveReader& archive)
void CGIF::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REGS_M3P, m_path3Masked ? 1 : 0);
registerFile->SetRegister32(STATE_REGS_ACTIVEPATH, m_activePath);
registerFile->SetRegister32(STATE_REGS_MODE, m_MODE);
@ -91,7 +91,7 @@ void CGIF::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REGS_PATH3_XFER_ACTIVE_TICKS, m_path3XferActiveTicks);
registerFile->SetRegister128(STATE_REGS_FIFO_BUFFER, *reinterpret_cast<uint128*>(&m_fifoBuffer));
registerFile->SetRegister32(STATE_REGS_FIFO_INDEX, m_fifoIndex);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
uint32 CGIF::ProcessPacked(const uint8* memory, uint32 address, uint32 end)

4
Source/ee/INTC.cpp
View file

@ -71,8 +71,8 @@ void CINTC::LoadState(Framework::CZipArchiveReader& archive)
void CINTC::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32("INTC_STAT", m_INTC_STAT);
registerFile->SetRegister32("INTC_MASK", m_INTC_MASK);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}

14
Source/ee/SIF.cpp
View file

@ -313,7 +313,7 @@ void CSIF::LoadState(Framework::CZipArchiveReader& archive)
void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
{
{
auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REG_MAINADDR, m_nMAINADDR);
registerFile->SetRegister32(STATE_REG_SUBADDR, m_nSUBADDR);
registerFile->SetRegister32(STATE_REG_MSFLAG, m_nMSFLAG);
@ -321,10 +321,10 @@ void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REG_EERECVADDR, m_nEERecvAddr);
registerFile->SetRegister32(STATE_REG_DATAADDR, m_nDataAddr);
registerFile->SetRegister32(STATE_REG_PACKETPROCESSED, m_packetProcessed);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
archive.InsertFile(new CMemoryStateFile(STATE_PACKETQUEUE, m_packetQueue.data(), m_packetQueue.size()));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_PACKETQUEUE, m_packetQueue.data(), m_packetQueue.size()));
SaveCallReplies(archive);
SaveBindReplies(archive);
@ -332,7 +332,7 @@ void CSIF::SaveState(Framework::CZipArchiveWriter& archive)
void CSIF::SaveCallReplies(Framework::CZipArchiveWriter& archive)
{
auto callRepliesFile = new CStructCollectionStateFile(STATE_CALL_REPLIES_XML);
auto callRepliesFile = std::make_unique<CStructCollectionStateFile>(STATE_CALL_REPLIES_XML);
for(const auto& callReplyIterator : m_callReplies)
{
const auto& callReply(callReplyIterator.second);
@ -344,12 +344,12 @@ void CSIF::SaveCallReplies(Framework::CZipArchiveWriter& archive)
}
callRepliesFile->InsertStruct(replyId.c_str(), replyStruct);
}
archive.InsertFile(callRepliesFile);
archive.InsertFile(std::move(callRepliesFile));
}
void CSIF::SaveBindReplies(Framework::CZipArchiveWriter& archive)
{
auto bindRepliesFile = new CStructCollectionStateFile(STATE_BIND_REPLIES_XML);
auto bindRepliesFile = std::make_unique<CStructCollectionStateFile>(STATE_BIND_REPLIES_XML);
for(const auto& bindReplyIterator : m_bindReplies)
{
const auto& bindReply(bindReplyIterator.second);
@ -361,7 +361,7 @@ void CSIF::SaveBindReplies(Framework::CZipArchiveWriter& archive)
replyStruct.SetRegister32(STATE_BIND_REPLY_TIMEOUT, bindReply.timeout);
bindRepliesFile->InsertStruct(replyId.c_str(), replyStruct);
}
archive.InsertFile(bindRepliesFile);
archive.InsertFile(std::move(bindRepliesFile));
}
CSIF::PacketQueue CSIF::LoadPacketQueue(Framework::CZipArchiveReader& archive)

4
Source/ee/Timer.cpp
View file

@ -259,7 +259,7 @@ void CTimer::LoadState(Framework::CZipArchiveReader& archive)
void CTimer::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
for(unsigned int i = 0; i < MAX_TIMER; i++)
{
const auto& timer = m_timer[i];
@ -270,7 +270,7 @@ void CTimer::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32((timerPrefix + "HOLD").c_str(), timer.nHOLD);
registerFile->SetRegister32((timerPrefix + "REM").c_str(), timer.clockRemain);
}
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CTimer::NotifyVBlankStart()

6
Source/ee/Vif.cpp
View file

@ -268,7 +268,7 @@ void CVif::SaveState(Framework::CZipArchiveWriter& archive)
{
{
auto path = string_format(STATE_PATH_REGS_FORMAT, m_number);
auto registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_STAT, m_STAT);
registerFile->SetRegister32(STATE_REGS_ERR, m_ERR);
registerFile->SetRegister32(STATE_REGS_CODE, m_CODE);
@ -295,11 +295,11 @@ void CVif::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REGS_INTERRUPTDELAYTICKS, m_interruptDelayTicks);
registerFile->SetRegister128(STATE_REGS_STREAM_BUFFER, m_stream.GetBuffer());
registerFile->SetRegister32(STATE_REGS_STREAM_BUFFERPOSITION, m_stream.GetBufferPosition());
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
{
auto path = string_format(STATE_PATH_FIFO_FORMAT, m_number);
archive.InsertFile(new CMemoryStateFile(path.c_str(), &m_fifoBuffer, sizeof(m_fifoBuffer)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(path.c_str(), &m_fifoBuffer, sizeof(m_fifoBuffer)));
}
}

4
Source/ee/Vif1.cpp
View file

@ -38,14 +38,14 @@ void CVif1::SaveState(Framework::CZipArchiveWriter& archive)
CVif::SaveState(archive);
auto path = string_format(STATE_PATH_FORMAT, m_number);
CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_BASE, m_BASE);
registerFile->SetRegister32(STATE_REGS_TOP, m_TOP);
registerFile->SetRegister32(STATE_REGS_TOPS, m_TOPS);
registerFile->SetRegister32(STATE_REGS_OFST, m_OFST);
registerFile->SetRegister128(STATE_REGS_DIRECTQWORDBUFFER, *reinterpret_cast<uint128*>(&m_directQwordBuffer));
registerFile->SetRegister32(STATE_REGS_DIRECTQWORDBUFFER_INDEX, m_directQwordBufferIndex);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CVif1::LoadState(Framework::CZipArchiveReader& archive)

4
Source/ee/Vpu.cpp
View file

@ -113,9 +113,9 @@ void CVpu::SaveState(Framework::CZipArchiveWriter& archive)
{
{
auto path = string_format(STATE_PATH_REGS_FORMAT, m_number);
auto registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_RUNNING, m_running);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
m_vif->SaveState(archive);

10
Source/gs/GSHandler.cpp
View file

@ -245,12 +245,12 @@ void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive)
{
SendGSCall([&]() { SyncMemoryCache(); }, true);
archive.InsertFile(new CMemoryStateFile(STATE_RAM, GetRam(), RAMSIZE));
archive.InsertFile(new CMemoryStateFile(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX));
archive.InsertFile(new CMemoryStateFile(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, GetRam(), RAMSIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT)));
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_PRIVREGS);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_PRIVREGS);
registerFile->SetRegister64(STATE_PRIVREGS_PMODE, m_nPMODE);
registerFile->SetRegister64(STATE_PRIVREGS_SMODE2, m_nSMODE2);
@ -266,7 +266,7 @@ void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REG_CBP0, m_nCBP0);
registerFile->SetRegister32(STATE_REG_CBP1, m_nCBP1);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
}

6
Source/iop/IopBios.cpp
View file

@ -326,7 +326,7 @@ uint32& CIopBios::ModuleStartRequestFree() const
void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
{
CStructCollectionStateFile* modulesFile = new CStructCollectionStateFile(STATE_MODULES);
auto modulesFile = std::make_unique<CStructCollectionStateFile>(STATE_MODULES);
{
for(const auto& modulePair : m_modules)
{
@ -341,7 +341,7 @@ void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
}
}
}
archive.InsertFile(modulesFile);
archive.InsertFile(std::move(modulesFile));
auto builtInModules = GetBuiltInModules();
for(const auto& module : builtInModules)
@ -349,7 +349,7 @@ void CIopBios::SaveState(Framework::CZipArchiveWriter& archive)
module->SaveState(archive);
}
archive.InsertFile(new CMemoryStateFile(STATE_MODULESTARTREQUESTS, m_moduleStartRequests, sizeof(m_moduleStartRequests)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_MODULESTARTREQUESTS, m_moduleStartRequests, sizeof(m_moduleStartRequests)));
}
void CIopBios::LoadState(Framework::CZipArchiveReader& archive)

4
Source/iop/Iop_Cdvdfsv.cpp
View file

@ -139,7 +139,7 @@ void CCdvdfsv::LoadState(Framework::CZipArchiveReader& archive)
void CCdvdfsv::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_FILENAME);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
registerFile->SetRegister32(STATE_PENDINGCOMMAND, m_pendingCommand);
registerFile->SetRegister32(STATE_PENDINGREADSECTOR, m_pendingReadSector);
@ -150,7 +150,7 @@ void CCdvdfsv::SaveState(Framework::CZipArchiveWriter& archive) const
registerFile->SetRegister32(STATE_STREAMPOS, m_streamPos);
registerFile->SetRegister32(STATE_STREAMBUFFERSIZE, m_streamBufferSize);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CCdvdfsv::Invoke(CMIPS& context, unsigned int functionId)

4
Source/iop/Iop_Cdvdman.cpp
View file

@ -66,13 +66,13 @@ void CCdvdman::LoadState(Framework::CZipArchiveReader& archive)
void CCdvdman::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_FILENAME);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
registerFile->SetRegister32(STATE_CALLBACK_ADDRESS, m_callbackPtr);
registerFile->SetRegister32(STATE_STATUS, m_status);
registerFile->SetRegister32(STATE_DISCCHANGED, m_discChanged);
registerFile->SetRegister32(STATE_PENDING_COMMAND, m_pendingCommand);
registerFile->SetRegister32(STATE_PENDING_COMMAND_DELAY, m_pendingCommandDelay);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
static uint8 Uint8ToBcd(uint8 input)

4
Source/iop/Iop_Dmac.cpp
View file

@ -209,12 +209,12 @@ void CDmac::LoadState(Framework::CZipArchiveReader& archive)
void CDmac::SaveState(Framework::CZipArchiveWriter& archive)
{
{
auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REGS_DPCR, m_DPCR);
registerFile->SetRegister32(STATE_REGS_DPCR2, m_DPCR2);
registerFile->SetRegister32(STATE_REGS_DPCR3, m_DPCR3);
registerFile->SetRegister32(STATE_REGS_DICR, m_DICR);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
for(unsigned int i = 0; i < MAX_CHANNEL; i++)

4
Source/iop/Iop_DmacChannel.cpp
View file

@ -41,11 +41,11 @@ void CChannel::LoadState(Framework::CZipArchiveReader& archive)
void CChannel::SaveState(Framework::CZipArchiveWriter& archive)
{
auto path = string_format(STATE_REGS_XML_FORMAT, m_number);
auto registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR);
registerFile->SetRegister32(STATE_REGS_BCR, m_BCR);
registerFile->SetRegister32(STATE_REGS_MADR, m_MADR);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CChannel::SetReceiveFunction(const ReceiveFunctionType& receiveFunction)

4
Source/iop/Iop_FileIo.cpp
View file

@ -111,9 +111,9 @@ void CFileIo::LoadState(Framework::CZipArchiveReader& archive)
void CFileIo::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_VERSION_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VERSION_XML);
registerFile->SetRegister32(STATE_VERSION_MODULEVERSION, m_moduleVersion);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
m_handler->SaveState(archive);
}

4
Source/iop/Iop_FileIoHandler1000.cpp
View file

@ -43,10 +43,10 @@ void CFileIoHandler1000::LoadState(Framework::CZipArchiveReader& archive)
void CFileIoHandler1000::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
registerFile->SetRegister32(STATE_MODULEDATAADDR, m_moduleDataAddr);
registerFile->SetRegister32(STATE_TRAMPOLINEADDR, m_trampolineAddr);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CFileIoHandler1000::AllocateMemory()

8
Source/iop/Iop_FileIoHandler2200.cpp
View file

@ -120,15 +120,15 @@ void CFileIoHandler2200::LoadState(Framework::CZipArchiveReader& archive)
void CFileIoHandler2200::SaveState(Framework::CZipArchiveWriter& archive) const
{
{
auto registerFile = new CRegisterStateFile(STATE_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_XML);
registerFile->SetRegister32(STATE_RESULTPTR0, m_resultPtr[0]);
registerFile->SetRegister32(STATE_RESULTPTR1, m_resultPtr[1]);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
{
auto memoryFile = new CMemoryStateFile(STATE_PENDINGREPLY, &m_pendingReply, sizeof(m_pendingReply));
archive.InsertFile(memoryFile);
auto memoryFile = std::make_unique<CMemoryStateFile>(STATE_PENDINGREPLY, &m_pendingReply, sizeof(m_pendingReply));
archive.InsertFile(std::move(memoryFile));
}
}

4
Source/iop/Iop_Ilink.cpp
View file

@ -50,7 +50,7 @@ void CIlink::LoadState(Framework::CZipArchiveReader& archive)
void CIlink::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REGS_CTRL2, m_ctrl2);
registerFile->SetRegister32(STATE_REGS_PHYRESULT, m_phyResult);
registerFile->SetRegister32(STATE_REGS_INTR0, m_intr0);
@ -59,7 +59,7 @@ void CIlink::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32(STATE_REGS_INTR1MASK, m_intr1Mask);
registerFile->SetRegister32(STATE_REGS_INTR2, m_intr2);
registerFile->SetRegister32(STATE_REGS_INTR2MASK, m_intr2Mask);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
uint32 CIlink::ReadRegister(uint32 address)

4
Source/iop/Iop_Intc.cpp
View file

@ -22,10 +22,10 @@ void CIntc::LoadState(Framework::CZipArchiveReader& archive)
void CIntc::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister64(STATE_REGS_STATUS, m_status.f);
registerFile->SetRegister64(STATE_REGS_MASK, m_mask.f);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
uint32 CIntc::ReadRegister(uint32 address)

12
Source/iop/Iop_Ioman.cpp
View file

@ -1050,7 +1050,7 @@ void CIoman::LoadState(Framework::CZipArchiveReader& archive)
void CIoman::SaveFilesState(Framework::CZipArchiveWriter& archive) const
{
auto fileStateFile = new CXmlStateFile(STATE_FILES_FILENAME, STATE_FILES_FILESNODE);
auto fileStateFile = std::make_unique<CXmlStateFile>(STATE_FILES_FILENAME, STATE_FILES_FILESNODE);
auto filesStateNode = fileStateFile->GetRoot();
for(const auto& filePair : m_files)
@ -1068,12 +1068,12 @@ void CIoman::SaveFilesState(Framework::CZipArchiveWriter& archive) const
filesStateNode->InsertNode(fileStateNode);
}
archive.InsertFile(fileStateFile);
archive.InsertFile(std::move(fileStateFile));
}
void CIoman::SaveUserDevicesState(Framework::CZipArchiveWriter& archive) const
{
auto deviceStateFile = new CXmlStateFile(STATE_USERDEVICES_FILENAME, STATE_USERDEVICES_DEVICESNODE);
auto deviceStateFile = std::make_unique<CXmlStateFile>(STATE_USERDEVICES_FILENAME, STATE_USERDEVICES_DEVICESNODE);
auto devicesStateNode = deviceStateFile->GetRoot();
for(const auto& devicePair : m_userDevices)
@ -1084,12 +1084,12 @@ void CIoman::SaveUserDevicesState(Framework::CZipArchiveWriter& archive) const
devicesStateNode->InsertNode(deviceStateNode);
}
archive.InsertFile(deviceStateFile);
archive.InsertFile(std::move(deviceStateFile));
}
void CIoman::SaveMountedDevicesState(Framework::CZipArchiveWriter& archive) const
{
auto deviceStateFile = new CXmlStateFile(STATE_MOUNTEDDEVICES_FILENAME, STATE_MOUNTEDDEVICES_DEVICESNODE);
auto deviceStateFile = std::make_unique<CXmlStateFile>(STATE_MOUNTEDDEVICES_FILENAME, STATE_MOUNTEDDEVICES_DEVICESNODE);
auto devicesStateNode = deviceStateFile->GetRoot();
for(const auto& devicePair : m_mountedDevices)
@ -1100,7 +1100,7 @@ void CIoman::SaveMountedDevicesState(Framework::CZipArchiveWriter& archive) cons
devicesStateNode->InsertNode(deviceStateNode);
}
archive.InsertFile(deviceStateFile);
archive.InsertFile(std::move(deviceStateFile));
}
void CIoman::LoadFilesState(Framework::CZipArchiveReader& archive)

4
Source/iop/Iop_Loadcore.cpp
View file

@ -142,9 +142,9 @@ void CLoadcore::LoadState(Framework::CZipArchiveReader& archive)
void CLoadcore::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_VERSION_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_VERSION_XML);
registerFile->SetRegister32(STATE_VERSION_MODULEVERSION, m_moduleVersion);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CLoadcore::SetLoadExecutableHandler(const LoadExecutableHandler& loadExecutableHandler)

4
Source/iop/Iop_McServ.cpp
View file

@ -1141,7 +1141,7 @@ void CMcServ::LoadState(Framework::CZipArchiveReader& archive)
void CMcServ::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto stateFile = new CXmlStateFile(STATE_MEMCARDS_FILE, STATE_MEMCARDS_NODE);
auto stateFile = std::make_unique<CXmlStateFile>(STATE_MEMCARDS_FILE, STATE_MEMCARDS_NODE);
auto stateNode = stateFile->GetRoot();
for(unsigned int i = 0; i < MAX_PORTS; i++)
@ -1152,7 +1152,7 @@ void CMcServ::SaveState(Framework::CZipArchiveWriter& archive) const
stateNode->InsertNode(cardNode);
}
archive.InsertFile(stateFile);
archive.InsertFile(std::move(stateFile));
}
/////////////////////////////////////////////

4
Source/iop/Iop_NamcoArcade.cpp
View file

@ -453,10 +453,10 @@ void CNamcoArcade::ProcessJvsPacket(const uint8* input, uint8* output)
void CNamcoArcade::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_FILE);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILE);
registerFile->SetRegister32(STATE_RECV_ADDR, m_recvAddr);
registerFile->SetRegister32(STATE_SEND_ADDR, m_sendAddr);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CNamcoArcade::LoadState(Framework::CZipArchiveReader& archive)

4
Source/iop/Iop_PadMan.cpp
View file

@ -77,13 +77,13 @@ bool CPadMan::Invoke(uint32 method, uint32* args, uint32 argsSize, uint32* ret,
void CPadMan::SaveState(Framework::CZipArchiveWriter& archive) const
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_PADDATA);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_PADDATA);
registerFile->SetRegister32(STATE_PADDATA_PAD0_ADDRESS, m_padDataAddress[0]);
registerFile->SetRegister32(STATE_PADDATA_PAD1_ADDRESS, m_padDataAddress[1]);
registerFile->SetRegister32(STATE_PADDATA_TYPE, m_padDataType);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CPadMan::LoadState(Framework::CZipArchiveReader& archive)

4
Source/iop/Iop_RootCounters.cpp
View file

@ -99,7 +99,7 @@ void CRootCounters::LoadState(Framework::CZipArchiveReader& archive)
void CRootCounters::SaveState(Framework::CZipArchiveWriter& archive)
{
CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
for(unsigned int i = 0; i < MAX_COUNTERS; i++)
{
const auto& counter = m_counter[i];
@ -109,7 +109,7 @@ void CRootCounters::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32((counterPrefix + "TGT").c_str(), counter.target);
registerFile->SetRegister32((counterPrefix + "REM").c_str(), counter.clockRemain);
}
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CRootCounters::Update(unsigned int ticks)

4
Source/iop/Iop_SifCmd.cpp
View file

@ -93,7 +93,7 @@ void CSifCmd::LoadState(Framework::CZipArchiveReader& archive)
void CSifCmd::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto modulesFile = new CStructCollectionStateFile(STATE_MODULES);
auto modulesFile = std::make_unique<CStructCollectionStateFile>(STATE_MODULES);
{
int moduleIndex = 0;
for(const auto& module : m_servers)
@ -107,7 +107,7 @@ void CSifCmd::SaveState(Framework::CZipArchiveWriter& archive) const
modulesFile->InsertStruct(moduleName.c_str(), moduleStruct);
}
}
archive.InsertFile(modulesFile);
archive.InsertFile(std::move(modulesFile));
}
std::string CSifCmd::GetId() const

16
Source/iop/Iop_Sio2.cpp
View file

@ -105,18 +105,18 @@ void CSio2::SaveState(Framework::CZipArchiveWriter& archive)
auto outputBuffer = std::vector<uint8>(m_outputBuffer.begin(), m_outputBuffer.end());
{
auto registerFile = new CRegisterStateFile(STATE_REGS_XML);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_REGS_XML);
registerFile->SetRegister32(STATE_REGS_CURRENTREGINDEX, m_currentRegIndex);
registerFile->SetRegister32(STATE_REGS_STAT6C, m_stat6C);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
archive.InsertFile(new CMemoryStateFile(STATE_REGS, &m_regs, sizeof(m_regs)));
archive.InsertFile(new CMemoryStateFile(STATE_CTRL1, &m_ctrl1, sizeof(m_ctrl1)));
archive.InsertFile(new CMemoryStateFile(STATE_CTRL2, &m_ctrl2, sizeof(m_ctrl2)));
archive.InsertFile(new CMemoryStateFile(STATE_PAD, &m_padState, sizeof(m_padState)));
archive.InsertFile(new CMemoryStateFile(STATE_INPUT, inputBuffer.data(), inputBuffer.size()));
archive.InsertFile(new CMemoryStateFile(STATE_OUTPUT, outputBuffer.data(), outputBuffer.size()));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_REGS, &m_regs, sizeof(m_regs)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CTRL1, &m_ctrl1, sizeof(m_ctrl1)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CTRL2, &m_ctrl2, sizeof(m_ctrl2)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_PAD, &m_padState, sizeof(m_padState)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_INPUT, inputBuffer.data(), inputBuffer.size()));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_OUTPUT, outputBuffer.data(), outputBuffer.size()));
}
void CSio2::SetButtonState(unsigned int padNumber, PS2::CControllerInfo::BUTTON button, bool pressed, uint8* ram)

6
Source/iop/Iop_SpuBase.cpp
View file

@ -258,7 +258,7 @@ void CSpuBase::SaveState(Framework::CZipArchiveWriter& archive)
{
auto path = string_format(STATE_PATH_FORMAT, m_spuNumber);
auto registerFile = new CRegisterStateFile(path.c_str());
auto registerFile = std::make_unique<CRegisterStateFile>(path.c_str());
registerFile->SetRegister32(STATE_REGS_CTRL, m_ctrl);
registerFile->SetRegister32(STATE_REGS_IRQADDR, m_irqAddr);
registerFile->SetRegister32(STATE_REGS_TRANSFERMODE, m_transferMode);
@ -294,10 +294,10 @@ void CSpuBase::SaveState(Framework::CZipArchiveWriter& archive)
registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_ADDRESS).c_str(), channel.address);
registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_REPEAT).c_str(), channel.repeat);
registerFile->SetRegister32((channelPrefix + STATE_CHANNEL_REGS_CURRENT).c_str(), channel.current);
reader.SaveState(registerFile, channelPrefix);
reader.SaveState(registerFile.get(), channelPrefix);
}
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
bool CSpuBase::IsEnabled() const

8
Source/iop/Iop_SubSystem.cpp
View file

@ -106,10 +106,10 @@ void CSubSystem::NotifyVBlankEnd()
void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive)
{
archive.InsertFile(new CMemoryStateFile(STATE_CPU, &m_cpu.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, IOP_RAM_SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_SCRATCH, m_scratchPad, IOP_SCRATCH_SIZE));
archive.InsertFile(new CMemoryStateFile(STATE_SPURAM, m_spuRam, SPU_RAM_SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_CPU, &m_cpu.m_State, sizeof(MIPSSTATE)));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_RAM, m_ram, IOP_RAM_SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SCRATCH, m_scratchPad, IOP_SCRATCH_SIZE));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_SPURAM, m_spuRam, SPU_RAM_SIZE));
m_intc.SaveState(archive);
m_dmac.SaveState(archive);
m_counters.SaveState(archive);

4
Source/iop/Iop_Timrman.cpp
View file

@ -180,9 +180,9 @@ void CTimrman::Invoke(CMIPS& context, unsigned int functionId)
void CTimrman::SaveState(Framework::CZipArchiveWriter& archive) const
{
auto registerFile = new CRegisterStateFile(STATE_FILENAME);
auto registerFile = std::make_unique<CRegisterStateFile>(STATE_FILENAME);
registerFile->SetRegister32(STATE_HARDTIMERALLOC, m_hardTimerAlloc);
archive.InsertFile(registerFile);
archive.InsertFile(std::move(registerFile));
}
void CTimrman::LoadState(Framework::CZipArchiveReader& archive)

2
Source/iop/namco_arcade/Iop_NamcoAcRam.cpp
View file

@ -96,7 +96,7 @@ void CAcRam::Invoke(CMIPS& context, unsigned int functionId)
void CAcRam::SaveState(Framework::CZipArchiveWriter& archive) const
{
archive.InsertFile(new CMemoryStateFile(STATE_EXTRAM_FILE, m_extRam, g_extRamSize));
archive.InsertFile(std::make_unique<CMemoryStateFile>(STATE_EXTRAM_FILE, m_extRam, g_extRamSize));
}
void CAcRam::LoadState(Framework::CZipArchiveReader& archive)

2
deps/Framework vendored

@ -1 +1 @@
Subproject commit 64bddd377a74292965ab7cad99966efd72cdd892
Subproject commit cbeb7e234eb37d87b1ab7cbfad4fb4b46af949ce