bool EvalBool(compat_classad::ClassAd *ad, const char *constraint)
{
static classad::ExprTree *tree = NULL;
static char * saved_constraint = NULL;
classad::Value result;
bool constraint_changed = true;
double doubleVal;
long long intVal;
bool boolVal;
if ( saved_constraint ) {
if ( strcmp(saved_constraint,constraint) == 0 ) {
constraint_changed = false;
}
}
if ( constraint_changed ) {
// constraint has changed, or saved_constraint is NULL
if ( saved_constraint ) {
free(saved_constraint);
saved_constraint = NULL;
}
if ( tree ) {
delete tree;
tree = NULL;
}
classad::ExprTree *tmp_tree = NULL;
if ( ParseClassAdRvalExpr( constraint, tmp_tree ) != 0 ) {
dprintf( D_ALWAYS,
"can't parse constraint: %s\n", constraint );
return false;
}
tree = compat_classad::RemoveExplicitTargetRefs( tmp_tree );
delete tmp_tree;
saved_constraint = strdup( constraint );
}
// Evaluate constraint with ad in the target scope so that constraints
// have the same semantics as the collector queries. --RR
if ( !EvalExprTree( tree, ad, NULL, result ) ) {
dprintf( D_ALWAYS, "can't evaluate constraint: %s\n", constraint );
return false;
}
if( result.IsBooleanValue( boolVal ) ) {
return boolVal;
} else if( result.IsIntegerValue( intVal ) ) {
return intVal != 0;
} else if( result.IsRealValue( doubleVal ) ) {
return !IS_DOUBLE_ZERO(doubleVal);
}
dprintf( D_ALWAYS, "constraint (%s) does not evaluate to bool\n",
constraint );
return false;
}
static char * fcvtbuf (double value, int ndigits, int *decpt, int *sign, char *buf)
{
static const char INFINITY[] = "Infinity";
char decimal = '.' ;
char chBuffer[20];
char *cvtbuf = chBuffer;
char *s = cvtbuf;
char *dot;
char *pchRet = 0;
ftoa(value, cvtbuf);
*sign = ('-' == *s++) ? 1 : 0; /* The sign. */
/* Where's the decimal point? */
dot = strchr(s, decimal);
*decpt = dot ? (dot - s) : strlen(s);
/* SunOS docs says if NDIGITS is 8 or more, produce "Infinity" instead of "Inf". */
if (strncmp (s, "Inf", 3) == 0)
{
memcpy (buf, INFINITY, ndigits >= 8 ? 9 : 3);
if (ndigits < 8) buf[3] = '\0';
pchRet = buf; /*return buf;*/
}
else if (ndigits < 0)
{/*return ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf (value, *decpt + ndigits, decpt, sign, buf);
}
else if (*s == '0' && !IS_DOUBLE_ZERO(value)/*value != 0.0*/)
{/*return ecvtbuf (value, ndigits, decpt, sign, buf);*/
pchRet = ecvtbuf(value, ndigits, decpt, sign, buf);
}
else
{
memcpy (buf, s, *decpt);
if (s[*decpt] == decimal)
{
memcpy (buf + *decpt, s + *decpt + 1, ndigits);
buf[*decpt + ndigits] = '\0';
}
else
{
buf[*decpt] = '\0';
}
__ecvround (buf, buf + *decpt + ndigits - 1,
s + *decpt + ndigits + 1, decpt);
pchRet = buf; /*return buf;*/
}
/*delete [] cvtbuf; */
return pchRet;
}
static char * ftoa(double dValue, char * chBuffer)
{
char * pch = chBuffer;
if(!pch) return 0;
if(!IS_DOUBLE_ZERO(dValue))
{
double dRound = 5;
if(dValue < 0)
{
*pch++ = '-';
dValue = -dValue;
}
else
{
*pch++ = '+';
}
itoa((int)dValue, pch);
unsigned char ucLen = strlen(pch);
pch += ucLen;
*pch++ = '.';
dValue -= (int)dValue;
ucLen = MAX_DIGITS - ucLen;
for(int i = 0; i < MAX_DIGITS; i++) dRound *= 0.1;
for(int i = 0; i < ucLen; i++)
{
dValue = (dValue + dRound) * 10;
itoa((int)dValue, pch);
pch += strlen(pch);
dValue -= (int)dValue;
}
}
else
{
*pch++ = '0';
*pch = '\0';
}
pch--;
//while ('0' == *pch) *pch-- = '';
return chBuffer;
}
bool EvalBool(compat_classad::ClassAd *ad, classad::ExprTree *tree)
{
classad::Value result;
double doubleVal;
long long intVal;
bool boolVal;
// Evaluate constraint with ad in the target scope so that constraints
// have the same semantics as the collector queries. --RR
if ( !EvalExprTree( tree, ad, NULL, result ) ) {
return false;
}
if( result.IsBooleanValue( boolVal ) ) {
return boolVal;
} else if( result.IsIntegerValue( intVal ) ) {
return intVal != 0;
} else if( result.IsRealValue( doubleVal ) ) {
return !IS_DOUBLE_ZERO(doubleVal);
}
return false;
}
static void cfltcvt(double value, char *buffer, char fmt, int precision)
{
int decpt, sign;
char cvtbuf[80];
int capexp = 0;
if ('G' == fmt || 'E' == fmt)
{
capexp = 1;
fmt += 'a' - 'A';
}
if (fmt == 'g')
{
char * digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
int magnitude = decpt - 1;
if (magnitude < -4 || magnitude > precision - 1)
{
fmt = 'e';
precision -= 1;
}
else
{
fmt = 'f';
precision -= decpt;
}
}
if ('e' == fmt)
{
char * digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
int exp = 0;
if (sign) *buffer++ = '-';
*buffer++ = *digits;
if (precision > 0) *buffer++ = '.';
memcpy(buffer, digits + 1, precision);
buffer += precision;
*buffer++ = capexp ? 'E' : 'e';
if (decpt == 0)
{
exp = (IS_DOUBLE_ZERO(value)) ? 0 : -1; /* if (value == 0.0)*/
}
else
{
exp = decpt - 1;
}
if (exp < 0)
{
*buffer++ = '-';
exp = -exp;
}
else
{
*buffer++ = '+';
}
buffer[2] = (exp % 10) + '0';
exp /= 10;
buffer[1] = (exp % 10) + '0';
exp /= 10;
buffer[0] = (exp % 10) + '0';
buffer += 3;
}
else if ('f' == fmt)
{
char * digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
if (sign) *buffer++ = '-';
if (*digits)
{
if (decpt <= 0)
{
*buffer++ = '0';
*buffer++ = '.';
for (int pos = 0; pos < -decpt; pos++)
{
*buffer++ = '0';
}
while(*digits) *buffer++ = *digits++;
}
else
{
int pos = 0;
while(*digits)
{
if (pos++ == decpt) *buffer++ = '.';
*buffer++ = *digits++;
}
}
}
else
{
*buffer++ = '0';
if(precision > 0)
{
*buffer++ = '.';
for(int pos = 0; pos < precision; pos++)
{
*buffer++ = '0';
}
}
}
}
*buffer = '\0';
}
static char * ftoaE(char* pchBuffer, int dppos, double value)
{
double roundingValue = 0.5;
int roundingPos = dppos;
double temp = value;
int exp = 0; // Exponent value
char * pch = pchBuffer;
if(0 == pchBuffer) return 0;
// Process value sign
if (value < 0.0)
{
value = -value;
*pchBuffer++ = '-';
}
else
{
*pchBuffer++ = '+';
}
// Round value and get exponent
if(!IS_DOUBLE_ZERO(value)) /*if (value != 0.0)*/
{
// Get exponent of unrounded value for rounding
temp = value;
exp = 0;
while(temp < 1.0)
{
temp *= 10.0;
exp--;
}
while(temp >= 10.0)
{
temp *= 0.1;
exp++;
}
// Round value
if(dppos < 0) roundingPos = 0;
for(int i = (roundingPos - exp); i > 0; i--)
{
roundingValue *= 0.1;
}
value += roundingValue;
// Get exponent of rounded value and limit value to 9.999...1.000
exp = 0;
while(value < 1.0)
{
value *= 10.0;
exp--;
}
while(value >= 10.0)
{
value *= 0.1;
exp++;
}
}
// Compose mantissa output string
for (int i = ((dppos < 0) ? 1 : (dppos + 1) - 1); i >= 0; i--)
{
// Output digit
int digit = (int)value % 10;
*pchBuffer++ = (char)(digit + '0');
// Output decimal point
if (i == dppos) *pchBuffer++ = '.';
value = (value - (double)digit) * 10.0;
}
// Compose exponent output string
*pchBuffer++ = 'E';
itoa(exp, pchBuffer);
return pch;
}
