bool AttributeReference::
_Evaluate (EvalState &state, Value &val, ExprTree *&sig ) const
{
ExprTree *tree;
ExprTree *exprSig;
const ClassAd *curAd;
bool rval;
curAd = state.curAd;
exprSig = NULL;
rval = true;
switch( FindExpr( state , tree , exprSig , true ) ) {
case EVAL_FAIL:
rval = false;
break;
case EVAL_ERROR:
val.SetErrorValue( );
break;
case EVAL_UNDEF:
val.SetUndefinedValue( );
break;
case EVAL_OK:
{
if( state.depth_remaining <= 0 ) {
val.SetErrorValue();
state.curAd = curAd;
return false;
}
state.depth_remaining--;
rval = tree->Evaluate( state, val );
state.depth_remaining++;
break;
}
default: CLASSAD_EXCEPT( "ClassAd: Should not reach here" );
}
if(!rval || !(sig=new AttributeReference(exprSig,attributeStr,absolute))){
if( rval ) {
CondorErrno = ERR_MEM_ALLOC_FAILED;
CondorErrMsg = "";
}
delete exprSig;
sig = NULL;
return( false );
}
state.curAd = curAd;
return rval;
}
bool AttributeReference::
_Evaluate (EvalState &state, Value &val) const
{
ExprTree *tree;
ExprTree *dummy;
const ClassAd *curAd;
bool rval;
// find the expression and the evalstate
curAd = state.curAd;
switch( FindExpr( state, tree, dummy, false ) ) {
case EVAL_FAIL:
return false;
case EVAL_ERROR:
val.SetErrorValue();
state.curAd = curAd;
return true;
case EVAL_UNDEF:
val.SetUndefinedValue();
state.curAd = curAd;
return true;
case EVAL_OK:
{
if( state.depth_remaining <= 0 ) {
val.SetErrorValue();
state.curAd = curAd;
return false;
}
state.depth_remaining--;
rval = tree->Evaluate( state, val );
state.depth_remaining++;
state.curAd = curAd;
return rval;
}
default: CLASSAD_EXCEPT( "ClassAd: Should not reach here" );
}
return false;
}
int
unwind_attributes(classad_context cad, char *attribute_name, char ***results)
{
if (cad == NULL) return C_CLASSAD_INVALID_CONTEXT;
if ((results == NULL) || (attribute_name == NULL))
return C_CLASSAD_INVALID_ARG;
ClassAd *ad = (ClassAd *)cad;
ExprTree *et;
bool need_to_delete_et = false;
et = ad->Lookup(attribute_name);
if (et == NULL)
{
return C_CLASSAD_VALUE_NOT_FOUND;
}
if (et->GetKind() == ExprTree::LITERAL_NODE)
{
// The attribute was probably stringified. Try to parse it.
Value v;
EvalState state;
state.SetScopes( ad );
et->Evaluate(state,v);
std::string strres;
if (v.IsStringValue( strres ))
{
ClassAdParser parser;
et=NULL;
parser.ParseExpression(strres,et);
need_to_delete_et = true;
}
}
BinaryOpUnwind res_unp;
std::string result;
res_unp.Unparse(result, et);
int n_results;
if (*results == NULL)
{
n_results = 0;
(*results) = (char **)malloc(sizeof(char **));
if ((*results) == NULL) return C_CLASSAD_OUT_OF_MEMORY;
(*results)[0] = NULL;
}
else
{
for (n_results = 0; (*results)[n_results] != NULL; n_results++) /*NOP*/ ;
}
std::vector<std::string>::const_iterator it;
for (it = res_unp.m_unwind_output.begin();
it != res_unp.m_unwind_output.end(); ++it)
{
n_results++;
char **new_results;
new_results = (char **)realloc(*results, (n_results+1)*sizeof(char *));
if (new_results == NULL)
{
if (need_to_delete_et) delete et;
return C_CLASSAD_OUT_OF_MEMORY;
}
(*results) = new_results;
(*results)[n_results] = NULL;
(*results)[n_results-1] = strdup(it->c_str());
if (((*results)[n_results-1]) == NULL)
{
if (need_to_delete_et) delete et;
return C_CLASSAD_OUT_OF_MEMORY;
}
}
if (need_to_delete_et) delete et;
return C_CLASSAD_NO_ERROR;
}
void
LiveJobImpl::Set ( const char *_name, const char *_value )
{
if ( strcasecmp ( _name, ATTR_JOB_SUBMISSION ) == 0 )
{
std::string val = TrimQuotes( _value );
// TODO: grab the cluster from our key
PROC_ID id = getProcByString(m_job->GetKey());
if (m_job) {
m_job->SetSubmission ( val.c_str(), id.cluster );
}
}
// our status is changing...decrement for old one
if ( strcasecmp ( _name, ATTR_JOB_STATUS ) == 0 )
{
if ( m_job )
{
m_job->SetStatus(this->GetStatus());
m_job->DecrementSubmission ();
}
}
if ( strcasecmp ( _name, ATTR_OWNER ) == 0 )
{
// need to leave an owner for this job
// to be picked up soon
// if we are in here, we don't have m_submission
PROC_ID id = getProcByString(m_job->GetKey());
std::string val = TrimQuotes( _value );
g_ownerless_clusters[id.cluster] = val;
m_job->UpdateSubmission(id.cluster,val.c_str());
}
// parse the type
ExprTree *expr;
if ( ParseClassAdRvalExpr ( _value, expr ) )
{
dprintf ( D_ALWAYS,
"error: parsing %s[%s] = %s, skipping\n",
m_job->GetKey(), _name, _value );
return;
}
// add this value to the classad
classad::Value value;
expr->Evaluate(value);
switch ( value.GetType() )
{
case classad::Value::INTEGER_VALUE:
int i;
from_string<int> ( i, std::string ( _value ), std::dec );
m_full_ad->Assign ( _name, i );
break;
case classad::Value::REAL_VALUE:
float f;
from_string<float> ( f, std::string ( _value ), std::dec );
m_full_ad->Assign ( _name, f );
break;
case classad::Value::STRING_VALUE:
m_full_ad->Assign ( _name, _value );
break;
default:
m_full_ad->AssignExpr ( _name, _value );
break;
}
delete expr;
expr = NULL;
// our status has changed...increment for new one
if ( strcasecmp ( _name, ATTR_JOB_STATUS ) == 0 )
{
if ( m_job )
{
m_job->SetStatus(this->GetStatus());
m_job->IncrementSubmission ();
}
}
}