const char* csConditionEvaluator::ProcessExpressionInternal (
csExpression* expression, csConditionID& cond)
{
CondOperation newOp;
const char* err = ProcessExpressionInternal (expression, newOp);
if (err) return err;
cond = FindOptimizedConditionInternal (newOp);
return 0;
}
const char* csConditionEvaluator::ResolveOperand (csExpression* expression,
CondOperand& operand)
{
const char* err;
if (expression->type == csExpression::Value)
{
err = ResolveExpValue (expression->valueValue, operand);
if (err)
{
return SetLastError ("Can't resolve value %s: %s",
CS::Quote::Single (csExpressionToken::Extractor (expression->valueValue).Get ()),
err);
}
return 0;
}
const csExpressionToken& t = expression->expressionValue.op;
if (TokenEquals (t.tokenStart, t.tokenLen, "."))
{
CS_ASSERT (expression->expressionValue.left->type
== csExpression::Value);
const csExpressionToken& left =
expression->expressionValue.left->valueValue;
if (TokenEquals (left.tokenStart, left.tokenLen, "vars"))
{
err = ResolveSVIdentifier (expression->expressionValue.right,
operand);
if (err)
return err;
return 0;
}
else if (TokenEquals (left.tokenStart, left.tokenLen, "consts"))
{
err = ResolveConst (expression->expressionValue.right,
operand);
if (err)
return err;
return 0;
}
else
{
return SetLastError ("Unknown identifier %s",
CS::Quote::Single (csExpressionToken::Extractor (left).Get ()));
}
}
else
{
operand.type = operandOperation;
err = ProcessExpressionInternal (expression, operand.operation);
if (err)
return err;
return 0;
}
CS_ASSERT (false);
return 0;
}
const char* csConditionEvaluator::ProcessExpression (csExpression* expression,
CondOperation& operation)
{
LockType lock (mutex);
return ProcessExpressionInternal (expression, operation);
}
const char* csConditionEvaluator::ProcessExpression (
csExpression* expression, csConditionID& cond)
{
LockType lock (mutex);
return ProcessExpressionInternal (expression, cond);
}
