public static void checkForRuleFile(ruleSet rs, List <string> ruleFiles, string str) { if (!str.EndsWith(".cs")) { str += ".cs"; } if (ruleFiles.Contains(str)) { SearchIO.output(rs.name + " already contains a reference to code file, " + str + "."); } else if (!File.Exists(rs.rulesDir + str)) { var result = MessageBox.Show("Source File " + rs.rulesDir + str + " not found. Would you like to create it?", "File not found.", MessageBoxButton.YesNo, MessageBoxImage.Question); if (result == MessageBoxResult.Yes) { createRulesSourceFile(rs.rulesDir + str); ruleFiles.Add(str); } } else { SearchIO.output("Code file, " + str + " found: Adding file reference to ruleset."); ruleFiles.Add(str); } }
internal void Update(ruleSet RuleSet, ruleSetWindow rsW) { SelectedRuleSet = RuleSet; txtName.Text = rsW.Title; for (int i = 0; i < GSApp.settings.rulesets.GetLength(0); i++) { if (SelectedRuleSet.Equals(GSApp.settings.rulesets[i])) { txtName.Text += " (set to RuleSet #" + i + ")"; break; } } txtTriggerRuleNo.Text = SelectedRuleSet.TriggerRuleNum.ToString(); cmdChoiceMethod.SelectedIndex = cmdChoiceMethod.Items.IndexOf(SelectedRuleSet.choiceMethod); cmdInterimCandidates.SelectedIndex = cmdInterimCandidates.Items.IndexOf(SelectedRuleSet.interimCandidates); cmdFinalCandidates.SelectedIndex = cmdFinalCandidates.Items.IndexOf(SelectedRuleSet.finalCandidates); cmdAfterNormalCycle.SelectedIndex = cmdAfterNormalCycle.Items.IndexOf(SelectedRuleSet.generationAfterNormal); cmdChoiceSendsStop.SelectedIndex = cmdChoiceSendsStop.Items.IndexOf(SelectedRuleSet.generationAfterChoice); cmdNoOfCallsReached.SelectedIndex = cmdNoOfCallsReached.Items.IndexOf(SelectedRuleSet.generationAfterCycleLimit); cmdNoRulesRecognized.SelectedIndex = cmdNoRulesRecognized.Items.IndexOf(SelectedRuleSet.generationAfterNoRules); cmdTriggerRuleInvoked.SelectedIndex = cmdTriggerRuleInvoked.Items.IndexOf(SelectedRuleSet.generationAfterTriggerRule); txtRecognizeSourceFiles.Text = StringCollectionConverter.Convert(SelectedRuleSet.recognizeSourceFiles); txtApplySourceFiles.Text = StringCollectionConverter.Convert(SelectedRuleSet.applySourceFiles); }
/// <summary> /// Loads the default seed and rule sets. /// </summary> public void LoadDefaultSeedAndRuleSets() { try { rulesets = new ruleSet[numOfRuleSets]; SearchIO.output("There are " + numOfRuleSets + " rulesets."); var filename = getOpenFilename(InputDirAbs, DefaultSeedFileName); if (filename != "") { var graphAndCanvas = filer.Open(filename, true); if (graphAndCanvas == null) { seed = null; DefaultSeedFileName = ""; SearchIO.MessageBoxShow("The seed graph was not found. Please change to valid file" + " in settings.", "Seed Graph Not Found.", "Error"); } else { seed = (designGraph)graphAndCanvas[0]; DefaultSeedFileName = filename; SearchIO.addAndShowGraphWindow(graphAndCanvas, "SEED: " + Path.GetFileNameWithoutExtension(filename)); SearchIO.output("Seed graph, " + Path.GetFileNameWithoutExtension(filename) + " ,successfully opened."); } } for (var i = 0; i < numOfRuleSets; i++) { var RSFileName = ""; if (i < defaultRSFileNames.Count) { RSFileName = defaultRSFileNames[i]; } filename = getOpenFilename(RulesDirAbs, RSFileName); if (filename == "") { continue; } object objRS = filer.Open(filename, true); if (objRS == null) { rulesets[i] = null; defaultRSFileNames[i] = ""; SearchIO.output("No Rule Set found at #" + i + "."); } else { rulesets[i] = (ruleSet)((object[])objRS)[0]; SearchIO.addAndShowRuleSetWindow(new object[] { rulesets[i], filename }, "RS" + i + ": " + Path.GetFileNameWithoutExtension(filename)); // SearchIO.output("Rule Set #" + i + " sucessfully opened."); } } } catch (Exception exc) { ErrorLogger.Catch(exc); } }
public ruleSetDisplay(ruleSet rules, string formTitle) { this.MdiParent = Program.main; InitializeComponent(); ruleset = rules; this.Text = formTitle; rules.initPropertiesBag(); this.propertyGrid1.SelectedObject = rules.Bag; this.GotFocus += new EventHandler(ruleSetDisplay_Enter); this.Enter += new EventHandler(ruleSetDisplay_Enter); }
public void addAndShowRuleSetWindow(object obj, string title = null) { var rs = new ruleSet(); string filename = null; if (obj == null) { rs = null; } else if (obj is ruleSet) { rs = (ruleSet)obj; } else if (obj is object[]) { var objArray = (object[])obj; if (objArray.GetLength(0) > 0) { if (objArray[0] is ruleSet) { rs = (ruleSet)objArray[0]; } else if (objArray[0] is string) { filename = (string)objArray[0]; } } if (objArray.GetLength(0) > 1) { if (objArray[1] is ruleSet) { rs = (ruleSet)objArray[1]; } else if (objArray[1] is string) { filename = (string)objArray[1]; } } } if (title == null) { title = rs.name; } if (!windowsMgr.FindAndFocusFileInCollection(filename, WindowType.RuleSet)) { var rSW = new ruleSetWindow(rs, filename, title); windowsMgr.AddandShowWindow(rSW); } }
/// <summary> /// Runs the search process. /// </summary> public void RunSearchProcess() { if ((numOfRuleSets > 0) && (RequiredNumRuleSets > 0)) { rulesets = new ruleSet[settings.numOfRuleSets]; for (var i = 0; i < settings.numOfRuleSets; i++) { rulesets[i] = settings.rulesets[i]; } ruleSet.loadAndCompileSourceFiles(rulesets, settings.RecompileRuleConditions, settings.CompiledRuleFunctions, GlobalSettings.ExecDir); } Run(); rulesets = null; }
/// <summary> /// Opens the rule set. /// </summary> /// <param name = "filename">The filename.</param> /// <returns></returns> public virtual ruleSet OpenRuleSet(string filename) { ruleSet newRuleSet = null; StreamReader ruleReader = null; try { ruleReader = new StreamReader(filename); var ruleDeserializer = new XmlSerializer(typeof(ruleSet)); newRuleSet = (ruleSet)ruleDeserializer.Deserialize(ruleReader); newRuleSet.rulesDir = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar; newRuleSet.filer = this; var numRules = newRuleSet.ruleFileNames.Count; int numLoaded; newRuleSet.rules = LoadRulesFromFileNames(newRuleSet.rulesDir, newRuleSet.ruleFileNames, out numLoaded); SearchIO.output(Path.GetFileName(filename) + " successfully loaded"); if (numRules == numLoaded) { SearchIO.output(" and all (" + numLoaded + ") rules loaded successfully."); } else { SearchIO.output(" but " + (numRules - numLoaded) + " rules did not load."); } if ((string.IsNullOrWhiteSpace(newRuleSet.name)) || (newRuleSet.name == "Untitled")) { newRuleSet.name = Path.GetFileNameWithoutExtension(filename); } } catch (Exception ioe) { SearchIO.output("***XML Serialization Error***"); SearchIO.output(ioe.ToString()); } finally { if (ruleReader != null) { ruleReader.Close(); } } return(newRuleSet); }
/// <summary> /// Reloads the specific rule. /// </summary> /// <param name = "rs">The rs.</param> /// <param name = "i">The i.</param> public virtual void ReloadSpecificRule(ruleSet rs, int i) { var rulePath = rs.rulesDir + rs.ruleFileNames[i]; SearchIO.output("Loading " + rs.ruleFileNames[i]); object ruleObj = Open(rulePath); if (ruleObj is grammarRule) { rs.rules[i] = (grammarRule)ruleObj; } else if (ruleObj is object[] && ((object[])ruleObj)[0] is grammarRule) { rs.rules[i] = ((grammarRule)((object[])ruleObj)[0]); } }
public override void ReloadSpecificRule(ruleSet rs, int i) { lock (fileTransfer) { dispatch.Invoke((ThreadStart) delegate { var rulePath = rs.rulesDir + rs.ruleFileNames[i]; SearchIO.output("Loading " + rs.ruleFileNames[i]); object ruleObj = Open(rulePath); if (ruleObj is grammarRule) { rs.rules[i] = (grammarRule)ruleObj; } else if (ruleObj is object[] && ((object[])ruleObj)[0] is grammarRule) { rs.rules[i] = ((grammarRule)((object[])ruleObj)[0]); } }); } }
public ruleSetWindow(ruleSet rs, string filename, string title) { try { /* the following is common to all GS window types. */ InitializeComponent(); Owner = main; ShowInTaskbar = false; foreach (CommandBinding cb in main.CommandBindings) { CommandBindings.Add(cb); } foreach (InputBinding ib in main.InputBindings) { InputBindings.Add(ib); } /***************************************************/ this.Ruleset = rs; this.Filename = !string.IsNullOrEmpty(filename) ? filename : "Untitled"; Title = !string.IsNullOrEmpty(title) ? title : Path.GetFileNameWithoutExtension(this.Filename); listBoxOfRules.Items.Clear(); for (var i = 1; i <= rs.rules.Count; i++) { var li = new ListBoxItem { Content = i + ". " + rs.ruleFileNames[(i - 1)] }; listBoxOfRules.Items.Add(li); } initializeFileWatcher(rs.rulesDir); } catch (Exception exc) { ErrorLogger.Catch(exc); } }
/// <summary> /// Saves the rule set. /// </summary> /// <param name = "filename">The filename.</param> /// <param name = "ruleSetToSave">The rule set to save.</param> protected void SaveRuleSet(string filename, ruleSet ruleSetToSave) { StreamWriter ruleWriter = null; try { //ruleSetToSave.name = Path.GetFileNameWithoutExtension(filename); ruleWriter = new StreamWriter(filename); var ruleSerializer = new XmlSerializer(typeof(ruleSet)); ruleSerializer.Serialize(ruleWriter, ruleSetToSave); } catch (Exception ioe) { SearchIO.output("***XML Serialization Error***"); SearchIO.output(ioe.ToString()); } finally { if (ruleWriter != null) { ruleWriter.Close(); } } }
public static void Run(designGraph seed, grammarRule rule, Relaxation RelaxationTemplate = null) { try { if (RelaxationTemplate == null) { RelaxationTemplate = new Relaxation(0); } var rnd = new Random(); int k = 0; var continueTesting = true; SearchIO.output("begin recognizing rule: " + rule.name + "on graph :" + seed.name, 2); var dummyRS = new ruleSet(); dummyRS.Add(rule); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var options = dummyRS.recognize(seed, false, RelaxationTemplate.copy()); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var numOptions = options.Count; if (numOptions == 0) { if (MessageBox.Show("There were no recognized options. Should the rule be relaxed?", "Test Rule Status", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes) { Run(seed, rule, new Relaxation(RelaxationTemplate.NumberAllowable + 1)); } return; } do { var status = "There "; int choice = -1; switch (numOptions) { case 0: throw new Exception("Should not be able to reach here. (Test Rule Chooser, zero options.)"); case 1: status += "was only one recognized option and it applied as shown.\n"; choice = 0; status += options[choice].Relaxations.RelaxationSummary; break; default: status += "were " + numOptions + " recognized locations.\n"; choice = rnd.Next(options.Count); status += options[choice].Relaxations.RelaxationSummary; option.AssignOptionConfluence(options, new candidate(seed, 0), ConfluenceAnalysis.Full); var numberWithConfluence = options.Count(o => (o.confluence.Count > 0)); var maxConfluence = options.Max(o => o.confluence.Count); var withMaxConfluence = options.Count(o => (o.confluence.Count == maxConfluence)); if (numberWithConfluence > 0) { status += "Confluence existed between " + numberWithConfluence + " of them"; if (maxConfluence > 1) { status += "; \nwith " + withMaxConfluence + " options having a confluence with " + maxConfluence + " other options.\n"; } else { status += ".\n"; } } status += "Option #" + choice + " was randomly chosen, and invoked.\n"; break; } if (!continueTesting) { continue; } if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var chosenOption = options[choice]; { var seedCopy = seed.copy(); SearchProcess.transferLmappingToChild(seedCopy, seed, chosenOption); seed = seedCopy; } chosenOption.apply(seed, null); SearchIO.output("Rule sucessfully applied", 4); SearchIO.addAndShowGraphWindow(seed, "After calling " + ++k + " rules"); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } options = dummyRS.recognize(seed, true, RelaxationTemplate.copy()); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } numOptions = options.Count; switch (numOptions) { case 0: status += "There are no recognized locations on the new graph"; continueTesting = false; MessageBox.Show(status, "Test Rule Status", MessageBoxButton.OK, MessageBoxImage.Asterisk); break; case 1: status += "There is one recognized location on the new graph. Would you like to invoke it?"; continueTesting = (MessageBox.Show(status, "Continue Applying?", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes); break; default: status += "There are " + options.Count + " recognized locations on the new graph. Would you " + "like to randomly invoke one?"; continueTesting = (MessageBox.Show(status, "Continue Applying?", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes); break; } } while (continueTesting); } catch (Exception exc) { ErrorLogger.Catch(exc); } }
private void openToolStripMenuItem_Click(object sender, EventArgs e) { string filename; try { filename = getOpenFilename(Program.settings.workingDirectory); } catch { filename = ""; } if (filename != "" && filename != null) { /* Load the file. */ XmlDocument doc = new XmlDocument(); doc.Load(filename); /* create prefix<->namespace mappings (if any) */ XmlNamespaceManager nsMgr = new XmlNamespaceManager(doc.NameTable); /* Query the document */ if (doc.SelectNodes("/grammarRule", nsMgr).Count > 0) { grammarRule rule = grammarRule.openRuleFromXml(filename); grammarDisplays.Add(new grammarRuleDisplay(rule, Path.GetFileName(filename))); grammarDisplays[grammarChildCount].Show(); } else if (doc.SelectNodes("/ruleSet", nsMgr).Count > 0) { ruleSet rs = ruleSet.openRuleSetFromXml(filename, Program.settings.defaultGenSteps); ruleSetDisplays.Add(new ruleSetDisplay(rs, Path.GetFileName(filename))); ruleSetDisplays[ruleSetChildCount].Show(); } else if (doc.SelectNodes("/designGraph", nsMgr).Count > 0) { designGraph graph = designGraph.openGraphFromXml(filename); addAndShowGraphDisplay(graph, Path.GetFileName(filename)); } else if (doc.SelectNodes("/candidate", nsMgr).Count > 0) { string tempString = ""; candidate c = candidate.openCandidateFromXml(filename); SearchIO.output("The candidate found in " + filename, 0); if (c.performanceParams.Count > 0) { tempString = "has the following performance parameters"; foreach (double a in c.performanceParams) { tempString += ": " + a.ToString(); } SearchIO.output(tempString, 0); } if (c.age > 0) { SearchIO.output("The candidate has existed for " + c.age.ToString() + " iterations.", 0); } SearchIO.output("It's generation ended in RuleSet #" + c.activeRuleSetIndex.ToString(), 0); tempString = "Generation terminated with"; foreach (GenerationStatuses a in c.GenerationStatus) { tempString += ": " + a.ToString(); } SearchIO.output(tempString, 0); addAndShowGraphDisplay(c.graph, "Candidate in " + Path.GetFileName(filename)); } else { MessageBox.Show("The XML files that you have attempted to open contains an unknown" + "type (not designGraph, grammarRule, ruleSet, or candidate).", "XML Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Information); } } }
public void addAndShowRuleSetDisplay(ruleSet rs, string title) { ruleSetDisplays.Add(new ruleSetDisplay(rs, title)); ruleSetDisplays[ruleSetChildCount].Show(); }