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;
}
