internal bool IsItemPenultUnique(EarleyItem selectedEarleyItem)
{
List <EarleyItem> items = GetEarleyItemList();
if (items.Find(el => el.Equals(selectedEarleyItem)) == null)
{
return(false);
}
Symbol penult = selectedEarleyItem.GetItemPenult();
if (penult == null)
{
return(false);
}
for (int i = 0; i < items.Count; i++)
{
EarleyItem item = items[i];
if (penult.Equals(item.GetItemPenult()) && !item.GetRule().Equals(selectedEarleyItem.GetRule()))
{
return(false);
}
}
return(true);
}
private void LeoMemoization(EarleyItem earleyItem, int setNumber)
{
if (!Sets[setNumber].IsItemLeoEligible(earleyItem))
{
return;
}
Symbol penult = earleyItem.GetItemPenult();
LeoItem predecessorLeoItem = FindLeoItemPredecessor(earleyItem);
if (predecessorLeoItem != null)
{
Sets[predecessorLeoItem.GetOrignPosition()]
.AddLeoItem(new LeoItem(
predecessorLeoItem.GetDottedRule(),
predecessorLeoItem.GetOrignPosition(),
penult
));
}
else
{
Sets[earleyItem.GetOrignPosition()]
.AddLeoItem(new LeoItem(
new DottedRule(earleyItem.GetRule(), earleyItem.GetRulePosition() + 1),
earleyItem.GetOrignPosition(),
penult
));
}
}
private bool LeoReducer(EarleyItem completed, int setNumber)
{
int position = completed.GetOrignPosition();
Symbol lhs = completed.GetRule().GetLeftHandSideOfRule();
EarleySet set = Sets[position];
LeoItem transitiveItem = set.FindLeoItemBySymbol(lhs);
if (transitiveItem == null)
{
return(false);
}
EarleyItem newEarleyItem = new EarleyItem(
setNumber,
transitiveItem.GetDottedRule(),
transitiveItem.GetOrignPosition()
);
EarleyItem current = Sets[transitiveItem.GetOrignPosition()].GetEarleyItemList()
.Find(el => el.GetDottedRule().Equals(transitiveItem.GetDottedRule()) && el.GetOrignPosition() == transitiveItem.GetOrignPosition());
if (current.GetCurrentPrevSymbolList() != null && current.GetCurrentPrevSymbolList().Count > 0)
{
newEarleyItem.AddPredecessorLink(current, position);
}
newEarleyItem.AddReducerLink(completed, position);
AddToSet(
newEarleyItem,
setNumber,
"LeoReducer"
);
return(true);
}
private void EarleyReducer(EarleyItem completed, int setNumber)
{
int position = completed.GetOrignPosition();
EarleySet set = Sets[position];
List <EarleyItem> items = set.GetEarleyItemList();
for (int j = 0; j < items.Count; j++)
{
EarleyItem current = items[j];
Symbol next = current.GetCurrentNextSymbol();
if (next != null && next.Equals(completed.GetRule().GetLeftHandSideOfRule()))
{
EarleyItem newEarleyItem = new EarleyItem(
setNumber,
new DottedRule(current.GetRule(), current.GetRulePosition() + 1),
current.GetOrignPosition()
);
if (current.GetCurrentPrevSymbolList() != null && current.GetCurrentPrevSymbolList().Count > 0)
{
newEarleyItem.AddPredecessorLink(current, position);
}
newEarleyItem.AddReducerLink(completed, position);
AddToSet(newEarleyItem, setNumber, "EarleyReducer");
}
}
}
private void Completer(EarleyItem current, int setNumber)
{
if (!LeoReducer(current, setNumber))
{
EarleyReducer(current, setNumber);
}
}
internal bool IsItemLeoEligible(EarleyItem earleyItem)
{
bool isRightRecursive = earleyItem.GetRule().IsRuleRightRecursive();
bool isLeoUnique = IsItemLeoUnique(earleyItem);
if (isRightRecursive && isLeoUnique)
{
// TODO
}
return(isRightRecursive && isLeoUnique);
}
internal void AddEarleyItem(EarleyItem earleyItem, String operationType)
{
if (
_earleyItemList.Find(erl =>
erl.GetRule().Equals(earleyItem.GetRule()) &&
erl.GetRulePosition() == earleyItem.GetRulePosition() &&
erl.GetOrignPosition() == earleyItem.GetOrignPosition()
) == null
)
{
_earleyItemList.Add(earleyItem);
_earleyItemReportList.Add(new EarleyItemRepresentaion(earleyItem, operationType));
}
}
private void Scanner(EarleyItem current, int setNumber, Char inputSymbol)
{
Symbol nextSymbol = current.GetCurrentNextSymbol();
if (nextSymbol != null && nextSymbol.Equals(inputSymbol.ToString()))
{
EarleyItem newEarleyItem = new EarleyItem(
setNumber + 1,
new DottedRule(current.GetRule(), current.GetRulePosition() + 1),
current.GetOrignPosition()
);
if (newEarleyItem.GetCurrentPrevSymbolList() != null && newEarleyItem.GetCurrentPrevSymbolList().Count > 0)
{
newEarleyItem.AddPredecessorLink(current, setNumber);
}
AddToSet(newEarleyItem, setNumber + 1, "Scanner");
}
}
private void Predictor(EarleyItem current, int setNumber)
{
Symbol sym = current.GetCurrentNextSymbol();
List <Rule> filteredRules = Grammar.GetRulesWithSpecificStartSymbol(sym);
filteredRules.ForEach((Rule r) =>
{
List <Symbol> symList = r.GetRightHandSideOfRule();
if (symList.Count == 1 && Grammar.CheckIsSymbolANullStringSymbol(symList[0]))
{
AddToSet(new EarleyItem(setNumber, new DottedRule(current.GetRule(), current.GetRulePosition() + 1), setNumber), setNumber, "Predictor");
}
else
{
EarleyItem ei = new EarleyItem(setNumber, r, setNumber);
AddToSet(ei, setNumber, "Predictor");
LeoMemoization(ei, setNumber);
}
});
}
internal static void PrintSets(List <EarleySet> setsToPrint, bool all)
{
if (setsToPrint == null)
{
return;
}
for (int i = 0; i < setsToPrint.Count; i++)
{
Console.WriteLine("\n <=============================SET=================================> " + i);
EarleySet set = setsToPrint[i];
List <EarleyItem> items = set.GetEarleyItemList();
for (int k = 0; k < items.Count; k++)
{
EarleyItem e = items[k];
if (!all)
{
if (e.IsCompleted())
{
Console.WriteLine("\t\t" + e.ToString());
}
}
else
{
Console.WriteLine((e.IsCompleted() ? "\t\t" : "\t") + e.ToString());
}
}
Console.WriteLine("\n <--------> ");
List <LeoItem> transitiveItems = set.GetLeoItemList();
for (int k = 0; k < transitiveItems.Count; k++)
{
LeoItem e = transitiveItems[k];
Console.WriteLine(e.ToString());
}
Console.WriteLine("\n <=====================================================================> " + i);
}
}
private void RunMarpa(String input, int fromPosition)
{
for (int i = fromPosition; i <= input.Length; i++)
{
EarleySet set = Sets[i];
List <EarleyItem> items = set.GetEarleyItemList();
for (int j = 0; j < items.Count; j++)
{
EarleyItem current = items[j];
if (current.IsCompleted())
{
Completer(current, i);
}
else
{
bool condition = Grammar.DoesBelongToTerminals(current.GetCurrentNextSymbol());
if (!condition)
{
Predictor(current, i);
}
else if (input.Length > i)
{
Scanner(current, i, input[i]);
}
}
}
if (i + 1 < Sets.Count && Sets[i + 1].GetEarleyItemList().Count == 0)
{
errorHandler.AddNewError(ErrorCode.UNRECOGNISED_SYMBOL, input[i], i);
return;
}
}
}
private void BuildTree(TreeNode parent, EarleyItem current)
{
current.SetItemIsProcessed();
Symbol lhs = current.GetRule().GetLeftHandSideOfRule();
List <Symbol> prev = current.GetCurrentPrevSymbolList();
int setNumber = current.GetSetNumber();
if (IsEmptyRule(current))
{
if (!parent.DoesChildExists(new TreeNode(lhs, setNumber, setNumber)))
{
parent.AddChild(new TreeNode(_grammar.GetNullStringSymbol(), setNumber, setNumber));
}
}
else if (prev.Count == 1 && IsLastSymbolBeforeDotTerminal(prev))
{
Symbol symBeforeDot = prev[prev.Count - 1];
if (!parent.DoesChildExists(new TreeNode(symBeforeDot, setNumber, setNumber)))
{
parent.AddChild(new TreeNode(symBeforeDot, setNumber - 1, setNumber));
}
}
else if (prev.Count == 1 && IsLastSymbolBeforeDotNonTerminal(prev))
{
Symbol symBeforeDot = prev[prev.Count - 1];
TreeNode newNode = new TreeNode(symBeforeDot, current.GetOrignPosition(), setNumber);
if (!parent.DoesChildExists(newNode))
{
parent.AddChild(newNode);
}
current.GetReducerLinks().ForEach(el =>
{
if (el._label == current.GetOrignPosition() && !el._link.IsItemProcessed())
{
BuildTree(newNode, el._link);
}
});
}
else if (IsLastSymbolBeforeDotTerminal(prev))
{
Symbol symBeforeDot = prev[prev.Count - 1];
TreeNode newNode = new TreeNode(symBeforeDot, setNumber - 1, setNumber);
if (!parent.DoesChildExists(newNode))
{
parent.AddChild(newNode);
}
TreeNode newComplexNode = new TreeNode(
new DottedRule(current.GetRule(), current.GetRulePosition() - 1),
current.GetOrignPosition(),
setNumber - 1
);
if (!parent.DoesChildExists(newComplexNode))
{
parent.AddChild(newComplexNode);
}
current.GetPredecessorLinks().ForEach(link =>
{
if (link._label == setNumber - 1 && !link._link.IsItemProcessed())
{
BuildTree(newComplexNode, link._link);
}
});
}
else if (IsLastSymbolBeforeDotNonTerminal(prev))
{
Symbol symBeforeDot = prev[prev.Count - 1];
current.GetReducerLinks().ForEach(item =>
{
TreeNode newNode = new TreeNode(symBeforeDot, item._label, setNumber);
if (!parent.DoesChildExists(newNode))
{
parent.AddChild(newNode);
}
if (!item._link.IsItemProcessed())
{
BuildTree(newNode, item._link);
}
TreeNode newComplexNode = new TreeNode(
new DottedRule(current.GetRule(), current.GetRulePosition() - 1),
current.GetOrignPosition(),
item._label
);
if (!parent.DoesChildExists(newComplexNode))
{
parent.AddChild(newComplexNode);
}
current.GetPredecessorLinks().ForEach(predItem =>
{
if (!predItem._link.IsItemProcessed())
{
BuildTree(newComplexNode, predItem._link);
}
});
});
}
;
}
private LeoItem FindLeoItemPredecessor(EarleyItem earleyItem)
{
EarleySet predecessorSet = Sets[earleyItem.GetOrignPosition()];
return(predecessorSet.FindLeoItemBySymbol(earleyItem.GetRule().GetLeftHandSideOfRule()));
}
internal void AddReducerLink(EarleyItem link, int label)
{
_reducorLinkList.Add(new ItemLink(link, label));
}
internal void AddPredecessorLink(EarleyItem link, int label)
{
_predecessorLinkList.Add(new ItemLink(link, label));
}
public override bool Equals(object obj)
{
EarleyItem earleyItem = obj as EarleyItem;
return(GetDottedRule().Equals(earleyItem.GetDottedRule()) && GetOrignPosition() == earleyItem.GetOrignPosition());
}
internal ItemLink(EarleyItem link, int label)
{
_label = label;
_link = link;
}
public LeoItem(EarleyItem ei, Symbol symbol)
{
_symbol = symbol;
_dotteRule = ei.GetDottedRule();
_orignPosition = ei.GetOrignPosition();
}
internal bool IsItemLeoUnique(EarleyItem earleyItem)
{
return(earleyItem.GetItemPenult() != null && IsItemPenultUnique(earleyItem));
}
private bool IsEmptyRule(EarleyItem current)
{
return(current.GetRule().GetRightHandSideOfRule()[0].Equals(_grammar.GetNullStringSymbol()));
}
private void AddToSet(EarleyItem earleme, int setIndex, String operationType)
{
Sets[setIndex].AddEarleyItem(earleme, operationType);
}
internal EarleyItemRepresentaion(EarleyItem item, String operation)
{
_item = item.ToString();
_operation = operation;
}
