public void visit(NonterminalHeadD nonterminalHeadD) { nonterminalHeadD.IsSelected = false; // visit rule where representation is done for each choiceLineD nonterminalHeadD.Rule.accept(this); }
public void visit(NonterminalHeadD nonterminalHeadD) { representation = ""; currentNonterminalHead = nonterminalHeadD; // visit rule where representation is done for each choiceLineD nonterminalHeadD.Rule.accept(this); }
public GrammarNodeD AddAfter(NonterminalHeadD nonterminalHeadD, GrammarNodeV target, VADG.Global.SymbolType symbolType) { GrammarNodeDAddAfterVisitor visitor = new GrammarNodeDAddAfterVisitor(); visitor.Target = target.getReference(); visitor.SymbolType = symbolType; visitor.visit(nonterminalHeadD); return visitor.Item; }
public GrammarNodeD AddBefore(NonterminalHeadD nonterminalHeadD, GrammarNodeV grammarNodeV, VADG.Global.SymbolType symbolType) { GrammarNodeDAddBeforeVisitor visitor = new GrammarNodeDAddBeforeVisitor(); visitor.Target = grammarNodeV.getReference(); visitor.SymbolType = symbolType; visitor.visit(nonterminalHeadD); return visitor.Item; }
public void visit(NonterminalHeadD nonterminalHeadD) { representation = new Paragraph(); if (nonterminalHeadD.IsSelected) representation.FontWeight = FontWeights.Bold; currentNonterminalHead = nonterminalHeadD; // visit rule where representation is done for each choiceLineD nonterminalHeadD.Rule.accept(this); }
public bool Analyse() { try { if (synA.ProductionRulesHead == null || synA.ProductionRulesHead.Count == 0 || synA.ProductionRulesTail == null || synA.ProductionRulesTail.Count == 0) { errorMsg = "There are no rules found. Possible empty file / Syntactic Analyser failed?"; return false; } // create nonterminal heads foreach (Lexeme nonterminalLexeme in synA.ProductionRulesHead) { //if (getNonterminalHead(nonterminalLexeme.Value) == null) //{ // create the nont, add to rules // create the nonterminal NonterminalHeadD nontHead = new NonterminalHeadD(nonterminalLexeme.Value); nontHead.Rule = new ChoiceLineD(nontHead); rules.Add(nontHead); // otherwise do nothing now, add to choiceLineD when analysing rules } // create tree structure for each rule for (int i=0; i<synA.ProductionRulesHead.Count; i++) { Lexeme nonterminalLexeme = synA.ProductionRulesHead[i]; NonterminalHeadD nontTerminalHead = getNonterminalHead(nonterminalLexeme.Value); if (nontTerminalHead == null) throw new Exception("There was an unknown error during the processing of rules"); List<Lexeme> productionRuleLexemes = synA.ProductionRulesTail[i] as List<Lexeme>; if (productionRuleLexemes == null) throw new Exception("The given rule " + nontTerminalHead.Name + " has no production rule associated with it."); CreateRuleDataStructure(productionRuleLexemes, nontTerminalHead.Rule); //nontTerminalHead.Rule.appendChild(ruleStructure); } return true; } catch (Exception e) { errorMsg = e.Message; return false; } }
public void visit(NonterminalHeadD nonterminalHeadD) { rulesVisited.Add(nonterminalHeadD); if (symbolType == SymbolType.Nonterminal) { if (nonterminalHeadD.Name.Equals(name)) { found = true; return; } } // visit rule where representation is done for each choiceLineD nonterminalHeadD.Rule.accept(this); }
public void visit(NonterminalHeadD nonterminalHeadD) { //this is the start of the visit, we create a nonterminalheadV - note one in grammar // if this is called again then something has gone wrong if (current != null) throw new Exception("You should only be calling visit on a NonterminalHeadD node once when creating a visualised grammar. Also use the visitor pattern once, then re-initialize"); // visit rule nonterminalHeadD.Rule.accept(this); // current should now be a ChoiceLineV with the rest of the visualised grammar NonterminalHeadV startSymbolV = nonterminalHeadD.CreateNonterminalHeadV(); if (!(current is ChoiceLineV)) throw new Exception("the current node is not of type ChoiceLineV, is the definitive grammar constructed properly?"); startSymbolV.Rule = (ChoiceLineV)current; current = startSymbolV; }
private void createNonterminalD(Lexeme nonterminalLexeme) { NonterminalHeadD nont = new NonterminalHeadD(nonterminalLexeme.Value); nont.Rule = new ChoiceLineD(nont); rules.Add(nont); }
/// <summary> /// Creates a new nonterminal and add's it to the defintive grammar. /// It's rule is a simple Nont -> ChoiceLineD -> ConcatD -> Undefined /// </summary> /// <param name="name"></param> public NonterminalHeadD CreateNewNonterminal(String name) { if (model.DefinitiveGrammar.getNonterminal(name) != null) throw new Exception("The given name already exists as a nonterminal, dummy"); // build nonterminal NonterminalHeadD newNonterminal = new NonterminalHeadD(name); ChoiceLineD choiceLineD = new ChoiceLineD(newNonterminal); newNonterminal.Rule = choiceLineD; ChoiceD choiceD = new ChoiceD(choiceLineD); newNonterminal.Rule.appendChild(choiceD); ConcatenationD concatD = new ConcatenationD(choiceD); choiceD.appendChild(concatD); concatD.appendChild(new UndefinedD(concatD)); // add to model model.DefinitiveGrammar.Nonterminals.Add(newNonterminal); return newNonterminal; }
/// <summary> /// Returns the nonterminal head with the name given. Null if not found. /// </summary> /// <param name="name"></param> /// <returns></returns> private NonterminalHeadD getNonterminalHead(String name) { foreach (NonterminalHeadD nonterminalHead in rules) { if (nonterminalHead.Name.Equals(name)) return nonterminalHead; } // create the nonterminal NonterminalHeadD returnVal = new NonterminalHeadD(name); returnVal.Rule = new ChoiceLineD(returnVal); rules.Add(returnVal); synA.ProductionRulesHead.Add(new Lexeme(LexemeType.Nonterminal, name, -1)); // create the rule tail List<Lexeme> newRule = new List<Lexeme>(); newRule.Add(new Lexeme(LexemeType.Undefined, -1)); synA.ProductionRulesTail.Add(newRule); return returnVal; }
internal void setRule(TerminalV terminalV) { rule = terminalV.Reference.getMyRule(); }
/// <summary> /// Creates a new nonterminal head for use in the visuualised grammar, with references to it's nonterminal head D passed. /// </summary> /// <param name="nonterminalHeadD"></param> public NonterminalHeadV(NonterminalHeadD nonterminalHeadD) { Init(nonterminalHeadD); }
private void Init(NonterminalHeadD nonterminalHeadD) { reference = nonterminalHeadD; }
internal DefinitiveGrammar(List<NonterminalHeadD> nonterminalsIn, NonterminalHeadD startSymbolIn) { Init(nonterminalsIn, startSymbolIn); }
internal void setRule(NonterminalTailV nonterminalTailV) { rule = nonterminalTailV.Reference.getMyRule(); }
internal void setStartSymbol(NonterminalHeadD nonterminalHeadD) { if (nonterminals.Contains(nonterminalHeadD)) startSymbol = nonterminalHeadD; else throw new Exception("That start symbol is not in the grammar."); }
internal void setRule(UndefinedV undefinedV) { rule = undefinedV.Reference.getMyRule(); }
private void Init(NonterminalHeadD nonterminalHeadD) { this.nameTextBox.Text = nonterminalHeadD.Name; }
public void DeleteRule(NonterminalHeadD rule) { model.DefinitiveGrammar.Nonterminals.Remove(rule); }
public void Rename(NonterminalHeadD nont, string newName) { nont.Name = newName; }
public Factorisation(SubRule subRuleIn, NonterminalHeadD nontHeadIn) { subRule = subRuleIn; nontHeads = new List<NonterminalHeadD>(); nontHeads.Add(nontHeadIn); }
void controller_OfferDeleteRule(NonterminalHeadD rule) { string message = "The rule '" + rule.Name + "' is not used within your grammar any more." + "\nDo you want to remove the rule now?"; MessageBoxResult result = MessageBox.Show(message, "Rule Deletion Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Exclamation); if (result == MessageBoxResult.Yes) { model.Functions.DeleteRule(rule); } }
public SubRule(List<Lexeme> rulesIn, NonterminalHeadD nontHeadIn) { Rule = rulesIn; NonterminalHeadD = nontHeadIn; }
/// <summary> /// Creates a new class that has a reference to a nonterminal head D. For use in the definitive grammar when defining a rule. /// </summary> /// <param name="nonterminalHeadD"></param> public NonterminalTailD(NonterminalHeadD nonterminalHeadD, GrammarNodeD parentIn) { Init(nonterminalHeadD, parentIn); }
private void Init(List<NonterminalHeadD> nonterminalsIn, NonterminalHeadD startSymbolIn) { nonterminals = nonterminalsIn; startSymbol = startSymbolIn; }
private void Init(NonterminalHeadD nonterminalHeadD, GrammarNodeD parentIn) { reference = nonterminalHeadD; parent = parentIn; }
/// <summary> /// Returns all sub rules for a given rule in string representation /// </summary> /// <param name="nontHead"></param> /// <returns></returns> private static List<SubRule> SubRules(NonterminalHeadD nontHead) { // assert that choiceLineD has 1 child and it is of type ChoiceD if (nontHead.Rule.Children.Count > 1) throw new Exception("The choiceLineD has more than one child, cannot analyse."); if (!(nontHead.Rule.Children[0] is ChoiceD)) throw new Exception("The rule does not have the structure ChoiceLineD -> ChoiceD -> ..."); List<SubRule> returnVal = new List<SubRule>(); // get the lexemes from the nonthead rule List<Lexeme> totalLexemes = LexemeGenerator.Reverse(nontHead.Rule.Children[0]); SubRule totalRule = new SubRule(totalLexemes, nontHead); for (int stepSize = 2; stepSize <= totalRule.SymbolCount; stepSize++) { for (int position = 0; position <= totalRule.SymbolCount - stepSize; position++) { List<Lexeme> lexemes = totalRule.getSubRule(position, stepSize); SubRule subRule = new SubRule(lexemes, nontHead); returnVal.Add(subRule); } } return returnVal; }
internal void setRule(NonterminalHeadV nonterminalHeadV) { rule = nonterminalHeadV.Reference; }