private SetBigIntegerEvent(CtorType ctorType, int position, Int64 val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetIntegerEvent(CtorType ctorType, int position, int val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetCharacterEvent(CtorType ctorType, int position, char val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetBinaryEvent(CtorType ctorType, int position, byte[] val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetShortEvent(CtorType ctorType, int position, short val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetBooleanEvent(CtorType ctorType, int position, bool val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetDecimalEvent(CtorType ctorType, int position, decimal val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
public override CtorType VisitCtorType(CtorType node) { var argTypes = node.Arguments.Select(t => Translate(t)).ToList(); ReturnResult(IsaBoogieType.TConType(node.Decl.Name, argTypes, usedClosedConstructors)); return(node); }
private SetEnumEvent(CtorType ctorType, int position, Enum val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetSingleEvent(CtorType ctorType, int position, float val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private SetDoubleEvent(CtorType ctorType, int position, double val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
private Dictionary<string, Type> GetPermissionTypes() { var permissionTypes = new Dictionary<string, Type>(); foreach (var decl in program.TopLevelDeclarations.Where(decl => decl is TypeCtorDecl || decl is TypeSynonymDecl)) { foreach (var domainName in FindDomainNames(decl.Attributes)) { if (permissionTypes.ContainsKey(domainName)) { Error(decl, $"Duplicate permission type for domain {domainName}"); } else if (decl is TypeCtorDecl typeCtorDecl) { if (typeCtorDecl.Arity > 0) { Error(decl, "Permission type must be fully instantiated"); } else { permissionTypes[domainName] = new CtorType(Token.NoToken, typeCtorDecl, new List<Type>()); } } else { permissionTypes[domainName] = new TypeSynonymAnnotation(Token.NoToken, (TypeSynonymDecl) decl, new List<Type>()); } } } return permissionTypes; }
public void Arguments() { var tcDecl = new TypeCtorDecl(Token.NoToken, "fox", 1); var tc = new CtorType(Token.NoToken, tcDecl, new List <Microsoft.Boogie.Type>() { Microsoft.Boogie.Type.Bool }); var tcTypeIdent = new TypedIdent(Token.NoToken, "fox", tc); var gv = new GlobalVariable(Token.NoToken, tcTypeIdent); // FIXME: The Symbolic constructor shouldn't really need the program location gv.SetMetadata <ProgramLocation>((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(gv)); var sym = new SymbolicVariable("y", gv); var builder = new SimpleExprBuilder(/*immutable=*/ true); var eq = builder.Eq(sym.Expr, sym.Expr); Assert.IsNotInstanceOf <LiteralExpr>(eq); // Check that it wasn't constant folded using (var writer = new StringWriter()) { var printer = GetPrinter(writer); printer.AddDeclarations(eq); printer.PrintSortDeclarations(); Assert.AreEqual("(declare-sort @fox)\n", writer.ToString()); } }
private SetTimeEvent(CtorType ctorType, int position, DateTime val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
public override CtorType VisitCtorType(CtorType node) { insideContructedType++; base.VisitCtorType(node); insideContructedType--; return(node); }
private SetTimestampEvent(CtorType ctorType, int position, DateTime val, String name) { this.ctorType = ctorType; this.position = position; this.val = val; this.name = name; }
public override CtorType VisitCtorType(CtorType node) { //Contract.Requires(node != null); Contract.Ensures(Contract.Result <CtorType>() != null); // do /not/ clone the type recursively return((CtorType)node.Clone()); }
private SetParameterListEvent(CtorType ctorType, String name, ICollection valsColl, Object[] valsArr, IType type) { this.ctorType = ctorType; this.name = name; this.valsColl = valsColl; this.valsArr = valsArr; this.type = type; }
private SetParameterEvent(CtorType ctorType, int position, String name, object val, IType type) { this.ctorType = ctorType; this.position = position; this.val = val; this.type = type; this.name = name; }
private void RegisterType(Type type) { Contract.Requires(type != null); if (KnownTypes.Contains(type)) { return; } if (type.IsMap && CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.Monomorphic) { KnownTypes.Add(type); MapType mapType = type.AsMap; Contract.Assert(mapType != null); foreach (Type t in mapType.Arguments) { Contract.Assert(t != null); RegisterType(t); } RegisterType(mapType.Result); if (!CommandLineOptions.Clo.UseArrayTheory) { AddDeclaration("(declare-sort " + TypeToString(type) + " 0)"); } return; } if (type.IsBool || type.IsInt || type.IsReal || type.IsBv || type.IsFloat || type.IsRMode || type.IsString || type.IsRegEx) { return; } CtorType ctorType = type as CtorType; if (ctorType != null) { // Check if this is a built-in type. If so, no declaration is needed. string decl = ctorType.GetBuiltin(); if (decl != null) { KnownTypes.Add(type); return; } if (ctorType.IsDatatype()) { return; } } if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.Monomorphic) { AddDeclaration("(declare-sort " + TypeToString(type) + " 0)"); KnownTypes.Add(type); return; } }
public Sort BuildCtorType(CtorType ctorType) { Context z3 = ((Z3apiProverContext)container).z3; if (ctorType.Arguments.Count > 0) { throw new Exception("Type constructor of non-zero arity are not handled"); } return(z3.MkSort(ctorType.Decl.Name)); }
// the instantiations of inserted type variables, the order corresponds to the order in which "AbstractionVariable(int)" delivers variables private Type /*!*/ ThinOutType(Type rawType, List <TypeVariable> boundTypeParams, List <Type> instantiations) { if (rawType.FreeVariables.All(var => !boundTypeParams.Contains(var))) { // Bingo! // if the type does not contain any bound variables, we can simply // replace it with a type variable TypeVariable /*!*/ abstractionVar = AbstractionVariable(instantiations.Count); instantiations.Add(rawType); return(abstractionVar); } if (rawType.IsVariable) { // // then the variable has to be bound, we cannot do anything TypeVariable /*!*/ rawVar = rawType.AsVariable; return(rawVar); // } else if (rawType.IsMap) { // // recursively abstract this map type and continue abstracting CtorType /*!*/ abstraction = AbstractMapType(rawType.AsMap); return(ThinOutType(abstraction, boundTypeParams, instantiations)); // } else if (rawType.IsCtor) { // // traverse the subtypes CtorType /*!*/ rawCtorType = rawType.AsCtor; List <Type> /*!*/ newArguments = new List <Type>(); foreach (Type /*!*/ subtype in rawCtorType.Arguments.ToList()) { newArguments.Add(ThinOutType(subtype, boundTypeParams, instantiations)); } return(new CtorType(Token.NoToken, rawCtorType.Decl, newArguments)); // } else { System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + rawType); return(rawType); // compiler appeasement policy } }
public virtual CtorType VisitCtorType(CtorType node) { Contract.Requires(node != null); Contract.Ensures(Contract.Result <CtorType>() != null); lock (node) { for (int i = 0; i < node.Arguments.Count; ++i) { node.Arguments[i] = cce.NonNull((Type /*!*/)this.Visit(node.Arguments[i])); } } return(node); }
private Sort GetCtorType(CtorType ctorType) { if (!ctorTypes.ContainsKey(ctorType)) { Sort typeAst = BuildCtorType(ctorType); ctorTypes.Add(ctorType, typeAst); } Sort result; bool containsKey = ctorTypes.TryGetValue(ctorType, out result); Debug.Assert(containsKey); return(result); }
/// <summary> /// input type should be a map type or a constructor type that was generated for a map /// </summary> private MapType TranslateToMapType(Type type) { if (type.IsMap) { return(type.AsMap); } if (type.IsCtor) { CtorType ctorType = type.AsCtor; return(_mapAbstractionBuilder.RawType(ctorType.Decl)); } throw new cce.UnreachableException(); }
private void RegisterType(Type type) { Contract.Requires(type != null); if (KnownTypes.Contains(type)) { return; } if (type.IsMap && CommandLineOptions.Clo.MonomorphicArrays) { KnownTypes.Add(type); MapType mapType = type.AsMap; Contract.Assert(mapType != null); foreach (Type t in mapType.Arguments) { Contract.Assert(t != null); RegisterType(t); } RegisterType(mapType.Result); if (!CommandLineOptions.Clo.UseArrayTheory) { AddDeclaration("(declare-sort " + TypeToString(type) + " 0)"); } return; } if (type.IsBool || type.IsInt || type.IsReal || type.IsBv || type.IsFloat) { return; } CtorType ctorType = type as CtorType; if (ctorType != null && ctorType.IsDatatype()) { return; } if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.Monomorphic) { AddDeclaration("(declare-sort " + TypeToString(type) + " 0)"); KnownTypes.Add(type); return; } }
private Function SelectFun(MapType m, TypeCtorDecl ctorDecl) { var ctorTypeParams = m.FreeVariables.Select(tv => (Type)tv).ToList(); var ctorType = new CtorType(Token.NoToken, ctorDecl, ctorTypeParams); var valueTypes = new List <Type> { ctorType }; valueTypes.AddRange(m.Arguments); valueTypes.Add(m.Result); List <TypeVariable> typeParams = new List <TypeVariable> (m.TypeParameters); typeParams.AddRange(m.FreeVariables); return(HelperFuns.BoogieFunction("select_" + ctorDecl.Name, typeParams, valueTypes.ToArray())); }
public override CtorType VisitCtorType(CtorType node) { //TODO: checking for T by name does not work in general, fix this by parametrizing the class by the actual object if (node.Decl.Name.Equals("T") && !node.Arguments.Any()) { ReturnResult(typeTy); } else { //we don't support VC optimizations that monomorphize the VC if there are no polymorphic types for now //hence values of a type generated via a constructor are always represented by u ReturnResult(valueTy); } return(node); }
MapTypeClassRepresentation GetRepresentation(MapType rawType, out CtorType ctorType) { if (!rawToAbstractType.TryGetValue(rawType, out Tuple <MapType, CtorType> res)) { MapType abstraction = rawType; List <Type> instantiation = new List <Type>(); if (!useUniqueType(rawType)) { abstraction = ThinOutMapType(rawType, out instantiation); } var repr = GetClassRepresentation(abstraction, rawType); ctorType = new CtorType(Token.NoToken, repr.RepresentingType, instantiation); rawToAbstractType.Add(rawType, Tuple.Create(abstraction, ctorType)); return(repr); } ctorType = res.Item2; return(GetClassRepresentation(res.Item1, rawType)); }
public void MapWithTypeConstructorTypesNoArguments() { var tcDecl = new TypeCtorDecl(Token.NoToken, "fox", 0); var tc = new CtorType(Token.NoToken, tcDecl, new List <Microsoft.Boogie.Type>()); var tcDecl2 = new TypeCtorDecl(Token.NoToken, "fox_two", 0); var tc2 = new CtorType(Token.NoToken, tcDecl2, new List <Microsoft.Boogie.Type>()); var tcDecl3 = new TypeCtorDecl(Token.NoToken, "fox_three", 0); var tc3 = new CtorType(Token.NoToken, tcDecl3, new List <Microsoft.Boogie.Type>()); var mapType = new MapType( Token.NoToken, new List <Microsoft.Boogie.TypeVariable>(), new List <Microsoft.Boogie.Type>() { tc, tc2 }, tc3); var mapTypeTypeIdent = new TypedIdent(Token.NoToken, "mapx", mapType); var gv = new GlobalVariable(Token.NoToken, mapTypeTypeIdent); // FIXME: The Symbolic constructor shouldn't really need the program location gv.SetMetadata <ProgramLocation>((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(gv)); var sym = new SymbolicVariable("y", gv); var builder = new SimpleExprBuilder(/*immutable=*/ true); var eq = builder.Eq(sym.Expr, sym.Expr); Assert.IsNotInstanceOf <LiteralExpr>(eq); // Check that it wasn't constant folded using (var writer = new StringWriter()) { var printer = GetPrinter(writer); printer.AddDeclarations(eq); printer.PrintSortDeclarations(); var str = writer.ToString().Trim(); // Check we can see all the sort declarations we expect but don't depend on their order Assert.IsTrue(str.Contains("(declare-sort @fox)")); Assert.IsTrue(str.Contains("(declare-sort @fox_two)")); Assert.IsTrue(str.Contains("(declare-sort @fox_three)")); } }
protected void GenTypeAxiomParams(MapType/*!*/ abstractedType, TypeCtorDecl/*!*/ synonymDecl, out Type/*!*/ mapTypeSynonym, out List<TypeVariable/*!*/>/*!*/ typeParams, out List<Type/*!*/>/*!*/ originalIndexTypes) { Contract.Requires(abstractedType != null); Contract.Requires(synonymDecl != null); Contract.Ensures(Contract.ValueAtReturn(out mapTypeSynonym) != null); Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out typeParams))); Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out originalIndexTypes))); typeParams = new List<TypeVariable/*!*/>(); typeParams.AddRange(abstractedType.TypeParameters); typeParams.AddRange(abstractedType.FreeVariables); originalIndexTypes = new List<Type/*!*/>(abstractedType.Arguments.Count + 1); List<Type>/*!*/ mapTypeParams = new List<Type>(); foreach (TypeVariable/*!*/ var in abstractedType.FreeVariables) { Contract.Assert(var != null); mapTypeParams.Add(var); } if (CommandLineOptions.Clo.MonomorphicArrays) mapTypeSynonym = abstractedType; else mapTypeSynonym = new CtorType(Token.NoToken, synonymDecl, mapTypeParams); originalIndexTypes.Add(mapTypeSynonym); originalIndexTypes.AddRange(abstractedType.Arguments.ToList()); }
public override CtorType VisitCtorType(CtorType node) { add(node); return(base.VisitCtorType(node)); }
public override CtorType VisitCtorType(CtorType node) { //Contract.Requires(node != null); Contract.Ensures(Contract.Result<CtorType>() != null); // do /not/ clone the type recursively return (CtorType)node.Clone(); }
public virtual CtorType VisitCtorType(CtorType node) { Contract.Requires(node != null); Contract.Ensures(Contract.Result<CtorType>() != null); lock (node) { for (int i = 0; i < node.Arguments.Count; ++i) node.Arguments[i] = cce.NonNull((Type/*!*/)this.Visit(node.Arguments[i])); } return node; }
public override CtorType VisitCtorType(CtorType node) { Contract.Ensures(Contract.Result<CtorType>() == node); for (int i = 0; i < node.Arguments.Count; ++i) this.Visit(node.Arguments[i]); return node; }
public override CtorType VisitCtorType(CtorType node) { //instantiate T@U with the Boogie values means we do not need to transform the value ReturnResult(v => v); return(node); }