void CBaseObject::ValidateDistToRoot(void)
{
CChars sz;
CBaseObject* pcContainer;
if (!((miDistToRoot >= ROOT_DIST_TO_ROOT) || (miDistToRoot == UNATTACHED_DIST_TO_ROOT)))
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should not have a dist to root of [", IntToString(miDistToRoot), "].", NULL);
sz.Kill();
}
if (IsEmbedded())
{
pcContainer = GetEmbeddingContainer();
if (pcContainer->GetDistToRoot() != GetDistToRoot())
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should have a dist to root [", IntToString(miDistToRoot), "] the same as it's embedding object [", IntToString(pcContainer->GetDistToRoot()),"].", NULL);
sz.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 CBaseObject::ValidateIndex(void)
{
CChars sz;
if (IsEmbedded())
{
if (moi != INVALID_O_INDEX)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should have an Index [", IndexToString(moi), "] of INVALID_O_INDEX [", IndexToString(INVALID_O_INDEX),"].", NULL);
sz.Kill();
}
}
else
{
if (moi == INVALID_O_INDEX)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should not have an Index of INVALID_O_INDEX [", IndexToString(INVALID_O_INDEX),"].", NULL);
sz.Kill();
}
}
}
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();
}
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);
}
void CBaseObject::DumpFroms(void)
{
CChars sz;
int i;
int iNumEmbedded;
CEmbeddedObject* pcEmbedded;
int j;
int iNumHeapFroms;
CBaseObject* pcFromObject;
int iLength;
CChars szLine;
sz.Init();
sz.Append("-- ");
PrintObject(&sz);
sz.Append(" --\n");
iLength = sz.Length()-1;
szLine.Init('-', iLength);
szLine.AppendNewLine();
sz.Insert(0, &szLine);
sz.Append("Total Heap Froms [");
sz.Append(NumHeapFroms());
sz.Append("], ");
sz.Append("Stack Froms [");
sz.Append(NumStackFroms());
sz.Append("]\n");
iNumEmbedded = GetNumEmbedded();
for (i = 0; i < iNumEmbedded; i++)
{
pcEmbedded = GetEmbeddedObject(i);
iNumHeapFroms = pcEmbedded->CEmbeddedObject::NumHeapFroms();
sz.Append("Embedded ");
sz.Append(i);
sz.Append(" Heap Froms [");
sz.Append(iNumHeapFroms);
sz.Append("], ");
sz.Append("Stack Froms [");
sz.Append(pcEmbedded->CEmbeddedObject::NumStackFroms());
sz.Append("]\n");
for (j = 0; j < iNumHeapFroms; j++)
{
pcFromObject = pcEmbedded->GetHeapFrom(j);
sz.Append(" ");
pcFromObject->PrintObject(&sz);
sz.AppendNewLine();
}
}
sz.Append(&szLine);
szLine.Kill();
sz.Dump();
sz.Kill();
}
void CEmbeddedObject::ValidateFrom(CBaseObject* pcBaseObject)
{
CChars szObject;
CChars szFromObject;
int iThisDistToRoot;
int iOtherDistToRoot;
BOOL bFromPointsTo;
iThisDistToRoot = GetDistToRoot();
iOtherDistToRoot = pcBaseObject->GetDistToRoot();
if ((iThisDistToRoot >= ROOT_DIST_TO_ROOT && iOtherDistToRoot >= ROOT_DIST_TO_ROOT) && (iOtherDistToRoot < iThisDistToRoot - 1))
{
szObject.Init();
PrintObject(&szObject, IsEmbedded());
szFromObject.Init();
pcBaseObject->PrintObject(&szFromObject, pcBaseObject->IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", szObject.Text(), "} pointed to from object {", szFromObject.Text(), "} cannot have a DistToRoot that is different by more than 1.", NULL);
szFromObject.Kill();
szObject.Kill();
}
bFromPointsTo = pcBaseObject->ContainsPointerTo(this);
if (!bFromPointsTo)
{
szObject.Init();
PrintObject(&szObject, IsEmbedded());
szFromObject.Init();
pcBaseObject->PrintObject(&szFromObject, pcBaseObject->IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", szObject.Text(), "} pointed to from object {", szFromObject.Text(), "} does not have a from pointing to.", NULL);
szFromObject.Kill();
szObject.Kill();
}
}
void TestFileSystemInit(void)
{
CFileSystem cSystem;
char* szFullName;
CFileUtil cFileUtil;
CChars szWorkingDirectory;
CChars szTemp;
CTextFile cTextFile;
szWorkingDirectory.Init("Finder");
cFileUtil.FullPath(&szWorkingDirectory);
cSystem.Init("Finder");
szFullName = cSystem.GetFileName("Lord/1.rar");
szTemp.Init(szFullName);
szTemp.RemoveFromStart(szWorkingDirectory.Length()+1);
szTemp.Replace(FILE_SEPARATOR[0], '/');
AssertString("Lord/1.rar", szTemp.Text());
szTemp.Kill();
szFullName = cSystem.GetFileName("File.txt");
cTextFile.Init();
cTextFile.Read(szFullName);
AssertString("Hello World.", cTextFile.Text());
cTextFile.Kill();
cSystem.Kill();
}
void TestFileSystemNearest(void)
{
CFileSystem cSystem;
CFileUtil cFileUtil;
CChars szWorkingDirectory;
CFileNodeSystemFile* pcNode;
CChars szRemaining;
szWorkingDirectory.Init("Finder");
cFileUtil.FullPath(&szWorkingDirectory);
cSystem.Init("Finder");
szRemaining.Init();
pcNode = cSystem.GetFileNode("Lord/1.rar/Happy/Quan", &szRemaining);
AssertNotNull(pcNode);
AssertString("Happy/Quan", szRemaining.Text());
szRemaining.Kill();
szRemaining.Init();
pcNode = cSystem.GetFileNode("File.txt/Sad/Quan", &szRemaining);
AssertNotNull(pcNode);
AssertString("Sad/Quan", szRemaining.Text());
szRemaining.Kill();
cSystem.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;
}
void CBaseObject::ValidateObjectsThisIn(void)
{
CChars sz;
if (IsEmbedded())
{
if (mpcObjectsThisIn != NULL)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should not have ObjectsThisIn [", PointerToString(mpcObjectsThisIn), "] set.", NULL);
sz.Kill();
}
}
else
{
if (mpcObjectsThisIn == NULL)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should have ObjectsThisIn [NULL] set.", NULL);
sz.Kill();
}
}
}
void CBaseObject::ValidateCanFindRoot(void)
{
ValidateNotEmbedded(__METHOD__);
CChars sz;
BOOL bCanFindRoot;
if (miDistToRoot > ROOT_DIST_TO_ROOT)
{
bCanFindRoot = CanFindRoot();
if (!bCanFindRoot)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} has a positive dist to root and should be able to find the Root object.", NULL);
sz.Kill();
}
}
else if (miDistToRoot == ROOT_DIST_TO_ROOT)
{
if (!IsRoot())
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} has a dist to root [0] but is not the Root object.", NULL);
sz.Kill();
}
}
else if (miDistToRoot == UNATTACHED_DIST_TO_ROOT)
{
bCanFindRoot = CanFindRoot();
if (bCanFindRoot)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} has an [UNATTACHED_DIST_TO_ROOT] dist to root should not be able to find the Root object.", NULL);
sz.Kill();
}
}
else if (miDistToRoot == CLEARED_DIST_TO_ROOT)
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should not have dist to root [CLEARED_DIST_TO_ROOT].", NULL);
sz.Kill();
}
else
{
sz.Init();
PrintObject(&sz, IsEmbedded());
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should not have dist to root [", IntToString(miDistToRoot), "].", NULL);
sz.Kill();
}
}
void TestFileUtilNaming(void)
{
CFileUtil cFileUtil;
CChars sz;
CChars szExpected;
sz.Init();
cFileUtil.FullPath(&sz);
sz.LowerCase();
szExpected.Init("C:\\GameEngine\\Test\\TestBaseLib\\TestBaseLib");
szExpected.LowerCase();
AssertString(szExpected.Text(), sz.Text());
szExpected.Kill();
sz.Kill();
sz.Init("c:\\Documents and Settings\\Joe\\..\\..\\");
cFileUtil.CollapsePath(&sz);
AssertStringCase("C:\\", sz.Text(), FALSE);
sz.Kill();
sz.Init("\\Documents\\and\\Settings\\..\\..\\Joe");
cFileUtil.CollapsePath(&sz);
AssertString("\\Documents\\Joe", sz.Text());
sz.Kill();
sz.Init("\\Documents\\and\\Settings\\..\\..\\Joe\\");
cFileUtil.CollapsePath(&sz);
AssertString("\\Documents\\Joe", sz.Text());
sz.Kill();
sz.Init(".\\.\\.\\.");
cFileUtil.CollapsePath(&sz);
AssertString("", sz.Text());
sz.Kill();
sz.Init(".\\.\\.\\");
cFileUtil.CollapsePath(&sz);
AssertString("", sz.Text());
sz.Kill();
sz.Init("c:\\..");
cFileUtil.CollapsePath(&sz);
AssertString("c:", sz.Text());
sz.Kill();
sz.Init("c:\\..\\..");
cFileUtil.CollapsePath(&sz);
AssertString("c:", sz.Text());
sz.Kill();
sz.Init("\\..\\..");
cFileUtil.CollapsePath(&sz);
AssertString("", sz.Text());
sz.Kill();
}
void TestObjectsFlushNoClear(void)
{
CFileUtil cFileUtil;
BOOL bResult;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Flush1");
ObjectsInit("Output/Flush1");
SetupObjectsForDehollowfication();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
bResult = gcObjects.Flush(FALSE, FALSE);
AssertTrue(bResult);
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
AssertLongLongInt(6, gcObjects.NumDatabaseNames());
AssertLongLongInt(9, gcObjects.NumMemoryIndexes());
AssertLongLongInt(6, gcObjects.NumMemoryNames());
ObjectsKill();
CArrayChars aszFileNames;
int i;
CChars* psz;
CChars szOutput;
CChars szFileName;
aszFileNames.Init();
cFileUtil.FindAllFiles("Input/Dehollowfication", &aszFileNames, FALSE, FALSE);
for (i = 0; i < aszFileNames.NumElements(); i++)
{
psz = aszFileNames.Get(i);
szFileName.Init(psz->Text());
cFileUtil.RemovePath(&szFileName);
szOutput.Init();
cFileUtil.CurrentDirectory(&szOutput);
cFileUtil.AppendToPath(&szOutput, "Output/Flush1");
cFileUtil.AppendToPath(&szOutput, szFileName.Text());
AssertFile(psz->Text(), szOutput.Text());
szOutput.Kill();
szFileName.Kill();
}
aszFileNames.Kill();
}
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 TestReadExternalReference(void)
{
CXMLFile cXMLFile;
CChars szDoc;
int iLine;
char szExpected[] = "<InputDevices>\n\
This is text < and doom stuff\n\
<RootInSecond>\n\
Hello\n\
</RootInSecond>\n\
Sweet > other stuff\n\
<ThirdsRoot>\n\
World\n\
</ThirdsRoot>\n\
</InputDevices>\n";
CMarkupTag* pcTag;
CMarkupTag* pcSecondTag;
CMarkupTag* pcThirdTag;
CChars szText;
cXMLFile.Init();
cXMLFile.Read("First.xml", ".");
szDoc.Init(16);
iLine = cXMLFile.mcMarkup.mpcDoc->ToString(&szDoc);
AssertInt(10, iLine);
AssertString(szExpected, szDoc.Text());
szDoc.Kill();
pcTag = cXMLFile.mcMarkup.mpcDoc->GetRootTag();
pcSecondTag = pcTag->GetTag("RootInSecond");
AssertNotNull(pcSecondTag);
szText.Init();
pcSecondTag->GetText(&szText);
szText.StripWhiteSpace(TRUE);
AssertString("Hello", szText.Text());
szText.Kill();
pcTag = cXMLFile.mcMarkup.mpcDoc->GetRootTag();
pcThirdTag = pcTag->GetTag("ThirdsRoot");
AssertNotNull(pcThirdTag);
szText.Init();
pcThirdTag->GetText(&szText);
szText.StripWhiteSpace(TRUE);
AssertString("World", szText.Text());
szText.Kill();
cXMLFile.Kill();
}
BOOL CFileUtil::RemoveDir(const char*szPathName)
{
WIN32_FIND_DATA sFindData;
CChars szFindName;
CChars szTemp;
HANDLE hFindHandle;
BOOL bContinue;
BOOL bValid;
CChars szDirectory;
BOOL bDeleted;
szDirectory.Init(szPathName);
RemoveFileSeparator(&szDirectory);
szFindName.Init(szPathName);
AppendToPath(&szFindName, "*.*");
hFindHandle = FindFirstFile(szFindName.Text(), &sFindData);
bContinue = (hFindHandle != INVALID_HANDLE_VALUE);
bDeleted = TRUE;
while (bContinue)
{
bValid = TRUE;
if (sFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!((strcmp(sFindData.cFileName, ".") == 0) || (strcmp(sFindData.cFileName, "..") == 0)))
{
szTemp.Init(szDirectory);
AppendToPath(&szTemp, sFindData.cFileName);
RemoveDir(szTemp.Text());
szTemp.Kill();
}
}
else
{
szTemp.Init(szPathName);
AppendToPath(&szTemp, sFindData.cFileName);
bDeleted &= DeleteFile(szTemp.Text());
szTemp.Kill();
}
bContinue = FindNextFile(hFindHandle, &sFindData);
}
FindClose(hFindHandle);
RemoveDirectory(szDirectory.Text());
szDirectory.Kill();
szFindName.Kill();
return bDeleted;
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
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;
}
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;
}
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;
}
void CIndexedFile::Dump(void)
{
CChars sz;
int i;
filePos iSizeOnDisk;
filePos iPos;
BOOL bDurable;
char pvData[80];
int iReadSize;
iSizeOnDisk = mcFile.SizeFromFile();
bDurable = mcFile.mbDurable;
mcFile.mbDurable = FALSE;
sz.Init();
sz.Append("File Descriptor (");
sz.Append(miFileIndex);
sz.Append(")\n------------------\n");
sz.Append("Primary Name: ");
sz.Append(mszFileName);
sz.AppendNewLine();
sz.Append("Rewrite Name: ");
sz.Append(mszRewriteName);
sz.AppendNewLine();
sz.Append("Durable: ");
sz.AppendBool(bDurable);
sz.AppendNewLine();
sz.Append("Datas (A:");
sz.Append(miNumDatas);
sz.Append(", D:");
sz.Append(mcFile.miLength/miDataSize);
sz.Append(", F:");
sz.Append(iSizeOnDisk/miDataSize);
sz.Append(")\n\n");
sz.Append("Data on Disk\n------------\n");
iReadSize = 80;
if (miDataSize < iReadSize)
{
iReadSize = miDataSize;
}
iPos = mcFile.Tell();
for (i = 0; i < iSizeOnDisk/miDataSize; i++)
{
mcFile.Read(i*miDataSize, pvData, iReadSize, 1);
sz.AppendData(pvData, iReadSize);
sz.AppendNewLine();
}
sz.AppendNewLine();
mcFile.Seek(EFSO_SET, iPos);
sz.Dump();
sz.Kill();
mcFile.Dump();
mcFile.mbDurable = bDurable;
}
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();
}
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;
}
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();
}
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;
}
void CImageCelsSource::AddDiskFileSource(char* szFileName, char* szImageName, CImageCelSource* pcCelSource)
{
CImageSourceDiskFile* pcDiskFile;
int iLen;
CChars szNewName;
CFileUtil cFileUtil;
if (!szFileName)
{
return;
}
iLen = (int)strlen(szFileName);
if (iLen == 0)
{
return;
}
pcDiskFile = UMalloc(CImageSourceDiskFile);
if (szImageName)
{
pcDiskFile->Init(szFileName, szImageName);
}
else
{
szNewName.Init(szFileName);
cFileUtil.RemovePath(&szNewName);
pcDiskFile->Init(szFileName, szNewName.Text());
szNewName.Kill();
}
AddSource(pcDiskFile, pcCelSource);
}
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 CFiles::AddPackFile(CFileNodeSystemFile* pcFileNodeSystemFile)
{
CPackFileOffset* pcPackFiles;
char* szFullName;
CChars szPackFileOffset;
CChars* pszFullDirectory;
int iLength;
BOOL bResult;
int iRank;
pszFullDirectory = mcFileSystem.GetFullDirectoryName();
iLength = mszPackFilesExtension.Length()+1;
pcPackFiles = mcPackFilesArray.Add();
new(pcPackFiles) CPackFileOffset();
szFullName = pcFileNodeSystemFile->GetFullName();
szPackFileOffset.Init(szFullName);
szPackFileOffset.RemoveFromStart(pszFullDirectory->Length()+1);
szPackFileOffset.RemoveFromEnd(iLength);
szPackFileOffset.Replace('\\', '/');
iRank = szPackFileOffset.Count('/');
bResult = pcPackFiles->Init(szPackFileOffset.Text(), szFullName, iRank);
szPackFileOffset.Kill();
return bResult;
}
void CChars::Difference(CArrayInt* paiNewToOldIndices, CArrayInt* paiOldToNewIndices, CChars szOldString)
{
int i;
int j;
CChars cTemp;
char cNew;
char cOld;
//This will find the index of each character in this string in the old string.
paiOldToNewIndices->SetUsedElements(szOldString.Length());
paiOldToNewIndices->SetArrayValues(-1);
paiNewToOldIndices->SetUsedElements(Length());
paiNewToOldIndices->SetArrayValues(-1);
cTemp.Init(szOldString);
for (j = 0; j < Length(); j++)
{
cNew = GetChar(j);
for (i = 0; i < cTemp.Length(); i++)
{
cOld = cTemp.GetChar(i);
if (cOld == cNew)
{
cTemp.SetChar(i, 1);
paiOldToNewIndices->SetValue(i, j);
paiNewToOldIndices->SetValue(j, i);
break;
}
}
}
cTemp.Kill();
}
void CBaseObject::ValidateContainerFlag(void)
{
CChars sz;
int iEmbeddedFlags;
int iThisFlags;
int iIgnoredFlags;
char* szEmbeddedFlags;
char* szFlags;
char* szIgnoredFlags;
if (IsEmbedded())
{
iIgnoredFlags = OBJECT_FLAGS_CALLED_CLASS;
iEmbeddedFlags = mpcEmbedded->miFlags & ~iIgnoredFlags;
iThisFlags = miFlags & ~iIgnoredFlags;
if ((iEmbeddedFlags) != (iThisFlags))
{
sz.Init();
PrintObject(&sz, IsEmbedded());
szFlags = ShortToFlags(miFlags);
szEmbeddedFlags = ShortToFlags(mpcEmbedded->miFlags);
szIgnoredFlags = ShortToFlags(iIgnoredFlags);
ReplaceOneWithX(szFlags, szIgnoredFlags);
ReplaceOneWithX(szEmbeddedFlags, szIgnoredFlags);
gcLogger.Error2(__METHOD__, " Object {", sz.Text(), "} should have the same flags [", szFlags ,"] as it's embedding container's flags [", szEmbeddedFlags, "].", NULL);
sz.Kill();
}
}
}
