/// <summary>
/// Indicates whether the expression is based on a placeholder value, ommiting the parameter provided
/// </summary>
/// <param name="context">The current interpretation context</param>
/// <param name="expression">The expression to evaluate</param>
/// <returns></returns>
private bool ExpressionBasedOnPlaceHolder(Interpreter.InterpretationContext context, Interpreter.BinaryExpression expression)
{
bool retVal = false;
if (expression != null)
{
foreach (Types.ITypedElement element in expression.GetRightSides())
{
Parameter parameter = element as Parameter;
if (parameter != null)
{
Variables.IVariable variable = context.findOnStack(parameter);
if (variable != null)
{
Values.PlaceHolder placeHolder = variable.Value as Values.PlaceHolder;
if (placeHolder != null)
{
retVal = true;
break;
}
}
}
}
}
return(retVal);
}
/// <summary>
/// Provides the graph of this function if it has been statically defined
/// </summary>
/// <param name="context">the context used to create the graph</param>
/// <returns></returns>
public virtual Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter)
{
Graph retVal = Graph;
if (retVal == null)
{
try
{
Interpreter.InterpretationContext ctxt = new Interpreter.InterpretationContext(context);
if (Cases.Count > 0)
{
// For now, just create graphs for functions using 0 or 1 parameter.
if (FormalParameters.Count == 0)
{
Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>());
retVal = Graph.createGraph(value, parameter);
}
else if (FormalParameters.Count == 1)
{
Parameter param = (Parameter)FormalParameters[0];
int token = ctxt.LocalScope.PushContext();
Values.IValue actualValue = null;
if (parameter != null)
{
Variables.IVariable actual = ctxt.findOnStack(parameter);
if (actual != null)
{
actualValue = actual.Value;
}
else
{
actualValue = new Values.PlaceHolder(parameter.Type, 1);
}
ctxt.LocalScope.setParameter(param, actualValue);
}
retVal = createGraphForParameter(ctxt, param);
if (getCacheable() && actualValue is Values.PlaceHolder)
{
Graph = retVal;
}
ctxt.LocalScope.PopContext(token);
}
else
{
Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>());
retVal = Graph.createGraph(value, parameter);
}
}
}
catch (Exception e)
{
AddError("Cannot create graph of function, reason : " + e.Message);
}
}
return(retVal);
}
/// <summary>
/// Provides the parameters whose value are place holders
/// </summary>
/// <param name="function">The function on which the call is performed</param>
/// <param name="parameterValues">The actual parameter values</param>
/// <returns></returns>
private List <Parameter> GetPlaceHolders(Functions.Function function, Dictionary <Variables.Actual, Values.IValue> parameterValues)
{
List <Parameter> retVal = new List <Parameter>();
foreach (KeyValuePair <Variables.Actual, Values.IValue> pair in parameterValues)
{
Variables.Actual actual = pair.Key;
Values.PlaceHolder placeHolder = pair.Value as Values.PlaceHolder;
if (placeHolder != null && actual.Parameter.Enclosing == function)
{
retVal.Add(actual.Parameter);
}
}
if (retVal.Count != parameterValues.Count || retVal.Count == 0)
{
retVal = null;
}
return(retVal);
}
/// <summary>
/// Gets the unbound parameters from the function definition and place holders
/// </summary>
/// <param name="context"></param>
/// <param name="function"></param>
/// <returns></returns>
private List <Parameter> getUnboundParameter(InterpretationContext context, Functions.Function function)
{
List <Parameter> retVal = new List <Parameter>();
if (function != null)
{
foreach (Parameter formal in function.FormalParameters)
{
Variables.IVariable actual = context.findOnStack(formal);
if (actual != null)
{
Values.PlaceHolder placeHolder = actual.Value as Values.PlaceHolder;
if (placeHolder != null)
{
retVal.Add(formal);
}
}
}
}
return(retVal);
}
/// <summary>
/// Provides the graph of this function if it has been statically defined
/// </summary>
/// <param name="context">the context used to create the graph</param>
/// <returns></returns>
public virtual Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter)
{
Graph retVal = Graph;
if (retVal == null)
{
try
{
Interpreter.InterpretationContext ctxt = new Interpreter.InterpretationContext(context);
if (Cases.Count > 0)
{
// For now, just create graphs for functions using 0 or 1 parameter.
if (FormalParameters.Count == 0)
{
Values.IValue value = Evaluate(ctxt, new Dictionary<Variables.Actual, Values.IValue>());
retVal = Graph.createGraph(value, parameter);
}
else if (FormalParameters.Count == 1)
{
Parameter param = (Parameter)FormalParameters[0];
int token = ctxt.LocalScope.PushContext();
Values.IValue actualValue = null;
if (parameter != null)
{
Variables.IVariable actual = ctxt.findOnStack(parameter);
if (actual != null)
{
actualValue = actual.Value;
}
else
{
actualValue = new Values.PlaceHolder(parameter.Type, 1);
}
ctxt.LocalScope.setParameter(param, actualValue);
}
retVal = createGraphForParameter(ctxt, param);
if (getCacheable() && actualValue is Values.PlaceHolder)
{
Graph = retVal;
}
ctxt.LocalScope.PopContext(token);
}
else
{
Values.IValue value = Evaluate(ctxt, new Dictionary<Variables.Actual, Values.IValue>());
retVal = Graph.createGraph(value, parameter);
}
}
}
catch (Exception e)
{
AddError("Cannot create graph of function, reason : " + e.Message);
}
}
return retVal;
}
