381 lines
8.6 KiB
C++
381 lines
8.6 KiB
C++
#include "HexFile.h"
|
|
#include <QTextStream>
|
|
#include <QMessageBox>
|
|
#include "CRC32.h"
|
|
|
|
#define USE_BIG_RECORDS
|
|
#define MAX_RECORDS_IN_BIG_RECORDS 512 //16 bytes by record, 512 bytes by row --> 16 rows / big record
|
|
|
|
|
|
|
|
CHexFile::CHexFile(void)
|
|
{
|
|
mFileOpened = false;
|
|
mFileParsed = false;
|
|
mRecordsListValid = false;
|
|
mHighAddress = 0;
|
|
mDiscardedRecords = 0;
|
|
mTotalParsedRecords = 0;
|
|
mFirmwareCRC = 0;
|
|
|
|
}
|
|
|
|
CHexFile::~CHexFile(void)
|
|
{
|
|
for(int i = 0; i < mRecordsList.size(); i++)
|
|
delete mRecordsList.at(i);
|
|
|
|
}
|
|
|
|
int CHexFile::CloseOpenedHexFile()
|
|
{
|
|
for(int i = 0; i < mRecordsList.size(); i++)
|
|
delete mRecordsList.at(i);
|
|
|
|
mRecordsList.clear();
|
|
|
|
mFileOpened = false;
|
|
mFileParsed = false;
|
|
mHexfileHandle = 0;
|
|
mRecordsListValid = false;
|
|
mHighAddress = 0;
|
|
mDiscardedRecords = 0;
|
|
mTotalParsedRecords = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int CHexFile::OpenDataFile(QString FilePath, bool CloseIfAlreadyParsed)
|
|
{
|
|
|
|
//Check if file exists
|
|
if(QFile::exists(FilePath) == false)
|
|
return 0;
|
|
|
|
if(mFileParsed == true)
|
|
{
|
|
if(CloseIfAlreadyParsed == false)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
CloseOpenedHexFile();
|
|
}
|
|
}
|
|
|
|
mHexfileHandle = new QFile(FilePath);
|
|
|
|
if(mHexfileHandle->open(QIODevice::ReadOnly|QIODevice::Text|QIODevice::Unbuffered) == false)
|
|
{
|
|
delete mHexfileHandle;
|
|
mHexfileHandle = 0;
|
|
qDebug("Cannot open specified HEX file...");
|
|
return 0;
|
|
}
|
|
|
|
mHexFileSize = mHexfileHandle->size();
|
|
|
|
mFileOpened = true;
|
|
|
|
mRecordsTableSize = 0;
|
|
mFirmwareDataSize = 0;
|
|
|
|
return ParseData();
|
|
|
|
mHexfileHandle->close();
|
|
|
|
}
|
|
|
|
|
|
int CHexFile::ParseData(void)
|
|
{
|
|
if(!mFileOpened)
|
|
return 0;
|
|
|
|
int Ret;
|
|
bool Finished = false;
|
|
unsigned int CurAddress;
|
|
|
|
// CArray<CHexRecord*,CHexRecord*> TempArray;
|
|
QList<CHexRecord*> TempList;
|
|
QString RecordString;
|
|
QTextStream RecordFileStream(mHexfileHandle);
|
|
// CArchive ar(&mHexfileHandle,CArchive::load);
|
|
|
|
while(!Finished)
|
|
{
|
|
CHexRecord *NewRecord = new CHexRecord;
|
|
RecordString.clear();
|
|
// ar.ReadString(mRecordString);
|
|
RecordString = RecordFileStream.readLine();
|
|
// Ret = NewRecord.DecodeRawRecord(&mRecordString,mHighAddress);
|
|
Ret = NewRecord->DecodeRawRecord(&RecordString,mHighAddress);
|
|
mTotalParsedRecords++;
|
|
|
|
switch(Ret)
|
|
{
|
|
case CHexRecord::RET_DATA_RECORD:
|
|
{
|
|
#ifdef USE_BIG_RECORDS
|
|
TempList.append(NewRecord);
|
|
// mRecordsTable[mRecordsTableSize] = NewRecord;
|
|
// mRecordsTableSize++;
|
|
#else
|
|
mRecordsList.append(NewRecord);
|
|
mRecordsTable[mRecordsTableSize] = NewRecord;
|
|
mRecordsTableSize++;
|
|
#endif
|
|
break;
|
|
}
|
|
case CHexRecord::RET_EOF_RECORD:
|
|
{
|
|
mHexfileHandle->close();
|
|
mFileOpened = false;
|
|
delete mHexfileHandle;
|
|
mRecordsListValid = true;
|
|
Finished = true;
|
|
delete NewRecord;
|
|
|
|
break;
|
|
}
|
|
|
|
case CHexRecord::RET_EXTENDED_LINEAR_ADDRESS:
|
|
{
|
|
// mHighAddress = NewRecord.GetExtenedAddress();
|
|
mHighAddress = NewRecord->GetExtenedAddress();
|
|
CurAddress = mHighAddress;
|
|
delete NewRecord;
|
|
break;
|
|
}
|
|
case CHexRecord::RET_IGNORED_ALL_FF_RECORD:
|
|
{
|
|
delete NewRecord;
|
|
mDiscardedRecords++;
|
|
break;
|
|
}
|
|
case CHexRecord::RET_EXTENDED_ADDRESS:
|
|
case CHexRecord::RET_START_SEGMENT_ADDRESS:
|
|
case CHexRecord::RET_START_LINEAR_ADDRESS:
|
|
case CHexRecord::RET_UNKNOWN_RECORD_TYPE:
|
|
case CHexRecord::RET_INVALID_RECORD:
|
|
case CHexRecord::RET_BAD_RECORD_CHECKSUM:
|
|
case CHexRecord::RET_UNMANAGED_RECORD_TYPE:
|
|
{
|
|
mHexfileHandle->close();
|
|
mFileOpened = false;
|
|
delete mHexfileHandle;
|
|
Finished = true;
|
|
//MessageBox(NULL,"Parsing Error", "Cannot Parse Hex File",MB_OK);
|
|
QMessageBox::warning(0,"Parsing Error","Cannot parse HEX file",QMessageBox::Ok);
|
|
delete NewRecord;
|
|
return 0;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#ifdef USE_BIG_RECORDS
|
|
int i;
|
|
int RecordCount;
|
|
CHexRecord *TempRecordPtr;
|
|
CHexRecord *BigRecord = new CHexRecord;
|
|
CCRC32 Crc32Engine;
|
|
|
|
|
|
TempRecordPtr = TempList.at(0);
|
|
CurAddress = TempRecordPtr->GetStartAddress();
|
|
*BigRecord = *TempRecordPtr;
|
|
RecordCount = 1;
|
|
|
|
for(i = 1; i < TempList.size(); i++)
|
|
{
|
|
// if(CurAddress == 0x1d0097F0)
|
|
// {
|
|
// CurAddress = CurAddress;
|
|
// }
|
|
CurAddress += (TempRecordPtr->GetRecordSizeInBytes());
|
|
TempRecordPtr = TempList.at(i);
|
|
if(CurAddress == TempRecordPtr->GetStartAddress() && RecordCount<MAX_RECORDS_IN_BIG_RECORDS && (i != (TempList.size()-1)))
|
|
{
|
|
BigRecord->AppendRecord(TempRecordPtr);
|
|
RecordCount++;
|
|
}
|
|
else
|
|
{
|
|
RecordCount = 1; //Init to 1 because we load the record right below...
|
|
mRecordsList.append(BigRecord);
|
|
BigRecord = new CHexRecord;
|
|
|
|
if(i == TempList.size()-1) //Manage the last record.
|
|
{
|
|
*BigRecord = *TempRecordPtr;
|
|
mRecordsList.append(BigRecord);
|
|
BigRecord->mRecordSize += TempRecordPtr->mRecordSize;
|
|
|
|
}
|
|
else
|
|
{
|
|
*BigRecord = *TempRecordPtr;
|
|
CurAddress = TempRecordPtr->GetStartAddress();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
for(i = 0; i < TempList.size(); i++)
|
|
{
|
|
delete TempList[i];
|
|
}
|
|
|
|
// for(i = 0; i < mRecordsList.size(); i++)
|
|
// {
|
|
// mFirmwareDataSize += mRecordsList.at(i)->GetRecordSizeInBytes();
|
|
// }
|
|
|
|
FilterRecords(0x1D004000,0x1D07FFFF);
|
|
|
|
QByteArray RawShit = GetRawData(false);
|
|
|
|
mFirmwareDataSize = RawShit.size();
|
|
|
|
unsigned int testcrc = CRC_START_32;
|
|
for(unsigned int i = 0; i < mFirmwareDataSize; i++)
|
|
{
|
|
testcrc = Crc32Engine.UpdateCRC32(testcrc,RawShit[i]);
|
|
}
|
|
testcrc ^= 0xffffffffL;
|
|
|
|
mFirmwareCRC = Crc32Engine.ComputeCRC32((const unsigned char *)RawShit.data(),RawShit.size());
|
|
|
|
mFileParsed = true;
|
|
return 1;
|
|
}
|
|
|
|
int CHexFile::FilterRecords(unsigned int StartAddress, unsigned int EndAddress)
|
|
{
|
|
if(mRecordsList.isEmpty() == true)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool done = false;
|
|
int i = 0;
|
|
while(done == false)
|
|
{
|
|
if(mRecordsList.at(i)->GetStartAddress() < StartAddress ||
|
|
mRecordsList.at(i)->GetStartAddress() > EndAddress)
|
|
{
|
|
//Record is outside filter area, delete it...
|
|
delete mRecordsList.at(i);
|
|
mRecordsList.removeAt(i);
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
|
|
if(i == mRecordsList.size())
|
|
{
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
unsigned int CHexFile::GetNBRecords(void)
|
|
{
|
|
// return mRecordsTableSize;
|
|
|
|
return mRecordsList.size();
|
|
|
|
}
|
|
|
|
unsigned long CHexFile::GetFileSize(void)
|
|
{
|
|
return mHexFileSize;
|
|
}
|
|
|
|
unsigned int CHexFile::GetDataCRC32()
|
|
{
|
|
return mFirmwareCRC;
|
|
}
|
|
|
|
CHexRecord * CHexFile::GetRecord(int RecordIndex, int &Status)
|
|
{
|
|
|
|
if(RecordIndex > mRecordsList.size())
|
|
// if(RecordIndex > mRecordsTableSize)
|
|
{
|
|
Status = ERR_INDEX_OUT_OF_BOUND;
|
|
return 0;
|
|
}
|
|
//CHexRecord *mRecordPtr = (CHexRecord*)&mRecordsList.GetAt(RecordIndex);
|
|
CHexRecord *mRecordPtr = mRecordsList.at(RecordIndex);
|
|
// CHexRecord *mRecordPtr = mRecordsTable[RecordIndex];
|
|
return mRecordPtr;
|
|
}
|
|
|
|
QByteArray CHexFile::GetRawData(bool IncludeHeader)
|
|
{
|
|
QByteArray Data;
|
|
Data.clear();
|
|
|
|
|
|
if(IncludeHeader)
|
|
{
|
|
QDataStream Strm(&Data,QIODevice::WriteOnly);
|
|
|
|
//Header
|
|
Strm << HEX_FILE_HEADER_CODE;
|
|
//Flags
|
|
Strm << (int)0x0000; //TODO: Manage that
|
|
//Nb Records
|
|
Strm << GetNBRecords();
|
|
//Firmware size
|
|
Strm << GetFirmwareSize();
|
|
//Version
|
|
Strm << (int)0x00; //TODO: Manage that
|
|
//CRC32
|
|
Strm << GetDataCRC32();
|
|
|
|
}
|
|
|
|
|
|
|
|
for(int i = 0; i < mRecordsList.size(); i++)
|
|
{
|
|
Data.append(mRecordsList.at(i)->GetRecord());
|
|
}
|
|
|
|
return Data;
|
|
}
|
|
|
|
|
|
QString CHexFile::GetHexFileInfoString()
|
|
{
|
|
|
|
QString string;
|
|
string.clear();
|
|
|
|
if(HexDataValid() == false)
|
|
return QString("No file loaded\n");
|
|
|
|
for(int i = 0; i < mRecordsList.size(); i++)
|
|
{
|
|
CHexRecord *rec = mRecordsList.at(i);
|
|
unsigned int StartAddress = rec->GetStartAddress();
|
|
unsigned int Size = rec->GetRecordSizeInBytes();
|
|
unsigned int EndAddress = StartAddress + Size;
|
|
string.append(QString("Record %1: Start = [0x%2], Length = [%3], End = 0x%4\n").arg(i).arg(StartAddress,0,16).arg(Size).arg(EndAddress,0,16));
|
|
}
|
|
string.prepend("-------------------------------------------------------------\n");
|
|
string.append("-------------------------------------------------------------\n");
|
|
|
|
return string;
|
|
}
|
|
|
|
|