int TestTotalStatistics(void)
{
CChars sz;
clock_t time;
time = clock() - gClock;
sz.Init();
sz.Append("------------------------------ Total Results ------------------------------\n");
if (giTotalTestsRun > 0)
{
sz.Append("Total Tests Run: ");
sz.Append(giTotalTestsRun);
sz.AppendNewLine();
sz.Append("Total Passed: ");
sz.Append(giTotalTestsPassed);
sz.AppendNewLine();
sz.Append("Total Failed: ");
sz.Append(giTotalTestsFailed);
sz.AppendNewLine();
sz.AppendNewLine();
sz.Append("Time Taken: ");
sz.Append((float)time / ((float)CLOCKS_PER_SEC));
sz.Append("s");
sz.AppendNewLine();
sz.AppendNewLine();
gcLogger.Add(sz.Text());
sz.Kill();
}
gcLogger.Kill();
return giTotalTestsFailed;
}
CNumber CCalculator::Eval(char* szText)
{
CCalcExpression* pcExpression;
CNumber cAnswer;
BOOL bResult;
CChars sz;
mcParser.Init(szText);
bResult = Expression(&pcExpression);
mcParser.Kill();
if (bResult)
{
cAnswer = pcExpression->Evaluate();
SafeKill(pcExpression);
}
else
{
sz.Init("Cannot evaluate expression [");
sz.Append(szText);
sz.Append("]\n");
gcUserError.Set(sz.Text());
sz.Kill();
cAnswer.Zero();
}
return cAnswer;
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
CPPToken* CPreprocessor::QuoteTokens(CPPTokenHolder* pcDest, CPPAbstractHolder* pcHolder)
{
int j;
BOOL bQuoteNextReplacement;
CChars szQuoted;
char* szInStrings;
CPPText* pcQuoted;
CPPToken* pcToken;
szQuoted.Init(100);
szQuoted.Append('"');
for (j = 0; j < pcHolder->mcTokens.mcArray.NumElements(); j++)
{
pcToken = *(pcHolder->mcTokens.mcArray.Get(j));
pcToken->Append(&szQuoted);
}
szQuoted.Append('"');
bQuoteNextReplacement = FALSE;
szInStrings = (char*)gcTokenStrings.Add(szQuoted.Length()+1);
memcpy(szInStrings, szQuoted.Text(), szQuoted.Length()+1);
pcQuoted = CPPText::Construct(mpcStack->Add(sizeof(CPPText)));
pcQuoted->Init(PPT_DoubleQuoted, -1, -1, szInStrings, szInStrings+szQuoted.Length());
pcDest->Add((CPPToken**)&pcQuoted);
szQuoted.Kill();
return pcQuoted;
}
void CLogFile::Dump(void)
{
CChars sz;
int i;
char* pvData;
CLogFileCommandWrite* psWrite;
filePos iLen;
sz.Init();
sz.Append("Log File (?");
sz.Append(")\n------------------\n");
sz.Append("Commands: ");
sz.Append(macCommands.NumElements());
sz.AppendNewLine();
for (i = 0; i < macCommands.NumElements(); i++)
{
macCommands.Get(i, (void**)&pvData);
sz.Append(" ");
sz.Append("Write: (");
psWrite = (CLogFileCommandWrite*)pvData;
sz.Append(psWrite->iPosition);
sz.Append(", ");
sz.Append(psWrite->iSize);
sz.Append(") ");
pvData = (char*)RemapSinglePointer(psWrite, sizeof(CLogFileCommandWrite));
iLen = psWrite->iSize;
sz.AppendData(pvData, 80);
sz.AppendNewLine();
}
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
BOOL CObjectWriterChunked::Begin(void)
{
CDiskFile* pcDiskFile;
CFileUtil cFileUtil;
CChars szFullDirectory;
CChars szFileName;
CObjectWriter::Begin();
szFullDirectory.Init(mszDirectory);
cFileUtil.AppendToPath(&szFullDirectory, mszObjectBaseName.Text());
cFileUtil.MakeDir(szFullDirectory.Text());
szFileName.Init(szFullDirectory);
szFullDirectory.Kill();
cFileUtil.AppendToPath(&szFileName, mszFileName.Text());
szFileName.Append(".");
szFileName.Append(OBJECT_FILE_EXTENSION);
pcDiskFile = DiskFile(szFileName.Text());
szFileName.Kill();
mcChunkFile.Init(pcDiskFile);
return mcChunkFile.WriteOpen(CHUNKED_OBJECT_FILE);
}
BOOL CMeshConverter::CreateLinkNodes(void)
{
int i;
CConnection* pcConnection;
SFloat4x4* psWorldMatrix;
SFloat4x4* psMatrix;
float fDeterminant;
CMeshObjectNode* pcLinkNode;
int iConnectionIndex;
//Link nodes are created here so that the reference meshes matricies can be whatevered.
mpcConnectionsAndIndices->Get(0, (void**)&pcConnection, &iConnectionIndex);
if (pcConnection)
{
psWorldMatrix = (SFloat4x4*)&pcConnection->msWorldMatrix;
for (i = 1; i < mpcConnectionsAndIndices->NumElements(); i++)
{
mpcConnectionsAndIndices->Get(i, (void**)&pcConnection, &iConnectionIndex);
psMatrix = (SFloat4x4*)&pcConnection->msWorldMatrix;
if (i == 1)
{
pcLinkNode = mpcMeshObject->GetNodes()->InsertBeforeHead();
}
else
{
pcLinkNode = mpcMeshObject->GetNodes()->InsertAfterNode(pcLinkNode);
}
pcLinkNode->psToSubObjectSpaceFromZeroSpace = mpcSceneConverter->GetWorld()->CreateMatrix();
pcLinkNode->psToZeroSpaceFromSubObjectSpace = mpcSceneConverter->GetWorld()->CreateMatrix();
if (Float4x4Inverse(&pcLinkNode->psToSubObjectSpaceFromZeroSpace->sD3DMatrix, &fDeterminant, psMatrix) == NULL)
{
gcUserError.Set("Matrix has no inverse");
return FALSE;
}
}
return TRUE;
}
else
{
CChars sz;
sz.Init("The Mesh [");
sz.Append(mpcMesh->GetName());
sz.Append("] has no Connection (root node matrix).");
gcUserError.Set(sz.Text());
sz.Kill();
return FALSE;
}
}
void CDirectInputDetail::Dump(void)
{
CChars sz;
sz.Init();
sz.Append("Joystick ");
sz.Append(": ");
sz.Append(szID);
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
void CWindow::EndingWinloop(char* szReason)
{
CChars szShutdown;
mcLoopTimer.Update();
szShutdown.Init("Shutdown winloop [");
szShutdown.Append(szReason);
szShutdown.Append("] - ");
mcLoopTimer.HumanReadable(&szShutdown);
mcLoopTimer.Kill();
szShutdown.AppendNewLine();
gcLogger.Add(szShutdown.Text());
}
void CNamedIndexesBlock::Dump(CArrayBlock* pavFakeBlock)
{
int i;
CNamedIndexedBlock* pvcBlock;
CChars szText;
szText.Init("--- Block(");
szText.Append(pavFakeBlock->NumElements());
szText.Append(") ---\n");
szText.Append("(");
szText.Append(mszFirst.Text());
szText.Append(") -> (");
szText.Append(mszLast.Text());
szText.Append(")\n");
for (i = 0; i < pavFakeBlock->NumElements(); i++)
{
pvcBlock = (CNamedIndexedBlock*)pavFakeBlock->Get(i);
szText.Append(pvcBlock->Name());
szText.AppendNewLine();
}
szText.AppendNewLine();
szText.Dump();
szText.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 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();
}
CInputVirtualDevice* CInputDevice::CreateDefaultVirtualDeviceFromThis(char* szName)
{
CInputVirtualDevice* pcVirtual;
SSetIterator sIter;
CInputSourceDesc* pcSource;
CInputDevices* pcInputDevices;
CChars szTemp;
pcInputDevices = GetInputDevices();
if (szName)
{
szTemp.Init(szName);
}
else
{
szTemp.Init(mszFriendlyName.Text());
szTemp.Append(" Default");
}
pcVirtual = pcInputDevices->CreateVirtualDevice(szTemp.Text());
szTemp.Kill();
pcSource = mpcDesc->StartInputsIteration(&sIter);
while (pcSource)
{
pcVirtual->AddSource(this, pcSource);
pcSource = mpcDesc->IterateInputs(&sIter);
}
pcVirtual->DoneAddingSources();
pcInputDevices->UpdateCommonality();
return pcVirtual;
}
CInputVirtualDevice* CInputDevice::CreateVariableVirtualDeviceFromThis(CInputActions* pcInputActions)
{
CInputVirtualDevice* pcVirtual;
CInputSourceDesc* pcSource;
CInputDevices* pcInputDevices;
CChars szTemp;
CArrayIntAndPointer apcSourceDescs;
int i;
pcInputDevices = GetInputDevices();
szTemp.Init(mszFriendlyName.Text());
szTemp.Append(" Variable");
pcVirtual = pcInputDevices->CreateVirtualDevice(szTemp.Text());
szTemp.Kill();
mcVariables.SetChords(pcVirtual->GetChords());
apcSourceDescs.Init(8);
mpcDesc->GetVariableChordDescs()->GetInputSourceDescs(&apcSourceDescs, mpcDesc);
for (i = 0; i < apcSourceDescs.NumElements(); i++)
{
pcSource = (CInputSourceDesc*)apcSourceDescs.GetPtr(i);
pcVirtual->AddSource(this, pcSource);
}
apcSourceDescs.Kill();
pcVirtual->DoneAddingSources();
GetInputDevices()->AddChords(pcVirtual, mpcDesc->GetVariableChordDescs(), this);
pcInputDevices->UpdateCommonality();
pcVirtual->Unstoppable();
return pcVirtual;
}
void TestFileUtilTouchDirectory(void)
{
CFileUtil cFileUtil;
CChars szDirectory;
CChars szFileName;
cFileUtil.RemoveDir("file_util");
szDirectory.Init("file_util" _FS_ "directory" _FS_ "make" _FS_ "test");
cFileUtil.FullPath(&szDirectory);
szFileName.Init(szDirectory);
cFileUtil.AppendToPath(&szFileName, "Warthog.PIG");
AssertTrue(cFileUtil.TouchDir(szFileName.Text()));
AssertTrue(cFileUtil.Touch(szFileName.Text()));
szDirectory.Kill();
szFileName.Kill();
cFileUtil.RemoveDir("file_util");
AssertFalse(cFileUtil.TouchDir("C:\\Warthog.PIG"));
AssertFalse(cFileUtil.TouchDir("\\Warthog.PIG"));
szDirectory.Init();
cFileUtil.CurrentDirectory(&szDirectory);
szDirectory.Append("War-pig.hog");
AssertFalse(cFileUtil.TouchDir(szDirectory.Text()));
szDirectory.Kill();
}
void CUnknowns::DumpAddDetail(CUnknown* pcUnknown)
{
SMemoryAllocation* psAlloc;
CChars sz;
psAlloc = MEMORY_GET_ALLOCATION(pcUnknown);
if (!IsFreed(pcUnknown))
{
sz.Init("Size: ");
sz.Append(psAlloc->uiSize);
sz.AppendNewLine();
sz.Append("AllocCount: ");
sz.Append(psAlloc->uiAllocCount);
sz.AppendNewLine();
sz.Append("DebugName: ");
sz.Append(psAlloc->szDebug, 4);
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
else
{
sz.Init("Freed CUnknown.\n");
sz.Append("AllocCount: ");
sz.Append(psAlloc->uiAllocCount);
sz.AppendNewLine();
sz.Dump();
sz.Kill();
}
}
void PrivateTestStatistics(void)
{
CChars sz;
sz.Init();
if (giTestsRun > 0)
{
sz.Append("Tests Run: ");
sz.Append(giTestsRun);
sz.AppendNewLine();
sz.Append("Passed: ");
sz.Append(giTestsPassed);
sz.AppendNewLine();
sz.Append("Failed: ");
sz.Append(giTestsFailed);
}
else
{
sz.Append("No Tests Run!");
}
sz.AppendNewLine();
sz.AppendNewLine();
gcLogger.Add(sz.Text());
sz.Kill();
}
BOOL Fail(char* szExpected, char* szActual, int iLine, char* szFile)
{
char szLine[1024];
CChars szError;
Fail();
IToA(iLine, szLine, 10);
szError.Init("Failed: ");
szError.Append(szFile);
szError.Append(" line ");
szError.Append(szLine);
szError.AppendNewLine();
szError.Append("Expected: ");
szError.Append(szExpected);
szError.AppendNewLine();
szError.Append("Actual: ");
szError.Append(szActual);
szError.AppendNewLine();
szError.AppendNewLine();
gcLogger.Add(szError.Text());
szError.Kill();
return FALSE;
}
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 CObjects::DumpIndex(void)
{
CChars sz;
sz.Init("-------------------------- Indices -------------------------- \n");
PrintMemory(&sz);
sz.Append("------------------------------------------------------------ \n");
sz.Dump();
sz.Kill();
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
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();
}
BOOL CTransientIndexedFile::DataFileName(char* szFile1, int iDataSize, int iFileNum)
{
CChars szFileName;
szFileName.Init(mszDirectory);
szFileName.Append(FILE_SEPARATOR);
szFileName.Append(iDataSize);
szFileName.Append("_");
szFileName.Append(iFileNum);
szFileName.Append(".DAT");
if (szFileName.Length() < 65536)
{
strcpy(szFile1, szFileName.Text());
szFileName.Kill();
return TRUE;
}
szFileName.Kill();
return FALSE;
}
void CObjects::DumpNames(void)
{
CChars sz;
sz.Init("-------------------------- Names -------------------------- \n");
sz.Dump();
sz.Kill();
// mcMemory.GetNames()->DumpTree();
sz.Init();
sz.Append("------------------------------------------------------------ \n");
sz.Dump();
sz.Kill();
}
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();
}
}
char* MethodToString(char* szFile, int iLine, char* szFunction)
{
int iCount = IncrementLogToStringCount();
char* sz = gaszLogToStringScratchPad[iCount];
CChars szOutput;
CFileUtil cFileUtil;
szOutput.Init();
szOutput.Append(szFile);
cFileUtil.RemovePath(&szOutput);
szOutput.Insert(0, '(');
szOutput.Append(':');
szOutput.Append(iLine);
szOutput.Append(") ");
szOutput.Append(szFunction);
StrCpySafe(sz, szOutput.Text(), LOG_TO_STRING_MAX_LENGTH);
szOutput.Kill();
return sz;
}
void CDurableFileController::InitFile(CDurableFile* pcFile, char* szDescricptorName, char* szDescricptorRewrite)
{
CChars szName;
CChars szRewrite;
szName.Init(GetDirectory());
szName.Append(FILE_SEPARATOR);
szName.Append(szDescricptorName);
if (IsDurable())
{
szRewrite.Init(GetRewriteDirectory());
szRewrite.Append(FILE_SEPARATOR);
szRewrite.Append(szDescricptorRewrite);
}
else
{
szRewrite.Init();
}
pcFile->Init(this, szName.Text(), szRewrite.Text());
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
void SFloat4::ToString(CChars* psz, int iWholeNumbers, int iDecimals)
{
CChars sz;
int iWidth;
if (iWholeNumbers == -1)
{
iWholeNumbers = WholeNumbers();
iWholeNumbers++;
if (iWholeNumbers < 2)
{
iWholeNumbers = 2;
}
}
iWidth = iWholeNumbers + 1 + iDecimals;
psz->Append('[');
sz.Init();
sz.Append(x, iDecimals);
sz.RightAlign(' ', iWidth);
psz->Append(sz);
psz->Append(',');
sz.Clear();
sz.Append(y, iDecimals);
sz.RightAlign(' ', iWidth);
psz->Append(sz);
psz->Append(',');
sz.Clear();
sz.Append(z, iDecimals);
sz.RightAlign(' ', iWidth);
psz->Append(sz);
psz->Append(',');
sz.Clear();
sz.Append(w, iDecimals);
sz.RightAlign(' ', iWidth);
psz->Append(sz);
psz->Append(']');
sz.Kill();
}
BOOL CPackFiles::RecurseUnpack(CFileNodePackFileNode* pcNode, char* szDestination)
{
CChars szFileName;
CFileNodePackFileNode* pcChild;
int i;
CPackFileNode* pcFile;
BOOL bResult;
CPackFile* pcPackFile;
CFileCopier cCopier;
CDiskFile cDiskFile;
CFileUtil cFileUtil;
if (pcNode->IsDirectory())
{
bResult = TRUE;
for (i = 0; i < pcNode->Directory()->maNodeFiles.NumElements(); i++)
{
pcChild = (CFileNodePackFileNode*)pcNode->Directory()->maNodeFiles.Get(i);
bResult &= RecurseUnpack(pcChild, szDestination);
}
return bResult;
}
else if (pcNode->IsFile())
{
szFileName.Init(szDestination);
szFileName.Append('/');
pcNode->GetFullName(&szFileName);
szFileName.Replace('/', FILE_SEPARATOR[0]);
pcFile = pcNode->File();
pcPackFile = PackFile(this, pcFile);
if (!pcPackFile)
{
szFileName.Kill();
return FALSE;
}
cDiskFile.Init(szFileName.Text());
cFileUtil.RemoveLastFromPath(&szFileName);
cFileUtil.MakeDir(szFileName.Text());
bResult = cCopier.Copy(pcPackFile, &cDiskFile);
cDiskFile.Kill();
szFileName.Kill();
return bResult;
}
return FALSE;
}
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();
}
