public Term MkFindTerm(TermIndex index) { if (IsNull) { return(index.FalseValue); } else if (Binding.Symbol.IsReservedOperation) { //// In this case, do not create a find(...) term. return(Binding); } bool wasAdded; return(index.MkApply( index.SymbolTable.GetOpSymbol(ReservedOpKind.Find), new Term[] { Binding, Pattern, index.MkApply(index.TypeRelSymbol, new Term[] { Pattern, Type }, out wasAdded) }, out wasAdded)); }
/// <summary> /// Create a type term from this union. An optional renaming may be applied /// to its elements. /// </summary> internal Term MkTypeTerm(TermIndex index) { Contract.Assert(elements.Count > 0 || intervals.Count > 0); Term t = null; var tunSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.TypeUnn); var noArgs = new Term[0]; bool wasAdded; //// Step 1. Create an enum of all non-integral constants. foreach (var e in elements) { t = t == null?index.MkApply(e, noArgs, out wasAdded) : index.MkApply(tunSymb, new Term[] { index.MkApply(e, noArgs, out wasAdded), t }, out wasAdded); } //// Step 2. Create an enum of all integer intervals var rngSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.Range); Term beg, end; foreach (var kv in intervals.CanonicalForm) { beg = index.MkCnst(new Rational(kv.Key, BigInteger.One), out wasAdded); end = index.MkCnst(new Rational(kv.Value, BigInteger.One), out wasAdded); t = t == null?index.MkApply(rngSymb, new Term[] { beg, end }, out wasAdded) : index.MkApply(tunSymb, new Term[] { index.MkApply(rngSymb, new Term[] { beg, end }, out wasAdded), t }, out wasAdded); } return(t); }
public override CoreRule Clone(int ruleId, Predicate <Symbol> isCompr, TermIndex index, Map <Term, Term> bindingReificationCache, Map <UserSymbol, UserSymbol> symbolTransfer, string renaming) { Contract.Assert(isCompr == null && index != null && bindingReificationCache == null && string.IsNullOrEmpty(renaming)); bool wasAdded; var newHeadArgs = new Term[Head.Symbol.Arity]; var newHeadCon = symbolTransfer[(UserSymbol)Head.Symbol]; for (int i = 0; i < newHeadArgs.Length; ++i) { newHeadArgs[i] = index.MkVar(((UserSymbol)Head.Args[i].Symbol).Name, true, out wasAdded); } var newHead = index.MkApply(newHeadCon, newHeadArgs, out wasAdded); return(new CoreSubRule( ruleId, newHead, index.MkVar(((UserSymbol)Find1.Binding.Symbol).Name, true, out wasAdded), Matcher.Clone(index))); }
private Tuple <Term, Term> Expand_Fold( Node n, IEnumerable <Tuple <Term, Term> > args, Stack <Tuple <Namespace, Symbol> > symbStack, Map <UserCnstSymb, Term> valParamToValue, SuccessToken success, List <Flag> flags) { bool wasAdded; var space = symbStack.Peek().Item1; var symb = symbStack.Pop().Item2; if (symb == null) { return(null); } if (symb.IsNonVarConstant) { var cnst = symb as UserCnstSymb; if (cnst != null && cnst.IsSymbolicConstant) { var expDef = valParamToValue[cnst]; Contract.Assert(expDef != null); return(new Tuple <Term, Term>(expDef, index.MkDataWidenedType(expDef))); } else { var valTerm = index.MkApply(symb, TermIndex.EmptyArgs, out wasAdded); return(new Tuple <Term, Term>(valTerm, valTerm)); } } else if (symb.IsVariable) { var varTerm = index.MkApply(symb, TermIndex.EmptyArgs, out wasAdded); return(new Tuple <Term, Term>(varTerm, varTerm)); } else if (symb.IsDataConstructor) { var con = (UserSymbol)symb; var sort = symb.Kind == SymbolKind.ConSymb ? ((ConSymb)con).SortSymbol : ((MapSymb)con).SortSymbol; var i = 0; var vargs = new Term[con.Arity]; var typed = true; foreach (var a in args) { if (a == null) { //// If an arg is null, then it already has errors, //// so skip it an check the rest. typed = false; continue; } else if (a.Item2.Symbol.IsNonVarConstant) { if (!sort.DataSymbol.CanonicalForm[i].AcceptsConstant(a.Item2.Symbol)) { flags.Add(new Flag( SeverityKind.Error, n, Constants.BadArgType.ToString(i + 1, sort.DataSymbol.FullName), Constants.BadArgType.Code)); success.Failed(); typed = false; continue; } } else if (a.Item2.Symbol.Kind == SymbolKind.UserSortSymb) { if (!sort.DataSymbol.CanonicalForm[i].Contains(a.Item2.Symbol)) { flags.Add(new Flag( SeverityKind.Error, n, Constants.BadArgType.ToString(i + 1, sort.DataSymbol.FullName), Constants.BadArgType.Code)); success.Failed(); typed = false; continue; } } else if (!a.Item2.Symbol.IsVariable) { //// Only don't care variables are allowed, which always type check. throw new NotImplementedException(); } vargs[i] = a.Item1; ++i; } if (!typed) { success.Failed(); return(null); } return(new Tuple <Term, Term>( index.MkApply(con, vargs, out wasAdded), index.MkApply(sort, TermIndex.EmptyArgs, out wasAdded))); } else { throw new NotImplementedException(); } }
private static Term Parse(string t, int start, TermIndex index, out int end) { Contract.Requires(!string.IsNullOrEmpty(t) && start < t.Length); end = -1; bool wasAdded, result; var tstart = t[start]; while (char.IsWhiteSpace(tstart)) { ++start; tstart = t[start]; } if (tstart == '\"') { end = start; do { end = t.IndexOf('\"', end + 1); Contract.Assert(end >= 0); }while (t[end - 1] == '\\'); if (end == start + 1) { return(index.MkCnst(string.Empty, out wasAdded)); } else { return(index.MkCnst(t.Substring(start + 1, end - start - 1).Replace("\\\"", "\""), out wasAdded)); } } else if (char.IsDigit(tstart) || tstart == '+' || tstart == '-' || tstart == '.') { var end1 = t.IndexOf(',', start); var end2 = t.IndexOf(')', start); end = (end1 >= 0 && end2 >= 0) ? Math.Min(end1, end2) : Math.Max(end1, end2); Rational r; if (end < 0) { result = Rational.TryParseDecimal(t.Substring(start).Trim(), out r); Contract.Assert(result); end = t.Length - 1; } else { --end; result = Rational.TryParseDecimal(t.Substring(start, end - start + 1).Trim(), out r); Contract.Assert(result); } return(index.MkCnst(r, out wasAdded)); } else { Contract.Assert(char.IsLetter(tstart) || tstart == '_'); UserSymbol us, other; var end1 = t.IndexOf(',', start); var end2 = t.IndexOf(')', start); var end3 = t.IndexOf('(', start); end = (end1 >= 0 && end2 >= 0) ? Math.Min(end1, end2) : Math.Max(end1, end2); end = (end >= 0 && end3 >= 0) ? Math.Min(end, end3) : Math.Max(end, end3); if (end < 0) { us = index.SymbolTable.Resolve(t.Substring(start).Trim(), out other); Contract.Assert(us != null && other == null && us.Kind == SymbolKind.UserCnstSymb); end = t.Length - 1; return(index.MkApply(us, TermIndex.EmptyArgs, out wasAdded)); } else if (end == end1 || end == end2) { --end; us = index.SymbolTable.Resolve(t.Substring(start, end - start + 1).Trim(), out other); Contract.Assert(us != null && other == null && us.Kind == SymbolKind.UserCnstSymb); return(index.MkApply(us, TermIndex.EmptyArgs, out wasAdded)); } else { us = index.SymbolTable.Resolve(t.Substring(start, end - start).Trim(), out other); Contract.Assert(us != null && other == null && us.IsDataConstructor); var args = new Term[us.Arity]; for (int i = 0; i < us.Arity; ++i) { ++end; args[i] = Parse(t, end, index, out end); if (i < us.Arity - 1) { end = t.IndexOf(',', end + 1); } else { end = t.IndexOf(')', end + 1); } Contract.Assert(end >= 0); } return(index.MkApply(us, args, out wasAdded)); } } }
public SubtermMatcher(TermIndex index, bool onlyNewKinds, Term[] pattern) { Contract.Requires(pattern != null && pattern.Length > 0); //// Appears that Requires is triggering bug in Code Contracts 1.9.10714.2 Contract.Assert(index != null); this.pattern = pattern; IsMatchOnlyNewKinds = onlyNewKinds; matchingUnions = new AppFreeCanUnn[pattern.Length]; bool wasAdded; Term type, intr; Term levelTypes = null; IsSatisfiable = true; IsTriggerable = false; Stack <Term> pending = new Stack <Term>(); Set <Term> pendingOrVisited = new Set <Term>(Term.Compare); for (int i = pattern.Length - 1; i >= 0; --i) { if (!IsSatisfiable) { return; } if (i == pattern.Length - 1) { intr = pattern[pattern.Length - 1]; } else if (!index.MkIntersection(pattern[i], levelTypes, out intr)) { IsSatisfiable = false; return; } levelTypes = null; IsSatisfiable = false; pendingOrVisited.Clear(); foreach (var t in intr.Enumerate(x => x.Symbol == index.TypeUnionSymbol ? x.Args : null)) { if (t.Symbol == index.TypeUnionSymbol) { continue; } else if (IsPermitted(index, onlyNewKinds, t)) { IsSatisfiable = true; GetMatchingSet(i, t).Add(CanMatch); pending.Push(t); pendingOrVisited.Add(t); levelTypes = levelTypes == null ? t : index.MkApply(index.TypeUnionSymbol, new Term[] { t, levelTypes }, out wasAdded); if (i == 0 && (t.Symbol.Kind == SymbolKind.UserSortSymb || t.Symbol.IsDerivedConstant)) { IsTriggerable = true; } } } if (!IsSatisfiable) { return; } else { matchingUnions[i] = new AppFreeCanUnn(levelTypes); } while (pending.Count > 0) { type = pending.Pop(); foreach (var tup in index.GetTypeUses(type)) { if (tup.Item1.Kind == SymbolKind.ConSymb) { type = index.MkApply(((ConSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded); } else if (tup.Item1.Kind == SymbolKind.MapSymb) { type = index.MkApply(((MapSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded); } else { throw new NotImplementedException(); } if (IsPermitted(index, onlyNewKinds, type)) { GetMatchingSet(i, type).Add(tup.Item2); if (!pendingOrVisited.Contains(type)) { pending.Push(type); pendingOrVisited.Add(type); levelTypes = levelTypes == null ? type : index.MkApply(index.TypeUnionSymbol, new Term[] { type, levelTypes }, out wasAdded); if (i == 0 && (type.Symbol.Kind == SymbolKind.UserSortSymb || type.Symbol.IsDerivedConstant)) { IsTriggerable = true; } } } } } } if (IsTriggerable) { var level0 = matcher[0]; levelTypes = null; foreach (var kv in level0) { if (kv.Key.Symbol.Kind == SymbolKind.UserSortSymb || kv.Key.Symbol.IsDerivedConstant) { levelTypes = levelTypes == null ? kv.Key : index.MkApply(index.TypeUnionSymbol, new Term[] { kv.Key, levelTypes }, out wasAdded); } } Trigger = levelTypes; } }