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)); } } }
public string ExtractEdgeType(SourceBuilder source, SequenceExpression typeExpr) { string incidentEdgeType = "graph.Model.EdgeModel.RootType"; if (typeExpr != null) { if (typeExpr.Type(env) != "") { if (typeExpr.Type(env) == "string") { incidentEdgeType = "graph.Model.EdgeModel.GetType((string)" + exprGen.GetSequenceExpression(typeExpr, source) + ")"; } else { incidentEdgeType = "(GRGEN_LIBGR.EdgeType)" + exprGen.GetSequenceExpression(typeExpr, source); } } else { incidentEdgeType = exprGen.GetSequenceExpression(typeExpr, source) + " is string ? " + "graph.Model.EdgeModel.GetType((string)" + exprGen.GetSequenceExpression(typeExpr, source) + ")" + " : " + "(GRGEN_LIBGR.EdgeType)" + exprGen.GetSequenceExpression(typeExpr, source); } } return("(" + incidentEdgeType + ")"); }
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)); } } }
/// <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; } GrGenType ownerType = TypesHelper.GetNodeOrEdgeType(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); }
protected string GetTypeString(SequenceCheckingEnvironment env, SequenceExpression typeExpr) { if (typeExpr.Type(env) == "string") { if (typeExpr is SequenceExpressionConstant) { return((string)((SequenceExpressionConstant)typeExpr).Constant); } } else { return(typeExpr.Type(env)); } return(null); }
protected void CheckEdgeTypeIsKnown(SequenceCheckingEnvironment env, SequenceExpression typeExpr, String whichArgument) { if (typeExpr == null || typeExpr.Type(env) == "") { return; } string typeString = GetTypeString(env, typeExpr); if (TypesHelper.GetEdgeType(typeString, env.Model) == null && typeString != null) { throw new SequenceParserException(Symbol + whichArgument, "edge type or string denoting edge type", typeString); } }