private void UpdateTerminalIndexList() { int pos = 0; for (int i = 0; i < newGrammarList.Count; i++) { bool isExist = newIndexOfTerminal.Exists(x => x.terminal == newGrammarList[i].ruleName); if (!isExist) { IndexOfTerminal currIndexOfTerminal; currIndexOfTerminal.terminal = newGrammarList[i].ruleName; List <int> startIndex = new List <int>(); startIndex.Add(pos); currIndexOfTerminal.startIndex = startIndex; List <int> rowIndex = new List <int>(); rowIndex.Add(i); currIndexOfTerminal.rowIndex = rowIndex; newIndexOfTerminal.Add(currIndexOfTerminal); } else { IndexOfTerminal currIndexOfTerminal = newIndexOfTerminal.Find(x => x.terminal == newGrammarList[i].ruleName); currIndexOfTerminal.startIndex.Add(pos); currIndexOfTerminal.rowIndex.Add(i); } pos += newGrammarList[i].ruleСomposition.Count(); } }
private void ToExstractFirstComponents(ref List <Rule> grammarList, ref IndexOfTerminal currList) { for (int i = 0; i < currList.rowIndex.Count(); i++) { int currIndex = currList.rowIndex[i]; Rule currRule = grammarList[currIndex]; List <string> ruleСomposition = currRule.ruleСomposition; string firstComponent = ruleСomposition[0]; bool isExist = dataForFacotization.Exists(x => x.commonElement == firstComponent); if (isExist) { DataForFactorization currData = dataForFacotization.Find(x => x.commonElement == firstComponent); currData.indexList.Add(currIndex); } else { DataForFactorization currData = new DataForFactorization(); currData.rule = currRule.ruleName; currData.commonElement = firstComponent; currData.indexList = new List <int> { currIndex }; dataForFacotization.Add(currData); } } ToAnalyze(ref grammarList); dataForFacotization.Clear(); }
public void ApplyFactorization(ref GrammarConverter grammarConverter) { while (isNeedToRepeatFactorization) { isNeedToRepeatFactorization = false; List <Rule> grammarList = grammarConverter.GetGrammarList(); List <IndexOfTerminal> indexOfTerminalList = grammarConverter.GetIndexOfTerminalList(); for (int i = 0; i < indexOfTerminalList.Count(); i++) { IndexOfTerminal currList = indexOfTerminalList[i]; ToExstractFirstComponents(ref grammarList, ref currList); } grammarConverter.SetGrammarList(newGrammarList); UpdateTerminalIndexList(); grammarConverter.SetTerminalIndexList(newIndexOfTerminal); UpdateTerminalList(); grammarConverter.SetTerminalList(newTerminalList); newGrammarList.Clear(); newIndexOfTerminal.Clear(); newTerminalList.Clear(); } }
private void UpdateTerminalIndexList(string terminal, int wordIndex, int row, ref List <IndexOfTerminal> indexOfTerminalList) { bool isExist = indexOfTerminalList.Exists(x => x.terminal == terminal); if (!isExist) { IndexOfTerminal newIndexOfTerminal; newIndexOfTerminal.terminal = terminal; List <int> startIndex = new List <int>(); startIndex.Add(wordIndex); newIndexOfTerminal.startIndex = startIndex; List <int> rowIndex = new List <int>(); rowIndex.Add(row); newIndexOfTerminal.rowIndex = rowIndex; indexOfTerminalList.Add(newIndexOfTerminal); } else { IndexOfTerminal currIndexOfTerminal = indexOfTerminalList.Find(x => x.terminal == terminal); currIndexOfTerminal.startIndex.Add(wordIndex); currIndexOfTerminal.rowIndex.Add(row); } }
private void DeleteLeftRecursion(int index, string currRuleName, ref GrammarConverter grammarConverter) { List <Rule> grammarList = grammarConverter.GetGrammarList(); List <IndexOfTerminal> currIndexOfTerminal = grammarConverter.GetIndexOfTerminalList(); IndexOfTerminal currRuleList = currIndexOfTerminal.Find(x => x.terminal == currRuleName); List <int> rowList = currRuleList.rowIndex; string newRule = "<" + RULE_NAME + ruleIndex + ">"; Rule rule; foreach (int row in rowList) { if (row != index) { rule = new Rule(); rule.ruleName = currRuleName; rule.guideSet = new List <string>(); rule.ruleСomposition = new List <string>(); foreach (string element in grammarList[row].ruleСomposition) { if (element != "[empty]") { rule.ruleСomposition.Add(element); } } rule.ruleСomposition.Add(newRule); newGrammarList.Add(rule); } } rule = new Rule(); rule.ruleName = newRule; rule.guideSet = new List <string>(); rule.ruleСomposition = new List <string> { "[empty]" }; newGrammarList.Add(rule); rule = new Rule(); rule.ruleName = newRule; rule.guideSet = new List <string>(); rule.ruleСomposition = new List <string> (); List <string> composition = grammarList[index].ruleСomposition; for (int i = 1; i < composition.Count(); i++) { rule.ruleСomposition.Add(composition[i]); } rule.ruleСomposition.Add(newRule); newGrammarList.Add(rule); ruleIndex++; }
public void InitializeStartRule() { string terminal = grammarList[0].ruleName; Rule newRule; newRule.ruleName = "<Start>"; List <string> currComposition = new List <string>(); currComposition.Add(terminal); currComposition.Add("[end]"); newRule.ruleСomposition = currComposition; newRule.guideSet = new List <string>(); bool isExist = terminalList.Exists(x => x.terminal == terminal); if (isExist) { TerminalList currTerminalList = terminalList.Find(x => x.terminal.Contains(terminal)); currTerminalList.index.Add(1); } else { TerminalList newTerminalList; newTerminalList.terminal = terminal; newTerminalList.index = new List <int>() { 1 }; terminalList.Add(newTerminalList); } IndexOfTerminal startIndexOfTerminal = new IndexOfTerminal(); startIndexOfTerminal.terminal = newRule.ruleName; startIndexOfTerminal.rowIndex = new List <int>() { 0 }; startIndexOfTerminal.startIndex = new List <int>() { 0 }; indexOfTerminalList.Insert(0, startIndexOfTerminal); grammarList.Insert(0, newRule); }
public void PrintIndex() { int amount1 = indexOfTerminalList.Count; Console.WriteLine("Printing Index..."); Console.WriteLine("--benig"); for (int i = 0; i < amount1; i++) { IndexOfTerminal t1 = indexOfTerminalList[i]; Console.Write(t1.terminal); Console.Write(" : "); int amount2 = t1.startIndex.Count; for (int j = 0; j < amount2; j++) { Console.Write(t1.startIndex[j]); Console.Write(", "); } Console.Write(" // "); amount2 = t1.rowIndex.Count; for (int j = 0; j < amount2; j++) { Console.Write(t1.rowIndex[j]); Console.Write(", "); } Console.WriteLine(); } Console.WriteLine("--end"); Console.WriteLine(); }