private string FilterFunctionParameterType(int i, SequenceFilterCall sequenceFilterCall)
{
if (sequenceFilterCall.Filter is IFilterAutoSupplied)
{
IFilterAutoSupplied filterAutoSupplied = (IFilterAutoSupplied)sequenceFilterCall.Filter;
return(TypesHelper.DotNetTypeToXgrsType(filterAutoSupplied.Inputs[i]));
}
if (sequenceFilterCall.Filter is IFilterFunction)
{
IFilterFunction filterFunction = (IFilterFunction)sequenceFilterCall.Filter;
return(TypesHelper.DotNetTypeToXgrsType(filterFunction.Inputs[i]));
}
throw new Exception("Internal error"); // auto-generated
}
private int NumFilterFunctionParameters(SequenceFilterCall sequenceFilterCall)
{
if (sequenceFilterCall.Filter is IFilterAutoSupplied)
{
IFilterAutoSupplied filterAutoSupplied = (IFilterAutoSupplied)sequenceFilterCall.Filter;
return(filterAutoSupplied.Inputs.Length);
}
if (sequenceFilterCall.Filter is IFilterFunction)
{
IFilterFunction filterFunction = (IFilterFunction)sequenceFilterCall.Filter;
return(filterFunction.Inputs.Length);
}
return(0); // auto-generated
}
protected override string GetMatchClassName(SequenceFilterCall sequenceFilterCall)
{
SequenceFilterCallCompiled sequenceFilterCallCompiled = (SequenceFilterCallCompiled)sequenceFilterCall;
return(sequenceFilterCallCompiled.MatchClassPackagePrefixedName);
}
protected override bool IsMatchClassExisting(SequenceFilterCall sequenceFilterCall)
{
SequenceFilterCallCompiled sequenceFilterCallCompiled = (SequenceFilterCallCompiled)sequenceFilterCall;
return(actionNames.ContainsMatchClass(sequenceFilterCallCompiled.MatchClassPackagePrefixedName));
}
protected override string GetMatchClassName(SequenceFilterCall sequenceFilterCall)
{
SequenceFilterCallInterpreted sequenceFilterCallInterpreted = (SequenceFilterCallInterpreted)sequenceFilterCall;
return(sequenceFilterCallInterpreted.MatchClass.info.PackagePrefixedName);
}
protected override bool IsMatchClassExisting(SequenceFilterCall sequenceFilterCall)
{
SequenceFilterCallInterpreted sequenceFilterCallInterpreted = (SequenceFilterCallInterpreted)sequenceFilterCall;
return(sequenceFilterCallInterpreted.MatchClass != null);
}
protected abstract string GetMatchClassName(SequenceFilterCall sequenceFilterCall);
protected abstract bool IsMatchClassExisting(SequenceFilterCall sequenceFilterCall);
private string GetFilterCallName(SequenceFilterCall sequenceFilterCall)
{
return(sequenceFilterCall.Filter.PackagePrefixedName);
}
/// <summary>
/// Checks whether called match class filter exists, and type checks the inputs.
/// </summary>
public void CheckMatchClassFilterCalls(List <SequenceFilterCallBase> sequenceFilterCalls, List <SequenceRuleCall> ruleCalls)
{
foreach (SequenceFilterCallBase sequenceFilterCallBase in sequenceFilterCalls)
{
String matchClassName = GetMatchClassName(sequenceFilterCallBase);
foreach (SequenceRuleCall ruleCall in ruleCalls)
{
if (!IsRuleImplementingMatchClass(ruleCall.PackagePrefixedName, matchClassName))
{
throw new SequenceParserException(matchClassName, ruleCall.PackagePrefixedName, SequenceParserError.MatchClassNotImplementedError);
}
}
if (sequenceFilterCallBase is SequenceFilterCall)
{
SequenceFilterCall sequenceFilterCall = (SequenceFilterCall)sequenceFilterCallBase;
String filterCallName = GetFilterCallName(sequenceFilterCall);
// Check whether number of filter parameters match
if (NumFilterFunctionParameters(sequenceFilterCall) != sequenceFilterCall.ArgumentExpressions.Length)
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterParameterError);
}
// Check parameter types
for (int i = 0; i < sequenceFilterCall.ArgumentExpressions.Length; i++)
{
sequenceFilterCall.ArgumentExpressions[i].Check(this);
String argumentType = sequenceFilterCall.ArgumentExpressions[i].Type(this);
String paramterType = FilterFunctionParameterType(i, sequenceFilterCall);
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterParameterError);
}
}
}
else
{
SequenceFilterCallLambdaExpression sequenceFilterCallLambdaExpression = (SequenceFilterCallLambdaExpression)sequenceFilterCallBase;
String filterCallName = GetFilterCallName(sequenceFilterCallLambdaExpression);
FilterCallWithLambdaExpression filterCall = sequenceFilterCallLambdaExpression.FilterCall;
if (filterCall.initArrayAccess != null)
{
String argumentType = filterCall.initArrayAccess.Type;
String paramterType = "array<match<class " + matchClassName + ">>";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.initExpression != null)
{
filterCall.initExpression.Check(this);
}
if (filterCall.arrayAccess != null)
{
String argumentType = filterCall.arrayAccess.Type;
String paramterType = "array<match<class " + matchClassName + ">>";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.previousAccumulationAccess != null)
{
String argumentType = filterCall.previousAccumulationAccess.Type;
String paramterType = TypeOfMemberOrAttribute("match<class " + matchClassName + ">", filterCall.Entity);
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.index != null)
{
String argumentType = filterCall.index.Type;
String paramterType = "int";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
String elementArgumentType = filterCall.element.Type;
String elementParamterType = "match<class " + matchClassName + ">";
if (!TypesHelper.IsSameOrSubtype(elementArgumentType, elementParamterType, Model))
{
throw new SequenceParserException(matchClassName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
filterCall.lambdaExpression.Check(this);
}
}
}
/// <summary>
/// Checks whether called filter exists, and type checks the inputs.
/// </summary>
private void CheckFilterCalls(String ruleName, List <SequenceFilterCallBase> sequenceFilterCalls)
{
foreach (SequenceFilterCallBase sequenceFilterCallBase in sequenceFilterCalls)
{
if (sequenceFilterCallBase is SequenceFilterCall)
{
SequenceFilterCall sequenceFilterCall = (SequenceFilterCall)sequenceFilterCallBase;
String filterCallName = GetFilterCallName(sequenceFilterCall);
// Check whether number of filter parameters match
if (NumFilterFunctionParameters(sequenceFilterCall) != sequenceFilterCall.ArgumentExpressions.Length)
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterParameterError);
}
// Check parameter types
for (int i = 0; i < sequenceFilterCall.ArgumentExpressions.Length; i++)
{
sequenceFilterCall.ArgumentExpressions[i].Check(this);
String argumentType = sequenceFilterCall.ArgumentExpressions[i].Type(this);
String paramterType = FilterFunctionParameterType(i, sequenceFilterCall);
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterParameterError);
}
}
}
else
{
SequenceFilterCallLambdaExpression sequenceFilterCallLambdaExpression = (SequenceFilterCallLambdaExpression)sequenceFilterCallBase;
String filterCallName = GetFilterCallName(sequenceFilterCallLambdaExpression);
FilterCallWithLambdaExpression filterCall = sequenceFilterCallLambdaExpression.FilterCall;
if (filterCall.initArrayAccess != null)
{
String argumentType = filterCall.initArrayAccess.Type;
String paramterType = "array<match<" + ruleName + ">>";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.initExpression != null)
{
filterCall.initExpression.Check(this);
}
if (filterCall.arrayAccess != null)
{
String argumentType = filterCall.arrayAccess.Type;
String paramterType = "array<match<" + ruleName + ">>";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.previousAccumulationAccess != null)
{
String argumentType = filterCall.previousAccumulationAccess.Type;
String paramterType = TypeOfTopLevelEntityInRule(ruleName, filterCall.Entity);
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
if (filterCall.index != null)
{
String argumentType = filterCall.index.Type;
String paramterType = "int";
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
}
String elementArgumentType = filterCall.element.Type;
String elementParamterType = "match<" + ruleName + ">";
if (!TypesHelper.IsSameOrSubtype(elementArgumentType, elementParamterType, Model))
{
throw new SequenceParserException(ruleName, filterCallName, SequenceParserError.FilterLambdaExpressionError);
}
filterCall.lambdaExpression.Check(this);
}
}
}
