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)); } }
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) ?? ""); } }
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)); } }
/// <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 Type(SequenceCheckingEnvironment env) { if (DestVar.Type == "") { return(""); } InheritanceType inheritanceType = TypesHelper.GetInheritanceType(DestVar.Type, env.Model); AttributeType attributeType = inheritanceType.GetAttributeType(AttributeName); return(TypesHelper.AttributeTypeToXgrsType(attributeType)); }
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)); } } }
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); } }