public void appendChild(GrammarNodeD child) { if (child is NonterminalHeadD) throw new Exception("An operations children must be of type NonterminalTailTailD."); children.Add(child); }
/// <summary> /// Used in Analysis, we reverse the compilation by going back to Lexemes /// </summary> /// <param name="grammarNodeD"></param> /// <returns></returns> public static List<Lexeme> Reverse(GrammarNodeD grammarNodeD) { if (grammarNodeD is OperationD) return Reverse(grammarNodeD as OperationD); List<Lexeme> returnVal = new List<Lexeme>(); if (grammarNodeD is TerminalD) { returnVal.Add(Reverse((TerminalD)grammarNodeD)); return returnVal; } if (grammarNodeD is NonterminalTailD) { returnVal.Add(Reverse((NonterminalTailD)grammarNodeD)); return returnVal; } if (grammarNodeD is UndefinedD) { returnVal.Add(Reverse((UndefinedD)grammarNodeD)); return returnVal; } throw new NotImplementedException(); }
/// <summary> /// Will put child at the position in the children /// If position is at end will append to end /// </summary> /// <param name="position"></param> public void insertChild(int position, GrammarNodeD child) { if (position > children.Count || children.Count < 0) throw new Exception("The position attempted [" + position + "] was outside the bounds of the children array"); if (position == children.Count) appendChild(child); else children.Insert(position, child); }
public void AddChoice(GrammarNodeD grammarNodeD) { // assert parent is concatenation ConcatenationD parent = grammarNodeD.Parent as ConcatenationD; if (parent == null) throw new Exception("The grammarNodeD parent is not of type concatenation"); // assert parent parent is choiceD ChoiceD parentParent = parent.Parent as ChoiceD; if (parentParent == null) throw new Exception("The grammarNodeD parent parent is not of type choiceD"); ConcatenationD concatD = new ConcatenationD(parentParent); parentParent.appendChild(concatD); concatD.appendChild(new UndefinedD(concatD)); }
public TerminalD(String nameIn, GrammarNodeD parentIn) { Init(nameIn, parentIn); }
private void Init(string nameIn, GrammarNodeD parentIn) { name = nameIn; references = new List<TerminalV>(); parent = parentIn; }
/// <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(NonterminalHeadD nonterminalHeadD, GrammarNodeD parentIn) { reference = nonterminalHeadD; parent = parentIn; }
public GrammarNodeVReplaceVisitor(GrammarNodeD targetIn, GrammarNodeD itemIn) { target = targetIn; newItem = itemIn; }
private void createItem(GrammarNodeD parent) { GrammarNodeD newItem; switch (symbolType) { case VADG.Global.SymbolType.Undefined: newItem = new UndefinedD(parent); break; default: throw new Exception("The visitor does not support that type yet, get on it!"); } item = newItem; }
public void AddBefore(SymbolV symbolV, GrammarNodeD itemToAdd) { GrammarNodeVAddBeforeVisitor visitor = new GrammarNodeVAddBeforeVisitor(symbolV, itemToAdd); startSymbol.accept(visitor); }
public GrammarNodeVAddChoiceVisitor(GrammarNodeD targetIn) { target = targetIn; }
public UndefinedD(GrammarNodeD parentIn) { references = new List<UndefinedV>(); parent = parentIn; }
private void Init(List<GrammarNodeD> childrenIn, List<ChoiceV> referencesIn, GrammarNodeD parentIn) { children = childrenIn; references = referencesIn; parent = parentIn; }
public GrammarNodeD Replace(GrammarNodeD itemToReplace, VADG.Global.SymbolType symbolType, string name) { OperationD parent = itemToReplace.Parent as OperationD; if (parent == null) throw new Exception("The item to replace does not have an operation D as a parent, fail."); // the rule we are editing NonterminalHeadD rule = itemToReplace.getMyRule(); if (rule == null) throw new Exception("The item to replace could not find a nonterminalhead D associated with it."); // remove old item int index = parent.Children.IndexOf(itemToReplace); parent.Children.Remove(itemToReplace); itemToReplace.Dispose(); // create new item to add GrammarNodeD newItem; if (symbolType == VADG.Global.SymbolType.Terminal) { // create new Terminal newItem = new TerminalD(name, parent); } else { // If the nont head doesn't exist, create and add to grammar NonterminalHeadD nontHead = model.DefinitiveGrammar.getNonterminal(name); if (nontHead == null) nontHead = CreateNewNonterminal(name); newItem = nontHead.CreateNonterminalTailD(parent); } // insert new item into parent parent.insertChild(index, newItem); return newItem; }
public void Delete(GrammarNodeD grammarNodeD) { if (grammarNodeD.Parent is ConcatenationD) { ConcatenationD parent = grammarNodeD.Parent as ConcatenationD; // do the removal grammarNodeD.Dispose(); parent.Children.Remove(grammarNodeD); if (parent.Children.Count == 0) // add undefined parent.appendChild(new UndefinedD(parent)); } else if (grammarNodeD.Parent is ChoiceD) { // removing a choice ChoiceD parent = grammarNodeD.Parent as ChoiceD; // do removal grammarNodeD.Dispose(); parent.Children.Remove(grammarNodeD); if (parent.Children.Count == 0) { ConcatenationD concatD = new ConcatenationD(parent); parent.appendChild(concatD); concatD.appendChild(new UndefinedD(concatD)); } } else throw new Exception("The parent was not of type concatenation, I don't know what to do..."); }
/// <summary> /// Creates a new class that is a nonterminal tail for use in the definitive grammar, used to define a rule. /// </summary> /// <returns></returns> public NonterminalTailD CreateNonterminalTailD(GrammarNodeD parentIn) { return new NonterminalTailD(this, parentIn); }
public ConcatenationD(GrammarNodeD parentIn) { Init(new List<GrammarNodeD>(), new List<ConcatenationV>(), parentIn); }
public GrammarNodeVAddAfterVisitor(GrammarNodeV targetIn, GrammarNodeD itemIn) { target = targetIn; item = itemIn; }
public ChoiceD(GrammarNodeD parentIn) { Init(new List<GrammarNodeD>(), new List<ChoiceV>(), parentIn); }
public GrammarNodeVDeleteVisitor(GrammarNodeD targetIn) { target = targetIn; }
public GrammarNodeVAddBeforeVisitor(GrammarNodeV targetIn, GrammarNodeD itemIn) { target = targetIn; item = itemIn; }
public void Replace(GrammarNodeD itemToReplace, GrammarNodeD newItem) { GrammarNodeVReplaceVisitor visitor = new GrammarNodeVReplaceVisitor(itemToReplace, newItem); startSymbol.accept(visitor); }