vwemirror/TeslaRel410
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e610a2a3aa5dc072ddfdc996905251a5bb830da1
TeslaRel410/BORLAND/BC45/INCLUDE/CLASSLIB/ARRAYS.H
T
CydandClaude Fable 5 63312e07f9 source410: literal 4.10 source reconstruction + BC++ 4.52 fleet toolchain archived 
- 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>
2026-07-19 07:33:26 -05:00

849 lines
26 KiB
C++
Raw Blame History

/*------------------------------------------------------------------------*/
/* */
/* ARRAYS.H */
/* */
/* Copyright (c) 1991, 1994 Borland International */
/* All Rights Reserved */
/* */
/*------------------------------------------------------------------------*/
#if !defined( CLASSLIB_ARRAYS_H )
#define CLASSLIB_ARRAYS_H
//#define TEMPLATES
#if !defined( __MEM_H )
#include <mem.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_ALLOCTR_H )
#include <classlib/alloctr.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
/*------------------------------------------------------------------------*/
/* */
/* [INTERNAL USE ONLY] */
/* */
/* template <class Vect, class T> class TArrayAsVectorImp */
/* */
/* Implements the type-independent array operations, using a vector */
/* as the underlying implementation. The type Vect specifies the */
/* form of the vector, either a TCVectorImp<T0>, a TSVectorImp<T0>, a */
/* TICVectorImp<T0>, or a TISVectorImp<T0>. The type T specifies the */
/* type of the objects to be put in the array. When using */
/* TCVectorImp<T0> or a TSVectorImp<T0> T should be the same as T0. When */
/* using TICVectorImp<T0> or TISVectorImp<T0> T should be of type */
/* pointer to T0. See TArrayAsVector and */
/* TIArrayAsVector for examples. */
/* */
/*------------------------------------------------------------------------*/
template <class Vect, class T> class TArrayAsVectorImp
{
public:
TArrayAsVectorImp( int upper, int lower, int delta ) :
Data( upper-lower+1,delta ),
Lowerbound( lower )
{
}
int LowerBound() const
{
return Lowerbound;
}
int UpperBound() const
{
return BoundBase( Data.Limit() )-1;
}
unsigned ArraySize() const
{
return Data.Limit();
}
int IsFull() const
{
return Data.GetDelta() == 0 && Data.Count() >= Data.Limit();
}
int IsEmpty() const
{
return Data.Count() == 0;
}
unsigned GetItemsInContainer() const
{
return Data.Count();
}
#if defined( BI_OLDNAMES )
int lowerBound() const { return LowerBound(); }
int upperBound() const { return UpperBound(); }
unsigned arraySize() const { return ArraySize(); }
int isFull() const { return IsFull(); }
int isEmpty() const { return IsEmpty(); }
unsigned getItemsInContainer() const { return GetItemsInContainer(); }
#endif
void Reallocate( unsigned sz, unsigned offset = 0 )
{
Data.Resize( sz, offset );
}
void SetData( int loc, const T& t )
{
PRECONDITION( loc >= Lowerbound && loc <= UpperBound() );
Data[ ZeroBase(loc) ] = t;
}
void RemoveEntry( int loc )
{
SqueezeEntry( ZeroBase(loc) );
}
void SqueezeEntry( unsigned loc )
{
PRECONDITION( loc < Data.Count() );
Data.Detach( loc );
}
unsigned ZeroBase( int loc ) const
{
return loc - Lowerbound;
}
int BoundBase( unsigned loc ) const
{
return loc == UINT_MAX ? INT_MAX : loc + Lowerbound;
}
void Grow( int loc )
{
if( loc < LowerBound() )
Reallocate( ArraySize() + (loc - Lowerbound) );
else if( loc >= BoundBase( Data.Limit()) )
Reallocate( ZeroBase(loc) );
}
int Lowerbound;
Vect Data;
};
/*------------------------------------------------------------------------*/
/* */
/* [INTERNAL USE ONLY] */
/* */
/* template <class Vect, class T> class TDArrayAsVectorImp */
/* */
/* Implements the fundamental array operations for direct arrays, using */
/* a vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class Vect, class T> class TDArrayAsVectorImp :
public TArrayAsVectorImp<Vect,T>
{
public:
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
TDArrayAsVectorImp( int upper, int lower, int delta ) :
TArrayAsVectorImp<Vect,T>( upper, lower, delta )
{
}
int Add( const T& t )
{
return Data.Add(t);
}
int Detach( const T& t )
{
return Data.Detach(t);
}
int Detach( int loc )
{
return Data.Detach( ZeroBase(loc) );
}
int Destroy( const T& t )
{
return Detach(t);
}
int Destroy( int loc )
{
return Detach(loc);
}
int HasMember( const T& t ) const
{
return Data.Find(t) != UINT_MAX;
}
int Find( const T& t ) const
{
return BoundBase( Data.Find( t ) );
}
T& operator []( int loc )
{
Grow( loc+1 );
return Data[ZeroBase(loc)];
}
T& operator []( int loc ) const
{
PRECONDITION( loc >= Lowerbound && ZeroBase(loc) < Data.Limit() );
return Data[ZeroBase(loc)];
}
void ForEach( IterFunc iter, void *args )
{
if( !IsEmpty() )
Data.ForEach( iter, args );
}
T *FirstThat( CondFunc cond, void *args ) const
{
if( IsEmpty() )
return 0;
return Data.FirstThat( cond, args );
}
T *LastThat( CondFunc cond, void *args ) const
{
if( IsEmpty() )
return 0;
return Data.LastThat( cond, args );
}
void Flush()
{
Data.Flush();
}
#if defined( BI_OLDNAMES )
int add( const T& t ) { return Add(t); }
int detach( const T& t,TShouldDelete::DeleteType=TShouldDelete::NoDelete)
{ return Detach(t); }
int detach( int loc,TShouldDelete::DeleteType=TShouldDelete::NoDelete)
{ return Detach(loc); }
int destroy( const T& t ) { return Destroy(t); }
int destroy( int loc,TShouldDelete::DeleteType ) { return Destroy(loc); }
int hasMember( const T& t ) const { return HasMember(t); }
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 = TShouldDelete::DefDelete )
{ Flush(); }
#endif
protected:
const T& ItemAt( int i ) const
{
return Data[ ZeroBase(i) ];
}
};
/*------------------------------------------------------------------------*/
/* */
/* [INTERNAL USE ONLY] */
/* */
/* template <class Vect, class T> class TIArrayAsVectorImp */
/* */
/* Implements the fundamental array operations for indirect arrays, */
/* using a vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class Vect, class T> class TIArrayAsVectorImp :
public TArrayAsVectorImp<Vect,T *>, public TShouldDelete
{
public:
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
TIArrayAsVectorImp( int upper, int lower, int delta ) :
TArrayAsVectorImp<Vect,T *>( upper, lower, delta )
{
}
~TIArrayAsVectorImp()
{
Flush();
}
int Add( T *t )
{
return Data.Add(t);
}
int Detach( T *t,
TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
{
return Data.Detach(t,DelObj(dt));
}
int Detach( int loc,
TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
{
return Data.Detach( ZeroBase(loc), DelObj(dt) );
}
int Destroy( T *t )
{
return Detach(t,TShouldDelete::Delete);
}
int Destroy( int loc )
{
return Detach(loc,TShouldDelete::Delete);
}
int HasMember( const T *t ) const
{
return Data.Find(t) != UINT_MAX;
}
int Find( const T *t ) const
{
return BoundBase( Data.Find( t ) );
}
T *& operator []( int loc )
{
Grow( loc+1 );
return Data[ZeroBase(loc)];
}
T *& operator []( int loc ) const
{
PRECONDITION( loc >= Lowerbound && ZeroBase(loc) < Data.Limit() );
return Data[ZeroBase(loc)];
}
void ForEach( IterFunc iter, void *args )
{
if( !IsEmpty() )
Data.ForEach( iter, args );
}
T *FirstThat( CondFunc cond, void *args ) const
{
if( IsEmpty() )
return 0;
return Data.FirstThat( cond, args );
}
T *LastThat( CondFunc cond, void *args ) const
{
if( IsEmpty() )
return 0;
return Data.LastThat( cond, args );
}
void Flush( DeleteType dt = DefDelete )
{
Data.Flush(DelObj(dt));
}
#if defined( BI_OLDNAMES )
int add( T *t ) { return Add(t); }
int detach( T *t,TShouldDelete::DeleteType dt =TShouldDelete::NoDelete)
{ return Detach(t,dt); }
int detach( int loc,TShouldDelete::DeleteType dt =TShouldDelete::NoDelete)
{ return Detach(loc,dt); }
int destroy( T *t ) { return Destroy(t); }
int destroy( int loc,TShouldDelete::DeleteType ) { return Destroy(loc); }
int find( const T *t ) const { return Find(t); }
int hasMember( T *t ) const { return HasMember(t); }
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 = TShouldDelete::DefDelete )
{ Flush(); }
#endif
protected:
T *& ItemAt( int i ) const
{
return Data[ ZeroBase(i) ];
}
};
/*------------------------------------------------------------------------*/
/* */
/* template <class T,class Alloc> class TMArrayAsVector */
/* template <class T,class Alloc> class TMArrayAsVectorIterator */
/* */
/* Implements a managed array of objects of type T, using a vector as */
/* the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Alloc> class TMArrayAsVectorIterator;
template <class T, class Alloc> class TMArrayAsVector :
public TDArrayAsVectorImp<TMCVectorImp<T,Alloc>,T>
{
friend TMArrayAsVectorIterator<T,Alloc>;
public:
TMArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TDArrayAsVectorImp<TMCVectorImp<T,Alloc>,T>( upper, lower, delta )
{
}
int AddAt( const T& t, int loc )
{
return Data.AddAt( t, ZeroBase(loc) );
}
#if defined( BI_OLDNAMES )
int addAt( const T& t, int loc ) { return AddAt(t,loc); }
#endif
};
template <class T, class Alloc> class TMArrayAsVectorIterator :
public TMCVectorIteratorImp<T,Alloc>
{
public:
TMArrayAsVectorIterator( const TMArrayAsVector<T,Alloc>& a ) :
TMCVectorIteratorImp<T,Alloc>( a.Data ) {}
};
#if defined( BI_OLDNAMES )
#define BI_MArrayAsVector TMArrayAsVector
#define BI_MArrayAsVectorIterator TMArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TArrayAsVector */
/* template <class T> class TArrayAsVectorIterator */
/* */
/* Implements an array of objects of type T, using a vector as the */
/* underlying implementation and TStandardAllocator as its memory */
/* manager. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TArrayAsVector :
public TMArrayAsVector<T,TStandardAllocator>
{
public:
TArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TMArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
{
}
};
template <class T> class TArrayAsVectorIterator :
public TMArrayAsVectorIterator<T,TStandardAllocator>
{
public:
TArrayAsVectorIterator( const TArrayAsVector<T>& a ) :
TMArrayAsVectorIterator<T,TStandardAllocator>(a)
{
}
};
#if defined( BI_OLDNAMES )
#define BI_ArrayAsVector TArrayAsVector
#define BI_ArrayAsVectorIterator TArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T,class Alloc> class TMSArrayAsVector */
/* template <class T,class Alloc> class TMSArrayAsVectorIterator */
/* */
/* Implements a managed, sorted array of objects of type T, using a */
/* vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Alloc> class TMSArrayAsVectorIterator;
template <class T, class Alloc> class TMSArrayAsVector :
public TDArrayAsVectorImp<TMSVectorImp<T,Alloc>,T>
{
friend TMSArrayAsVectorIterator<T,Alloc>;
public:
TMSArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TDArrayAsVectorImp<TMSVectorImp<T,Alloc>,T>( upper, lower, delta )
{
}
};
template <class T, class Alloc> class TMSArrayAsVectorIterator :
public TMSVectorIteratorImp<T,Alloc>
{
public:
TMSArrayAsVectorIterator( const TMSArrayAsVector<T,Alloc>& a ) :
TMSVectorIteratorImp<T,Alloc>( a.Data ) {}
};
#if defined( BI_OLDNAMES )
#define BI_MSArrayAsVector TMSArrayAsVector
#define BI_MSArrayAsVectorIterator TMSArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TSArrayAsVector */
/* template <class T> class TSArrayAsVectorIterator */
/* */
/* Implements a sorted array of objects of type T, using a vector as */
/* the underlying implementation and TStandardAllocator as its memory */
/* manager. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TSArrayAsVector :
public TMSArrayAsVector<T,TStandardAllocator>
{
public:
TSArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TMSArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
{
}
};
template <class T> class TSArrayAsVectorIterator :
public TMSArrayAsVectorIterator<T,TStandardAllocator>
{
public:
TSArrayAsVectorIterator( const TSArrayAsVector<T>& a ) :
TMSArrayAsVectorIterator<T,TStandardAllocator>( a ) {}
}
#if defined( BI_OLDNAMES )
#define BI_SArrayAsVector TSArrayAsVector
#define BI_SArrayAsVectorIterator TSArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T,class Alloc> class TMIArrayAsVector */
/* template <class T,class Alloc> class TMIArrayAsVectorIterator */
/* */
/* Implements a managed indirect array of objects of type T, using a */
/* vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Alloc> class TMIArrayAsVectorIterator;
template <class T, class Alloc> class TMIArrayAsVector :
public TIArrayAsVectorImp<TMICVectorImp<T,Alloc>,T>
{
friend TMIArrayAsVectorIterator<T,Alloc>;
public:
TMIArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TIArrayAsVectorImp<TMICVectorImp<T,Alloc>,T>( upper, lower, delta )
{
}
int AddAt( T *t, int loc )
{
return Data.AddAt( t, ZeroBase(loc) );
}
#if defined( BI_OLDNAMES )
int addAt( T *t, int loc ) { return AddAt(t,loc); }
#endif
};
template <class T, class Alloc> class TMIArrayAsVectorIterator :
public TMICVectorIteratorImp<T,Alloc>
{
public:
TMIArrayAsVectorIterator( const TMIArrayAsVector<T,Alloc>& a ) :
TMICVectorIteratorImp<T,Alloc>( a.Data ) {}
};
#if defined( BI_OLDNAMES )
#define BI_MIArrayAsVector TMIArrayAsVector
#define BI_MIArrayAsVectorIterator TMIArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TIArrayAsVector */
/* template <class T> class TIArrayAsVectorIterator */
/* */
/* Implements an indirect array of objects of type T, using a vector as */
/* the underlying implementation and TStandardAllocator as its memory */
/* manager. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TIArrayAsVector :
public TMIArrayAsVector<T,TStandardAllocator>
{
public:
TIArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TMIArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
{
}
};
template <class T> class TIArrayAsVectorIterator :
public TMIArrayAsVectorIterator<T,TStandardAllocator>
{
public:
TIArrayAsVectorIterator( const TIArrayAsVector<T>& a ) :
TMIArrayAsVectorIterator<T,TStandardAllocator>(a)
{
}
};
#if defined( BI_OLDNAMES )
#define BI_IArrayAsVector TIArrayAsVector
#define BI_IArrayAsVectorIterator TIArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T,class Alloc> class TMISArrayAsVector */
/* template <class T,class Alloc> class TMISArrayAsVectorIterator */
/* */
/* Implements a managed, indirect sorted array of objects of type T, */
/* using a vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Alloc> class TMISArrayAsVectorIterator;
template <class T, class Alloc> class TMISArrayAsVector :
public TIArrayAsVectorImp<TMISVectorImp<T,Alloc>,T>
{
friend TMISArrayAsVectorIterator<T,Alloc>;
public:
TMISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TIArrayAsVectorImp<TMISVectorImp<T,Alloc>,T>( upper, lower, delta )
{
}
};
template <class T, class Alloc> class TMISArrayAsVectorIterator :
public TMISVectorIteratorImp<T,Alloc>
{
public:
TMISArrayAsVectorIterator( const TMISArrayAsVector<T,Alloc>& a ) :
TMISVectorIteratorImp<T,Alloc>( a.Data ) {}
};
#if defined( BI_OLDNAMES )
#define BI_MISArrayAsVector TMISArrayAsVector
#define BI_MIArrayAsVectorIterator TMIArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TISArrayAsVector */
/* template <class T> class TISArrayAsVectorIterator */
/* */
/* Implements an indirect sorted array of objects of type T, using a */
/* vector as the underlying implementation and TStandardAllocator as its */
/* memory manager. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TISArrayAsVector :
public TMISArrayAsVector<T,TStandardAllocator>
{
public:
TISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
TMISArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
{
}
};
template <class T> class TISArrayAsVectorIterator :
public TMISArrayAsVectorIterator<T,TStandardAllocator>
{
public:
TISArrayAsVectorIterator( const TISArrayAsVector<T>& a ) :
TMISArrayAsVectorIterator<T,TStandardAllocator>(a)
{
}
};
#if defined( BI_OLDNAMES )
#define BI_ISArrayAsVector TISArrayAsVector
#define BI_ISArrayAsVectorIterator TISArrayAsVectorIterator
#endif
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TArray */
/* template <class T> class TArrayIterator */
/* */
/* Easy names for TArrayAsVector and TArrayAsVectorIterator */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TArray :
public TArrayAsVector<T>
{
public:
TArray( int upper, int lower = 0, int delta = 0 ) :
TArrayAsVector<T>( upper, lower, delta )
{
}
};
template <class T> class TArrayIterator :
public TArrayAsVectorIterator<T>
{
public:
TArrayIterator( const TArray<T>& a ) :
TArrayAsVectorIterator<T>(a)
{
}
};
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class TSArray */
/* template <class T> class TSArrayIterator */
/* */
/* Easy names for TSArrayAsVector and TSArrayAsVectorIterator */
/* */
/*------------------------------------------------------------------------*/
template <class T> class TSArray :
public TSArrayAsVector<T>
{
public:
TSArray( int upper, int lower = 0, int delta = 0 ) :
TSArrayAsVector<T>( upper, lower, delta )
{
}
};
template <class T> class TSArrayIterator :
public TSArrayAsVectorIterator<T>
{
public:
TSArrayIterator( const TSArray<T>& a ) :
TSArrayAsVectorIterator<T>(a)
{
}
};
#if defined( BI_CLASSLIB_NO_po )
#pragma option -po.
#endif
#pragma option -Vo.
#endif // CLASSLIB_ARRAYS_H
Reference in New Issue View Git Blame Copy Permalink