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::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 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();
}
}
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 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();
}
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 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 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 TestRemoveExtension(void)
{
CChars szFileName;
CFileUtil cFileUtil;
szFileName.Init("/mnt/world/hello.txt");
cFileUtil.RemoveExtension(&szFileName);
AssertString("/mnt/world/hello", szFileName.Text());
cFileUtil.RemoveExtension(&szFileName);
AssertString("/mnt/world/hello", szFileName.Text());
szFileName.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 CImageCelsSource::AddDiskFileSources(char* szPathName, char* szFileNameContains, char* szImageName, CImageCelSource* pcCelSource)
{
CFileUtil cFileUtil;
CArrayString cFileNames;
int i;
CChars* pszName;
CImageSourceDiskFile* pcDiskFile;
CChars szNiceName;
int iIndex;
int iLen;
if (!szFileNameContains)
{
return;
}
iLen = (int)strlen(szFileNameContains);
if (iLen == 0)
{
return;
}
cFileNames.Init(32);
cFileUtil.FindFilesWithNameContaining(szPathName, szFileNameContains, &cFileNames, FALSE);
for (i = 0; i < cFileNames.NumElements(); i++)
{
pszName = cFileNames.Get(i);
pcDiskFile = UMalloc(CImageSourceDiskFile);
if (szImageName)
{
szNiceName.Init(*pszName);
cFileUtil.RemovePath(&szNiceName);
cFileUtil.RemoveExtension(&szNiceName);
iIndex = szNiceName.Find(0, szFileNameContains);
iIndex += iLen;
szNiceName.RemoveFromStart(iIndex);
szNiceName.Insert(0, szImageName);
pcDiskFile->Init(pszName->Text(), szNiceName.Text());
szNiceName.Kill();
}
else
{
pcDiskFile->Init(pszName->Text());
}
AddSource(pcDiskFile, pcCelSource);
}
cFileNames.Kill();
}
BOOL CImageCelsSourceXML::ImportCels(CMarkupTag* pcCelsTag, char* szFileName)
{
STagIterator sIter;
CSubImageXML cSubImageXML;
CMarkupTag* pcCelTag;
CArraySubImage acSubImages;
CSubImage* pcSubImage;
BOOL bResult;
CImageCelSourceSubImages cSubImagesSource;
CImageCelsSource cCelsSource;
CChars szGroupName;
CFileUtil cFileUtil;
Ptr<CImageCelGroup> pcGroup;
acSubImages.Init();
pcCelTag = pcCelsTag->GetTag("Cel", &sIter);
while (pcCelTag)
{
pcSubImage = acSubImages.Add();
bResult = cSubImageXML.Import(pcCelTag, pcSubImage);
if (!bResult)
{
acSubImages.Kill();
return FALSE;
}
pcCelTag = pcCelsTag->GetNextTag(&sIter);
}
cSubImagesSource.Init(&acSubImages);
szGroupName.Init(szFileName);
cFileUtil.RemovePath(&szGroupName);
cCelsSource.Init();
cCelsSource.AddDiskFileSource(szFileName, szGroupName.Text(), &cSubImagesSource);
cCelsSource.Load();
mpcWorld->AddImages(cCelsSource.GetImages());
pcGroup = ONMalloc(CImageCelGroup, szGroupName.Text());
mpcWorld->AddGroup(pcGroup);
pcGroup->AddCels(cCelsSource.GetImageCels());
szGroupName.Kill();
cSubImagesSource.Kill();
cCelsSource.Kill();
acSubImages.Kill();
return TRUE;
}
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;
}
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 CPackFiles::ReadNode(void)
{
CChars sz;
CFileNodePackFileNode* pcNode;
sz.Init();
if (!sz.ReadString(&mcFile))
{
return FALSE;
}
pcNode = AddFile(sz.Text());
sz.Kill();
if (!((pcNode) && (pcNode->IsFile())))
{
return FALSE;
}
ReturnOnFalse(pcNode->File()->Load(&mcFile));
miPosition = mcFile.GetFilePos();
return TRUE;
}
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();
}
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;
}
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;
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
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 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);
}
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;
}
BOOL CObjectWriterChunked::Write(CSerialisedObject* pcSerialised)
{
CChars szChunkName;
if (pcSerialised->IsNamed())
{
ReturnOnFalse(ObjectStartsWithBase(pcSerialised->GetName()));
RemainingName(&szChunkName, pcSerialised->GetName());
}
else if (pcSerialised->IsIndexed())
{
Unnamed(pcSerialised, &szChunkName);
}
else
{
return FALSE;
}
ReturnOnFalse(mcChunkFile.WriteChunkBegin(szChunkName.Text()));
ReturnOnFalse(mcChunkFile.WriteData(pcSerialised, pcSerialised->GetLength()));
ReturnOnFalse(mcChunkFile.WriteChunkEnd());
szChunkName.Kill();
return TRUE;
}
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 CChars::AppendSubString(CChars sz, int iStartInclusive, int iEndExclusive)
{
const char* pcPosition;
pcPosition = (char*)RemapSinglePointer((void*)sz.Text(), iStartInclusive);
AppendSubString(pcPosition, iEndExclusive-iStartInclusive);
}
//////////////////////////////////////////////////////////////////////////
// //
// //
//////////////////////////////////////////////////////////////////////////
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;
}
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;
}
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 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();
}
}
}
