public void DisplayTree(SpecificationBase Spec)
{
try
{
Specification = Spec;
foreach (TreeNode node in TreeView_Model.Nodes)
{
node.Nodes.Clear();
}
if (Spec != null)
{
foreach (KeyValuePair<string, Declaration> pair in Spec.DeclaritionTable)
{
try
{
TreeNode node = this.TreeView_Model.Nodes[pair.Value.DeclarationType.ToString()].Nodes.Add(pair.Key);
node.Tag = pair.Value.DeclarationToken;
}
catch (Exception)
{
}
}
TreeView_Model.ExpandAll();
}
}
catch (Exception)
{
}
}
public override void Initialize(SpecificationBase spec)
{
//initialize the ModelCheckingOptions
base.Initialize(spec);
Specification Spec = spec as Specification;
ReachableStateCondition = Spec.DeclarationDatabase[ReachableStateLabel];
List<string> varList = Process.GetGlobalVariables();
varList.AddRange(ReachableStateCondition.GetVars());
varList.AddRange(ConstraintCondition.GetVars());
PNValuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels()) as PNValuation;
//Initialize InitialStep
InitialStep = new PNConfiguration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
if (MustAbstract)
{
throw new ParsingException(
"Process " + StartingProcess +
" has infinite states and therefore can not be used to assert reachability with MIN/MAX constraints!",
AssertToken);
}
}
public override void Initialize(SpecificationBase spec)
{
//initialize the ModelCheckingOptions
base.Initialize(spec);
Assertion.Initialize(this, Process, spec);
}
/// <summary>
/// Assertion Initialization to create the initial step based on the concrete types.
/// This method shall be invoked after the parsing immediately to instanciate the initial step
/// </summary>
/// <param name="spec">The concrete specification of the module</param>
public override void Initialize(SpecificationBase spec)
{
//initialize model checking options, the default option is for deadlock/reachablity algorithms
ModelCheckingOptions = new ModelCheckingOptions();
List<string> DeadlockEngine = new List<string>();
DeadlockEngine.Add(Constants.ENGINE_SMT_DTMC);
DeadlockEngine.Add(Constants.ENGINE_SMT_MDP);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, DeadlockEngine);
}
public static void Initialize(AssertionBase Assertion, PetriNet Process, SpecificationBase spec)
{
Specification Spec = spec as Specification;
//get the relevant global variables; remove irrelevant variables so as to save memory;
Valuation GlobalEnv = Spec.SpecValuation.GetClone();
//Initialize InitialStep
Assertion.InitialStep = new PNConfiguration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec);
}
/// <summary>
/// Assertion Initialization to create the initial step based on the concrete types.
/// This method shall be invoked after the parsing immediately to instanciate the initial step
/// </summary>
/// <param name="spec">The concrete specification of the module</param>
public virtual void Initialize(SpecificationBase spec)
{
//initialize model checking options, the default option is for deadlock/reachablity algorithms
ModelCheckingOptions = new ModelCheckingOptions();
List <string> DeadlockEngine = new List <string>();
DeadlockEngine.Add(Constants.ENGINE_DEPTH_FIRST_SEARCH);
DeadlockEngine.Add(Constants.ENGINE_BREADTH_FIRST_SEARCH);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, DeadlockEngine);
}
public static void Initialize(AssertionBase Assertion, DefinitionRef Process, SpecificationBase spec)
{
Specification Spec = spec as Specification;
//get the relevant global variables; remove irrelevant variables so as to save memory;
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(Process.GetGlobalVariables(), Process.GetChannels());
//Initialize InitialStep
Assertion.InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
Assertion.MustAbstract = Process.MustBeAbstracted();
}
public void startVerify()
{
if (this.LoadModule(this.ModuleName))
{
this.Specification = ParseSpecification();
this.SpecWorker = new SpecificationWorker(this.Specification);
this.SpecWorker.startVerification(this.SpecWorker.mSpec.AssertionDatabase.First().Key);
} else
{
System.Console.WriteLine("Error had occur!");
}
}
public virtual SpecificationBase ParseSpecification(string text, string options, string filePath)
{
if (Common.Classes.Ultility.Ultility.GrabSharedDataLock())
{
Specification = InstanciateSpecification(text, options, filePath);
return Specification;
}
else
{
MessageBox.Show(Resources.Please_stop_verification_or_simulation_before_parsing_the_model_, Common.Utility.Utilities.APPLICATION_NAME, MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
return null;
}
}
// added by Tinh
public PNConfiguration(PetriNet p, string e, string displayName, Valuation globalEnv, bool isDataOperation, SpecificationBase spec)
{
Process = p;
Event = e;//base event
GlobalEnv = globalEnv;
DisplayName = displayName;
IsDataOperation = isDataOperation;
if (spec != null)
{
p.Transitions = new List<PNTransition>(16);
foreach (KeyValuePair<string, PetriNet> entry in (spec as Specification).PNDefinitionDatabase)
p.Transitions.AddRange(entry.Value.Transitions);
}
}
public override void Initialize(SpecificationBase spec)
{
if (ConstraintType == QueryConstraintType.NONE)
{
base.Initialize(spec);
}
else
{
//initialize model checking options
ModelCheckingOptions = new ModelCheckingOptions();
List<string> LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_MDP_SEARCH);
LTLEngine.Add(Constants.ENGINE_MDP_ANTICHAIN_SEARCH);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, LTLEngine);
}
}
public void FillData(string name, List<ParsingException> usages, SpecificationBase Spec)
{
ListView.Enabled = true;
Term = name;
ListView.Items.Clear();
if (Spec.DeclaritionTable.ContainsKey(name))
{
ToolStripLabel_Usage.Text = "Usages of " + Spec.DeclaritionTable[name].DeclarationType.ToString() + " \"" + name + "\"";
ParsingException warning = Spec.DeclaritionTable[name].DeclarationToken;
string definition = "";
if(warning.ContainingDefinition != null)
{
definition = warning.ContainingDefinition.Text;
}
string[] data = new string[] { (ListView.Items.Count + 1).ToString(), "Declaration at " + warning.Line + " column " + warning.CharPositionInLine + " for '" + warning.Text + "'", warning.Source, definition, warning.DisplayFileName };
ListViewItem item = new ListViewItem(data);
item.Tag = warning;
ListView.Items.Add(item);
}
else
{
ToolStripLabel_Usage.Text = "Usages of \"" + name + "\"";
return;
}
foreach (ParsingException usage in usages)
{
if (usage.Line > 0)
{
string definition = "";
if (usage.ContainingDefinition != null)
{
definition = usage.ContainingDefinition.Text;
}
string[] data = new string[] { (ListView.Items.Count + 1).ToString(), "Usage found at " + usage.Line + " column " + usage.CharPositionInLine + " for '" + usage.Text + "'", usage.Source, definition, usage.DisplayFileName };
ListViewItem item = new ListViewItem(data);
item.Tag = usage;
ListView.Items.Add(item);
}
}
}
public override void Initialize(SpecificationBase spec)
{
Specification Spec = spec as Specification;
List<string> varList = Process.GetGlobalVariables();
BA.Initialize(Spec.DeclarationDatabase);
foreach (KeyValuePair<string, Expression> pair in BA.DeclarationDatabase)
varList.AddRange(pair.Value.GetVars());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels());
InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
base.Initialize(spec);
}
public override void Initialize(SpecificationBase spec)
{
//initialize the ModelCheckingOptions
base.Initialize(spec);
Specification Spec = spec as Specification;
ReachableStateCondition = Spec.DeclarationDatabase[ReachableStateLabel];
List<string> varList = Process.GetGlobalVariables();
varList.AddRange(ReachableStateCondition.GetVars());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels());
//Initialize InitialStep
InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
}
public ModelCheckingForm(string Name, SpecificationBase spec, PNExtendInfo extendInfo)
{
mSpecWorker = new SpecificationWorker(spec, this, this);
mExtendInfo = extendInfo;
InitializeComponent();
initPerformanceAnalytics();
initLogic();
mLatexWorker = new LatexWorker(extendInfo, Name);
if (Name != "")
{
#if DEBUG
Text = Text + " (Debug Model) - " + Name;
#else
this.Text = this.Text + " - " + Name;
#endif
}
}
public static void Initialize(AssertionRefinement Assertion, DefinitionRef ImplementationProcess, DefinitionRef SpecificationProcess, SpecificationBase spec)
{
Specification Spec = spec as Specification;
//get the relevant global variables; remove irrelevant variables so as to save memory;
List<string> varList = ImplementationProcess.GetGlobalVariables();
varList.AddRange(SpecificationProcess.GetGlobalVariables());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, ImplementationProcess.GetChannels());
//Initialize InitialStep
Assertion.InitialStep = new PNConfiguration(ImplementationProcess, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec);
Assertion.InitSpecStep = new PNConfiguration(SpecificationProcess, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec);
Assertion.MustAbstract = ImplementationProcess.MustBeAbstracted();
if (SpecificationProcess.MustBeAbstracted())
{
throw new ParsingException(
"Process " + Assertion.SpecProcess + " has infinite states and therefore can not be used as a property model for refinement checking!", Assertion.AssertToken);
}
}
public ExceptionDialog(Exception ex, string APPLICATION_NAME, SpecificationBase specification)
{
InitializeComponent();
spec = specification;
this.Text = APPLICATION_NAME + " " + this.Text;
ActionBox.Text = Resources.You_have_following_options_ + Environment.NewLine;
ActionBox.Text += Resources._1__Click_the_Email_button_to_report_the_error_to_us_ + Environment.NewLine;
ActionBox.Text += Resources._2__Click_the_Continue_button_to_ingore_the_error_ + Environment.NewLine;
ActionBox.Text += Resources._3__Click_the_Stop_button_to_exit_the_application_ + Environment.NewLine;
ActionBox.Text += Resources.At_same_time__you_can_submit_your_model_to_us_by_using_model_submit_button_in_the_PAT_editor_ + Environment.NewLine;
DetailBox.Text = ExceptionToString(ex);
string trace = "";
if (ex.Data.Contains("trace"))
{
trace = Environment.NewLine + "Trace leads to exception:" + Environment.NewLine + ex.Data["trace"].ToString();
}
ErrorBox.Text = ErrorBox.Text + APPLICATION_NAME + ". " + Environment.NewLine + ex.Message + trace;
}
/// <summary>
/// Assertion Initialization to create the initial step based on the concrete types.
/// This method shall be invoked after the parsing immediately to instanciate the initial step
/// </summary>
/// <param name="spec">The concrete specification of the module</param>
public override void Initialize(SpecificationBase spec)
{
//initialize model checking options
ModelCheckingOptions = new ModelCheckingOptions();
List<string> LTLEngine = new List<string>();
if(IsSafety)
{
LTLEngine.Add(Constants.ENGINE_DEPTH_FIRST_SEARCH);
LTLEngine.Add(Constants.ENGINE_BREADTH_FIRST_SEARCH);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, LTLEngine);
}
else
{
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_IMPROVED);
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, LTLEngine);
LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.BEHAVIOR_EVENT_LEVEL_WEAK_FAIRNESS, LTLEngine);
LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.BEHAVIOR_EVENT_LEVEL_STRONG_FAIRNESS, LTLEngine);
if (IsProcessLevelFairnessApplicable())
{
LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.BEHAVIOR_PROCESS_LEVEL_WEAK_FAIRNESS, LTLEngine);
LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.BEHAVIOR_PROCESS_LEVEL_STRONG_FAIRNESS, LTLEngine);
}
LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_SCC_BASED_SEARCH_MULTICORE);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.BEHAVIOR_GLOBAL_FAIRNESS, LTLEngine);
}
}
public override void Initialize(SpecificationBase spec)
{
ltl2ba.Node LTLHeadNode;
switch (ConstraintType)
{
case QueryConstraintType.PROB:
//create the DRA from the BA
LTLHeadNode = LTL2BA.ParseLTL("!(" + this.LTLString + ")", "", new CommonToken(0, ""));
NegativeDRA = BA2DRAConverter.ConvertBA2DRA(BA, LTLHeadNode);
NegativeDRA.DeclarationDatabase = BA.DeclarationDatabase;
//todo: builf the positve DRA too
//create the DRA from the BA
LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, ""));
PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode);
PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase;
break;
case QueryConstraintType.PMAX:
//create the DRA from the BA
LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, ""));
PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode);
PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase;
break;
case QueryConstraintType.PMIN:
//create the DRA from the BA
if(AlmostFair)//note add by ssz
{
LTLHeadNode = LTL2BA.ParseLTL(this.LTLString, "", new CommonToken(0, ""));
PositiveDRA = BA2DRAConverter.ConvertBA2DRA(PositiveBA, LTLHeadNode);
PositiveDRA.DeclarationDatabase = BA.DeclarationDatabase;
}
else
{
LTLHeadNode = LTL2BA.ParseLTL("!(" + this.LTLString + ")", "", new CommonToken(0, ""));
NegativeDRA = BA2DRAConverter.ConvertBA2DRA(BA, LTLHeadNode);
NegativeDRA.DeclarationDatabase = BA.DeclarationDatabase;
}
break;
}
if (ConstraintType == QueryConstraintType.NONE)
{
base.Initialize(spec);
}
else
{
//initialize model checking options
ModelCheckingOptions = new ModelCheckingOptions();
List<string> LTLEngine = new List<string>();
LTLEngine.Add(Constants.ENGINE_MDP_SEARCH);
#if DEBUG
LTLEngine.Add(Constants.ENGINE_MDP_MEC_SEARCH);
LTLEngine.Add(Constants.ENGINE_MDP_SIM_SEARCH);
#endif
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, LTLEngine);
}
}
/// <summary>
/// Assertion Initialization to create the initial step based on the concrete types.
/// This method shall be invoked after the parsing immediately to instanciate the initial step
/// </summary>
/// <param name="spec">The concrete specification of the module</param>
public override void Initialize(SpecificationBase spec)
{
//initialize model checking options, the default option is for deadlock/reachablity algorithms
ModelCheckingOptions = new ModelCheckingOptions();
List<string> engines = new List<string>();
engines.Add(Constants.ENGINE_FD_REFINEMENT_ANTICHAIN_DEPTH_FIRST_SEARCH);
engines.Add(Constants.ENGINE_FD_REFINEMENT_ANTICHAIN_BREADTH_FIRST_SEARCH);
engines.Add(Constants.ENGINE_FD_REFINEMENT_DEPTH_FIRST_SEARCH);
engines.Add(Constants.ENGINE_FD_REFINEMENT_BREADTH_FIRST_SEARCH);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, engines);
}
//IToken methodName, int size
public static Expression TestMethod(StaticMethodCall call, IToken ID1, Dictionary<string, ChannelQueue> ChannelDatabase, Dictionary<string, Expression> ConstantDatabase, SpecificationBase Spec)
{
if (ChannelDatabase != null)
{
switch (call.MethodName)
{
case Common.Classes.Ultility.Constants.cfull:
case Common.Classes.Ultility.Constants.cempty:
case Common.Classes.Ultility.Constants.ccount:
case Common.Classes.Ultility.Constants.csize:
case Common.Classes.Ultility.Constants.cpeek:
if (call.Arguments.Length != 1)
{
throw new ParsingException(call.MethodName + " can only take exactly one argument!", ID1);
}
string cname = call.Arguments[0].ToString();
if (!ChannelDatabase.ContainsKey(cname))
{
throw new ParsingException(cname + " is not a valid channel name!", ID1);
}
else if (ChannelDatabase[cname].Size == 0)
{
throw new ParsingException(call + " cannot invoke on a synchronous channel!", ID1);
}
return call;
}
foreach (Expression argument in call.Arguments)
{
if (ChannelDatabase.ContainsKey(argument.ToString()))
{
throw new ParsingException("Channel name " + argument.ToString() + " cannot be used in method call!", ID1);
}
}
}
string key = call.MethodName + call.Arguments.Length;
if (!Utilities.CSharpMethods.ContainsKey(key))
{
if (Spec == null || !Spec.MacroDefinition.ContainsKey(key))
{
throw new ParsingException(string.Format(Resources.Can_NOT_find_the_method__0__with__1__parameters_in_the_imported_C__libraries_, call.MethodName, call.Arguments.Length), ID1);
}
else
{
Dictionary<string, Expression> constMapping = new Dictionary<string, Expression>();
List<string> para = Spec.MacroDefinition[key].Key;
for (int i = 0; i < para.Count; i++)
{
constMapping.Add(para[i], call.Arguments[i]);
}
AddIntoUsageTable(Spec.UsageTable, call.MethodName, ID1); //+ "(" + Common.Classes.Ultility.Ultility.PPStringList(para) + ")"
return Spec.MacroDefinition[key].Value.ClearConstant(constMapping);
}
}
else
{
return call;
}
}
public void SetSpec(string name, string simulateProcess, SpecificationBase spec, AssertionBase assertion)
{
this.Spec = spec;
Assertion = assertion;
this.ComboBox_Process.Items.Clear();
this.ComboBox_Process.Items.Add(simulateProcess);
ComboBox_Process.SelectedIndexChanged -= ComboBox_Process_SelectedIndexChanged;
ComboBox_Process.SelectedIndex = 0;
ComboBox_Process.SelectedIndexChanged += ComboBox_Process_SelectedIndexChanged;
if (name != "")
{
this.Text = this.Text + " - " + name; // +PAT.CSP.Ultility.Ultility.GetVersionNumber();
}
DisplayCounterExample();
}
public SpecificationWorker(SpecificationBase spec, ISpecificationWorker listener, Form parentFrm)
{
mSpec = spec;
mListener = listener;
mForm = parentFrm;
// Setup timer
mTimer = new Timer();
mTimer.Tick += MCTimer_Tick;
mTimer.Interval = 1000;
}
public void SetSpec(string name, SpecificationBase spec)
{
this.Spec = spec;
this.ComboBox_Process.Items.Clear();
List<string> names = Spec.GetProcessNames();
foreach (string s in names)
{
this.ComboBox_Process.Items.Add(s);
}
if (ComboBox_Process.Items.Count > 0)
{
ComboBox_Process.SelectedIndex = 0;
}
if (name != "")
{
#if DEBUG
this.Text = this.Text + " (Debug Model) - " + name; // +PAT.CSP.Ultility.Ultility.GetVersionNumber();
#else
this.Text = this.Text + " - " + name;
// +PAT.CSP.Ultility.Ultility.GetVersionNumber();
#endif
}
}
/// <summary>
/// Assertion Initialization to create the initial step based on the concrete types.
/// This method shall be invoked after the parsing immediately to instanciate the initial step
/// </summary>
/// <param name="spec">The concrete specification of the module</param>
public virtual void Initialize(SpecificationBase spec)
{
//initialize model checking options, the default option is for deadlock/reachablity algorithms
ModelCheckingOptions = new ModelCheckingOptions();
List<string> DeadlockEngine = new List<string>();
DeadlockEngine.Add(Constants.ENGINE_DEPTH_FIRST_SEARCH);
DeadlockEngine.Add(Constants.ENGINE_BREADTH_FIRST_SEARCH);
ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, DeadlockEngine);
}
private void tabItem_FindUsages(string name, List<ParsingException> usages, SpecificationBase spec)
{
MenuButton_FindUsages.Checked = true;
try
{
int N;
foreach (ParsingException parsingException in usages)
{
N = DockContainer.Documents.Length;
for (int i = 0; i < N; i++)
{
EditorTabItem item = DockContainer.Documents[i] as EditorTabItem;
if (item == null)
continue;
if (item.FileName == parsingException.FileName
|| (!Common.Utility.Utilities.IsWindowsOS && item.FileName.EndsWith(parsingException.FileName)))
{
parsingException.Source = item.GetLineText(parsingException.Line - 1);
break;
}
}
}
ParsingException declarationToken = spec.DeclaritionTable[name].DeclarationToken;
N = DockContainer.Documents.Length;
for (int i = 0; i < N; i++)
{
EditorTabItem item = DockContainer.Documents[i] as EditorTabItem;
if (item == null)
continue;
if (item.FileName == declarationToken.FileName
|| (!Common.Utility.Utilities.IsWindowsOS && item.FileName.EndsWith(declarationToken.FileName)))
{
declarationToken.Source = item.GetLineText(declarationToken.Line - 1);
break;
}
}
}
catch (Exception) { }
FindUsagesWindow.FillData(name, usages, spec);
if (FindUsagesWindow.VisibleState == DockState.DockBottomAutoHide)
this.DockContainer.ActiveAutoHideContent = FindUsagesWindow;
}
public SpecificationWorker(SpecificationBase spec)
{
this.mSpec = spec;
}
//Exception Logging for the application
public static void LogException(Exception ex, SpecificationBase spec)
{
ExceptionDialog log = new ExceptionDialog(ex, APPLICATION_NAME, spec);
log.ShowDialog();
if (Common.Ultility.Ultility.IsWindowsOS)
{
FlashWindowEx(log);
}
}
public static void LoadIncludeModel(IToken libPath, SpecificationBase Spec)
{
//string s = libPath.Text;
try
{
string filePath = ParsingException.GetFileNameByLineNumber(libPath.Line);
//s += "\r\n1" + filePath;
if (filePath == null)
{
throw new ParsingException(string.Format("Cannot get the current file path"), libPath);
}
string dll = libPath.Text.Trim('"');
/**
* Notes: if the dll path is start with "..\",
* which means that get the file name from the super directory,
* we parse this syntax here and assign the dll directory the value
* of the current file's super directory
*/
string dllFileDirectory = Path.GetDirectoryName(filePath);
//s += "\r\n2" + dllFileDirectory;
if (Common.Utility.Utilities.IsWindowsOS)
{
if (dll.StartsWith("../"))
{
throw new ParsingException(
string.Format("Please use char '\\' instead of '/' in the include file path"),
libPath);
}
while (dll.StartsWith("..\\"))
{
dllFileDirectory = dllFileDirectory.Substring(0, dllFileDirectory.LastIndexOf('\\'));
dll = dll.Substring(dll.IndexOf('\\') + 1);
}
}
else
{
while (dll.StartsWith("../") || dll.StartsWith("..\\"))
{
dllFileDirectory = dllFileDirectory.Substring(0, dllFileDirectory.LastIndexOf('/'));
if (dll.Contains("\\"))
{
dll = dll.Substring(dll.IndexOf('\\') + 1);
}
else if (dll.Contains("/"))
{
dll = dll.Substring(dll.IndexOf('/') + 1);
}
}
}
//s += "\r\n3" ;
if (File.Exists(dll))
{
Spec.IncludeFiles.Add(Path.Combine(dllFileDirectory, dll));
}
else
{
string dlllocal = "";
if (!string.IsNullOrEmpty(filePath))
{
dlllocal = Path.Combine(dllFileDirectory, dll);
//s += "\r\n4" + dlllocal;
if (File.Exists(dlllocal))
{
Spec.IncludeFiles.Add(dlllocal);
return;
}
}
throw new ParsingException(string.Format("Cannot find the including file: {0}", dll), libPath);
}
}
catch (Exception ex)
{
//MessageBox.Show(s + "\r\n" + ex.Message + ex.StackTrace);
//throw new ParsingException(s + "\r\n" + ex.Message + ex.StackTrace, libPath);
throw new ParsingException(string.Format("Cannot find the including file: {0}", libPath.Text), libPath);
}
}
