protected internal PredictionTreeBranch(IList <PredictionTreeLeaf> baseList, int depth = 0, bool chop = false, bool passAlong = true, short[] deviations = null, int[] epsilonState = null, int minDepth = 0) : base(baseList) { this.epsilonDerivations = epsilonState ?? new int[(baseList.Count + (sizeof(SlotType) - 1)) / sizeof(SlotType)]; this.MinDepth = minDepth; this.Depth = depth; this.SetDeviations(deviations ?? new short[0]); if (passAlong) { if (!chop && depth > 0) { if (depth == this.Count - 1) { baseList[depth].AddPath(this); } else { var addedPath = new PredictionTreeBranch(this.Take(depth + 1).ToList(), depth, true, false); addedPath.SetDeviations(this.deviations); baseList[depth].AddPath(addedPath); } } } this.Validate(); }
internal MultikeyedDictionary <GrammarVocabulary, int, List <Tuple <Tuple <int[], PredictionTree>[], int[]> > > ObtainTerminalAmbiguities( Dictionary <SyntacticalDFAState, PredictionTreeLeaf> fullSeries, ControlledDictionary <IOilexerGrammarProductionRuleEntry, SyntacticalDFARootState> ruleDFAs, Dictionary <IOilexerGrammarProductionRuleEntry, GrammarVocabulary> ruleLookup, GrammarSymbolSet grammarSymbols) { if (!this.Veins.DFAOriginState.IsEdge) { return(new MultikeyedDictionary <GrammarVocabulary, int, List <Tuple <Tuple <int[], PredictionTree>[], int[]> > >()); } var tempDictionary = new MultikeyedDictionary <PredictionTreeBranch, GrammarVocabulary, Tuple <int[], PredictionTree> >(); var rootNode = fullSeries[ruleDFAs[this.Rule]]; var currentIncoming = new List <PredictionTreeBranch>(rootNode.incoming); var reductions = rootNode.PointsOfReduction.ToArray(); if (reductions.Length > 0) { } var totalIncoming = new HashSet <PredictionTreeBranch>(); Dictionary <PredictionTree, PredictionTree> uniqueSet = new Dictionary <PredictionTree, PredictionTree>(); foreach (var path in currentIncoming) { var transitionTableResult = new FiniteAutomataMultiTargetTransitionTable <GrammarVocabulary, Tuple <int, PredictionTreeBranch> >(); var masterPathChop = new PredictionTreeBranch(path.Take(path.Depth).Concat(new[] { this }).ToArray(), path.Depth, false, false); masterPathChop.SetDeviations(path.GetDeviationsUpTo(path.Depth)); ObtainTerminalAmbiguitiesOnPath(masterPathChop, fullSeries, ruleDFAs, ruleLookup, transitionTableResult, grammarSymbols); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ * Construct the sequence of Path->Grammar->PathSets based * * off of the table provided by the ObtainTerminalAmbiguitiesOnPath. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/ foreach (var transition in transitionTableResult.Keys) { var epDepthLookup = (from entry in transitionTableResult[transition] group entry.Item1 by entry.Item2).ToDictionary(k => k.Key, v => v.ToArray()); //int minDepth; //var uniqueCurrent = GetUniqueDPathSet(uniqueSet, transitionTableResult, transition, epDepthLookup); //var subPath = new PredictionTreeBranch(path.Skip(minDepth).ToList(), path.Depth - minDepth, minDepth: path.MinDepth); tempDictionary.TryAdd(path, transition, Tuple.Create((from epDepth in transitionTableResult[transition] select epDepth.Item1).ToArray(), GetFollowDPathSet(transitionTableResult, transition, epDepthLookup))); } } var regrouping = (from ksvp in tempDictionary group new { Path = ksvp.Keys.Key1, Set = ksvp.Value } by ksvp.Keys.Key2).ToDictionary(k => k.Key, v => v.ToArray()); /* * foreach (var pathSet in from key in regrouping.Keys * let value = regrouping[key] * from r in value * select r.Set) * pathSet.Item2.FixAllPaths();//*/ var comparisons = (from key in regrouping.Keys let value = regrouping[key] let kRewrite = from r in value select r.Set let commonalities = PredictionTree.GetCompoundRightSideSimilarities(kRewrite) select new { Commonalities = commonalities, Transition = key }).ToDictionary(k => k.Transition, v => v.Commonalities); var resultDictionary = new MultikeyedDictionary <GrammarVocabulary, int, List <Tuple <Tuple <int[], PredictionTree>[], int[]> > >(); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ * Once we're done, we need to rebuild the paths with the MinDepth set to * * their current Depth. This is to ensure that it the PathSets don't try * * to reduce more than necessary. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Then we take that set and perform a right-hand-side comparison between * * the elements. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * This will be used later to reduce the walking necessary to isolate the * * proper machine to use to disambiguate the look-ahead. * \ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/ foreach (var comparison in comparisons.Keys) { var comparisonElements = comparisons[comparison]; foreach (var memberCount in comparisonElements.Keys) { var comparisonElement = comparisonElements[memberCount]; resultDictionary.Add(comparison, memberCount, comparisonElement); } } return(resultDictionary); }