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>
477 lines
14 KiB
C++
477 lines
14 KiB
C++
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* MEMMGR.H */
|
|
/* */
|
|
/* Copyright (c) 1991, 1994 Borland International */
|
|
/* All Rights Reserved */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
#if !defined( CLASSLIB_MEMMGR_H )
|
|
#define CLASSLIB_MEMMGR_H
|
|
|
|
#if !defined( __STDLIB_H )
|
|
#include <stdlib.h>
|
|
#endif
|
|
|
|
#if !defined( __DOS_H )
|
|
#include <dos.h>
|
|
#endif
|
|
|
|
#if !defined( __CHECKS_H )
|
|
#include <checks.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_DEFS_H )
|
|
#include <classlib/defs.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_STDTEMPL_H )
|
|
#include <classlib/stdtempl.h>
|
|
#endif
|
|
|
|
#if !defined( CLASSLIB_ALLOCTR_H )
|
|
#include <classlib/alloctr.h>
|
|
#endif
|
|
|
|
#pragma option -Vo-
|
|
#if defined( BI_CLASSLIB_NO_po )
|
|
#pragma option -po-
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMBlockList */
|
|
/* */
|
|
/* Used internally. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Alloc> class TMBaseMemBlocks;
|
|
|
|
template <class Alloc> class TMBlockList
|
|
{
|
|
|
|
public:
|
|
|
|
TMBlockList( TMBlockList * );
|
|
|
|
private:
|
|
|
|
void *operator new( size_t, size_t, const Alloc& );
|
|
void *operator new [] ( size_t, size_t, const Alloc& );
|
|
void operator delete( void * );
|
|
void operator delete [] ( void * );
|
|
|
|
TMBlockList *Next;
|
|
|
|
friend TMBaseMemBlocks<Alloc>;
|
|
|
|
};
|
|
|
|
template <class Alloc>
|
|
inline TMBlockList<Alloc>::TMBlockList( TMBlockList<Alloc> *nxt ) :
|
|
Next( nxt )
|
|
{
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline void *TMBlockList<Alloc>::operator new ( size_t sz,
|
|
size_t extra,
|
|
const Alloc& a )
|
|
{
|
|
return new(a)char[sz+extra];
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline void TMBlockList<Alloc>::operator delete ( void *ptr )
|
|
{
|
|
Alloc::operator delete(ptr);
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline void TMBlockList<Alloc>::operator delete [] ( void _BIDSFAR * ptr )
|
|
{
|
|
Alloc::operator delete [] (ptr);
|
|
}
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MBlockList TMBlockList
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* class TBlockList */
|
|
/* */
|
|
/* Used internally. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
class TBlockList : public TMBlockList<TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TBlockList( TBlockList *blk ) :
|
|
TMBlockList<TStandardAllocator>( blk ) {}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BlockList TBlockList
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMBaseMemBlocks */
|
|
/* */
|
|
/* Used internally. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Alloc> class TMBaseMemBlocks :
|
|
public Alloc
|
|
{
|
|
|
|
public:
|
|
|
|
TMBaseMemBlocks( size_t = 8192 );
|
|
~TMBaseMemBlocks();
|
|
|
|
char *Block() const { return REINTERPRET_CAST(char *,CurBlock); }
|
|
unsigned Count() const { return BlockCount; }
|
|
AllocBlock( size_t );
|
|
void FreeTo( unsigned );
|
|
size_t GetBlockSize() const { return BlockSize; }
|
|
|
|
private:
|
|
|
|
TMBlockList<Alloc> *CurBlock;
|
|
const size_t BlockSize;
|
|
unsigned BlockCount;
|
|
|
|
};
|
|
|
|
template <class Alloc>
|
|
inline TMBaseMemBlocks<Alloc>::TMBaseMemBlocks( size_t sz ) :
|
|
CurBlock(0),
|
|
BlockCount(0),
|
|
BlockSize(sz)
|
|
{
|
|
CHECK( sz != 0 );
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline TMBaseMemBlocks<Alloc>::~TMBaseMemBlocks()
|
|
{
|
|
#if !defined( BI_WINDOWS_WEP_BUG )
|
|
FreeTo( 0 );
|
|
#endif
|
|
}
|
|
|
|
template <class Alloc> int TMBaseMemBlocks<Alloc>::AllocBlock( size_t sz )
|
|
{
|
|
TMBlockList<Alloc> *temp =
|
|
new( max(sz,BlockSize), *this ) TMBlockList<Alloc>( CurBlock-1 );
|
|
if( temp == 0 )
|
|
return 0;
|
|
CurBlock = temp+1;
|
|
BlockCount++;
|
|
return 1;
|
|
}
|
|
|
|
template <class Alloc> void TMBaseMemBlocks<Alloc>::FreeTo( unsigned term )
|
|
{
|
|
PRECONDITION( BlockCount >= term );
|
|
while( BlockCount > term )
|
|
{
|
|
TMBlockList<Alloc> *temp = CurBlock-1;
|
|
CurBlock = (temp->Next)+1;
|
|
delete temp;
|
|
BlockCount--;
|
|
}
|
|
}
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MBaseMemBlocks TMBaseMemBlocks
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* class TBaseMemBlocks */
|
|
/* */
|
|
/* Used internally. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
class TBaseMemBlocks : public TMBaseMemBlocks<TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TBaseMemBlocks( size_t sz = 8192 ) :
|
|
TMBaseMemBlocks<TStandardAllocator>(sz) {}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define BaseMemBlocks TBaseMemBlocks
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMMemStack */
|
|
/* */
|
|
/* Managed memory stack. Implements mark and release style memory */
|
|
/* management, using the allocator Alloc. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Alloc> class TMMarker;
|
|
|
|
template <class Alloc> class TMMemStack
|
|
{
|
|
|
|
public:
|
|
|
|
friend TMMarker<Alloc>;
|
|
|
|
TMMemStack( size_t = 8192 );
|
|
|
|
void *Allocate( size_t );
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
void *allocate( size_t sz ) { return Allocate( sz ); }
|
|
#endif // BI_OLDNAMES
|
|
|
|
private:
|
|
|
|
TMBaseMemBlocks<Alloc> Data;
|
|
size_t CurLoc;
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MMemStack TMMemStack
|
|
#endif
|
|
|
|
template <class Alloc>
|
|
inline void *operator new( size_t sz, TMMemStack<Alloc>& m )
|
|
{
|
|
return m.Allocate( sz );
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline void *operator new [] ( size_t sz, TMMemStack<Alloc>& m )
|
|
{
|
|
return m.Allocate( sz );
|
|
}
|
|
|
|
template <class Alloc> inline TMMemStack<Alloc>::TMMemStack( size_t sz ) :
|
|
Data( sz ),
|
|
CurLoc(sz)
|
|
{
|
|
CHECK( sz != 0 );
|
|
}
|
|
|
|
template <class Alloc> void *TMMemStack<Alloc>::Allocate( size_t sz )
|
|
{
|
|
sz = max( 1U, sz );
|
|
if( sz > Data.GetBlockSize() - CurLoc )
|
|
if( Data.AllocBlock( sz ) == 0 )
|
|
return 0;
|
|
else
|
|
CurLoc = 0;
|
|
void *temp = Data.Block() + CurLoc;
|
|
CurLoc += sz;
|
|
return temp;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMMarker */
|
|
/* */
|
|
/* Provides the mark for TMMemStack. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Alloc> class TMMarker
|
|
{
|
|
|
|
public:
|
|
|
|
TMMarker( TMMemStack<Alloc>& ms ) :
|
|
Memstk(ms),
|
|
Blk(ms.Data.Count()),
|
|
CurLoc(ms.CurLoc)
|
|
{
|
|
}
|
|
|
|
~TMMarker()
|
|
{
|
|
PRECONDITION( Blk < Memstk.Data.Count() ||
|
|
(Blk == Memstk.Data.Count() && CurLoc <= Memstk.CurLoc )
|
|
);
|
|
Memstk.Data.FreeTo( Blk );
|
|
Memstk.CurLoc = CurLoc;
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
TMMemStack<Alloc>& Memstk;
|
|
const unsigned Blk;
|
|
const size_t CurLoc;
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MMarker TMMarker
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* class TMemStack */
|
|
/* */
|
|
/* Implements mark and release style memory management using the */
|
|
/* standard allocator. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
class TMemStack : public TMMemStack<TStandardAllocator>
|
|
{
|
|
public:
|
|
|
|
TMemStack( size_t sz = 8192 ) : TMMemStack<TStandardAllocator>(sz) {}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MemStack TMemStack
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMarker */
|
|
/* */
|
|
/* Provides the mark for TMemStack. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
class TMarker : public TMMarker<TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TMarker( TMMemStack<TStandardAllocator>& ms ) :
|
|
TMMarker<TStandardAllocator>(ms) {}
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* template <class Alloc> class TMMemBlocks */
|
|
/* */
|
|
/* Managed single-size block allocator. Allocates blocks */
|
|
/* of the size specified in the constructor, using the memory */
|
|
/* manager specified by Alloc. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
template <class Alloc> class TMMemBlocks
|
|
{
|
|
|
|
public:
|
|
|
|
TMMemBlocks( size_t, unsigned = 100 );
|
|
|
|
void *Allocate( size_t );
|
|
void Free( void * );
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
void *allocate( size_t sz ) { return Allocate(sz); }
|
|
void free( void *ptr ) { Free(ptr); }
|
|
#endif // BI_OLDNAMES
|
|
|
|
private:
|
|
|
|
void *FreeList;
|
|
TMMemStack<Alloc> Mem;
|
|
size_t Size;
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MMemBlocks TMemBlocks
|
|
#endif
|
|
|
|
template <class Alloc>
|
|
inline TMMemBlocks<Alloc>::TMMemBlocks( size_t sz, unsigned count ) :
|
|
Mem( sz*count ),
|
|
FreeList(0),
|
|
Size( max(sz,sizeof(void *)) )
|
|
{
|
|
CHECK( sz != 0 && count != 0 );
|
|
}
|
|
|
|
#pragma argsused
|
|
template <class Alloc>
|
|
inline void *TMMemBlocks<Alloc>::Allocate( size_t sz )
|
|
{
|
|
PRECONDITION( Size == max(sz,sizeof(void *)) );
|
|
if( FreeList == 0 )
|
|
return Mem.Allocate( Size );
|
|
else
|
|
{
|
|
void *temp = FreeList;
|
|
FreeList = *(void **)temp;
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
template <class Alloc>
|
|
inline void TMMemBlocks<Alloc>::Free( void *block )
|
|
{
|
|
*(void **)block = FreeList;
|
|
FreeList = block;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
/* */
|
|
/* class TMemBlocks */
|
|
/* */
|
|
/* Single-size block allocator. Allocates blocks of the size */
|
|
/* specified in the constructor, using the global operator new */
|
|
/* and operator delete. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
class TMemBlocks : public TMMemBlocks<TStandardAllocator>
|
|
{
|
|
|
|
public:
|
|
|
|
TMemBlocks( size_t sz, unsigned n = 100 ) :
|
|
TMMemBlocks<TStandardAllocator>( sz, n ) {}
|
|
|
|
};
|
|
|
|
#if defined( BI_OLDNAMES )
|
|
#define MemBlocks TMemBlocks
|
|
#endif
|
|
|
|
typedef TMMemBlocks<TStandardAllocator> TStandardBlocks;
|
|
|
|
#if defined( BI_PLAT_WIN16 ) && defined( BI_DATA_FAR )
|
|
typedef TMMemBlocks<TSharedAllocator> TSharedBlocks;
|
|
#endif
|
|
|
|
#if defined( BI_CLASSLIB_NO_po )
|
|
#pragma option -po.
|
|
#endif
|
|
|
|
#pragma option -Vo.
|
|
|
|
#endif // CLASSLIB_MEMMGR_H
|
|
|