void SBNK::Read(PseudoReadFile &file)
{
uint32_t startOfSBNK = file.pos;
this->header.Read(file);
try
{
this->header.Verify("SBNK", 0x0100FEFF);
}
catch (const std::exception &)
{
if (SDAT::failOnMissingFiles)
throw;
else
return;
}
int8_t type[4];
file.ReadLE(type);
if (!VerifyHeader(type, "DATA"))
throw std::runtime_error("SBNK DATA structure invalid");
file.ReadLE<uint32_t>(); // size
uint32_t reserved[8];
file.ReadLE(reserved);
this->count = file.ReadLE<uint32_t>();
this->instruments.resize(this->count);
for (uint32_t i = 0; i < this->count; ++i)
this->instruments[i].Read(file, startOfSBNK);
}
void INFOSection::Read(PseudoReadFile &file)
{
uint32_t startOfINFO = file.pos;
file.ReadLE(this->type);
if (!VerifyHeader(this->type, "INFO"))
throw std::runtime_error("SDAT INFO Section invalid");
this->size = file.ReadLE<uint32_t>();
file.ReadLE(this->recordOffsets);
if (this->recordOffsets[REC_SEQ])
{
file.pos = startOfINFO + this->recordOffsets[REC_SEQ];
this->SEQrecord.Read(file, startOfINFO);
}
if (this->recordOffsets[REC_BANK])
{
file.pos = startOfINFO + this->recordOffsets[REC_BANK];
this->BANKrecord.Read(file, startOfINFO);
}
if (this->recordOffsets[REC_WAVEARC])
{
file.pos = startOfINFO + this->recordOffsets[REC_WAVEARC];
this->WAVEARCrecord.Read(file, startOfINFO);
}
if (this->recordOffsets[REC_PLAYER])
{
file.pos = startOfINFO + this->recordOffsets[REC_PLAYER];
this->PLAYERrecord.Read(file, startOfINFO);
}
}
void FATSection::Read(PseudoFile &file)
{
int8_t type[4];
file.ReadLE(type);
if (!VerifyHeader(type, "FAT "))
throw std::runtime_error("SDAT FAT Section invalid");
file.ReadLE<uint32_t>(); // size
uint32_t count = file.ReadLE<uint32_t>();
this->records.resize(count);
for (uint32_t i = 0; i < count; ++i)
this->records[i].Read(file);
}
bool CWorkGrammar::LoadFromFile(const Stroka& file_name, const ITerminalDictionary& terminals)
{
TIFStream f(file_name);
// binary protection
VerifyHeader(&f);
TLz4Decompress z(&f);
// first load kw-types table
GetMutableKWTypePool().Load(&z);
// then load the grammar itself
::LoadProtectedSize(&z);
this->Load(&z, terminals);
return true;
}
void NDSStdHeader::Verify(const std::string &typeToCheck, uint32_t magicToCheck)
{
if (!VerifyHeader(this->type, typeToCheck) || this->magic != magicToCheck)
throw std::runtime_error("NDS Standard Header for " + typeToCheck + " invalid");
}
/// Saves map data to file.
bool Map::Save(const char * filename){
std::fstream file;
file.open(filename, std::ios_base::out | std::ios_base::binary);
/// If failed to open, close and return false.
if (!file.is_open()){
file.close();
std::cout<<"\nERROR: Unable to open filestream to ";
PrintPath(filename);
lastErrorString = "Unable to open file stream.";
return false;
}
/// Set version to latest
header.version = MV_LATEST;
header.dateCreated = time(0); // Get current time
strcpy(header.mapName, name); // Set header map name to the one we're using in the editor
/// Verify that header is OK before we save it!
if (!VerifyHeader()){
std::cout<<"\nERROR: Unsupported map version. Try updating the game! ^^";
return false;
}
int size = sizeof(MapFileHeader); // Should be int(4) + long(4) + 260 chars
header.Write(file);
/// Make sure, // NO! this is check in the WriteEntities() function!
// assert(cEntities.Size() == entities.Size());
/// Block types for writing
int blockType = -1;
// Write entities if we have any
if (NumEntities() > 0 && NumEntities() <= MAX_ENTITIES){
WriteEntities(file);
}
else{
std::cout<<"\nInvalid amount of entities: "<<NumEntities();
lastErrorString = "No entities to save.";
return false;
}
/// Write paths block if we got any
if (paths.Size() > 0){
WritePaths(file);
}
int end = BLOCK_END_OF_FILE;
if (header.version < MV_PATHS)
end = OLD_BLOCK_END_OF_FILE;
file.write((char*)&end, sizeof(int));
int endNull = 0;
file.write((char*)&endNull, sizeof(int));
file.close();
/// Consider using other mechanisms to check that everything was written correctly...
//////////////////////////////////////////
// Check that the written contents are the same as what we wanted to save..
if (false){
file.open(filename, std::ios_base::in | std::ios_base::binary);
Map verificationMap;
file.read((char*) &verificationMap.header, sizeof(MapFileHeader));
// Check stuff
bool verificationDone = false;
while(!verificationDone){
int blockType;
file.read((char*) &blockType, sizeof(int));
int blockSize;
file.read((char*) &blockSize, sizeof(int));
switch(blockType){
case BLOCK_ENTITIES:
verificationMap.ReadEntities(file);
break;
case OLD_BLOCK_END_OF_FILE:
verificationDone = true;
std::cout<<"\nVerification done! File is as it should be.";
break;
default:
std::cout<<"\nUnknown block type! You failed douche!";
assert(false && "Unknown block type when verifying saved file!");
break;
}
}
file.close();
}
return true;
}
/// Loads map data from file.
bool Map::Load(const char * fromFile){
std::cout<<"\nLoading map from file: "<<fromFile;
std::fstream file;
file.open(fromFile, std::ios_base::in | std::ios_base::binary);
/// If failed to open, close and return false.
if (!file.is_open()){
file.close();
std::cout<<"\nERROR: Unable to open filestream to ";
lastErrorString = "Unable to open filestream.";
PrintPath(fromFile);
return false;
}
/// Read and verify header before reading any more
header.Read(file);
if (!VerifyHeader()){
std::cout<<"\nERROR: Unsupported map version. Try updating the game! ^^";
return false;
}
bool endOfFile = false;
while (!file.eof() && !endOfFile){
/// Read next integer to inrepret type of next data block
int type;
int blockSize;
file.read((char*) &type, sizeof(int));
if (header.version < MV_PATHS)
file.read((char*) &blockSize, sizeof(int));
if (type < 0 || type > MAX_BLOCK_TYPES){
SWAPFOUR(type);
}
switch(type){
case BLOCK_ENTITIES:
ReadEntities(file);
break;
case BLOCK_PATHS:
ReadPaths(file);
break;
case OLD_BLOCK_END_OF_FILE: {
/// Check version here.
if (header.version < MV_PATHS){
endOfFile = true;
break;
}
break;
}
case BLOCK_END_OF_FILE:
endOfFile = true;
break;
default:
std::cout<<"\nUnknown block type: "<<type;
std::cout<<"\nAborting loading procedure because of unknown data in stream.";
file.close();
return false;
}
}
/// Close file ^^
file.close();
source = fromFile;
mapDataOK = true;
std::cout<<"\nFile successfully read.";
return true;
}
bool WP_Message::Process()
{
UINT8* buf = (UINT8*)&m_header;
int len;
while(true)
{
switch(m_rxState)
{
case ReceiveState::Idle:
return true;
case ReceiveState::Initialize:
Release();
m_rxState = ReceiveState::WaitingForHeader;
m_pos = (UINT8*)&m_header;
m_size = sizeof(m_header);
break;
case ReceiveState::WaitingForHeader:
if(m_parent->m_phy->ReceiveBytes( m_parent->m_state, m_pos, m_size ) == false) return true;
//
// Synch to the start of a message.
//
while(true)
{
len = sizeof(m_header) - m_size; if(len <= 0) break;
size_t lenCmp = __min( len, sizeof(m_header.m_signature) );
if(memcmp( &m_header, MARKER_DEBUGGER_V1, lenCmp ) == 0) break;
if(memcmp( &m_header, MARKER_PACKET_V1 , lenCmp ) == 0) break;
memmove( &buf[ 0 ], &buf[ 1 ], len-1 );
m_pos--;
m_size++;
}
if(len >= sizeof(m_header.m_signature))
{
m_rxState = ReceiveState::ReadingHeader;
}
break;
case ReceiveState::ReadingHeader:
if(m_parent->m_phy->ReceiveBytes( m_parent->m_state, m_pos, m_size ) == false) return true;
if(m_size == 0)
{
m_rxState = ReceiveState::CompleteHeader;
}
break;
case ReceiveState::CompleteHeader:
{
bool fBadPacket=true;
if( VerifyHeader() )
{
#if defined(BIG_ENDIAN)
SwapEndian();
#endif
if ( m_parent->m_app->ProcessHeader( m_parent->m_state, this ) )
{
fBadPacket = false;
if(m_header.m_size)
{
if(m_payload == NULL) // Bad, no buffer...
{
m_rxState = ReceiveState::Initialize;
}
else
{
m_payloadTicks = HAL_Time_CurrentTicks();
m_rxState = ReceiveState::ReadingPayload;
m_pos = (UINT8*)m_payload;
m_size = m_header.m_size;
}
}
else
{
m_rxState = ReceiveState::CompletePayload;
}
}
}
if ( fBadPacket )
{
if((m_header.m_flags & WP_Flags::c_NonCritical) == 0)
{
ReplyBadPacket( WP_Flags::c_BadHeader );
}
m_rxState = ReceiveState::Initialize;
}
}
break;
case ReceiveState::ReadingPayload:
{
UINT64 curTicks = HAL_Time_CurrentTicks();
// If the time between consecutive payload bytes exceeds the timeout threshold then assume that
// the rest of the payload is not coming. Reinitialize to synch on the next header.
if(HAL_Time_TicksToTime( curTicks - m_payloadTicks ) < (UINT64)c_PayloadTimeout)
{
m_payloadTicks = curTicks;
if(m_parent->m_phy->ReceiveBytes( m_parent->m_state, m_pos, m_size ) == false) return true;
if(m_size == 0)
{
m_rxState = ReceiveState::CompletePayload;
}
}
else
{
m_rxState = ReceiveState::Initialize;
}
}
break;
case ReceiveState::CompletePayload:
if(VerifyPayload() == true)
{
m_parent->m_app->ProcessPayload( m_parent->m_state, this );
}
else
{
ReplyBadPacket( WP_Flags::c_BadPayload );
}
m_rxState = ReceiveState::Initialize;
break;
default:
return false;
}
}
}
