int _LibMain( int hdll, int reason, void *reserved )
{
thread_data *tdata;
int rc = 0;
switch( reason ) {
case DLL_THREAD_ATTACH:
tdata = ( thread_data * )RdosAllocateMem( __ThreadDataSize );
if( tdata ) {
memset( tdata, 0, __ThreadDataSize );
tdata->__data_size = __ThreadDataSize;
__RdosAddThread( tdata );
}
break;
case DLL_PROCESS_ATTACH:
__InitRtns( INIT_PRIORITY_THREAD );
tdata = ( thread_data * )RdosAllocateMem( __ThreadDataSize );
memset( tdata, 0, __ThreadDataSize );
tdata->__data_size = __ThreadDataSize;
__InitThreadData( tdata );
__RdosInit( 1, tdata, hdll );
__InitRtns( 255 );
__CommonInit();
__sig_init_rtn();
if( !__RdosThreadInit() ) return( -1 );
__InitMultipleThread();
rc = LibMain( hdll, reason, reserved );
if( !rc ) {
__FiniRtns( 0, 255 );
}
break;
case DLL_THREAD_DETACH:
__RdosRemoveThread();
break;
case DLL_PROCESS_DETACH:
__FiniRtns( 0, FINI_PRIORITY_EXIT - 1 );
__RdosRemoveThread();
RdosFreeMem( __FirstThreadData );
__FirstThreadData = NULL;
break;
}
return( rc );
}
_WCRTLINK void_nptr sbrk( int increment )
{
void *cstg;
if( increment > 0 ) {
increment = __ROUND_UP_SIZE_4K( increment );
cstg = RdosAllocateMem( increment );
if( cstg != NULL ) {
return( cstg );
}
}
return( (void_nptr)-1 );
}
static void begin_thread_helper( void *param )
/********************************************************/
{
thread_args *td = (thread_args *)param;
thread_fn *rtn;
void *arg;
thread_data *tdata;
int thread_handle;
REGISTRATION_RECORD rr;
td->tid = RdosGetThreadHandle();
rtn = td->rtn;
arg = td->argument;
thread_handle = td->thread_handle;
RdosSetSignal( td->signal );
tdata = (thread_data *)RdosAllocateMem( __ThreadDataSize );
if( tdata != NULL ) {
memset( tdata, 0, __ThreadDataSize );
tdata->__data_size = __ThreadDataSize;
if( !__RdosAddThread( tdata ) ) {
// print runtime error message now ?
return;
}
}
// now get the thread_data ptr the 'standard' way -- this may cause
// a new thread_data structure to be allocated on heap:
tdata = __THREADDATAPTR;
if( tdata == NULL ) {
// this is a library runtime error, should we print an error message ?
return;
}
__NewExceptionFilter( &rr );
__sig_init_rtn(); // fills in a thread-specific copy of signal table
(*rtn)( arg );
_endthread();
RdosFreeMem(tdata);
return;
}
static int __CreateNewNHeap( unsigned amount )
{
mheapptr p1;
frlptr flp;
unsigned brk_value;
#if defined(__WARP__)
ULONG os2_alloc_flags;
#endif
if( !__heap_enabled )
return( 0 );
if( _curbrk == ~1u )
return( 0 );
if( __AdjustAmount( &amount ) == 0 )
return( 0 );
#if defined(__WINDOWS_286__)
brk_value = (unsigned)LocalAlloc( LMEM_FIXED, amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__WINDOWS_386__)
brk_value = (unsigned)DPMIAlloc( amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__WARP__)
{
PBYTE p;
APIRET apiret;
os2_alloc_flags = PAG_COMMIT | PAG_READ | PAG_WRITE;
if( _os2_obj_any_supported && _os2_use_obj_any ) {
os2_alloc_flags |= OBJ_ANY;
}
apiret = DosAllocMem( (PPVOID)&p, amount, os2_alloc_flags );
if( apiret )
return( 0 );
brk_value = (unsigned)p;
}
#elif defined(__NT__)
brk_value = (unsigned)VirtualAlloc( NULL, amount, MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
//brk_value = (unsigned) LocalAlloc( LMEM_FIXED, amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__CALL21__)
{
tag _WCNEAR *tmp_tag;
tmp_tag = (tag _WCNEAR *)TinyMemAlloc( amount );
if( tmp_tag == NULL ) {
return( 0 );
}
/* make sure it will not look like the end of a heap */
tmp_tag[0] = ! END_TAG;
brk_value = (unsigned)&tmp_tag[2];
amount -= 2 * TAG_SIZE; // 11-jun-95, subtract extra tag
}
#elif defined(__DOS_EXT__)
// if( !__IsCtsNHeap() ) {
{
tag *tmp_tag;
if( _IsRational() ) {
tmp_tag = RationalAlloc( amount );
if( tmp_tag ) {
amount = *tmp_tag;
}
} else { /* CodeBuilder */
tmp_tag = TinyCBAlloc( amount );
amount -= TAG_SIZE;
}
if( tmp_tag == NULL ) {
return( 0 );
}
brk_value = (unsigned)tmp_tag;
}
// Pharlap, RSI/non-zero can never call this function
#elif defined(__RDOS__)
brk_value = (unsigned)RdosAllocateMem( amount );
if( brk_value == 0 ) {
return( 0 );
}
#endif
if( amount - TAG_SIZE > amount ) {
return( 0 );
} else {
amount -= TAG_SIZE;
}
if( amount < sizeof( miniheapblkp ) + sizeof( frl ) ) {
/* there isn't enough for a heap block (struct miniheapblkp) and
one free block (frl) */
return( 0 );
}
/* we've got a new heap block */
p1 = (mheapptr)brk_value;
p1->len = amount;
#if defined(__WARP__)
// Remeber if block was allocated with OBJ_ANY - may be in high memory
p1->used_obj_any = ( _os2_obj_any_supported && _os2_use_obj_any );
#endif
// Now link it up
flp = __LinkUpNewMHeap( p1 );
amount = flp->len;
/* build a block for _nfree() */
SET_MEMBLK_SIZE_USED( flp, amount );
++p1->numalloc;
p1->largest_blk = 0;
_nfree( (PTR)flp + TAG_SIZE );
return( 1 );
}
static int __AdjustAmount( unsigned *amount )
{
unsigned old_amount = *amount;
unsigned amt;
#if ! ( defined(__WINDOWS_286__) || \
defined(__WINDOWS_386__) || \
defined(__WARP__) || \
defined(__NT__) \
)
unsigned last_free_amt;
#endif
amt = old_amount;
amt = ( amt + TAG_SIZE + ROUND_SIZE) & ~ROUND_SIZE;
if( amt < old_amount ) {
return( 0 );
}
#if ! ( defined(__WINDOWS_286__) || \
defined(__WINDOWS_386__) || \
defined(__WARP__) || \
defined(__NT__) \
)
#if defined(__DOS_EXT__)
if( _IsRationalZeroBase() || _IsCodeBuilder() ) {
// Allocating extra to identify the dpmi block
amt += sizeof(struct dpmi_hdr);
} else {
#else
{
#endif
last_free_amt = __LastFree(); /* adjust for last free block */
if( last_free_amt >= amt ) {
amt = 0;
} else {
amt -= last_free_amt;
}
}
#endif
/* amount is even here */
/*
extra amounts (22-feb-91 AFS)
(1) adding a new heap needs:
frl free block req'd for _nmalloc request
(frl is the MINIMUM because the block
may be freed)
tag end of miniheap descriptor
struct miniheapblkp start of miniheap descriptor
(2) extending heap needs:
tag free block req'd for _nmalloc request
*/
*amount = amt;
amt += ( (TAG_SIZE) + sizeof(frl) + sizeof(struct miniheapblkp) );
if( amt < *amount ) return( 0 );
if( amt < _amblksiz ) {
/*
_amblksiz may not be even so round down to an even number
nb. pathological case: where _amblksiz == 0xffff, we don't
want the usual round up to even
*/
amt = _amblksiz & ~1u;
}
#if defined(__WINDOWS_386__) || \
defined(__WARP__) || \
defined(__NT__) || \
defined(__CALL21__) || \
defined(__DOS_EXT__) || \
defined(__RDOS__)
/* make sure amount is a multiple of 4k */
*amount = amt;
amt += 0x0fff;
if( amt < *amount ) return( 0 );
amt &= ~0x0fff;
#endif
*amount = amt;
return( *amount != 0 );
}
#if defined(__WINDOWS_286__) || \
defined(__WINDOWS_386__) || \
defined(__WARP__) || \
defined(__NT__) || \
defined(__CALL21__) || \
defined(__DOS_EXT__) || \
defined(__RDOS__)
static int __CreateNewNHeap( unsigned amount )
{
mheapptr p1;
frlptr flp;
unsigned brk_value;
if( !__heap_enabled ) return( 0 );
if( _curbrk == ~1u ) return( 0 );
if( __AdjustAmount( &amount ) == 0 ) return( 0 );
#if defined(__WINDOWS_286__)
brk_value = (unsigned) LocalAlloc( LMEM_FIXED, amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__WINDOWS_386__)
brk_value = (unsigned) DPMIAlloc( amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__WARP__)
{
PBYTE p;
if( DosAllocMem( (PPVOID)&p, amount, PAG_COMMIT|PAG_READ|PAG_WRITE ) ) {
return( 0 );
}
brk_value = (unsigned)p;
}
#elif defined(__NT__)
brk_value = (unsigned) VirtualAlloc( NULL, amount, MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
//brk_value = (unsigned) LocalAlloc( LMEM_FIXED, amount );
if( brk_value == 0 ) {
return( 0 );
}
#elif defined(__CALL21__)
{
tag _WCNEAR *tmp_tag;
tmp_tag = (tag _WCNEAR *)TinyMemAlloc( amount );
if( tmp_tag == NULL ) {
return( 0 );
}
/* make sure it will not look like the end of a heap */
tmp_tag[0] = ! END_TAG;
brk_value = (unsigned) &tmp_tag[2];
amount -= 2 * TAG_SIZE; // 11-jun-95, subtract extra tag
}
#elif defined(__DOS_EXT__)
// if( _IsRationalZeroBase() || _IsCodeBuilder() ) {
{
tag *tmp_tag;
if( _IsRational() ) {
tmp_tag = RationalAlloc( amount );
if( tmp_tag ) amount = *tmp_tag;
} else { /* CodeBuilder */
tmp_tag = TinyCBAlloc( amount );
amount -= TAG_SIZE;
}
if( tmp_tag == NULL ) {
return( 0 );
}
brk_value = (unsigned) tmp_tag;
}
// Pharlap, RSI/non-zero can never call this function
#elif defined(__RDOS__)
brk_value = (unsigned) RdosAllocateMem( amount );
if( brk_value == 0 ) {
return( 0 );
}
#endif
if( amount - TAG_SIZE > amount ) {
return( 0 );
} else {
amount -= TAG_SIZE;
}
if( amount < sizeof( struct miniheapblkp ) + sizeof( frl ) ) {
/* there isn't enough for a heap block (struct miniheapblkp) and
one free block (frl) */
return( 0 );
}
/* we've got a new heap block */
p1 = (mheapptr) brk_value;
p1->len = amount;
// Now link it up
flp = __LinkUpNewMHeap( p1 );
amount = flp->len;
/* build a block for _nfree() */
flp->len = amount | 1;
++p1->numalloc; /* 28-dec-90 */
p1->largest_blk = 0;
_nfree( (PTR)flp + TAG_SIZE );
return( 1 );
}
void *sbrk (int incr)
{
return RdosAllocateMem(incr);
}
