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>
478 lines
14 KiB
C++
478 lines
14 KiB
C++
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* BAGS.H */
|
|
/* */
|
|
/* Copyright (c) 1991, 1994 Borland International */
|
|
/* All Rights Reserved */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
#if !defined( CLASSLIB_BAGS_H )
|
|
#define CLASSLIB_BAGS_H
|
|
|
|
#if !defined( __CHECKS_H )
|
|
#include <checks.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_DEFS_H )
|
|
#include <classlib/defs.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_SHDDEL_H )
|
|
#include <classlib/shddel.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_VECTIMP_H )
|
|
#include <classlib/vectimp.h>
|
|
#endif
|
|
|
|
#pragma option -Vo-
|
|
#if defined( BI_CLASSLIB_NO_po )
|
|
#pragma option -po-
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Vect, class T> class TBagAsVectorImp */
|
|
/* */
|
|
/* Implements a bag, using a vector as the underlying implementation. */
|
|
/* The type Vect specifies the form of the vector, either a */
|
|
/* TCVectorImp<T0> or a TICVectorImp<T0>. The type T specifies the */
|
|
/* type of the objects to be put in the bag. When using */
|
|
/* TVectorImp<T0>, T should be the same as T0. When using */
|
|
/* TIVectorImp<T0>, T should be of type pointer to T0. See */
|
|
/* TBagAsVector and TIBagAsVector for examples. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Vect, class T> class TBagAsVectorImp
|
|
{
|
|
|
|
public:
|
|
|
|
TBagAsVectorImp( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
Data(sz,1)
|
|
{
|
|
}
|
|
|
|
int IsEmpty() const
|
|
{
|
|
return Data.IsEmpty();
|
|
}
|
|
|
|
int IsFull() const
|
|
{ return 0;
|
|
}
|
|
|
|
int GetItemsInContainer() const
|
|
{
|
|
return Data.Top();
|
|
}
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
int isEmpty() const { return IsEmpty(); }
|
|
int isFull() const { return IsFull(); }
|
|
int getItemsInContainer() const { return GetItemsInContainer(); }
|
|
#endif
|
|
|
|
protected:
|
|
|
|
Vect Data;
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BI_BagAsVectorImp TBagAsVectorImp
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class T,class Alloc> class TMBagAsVector */
|
|
/* template <class T,class Alloc> class TMBagAsVectorIterator */
|
|
/* */
|
|
/* Implements a managed bag of objects of type T, using a vector as */
|
|
/* the underlying implementation. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class T, class Alloc> class TMBagAsVectorIterator;
|
|
|
|
template <class T,class Alloc> class TMBagAsVector :
|
|
public TBagAsVectorImp<TMCVectorImp<T,Alloc>,T>
|
|
{
|
|
|
|
typedef TBagAsVectorImp<TMCVectorImp<T,Alloc>,T> Parent;
|
|
|
|
public:
|
|
|
|
friend class TMBagAsVectorIterator<T,Alloc>;
|
|
|
|
typedef void (*IterFunc)(T&, void *);
|
|
typedef int (*CondFunc)(const T&, void *);
|
|
|
|
TMBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
TBagAsVectorImp<TMCVectorImp<T,Alloc>,T>( sz )
|
|
{
|
|
}
|
|
|
|
int Add( const T& t )
|
|
{
|
|
return Data.Add( t );
|
|
}
|
|
|
|
int Detach( const T& t )
|
|
{
|
|
return Data.Detach( t );
|
|
}
|
|
|
|
int HasMember( const T& t ) const
|
|
{
|
|
return Data.Find(t) != UINT_MAX;
|
|
}
|
|
|
|
const T *Find( const T& t ) const
|
|
{
|
|
unsigned loc = Data.Find(t);
|
|
return ( loc == UINT_MAX ? 0 : &Data[loc] );
|
|
}
|
|
|
|
void ForEach( IterFunc iter, void *args )
|
|
{
|
|
Data.ForEach( iter, args, 0, Data.Top() );
|
|
}
|
|
|
|
T *FirstThat( CondFunc cond, void *args ) const
|
|
{
|
|
return Data.FirstThat( cond, args, 0, Data.Top() );
|
|
}
|
|
|
|
T *LastThat( CondFunc cond, void *args ) const
|
|
{
|
|
return Data.LastThat( cond, args, 0, Data.Top() );
|
|
}
|
|
|
|
void Flush()
|
|
{
|
|
Data.Flush();
|
|
}
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
void add( const T& t ) { Add(t); }
|
|
void detach( const T& t,
|
|
TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
|
|
{ Detach( t ); }
|
|
int hasMember( const T& t ) const { return HasMember(t); }
|
|
T findMember( const T& t ) const
|
|
{
|
|
PRECONDITION( HasMember(t) );
|
|
return *Find(t);
|
|
}
|
|
Parent::isEmpty;
|
|
Parent::isFull;
|
|
Parent::getItemsInContainer;
|
|
void forEach( IterFunc iter, void *args )
|
|
{ ForEach( iter, args ); }
|
|
T *firstThat( CondFunc cond, void *args ) const
|
|
{ return FirstThat( cond, args ); }
|
|
T *lastThat( CondFunc cond, void *args ) const
|
|
{ return LastThat( cond, args ); }
|
|
void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
|
|
{
|
|
Flush();
|
|
}
|
|
|
|
#endif // BI_OLDNAMES
|
|
|
|
};
|
|
|
|
template <class T,class Alloc> class TMBagAsVectorIterator :
|
|
private TMVectorIteratorImp<T,Alloc>
|
|
{
|
|
|
|
typedef TMVectorIteratorImp<T,Alloc> Parent;
|
|
|
|
public:
|
|
|
|
TMBagAsVectorIterator( const TMBagAsVector<T,Alloc>& b ) :
|
|
TMVectorIteratorImp<T,Alloc>(b.Data)
|
|
{
|
|
}
|
|
|
|
void Restart()
|
|
{
|
|
Parent::Restart();
|
|
}
|
|
|
|
Parent::operator int;
|
|
Parent::Current;
|
|
Parent::operator ++;
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
Parent::restart;
|
|
Parent::current;
|
|
#endif
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BI_MBagAsVector TMBagAsVector
|
|
#define BI_MBagAsVectorIterator TMBagAsVectorIterator
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class T> class TBagAsVector */
|
|
/* template <class T> class TBagAsVectorIterator */
|
|
/* */
|
|
/* Implements a bag of objects of type T, using a vector as the */
|
|
/* underlying implementation and TStandardAllocator as its memory */
|
|
/* manager. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class T> class TBagAsVector :
|
|
public TMBagAsVector<T,TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
TMBagAsVector<T,TStandardAllocator>( sz )
|
|
{
|
|
}
|
|
|
|
};
|
|
|
|
template <class T> class TBagAsVectorIterator :
|
|
public TMBagAsVectorIterator<T,TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TBagAsVectorIterator( const TBagAsVector<T>& b ) :
|
|
TMBagAsVectorIterator<T,TStandardAllocator>(b)
|
|
{
|
|
}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BI_BagAsVector TBagAsVector
|
|
#define BI_BagAsVectorIterator TBagAsVectorIterator
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class T,class Alloc> class TMIBagAsVector */
|
|
/* template <class T,class Alloc> class TMIBagAsVectorIterator */
|
|
/* */
|
|
/* Implements a managed bag of pointers to objects of type T, */
|
|
/* using a vector as the underlying implementation. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class T, class Alloc> class TMIBagAsVectorIterator;
|
|
|
|
template <class T,class Alloc> class TMIBagAsVector :
|
|
public TBagAsVectorImp<TMICVectorImp<T,Alloc>,T *>,
|
|
public TShouldDelete
|
|
{
|
|
|
|
typedef TBagAsVectorImp<TMICVectorImp<T,Alloc>,T *> Parent;
|
|
|
|
public:
|
|
|
|
typedef void (*IterFunc)(T&, void *);
|
|
typedef int (*CondFunc)(const T&, void *);
|
|
|
|
friend TMIBagAsVectorIterator<T,Alloc>;
|
|
|
|
TMIBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
TBagAsVectorImp<TMICVectorImp<T,Alloc>,T *>(sz)
|
|
{
|
|
}
|
|
|
|
~TMIBagAsVector()
|
|
{
|
|
Flush();
|
|
}
|
|
|
|
int Add( T *t )
|
|
{
|
|
return Data.Add( t );
|
|
}
|
|
|
|
int Detach( T *t, DeleteType dt = NoDelete )
|
|
{
|
|
return Data.Detach( t, dt );
|
|
}
|
|
|
|
int HasMember( const T *t ) const
|
|
{
|
|
return Data.Find(t) != UINT_MAX;
|
|
}
|
|
|
|
void Flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
|
|
{
|
|
Data.Flush( DelObj(dt), Data.Top(), 0 );
|
|
}
|
|
|
|
T *Find( T *t ) const
|
|
{
|
|
unsigned loc = Data.Find(t);
|
|
return ( loc == UINT_MAX ? 0 : STATIC_CAST(T *,Data[loc]) );
|
|
}
|
|
|
|
void ForEach( IterFunc iter, void *args )
|
|
{
|
|
Data.ForEach( iter, args, 0, Data.Top() );
|
|
}
|
|
|
|
T *FirstThat( CondFunc cond, void *args ) const
|
|
{
|
|
return Data.FirstThat( cond, args, 0, Data.Top() );
|
|
}
|
|
|
|
T *LastThat( CondFunc cond, void *args ) const
|
|
{
|
|
return Data.LastThat( cond, args, 0, Data.Top() );
|
|
}
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
void add( T *t ) { Add(t); }
|
|
void detach( T *t, DeleteType dt = NoDelete ) { Detach( t, dt ); }
|
|
void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
|
|
{ Flush( dt ); }
|
|
T *findMember( T *t ) const { return Find(t); }
|
|
Parent::isEmpty;
|
|
Parent::isFull;
|
|
Parent::getItemsInContainer;
|
|
void forEach( IterFunc iter, void *args )
|
|
{ ForEach( iter, args ); }
|
|
T *firstThat( CondFunc cond, void *args ) const
|
|
{ return FirstThat( cond, args ); }
|
|
T *lastThat( CondFunc cond, void *args ) const
|
|
{ return LastThat( cond, args ); }
|
|
#endif // BI_OLDNAMES
|
|
|
|
};
|
|
|
|
template <class T,class Alloc> class TMIBagAsVectorIterator :
|
|
public TMICVectorIteratorImp<T,Alloc>
|
|
{
|
|
|
|
public:
|
|
|
|
TMIBagAsVectorIterator( const TMIBagAsVector<T,Alloc>& s ) :
|
|
TMICVectorIteratorImp<T,Alloc>(s.Data,0,s.Data.Top()) {}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BI_MIBagAsVector TMIBagAsVector
|
|
#define BI_MIBagAsVectorIterator TMIBagAsVectorIterator
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class T> class TIBagAsVector */
|
|
/* template <class T> class TIBagAsVectorIterator */
|
|
/* */
|
|
/* Implements a bag of pointers to objects of type T, using a vector as */
|
|
/* the underlying implementation and TStandardAllocator as its memory */
|
|
/* manager. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class T> class TIBagAsVector :
|
|
public TMIBagAsVector<T,TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TIBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
TMIBagAsVector<T,TStandardAllocator>(sz)
|
|
{
|
|
}
|
|
|
|
};
|
|
|
|
template <class T> class TIBagAsVectorIterator :
|
|
private TMIBagAsVectorIterator<T,TStandardAllocator>
|
|
{
|
|
|
|
typedef TMIBagAsVectorIterator<T,TStandardAllocator> Parent;
|
|
|
|
public:
|
|
|
|
TIBagAsVectorIterator( const TIBagAsVector<T>& s ) :
|
|
TMIBagAsVectorIterator<T,TStandardAllocator>(s)
|
|
{
|
|
}
|
|
|
|
void Restart()
|
|
{
|
|
Parent::Restart();
|
|
}
|
|
|
|
Parent::operator int;
|
|
Parent::Current;
|
|
Parent::operator ++;
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
Parent::restart;
|
|
Parent::current;
|
|
#endif
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BI_IBagAsVector TIBagAsVector
|
|
#define BI_IBagAsVectorIterator TIBagAsVectorIterator
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class T> class TBag */
|
|
/* template <class T> class TBagIterator */
|
|
/* */
|
|
/* Easy names for TBagAsVector and TBagAsVectorIterator. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class T> class TBag :
|
|
public TBagAsVector<T>
|
|
{
|
|
|
|
public:
|
|
|
|
TBag( unsigned sz = DEFAULT_BAG_SIZE ) :
|
|
TBagAsVector<T>( sz )
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
template <class T> class TBagIterator :
|
|
public TBagAsVectorIterator<T>
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
TBagIterator( const TBag<T>& a ) :
|
|
TBagAsVectorIterator<T>(a)
|
|
{
|
|
}
|
|
|
|
};
|
|
|
|
#if defined( BI_CLASSLIB_NO_po )
|
|
#pragma option -po.
|
|
#endif
|
|
|
|
#pragma option -Vo.
|
|
|
|
#endif // CLASSLIB_BAGS_H
|
|
|