void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain) { if ( !bMain ) return; CBotStack* pile1 = pj->RestoreStack(this); // adds an item to the stack if ( pile1 == nullptr ) return; CBotInstr* p = m_Block; // first expression int state = pile1->GetState(); if (state == 0) { m_Value->RestoreState(pile1, bMain); return; } if ( state == -1 ) { return; } // p = m_Block; // returns to the beginning while ( p != nullptr && state-- > 0 ) { p->RestoreState(pile1, false); p = p->GetNext(); // advance in the list } if( p != nullptr ) { p->RestoreState(pile1, true); return; } }
void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain) { CBotStack* pile = pj; int state = 0x7000; if ( bMain ) { pile = pj->RestoreStack(); if ( pile == nullptr ) return; state = pile->GetState(); } CBotInstr* p = m_Expr; // the first expression while (p != nullptr && state-->0) { p->RestoreState(pile, false); p = p->GetNext(); // returns to the interrupted operation } if ( p != nullptr ) { p->RestoreState(pile, bMain); } }
void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain) { if ( !bMain ) return; CBotStack* pile = pj->RestoreStack(this); if ( pile == NULL ) return; // CBotStack* pile1 = pile; int i = 0; CBotVar* ppVars[1000]; CBotInstr* p = m_Parameters; // evaluate parameters // and place the values on the stack // for allow of interruption at any time if ( p != NULL) while ( true ) { pile = pile->RestoreStack(); // place on the stack for the results if ( pile == NULL ) return; if ( pile->GetState() == 0 ) { p->RestoreState(pile, bMain); // interrupt here! return; } ppVars[i++] = pile->GetVar(); // constructs the list of parameters p = p->GetNext(); if ( p == NULL) break; } ppVars[i] = NULL; CBotStack* pile2 = pile->RestoreStack(); if ( pile2 == NULL ) return; pile2->RestoreCall(m_nFuncIdent, GetToken(), ppVars); }
bool CBotInstrCall::Execute(CBotStack* &pj) { CBotVar* ppVars[1000]; CBotStack* pile = pj->AddStack(this); if ( pile->StackOver() ) return pj->Return( pile ); // CBotStack* pile1 = pile; int i = 0; CBotInstr* p = m_Parameters; // evaluates parameters // and places the values on the stack // for allow of interruption at any time if ( p != NULL) while ( true ) { pile = pile->AddStack(); // place on the stack for the results if ( pile->GetState() == 0 ) { if (!p->Execute(pile)) return false; // interrupted here? pile->SetState(1); // mark as special for reknowed parameters \TODO marque spéciale pour reconnaîre parameters } ppVars[i++] = pile->GetVar(); p = p->GetNext(); if ( p == NULL) break; } ppVars[i] = NULL; CBotStack* pile2 = pile->AddStack(); if ( pile2->IfStep() ) return false; if ( !pile2->ExecuteCall(m_nFuncIdent, GetToken(), ppVars, m_typRes)) return false; // interrupt return pj->Return(pile2); // release the entire stack }
bool CBotSwitch :: Execute(CBotStack* &pj) { CBotStack* pile1 = pj->AddStack(this); // adds an item to the stack // if ( pile1 == EOX ) return true; CBotInstr* p = m_Block; // first expression int state = pile1->GetState(); if (state == 0) { if ( !m_Value->Execute(pile1) ) return false; pile1->SetState(state = -1); } if ( pile1->IfStep() ) return false; if ( state == -1 ) { state = 0; int val = pile1->GetVal(); // result of the value CBotStack* pile2 = pile1->AddStack(); while ( p != nullptr ) // search for the corresponding case in a list { state++; if ( p->CompCase( pile2, val ) ) break; // found the case p = p->GetNext(); } pile2->Delete(); if ( p == nullptr ) return pj->Return(pile1); // completed if nothing if ( !pile1->SetState(state) ) return false; } p = m_Block; // returns to the beginning while (state-->0) p = p->GetNext(); // advance in the list while( p != nullptr ) { if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1); if ( !pile1->IncState() ) return false; p = p->GetNext(); } return pj->Return(pile1); }
bool CBotListExpression::Execute(CBotStack* &pj) { CBotStack* pile = pj->AddStack(); // essential CBotInstr* p = m_Expr; // the first expression int state = pile->GetState(); while (state-->0) p = p->GetNext(); // returns to the interrupted operation if ( p != nullptr ) while (true) { if ( !p->Execute(pile) ) return false; p = p->GetNext(); if ( p == nullptr ) break; if (!pile->IncState()) return false; // ready for next } return pj->Return(pile); }
bool CBotInstrCall::Execute(CBotStack* &pj) { CBotVar* ppVars[1000]; CBotStack* pile = pj->AddStack(this); if ( pile->StackOver() ) return pj->Return( pile ); CBotStack* pile3 = nullptr; if (m_exprRetVar != nullptr) // func().member { pile3 = pile->AddStack2(); if (pile3->GetState() == 1) // function call is done? { if (!m_exprRetVar->Execute(pile3)) return false; return pj->Return(pile3); } } // CBotStack* pile1 = pile; int i = 0; CBotInstr* p = m_parameters; // evaluates parameters // and places the values on the stack // for allow of interruption at any time if ( p != nullptr) while ( true ) { pile = pile->AddStack(); // place on the stack for the results if ( pile->GetState() == 0 ) { if (!p->Execute(pile)) return false; // interrupted here? pile->SetState(1); // set state to remember that parameters were executed } ppVars[i++] = pile->GetVar(); p = p->GetNext(); if ( p == nullptr) break; } ppVars[i] = nullptr; CBotStack* pile2 = pile->AddStack(); if ( pile2->IfStep() ) return false; if ( !pile2->ExecuteCall(m_nFuncIdent, GetToken(), ppVars, m_typRes)) return false; // interrupt if (m_exprRetVar != nullptr) // func().member { pile3->SetCopyVar( pile2->GetVar() ); // copy the result pile2->SetVar(nullptr); pile3->SetState(1); // set call is done return false; // go back to the top ^^^ } return pj->Return(pile2); // release the entire stack }
bool CBotListInstr::Execute(CBotStack* &pj) { CBotStack* pile = pj->AddStack(this, CBotStack::BlockVisibilityType::BLOCK); //needed for SetState() if (pile->StackOver() ) return pj->Return( pile); CBotInstr* p = m_instr; // the first expression int state = pile->GetState(); while (state-->0) p = p->GetNext(); // returns to the interrupted operation if (p != nullptr) while (true) { if (!p->Execute(pile)) return false; p = p->GetNext(); if (p == nullptr) break; (void)pile->IncState(); // ready for next } return pj->Return(pile); }
void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain) { if ( !bMain ) return; CBotStack* pile = pj->RestoreStack(this); if ( pile == nullptr ) return; if (m_exprRetVar != nullptr) // func().member { CBotStack* pile3 = pile->AddStack2(); if (pile3->GetState() == 1) // function call is done? { m_exprRetVar->RestoreState(pile3, bMain); return; } } // CBotStack* pile1 = pile; int i = 0; CBotVar* ppVars[1000]; CBotInstr* p = m_parameters; // evaluate parameters // and place the values on the stack // for allow of interruption at any time if ( p != nullptr) while ( true ) { pile = pile->RestoreStack(); // place on the stack for the results if ( pile == nullptr ) return; if ( pile->GetState() == 0 ) { p->RestoreState(pile, bMain); // interrupt here! return; } ppVars[i++] = pile->GetVar(); // constructs the list of parameters p = p->GetNext(); if ( p == nullptr) break; } ppVars[i] = nullptr; CBotStack* pile2 = pile->RestoreStack(); if ( pile2 == nullptr ) return; pile2->RestoreCall(m_nFuncIdent, GetToken(), ppVars); }
void CBotListInstr::RestoreState(CBotStack* &pj, bool bMain) { if (!bMain) return; CBotStack* pile = pj->RestoreStack(this); if (pile == nullptr) return; CBotInstr* p = m_instr; // the first expression int state = pile->GetState(); while ( p != nullptr && state-- > 0) { p->RestoreState(pile, false); p = p->GetNext(); // returns to the interrupted operation } if (p != nullptr) p->RestoreState(pile, true); }
void CBotNew::RestoreState(CBotStack* &pj, bool bMain) { if (!bMain) return; CBotStack* pile = pj->RestoreStack(this); //primary stack if (pile == nullptr) return; if (m_exprRetVar != nullptr) // new Class().method() { if (pile->GetState() == 2) { CBotStack* pile3 = pile->RestoreStack(); m_exprRetVar->RestoreState(pile3, bMain); return; } } CBotStack* pile1 = pj->AddStack2(); //secondary stack CBotToken* pt = &m_vartoken; CBotClass* pClass = CBotClass::Find(pt); // create the variable "this" pointer type to the object if ( pile->GetState()==0) { return; } CBotVar* pThis = pile1->GetVar(); // find the pointer pThis->SetUniqNum(-2); // is ther an assignment or parameters (constructor) if ( pile->GetState()==1) { // evaluates the constructor of the instance CBotVar* ppVars[1000]; CBotStack* pile2 = pile; int i = 0; CBotInstr* p = m_parameters; // evaluate the parameters // and places the values on the stack // to be interrupted at any time if (p != nullptr) while ( true) { pile2 = pile2->RestoreStack(); // space on the stack for the result if (pile2 == nullptr) return; if (pile2->GetState() == 0) { p->RestoreState(pile2, bMain); // interrupt here! return; } ppVars[i++] = pile2->GetVar(); p = p->GetNext(); if ( p == nullptr) break; } ppVars[i] = nullptr; pClass->RestoreMethode(m_nMethodeIdent, m_vartoken.GetString(), pThis, ppVars, pile2) ; // interrupt here! } }
bool CBotNew::Execute(CBotStack* &pj) { CBotStack* pile = pj->AddStack(this); //main stack if (m_exprRetVar != nullptr) // new Class().method() { if (pile->GetState() == 2) { CBotStack* pile3 = pile->AddStack(); if (!m_exprRetVar->Execute(pile3)) return false; return pj->Return(pile3); } } if (pile->IfStep()) return false; CBotStack* pile1 = pj->AddStack2(); //secondary stack CBotVar* pThis = nullptr; CBotToken* pt = &m_vartoken; CBotClass* pClass = CBotClass::Find(pt); // create the variable "this" pointer type to the stack if ( pile->GetState()==0) { // create an instance of the requested class // and initialize the pointer to that object pThis = CBotVar::Create("this", pClass); pThis->SetUniqNum(-2) ; pile1->SetVar(pThis); // place on stack1 pile->IncState(); } // fetch the this pointer if it was interrupted if ( pThis == nullptr) { pThis = pile1->GetVar(); // find the pointer } // is there an assignment or parameters (constructor) if ( pile->GetState()==1) { // evaluates the constructor of the instance CBotVar* ppVars[1000]; CBotStack* pile2 = pile; int i = 0; CBotInstr* p = m_parameters; // evaluate the parameters // and places the values on the stack // to be interrupted at any time if (p != nullptr) while ( true) { pile2 = pile2->AddStack(); // space on the stack for the result if (pile2->GetState() == 0) { if (!p->Execute(pile2)) return false; // interrupted here? pile2->SetState(1); } ppVars[i++] = pile2->GetVar(); p = p->GetNext(); if ( p == nullptr) break; } ppVars[i] = nullptr; // create a variable for the result CBotVar* pResult = nullptr; // constructos still void if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GetName(), pThis, ppVars, pResult, pile2, GetToken())) return false; // interrupt pThis->ConstructorSet(); // indicates that the constructor has been called } if (m_exprRetVar != nullptr) // new Class().method() { pile->AddStack()->Delete(); // release pile2 stack CBotStack* pile3 = pile->AddStack(); // add new stack pile3->SetCopyVar(pThis); // copy the pointer (from pile1) pile1->Delete(); // release secondary stack(pile1) pile->SetState(2); return false; // go back to the top ^^^ } return pj->Return(pile1); // passes below }
void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain) { CBotVar* pThis = NULL; CBotStack* pile = pj; if ( bMain ) pile = pj->RestoreStack(this); if ( pile == NULL ) return; // creates the variable of type pointer to the object { CBotString name = m_var->m_token.GetString(); pThis = pile->FindVar(name); pThis->SetUniqNum((static_cast<CBotLeftExprVar*>(m_var))->m_nIdent); // its attribute a unique number } CBotToken* pt = &m_token; CBotClass* pClass = CBotClass::Find(pt); bool bIntrincic = pClass->IsIntrinsic(); if ( bMain && pile->GetState()<3) { // is there an assignment or parameters (constructor) // CBotVarClass* pInstance = NULL; if ( m_expr != NULL ) { // evaluates the expression for the assignment m_expr->RestoreState(pile, bMain); return; } else if ( m_hasParams ) { // evaluates the constructor of an instance if ( !bIntrincic && pile->GetState() == 1) { return; } CBotVar* ppVars[1000]; CBotStack* pile2 = pile; int i = 0; CBotInstr* p = m_Parameters; // evaluates the parameters // and the values an the stack // for the ability to be interrupted at any time (\TODO pour pouvoir être interrompu n'importe quand) if ( p != NULL) while ( true ) { pile2 = pile2->RestoreStack(); // place on the stack for the results if ( pile2 == NULL ) return; if ( pile2->GetState() == 0 ) { p->RestoreState(pile2, bMain); // interrupted here? return; } ppVars[i++] = pile2->GetVar(); p = p->GetNext(); if ( p == NULL) break; } ppVars[i] = NULL; // creates a variable for the result // CBotVar* pResult = NULL; // constructor still void pClass->RestoreMethode(m_nMethodeIdent, pClass->GetName(), pThis, ppVars, pile2); return; } } if ( m_next2b != NULL ) m_next2b->RestoreState(pile, bMain); // other(s) definition(s) }
bool CBotClassInst::Execute(CBotStack* &pj) { CBotVar* pThis = NULL; CBotStack* pile = pj->AddStack(this);//essential for SetState() // if ( pile == EOX ) return true; CBotToken* pt = &m_token; CBotClass* pClass = CBotClass::Find(pt); bool bIntrincic = pClass->IsIntrinsic(); // creates the variable of type pointer to the object if ( pile->GetState()==0) { CBotString name = m_var->m_token.GetString(); if ( bIntrincic ) { pThis = CBotVar::Create(name, CBotTypResult( CBotTypIntrinsic, pClass )); } else { pThis = CBotVar::Create(name, CBotTypResult( CBotTypPointer, pClass )); } pThis->SetUniqNum((static_cast<CBotLeftExprVar*>(m_var))->m_nIdent); // its attribute as unique number pile->AddVar(pThis); // place on the stack pile->IncState(); } if ( pThis == NULL ) pThis = pile->FindVar((static_cast<CBotLeftExprVar*>(m_var))->m_nIdent); if ( pile->GetState()<3) { // ss there an assignment or parameters (contructor) // CBotVarClass* pInstance = NULL; if ( m_expr != NULL ) { // evaluates the expression for the assignment if (!m_expr->Execute(pile)) return false; if ( bIntrincic ) { CBotVar* pv = pile->GetVar(); if ( pv == NULL || pv->GetPointer() == NULL ) { pile->SetError(TX_NULLPT, &m_token); return pj->Return(pile); } pThis->Copy(pile->GetVar(), false); } else { CBotVarClass* pInstance; pInstance = (static_cast<CBotVarPointer*>(pile->GetVar()))->GetPointer(); // value for the assignment pThis->SetPointer(pInstance); } pThis->SetInit(true); } else if ( m_hasParams ) { // evaluates the constructor of an instance if ( !bIntrincic && pile->GetState() == 1) { CBotToken* pt = &m_token; CBotClass* pClass = CBotClass::Find(pt); // creates an instance of the requested class CBotVarClass* pInstance; pInstance = static_cast<CBotVarClass*>(CBotVar::Create("", pClass)); pThis->SetPointer(pInstance); delete pInstance; pile->IncState(); } CBotVar* ppVars[1000]; CBotStack* pile2 = pile; int i = 0; CBotInstr* p = m_Parameters; // evaluates the parameters // and places the values on the stack // to (can) be interrupted (broken) at any time if ( p != NULL) while ( true ) { pile2 = pile2->AddStack(); // place on the stack for the results if ( pile2->GetState() == 0 ) { if (!p->Execute(pile2)) return false; // interrupted here? pile2->SetState(1); } ppVars[i++] = pile2->GetVar(); p = p->GetNext(); if ( p == NULL) break; } ppVars[i] = NULL; // creates a variable for the result CBotVar* pResult = NULL; // constructor still void if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GetName(), pThis, ppVars, pResult, pile2, GetToken())) return false; // interrupt pThis->SetInit(true); pThis->ConstructorSet(); // indicates that the constructor has been called pile->Return(pile2); // releases a piece of stack // pInstance = pThis->GetPointer(); } // if ( !bIntrincic ) pThis->SetPointer(pInstance); // a pointer to the instance pile->SetState(3); // finished this part } if ( pile->IfStep() ) return false; if ( m_next2b != NULL && !m_next2b->Execute(pile)) return false; // other (s) definition (s) return pj->Return( pile ); // transmits below (further) }