public override void Check(SequenceCheckingEnvironment env)
{
base.Check(env);
if (DestVar.Type == "")
{
return; // we can't check source and destination types if the variable is untyped, only runtime-check possible
}
if (TypesHelper.ExtractSrc(DestVar.Type) == null || TypesHelper.ExtractDst(DestVar.Type) == null || TypesHelper.ExtractDst(DestVar.Type) == "SetValueType")
{
throw new SequenceParserException(Symbol, "map<S,T> or array<T> or deque<T>", DestVar.Type);
}
if (DestVar.Type.StartsWith("array"))
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), "int", env.Model))
{
throw new SequenceParserException(Symbol, "int", KeyExpression.Type(env));
}
}
else if (DestVar.Type.StartsWith("deque"))
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), "int", env.Model))
{
throw new SequenceParserException(Symbol, "int", KeyExpression.Type(env));
}
}
else
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), TypesHelper.ExtractSrc(DestVar.Type), env.Model))
{
throw new SequenceParserException(Symbol, TypesHelper.ExtractSrc(DestVar.Type), KeyExpression.Type(env));
}
}
}
/// <summary>
/// Checks whether called match class filter exists, and type checks the inputs.
/// </summary>
public void CheckMatchClassFilterCalls(List <SequenceFilterCall> sequenceFilterCalls, List <SequenceRuleCall> ruleCalls)
{
foreach (SequenceFilterCall sequenceFilterCall in sequenceFilterCalls)
{
String matchClassName = GetMatchClassName(sequenceFilterCall);
foreach (SequenceRuleCall ruleCall in ruleCalls)
{
if (!IsRuleImplementingMatchClass(ruleCall.PackagePrefixedName, matchClassName))
{
throw new SequenceParserException(matchClassName, ruleCall.PackagePrefixedName, SequenceParserError.MatchClassNotImplementedError);
}
}
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);
}
}
}
}
private void CheckOutputParametersRuleAll(Invocation invocation, SequenceVariable[] ReturnVars)
{
// Check whether number of parameters and return parameters match
if (ReturnVars.Length != 0 && NumOutputParameters(invocation, null) != ReturnVars.Length)
{
throw new SequenceParserException(invocation, ReturnVars.Length, SequenceParserError.BadNumberOfReturnParameters);
}
// Check return types
for (int i = 0; i < ReturnVars.Length; ++i)
{
String argumentType = ReturnVars[i].Type;
String paramterType = OutputParameterType(i, invocation, null);
if (argumentType == "")
{
continue; // only runtime checks possible
}
if (!argumentType.StartsWith("array<"))
{
Console.Error.WriteLine("An all call expects all return parameters T in an array<T>");
throw new SequenceParserException(invocation, -1, SequenceParserError.BadReturnParameter, i);
}
if (!TypesHelper.IsSameOrSubtype(paramterType, argumentType.Substring(6, ReturnVars[i].Type.Length - 7), Model))
{
Console.Error.WriteLine("The arrays of the all call are inconsemurable in their value types");
throw new SequenceParserException(invocation, -1, SequenceParserError.BadReturnParameter, i);
}
}
}
/// <summary>
/// Checks whether called filter exists, and type checks the inputs.
/// </summary>
private void CheckFilterCalls(String ruleName, List <SequenceFilterCall> sequenceFilterCalls)
{
foreach (SequenceFilterCall sequenceFilterCall in sequenceFilterCalls)
{
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);
}
}
}
}
public override void Check(SequenceCheckingEnvironment env)
{
base.Check(env);
GrGenType nodeOrEdgeType = TypesHelper.GetNodeOrEdgeType(GraphElementVar.Type, env.Model);
if(GraphElementVar.Type != "" && nodeOrEdgeType == null)
throw new SequenceParserException(Symbol, "node or edge type", GraphElementVar.Type);
if(!TypesHelper.IsSameOrSubtype(VisitedFlagExpression.Type(env), "int", env.Model))
throw new SequenceParserException(Symbol, "int", VisitedFlagExpression.Type(env));
}
public override void Check(SequenceCheckingEnvironment env)
{
base.Check(env);
if (DestVar.Type == "")
{
return; // we can't gain access to an attribute type if the variable is untyped, only runtime-check possible
}
InheritanceType inheritanceType = TypesHelper.GetInheritanceType(DestVar.Type, env.Model);
if (inheritanceType == null)
{
throw new SequenceParserException(Symbol, "node or edge or object or transient object type (class)", DestVar.Type);
}
AttributeType attributeType = inheritanceType.GetAttributeType(AttributeName);
if (attributeType == null)
{
throw new SequenceParserException(AttributeName, SequenceParserError.UnknownAttribute);
}
string ContainerType = TypesHelper.AttributeTypeToXgrsType(attributeType);
if (TypesHelper.ExtractSrc(ContainerType) == null ||
TypesHelper.ExtractDst(ContainerType) == null ||
TypesHelper.ExtractDst(ContainerType) == "SetValueType")
{
throw new SequenceParserException(Symbol, "map<S,T> or array<T> or deque<T>", DestVar.Type);
}
if (ContainerType.StartsWith("array"))
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), "int", env.Model))
{
throw new SequenceParserException(Symbol, "int", KeyExpression.Type(env));
}
}
else if (ContainerType.StartsWith("deque"))
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), "int", env.Model))
{
throw new SequenceParserException(Symbol, "int", KeyExpression.Type(env));
}
}
else
{
if (!TypesHelper.IsSameOrSubtype(KeyExpression.Type(env), TypesHelper.ExtractSrc(ContainerType), env.Model))
{
throw new SequenceParserException(Symbol, TypesHelper.ExtractSrc(ContainerType), KeyExpression.Type(env));
}
}
}
private void CheckSubgraph(Invocation invocation)
{
SequenceVariable subgraph;
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
subgraph = ruleInvocation.Subgraph;
}
else
{
SequenceInvocation sequenceInvocation = (SequenceInvocation)invocation;
subgraph = sequenceInvocation.Subgraph;
}
if (subgraph != null && !TypesHelper.IsSameOrSubtype("graph", subgraph.Type, Model))
{
throw new SequenceParserException(invocation.Name, subgraph.Type, SequenceParserError.SubgraphTypeError);
}
}
private void CheckOutputParameters(Invocation invocation, SequenceVariable[] ReturnVars, GrGenType ownerType)
{
// Check whether number of parameters and return parameters match
if (ReturnVars.Length != 0 && NumOutputParameters(invocation, ownerType) != ReturnVars.Length)
{
throw new SequenceParserException(invocation, ReturnVars.Length, SequenceParserError.BadNumberOfReturnParameters);
}
// Check return types
for (int i = 0; i < ReturnVars.Length; ++i)
{
String argumentType = ReturnVars[i].Type;
String paramterType = OutputParameterType(i, invocation, ownerType);
if (!TypesHelper.IsSameOrSubtype(paramterType, argumentType, Model))
{
throw new SequenceParserException(invocation, -1, SequenceParserError.BadReturnParameter, i);
}
}
}
private void CheckInputParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, GrGenType ownerType)
{
// Check whether number of parameters and return parameters match
if (NumInputParameters(invocation, ownerType) != ArgumentExpressions.Length)
{
throw new SequenceParserException(invocation, ArgumentExpressions.Length, SequenceParserError.BadNumberOfParameters);
}
// Check parameter types
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
ArgumentExpressions[i].Check(this);
String argumentType = ArgumentExpressions[i].Type(this);
String paramterType = InputParameterType(i, invocation, ownerType);
if (!TypesHelper.IsSameOrSubtype(argumentType, paramterType, Model))
{
throw new SequenceParserException(invocation, -1, SequenceParserError.BadParameter, i);
}
}
}
/// <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);
}
}
}
