void AssertCacheElement(CMemoryCache* pcCache, SMemoryCacheDescriptor* psCacheDesc, int iDataSize, char cExpected)
{
char* szData;
CChars szExpected;
AssertInt(iDataSize, psCacheDesc->iDataSize);
AssertInt(1, psCacheDesc->iFlags);
szData = (char*)pcCache->GetData(psCacheDesc);
szExpected.Init();
szExpected.Append(cExpected, iDataSize-1);
AssertString(szExpected.Text(), szData);
szExpected.Kill();
}
BOOL PrivateAssertFileMemory(char* szExpectedFileName, void* pcMemory, int iLength, int iLine, char* szFile)
{
CFileCompare cCompare;
BOOL bResult;
CChars szExpected;
CChars szActual;
szExpected.Init();
szActual.Init();
bResult = cCompare.Compare(szExpectedFileName, pcMemory, iLength, &szExpected, &szActual);
if (!bResult)
{
bResult = Fail(szExpected.Text(), szActual.Text(), iLine, szFile);
szActual.Kill();
szExpected.Kill();
return bResult;
}
else
{
return Pass();
}
}
void CBaseObject::ValidateHasClass(void)
{
CChars sz;
if (!HasClass())
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} does not have Class initialised.", NULL);
sz.Kill();
}
}
BOOL CImageCelsSourceXML::ImportCelSource(CMarkupTag* pcBrushSourceTag, char* szTexturePath)
{
CMarkupTag* pcFileName;
CChars szFileName;
CChars szShortFileName;
BOOL bResult;
CMarkupTag* pcCels;
CFileUtil cFileUtil;
pcFileName = CMarkupTextParser::GetTag(pcBrushSourceTag, "FileName");
if (!pcFileName)
{
return FALSE;
}
szShortFileName.Init();
pcFileName->GetText(&szShortFileName);
if (szFileName.Empty())
{
szShortFileName.Kill();
CMarkupTextParser::LogErrorTagWasEmpty(pcBrushSourceTag);
return FALSE;
}
pcCels = CMarkupTextParser::GetTag(pcBrushSourceTag, "Cels");
if (!pcCels)
{
szShortFileName.Kill();
return FALSE;
}
szFileName.Init(szTexturePath);
cFileUtil.AppendToPath(&szFileName, szShortFileName.Text());
bResult = ImportCels(pcCels, szFileName.Text());
return bResult;
}
void PrivateBeginTests(char* szFile)
{
CChars sz;
giTestsRun = 0;
giTestsPassed = 0;
giTestsFailed = 0;
sz.Init();
sz.Append("--------------- ");
sz.Append(szFile);
sz.Append(" ---------------\n");
gcLogger.Add(sz.Text());
sz.Kill();
}
void CChars::Dump(void)
{
CChars sz;
int i;
if (Length() <= 10000)
{
if (Length() > 0)
{
EngineOutput(Text());
}
return;
}
for (i = 0; i < Length()-10000; i+=10000)
{
sz.Init(Text(), i, i+10000);
EngineOutput(sz.Text());
sz.Kill();
}
sz.Init(Text(), i, Length());
EngineOutput(sz.Text());
sz.Kill();
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CArrayString::Kill(void)
{
int i;
CChars* pcChars;
if (!mbFaked)
{
for (i = 0; i < mcArray.NumElements(); i++)
{
pcChars = mcArray.Get(i);
pcChars->Kill();
}
}
mcArray.Kill();
}
void CInputDeviceDesc::Dump(void)
{
CTextFile cFile;
CChars szName;
cFile.Init();
ToString(&cFile.mcText);
szName.Init("../");
szName.Append(mszFriendlyName.Text());
szName.Append(".txt");
cFile.Write(szName.Text());
szName.Kill();
cFile.Kill();
}
void CLibrary::Init(char* szName, char* szBaseDir, CHeaderFileMap* pcHeaderFileMap)
{
CFileUtil cFileUtil;
CChars szPath;
szPath.Init(szBaseDir);
cFileUtil.FullPath(&szPath);
mszName.Init(szName);
mszBaseDir.Init(szPath);
szPath.Kill();
mcConfigs.Init();
mcTranslationUnits.Init(this);
mcHeaderNameMap.Init(mszBaseDir.Text(), pcHeaderFileMap, FALSE);
}
void CPointer::Dump(void)
{
CChars sz;
CBaseObject* pvBaseObject = BaseObject();
if (pvBaseObject)
{
pvBaseObject->Dump();
}
else
{
sz.Init("NULL\n");
sz.Dump();
sz.Kill();
}
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CArrayString::Dump(void)
{
int i;
CChars* psz;
CChars sz;
sz.Init(1024);
for (i = 0; i < mcArray.NumElements(); i++)
{
psz = mcArray.Get(i);
sz.Append(psz);
sz.AppendNewLine();
}
sz.Dump();
sz.Kill();
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
BOOL CArrayString::Split(char* szString, char cSplitter)
{
CChars szTemp;
szTemp.Init(szString);
if (!szTemp.Empty())
{
szTemp.Split(this, cSplitter);
szTemp.Kill();
return TRUE;
}
else
{
return FALSE;
}
}
BOOL CPackFiles::AddDirectory(char* szDirectory, char* szPackDirectory)
{
CFileUtil cFileUtil;
CArrayChars aszFileNames;
int i;
CChars* pszFileName;
CDiskFile cDiskFile;
CChars szName;
CChars szNameDirectory;
BOOL bResult;
BOOL bAnyFiles;
aszFileNames.Init();
bAnyFiles = cFileUtil.FindAllFiles(szDirectory, &aszFileNames, TRUE, FALSE);
if (!bAnyFiles)
{
aszFileNames.Kill();
return FALSE;
}
szNameDirectory.Init(szDirectory);
for (i = 0; i < aszFileNames.NumElements(); i++)
{
pszFileName = aszFileNames.Get(i);
cDiskFile.Init(pszFileName->Text());
cFileUtil.MakeNameFromDirectory(&szName, pszFileName, &szNameDirectory);
if (szPackDirectory)
{
szName.Insert(0, '/');
szName.Insert(0, szPackDirectory);
}
bResult = AddFile(&cDiskFile, szName.Text());
szName.Kill();
cDiskFile.Kill();
if (!bResult)
{
aszFileNames.Kill();
return FALSE;
}
}
aszFileNames.Kill();
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
SCTokenBlock CPreprocessor::ProcessHashElif(CPreprocessorTokenParser* pcParser, CPPConditional* pcCond, SCTokenBlock iLine)
{
BOOL bEvaluated;
CPPTokenHolder cTokenHolder;
CChars sz;
cTokenHolder.Init(32);
ProcessLine(&cTokenHolder, pcParser, TRUE, 0);
sz.Init(128);
cTokenHolder.Append(&sz);
bEvaluated = Evaluate(sz.Text());;
mcConditionalStack.SwapForElseIf(bEvaluated);
sz.Kill();
cTokenHolder.Kill();
return Condition(pcCond, iLine);
}
CTranslationUnit* CTranslationUnitFileArray::AddFile(char* szRelativeFileName, BOOL bLogIncludes, BOOL bLogBlocks)
{
CChars szTemp;
CTranslationUnit* pcTranslationUnit;
CTranslationUnit cTranslationUnit;
szTemp.Init(mpcLibrary->mszBaseDir);
szTemp.Append(FILE_SEPARATOR);
szTemp.Append(szRelativeFileName);
cTranslationUnit.Init(8, szTemp.Text(), mpcLibrary, bLogIncludes, bLogBlocks);
szTemp.Kill();
pcTranslationUnit = mcFiles.InsertAfterTail();
memcpy(pcTranslationUnit, &cTranslationUnit, sizeof(CTranslationUnit));
pcTranslationUnit->macBlockSets.mpcFile = pcTranslationUnit;
return pcTranslationUnit;
}
void CObjects::ValidateEmpty(void)
{
OIndex iNumIndexed;
iNumIndexed = mcMemory.NumIndexed();
if (iNumIndexed != 0)
{
CChars sz;
sz.Init("\n");
sz.Append("Memory not empty. ");
sz.Append(iNumIndexed);
sz.Append(" objects are still indexed.\n");
PrintMemory(&sz);
gcLogger.Error(sz.Text());
sz.Kill();
}
}
void CTranslationUnitFileArray::AddAllFiles(BOOL bLogInlucdes, BOOL bLogBlocks)
{
CChars szTemp;
CArrayString aszTemp;
int i;
CChars* pszFile;
int iIndex;
int j;
CChars* szFile;
char* szExtension;
int iBaseDirLen;
CFileUtil cFileUtil;
CArrayString aszFileNames;
szTemp.Init("*.c;*.cpp");
aszTemp.Init(16);
szTemp.Split(&aszTemp, ';');
iBaseDirLen = mpcLibrary->mszBaseDir.Length();
for (i = 0; i < aszTemp.NumElements(); i++)
{
pszFile = aszTemp.Get(i);
pszFile->StripWhiteSpace();
iIndex = pszFile->Find(0, ".");
szExtension = pszFile->Text(iIndex+1);
aszFileNames.Init(32);
cFileUtil.FindFilesWithExtension(mpcLibrary->mszBaseDir.Text(), szExtension, &aszFileNames);
for (j = 0; j < aszFileNames.NumElements(); j++)
{
szFile = aszFileNames.Get(j);
AddFile(szFile->Text(iBaseDirLen+1), bLogInlucdes, bLogBlocks);
}
aszFileNames.Kill();
}
szTemp.Kill();
aszTemp.Kill();
}
CPackFile* CFiles::GetPackFile(CPackFileOffset* pcPackFiles, char* szFullName)
{
CFileNodePackFileNode* pcNode;
CPackFile* pcPackFile;
CChars sz;
sz.Init(szFullName, pcPackFiles->mszOffset.Length()+1);
pcNode = pcPackFiles->mcPackFiles.GetNode(sz.Text());
sz.Kill();
if (pcNode)
{
pcPackFile = PackFile(&pcPackFiles->mcPackFiles, pcNode->File());
return pcPackFile;
}
else
{
return NULL;
}
}
void TestFileSystemIteration(void)
{
CFileSystem cFileSystem;
CFileSystemIterator cIter;
CSystemFileNode* pcSystemFile;
CChars szName;
int i;
CArrayChars aszExpected;
CChars* pszExpected;
aszExpected.Init();
aszExpected.AddList("Models/Super/Barbie.txt",
"Models/Super/Ken.txt",
"Models/Cars.txt",
"Sounds/Santa/Seattle.txt",
"Sounds/Ambient.txt",
"Sounds/Cheese.PAK",
"Sounds/Santa.PAK",
"Videos/Intro.txt",
"Videos/Outro.txt",
"Models.PAK",
"Sounds.PAK",
"Textures.PAK",
"Videos.PAK",
NULL);
cFileSystem.Init("Game");
i = 0;
pcSystemFile = cFileSystem.StartIteration(&cIter);
while (pcSystemFile)
{
szName.Init();
pcSystemFile->GetFullName(&szName);
pszExpected = aszExpected.Get(i);
AssertString(pszExpected->Text(), szName.Text());
szName.Kill();
i++;
pcSystemFile = cFileSystem.Iterate(&cIter);
}
aszExpected.Kill();
}
void CNamedIndexesOptimiser::DeleteFiles(void)
{
int i;
CNamedIndexesBlocks* pcBlocks;
CIndexedFile* pcIndexedFile;
CFileUtil cFileUtil;
CChars szFullName;
for (i = 0; i < mpacBlocks->NumElements(); i++)
{
pcBlocks = mpacBlocks->Get(i);
pcIndexedFile = GetFile(pcBlocks->GetDataSize(), pcBlocks->GetFileNumber());
if (pcIndexedFile)
{
cFileUtil.Delete(TempFileName(&szFullName, pcIndexedFile->GetFileName()));
szFullName.Kill();
}
}
}
BOOL CPackFiles::RecurseWriteUnwrittenNames(CFileNodePackFileNode* pcNode, CChars* pszPath)
{
CFileNodePackFileNode* pcChild;
int i;
BOOL bResult;
int iPathLength;
CChars szPath;
if (pcNode->IsDirectory())
{
iPathLength = pszPath->Length();
for (i = 0; i < pcNode->Directory()->maNodeFiles.NumElements(); i++)
{
pcChild = (CFileNodePackFileNode*)pcNode->Directory()->maNodeFiles.Get(i);
pszPath->Append("/");
pszPath->Append(pcChild->GetName());
bResult = RecurseWriteUnwrittenNames(pcChild, pszPath);
pszPath->SetLength(iPathLength);
if (!bResult)
{
return FALSE;
}
}
return TRUE;
}
else if (pcNode->IsFile())
{
if (!pcNode->File()->IsNameWritten())
{
szPath.Init(pszPath->Text(1));
ReturnOnFalse(szPath.WriteString(&mcFile));
szPath.Kill();
return pcNode->File()->Save(&mcFile);
}
return TRUE;
}
else
{
return FALSE;
}
}
void CPlainTextEditor::Paste(char* szSource)
{
CChars szTemp;
if (!IsSelected())
{
szTemp.Init(szSource);
szTemp.PassifyNewlines();
mszText.Insert(miEditPos, &szTemp);
miEditPos += szTemp.Length();
szTemp.Kill();
ResetUpDown();
}
else
{
OverwriteSelection(szSource);
}
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CPreprocessor::LogIncludes(CCFile* pcFile)
{
CChars sz;
if (mbLogInlucdes)
{
sz.Init();
sz.Append(' ', miIncludeDepth*4);
sz.Append(" ");
sz.Append(pcFile->ShortName());
sz.Append("\n");
if (mbDumpLogs)
{
sz.Dump();
}
mpszIncludesLog->Append(sz);
sz.Kill();
}
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CPreprocessor::ProcessHashError(CPreprocessorTokenParser* pcParser)
{
CChars szError;
CPPToken* pcToken;
pcParser->SkipWhiteSpace();
szError.Init("Error (");
szError.Append(mpcCurrentFile->ShortName());
szError.Append("):");
while (pcParser->HasToken())
{
pcToken = pcParser->GetToken();
pcToken->Append(&szError);
pcParser->NextToken();
}
szError.AppendNewLine();
szError.Dump();
szError.Kill();
}
void CIndexedMemory::Dump(void)
{
int iNumElements;
int i;
SIndexedMemory* psIndexedMemory;
void* pvDest;
CChars sz;
sz.Init();
iNumElements = mcDatas.NumElements();
sz.Append("Transaction Data (");
sz.Append(iNumElements);
sz.Append(") (Memory)\n-----------------\n");
for (i = 0; i < iNumElements; i++)
{
mcDatas.Get(i, (void**)&psIndexedMemory);
pvDest = RemapSinglePointer(psIndexedMemory, sizeof(SIndexedMemory));
sz.Append("Index[");
sz.Append((int)psIndexedMemory->oi);
sz.Append("] Size[");
sz.Append((int)psIndexedMemory->uiSize);
sz.Append("] ");
if (psIndexedMemory->uiSize > 0)
{
sz.Append("\"");
sz.AppendData((char*)pvDest, 80);
sz.Append("\" ");
}
if (psIndexedMemory->IsRemoved())
{
sz.Append("(Removed)");
}
sz.Append("\n");
}
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void CPreprocessor::LogBlocks(CCFile* pcFile, SCTokenBlock sResult)
{
CChars szLine;
CCBlockSet* pcBlocksSet;
if (mbLogBlocks)
{
szLine.Init();
szLine.Append(mpcCurrentFile->ShortName());
if (mcConditionalStack.IsParsing())
{
szLine.Append(" (Parsing): ");
}
else
{
szLine.Append(" : ");
}
sResult.Append(&szLine);
pcBlocksSet = pcFile->macBlockSets.SafeGet(sResult.iBlockIndex);
if (!pcBlocksSet)
{
szLine.AppendNewLine();
}
else
{
szLine.Append(" (");
szLine.Append(pcBlocksSet->miLine);
szLine.Append(")\n");
}
if (mbDumpLogs)
{
szLine.Dump();
}
mpszBlocksLog->Append(szLine);
szLine.Kill();
}
}
void CTransientIndexedFile::Dump(void)
{
int iNumElements;
int i;
SIndexedMemory* psIndexedMemory;
void* pvDest;
CChars sz;
sz.Init();
iNumElements = NumDatas();
sz.Append("Transaction Data (");
sz.Append(iNumElements);
sz.Append(") (Huge)\n-----------------\n");
for (i = 0; i < iNumElements; i++)
{
psIndexedMemory = GetIndexedData(i);
pvDest = GetData(psIndexedMemory);
sz.Append("Index[");
sz.Append((int)psIndexedMemory->oi);
sz.Append("] Size[");
sz.Append((int)psIndexedMemory->uiSize);
sz.Append("] ");
if (psIndexedMemory->uiSize > 0)
{
sz.Append("\"");
sz.AppendData((char*)pvDest, 80);
sz.Append("\" ");
}
if (psIndexedMemory->IsRemoved())
{
sz.Append("(Removed)");
}
sz.Append("\n");
}
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
BOOL CChars::AppendData2(const char* szData, int iDataLength)
{
int i;
int iPrintable;
unsigned char c;
float fPrintable;
CChars sz;
iPrintable = StrPrintable(szData, iDataLength);
fPrintable = (float)iPrintable / (float)iDataLength;
if (fPrintable >= 0.9f)
{
Append(szData, iDataLength);
return FALSE;
}
else
{
Append("0x");
sz.Init();
for (i = 0; i < iDataLength; i++)
{
c = szData[i];
sz.Clear();
sz.Append((int)c, 16);
sz.RightAlign('0', 2);
Append(sz);
if (i != iDataLength - 1)
{
Append(' ');
}
}
sz.Kill();
}
return TRUE;
}
void CObjects::DumpGraph(void)
{
CChars sz;
Ptr<CRoot> pRoot;
sz.Init("-------------------------- Graph --------------------------- \n");
pRoot = Get(ROOT_NAME);
if (pRoot.IsNotNull())
{
RecurseDumpGraph(&sz, pRoot.Object(), 0, FALSE);
}
sz.Append("------------------------------------------------------------ \n");
sz.Dump();
sz.Kill();
SIndexesIterator sIter;
CBaseObject* pcBaseObject;
CBaseObject* pcEmbeddedObject;
CObject* pcObject;
int i;
pcBaseObject = mcMemory.StartIteration(&sIter);
while (pcBaseObject)
{
SetFlag(&pcBaseObject->miFlags, OBJECT_FLAGS_DUMPED, FALSE);
if (pcBaseObject->IsObject())
{
pcObject = (CObject*)pcBaseObject;
for (i = 0; i < pcObject->mapEmbedded.NumElements(); i++)
{
pcEmbeddedObject = *pcObject->mapEmbedded.Get(i);
SetFlag(&pcEmbeddedObject->miFlags, OBJECT_FLAGS_DUMPED, FALSE);
}
}
pcBaseObject = mcMemory.Iterate(&sIter);
}
}
void CNamedIndexesBlock::Dump(void)
{
CArrayBlock avFakeBlock;
CChars szText;
if (IsCached())
{
avFakeBlock.Fake(miBlockWidth, mpvCachePos, (int)miUsedBlocks, (int)miBlockChunkSize);
Dump(&avFakeBlock);
}
else
{
szText.Init("--- Block(Not Cached) ---\n");
szText.Append("(");
szText.Append(mszFirst.Text());
szText.Append(") -> (");
szText.Append(mszLast.Text());
szText.Append(")\n\n");
szText.Dump();
szText.Kill();
}
}
