string
LDemonstrator::Print_Tex_str(void){
string result="";
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end();++it)
result+=(*it)->Print_Tex_str()+" \\\\ ";
return result;
}
bool
LDemonstrator::IsAccurate(vector<Inequation*>* precedence, vector<string>* param){
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it)
if((*it)->IsAccurate(precedence,param))
return true;
return false;
}
LDemonstrator*
LDemonstrator::Clone(){
LDemonstrator* result=new LDemonstrator();
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it)
result->PUSHBACK((*it)->GetKnowledge());
return result;
}
string
LDemonstrator::Print_str(void){
string result;
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it)
result+="\n"+(*it)->Print_str();
return result+"\n";
}
vector<LogicalClause*>
LDemonstrator::RecoverUnified(){
vector<LogicalClause*> result;
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it)
if((*it)->WereUnified())
result.push_back((*it)->GetUnified());
return result;
}
string
LDemonstrator::Full_Tex_Print_str(vector<string>* param){
string result="";
AttachedClauses* att;
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end();++it)
result+=(*it)->Full_Tex_Print_str(param)+" \\\\ ";
return result;
}
AttachedClauses*
LDemonstrator::GetHeader(void){
if(GetStack()->size() > 0){
AttachedClauses* result;
result=*GetStack()->begin();
return result;
}
return NULL;
}
void Tile::UpdTemps()
{
if (GetStack())
{
GetStack()->SetTemp(temp);
if (GetStack()->BrakeAll())
StackAndPack();
}
}
AttachedClauses*
LDemonstrator::POP(void){
if(GetStack()->size() >0){
AttachedClauses* result;
result=*GetStack()->begin();
GetStack()->erase(GetStack()->begin());
return result;
}
return NULL;
}
/// \brief register reference from view to stack
/// \param size - size of UNDOVIEWTOSTACK structure
/// \param param - pointer to UNDOVIEWTOSTACK structure
DWORD CUndoRedoComponent::OnUndoRegisterViewStack(DWORD size, void *param)
{
UNDOVIEWTOSTACK *pViewToStack = reinterpret_cast<UNDOVIEWTOSTACK *>(param);
VERIFY_MESSAGE_SIZE(size, sizeof(*pViewToStack));
if (pViewToStack->pStackView == NULL)
{
ASSERT(!"NULL pointer to CView was passsed");
return MSG_ERROR;
}
if (pViewToStack->pStackName == NULL)
{
ASSERT(!"NULL pointer to stack name was passsed");
return MSG_ERROR;
}
CUndoStack *pStack = GetStack(pViewToStack->pStackName);
if (pStack == NULL)
{
ASSERT(!"Unknown stack name was passsed");
return MSG_ERROR;
}
View2StackMap::iterator it = m_View2Stack.find(pViewToStack->pStackView);
if (it != m_View2Stack.end())
{
ASSERT(!"View already registered");
return MSG_ERROR;
}
m_View2Stack.insert(make_pair(pViewToStack->pStackView, pStack));
return MSG_HANDLED;
}
/// \brief clear undo stack. This is useful for operations that cannot be undone
/// \param size - unused
/// \param param - unused
DWORD CUndoRedoComponent::OnUndoClearStack(DWORD size, void *param)
{
ASSERT(m_pCurrentCommandData == NULL);
UNDOSTACKINFO *pInfo = reinterpret_cast<UNDOSTACKINFO *>(param);
VERIFY_MESSAGE_SIZE(size, sizeof(*pInfo));
if (NULL != pInfo->pStackName)
{
StackList::iterator itStack = FindStack(pInfo->pStackName);
if (itStack == m_Stacks.end())
{
m_pToolBox->Log(LOGERROR, _T("%s(%i): Can't find undo stack '%s' for clearing .\n"), __FILE__, __LINE__, pInfo->pStackName->GetString());
return MSG_ERROR;
}
(*itStack)->ClearStack();
}
else
{
CUndoStack *pStack = GetStack();
if (pStack == NULL)
{
return MSG_ERROR;
}
pStack->ClearStack();
}
return MSG_HANDLED;
}
/// \brief end collecting data for undo command and place it into undo stack
/// \param size - unused
/// \param param - unused
DWORD CUndoRedoComponent::OnUndoEndCommand(DWORD size, void *param)
{
if (m_pCurrentCommandData == NULL)
{
// this error means that command end may occur early then it expects
ASSERT(!"Undo command was ended");
m_pToolBox->Log(LOGERROR, _T("Undo command was ended\n"));
return MSG_ERROR;
}
// check if this is valid command
if (m_pCurrentCommandData->HasUndoActions())
{
CUndoStack *pStack = GetStack();
if (pStack == NULL)
{
delete m_pCurrentCommandData;
m_pCurrentCommandData = NULL;
return MSG_ERROR;
}
m_pCurrentCommandData->CompactData();
pStack->AddUndo(m_pCurrentCommandData);
}
else
{
delete m_pCurrentCommandData;
}
m_pCurrentCommandData = NULL;
return MSG_HANDLED;
}
boolean isStackEmpty(Stack S){
struct LinkedListStack *s = GetStack(S);
if(s==NULL){
return true;
}
return (s->top==NULL) ? true: false;
}
void push(Stack S , int n){
struct LinkedListStack *s = GetStack(S);
if(isStackFull(s)){
fprintf(stderr, "Stack Overflow! Cannot Push a thing right now\n");
return;
}
insert(&s->top,n);
}
void
LDemonstrator::EliminateDoubles(void){
list<AttachedClauses*> __stack;
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it){
bool found=false;
for(list<AttachedClauses*>::iterator it2=__stack.begin(); it2 != __stack.end(); ++it2){
if((*it)->Print_str() == (*it2)->Print_str()){
found=true;
break;
}
}
if(!found)
__stack.push_back(*it);
}
SetStack(&__stack);
}
int top(Stack S){
struct LinkedListStack *s = GetStack(S);
if(isStackEmpty(s)){
printf("Nothing on the top!\n");
return -1;
}
return s->top->data;
}
/// \brief get pointer to stack by active scene or current view
/// \return pointer to active stack or NULL otherwise
CUndoStack *CUndoRedoComponent::GetStack()
{
CHashString hszScene = GetActiveScene();
if (hszScene.IsEmpty())
{
CView* pActiveView = NULL;
static DWORD msgHash_GetActiveView = CHashString(_T("GetActiveView")).GetUniqueID();
if (MSG_HANDLED != m_pToolBox->SendMessage(msgHash_GetActiveView, sizeof(pActiveView), &pActiveView) &&
pActiveView == NULL)
{
m_pToolBox->Log(LOGERROR, _T("%s(%i): GetActiveView failed\n"), __FILE__, __LINE__);
return NULL;
}
return GetStack(pActiveView);
}
return GetStack(&hszScene);
}
SdfCleanupEnabler::~SdfCleanupEnabler()
{
if (GetStack().size() == 1) {
// The last CleanupEnabler is being removed from the stack, so notify
// the CleanupTracker that it's time to clean up any specs it collected.
Sdf_CleanupTracker::GetInstance().CleanupSpecs();
}
}
LDemonstrator*
LDemonstrator::RemoveDoubles(){
list<AttachedClauses*> result;
for(list<AttachedClauses*>::iterator it=GetStack()->begin(); it != GetStack()->end(); ++it){
bool insert=true;
string ch=(*it)->Print_str();
for(list<AttachedClauses*>::iterator it2=result.begin(); it2 != result.end(); ++it2)
if(ch == (*it2)->Print_str()){
insert=false;
break;
}
if(insert)
result.push_back(*it);
}
LDemonstrator* res =new LDemonstrator();
res->SetStack(&result);
return res;
}
rbToken* rbBytecode::GetLastToken()
{
rbToken* t = GetStack();
if( t && !t->empty() )
{
return t->back();
}
return t;
}
void Tile::SaveStack(TCODZip &file)
{
if (GetStack())
{
file.putChar(1);
stack->Save(file);
}
else
file.putChar(0);
}
void interrupt far PAS_ServiceInterrupt
(
void
)
{
#ifdef USESTACK
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
#endif
irqstatus = PAS_Read( InterruptStatus );
if ( ( irqstatus & SampleBufferInterruptFlag ) == 0 )
{
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
_chain_intr( PAS_OldInt );
}
// Clear the interrupt
irqstatus &= ~SampleBufferInterruptFlag;
PAS_Write( InterruptStatus, irqstatus );
// send EOI to Interrupt Controller
if ( PAS_Irq > 7 )
{
outp( 0xA0, 0x20 );
}
outp( 0x20, 0x20 );
// Keep track of current buffer
PAS_CurrentDMABuffer += PAS_TransferLength;
if ( PAS_CurrentDMABuffer >= PAS_DMABufferEnd )
{
PAS_CurrentDMABuffer = PAS_DMABuffer;
}
// Call the caller's callback function
if ( PAS_CallBack != NULL )
{
PAS_CallBack();
}
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
}
static void __interrupt __far TS_ServiceSchedule
(
void
)
{
task *ptr;
task *next;
TS_InInterrupt = TRUE;
#ifdef USESTACK
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
#endif
ptr = TaskList->next;
while( ptr != TaskList )
{
next = ptr->next;
if ( ptr->active )
{
ptr->count += TaskServiceRate;
//JIM
// if ( ptr->count >= ptr->rate )
while( ptr->count >= ptr->rate )
{
ptr->count -= ptr->rate;
ptr->TaskService( ptr );
}
}
ptr = next;
}
#ifdef USESTACK
// restore stack
SetStack( oldStackSelector, oldStackPointer );
#endif
TaskServiceCount += TaskServiceRate;
if ( TaskServiceCount > 0xffffL )
{
TaskServiceCount &= 0xffff;
_chain_intr( OldInt8 );
}
outp( 0x20,0x20 );
TS_InInterrupt = FALSE;
}
int pop(Stack S){
struct LinkedListStack *s = GetStack(S);
if(isStackEmpty(s)){
fprintf(stderr, "Stack underflow! Cannot Pop\n");
return -1;
}
int n = s->top->data;
struct Node *temp = s->top->next;
free(s->top);
s->top=temp;
return n;
}
int size(Stack S){
struct LinkedListStack *s = GetStack(S);
if(s!=NULL){
struct Node *temp = s->top;
int count=0;
while(temp!=NULL){
temp = temp->next;
++count;
}
return count;
}
return 0;
}
void printStack(Stack S){
struct LinkedListStack *s = GetStack(S);
if(isStackEmpty(s)){
printf("Stack is empty nothing to print\n" );
return;
}
int i;
struct Node *temp = s->top;
while(temp!=NULL){
printf("%d\n",temp->data);
temp = temp->next;
}
}
void
ThreadStackHelper::GetNativeStack(Stack& aStack)
{
#ifdef MOZ_THREADSTACKHELPER_NATIVE
ThreadContext context;
context.mStack = MakeUnique<uint8_t[]>(ThreadContext::kMaxStackSize);
ScopedSetPtr<ThreadContext> contextPtr(mContextToFill, &context);
// Get pseudostack first and fill the thread context.
GetStack(aStack);
NS_ENSURE_TRUE_VOID(context.mValid);
// TODO: walk the saved stack frames.
#endif // MOZ_THREADSTACKHELPER_NATIVE
}
/// \brief redo last rolled back command
void CUndoRedoComponent::OnRedo()
{
CUndoStack *pStack = GetStack();
if (pStack != NULL && pStack->CanRedo())
{
CWinApp* pApp = AfxGetApp();
pApp->BeginWaitCursor();
m_bIsExecuting = true;
pStack->Redo();
m_bIsExecuting = false;
// send out a message that the scene is modified according to save point value in the stack
static DWORD msgHash_WorldModified = CHashString(_T("WorldModified")).GetUniqueID();
m_pToolBox->SendMessage(msgHash_WorldModified, sizeof(BOOL), (void *)!pStack->IsSavePoint());
pApp->EndWaitCursor();
}
}
static void __interrupt __far SOUNDSCAPE_ServiceInterrupt
(
void
)
{
// save stack
GetStack( &oldStackSelector, &oldStackPointer );
// set our stack
SetStack( StackSelector, StackPointer );
if ( !( inp( SOUNDSCAPE_Config.WavePort + AD_STATUS ) & 0x01 ) )
{
// restore stack
SetStack( oldStackSelector, oldStackPointer );
// Wasn't our interrupt. Call the old one.
_chain_intr( SOUNDSCAPE_OldInt );
}
// clear the AD-1848 interrupt
outp( SOUNDSCAPE_Config.WavePort + AD_STATUS, 0x00 );
// Keep track of current buffer
SOUNDSCAPE_CurrentDMABuffer += SOUNDSCAPE_TransferLength;
if ( SOUNDSCAPE_CurrentDMABuffer >= SOUNDSCAPE_DMABufferEnd )
{
SOUNDSCAPE_CurrentDMABuffer = SOUNDSCAPE_DMABuffer;
}
// Call the caller's callback function
if ( SOUNDSCAPE_CallBack != NULL )
{
SOUNDSCAPE_CallBack();
}
// restore stack
SetStack( oldStackSelector, oldStackPointer );
// send EOI to Interrupt Controller
if ( SOUNDSCAPE_Config.WaveIRQ > 7 )
{
outp( 0xA0, 0x20 );
}
outp( 0x20, 0x20 );
}
LDemonstrator*
LDemonstrator::POPAffines(void){
LDemonstrator* result=new LDemonstrator();
int nb_repeats=GetStack()->size();
for(int i=0; i<nb_repeats;++i) {
AttachedClauses* current=POP();
if(current->GetKnowledge()->GetNonAffineInequations()->size() ==0){
result->PUSHBACK(current->GetKnowledge());
}
else {
PUSHBACK(current->GetKnowledge());
}
}
return result;
}
