public bool TryInferPreconditions(APC pc, Postconditions postconditions) { Trace("Starting backwards postcondition propagation", postconditions); if (this.timeout.HasAlreadyTimeOut) { return(false); } try { this.timeout.Start(); FixpointComputation(pc, postconditions); return(this.invariants != null && this.invariants.Count != 0); } catch (TimeoutExceptionFixpointComputation) { return(false); } finally { this.timeout.Stop(); } }
/// <summary> /// Get the temporary directory path to store instance data. Sub-Directory will be appended /// if specified. /// </summary> /// <param name="subdir">Relative Sub-Directory</param> /// <returns>Temporary Folder path</returns> public string GetInstancePath(string subdir) { Postconditions.CheckCondition(Settings); Postconditions.CheckCondition(Header); lock (this) { string dir = String.Format("{0}{1}{2}{1}{3}{1}{4}", Header.ApplicationGroup, Path.PathSeparator, Header.Application, Header.Name, Header.Version.ToString()); if (!String.IsNullOrWhiteSpace(subdir)) { dir = String.Format("{0}{1}{2}", dir, Path.PathSeparator, subdir); } return(Settings.GetTempDirectory(dir)); } }
/// <summary> /// Load a configuration from local file. /// </summary> /// <param name="configName">Configuration name</param> /// <param name="configFile">Configuration File Path</param> /// <param name="version">Configuration Version (expected)</param> /// <param name="settings">Configuration Settings</param> /// <param name="password">Password (if required)</param> /// <returns>Loaded Configruation</returns> public Configuration Load(string configName, string configFile, Version version, ConfigurationSettings settings, string password = null) { Preconditions.CheckArgument(configName); Preconditions.CheckArgument(configFile); Preconditions.CheckArgument(version); LogUtils.Info(String.Format("Loading Configuration. [name={0}][version={1}][file={2}]", configName, version.ToString(), configFile)); using (FileReader reader = new FileReader(configFile)) { AbstractConfigParser parser = ConfigProviderFactory.GetParser(configFile); Postconditions.CheckCondition(parser); parser.Parse(configName, reader, version, settings, password); return(parser.GetConfiguration()); } }
private void FixpointComputation(APC entry, Postconditions initialState) { var todo = new List <Tuple <APC, Preconditions> >() { new Tuple <APC, Preconditions>(entry, initialState) }; var stable = new Set <APC>(); while (todo.Count != 0) { this.timeout.CheckTimeOut("backwards postcondition propagation"); var next = todo.ExtractFirst(); var nextPC = next.Item1; var nextState = next.Item2; var newPre = nextState; // do the block { APC pred; while (CFG.HasSinglePredecessor(nextPC, out pred) && !CFG.IsJoinPoint(nextPC)) { this.timeout.CheckTimeOut("backwards postcondition propagation (block)"); //var post = CFG.Predecessors(nextPC).First(); newPre = this.Mdriver.BackwardTransfer(nextPC, pred, newPre, this); // no pre, killing the path if (newPre == null) { break; } // TODO: check for contraddictions nextPC = pred; } } if (nextPC.Equals(CFG.EntryAfterRequires) || nextPC.Equals(CFG.Entry)) { this.invariants = newPre; continue; } var fixpointReached = false; if (CFG.IsJoinPoint(nextPC)) { Preconditions prev; if (this.joinPoints.TryGetValue(nextPC, out prev)) { newPre = Join(prev, newPre, CFG.IsForwardBackEdgeTarget(nextPC.Block.First), out fixpointReached); if (fixpointReached) { stable.Add(nextPC.Block.First); } } joinPoints[nextPC] = newPre; } // Split in the backwards analysis foreach (var pred in CFG.Predecessors(nextPC)) { if (fixpointReached && CFG.IsForwardBackEdge(pred, nextPC)) { continue; } if (this.Mdriver.IsUnreachable(nextPC)) { continue; } var transf = this.Mdriver.BackwardTransfer(nextPC, pred, newPre, this); if (transf != null) { todo.Add(new Tuple <APC, Preconditions>(pred, transf)); } } } }
public void AddPostcondition(string key, bool value) { Postconditions.Add(new KeyValuePair <string, bool>(key, value)); }