globle long int EnvReleaseMem(
void *theEnv,
long int maximum)
{
struct memoryPtr *tmpPtr, *memPtr;
int i;
long int returns = 0;
long int amount = 0;
for (i = (MEM_TABLE_SIZE - 1) ; i >= (int) sizeof(char *) ; i--)
{
YieldTime(theEnv);
memPtr = MemoryData(theEnv)->MemoryTable[i];
while (memPtr != NULL)
{
tmpPtr = memPtr->next;
genfree(theEnv,(void *) memPtr,(unsigned) i);
memPtr = tmpPtr;
amount += i;
returns++;
if ((returns % 100) == 0)
{ YieldTime(theEnv); }
}
MemoryData(theEnv)->MemoryTable[i] = NULL;
if ((amount > maximum) && (maximum > 0))
{ return(amount); }
}
return(amount);
}
void dThread::Lock(unsigned& lockVar)
{
_ASSERTE (sizeof (unsigned) == sizeof (long));
while (dInterlockedExchange((int*) &lockVar, 1)) {
YieldTime();
}
}
void dThread::TerminateTask ()
{
dInterlockedExchange((int*) &m_terminated, 1);
while (m_taskExecuting) {
YieldTime();
}
}
void dThread::StopsExecution ()
{
dInterlockedIncrement((int*) &m_taskSuspendedCount);
_ASSERTE (!(m_taskSuspendedCount & 0x80000000));
while (m_taskExecuting) {
YieldTime();
}
}
void dThread::ExcuteTask()
{
while (!m_terminated) {
if (m_taskSuspendedCount) {
dInterlockedExchange((int*) &m_taskExecuting, 0);
//WaitForSingleObject(m_controlKey, INFINITE);
while (m_taskSuspendedCount) {
if (m_terminated) {
break;
}
YieldTime();
}
}
dInterlockedExchange((int*) &m_taskExecuting, 1);
RunMyTask ();
YieldTime();
}
dInterlockedExchange((int*) &m_taskExecuting, 0);
}
globle long int EnvReleaseMem(
void *theEnv,
long int maximum,
int printMessage)
{
struct memoryPtr *tmpPtr, *memPtr;
int i;
long int returns = 0;
long int amount = 0;
if (printMessage == TRUE)
{ EnvPrintRouter(theEnv,WDIALOG,(char*)"\n*** DEALLOCATING MEMORY ***\n"); }
for (i = (MEM_TABLE_SIZE - 1) ; i >= (int) sizeof(char *) ; i--)
{
YieldTime(theEnv);
memPtr = MemoryData(theEnv)->MemoryTable[i];
while (memPtr != NULL)
{
tmpPtr = memPtr->next;
genfree(theEnv,(void *) memPtr,(unsigned) i);
memPtr = tmpPtr;
amount += i;
returns++;
if ((returns % 100) == 0)
{ YieldTime(theEnv); }
}
MemoryData(theEnv)->MemoryTable[i] = NULL;
if ((amount > maximum) && (maximum > 0))
{
if (printMessage == TRUE)
{ EnvPrintRouter(theEnv,WDIALOG,(char*)"*** MEMORY DEALLOCATED ***\n"); }
return(amount);
}
}
if (printMessage == TRUE)
{ EnvPrintRouter(theEnv,WDIALOG,(char*)"*** MEMORY DEALLOCATED ***\n"); }
return(amount);
}
globle int LoadConstructsFromLogicalName(
void *theEnv,
char *readSource)
{
int constructFlag;
struct token theToken;
int noErrors = TRUE;
int foundConstruct;
/*=========================================*/
/* Reset the halt execution and evaluation */
/* error flags in preparation for parsing. */
/*=========================================*/
if (EvaluationData(theEnv)->CurrentEvaluationDepth == 0) SetHaltExecution(theEnv,FALSE);
SetEvaluationError(theEnv,FALSE);
/*========================================================*/
/* Find the beginning of the first construct in the file. */
/*========================================================*/
EvaluationData(theEnv)->CurrentEvaluationDepth++;
GetToken(theEnv,readSource,&theToken);
foundConstruct = FindConstructBeginning(theEnv,readSource,&theToken,FALSE,&noErrors);
/*==================================================*/
/* Parse the file until the end of file is reached. */
/*==================================================*/
while ((foundConstruct == TRUE) && (GetHaltExecution(theEnv) == FALSE))
{
/*===========================================================*/
/* Clear the pretty print buffer in preparation for parsing. */
/*===========================================================*/
FlushPPBuffer(theEnv);
/*======================*/
/* Parse the construct. */
/*======================*/
constructFlag = ParseConstruct(theEnv,ValueToString(theToken.value),readSource);
/*==============================================================*/
/* If an error occurred while parsing, then find the beginning */
/* of the next construct (but don't generate any more error */
/* messages--in effect, skip everything until another construct */
/* is found). */
/*==============================================================*/
if (constructFlag == 1)
{
EnvPrintRouter(theEnv,WERROR,"\nERROR:\n");
PrintInChunks(theEnv,WERROR,GetPPBuffer(theEnv));
EnvPrintRouter(theEnv,WERROR,"\n");
noErrors = FALSE;
GetToken(theEnv,readSource,&theToken);
foundConstruct = FindConstructBeginning(theEnv,readSource,&theToken,TRUE,&noErrors);
}
/*======================================================*/
/* Otherwise, find the beginning of the next construct. */
/*======================================================*/
else
{
GetToken(theEnv,readSource,&theToken);
foundConstruct = FindConstructBeginning(theEnv,readSource,&theToken,FALSE,&noErrors);
}
/*=====================================================*/
/* Yield time if necessary to foreground applications. */
/*=====================================================*/
if (foundConstruct)
{ IncrementSymbolCount(theToken.value); }
EvaluationData(theEnv)->CurrentEvaluationDepth--;
PeriodicCleanup(theEnv,FALSE,TRUE);
YieldTime(theEnv);
EvaluationData(theEnv)->CurrentEvaluationDepth++;
if (foundConstruct)
{ DecrementSymbolCount(theEnv,(SYMBOL_HN *) theToken.value); }
}
EvaluationData(theEnv)->CurrentEvaluationDepth--;
/*========================================================*/
/* Print a carriage return if a single character is being */
/* printed to indicate constructs are being processed. */
/*========================================================*/
#if DEBUGGING_FUNCTIONS
if ((EnvGetWatchItem(theEnv,"compilations") != TRUE) && GetPrintWhileLoading(theEnv))
#else
if (GetPrintWhileLoading(theEnv))
#endif
{ EnvPrintRouter(theEnv,WDIALOG,"\n"); }
/*=============================================================*/
/* Once the load is complete, destroy the pretty print buffer. */
/* This frees up any memory that was used to create the pretty */
/* print forms for constructs during parsing. Thus calls to */
/* the mem-used function will accurately reflect the amount of */
/* memory being used after a load command. */
/*=============================================================*/
DestroyPPBuffer(theEnv);
/*==========================================================*/
/* Return a boolean flag which indicates whether any errors */
/* were encountered while loading the constructs. */
/*==========================================================*/
return(noErrors);
}
