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();
}
