/// <summary> /// Creates the association between parameter (from the called ICallable) and its associated expression /// </summary> /// <param name="callable"></param> /// <returns></returns> private Dictionary <Parameter, Expression> createParameterAssociation(ICallable callable) { Dictionary <Parameter, Expression> retVal = null; if (callable != null) { if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count) { retVal = new Dictionary <Parameter, Expression>(); int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = callable.FormalParameters[i] as Parameter; retVal.Add(parameter, expression); i = i + 1; } foreach (KeyValuePair <string, Expression> pair in NamedActualParameters) { Parameter parameter = callable.getFormalParameter(pair.Key); if (parameter != null) { retVal.Add(parameter, pair.Value); } } } } return(retVal); }
/// <summary> /// Creates the parameter value associationg according to actual parameters /// </summary> /// <param name="context">The interpretation context</param> /// <param name="callable">The callable</param> /// <param name="log">Indicates whether errors should be logged</param> /// <returns></returns> public Dictionary <Variables.Actual, Values.IValue> AssignParameterValues(InterpretationContext context, ICallable callable, bool log) { // Compute the unnamed actual parameter values Dictionary <Variables.Actual, Values.IValue> retVal = new Dictionary <Variables.Actual, Values.IValue>(); if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count) { int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = callable.FormalParameters[i] as Parameter; Values.IValue val = expression.GetValue(context); if (val != null) { Variables.Actual actual = parameter.createActual(); val = val.RightSide(actual, false); retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + i + " (" + expression.ToString() + ") of function " + callable.Name); return(new Dictionary <Variables.Actual, Values.IValue>()); } i = i + 1; } foreach (KeyValuePair <string, Expression> pair in NamedActualParameters) { Parameter parameter = callable.getFormalParameter(pair.Key); Values.IValue val = pair.Value.GetValue(context); if (val != null) { Variables.Actual actual = parameter.createActual(); val = val.RightSide(actual, false); actual.Value = val; retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + pair.Key + " of function " + callable.Name); return(new Dictionary <Variables.Actual, Values.IValue>()); } } } return(retVal); }
/// <summary> /// Creates the association between parameter (from the called ICallable) and its associated expression /// </summary> /// <param name="callable"></param> /// <returns></returns> private Dictionary<Parameter, Expression> createParameterAssociation(ICallable callable) { Dictionary<Parameter, Expression> retVal = null; if (callable != null) { if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count) { retVal = new Dictionary<Parameter, Expression>(); int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = callable.FormalParameters[i] as Parameter; retVal.Add(parameter, expression); i = i + 1; } foreach (KeyValuePair<string, Expression> pair in NamedActualParameters) { Parameter parameter = callable.getFormalParameter(pair.Key); if (parameter != null) { retVal.Add(parameter, pair.Value); } } } } return retVal; }
/// <summary> /// Creates the parameter value associationg according to actual parameters /// </summary> /// <param name="context">The interpretation context</param> /// <param name="callable">The callable</param> /// <param name="log">Indicates whether errors should be logged</param> /// <returns></returns> public Dictionary<Variables.Actual, Values.IValue> AssignParameterValues(InterpretationContext context, ICallable callable, bool log) { // Compute the unnamed actual parameter values Dictionary<Variables.Actual, Values.IValue> retVal = new Dictionary<Variables.Actual, Values.IValue>(); if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count) { int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = callable.FormalParameters[i] as Parameter; Values.IValue val = expression.GetValue(context); if (val != null) { Variables.Actual actual = parameter.createActual(); val = val.RightSide(actual, false); retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + i + " (" + expression.ToString() + ") of function " + callable.Name); return new Dictionary<Variables.Actual, Values.IValue>(); } i = i + 1; } foreach (KeyValuePair<string, Expression> pair in NamedActualParameters) { Parameter parameter = callable.getFormalParameter(pair.Key); Values.IValue val = pair.Value.GetValue(context); if (val != null) { Variables.Actual actual = parameter.createActual(); val = val.RightSide(actual, false); actual.Value = val; retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + pair.Key + " of function " + callable.Name); return new Dictionary<Variables.Actual, Values.IValue>(); } } } return retVal; }
/// <summary> /// Creates the parameter value associationg according to actual parameters /// </summary> /// <param name="context">The interpretation context</param> /// <param name="callable">The callable</param> /// <param name="log">Indicates whether errors should be logged</param> /// <param name="explain"></param> /// <returns></returns> public Dictionary<Actual, IValue> AssignParameterValues(InterpretationContext context, ICallable callable, bool log, ExplanationPart explain) { // Compute the unnamed actual parameter values Dictionary<Actual, IValue> retVal = new Dictionary<Actual, IValue>(); if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count) { int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = callable.FormalParameters[i] as Parameter; ExplanationPart subExplanation = ExplanationPart.CreateSubExplanation(explain, parameter); IValue val = expression.GetValue(context, subExplanation); if (val != null) { Actual actual = parameter.createActual(); val = val.RightSide(actual, false, false); retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + i + " (" + expression.ToString() + ") of function " + callable.Name); throw new Exception("Evaluation of parameters failed"); } ExplanationPart.SetNamable(subExplanation, val); i = i + 1; } foreach (KeyValuePair<Designator, Expression> pair in NamedActualParameters) { Parameter parameter = callable.getFormalParameter(pair.Key.Image); ExplanationPart subExplanation = ExplanationPart.CreateSubExplanation(explain, parameter); IValue val = pair.Value.GetValue(context, subExplanation); if (val != null) { Actual actual = parameter.createActual(); val = val.RightSide(actual, false, false); actual.Value = val; retVal.Add(actual, val); } else { AddError("Cannot evaluate value for parameter " + pair.Key + " of function " + callable.Name); throw new Exception("Evaluation of parameters failed"); } ExplanationPart.SetNamable(subExplanation, val); } } return retVal; }
/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void checkExpression() { base.checkExpression(); Called.checkExpression(); ICallable called = Called.getStaticCallable(); if (called != null) { if (called.FormalParameters.Count != NamedActualParameters.Count + ActualParameters.Count) { AddError("Invalid number of arguments provided for function call " + ToString() + " expected " + called.FormalParameters.Count + " actual " + NamedActualParameters.Count); } else { Dictionary <string, Expression> actuals = new Dictionary <string, Expression>(); int i = 0; foreach (Expression expression in ActualParameters) { Parameter parameter = called.FormalParameters[i] as Parameter; CheckActualAgainstFormal(actuals, expression, parameter); i = i + 1; } foreach (KeyValuePair <string, Expression> pair in NamedActualParameters) { string name = pair.Key; Expression expression = pair.Value; Parameter parameter = called.getFormalParameter(name); if (parameter == null) { AddError("Parameter " + name + " is not defined as formal parameter of function " + called.FullName); } else { if (actuals.ContainsKey(name)) { AddError("Parameter " + name + " isassigned twice in " + ToString()); } else { CheckActualAgainstFormal(actuals, expression, parameter); } } } if (called.FormalParameters.Count > 2) { if (ActualParameters.Count > 0) { AddWarning("Calls where more than two parameters are provided must be performed using named association"); } } called.additionalChecks(Root, actuals); } } else { AddError("Cannot determine callable referenced by " + ToString()); } }