//New Entry, witch is called from the AddIn
public void load(string BPLFileName, string FunctionName, string PreludeFileName,
int randomSeed, bool randomSeedEnabled, string vcccmdswitches)
{
parameterConfiguration = new ParameterConfiguration();
parameterConfiguration.functionName = FunctionName;
parameterConfiguration.preludeBplFileInfo = new FileInfo(PreludeFileName);
parameterConfiguration.codeBplFileInfo = new FileInfo(BPLFileName);
parameterConfiguration.z3Options = getZ3Setting(randomSeed, randomSeedEnabled);
loadModelFromBoogie();
}
public ParameterConfiguration GetParameterConfiguration()
{
ParameterConfiguration config = ParameterConfiguration.loadParameterConfigurationFromSettings();
string allZ3Options = z3Options.Text;
config.z3InputFile = z3FilePath.Text;
if (rb_proofLogging.Checked)
{
allZ3Options += " PROOF_MODE=2 DISPLAY_PROOF=true";
}
config.z3Options = allZ3Options;
Int32.TryParse(z3Timeout.Text, out config.timeout);
return(config);
}
private void loadModel(ParameterConfiguration config, Loader.LoaderTask task)
{
try {
// Create a new loader and LoadingProgressForm and execute the loading
Loader loader = new Loader(config, task);
LoadingProgressForm lprogf = new LoadingProgressForm(loader);
lprogf.ShowDialog();
model = loader.GetModel();
loadTree();
} catch (Exception e) {
MessageBox.Show(String.Format("Cannot load model for current configuration:\n\n\"{0}\"", e));
return;
}
}
private void Z3AxiomProfiler_OnLoadEvent(object sender, EventArgs e)
{
if (!this.launchedFromAddin)
{
if (parameterConfiguration != null)
{
Loader.LoaderTask task = Loader.LoaderTask.LoaderTaskBoogie;
if ((parameterConfiguration.z3LogFile != null) &&
(parameterConfiguration.z3LogFile != ""))
{
task = Loader.LoaderTask.LoaderTaskParse;
}
loadModel(parameterConfiguration, task);
ParameterConfiguration.saveParameterConfigurationToSettings(parameterConfiguration);
}
}
}
static public ParameterConfiguration loadParameterConfigurationFromSettings()
{
ParameterConfiguration config = new ParameterConfiguration();
string preludeBplFile = Properties.Settings.Default.PreludeBplFile;
string codeBplFile = Properties.Settings.Default.CodeBplFile;
config.preludeBplFileInfo = (preludeBplFile.Length > 0) ? new FileInfo(preludeBplFile) : null;
config.codeBplFileInfo = (codeBplFile.Length > 0) ? new FileInfo(codeBplFile) : null;
config.boogieOptions = Properties.Settings.Default.BoogieOptions;
config.z3Options = Properties.Settings.Default.Z3Options;
config.functionName = Properties.Settings.Default.FunctionName;
config.timeout = Properties.Settings.Default.Timeout;
config.z3LogFile = Properties.Settings.Default.LogFile;
config.z3InputFile = Properties.Settings.Default.Z3InputFile;
return(config);
}
public Loader(ParameterConfiguration config, LoaderTask task)
{
List <FileInfo> filelist = null;
this.config = config;
this.task = task;
if (task == LoaderTask.LoaderTaskBoogie)
{
if ((config.preludeBplFileInfo == null) || (!config.preludeBplFileInfo.Exists))
{
throw new Exception("Cannot load VCC prelude file.");
}
if ((config.codeBplFileInfo == null) || (!config.codeBplFileInfo.Exists))
{
throw new Exception("Cannot load Boogie specification.");
}
filelist = new List <FileInfo> {
config.preludeBplFileInfo, config.codeBplFileInfo
};
}
else
{
filelist = new List <FileInfo>();
if (config.preludeBplFileInfo != null)
{
if (!config.preludeBplFileInfo.Exists)
{
throw new Exception("Cannot load VCC prelude file.");
}
filelist.Add(config.preludeBplFileInfo);
}
if (config.codeBplFileInfo != null)
{
if (!config.codeBplFileInfo.Exists)
{
throw new Exception("Cannot load Boogie specification.");
}
filelist.Add(config.codeBplFileInfo);
}
}
processor = new LogProcessor(filelist, config.skipDecisions, config.checkToConsider);
}
public void setParameterConfiguration(ParameterConfiguration config)
{
string allZ3Options = config.z3Options;
z3FilePath.Text = (config.z3InputFile == null) ? "" : config.z3InputFile;
z3Timeout.Text = config.timeout.ToString();
if (allZ3Options.Contains("PROOF_MODE=2") && allZ3Options.Contains("DISPLAY_PROOF=true"))
{
rb_proofLogging.Checked = true;
allZ3Options = allZ3Options.Replace("PROOF_MODE=2", "");
allZ3Options = allZ3Options.Replace("DISPLAY_PROOF=true", "");
allZ3Options = allZ3Options.Replace(" ", " ");
allZ3Options = allZ3Options.Trim();
}
else
{
rb_proofLogging.Checked = false;
}
z3Options.Text = allZ3Options;
}
static public bool saveParameterConfigurationToSettings(ParameterConfiguration config)
{
try
{
Properties.Settings.Default.PreludeBplFile = config.preludeBplFileInfo.FullName;
Properties.Settings.Default.CodeBplFile = config.codeBplFileInfo.FullName;
Properties.Settings.Default.BoogieOptions = config.boogieOptions;
Properties.Settings.Default.Z3Options = config.z3Options;
Properties.Settings.Default.FunctionName = config.functionName;
Properties.Settings.Default.Timeout = config.timeout;
Properties.Settings.Default.LogFile = config.z3LogFile;
Properties.Settings.Default.Z3InputFile = config.z3InputFile;
Properties.Settings.Default.Save();
return(true);
}
catch
{
return(false);
}
}
public void setParameterConfiguration(ParameterConfiguration config)
{
string allZ3Options = config.z3Options;
preludeFileTextBox.Text = (config.preludeBplFileInfo == null) ? "" : config.preludeBplFileInfo.FullName;
codeFileTextBox.Text = (config.codeBplFileInfo == null) ? "" : config.codeBplFileInfo.FullName;
boogieOptionTextBox.Text = config.boogieOptions;
functionTextBox.Text = config.functionName;
timeoutTextBox.Text = config.timeout.ToString();
if (allZ3Options.Contains("PROOF_MODE=2") && allZ3Options.Contains("DISPLAY_PROOF=true"))
{
rb_proofLogging.Checked = true;
allZ3Options = allZ3Options.Replace("PROOF_MODE=2", "");
allZ3Options = allZ3Options.Replace("DISPLAY_PROOF=true", "");
allZ3Options = allZ3Options.Replace(" ", " ");
allZ3Options = allZ3Options.Trim();
}
else
{
rb_proofLogging.Checked = false;
}
z3OptionsTextBox.Text = allZ3Options;
}
public ParameterConfiguration GetParameterConfiguration()
{
ParameterConfiguration config = ParameterConfiguration.loadParameterConfigurationFromSettings();
string allZ3Options = z3OptionsTextBox.Text;
if (File.Exists(preludeFileTextBox.Text))
{
config.preludeBplFileInfo = new FileInfo(preludeFileTextBox.Text);
}
if (File.Exists(codeFileTextBox.Text))
{
config.codeBplFileInfo = new FileInfo(codeFileTextBox.Text);
}
config.boogieOptions = boogieOptionTextBox.Text;
if (rb_proofLogging.Checked)
{
allZ3Options += " PROOF_MODE=2 DISPLAY_PROOF=true";
}
config.z3Options = allZ3Options;
config.functionName = functionTextBox.Text;
Int32.TryParse(timeoutTextBox.Text, out config.timeout);
config.z3LogFile = Path.ChangeExtension(config.codeBplFileInfo.FullName, "z3log");
return(config);
}
public void reloadParameterConfiguration()
{
ParameterConfiguration config = ParameterConfiguration.loadParameterConfigurationFromSettings();
setParameterConfiguration(config);
}
public bool parseCommandLineArguments(string[] args, out string error)
{
bool retval = false;
int idx;
ParameterConfiguration config = new ParameterConfiguration();
config.boogieOptions = "/bv:z /trace";
config.z3Options = "/rs:0";
error = "";
for (idx = 0; idx < args.Length; idx++)
{
args[idx] = stripCygdrive(args[idx]);
if (args[idx].StartsWith("-"))
{
args[idx] = "/" + args[idx].Substring(1);
}
if (args[idx].StartsWith("/"))
{
// parse command line parameter switches
if (args[idx].StartsWith("/f:"))
{
config.functionName = args[idx].Substring(3);
}
else if (args[idx].StartsWith("/l:"))
{
config.z3LogFile = args[idx].Substring(3);
// minimum requirements have been fulfilled.
retval = true;
}
else if (args[idx].StartsWith("/t:"))
{
uint timeout;
if (!UInt32.TryParse(args[idx].Substring(3), out timeout))
{
error = String.Format("Cannot parse timeout duration \"{0}\"", args[idx].Substring(3));
return(false);
}
config.timeout = (int)timeout;
}
else if (args[idx].StartsWith("/c:"))
{
uint ch;
if (!UInt32.TryParse(args[idx].Substring(3), out ch))
{
error = String.Format("Cannot parse check number \"{0}\"", args[idx].Substring(3));
return(false);
}
config.checkToConsider = (int)ch;
}
else if (args[idx] == "/v2")
{
// Silently accept old command line argument
}
else if (args[idx] == "/v1")
{
error = String.Format("Z3 version 1 is no longer supported.");
return(false);
}
else if (args[idx] == "/s")
{
config.skipDecisions = true;
}
else
{
error = String.Format("Unknown command line argument \"{0}\".", args[idx]);
return(false);
}
}
else
{
bool isLogFile = false;
try {
using (var s = File.OpenText(args[idx])) {
var l = s.ReadLine();
if (l.StartsWith("[mk-app]") || l.StartsWith("Z3 error model") || l.StartsWith("partitions:") || l.StartsWith("*** MODEL"))
{
isLogFile = true;
}
}
} catch (Exception) {
}
if (isLogFile)
{
config.z3LogFile = args[idx];
retval = true;
}
else if (config.preludeBplFileInfo == null)
{
config.preludeBplFileInfo = new FileInfo(args[idx]);
}
else if (config.codeBplFileInfo == null)
{
config.codeBplFileInfo = new FileInfo(args[idx]);
// minimum requirements have been fulfilled.
retval = true;
}
else
{
error = "Multiple inputs files specified.";
return(false);
}
}
}
if (retval)
{
parameterConfiguration = config;
}
return(true);
}
public void setParameterConfiguration(ParameterConfiguration config)
{
logFilePath.Text = (config.z3LogFile == null) ? "" : config.z3LogFile;
}
