public override string TypeOfMemberOrAttribute(string matchOrGraphElementType, string memberOrAttribute) { if (matchOrGraphElementType.StartsWith("match<class ")) { MatchClassFilterer matchClass = actions.GetMatchClass(TypesHelper.GetMatchClassName(matchOrGraphElementType)); IPatternElement element = matchClass.info.GetPatternElement(memberOrAttribute); if (element == null) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember); } GrGenType elementType = element.Type; return(TypesHelper.DotNetTypeToXgrsType(elementType)); } else if (matchOrGraphElementType.StartsWith("match<")) { IAction action = actions.GetAction(TypesHelper.GetRuleName(matchOrGraphElementType)); IPatternElement element = action.RulePattern.PatternGraph.GetPatternElement(memberOrAttribute); if (element == null) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember); } GrGenType elementType = element.Type; return(TypesHelper.DotNetTypeToXgrsType(elementType)); } else { InheritanceType inheritanceType = TypesHelper.GetInheritanceType(matchOrGraphElementType, Model); AttributeType attributeType = inheritanceType.GetAttributeType(memberOrAttribute); if (attributeType == null) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownAttribute); } return(TypesHelper.AttributeTypeToXgrsType(attributeType)); } }
public override string Type(SequenceCheckingEnvironment env) { if (DestVar.Type == "") { return(""); } InheritanceType inheritanceType = TypesHelper.GetInheritanceType(DestVar.Type, env.Model); AttributeType attributeType = inheritanceType.GetAttributeType(AttributeName); if (attributeType == null) { return(""); // error, will be reported by Check, just ensure we don't crash here } string ContainerType = TypesHelper.AttributeTypeToXgrsType(attributeType); if (DestVar.Type.StartsWith("map")) { return(TypesHelper.ExtractDst(DestVar.Type) ?? ""); } else { return(TypesHelper.ExtractSrc(DestVar.Type) ?? ""); } }
/// <summary> /// Helper for checking function method calls. /// Checks whether called entity exists, and type checks the input. /// Throws an exception when an error is found. /// </summary> /// <param name="seqExprFuncMethodCall">The function method call to check</param> /// <param name="targetExpr">The target of the procedure function call</param> public void CheckFunctionMethodCall(SequenceExpression targetExpr, SequenceExpressionFunctionMethodCall seqExprFuncMethodCall) { String targetExprType = targetExpr.Type(this); if (targetExprType == "") { // only runtime checks possible (we could check whether the called procedure signature exists in at least one of the model types, if not it's a type error, can't work at runtime, but that kind of negative check is not worth the effort) return; } InheritanceType ownerType = TypesHelper.GetInheritanceType(targetExprType, Model); if (ownerType == null) { // error, must be node or edge type throw new SequenceParserException(targetExprType, SequenceParserError.UserMethodsOnlyAvailableForGraphElements); } // check whether called function method exists if (ownerType.GetFunctionMethod(seqExprFuncMethodCall.Name) == null) { throw new SequenceParserException(seqExprFuncMethodCall, -1, SequenceParserError.UnknownProcedure); } CheckFunctionCallBase(seqExprFuncMethodCall, ownerType); }
public override string TypeOfMemberOrAttribute(string matchOrGraphElementType, string memberOrAttribute) { if (matchOrGraphElementType.StartsWith("match<class ")) { String matchClassName = TypesHelper.GetMatchClassName(matchOrGraphElementType); IMatchClass matchClass = actionsTypeInformation.matchClasses[matchClassName]; IPatternElement element = matchClass.GetPatternElement(memberOrAttribute); if (element == null) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember); } GrGenType elementType = element.Type; return(TypesHelper.DotNetTypeToXgrsType(elementType)); } else if (matchOrGraphElementType.StartsWith("match<")) { String ruleName = TypesHelper.GetRuleName(matchOrGraphElementType); if (!actionsTypeInformation.rulesToTopLevelEntities[ruleName].Contains(memberOrAttribute)) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownMatchMember); } int indexOfEntity = actionsTypeInformation.rulesToTopLevelEntities[ruleName].IndexOf(memberOrAttribute); return(actionsTypeInformation.rulesToTopLevelEntityTypes[ruleName][indexOfEntity]); } else { InheritanceType inheritanceType = TypesHelper.GetInheritanceType(matchOrGraphElementType, Model); AttributeType attributeType = inheritanceType.GetAttributeType(memberOrAttribute); if (attributeType == null) { throw new SequenceParserException(memberOrAttribute, SequenceParserError.UnknownAttribute); } return(TypesHelper.AttributeTypeToXgrsType(attributeType)); } }
protected override int NumOutputParameters(Invocation invocation, InheritanceType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; return(actionsTypeInformation.rulesToOutputTypes[ruleInvocation.PackagePrefixedName].Count); } else if (invocation is SequenceInvocation) { SequenceInvocation seqInvocation = (SequenceInvocation)invocation; return(actionsTypeInformation.sequencesToOutputTypes[seqInvocation.PackagePrefixedName].Count); } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(procDef.Outputs.Length); } else { return(actionsTypeInformation.proceduresToOutputTypes[procInvocation.PackagePrefixedName].Count); } } throw new Exception("Internal error"); }
protected override string OutputParameterType(int i, Invocation invocation, InheritanceType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; return(actionsTypeInformation.rulesToOutputTypes[ruleInvocation.PackagePrefixedName][i]); } else if (invocation is SequenceInvocation) { SequenceInvocation seqInvocation = (SequenceInvocation)invocation; return(actionsTypeInformation.sequencesToOutputTypes[seqInvocation.PackagePrefixedName][i]); } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(procDef.Outputs[i])); } else { return(actionsTypeInformation.proceduresToOutputTypes[procInvocation.PackagePrefixedName][i]); } } throw new Exception("Internal error"); }
public override string Type(SequenceCheckingEnvironment env) { if (DestVar.Type == "") { return(""); } InheritanceType inheritanceType = TypesHelper.GetInheritanceType(DestVar.Type, env.Model); AttributeType attributeType = inheritanceType.GetAttributeType(AttributeName); return(TypesHelper.AttributeTypeToXgrsType(attributeType)); }
protected override string InputParameterType(int i, Invocation invocation, InheritanceType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; IAction action = SequenceBase.GetAction(ruleInvocation); return(TypesHelper.DotNetTypeToXgrsType(action.RulePattern.Inputs[i])); } else if (invocation is SequenceInvocation) { SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation; if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted) { SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef; return(seqDef.InputVariables[i].Type); } else { SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef; return(TypesHelper.DotNetTypeToXgrsType(seqDef.SeqInfo.ParameterTypes[i])); } } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i])); } else { SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation; return(TypesHelper.DotNetTypeToXgrsType(procInvocationInterpreted.ProcedureDef.Inputs[i])); } } else if (invocation is FunctionInvocation) { FunctionInvocation funcInvocation = (FunctionInvocation)invocation; if (ownerType != null) { IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name); return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i])); } else { SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation; return(TypesHelper.DotNetTypeToXgrsType(funcInvocationInterpreted.FunctionDef.Inputs[i])); } } throw new Exception("Internal error"); }
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)); } } }
/// <summary> /// Initializes an AttributeType instance. /// </summary> /// <param name="name">The name for the attribute.</param> /// <param name="ownerType">The owner model type.</param> /// <param name="kind">The kind of the attribute.</param> /// <param name="enumType">The enum type description, if Kind == AttributeKind.EnumAttr, otherwise null.</param> /// <param name="valueType">The attribute type of the value of the set, if Kind == AttributeKind.SetAttr; the attribute type of the value of the map, if Kind == AttributeKind.MapAttr; the attribute type of the value of the array, if Kind == AttributeKind.ArrayAttr; the attribute type of the value of the deque, if Kind == AttributeKind.DequeAttr; otherwise null. </param> /// <param name="keyType">The attribute type of the key of the map, if Kind == AttributeKind.MapAttr; otherwise null.</param> /// <param name="typeName">The name of the attribute type, if Kind == AttributeKind.NodeAttr || Kind == AttributeKind.EdgeAttr; otherwise null.</param> /// <param name="package">The package name if this is a node or edge type that is contained in a package, otherwise null.</param> /// <param name="packagePrefixedTypeName">The name of the attribute type with the package as prefix if it is contained in a package, if Kind == AttributeKind.NodeAttr || Kind == AttributeKind.EdgeAttr.</param> /// <param name="type">The type of the attribute type.</param> public AttributeType(String name, InheritanceType ownerType, AttributeKind kind, EnumAttributeType enumType, AttributeType valueType, AttributeType keyType, String typeName, String package, String packagePrefixedTypeName, Type type) { Name = name; OwnerType = ownerType; Kind = kind; EnumType = enumType; ValueType = valueType; KeyType = keyType; TypeName = typeName; Package = package; PackagePrefixedTypeName = packagePrefixedTypeName; Type = type; }
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); } }
protected override int NumOutputParameters(Invocation invocation, InheritanceType ownerType) { if (invocation is RuleInvocation) { RuleInvocation ruleInvocation = (RuleInvocation)invocation; IAction action = SequenceBase.GetAction(ruleInvocation); return(action.RulePattern.Outputs.Length); } else if (invocation is SequenceInvocation) { SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation; if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted) { SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef; return(seqDef.OutputVariables.Length); } else { SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef; return(seqDef.SeqInfo.OutParameterTypes.Length); } } else if (invocation is ProcedureInvocation) { ProcedureInvocation procInvocation = (ProcedureInvocation)invocation; if (ownerType != null) { IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name); return(procDef.Outputs.Length); } else { SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation; return(procInvocationInterpreted.ProcedureDef.Outputs.Length); } } throw new Exception("Internal error"); }
/// <summary> /// Helper for checking procedure calls. /// Type checks the input, type checks the output. /// Throws an exception when an error is found. /// </summary> /// <param name="seqCompProcCall">The procedure call to check</param> /// <param name="ownerType">Gives the owner type of the procedure method call, in case this is a method call, otherwise null</param> private void CheckProcedureCallBase(SequenceComputationProcedureCall seqCompProcCall, InheritanceType ownerType) { CheckInputParameters(seqCompProcCall, seqCompProcCall.ArgumentExpressions, ownerType); CheckOutputParameters(seqCompProcCall, seqCompProcCall.ReturnVars, ownerType); // ok, this is a well-formed invocation }
protected abstract string OutputParameterType(int i, Invocation invocation, InheritanceType ownerType);
protected abstract int NumOutputParameters(Invocation invocation, InheritanceType ownerType);
private void CheckOutputParameters(Invocation invocation, SequenceVariable[] ReturnVars, InheritanceType 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, InheritanceType 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> /// Helper for checking function calls. /// Type checks the input. /// Throws an exception when an error is found. /// </summary> /// <param name="seqExprFuncCall">The function call to check</param> /// <param name="ownerType">Gives the owner type of the function method call, in case this is a method call, otherwise null</param> private void CheckFunctionCallBase(SequenceExpressionFunctionCall seqExprFuncCall, InheritanceType ownerType) { CheckInputParameters(seqExprFuncCall, seqExprFuncCall.ArgumentExpressions, ownerType); // ok, this is a well-formed invocation }