bool KviKvsTreeNodeSpecialCommandUnset::execute(KviKvsRunTimeContext * c) { for(KviKvsTreeNodeVariable * pVar = m_pVariableList->first(); pVar; pVar = m_pVariableList->next()) { KviKvsRWEvaluationResult * r = pVar->evaluateReadWrite(c); if(!r) return false; r->result()->setNothing(); delete r; // this will remove the data from its container } return true; }
KviKvsRWEvaluationResult * KviKvsTreeNodeHashElement::evaluateReadWriteInObjectScope(KviKvsObject *o,KviKvsRunTimeContext * c) { KviKvsVariant key; if(!m_pKey->evaluateReadOnly(c,&key))return 0; QString szKey; key.asString(szKey); if(szKey.isEmpty()) { c->warning(this,__tr2qs_ctx("Hash key evaluated to empty string: fix the script","kvs")); } KviKvsRWEvaluationResult * result; if(o)result = m_pSource->evaluateReadWriteInObjectScope(o,c); else result = m_pSource->evaluateReadWrite(c); if(!result)return 0; if(!result->result()->isHash()) { // convert to hash in some way //#warning "Supply a *real* conversion from other types to array ?" if(!result->result()->isNothing()) { QString szType; result->result()->getTypeName(szType); c->warning(this,__tr2qs_ctx("The argument of the {} subscript didn't evaluate to a hash: automatic conversion from %Q supplied","kvs"),&szType); } result->result()->setHash(new KviKvsHash()); } return new KviKvsHashElement(result,result->result()->hash()->get(szKey),result->result()->hash(),szKey); }
bool KviKvsTreeNodeSpecialCommandForeach::execute(KviKvsRunTimeContext * c) { KviKvsVariantList l; l.setAutoDelete(true); if(!m_pIterationData->evaluate(c,&l)) return false; KviKvsSwitchList swl; if(m_pSwitches) { if(!(m_pSwitches->evaluate(c,&swl))) return false; } bool bIncludeEmptyScalars = swl.find('a',"all") != 0; for(KviKvsVariant * pArg = l.first(); pArg; pArg = l.next()) { switch(pArg->type()) { case KviKvsVariantData::Array: { unsigned int uCnt = pArg->array()->size(); unsigned int idx = 0; while(idx < uCnt) { // we evaluate this each time (as it may actually be killed at each iteration) // FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here // (but might be far less efficient everywhere else...) KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c); if(!v) return false; KviKvsVariant * pOne = pArg->array()->at(idx); if(pOne) { if(bIncludeEmptyScalars || (!pOne->isEmpty())) { v->result()->copyFrom(*pOne); } else { delete v; // we're done with it for this iteration idx++; continue; } } else { if(bIncludeEmptyScalars) { v->result()->setNothing(); } else { delete v; // we're done with it for this iteration idx++; continue; } } delete v; // we're done with it for this iteration if(!m_pLoop->execute(c)) { if(c->error()) return false; // break allowed! if(c->breakPending()) { c->handleBreak(); return true; } if(c->continuePending()) { c->handleContinue(); idx++; continue; } return false; // propagate the false return value } idx++; } } break; case KviKvsVariantData::Hash: { KviKvsHashIterator it(*(pArg->hash()->dict())); while(KviKvsVariant * pOne = it.current()) { // we evaluate this each time (as it may actually be killed at each iteration) // FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here // (but might be far less efficient everywhere else...) KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c); if(!v) return false; if(bIncludeEmptyScalars || (!pOne->isEmpty())) { v->result()->copyFrom(*pOne); } else { delete v; // we're done with it for this iteration ++it; continue; } delete v; // we're done with it for this iteration if(!m_pLoop->execute(c)) { if(c->error()) return false; // break allowed! if(c->breakPending()) { c->handleBreak(); return true; } if(c->continuePending()) { c->handleContinue(); ++it; continue; } return false; // propagate the false return value } ++it; } } break; default: if(bIncludeEmptyScalars || (!pArg->isEqualToNothing())) { // we evaluate this each time (as it may actually be killed at each iteration) // FIXME: maybe some kind of reference counting or a observer pattern might be a bit more efficient here // (but might be far less efficient everywhere else...) KviKvsRWEvaluationResult * v = m_pIterationVariable->evaluateReadWrite(c); if(!v) return false; v->result()->copyFrom(*pArg); delete v; // we're done with it for this iteration if(!m_pLoop->execute(c)) { if(c->error()) return false; // break allowed! if(c->breakPending()) { c->handleBreak(); return true; } if(c->continuePending()) { c->handleContinue(); continue; } return false; // propagate the false return value } } break; } } return true; }