CydandClaude Fable 5
63312e07f9
- BORLAND/: Borland C++ 4.52 (chosen over 4.5 by byte-match: CODE/RP/CW32.LIB
is identical to 4.52's install lib). BCC32/TLINK32/TLIB/MAKE run natively on
Win11; CODE/BT/OPT.MAK is the shipped BTL4OPT.EXE's exact flag recipe
(extender = Borland PowerPack DPMI32, not Phar Lap TNT).
- restoration/source410/: the literal 1995-form reconstruction of the missing
BT game source (never mixed into CODE/). Round 1-3 state:
* 6 of 10 surviving original TUs COMPILE CLEAN under the period toolchain
(BTMSSN, BTCNSL, BTSCNRL, BTTEAM, BTL4MODE, BTL4ARND) - first builds
since 1996.
* BT_L4/BTL4APP.CPP pilot reconstruction: 12/12 functions, Fail() lands on
its binary-recorded line 400 exactly.
* BT/BTCNSL.HPP: console wire IDs recovered from the binary's ctors
(Killed=9, Damaged=10, ScoreUpdate=13, DeathWithoutHonor=15 [T1];
TeamScore=12 flagged [T4]).
* MUNGA/: 8 engine-header backfills back-dated from the BT412 WinTesla tree
(VDATA numbering decomp-verified; AUDREND's OpenAL-era virtual removed -
the period compiler is the drift detector).
* Tooling: backdate.py (WinTesla->1995 header transform), compile410.sh
(per-TU verification sweep under authentic OPT.MAK flags).
* README: corrected roadmap - MECH.HPP is the capstone grown with the mech
TU reconstructions; BTREG.CPP green = the header-family milestone.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
155 lines
4.3 KiB
Plaintext
155 lines
4.3 KiB
Plaintext
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* HASHTBL.CPP */
|
|
/* */
|
|
/* Copyright Borland International 1991, 1993 */
|
|
/* All Rights Reserved */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
#if !defined( __IOSTREAM_H )
|
|
#include <iostream.h>
|
|
#endif // __IOSTREAM_H
|
|
|
|
#if !defined( __HASHTBL_H )
|
|
#include "classlib\obsolete\hashtbl.h"
|
|
#endif // __HASHTBL_H
|
|
|
|
HashTable::HashTable( sizeType aPrime ) :
|
|
size( aPrime ),
|
|
table( aPrime ),
|
|
itemsInContainer(0)
|
|
{
|
|
}
|
|
|
|
void HashTable::add( Object& objectToAdd )
|
|
{
|
|
hashValueType index = getHashValue( objectToAdd );
|
|
if( table[ index ] == 0 )
|
|
table[index] = new List;
|
|
((List *)table[ index ])->add( objectToAdd );
|
|
itemsInContainer++;
|
|
}
|
|
|
|
void HashTable::detach( Object& objectToDetach, DeleteType dt )
|
|
{
|
|
hashValueType index = getHashValue( objectToDetach );
|
|
if( table[ index ] != 0 )
|
|
{
|
|
unsigned listSize = ((List *)table[ index ])->getItemsInContainer();
|
|
((List *)table[ index ])->detach( objectToDetach, delItem(dt) );
|
|
if( ((List *)table[ index ])->getItemsInContainer() != listSize )
|
|
itemsInContainer--;
|
|
}
|
|
}
|
|
|
|
static void setOwner( Object& list, void *owns )
|
|
{
|
|
((List&)list).ownsElements( *(TShouldDelete::DeleteType *)owns );
|
|
}
|
|
|
|
void HashTable::flush( DeleteType dt )
|
|
{
|
|
int shouldDel = delObj( dt );
|
|
table.forEach( setOwner, &shouldDel );
|
|
table.flush( 1 );
|
|
itemsInContainer = 0;
|
|
}
|
|
|
|
Object& HashTable::findMember( Object& testObject ) const
|
|
{
|
|
hashValueType index = getHashValue( testObject );
|
|
if( index >= table.limit() || table[ index ] == 0 )
|
|
{
|
|
return NOOBJECT;
|
|
}
|
|
return ((List *)table[ index ])->findMember( testObject );
|
|
}
|
|
|
|
ContainerIterator& HashTable::initIterator() const
|
|
{
|
|
return *( (ContainerIterator *)new HashTableIterator( *this ) );
|
|
}
|
|
|
|
HashTableIterator::HashTableIterator( const HashTable& toIterate ) :
|
|
beingIterated( toIterate ),
|
|
listIterator(0)
|
|
{
|
|
arrayIterator = new BI_IVectorIteratorImp<Object>( toIterate.table );
|
|
restart();
|
|
}
|
|
|
|
HashTableIterator::~HashTableIterator()
|
|
{
|
|
delete arrayIterator;
|
|
delete listIterator;
|
|
}
|
|
|
|
Object& HashTableIterator::operator ++ ( int )
|
|
{
|
|
Object& res = (listIterator == 0) ? NOOBJECT : listIterator->current();
|
|
scan();
|
|
return res;
|
|
}
|
|
|
|
Object& HashTableIterator::operator ++ ()
|
|
{
|
|
scan();
|
|
return (listIterator == 0) ? NOOBJECT : listIterator->current();
|
|
}
|
|
|
|
HashTableIterator::operator int()
|
|
{
|
|
return int(*arrayIterator);
|
|
}
|
|
|
|
Object& HashTableIterator::current()
|
|
{
|
|
return (listIterator == 0) ? NOOBJECT : listIterator->current();
|
|
}
|
|
|
|
void HashTableIterator::restart()
|
|
{
|
|
delete listIterator;
|
|
|
|
arrayIterator->restart();
|
|
while( *arrayIterator != 0 && arrayIterator->current() == 0 )
|
|
(*arrayIterator)++;
|
|
|
|
if( *arrayIterator != 0 )
|
|
{
|
|
const Object *curList = arrayIterator->current();
|
|
listIterator = &(((List *)curList)->initIterator());
|
|
if( listIterator->current() == NOOBJECT )
|
|
scan();
|
|
}
|
|
else
|
|
listIterator = 0;
|
|
}
|
|
|
|
void HashTableIterator::scan()
|
|
{
|
|
if( listIterator == 0 )
|
|
return;
|
|
|
|
(*listIterator)++;
|
|
while( listIterator != 0 && listIterator->current() == NOOBJECT )
|
|
{
|
|
delete listIterator;
|
|
|
|
(*arrayIterator)++;
|
|
while( *arrayIterator != 0 && arrayIterator->current() == 0 )
|
|
(*arrayIterator)++;
|
|
|
|
if( *arrayIterator == 0 || arrayIterator->current() == 0 )
|
|
{
|
|
listIterator = 0;
|
|
}
|
|
else
|
|
{
|
|
const Object *cur = arrayIterator->current();
|
|
listIterator = &(((Container *)cur)->initIterator());
|
|
}
|
|
}
|
|
}
|