internal SymbolicRegex <T> Transform <T>(SymbolicRegex <S> sr, SymbolicRegexBuilder <T> builderT, Func <S, T> predicateTransformer) { switch (sr.kind) { case SymbolicRegexKind.StartAnchor: return(builderT.startAnchor); case SymbolicRegexKind.EndAnchor: return(builderT.endAnchor); case SymbolicRegexKind.Epsilon: return(builderT.epsilon); case SymbolicRegexKind.Singleton: return(builderT.MkSingleton(predicateTransformer(sr.set))); case SymbolicRegexKind.Loop: return(builderT.MkLoop(Transform(sr.left, builderT, predicateTransformer), sr.lower, sr.upper)); case SymbolicRegexKind.Or: return(builderT.MkOr(sr.alts.Transform(builderT, predicateTransformer))); case SymbolicRegexKind.Concat: return(builderT.MkConcat(Transform(sr.left, builderT, predicateTransformer), Transform(sr.right, builderT, predicateTransformer))); default: //ITE return (builderT.MkIfThenElse(Transform(sr.IteCond, builderT, predicateTransformer), Transform(sr.left, builderT, predicateTransformer), Transform(sr.right, builderT, predicateTransformer))); } }
public SymbolicRegexSampler(SymbolicRegex <S> sr, int maxUnroll, int cornerCaseProb = 5, int maxSamplingIter = 3) { this.cornerCaseProb = cornerCaseProb; this.maxSamplingIter = maxSamplingIter; this.maxUnroll = maxUnroll; this.sr = sr; this.builder = sr.builder; rand = new Random(); }
//public SymbolicRegexBuilder<S> SRBuilder //{ // get // { // return srBuilder; // } //} /// <summary> /// Constructs a regex to symbolic finite automata converter /// </summary> /// <param name="solver">solver for character constraints</param> /// <param name="categorizer">maps unicode categories to corresponding character conditions</param> internal RegexToAutomatonConverter(ICharAlgebra <S> solver, IUnicodeCategoryTheory <S> categorizer = null) { this.solver = solver; this.categorizer = (categorizer == null ? new UnicodeCategoryTheory <S>(solver) : categorizer); description.Add(solver.True, "."); //"[]" does not unfortunately parse as a valid regex //description.Add(solver.False, "[0-[0]]"); description.Add(solver.False, "[]"); this.automBuilder = new RegexToAutomatonBuilder <RegexNode, S>(solver, ConvertNode); this.srBuilder = new SymbolicRegexBuilder <S>((ICharAlgebra <S>)solver); //this.converterHelper.Callback = (node, start, end) => ConvertNode(node, start, end); }
/// <summary> /// Copmiles a regex into a symbolic regex /// </summary> /// <param name="regex">given regex</param> /// <param name="css">given solver, if null a new one is created</param> /// <param name="simplify">if true then lower loop bounds are unwound (default is true)</param> /// <returns></returns> public static SymbolicRegex <BV> Compile(this Regex regex, CharSetSolver css = null, bool simplify = true) { if (css == null) { css = new CharSetSolver(); } var sr_bdd = css.RegexConverter.ConvertToSymbolicRegex(regex, true); BVAlgebra bva = new BVAlgebra(css, sr_bdd.ComputeMinterms()); SymbolicRegexBuilder <BV> builder = new SymbolicRegexBuilder <BV>(bva); var sr_bv = sr_bdd.builder.Transform <BV>(sr_bdd, builder, builder.solver.ConvertFromCharSet); if (simplify) { sr_bv = sr_bv.Simplify(); } sr_bv.InitializeMatcher(); return(sr_bv); }
///// <summary> ///// node is assumed to be in left-assoc form if it is a concatenation ///// </summary> //Sequence<CounterOperation> GetNullabilityCondition_of_left_assoc(SymbolicRegexNode<S> node) //{ // switch (node.kind) // { // case SymbolicRegexKind.StartAnchor: // case SymbolicRegexKind.EndAnchor: // case SymbolicRegexKind.Epsilon: // { // return Sequence<CounterOperation>.Empty; // } // case SymbolicRegexKind.Singleton: // { // return null; // } // case SymbolicRegexKind.Or: // { // if (node.isNullable) // return Sequence<CounterOperation>.Empty; // else // return null; // } // case SymbolicRegexKind.Loop: // { // if (node.isNullable) // return Sequence<CounterOperation>.Empty; // else if (IsCountingLoop(node)) // return new Sequence<CounterOperation>(new CounterOperation(node, CounterOp.EXIT)); // else // return null; // } // case SymbolicRegexKind.Concat: // { // var reset1 = GetNullabilityCondition_of_left_assoc(node.left); // if (reset1 == null) // return null; // else // { // //we know that right is not a concat // var reset2 = GetNullabilityCondition_of_left_assoc(node.right); // if (reset2 == null) // return null; // else // { // //TBD: this optimization needs to be verified // //if reset2 is nonempty it can only be a singleton // if (reset1.IsEmpty || reset2.IsEmpty || // reset1.TrueForAll(x => reset2[0].Counter.ContainsSubCounter(x.Counter))) // return reset1.Append(reset2); // else if (reset2[0].Counter.LowerBound == 0) // { // return reset1; // } // else // { // return null; // } // } // } // } // default: // { // throw new NotSupportedException("GetNullabilityCondition not supported for " + node.kind); // } // } //} internal SymbolicRegexNode <T> Transform <T>(SymbolicRegexNode <S> sr, SymbolicRegexBuilder <T> builderT, Func <S, T> predicateTransformer) { switch (sr.kind) { case SymbolicRegexKind.StartAnchor: return(builderT.startAnchor); case SymbolicRegexKind.EndAnchor: return(builderT.endAnchor); case SymbolicRegexKind.WatchDog: return(builderT.MkWatchDog(sr.lower)); case SymbolicRegexKind.Epsilon: return(builderT.epsilon); case SymbolicRegexKind.Singleton: return(builderT.MkSingleton(predicateTransformer(sr.set))); //case SymbolicRegexKind.Sequence: // return builderT.MkSequence(new Sequence<T>(Array.ConvertAll<S,T>(sr.sequence.ToArray(), x => predicateTransformer(x)))); case SymbolicRegexKind.Loop: return(builderT.MkLoop(Transform(sr.left, builderT, predicateTransformer), sr.isLazyLoop, sr.lower, sr.upper)); case SymbolicRegexKind.Or: return(builderT.MkOr(sr.alts.Transform(builderT, predicateTransformer))); case SymbolicRegexKind.And: return(builderT.MkAnd(sr.alts.Transform(builderT, predicateTransformer))); case SymbolicRegexKind.Concat: { var sr_elems = sr.ToArray(); var sr_elems_trasformed = Array.ConvertAll(sr_elems, x => Transform(x, builderT, predicateTransformer)); return(builderT.MkConcat(sr_elems_trasformed, false)); } default: //ITE return (builderT.MkIfThenElse(Transform(sr.IteCond, builderT, predicateTransformer), Transform(sr.left, builderT, predicateTransformer), Transform(sr.right, builderT, predicateTransformer))); } }
string GenerateRandomMember(SymbolicRegexBuilder <S> builder, SymbolicRegexNode <S> root) { // TODO: ITE, And: are currently not supported. string sample = ""; Stack <SymbolicRegexNode <S> > nodeQueue = new Stack <SymbolicRegexNode <S> >(); SymbolicRegexNode <S> curNode = null; nodeQueue.Push(UnrollRE(root)); while (nodeQueue.Count > 0 || curNode != null) { if (curNode == null) { curNode = nodeQueue.Pop(); } switch (curNode.Kind) { case SymbolicRegexKind.Singleton: if (!builder.solver.IsSatisfiable(curNode.Set)) { throw new AutomataException(AutomataExceptionKind.SetIsEmpty); } sample += builder.solver.ChooseUniformly(curNode.Set); curNode = null; break; case SymbolicRegexKind.Loop: curNode = curNode.Left; break; case SymbolicRegexKind.Epsilon: curNode = null; break; case SymbolicRegexKind.Concat: nodeQueue.Push(curNode.Right); curNode = curNode.Left; break; case SymbolicRegexKind.Or: int choice = rand.Next(curNode.OrCount); int i = 0; foreach (var elem in curNode.alts) { if (i == choice) { curNode = elem; break; } else { i += 1; } } break; case SymbolicRegexKind.EndAnchor: case SymbolicRegexKind.StartAnchor: case SymbolicRegexKind.WatchDog: curNode = null; break; default: throw new NotImplementedException(curNode.Kind.ToString()); } } return(sample); }
public CABA(SymbolicRegexBuilder <S> builder) { this.builder = builder; }
//public SymbolicRegexBuilder<S> SRBuilder //{ // get // { // return srBuilder; // } //} /// <summary> /// Constructs a regex to symbolic finite automata converter /// </summary> /// <param name="solver">solver for character constraints</param> /// <param name="categorizer">maps unicode categories to corresponding character conditions</param> public RegexToAutomatonConverter(ICharAlgebra <S> solver, IUnicodeCategoryTheory <S> categorizer = null) { this.solver = solver; this.categorizer = (categorizer == null ? new UnicodeCategoryTheory <S>(solver) : categorizer); this.srBuilder = new SymbolicRegexBuilder <S>((ICharAlgebra <S>)solver); }