bool csConditionEvaluator::EvaluateCachedInternal (EvalState* evalState,
EvaluatorShadervar& eval,
csConditionID condition)
{
if (condition == csCondAlwaysTrue)
return true;
else if (condition == csCondAlwaysFalse)
return false;
/* Hack: it can happen that while evaluating a shader, new conditions
* are added (notably when a shader source is retrieved from an
* external source). Make sure the cache is large enough.
*/
if (evalState->condChecked.GetSize() < conditions.GetNumConditions ())
{
evalState->condChecked.SetSize (conditions.GetNumConditions ());
evalState->condResult.SetSize (conditions.GetNumConditions ());
}
if (evalState->condChecked.IsBitSet (condition))
{
return evalState->condResult.IsBitSet (condition);
}
bool result = EvaluateInternal (eval, condition);
evalState->condChecked.Set (condition, true);
evalState->condResult.Set (condition, result);
return result;
}
Logic3 csConditionEvaluator::CheckConditionResultsInternal (
csConditionID condition, const Variables& vars,
Variables& trueVars, Variables& falseVars)
{
trueVars = falseVars = vars;
EvaluatorShadervarValues eval (*this, vars, trueVars, falseVars);
return EvaluateInternal (eval, condition);
}
Interpreter::CompilationResult
Interpreter::echo(const std::string& input, Value* V /* = 0 */) {
CompilationOptions CO;
CO.DeclarationExtraction = 0;
CO.ValuePrinting = CompilationOptions::VPEnabled;
CO.ResultEvaluation = (bool)V;
return EvaluateInternal(input, CO, V);
}
Interpreter::CompilationResult
Interpreter::execute(const std::string& input) {
CompilationOptions CO;
CO.DeclarationExtraction = 0;
CO.ValuePrinting = 0;
CO.ResultEvaluation = 0;
CO.DynamicScoping = 0;
CO.Debug = isPrintingDebug();
return EvaluateInternal(input, CO);
}
Interpreter::CompilationResult
Interpreter::evaluate(const std::string& input, Value& V) {
// Here we might want to enforce further restrictions like: Only one
// ExprStmt can be evaluated and etc. Such enforcement cannot happen in the
// worker, because it is used from various places, where there is no such
// rule
CompilationOptions CO;
CO.DeclarationExtraction = 0;
CO.ValuePrinting = 0;
CO.ResultEvaluation = 1;
return EvaluateInternal(input, CO, &V);
}
///\brief Maybe transform the input line to implement cint command line
/// semantics (declarations are global) and compile to produce a module.
///
Interpreter::CompilationResult
Interpreter::process(const std::string& input, Value* V /* = 0 */,
Transaction** T /* = 0 */) {
if (isRawInputEnabled() || !ShouldWrapInput(input))
return declare(input, T);
CompilationOptions CO;
CO.DeclarationExtraction = 1;
CO.ValuePrinting = CompilationOptions::VPAuto;
CO.ResultEvaluation = (bool)V;
CO.DynamicScoping = isDynamicLookupEnabled();
CO.Debug = isPrintingDebug();
if (EvaluateInternal(input, CO, V, T) == Interpreter::kFailure) {
return Interpreter::kFailure;
}
return Interpreter::kSuccess;
}
Logic3 csConditionEvaluator::CheckConditionResultsInternal (
csConditionID condition, const Variables& vars)
{
EvaluatorShadervarValuesSimple eval (*this, vars);
return EvaluateInternal (eval, condition);
}
typename Evaluator::EvalResult csConditionEvaluator::Evaluate (
Evaluator& eval, csConditionID condition)
{
LockType lock (mutex);
return EvaluateInternal (eval, condition);
}
optional<bool> Constraint_L_Unary::Evaluate(
const std::vector<std::shared_ptr<ParamSpec> >& param_specs,
const Assignment& assignment) const {
return EvaluateInternal(
get_oprd()->Evaluate(param_specs, assignment));
}
