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