TFileNameDatabase Class Reference

#include <CascMndx.h>

Public Member Functions
	TFileNameDatabase ()
void	ExchangeWith (TFileNameDatabase &Target)
int	LoadFromStream (TByteStream &InStream)
int	LoadFromStream_Exchange (TByteStream &InStream)
DWORD	sub_1959CB0 (DWORD dwHashValue)
DWORD	sub_1959F50 (DWORD arg_0)
DWORD	GetNameFragmentOffsetEx (DWORD LoBitsIndex, DWORD HiBitsIndex)
DWORD	GetNameFragmentOffset (DWORD LoBitsIndex)
bool	sub_1957B80 (TMndxFindResult *pStruct1C, DWORD dwKey)
bool	CheckNextPathFragment (TMndxFindResult *pStruct1C)
bool	FindFileInDatabase (TMndxFindResult *pStruct1C)
void	sub_1958D70 (TMndxFindResult *pStruct1C, DWORD arg_4)
bool	sub_1959010 (TMndxFindResult *pStruct1C, DWORD arg_4)
bool	sub_1958B00 (TMndxFindResult *pStruct1C)
bool	sub_1959460 (TMndxFindResult *pStruct1C)

Public Attributes
TSparseArray	Struct68_00
TSparseArray	FileNameIndexes
TSparseArray	Struct68_D0
TGenericArray	FrgmDist_LoBits
TBitEntryArray	FrgmDist_HiBits
TNameIndexStruct	IndexStruct_174
TFileNameDatabasePtr	NextDB
TGenericArray	NameFragTable
DWORD	NameFragIndexMask
DWORD	field_214
TStruct10	Struct10
TByteStream	MarStream

Constructor & Destructor Documentation

TFileNameDatabase::TFileNameDatabase

(

)

{
 NameFragIndexMask = 0;
 field_214 = 0;
}

Here is the caller graph for this function:

Member Function Documentation

bool TFileNameDatabase::CheckNextPathFragment

(

TMndxFindResult *

pStruct1C

)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 LPBYTE pbPathName = (LPBYTE)pStruct1C->szSearchMask;
 DWORD CollisionIndex;
 DWORD NameFragIndex;
 DWORD SaveCharIndex;
 DWORD HiBitsIndex;
 DWORD FragOffs;

 // Calculate index of the next name fragment in the name fragment table
 NameFragIndex = ((pStruct40->ItemIndex << 0x05) ^ pStruct40->ItemIndex ^ pbPathName[pStruct40->CharIndex]) & NameFragIndexMask;

 // Does the hash value match?
 if(NameFragTable.NameFragArray[NameFragIndex].ItemIndex == pStruct40->ItemIndex)
 {
 // Check if there is single character match
 if(IS_SINGLE_CHAR_MATCH(NameFragTable, NameFragIndex))
 {
 pStruct40->ItemIndex = NameFragTable.NameFragArray[NameFragIndex].NextIndex;
 pStruct40->CharIndex++;
 return true;
 }

 // Check if there is a name fragment match
 if(NextDB.pDB != NULL)
 {
 if(!NextDB.pDB->sub_1957B80(pStruct1C, NameFragTable.NameFragArray[NameFragIndex].FragOffs))
 return false;
 }
 else
 {
 if(!IndexStruct_174.CheckNameFragment(pStruct1C, NameFragTable.NameFragArray[NameFragIndex].FragOffs))
 return false;
 }

 pStruct40->ItemIndex = NameFragTable.NameFragArray[NameFragIndex].NextIndex;
 return true;
 }

 //
 // Conflict: Multiple hashes give the same table index
 //

 // HOTS: 1957A0E
 CollisionIndex = sub_1959CB0(pStruct40->ItemIndex) + 1;
 if(!Struct68_00.IsItemPresent(CollisionIndex))
 return false;

 pStruct40->ItemIndex = (CollisionIndex - pStruct40->ItemIndex - 1);
 HiBitsIndex = 0xFFFFFFFF;

// CascDumpSparseArray("E:\\casc-array-68.txt", &FileNameIndexes);
// CascDumpSparseArray("E:\\casc-array-D0.txt", &Struct68_D0);

 // HOTS: 1957A41:
 do
 {
 // HOTS: 1957A41
 // Check if the low 8 bits if the fragment offset contain a single character
 // or an offset to a name fragment
 if(Struct68_D0.IsItemPresent(pStruct40->ItemIndex))
 {
 if(HiBitsIndex == 0xFFFFFFFF)
 {
 // HOTS: 1957A6C
 HiBitsIndex = Struct68_D0.GetItemValue(pStruct40->ItemIndex);
 }
 else
 {
 // HOTS: 1957A7F
 HiBitsIndex++;
 }

 // HOTS: 1957A83
 SaveCharIndex = pStruct40->CharIndex;

 // Get the name fragment offset as combined value from lower 8 bits and upper bits
 FragOffs = GetNameFragmentOffsetEx(pStruct40->ItemIndex, HiBitsIndex);

 // Compare the string with the fragment name database
 if(NextDB.pDB != NULL)
 {
 // HOTS: 1957AEC
 if(NextDB.pDB->sub_1957B80(pStruct1C, FragOffs))
 return true;
 }
 else
 {
 // HOTS: 1957AF7
 if(IndexStruct_174.CheckNameFragment(pStruct1C, FragOffs))
 return true;
 }

 // HOTS: 1957B0E
 // If there was partial match with the fragment, end the search
 if(pStruct40->CharIndex != SaveCharIndex)
 return false;
 }
 else
 {
 // HOTS: 1957B1C
 if(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex] == pStruct1C->szSearchMask[pStruct40->CharIndex])
 {
 pStruct40->CharIndex++;
 return true;
 }
 }

 // HOTS: 1957B32
 pStruct40->ItemIndex++;
 CollisionIndex++;
 }
 while(Struct68_00.IsItemPresent(CollisionIndex));
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TFileNameDatabase::ExchangeWith

(

TFileNameDatabase &

Target

)

{
 TFileNameDatabasePtr TempPtr;
 DWORD dwTemp;

 Struct68_00.ExchangeWith(Target.Struct68_00);
 FileNameIndexes.ExchangeWith(Target.FileNameIndexes);
 Struct68_D0.ExchangeWith(Target.Struct68_D0);

 FrgmDist_LoBits.ExchangeWith(Target.FrgmDist_LoBits);
 FrgmDist_HiBits.ExchangeWith(Target.FrgmDist_HiBits);

 IndexStruct_174.ExchangeWith(Target.IndexStruct_174);

 TempPtr = NextDB;
 NextDB = Target.NextDB;
 Target.NextDB = TempPtr;

 NameFragTable.ExchangeWith(Target.NameFragTable);

 dwTemp = NameFragIndexMask;
 NameFragIndexMask = Target.NameFragIndexMask;
 Target.NameFragIndexMask = dwTemp;

 dwTemp = field_214;
 field_214 = Target.field_214;
 Target.field_214 = dwTemp;

 Struct10.CopyFrom(Target.Struct10);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TFileNameDatabase::FindFileInDatabase

(

TMndxFindResult *

pStruct1C

)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;

 pStruct40->ItemIndex = 0;
 pStruct40->CharIndex = 0;
 pStruct40->SearchPhase = CASC_SEARCH_INITIALIZING;

 if(pStruct1C->cchSearchMask > 0)
 {
 while(pStruct40->CharIndex < pStruct1C->cchSearchMask)
 {
 // HOTS: 01957F12
 if(!CheckNextPathFragment(pStruct1C))
 return false;
 }
 }

 // HOTS: 1957F26
 if(!FileNameIndexes.IsItemPresent(pStruct40->ItemIndex))
 return false;

 pStruct1C->szFoundPath = pStruct1C->szSearchMask;
 pStruct1C->cchFoundPath = pStruct1C->cchSearchMask;
 pStruct1C->FileNameIndex = FileNameIndexes.GetItemValue(pStruct40->ItemIndex);
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD TFileNameDatabase::GetNameFragmentOffset ( DWORD  LoBitsIndex )

inline

 {
 return GetNameFragmentOffsetEx(LoBitsIndex, Struct68_D0.GetItemValue(LoBitsIndex));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD TFileNameDatabase::GetNameFragmentOffsetEx ( DWORD  LoBitsIndex, DWORD  HiBitsIndex  )

inline

 {
 return (FrgmDist_HiBits.GetBitEntry(HiBitsIndex) << 0x08) | FrgmDist_LoBits.ByteArray[LoBitsIndex];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int TFileNameDatabase::LoadFromStream

(

TByteStream &

InStream

)

{
 DWORD dwBitMask;
 int nError;

 nError = Struct68_00.LoadFromStream_Exchange(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 nError = FileNameIndexes.LoadFromStream_Exchange(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 nError = Struct68_D0.LoadFromStream_Exchange(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 // HOTS: 019597CD
 nError = FrgmDist_LoBits.LoadBytes_Copy(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 nError = FrgmDist_HiBits.LoadFromStream_Exchange(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 // HOTS: 019597F5
 nError = IndexStruct_174.LoadFromStream_Exchange(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 // HOTS: 0195980A
 if(Struct68_D0.ValidItemCount != 0 && IndexStruct_174.NameFragments.ItemCount == 0)
 {
 TFileNameDatabase * pNextDB = new TFileNameDatabase;

 nError = NextDB.SetDatabase(pNextDB);
 if(nError != ERROR_SUCCESS)
 return nError;

 if(NextDB.pDB == NULL)
 return ERROR_NOT_ENOUGH_MEMORY;

 nError = NextDB.pDB->LoadFromStream(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;
 }

 // HOTS: 0195986B
 nError = NameFragTable.LoadFragmentInfos_Copy(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 NameFragIndexMask = NameFragTable.ItemCount - 1;

 nError = InStream.GetValue_DWORD(field_214);
 if(nError != ERROR_SUCCESS)
 return nError;

 nError = InStream.GetValue_DWORD(dwBitMask);
 if(nError != ERROR_SUCCESS)
 return nError;

 return Struct10.sub_1957800(dwBitMask);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int TFileNameDatabase::LoadFromStream_Exchange

(

TByteStream &

InStream

)

{
 TFileNameDatabase TempDatabase;
 ARRAY_POINTER Pointer;
 DWORD dwSignature;
 int nError;

 // Get pointer to MAR signature
 nError = InStream.GetBytes(sizeof(DWORD), &Pointer);
 if(nError != ERROR_SUCCESS)
 return nError;

 // Verify the signature
 dwSignature = Pointer.Uint32s[0];
 if(dwSignature != CASC_MAR_SIGNATURE)
 return ERROR_BAD_FORMAT;

 nError = TempDatabase.LoadFromStream(InStream);
 if(nError != ERROR_SUCCESS)
 return nError;

 MarStream.ExchangeWith(InStream);
 ExchangeWith(TempDatabase);
 return ERROR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TFileNameDatabase::sub_1957B80	(	TMndxFindResult *	pStruct1C,
		DWORD	dwKey
	)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 PNAME_FRAG pNameEntry;
 DWORD FragOffs;
 DWORD eax, edi;

 edi = arg_4;

 // HOTS: 1957B95
 for(;;)
 {
 pNameEntry = NameFragTable.NameFragArray + (edi & NameFragIndexMask);
 if(edi == pNameEntry->NextIndex)
 {
 // HOTS: 01957BB4
 if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00)
 {
 // HOTS: 1957BC7
 if(NextDB.pDB != NULL)
 {
 // HOTS: 1957BD3
 if(!NextDB.pDB->sub_1957B80(pStruct1C, pNameEntry->FragOffs))
 return false;
 }
 else
 {
 // HOTS: 1957BE0
 if(!IndexStruct_174.CheckNameFragment(pStruct1C, pNameEntry->FragOffs))
 return false;
 }
 }
 else
 {
 // HOTS: 1957BEE
 if(pStruct1C->szSearchMask[pStruct40->CharIndex] != (char)pNameEntry->FragOffs)
 return false;
 pStruct40->CharIndex++;
 }

 // HOTS: 1957C05
 edi = pNameEntry->ItemIndex;
 if(edi == 0)
 return true;

 if(pStruct40->CharIndex >= pStruct1C->cchSearchMask)
 return false;
 }
 else
 {
 // HOTS: 1957C30
 if(Struct68_D0.IsItemPresent(edi))
 {
 // HOTS: 1957C4C
 if(NextDB.pDB != NULL)
 {
 // HOTS: 1957C58
 FragOffs = GetNameFragmentOffset(edi);
 if(!NextDB.pDB->sub_1957B80(pStruct1C, FragOffs))
 return false;
 }
 else
 {
 // HOTS: 1957350
 FragOffs = GetNameFragmentOffset(edi);
 if(!IndexStruct_174.CheckNameFragment(pStruct1C, FragOffs))
 return false;
 }
 }
 else
 {
 // HOTS: 1957C8E
 if(FrgmDist_LoBits.ByteArray[edi] != pStruct1C->szSearchMask[pStruct40->CharIndex])
 return false;

 pStruct40->CharIndex++;
 }

 // HOTS: 1957CB2
 if(edi <= field_214)
 return true;

 if(pStruct40->CharIndex >= pStruct1C->cchSearchMask)
 return false;

 eax = sub_1959F50(edi);
 edi = (eax - edi - 1);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TFileNameDatabase::sub_1958B00

(

TMndxFindResult *

pStruct1C

)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 LPBYTE pbPathName = (LPBYTE)pStruct1C->szSearchMask;
 DWORD CollisionIndex;
 DWORD FragmentOffset;
 DWORD SaveCharIndex;
 DWORD ItemIndex;
 DWORD FragOffs;
 DWORD var_4;

 ItemIndex = pbPathName[pStruct40->CharIndex] ^ (pStruct40->ItemIndex << 0x05) ^ pStruct40->ItemIndex;
 ItemIndex = ItemIndex & NameFragIndexMask;
 if(pStruct40->ItemIndex == NameFragTable.NameFragArray[ItemIndex].ItemIndex)
 {
 // HOTS: 1958B45
 FragmentOffset = NameFragTable.NameFragArray[ItemIndex].FragOffs;
 if((FragmentOffset & 0xFFFFFF00) == 0xFFFFFF00)
 {
 // HOTS: 1958B88
 pStruct40->array_00.InsertOneItem_CHAR((char)FragmentOffset);
 pStruct40->ItemIndex = NameFragTable.NameFragArray[ItemIndex].NextIndex;
 pStruct40->CharIndex++;
 return true;
 }

 // HOTS: 1958B59
 if(NextDB.pDB != NULL)
 {
 if(!NextDB.pDB->sub_1959010(pStruct1C, FragmentOffset))
 return false;
 }
 else
 {
 if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragmentOffset))
 return false;
 }

 // HOTS: 1958BCA
 pStruct40->ItemIndex = NameFragTable.NameFragArray[ItemIndex].NextIndex;
 return true;
 }

 // HOTS: 1958BE5
 CollisionIndex = sub_1959CB0(pStruct40->ItemIndex) + 1;
 if(!Struct68_00.IsItemPresent(CollisionIndex))
 return false;

 pStruct40->ItemIndex = (CollisionIndex - pStruct40->ItemIndex - 1);
 var_4 = 0xFFFFFFFF;

 // HOTS: 1958C20
 for(;;)
 {
 if(Struct68_D0.IsItemPresent(pStruct40->ItemIndex))
 {
 // HOTS: 1958C0E
 if(var_4 == 0xFFFFFFFF)
 {
 // HOTS: 1958C4B
 var_4 = Struct68_D0.GetItemValue(pStruct40->ItemIndex);
 }
 else
 {
 var_4++;
 }

 // HOTS: 1958C62
 SaveCharIndex = pStruct40->CharIndex;

 FragOffs = GetNameFragmentOffsetEx(pStruct40->ItemIndex, var_4);
 if(NextDB.pDB != NULL)
 {
 // HOTS: 1958CCB
 if(NextDB.pDB->sub_1959010(pStruct1C, FragOffs))
 return true;
 }
 else
 {
 // HOTS: 1958CD6
 if(IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragOffs))
 return true;
 }

 // HOTS: 1958CED
 if(SaveCharIndex != pStruct40->CharIndex)
 return false;
 }
 else
 {
 // HOTS: 1958CFB
 if(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex] == pStruct1C->szSearchMask[pStruct40->CharIndex])
 {
 // HOTS: 1958D11
 pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex]);
 pStruct40->CharIndex++;
 return true;
 }
 }

 // HOTS: 1958D11
 pStruct40->ItemIndex++;
 CollisionIndex++;

 if(!Struct68_00.IsItemPresent(CollisionIndex))
 break;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TFileNameDatabase::sub_1958D70	(	TMndxFindResult *	pStruct1C,
		DWORD	arg_4
	)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 PNAME_FRAG pNameEntry;

 // HOTS: 1958D84
 for(;;)
 {
 pNameEntry = NameFragTable.NameFragArray + (arg_4 & NameFragIndexMask);
 if(arg_4 == pNameEntry->NextIndex)
 {
 // HOTS: 1958DA6
 if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00)
 {
 // HOTS: 1958DBA
 if(NextDB.pDB != NULL)
 {
 NextDB.pDB->sub_1958D70(pStruct1C, pNameEntry->FragOffs);
 }
 else
 {
 IndexStruct_174.CopyNameFragment(pStruct1C, pNameEntry->FragOffs);
 }
 }
 else
 {
 // HOTS: 1958DE7
 // Insert the low 8 bits to the path being built
 pStruct40->array_00.InsertOneItem_CHAR((char)(pNameEntry->FragOffs & 0xFF));
 }

 // HOTS: 1958E71
 arg_4 = pNameEntry->ItemIndex;
 if(arg_4 == 0)
 return;
 }
 else
 {
 // HOTS: 1958E8E
 if(Struct68_D0.IsItemPresent(arg_4))
 {
 DWORD FragOffs;

 // HOTS: 1958EAF
 FragOffs = GetNameFragmentOffset(arg_4);
 if(NextDB.pDB != NULL)
 {
 NextDB.pDB->sub_1958D70(pStruct1C, FragOffs);
 }
 else
 {
 IndexStruct_174.CopyNameFragment(pStruct1C, FragOffs);
 }
 }
 else
 {
 // HOTS: 1958F50
 // Insert one character to the path being built
 pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[arg_4]);
 }

 // HOTS: 1958FDE
 if(arg_4 <= field_214)
 return;

 arg_4 = 0xFFFFFFFF - arg_4 + sub_1959F50(arg_4);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TFileNameDatabase::sub_1959010	(	TMndxFindResult *	pStruct1C,
		DWORD	arg_4
	)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 PNAME_FRAG pNameEntry;

 // HOTS: 1959024
 for(;;)
 {
 pNameEntry = NameFragTable.NameFragArray + (arg_4 & NameFragIndexMask);
 if(arg_4 == pNameEntry->NextIndex)
 {
 // HOTS: 1959047
 if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00)
 {
 // HOTS: 195905A
 if(NextDB.pDB != NULL)
 {
 if(!NextDB.pDB->sub_1959010(pStruct1C, pNameEntry->FragOffs))
 return false;
 }
 else
 {
 if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, pNameEntry->FragOffs))
 return false;
 }
 }
 else
 {
 // HOTS: 1959092
 if((char)(pNameEntry->FragOffs & 0xFF) != pStruct1C->szSearchMask[pStruct40->CharIndex])
 return false;

 // Insert the low 8 bits to the path being built
 pStruct40->array_00.InsertOneItem_CHAR((char)(pNameEntry->FragOffs & 0xFF));
 pStruct40->CharIndex++;
 }

 // HOTS: 195912E
 arg_4 = pNameEntry->ItemIndex;
 if(arg_4 == 0)
 return true;
 }
 else
 {
 // HOTS: 1959147
 if(Struct68_D0.IsItemPresent(arg_4))
 {
 DWORD FragOffs;

 // HOTS: 195917C
 FragOffs = GetNameFragmentOffset(arg_4);
 if(NextDB.pDB != NULL)
 {
 if(!NextDB.pDB->sub_1959010(pStruct1C, FragOffs))
 return false;
 }
 else
 {
 if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragOffs))
 return false;
 }
 }
 else
 {
 // HOTS: 195920E
 if(FrgmDist_LoBits.CharArray[arg_4] != pStruct1C->szSearchMask[pStruct40->CharIndex])
 return false;

 // Insert one character to the path being built
 pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[arg_4]);
 pStruct40->CharIndex++;
 }

 // HOTS: 19592B6
 if(arg_4 <= field_214)
 return true;

 arg_4 = 0xFFFFFFFF - arg_4 + sub_1959F50(arg_4);
 }

 // HOTS: 19592D5
 if(pStruct40->CharIndex >= pStruct1C->cchSearchMask)
 break;
 }

 sub_1958D70(pStruct1C, arg_4);
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TFileNameDatabase::sub_1959460

(

TMndxFindResult *

pStruct1C

)

{
 TStruct40 * pStruct40 = pStruct1C->pStruct40;
 PPATH_STOP pPathStop;
 PATH_STOP PathStop;
 DWORD NewMaxItemCount;
 DWORD FragOffs;
 DWORD edi;

 if(pStruct40->SearchPhase == CASC_SEARCH_FINISHED)
 return false;

 if(pStruct40->SearchPhase != CASC_SEARCH_SEARCHING)
 {
 // HOTS: 1959489
 pStruct40->InitSearchBuffers();

 // If the caller passed a part of the search path, we need to find that one
 while(pStruct40->CharIndex < pStruct1C->cchSearchMask)
 {
 if(!sub_1958B00(pStruct1C))
 {
 pStruct40->SearchPhase = CASC_SEARCH_FINISHED;
 return false;
 }
 }

 // HOTS: 19594b0
 PathStop.ItemIndex = pStruct40->ItemIndex;
 PathStop.field_4 = 0;
 PathStop.field_8 = pStruct40->array_00.ItemCount;
 PathStop.field_C = 0xFFFFFFFF;
 PathStop.field_10 = 0xFFFFFFFF;
 pStruct40->PathStops.InsertOneItem_PATH_STOP(PathStop);
 pStruct40->ItemCount = 1;

 if(FileNameIndexes.IsItemPresent(pStruct40->ItemIndex))
 {
 pStruct1C->szFoundPath = pStruct40->array_00.FirstValid.Chars;
 pStruct1C->cchFoundPath = pStruct40->array_00.ItemCount;
 pStruct1C->FileNameIndex = FileNameIndexes.GetItemValue(pStruct40->ItemIndex);
 return true;
 }
 }

 // HOTS: 1959522
 for(;;)
 {
 // HOTS: 1959530
 if(pStruct40->ItemCount == pStruct40->PathStops.ItemCount)
 {
 PPATH_STOP pLastStop;
 DWORD CollisionIndex;

 pLastStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->PathStops.ItemCount - 1;
 CollisionIndex = sub_1959CB0(pLastStop->ItemIndex) + 1;

 // Insert a new structure
 PathStop.ItemIndex = CollisionIndex - pLastStop->ItemIndex - 1;;
 PathStop.field_4 = CollisionIndex;
 PathStop.field_8 = 0;
 PathStop.field_C = 0xFFFFFFFF;
 PathStop.field_10 = 0xFFFFFFFF;
 pStruct40->PathStops.InsertOneItem_PATH_STOP(PathStop);
 }

 // HOTS: 19595BD
 pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount;

 // HOTS: 19595CC
 if(Struct68_00.IsItemPresent(pPathStop->field_4++))
 {
 // HOTS: 19595F2
 pStruct40->ItemCount++;

 if(Struct68_D0.IsItemPresent(pPathStop->ItemIndex))
 {
 // HOTS: 1959617
 if(pPathStop->field_C == 0xFFFFFFFF)
 pPathStop->field_C = Struct68_D0.GetItemValue(pPathStop->ItemIndex);
 else
 pPathStop->field_C++;

 // HOTS: 1959630
 FragOffs = GetNameFragmentOffsetEx(pPathStop->ItemIndex, pPathStop->field_C);
 if(NextDB.pDB != NULL)
 {
 // HOTS: 1959649
 NextDB.pDB->sub_1958D70(pStruct1C, FragOffs);
 }
 else
 {
 // HOTS: 1959654
 IndexStruct_174.CopyNameFragment(pStruct1C, FragOffs);
 }
 }
 else
 {
 // HOTS: 1959665
 // Insert one character to the path being built
 pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[pPathStop->ItemIndex]);
 }

 // HOTS: 19596AE
 pPathStop->field_8 = pStruct40->array_00.ItemCount;

 // HOTS: 19596b6
 if(FileNameIndexes.IsItemPresent(pPathStop->ItemIndex))
 {
 // HOTS: 19596D1
 if(pPathStop->field_10 == 0xFFFFFFFF)
 {
 // HOTS: 19596D9
 pPathStop->field_10 = FileNameIndexes.GetItemValue(pPathStop->ItemIndex);
 }
 else
 {
 pPathStop->field_10++;
 }

 // HOTS: 1959755
 pStruct1C->szFoundPath = pStruct40->array_00.FirstValid.Chars;
 pStruct1C->cchFoundPath = pStruct40->array_00.ItemCount;
 pStruct1C->FileNameIndex = pPathStop->field_10;
 return true;
 }
 }
 else
 {
 // HOTS: 19596E9
 if(pStruct40->ItemCount == 1)
 {
 pStruct40->SearchPhase = CASC_SEARCH_FINISHED;
 return false;
 }

 // HOTS: 19596F5
 pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount - 1;
 pPathStop->ItemIndex++;

 pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount - 2;
 edi = pPathStop->field_8;

 if(edi > pStruct40->array_00.MaxItemCount)
 {
 // HOTS: 1959717
 NewMaxItemCount = edi;

 if(pStruct40->array_00.MaxItemCount > (edi / 2))
 {
 if(pStruct40->array_00.MaxItemCount > 0x7FFFFFFF)
 {
 NewMaxItemCount = 0xFFFFFFFF;
 }
 else
 {
 NewMaxItemCount = pStruct40->array_00.MaxItemCount + pStruct40->array_00.MaxItemCount;
 }
 }

 pStruct40->array_00.SetMaxItems_CHARS(NewMaxItemCount);
 }

 // HOTS: 1959749
 pStruct40->array_00.ItemCount = edi;
 pStruct40->ItemCount--;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD TFileNameDatabase::sub_1959CB0

(

DWORD

dwHashValue

)

{
 PTRIPLET pTriplet;
 DWORD dwKeyShifted = (dwItemIndex >> 9);
 DWORD eax, ebx, ecx, edx, esi, edi;

 // If lower 9 is zero
 edx = dwItemIndex;
 if((edx & 0x1FF) == 0)
 return Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted];

 eax = Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted] >> 9;
 esi = (Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted + 1] + 0x1FF) >> 9;
 dwItemIndex = esi;

 if((eax + 0x0A) >= esi)
 {
 // HOTS: 1959CF7
 pTriplet = Struct68_00.BaseValues.TripletArray + eax + 1;
 edi = (eax << 0x09);
 ebx = edi - pTriplet->BaseValue + 0x200;
 while(edx >= ebx)
 {
 // HOTS: 1959D14
 edi += 0x200;
 pTriplet++;

 ebx = edi - pTriplet->BaseValue + 0x200;
 eax++;
 }
 }
 else
 {
 // HOTS: 1959D2E
 while((eax + 1) < esi)
 {
 // HOTS: 1959D38
 // ecx = Struct68_00.BaseValues.TripletArray;
 esi = (esi + eax) >> 1;
 ebx = (esi << 0x09) - Struct68_00.BaseValues.TripletArray[esi].BaseValue;
 if(edx < ebx)
 {
 // HOTS: 01959D4B
 dwItemIndex = esi;
 }
 else
 {
 // HOTS: 1959D50
 eax = esi;
 esi = dwItemIndex;
 }
 }
 }

 // HOTS: 1959D5F
 pTriplet = Struct68_00.BaseValues.TripletArray + eax;
 edx += pTriplet->BaseValue - (eax << 0x09);
 edi = (eax << 4);

 eax = pTriplet->Value2;
 ecx = (eax >> 0x17);
 ebx = 0x100 - ecx;
 if(edx < ebx)
 {
 // HOTS: 1959D8C
 ecx = ((eax >> 0x07) & 0xFF);
 esi = 0x80 - ecx;
 if(edx < esi)
 {
 // HOTS: 01959DA2
 eax = eax & 0x7F;
 ecx = 0x40 - eax;
 if(edx >= ecx)
 {
 // HOTS: 01959DB7
 edi += 2;
 edx = edx + eax - 0x40;
 }
 }
 else
 {
 // HOTS: 1959DC0
 eax = (eax >> 0x0F) & 0xFF;
 esi = 0xC0 - eax;
 if(edx < esi)
 {
 // HOTS: 1959DD3
 edi += 4;
 edx = edx + ecx - 0x80;
 }
 else
 {
 // HOTS: 1959DD3
 edi += 6;
 edx = edx + eax - 0xC0;
 }
 }
 }
 else
 {
 // HOTS: 1959DE8
 esi = pTriplet->Value3;
 eax = ((esi >> 0x09) & 0x1FF);
 ebx = 0x180 - eax;
 if(edx < ebx)
 {
 // HOTS: 01959E00
 esi = esi & 0x1FF;
 eax = (0x140 - esi);
 if(edx < eax)
 {
 // HOTS: 1959E11
                edi = edi + 8;
                edx = edx + ecx - 0x100;
            }
            else
            {
                // HOTS: 1959E1D
                edi = edi + 0x0A;
                edx = edx + esi - 0x140;
            }
        }
        else
        {
            // HOTS: 1959E29
            esi = (esi >> 0x12) & 0x1FF;
            ecx = (0x1C0 - esi);
            if(edx < ecx)
            {
                // HOTS: 1959E3D
                edi = edi + 0x0C;
                edx = edx + eax - 0x180;
            }
            else
            {
                // HOTS: 1959E49
                edi = edi + 0x0E;
                edx = edx + esi - 0x1C0;
            }
        }
    }

    // HOTS: 1959E53:
    // Calculate the number of bits set in the value of "ecx"
    ecx = ~Struct68_00.ItemBits.Uint32Array[edi];
    eax = GetNumberOfSetBits(ecx);
    esi = eax >> 0x18;

    if(edx >= esi)
    {
        // HOTS: 1959ea4
        ecx = ~Struct68_00.ItemBits.Uint32Array[++edi];
        edx = edx - esi;
        eax = GetNumberOfSetBits(ecx);
    }

    // HOTS: 1959eea
    // ESI gets the number of set bits in the lower 16 bits of ECX
    esi = (eax >> 0x08) & 0xFF;
    edi = edi << 0x05;
    if(edx < esi)
    {
        // HOTS: 1959EFC
        eax = eax & 0xFF;
        if(edx >= eax)
        {
            // HOTS: 1959F05
            ecx >>= 0x08;
            edi += 0x08;
            edx -= eax;
        }
    }
    else
    {
        // HOTS: 1959F0D
        eax = (eax >> 0x10) & 0xFF;
        if(edx < eax)
        {
            // HOTS: 1959F19
            ecx >>= 0x10;
            edi += 0x10;
            edx -= esi;
        }
        else
        {
            // HOTS: 1959F23
            ecx >>= 0x18;
            edi += 0x18;
            edx -= eax;
        }
    }

    // HOTS: 1959f2b
    edx = edx << 0x08;
    ecx = ecx & 0xFF;

    // BUGBUG: Possible buffer overflow here. Happens when dwItemIndex >= 0x9C.
    // The same happens in Heroes of the Storm (build 29049), so I am not sure
    // if this is a bug or a case that never happens
    assert((ecx + edx) < sizeof(table_1BA1818));
    return table_1BA1818[ecx + edx] + edi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD TFileNameDatabase::sub_1959F50

(

DWORD

arg_0

)

{
    PTRIPLET pTriplet;
    PDWORD ItemArray;
    DWORD eax, ebx, ecx, edx, esi, edi;

    edx = arg_0;
    eax = arg_0 >> 0x09;
    if((arg_0 & 0x1FF) == 0)
        return Struct68_00.ArrayDwords_50.Uint32Array[eax];

    ItemArray = Struct68_00.ArrayDwords_50.Uint32Array + eax;
    eax = (ItemArray[0] >> 0x09);
    edi = (ItemArray[1] + 0x1FF) >> 0x09;

    if((eax + 0x0A) > edi)
    {
        // HOTS: 01959F94
        pTriplet = Struct68_00.BaseValues.TripletArray + eax + 1;
        while(edx >= pTriplet->BaseValue)
        {
            // HOTS: 1959FA3
            pTriplet++;
            eax++;
        }
    }
    else
    {
        // Binary search
        // HOTS: 1959FAD
        if((eax + 1) < edi)
        {
            // HOTS: 1959FB4
            esi = (edi + eax) >> 1;
            if(edx < Struct68_00.BaseValues.TripletArray[esi].BaseValue)
            {
                // HOTS: 1959FC4
                edi = esi;
            }
            else
            {
                // HOTS: 1959FC8
                eax = esi;
            }
        }
    }

    // HOTS: 1959FD4
    pTriplet = Struct68_00.BaseValues.TripletArray + eax;
    edx = edx - pTriplet->BaseValue;
    edi = eax << 0x04;
    eax = pTriplet->Value2;
    ebx = (eax >> 0x17);
    if(edx < ebx)
    {
        // HOTS: 1959FF1
        esi = (eax >> 0x07) & 0xFF;
        if(edx < esi)
        {
            // HOTS: 0195A000
            eax = eax & 0x7F;
            if(edx >= eax)
            {
                // HOTS: 195A007
                edi = edi + 2;
                edx = edx - eax;
            }
        }
        else
        {
            // HOTS: 195A00E
            eax = (eax >> 0x0F) & 0xFF;
            if(edx < eax)
            {
                // HOTS: 195A01A
                edi += 4;
                edx = edx - esi;
            }
            else
            {
                // HOTS: 195A01F
                edi += 6;
                edx = edx - eax;
            }
        }
    }
    else
    {
        // HOTS: 195A026
        esi = pTriplet->Value3;
        eax = (pTriplet->Value3 >> 0x09) & 0x1FF;
        if(edx < eax)
        {
            // HOTS: 195A037
            esi = esi & 0x1FF;
            if(edx < esi)
            {
                // HOTS: 195A041
                edi = edi + 8;
                edx = edx - ebx;
            }
            else
            {
                // HOTS: 195A048
                edi = edi + 0x0A;
                edx = edx - esi;
            }
        }
        else
        {
            // HOTS: 195A04D
            esi = (esi >> 0x12) & 0x1FF;
            if(edx < esi)
            {
                // HOTS: 195A05A
                edi = edi + 0x0C;
                edx = edx - eax;
            }
            else
            {
                // HOTS: 195A061
                edi = edi + 0x0E;
                edx = edx - esi;
            }
        }
    }

    // HOTS: 195A066
    esi = Struct68_00.ItemBits.Uint32Array[edi];
    eax = GetNumberOfSetBits(esi);
    ecx = eax >> 0x18;

    if(edx >= ecx)
    {
        // HOTS: 195A0B2
        esi = Struct68_00.ItemBits.Uint32Array[++edi];
        edx = edx - ecx;
        eax = GetNumberOfSetBits(esi);
    }

    // HOTS: 195A0F6
    ecx = (eax >> 0x08) & 0xFF;

    edi = (edi << 0x05);
    if(edx < ecx)
    {
        // HOTS: 195A111
        eax = eax & 0xFF;
        if(edx >= eax)
        {
            // HOTS: 195A111
            edi = edi + 0x08;
            esi = esi >> 0x08;
            edx = edx - eax;
        }
    }
    else
    {
        // HOTS: 195A119
        eax = (eax >> 0x10) & 0xFF;
        if(edx < eax)
        {
            // HOTS: 195A125
            esi = esi >> 0x10;
            edi = edi + 0x10;
            edx = edx - ecx;
        }
        else
        {
            // HOTS: 195A12F
            esi = esi >> 0x18;
            edi = edi + 0x18;
            edx = edx - eax;
        }
    }

    esi = esi & 0xFF;
    edx = edx << 0x08;

    // BUGBUG: Potential buffer overflow
    // Happens in Heroes of the Storm when arg_0 == 0x5B
    assert((esi + edx) < sizeof(table_1BA1818));
    return table_1BA1818[esi + edx] + edi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

DWORD TFileNameDatabase::field_214

TSparseArray TFileNameDatabase::FileNameIndexes

TBitEntryArray TFileNameDatabase::FrgmDist_HiBits

TGenericArray TFileNameDatabase::FrgmDist_LoBits

TNameIndexStruct TFileNameDatabase::IndexStruct_174

TByteStream TFileNameDatabase::MarStream

DWORD TFileNameDatabase::NameFragIndexMask

TGenericArray TFileNameDatabase::NameFragTable

TFileNameDatabasePtr TFileNameDatabase::NextDB

TStruct10 TFileNameDatabase::Struct10

TSparseArray TFileNameDatabase::Struct68_00

TSparseArray TFileNameDatabase::Struct68_D0

---

The documentation for this class was generated from the following files:

• dep/CascLib/src/CascMndx.h
• dep/CascLib/src/CascRootFile_Mndx.cpp